| blob | 74eb64fd4719a9f2e37162ad05ae3943a1b454d3 |
1 ---
3 source/interpret.c | 118 +++++++++++++++++++++++++++++------------------------
4 source/interpret.h | 20 ++++++--
5 source/macro.c | 39 ++++++++++-------
6 source/parse.y | 13 ++++-
7 4 files changed, 112 insertions(+), 78 deletions(-)
9 diff --quilt old/source/interpret.c new/source/interpret.c
10 --- old/source/interpret.c
11 +++ new/source/interpret.c
12 @@ -76,7 +76,7 @@ static const char CVSID[] = "$Id: interp
13 #define NEEDS_BREAK 1
14 #define NEEDS_CONTINUE 2
16 -#define N_ARGS_ARG_SYM -1 /* special arg number meaning $n_args value */
17 +#define N_ARGS_ARG_VAR -1 /* special arg number meaning $n_args value */
19 enum opStatusCodes {STAT_OK=2, STAT_DONE, STAT_ERROR, STAT_PREEMPT};
21 @@ -228,26 +228,30 @@ void InitMacroGlobals(void)
23 /* Add action routines from NEdit menus and text widget */
24 actions = GetMenuActions(&nActions);
25 + dv.tag = ACTION_SUBR_TAG;
26 for (i=0; i<nActions; i++) {
27 dv.val.xtproc = actions[i].proc;
28 - InstallSymbol(actions[i].string, ACTION_ROUTINE_SYM, dv);
29 + InstallSymbol(actions[i].string, GLOBAL_SCOPE, READONLY_ATTR, dv);
30 }
31 actions = TextGetActions(&nActions);
32 + dv.tag = ACTION_SUBR_TAG;
33 for (i=0; i<nActions; i++) {
34 dv.val.xtproc = actions[i].proc;
35 - InstallSymbol(actions[i].string, ACTION_ROUTINE_SYM, dv);
36 + InstallSymbol(actions[i].string, GLOBAL_SCOPE, READONLY_ATTR, dv);
37 }
39 /* Add subroutine argument symbols ($1, $2, ..., $9) */
40 + dv.tag = ARG_VAR_TAG;
41 for (i=0; i<9; i++) {
42 argName[1] = '1' + i;
43 dv.val.n = i;
44 - InstallSymbol(argName, ARG_SYM, dv);
45 + InstallSymbol(argName, GLOBAL_SCOPE, READONLY_ATTR, dv);
46 }
48 /* Add special symbol $n_args */
49 - dv.val.n = N_ARGS_ARG_SYM;
50 - InstallSymbol("$n_args", ARG_SYM, dv);
51 + dv.tag = ARG_VAR_TAG;
52 + dv.val.n = N_ARGS_ARG_VAR;
53 + InstallSymbol("$n_args", GLOBAL_SCOPE, READONLY_ATTR, dv);
54 }
56 /*
57 @@ -828,8 +832,8 @@ static Symbol *lookupSymbol(Symbol *syml
58 /*
59 ** find a symbol in the symbol table
60 **
61 -** will create only LOCAL_SYM and GLOBAL_SYM (depending on first character)
62 -** with a NO_TAG value
63 +** will create only LOCAL_SCOPE and GLOBAL_SCOPE (depending on first character)
64 +** with a NO_TAG value and NO_ATTR
65 */
66 Symbol *LookupSymbol(const char *name, int create)
67 {
68 @@ -853,8 +857,8 @@ Symbol *LookupSymbol(const char *name, i
70 if (create) {
71 DataValue noValue = {NO_TAG, {0}};
72 - s = InstallSymbol(name, name[0] == '$' ? GLOBAL_SYM : LOCAL_SYM,
73 - noValue);
74 + s = InstallSymbol(name, name[0] == '$' ? GLOBAL_SCOPE : LOCAL_SCOPE,
75 + NO_ATTR, noValue);
76 }
78 return s;
79 @@ -863,16 +867,17 @@ Symbol *LookupSymbol(const char *name, i
80 /*
81 ** install symbol name in symbol table
82 */
83 -Symbol *InstallSymbol(const char *name, enum symTypes type, DataValue value)
84 +Symbol *InstallSymbol(const char *name, enum symScope scope, unsigned attr,
85 + DataValue value)
86 {
87 Symbol *s;
89 s = XtNew(Symbol);
90 s->name = LookupString(name, True);
91 - s->type = type;
92 + s->attr = attr;
93 s->value = value;
94 s->hash = hashName(s->name);
95 - if (type == LOCAL_SYM) {
96 + if (scope == LOCAL_SCOPE) {
97 if (Interpreter) {
98 s->next = LocalSymList;
99 LocalSymList = s;
100 @@ -1441,36 +1446,49 @@ static void addToGlobalSymTab(Symbol *sy
101 static int pushSymVal(void)
102 {
103 Symbol *s;
104 - int nArgs, argNum;
105 - DataValue symVal;
106 + DataValue symVal = {NO_TAG, {0}};
108 DISASM_RT();
109 STACKDUMP(0, 3);
111 GET_SYM(s, False);
113 - if (s->type == LOCAL_SYM || s->type == GLOBAL_SYM) {
114 + switch (s->value.tag) {
115 + case INT_TAG:
116 + case STRING_TAG:
117 + case ARRAY_TAG:
118 symVal = s->value;
119 - } else if (s->type == ARG_SYM) {
120 - nArgs = FP_GET_ARG_COUNT(FrameP);
121 - argNum = s->value.val.n;
122 - if (argNum >= nArgs) {
123 - EXEC_ERROR("referenced undefined argument: %s", s->name);
124 - }
125 - if (argNum == N_ARGS_ARG_SYM) {
126 - symVal.tag = INT_TAG;
127 - symVal.val.n = nArgs;
128 - }
129 - else {
130 - symVal = FP_GET_ARG_N(FrameP, argNum);
131 + case NO_TAG:
132 + break;
133 +
134 + case ARG_VAR_TAG: {
135 + int nArgs = FP_GET_ARG_COUNT(FrameP);
136 + int argNum = s->value.val.n;
137 + if (argNum >= nArgs) {
138 + EXEC_ERROR("referenced undefined argument: %s", s->name);
139 + }
140 + if (argNum == N_ARGS_ARG_VAR) {
141 + symVal.tag = INT_TAG;
142 + symVal.val.n = nArgs;
143 + }
144 + else {
145 + symVal = FP_GET_ARG_N(FrameP, argNum);
146 + }
147 }
148 - } else if (s->type == PROC_VALUE_SYM) {
149 - char *errMsg;
150 - if (!s->value.val.subr(FocusWindow, NULL, 0, &symVal, &errMsg)) {
151 + break;
152 +
153 + case BUILT_IN_VAR_TAG: {
154 + char *errMsg;
155 + if (!s->value.val.subr(FocusWindow, NULL, 0, &symVal, &errMsg)) {
156 EXEC_ERROR(errMsg, s->name);
157 + }
158 }
159 - } else
160 + break;
161 +
162 + default:
163 EXEC_ERROR("reading non-variable: %s", s->name);
164 + }
165 +
166 if (symVal.tag == NO_TAG && !inTypeOfMode) {
167 EXEC_ERROR("variable not set: %s", s->name);
168 }
169 @@ -1602,7 +1620,7 @@ static int pushArraySymVal(void)
170 GET_SYM(sym, True);
171 GET_IMMED(initEmpty);
173 - if (sym->type != LOCAL_SYM && sym->type != GLOBAL_SYM) {
174 + if (sym->attr & READONLY_ATTR) {
175 EXEC_ERROR("assigning to non-lvalue array or non-array: %s", sym->name);
176 }
177 dataPtr = &sym->value;
178 @@ -1909,16 +1927,8 @@ static int assign(void)
180 GET_SYM(sym, True);
182 - if (sym->type != GLOBAL_SYM && sym->type != LOCAL_SYM) {
183 - if (sym->type == ARG_SYM) {
184 - EXEC_ERROR("assignment to function argument: %s", sym->name);
185 - }
186 - else if (sym->type == PROC_VALUE_SYM) {
187 - EXEC_ERROR("assignment to read-only variable: %s", sym->name);
188 - }
189 - else {
190 - EXEC_ERROR("assignment to non-variable: %s", sym->name);
191 - }
192 + if (sym->attr & READONLY_ATTR) {
193 + EXEC_ERROR("assignment to read-only variable: %s", sym->name);
194 }
195 dataPtr = &sym->value;
197 @@ -2636,7 +2646,7 @@ static int callSubroutineFromSymbol(Symb
198 /*
199 ** If the subroutine is built-in, call the built-in routine
200 */
201 - if (sym->type == C_FUNCTION_SYM) {
202 + if (sym->value.tag == BUILT_IN_SUBR_TAG) {
203 DataValue result;
204 char *errMsg;
206 @@ -2661,7 +2671,7 @@ static int callSubroutineFromSymbol(Symb
207 ** stack for local variables (and initialize them), on top of the argument
208 ** values which are already there.
209 */
210 - if (sym->type == MACRO_FUNCTION_SYM) {
211 + if (sym->value.tag == MACRO_SUBR_TAG) {
212 prog = sym->value.val.prog;
213 prog->refcount++;
214 /* -nArgs means 'arguments are on stack' */
215 @@ -2671,7 +2681,7 @@ static int callSubroutineFromSymbol(Symb
216 /*
217 ** Call an action routine
218 */
219 - if (sym->type == ACTION_ROUTINE_SYM) {
220 + if (sym->value.tag == ACTION_SUBR_TAG) {
221 String *argList;
222 Cardinal numArgs = nArgs;
223 XKeyEvent key_event;
224 @@ -2715,7 +2725,7 @@ static int callSubroutineFromSymbol(Symb
225 }
227 /* Calling a non subroutine symbol */
228 - EXEC_ERROR("%s is not a function or subroutine", sym->name);
229 + EXEC_ERROR("Calling non subroutine %s", sym->name);
230 }
232 /*
233 @@ -2878,9 +2888,9 @@ int OverlayRoutineFromProg(Program *prog
234 {
235 Symbol sym;
237 - sym.type = MACRO_FUNCTION_SYM;
238 + sym.attr = NO_ATTR;
239 sym.name = LookupString(prog->name, True);
240 - sym.value.tag = NO_TAG;
241 + sym.value.tag = MACRO_SUBR_TAG;
242 sym.value.val.prog = prog;
243 sym.next = NULL;
245 @@ -3591,14 +3601,14 @@ static int arrayIter(void)
247 POP(iterator);
249 - if (keySym->type != LOCAL_SYM && keySym->type != GLOBAL_SYM) {
250 + if (keySym->attr & READONLY_ATTR) {
251 EXEC_ERROR("can't assign to: %s", keySym->name);
252 }
253 keyValPtr = &keySym->value;
254 keyValPtr->tag = NO_TAG;
256 if (withVal) {
257 - if (valSym->type != LOCAL_SYM && valSym->type != GLOBAL_SYM) {
258 + if (valSym->attr & READONLY_ATTR) {
259 EXEC_ERROR("can't assign to: %s", valSym->name);
260 }
261 valPtr = &valSym->value;
262 @@ -3749,7 +3759,7 @@ static int arrayIterArray(void)
263 POP(iterator);
264 PEEK_INT(nDims, 0);
266 - if (keyArraySym->type != LOCAL_SYM && keyArraySym->type != GLOBAL_SYM) {
267 + if (keyArraySym->attr & READONLY_ATTR) {
268 EXEC_ERROR("can't assign to: %s", keyArraySym->name);
269 }
270 keyArrayPtr = &keyArraySym->value;
271 @@ -3757,7 +3767,7 @@ static int arrayIterArray(void)
272 keyArrayPtr->val.arrayPtr = NULL;
274 if (withVal) {
275 - if (valSym->type != LOCAL_SYM && valSym->type != GLOBAL_SYM) {
276 + if (valSym->attr & READONLY_ATTR) {
277 EXEC_ERROR("can't assign to: %s", valSym->name);
278 }
279 valPtr = &valSym->value;
280 @@ -3935,6 +3945,8 @@ static int typeOfOut(void)
281 case ARRAY_TAG:
282 retVal.val.str.rep = PERM_ALLOC_STR("ARRAY");
283 break;
284 + default:
285 + retVal.val.str.rep = PERM_ALLOC_STR("UNKNOWN");
286 }
287 retVal.val.str.len = strlen(retVal.val.str.rep);
289 diff --quilt old/source/interpret.h new/source/interpret.h
290 --- old/source/interpret.h
291 +++ new/source/interpret.h
292 @@ -40,8 +40,10 @@
293 #define LOOP_STACK_SIZE 256 /* (Approx.) Number of break/continue stmts
294 allowed per program */
296 -enum symTypes {GLOBAL_SYM, LOCAL_SYM, ARG_SYM, PROC_VALUE_SYM,
297 - C_FUNCTION_SYM, MACRO_FUNCTION_SYM, ACTION_ROUTINE_SYM};
298 +/* LOCAL_SYM -> LOCAL_SCOPE */
299 +/* GLOBAL_SYM -> GLOBAL_SCOPE */
300 +enum symScope {LOCAL_SCOPE, GLOBAL_SCOPE};
301 +enum symAttr {NO_ATTR = 0, READONLY_ATTR = 1 << 0};
303 enum operations {
304 #define OP(name, fn) OP_##name,
305 @@ -50,7 +52,14 @@ enum operations {
306 N_OPS
307 };
309 -enum typeTags {NO_TAG, INT_TAG, STRING_TAG, ARRAY_TAG};
310 +/* ARG_SYM -> ARG_VAR_TAG */
311 +/* MACRO_FUNCTION_SYM -> MACRO_SUBR_TAG */
312 +/* C_FUNCTION_SYM -> BUILT_IN_SUBR_TAG */
313 +/* PROC_VALUE_SYM -> BUILT_IN_VAR_TAG */
314 +/* ACTION_ROUTINE_SYM -> ACTION_SUBR_TAG */
315 +enum typeTags {NO_TAG, INT_TAG, STRING_TAG, ARRAY_TAG, ARG_VAR_TAG,
316 + BUILT_IN_VAR_TAG, BUILT_IN_SUBR_TAG, MACRO_SUBR_TAG,
317 + ACTION_SUBR_TAG};
319 enum execReturnCodes {MACRO_TIME_LIMIT, MACRO_PREEMPT, MACRO_DONE, MACRO_ERROR};
321 @@ -105,7 +114,7 @@ typedef struct SparseArrayEntryTag {
322 /* symbol table entry */
323 typedef struct SymbolRec {
324 const char *name;
325 - enum symTypes type;
326 + unsigned attr;
327 DataValue value;
328 unsigned int hash;
329 struct SymbolRec *next; /* to link to another */
330 @@ -161,7 +170,8 @@ int AddBranchOffset(Inst *to, char **msg
331 int SetBranchOffset(Inst *from, Inst *to, char **msg);
332 Inst *GetPC(void);
333 Symbol *LookupSymbol(const char *name, int create);
334 -Symbol *InstallSymbol(const char *name, enum symTypes type, DataValue value);
335 +Symbol *InstallSymbol(const char *name, enum symScope scope, unsigned attr,
336 + DataValue value);
337 const char *LookupString(const char *str, int create);
338 Inst *SwapCode(Inst *start, Inst *boundary, Inst *end);
339 int StartLoopAddrList(char **msg);
340 diff --quilt old/source/macro.c new/source/macro.c
341 --- old/source/macro.c
342 +++ new/source/macro.c
343 @@ -671,14 +671,15 @@ static char EscapeChars[] = "\\\"\n\t\b\
344 /*
345 ** Installs a set of built-in macro subroutines as symbols of given type.
346 */
347 -void RegisterMacroSubroutineSet(const BuiltInSubrName *set, enum symTypes type)
348 +void RegisterMacroSubroutineSet(const BuiltInSubrName *set, enum typeTags tag)
349 {
350 static DataValue subrPtr = {NO_TAG, {0}};
351 unsigned i;
353 + subrPtr.tag = tag;
354 for (i = 0; set[i].name; i++) {
355 subrPtr.val.subr = set[i].macroSubr;
356 - InstallSymbol(set[i].name, type, subrPtr);
357 + InstallSymbol(set[i].name, GLOBAL_SCOPE, READONLY_ATTR, subrPtr);
358 }
359 }
361 @@ -686,7 +687,7 @@ void RegisterMacroSubroutineSet(const Bu
362 ** Installs a set of built-in macro secondary return values as symbols of
363 ** given type.
364 */
365 -void RegisterGlobalReturnValuesSet(ReturnGlobalName *set, enum symTypes type)
366 +void RegisterGlobalReturnValuesSet(ReturnGlobalName *set)
367 {
368 int n, i, oldn;
369 Symbol **newRetGlobals;
370 @@ -710,7 +711,8 @@ void RegisterGlobalReturnValuesSet(Retur
371 /* now assign the (new) symbols at the newly allocated end of the table
372 and store the indices in set */
373 for (i = 0, n = oldn; set[i].name; i++, n++) {
374 - ReturnGlobals[n] = InstallSymbol(set[i].name, type, noValue);
375 + ReturnGlobals[n] = InstallSymbol(set[i].name, GLOBAL_SCOPE,
376 + READONLY_ATTR, noValue);
377 *set[i].pIndex = n;
378 }
379 /* add the sentinel */
380 @@ -725,10 +727,10 @@ void RegisterMacroSubroutines(void)
381 {
382 /* Install symbols for built-in routines and variables, with pointers
383 to the appropriate c routines to do the work */
384 - RegisterMacroSubroutineSet(MacroSubrs, C_FUNCTION_SYM);
385 - RegisterMacroSubroutineSet(SpecialVars, PROC_VALUE_SYM);
386 + RegisterMacroSubroutineSet(MacroSubrs, BUILT_IN_SUBR_TAG);
387 + RegisterMacroSubroutineSet(SpecialVars, BUILT_IN_VAR_TAG);
388 /* Define global variables used for return values */
389 - RegisterGlobalReturnValuesSet(ReturnGlobalNames, GLOBAL_SYM);
390 + RegisterGlobalReturnValuesSet(ReturnGlobalNames);
391 }
393 #define MAX_LEARN_MSG_LEN ((2 * MAX_ACCEL_LEN) + 60)
394 @@ -3908,20 +3910,25 @@ static int defineMS(WindowInfo *window,
395 FreeProgram(prog);
396 *errMsg = "Try to override existing function.";
397 return False;
398 - } else {
399 - if (sym->type != MACRO_FUNCTION_SYM) {
400 + }
401 + else if (sym->attr & READONLY_ATTR) {
402 + FreeProgram(prog);
403 + *errMsg = "Try to override read only symbol.";
404 + return False;
405 + }
406 + else if (sym->value.tag != MACRO_SUBR_TAG) {
407 FreeProgram(prog);
408 *errMsg = "Try to override a non macro function.";
409 return False;
410 - }
411 - FreeProgram(sym->value.val.prog);
412 - sym->value.val.prog = prog;
413 }
414 - } else {
415 + FreeProgram(sym->value.val.prog);
416 + sym->value.val.prog = prog;
417 + }
418 + else {
419 DataValue subrPtr;
420 - subrPtr.tag = NO_TAG;
421 + subrPtr.tag = MACRO_SUBR_TAG;
422 subrPtr.val.prog = prog;
423 - sym = InstallSymbol(name, MACRO_FUNCTION_SYM, subrPtr);
424 + sym = InstallSymbol(name, GLOBAL_SCOPE, NO_ATTR, subrPtr);
425 }
427 return True;
428 @@ -7314,7 +7321,7 @@ Boolean MacroApplyHook(WindowInfo *docum
429 Boolean succ = False;
431 hookSymbol = LookupSymbol(hook, False);
432 - if (NULL != hookSymbol && MACRO_FUNCTION_SYM == hookSymbol->type) {
433 + if (NULL != hookSymbol && MACRO_SUBR_TAG == hookSymbol->value.tag) {
434 Program *hookProg = hookSymbol->value.val.prog;
435 RestartData *restartData;
436 DataValue dummyResultDV;
437 diff --quilt old/source/parse.y new/source/parse.y
438 --- old/source/parse.y
439 +++ new/source/parse.y
440 @@ -202,15 +202,20 @@ definekw: DEFINE {
441 definesym: SYMBOL {
442 $$.sym = LookupSymbol($1, False);
443 if ($$.sym) {
444 - if ($$.sym->type != MACRO_FUNCTION_SYM) {
445 - yyerror("try to override built-in subroutine"); YYERROR;
446 + if ($$.sym->attr & READONLY_ATTR) {
447 + yyerror("try to re-define read-only symbol");
448 + YYERROR;
449 + }
450 + else if ($$.sym->value.tag != MACRO_SUBR_TAG) {
451 + yyerror("try to override built-in subroutine");
452 + YYERROR;
453 }
454 }
455 else {
456 DataValue subrPtr;
457 - subrPtr.tag = NO_TAG;
458 + subrPtr.tag = MACRO_SUBR_TAG;
459 subrPtr.val.prog = NULL;
460 - $$.sym = InstallSymbol($1, MACRO_FUNCTION_SYM, subrPtr);
461 + $$.sym = InstallSymbol($1, GLOBAL_SCOPE, NO_ATTR, subrPtr);
462 }
463 $$.acc = BeginCreatingProgram($$.sym->name);
464 }