| blob | 4603e28260c2e2b89cf33188b35a8a3368c9103d |
1 Subject: extend fn(=array) syntax to fn(..., =array)
3 All non-negative one-dimensional numerical keys are appended to the
4 previously arguments, in order. All other entries are merge into the named
5 argument array.
7 ---
9 source/interpret.c | 162 +++++++++++++++++++++++++++--------------------------
10 source/ops.h | 3
11 source/parse.y | 30 +++++++++
12 3 files changed, 114 insertions(+), 81 deletions(-)
14 diff --quilt old/source/interpret.c new/source/interpret.c
15 --- old/source/interpret.c
16 +++ new/source/interpret.c
17 @@ -2501,7 +2501,7 @@ static int concat(void)
18 ** Before: Prog-> [subrSym], nArgs, next, ...
19 ** TheStack-> argArray?, argN-arg1, next, ...
20 **
21 -** For callSubroutineStackedN:
22 +** For callSubroutineUnpackArray:
23 ** Before: Prog-> [subrSym], next, ...
24 ** TheStack-> nArgs, argArray, argN-arg1, next, ...
25 **
26 @@ -2642,37 +2642,92 @@ static int callSubroutine(void)
27 }
29 /*
30 -** Before: Prog-> [subrSym], next, ...
31 -** Stack-> nArgs, argArray, argN-arg1, next, ...
32 +** For special call style where the $args array in the called function is
33 +** assigned from an array in the caller (as "calledFunc(=argsArray)"),
34 +** take consecutive elements indexed from 1 and put them on the stack, leaving
35 +** a copy of the actual array at the top of the stack, with the stacked
36 +** arguments removed. Finally, add the negative of the number of arguments
37 +** aplus 1 (for the argArray itself). This operation must be followed
38 +** by OP_SUBR_CALL_UNPACK_ARRAY (callSubroutineUnpackArray()).
39 **
40 -** After: Prog-> next, ... -- (built-in called subr)
41 -** Stack-> retVal?, next, ...
42 -** or: Prog-> (in called)next, ... -- (macro code called subr)
43 -** Stack-> symN-sym1(FP), nArgs, oldFP, retPC, argArray, argN-arg1, next, ...
44 +** The array copy is needed because if/when the $args array is accessed, the
45 +** arguments are copied back to the array, probably in different positions, as
46 +** is the case of a "call(=array)" function, where the first argument is
47 +** removed (the function name) and the others shifted down once. Without a
48 +** copy, this modifies the original array - a pass by reference not allowed in
49 +** the language.
50 +**
51 +** Before: Prog-> [sym], nArgs, next, ...
52 +** TheStack-> argArray(, namedArgsArray), argN-arg1, next, ...
53 +** After: Prog-> sym, nArgs, [next], ...
54 +** TheStack-> namedArgsArray, argM-arg1, next, ...
55 */
56 -static int callSubroutineStackedN(void)
57 +static int callSubroutineUnpackArray(void)
58 {
59 Symbol *sym;
60 - int nArgs;
61 - /* this is much like callSubroutine, but we get nArgs off the stack
62 - and it will always be negative since there is always an argArray */
63 + int nArgs, i, res, haveNamedArgs = 0;
64 + SparseArrayEntry *iter;
65 + DataValue dvEntry, dvArray, argArray;
66 +
67 + DISASM_RT(PC-1, 1);
69 sym = PC++->sym;
70 + nArgs = PC++->value;
72 - PEEK_INT(nArgs, 0);
73 - DISASM_RT(PC-2, 2);
74 - STACKDUMP(-nArgs + 1, 3); /* +1 for stacked nArgs */
75 + if (nArgs < 0) {
76 + haveNamedArgs = 1;
77 + nArgs = -nArgs - 1;
78 + }
80 - POP_INT(nArgs);
81 + STACKDUMP(nArgs + haveNamedArgs + 1, 3);
83 - assert (nArgs < 0);
84 + POP(argArray);
86 - if (nArgs >= 0) {
87 - /* should never happen */
88 - return execError("array argument call to %s erroneous", sym->name);
89 + if (argArray.tag != ARRAY_TAG) {
90 + return execError("argument array call made with non-array value", NULL);
91 }
93 - return callSubroutineFromSymbol(sym, nArgs);
94 + if (haveNamedArgs) {
95 + POP(dvArray);
96 + }
97 + else {
98 + dvArray.tag = ARRAY_TAG;
99 + dvArray.val.arrayPtr = ArrayNew();
100 + }
101 +
102 + iter = arrayIterateFirst(&argArray);
103 + while (iter) {
104 + int thisKey;
105 +
106 + if (iter->value.tag == ARRAY_TAG) {
107 + int errNum;
108 + DataValue tmpArray;
109 +
110 + errNum = ArrayCopy(&dvEntry, &iter->value);
111 + if (errNum != STAT_OK) {
112 + return(errNum);
113 + }
114 + }
115 + else {
116 + dvEntry = iter->value;
117 + }
118 +
119 + if (StringToNum(iter->key, &thisKey) && thisKey >= 0) {
120 + PUSH(dvEntry);
121 + nArgs++;
122 + }
123 + else {
124 + if (!ArrayInsert(&dvArray, iter->key, &dvEntry)) {
125 + return(execError("array copy failed", NULL));
126 + }
127 + }
128 +
129 + iter = arrayIterateNext(iter);
130 + }
131 +
132 + PUSH(dvArray);
133 +
134 + return callSubroutineFromSymbol(sym, -nArgs - 1);
135 }
137 /*
138 @@ -2732,60 +2787,6 @@ int OverlayRoutineFromProg(Program *prog
139 }
141 /*
142 -** For special call style where the $args array in the called function is
143 -** assigned from an array in the caller (as "calledFunc(=argsArray)"),
144 -** take consecutive elements indexed from 1 and put them on the stack, leaving
145 -** a copy of the actual array at the top of the stack, with the stacked
146 -** arguments removed. Finally, add the negative of the number of arguments
147 -** aplus 1 (for the argArray itself). This operation must be followed
148 -** by OP_SUBR_CALL_STACKED_N (callSubroutineStackedN()).
149 -**
150 -** The array copy is needed because if/when the $args array is accessed, the
151 -** arguments are copied back to the array, probably in different positions, as
152 -** is the case of a "call(=array)" function, where the first argument is
153 -** removed (the function name) and the others shifted down once. Without a
154 -** copy, this modifies the original array - a pass by reference not allowed in
155 -** the language.
156 -**
157 -** Before: Prog-> next, ...
158 -** TheStack-> argArray, next, ...
159 -** After: Prog-> next, ...
160 -** TheStack-> -(nArgs+1), argArray, argN-arg1, next, ...
161 -*/
162 -static int unpackArrayToArgs(void)
163 -{
164 - int nArgs, res;
165 -
166 - DataValue dvEntry, dvArray;
167 -
168 - DISASM_RT(PC-1, 1);
169 - STACKDUMP(1, 3);
170 -
171 - POP(dvEntry);
172 -
173 - if (dvEntry.tag != ARRAY_TAG) {
174 - return execError("argument array call made with non-array value", NULL);
175 - }
176 - res = ArrayCopy(&dvArray, &dvEntry);
177 - if (res != STAT_OK) {
178 - return execError("cannot copy array in array call", NULL);
179 - }
180 -
181 - /* push positional argument entries in the array on the stack */
182 - for (nArgs = 1; ; ++nArgs) {
183 - char *ind = (char *)longAsStr(nArgs);
184 - if (!ArrayGet(&dvArray, ind, &dvEntry))
185 - break;
186 - /* remove them from remaining array */
187 - ArrayDelete(&dvArray, ind);
188 - PUSH(dvEntry);
189 - }
190 - PUSH(dvArray);
191 - PUSH_INT(-nArgs);
192 - return STAT_OK;
193 -}
194 -
195 -/*
196 ** This should never be executed, returnVal checks for the presence of this
197 ** instruction at the PC to decide whether to push the function's return
198 ** value, then skips over it without executing.
199 @@ -4330,9 +4331,16 @@ static void disasmInternal(Inst *inst, i
200 }
201 i += 2;
202 }
203 - else if (j == OP_SUBR_CALL_STACKED_N) {
204 - printd(" %s args[] (?)", inst[i+1].sym->name);
205 - ++i;
206 + else if (j == OP_SUBR_CALL_UNPACK_ARRAY) {
207 + int args = inst[i+2].value;
208 + printd(" %s", inst[i+1].sym->name);
209 + if (args < 0) {
210 + printd(" %d+args[] =args[]", -args - 1);
211 + }
212 + else {
213 + printd(" %d args =args[]", args);
214 + }
215 + i += 2;
216 }
217 else if (j == OP_BEGIN_ARRAY_ITER ||
218 j == OP_BEGIN_ARRAY_ITER_ARRAY) {
219 diff --quilt old/source/parse.y new/source/parse.y
220 --- old/source/parse.y
221 +++ new/source/parse.y
222 @@ -69,6 +69,7 @@ static int follow(char expect, int yes,
223 static int follow2(char expect1, int yes1, char expect2, int yes2, int no);
224 static int follow_non_whitespace(char expect, int yes, int no);
225 static int eq_look_ahead(void);
226 +static int comma_look_ahead(void);
227 static Symbol *matchesActionRoutine(char **inPtr);
228 static int scanString(void);
230 @@ -117,6 +118,7 @@ typedef struct LVinst {
231 %token <oper> '=' ADDEQ SUBEQ MULEQ DIVEQ MODEQ ANDEQ OREQ
232 %token <oper> INCR DECR
233 %type <lvinst> lvlist lventry
234 +%token ARGSEP
236 %nonassoc IF_NO_ELSE
237 %nonassoc ELSE
238 @@ -554,9 +556,15 @@ funccall: TYPEOF '(' {
239 }
240 | SYMBOL '(' blank '=' blank expr blank ')' {
241 /* a single array replaces the argument list */
242 - ADD_OP(OP_UNPACKTOARGS);
243 - ADD_OP(OP_SUBR_CALL_STACKED_N);
244 + ADD_OP(OP_SUBR_CALL_UNPACK_ARRAY);
245 ADD_SYM(PromoteToGlobal($1));
246 + ADD_IMMED(0); /* zero arguments */
247 + }
248 + | SYMBOL '(' fnarglist ARGSEP blank '=' blank expr blank ')' {
249 + /* a single array replaces the argument list */
250 + ADD_OP(OP_SUBR_CALL_UNPACK_ARRAY);
251 + ADD_SYM(PromoteToGlobal($1));
252 + ADD_IMMED($3);
253 }
254 ;
256 @@ -991,6 +999,7 @@ static int yylex(void)
257 ++InPtr;
258 return result; /* but return what we started with */
259 }
260 + case ',': return comma_look_ahead();
261 default: return *(InPtr-1);
262 }
263 }
264 @@ -1075,6 +1084,23 @@ static int eq_look_ahead(void)
265 return '=';
266 }
268 +static int comma_look_ahead(void)
269 +{
270 + char *savedInPtr = InPtr;
271 +
272 + /* skip any whitespace */
273 + skipWhitespace();
274 +
275 + /* '=' from array argument */
276 + if (*InPtr == '=') {
277 + InPtr = savedInPtr;
278 + return ARGSEP;
279 + }
280 +
281 + InPtr = savedInPtr;
282 + return ',';
283 +}
284 +
285 /*
286 ** Look (way) ahead for hyphenated routine names which begin at inPtr. A
287 ** hyphenated name is allowed if it is pre-defined in the global symbol
288 diff --quilt old/source/ops.h new/source/ops.h
289 --- old/source/ops.h
290 +++ new/source/ops.h
291 @@ -60,7 +60,6 @@ OP(ANONARRAY_CLOSE, anonArrayClos
292 OP(NAMED_ARG1, namedArg1) /* N */ /* pop(v,kN..k1), a=ary(), a[k1..kN]=v, push(a) */
293 OP(NAMED_ARGN, namedArgN) /* N */ /* pop(v,kN..k1,a), a[k1..kN]=v, push(a) */
294 OP(SWAP_TOP2, swapTop2) /* pop(v1,v2), push(v1,v2) */
295 -OP(SUBR_CALL_STACKED_N, callSubroutineStackedN) /*s*/ /* pop(N,a,pN..p1), call(s) */
296 -OP(UNPACKTOARGS, unpackArrayToArgs) /* pop(a), push(a[1]..a[N],a,-(N+1)) */
297 +OP(SUBR_CALL_UNPACK_ARRAY, callSubroutineUnpackArray) /*s,N*/ /* pop(a), push(numerics(a)), call(s) */
298 OP(TYPEOF_IN, typeOfIn) /* enable typeof() */
299 OP(TYPEOF_OUT, typeOfOut) /* pop(v), push(typeof(v)) */