diff options
-rw-r--r-- | apps/interpreters/bas/bas.c | 738 | ||||
-rw-r--r-- | apps/interpreters/bas/fs.c | 32 | ||||
-rw-r--r-- | apps/interpreters/bas/statement.c | 2194 |
3 files changed, 1485 insertions, 1479 deletions
diff --git a/apps/interpreters/bas/bas.c b/apps/interpreters/bas/bas.c index fb7006a60..89b8716f9 100644 --- a/apps/interpreters/bas/bas.c +++ b/apps/interpreters/bas/bas.c @@ -90,14 +90,14 @@ * Pre-processor Definitions ****************************************************************************/ -#define DIRECTMODE (pc.line== -1) +#define DIRECTMODE (g_pc.line== -1) #define _(String) String /**************************************************************************** * Private Types ****************************************************************************/ -enum LabelType +enum labeltype_e { L_IF = 1, L_ELSE, @@ -113,9 +113,9 @@ enum LabelType L_FUNC }; -struct LabelStack +struct labelstack_s { - enum LabelType type; + enum labeltype_e type; struct Pc patch; }; @@ -123,26 +123,27 @@ struct LabelStack * Private Data ****************************************************************************/ -static unsigned int labelStackPointer, labelStackCapacity; -static struct LabelStack *labelStack; -static struct Pc *lastdata; -static struct Pc curdata; -static struct Pc nextdata; +static unsigned int g_labelstack_index; +static unsigned int g_labelstack_capacity; +static struct labelstack_s *g_labelstack; +static struct Pc *g_lastdata; +static struct Pc g_curdata; +static struct Pc g_nextdata; static enum { DECLARE, COMPILE, INTERPRET - } pass; + } g_pass; -static int stopped; +static int g_stopped; static int optionbase; -static struct Pc pc; -static struct Auto stack; -static struct Program program; -static struct Global globals; -static int run_restricted; +static struct Pc g_pc; +static struct Auto g_stack; +static struct Program g_program; +static struct Global g_globals; +static int g_run_restricted; /**************************************************************************** * Public Data @@ -211,25 +212,25 @@ static int cat(const char *filename) static struct Value *lvalue(struct Value *value) { struct Symbol *sym; - struct Pc lvpc = pc; + struct Pc lvpc = g_pc; - sym = pc.token->u.identifier->sym; - assert(pass == DECLARE || sym->type == GLOBALVAR || sym->type == GLOBALARRAY + sym = g_pc.token->u.identifier->sym; + assert(g_pass == DECLARE || sym->type == GLOBALVAR || sym->type == GLOBALARRAY || sym->type == LOCALVAR); - if ((pc.token + 1)->type == T_OP) + if ((g_pc.token + 1)->type == T_OP) { struct Pc idxpc; unsigned int dim, capacity; int *idx; - pc.token += 2; + g_pc.token += 2; dim = 0; capacity = 0; idx = (int *)0; while (1) { - if (dim == capacity && pass == INTERPRET) /* enlarge idx */ + if (dim == capacity && g_pass == INTERPRET) /* enlarge idx */ { int *more; @@ -247,7 +248,7 @@ static struct Value *lvalue(struct Value *value) idx = more; } - idxpc = pc; + idxpc = g_pc; if (eval(value, _("index"))->type == V_ERROR || VALUE_RETYPE(value, V_INTEGER)->type == V_ERROR) { @@ -256,20 +257,20 @@ static struct Value *lvalue(struct Value *value) free(idx); } - pc = idxpc; + g_pc = idxpc; return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { idx[dim] = value->u.integer; ++dim; } Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -277,24 +278,24 @@ static struct Value *lvalue(struct Value *value) } } - if (pc.token->type != T_CP) + if (g_pc.token->type != T_CP) { - assert(pass != INTERPRET); + assert(g_pass != INTERPRET); return Value_new_ERROR(value, MISSINGCP); } else { - ++pc.token; + ++g_pc.token; } - switch (pass) + switch (g_pass) { case INTERPRET: { if ((value = Var_value(&(sym->u.var), dim, idx, value))->type == V_ERROR) { - pc = lvpc; + g_pc = lvpc; } free(idx); @@ -310,7 +311,7 @@ static struct Value *lvalue(struct Value *value) { return Value_nullValue(sym->type == GLOBALARRAY ? sym->u. - var.type : Auto_varType(&stack, sym)); + var.type : Auto_varType(&g_stack, sym)); } default: @@ -321,12 +322,12 @@ static struct Value *lvalue(struct Value *value) } else { - ++pc.token; - switch (pass) + ++g_pc.token; + switch (g_pass) { case INTERPRET: return VAR_SCALAR_VALUE(sym->type == - GLOBALVAR ? &(sym->u.var) : Auto_local(&stack, + GLOBALVAR ? &(sym->u.var) : Auto_local(&g_stack, sym-> u.local.offset)); @@ -336,7 +337,7 @@ static struct Value *lvalue(struct Value *value) case COMPILE: return Value_nullValue(sym->type == GLOBALVAR ? sym->u. - var.type : Auto_varType(&stack, sym)); + var.type : Auto_varType(&g_stack, sym)); default: assert(0); @@ -349,12 +350,12 @@ static struct Value *lvalue(struct Value *value) static struct Value *func(struct Value *value) { struct Identifier *ident; - struct Pc funcpc = pc; + struct Pc funcpc = g_pc; int firstslot = -99; int args = 0; struct Symbol *sym; - assert(pc.token->type == T_IDENTIFIER); + assert(g_pc.token->type == T_IDENTIFIER); /* Evaluating a function in direct mode may start a program, so it needs to * be compiled. If in direct mode, programs will be compiled after the @@ -364,7 +365,7 @@ static struct Value *func(struct Value *value) * this point, compile it again to get the error and abort. */ - if (DIRECTMODE && !program.runnable && pass != DECLARE) + if (DIRECTMODE && !g_program.runnable && g_pass != DECLARE) { if (compileProgram(value, 0)->type == V_ERROR) { @@ -374,29 +375,29 @@ static struct Value *func(struct Value *value) Value_destroy(value); } - ident = pc.token->u.identifier; - assert(pass == DECLARE || ident->sym->type == BUILTINFUNCTION || + ident = g_pc.token->u.identifier; + assert(g_pass == DECLARE || ident->sym->type == BUILTINFUNCTION || ident->sym->type == USERFUNCTION); - ++pc.token; - if (pass != DECLARE) + ++g_pc.token; + if (g_pass != DECLARE) { - firstslot = stack.stackPointer; + firstslot = g_stack.stackPointer; if (ident->sym->type == USERFUNCTION && ident->sym->u.sub.retType != V_VOID) { - struct Var *v = Auto_pushArg(&stack); + struct Var *v = Auto_pushArg(&g_stack); Var_new(v, ident->sym->u.sub.retType, 0, (const unsigned int *)0, 0); } } - if (pc.token->type == T_OP) /* push arguments to stack */ + if (g_pc.token->type == T_OP) /* push arguments to stack */ { - ++pc.token; - if (pc.token->type != T_CP) + ++g_pc.token; + if (g_pc.token->type != T_CP) { while (1) { - if (pass == DECLARE) + if (g_pass == DECLARE) { if (eval(value, _("actual parameter"))->type == V_ERROR) { @@ -407,15 +408,15 @@ static struct Value *func(struct Value *value) } else { - struct Var *v = Auto_pushArg(&stack); + struct Var *v = Auto_pushArg(&g_stack); Var_new_scalar(v); if (eval(v->value, (const char *)0)->type == V_ERROR) { Value_clone(value, v->value); - while (stack.stackPointer > firstslot) + while (g_stack.stackPointer > firstslot) { - Var_destroy(&stack.slot[--stack.stackPointer].var); + Var_destroy(&g_stack.slot[--g_stack.stackPointer].var); } return value; @@ -425,9 +426,9 @@ static struct Value *func(struct Value *value) } ++args; - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -435,24 +436,24 @@ static struct Value *func(struct Value *value) } } - if (pc.token->type != T_CP) + if (g_pc.token->type != T_CP) { - if (pass != DECLARE) + if (g_pass != DECLARE) { - while (stack.stackPointer > firstslot) + while (g_stack.stackPointer > firstslot) { - Var_destroy(&stack.slot[--stack.stackPointer].var); + Var_destroy(&g_stack.slot[--g_stack.stackPointer].var); } } return Value_new_ERROR(value, MISSINGCP); } - ++pc.token; + ++g_pc.token; } } - if (pass == DECLARE) + if (g_pass == DECLARE) { Value_new_null(value, ident->defaultType); } @@ -463,24 +464,24 @@ static struct Value *func(struct Value *value) int argerr; int overloaded; - if (pass == INTERPRET && ident->sym->type == USERFUNCTION) + if (g_pass == INTERPRET && ident->sym->type == USERFUNCTION) { for (i = 0; i < ident->sym->u.sub.u.def.localLength; ++i) { - struct Var *v = Auto_pushArg(&stack); + struct Var *v = Auto_pushArg(&g_stack); Var_new(v, ident->sym->u.sub.u.def.localTypes[i], 0, (const unsigned int *)0, 0); } } - Auto_pushFuncRet(&stack, firstslot, &pc); + Auto_pushFuncRet(&g_stack, firstslot, &g_pc); sym = ident->sym; - overloaded = (pass == COMPILE && sym->type == BUILTINFUNCTION && + overloaded = (g_pass == COMPILE && sym->type == BUILTINFUNCTION && sym->u.sub.u.bltin.next); do { - nomore = (pass == COMPILE && + nomore = (g_pass == COMPILE && !(sym->type == BUILTINFUNCTION && sym->u.sub.u.bltin.next)); argerr = 0; if (args < sym->u.sub.argLength) @@ -507,7 +508,7 @@ static struct Value *func(struct Value *value) for (i = 0; i < args; ++i) { struct Value *arg = - Var_value(Auto_local(&stack, i), 0, (int *)0, value); + Var_value(Auto_local(&g_stack, i), 0, (int *)0, value); assert(arg->type != V_ERROR); if (overloaded) @@ -542,8 +543,8 @@ static struct Value *func(struct Value *value) { if (nomore) { - Auto_funcReturn(&stack, (struct Pc *)0); - pc = funcpc; + Auto_funcReturn(&g_stack, (struct Pc *)0); + g_pc = funcpc; return value; } else @@ -557,11 +558,11 @@ static struct Value *func(struct Value *value) ident->sym = sym; if (sym->type == BUILTINFUNCTION) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - if (sym->u.sub.u.bltin.call(value, &stack)->type == V_ERROR) + if (sym->u.sub.u.bltin.call(value, &g_stack)->type == V_ERROR) { - pc = funcpc; + g_pc = funcpc; } } else @@ -571,18 +572,18 @@ static struct Value *func(struct Value *value) } else if (sym->type == USERFUNCTION) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { int r = 1; - pc = sym->u.sub.u.def.scope.start; - if (pc.token->type == T_COLON) + g_pc = sym->u.sub.u.def.scope.start; + if (g_pc.token->type == T_COLON) { - ++pc.token; + ++g_pc.token; } else { - Program_skipEOL(&program, &pc, STDCHANNEL, 1); + Program_skipEOL(&g_program, &g_pc, STDCHANNEL, 1); } do @@ -591,20 +592,20 @@ static struct Value *func(struct Value *value) { if (strchr(value->u.error.msg, '\n') == (char *)0) { - Auto_setError(&stack, - Program_lineNumber(&program, &pc), &pc, + Auto_setError(&g_stack, + Program_lineNumber(&g_program, &g_pc), &g_pc, value); - Program_PCtoError(&program, &pc, value); + Program_PCtoError(&g_program, &g_pc, value); } - if (stack.onerror.line != -1) + if (g_stack.onerror.line != -1) { - stack.resumeable = 1; - pc = stack.onerror; + g_stack.resumeable = 1; + g_pc = g_stack.onerror; } else { - Auto_frameToError(&stack, &program, value); + Auto_frameToError(&g_stack, &g_program, value); break; } } @@ -615,7 +616,7 @@ static struct Value *func(struct Value *value) Value_destroy(value); } - while ((r = Program_skipEOL(&program, &pc, STDCHANNEL, 1))); + while ((r = Program_skipEOL(&g_program, &g_pc, STDCHANNEL, 1))); if (!r) { @@ -628,8 +629,8 @@ static struct Value *func(struct Value *value) } } - Auto_funcReturn(&stack, pass == INTERPRET && - value->type != V_ERROR ? &pc : (struct Pc *)0); + Auto_funcReturn(&g_stack, g_pass == INTERPRET && + value->type != V_ERROR ? &g_pc : (struct Pc *)0); } return value; @@ -730,7 +731,7 @@ static struct Value *eval(struct Value *value, const char *desc) stackEnd = pdastack + capacity - 1; } - ip = pc.token->type; + ip = g_pc.token->type; switch (sp->state) { case 0: @@ -745,22 +746,22 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = gotoState[(sp - 1)->state]; - if (pass == COMPILE) + if (g_pass == COMPILE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_find(&globals, pc.token->u.identifier, - (pc.token + 1)->type == T_OP) == 0) + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_find(&g_globals, g_pc.token->u.identifier, + (g_pc.token + 1)->type == T_OP) == 0) { Value_new_ERROR(value, UNDECLARED); goto error; } } - if (pass != DECLARE && - (pc.token->u.identifier->sym->type == GLOBALVAR || - pc.token->u.identifier->sym->type == GLOBALARRAY || - pc.token->u.identifier->sym->type == LOCALVAR)) + if (g_pass != DECLARE && + (g_pc.token->u.identifier->sym->type == GLOBALVAR || + g_pc.token->u.identifier->sym->type == GLOBALARRAY || + g_pc.token->u.identifier->sym->type == LOCALVAR)) { struct Value *l; @@ -770,12 +771,12 @@ static struct Value *eval(struct Value *value, const char *desc) } else { - struct Pc var = pc; + struct Pc var = g_pc; func(&sp->u.value); if (sp->u.value.type == V_VOID) { - pc = var; + g_pc = var; Value_new_ERROR(value, VOIDVALUE); goto error; } @@ -788,8 +789,8 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = gotoState[(sp - 1)->state]; - VALUE_NEW_INTEGER(&sp->u.value, pc.token->u.integer); - ++pc.token; + VALUE_NEW_INTEGER(&sp->u.value, g_pc.token->u.integer); + ++g_pc.token; } else if (ip == T_REAL) { @@ -798,8 +799,8 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = gotoState[(sp - 1)->state]; - VALUE_NEW_REAL(&sp->u.value, pc.token->u.real); - ++pc.token; + VALUE_NEW_REAL(&sp->u.value, g_pc.token->u.real); + ++g_pc.token; } else if (TOKEN_ISUNARYOPERATOR(ip)) { @@ -808,7 +809,7 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = 2; sp->u.token = ip; - ++pc.token; + ++g_pc.token; } else if (ip == T_HEXINTEGER) { @@ -817,8 +818,8 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = gotoState[(sp - 1)->state]; - VALUE_NEW_INTEGER(&sp->u.value, pc.token->u.hexinteger); - ++pc.token; + VALUE_NEW_INTEGER(&sp->u.value, g_pc.token->u.hexinteger); + ++g_pc.token; } else if (ip == T_OCTINTEGER) { @@ -827,8 +828,8 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = gotoState[(sp - 1)->state]; - VALUE_NEW_INTEGER(&sp->u.value, pc.token->u.octinteger); - ++pc.token; + VALUE_NEW_INTEGER(&sp->u.value, g_pc.token->u.octinteger); + ++g_pc.token; } else if (ip == T_OP) { @@ -837,7 +838,7 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = 3; sp->u.token = T_OP; - ++pc.token; + ++g_pc.token; } else if (ip == T_STRING) { @@ -848,8 +849,8 @@ static struct Value *eval(struct Value *value, const char *desc) sp->state = gotoState[(sp - 1)->state]; Value_new_STRING(&sp->u.value); String_destroy(&sp->u.value.u.string); - String_clone(&sp->u.value.u.string, pc.token->u.string); - ++pc.token; + String_clone(&sp->u.value.u.string, g_pc.token->u.string); + ++g_pc.token; } else { @@ -886,7 +887,7 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = 1; sp->u.token = ip; - ++pc.token; + ++g_pc.token; break; } else @@ -913,7 +914,7 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = 1; sp->u.token = ip; - ++pc.token; + ++g_pc.token; } else { @@ -930,11 +931,11 @@ static struct Value *eval(struct Value *value, const char *desc) break; case T_MINUS: - Value_uneg(&sp->u.value, pass == INTERPRET); + Value_uneg(&sp->u.value, g_pass == INTERPRET); break; case T_NOT: - Value_unot(&sp->u.value, pass == INTERPRET); + Value_unot(&sp->u.value, g_pass == INTERPRET); break; default: @@ -962,7 +963,7 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = 1; sp->u.token = ip; - ++pc.token; + ++g_pc.token; } else if (ip == T_CP) { @@ -972,7 +973,7 @@ static struct Value *eval(struct Value *value, const char *desc) --sp; sp->state = gotoState[(sp - 1)->state]; sp->u.value = (sp + 1)->u.value; - ++pc.token; + ++g_pc.token; } else { @@ -999,7 +1000,7 @@ static struct Value *eval(struct Value *value, const char *desc) ++sp; sp->state = 1; sp->u.token = ip; - ++pc.token; + ++g_pc.token; } else { @@ -1021,91 +1022,91 @@ static struct Value *eval(struct Value *value, const char *desc) { case T_LT: Value_lt(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_LE: Value_le(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_EQ: Value_eq(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_GE: Value_ge(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_GT: Value_gt(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_NE: Value_ne(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_PLUS: Value_add(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_MINUS: Value_sub(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_MULT: Value_mult(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_DIV: Value_div(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_IDIV: Value_idiv(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_MOD: Value_mod(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_POW: Value_pow(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_AND: Value_and(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_OR: Value_or(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_XOR: Value_xor(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_EQV: Value_eqv(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; case T_IMP: Value_imp(&(sp - 2)->u.value, &sp->u.value, - pass == INTERPRET); + g_pass == INTERPRET); break; default: @@ -1170,14 +1171,14 @@ static inline struct Value *binarydown(struct Value *value, { struct Value x; - op = pc.token->type; + op = g_pc.token->type; if (!TOKEN_ISBINARYOPERATOR(op) || TOKEN_BINARYPRIORITY(op) != prio) { return value; } - oppc = pc; - ++pc.token; + oppc = g_pc; + ++g_pc.token; if (level(&x) == (struct Value *)0) { Value_destroy(value); @@ -1202,75 +1203,75 @@ static inline struct Value *binarydown(struct Value *value, switch (op) { case T_LT: - Value_lt(value, &x, pass == INTERPRET); + Value_lt(value, &x, g_pass == INTERPRET); break; case T_LE: - Value_le(value, &x, pass == INTERPRET); + Value_le(value, &x, g_pass == INTERPRET); break; case T_EQ: - Value_eq(value, &x, pass == INTERPRET); + Value_eq(value, &x, g_pass == INTERPRET); break; case T_GE: - Value_ge(value, &x, pass == INTERPRET); + Value_ge(value, &x, g_pass == INTERPRET); break; case T_GT: - Value_gt(value, &x, pass == INTERPRET); + Value_gt(value, &x, g_pass == INTERPRET); break; case T_NE: - Value_ne(value, &x, pass == INTERPRET); + Value_ne(value, &x, g_pass == INTERPRET); break; case T_PLUS: - Value_add(value, &x, pass == INTERPRET); + Value_add(value, &x, g_pass == INTERPRET); break; case T_MINUS: - Value_sub(value, &x, pass == INTERPRET); + Value_sub(value, &x, g_pass == INTERPRET); break; case T_MULT: - Value_mult(value, &x, pass == INTERPRET); + Value_mult(value, &x, g_pass == INTERPRET); break; case T_DIV: - Value_div(value, &x, pass == INTERPRET); + Value_div(value, &x, g_pass == INTERPRET); break; case T_IDIV: - Value_idiv(value, &x, pass == INTERPRET); + Value_idiv(value, &x, g_pass == INTERPRET); break; case T_MOD: - Value_mod(value, &x, pass == INTERPRET); + Value_mod(value, &x, g_pass == INTERPRET); break; case T_POW: - Value_pow(value, &x, pass == INTERPRET); + Value_pow(value, &x, g_pass == INTERPRET); break; case T_AND: - Value_and(value, &x, pass == INTERPRET); + Value_and(value, &x, g_pass == INTERPRET); break; case T_OR: - Value_or(value, &x, pass == INTERPRET); + Value_or(value, &x, g_pass == INTERPRET); break; case T_XOR: - Value_xor(value, &x, pass == INTERPRET); + Value_xor(value, &x, g_pass == INTERPRET); break; case T_EQV: - Value_eqv(value, &x, pass == INTERPRET); + Value_eqv(value, &x, g_pass == INTERPRET); break; case T_IMP: - Value_imp(value, &x, pass == INTERPRET); + Value_imp(value, &x, g_pass == INTERPRET); break; default: @@ -1284,7 +1285,7 @@ static inline struct Value *binarydown(struct Value *value, if (value->type == V_ERROR) { - pc = oppc; + g_pc = oppc; } return value; @@ -1298,14 +1299,14 @@ static inline struct Value *unarydown(struct Value *value, enum TokenType op; struct Pc oppc; - op = pc.token->type; + op = g_pc.token->type; if (!TOKEN_ISUNARYOPERATOR(op) || TOKEN_UNARYPRIORITY(op) != prio) { return level(value); } - oppc = pc; - ++pc.token; + oppc = g_pc; + ++g_pc.token; if (unarydown(value, level, prio) == (struct Value *)0) { return Value_new_ERROR(value, MISSINGEXPR, _("unary operand")); @@ -1319,15 +1320,15 @@ static inline struct Value *unarydown(struct Value *value, switch (op) { case T_PLUS: - Value_uplus(value, pass == INTERPRET); + Value_uplus(value, g_pass == INTERPRET); break; case T_MINUS: - Value_uneg(value, pass == INTERPRET); + Value_uneg(value, g_pass == INTERPRET); break; case T_NOT: - Value_unot(value, pass == INTERPRET); + Value_unot(value, g_pass == INTERPRET); break; default: @@ -1336,7 +1337,7 @@ static inline struct Value *unarydown(struct Value *value, if (value->type == V_ERROR) { - pc = oppc; + g_pc = oppc; } return value; @@ -1344,28 +1345,28 @@ static inline struct Value *unarydown(struct Value *value, static struct Value *eval8(struct Value *value) { - switch (pc.token->type) + switch (g_pc.token->type) { case T_IDENTIFIER: { struct Pc var; struct Value *l; - var = pc; - if (pass == COMPILE) + var = g_pc; + if (g_pass == COMPILE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_find(&globals, pc.token->u.identifier, - (pc.token + 1)->type == T_OP) == 0) + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_find(&g_globals, g_pc.token->u.identifier, + (g_pc.token + 1)->type == T_OP) == 0) return Value_new_ERROR(value, UNDECLARED); } - assert(pass == DECLARE || pc.token->u.identifier->sym); - if (pass != DECLARE && - (pc.token->u.identifier->sym->type == GLOBALVAR || - pc.token->u.identifier->sym->type == GLOBALARRAY || - pc.token->u.identifier->sym->type == LOCALVAR)) + assert(g_pass == DECLARE || g_pc.token->u.identifier->sym); + if (g_pass != DECLARE && + (g_pc.token->u.identifier->sym->type == GLOBALVAR || + g_pc.token->u.identifier->sym->type == GLOBALARRAY || + g_pc.token->u.identifier->sym->type == LOCALVAR)) { if ((l = lvalue(value))->type == V_ERROR) { @@ -1380,7 +1381,7 @@ static struct Value *eval8(struct Value *value) if (value->type == V_VOID) { Value_destroy(value); - pc = var; + g_pc = var; return Value_new_ERROR(value, VOIDVALUE); } } @@ -1390,15 +1391,15 @@ static struct Value *eval8(struct Value *value) case T_INTEGER: { - VALUE_NEW_INTEGER(value, pc.token->u.integer); - ++pc.token; + VALUE_NEW_INTEGER(value, g_pc.token->u.integer); + ++g_pc.token; break; } case T_REAL: { - VALUE_NEW_REAL(value, pc.token->u.real); - ++pc.token; + VALUE_NEW_REAL(value, g_pc.token->u.real); + ++g_pc.token; break; } @@ -1406,40 +1407,40 @@ static struct Value *eval8(struct Value *value) { Value_new_STRING(value); String_destroy(&value->u.string); - String_clone(&value->u.string, pc.token->u.string); - ++pc.token; + String_clone(&value->u.string, g_pc.token->u.string); + ++g_pc.token; break; } case T_HEXINTEGER: { - VALUE_NEW_INTEGER(value, pc.token->u.hexinteger); - ++pc.token; + VALUE_NEW_INTEGER(value, g_pc.token->u.hexinteger); + ++g_pc.token; break; } case T_OCTINTEGER: { - VALUE_NEW_INTEGER(value, pc.token->u.octinteger); - ++pc.token; + VALUE_NEW_INTEGER(value, g_pc.token->u.octinteger); + ++g_pc.token; break; } case T_OP: { - ++pc.token; + ++g_pc.token; if (eval(value, _("parenthetic"))->type == V_ERROR) { return value; } - if (pc.token->type != T_CP) + if (g_pc.token->type != T_CP) { Value_destroy(value); return Value_new_ERROR(value, MISSINGCP); } - ++pc.token; + ++g_pc.token; break; } @@ -1491,7 +1492,7 @@ static struct Value *eval(struct Value *value, const char *desc) { /* Avoid function calls for atomic expression */ - switch (pc.token->type) + switch (g_pc.token->type) { case T_STRING: case T_REAL: @@ -1499,8 +1500,8 @@ static struct Value *eval(struct Value *value, const char *desc) case T_HEXINTEGER: case T_OCTINTEGER: case T_IDENTIFIER: - if (!TOKEN_ISBINARYOPERATOR((pc.token + 1)->type) && - (pc.token + 1)->type != T_OP) + if (!TOKEN_ISBINARYOPERATOR((g_pc.token + 1)->type) && + (g_pc.token + 1)->type != T_OP) { return eval7(value); } @@ -1529,55 +1530,55 @@ static struct Value *eval(struct Value *value, const char *desc) static void new(void) { - Global_destroy(&globals); - Global_new(&globals); - Auto_destroy(&stack); - Auto_new(&stack); - Program_destroy(&program); - Program_new(&program); + Global_destroy(&g_globals); + Global_new(&g_globals); + Auto_destroy(&g_stack); + Auto_new(&g_stack); + Program_destroy(&g_program); + Program_new(&g_program); FS_closefiles(); optionbase = 0; } -static void pushLabel(enum LabelType type, struct Pc *patch) +static void pushLabel(enum labeltype_e type, struct Pc *patch) { - if (labelStackPointer == labelStackCapacity) + if (g_labelstack_index == g_labelstack_capacity) { - struct LabelStack *more; + struct labelstack_s *more; more = - realloc(labelStack, - sizeof(struct LabelStack) * - (labelStackCapacity ? (labelStackCapacity *= 2) : (32))); - labelStack = more; + realloc(g_labelstack, + sizeof(struct labelstack_s) * + (g_labelstack_capacity ? (g_labelstack_capacity *= 2) : (32))); + g_labelstack = more; } - labelStack[labelStackPointer].type = type; - labelStack[labelStackPointer].patch = *patch; - ++labelStackPointer; + g_labelstack[g_labelstack_index].type = type; + g_labelstack[g_labelstack_index].patch = *patch; + ++g_labelstack_index; } -static struct Pc *popLabel(enum LabelType type) +static struct Pc *popLabel(enum labeltype_e type) { - if (labelStackPointer == 0 || labelStack[labelStackPointer - 1].type != type) + if (g_labelstack_index == 0 || g_labelstack[g_labelstack_index - 1].type != type) { return (struct Pc *)0; } else { - return &labelStack[--labelStackPointer].patch; + return &g_labelstack[--g_labelstack_index].patch; } } -static struct Pc *findLabel(enum LabelType type) +static struct Pc *findLabel(enum labeltype_e type) { int i; - for (i = labelStackPointer - 1; i >= 0; --i) + for (i = g_labelstack_index - 1; i >= 0; --i) { - if (labelStack[i].type == type) + if (g_labelstack[i].type == type) { - return &labelStack[i].patch; + return &g_labelstack[i].patch; } } @@ -1586,9 +1587,9 @@ static struct Pc *findLabel(enum LabelType type) static void labelStackError(struct Value *v) { - assert(labelStackPointer); - pc = labelStack[labelStackPointer - 1].patch; - switch (labelStack[labelStackPointer - 1].type) + assert(g_labelstack_index); + g_pc = g_labelstack[g_labelstack_index - 1].patch; + switch (g_labelstack[g_labelstack_index - 1].type) { case L_IF: Value_new_ERROR(v, STRAYIF); @@ -1609,7 +1610,7 @@ static void labelStackError(struct Value *v) case L_FOR_BODY: { Value_new_ERROR(v, STRAYFOR); - pc = *findLabel(L_FOR); + g_pc = *findLabel(L_FOR); break; } @@ -1636,12 +1637,12 @@ static void labelStackError(struct Value *v) static const char *topLabelDescription(void) { - if (labelStackPointer == 0) + if (g_labelstack_index == 0) { return _("program"); } - switch (labelStack[labelStackPointer - 1].type) + switch (g_labelstack[g_labelstack_index - 1].type) { case L_IF: return _("`if' branch"); @@ -1683,30 +1684,30 @@ static struct Value *assign(struct Value *value) { struct Pc expr; - if (strcasecmp(pc.token->u.identifier->name, "mid$") == 0) + if (strcasecmp(g_pc.token->u.identifier->name, "mid$") == 0) { long int n, m; struct Value *l; - ++pc.token; - if (pc.token->type != T_OP) + ++g_pc.token; + if (g_pc.token->type != T_OP) { return Value_new_ERROR(value, MISSINGOP); } - ++pc.token; - if (pc.token->type != T_IDENTIFIER) + ++g_pc.token; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGSTRIDENT); } - if (pass == DECLARE) + if (g_pass == DECLARE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); @@ -1718,17 +1719,17 @@ static struct Value *assign(struct Value *value) return value; } - if (pass == COMPILE && l->type != V_STRING) + if (g_pass == COMPILE && l->type != V_STRING) { return Value_new_ERROR(value, TYPEMISMATCH4); } - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGCOMMA); } - ++pc.token; + ++g_pc.token; if (eval(value, _("position"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -1737,14 +1738,14 @@ static struct Value *assign(struct Value *value) n = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && n < 1) + if (g_pass == INTERPRET && n < 1) { return Value_new_ERROR(value, OUTOFRANGE, "position"); } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; if (eval(value, _("length"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -1752,7 +1753,7 @@ static struct Value *assign(struct Value *value) } m = value->u.integer; - if (pass == INTERPRET && m < 0) + if (g_pass == INTERPRET && m < 0) { return Value_new_ERROR(value, OUTOFRANGE, _("length")); } @@ -1764,25 +1765,25 @@ static struct Value *assign(struct Value *value) m = -1; } - if (pc.token->type != T_CP) + if (g_pc.token->type != T_CP) { return Value_new_ERROR(value, MISSINGCP); } - ++pc.token; - if (pc.token->type != T_EQ) + ++g_pc.token; + if (g_pc.token->type != T_EQ) { return Value_new_ERROR(value, MISSINGEQ); } - ++pc.token; + ++g_pc.token; if (eval(value, _("rhs"))->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (m == -1) { @@ -1809,13 +1810,13 @@ static struct Value *assign(struct Value *value) l = more; } - if (pass == DECLARE) + if (g_pass == DECLARE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { if (capacity) @@ -1833,9 +1834,9 @@ static struct Value *assign(struct Value *value) } ++used; - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -1843,13 +1844,13 @@ static struct Value *assign(struct Value *value) } } - if (pc.token->type != T_EQ) + if (g_pc.token->type != T_EQ) { return Value_new_ERROR(value, MISSINGEQ); } - ++pc.token; - expr = pc; + ++g_pc.token; + expr = g_pc; if (eval(value, _("rhs"))->type == V_ERROR) { return value; @@ -1858,17 +1859,17 @@ static struct Value *assign(struct Value *value) for (i = 0; i < used; ++i) { Value_clone(&retyped_value, value); - if (pass != DECLARE && + if (g_pass != DECLARE && VALUE_RETYPE(&retyped_value, (l[i])->type)->type == V_ERROR) { - pc = expr; + g_pc = expr; free(l); Value_destroy(value); *value = retyped_value; return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { Value_destroy(l[i]); *(l[i]) = retyped_value; @@ -1887,37 +1888,37 @@ static struct Value *compileProgram(struct Value *v, int clearGlobals) { struct Pc begin; - stack.resumeable = 0; + g_stack.resumeable = 0; if (clearGlobals) { - Global_destroy(&globals); - Global_new(&globals); + Global_destroy(&g_globals); + Global_new(&g_globals); } else { - Global_clearFunctions(&globals); + Global_clearFunctions(&g_globals); } - if (Program_beginning(&program, &begin)) + if (Program_beginning(&g_program, &begin)) { struct Pc savepc; int savepass; - savepc = pc; - savepass = pass; - Program_norun(&program); - for (pass = DECLARE; pass != INTERPRET; ++pass) + savepc = g_pc; + savepass = g_pass; + Program_norun(&g_program); + for (g_pass = DECLARE; g_pass != INTERPRET; ++g_pass) { - if (pass == DECLARE) + if (g_pass == DECLARE) { - stack.begindata.line = -1; - lastdata = &stack.begindata; + g_stack.begindata.line = -1; + g_lastdata = &g_stack.begindata; } optionbase = 0; - stopped = 0; - program.runnable = 1; - pc = begin; + g_stopped = 0; + g_program.runnable = 1; + g_pc = begin; while (1) { statements(v); @@ -1927,14 +1928,14 @@ static struct Value *compileProgram(struct Value *v, int clearGlobals) } Value_destroy(v); - if (!Program_skipEOL(&program, &pc, 0, 0)) + if (!Program_skipEOL(&g_program, &g_pc, 0, 0)) { Value_new_NIL(v); break; } } - if (v->type != V_ERROR && labelStackPointer > 0) + if (v->type != V_ERROR && g_labelstack_index > 0) { Value_destroy(v); labelStackError(v); @@ -1942,35 +1943,35 @@ static struct Value *compileProgram(struct Value *v, int clearGlobals) if (v->type == V_ERROR) { - labelStackPointer = 0; - Program_norun(&program); - if (stack.cur) + g_labelstack_index = 0; + Program_norun(&g_program); + if (g_stack.cur) { - Auto_funcEnd(&stack); /* Always correct? */ + Auto_funcEnd(&g_stack); /* Always correct? */ } - pass = savepass; + g_pass = savepass; return v; } } - pc = begin; - if (Program_analyse(&program, &pc, v)) + g_pc = begin; + if (Program_analyse(&g_program, &g_pc, v)) { - labelStackPointer = 0; - Program_norun(&program); - if (stack.cur) + g_labelstack_index = 0; + Program_norun(&g_program); + if (g_stack.cur) { - Auto_funcEnd(&stack); /* Always correct? */ + Auto_funcEnd(&g_stack); /* Always correct? */ } - pass = savepass; + g_pass = savepass; return v; } - curdata = stack.begindata; - pc = savepc; - pass = savepass; + g_curdata = g_stack.begindata; + g_pc = savepc; + g_pass = savepass; } return Value_new_NIL(v); @@ -1981,21 +1982,21 @@ static void runline(struct Token *line) struct Value value; FS_flush(STDCHANNEL); - for (pass = DECLARE; pass != INTERPRET; ++pass) + for (g_pass = DECLARE; g_pass != INTERPRET; ++g_pass) { - curdata.line = -1; - pc.line = -1; - pc.token = line; + g_curdata.line = -1; + g_pc.line = -1; + g_pc.token = line; optionbase = 0; - stopped = 0; + g_stopped = 0; statements(&value); - if (value.type != V_ERROR && pc.token->type != T_EOL) + if (value.type != V_ERROR && g_pc.token->type != T_EOL) { Value_destroy(&value); Value_new_ERROR(&value, SYNTAX); } - if (value.type != V_ERROR && labelStackPointer > 0) + if (value.type != V_ERROR && g_labelstack_index > 0) { Value_destroy(&value); labelStackError(&value); @@ -2005,9 +2006,9 @@ static void runline(struct Token *line) { struct String s; - Auto_setError(&stack, Program_lineNumber(&program, &pc), &pc, &value); - Program_PCtoError(&program, &pc, &value); - labelStackPointer = 0; + Auto_setError(&g_stack, Program_lineNumber(&g_program, &g_pc), &g_pc, &value); + Program_PCtoError(&g_program, &g_pc, &value); + g_labelstack_index = 0; FS_putChars(STDCHANNEL, _("Error: ")); String_new(&s); Value_toString(&value, &s, ' ', -1, 0, 0, 0, 0, -1, 0, 0); @@ -2017,54 +2018,54 @@ static void runline(struct Token *line) return; } - if (!program.runnable && pass == COMPILE) + if (!g_program.runnable && g_pass == COMPILE) { Value_destroy(&value); (void)compileProgram(&value, 0); } } - pc.line = -1; - pc.token = line; + g_pc.line = -1; + g_pc.token = line; optionbase = 0; - curdata = stack.begindata; - nextdata.line = -1; + g_curdata = g_stack.begindata; + g_nextdata.line = -1; Value_destroy(&value); - pass = INTERPRET; + g_pass = INTERPRET; do { - assert(pass == INTERPRET); + assert(g_pass == INTERPRET); statements(&value); - assert(pass == INTERPRET); + assert(g_pass == INTERPRET); if (value.type == V_ERROR) { if (strchr(value.u.error.msg, '\n') == (char *)0) { - Auto_setError(&stack, Program_lineNumber(&program, &pc), &pc, + Auto_setError(&g_stack, Program_lineNumber(&g_program, &g_pc), &g_pc, &value); - Program_PCtoError(&program, &pc, &value); + Program_PCtoError(&g_program, &g_pc, &value); } - if (stack.onerror.line != -1) + if (g_stack.onerror.line != -1) { - stack.resumeable = 1; - pc = stack.onerror; + g_stack.resumeable = 1; + g_pc = g_stack.onerror; } else { struct String s; String_new(&s); - if (!stopped) + if (!g_stopped) { - stopped = 0; + g_stopped = 0; FS_putChars(STDCHANNEL, _("Error: ")); } - Auto_frameToError(&stack, &program, &value); + Auto_frameToError(&g_stack, &g_program, &value); Value_toString(&value, &s, ' ', -1, 0, 0, 0, 0, -1, 0, 0); - while (Auto_gosubReturn(&stack, (struct Pc *)0)); + while (Auto_gosubReturn(&g_stack, (struct Pc *)0)); FS_putString(STDCHANNEL, &s); String_destroy(&s); Value_destroy(&value); @@ -2074,44 +2075,44 @@ static void runline(struct Token *line) Value_destroy(&value); } - while (pc.token->type != T_EOL || - Program_skipEOL(&program, &pc, STDCHANNEL, 1)); + while (g_pc.token->type != T_EOL || + Program_skipEOL(&g_program, &g_pc, STDCHANNEL, 1)); } static struct Value *evalGeometry(struct Value *value, unsigned int *dim, unsigned int geometry[]) { - struct Pc exprpc = pc; + struct Pc exprpc = g_pc; if (eval(value, _("dimension"))->type == V_ERROR || - (pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) + (g_pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) { return value; } - if (pass == INTERPRET && value->u.integer < optionbase) + if (g_pass == INTERPRET && value->u.integer < optionbase) { Value_destroy(value); - pc = exprpc; + g_pc = exprpc; return Value_new_ERROR(value, OUTOFRANGE, _("dimension")); } geometry[0] = value->u.integer - optionbase + 1; Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; - exprpc = pc; + ++g_pc.token; + exprpc = g_pc; if (eval(value, _("dimension"))->type == V_ERROR || - (pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) + (g_pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) { return value; } - if (pass == INTERPRET && value->u.integer < optionbase) + if (g_pass == INTERPRET && value->u.integer < optionbase) { Value_destroy(value); - pc = exprpc; + g_pc = exprpc; return Value_new_ERROR(value, OUTOFRANGE, _("dimension")); } @@ -2124,9 +2125,9 @@ static struct Value *evalGeometry(struct Value *value, unsigned int *dim, *dim = 1; } - if (pc.token->type == T_CP) + if (g_pc.token->type == T_CP) { - ++pc.token; + ++g_pc.token; } else { @@ -2223,30 +2224,30 @@ static struct Value *convert(struct Value *value, struct Value *l, static struct Value *dataread(struct Value *value, struct Value *l) { - if (curdata.line == -1) + if (g_curdata.line == -1) { return Value_new_ERROR(value, ENDOFDATA); } - if (curdata.token->type == T_DATA) + if (g_curdata.token->type == T_DATA) { - nextdata = curdata.token->u.nextdata; - ++curdata.token; + g_nextdata = g_curdata.token->u.nextdata; + ++g_curdata.token; } - if (convert(value, l, curdata.token)) + if (convert(value, l, g_curdata.token)) { return value; } - ++curdata.token; - if (curdata.token->type == T_COMMA) + ++g_curdata.token; + if (g_curdata.token->type == T_COMMA) { - ++curdata.token; + ++g_curdata.token; } else { - curdata = nextdata; + g_curdata = g_nextdata; } return (struct Value *)0; @@ -2257,11 +2258,11 @@ static struct Value more_statements; static struct Value *statements(struct Value *value) { more: - if (pc.token->statement) + if (g_pc.token->statement) { struct Value *v; - if ((v = pc.token->statement(value))) + if ((v = g_pc.token->statement(value))) { if (v == &more_statements) { @@ -2278,18 +2279,18 @@ more: return Value_new_ERROR(value, MISSINGSTATEMENT); } - if (pc.token->type == T_COLON && (pc.token + 1)->type == T_ELSE) + if (g_pc.token->type == T_COLON && (g_pc.token + 1)->type == T_ELSE) { - ++pc.token; + ++g_pc.token; } - else if ((pc.token->type == T_COLON && (pc.token + 1)->type != T_ELSE) || - pc.token->type == T_QUOTE) + else if ((g_pc.token->type == T_COLON && (g_pc.token + 1)->type != T_ELSE) || + g_pc.token->type == T_QUOTE) { - ++pc.token; + ++g_pc.token; goto more; } - else if ((pass == DECLARE || pass == COMPILE) && pc.token->type != T_EOL && - pc.token->type != T_ELSE) + else if ((g_pass == DECLARE || g_pass == COMPILE) && g_pc.token->type != T_EOL && + g_pc.token->type != T_ELSE) { return Value_new_ERROR(value, MISSINGCOLON); } @@ -2303,14 +2304,14 @@ more: void bas_init(int backslash_colon, int restricted, int uppercase, int lpfd) { - stack.begindata.line = -1; + g_stack.begindata.line = -1; Token_init(backslash_colon, uppercase); - Global_new(&globals); - Auto_new(&stack); - Program_new(&program); + Global_new(&g_globals); + Auto_new(&g_stack); + Program_new(&g_program); FS_opendev(STDCHANNEL, 0, 1); FS_opendev(LPCHANNEL, -1, lpfd); - run_restricted = restricted; + g_run_restricted = restricted; } void bas_runFile(const char *runFile) @@ -2329,7 +2330,7 @@ void bas_runFile(const char *runFile) FS_putChars(0, errmsg); FS_putChars(0, _(").\n")); } - else if (Program_merge(&program, dev, &value)) + else if (Program_merge(&g_program, dev, &value)) { struct String s; @@ -2345,7 +2346,7 @@ void bas_runFile(const char *runFile) { struct Token line[2]; - Program_setname(&program, runFile); + Program_setname(&g_program, runFile); line[0].type = T_RUN; line[0].statement = stmt_RUN; line[1].type = T_EOL; @@ -2381,7 +2382,7 @@ void bas_interpreter(void) struct Token *line; struct String s; - stopped = 0; + g_stopped = 0; FS_nextline(STDCHANNEL); if (FS_istty(STDCHANNEL)) { @@ -2410,27 +2411,27 @@ void bas_interpreter(void) { if (line->type == T_INTEGER && line->u.integer > 0) { - if (program.numbered) + if (g_program.numbered) { if ((line + 1)->type == T_EOL) { struct Pc where; - if (Program_goLine(&program, line->u.integer, &where) == + if (Program_goLine(&g_program, line->u.integer, &where) == (struct Pc *)0) { FS_putChars(STDCHANNEL, (NOSUCHLINE)); } else { - Program_delete(&program, &where, &where); + Program_delete(&g_program, &where, &where); } Token_destroy(line); } else { - Program_store(&program, line, line->u.integer); + Program_store(&g_program, line, line->u.integer); } } else @@ -2465,12 +2466,13 @@ void bas_interpreter(void) void bas_exit(void) { - Auto_destroy(&stack); - Global_destroy(&globals); - Program_destroy(&program); - if (labelStack) + Auto_destroy(&g_stack); + Global_destroy(&g_globals); + Program_destroy(&g_program); + if (g_labelstack) { - free(labelStack); + free(g_labelstack); + g_labelstack = (struct labelstack_s *)0; } FS_closefiles(); diff --git a/apps/interpreters/bas/fs.c b/apps/interpreters/bas/fs.c index aea3a466e..5895dc5c0 100644 --- a/apps/interpreters/bas/fs.c +++ b/apps/interpreters/bas/fs.c @@ -97,10 +97,14 @@ static struct FileStream **g_file; static int g_capacity; static int g_used; -static const int open_mode[4] = { 0, O_RDONLY, O_WRONLY, O_RDWR }; +static const int g_open_mode[4] = { 0, O_RDONLY, O_WRONLY, O_RDWR }; +static char g_errmsgbuf[80]; + +/**************************************************************************** + * Public Data + ****************************************************************************/ const char *FS_errmsg; -static char FS_errmsgbuf[80]; /**************************************************************************** * Private Functions @@ -139,9 +143,9 @@ static int opened(int dev, int mode) if (dev < 0 || dev >= g_capacity || g_file[dev] == (struct FileStream *)0) { - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), _("channel #%d not open"), + snprintf(g_errmsgbuf, sizeof(g_errmsgbuf), _("channel #%d not open"), dev); - FS_errmsg = FS_errmsgbuf; + FS_errmsg = g_errmsgbuf; return -1; } @@ -157,7 +161,7 @@ static int opened(int dev, int mode) fd = g_file[dev]->outfd; if (fd == -1) { - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + snprintf(g_errmsgbuf, sizeof(g_errmsgbuf), _("channel #%d not opened for writing"), dev); } break; @@ -168,7 +172,7 @@ static int opened(int dev, int mode) fd = g_file[dev]->infd; if (fd == -1) { - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + snprintf(g_errmsgbuf, sizeof(g_errmsgbuf), _("channel #%d not opened for reading"), dev); } break; @@ -179,7 +183,7 @@ static int opened(int dev, int mode) fd = g_file[dev]->randomfd; if (fd == -1) { - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + snprintf(g_errmsgbuf, sizeof(g_errmsgbuf), _("channel #%d not opened for random access"), dev); } break; @@ -190,7 +194,7 @@ static int opened(int dev, int mode) fd = g_file[dev]->binaryfd; if (fd == -1) { - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + snprintf(g_errmsgbuf, sizeof(g_errmsgbuf), _("channel #%d not opened for binary access"), dev); } break; @@ -201,7 +205,7 @@ static int opened(int dev, int mode) fd = (g_file[dev]->randomfd != -1 ? g_file[dev]->randomfd : g_file[dev]->binaryfd); if (fd == -1) { - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + snprintf(g_errmsgbuf, sizeof(g_errmsgbuf), _("channel #%d not opened for random or binary access"), dev); } @@ -214,7 +218,7 @@ static int opened(int dev, int mode) if (fd == -1) { - FS_errmsg = FS_errmsgbuf; + FS_errmsg = g_errmsgbuf; return -1; } else @@ -509,7 +513,7 @@ int FS_openinChn(int chn, const char *name, int mode) return -1; } - fl = open_mode[mode]; + fl = g_open_mode[mode]; /* Serial devices on Linux should be opened non-blocking, otherwise the * open() may block already. Named pipes can not be opened non-blocking in @@ -602,7 +606,7 @@ int FS_openoutChn(int chn, const char *name, int mode, int append) return -1; } - fl = open_mode[mode] | (append ? O_APPEND : 0); + fl = g_open_mode[mode] | (append ? O_APPEND : 0); /* Serial devices on Linux should be opened non-blocking, otherwise the */ /* open() may block already. Named pipes can not be opened non-blocking */ @@ -661,7 +665,7 @@ int FS_openrandomChn(int chn, const char *name, int mode, int recLength) return -1; } - if ((fd = open(name, open_mode[mode] | O_CREAT, 0666)) == -1) + if ((fd = open(name, g_open_mode[mode] | O_CREAT, 0666)) == -1) { FS_errmsg = strerror(errno); return -1; @@ -700,7 +704,7 @@ int FS_openbinaryChn(int chn, const char *name, int mode) return -1; } - if ((fd = open(name, open_mode[mode] | O_CREAT, 0666)) == -1) + if ((fd = open(name, g_open_mode[mode] | O_CREAT, 0666)) == -1) { FS_errmsg = strerror(errno); return -1; diff --git a/apps/interpreters/bas/statement.c b/apps/interpreters/bas/statement.c index 8ed0256e9..8ecfd1d79 100644 --- a/apps/interpreters/bas/statement.c +++ b/apps/interpreters/bas/statement.c @@ -82,13 +82,13 @@ struct Value *stmt_CALL(struct Value *value) { - ++pc.token; - if (pc.token->type != T_IDENTIFIER) + ++g_pc.token; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGPROCIDENT); } - if (pass == DECLARE) + if (g_pass == DECLARE) { if (func(value)->type == V_ERROR) { @@ -101,18 +101,18 @@ struct Value *stmt_CALL(struct Value *value) } else { - if (pass == COMPILE) + if (g_pass == COMPILE) { if (Global_find - (&globals, pc.token->u.identifier, - (pc.token + 1)->type == T_OP) == 0) + (&g_globals, g_pc.token->u.identifier, + (g_pc.token + 1)->type == T_OP) == 0) { return Value_new_ERROR(value, UNDECLARED); } } - if (pc.token->u.identifier->sym->type != USERFUNCTION && - pc.token->u.identifier->sym->type != BUILTINFUNCTION) + if (g_pc.token->u.identifier->sym->type != USERFUNCTION && + g_pc.token->u.identifier->sym->type != BUILTINFUNCTION) { return Value_new_ERROR(value, TYPEMISMATCH1, "variable", "function"); } @@ -131,9 +131,9 @@ struct Value *stmt_CALL(struct Value *value) struct Value *stmt_CASE(struct Value *value) { - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { struct Pc *selectcase, *nextcasevalue; @@ -146,15 +146,15 @@ struct Value *stmt_CASE(struct Value *value) nextcasevalue->line != -1; nextcasevalue = &nextcasevalue->token->u.casevalue->nextcasevalue); - *nextcasevalue = pc; - if (pass == COMPILE) + *nextcasevalue = g_pc; + if (g_pass == COMPILE) { - pc.token->u.casevalue->endselect = + g_pc.token->u.casevalue->endselect = selectcase->token->u.selectcase->endselect; } - pc.token->u.casevalue->nextcasevalue.line = -1; - ++pc.token; + g_pc.token->u.casevalue->nextcasevalue.line = -1; + ++g_pc.token; switch (statementpc.token->type) { case T_CASEELSE: @@ -166,10 +166,10 @@ struct Value *stmt_CASE(struct Value *value) do { - if (pc.token->type == T_IS) + if (g_pc.token->type == T_IS) { - ++pc.token; - switch (pc.token->type) + ++g_pc.token; + switch (g_pc.token->type) { case T_LT: case T_LE: @@ -183,8 +183,8 @@ struct Value *stmt_CASE(struct Value *value) return Value_new_ERROR(value, MISSINGRELOP); } - ++pc.token; - exprpc = pc; + ++g_pc.token; + exprpc = g_pc; if (eval(value, "`is'")->type == V_ERROR) { return value; @@ -195,7 +195,7 @@ struct Value *stmt_CASE(struct Value *value) selectcase->token->u.selectcase->type)->type == V_ERROR) { - pc = exprpc; + g_pc = exprpc; return value; } @@ -204,7 +204,7 @@ struct Value *stmt_CASE(struct Value *value) else /* value or range */ { - exprpc = pc; + exprpc = g_pc; if (eval(value, "`case'")->type == V_ERROR) { return value; @@ -215,15 +215,15 @@ struct Value *stmt_CASE(struct Value *value) selectcase->token->u.selectcase->type)->type == V_ERROR) { - pc = exprpc; + g_pc = exprpc; return value; } Value_destroy(value); - if (pc.token->type == T_TO) + if (g_pc.token->type == T_TO) { - ++pc.token; - exprpc = pc; + ++g_pc.token; + exprpc = g_pc; if (eval(value, "`case'")->type == V_ERROR) { return value; @@ -234,7 +234,7 @@ struct Value *stmt_CASE(struct Value *value) selectcase->token->u.selectcase->type)->type == V_ERROR) { - pc = exprpc; + g_pc = exprpc; return value; } @@ -243,9 +243,9 @@ struct Value *stmt_CASE(struct Value *value) } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -263,7 +263,7 @@ struct Value *stmt_CASE(struct Value *value) } else { - pc = pc.token->u.casevalue->endselect; + g_pc = g_pc.token->u.casevalue->endselect; } return (struct Value *)0; @@ -273,17 +273,17 @@ struct Value *stmt_CHDIR_MKDIR(struct Value *value) { int res = -1, err = -1; struct Pc dirpc; - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - ++pc.token; - dirpc = pc; + ++g_pc.token; + dirpc = g_pc; if (eval(value, _("directory"))->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { switch (statementpc.token->type) { @@ -303,9 +303,9 @@ struct Value *stmt_CHDIR_MKDIR(struct Value *value) } Value_destroy(value); - if (pass == INTERPRET && res == -1) + if (g_pass == INTERPRET && res == -1) { - pc = dirpc; + g_pc = dirpc; return Value_new_ERROR(value, IOERROR, strerror(err)); } @@ -314,13 +314,13 @@ struct Value *stmt_CHDIR_MKDIR(struct Value *value) struct Value *stmt_CLEAR(struct Value *value) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - Global_clear(&globals); + Global_clear(&g_globals); FS_closefiles(); } - ++pc.token; + ++g_pc.token; return (struct Value *)0; } @@ -329,14 +329,14 @@ struct Value *stmt_CLOSE(struct Value *value) int hasargs = 0; struct Pc chnpc; - ++pc.token; + ++g_pc.token; while (1) { - chnpc = pc; - if (pc.token->type == T_CHANNEL) + chnpc = g_pc; + if (g_pc.token->type == T_CHANNEL) { hasargs = 1; - ++pc.token; + ++g_pc.token; } if (eval(value, (const char *)0) == (struct Value *)0) @@ -358,16 +358,16 @@ struct Value *stmt_CLOSE(struct Value *value) return value; } - if (pass == INTERPRET && FS_close(value->u.integer) == -1) + if (g_pass == INTERPRET && FS_close(value->u.integer) == -1) { Value_destroy(value); - pc = chnpc; + g_pc = chnpc; return Value_new_ERROR(value, IOERROR, FS_errmsg); } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -375,7 +375,7 @@ struct Value *stmt_CLOSE(struct Value *value) } } - if (!hasargs && pass == INTERPRET) + if (!hasargs && g_pass == INTERPRET) { FS_closefiles(); } @@ -385,12 +385,12 @@ struct Value *stmt_CLOSE(struct Value *value) struct Value *stmt_CLS(struct Value *value) { - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - ++pc.token; - if (pass == INTERPRET && FS_cls(STDCHANNEL) == -1) + ++g_pc.token; + if (g_pass == INTERPRET && FS_cls(STDCHANNEL) == -1) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROR, FS_errmsg); } @@ -400,13 +400,13 @@ struct Value *stmt_CLS(struct Value *value) struct Value *stmt_COLOR(struct Value *value) { int foreground = -1, background = -1; - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - ++pc.token; + ++g_pc.token; if (eval(value, (const char *)0)) { if (value->type == V_ERROR || - (pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) + (g_pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) { return value; } @@ -415,19 +415,19 @@ struct Value *stmt_COLOR(struct Value *value) if (foreground < 0 || foreground > 15) { Value_destroy(value); - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, OUTOFRANGE, _("foreground colour")); } } Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; if (eval(value, (const char *)0)) { if (value->type == V_ERROR || - (pass != DECLARE && + (g_pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) { return value; @@ -437,21 +437,21 @@ struct Value *stmt_COLOR(struct Value *value) if (background < 0 || background > 15) { Value_destroy(value); - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, OUTOFRANGE, _("background colour")); } } Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; if (eval(value, (const char *)0)) { int bordercolour = -1; if (value->type == V_ERROR || - (pass != DECLARE && + (g_pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) { return value; @@ -461,7 +461,7 @@ struct Value *stmt_COLOR(struct Value *value) if (bordercolour < 0 || bordercolour > 15) { Value_destroy(value); - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, OUTOFRANGE, _("border colour")); } } @@ -470,7 +470,7 @@ struct Value *stmt_COLOR(struct Value *value) } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { FS_colour(STDCHANNEL, foreground, background); } @@ -485,28 +485,28 @@ struct Value *stmt_DATA(struct Value *value) return Value_new_ERROR(value, NOTINDIRECTMODE); } - if (pass == DECLARE) + if (g_pass == DECLARE) { - *lastdata = pc; - (lastdata = &(pc.token->u.nextdata))->line = -1; + *g_lastdata = g_pc; + (g_lastdata = &(g_pc.token->u.nextdata))->line = -1; } - ++pc.token; + ++g_pc.token; while (1) { - if (pc.token->type != T_STRING && pc.token->type != T_DATAINPUT) + if (g_pc.token->type != T_STRING && g_pc.token->type != T_DATAINPUT) { return Value_new_ERROR(value, MISSINGDATAINPUT); } - ++pc.token; - if (pc.token->type != T_COMMA) + ++g_pc.token; + if (g_pc.token->type != T_COMMA) { break; } else { - ++pc.token; + ++g_pc.token; } } @@ -515,9 +515,9 @@ struct Value *stmt_DATA(struct Value *value) struct Value *stmt_DEFFN_DEFPROC_FUNCTION_SUB(struct Value *value) { - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; struct Identifier *fn; int proc; int args = 0; @@ -527,9 +527,9 @@ struct Value *stmt_DEFFN_DEFPROC_FUNCTION_SUB(struct Value *value) return Value_new_ERROR(value, NOTINDIRECTMODE); } - proc = (pc.token->type == T_DEFPROC || pc.token->type == T_SUB); - ++pc.token; - if (pc.token->type != T_IDENTIFIER) + proc = (g_pc.token->type == T_DEFPROC || g_pc.token->type == T_SUB); + ++g_pc.token; + if (g_pc.token->type != T_IDENTIFIER) { if (proc) { @@ -541,42 +541,42 @@ struct Value *stmt_DEFFN_DEFPROC_FUNCTION_SUB(struct Value *value) } } - fn = pc.token->u.identifier; + fn = g_pc.token->u.identifier; if (proc) { fn->defaultType = V_VOID; } - ++pc.token; + ++g_pc.token; if (findLabel(L_FUNC)) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, NESTEDDEFINITION); } - Auto_variable(&stack, fn); - if (pc.token->type == T_OP) /* arguments */ + Auto_variable(&g_stack, fn); + if (g_pc.token->type == T_OP) /* arguments */ { - ++pc.token; + ++g_pc.token; while (1) { - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { - Auto_funcEnd(&stack); + Auto_funcEnd(&g_stack); return Value_new_ERROR(value, MISSINGFORMIDENT); } - if (Auto_variable(&stack, pc.token->u.identifier) == 0) + if (Auto_variable(&g_stack, g_pc.token->u.identifier) == 0) { - Auto_funcEnd(&stack); + Auto_funcEnd(&g_stack); return Value_new_ERROR(value, ALREADYDECLARED); } ++args; - ++pc.token; - if (pc.token->type == T_COMMA) + ++g_pc.token; + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -584,16 +584,16 @@ struct Value *stmt_DEFFN_DEFPROC_FUNCTION_SUB(struct Value *value) } } - if (pc.token->type != T_CP) + if (g_pc.token->type != T_CP) { - Auto_funcEnd(&stack); + Auto_funcEnd(&g_stack); return Value_new_ERROR(value, MISSINGCP); } - ++pc.token; + ++g_pc.token; } - if (pass == DECLARE) + if (g_pass == DECLARE) { enum ValueType *t = args ? malloc(args * sizeof(enum ValueType)) : (enum ValueType *)0; @@ -601,30 +601,30 @@ struct Value *stmt_DEFFN_DEFPROC_FUNCTION_SUB(struct Value *value) for (i = 0; i < args; ++i) { - t[i] = Auto_argType(&stack, i); + t[i] = Auto_argType(&g_stack, i); } if (Global_function - (&globals, fn, fn->defaultType, &pc, &statementpc, args, t) == 0) + (&g_globals, fn, fn->defaultType, &g_pc, &statementpc, args, t) == 0) { free(t); - Auto_funcEnd(&stack); - pc = statementpc; + Auto_funcEnd(&g_stack); + g_pc = statementpc; return Value_new_ERROR(value, REDECLARATION); } - Program_addScope(&program, &fn->sym->u.sub.u.def.scope); + Program_addScope(&g_program, &fn->sym->u.sub.u.def.scope); } pushLabel(L_FUNC, &statementpc); - if (pc.token->type == T_EQ) + if (g_pc.token->type == T_EQ) { return stmt_EQ_FNRETURN_FNEND(value); } } else { - pc = (pc.token + 1)->u.identifier->sym->u.sub.u.def.scope.end; + g_pc = (g_pc.token + 1)->u.identifier->sym->u.sub.u.def.scope.end; } return (struct Value *)0; @@ -634,23 +634,23 @@ struct Value *stmt_DEC_INC(struct Value *value) { int step; - step = (pc.token->type == T_DEC ? -1 : 1); - ++pc.token; + step = (g_pc.token->type == T_DEC ? -1 : 1); + ++g_pc.token; while (1) { struct Value *l, stepValue; struct Pc lvaluepc; - lvaluepc = pc; - if (pc.token->type != T_IDENTIFIER) + lvaluepc = g_pc; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGDECINCIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); @@ -671,19 +671,19 @@ struct Value *stmt_DEC_INC(struct Value *value) } else { - pc = lvaluepc; + g_pc = lvaluepc; return Value_new_ERROR(value, TYPEMISMATCH5); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { Value_add(l, &stepValue, 1); } Value_destroy(&stepValue); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -698,7 +698,7 @@ struct Value *stmt_DEFINT_DEFDBL_DEFSTR(struct Value *value) { enum ValueType dsttype = V_NIL; - switch (pc.token->type) + switch (g_pc.token->type) { case T_DEFINT: dsttype = V_INTEGER; @@ -716,17 +716,17 @@ struct Value *stmt_DEFINT_DEFDBL_DEFSTR(struct Value *value) assert(0); } - ++pc.token; + ++g_pc.token; while (1) { struct Identifier *ident; - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGVARIDENT); } - if (pc.token->u.identifier->defaultType != V_REAL) + if (g_pc.token->u.identifier->defaultType != V_REAL) { switch (dsttype) { @@ -744,9 +744,9 @@ struct Value *stmt_DEFINT_DEFDBL_DEFSTR(struct Value *value) } } - ident = pc.token->u.identifier; - ++pc.token; - if (pc.token->type == T_MINUS) + ident = g_pc.token->u.identifier; + ++g_pc.token; + if (g_pc.token->type == T_MINUS) { struct Identifier i; @@ -755,34 +755,34 @@ struct Value *stmt_DEFINT_DEFDBL_DEFSTR(struct Value *value) return Value_new_ERROR(value, BADRANGE); } - ++pc.token; - if (pc.token->type != T_IDENTIFIER) + ++g_pc.token; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGVARIDENT); } - if (strlen(pc.token->u.identifier->name) != 1) + if (strlen(g_pc.token->u.identifier->name) != 1) { return Value_new_ERROR(value, BADRANGE); } for (i.name[0] = tolower(ident->name[0]), i.name[1] = '\0'; - i.name[0] <= tolower(pc.token->u.identifier->name[0]); + i.name[0] <= tolower(g_pc.token->u.identifier->name[0]); ++i.name[0]) { - Global_variable(&globals, &i, dsttype, GLOBALVAR, 1); + Global_variable(&g_globals, &i, dsttype, GLOBALVAR, 1); } - ++pc.token; + ++g_pc.token; } else { - Global_variable(&globals, ident, dsttype, GLOBALVAR, 1); + Global_variable(&g_globals, ident, dsttype, GLOBALVAR, 1); } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -798,39 +798,39 @@ struct Value *stmt_DELETE(struct Value *value) struct Pc from, to; int f = 0, t = 0; - if (pass == INTERPRET && !DIRECTMODE) + if (g_pass == INTERPRET && !DIRECTMODE) { return Value_new_ERROR(value, NOTINPROGRAMMODE); } - ++pc.token; - if (pc.token->type == T_INTEGER) + ++g_pc.token; + if (g_pc.token->type == T_INTEGER) { - if (pass == INTERPRET && - Program_goLine(&program, pc.token->u.integer, + if (g_pass == INTERPRET && + Program_goLine(&g_program, g_pc.token->u.integer, &from) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); } f = 1; - ++pc.token; + ++g_pc.token; } - if (pc.token->type == T_MINUS || pc.token->type == T_COMMA) + if (g_pc.token->type == T_MINUS || g_pc.token->type == T_COMMA) { - ++pc.token; - if (pc.token->type == T_INTEGER) + ++g_pc.token; + if (g_pc.token->type == T_INTEGER) { - if (pass == INTERPRET && - Program_goLine(&program, pc.token->u.integer, + if (g_pass == INTERPRET && + Program_goLine(&g_program, g_pc.token->u.integer, &to) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); } t = 1; - ++pc.token; + ++g_pc.token; } } else if (f == 1) @@ -844,9 +844,9 @@ struct Value *stmt_DELETE(struct Value *value) return Value_new_ERROR(value, MISSINGLINENUMBER); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - Program_delete(&program, f ? &from : (struct Pc *)0, + Program_delete(&g_program, f ? &from : (struct Pc *)0, t ? &to : (struct Pc *)0); } @@ -855,7 +855,7 @@ struct Value *stmt_DELETE(struct Value *value) struct Value *stmt_DIM(struct Value *value) { - ++pc.token; + ++g_pc.token; while (1) { unsigned int capacity = 0, *geometry = (unsigned int *)0; @@ -864,39 +864,39 @@ struct Value *stmt_DIM(struct Value *value) unsigned int dim; enum ValueType vartype; - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGARRIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, GLOBALARRAY, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, GLOBALARRAY, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } - var = &pc.token->u.identifier->sym->u.var; - if (pass == INTERPRET && var->dim) + var = &g_pc.token->u.identifier->sym->u.var; + if (g_pass == INTERPRET && var->dim) { return Value_new_ERROR(value, REDIM); } vartype = var->type; - ++pc.token; - if (pc.token->type != T_OP) + ++g_pc.token; + if (g_pc.token->type != T_OP) { return Value_new_ERROR(value, MISSINGOP); } - ++pc.token; + ++g_pc.token; dim = 0; while (1) { - dimpc = pc; + dimpc = g_pc; if (eval(value, _("dimension"))->type == V_ERROR || - (pass != DECLARE && + (g_pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) { if (capacity) @@ -907,7 +907,7 @@ struct Value *stmt_DIM(struct Value *value) return value; } - if (pass == INTERPRET && value->u.integer < optionbase) /* error */ + if (g_pass == INTERPRET && value->u.integer < optionbase) /* error */ { Value_destroy(value); Value_new_ERROR(value, OUTOFRANGE, _("dimension")); @@ -920,11 +920,11 @@ struct Value *stmt_DIM(struct Value *value) free(geometry); } - pc = dimpc; + g_pc = dimpc; return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (dim == capacity) /* enlarge geometry */ { @@ -942,9 +942,9 @@ struct Value *stmt_DIM(struct Value *value) } Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -952,7 +952,7 @@ struct Value *stmt_DIM(struct Value *value) } } - if (pc.token->type != T_CP) /* abort */ + if (g_pc.token->type != T_CP) /* abort */ { if (capacity) { @@ -962,8 +962,8 @@ struct Value *stmt_DIM(struct Value *value) return Value_new_ERROR(value, MISSINGCP); } - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { struct Var newarray; @@ -980,9 +980,9 @@ struct Value *stmt_DIM(struct Value *value) free(geometry); } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; /* advance to next var */ + ++g_pc.token; /* advance to next var */ } else { @@ -995,21 +995,21 @@ struct Value *stmt_DIM(struct Value *value) struct Value *stmt_DISPLAY(struct Value *value) { - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - ++pc.token; + ++g_pc.token; if (eval(value, _("file name"))->type == V_ERROR || - (pass != DECLARE && Value_retype(value, V_STRING)->type == V_ERROR)) + (g_pass != DECLARE && Value_retype(value, V_STRING)->type == V_ERROR)) { return value; } - if (pass == INTERPRET && cat(value->u.string.character) == -1) + if (g_pass == INTERPRET && cat(value->u.string.character) == -1) { const char *msg = strerror(errno); Value_destroy(value); - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROR, msg); } else @@ -1022,32 +1022,32 @@ struct Value *stmt_DISPLAY(struct Value *value) struct Value *stmt_DO(struct Value *value) { - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - pushLabel(L_DO, &pc); + pushLabel(L_DO, &g_pc); } - ++pc.token; + ++g_pc.token; return (struct Value *)0; } struct Value *stmt_DOcondition(struct Value *value) { - struct Pc dowhilepc = pc; - int negate = (pc.token->type == T_DOUNTIL); + struct Pc dowhilepc = g_pc; + int negate = (g_pc.token->type == T_DOUNTIL); - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - pushLabel(L_DOcondition, &pc); + pushLabel(L_DOcondition, &g_pc); } - ++pc.token; + ++g_pc.token; if (eval(value, "condition")->type == V_ERROR) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { int condition; @@ -1059,7 +1059,7 @@ struct Value *stmt_DOcondition(struct Value *value) if (condition) { - pc = dowhilepc.token->u.exitdo; + g_pc = dowhilepc.token->u.exitdo; } Value_destroy(value); @@ -1072,17 +1072,17 @@ struct Value *stmt_EDIT(struct Value *value) { #ifdef CONFIG_ARCH_HAVE_VFORK long int line; - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; int status; - ++pc.token; - if (pc.token->type == T_INTEGER) + ++g_pc.token; + if (g_pc.token->type == T_INTEGER) { struct Pc where; - if (program.numbered) + if (g_program.numbered) { - if (Program_goLine(&program, pc.token->u.integer, &where) == + if (Program_goLine(&g_program, g_pc.token->u.integer, &where) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); @@ -1092,25 +1092,25 @@ struct Value *stmt_EDIT(struct Value *value) } else { - if (!Program_end(&program, &where)) + if (!Program_end(&g_program, &where)) { return Value_new_ERROR(value, NOPROGRAM); } - line = pc.token->u.integer; + line = g_pc.token->u.integer; if (line < 1 || line > (where.line + 1)) { return Value_new_ERROR(value, NOSUCHLINE); } } - ++pc.token; + ++g_pc.token; } else { line = 1; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { /* variables */ @@ -1157,33 +1157,33 @@ struct Value *stmt_EDIT(struct Value *value) if (!DIRECTMODE) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, NOTINPROGRAMMODE); } if ((name = tmpnam(NULL)) == (char *)0) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROR, _("generating temporary file name failed")); } if ((chn = FS_openout(name)) == -1) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERRORCREATE, name, FS_errmsg); } FS_width(chn, 0); - if (Program_list(&program, chn, 0, (struct Pc *)0, (struct Pc *)0, value)) + if (Program_list(&g_program, chn, 0, (struct Pc *)0, (struct Pc *)0, value)) { - pc = statementpc; + g_pc = statementpc; return value; } if (FS_close(chn) == -1) { - pc = statementpc; + g_pc = statementpc; unlink(name); return Value_new_ERROR(value, IOERRORCLOSE, name, FS_errmsg); } @@ -1246,7 +1246,7 @@ struct Value *stmt_EDIT(struct Value *value) String_destroy(&cmd); if ((chn = FS_openin(name)) == -1) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROROPEN, name, FS_errmsg); } @@ -1255,14 +1255,14 @@ struct Value *stmt_EDIT(struct Value *value) { FS_close(chn); unlink(name); - pc = statementpc; + g_pc = statementpc; return value; } FS_close(chn); - Program_setname(&newProgram, program.name.character); - Program_destroy(&program); - program = newProgram; + Program_setname(&newProgram, g_program.name.character); + Program_destroy(&g_program); + g_program = newProgram; unlink(name); } @@ -1274,16 +1274,16 @@ struct Value *stmt_EDIT(struct Value *value) struct Value *stmt_ELSE_ELSEIFELSE(struct Value *value) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - pc = pc.token->u.endifpc; + g_pc = g_pc.token->u.endifpc; } - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - struct Pc elsepc = pc; + struct Pc elsepc = g_pc; struct Pc *ifinstr; - int elseifelse = (pc.token->type == T_ELSEIFELSE); + int elseifelse = (g_pc.token->type == T_ELSEIFELSE); if ((ifinstr = popLabel(L_IF)) == (struct Pc *)0) { @@ -1292,11 +1292,11 @@ struct Value *stmt_ELSE_ELSEIFELSE(struct Value *value) if (ifinstr->token->type == T_ELSEIFIF) { - (ifinstr->token - 1)->u.elsepc = pc; + (ifinstr->token - 1)->u.elsepc = g_pc; } - ++pc.token; - ifinstr->token->u.elsepc = pc; + ++g_pc.token; + ifinstr->token->u.elsepc = g_pc; assert(ifinstr->token->type == T_ELSEIFIF || ifinstr->token->type == T_IF); if (elseifelse) @@ -1313,27 +1313,27 @@ struct Value *stmt_ELSE_ELSEIFELSE(struct Value *value) struct Value *stmt_END(struct Value *value) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - pc = pc.token->u.endpc; + g_pc = g_pc.token->u.endpc; bas_end = 1; } - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - if (Program_end(&program, &pc.token->u.endpc)) + if (Program_end(&g_program, &g_pc.token->u.endpc)) { - ++pc.token; + ++g_pc.token; } else { struct Token *eol; - for (eol = pc.token; eol->type != T_EOL; ++eol); + for (eol = g_pc.token; eol->type != T_EOL; ++eol); - pc.token->u.endpc = pc; - pc.token->u.endpc.token = eol; - ++pc.token; + g_pc.token->u.endpc = g_pc; + g_pc.token->u.endpc.token = eol; + ++g_pc.token; } } @@ -1342,9 +1342,9 @@ struct Value *stmt_END(struct Value *value) struct Value *stmt_ENDIF(struct Value *value) { - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - struct Pc endifpc = pc; + struct Pc endifpc = g_pc; struct Pc *ifpc; struct Pc *elsepc; @@ -1353,7 +1353,7 @@ struct Value *stmt_ENDIF(struct Value *value) ifpc->token->u.elsepc = endifpc; if (ifpc->token->type == T_ELSEIFIF) { - (ifpc->token - 1)->u.elsepc = pc; + (ifpc->token - 1)->u.elsepc = g_pc; } } else if ((elsepc = popLabel(L_ELSE))) @@ -1366,16 +1366,16 @@ struct Value *stmt_ENDIF(struct Value *value) } } - ++pc.token; + ++g_pc.token; return (struct Value *)0; } struct Value *stmt_ENDFN(struct Value *value) { struct Pc *curfn = (struct Pc *)0; - struct Pc eqpc = pc; + struct Pc eqpc = g_pc; - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { if ((curfn = popLabel(L_FUNC)) == (struct Pc *)0) { @@ -1389,20 +1389,20 @@ struct Value *stmt_ENDFN(struct Value *value) } } - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { return Value_clone(value, - Var_value(Auto_local(&stack, 0), 0, (int *)0, + Var_value(Auto_local(&g_stack, 0), 0, (int *)0, (struct Value *)0)); } else { - if (pass == DECLARE) + if (g_pass == DECLARE) { - Global_endfunction(&globals, (curfn->token + 1)->u.identifier, &pc); + Global_endfunction(&g_globals, (curfn->token + 1)->u.identifier, &g_pc); } - Auto_funcEnd(&stack); + Auto_funcEnd(&g_stack); } return (struct Value *)0; @@ -1412,7 +1412,7 @@ struct Value *stmt_ENDPROC_SUBEND(struct Value *value) { struct Pc *curfn = (struct Pc *)0; - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { if ((curfn = popLabel(L_FUNC)) == (struct Pc *)0 || (curfn->token + 1)->u.identifier->defaultType != V_VOID) @@ -1426,19 +1426,19 @@ struct Value *stmt_ENDPROC_SUBEND(struct Value *value) } } - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { return Value_new_VOID(value); } else { - if (pass == DECLARE) + if (g_pass == DECLARE) { - Global_endfunction(&globals, (curfn->token + 1)->u.identifier, &pc); + Global_endfunction(&g_globals, (curfn->token + 1)->u.identifier, &g_pc); } - Auto_funcEnd(&stack); + Auto_funcEnd(&g_stack); } return (struct Value *)0; @@ -1446,20 +1446,20 @@ struct Value *stmt_ENDPROC_SUBEND(struct Value *value) struct Value *stmt_ENDSELECT(struct Value *value) { - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - ++pc.token; - if (pass == DECLARE || pass == COMPILE) + ++g_pc.token; + if (g_pass == DECLARE || g_pass == COMPILE) { struct Pc *selectcasepc; if ((selectcasepc = popLabel(L_SELECTCASE))) { - selectcasepc->token->u.selectcase->endselect = pc; + selectcasepc->token->u.selectcase->endselect = g_pc; } else { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, STRAYENDSELECT); } } @@ -1469,21 +1469,21 @@ struct Value *stmt_ENDSELECT(struct Value *value) struct Value *stmt_ENVIRON(struct Value *value) { - struct Pc epc = pc; + struct Pc epc = g_pc; - ++pc.token; + ++g_pc.token; if (eval(value, _("environment variable"))->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { return value; } - if (pass == INTERPRET && value->u.string.character) + if (g_pass == INTERPRET && value->u.string.character) { if (putenv(value->u.string.character) == -1) { Value_destroy(value); - pc = epc; + g_pc = epc; return Value_new_ERROR(value, ENVIRONFAILED, strerror(errno)); } } @@ -1496,7 +1496,7 @@ struct Value *stmt_FNEXIT(struct Value *value) { struct Pc *curfn = (struct Pc *)0; - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { if ((curfn = findLabel(L_FUNC)) == (struct Pc *)0 || (curfn->token + 1)->u.identifier->defaultType == V_VOID) @@ -1505,11 +1505,11 @@ struct Value *stmt_FNEXIT(struct Value *value) } } - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { return Value_clone(value, - Var_value(Auto_local(&stack, 0), 0, (int *)0, + Var_value(Auto_local(&g_stack, 0), 0, (int *)0, (struct Value *)0)); } @@ -1523,17 +1523,17 @@ struct Value *stmt_COLON_EOL(struct Value *value) struct Value *stmt_QUOTE_REM(struct Value *value) { - ++pc.token; + ++g_pc.token; return (struct Value *)0; } struct Value *stmt_EQ_FNRETURN_FNEND(struct Value *value) { struct Pc *curfn = (struct Pc *)0; - struct Pc eqpc = pc; - enum TokenType t = pc.token->type; + struct Pc eqpc = g_pc; + enum TokenType t = g_pc.token->type; - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { if (t == T_EQ) { @@ -1576,20 +1576,20 @@ struct Value *stmt_EQ_FNRETURN_FNEND(struct Value *value) } } - ++pc.token; + ++g_pc.token; if (eval(value, _("return"))->type == V_ERROR || Value_retype(value, eqpc.token->u.type)->type == V_ERROR) { - if (pass != INTERPRET) + if (g_pass != INTERPRET) { - Auto_funcEnd(&stack); + Auto_funcEnd(&g_stack); } - pc = eqpc; + g_pc = eqpc; return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { return value; } @@ -1598,13 +1598,13 @@ struct Value *stmt_EQ_FNRETURN_FNEND(struct Value *value) Value_destroy(value); if (t == T_EQ || t == T_FNEND) { - if (pass == DECLARE) + if (g_pass == DECLARE) { - Global_endfunction(&globals, (curfn->token + 1)->u.identifier, - &pc); + Global_endfunction(&g_globals, (curfn->token + 1)->u.identifier, + &g_pc); } - Auto_funcEnd(&stack); + Auto_funcEnd(&g_stack); } } @@ -1613,31 +1613,31 @@ struct Value *stmt_EQ_FNRETURN_FNEND(struct Value *value) struct Value *stmt_ERASE(struct Value *value) { - ++pc.token; + ++g_pc.token; while (1) { - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGARRIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, GLOBALARRAY, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, GLOBALARRAY, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - Var_destroy(&pc.token->u.identifier->sym->u.var); + Var_destroy(&g_pc.token->u.identifier->sym->u.var); } - ++pc.token; - if (pc.token->type == T_COMMA) + ++g_pc.token; + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -1650,13 +1650,13 @@ struct Value *stmt_ERASE(struct Value *value) struct Value *stmt_EXITDO(struct Value *value) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - pc = pc.token->u.exitdo; + g_pc = g_pc.token->u.exitdo; } else { - if (pass == COMPILE) + if (g_pass == COMPILE) { struct Pc *exitdo; @@ -1666,10 +1666,10 @@ struct Value *stmt_EXITDO(struct Value *value) return Value_new_ERROR(value, STRAYEXITDO); } - pc.token->u.exitdo = exitdo->token->u.exitdo; + g_pc.token->u.exitdo = exitdo->token->u.exitdo; } - ++pc.token; + ++g_pc.token; } return (struct Value *)0; @@ -1677,13 +1677,13 @@ struct Value *stmt_EXITDO(struct Value *value) struct Value *stmt_EXITFOR(struct Value *value) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - pc = pc.token->u.exitfor; + g_pc = g_pc.token->u.exitfor; } else { - if (pass == COMPILE) + if (g_pass == COMPILE) { struct Pc *exitfor; @@ -1692,10 +1692,10 @@ struct Value *stmt_EXITFOR(struct Value *value) return Value_new_ERROR(value, STRAYEXITFOR); } - pc.token->u.exitfor = exitfor->token->u.exitfor; + g_pc.token->u.exitfor = exitfor->token->u.exitfor; } - ++pc.token; + ++g_pc.token; } return (struct Value *)0; @@ -1705,10 +1705,10 @@ struct Value *stmt_FIELD(struct Value *value) { long int chn, offset, recLength = -1; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; } if (eval(value, _("channel"))->type == V_ERROR || @@ -1719,17 +1719,17 @@ struct Value *stmt_FIELD(struct Value *value) chn = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && (recLength = FS_recLength(chn)) == -1) + if (g_pass == INTERPRET && (recLength = FS_recLength(chn)) == -1) { return Value_new_ERROR(value, IOERROR, FS_errmsg); } - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGCOMMA); } - ++pc.token; + ++g_pc.token; offset = 0; while (1) { @@ -1737,7 +1737,7 @@ struct Value *stmt_FIELD(struct Value *value) struct Value *l; long int width; - curpc = pc; + curpc = g_pc; if (eval(value, _("field width"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -1746,28 +1746,28 @@ struct Value *stmt_FIELD(struct Value *value) width = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && offset + width > recLength) + if (g_pass == INTERPRET && offset + width > recLength) { - pc = curpc; + g_pc = curpc; return Value_new_ERROR(value, OUTOFRANGE, _("field width")); } - if (pc.token->type != T_AS) + if (g_pc.token->type != T_AS) { return Value_new_ERROR(value, MISSINGAS); } - ++pc.token; - curpc = pc; - if (pc.token->type != T_IDENTIFIER) + ++g_pc.token; + curpc = g_pc; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGVARIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); @@ -1778,21 +1778,21 @@ struct Value *stmt_FIELD(struct Value *value) return value; } - if (pass != DECLARE && l->type != V_STRING) + if (g_pass != DECLARE && l->type != V_STRING) { - pc = curpc; + g_pc = curpc; return Value_new_ERROR(value, TYPEMISMATCH4); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { FS_field(chn, &l->u.string, offset, width); } offset += width; - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -1805,14 +1805,14 @@ struct Value *stmt_FIELD(struct Value *value) struct Value *stmt_FOR(struct Value *value) { - struct Pc forpc = pc; + struct Pc forpc = g_pc; struct Pc varpc; struct Pc limitpc; struct Value limit, stepValue; - ++pc.token; - varpc = pc; - if (pc.token->type != T_IDENTIFIER) + ++g_pc.token; + varpc = g_pc; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGLOOPIDENT); } @@ -1822,9 +1822,9 @@ struct Value *stmt_FOR(struct Value *value) return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - ++pc.token; + ++g_pc.token; if (eval(&limit, (const char *)0)->type == V_ERROR) { *value = limit; @@ -1833,17 +1833,17 @@ struct Value *stmt_FOR(struct Value *value) Value_retype(&limit, value->type); assert(limit.type != V_ERROR); - if (pc.token->type == T_STEP) /* STEP x */ + if (g_pc.token->type == T_STEP) /* STEP x */ { struct Pc stepPc; - ++pc.token; - stepPc = pc; + ++g_pc.token; + stepPc = g_pc; if (eval(&stepValue, "`step'")->type == V_ERROR) { Value_destroy(value); *value = stepValue; - pc = stepPc; + g_pc = stepPc; return value; } @@ -1864,7 +1864,7 @@ struct Value *stmt_FOR(struct Value *value) if (Value_exitFor(value, &limit, &stepValue)) { - pc = forpc.token->u.exitfor; + g_pc = forpc.token->u.exitfor; } Value_destroy(&limit); @@ -1875,15 +1875,15 @@ struct Value *stmt_FOR(struct Value *value) { pushLabel(L_FOR, &forpc); pushLabel(L_FOR_VAR, &varpc); - if (pc.token->type != T_TO) + if (g_pc.token->type != T_TO) { Value_destroy(value); return Value_new_ERROR(value, MISSINGTO); } - ++pc.token; - pushLabel(L_FOR_LIMIT, &pc); - limitpc = pc; + ++g_pc.token; + pushLabel(L_FOR_LIMIT, &g_pc); + limitpc = g_pc; if (eval(&limit, (const char *)0) == (struct Value *)0) { Value_destroy(value); @@ -1897,44 +1897,44 @@ struct Value *stmt_FOR(struct Value *value) return value; } - if (pass != DECLARE) + if (g_pass != DECLARE) { struct Symbol *sym = varpc.token->u.identifier->sym; if (VALUE_RETYPE (&limit, sym->type == GLOBALVAR || - sym->type == GLOBALARRAY ? sym->u.var.type : Auto_varType(&stack, + sym->type == GLOBALARRAY ? sym->u.var.type : Auto_varType(&g_stack, sym))->type == V_ERROR) { Value_destroy(value); *value = limit; - pc = limitpc; + g_pc = limitpc; return value; } } Value_destroy(&limit); - if (pc.token->type == T_STEP) /* STEP x */ + if (g_pc.token->type == T_STEP) /* STEP x */ { struct Pc stepPc; - ++pc.token; - stepPc = pc; + ++g_pc.token; + stepPc = g_pc; if (eval(&stepValue, "`step'")->type == V_ERROR || - (pass != DECLARE && + (g_pass != DECLARE && Value_retype(&stepValue, value->type)->type == V_ERROR)) { Value_destroy(value); *value = stepValue; - pc = stepPc; + g_pc = stepPc; return value; } } else /* implicit numeric STEP */ { VALUE_NEW_INTEGER(&stepValue, 1); - if (pass != DECLARE && + if (g_pass != DECLARE && VALUE_RETYPE(&stepValue, value->type)->type == V_ERROR) { Value_destroy(value); @@ -1944,7 +1944,7 @@ struct Value *stmt_FOR(struct Value *value) } } - pushLabel(L_FOR_BODY, &pc); + pushLabel(L_FOR_BODY, &g_pc); Value_destroy(&stepValue); Value_destroy(value); } @@ -1954,15 +1954,15 @@ struct Value *stmt_FOR(struct Value *value) struct Value *stmt_GET_PUT(struct Value *value) { - struct Pc statementpc = pc; - int put = pc.token->type == T_PUT; + struct Pc statementpc = g_pc; + int put = g_pc.token->type == T_PUT; long int chn; struct Pc errpc; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; } if (eval(value, _("channel"))->type == V_ERROR || @@ -1973,10 +1973,10 @@ struct Value *stmt_GET_PUT(struct Value *value) chn = value->u.integer; Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; - errpc = pc; + ++g_pc.token; + errpc = g_pc; if (eval(value, (const char *)0)) /* process record number/position */ { int rec; @@ -1989,17 +1989,17 @@ struct Value *stmt_GET_PUT(struct Value *value) rec = value->u.integer; Value_destroy(value); - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (rec < 1) { - pc = errpc; + g_pc = errpc; return Value_new_ERROR(value, OUTOFRANGE, _("record number")); } if (FS_seek((int)chn, rec - 1) == -1) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROR, FS_errmsg); } } @@ -2007,11 +2007,11 @@ struct Value *stmt_GET_PUT(struct Value *value) } - if (pc.token->type == T_COMMA) /* BINARY mode get/put */ + if (g_pc.token->type == T_COMMA) /* BINARY mode get/put */ { int res = -1; - ++pc.token; + ++g_pc.token; if (put) { if (eval(value, _("`put'/`get' data"))->type == V_ERROR) @@ -2019,7 +2019,7 @@ struct Value *stmt_GET_PUT(struct Value *value) return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { switch (value->type) { @@ -2046,18 +2046,18 @@ struct Value *stmt_GET_PUT(struct Value *value) { struct Value *l; - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGPROCIDENT); } - if (pass == DECLARE) + if (g_pass == DECLARE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); @@ -2069,7 +2069,7 @@ struct Value *stmt_GET_PUT(struct Value *value) return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { switch (l->type) { @@ -2091,15 +2091,15 @@ struct Value *stmt_GET_PUT(struct Value *value) } } - if (pass == INTERPRET && res == -1) + if (g_pass == INTERPRET && res == -1) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROR, FS_errmsg); } } - else if (pass == INTERPRET && ((put ? FS_put : FS_get) (chn)) == -1) + else if (g_pass == INTERPRET && ((put ? FS_put : FS_get) (chn)) == -1) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROR, FS_errmsg); } @@ -2108,43 +2108,43 @@ struct Value *stmt_GET_PUT(struct Value *value) struct Value *stmt_GOSUB(struct Value *value) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - if (!program.runnable && + if (!g_program.runnable && compileProgram(value, !DIRECTMODE)->type == V_ERROR) { return value; } - pc.token += 2; - Auto_pushGosubRet(&stack, &pc); - pc = (pc.token - 2)->u.gosubpc; - Program_trace(&program, &pc, 0, 1); + g_pc.token += 2; + Auto_pushGosubRet(&g_stack, &g_pc); + g_pc = (g_pc.token - 2)->u.gosubpc; + Program_trace(&g_program, &g_pc, 0, 1); } - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - struct Token *gosubpc = pc.token; + struct Token *gosubpc = g_pc.token; - ++pc.token; - if (pc.token->type != T_INTEGER) + ++g_pc.token; + if (g_pc.token->type != T_INTEGER) { return Value_new_ERROR(value, MISSINGLINENUMBER); } - if (Program_goLine(&program, pc.token->u.integer, &gosubpc->u.gosubpc) == + if (Program_goLine(&g_program, g_pc.token->u.integer, &gosubpc->u.gosubpc) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); } - if (pass == COMPILE && - Program_scopeCheck(&program, &gosubpc->u.gosubpc, findLabel(L_FUNC))) + if (g_pass == COMPILE && + Program_scopeCheck(&g_program, &gosubpc->u.gosubpc, findLabel(L_FUNC))) { return Value_new_ERROR(value, OUTOFSCOPE); } - ++pc.token; + ++g_pc.token; } return (struct Value *)0; @@ -2152,50 +2152,50 @@ struct Value *stmt_GOSUB(struct Value *value) struct Value *stmt_RESUME_GOTO(struct Value *value) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - if (!program.runnable && + if (!g_program.runnable && compileProgram(value, !DIRECTMODE)->type == V_ERROR) { return value; } - if (pc.token->type == T_RESUME) + if (g_pc.token->type == T_RESUME) { - if (!stack.resumeable) + if (!g_stack.resumeable) { return Value_new_ERROR(value, STRAYRESUME); } - stack.resumeable = 0; + g_stack.resumeable = 0; } - pc = pc.token->u.gotopc; - Program_trace(&program, &pc, 0, 1); + g_pc = g_pc.token->u.gotopc; + Program_trace(&g_program, &g_pc, 0, 1); } - else if (pass == DECLARE || pass == COMPILE) + else if (g_pass == DECLARE || g_pass == COMPILE) { - struct Token *gotopc = pc.token; + struct Token *gotopc = g_pc.token; - ++pc.token; - if (pc.token->type != T_INTEGER) + ++g_pc.token; + if (g_pc.token->type != T_INTEGER) { return Value_new_ERROR(value, MISSINGLINENUMBER); } - if (Program_goLine(&program, pc.token->u.integer, &gotopc->u.gotopc) == + if (Program_goLine(&g_program, g_pc.token->u.integer, &gotopc->u.gotopc) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); } - if (pass == COMPILE && - Program_scopeCheck(&program, &gotopc->u.gotopc, findLabel(L_FUNC))) + if (g_pass == COMPILE && + Program_scopeCheck(&g_program, &gotopc->u.gotopc, findLabel(L_FUNC))) { return Value_new_ERROR(value, OUTOFSCOPE); } - ++pc.token; + ++g_pc.token; } return (struct Value *)0; @@ -2203,21 +2203,21 @@ struct Value *stmt_RESUME_GOTO(struct Value *value) struct Value *stmt_KILL(struct Value *value) { - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - ++pc.token; + ++g_pc.token; if (eval(value, _("file name"))->type == V_ERROR || - (pass != DECLARE && Value_retype(value, V_STRING)->type == V_ERROR)) + (g_pass != DECLARE && Value_retype(value, V_STRING)->type == V_ERROR)) { return value; } - if (pass == INTERPRET && unlink(value->u.string.character) == -1) + if (g_pass == INTERPRET && unlink(value->u.string.character) == -1) { const char *msg = strerror(errno); Value_destroy(value); - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROR, msg); } else @@ -2230,8 +2230,8 @@ struct Value *stmt_KILL(struct Value *value) struct Value *stmt_LET(struct Value *value) { - ++pc.token; - if (pc.token->type != T_IDENTIFIER) + ++g_pc.token; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGVARIDENT); } @@ -2241,7 +2241,7 @@ struct Value *stmt_LET(struct Value *value) return value; } - if (pass != INTERPRET) + if (g_pass != INTERPRET) { Value_destroy(value); } @@ -2255,10 +2255,10 @@ struct Value *stmt_LINEINPUT(struct Value *value) struct Pc lpc; struct Value *l; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -2267,66 +2267,66 @@ struct Value *stmt_LINEINPUT(struct Value *value) channel = value->u.integer; Value_destroy(value); - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGCOMMA); } else { - ++pc.token; + ++g_pc.token; } } /* prompt */ - if (pc.token->type == T_STRING) + if (g_pc.token->type == T_STRING) { - if (pass == INTERPRET && channel == 0) + if (g_pass == INTERPRET && channel == 0) { - FS_putString(channel, pc.token->u.string); + FS_putString(channel, g_pc.token->u.string); } - ++pc.token; - if (pc.token->type != T_SEMICOLON && pc.token->type != T_COMMA) + ++g_pc.token; + if (g_pc.token->type != T_SEMICOLON && g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGSEMICOMMA); } - ++pc.token; + ++g_pc.token; } - if (pass == INTERPRET && channel == 0) + if (g_pass == INTERPRET && channel == 0) { FS_flush(channel); } - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGVARIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } - lpc = pc; + lpc = g_pc; if (((l = lvalue(value))->type) == V_ERROR) { return value; } - if (pass == COMPILE && l->type != V_STRING) + if (g_pass == COMPILE && l->type != V_STRING) { - pc = lpc; + g_pc = lpc; return Value_new_ERROR(value, TYPEMISMATCH4); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { String_size(&l->u.string, 0); if (FS_appendToString(channel, &l->u.string, 1) == -1) @@ -2353,33 +2353,33 @@ struct Value *stmt_LIST_LLIST(struct Value *value) struct Pc from, to; int f = 0, t = 0, channel; - channel = (pc.token->type == T_LLIST ? LPCHANNEL : STDCHANNEL); - ++pc.token; - if (pc.token->type == T_INTEGER) + channel = (g_pc.token->type == T_LLIST ? LPCHANNEL : STDCHANNEL); + ++g_pc.token; + if (g_pc.token->type == T_INTEGER) { - if (pass == INTERPRET && - Program_fromLine(&program, pc.token->u.integer, + if (g_pass == INTERPRET && + Program_fromLine(&g_program, g_pc.token->u.integer, &from) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); } f = 1; - ++pc.token; + ++g_pc.token; } - else if (pc.token->type != T_MINUS && pc.token->type != T_COMMA) + else if (g_pc.token->type != T_MINUS && g_pc.token->type != T_COMMA) { if (eval(value, (const char *)0)) { if (value->type == V_ERROR || - (pass != DECLARE && + (g_pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) { return value; } - if (pass == INTERPRET && - Program_fromLine(&program, value->u.integer, + if (g_pass == INTERPRET && + Program_fromLine(&g_program, value->u.integer, &from) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); @@ -2390,20 +2390,20 @@ struct Value *stmt_LIST_LLIST(struct Value *value) } } - if (pc.token->type == T_MINUS || pc.token->type == T_COMMA) + if (g_pc.token->type == T_MINUS || g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; if (eval(value, (const char *)0)) { if (value->type == V_ERROR || - (pass != DECLARE && + (g_pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) { return value; } - if (pass == INTERPRET && - Program_toLine(&program, value->u.integer, &to) == (struct Pc *)0) + if (g_pass == INTERPRET && + Program_toLine(&g_program, value->u.integer, &to) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); } @@ -2418,12 +2418,12 @@ struct Value *stmt_LIST_LLIST(struct Value *value) t = 1; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { /* Some implementations do not require direct mode */ if (Program_list - (&program, channel, channel == STDCHANNEL, f ? &from : (struct Pc *)0, + (&g_program, channel, channel == STDCHANNEL, f ? &from : (struct Pc *)0, t ? &to : (struct Pc *)0, value)) { return value; @@ -2437,43 +2437,43 @@ struct Value *stmt_LOAD(struct Value *value) { struct Pc loadpc; - if (pass == INTERPRET && !DIRECTMODE) + if (g_pass == INTERPRET && !DIRECTMODE) { return Value_new_ERROR(value, NOTINPROGRAMMODE); } - ++pc.token; - loadpc = pc; + ++g_pc.token; + loadpc = g_pc; if (eval(value, _("file name"))->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { - pc = loadpc; + g_pc = loadpc; return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { int dev; new(); - Program_setname(&program, value->u.string.character); + Program_setname(&g_program, value->u.string.character); if ((dev = FS_openin(value->u.string.character)) == -1) { - pc = loadpc; + g_pc = loadpc; Value_destroy(value); return Value_new_ERROR(value, IOERROR, FS_errmsg); } FS_width(dev, 0); Value_destroy(value); - if (Program_merge(&program, dev, value)) + if (Program_merge(&g_program, dev, value)) { - pc = loadpc; + g_pc = loadpc; return value; } FS_close(dev); - program.unsaved = 0; + g_program.unsaved = 0; } else { @@ -2487,27 +2487,27 @@ struct Value *stmt_LOCAL(struct Value *value) { struct Pc *curfn = (struct Pc *)0; - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { if ((curfn = findLabel(L_FUNC)) == (struct Pc *)0) return Value_new_ERROR(value, STRAYLOCAL); } - ++pc.token; + ++g_pc.token; while (1) { - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGVARIDENT); } - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { struct Symbol *fnsym; - if (Auto_variable(&stack, pc.token->u.identifier) == 0) + if (Auto_variable(&g_stack, g_pc.token->u.identifier) == 0) return Value_new_ERROR(value, ALREADYLOCAL); - if (pass == DECLARE) + if (g_pass == DECLARE) { assert(curfn->token->type == T_DEFFN || curfn->token->type == T_DEFPROC || @@ -2520,15 +2520,15 @@ struct Value *stmt_LOCAL(struct Value *value) sizeof(enum ValueType) * (fnsym->u.sub.u.def.localLength + 1)); fnsym->u.sub.u.def.localTypes[fnsym->u.sub.u.def.localLength] = - pc.token->u.identifier->defaultType; + g_pc.token->u.identifier->defaultType; ++fnsym->u.sub.u.def.localLength; } } - ++pc.token; - if (pc.token->type == T_COMMA) + ++g_pc.token; + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -2543,10 +2543,10 @@ struct Value *stmt_LOCATE(struct Value *value) { long int line, column; struct Pc argpc; - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - ++pc.token; - argpc = pc; + ++g_pc.token; + argpc = g_pc; if (eval(value, _("row"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -2555,22 +2555,22 @@ struct Value *stmt_LOCATE(struct Value *value) line = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && line < 1) + if (g_pass == INTERPRET && line < 1) { - pc = argpc; + g_pc = argpc; return Value_new_ERROR(value, OUTOFRANGE, _("row")); } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { return Value_new_ERROR(value, MISSINGCOMMA); } - argpc = pc; + argpc = g_pc; if (eval(value, _("column"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -2579,15 +2579,15 @@ struct Value *stmt_LOCATE(struct Value *value) column = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && column < 1) + if (g_pass == INTERPRET && column < 1) { - pc = argpc; + g_pc = argpc; return Value_new_ERROR(value, OUTOFRANGE, _("column")); } - if (pass == INTERPRET && FS_locate(STDCHANNEL, line, column) == -1) + if (g_pass == INTERPRET && FS_locate(STDCHANNEL, line, column) == -1) { - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROR, FS_errmsg); } @@ -2596,13 +2596,13 @@ struct Value *stmt_LOCATE(struct Value *value) struct Value *stmt_LOCK_UNLOCK(struct Value *value) { - int lock = pc.token->type == T_LOCK; + int lock = g_pc.token->type == T_LOCK; int channel; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; } if (eval(value, _("channel"))->type == V_ERROR || @@ -2613,7 +2613,7 @@ struct Value *stmt_LOCK_UNLOCK(struct Value *value) channel = value->u.integer; Value_destroy(value); - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (FS_lock(channel, 0, 0, lock ? FS_LOCK_EXCLUSIVE : FS_LOCK_NONE, 1) == -1) @@ -2627,16 +2627,16 @@ struct Value *stmt_LOCK_UNLOCK(struct Value *value) struct Value *stmt_LOOP(struct Value *value) { - struct Pc looppc = pc; + struct Pc looppc = g_pc; struct Pc *dopc; - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { - pc = looppc.token->u.dopc; + g_pc = looppc.token->u.dopc; } - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { if ((dopc = popLabel(L_DO)) == (struct Pc *)0 && (dopc = popLabel(L_DOcondition)) == (struct Pc *)0) @@ -2645,7 +2645,7 @@ struct Value *stmt_LOOP(struct Value *value) } looppc.token->u.dopc = *dopc; - dopc->token->u.exitdo = pc; + dopc->token->u.exitdo = g_pc; } return (struct Value *)0; @@ -2653,23 +2653,23 @@ struct Value *stmt_LOOP(struct Value *value) struct Value *stmt_LOOPUNTIL(struct Value *value) { - struct Pc loopuntilpc = pc; + struct Pc loopuntilpc = g_pc; struct Pc *dopc; - ++pc.token; + ++g_pc.token; if (eval(value, _("condition"))->type == V_ERROR) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (Value_isNull(value)) - pc = loopuntilpc.token->u.dopc; + g_pc = loopuntilpc.token->u.dopc; Value_destroy(value); } - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { if ((dopc = popLabel(L_DO)) == (struct Pc *)0) { @@ -2677,7 +2677,7 @@ struct Value *stmt_LOOPUNTIL(struct Value *value) } loopuntilpc.token->u.until = *dopc; - dopc->token->u.exitdo = pc; + dopc->token->u.exitdo = g_pc; } return (struct Value *)0; @@ -2687,49 +2687,49 @@ struct Value *stmt_LSET_RSET(struct Value *value) { struct Value *l; struct Pc tmppc; - int lset = (pc.token->type == T_LSET); + int lset = (g_pc.token->type == T_LSET); - ++pc.token; - if (pass == DECLARE) + ++g_pc.token; + if (g_pass == DECLARE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } } - tmppc = pc; + tmppc = g_pc; if ((l = lvalue(value))->type == V_ERROR) { return value; } - if (pass == COMPILE && l->type != V_STRING) + if (g_pass == COMPILE && l->type != V_STRING) { - pc = tmppc; + g_pc = tmppc; return Value_new_ERROR(value, TYPEMISMATCH4); } - if (pc.token->type != T_EQ) + if (g_pc.token->type != T_EQ) { return Value_new_ERROR(value, MISSINGEQ); } - ++pc.token; - tmppc = pc; + ++g_pc.token; + tmppc = g_pc; if (eval(value, _("rhs"))->type == V_ERROR || - (pass != DECLARE && Value_retype(value, l->type)->type == V_ERROR)) + (g_pass != DECLARE && Value_retype(value, l->type)->type == V_ERROR)) { - pc = tmppc; + g_pc = tmppc; return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { (lset ? String_lset : String_rset) (&l->u.string, &value->u.string); } @@ -2740,9 +2740,9 @@ struct Value *stmt_LSET_RSET(struct Value *value) struct Value *stmt_IDENTIFIER(struct Value *value) { - struct Pc here = pc; + struct Pc here = g_pc; - if (pass == DECLARE) + if (g_pass == DECLARE) { if (func(value)->type == V_ERROR) { @@ -2753,9 +2753,9 @@ struct Value *stmt_IDENTIFIER(struct Value *value) Value_destroy(value); } - if (pc.token->type == T_EQ || pc.token->type == T_COMMA) + if (g_pc.token->type == T_EQ || g_pc.token->type == T_COMMA) { - pc = here; + g_pc = here; if (assign(value)->type == V_ERROR) { return value; @@ -2766,20 +2766,20 @@ struct Value *stmt_IDENTIFIER(struct Value *value) } else { - if (pass == COMPILE) + if (g_pass == COMPILE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_find(&globals, pc.token->u.identifier, - (pc.token + 1)->type == T_OP) == 0) + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_find(&g_globals, g_pc.token->u.identifier, + (g_pc.token + 1)->type == T_OP) == 0) { return Value_new_ERROR(value, UNDECLARED); } } - if (strcasecmp(pc.token->u.identifier->name, "mid$") - && (pc.token->u.identifier->sym->type == USERFUNCTION || - pc.token->u.identifier->sym->type == BUILTINFUNCTION)) + if (strcasecmp(g_pc.token->u.identifier->name, "mid$") + && (g_pc.token->u.identifier->sym->type == USERFUNCTION || + g_pc.token->u.identifier->sym->type == BUILTINFUNCTION)) { func(value); if (Value_retype(value, V_VOID)->type == V_ERROR) @@ -2796,7 +2796,7 @@ struct Value *stmt_IDENTIFIER(struct Value *value) return value; } - if (pass != INTERPRET) + if (g_pass != INTERPRET) { Value_destroy(value); } @@ -2808,26 +2808,26 @@ struct Value *stmt_IDENTIFIER(struct Value *value) struct Value *stmt_IF_ELSEIFIF(struct Value *value) { - struct Pc ifpc = pc; + struct Pc ifpc = g_pc; - ++pc.token; + ++g_pc.token; if (eval(value, _("condition"))->type == V_ERROR) { return value; } - if (pc.token->type != T_THEN) + if (g_pc.token->type != T_THEN) { Value_destroy(value); return Value_new_ERROR(value, MISSINGTHEN); } - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { if (Value_isNull(value)) { - pc = ifpc.token->u.elsepc; + g_pc = ifpc.token->u.elsepc; } Value_destroy(value); @@ -2835,7 +2835,7 @@ struct Value *stmt_IF_ELSEIFIF(struct Value *value) else { Value_destroy(value); - if (pc.token->type == T_EOL) + if (g_pc.token->type == T_EOL) { pushLabel(L_IF, &ifpc); } @@ -2847,15 +2847,15 @@ struct Value *stmt_IF_ELSEIFIF(struct Value *value) } Value_destroy(value); - if (pc.token->type == T_ELSE) + if (g_pc.token->type == T_ELSE) { - struct Pc elsepc = pc; + struct Pc elsepc = g_pc; - ++pc.token; - ifpc.token->u.elsepc = pc; + ++g_pc.token; + ifpc.token->u.elsepc = g_pc; if (ifpc.token->type == T_ELSEIFIF) { - (ifpc.token - 1)->u.elsepc = pc; + (ifpc.token - 1)->u.elsepc = g_pc; } if (statements(value)->type == V_ERROR) @@ -2864,14 +2864,14 @@ struct Value *stmt_IF_ELSEIFIF(struct Value *value) } Value_destroy(value); - elsepc.token->u.endifpc = pc; + elsepc.token->u.endifpc = g_pc; } else { - ifpc.token->u.elsepc = pc; + ifpc.token->u.elsepc = g_pc; if (ifpc.token->type == T_ELSEIFIF) { - (ifpc.token - 1)->u.elsepc = pc; + (ifpc.token - 1)->u.elsepc = g_pc; } } } @@ -2883,13 +2883,13 @@ struct Value *stmt_IF_ELSEIFIF(struct Value *value) struct Value *stmt_IMAGE(struct Value *value) { - ++pc.token; - if (pc.token->type != T_STRING) + ++g_pc.token; + if (g_pc.token->type != T_STRING) { return Value_new_ERROR(value, MISSINGFMT); } - ++pc.token; + ++g_pc.token; return (struct Value *)0; } @@ -2901,10 +2901,10 @@ struct Value *stmt_INPUT(struct Value *value) struct Token *inputdata = (struct Token *)0, *t = (struct Token *)0; struct Pc lvaluepc; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -2913,40 +2913,40 @@ struct Value *stmt_INPUT(struct Value *value) channel = value->u.integer; Value_destroy(value); - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGCOMMA); } else { - ++pc.token; + ++g_pc.token; } } - if (pc.token->type == T_SEMICOLON) + if (g_pc.token->type == T_SEMICOLON) { nl = 0; - ++pc.token; + ++g_pc.token; } /* prompt */ - if (pc.token->type == T_STRING) + if (g_pc.token->type == T_STRING) { - if (pass == INTERPRET && channel == STDCHANNEL) + if (g_pass == INTERPRET && channel == STDCHANNEL) { - FS_putString(STDCHANNEL, pc.token->u.string); + FS_putString(STDCHANNEL, g_pc.token->u.string); } - ++pc.token; - if (pc.token->type == T_COMMA || pc.token->type == T_COLON) + ++g_pc.token; + if (g_pc.token->type == T_COMMA || g_pc.token->type == T_COLON) { - ++pc.token; + ++g_pc.token; extraprompt = 0; } - else if (pc.token->type == T_SEMICOLON) + else if (g_pc.token->type == T_SEMICOLON) { - ++pc.token; + ++g_pc.token; } else { @@ -2954,13 +2954,13 @@ struct Value *stmt_INPUT(struct Value *value) } } - if (pass == INTERPRET && channel == STDCHANNEL && extraprompt) + if (g_pass == INTERPRET && channel == STDCHANNEL && extraprompt) { FS_putChars(STDCHANNEL, "? "); } retry: - if (pass == INTERPRET) /* read input line and tokenise it */ + if (g_pass == INTERPRET) /* read input line and tokenise it */ { struct String s; @@ -2988,27 +2988,27 @@ retry: { struct Value *l; - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGVARIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } - lvaluepc = pc; + lvaluepc = g_pc; if (((l = lvalue(value))->type) == V_ERROR) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (t->type == T_COMMA || t->type == T_EOL) { @@ -3019,7 +3019,7 @@ retry: } else if (convert(value, l, t)) { - pc = lvaluepc; + g_pc = lvaluepc; if (channel == STDCHANNEL) { struct String s; @@ -3044,7 +3044,7 @@ retry: ++t; } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { if (t->type == T_COMMA) { @@ -3056,21 +3056,21 @@ retry: if (channel == STDCHANNEL) { FS_putChars(STDCHANNEL, "?? "); - ++pc.token; + ++g_pc.token; goto retry; } else { - pc = lvaluepc; + g_pc = lvaluepc; return Value_new_ERROR(value, MISSINGINPUTDATA); } } } } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -3078,7 +3078,7 @@ retry: } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (t->type != T_EOL) { @@ -3099,160 +3099,160 @@ struct Value *stmt_MAT(struct Value *value) oppc.line = -1; oppc.token = (struct Token *)0; - ++pc.token; - if (pc.token->type != T_IDENTIFIER) + ++g_pc.token; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGMATIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, GLOBALARRAY, 0) == 0) + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, GLOBALARRAY, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } - var1 = &pc.token->u.identifier->sym->u.var; - ++pc.token; - if (pc.token->type != T_EQ) + var1 = &g_pc.token->u.identifier->sym->u.var; + ++g_pc.token; + if (g_pc.token->type != T_EQ) { return Value_new_ERROR(value, MISSINGEQ); } - ++pc.token; - if (pc.token->type == T_IDENTIFIER) /* a = b [ +|-|* c ] */ + ++g_pc.token; + if (g_pc.token->type == T_IDENTIFIER) /* a = b [ +|-|* c ] */ { - if (pass == COMPILE) + if (g_pass == COMPILE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_find(&globals, pc.token->u.identifier, 1) == 0) + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_find(&g_globals, g_pc.token->u.identifier, 1) == 0) return Value_new_ERROR(value, UNDECLARED); } - var2 = &pc.token->u.identifier->sym->u.var; - if (pass == INTERPRET && + var2 = &g_pc.token->u.identifier->sym->u.var; + if (g_pass == INTERPRET && ((var2->dim != 1 && var2->dim != 2) || var2->base < 0 || var2->base > 1)) { return Value_new_ERROR(value, NOMATRIX, var2->dim, var2->base); } - if (pass == COMPILE && + if (g_pass == COMPILE && Value_commonType[var1->type][var2->type] == V_ERROR) { return Value_new_typeError(value, var2->type, var1->type); } - ++pc.token; - if (pc.token->type == T_PLUS || pc.token->type == T_MINUS || - pc.token->type == T_MULT) + ++g_pc.token; + if (g_pc.token->type == T_PLUS || g_pc.token->type == T_MINUS || + g_pc.token->type == T_MULT) { - oppc = pc; - op = pc.token->type; - ++pc.token; - if (pc.token->type != T_IDENTIFIER) + oppc = g_pc; + op = g_pc.token->type; + ++g_pc.token; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGARRIDENT); } - if (pass == COMPILE) + if (g_pass == COMPILE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_find(&globals, pc.token->u.identifier, 1) == 0) + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_find(&g_globals, g_pc.token->u.identifier, 1) == 0) { return Value_new_ERROR(value, UNDECLARED); } } - var3 = &pc.token->u.identifier->sym->u.var; - if (pass == INTERPRET && + var3 = &g_pc.token->u.identifier->sym->u.var; + if (g_pass == INTERPRET && ((var3->dim != 1 && var3->dim != 2) || var3->base < 0 || var3->base > 1)) { return Value_new_ERROR(value, NOMATRIX, var3->dim, var3->base); } - ++pc.token; + ++g_pc.token; } - if (pass != DECLARE) + if (g_pass != DECLARE) { if (var3 == (struct Var *)0) { - if (Var_mat_assign(var1, var2, value, pass == INTERPRET)) + if (Var_mat_assign(var1, var2, value, g_pass == INTERPRET)) { assert(oppc.line != -1); - pc = oppc; + g_pc = oppc; return value; } } else if (op == T_MULT) { - if (Var_mat_mult(var1, var2, var3, value, pass == INTERPRET)) + if (Var_mat_mult(var1, var2, var3, value, g_pass == INTERPRET)) { assert(oppc.line != -1); - pc = oppc; + g_pc = oppc; return value; } } else if (Var_mat_addsub - (var1, var2, var3, op == T_PLUS, value, pass == INTERPRET)) + (var1, var2, var3, op == T_PLUS, value, g_pass == INTERPRET)) { assert(oppc.line != -1); - pc = oppc; + g_pc = oppc; return value; } } } - else if (pc.token->type == T_OP) + else if (g_pc.token->type == T_OP) { if (var1->type == V_STRING) { return Value_new_ERROR(value, TYPEMISMATCH5); } - ++pc.token; + ++g_pc.token; if (eval(value, _("factor"))->type == V_ERROR) { return value; } - if (pass == COMPILE && + if (g_pass == COMPILE && Value_commonType[var1->type][value->type] == V_ERROR) { return Value_new_typeError(value, var1->type, value->type); } - if (pc.token->type != T_CP) + if (g_pc.token->type != T_CP) { Value_destroy(value); return Value_new_ERROR(value, MISSINGCP); } - ++pc.token; - if (pc.token->type != T_MULT) + ++g_pc.token; + if (g_pc.token->type != T_MULT) { Value_destroy(value); return Value_new_ERROR(value, MISSINGMULT); } - oppc = pc; - ++pc.token; - if (pass == COMPILE) + oppc = g_pc; + ++g_pc.token; + if (g_pass == COMPILE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_find(&globals, pc.token->u.identifier, 1) == 0) + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_find(&g_globals, g_pc.token->u.identifier, 1) == 0) { Value_destroy(value); return Value_new_ERROR(value, UNDECLARED); } } - var2 = &pc.token->u.identifier->sym->u.var; - if (pass == INTERPRET && + var2 = &g_pc.token->u.identifier->sym->u.var; + if (g_pass == INTERPRET && ((var2->dim != 1 && var2->dim != 2) || var2->base < 0 || var2->base > 1)) { @@ -3260,47 +3260,47 @@ struct Value *stmt_MAT(struct Value *value) return Value_new_ERROR(value, NOMATRIX, var2->dim, var2->base); } - if (pass != DECLARE && - Var_mat_scalarMult(var1, value, var2, pass == INTERPRET)) + if (g_pass != DECLARE && + Var_mat_scalarMult(var1, value, var2, g_pass == INTERPRET)) { assert(oppc.line != -1); - pc = oppc; + g_pc = oppc; return value; } Value_destroy(value); - ++pc.token; + ++g_pc.token; } - else if (pc.token->type == T_CON || pc.token->type == T_ZER || - pc.token->type == T_IDN) + else if (g_pc.token->type == T_CON || g_pc.token->type == T_ZER || + g_pc.token->type == T_IDN) { - op = pc.token->type; - if (pass == COMPILE && Value_commonType[var1->type][V_INTEGER] == V_ERROR) + op = g_pc.token->type; + if (g_pass == COMPILE && Value_commonType[var1->type][V_INTEGER] == V_ERROR) { return Value_new_typeError(value, V_INTEGER, var1->type); } - ++pc.token; - if (pc.token->type == T_OP) + ++g_pc.token; + if (g_pc.token->type == T_OP) { unsigned int dim, geometry[2]; enum ValueType vartype = var1->type; - ++pc.token; + ++g_pc.token; if (evalGeometry(value, &dim, geometry)) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { Var_destroy(var1); Var_new(var1, vartype, dim, geometry, optionbase); } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { unsigned int i; int unused = 1 - var1->base; @@ -3394,39 +3394,39 @@ struct Value *stmt_MAT(struct Value *value) } } - else if (pc.token->type == T_TRN || pc.token->type == T_INV) + else if (g_pc.token->type == T_TRN || g_pc.token->type == T_INV) { - op = pc.token->type; - ++pc.token; - if (pc.token->type != T_OP) + op = g_pc.token->type; + ++g_pc.token; + if (g_pc.token->type != T_OP) { return Value_new_ERROR(value, MISSINGOP); } - ++pc.token; - if (pc.token->type != T_IDENTIFIER) + ++g_pc.token; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGMATIDENT); } - if (pass == COMPILE) + if (g_pass == COMPILE) { - if (((pc.token + 1)->type == T_OP || - Auto_find(&stack, pc.token->u.identifier) == 0) && - Global_find(&globals, pc.token->u.identifier, 1) == 0) + if (((g_pc.token + 1)->type == T_OP || + Auto_find(&g_stack, g_pc.token->u.identifier) == 0) && + Global_find(&g_globals, g_pc.token->u.identifier, 1) == 0) { return Value_new_ERROR(value, UNDECLARED); } } - var2 = &pc.token->u.identifier->sym->u.var; - if (pass == COMPILE && + var2 = &g_pc.token->u.identifier->sym->u.var; + if (g_pass == COMPILE && Value_commonType[var1->type][var2->type] == V_ERROR) { return Value_new_typeError(value, var2->type, var1->type); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (var2->dim != 2 || var2->base < 0 || var2->base > 1) { @@ -3440,7 +3440,7 @@ struct Value *stmt_MAT(struct Value *value) break; case T_INV: - if (Var_mat_invert(var1, var2, &stack.lastdet, value)) + if (Var_mat_invert(var1, var2, &g_stack.lastdet, value)) { return value; } @@ -3452,13 +3452,13 @@ struct Value *stmt_MAT(struct Value *value) } } - ++pc.token; - if (pc.token->type != T_CP) + ++g_pc.token; + if (g_pc.token->type != T_CP) { return Value_new_ERROR(value, MISSINGCP); } - ++pc.token; + ++g_pc.token; } else { @@ -3472,10 +3472,10 @@ struct Value *stmt_MATINPUT(struct Value *value) { int channel = STDCHANNEL; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -3484,13 +3484,13 @@ struct Value *stmt_MATINPUT(struct Value *value) channel = value->u.integer; Value_destroy(value); - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGCOMMA); } else { - ++pc.token; + ++g_pc.token; } } @@ -3499,41 +3499,41 @@ struct Value *stmt_MATINPUT(struct Value *value) struct Pc lvaluepc; struct Var *var; - lvaluepc = pc; - if (pc.token->type != T_IDENTIFIER) + lvaluepc = g_pc; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGMATIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, GLOBALARRAY, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, GLOBALARRAY, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } - var = &pc.token->u.identifier->sym->u.var; - ++pc.token; - if (pc.token->type == T_OP) + var = &g_pc.token->u.identifier->sym->u.var; + ++g_pc.token; + if (g_pc.token->type == T_OP) { unsigned int dim, geometry[2]; enum ValueType vartype = var->type; - ++pc.token; + ++g_pc.token; if (evalGeometry(value, &dim, geometry)) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { Var_destroy(var); Var_new(var, vartype, dim, geometry, optionbase); } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { unsigned int i, j; int unused = 1 - var->base; @@ -3592,7 +3592,7 @@ struct Value *stmt_MATINPUT(struct Value *value) else if (convert(value, &(var->value[j * columns + i]), t)) { Token_destroy(inputdata); - pc = lvaluepc; + g_pc = lvaluepc; return value; } else @@ -3618,9 +3618,9 @@ struct Value *stmt_MATINPUT(struct Value *value) } } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -3640,10 +3640,10 @@ struct Value *stmt_MATPRINT(struct Value *value) size_t usingpos = 0; int notfirst = 0; - ++pc.token; - if (chn == STDCHANNEL && pc.token->type == T_CHANNEL) + ++g_pc.token; + if (chn == STDCHANNEL && g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -3652,34 +3652,34 @@ struct Value *stmt_MATPRINT(struct Value *value) chn = value->u.integer; Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } } - if (pc.token->type == T_USING) + if (g_pc.token->type == T_USING) { struct Pc usingpc; - usingpc = pc; + usingpc = g_pc; printusing = 1; - ++pc.token; - if (pc.token->type == T_INTEGER) + ++g_pc.token; + if (g_pc.token->type == T_INTEGER) { - if (pass == COMPILE && - Program_imageLine(&program, pc.token->u.integer, + if (g_pass == COMPILE && + Program_imageLine(&g_program, g_pc.token->u.integer, &usingpc.token->u.image) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHIMAGELINE); } - else if (pass == INTERPRET) + else if (g_pass == INTERPRET) { using = usingpc.token->u.image.token->u.string; } Value_new_STRING(&usingval); - ++pc.token; + ++g_pc.token; } else { @@ -3693,13 +3693,13 @@ struct Value *stmt_MATPRINT(struct Value *value) using = &usingval.u.string; } - if (pc.token->type != T_SEMICOLON) + if (g_pc.token->type != T_SEMICOLON) { Value_destroy(&usingval); return Value_new_ERROR(value, MISSINGSEMICOLON); } - ++pc.token; + ++g_pc.token; } else { @@ -3711,7 +3711,7 @@ struct Value *stmt_MATPRINT(struct Value *value) struct Var *var; int zoned = 1; - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { if (notfirst) { @@ -3722,23 +3722,23 @@ struct Value *stmt_MATPRINT(struct Value *value) return Value_new_ERROR(value, MISSINGMATIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, GLOBALARRAY, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, GLOBALARRAY, 0) == 0) { Value_destroy(&usingval); return Value_new_ERROR(value, REDECLARATION); } - var = &pc.token->u.identifier->sym->u.var; - ++pc.token; - if (pc.token->type == T_SEMICOLON) + var = &g_pc.token->u.identifier->sym->u.var; + ++g_pc.token; + if (g_pc.token->type == T_SEMICOLON) { zoned = 0; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { unsigned int i, j; int unused = 1 - var->base; @@ -3797,9 +3797,9 @@ struct Value *stmt_MATPRINT(struct Value *value) } } - if (pc.token->type == T_COMMA || pc.token->type == T_SEMICOLON) + if (g_pc.token->type == T_COMMA || g_pc.token->type == T_SEMICOLON) { - ++pc.token; + ++g_pc.token; } else { @@ -3810,7 +3810,7 @@ struct Value *stmt_MATPRINT(struct Value *value) } Value_destroy(&usingval); - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (FS_flush(chn) == -1) { @@ -3823,47 +3823,47 @@ struct Value *stmt_MATPRINT(struct Value *value) struct Value *stmt_MATREAD(struct Value *value) { - ++pc.token; + ++g_pc.token; while (1) { struct Pc lvaluepc; struct Var *var; - lvaluepc = pc; - if (pc.token->type != T_IDENTIFIER) + lvaluepc = g_pc; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGMATIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, GLOBALARRAY, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, GLOBALARRAY, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } - var = &pc.token->u.identifier->sym->u.var; - ++pc.token; - if (pc.token->type == T_OP) + var = &g_pc.token->u.identifier->sym->u.var; + ++g_pc.token; + if (g_pc.token->type == T_OP) { unsigned int dim, geometry[2]; enum ValueType vartype = var->type; - ++pc.token; + ++g_pc.token; if (evalGeometry(value, &dim, geometry)) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { Var_destroy(var); Var_new(var, vartype, dim, geometry, optionbase); } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { unsigned int i; int unused = 1 - var->base; @@ -3880,7 +3880,7 @@ struct Value *stmt_MATREAD(struct Value *value) { if (dataread(value, &(var->value[i]))) { - pc = lvaluepc; + g_pc = lvaluepc; return value; } } @@ -3896,7 +3896,7 @@ struct Value *stmt_MATREAD(struct Value *value) if (dataread (value, &(var->value[i * var->geometry[1] + j]))) { - pc = lvaluepc; + g_pc = lvaluepc; return value; } } @@ -3904,9 +3904,9 @@ struct Value *stmt_MATREAD(struct Value *value) } } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -3919,47 +3919,47 @@ struct Value *stmt_MATREAD(struct Value *value) struct Value *stmt_MATREDIM(struct Value *value) { - ++pc.token; + ++g_pc.token; while (1) { struct Var *var; unsigned int dim, geometry[2]; - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGMATIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, GLOBALARRAY, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, GLOBALARRAY, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } - var = &pc.token->u.identifier->sym->u.var; - ++pc.token; - if (pc.token->type != T_OP) + var = &g_pc.token->u.identifier->sym->u.var; + ++g_pc.token; + if (g_pc.token->type != T_OP) { return Value_new_ERROR(value, MISSINGOP); } - ++pc.token; + ++g_pc.token; if (evalGeometry(value, &dim, geometry)) { return value; } - if (pass == INTERPRET && + if (g_pass == INTERPRET && Var_mat_redim(var, dim, geometry, value) != (struct Value *)0) { return value; } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -3976,10 +3976,10 @@ struct Value *stmt_MATWRITE(struct Value *value) int notfirst = 0; int comma = 0; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -3988,9 +3988,9 @@ struct Value *stmt_MATWRITE(struct Value *value) chn = value->u.integer; Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } } @@ -3998,7 +3998,7 @@ struct Value *stmt_MATWRITE(struct Value *value) { struct Var *var; - if (pc.token->type != T_IDENTIFIER) + if (g_pc.token->type != T_IDENTIFIER) { if (notfirst) { @@ -4009,17 +4009,17 @@ struct Value *stmt_MATWRITE(struct Value *value) } notfirst = 1; - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, GLOBALARRAY, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, GLOBALARRAY, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); } - var = &pc.token->u.identifier->sym->u.var; - ++pc.token; - if (pass == INTERPRET) + var = &g_pc.token->u.identifier->sym->u.var; + ++g_pc.token; + if (g_pass == INTERPRET) { unsigned int i, j; int unused = 1 - var->base; @@ -4067,9 +4067,9 @@ struct Value *stmt_MATWRITE(struct Value *value) } } - if (pc.token->type == T_COMMA || pc.token->type == T_SEMICOLON) + if (g_pc.token->type == T_COMMA || g_pc.token->type == T_SEMICOLON) { - ++pc.token; + ++g_pc.token; } else { @@ -4077,7 +4077,7 @@ struct Value *stmt_MATWRITE(struct Value *value) } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (FS_flush(chn) == -1) { @@ -4090,25 +4090,25 @@ struct Value *stmt_MATWRITE(struct Value *value) struct Value *stmt_NAME(struct Value *value) { - struct Pc namepc = pc; + struct Pc namepc = g_pc; struct Value old; int res = -1, reserrno = -1; - ++pc.token; + ++g_pc.token; if (eval(value, _("file name"))->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { return value; } - if (pc.token->type != T_AS) + if (g_pc.token->type != T_AS) { Value_destroy(value); return Value_new_ERROR(value, MISSINGAS); } old = *value; - ++pc.token; + ++g_pc.token; if (eval(value, _("file name"))->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { @@ -4116,7 +4116,7 @@ struct Value *stmt_NAME(struct Value *value) return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { res = rename(old.u.string.character, value->u.string.character); reserrno = errno; @@ -4124,9 +4124,9 @@ struct Value *stmt_NAME(struct Value *value) Value_destroy(&old); Value_destroy(value); - if (pass == INTERPRET && res == -1) + if (g_pass == INTERPRET && res == -1) { - pc = namepc; + g_pc = namepc; return Value_new_ERROR(value, IOERROR, strerror(reserrno)); } @@ -4135,7 +4135,7 @@ struct Value *stmt_NAME(struct Value *value) struct Value *stmt_NEW(struct Value *value) { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (!DIRECTMODE) { @@ -4145,38 +4145,38 @@ struct Value *stmt_NEW(struct Value *value) new(); } - ++pc.token; + ++g_pc.token; return (struct Value *)0; } struct Value *stmt_NEXT(struct Value *value) { - struct Next **next = &pc.token->u.next; + struct Next **next = &g_pc.token->u.next; int level = 0; - if (pass == INTERPRET) + if (g_pass == INTERPRET) { struct Value *l, inc; struct Pc savepc; - ++pc.token; + ++g_pc.token; while (1) { /* get variable lvalue */ - savepc = pc; - pc = (*next)[level].var; + savepc = g_pc; + g_pc = (*next)[level].var; if ((l = lvalue(value))->type == V_ERROR) { return value; } - pc = savepc; + g_pc = savepc; /* get limit value and increment */ - savepc = pc; - pc = (*next)[level].limit; + savepc = g_pc; + g_pc = (*next)[level].limit; if (eval(value, _("limit"))->type == V_ERROR) { return value; @@ -4184,9 +4184,9 @@ struct Value *stmt_NEXT(struct Value *value) Value_retype(value, l->type); assert(value->type != V_ERROR); - if (pc.token->type == T_STEP) + if (g_pc.token->type == T_STEP) { - ++pc.token; + ++g_pc.token; if (eval(&inc, _("step"))->type == V_ERROR) { Value_destroy(value); @@ -4201,23 +4201,23 @@ struct Value *stmt_NEXT(struct Value *value) VALUE_RETYPE(&inc, l->type); assert(inc.type != V_ERROR); - pc = savepc; + g_pc = savepc; Value_add(l, &inc, 1); if (Value_exitFor(l, value, &inc)) { Value_destroy(value); Value_destroy(&inc); - if (pc.token->type == T_IDENTIFIER) + if (g_pc.token->type == T_IDENTIFIER) { if (lvalue(value)->type == V_ERROR) { return value; } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; ++level; } else @@ -4232,7 +4232,7 @@ struct Value *stmt_NEXT(struct Value *value) } else { - pc = (*next)[level].body; + g_pc = (*next)[level].body; Value_destroy(value); Value_destroy(&inc); break; @@ -4243,7 +4243,7 @@ struct Value *stmt_NEXT(struct Value *value) { struct Pc *body; - ++pc.token; + ++g_pc.token; while (1) { if ((body = popLabel(L_FOR_BODY)) == (struct Pc *)0) @@ -4263,19 +4263,19 @@ struct Value *stmt_NEXT(struct Value *value) (*next)[level].limit = *popLabel(L_FOR_LIMIT); (*next)[level].var = *popLabel(L_FOR_VAR); (*next)[level].fr = *popLabel(L_FOR); - if (pc.token->type == T_IDENTIFIER) + if (g_pc.token->type == T_IDENTIFIER) { if (cistrcmp - (pc.token->u.identifier->name, + (g_pc.token->u.identifier->name, (*next)[level].var.token->u.identifier->name)) { return Value_new_ERROR(value, FORMISMATCH); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); @@ -4286,9 +4286,9 @@ struct Value *stmt_NEXT(struct Value *value) return value; } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; ++level; } else @@ -4304,7 +4304,7 @@ struct Value *stmt_NEXT(struct Value *value) while (level >= 0) { - (*next)[level--].fr.token->u.exitfor = pc; + (*next)[level--].fr.token->u.exitfor = g_pc; } } @@ -4313,9 +4313,9 @@ struct Value *stmt_NEXT(struct Value *value) struct Value *stmt_ON(struct Value *value) { - struct On *on = &pc.token->u.on; + struct On *on = &g_pc.token->u.on; - ++pc.token; + ++g_pc.token; if (eval(value, _("selector"))->type == V_ERROR) { return value; @@ -4326,7 +4326,7 @@ struct Value *stmt_ON(struct Value *value) return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { struct Pc newpc; @@ -4339,55 +4339,55 @@ struct Value *stmt_ON(struct Value *value) newpc = on->pc[0]; } - if (pc.token->type == T_GOTO) + if (g_pc.token->type == T_GOTO) { - pc = newpc; + g_pc = newpc; } else { - pc = on->pc[0]; - Auto_pushGosubRet(&stack, &pc); - pc = newpc; + g_pc = on->pc[0]; + Auto_pushGosubRet(&g_stack, &g_pc); + g_pc = newpc; } - Program_trace(&program, &pc, 0, 1); + Program_trace(&g_program, &g_pc, 0, 1); } - else if (pass == DECLARE || pass == COMPILE) + else if (g_pass == DECLARE || g_pass == COMPILE) { Value_destroy(value); - if (pc.token->type != T_GOTO && pc.token->type != T_GOSUB) + if (g_pc.token->type != T_GOTO && g_pc.token->type != T_GOSUB) { return Value_new_ERROR(value, MISSINGGOTOSUB); } - ++pc.token; + ++g_pc.token; on->pcLength = 1; while (1) { on->pc = realloc(on->pc, sizeof(struct Pc) * ++on->pcLength); - if (pc.token->type != T_INTEGER) + if (g_pc.token->type != T_INTEGER) { return Value_new_ERROR(value, MISSINGLINENUMBER); } if (Program_goLine - (&program, pc.token->u.integer, + (&g_program, g_pc.token->u.integer, &on->pc[on->pcLength - 1]) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); } - if (pass == COMPILE && - Program_scopeCheck(&program, &on->pc[on->pcLength - 1], + if (g_pass == COMPILE && + Program_scopeCheck(&g_program, &on->pc[on->pcLength - 1], findLabel(L_FUNC))) { return Value_new_ERROR(value, OUTOFSCOPE); } - ++pc.token; - if (pc.token->type == T_COMMA) + ++g_pc.token; + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -4395,7 +4395,7 @@ struct Value *stmt_ON(struct Value *value) } } - on->pc[0] = pc; + on->pc[0] = g_pc; } return (struct Value *)0; @@ -4408,11 +4408,11 @@ struct Value *stmt_ONERROR(struct Value *value) return Value_new_ERROR(value, NOTINDIRECTMODE); } - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { - stack.onerror = pc; - Program_nextLine(&program, &pc); + g_stack.onerror = g_pc; + Program_nextLine(&g_program, &g_pc); return (struct Value *)0; } else @@ -4428,17 +4428,17 @@ struct Value *stmt_ONERRORGOTO0(struct Value *value) return Value_new_ERROR(value, NOTINDIRECTMODE); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - stack.onerror.line = -1; - if (stack.resumeable) + g_stack.onerror.line = -1; + if (g_stack.resumeable) { - pc = stack.erpc; - return Value_clone(value, &stack.err); + g_pc = g_stack.erpc; + return Value_clone(value, &g_stack.err); } } - ++pc.token; + ++g_pc.token; return (struct Value *)0; } @@ -4449,12 +4449,12 @@ struct Value *stmt_ONERROROFF(struct Value *value) return Value_new_ERROR(value, NOTINDIRECTMODE); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - stack.onerror.line = -1; + g_stack.onerror.line = -1; } - ++pc.token; + ++g_pc.token; return (struct Value *)0; } @@ -4466,17 +4466,17 @@ struct Value *stmt_OPEN(struct Value *value) long int recLength = -1; struct Pc errpc; struct Value recLengthValue; - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - ++pc.token; - errpc = pc; + ++g_pc.token; + errpc = g_pc; if (eval(value, _("mode or file"))->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { return value; } - if (pc.token->type == T_COMMA) /* parse MBASIC syntax */ + if (g_pc.token->type == T_COMMA) /* parse MBASIC syntax */ { if (value->u.string.length >= 1) { @@ -4506,44 +4506,44 @@ struct Value *stmt_OPEN(struct Value *value) } Value_destroy(value); - if (pass == INTERPRET && inout == -1) + if (g_pass == INTERPRET && inout == -1) { - pc = errpc; + g_pc = errpc; return Value_new_ERROR(value, BADMODE); } - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGCOMMA); } - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; } - errpc = pc; + errpc = g_pc; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { - pc = errpc; + g_pc = errpc; return value; } channel = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && channel < 0) + if (g_pass == INTERPRET && channel < 0) { return Value_new_ERROR(value, OUTOFRANGE, _("channel")); } - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGCOMMA); } - ++pc.token; + ++g_pc.token; if (eval(value, _("file name"))->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { @@ -4552,14 +4552,14 @@ struct Value *stmt_OPEN(struct Value *value) if (inout == 3) { - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { Value_destroy(value); return Value_new_ERROR(value, MISSINGCOMMA); } - ++pc.token; - errpc = pc; + ++g_pc.token; + errpc = g_pc; if (eval(&recLengthValue, _("record length"))->type == V_ERROR || Value_retype(&recLengthValue, V_INTEGER)->type == V_ERROR) { @@ -4570,10 +4570,10 @@ struct Value *stmt_OPEN(struct Value *value) recLength = recLengthValue.u.integer; Value_destroy(&recLengthValue); - if (pass == INTERPRET && recLength <= 0) + if (g_pass == INTERPRET && recLength <= 0) { Value_destroy(value); - pc = errpc; + g_pc = errpc; return Value_new_ERROR(value, OUTOFRANGE, _("record length")); } } @@ -4583,37 +4583,37 @@ struct Value *stmt_OPEN(struct Value *value) struct Value channelValue; int newMode; - switch (pc.token->type) + switch (g_pc.token->type) { case T_FOR_INPUT: inout = 0; mode = FS_ACCESS_READ; - ++pc.token; + ++g_pc.token; break; case T_FOR_OUTPUT: inout = 1; mode = FS_ACCESS_WRITE; - ++pc.token; + ++g_pc.token; break; case T_FOR_APPEND: inout = 1; mode = FS_ACCESS_WRITE; append = 1; - ++pc.token; + ++g_pc.token; break; case T_FOR_RANDOM: inout = 3; mode = FS_ACCESS_READWRITE; - ++pc.token; + ++g_pc.token; break; case T_FOR_BINARY: inout = 4; mode = FS_ACCESS_READWRITE; - ++pc.token; + ++g_pc.token; break; default: @@ -4622,7 +4622,7 @@ struct Value *stmt_OPEN(struct Value *value) break; } - switch (pc.token->type) + switch (g_pc.token->type) { case T_ACCESS_READ: newMode = FS_ACCESS_READ; @@ -4648,46 +4648,46 @@ struct Value *stmt_OPEN(struct Value *value) } mode = newMode; - ++pc.token; + ++g_pc.token; } - switch (pc.token->type) + switch (g_pc.token->type) { case T_SHARED: lock = FS_LOCK_NONE; - ++pc.token; + ++g_pc.token; break; case T_LOCK_READ: lock = FS_LOCK_SHARED; - ++pc.token; + ++g_pc.token; break; case T_LOCK_WRITE: lock = FS_LOCK_EXCLUSIVE; - ++pc.token; + ++g_pc.token; break; default:; } - if (pc.token->type != T_AS) + if (g_pc.token->type != T_AS) { Value_destroy(value); return Value_new_ERROR(value, MISSINGAS); } - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; } - errpc = pc; + errpc = g_pc; if (eval(&channelValue, _("channel"))->type == V_ERROR || Value_retype(&channelValue, V_INTEGER)->type == V_ERROR) { - pc = errpc; + g_pc = errpc; Value_destroy(value); *value = channelValue; return value; @@ -4697,23 +4697,23 @@ struct Value *stmt_OPEN(struct Value *value) Value_destroy(&channelValue); if (inout == 3) { - if (pc.token->type == T_IDENTIFIER) + if (g_pc.token->type == T_IDENTIFIER) { - if (cistrcmp(pc.token->u.identifier->name, "len")) + if (cistrcmp(g_pc.token->u.identifier->name, "len")) { Value_destroy(value); return Value_new_ERROR(value, MISSINGLEN); } - ++pc.token; - if (pc.token->type != T_EQ) + ++g_pc.token; + if (g_pc.token->type != T_EQ) { Value_destroy(value); return Value_new_ERROR(value, MISSINGEQ); } - ++pc.token; - errpc = pc; + ++g_pc.token; + errpc = g_pc; if (eval(&recLengthValue, _("record length"))->type == V_ERROR || Value_retype(&recLengthValue, V_INTEGER)->type == V_ERROR) { @@ -4724,10 +4724,10 @@ struct Value *stmt_OPEN(struct Value *value) recLength = recLengthValue.u.integer; Value_destroy(&recLengthValue); - if (pass == INTERPRET && recLength <= 0) + if (g_pass == INTERPRET && recLength <= 0) { Value_destroy(value); - pc = errpc; + g_pc = errpc; return Value_new_ERROR(value, OUTOFRANGE, _("record length")); } } @@ -4739,7 +4739,7 @@ struct Value *stmt_OPEN(struct Value *value) } /* open file with name value */ - if (pass == INTERPRET) + if (g_pass == INTERPRET) { int res = -1; @@ -4764,7 +4764,7 @@ struct Value *stmt_OPEN(struct Value *value) if (res == -1) { - pc = statementpc; + g_pc = statementpc; Value_destroy(value); return Value_new_ERROR(value, IOERROR, FS_errmsg); } @@ -4772,7 +4772,7 @@ struct Value *stmt_OPEN(struct Value *value) { if (lock != FS_LOCK_NONE && FS_lock(channel, 0, 0, lock, 0) == -1) { - pc = statementpc; + g_pc = statementpc; Value_destroy(value); Value_new_ERROR(value, IOERROR, FS_errmsg); FS_close(channel); @@ -4787,14 +4787,14 @@ struct Value *stmt_OPEN(struct Value *value) struct Value *stmt_OPTIONBASE(struct Value *value) { - ++pc.token; + ++g_pc.token; if (eval(value, _("array subscript base"))->type == V_ERROR || - (pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) + (g_pass != DECLARE && Value_retype(value, V_INTEGER)->type == V_ERROR)) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { optionbase = value->u.integer; } @@ -4805,8 +4805,8 @@ struct Value *stmt_OPTIONBASE(struct Value *value) struct Value *stmt_OPTIONRUN(struct Value *value) { - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { FS_xonxoff(STDCHANNEL, 0); } @@ -4816,8 +4816,8 @@ struct Value *stmt_OPTIONRUN(struct Value *value) struct Value *stmt_OPTIONSTOP(struct Value *value) { - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { FS_xonxoff(STDCHANNEL, 1); } @@ -4830,9 +4830,9 @@ struct Value *stmt_OUT_POKE(struct Value *value) int out, address, val; struct Pc lpc; - out = (pc.token->type == T_OUT); - lpc = pc; - ++pc.token; + out = (g_pc.token->type == T_OUT); + lpc = g_pc; + ++g_pc.token; if (eval(value, _("address"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -4841,12 +4841,12 @@ struct Value *stmt_OUT_POKE(struct Value *value) address = value->u.integer; Value_destroy(value); - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGCOMMA); } - ++pc.token; + ++g_pc.token; if (eval(value, _("output value"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -4855,11 +4855,11 @@ struct Value *stmt_OUT_POKE(struct Value *value) val = value->u.integer; Value_destroy(value); - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if ((out ? FS_portOutput : FS_memOutput) (address, val) == -1) { - pc = lpc; + g_pc = lpc; return Value_new_ERROR(value, IOERROR, FS_errmsg); } } @@ -4870,16 +4870,16 @@ struct Value *stmt_OUT_POKE(struct Value *value) struct Value *stmt_PRINT_LPRINT(struct Value *value) { int nl = 1; - int chn = (pc.token->type == T_PRINT ? STDCHANNEL : LPCHANNEL); + int chn = (g_pc.token->type == T_PRINT ? STDCHANNEL : LPCHANNEL); int printusing = 0; struct Value usingval; struct String *using = (struct String *)0; size_t usingpos = 0; - ++pc.token; - if (chn == STDCHANNEL && pc.token->type == T_CHANNEL) + ++g_pc.token; + if (chn == STDCHANNEL && g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -4888,34 +4888,34 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) chn = value->u.integer; Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } } - if (pc.token->type == T_USING) + if (g_pc.token->type == T_USING) { struct Pc usingpc; - usingpc = pc; + usingpc = g_pc; printusing = 1; - ++pc.token; - if (pc.token->type == T_INTEGER) + ++g_pc.token; + if (g_pc.token->type == T_INTEGER) { - if (pass == COMPILE && - Program_imageLine(&program, pc.token->u.integer, + if (g_pass == COMPILE && + Program_imageLine(&g_program, g_pc.token->u.integer, &usingpc.token->u.image) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHIMAGELINE); } - else if (pass == INTERPRET) + else if (g_pass == INTERPRET) { using = usingpc.token->u.image.token->u.string; } Value_new_STRING(&usingval); - ++pc.token; + ++g_pc.token; } else { @@ -4929,13 +4929,13 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) using = &usingval.u.string; } - if (pc.token->type != T_SEMICOLON) + if (g_pc.token->type != T_SEMICOLON) { Value_destroy(&usingval); return Value_new_ERROR(value, MISSINGSEMICOLON); } - ++pc.token; + ++g_pc.token; } else { @@ -4947,7 +4947,7 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) { struct Pc valuepc; - valuepc = pc; + valuepc = g_pc; if (eval(value, (const char *)0)) { if (value->type == V_ERROR) @@ -4956,7 +4956,7 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { struct String s; @@ -4966,7 +4966,7 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) { Value_destroy(&usingval); String_destroy(&s); - pc = valuepc; + g_pc = valuepc; return value; } @@ -4984,18 +4984,18 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) Value_destroy(value); nl = 1; } - else if (pc.token->type == T_TAB || pc.token->type == T_SPC) + else if (g_pc.token->type == T_TAB || g_pc.token->type == T_SPC) { - int tab = pc.token->type == T_TAB; + int tab = g_pc.token->type == T_TAB; - ++pc.token; - if (pc.token->type != T_OP) + ++g_pc.token; + if (g_pc.token->type != T_OP) { Value_destroy(&usingval); return Value_new_ERROR(value, MISSINGOP); } - ++pc.token; + ++g_pc.token; if (eval(value, _("count"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -5003,7 +5003,7 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { int s = value->u.integer; int r = 0; @@ -5026,26 +5026,26 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) } Value_destroy(value); - if (pc.token->type != T_CP) + if (g_pc.token->type != T_CP) { Value_destroy(&usingval); return Value_new_ERROR(value, MISSINGCP); } - ++pc.token; + ++g_pc.token; nl = 1; } - else if (pc.token->type == T_SEMICOLON) + else if (g_pc.token->type == T_SEMICOLON) { - ++pc.token; + ++g_pc.token; nl = 0; } - else if (pc.token->type == T_COMMA) + else if (g_pc.token->type == T_COMMA) { - ++pc.token; - if (pass == INTERPRET && !printusing) + ++g_pc.token; + if (g_pass == INTERPRET && !printusing) { FS_nextcol(chn); } @@ -5058,7 +5058,7 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) break; } - if (pass == INTERPRET && FS_flush(chn) == -1) + if (g_pass == INTERPRET && FS_flush(chn) == -1) { Value_destroy(&usingval); return Value_new_ERROR(value, IOERROR, FS_errmsg); @@ -5066,7 +5066,7 @@ struct Value *stmt_PRINT_LPRINT(struct Value *value) } Value_destroy(&usingval); - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (nl && FS_putChar(chn, '\n') == -1) { @@ -5086,22 +5086,22 @@ struct Value *stmt_RANDOMIZE(struct Value *value) { struct Pc argpc; - ++pc.token; - argpc = pc; + ++g_pc.token; + argpc = g_pc; if (eval(value, (const char *)0)) { Value_retype(value, V_INTEGER); if (value->type == V_ERROR) { - pc = argpc; + g_pc = argpc; Value_destroy(value); return Value_new_ERROR(value, MISSINGEXPR, _("random number generator seed")); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - srand(pc.token->u.integer); + srand(g_pc.token->u.integer); } Value_destroy(value); @@ -5116,22 +5116,22 @@ struct Value *stmt_RANDOMIZE(struct Value *value) struct Value *stmt_READ(struct Value *value) { - ++pc.token; + ++g_pc.token; while (1) { struct Value *l; struct Pc lvaluepc; - lvaluepc = pc; - if (pc.token->type != T_IDENTIFIER) + lvaluepc = g_pc; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGREADIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); @@ -5142,15 +5142,15 @@ struct Value *stmt_READ(struct Value *value) return value; } - if (pass == INTERPRET && dataread(value, l)) + if (g_pass == INTERPRET && dataread(value, l)) { - pc = lvaluepc; + g_pc = lvaluepc; return value; } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -5165,34 +5165,34 @@ struct Value *stmt_COPY_RENAME(struct Value *value) { struct Pc argpc; struct Value from; - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - ++pc.token; - argpc = pc; + ++g_pc.token; + argpc = g_pc; if (eval(&from, _("source file"))->type == V_ERROR || - (pass != DECLARE && Value_retype(&from, V_STRING)->type == V_ERROR)) + (g_pass != DECLARE && Value_retype(&from, V_STRING)->type == V_ERROR)) { - pc = argpc; + g_pc = argpc; *value = from; return value; } - if (pc.token->type != T_TO) + if (g_pc.token->type != T_TO) { Value_destroy(&from); return Value_new_ERROR(value, MISSINGTO); } - ++pc.token; - argpc = pc; + ++g_pc.token; + argpc = g_pc; if (eval(value, _("destination file"))->type == V_ERROR || - (pass != DECLARE && Value_retype(value, V_STRING)->type == V_ERROR)) + (g_pass != DECLARE && Value_retype(value, V_STRING)->type == V_ERROR)) { - pc = argpc; + g_pc = argpc; return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { const char *msg; int res; @@ -5212,7 +5212,7 @@ struct Value *stmt_COPY_RENAME(struct Value *value) { Value_destroy(&from); Value_destroy(value); - pc = statementpc; + g_pc = statementpc; return Value_new_ERROR(value, IOERROR, msg); } } @@ -5226,29 +5226,29 @@ struct Value *stmt_RENUM(struct Value *value) { int first = 10, inc = 10; - ++pc.token; - if (pc.token->type == T_INTEGER) + ++g_pc.token; + if (g_pc.token->type == T_INTEGER) { - first = pc.token->u.integer; - ++pc.token; - if (pc.token->type == T_COMMA) + first = g_pc.token->u.integer; + ++g_pc.token; + if (g_pc.token->type == T_COMMA) { - ++pc.token; - if (pc.token->type != T_INTEGER) + ++g_pc.token; + if (g_pc.token->type != T_INTEGER) return Value_new_ERROR(value, MISSINGINCREMENT); - inc = pc.token->u.integer; - ++pc.token; + inc = g_pc.token->u.integer; + ++g_pc.token; } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (!DIRECTMODE) { return Value_new_ERROR(value, NOTINPROGRAMMODE); } - Program_renum(&program, first, inc); + Program_renum(&g_program, first, inc); } return (struct Value *)0; @@ -5256,39 +5256,39 @@ struct Value *stmt_RENUM(struct Value *value) struct Value *stmt_REPEAT(struct Value *value) { - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - pushLabel(L_REPEAT, &pc); + pushLabel(L_REPEAT, &g_pc); } - ++pc.token; + ++g_pc.token; return (struct Value *)0; } struct Value *stmt_RESTORE(struct Value *value) { - struct Token *restorepc = pc.token; + struct Token *restorepc = g_pc.token; - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - curdata = pc.token->u.restore; + g_curdata = g_pc.token->u.restore; } - ++pc.token; - if (pc.token->type == T_INTEGER) + ++g_pc.token; + if (g_pc.token->type == T_INTEGER) { - if (pass == COMPILE && - Program_dataLine(&program, pc.token->u.integer, + if (g_pass == COMPILE && + Program_dataLine(&g_program, g_pc.token->u.integer, &restorepc->u.restore) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHDATALINE); } - ++pc.token; + ++g_pc.token; } - else if (pass == COMPILE) + else if (g_pass == COMPILE) { - restorepc->u.restore = stack.begindata; + restorepc->u.restore = g_stack.begindata; } return (struct Value *)0; @@ -5296,16 +5296,16 @@ struct Value *stmt_RESTORE(struct Value *value) struct Value *stmt_RETURN(struct Value *value) { - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - ++pc.token; + ++g_pc.token; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - if (Auto_gosubReturn(&stack, &pc)) + if (Auto_gosubReturn(&g_stack, &g_pc)) { - Program_trace(&program, &pc, 0, 1); + Program_trace(&g_program, &g_pc, 0, 1); } else { @@ -5320,41 +5320,41 @@ struct Value *stmt_RUN(struct Value *value) { struct Pc argpc, begin; - stack.resumeable = 0; - ++pc.token; - argpc = pc; - if (pc.token->type == T_INTEGER) + g_stack.resumeable = 0; + ++g_pc.token; + argpc = g_pc; + if (g_pc.token->type == T_INTEGER) { - if (Program_goLine(&program, pc.token->u.integer, &begin) == + if (Program_goLine(&g_program, g_pc.token->u.integer, &begin) == (struct Pc *)0) { return Value_new_ERROR(value, NOSUCHLINE); } - if (pass == COMPILE && - Program_scopeCheck(&program, &begin, findLabel(L_FUNC))) + if (g_pass == COMPILE && + Program_scopeCheck(&g_program, &begin, findLabel(L_FUNC))) { return Value_new_ERROR(value, OUTOFSCOPE); } - ++pc.token; + ++g_pc.token; } else if (eval(value, (const char *)0)) { if (value->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { - pc = argpc; + g_pc = argpc; return value; } - else if (pass == INTERPRET) + else if (g_pass == INTERPRET) { int chn; struct Program newprogram; if ((chn = FS_openin(value->u.string.character)) == -1) { - pc = argpc; + g_pc = argpc; Value_destroy(value); return Value_new_ERROR(value, IOERROR, FS_errmsg); } @@ -5363,16 +5363,16 @@ struct Value *stmt_RUN(struct Value *value) Program_new(&newprogram); if (Program_merge(&newprogram, chn, value)) { - pc = argpc; + g_pc = argpc; Program_destroy(&newprogram); return value; } FS_close(chn); new(); - Program_destroy(&program); - program = newprogram; - if (Program_beginning(&program, &begin) == (struct Pc *)0) + Program_destroy(&g_program); + g_program = newprogram; + if (Program_beginning(&g_program, &begin) == (struct Pc *)0) { return Value_new_ERROR(value, NOPROGRAM); } @@ -5384,24 +5384,24 @@ struct Value *stmt_RUN(struct Value *value) } else { - if (Program_beginning(&program, &begin) == (struct Pc *)0) + if (Program_beginning(&g_program, &begin) == (struct Pc *)0) { return Value_new_ERROR(value, NOPROGRAM); } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (compileProgram(value, 1)->type == V_ERROR) { return value; } - pc = begin; - curdata = stack.begindata; - Global_clear(&globals); + g_pc = begin; + g_curdata = g_stack.begindata; + Global_clear(&g_globals); FS_closefiles(); - Program_trace(&program, &pc, 0, 1); + Program_trace(&g_program, &g_pc, 0, 1); } return (struct Value *)0; @@ -5412,14 +5412,14 @@ struct Value *stmt_SAVE(struct Value *value) struct Pc loadpc; int name; - if (pass == INTERPRET && !DIRECTMODE) + if (g_pass == INTERPRET && !DIRECTMODE) { return Value_new_ERROR(value, NOTINPROGRAMMODE); } - ++pc.token; - loadpc = pc; - if (pc.token->type == T_EOL && program.name.length) + ++g_pc.token; + loadpc = g_pc; + if (g_pc.token->type == T_EOL && g_program.name.length) { name = 0; } @@ -5429,23 +5429,23 @@ struct Value *stmt_SAVE(struct Value *value) if (eval(value, _("file name"))->type == V_ERROR || Value_retype(value, V_STRING)->type == V_ERROR) { - pc = loadpc; + g_pc = loadpc; return value; } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { int chn; if (name) { - Program_setname(&program, value->u.string.character); + Program_setname(&g_program, value->u.string.character); } - if ((chn = FS_openout(program.name.character)) == -1) + if ((chn = FS_openout(g_program.name.character)) == -1) { - pc = loadpc; + g_pc = loadpc; if (name) { Value_destroy(value); @@ -5460,14 +5460,14 @@ struct Value *stmt_SAVE(struct Value *value) Value_destroy(value); } - if (Program_list(&program, chn, 0, (struct Pc *)0, (struct Pc *)0, value)) + if (Program_list(&g_program, chn, 0, (struct Pc *)0, (struct Pc *)0, value)) { - pc = loadpc; + g_pc = loadpc; return value; } FS_close(chn); - program.unsaved = 0; + g_program.unsaved = 0; } else if (name) { @@ -5479,20 +5479,20 @@ struct Value *stmt_SAVE(struct Value *value) struct Value *stmt_SELECTCASE(struct Value *value) { - struct Pc statementpc = pc; + struct Pc statementpc = g_pc; - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - pushLabel(L_SELECTCASE, &pc); + pushLabel(L_SELECTCASE, &g_pc); } - ++pc.token; + ++g_pc.token; if (eval(value, _("selector"))->type == V_ERROR) { return value; } - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { statementpc.token->u.selectcase->type = value->type; statementpc.token->u.selectcase->nextcasevalue.line = -1; @@ -5502,10 +5502,10 @@ struct Value *stmt_SELECTCASE(struct Value *value) struct Pc casevaluepc; int match = 0; - pc = casevaluepc = statementpc.token->u.selectcase->nextcasevalue; + g_pc = casevaluepc = statementpc.token->u.selectcase->nextcasevalue; do { - ++pc.token; + ++g_pc.token; switch (casevaluepc.token->type) { case T_CASEVALUE: @@ -5514,13 +5514,13 @@ struct Value *stmt_SELECTCASE(struct Value *value) { struct Value casevalue1; - if (pc.token->type == T_IS) + if (g_pc.token->type == T_IS) { enum TokenType relop; - ++pc.token; - relop = pc.token->type; - ++pc.token; + ++g_pc.token; + relop = g_pc.token->type; + ++g_pc.token; if (eval(&casevalue1, "`is'")->type == V_ERROR) { Value_destroy(value); @@ -5583,11 +5583,11 @@ struct Value *stmt_SELECTCASE(struct Value *value) Value_retype(&casevalue1, statementpc.token->u.selectcase->type); assert(casevalue1.type != V_ERROR); - if (pc.token->type == T_TO) /* match range */ + if (g_pc.token->type == T_TO) /* match range */ { struct Value casevalue2; - ++pc.token; + ++g_pc.token; if (eval(&casevalue2, "`case'")->type == V_ERROR) { Value_destroy(&casevalue1); @@ -5633,9 +5633,9 @@ struct Value *stmt_SELECTCASE(struct Value *value) Value_destroy(&casevalue1); } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { @@ -5661,12 +5661,12 @@ struct Value *stmt_SELECTCASE(struct Value *value) { if (casevaluepc.token->u.casevalue->nextcasevalue.line != -1) { - pc = casevaluepc = + g_pc = casevaluepc = casevaluepc.token->u.casevalue->nextcasevalue; } else { - pc = statementpc.token->u.selectcase->endselect; + g_pc = statementpc.token->u.selectcase->endselect; break; } } @@ -5684,7 +5684,7 @@ struct Value *stmt_SHELL(struct Value *value) pid_t pid; int status; - ++pc.token; + ++g_pc.token; if (eval(value, (const char *)0)) { if (value->type == V_ERROR || @@ -5693,9 +5693,9 @@ struct Value *stmt_SHELL(struct Value *value) return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - if (run_restricted) + if (g_run_restricted) { Value_destroy(value); return Value_new_ERROR(value, RESTRICTED, strerror(errno)); @@ -5733,9 +5733,9 @@ struct Value *stmt_SHELL(struct Value *value) } else { - if (pass == INTERPRET) + if (g_pass == INTERPRET) { - if (run_restricted) + if (g_run_restricted) { return Value_new_ERROR(value, RESTRICTED, strerror(errno)); } @@ -5787,7 +5787,7 @@ struct Value *stmt_SLEEP(struct Value *value) { double s; - ++pc.token; + ++g_pc.token; if (eval(value, _("pause"))->type == V_ERROR || Value_retype(value, V_REAL)->type == V_ERROR) { @@ -5796,7 +5796,7 @@ struct Value *stmt_SLEEP(struct Value *value) s = value->u.real; Value_destroy(value); - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (s < 0.0) { @@ -5811,9 +5811,9 @@ struct Value *stmt_SLEEP(struct Value *value) struct Value *stmt_STOP(struct Value *value) { - if (pass != INTERPRET) + if (g_pass != INTERPRET) { - ++pc.token; + ++g_pc.token; } return (struct Value *)0; @@ -5823,7 +5823,7 @@ struct Value *stmt_SUBEXIT(struct Value *value) { struct Pc *curfn = (struct Pc *)0; - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { if ((curfn = findLabel(L_FUNC)) == (struct Pc *)0 || (curfn->token + 1)->u.identifier->defaultType != V_VOID) @@ -5832,8 +5832,8 @@ struct Value *stmt_SUBEXIT(struct Value *value) } } - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { return Value_new_VOID(value); } @@ -5846,17 +5846,17 @@ struct Value *stmt_SWAP(struct Value *value) struct Value *l1, *l2; struct Pc lvaluepc; - ++pc.token; - lvaluepc = pc; - if (pc.token->type != T_IDENTIFIER) + ++g_pc.token; + lvaluepc = g_pc; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGSWAPIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); @@ -5867,25 +5867,25 @@ struct Value *stmt_SWAP(struct Value *value) return value; } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } else { return Value_new_ERROR(value, MISSINGCOMMA); } - lvaluepc = pc; - if (pc.token->type != T_IDENTIFIER) + lvaluepc = g_pc; + if (g_pc.token->type != T_IDENTIFIER) { return Value_new_ERROR(value, MISSINGSWAPIDENT); } - if (pass == DECLARE && - Global_variable(&globals, pc.token->u.identifier, - pc.token->u.identifier->defaultType, - (pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, + if (g_pass == DECLARE && + Global_variable(&g_globals, g_pc.token->u.identifier, + g_pc.token->u.identifier->defaultType, + (g_pc.token + 1)->type == T_OP ? GLOBALARRAY : GLOBALVAR, 0) == 0) { return Value_new_ERROR(value, REDECLARATION); @@ -5898,11 +5898,11 @@ struct Value *stmt_SWAP(struct Value *value) if (l1->type != l2->type) { - pc = lvaluepc; + g_pc = lvaluepc; return Value_new_typeError(value, l2->type, l1->type); } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { struct Value foo; @@ -5916,10 +5916,10 @@ struct Value *stmt_SWAP(struct Value *value) struct Value *stmt_SYSTEM(struct Value *value) { - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { - if (program.unsaved) + if (g_program.unsaved) { int ch; @@ -5949,15 +5949,15 @@ struct Value *stmt_SYSTEM(struct Value *value) struct Value *stmt_TROFF(struct Value *value) { - ++pc.token; - program.trace = 0; + ++g_pc.token; + g_program.trace = 0; return (struct Value *)0; } struct Value *stmt_TRON(struct Value *value) { - ++pc.token; - program.trace = 1; + ++g_pc.token; + g_program.trace = 1; return (struct Value *)0; } @@ -5966,11 +5966,11 @@ struct Value *stmt_TRUNCATE(struct Value *value) struct Pc chnpc; int chn; - chnpc = pc; - ++pc.token; - if (pc.token->type == T_CHANNEL) + chnpc = g_pc; + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; } if (eval(value, (const char *)0) == (struct Value *)0) @@ -5985,9 +5985,9 @@ struct Value *stmt_TRUNCATE(struct Value *value) chn = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && FS_truncate(chn) == -1) + if (g_pass == INTERPRET && FS_truncate(chn) == -1) { - pc = chnpc; + g_pc = chnpc; return Value_new_ERROR(value, IOERROR, FS_errmsg); } @@ -5996,15 +5996,15 @@ struct Value *stmt_TRUNCATE(struct Value *value) struct Value *stmt_UNNUM(struct Value *value) { - ++pc.token; - if (pass == INTERPRET) + ++g_pc.token; + if (g_pass == INTERPRET) { if (!DIRECTMODE) { return Value_new_ERROR(value, NOTINPROGRAMMODE); } - Program_unnum(&program); + Program_unnum(&g_program); } return (struct Value *)0; @@ -6012,26 +6012,26 @@ struct Value *stmt_UNNUM(struct Value *value) struct Value *stmt_UNTIL(struct Value *value) { - struct Pc untilpc = pc; + struct Pc untilpc = g_pc; struct Pc *repeatpc; - ++pc.token; + ++g_pc.token; if (eval(value, _("condition"))->type == V_ERROR) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (Value_isNull(value)) { - pc = untilpc.token->u.until; + g_pc = untilpc.token->u.until; } Value_destroy(value); } - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { if ((repeatpc = popLabel(L_REPEAT)) == (struct Pc *)0) { @@ -6049,8 +6049,8 @@ struct Value *stmt_WAIT(struct Value *value) int address, mask, sel = -1, usesel; struct Pc lpc; - lpc = pc; - ++pc.token; + lpc = g_pc; + ++g_pc.token; if (eval(value, _("address"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -6059,12 +6059,12 @@ struct Value *stmt_WAIT(struct Value *value) address = value->u.integer; Value_destroy(value); - if (pc.token->type != T_COMMA) + if (g_pc.token->type != T_COMMA) { return Value_new_ERROR(value, MISSINGCOMMA); } - ++pc.token; + ++g_pc.token; if (eval(value, _("mask"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -6073,9 +6073,9 @@ struct Value *stmt_WAIT(struct Value *value) mask = value->u.integer; Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; if (eval(value, _("select"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -6091,7 +6091,7 @@ struct Value *stmt_WAIT(struct Value *value) usesel = 0; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { int v; @@ -6099,7 +6099,7 @@ struct Value *stmt_WAIT(struct Value *value) { if ((v = FS_portInput(address)) == -1) { - pc = lpc; + g_pc = lpc; return Value_new_ERROR(value, IOERROR, FS_errmsg); } } @@ -6110,24 +6110,24 @@ struct Value *stmt_WAIT(struct Value *value) struct Value *stmt_WHILE(struct Value *value) { - struct Pc whilepc = pc; + struct Pc whilepc = g_pc; - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { - pushLabel(L_WHILE, &pc); + pushLabel(L_WHILE, &g_pc); } - ++pc.token; + ++g_pc.token; if (eval(value, _("condition"))->type == V_ERROR) { return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { if (Value_isNull(value)) { - pc = *whilepc.token->u.afterwend; + g_pc = *whilepc.token->u.afterwend; } Value_destroy(value); @@ -6138,7 +6138,7 @@ struct Value *stmt_WHILE(struct Value *value) struct Value *stmt_WEND(struct Value *value) { - if (pass == DECLARE || pass == COMPILE) + if (g_pass == DECLARE || g_pass == COMPILE) { struct Pc *whilepc; @@ -6147,13 +6147,13 @@ struct Value *stmt_WEND(struct Value *value) return Value_new_ERROR(value, STRAYWEND, topLabelDescription()); } - *pc.token->u.whilepc = *whilepc; - ++pc.token; - *(whilepc->token->u.afterwend) = pc; + *g_pc.token->u.whilepc = *whilepc; + ++g_pc.token; + *(whilepc->token->u.afterwend) = g_pc; } else { - pc = *pc.token->u.whilepc; + g_pc = *g_pc.token->u.whilepc; } return (struct Value *)0; @@ -6163,10 +6163,10 @@ struct Value *stmt_WIDTH(struct Value *value) { int chn = STDCHANNEL, width; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -6175,9 +6175,9 @@ struct Value *stmt_WIDTH(struct Value *value) chn = value->u.integer; Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } } @@ -6191,15 +6191,15 @@ struct Value *stmt_WIDTH(struct Value *value) width = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && FS_width(chn, width) == -1) + if (g_pass == INTERPRET && FS_width(chn, width) == -1) { return Value_new_ERROR(value, IOERROR, FS_errmsg); } } - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; if (eval(value, _("zone width"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -6208,7 +6208,7 @@ struct Value *stmt_WIDTH(struct Value *value) width = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && FS_zone(chn, width) == -1) + if (g_pass == INTERPRET && FS_zone(chn, width) == -1) { return Value_new_ERROR(value, IOERROR, FS_errmsg); } @@ -6222,10 +6222,10 @@ struct Value *stmt_WRITE(struct Value *value) int chn = STDCHANNEL; int comma = 0; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -6234,9 +6234,9 @@ struct Value *stmt_WRITE(struct Value *value) chn = value->u.integer; Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } } @@ -6249,7 +6249,7 @@ struct Value *stmt_WRITE(struct Value *value) return value; } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { struct String s; @@ -6276,9 +6276,9 @@ struct Value *stmt_WRITE(struct Value *value) Value_destroy(value); comma = 1; } - else if (pc.token->type == T_COMMA || pc.token->type == T_SEMICOLON) + else if (g_pc.token->type == T_COMMA || g_pc.token->type == T_SEMICOLON) { - ++pc.token; + ++g_pc.token; } else { @@ -6286,7 +6286,7 @@ struct Value *stmt_WRITE(struct Value *value) } } - if (pass == INTERPRET) + if (g_pass == INTERPRET) { FS_putChar(chn, '\n'); if (FS_flush(chn) == -1) @@ -6300,16 +6300,16 @@ struct Value *stmt_WRITE(struct Value *value) struct Value *stmt_XREF(struct Value *value) { - stack.resumeable = 0; - ++pc.token; - if (pass == INTERPRET) + g_stack.resumeable = 0; + ++g_pc.token; + if (g_pass == INTERPRET) { - if (!program.runnable && compileProgram(value, 1)->type == V_ERROR) + if (!g_program.runnable && compileProgram(value, 1)->type == V_ERROR) { return value; } - Program_xref(&program, STDCHANNEL); + Program_xref(&g_program, STDCHANNEL); } return (struct Value *)0; @@ -6319,10 +6319,10 @@ struct Value *stmt_ZONE(struct Value *value) { int chn = STDCHANNEL, width; - ++pc.token; - if (pc.token->type == T_CHANNEL) + ++g_pc.token; + if (g_pc.token->type == T_CHANNEL) { - ++pc.token; + ++g_pc.token; if (eval(value, _("channel"))->type == V_ERROR || Value_retype(value, V_INTEGER)->type == V_ERROR) { @@ -6331,9 +6331,9 @@ struct Value *stmt_ZONE(struct Value *value) chn = value->u.integer; Value_destroy(value); - if (pc.token->type == T_COMMA) + if (g_pc.token->type == T_COMMA) { - ++pc.token; + ++g_pc.token; } } @@ -6345,7 +6345,7 @@ struct Value *stmt_ZONE(struct Value *value) width = value->u.integer; Value_destroy(value); - if (pass == INTERPRET && FS_zone(chn, width) == -1) + if (g_pass == INTERPRET && FS_zone(chn, width) == -1) { return Value_new_ERROR(value, IOERROR, FS_errmsg); } |