shsajjadi
commented
1 year ago Is seems that mastering nested functions is as complicated as correctly implementing them. A variable in Coder intermediate C++ representation is implemented as Symbol class that has a two members : 1- (value)a COW pointer to octave data type and 2- (reference) a pointer to other Symbol. The (reference) data member solves to some extent implementing global and persistent variable and also variable in nested functions. Currently nested functions are implemented as nested c++ lambdas. Each function captures its own variables by value. Variables in the nesting function are captured by reference in the nested function. Also the nested function holds a COW pointer of the nesting function as one of its captures to keep it alive so its variables that are captured by reference can be used later from the handle to the nested functions. But this design has limitations and a more complex data structure is needed for holding the Octave objects. The new design should have theses specifications:
- All local variables should be declared on stack not on the lambda capture
- Variables from the nesting scope should be captured by value.
- Redesign Symbol class so that its copy constructor behaves as move constructor and its move constructor behaves as copy constructor! I cannot find a better way to integrate with the C++ lambda capture mechanism.
- Symbol will have two members A void pointer to something either a COW Octave object when it has value semantics or a shared ptr to COW object when it has ref semantics A boolean variable that say that the Symbol has value or reference mechanism
Nested functions specially in more complex nesting relations don't work correctly, have memory leak and are incompatible to some extent with global variables