* Assignments of the same variable to itself are a big problem. The underlying storge is dropped and then copied, but atm the drop code cleans out the storage (e.g. any pointers or references). * &array[n] is causing extra hanging locks in the interpreter. * &lvalue --- do not set SRS flags!!! The address is not the local stack address. * ptr.method() calls (other than new()) just don't understand whether the method object is locked or unlocked. This isn't a problem for ptr->method() calls through classes since the contents of a class is always naturally unlocked (but still ref'd of course). * XXX *pptr or *ptr-to-compound-type does not know whether the indirected object resides in naturally locked or naturally unlocked storage. --> intention - disallow &locked-storage-ptr or &locked-storage-comptype, require the use of 'unlocked' on the storage to be able to take its address. Relax requirements if TF_HASLVPTR is false. * Do not allow the address of any return argument be taken during a call. Messes up content-locked return data. * Global compound types need to be fixed to not try to maintain locks. * Lock global and (class) object storage in GenGetDeclarationData() * on LValueStor, do not flow-through LVRSGet's. Instead require that LValueStor's passed as an argument or return value have their underlying object locked (and other LValueStor's do not, even if on the stack). This makes .new() work as the lock will be borrowed if relaying an lvs passed in, and if not relaying the caller must lock the underlying. When an object is forwarded by constructing an LValueStor for it, the lock must be borrowed if the object is already locked. Access semantics are such that this should always be the case. * insnx86.c line 149 ish.. remove rea->regused ??? * gen_refstor.c ~720, make DOP_ARGS_STORAGE cacheable. But to work properly RAS needs to do a dummy load of each argument from EA[non-cache] to EA.CACHE to ensure that the register is properly initialized. And for pointers, to sync back on return (?) * Cacheability of compound types in RAS ? * see classes strlen() code. CMP/BRA opt causes RSPUT to be improperly handled (fix by optimizing out the PRSGET/RSPUT sequence for the comparison? what if both args need it?) * optimize const global access to immediate value XXX doesn't currently happen (strlen()'s test against NIL). * optimized stack storage in llvm is not cleared * return/result sequencing must be validated by the resolver. break/continue may not cross a result; point and result; cannot be conditionalized in one path unless it is also present in the other. * Add 'finalize' to class/subclass decl indicating that no further subclassing is allowed. * libgen initializers for global declarations w/ assignments or type defaults. * resolver propagate CTF_RESOLVING flag in run-time context. * resolver and runtime and generator - validate when casting pointers that an integral number of objects of the target fits in the source. Otherwise the cast is illegal. * tests/refine.d - method call through non-replicated (i.e. not part of subclass) @ref currently executes the superclass method instead of looking up the actual method via the type. * generally speaking must change how interfaces and classes work when making field accesses. Disallow in interfaces, allow otherwise but then restrict how refine operates so field offsets remain consistent across all sub-classes. Disallow alias access via @ref? * resolver - Disallow binding of incompatible subclasses to a superclass. Do this by flagging the incompatibility. * resolver - Enforce that non-interface classes cannot contain interfaces. * resolver - Enforce that it is not allowed to take the sizeof() an interface object. * resolver - Enforce that one cannot instantiate/declare an interface type. * resolver - Enforce that object accessors can only be to non-generic elements. * resolver - Reorder generic elements in an interface to the end for offset assignment purposes. * resolver - Do not allow pointer arithmatic on references. * libgen - chained temporary data returned along one side of an expressin can get corrupted by the other side. On the top-level temporary data is 'safe'. * libgen - RunRelsRefStor in operators a mess. * libgen - exp.c RunCastExpPtrToRef() is basically messing with the type of the passed-in lvalue, which is really a bad idea. * read, write, sizeof, arysize, and bcopy currently taking Int32 !!!'s. FIX! Add size_t, ssize_t. * When realizing persistent store we have to clean out any previously existing pointers. * map files containing structures with pointers can get corrupted. Maybe we should just disallow pointers entirely for any persistent store. * Persistent store mmap() file path is currently hacked up. Needs command line arg to set the home directory for the program, and the default should be "$HOME/./rune_%s.map". libgen/heap.c * infinintely recursive aliases are not currently detected. alias a = b; alias b = a + 1; * get rid of need for 'auto' prefix in casts to distinguish between variable names and types. * share pens and also share font information * Handle simple exposure aggregation and use clip to limit update area (see tests/gfxslider.d) * Wide char for SSTRING ? i.e. 'x' isg for resolveType's assigned expression DONE<> ? reference type resolver and libi/exp.c TOK_STRIND and TOK_CALL. METHOD CALLS via ref types (don't screw around with the exp, dup it instead?) refine: check validity of procedural refinements (different return types, argument types, etc...) is d_Search now obsolete? Add support for 'super'. Either 'structural->super' or 'super.' (for method calls), to access a superclass element that has been overloaded in the subclass. We need to be able to copy a statement tree (procedure body) on the fly in the resolver, when a subclass is passed to a procedure expecting its superclass. We have to keep track of compound types (proc args) in order to cache the various versions of the procedure. We already have d_Super to locate the procedure in a TOK_CALL if the procedure body is NULL. The modified procedure must be able to pass a different sg_Level.. i.e. the one for the superclass, even though all of its types will be the actual class (the subclass), in order to locate the proper declaration (a declaration may be invisible to the subclass but visible to the superclass). -- int ary[exp] ... the exp is shared across qualifications of the type, which is bad. Also, what about compound types sharing the same semgroup? that should be ok. double check 'isglobal' TF/SGF_NOINIT cache cast procedures generally work but we really need to formalize how ex_Type is set verses what the exp node really wants (e.g. for procedures... look at ex_Type or look at the procdecl's return type?). really fix cast... in libi/exp.c Check global scope when indirecting through a type or class rather then storage. only allow global scope for storage in that case. non-global procedure called through object -- automatic "this" reference. procedures embedded in class accessing class elements????? global vs non-global Implement STF_FORWARD checking (do not allow forward reference stack declarations to other decls at the same semantic level.) Make procedural refinement work Implement scope Implement heap variables (implement as initialized pointers / use '@' ?) Partial procedure args resolution procedure pointers (point to the declaration)