Rune - Clean up strings
[rune.git] / TODO
1
2 * libgen/gen_info.c, two major places where we have:
3
4         dassert(ptr->minfo == NULL);
5         ptr->minfo = blah
6
7   Are wrong.  We will need to bring back cinfo for sideband content
8   locking to allow locks to be retained across temporary variables.
9
10 * Recheck gfxinput2 memory bleeding.
11
12 * TODO: Give each global variable its own RefStor for locking
13   purposes if needed.
14
15 * Assignments of the same variable to itself are a big problem.  The
16   underlying storge is dropped and then copied, but atm the drop code
17   cleans out the storage (e.g. any pointers or references).
18
19 * &array[n] is causing extra hanging locks in the interpreter.
20
21 * &lvalue --- do not set SRS flags!!!  The address is not the local stack
22   address.
23
24 * ptr.method() calls (other than new()) just don't understand whether
25   the method object is locked or unlocked.  This isn't a problem for
26   ptr->method() calls through classes since the contents of a class is
27   always naturally unlocked (but still ref'd of course).
28
29 * XXX *pptr or *ptr-to-compound-type does not know whether the indirected
30   object resides in naturally locked or naturally unlocked storage.
31
32   --> intention - disallow &locked-storage-ptr or &locked-storage-comptype,
33       require the use of 'unlocked' on the storage to be able to take its
34       address.  Relax requirements if TF_HASLVPTR is false.
35
36 * Do not allow the address of any return argument be taken during a
37   call.  Messes up content-locked return data.
38
39 * Global compound types need to be fixed to not try to maintain locks.
40
41 * Lock global and (class) object storage in GenGetDeclarationData()
42
43 * on LValueStor, do not flow-through LVRSGet's.  Instead require that
44   LValueStor's passed as an argument or return value have their
45   underlying object locked (and other LValueStor's do not, even if on
46   the stack).
47
48   This makes .new() work as the lock will be borrowed if relaying an
49   lvs passed in, and if not relaying the caller must lock the underlying.
50
51   When an object is forwarded by constructing an LValueStor for it,
52   the lock must be borrowed if the object is already locked.  Access
53   semantics are such that this should always be the case.
54
55 * insnx86.c line 149 ish.. remove rea->regused ???
56
57 * gen_refstor.c ~720, make DOP_ARGS_STORAGE cacheable.  But to
58   work properly RAS needs to do a dummy load of each argument
59   from EA[non-cache] to EA.CACHE to ensure that the register
60   is properly initialized.  And for pointers, to sync back
61   on return (?)
62
63 * Cacheability of compound types in RAS ?
64
65 * see classes strlen() code. CMP/BRA opt causes RSPUT to be improperly
66   handled (fix by optimizing out the PRSGET/RSPUT sequence for the
67   comparison?  what if both args need it?)
68
69 * optimize const global access to immediate value XXX doesn't currently 
70   happen (strlen()'s test against NIL).
71
72 * optimized stack storage in llvm is not cleared
73
74 * return/result sequencing must be validated by the resolver.  break/continue
75   may not cross a result; point and result; cannot be conditionalized in one
76   path unless it is also present in the other.
77
78 * Add 'finalize' to class/subclass decl indicating that no further subclassing
79   is allowed.
80
81 * libgen initializers for global declarations w/ assignments or type defaults.
82
83 * resolver propagate CTF_RESOLVING flag in run-time context.
84
85 * resolver and runtime and generator - validate when casting pointers
86   that an integral number of objects of the target fits in the source.
87   Otherwise the cast is illegal.
88
89 * tests/refine.d - method call through non-replicated (i.e. not part of
90                    subclass) @ref currently executes the superclass method
91                    instead of looking up the actual method via the type.
92
93 * generally speaking must change how interfaces and classes work when making
94   field accesses.  Disallow in interfaces, allow otherwise but then restrict
95   how refine operates so field offsets remain consistent across all
96   sub-classes.  Disallow alias access via @ref?
97
98 * resolver - Disallow binding of incompatible subclasses to a superclass.
99              Do this by flagging the incompatibility.
100
101 * resolver - Enforce that non-interface classes cannot contain interfaces.
102
103 * resolver - Enforce that it is not allowed to take the sizeof() an interface
104              object.
105
106 * resolver - Enforce that one cannot instantiate/declare an interface type.
107
108 * resolver - Enforce that object accessors can only be to non-generic elements.
109
110 * resolver - Reorder generic elements in an interface to the end for offset
111              assignment purposes.
112
113 * resolver - Do not allow pointer arithmatic on references.
114
115 * libgen - chained temporary data returned along one side of an expressin
116   can get corrupted by the other side.  On the top-level temporary data is
117   'safe'.
118
119 * libgen - RunRelsRefStor in operators a mess.
120
121 * libgen - exp.c RunCastExpPtrToRef() is basically messing with the
122   type of the passed-in lvalue, which is really a bad idea.
123
124 * read, write, sizeof, arysize, and bcopy currently taking Int32 !!!'s. FIX!
125   Add size_t, ssize_t.
126
127 * When realizing persistent store we have to clean out any previously
128   existing pointers.
129
130 * map files containing structures with pointers can get corrupted.  Maybe
131   we should just disallow pointers entirely for any persistent store.
132
133 * Persistent store mmap() file path is currently hacked up.  Needs command
134   line arg to set the home directory for the program, and the default
135   should be "$HOME/.<program>/rune_%s.map".  libgen/heap.c
136
137 * infinintely recursive aliases are not currently detected.
138
139   alias a = b;
140   alias b = a + 1;
141
142 * get rid of need for 'auto' prefix in casts to distinguish between
143   variable names and types.
144
145 * share pens and also share font information
146
147 * Handle simple exposure aggregation and use clip to limit update area
148   (see tests/gfxslider.d)
149
150 * Wide char for SSTRING ?  i.e. 'x'
151
152 isg for resolveType's assigned expression
153
154 DONE<<constructors/destructors for global elements and statement blocks>> ?
155
156 reference type resolver and libi/exp.c TOK_STRIND and TOK_CALL.  METHOD CALLS
157 via ref types (don't screw around with the exp, dup it instead?)
158
159 refine: check validity of procedural refinements (different return types,
160 argument types, etc...)
161
162 is d_Search now obsolete?
163
164 Add support for 'super'.  Either 'structural->super' or 'super.<blah>'
165 (for method calls), to access a superclass element that has been overloaded
166 in the subclass.
167
168 We need to be able to copy a statement tree (procedure body) on the fly
169 in the resolver, when a subclass is passed to a procedure expecting its
170 superclass.  We have to keep track of compound types (proc args) in order
171 to cache the various versions of the procedure.  We already have d_Super
172 to locate the procedure in a TOK_CALL if the procedure body is NULL.
173 The modified procedure must be able to pass a different sg_Level.. i.e.
174 the one for the superclass, even though all of its types will be the actual
175 class (the subclass), in order to locate the proper declaration (a declaration
176 may be invisible to the subclass but visible to the superclass).
177
178 --
179
180
181 int ary[exp] ... the exp is shared across qualifications of the type,
182 which is bad.  Also, what about compound types sharing the same semgroup?
183 that should be ok.
184
185 double check 'isglobal' TF/SGF_NOINIT cache
186
187 cast procedures generally work but we really need to formalize
188 how ex_Type is set verses what the exp node really wants (e.g. for
189 procedures... look at ex_Type or look at the procdecl's return type?).
190
191 really fix cast... in libi/exp.c 
192
193 Check global scope when indirecting through a type or class rather 
194 then storage.  only allow global scope for storage in that case.
195
196 non-global procedure called through object -- automatic "this" reference.
197 procedures embedded in class accessing class elements?????  global vs
198 non-global
199
200 Implement STF_FORWARD checking (do not allow forward reference stack 
201 declarations to other decls at the same semantic level.)
202
203 Make procedural refinement work
204
205 Implement scope
206
207 Implement heap variables (implement as initialized pointers / use '@' ?)
208
209 Partial procedure args resolution
210
211 procedure pointers (point to the declaration)
212