From 5fa30c7a2271cc0d487fb1ebd91924eb3ee992a6 Mon Sep 17 00:00:00 2001 From: Etienne Brateau <etienne.brateau@ensiie.fr> Date: Sun, 8 Jul 2018 16:00:03 +0200 Subject: [PATCH] numex : clean code --- psys/include/p2c/numex.h | 15 - psys/src/numex.c | 6421 ++++++++++++++++++-------------------- 2 files changed, 3078 insertions(+), 3358 deletions(-) diff --git a/psys/include/p2c/numex.h b/psys/include/p2c/numex.h index 87b0cac..b9cc0ce 100644 --- a/psys/include/p2c/numex.h +++ b/psys/include/p2c/numex.h @@ -34,8 +34,6 @@ typedef enum { ne_lnot, ne_ior, ne_ror, ne_sor, ne_iand, ne_rand, ne_sand, ne_icond, ne_rcond, ne_scond, ne_round, ne_trunc, ne_ln, ne_exp, ne_iabs, ne_rabs, ne_sqrt, ne_sin, ne_cos, ne_tan, ne_arctan, ne_rxp, ne_rxor -/* p2c: numex.text, line 131: - * Note: Line breaker spent 3.0 seconds, 5000 tries on line 45 [251] */ } ne_opkind; @@ -57,8 +55,6 @@ typedef struct ne_functionrec { _PROCEDURE ipr; unsigned arg1 : 3, arg2 : 3, arg3 : 3, arg4 : 3; } U5; -/* p2c: numex.text, line 78: Note: - * Field width for ARG1 assumes enum ne_datatype has 5 elements [105] */ _PROCEDURE rpr; _PROCEDURE spr; struct { @@ -76,12 +72,8 @@ typedef struct ne_nexrec { uchar nargs; unsigned op : 7; union { -/* p2c: numex.text, line 94: - * Note: Field width for OP assumes enum ne_opkind has 76 elements [105] */ na_quadword qw; unsigned err : 4; -/* p2c: numex.text, line 98: Note: - * Field width for ERR assumes enum ne_errorkind has 9 elements [105] */ long i; double r; char *s; @@ -104,7 +96,6 @@ typedef struct ne_nexrec { } U15; struct { struct ne_nexrec **ep; - /*!*/ na_strlist_t *eps; } U16; struct { @@ -119,8 +110,6 @@ typedef struct ne_desc { na_strlist_t *symtab; unsigned casesens : 1, builtin : 1, scaled : 1, doubleeq : 1, isfunc : 1, dummy0 : 7, error : 4; -/* p2c: numex.text, line 123: Note: - * Field width for ERROR assumes enum ne_errorkind has 9 elements [105] */ char units[6]; long startident[9], ident[9]; /*must not contain #0*/ _PROCEDURE symproc; @@ -152,10 +141,6 @@ vextern na_quadword *ne_argarray; extern void ne_init (ne_desc *desc); extern void ne_compile (char *ex, ne_nexrec **nex, ne_desc *desc); -/* - procedure ne_intcompile(anyvar ex : na_chararray; var endp : integer; - var nex : ne_nexptr; var desc : ne_desc); -*/ extern void ne_intcompile (char *ex, long *endp, ne_nexrec **nex, ne_desc *desc); extern void ne_dump (ne_nexrec *nex); diff --git a/psys/src/numex.c b/psys/src/numex.c index 4f9be9d..aa8fd49 100644 --- a/psys/src/numex.c +++ b/psys/src/numex.c @@ -1,12 +1,3 @@ -/* Output from p2c, the Pascal-to-C translator */ -/* From input file "numex.text" */ - - -/* $debug$ {*/ - - - - #include <p2c/p2c.h> @@ -19,29 +10,31 @@ typedef ne_datatype typetab[76]; -static const typetab types = { - ne_notype, ne_integer, ne_real, ne_string, ne_integer, ne_real, ne_string, - ne_integer, ne_real, ne_string, ne_integer, ne_real, ne_string, ne_integer, - ne_integer, ne_integer, ne_integer, ne_integer, ne_real, ne_real, ne_real, - ne_real, ne_real, ne_real, ne_string, ne_real, ne_integer, ne_integer, - ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, - ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, - ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, - ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, - ne_integer, ne_integer, ne_integer, ne_real, ne_string, ne_integer, ne_real, - ne_string, ne_integer, ne_real, ne_string, ne_integer, ne_integer, ne_real, - ne_real, ne_integer, ne_real, ne_real, ne_real, ne_real, ne_real, ne_real, - ne_real, ne_real +static const typetab types = +{ + ne_notype, ne_integer, ne_real, ne_string, ne_integer, ne_real, ne_string, + ne_integer, ne_real, ne_string, ne_integer, ne_real, ne_string, ne_integer, + ne_integer, ne_integer, ne_integer, ne_integer, ne_real, ne_real, ne_real, + ne_real, ne_real, ne_real, ne_string, ne_real, ne_integer, ne_integer, + ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, + ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, + ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, + ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, ne_integer, + ne_integer, ne_integer, ne_integer, ne_real, ne_string, ne_integer, ne_real, + ne_string, ne_integer, ne_real, ne_string, ne_integer, ne_integer, ne_real, + ne_real, ne_integer, ne_real, ne_real, ne_real, ne_real, ne_real, ne_real, + ne_real, ne_real }; #define numbuiltins 11 -typedef struct builtinrec { - char name[9]; - char kind; - ne_opkind op; +typedef struct builtinrec +{ + char name[9]; + char kind; + ne_opkind op; } builtinrec; typedef builtinrec builtintab[numbuiltins]; @@ -52,40 +45,40 @@ static builtintab builtins; #define numopersyms 22 -typedef struct opersymrec { +typedef struct opersymrec +{ char name; uchar lprec, rprec; unsigned iop : 7, rop : 7, sop : 7; -/* p2c: numex.text, line 302: - * Note: Field width for IOP assumes enum ne_opkind has 76 elements [105] */ } opersymrec; typedef opersymrec opersymtab[numopersyms]; -static const opersymtab opers = { - { '?', 30, 29, ne_icond, ne_rcond, ne_scond }, - { '\b', 40, 40, ne_error, ne_rxor, ne_error }, - { '\005', 40, 40, ne_ior, ne_ror, ne_sor }, - { '\004', 50, 50, ne_iand, ne_rand, ne_sand }, - { '|', 60, 60, ne_or, ne_error, ne_error }, - { '@', 70, 70, ne_xor, ne_error, ne_error }, - { '&', 80, 80, ne_and, ne_error, ne_error }, - { '=', 90, 90, ne_ieq, ne_req, ne_seq }, - { '\001', 90, 90, ne_ine, ne_rne, ne_sne }, - { '<', 100, 100, ne_ilt, ne_rlt, ne_slt }, - { '>', 100, 100, ne_igt, ne_rgt, ne_sgt }, - { '\002', 100, 100, ne_ile, ne_rle, ne_sle }, - { '\003', 100, 100, ne_ige, ne_rge, ne_sge }, - { '\006', 110, 110, ne_lsh, ne_error, ne_error }, - { '\007', 110, 110, ne_rsh, ne_error, ne_error }, - { '+', 120, 120, ne_iadd, ne_radd, ne_sadd }, - { '-', 120, 120, ne_isub, ne_rsub, ne_error }, - { '*', 130, 130, ne_imul, ne_rmul, ne_error }, - { '/', 130, 130, ne_error, ne_rdiv, ne_error }, - { '\\', 130, 130, ne_idiv, ne_error, ne_error }, - { '%', 130, 130, ne_imod, ne_error, ne_error }, - { '^', 135, 134, ne_error, ne_rpow, ne_error } +static const opersymtab opers = +{ + { '?', 30, 29, ne_icond, ne_rcond, ne_scond }, + { '\b', 40, 40, ne_error, ne_rxor, ne_error }, + { '\005', 40, 40, ne_ior, ne_ror, ne_sor }, + { '\004', 50, 50, ne_iand, ne_rand, ne_sand }, + { '|', 60, 60, ne_or, ne_error, ne_error }, + { '@', 70, 70, ne_xor, ne_error, ne_error }, + { '&', 80, 80, ne_and, ne_error, ne_error }, + { '=', 90, 90, ne_ieq, ne_req, ne_seq }, + { '\001', 90, 90, ne_ine, ne_rne, ne_sne }, + { '<', 100, 100, ne_ilt, ne_rlt, ne_slt }, + { '>', 100, 100, ne_igt, ne_rgt, ne_sgt }, + { '\002', 100, 100, ne_ile, ne_rle, ne_sle }, + { '\003', 100, 100, ne_ige, ne_rge, ne_sge }, + { '\006', 110, 110, ne_lsh, ne_error, ne_error }, + { '\007', 110, 110, ne_rsh, ne_error, ne_error }, + { '+', 120, 120, ne_iadd, ne_radd, ne_sadd }, + { '-', 120, 120, ne_isub, ne_rsub, ne_error }, + { '*', 130, 130, ne_imul, ne_rmul, ne_error }, + { '/', 130, 130, ne_error, ne_rdiv, ne_error }, + { '\\', 130, 130, ne_idiv, ne_error, ne_error }, + { '%', 130, 130, ne_imod, ne_error, ne_error }, + { '^', 135, 134, ne_error, ne_rpow, ne_error } }; #define neg_prec 140 @@ -93,313 +86,297 @@ static const opersymtab opers = { #define lnot_prec 140 -static int readreal(s, i, r, desc) -char *s; -long *i; -double *r; -ne_desc *desc; -{ - int Result; - long j; - char ch; - char buf[256]; - char *STR1; - char STR2[256]; - - while (s[*i - 1] == ' ') - (*i)++; - j = *i; - if (s[*i - 1] == '-' || s[*i - 1] == '+') - (*i)++; - while (isdigit(s[*i - 1])) - (*i)++; - if (s[*i - 1] == '.' && isdigit(s[*i])) { - do { - (*i)++; - } while (isdigit(s[*i - 1])); - } - if ((s[*i - 1] == 'E' || s[*i - 1] == 'e') && - ((isdigit(s[*i]) || (s[*i] == '-' || s[*i] == '+')) && - isdigit(s[*i + 1]))) { - (*i)++; - if (s[*i - 1] == '-' || s[*i - 1] == '+') - (*i)++; - while (isdigit(s[*i - 1])) - (*i)++; - } - if (*i <= j) - return false; - buf[*i - j] = '\0'; -/* p2c: numex.text, line 394: - * Note: Modification of string length may translate incorrectly [146] */ - memmove((void*)buf, (void*)(&s[j - 1]), *i - j); - *r = strtod(buf, &STR1); - j = STR1 - buf + 1; - Result = true; - if (!P_inset(s[*i - 1], desc->startident)) - return Result; - *buf = '\0'; - while (P_inset(s[*i - 1], desc->ident) || - P_inset(s[*i - 1], desc->startident)) { - sprintf(buf + strlen(buf), "%c", s[*i - 1]); - (*i)++; - } - strupper(buf, buf); - if (strends(buf, strupper(STR2, desc->units))) { - buf[strlen(buf) - strlen(desc->units)] = '\0'; -/* p2c: numex.text, line 418: - * Note: Modification of string length may translate incorrectly [146] */ - } - if (*buf == '\0') - return Result; - ch = buf[0]; - if (ch == 'F') { - *r *= 1e-15; - return Result; - } - if (ch == 'P') { - *r *= 1e-12; - return Result; - } - if (ch == 'N') { - *r *= 1e-9; - return Result; - } - if (ch == 'U') { - *r *= 1e-6; - return Result; - } - if (ch == 'K') { - *r *= 1e3; - return Result; - } - if (ch == 'G') { - *r *= 1e9; - return Result; - } - if (ch == 'T') { - *r *= 1e12; - return Result; - } - if (ch != 'M') - return Result; - if (buf[1] == 'E' && buf[2] == 'G') - *r *= 1e6; - else - *r *= 1e-3; - return Result; -} - - - -int ne_readreal(s_, r, desc) -char *s_; -double *r; -ne_desc *desc; -{ - char s[256]; - long i; - char STR1[256]; - -/* p2c: numex.text, line 475: - * Note: Null character at end of sprintf control string [148] */ - strcpy(s, s_); - strcpy(STR1, s); - strcpy(s, STR1); - i = 1; - return (readreal(s, &i, r, desc)); -} - - - - -static char *realunit(Result, r, u) -char *Result; -double r; -char *u; -{ - char s[256]; - char STR2[256]; - - if (r == 0 || fabs(r) >= 1e15 || fabs(r) < 1e-16) - *s = '\0'; - else if (fabs(r) >= 1e12) { - strcpy(s, "T"); - r /= 1e12; - } else if (fabs(r) >= 1e9) { - strcpy(s, "G"); - r /= 1e9; - } else if (fabs(r) >= 1e6) { - strcpy(s, "Meg"); - r /= 1e6; - } else if (fabs(r) >= 1e3) { - strcpy(s, "K"); - r /= 1e3; - } else if (fabs(r) >= 0.1) - *s = '\0'; - else if (fabs(r) >= 1e-3) { - strcpy(s, "m"); - r *= 1e3; - } else if (fabs(r) >= 1e-6) { - strcpy(s, "u"); - r *= 1e6; - } else if (fabs(r) >= 1e-9) { - strcpy(s, "n"); - r *= 1e9; - } else if (fabs(r) >= 1e-12) { - strcpy(s, "p"); - r *= 1e12; - } else { - strcpy(s, "f"); - r *= 1e15; - } - sprintf(s, "%g%s", r, strcpy(STR2, s)); - sprintf(Result, "%s%s", s, u); - return Result; -} - - - - - - -static void dummysymproc(name, desc, symptr) -char *name; -ne_desc *desc; -na_strlist_t **symptr; -{ - *symptr = strlist_find(desc->symtab, name); -} - - - -void ne_init(desc) -ne_desc *desc; -{ - strcpy(builtins[0].name,"ROUND"); - builtins[0].kind = 'A'; - builtins[0].op = ne_error; - strcpy(builtins[1].name,"TRUNC"); - builtins[1].kind = 'A'; - builtins[1].op = ne_error; - strcpy(builtins[2].name,"LN"); - builtins[2].kind = 'B'; - builtins[2].op = ne_error; - strcpy(builtins[3].name,"EXP"); - builtins[3].kind = 'B'; - builtins[3].op = ne_error; - strcpy(builtins[4].name,"ABS"); - builtins[4].kind = 'C'; - builtins[4].op = ne_error; - strcpy(builtins[5].name,"SQRT"); - builtins[5].kind = 'B'; - builtins[5].op = ne_error; - strcpy(builtins[6].name,"SIN"); - builtins[6].kind = 'B'; - builtins[6].op = ne_error; - strcpy(builtins[7].name,"COS"); - builtins[7].kind = 'B'; - builtins[7].op = ne_error; - strcpy(builtins[8].name,"TAN"); - builtins[8].kind = 'B'; - builtins[8].op = ne_error; - strcpy(builtins[9].name,"ARCTAN"); - builtins[9].kind = 'B'; - builtins[9].op = ne_error; - strcpy(builtins[10].name,"PI"); - builtins[10].kind = 'P'; - builtins[10].op = ne_error; - desc->symtab = NULL; - desc->casesens = false; - desc->builtin = true; - *desc->units = '\0'; - desc->scaled = false; - desc->doubleeq = false; - desc->error = (unsigned)ne_noerror; - P_addsetr(P_expset(desc->startident, 0L), 'A', 'Z'); - P_addsetr(desc->startident, 'a', 'z'); - P_addset(desc->startident, '_'); - P_addsetr(P_expset(desc->ident, 0L), 'A', 'Z'); - P_addsetr(desc->ident, 'a', 'z'); - P_addsetr(desc->ident, '0', '9'); - P_addset(desc->ident, '_'); - desc->symproc.proc = (void*)dummysymproc; - desc->symproc.link = (void*)NULL; - desc->isfunc = false; -} - - - - -static void newnexrec(nex, nargs, op) -ne_nexrec **nex; -long nargs; -ne_opkind op; -{ -/* p2c: numex.text, line 580: - * Note: No SpecialSizeOf form known for NE_NEXREC.1 [187] */ -/* p2c: numex.text, line 580: - * Note: Suspicious mixture of sizes in NA_NEW [173] */ - *nex = (ne_nexrec *)Malloc(sizeof(ne_nexrec) + nargs * 4); - (*nex)->nargs = nargs; - (*nex)->op = (unsigned)op; -} +static int readreal(char *s, long *i, double *r, ne_desc *desc) +{ + int Result; + long j; + char ch; + char buf[256]; + char *STR1; + char STR2[256]; + + while (s[*i - 1] == ' ') + (*i)++; + j = *i; + + if (s[*i - 1] == '-' || s[*i - 1] == '+') + (*i)++; + + while (isdigit(s[*i - 1])) + (*i)++; + + if (s[*i - 1] == '.' && isdigit(s[*i])) + { + do { + (*i)++; + } while (isdigit(s[*i - 1])); + } + + if ((s[*i - 1] == 'E' || s[*i - 1] == 'e') && ((isdigit(s[*i]) || (s[*i] == '-' || s[*i] == '+')) && isdigit(s[*i + 1]))) + { + (*i)++; + if (s[*i - 1] == '-' || s[*i - 1] == '+') + (*i)++; + while (isdigit(s[*i - 1])) + (*i)++; + } + + if (*i <= j) + return false; + + buf[*i - j] = '\0'; + memmove((void*)buf, (void*)(&s[j - 1]), *i - j); + *r = strtod(buf, &STR1); + j = STR1 - buf + 1; + Result = true; + if (!P_inset(s[*i - 1], desc->startident)) + return Result; + *buf = '\0'; + while (P_inset(s[*i - 1], desc->ident) || P_inset(s[*i - 1], desc->startident)) + { + sprintf(buf + strlen(buf), "%c", s[*i - 1]); + (*i)++; + } + + strupper(buf, buf); + if (strends(buf, strupper(STR2, desc->units))) + { + buf[strlen(buf) - strlen(desc->units)] = '\0'; + } + + if (*buf == '\0') + return Result; + ch = buf[0]; + + switch (ch) { + case 'F': + *r *= 1e-15; + return Result; + + case 'P': + *r *= 1e-12; + return Result; + + case 'N': + *r *= 1e-9; + return Result; + + case 'U': + *r *= 1e-6; + return Result; + + case 'K': + *r *= 1e3; + return Result; + + case 'G': + *r *= 1e9; + return Result; + + case 'T': + *r *= 1e12; + return Result; + + case 'M': + return Result; + } + if (buf[1] == 'E' && buf[2] == 'G') + *r *= 1e6; + else + *r *= 1e-3; -static void disposenexrec(nex) -ne_nexrec **nex; -{ -/* p2c: numex.text, line 588: - * Note: No SpecialSizeOf form known for NE_NEXREC.1 [187] */ - Free(*nex); + return Result; } +int ne_readreal(char *s_, double *r, ne_desc *desc) +{ + char s[256]; + long i; + char STR1[256]; + strcpy(s, s_); + strcpy(STR1, s); + strcpy(s, STR1); + i = 1; + return (readreal(s, &i, r, desc)); +} -void ne_copy(nex, newnex) -ne_nexrec *nex, **newnex; +static char *realunit(char *Result, double r, char *u) { - ne_opkind op; - long i, FORLIM; + char s[256]; + char STR2[256]; - if (nex == NULL) { - *newnex = NULL; - return; - } - op = (ne_opkind)nex->op; - newnexrec(newnex, (long)nex->nargs, op); - (*newnex)->UU.qw = nex->UU.qw; - FORLIM = nex->nargs; - for (i = 0; i < FORLIM; i++) - ne_copy(nex->UU.U99.pvals[i], &(*newnex)->UU.U99.pvals[i]); - if (op == ne_sc) - nex->UU.s = (char *) strdup((*newnex)->UU.s); -} - - - -void ne_dispose(nex) -ne_nexrec **nex; -{ - long i, FORLIM; - - if (*nex == NULL) - return; - if ((ne_opkind)(*nex)->op == ne_sc) - strdispose(&(*nex)->UU.s); - FORLIM = (*nex)->nargs; - for (i = 0; i < FORLIM; i++) - ne_dispose(&(*nex)->UU.U99.pvals[i]); - disposenexrec(nex); + if (r == 0 || fabs(r) >= 1e15 || fabs(r) < 1e-16) + { + *s = '\0'; + } + else if (fabs(r) >= 1e12) + { + strcpy(s, "T"); + r /= 1e12; + } + else if (fabs(r) >= 1e9) + { + strcpy(s, "G"); + r /= 1e9; + } + else if (fabs(r) >= 1e6) + { + strcpy(s, "Meg"); + r /= 1e6; + } + else if (fabs(r) >= 1e3) + { + strcpy(s, "K"); + r /= 1e3; + } + else if (fabs(r) >= 0.1) + { + *s = '\0'; + } + else if (fabs(r) >= 1e-3) + { + strcpy(s, "m"); + r *= 1e3; + } + else if (fabs(r) >= 1e-6) + { + strcpy(s, "u"); + r *= 1e6; + } + else if (fabs(r) >= 1e-9) + { + strcpy(s, "n"); + r *= 1e9; + } + else if (fabs(r) >= 1e-12) + { + strcpy(s, "p"); + r *= 1e12; + } + else + { + strcpy(s, "f"); + r *= 1e15; + } + + sprintf(s, "%g%s", r, strcpy(STR2, s)); + sprintf(Result, "%s%s", s, u); + return Result; +} + + +static void dummysymproc(char *name, ne_desc *desc, na_strlist_t **symptr) +{ + *symptr = strlist_find(desc->symtab, name); +} + +void ne_init(ne_desc *desc) +{ + strcpy(builtins[0].name,"ROUND"); + builtins[0].kind = 'A'; + builtins[0].op = ne_error; + strcpy(builtins[1].name,"TRUNC"); + builtins[1].kind = 'A'; + builtins[1].op = ne_error; + strcpy(builtins[2].name,"LN"); + builtins[2].kind = 'B'; + builtins[2].op = ne_error; + strcpy(builtins[3].name,"EXP"); + builtins[3].kind = 'B'; + builtins[3].op = ne_error; + strcpy(builtins[4].name,"ABS"); + builtins[4].kind = 'C'; + builtins[4].op = ne_error; + strcpy(builtins[5].name,"SQRT"); + builtins[5].kind = 'B'; + builtins[5].op = ne_error; + strcpy(builtins[6].name,"SIN"); + builtins[6].kind = 'B'; + builtins[6].op = ne_error; + strcpy(builtins[7].name,"COS"); + builtins[7].kind = 'B'; + builtins[7].op = ne_error; + strcpy(builtins[8].name,"TAN"); + builtins[8].kind = 'B'; + builtins[8].op = ne_error; + strcpy(builtins[9].name,"ARCTAN"); + builtins[9].kind = 'B'; + builtins[9].op = ne_error; + strcpy(builtins[10].name,"PI"); + builtins[10].kind = 'P'; + builtins[10].op = ne_error; + desc->symtab = NULL; + desc->casesens = false; + desc->builtin = true; + *desc->units = '\0'; + desc->scaled = false; + desc->doubleeq = false; + desc->error = (unsigned)ne_noerror; + P_addsetr(P_expset(desc->startident, 0L), 'A', 'Z'); + P_addsetr(desc->startident, 'a', 'z'); + P_addset(desc->startident, '_'); + P_addsetr(P_expset(desc->ident, 0L), 'A', 'Z'); + P_addsetr(desc->ident, 'a', 'z'); + P_addsetr(desc->ident, '0', '9'); + P_addset(desc->ident, '_'); + desc->symproc.proc = (void*)dummysymproc; + desc->symproc.link = (void*)NULL; + desc->isfunc = false; +} + +static void newnexrec(ne_nexrec **nex, long nargs, ne_opkind op) +{ + *nex = (ne_nexrec *)Malloc(sizeof(ne_nexrec) + nargs * 4); + (*nex)->nargs = nargs; + (*nex)->op = (unsigned)op; +} + +static void disposenexrec(ne_nexrec **nex) +{ + Free(*nex); +} + +void ne_copy(ne_nexrec *nex, ne_nexrec **newnex) +{ + ne_opkind op; + long i, FORLIM; + + if (nex == NULL) + { + *newnex = NULL; + return; + } + op = (ne_opkind)nex->op; + newnexrec(newnex, (long)nex->nargs, op); + (*newnex)->UU.qw = nex->UU.qw; + FORLIM = nex->nargs; + for (i = 0; i < FORLIM; i++) + ne_copy(nex->UU.U99.pvals[i], &(*newnex)->UU.U99.pvals[i]); + if (op == ne_sc) + nex->UU.s = (char *) strdup((*newnex)->UU.s); } +void ne_dispose(ne_nexrec **nex) +{ + long i, FORLIM; + + if (*nex == NULL) + return; + if ((ne_opkind)(*nex)->op == ne_sc) + strdispose(&(*nex)->UU.s); + FORLIM = (*nex)->nargs; + for (i = 0; i < FORLIM; i++) + ne_dispose(&(*nex)->UU.U99.pvals[i]); + disposenexrec(nex); +} static char *ne_errorkind_NAMES[] = { "NE_NOERROR", "NE_SYNTAX", "NE_OVERFLOW", "NE_UNDERFLOW", "NE_DIVZERO", "NE_STRLONG", "NE_BADTYPES", "NE_UNDEF", "NE_BADVAL" } ; - static char *ne_opkind_NAMES[] = { "NE_ERROR", "NE_IC", "NE_RC", "NE_SC", "NE_IP", "NE_RP", "NE_SP", "NE_IF", "NE_RF", "NE_SF", "NE_IARG", "NE_RARG", "NE_SARG", "NE_IADD", "NE_ISUB", @@ -414,1105 +391,956 @@ static char *ne_opkind_NAMES[] = { "NE_SQRT", "NE_SIN", "NE_COS", "NE_TAN", "NE_ARCTAN", "NE_RXP", "NE_RXOR" } ; +void ne_dump(ne_nexrec *nex) +{ + char buf[256]; + long i; + ne_opkind op; + char STR1[256]; + long FORLIM; - -void ne_dump(nex) -ne_nexrec *nex; -{ - char buf[256]; - long i; - ne_opkind op; - char STR1[256]; - long FORLIM; - - if (nex == NULL) { - printf("(nil)"); - return; - } - op = (ne_opkind)nex->op; - switch (op) { - - case ne_ic: - printf("%ld", nex->UU.i); - break; - - case ne_rc: - sprintf(buf, "%g", nex->UU.r); - if (strpos2(buf, ".", 1) == 0 && strpos2(buf, "E", 1) == 0) - strcat(buf, "."); - fputs(buf, stdout); - break; - - case ne_sc: - printf("'%s'", nex->UU.s); - break; - - case ne_ip: - if (nex->UU.U10.ips != NULL) - fputs(nex->UU.U10.ips->s, stdout); - else - printf("(i)"); - break; - - case ne_rp: - case ne_rxp: - if (nex->UU.U11.rps != NULL) - fputs(nex->UU.U11.rps->s, stdout); - else - printf("(r)"); - break; - - case ne_sp: - if (nex->UU.U12.sps != NULL) - fputs(nex->UU.U12.sps->s, stdout); - else - printf("(s)"); - break; - - case ne_if: - case ne_rf: - case ne_sf: - if (nex->UU.U15.fps != NULL) - fputs(nex->UU.U15.fps->s, stdout); - else - printf("func"); - break; - - case ne_error: - printf("error(%s)", ne_errorkind_NAMES[nex->UU.err]); -/* p2c: numex.text, line 678: Note: - * Line breaker spent 0.0+2.00 seconds, 5000 tries on line 407 [251] */ - break; - - default: - strcpy(buf, ne_opkind_NAMES[(long)op]); - i = strlen(buf) + 1; - buf[i - 1] = '\0'; -/* p2c: numex.text, line 679: - * Note: Modification of string length may translate incorrectly [146] */ - strcpy_overlap(buf, buf + 3); - fputs(strlower(STR1, buf), stdout); - break; - } - if (nex->nargs <= 0) - return; - FORLIM = nex->nargs; - for (i = 1; i <= FORLIM; i++) { - if (i == 1) - putchar('['); - else - putchar(','); - ne_dump(nex->UU.U99.pvals[i - 1]); - } - putchar(']'); + if (nex == NULL) + { + printf("(nil)"); + return; + } + op = (ne_opkind)nex->op; + switch (op) + { + + case ne_ic: + printf("%ld", nex->UU.i); + break; + + case ne_rc: + sprintf(buf, "%g", nex->UU.r); + if (strpos2(buf, ".", 1) == 0 && strpos2(buf, "E", 1) == 0) + strcat(buf, "."); + fputs(buf, stdout); + break; + + case ne_sc: + printf("'%s'", nex->UU.s); + break; + + case ne_ip: + if (nex->UU.U10.ips != NULL) + fputs(nex->UU.U10.ips->s, stdout); + else + printf("(i)"); + break; + + case ne_rp: + case ne_rxp: + if (nex->UU.U11.rps != NULL) + fputs(nex->UU.U11.rps->s, stdout); + else + printf("(r)"); + break; + + case ne_sp: + if (nex->UU.U12.sps != NULL) + fputs(nex->UU.U12.sps->s, stdout); + else + printf("(s)"); + break; + + case ne_if: + case ne_rf: + case ne_sf: + if (nex->UU.U15.fps != NULL) + fputs(nex->UU.U15.fps->s, stdout); + else + printf("func"); + break; + + case ne_error: + printf("error(%s)", ne_errorkind_NAMES[nex->UU.err]); + break; + + default: + strcpy(buf, ne_opkind_NAMES[(long)op]); + i = strlen(buf) + 1; + buf[i - 1] = '\0'; + strcpy_overlap(buf, buf + 3); + fputs(strlower(STR1, buf), stdout); + break; + } + if (nex->nargs <= 0) + return; + FORLIM = nex->nargs; + for (i = 1; i <= FORLIM; i++) + { + if (i == 1) + putchar('['); + else + putchar(','); + ne_dump(nex->UU.U99.pvals[i - 1]); + } + putchar(']'); } - - - - - - - -static int integerp(nex) -ne_nexrec *nex; +static int integerp(ne_nexrec *nex) { - return (nex != NULL && types[nex->op] == ne_integer); + return (nex != NULL && types[nex->op] == ne_integer); } - - -static int realp(nex) -ne_nexrec *nex; +static int realp(ne_nexrec *nex) { - return (nex != NULL && types[nex->op] == ne_real); + return (nex != NULL && types[nex->op] == ne_real); } - - -static int stringp(nex) -ne_nexrec *nex; +static int stringp(ne_nexrec *nex) { - return (nex != NULL && types[nex->op] == ne_string); + return (nex != NULL && types[nex->op] == ne_string); } - - - - -ne_nexrec *ne_makeerror(err) -ne_errorkind err; +ne_nexrec *ne_makeerror(ne_errorkind err) { - ne_nexrec *nex; + ne_nexrec *nex; - newnexrec(&nex, 0L, ne_error); - nex->UU.err = (unsigned)err; - return nex; + newnexrec(&nex, 0L, ne_error); + nex->UU.err = (unsigned)err; + return nex; } - -static void optimize (ne_nexrec **nex, ne_desc *desc, na_strlist_t *which, - long mode); +static void optimize (ne_nexrec **nex, ne_desc *desc, na_strlist_t *which, long mode); /* Local variables for optimize: */ -struct LOC_optimize { - ne_desc *desc; - na_strlist_t *which; - long mode; - ne_errorkind err; - long ires; - double rres; - char sres[256]; +struct LOC_optimize +{ + ne_desc *desc; + na_strlist_t *which; + long mode; + ne_errorkind err; + long ires; + double rres; + char sres[256]; } ; /* Local variables for opt: */ -struct LOC_opt { - struct LOC_optimize *LINK; - ne_nexrec **nex; +struct LOC_opt +{ + struct LOC_optimize *LINK; + ne_nexrec **nex; } ; -static int makeconstant(name, LINK) -char *name; -struct LOC_opt *LINK; +static int makeconstant(char *name, struct LOC_opt *LINK) { - if (LINK->LINK->mode == 1 || LINK->LINK->mode == 2) - return ((strlist_find(LINK->LINK->which, name) != NULL) == - (LINK->LINK->mode == 1)); - else - return false; + if (LINK->LINK->mode == 1 || LINK->LINK->mode == 2) + return ((strlist_find(LINK->LINK->which, name) != NULL) == (LINK->LINK->mode == 1)); + else + return false; } -static void error(errk, LINK) -ne_errorkind errk; -struct LOC_opt *LINK; +static void error(ne_errorkind errk, struct LOC_opt *LINK) { - LINK->LINK->err = errk; - _Escape(2345); + LINK->LINK->err = errk; + _Escape(2345); } -static void collapsehalf(px, py, LINK) -ne_nexrec *px, *py; -struct LOC_opt *LINK; +static void collapsehalf(ne_nexrec *px, ne_nexrec *py, struct LOC_opt *LINK) { - /*keep px, dispose py*/ - disposenexrec(LINK->nex); - ne_dispose(&py); - *LINK->nex = px; + /*keep px, dispose py*/ + disposenexrec(LINK->nex); + ne_dispose(&py); + *LINK->nex = px; } -static void collapsecond(px, py, pz, LINK) -ne_nexrec *px, *py, *pz; -struct LOC_opt *LINK; +static void collapsecond(ne_nexrec *px, ne_nexrec *py, ne_nexrec *pz, struct LOC_opt *LINK) { - /*keep py, dispose px/pz*/ - disposenexrec(LINK->nex); - ne_dispose(&px); - ne_dispose(&pz); - *LINK->nex = py; + /*keep py, dispose px/pz*/ + disposenexrec(LINK->nex); + ne_dispose(&px); + ne_dispose(&pz); + *LINK->nex = py; } -static void collapseint(res, LINK) -long res; -struct LOC_opt *LINK; +static void collapseint(long res, struct LOC_opt *LINK) { - ne_dispose(LINK->nex); - newnexrec(LINK->nex, 0L, ne_ic); - (*LINK->nex)->UU.i = res; + ne_dispose(LINK->nex); + newnexrec(LINK->nex, 0L, ne_ic); + (*LINK->nex)->UU.i = res; } -static void collapsereal(res, LINK) -double res; -struct LOC_opt *LINK; +static void collapsereal(double res, struct LOC_opt *LINK) { - ne_dispose(LINK->nex); - newnexrec(LINK->nex, 0L, ne_rc); - (*LINK->nex)->UU.r = res; + ne_dispose(LINK->nex); + newnexrec(LINK->nex, 0L, ne_rc); + (*LINK->nex)->UU.r = res; } -static void collapsestr(res, LINK) -char *res; -struct LOC_opt *LINK; +static void collapsestr(char *res, struct LOC_opt *LINK) { - ne_dispose(LINK->nex); - newnexrec(LINK->nex, 0L, ne_sc); - (*LINK->nex)->UU.s = (char *)strdup(res); + ne_dispose(LINK->nex); + newnexrec(LINK->nex, 0L, ne_sc); + (*LINK->nex)->UU.s = (char *)strdup(res); } -static int istrue(nex, LINK) -ne_nexrec *nex; -struct LOC_opt *LINK; +static int istrue(ne_nexrec *nex, struct LOC_opt *LINK) { - int Result; - - switch ((ne_opkind)nex->op) { - - case ne_ic: - Result = (nex->UU.i != 0); - break; + int Result; - case ne_rc: - Result = (nex->UU.r != 0); - break; + switch ((ne_opkind)nex->op) + { + case ne_ic: + Result = (nex->UU.i != 0); + break; - case ne_sc: - Result = (*nex->UU.s != '\0'); - break; - - default: - Result = false; - break; - } - return Result; -} - -static int isfalse(nex, LINK) -ne_nexrec *nex; -struct LOC_opt *LINK; -{ - int Result; - - switch ((ne_opkind)nex->op) { - - case ne_error: - Result = ((ne_errorkind)nex->UU.err == ne_badval); - break; - - case ne_ic: - Result = (nex->UU.i == 0); - break; - - case ne_rc: - Result = (nex->UU.r == 0); - break; - - case ne_sc: - Result = (*nex->UU.s == '\0'); - break; - - default: - Result = false; - break; - } - return Result; -} - -static int foldfunction(LINK) -struct LOC_opt *LINK; -{ - int Result; - long i1; - ne_nexrec *WITH; - long FORLIM; - - WITH = *LINK->nex; - if (!WITH->UU.U15.fp->static_ || WITH->UU.U15.fp->subnex) - return false; - Result = true; - FORLIM = WITH->nargs; - for (i1 = 0; i1 < FORLIM; i1++) { - if (WITH->UU.U99.pvals[i1]->op >= 32 || - ((1L << WITH->UU.U99.pvals[i1]->op) & ((1L << ((long)ne_ic)) | - (1L << ((long)ne_rc)) | (1L << ((long)ne_sc)))) == 0) - Result = false; - } - return Result; -} - -static ne_nexrec *opt(nex_, LINK) -ne_nexrec **nex_; -struct LOC_optimize *LINK; -{ - struct LOC_opt V; - long i1; - ne_nexrec *WITH; - long FORLIM; - char STR1[256]; - - V.LINK = LINK; - V.nex = nex_; - if (*V.nex == NULL) - return (*V.nex); - WITH = *V.nex; - if ((ne_opkind)WITH->op != (int)ne_scond && - (ne_opkind)WITH->op != (int)ne_sor && - (ne_opkind)WITH->op != (int)ne_sand && - (ne_opkind)WITH->op != (int)ne_rcond && - (ne_opkind)WITH->op != (int)ne_ror && - (ne_opkind)WITH->op != (int)ne_rand && - (ne_opkind)WITH->op != (int)ne_icond && - (ne_opkind)WITH->op != (int)ne_ior && - (ne_opkind)WITH->op != (int)ne_iand && - (ne_opkind)WITH->op != (int)ne_rxor && - (ne_opkind)WITH->op != (int)ne_lnot) { - FORLIM = WITH->nargs; - for (i1 = 0; i1 < FORLIM; i1++) - WITH->UU.U99.pvals[i1] = opt(&WITH->UU.U99.pvals[i1], LINK); - } - /* optimize(pvals[i1], desc, which, mode); */ - switch ((ne_opkind)WITH->op) { - - case ne_error: - error((ne_errorkind)WITH->UU.err, &V); - break; - - case ne_ip: - if (WITH->UU.U10.ips != NULL && makeconstant(WITH->UU.U10.ips->s, &V)) { - WITH->op = (unsigned)ne_ic; - WITH->UU.i = *WITH->UU.U10.ip; - } - break; - - case ne_rp: - case ne_rxp: - if (WITH->UU.U11.rps != NULL && makeconstant(WITH->UU.U11.rps->s, &V)) { - WITH->op = (unsigned)ne_rc; - WITH->UU.r = *WITH->UU.U11.rp; - if ((ne_opkind)WITH->op == ne_rxp && WITH->UU.r == ne_badvalue) - error(ne_badval, &V); - } - break; - - case ne_sp: - if (WITH->UU.U12.sps != NULL && makeconstant(WITH->UU.U12.sps->s, &V)) { - WITH->op = (unsigned)ne_sc; - WITH->UU.s = (char *)strdup(*WITH->UU.U12.sp); - } - break; - - case ne_if: - if (foldfunction(&V)) { - if (WITH->UU.U15.fp->UU.U5.ipr.link != NULL) - (*(void(*) (ne_nexrec *nex, long *res, void* _link)) - WITH->UU.U15.fp->UU.U5.ipr.proc)(*V.nex, &LINK->ires, - WITH->UU.U15.fp->UU.U5.ipr.link); - else - (*(void(*) (ne_nexrec *nex, long *res)) - WITH->UU.U15.fp->UU.U5.ipr.proc)(*V.nex, &LINK->ires); - collapseint(LINK->ires, &V); - } - break; - - case ne_rf: - if (foldfunction(&V)) { - if (WITH->UU.U15.fp->UU.rpr.link != NULL) - (*(void(*) (ne_nexrec *nex, double *res, void* _link)) - WITH->UU.U15.fp->UU.rpr.proc)(*V.nex, &LINK->rres, + case ne_rc: + Result = (nex->UU.r != 0); + break; + + case ne_sc: + Result = (*nex->UU.s != '\0'); + break; + + default: + Result = false; + break; + } + return Result; +} + +static int isfalse(ne_nexrec *nex, struct LOC_opt *LINK) +{ + int Result; + + switch ((ne_opkind)nex->op) + { + + case ne_error: + Result = ((ne_errorkind)nex->UU.err == ne_badval); + break; + + case ne_ic: + Result = (nex->UU.i == 0); + break; + + case ne_rc: + Result = (nex->UU.r == 0); + break; + + case ne_sc: + Result = (*nex->UU.s == '\0'); + break; + + default: + Result = false; + break; + } + return Result; +} + +static int foldfunction(struct LOC_opt *LINK) +{ + int Result; + long i1; + ne_nexrec *WITH; + long FORLIM; + + WITH = *LINK->nex; + if (!WITH->UU.U15.fp->static_ || WITH->UU.U15.fp->subnex) + return false; + Result = true; + FORLIM = WITH->nargs; + + for (i1 = 0; i1 < FORLIM; i1++) + { + if (WITH->UU.U99.pvals[i1]->op >= 32 || + ((1L << WITH->UU.U99.pvals[i1]->op) & ((1L << ((long)ne_ic)) | (1L << ((long)ne_rc)) | (1L << ((long)ne_sc)))) == 0) + Result = false; + } + return Result; +} + +static ne_nexrec *opt(ne_nexrec **nex_, struct LOC_optimize *LINK) +{ + struct LOC_opt V; + long i1; + ne_nexrec *WITH; + long FORLIM; + char STR1[256]; + + V.LINK = LINK; + V.nex = nex_; + if (*V.nex == NULL) + return (*V.nex); + WITH = *V.nex; + if ((ne_opkind)WITH->op != (int)ne_scond && + (ne_opkind)WITH->op != (int)ne_sor && + (ne_opkind)WITH->op != (int)ne_sand && + (ne_opkind)WITH->op != (int)ne_rcond && + (ne_opkind)WITH->op != (int)ne_ror && + (ne_opkind)WITH->op != (int)ne_rand && + (ne_opkind)WITH->op != (int)ne_icond && + (ne_opkind)WITH->op != (int)ne_ior && + (ne_opkind)WITH->op != (int)ne_iand && + (ne_opkind)WITH->op != (int)ne_rxor && + (ne_opkind)WITH->op != (int)ne_lnot) + { + FORLIM = WITH->nargs; + for (i1 = 0; i1 < FORLIM; i1++) + WITH->UU.U99.pvals[i1] = opt(&WITH->UU.U99.pvals[i1], LINK); + } + + /* optimize(pvals[i1], desc, which, mode); */ + switch ((ne_opkind)WITH->op) + { + + case ne_error: + error((ne_errorkind)WITH->UU.err, &V); + break; + + case ne_ip: + if (WITH->UU.U10.ips != NULL && makeconstant(WITH->UU.U10.ips->s, &V)) + { + WITH->op = (unsigned)ne_ic; + WITH->UU.i = *WITH->UU.U10.ip; + } + break; + + case ne_rp: + case ne_rxp: + if (WITH->UU.U11.rps != NULL && makeconstant(WITH->UU.U11.rps->s, &V)) + { + WITH->op = (unsigned)ne_rc; + WITH->UU.r = *WITH->UU.U11.rp; + if ((ne_opkind)WITH->op == ne_rxp && WITH->UU.r == ne_badvalue) + error(ne_badval, &V); + } + break; + + case ne_sp: + if (WITH->UU.U12.sps != NULL && makeconstant(WITH->UU.U12.sps->s, &V)) + { + WITH->op = (unsigned)ne_sc; + WITH->UU.s = (char *)strdup(*WITH->UU.U12.sp); + } + break; + + case ne_if: + if (foldfunction(&V)) + { + if (WITH->UU.U15.fp->UU.U5.ipr.link != NULL) + (*(void(*) (ne_nexrec *nex, long *res, void* _link)) WITH->UU.U15.fp->UU.U5.ipr.proc)(*V.nex, &LINK->ires, + WITH->UU.U15.fp->UU.U5.ipr.link); + else + (*(void(*) (ne_nexrec *nex, long *res)) WITH->UU.U15.fp->UU.U5.ipr.proc)(*V.nex, &LINK->ires); + collapseint(LINK->ires, &V); + } + break; + + case ne_rf: + if (foldfunction(&V)) + { + if (WITH->UU.U15.fp->UU.rpr.link != NULL) + (*(void(*) (ne_nexrec *nex, double *res, void* _link)) WITH->UU.U15.fp->UU.rpr.proc)(*V.nex, &LINK->rres, WITH->UU.U15.fp->UU.rpr.link); - else - (*(void(*) (ne_nexrec *nex, double *res)) - WITH->UU.U15.fp->UU.rpr.proc)(*V.nex, &LINK->rres); - collapsereal(LINK->rres, &V); - } - break; - - case ne_sf: - if (foldfunction(&V)) { - if (WITH->UU.U15.fp->UU.spr.link != NULL) - (*(void(*) (ne_nexrec *nex, char *res, void* _link)) - WITH->UU.U15.fp->UU.spr.proc)(*V.nex, LINK->sres, - WITH->UU.U15.fp->UU.spr.link); - else - (*(void(*) (ne_nexrec *nex, char *res)) - WITH->UU.U15.fp->UU.spr.proc)(*V.nex, LINK->sres); - collapsestr(LINK->sres, &V); - } - break; - - case ne_iadd: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint(WITH->UU.U10.p1->UU.i + WITH->UU.U10.p2->UU.i, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == 0) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_isub: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint(WITH->UU.U10.p1->UU.i - WITH->UU.U10.p2->UU.i, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_imul: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint(WITH->UU.U10.p1->UU.i * WITH->UU.U10.p2->UU.i, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == 1) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 1) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 0) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - break; - - case ne_idiv: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint(WITH->UU.U10.p1->UU.i / WITH->UU.U10.p2->UU.i, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 1) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 0) - error(ne_divzero, &V); - break; - - case ne_ineg: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic) - collapseint(-WITH->UU.U10.p1->UU.i, &V); - break; - - case ne_radd: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapsereal(WITH->UU.U10.p1->UU.r + WITH->UU.U10.p2->UU.r, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - WITH->UU.U10.p1->UU.r == 0) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && - WITH->UU.U10.p2->UU.r == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_rsub: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapsereal(WITH->UU.U10.p1->UU.r - WITH->UU.U10.p2->UU.r, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && - WITH->UU.U10.p2->UU.r == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_rmul: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapsereal(WITH->UU.U10.p1->UU.r * WITH->UU.U10.p2->UU.r, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - WITH->UU.U10.p1->UU.r == 1) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && - WITH->UU.U10.p2->UU.r == 1) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - WITH->UU.U10.p1->UU.r == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && - WITH->UU.U10.p2->UU.r == 0) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - break; - - case ne_rdiv: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapsereal(WITH->UU.U10.p1->UU.r / WITH->UU.U10.p2->UU.r, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - WITH->UU.U10.p1->UU.r == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && - WITH->UU.U10.p2->UU.r == 1) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && - WITH->UU.U10.p2->UU.r == 0) - error(ne_divzero, &V); - break; - - case ne_rpow: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapsereal(ma_ytox(WITH->UU.U10.p1->UU.r, WITH->UU.U10.p2->UU.r), &V); - break; - - case ne_rneg: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapsereal(-WITH->UU.U10.p1->UU.r, &V); - break; - - case ne_sadd: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && - (ne_opkind)WITH->UU.U10.p2->op == ne_sc) { - if (strlen(WITH->UU.U10.p1->UU.s) + strlen(WITH->UU.U10.p2->UU.s) > 255) - error(ne_strlong, &V); - else { - sprintf(STR1, "%s%s", WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s); - collapsestr(STR1, &V); - } - } else if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && - *WITH->UU.U10.p1->UU.s == '\0') - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_sc && - *WITH->UU.U10.p2->UU.s == '\0') - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_itor: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic) - collapsereal((double)WITH->UU.U10.p1->UU.i, &V); - break; - - case ne_imod: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) { -/* p2c: numex.text, line 991: - * Note: Using % for possibly-negative arguments [317] */ - collapseint(WITH->UU.U10.p1->UU.i % WITH->UU.U10.p2->UU.i, &V); - } - break; - - case ne_rbool: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapseint((long)(WITH->UU.U10.p1->UU.r != 0), &V); - break; - - case ne_sbool: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc) - collapseint((long)(*WITH->UU.U10.p1->UU.s != '\0'), &V); - break; - - case ne_ieq: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint((long)(WITH->UU.U10.p1->UU.i == WITH->UU.U10.p2->UU.i), &V); - break; - - case ne_ine: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint((long)(WITH->UU.U10.p1->UU.i != WITH->UU.U10.p2->UU.i), &V); - break; - - case ne_ilt: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint((long)(WITH->UU.U10.p1->UU.i < WITH->UU.U10.p2->UU.i), &V); - break; - - case ne_ile: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint((long)(WITH->UU.U10.p1->UU.i <= WITH->UU.U10.p2->UU.i), &V); - break; - - case ne_igt: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint((long)(WITH->UU.U10.p1->UU.i > WITH->UU.U10.p2->UU.i), &V); - break; - - case ne_ige: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint((long)(WITH->UU.U10.p1->UU.i >= WITH->UU.U10.p2->UU.i), &V); - break; - - case ne_req: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapseint((long)(WITH->UU.U10.p1->UU.r == WITH->UU.U10.p2->UU.r), &V); - break; - - case ne_rne: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapseint((long)(WITH->UU.U10.p1->UU.r != WITH->UU.U10.p2->UU.r), &V); - break; - - case ne_rlt: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapseint((long)(WITH->UU.U10.p1->UU.r < WITH->UU.U10.p2->UU.r), &V); - break; - - case ne_rle: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapseint((long)(WITH->UU.U10.p1->UU.r <= WITH->UU.U10.p2->UU.r), &V); - break; - - case ne_rgt: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapseint((long)(WITH->UU.U10.p1->UU.r > WITH->UU.U10.p2->UU.r), &V); - break; - - case ne_rge: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && - (ne_opkind)WITH->UU.U10.p2->op == ne_rc) - collapseint((long)(WITH->UU.U10.p1->UU.r >= WITH->UU.U10.p2->UU.r), &V); - break; - - case ne_seq: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && - (ne_opkind)WITH->UU.U10.p2->op == ne_sc) - collapseint( - (long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) == 0), - &V); - break; - - case ne_sne: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && - (ne_opkind)WITH->UU.U10.p2->op == ne_sc) - collapseint( - (long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) != 0), - &V); - break; - - case ne_slt: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && - (ne_opkind)WITH->UU.U10.p2->op == ne_sc) - collapseint( - (long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) < 0), &V); - break; - - case ne_sle: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && - (ne_opkind)WITH->UU.U10.p2->op == ne_sc) - collapseint( - (long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) <= 0), - &V); - break; - - case ne_sgt: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && - (ne_opkind)WITH->UU.U10.p2->op == ne_sc) - collapseint( - (long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) > 0), &V); - break; - - case ne_sge: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && - (ne_opkind)WITH->UU.U10.p2->op == ne_sc) - collapseint( - (long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) >= 0), - &V); - break; - - case ne_not: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic) - collapseint(~WITH->UU.U10.p1->UU.i, &V); - break; - - case ne_and: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint(WITH->UU.U10.p1->UU.i & WITH->UU.U10.p2->UU.i, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == -1) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == -1) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 0) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - break; - - case ne_or: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint(WITH->UU.U10.p1->UU.i | WITH->UU.U10.p2->UU.i, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == 0) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == -1) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == -1) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - break; - - case ne_xor: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) - collapseint(WITH->UU.U10.p1->UU.i ^ WITH->UU.U10.p2->UU.i, &V); - else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == 0) - collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); - else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 0) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_lsh: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) { -/* p2c: numex.text, line 1086: - * Note: Assuming count for NA_ASL is positive [504] */ - collapseint(WITH->UU.U10.p1->UU.i << WITH->UU.U10.p2->UU.i, &V); - } else if (((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == 0) || - ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 0)) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_rsh: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - (ne_opkind)WITH->UU.U10.p2->op == ne_ic) { -/* p2c: numex.text, line 1092: - * Note: Assuming count for NA_ASL is negative [504] */ -/* p2c: numex.text, line 1092: - * Note: Assuming >> is an arithmetic shift [505] */ - collapseint(WITH->UU.U10.p1->UU.i >> WITH->UU.U10.p2->UU.i, &V); - } else if (((ne_opkind)WITH->UU.U10.p1->op == ne_ic && - WITH->UU.U10.p1->UU.i == 0) || - ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && - WITH->UU.U10.p2->UU.i == 0)) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_lnot: - optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); - if (istrue(WITH->UU.U10.p1, &V)) - collapseint(0L, &V); - else if (isfalse(WITH->UU.U10.p1, &V)) - collapseint(1L, &V); - break; - - case ne_iand: - optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); - if (istrue(WITH->UU.U10.p1, &V)) - collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); - else if (isfalse(WITH->UU.U10.p1, &V)) - collapseint(0L, &V); - break; - - case ne_ior: - optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); - if (isfalse(WITH->UU.U10.p1, &V)) - collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); - else if (istrue(WITH->UU.U10.p1, &V)) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_rand: - optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); - if (istrue(WITH->UU.U10.p1, &V)) - collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); - else if (isfalse(WITH->UU.U10.p1, &V)) - collapsereal(0.0, &V); - break; - - case ne_ror: - optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); - if (isfalse(WITH->UU.U10.p1, &V)) - collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); - else if (istrue(WITH->UU.U10.p1, &V)) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_rxor: - optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); - if ((ne_opkind)WITH->UU.U10.p1->op == ne_error && - (ne_errorkind)WITH->UU.U10.p1->UU.err == ne_badval) - collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); - else if (istrue(WITH->UU.U10.p1, &V)) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_sand: - optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); - if (istrue(WITH->UU.U10.p1, &V)) - collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); - else if (isfalse(WITH->UU.U10.p1, &V)) - collapsestr("", &V); - break; - - case ne_sor: - optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); - if (isfalse(WITH->UU.U10.p1, &V)) - collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); - else if (istrue(WITH->UU.U10.p1, &V)) - collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); - break; - - case ne_icond: - case ne_rcond: - case ne_scond: - optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); - if (isfalse(WITH->UU.U10.p1, &V)) - collapsecond(WITH->UU.U10.p1, opt(&WITH->UU.U10.p3, LINK), - WITH->UU.U10.p2, &V); - else if (istrue(WITH->UU.U10.p1, &V)) - collapsecond(WITH->UU.U10.p1, opt(&WITH->UU.U10.p2, LINK), - WITH->UU.U10.p3, &V); - break; - - case ne_round: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapseint((long)floor(WITH->UU.U10.p1->UU.r + 0.5), &V); - break; - - case ne_trunc: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapseint((long)WITH->UU.U10.p1->UU.r, &V); - break; - - case ne_ln: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapsereal(log(WITH->UU.U10.p1->UU.r), &V); - break; - - case ne_exp: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapsereal(exp(WITH->UU.U10.p1->UU.r), &V); - break; - - case ne_iabs: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic) - collapseint(labs(WITH->UU.U10.p1->UU.i), &V); - break; - - case ne_rabs: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapsereal(fabs(WITH->UU.U10.p1->UU.r), &V); - break; - - case ne_sqrt: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapsereal(sqrt(WITH->UU.U10.p1->UU.r), &V); - break; - - case ne_sin: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapsereal(sin(WITH->UU.U10.p1->UU.r), &V); - break; - - case ne_cos: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapsereal(cos(WITH->UU.U10.p1->UU.r), &V); - break; - - case ne_tan: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapsereal(tan(WITH->UU.U10.p1->UU.r), &V); - break; - - case ne_arctan: - if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) - collapsereal(atan(WITH->UU.U10.p1->UU.r), &V); - break; - - default: - break; - } - return (*V.nex); -} - - - -static void optimize(nex, desc_, which_, mode_) -ne_nexrec **nex; -ne_desc *desc_; -na_strlist_t *which_; -long mode_; -{ - struct LOC_optimize V; - - V.desc = desc_; - V.which = which_; - V.mode = mode_; - V.err = ne_noerror; - TRY(try1); - *nex = opt(nex, &V); - RECOVER(try1); - if (P_escapecode == -20) - _Escape(P_escapecode); - if (V.err == ne_noerror) { - switch (P_escapecode) { - - case -5: - V.err = ne_divzero; - break; - - case -7: - V.err = ne_underflow; - break; - - default: - V.err = ne_overflow; - break; - } - } - ne_dispose(nex); - *nex = ne_makeerror(V.err); - ENDTRY(try1); - if ((ne_opkind)(*nex)->op == ne_error) - V.desc->error = (unsigned)((ne_errorkind)(*nex)->UU.err); - else - V.desc->error = (unsigned)ne_noerror; + else + (*(void(*) (ne_nexrec *nex, double *res)) WITH->UU.U15.fp->UU.rpr.proc)(*V.nex, &LINK->rres); + collapsereal(LINK->rres, &V); + } + break; + + case ne_sf: + if (foldfunction(&V)) + { + if (WITH->UU.U15.fp->UU.spr.link != NULL) + (*(void(*) (ne_nexrec *nex, char *res, void* _link)) WITH->UU.U15.fp->UU.spr.proc)(*V.nex, LINK->sres, + WITH->UU.U15.fp->UU.spr.link); + else + (*(void(*) (ne_nexrec *nex, char *res)) WITH->UU.U15.fp->UU.spr.proc)(*V.nex, LINK->sres); + collapsestr(LINK->sres, &V); + } + break; + + case ne_iadd: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint(WITH->UU.U10.p1->UU.i + WITH->UU.U10.p2->UU.i, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == 0) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_isub: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint(WITH->UU.U10.p1->UU.i - WITH->UU.U10.p2->UU.i, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_imul: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint(WITH->UU.U10.p1->UU.i * WITH->UU.U10.p2->UU.i, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == 1) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 1) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 0) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + break; + + case ne_idiv: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint(WITH->UU.U10.p1->UU.i / WITH->UU.U10.p2->UU.i, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 1) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 0) + error(ne_divzero, &V); + break; + + case ne_ineg: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic) + collapseint(-WITH->UU.U10.p1->UU.i, &V); + break; + + case ne_radd: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc &&(ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapsereal(WITH->UU.U10.p1->UU.r + WITH->UU.U10.p2->UU.r, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && WITH->UU.U10.p1->UU.r == 0) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && WITH->UU.U10.p2->UU.r == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_rsub: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapsereal(WITH->UU.U10.p1->UU.r - WITH->UU.U10.p2->UU.r, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && WITH->UU.U10.p2->UU.r == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_rmul: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapsereal(WITH->UU.U10.p1->UU.r * WITH->UU.U10.p2->UU.r, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && WITH->UU.U10.p1->UU.r == 1) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && WITH->UU.U10.p2->UU.r == 1) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && WITH->UU.U10.p1->UU.r == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && + WITH->UU.U10.p2->UU.r == 0) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + break; + + case ne_rdiv: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapsereal(WITH->UU.U10.p1->UU.r / WITH->UU.U10.p2->UU.r, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && WITH->UU.U10.p1->UU.r == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && WITH->UU.U10.p2->UU.r == 1) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_rc && WITH->UU.U10.p2->UU.r == 0) + error(ne_divzero, &V); + break; + + case ne_rpow: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapsereal(ma_ytox(WITH->UU.U10.p1->UU.r, WITH->UU.U10.p2->UU.r), &V); + break; + + case ne_rneg: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapsereal(-WITH->UU.U10.p1->UU.r, &V); + break; + + case ne_sadd: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && (ne_opkind)WITH->UU.U10.p2->op == ne_sc) + { + if (strlen(WITH->UU.U10.p1->UU.s) + strlen(WITH->UU.U10.p2->UU.s) > 255) + { + error(ne_strlong, &V); + } + else + { + sprintf(STR1, "%s%s", WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s); + collapsestr(STR1, &V); + } + } + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && *WITH->UU.U10.p1->UU.s == '\0') + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_sc && *WITH->UU.U10.p2->UU.s == '\0') + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_itor: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic) + collapsereal((double)WITH->UU.U10.p1->UU.i, &V); + break; + + case ne_imod: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + { + collapseint(WITH->UU.U10.p1->UU.i % WITH->UU.U10.p2->UU.i, &V); + } + break; + + case ne_rbool: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapseint((long)(WITH->UU.U10.p1->UU.r != 0), &V); + break; + + case ne_sbool: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc) + collapseint((long)(*WITH->UU.U10.p1->UU.s != '\0'), &V); + break; + + case ne_ieq: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint((long)(WITH->UU.U10.p1->UU.i == WITH->UU.U10.p2->UU.i), &V); + break; + + case ne_ine: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint((long)(WITH->UU.U10.p1->UU.i != WITH->UU.U10.p2->UU.i), &V); + break; + + case ne_ilt: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint((long)(WITH->UU.U10.p1->UU.i < WITH->UU.U10.p2->UU.i), &V); + break; + + case ne_ile: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint((long)(WITH->UU.U10.p1->UU.i <= WITH->UU.U10.p2->UU.i), &V); + break; + + case ne_igt: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint((long)(WITH->UU.U10.p1->UU.i > WITH->UU.U10.p2->UU.i), &V); + break; + + case ne_ige: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint((long)(WITH->UU.U10.p1->UU.i >= WITH->UU.U10.p2->UU.i), &V); + break; + + case ne_req: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapseint((long)(WITH->UU.U10.p1->UU.r == WITH->UU.U10.p2->UU.r), &V); + break; + + case ne_rne: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapseint((long)(WITH->UU.U10.p1->UU.r != WITH->UU.U10.p2->UU.r), &V); + break; + + case ne_rlt: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapseint((long)(WITH->UU.U10.p1->UU.r < WITH->UU.U10.p2->UU.r), &V); + break; + + case ne_rle: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapseint((long)(WITH->UU.U10.p1->UU.r <= WITH->UU.U10.p2->UU.r), &V); + break; + + case ne_rgt: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapseint((long)(WITH->UU.U10.p1->UU.r > WITH->UU.U10.p2->UU.r), &V); + break; + + case ne_rge: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc && (ne_opkind)WITH->UU.U10.p2->op == ne_rc) + collapseint((long)(WITH->UU.U10.p1->UU.r >= WITH->UU.U10.p2->UU.r), &V); + break; + + case ne_seq: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && (ne_opkind)WITH->UU.U10.p2->op == ne_sc) + collapseint((long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) == 0), &V); + break; + + case ne_sne: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && (ne_opkind)WITH->UU.U10.p2->op == ne_sc) + collapseint((long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) != 0), &V); + break; + + case ne_slt: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && (ne_opkind)WITH->UU.U10.p2->op == ne_sc) + collapseint((long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) < 0), &V); + break; + + case ne_sle: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && (ne_opkind)WITH->UU.U10.p2->op == ne_sc) + collapseint((long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) <= 0), &V); + break; + + case ne_sgt: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && (ne_opkind)WITH->UU.U10.p2->op == ne_sc) + collapseint((long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) > 0), &V); + break; + + case ne_sge: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_sc && (ne_opkind)WITH->UU.U10.p2->op == ne_sc) + collapseint((long)(strcmp(WITH->UU.U10.p1->UU.s, WITH->UU.U10.p2->UU.s) >= 0), &V); + break; + + case ne_not: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic) + collapseint(~WITH->UU.U10.p1->UU.i, &V); + break; + + case ne_and: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint(WITH->UU.U10.p1->UU.i & WITH->UU.U10.p2->UU.i, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == -1) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == -1) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 0) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + break; + + case ne_or: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint(WITH->UU.U10.p1->UU.i | WITH->UU.U10.p2->UU.i, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == 0) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == -1) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == -1) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + break; + + case ne_xor: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint(WITH->UU.U10.p1->UU.i ^ WITH->UU.U10.p2->UU.i, &V); + else if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == 0) + collapsehalf(WITH->UU.U10.p2, WITH->UU.U10.p1, &V); + else if ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 0) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_lsh: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint(WITH->UU.U10.p1->UU.i << WITH->UU.U10.p2->UU.i, &V); + else if (((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == 0) || + ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 0)) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_rsh: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic && (ne_opkind)WITH->UU.U10.p2->op == ne_ic) + collapseint(WITH->UU.U10.p1->UU.i >> WITH->UU.U10.p2->UU.i, &V); + else if (((ne_opkind)WITH->UU.U10.p1->op == ne_ic && WITH->UU.U10.p1->UU.i == 0) || + ((ne_opkind)WITH->UU.U10.p2->op == ne_ic && WITH->UU.U10.p2->UU.i == 0)) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_lnot: + optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); + if (istrue(WITH->UU.U10.p1, &V)) + collapseint(0L, &V); + else if (isfalse(WITH->UU.U10.p1, &V)) + collapseint(1L, &V); + break; + + case ne_iand: + optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); + if (istrue(WITH->UU.U10.p1, &V)) + collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); + else if (isfalse(WITH->UU.U10.p1, &V)) + collapseint(0L, &V); + break; + + case ne_ior: + optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); + if (isfalse(WITH->UU.U10.p1, &V)) + collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); + else if (istrue(WITH->UU.U10.p1, &V)) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_rand: + optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); + if (istrue(WITH->UU.U10.p1, &V)) + collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); + else if (isfalse(WITH->UU.U10.p1, &V)) + collapsereal(0.0, &V); + break; + + case ne_ror: + optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); + if (isfalse(WITH->UU.U10.p1, &V)) + collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); + else if (istrue(WITH->UU.U10.p1, &V)) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_rxor: + optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); + if ((ne_opkind)WITH->UU.U10.p1->op == ne_error && (ne_errorkind)WITH->UU.U10.p1->UU.err == ne_badval) + collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); + else if (istrue(WITH->UU.U10.p1, &V)) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_sand: + optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); + if (istrue(WITH->UU.U10.p1, &V)) + collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); + else if (isfalse(WITH->UU.U10.p1, &V)) + collapsestr("", &V); + break; + + case ne_sor: + optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); + if (isfalse(WITH->UU.U10.p1, &V)) + collapsehalf(opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p1, &V); + else if (istrue(WITH->UU.U10.p1, &V)) + collapsehalf(WITH->UU.U10.p1, WITH->UU.U10.p2, &V); + break; + + case ne_icond: + case ne_rcond: + case ne_scond: + optimize(&WITH->UU.U10.p1, LINK->desc, LINK->which, LINK->mode); + if (isfalse(WITH->UU.U10.p1, &V)) + collapsecond(WITH->UU.U10.p1, opt(&WITH->UU.U10.p3, LINK), WITH->UU.U10.p2, &V); + else if (istrue(WITH->UU.U10.p1, &V)) + collapsecond(WITH->UU.U10.p1, opt(&WITH->UU.U10.p2, LINK), WITH->UU.U10.p3, &V); + break; + + case ne_round: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapseint((long)floor(WITH->UU.U10.p1->UU.r + 0.5), &V); + break; + + case ne_trunc: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapseint((long)WITH->UU.U10.p1->UU.r, &V); + break; + + case ne_ln: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapsereal(log(WITH->UU.U10.p1->UU.r), &V); + break; + + case ne_exp: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapsereal(exp(WITH->UU.U10.p1->UU.r), &V); + break; + + case ne_iabs: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_ic) + collapseint(labs(WITH->UU.U10.p1->UU.i), &V); + break; + + case ne_rabs: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapsereal(fabs(WITH->UU.U10.p1->UU.r), &V); + break; + + case ne_sqrt: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapsereal(sqrt(WITH->UU.U10.p1->UU.r), &V); + break; + + case ne_sin: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapsereal(sin(WITH->UU.U10.p1->UU.r), &V); + break; + + case ne_cos: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapsereal(cos(WITH->UU.U10.p1->UU.r), &V); + break; + + case ne_tan: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapsereal(tan(WITH->UU.U10.p1->UU.r), &V); + break; + + case ne_arctan: + if ((ne_opkind)WITH->UU.U10.p1->op == ne_rc) + collapsereal(atan(WITH->UU.U10.p1->UU.r), &V); + break; + + default: + break; + } + return (*V.nex); +} + + +static void optimize(ne_nexrec **nex, ne_desc *desc_, na_strlist_t *which_, long mode_) +{ + struct LOC_optimize V; + + V.desc = desc_; + V.which = which_; + V.mode = mode_; + V.err = ne_noerror; + TRY(try1); + *nex = opt(nex, &V); + RECOVER(try1); + if (P_escapecode == -20) + _Escape(P_escapecode); + if (V.err == ne_noerror) + { + switch (P_escapecode) + { + case -5: + V.err = ne_divzero; + break; + + case -7: + V.err = ne_underflow; + break; + + default: + V.err = ne_overflow; + break; + } + } + ne_dispose(nex); + *nex = ne_makeerror(V.err); + ENDTRY(try1); + if ((ne_opkind)(*nex)->op == ne_error) + V.desc->error = (unsigned)((ne_errorkind)(*nex)->UU.err); + else + V.desc->error = (unsigned)ne_noerror; } - - -void ne_constant(nex, desc, which_) -ne_nexrec **nex; -ne_desc *desc; -char *which_; +void ne_constant(ne_nexrec **nex, ne_desc *desc, char *which_) { - char which[256]; - na_strlist_t *l1, *l2; - char buf[256]; - - strcpy(which, which_); - if (!desc->casesens) - strupper(which, which); - l1 = NULL; - do { - strword(which, buf); - if (*buf != '\0') - l2 = strlist_add(&l1, buf); - } while (*which != '\0'); - optimize(nex, desc, l1, 1L); - strlist_empty(&l1); + char which[256]; + na_strlist_t *l1, *l2; + char buf[256]; + + strcpy(which, which_); + if (!desc->casesens) + strupper(which, which); + l1 = NULL; + do { + strword(which, buf); + if (*buf != '\0') + l2 = strlist_add(&l1, buf); + } while (*which != '\0'); + optimize(nex, desc, l1, 1L); + strlist_empty(&l1); } - -void ne_notconstant(nex, desc, which_) -ne_nexrec **nex; -ne_desc *desc; -char *which_; +void ne_notconstant(ne_nexrec **nex, ne_desc *desc, char *which_) { - char which[256]; - na_strlist_t *l1, *l2; - char buf[256]; - - strcpy(which, which_); - if (!desc->casesens) - strupper(which, which); - l1 = NULL; - do { - strword(which, buf); - if (*buf != '\0') - l2 = strlist_add(&l1, buf); - } while (*which != '\0'); - optimize(nex, desc, l1, 2L); - strlist_empty(&l1); + char which[256]; + na_strlist_t *l1, *l2; + char buf[256]; + + strcpy(which, which_); + if (!desc->casesens) + strupper(which, which); + l1 = NULL; + do { + strword(which, buf); + if (*buf != '\0') + l2 = strlist_add(&l1, buf); + } while (*which != '\0'); + optimize(nex, desc, l1, 2L); + strlist_empty(&l1); } - -void ne_constantlist(nex, desc, which) -ne_nexrec **nex; -ne_desc *desc; -na_strlist_t *which; +void ne_constantlist(ne_nexrec **nex, ne_desc *desc, na_strlist_t *which) { - optimize(nex, desc, which, 1L); + optimize(nex, desc, which, 1L); } - - -void ne_notconstantlist(nex, desc, which) -ne_nexrec **nex; -ne_desc *desc; -na_strlist_t *which; +void ne_notconstantlist(ne_nexrec **nex, ne_desc *desc, na_strlist_t *which) { - optimize(nex, desc, which, 2L); + optimize(nex, desc, which, 2L); } - - -static ne_nexrec *make2(op, nex, nex2) -ne_opkind op; -ne_nexrec *nex, *nex2; +static ne_nexrec *make2(ne_opkind op, ne_nexrec *nex, ne_nexrec *nex2) { - ne_nexrec *n; - - newnexrec(&n, (long)((nex != NULL) + (nex2 != NULL)), op); - if (nex != NULL) - n->UU.U10.p1 = nex; - if (nex2 != NULL) - n->UU.U10.p2 = nex2; - return n; + ne_nexrec *n; + + newnexrec(&n, (long)((nex != NULL) + (nex2 != NULL)), op); + n->UU.U10.p1 = nex; + n->UU.U10.p2 = nex2; + return n; } - -static ne_nexrec *make3(op, nex, nex2, nex3) -ne_opkind op; -ne_nexrec *nex, *nex2, *nex3; +static ne_nexrec *make3(ne_opkind op, ne_nexrec *nex, ne_nexrec *nex2, ne_nexrec *nex3) { - ne_nexrec *n; - - newnexrec(&n, 3L, op); - n->UU.U10.p1 = nex; - n->UU.U10.p2 = nex2; - n->UU.U10.p3 = nex3; + ne_nexrec *n; + + newnexrec(&n, 3L, op); + n->UU.U10.p1 = nex; + n->UU.U10.p2 = nex2; + n->UU.U10.p3 = nex3; return n; } - -ne_nexrec *ne_typecast(nex, typ) -ne_nexrec *nex; -ne_datatype typ; -{ - switch (typ) { - - case ne_notype: - ne_dispose(&nex); - nex = ne_makeerror(ne_badtypes); - break; - - case ne_integer: - if (realp(nex)) - nex = make2(ne_round, nex, NULL); - else if (!integerp(nex)) { - ne_dispose(&nex); - nex = ne_makeerror(ne_badtypes); - } - break; - - case ne_real: - if (integerp(nex)) - nex = make2(ne_itor, nex, NULL); - else if (!realp(nex)) { - ne_dispose(&nex); - nex = ne_makeerror(ne_badtypes); - } - break; - - case ne_string: - if (!stringp(nex)) { - ne_dispose(&nex); - nex = ne_makeerror(ne_badtypes); - } - break; - - case ne_boolean: - if (realp(nex)) - nex = make2(ne_rbool, nex, NULL); - else if (stringp(nex)) - nex = make2(ne_sbool, nex, NULL); - break; - } - return nex; +ne_nexrec *ne_typecast(ne_nexrec *nex, ne_datatype typ) +{ + switch (typ) + { + + case ne_notype: + ne_dispose(&nex); + nex = ne_makeerror(ne_badtypes); + break; + + case ne_integer: + if (realp(nex)) + { + nex = make2(ne_round, nex, NULL); + } + else if (!integerp(nex)) + { + ne_dispose(&nex); + nex = ne_makeerror(ne_badtypes); + } + break; + + case ne_real: + if (integerp(nex)) + { + nex = make2(ne_itor, nex, NULL); + } + else if (!realp(nex)) + { + ne_dispose(&nex); + nex = ne_makeerror(ne_badtypes); + } + break; + + case ne_string: + if (!stringp(nex)) + { + ne_dispose(&nex); + nex = ne_makeerror(ne_badtypes); + } + break; + + case ne_boolean: + if (realp(nex)) + nex = make2(ne_rbool, nex, NULL); + else if (stringp(nex)) + nex = make2(ne_sbool, nex, NULL); + break; + } + return nex; } /* Local variables for ne_intcompile: */ -struct LOC_ne_intcompile { +struct LOC_ne_intcompile +{ char *ex; ne_desc *desc; long p; @@ -1520,2158 +1348,2065 @@ struct LOC_ne_intcompile { static ne_nexrec *expr (long prec, struct LOC_ne_intcompile *LINK); -static void seterror(errk, LINK) -ne_errorkind errk; -struct LOC_ne_intcompile *LINK; +static void seterror(ne_errorkind errk, struct LOC_ne_intcompile *LINK) { - if ((ne_errorkind)LINK->desc->error == ne_noerror) - LINK->desc->error = (unsigned)errk; - LINK->p = 0; - while (LINK->ex[LINK->p - 1] != '\0') - LINK->p++; + if ((ne_errorkind)LINK->desc->error == ne_noerror) + LINK->desc->error = (unsigned)errk; + LINK->p = 0; + while (LINK->ex[LINK->p - 1] != '\0') + LINK->p++; } -static void error_(errk, nex1, nex2, LINK) -ne_errorkind errk; -ne_nexrec **nex1, *nex2; -struct LOC_ne_intcompile *LINK; +static void error_(ne_errorkind errk, ne_nexrec **nex1, ne_nexrec *nex2, struct LOC_ne_intcompile *LINK) { - ne_dispose(nex1); - ne_dispose(&nex2); - seterror(errk, LINK); + ne_dispose(nex1); + ne_dispose(&nex2); + seterror(errk, LINK); } -static char skipspc(LINK) -struct LOC_ne_intcompile *LINK; +static char skipspc(struct LOC_ne_intcompile *LINK) { - while (LINK->ex[LINK->p - 1] == ' ') - LINK->p++; - return (LINK->ex[LINK->p - 1]); + while (LINK->ex[LINK->p - 1] == ' ') + LINK->p++; + return (LINK->ex[LINK->p - 1]); } /* Local variables for expr: */ -struct LOC_expr { - struct LOC_ne_intcompile *LINK; +struct LOC_expr +{ + struct LOC_ne_intcompile *LINK; } ; -static ne_nexrec *parexp(LINK) -struct LOC_expr *LINK; -{ - ne_nexrec *nex; - char ch, ch2; - - nex = NULL; - ch = skipspc(LINK->LINK); - if (ch != '(' && ch != '[') { - error_(ne_syntax, &nex, NULL, LINK->LINK); - return nex; - } - LINK->LINK->p++; - nex = expr(0L, LINK->LINK); - ch2 = skipspc(LINK->LINK); - if ((ch == '(' && ch2 == ')') || (ch == '[' && ch2 == ']')) - LINK->LINK->p++; - else - error_(ne_syntax, &nex, NULL, LINK->LINK); - return nex; -} - -static ne_nexrec *factor(LINK) -struct LOC_expr *LINK; -{ - char ch, ch2, kind; - char name[256]; - ne_nexrec *nex; - ne_nexrec **args; - ne_datatype atype; - na_long value; - na_strlist_t *l1; - double *rp; - ne_functionrec *fp; - long i, p0; - double r; - int done; - char TEMP; - long FORLIM; - int allocdone; /* flag for deallocation */ - void* tryalloc; - - nex = NULL; - allocdone = 0; - ch = skipspc(LINK->LINK); - if (P_inset(ch, LINK->LINK->desc->startident)) { - *name = '\0'; - while (P_inset(LINK->LINK->ex[LINK->LINK->p - 1], LINK->LINK->desc->ident) || - P_inset(LINK->LINK->ex[LINK->LINK->p - 1], - LINK->LINK->desc->startident)) { - sprintf(name + strlen(name), "%c", LINK->LINK->ex[LINK->LINK->p - 1]); - LINK->LINK->p++; - } - if (!LINK->LINK->desc->casesens) - strupper(name, name); - ch = skipspc(LINK->LINK); - LINK->LINK->desc->isfunc = (ch == '[' || ch == '('); - kind = ' '; - l1 = NULL; - if (LINK->LINK->desc->symproc.link != NULL) - (*(void(*) (char *name, ne_desc *desc, na_strlist_t **symptr, - void* _link))LINK->LINK->desc->symproc.proc)(name, - LINK->LINK->desc, &l1, LINK->LINK->desc->symproc.link); - else - (*(void(*) (char *name, ne_desc *desc, na_strlist_t **symptr)) - LINK->LINK->desc->symproc.proc)(name, LINK->LINK->desc, &l1); - if (l1 != NULL) { - kind = l1->kind; - value = l1->value; - } else { - kind = 255; -/* p2c: numex.text, line 1448: Note: character >= 128 encountered [281] */ - } - switch (kind) { - - case ne_kind_intconst: - nex = make2(ne_ic, NULL, NULL); - nex->UU.i = (long)value; - break; - - case ne_kind_intvalue: - nex = make2(ne_ip, NULL, NULL); - nex->UU.U10.ip = (long*)(&l1->value); - nex->UU.U10.ips = l1; - break; - - case ne_kind_intptr: - nex = make2(ne_ip, NULL, NULL); - nex->UU.U10.ip = (long *)value; - nex->UU.U10.ips = l1; - break; - - case ne_kind_realconst: - nex = make2(ne_rc, NULL, NULL); - rp = (double *)value; - nex->UU.r = *rp; - break; - - case ne_kind_srealconst: - nex = make2(ne_rc, NULL, NULL); - nex->UU.r = na_srtor(value); - break; - - case ne_kind_realptr: - nex = make2(ne_rp, NULL, NULL); - nex->UU.U11.rp = (double *)value; - nex->UU.U11.rps = l1; - break; - - case ne_kind_realxptr: - nex = make2(ne_rxp, NULL, NULL); - nex->UU.U11.rp = (double *)value; - nex->UU.U11.rps = l1; - break; - - case ne_kind_strconst: - nex = make2(ne_sc, NULL, NULL); - nex->UU.s = (char *)strdup((char *)value); - break; - - case ne_kind_strvalue: - nex = make2(ne_sp, NULL, NULL); - nex->UU.U12.sp = (char **)(&l1->value); - nex->UU.U12.sps = l1; - break; - - case ne_kind_strptr: - nex = make2(ne_sp, NULL, NULL); - nex->UU.U12.sp = (char **)value; - nex->UU.U12.sps = l1; - break; - - case ne_kind_intfunc: - case ne_kind_realfunc: - case ne_kind_strfunc: - fp = (ne_functionrec *)value; -/* p2c: numex.text, line 1510: Note: Call to NA_ALLOC [501] */ - tryalloc = (void* *)(&args); /*G. Liu + */ - /* na_alloc(&args, fp->maxargs * sizeof(ne_nexrec *));*/ - na_alloc(tryalloc,fp->maxargs *sizeof(ne_nexrec *)); /* G. Liu + */ - allocdone = 1; - i = 0; - if (ch == '[' || ch == '(') { - LINK->LINK->p++; - TEMP = skipspc(LINK->LINK); - if (!(TEMP == ']' || TEMP == ')')) { - done = false; - while (!done && i < fp->maxargs) { - i++; - if (fp->nargs > 0) { - atype = fp->UU.U99.ptypes[P_imin2(i, (long)fp->nargs) - 1]; - args[i - 1] = ne_typecast(expr(0L, LINK->LINK), atype); - } else if (fp->subnex) - args[i - 1] = ne_typecast(expr(0L, LINK->LINK), ne_real); - else - args[i - 1] = expr(0L, LINK->LINK); - if ((ne_opkind)args[i - 1]->op == ne_error) - error_((ne_errorkind)args[i - 1]->UU.err, &args[i - 1], NULL, - LINK->LINK); - if (skipspc(LINK->LINK) == ',') - LINK->LINK->p++; - else - done = true; - } - if (!done) - seterror(ne_syntax, LINK->LINK); +static ne_nexrec *parexp(struct LOC_expr *LINK) +{ + ne_nexrec *nex; + char ch, ch2; + + nex = NULL; + ch = skipspc(LINK->LINK); + if (ch != '(' && ch != '[') { + error_(ne_syntax, &nex, NULL, LINK->LINK); + return nex; } + LINK->LINK->p++; + nex = expr(0L, LINK->LINK); ch2 = skipspc(LINK->LINK); if ((ch == '(' && ch2 == ')') || (ch == '[' && ch2 == ']')) - LINK->LINK->p++; + LINK->LINK->p++; else - seterror(ne_syntax, LINK->LINK); - } - if (i < fp->minargs) - seterror(ne_syntax, LINK->LINK); - if ((ne_errorkind)LINK->LINK->desc->error == ne_noerror) { - switch (kind) { - - case ne_kind_intfunc: - newnexrec(&nex, i, ne_if); - break; - - case ne_kind_realfunc: - newnexrec(&nex, i, ne_rf); - break; - - case ne_kind_strfunc: - newnexrec(&nex, i, ne_sf); - break; + error_(ne_syntax, &nex, NULL, LINK->LINK); + return nex; +} + +static ne_nexrec *factor(struct LOC_expr *LINK) +{ + char ch, ch2, kind; + char name[256]; + ne_nexrec *nex; + ne_nexrec **args; + ne_datatype atype; + na_long value; + na_strlist_t *l1; + double *rp; + ne_functionrec *fp; + long i, p0; + double r; + int done; + char TEMP; + long FORLIM; + int allocdone; /* flag for deallocation */ + void* tryalloc; + + nex = NULL; + allocdone = 0; + ch = skipspc(LINK->LINK); + if (P_inset(ch, LINK->LINK->desc->startident)) + { + *name = '\0'; + while (P_inset(LINK->LINK->ex[LINK->LINK->p - 1], LINK->LINK->desc->ident) || + P_inset(LINK->LINK->ex[LINK->LINK->p - 1], LINK->LINK->desc->startident)) + { + sprintf(name + strlen(name), "%c", LINK->LINK->ex[LINK->LINK->p - 1]); + LINK->LINK->p++; + } + if (!LINK->LINK->desc->casesens) + strupper(name, name); + ch = skipspc(LINK->LINK); + LINK->LINK->desc->isfunc = (ch == '[' || ch == '('); + kind = ' '; + l1 = NULL; + if (LINK->LINK->desc->symproc.link != NULL) + (*(void(*) (char *name, ne_desc *desc, na_strlist_t **symptr, void* _link))LINK->LINK->desc->symproc.proc)(name, + LINK->LINK->desc, &l1, LINK->LINK->desc->symproc.link); + else + (*(void(*) (char *name, ne_desc *desc, na_strlist_t **symptr)) LINK->LINK->desc->symproc.proc)(name, LINK->LINK->desc, &l1); + if (l1 != NULL) + { + kind = l1->kind; + value = l1->value; + } else { + kind = 255; + } + switch (kind) + { + + case ne_kind_intconst: + nex = make2(ne_ic, NULL, NULL); + nex->UU.i = (long)value; + break; + + case ne_kind_intvalue: + nex = make2(ne_ip, NULL, NULL); + nex->UU.U10.ip = (long*)(&l1->value); + nex->UU.U10.ips = l1; + break; + + case ne_kind_intptr: + nex = make2(ne_ip, NULL, NULL); + nex->UU.U10.ip = (long *)value; + nex->UU.U10.ips = l1; + break; + + case ne_kind_realconst: + nex = make2(ne_rc, NULL, NULL); + rp = (double *)value; + nex->UU.r = *rp; + break; + + case ne_kind_srealconst: + nex = make2(ne_rc, NULL, NULL); + nex->UU.r = na_srtor(value); + break; + + case ne_kind_realptr: + nex = make2(ne_rp, NULL, NULL); + nex->UU.U11.rp = (double *)value; + nex->UU.U11.rps = l1; + break; + + case ne_kind_realxptr: + nex = make2(ne_rxp, NULL, NULL); + nex->UU.U11.rp = (double *)value; + nex->UU.U11.rps = l1; + break; + + case ne_kind_strconst: + nex = make2(ne_sc, NULL, NULL); + nex->UU.s = (char *)strdup((char *)value); + break; + + case ne_kind_strvalue: + nex = make2(ne_sp, NULL, NULL); + nex->UU.U12.sp = (char **)(&l1->value); + nex->UU.U12.sps = l1; + break; + + case ne_kind_strptr: + nex = make2(ne_sp, NULL, NULL); + nex->UU.U12.sp = (char **)value; + nex->UU.U12.sps = l1; + break; + + case ne_kind_intfunc: + case ne_kind_realfunc: + case ne_kind_strfunc: + fp = (ne_functionrec *)value; + tryalloc = (void* *)(&args); /*G. Liu + */ + na_alloc(tryalloc,fp->maxargs *sizeof(ne_nexrec *)); /* G. Liu + */ + allocdone = 1; + i = 0; + if (ch == '[' || ch == '(') { + LINK->LINK->p++; + TEMP = skipspc(LINK->LINK); + if (!(TEMP == ']' || TEMP == ')')) + { + done = false; + while (!done && i < fp->maxargs) + { + i++; + if (fp->nargs > 0) + { + atype = fp->UU.U99.ptypes[P_imin2(i, (long)fp->nargs) - 1]; + args[i - 1] = ne_typecast(expr(0L, LINK->LINK), atype); + } + else if (fp->subnex) + { + args[i - 1] = ne_typecast(expr(0L, LINK->LINK), ne_real); + } + else + { + args[i - 1] = expr(0L, LINK->LINK); + } + + if ((ne_opkind)args[i - 1]->op == ne_error) + error_((ne_errorkind)args[i - 1]->UU.err, &args[i - 1], NULL, LINK->LINK); + + if (skipspc(LINK->LINK) == ',') + LINK->LINK->p++; + else + done = true; + } + if (!done) + seterror(ne_syntax, LINK->LINK); + } + ch2 = skipspc(LINK->LINK); + if ((ch == '(' && ch2 == ')') || (ch == '[' && ch2 == ']')) + LINK->LINK->p++; + else + seterror(ne_syntax, LINK->LINK); + } + if (i < fp->minargs) + seterror(ne_syntax, LINK->LINK); + if ((ne_errorkind)LINK->LINK->desc->error == ne_noerror) + { + switch (kind) + { + + case ne_kind_intfunc: + newnexrec(&nex, i, ne_if); + break; + + case ne_kind_realfunc: + newnexrec(&nex, i, ne_rf); + break; + + case ne_kind_strfunc: + newnexrec(&nex, i, ne_sf); + break; + } + FORLIM = nex->nargs; + for (i = 0; i < FORLIM; i++) + nex->UU.U99.pvals[i] = args[i]; + nex->UU.U15.fp = fp; + nex->UU.U15.fps = l1; + } + break; + + case ne_kind_intarg: + nex = make2(ne_iarg, NULL, NULL); + nex->UU.i = (long)value; + break; + + case ne_kind_realarg: + nex = make2(ne_rarg, NULL, NULL); + nex->UU.i = (long)value; + break; + + case ne_kind_strarg: + nex = make2(ne_sarg, NULL, NULL); + nex->UU.i = (long)value; + break; + + case ne_kind_nex: + if (value == NULL) + error_(ne_undef, &nex, NULL, LINK->LINK); + else + ne_copy((ne_nexrec *)value, &nex); + break; + + default: + if (LINK->LINK->desc->builtin) + { + i = numbuiltins; + while (i >= 1 && strcmp(builtins[i - 1].name, name)) + i--; + } else + i = 0; + if (i >= 1) + { + switch (builtins[i - 1].kind) + { + + case 'A': + nex = parexp(LINK); + if (realp(nex)) + nex = make2(builtins[i - 1].op, nex, NULL); + else if (!integerp(nex)) + error_(ne_badtypes, &nex, NULL, LINK->LINK); + break; + + case 'B': + nex = ne_typecast(parexp(LINK), ne_real); + if ((ne_opkind)nex->op == ne_error) + error_((ne_errorkind)nex->UU.err, &nex, NULL, LINK->LINK); + nex = make2(builtins[i - 1].op, nex, NULL); + break; + + case 'C': + nex = parexp(LINK); + if (integerp(nex)) + nex = make2(builtins[i - 1].op, nex, NULL); + else if (realp(nex)) + nex = make2((ne_opkind)((long)builtins[i - 1].op + 1), nex, NULL); + else + error_(ne_badtypes, &nex, NULL, LINK->LINK); + break; + + case 'P': + nex = make2(ne_rc, NULL, NULL); + nex->UU.r = 3.1415926536; + break; + } + } else + error_(ne_undef, &nex, NULL, LINK->LINK); + break; + } + if (allocdone) + na_free((void*)&args); + return nex; } - FORLIM = nex->nargs; - for (i = 0; i < FORLIM; i++) - nex->UU.U99.pvals[i] = args[i]; - nex->UU.U15.fp = fp; - nex->UU.U15.fps = l1; - } - break; - - case ne_kind_intarg: - nex = make2(ne_iarg, NULL, NULL); - nex->UU.i = (long)value; - break; - - case ne_kind_realarg: - nex = make2(ne_rarg, NULL, NULL); - nex->UU.i = (long)value; - break; - - case ne_kind_strarg: - nex = make2(ne_sarg, NULL, NULL); - nex->UU.i = (long)value; - break; - - case ne_kind_nex: - if (value == NULL) - error_(ne_undef, &nex, NULL, LINK->LINK); - else - ne_copy((ne_nexrec *)value, &nex); - break; - - default: - if (LINK->LINK->desc->builtin) { - i = numbuiltins; - while (i >= 1 && strcmp(builtins[i - 1].name, name)) - i--; - } else + + if (ch == '+') + { + LINK->LINK->p++; + nex = expr((long)neg_prec, LINK->LINK); + if (allocdone) + na_free((void*)&args); + return nex; + } + + if (ch == '-') + { + LINK->LINK->p++; + nex = expr((long)neg_prec, LINK->LINK); + if (realp(nex)) { + nex = make2(ne_rneg, nex, NULL); + if (allocdone) + na_free((void*)&args); + return nex; + } + if (integerp(nex)) + nex = make2(ne_ineg, nex, NULL); + else + error_(ne_badtypes, &nex, NULL, LINK->LINK); + if (allocdone) + na_free((void*)&args); + return nex; + } + + if (ch == '!') + { + LINK->LINK->p++; + nex = ne_typecast(expr((long)lnot_prec, LINK->LINK), ne_boolean); + nex = make2(ne_lnot, nex, NULL); + if (allocdone) + na_free((void*)&args); + return nex; + } + + if (ch == '~') + { + LINK->LINK->p++; + nex = expr((long)not_prec, LINK->LINK); + if (realp(nex)) + nex = make2(ne_round, nex, NULL); + if (integerp(nex)) + nex = make2(ne_not, nex, NULL); + else + error_(ne_badtypes, &nex, NULL, LINK->LINK); + if (allocdone) + na_free((void*)&args); + return nex; + } + + if (ch == '#' || ch == '\'' || ch == '"') + { + *name = '\0'; + done = false; + do + { + ch = skipspc(LINK->LINK); + if (ch == '#') + { + ch = toupper(LINK->LINK->ex[LINK->LINK->p]); + if (ch >= '@' && ch <= '_') + { + sprintf(name + strlen(name), "%c", ch - 64); + LINK->LINK->p += 2; + } + else if (isdigit(ch)) + { + i = 0; + LINK->LINK->p++; + while (isdigit(LINK->LINK->ex[LINK->LINK->p - 1])) + { + i = i * 10 + LINK->LINK->ex[LINK->LINK->p - 1] - 48; + LINK->LINK->p++; + } + sprintf(name + strlen(name), "%c", (char)(i & 255)); + } + else + { + done = true; + } + } + else if (ch == '\'' || ch == '"') + { + done = false; + do + { + LINK->LINK->p++; + if (LINK->LINK->ex[LINK->LINK->p - 1] == ch) + { + if (LINK->LINK->ex[LINK->LINK->p] == ch) + { + sprintf(name + strlen(name), "%c", ch); + LINK->LINK->p++; + } + else + { + done = true; + } + } + else if (LINK->LINK->ex[LINK->LINK->p - 1] == '\0') + { + done = true; + } + else + { + sprintf(name + strlen(name), "%c", LINK->LINK->ex[LINK->LINK->p - 1]); + } + } while (!done); + if (LINK->LINK->ex[LINK->LINK->p - 1] == ch) + LINK->LINK->p++; + done = false; + } + else + { + done = true; + } + } while (!done); + nex = make2(ne_sc, nex, NULL); + nex->UU.s = (char *)strdup(name); + if (allocdone) + na_free((void*)&args); + return nex; + } + + if (ch == '[' || ch == '(') + { + nex = parexp(LINK); + if (allocdone) + na_free((void*)&args); + return nex; + } + + if (!(ch == '.' || isdigit(ch))) + { + error_(ne_syntax, &nex, NULL, LINK->LINK); + if (allocdone) + na_free((void*)&args); + return nex; + } + i = 0; - if (i >= 1) { - switch (builtins[i - 1].kind) { - - case 'A': - nex = parexp(LINK); - if (realp(nex)) - nex = make2(builtins[i - 1].op, nex, NULL); - else if (!integerp(nex)) - error_(ne_badtypes, &nex, NULL, LINK->LINK); - break; - - case 'B': - nex = ne_typecast(parexp(LINK), ne_real); - if ((ne_opkind)nex->op == ne_error) - error_((ne_errorkind)nex->UU.err, &nex, NULL, LINK->LINK); - nex = make2(builtins[i - 1].op, nex, NULL); - break; - - case 'C': - nex = parexp(LINK); - if (integerp(nex)) - nex = make2(builtins[i - 1].op, nex, NULL); - else if (realp(nex)) - nex = make2((ne_opkind)((long)builtins[i - 1].op + 1), nex, NULL); - else - error_(ne_badtypes, &nex, NULL, LINK->LINK); - break; - - case 'P': - nex = make2(ne_rc, NULL, NULL); - nex->UU.r = 3.1415926536; - break; + p0 = LINK->LINK->p; + while (isdigit(LINK->LINK->ex[LINK->LINK->p - 1]) && (i < 214748364L || + (i == 214748364L && LINK->LINK->ex[LINK->LINK->p - 1] >= '0' && + LINK->LINK->ex[LINK->LINK->p - 1] <= '7'))) + { + i = i * 10 + LINK->LINK->ex[LINK->LINK->p - 1] - '0'; + LINK->LINK->p++; } - } else - error_(ne_undef, &nex, NULL, LINK->LINK); - break; - } - if (allocdone) - na_free((void*)&args); - return nex; - } - if (ch == '+') { - LINK->LINK->p++; - nex = expr((long)neg_prec, LINK->LINK); - if (allocdone) - na_free((void*)&args); - return nex; - } - if (ch == '-') { - LINK->LINK->p++; - nex = expr((long)neg_prec, LINK->LINK); - if (realp(nex)) { - nex = make2(ne_rneg, nex, NULL); - if (allocdone) - na_free((void*)&args); - return nex; - } - if (integerp(nex)) - nex = make2(ne_ineg, nex, NULL); - else - error_(ne_badtypes, &nex, NULL, LINK->LINK); - if (allocdone) - na_free((void*)&args); - return nex; - } - if (ch == '!') { - LINK->LINK->p++; - nex = ne_typecast(expr((long)lnot_prec, LINK->LINK), ne_boolean); - nex = make2(ne_lnot, nex, NULL); - if (allocdone) - na_free((void*)&args); - return nex; - } - if (ch == '~') { - LINK->LINK->p++; - nex = expr((long)not_prec, LINK->LINK); - if (realp(nex)) - nex = make2(ne_round, nex, NULL); - if (integerp(nex)) - nex = make2(ne_not, nex, NULL); - else - error_(ne_badtypes, &nex, NULL, LINK->LINK); - if (allocdone) - na_free((void*)&args); - return nex; - } - if (ch == '#' || ch == '\'' || ch == '"') { - *name = '\0'; - done = false; - do { - ch = skipspc(LINK->LINK); - if (ch == '#') { - ch = toupper(LINK->LINK->ex[LINK->LINK->p]); - if (ch >= '@' && ch <= '_') { - sprintf(name + strlen(name), "%c", ch - 64); - LINK->LINK->p += 2; - } else if (isdigit(ch)) { - i = 0; - LINK->LINK->p++; - while (isdigit(LINK->LINK->ex[LINK->LINK->p - 1])) { - i = i * 10 + LINK->LINK->ex[LINK->LINK->p - 1] - 48; - LINK->LINK->p++; - } - sprintf(name + strlen(name), "%c", (char)(i & 255)); - } else - done = true; - } else if (ch == '\'' || ch == '"') { - done = false; - do { - LINK->LINK->p++; - if (LINK->LINK->ex[LINK->LINK->p - 1] == ch) { - if (LINK->LINK->ex[LINK->LINK->p] == ch) { - sprintf(name + strlen(name), "%c", ch); - LINK->LINK->p++; - } else - done = true; - } else if (LINK->LINK->ex[LINK->LINK->p - 1] == '\0') - done = true; - else - sprintf(name + strlen(name), "%c", - LINK->LINK->ex[LINK->LINK->p - 1]); - } while (!done); - if (LINK->LINK->ex[LINK->LINK->p - 1] == ch) - LINK->LINK->p++; - done = false; - } else - done = true; - } while (!done); - nex = make2(ne_sc, nex, NULL); - nex->UU.s = (char *)strdup(name); - if (allocdone) - na_free((void*)&args); - return nex; - } - if (ch == '[' || ch == '(') { - nex = parexp(LINK); - if (allocdone) - na_free((void*)&args); - return nex; - } - if (!(ch == '.' || isdigit(ch))) { - error_(ne_syntax, &nex, NULL, LINK->LINK); - if (allocdone) - na_free((void*)&args); - return nex; - } - i = 0; - p0 = LINK->LINK->p; - while (isdigit(LINK->LINK->ex[LINK->LINK->p - 1]) && (i < 214748364L || - (i == 214748364L && LINK->LINK->ex[LINK->LINK->p - 1] >= '0' && - LINK->LINK->ex[LINK->LINK->p - 1] <= '7'))) { - i = i * 10 + LINK->LINK->ex[LINK->LINK->p - 1] - '0'; - LINK->LINK->p++; - } - TEMP = skipspc(LINK->LINK); - if (!(TEMP == '.' || isalnum(TEMP))) { - nex = make2(ne_ic, NULL, NULL); - nex->UU.i = i; - if (allocdone) - na_free((void*)&args); - return nex; - } - LINK->LINK->p = p0; - if (readreal(LINK->LINK->ex, &LINK->LINK->p, &r, LINK->LINK->desc)) { - nex = make2(ne_rc, NULL, NULL); - nex->UU.r = r; - } else - error_(ne_syntax, &nex, NULL, LINK->LINK); - if (allocdone) - na_free((void*)&args); - return nex; -} - -static ne_nexrec *expr(prec, LINK) -long prec; -struct LOC_ne_intcompile *LINK; -{ - struct LOC_expr V; - ne_nexrec *nex, *nex2, *nex3; - char ch; - long opn, dp; - - V.LINK = LINK; - nex = factor(&V); - do { - ch = skipspc(LINK); - dp = 1; - if (ch == '=' && LINK->ex[LINK->p] == '=') - dp = 2; - else if (ch == '!' && LINK->ex[LINK->p] == '=') { - ch = '\001'; /*ne*/ - dp = 2; - } else if (ch == '<') { - if (LINK->ex[LINK->p] == '>') { - ch = '\001'; /*ne*/ - dp = 2; - } else if (LINK->ex[LINK->p] == '=') { - ch = '\002'; /*le*/ - dp = 2; - } else if (LINK->ex[LINK->p] == '<') { - ch = '\006'; /*lsh*/ - dp = 2; - } - } else if (ch == '>') { - if (LINK->ex[LINK->p] == '=') { - ch = '\003'; /*ge*/ - dp = 2; - } else if (LINK->ex[LINK->p] == '>') { - ch = '\007'; /*rsh*/ - dp = 2; - } - } else if (ch == '&' && LINK->ex[LINK->p] == '&') { - ch = '\004'; /*log. and*/ - dp = 2; - } else if (ch == '|' && LINK->ex[LINK->p] == '|') { - ch = '\005'; /*log. or*/ - dp = 2; - } else if (ch == '!' && LINK->ex[LINK->p] == '!') { - ch = '\b'; /*log. X-checking or*/ - dp = 2; - } - opn = numopersyms; - while (opn >= 1 && opers[opn - 1].name != ch) - opn--; - if (opn >= 1 && opers[opn - 1].lprec > prec) { - if (ch == '?') { - LINK->p++; - nex = ne_typecast(nex, ne_boolean); - nex2 = expr(0L, LINK); - if (skipspc(LINK) == ':') { - LINK->p++; - nex3 = expr((long)opers[opn - 1].rprec, LINK); - if (stringp(nex2) && stringp(nex3)) - nex = make3(ne_scond, nex, nex2, nex3); - else if (!stringp(nex2) && !stringp(nex3)) { - if (realp(nex2) || realp(nex3)) - nex = make3(ne_rcond, nex, ne_typecast(nex2, ne_real), - ne_typecast(nex3, ne_real)); - else - nex = make3(ne_icond, nex, nex2, nex3); - } else { - ne_dispose(&nex3); - error_(ne_badtypes, &nex, nex2, LINK); - } - } else - error_(ne_syntax, &nex, nex2, LINK); - } else { - LINK->p += dp; - nex2 = expr((long)opers[opn - 1].rprec, LINK); - if (stringp(nex) && stringp(nex2) && - (ne_opkind)opers[opn - 1].sop != ne_error) - nex = make2((ne_opkind)opers[opn - 1].sop, nex, nex2); - else if (stringp(nex) || stringp(nex2)) - error_(ne_badtypes, &nex, nex2, LINK); - else if (integerp(nex) && integerp(nex2) && - (ne_opkind)opers[opn - 1].iop != ne_error) - nex = make2((ne_opkind)opers[opn - 1].iop, nex, nex2); - else if ((ne_opkind)opers[opn - 1].rop != ne_error) { - if (integerp(nex)) - nex = make2(ne_itor, nex, NULL); - if (integerp(nex2)) - nex2 = make2(ne_itor, nex2, NULL); - nex = make2((ne_opkind)opers[opn - 1].rop, nex, nex2); - } else { - if (realp(nex)) - nex = make2(ne_round, nex, NULL); - if (realp(nex2)) - nex2 = make2(ne_round, nex2, NULL); - nex = make2((ne_opkind)opers[opn - 1].iop, nex, nex2); + TEMP = skipspc(LINK->LINK); + + if (!(TEMP == '.' || isalnum(TEMP))) + { + nex = make2(ne_ic, NULL, NULL); + nex->UU.i = i; + if (allocdone) + na_free((void*)&args); + return nex; + } + + LINK->LINK->p = p0; + if (readreal(LINK->LINK->ex, &LINK->LINK->p, &r, LINK->LINK->desc)) + { + nex = make2(ne_rc, NULL, NULL); + nex->UU.r = r; + } + else + { + error_(ne_syntax, &nex, NULL, LINK->LINK); } - } - } - } while (opn >= 1 && opers[opn - 1].lprec > prec); - return nex; -} - - - -void ne_intcompile(ex_, endp, nex, desc_) -char *ex_; -long *endp; -ne_nexrec **nex; -ne_desc *desc_; -{ - struct LOC_ne_intcompile V; - long startp; - - V.ex = ex_; - V.desc = desc_; - *nex = NULL; - V.desc->error = (unsigned)ne_noerror; - V.p = *endp; - startp = *endp; - *nex = expr(0L, &V); - if ((ne_errorkind)V.desc->error == ne_noerror) { - *endp = V.p; - return; - } - ne_dispose(nex); - *nex = ne_makeerror((ne_errorkind)V.desc->error); - *endp = startp; -} - - -void ne_compile(ex_, nex, desc) -char *ex_; -ne_nexrec **nex; -ne_desc *desc; -{ - char ex[256]; - long len, endp; - char STR1[256]; - - strcpy(ex, ex_); - if (strlen(ex) == 255) { - desc->error = (unsigned)ne_strlong; - *nex = ne_makeerror(ne_strlong); - return; - } - len = strlen(ex); -/* p2c: numex.text, line 1913: - * Note: Null character at end of sprintf control string [148] */ - strcpy(STR1, ex); - strcpy(ex, STR1); - endp = 1; - ne_intcompile(ex, &endp, nex, desc); - if (endp == len + 1) { - if ((ne_errorkind)desc->error == ne_noerror) - optimize(nex, desc, NULL, 0L); - return; - } - desc->error = (unsigned)ne_syntax; - ne_dispose(nex); - *nex = ne_makeerror(ne_syntax); + + if (allocdone) + { + na_free((void*)&args); + } + return nex; +} + +static ne_nexrec *expr(long prec, struct LOC_ne_intcompile *LINK) +{ + struct LOC_expr V; + ne_nexrec *nex, *nex2, *nex3; + char ch; + long opn, dp; + + V.LINK = LINK; + nex = factor(&V); + do + { + ch = skipspc(LINK); + dp = 1; + if (ch == '=' && LINK->ex[LINK->p] == '=') + { + dp = 2; + } + else if (ch == '!' && LINK->ex[LINK->p] == '=') + { + ch = '\001'; /*ne*/ + dp = 2; + } + else if (ch == '<') + { + if (LINK->ex[LINK->p] == '>') + { + ch = '\001'; /*ne*/ + dp = 2; + } + else if (LINK->ex[LINK->p] == '=') + { + ch = '\002'; /*le*/ + dp = 2; + } + else if (LINK->ex[LINK->p] == '<') + { + ch = '\006'; /*lsh*/ + dp = 2; + } + } + else if (ch == '>') + { + if (LINK->ex[LINK->p] == '=') + { + ch = '\003'; /*ge*/ + dp = 2; + } + else if (LINK->ex[LINK->p] == '>') + { + ch = '\007'; /*rsh*/ + dp = 2; + } + } + else if (ch == '&' && LINK->ex[LINK->p] == '&') + { + ch = '\004'; /*log. and*/ + dp = 2; + } + else if (ch == '|' && LINK->ex[LINK->p] == '|') + { + ch = '\005'; /*log. or*/ + dp = 2; + } + else if (ch == '!' && LINK->ex[LINK->p] == '!') + { + ch = '\b'; /*log. X-checking or*/ + dp = 2; + } + + opn = numopersyms; + while (opn >= 1 && opers[opn - 1].name != ch) + opn--; + + if (opn >= 1 && opers[opn - 1].lprec > prec) + { + if (ch == '?') + { + LINK->p++; + nex = ne_typecast(nex, ne_boolean); + nex2 = expr(0L, LINK); + if (skipspc(LINK) == ':') + { + LINK->p++; + nex3 = expr((long)opers[opn - 1].rprec, LINK); + if (stringp(nex2) && stringp(nex3)) + { + nex = make3(ne_scond, nex, nex2, nex3); + } + else if (!stringp(nex2) && !stringp(nex3)) + { + if (realp(nex2) || realp(nex3)) + nex = make3(ne_rcond, nex, ne_typecast(nex2, ne_real), ne_typecast(nex3, ne_real)); + else + nex = make3(ne_icond, nex, nex2, nex3); + } + else + { + ne_dispose(&nex3); + error_(ne_badtypes, &nex, nex2, LINK); + } + } + else + { + error_(ne_syntax, &nex, nex2, LINK); + } + } + else + { + LINK->p += dp; + nex2 = expr((long)opers[opn - 1].rprec, LINK); + if (stringp(nex) && stringp(nex2) && (ne_opkind)opers[opn - 1].sop != ne_error) + { + nex = make2((ne_opkind)opers[opn - 1].sop, nex, nex2); + } + else if (stringp(nex) || stringp(nex2)) + { + error_(ne_badtypes, &nex, nex2, LINK); + } + else if (integerp(nex) && integerp(nex2) && (ne_opkind)opers[opn - 1].iop != ne_error) + { + nex = make2((ne_opkind)opers[opn - 1].iop, nex, nex2); + } + else if ((ne_opkind)opers[opn - 1].rop != ne_error) + { + if (integerp(nex)) + nex = make2(ne_itor, nex, NULL); + if (integerp(nex2)) + nex2 = make2(ne_itor, nex2, NULL); + nex = make2((ne_opkind)opers[opn - 1].rop, nex, nex2); + } + else + { + if (realp(nex)) + nex = make2(ne_round, nex, NULL); + if (realp(nex2)) + nex2 = make2(ne_round, nex2, NULL); + nex = make2((ne_opkind)opers[opn - 1].iop, nex, nex2); + } + } + } + } while (opn >= 1 && opers[opn - 1].lprec > prec); + + return nex; +} + + +void ne_intcompile(char *ex_, long *endp, ne_nexrec **nex, ne_desc *desc_) +{ + struct LOC_ne_intcompile V; + long startp; + + V.ex = ex_; + V.desc = desc_; + *nex = NULL; + V.desc->error = (unsigned)ne_noerror; + V.p = *endp; + startp = *endp; + *nex = expr(0L, &V); + if ((ne_errorkind)V.desc->error == ne_noerror) + { + *endp = V.p; + return; + } + ne_dispose(nex); + *nex = ne_makeerror((ne_errorkind)V.desc->error); + *endp = startp; } +void ne_compile(char *ex_, ne_nexrec **nex, ne_desc *desc) +{ + char ex[256]; + long len, endp; + char STR1[256]; + + strcpy(ex, ex_); + if (strlen(ex) == 255) + { + desc->error = (unsigned)ne_strlong; + *nex = ne_makeerror(ne_strlong); + return; + } + len = strlen(ex); + strcpy(STR1, ex); + strcpy(ex, STR1); + endp = 1; + ne_intcompile(ex, &endp, nex, desc); + if (endp == len + 1) + { + if ((ne_errorkind)desc->error == ne_noerror) + optimize(nex, desc, NULL, 0L); + return; + } + desc->error = (unsigned)ne_syntax; + ne_dispose(nex); + *nex = ne_makeerror(ne_syntax); +} + /* Local variables for ne_uncompile: */ -struct LOC_ne_uncompile { - char *ex; - ne_desc *desc; - ne_opkind lastop; - char ch; - int flag; +struct LOC_ne_uncompile +{ + char *ex; + ne_desc *desc; + ne_opkind lastop; + char ch; + int flag; } ; -static void uncompile (ne_nexrec *nex, int prec, - struct LOC_ne_uncompile *LINK); +static void uncompile (ne_nexrec *nex, int prec, struct LOC_ne_uncompile *LINK); -static void append(s, LINK) -char *s; -struct LOC_ne_uncompile *LINK; +static void append(char *s, struct LOC_ne_uncompile *LINK) { - long i; - - i = strlen(LINK->ex) + strlen(s) - 255; -/* p2c: numex.text, line 1940: - * Note: STRMAX of "ex" wants VarStrings=1 [151] */ - if (i < 1) { - strcat(LINK->ex, s); - return; - } - if (i > 1) - sprintf(LINK->ex + strlen(LINK->ex), "%.*s", (int)(i - 1), s); - LINK->desc->error = (unsigned)ne_strlong; + long i; + + i = strlen(LINK->ex) + strlen(s) - 255; + if (i < 1) { + strcat(LINK->ex, s); + return; + } + if (i > 1) + sprintf(LINK->ex + strlen(LINK->ex), "%.*s", (int)(i - 1), s); + LINK->desc->error = (unsigned)ne_strlong; } -static void appendc(ch, LINK) -char ch; -struct LOC_ne_uncompile *LINK; +static void appendc(char ch, struct LOC_ne_uncompile *LINK) { - if (strlen(LINK->ex) < 255) - sprintf(LINK->ex + strlen(LINK->ex), "%c", ch); - else - LINK->desc->error = (unsigned)ne_strlong; -/* p2c: numex.text, line 1953: - * Note: STRMAX of "ex" wants VarStrings=1 [151] */ + if (strlen(LINK->ex) < 255) + sprintf(LINK->ex + strlen(LINK->ex), "%c", ch); + else + LINK->desc->error = (unsigned)ne_strlong; } -static void appenderrname(nex, LINK) -ne_nexrec *nex; -struct LOC_ne_uncompile *LINK; +static void appenderrname(ne_nexrec *nex, struct LOC_ne_uncompile *LINK) { - char buf[256]; - long i; - char STR1[256]; - - strcpy(buf, ne_errorkind_NAMES[nex->UU.err]); - i = strlen(buf) + 1; - buf[i - 1] = '\0'; -/* p2c: numex.text, line 1966: - * Note: Modification of string length may translate incorrectly [146] */ - strcpy_overlap(buf, buf + 3); - append(strlower(STR1, buf), LINK); + char buf[256]; + long i; + char STR1[256]; + + strcpy(buf, ne_errorkind_NAMES[nex->UU.err]); + i = strlen(buf) + 1; + buf[i - 1] = '\0'; + strcpy_overlap(buf, buf + 3); + append(strlower(STR1, buf), LINK); } /* Local variables for uncompile: */ -struct LOC_uncompile { - struct LOC_ne_uncompile *LINK; - ne_nexrec *nex; +struct LOC_uncompile +{ + struct LOC_ne_uncompile *LINK; + ne_nexrec *nex; } ; -static void args(LINK) -struct LOC_uncompile *LINK; -{ - long i1; - ne_nexrec *WITH; - long FORLIM; - - WITH = LINK->nex; - if (WITH->nargs == 0) - return; - appendc('(', LINK->LINK); - FORLIM = WITH->nargs; - for (i1 = 1; i1 <= FORLIM; i1++) { - if (i1 > 1) - appendc(',', LINK->LINK); - uncompile(WITH->UU.U99.pvals[WITH->UU.i - 1], 0, LINK->LINK); - } - appendc(')', LINK->LINK); -} - -static void func(name, LINK) -char *name; -struct LOC_uncompile *LINK; -{ - append(name, LINK->LINK); - args(LINK); -} - -static void uncompile(nex_, prec, LINK) -ne_nexrec *nex_; -short prec; -struct LOC_ne_uncompile *LINK; -{ - struct LOC_uncompile V; - ne_nexrec *nex2; - long j; - ne_nexrec *WITH; - char STR1[256]; - long FORLIM; - - V.LINK = LINK; - V.nex = nex_; - WITH = V.nex; - LINK->lastop = (ne_opkind)WITH->op; - switch ((ne_opkind)WITH->op) { - - case ne_error: - append("error(", LINK); - appenderrname(V.nex, LINK); - appendc(')', LINK); - break; - - case ne_ic: - if (LINK->desc->scaled) - append(realunit(STR1, (double)WITH->UU.i, LINK->desc->units), LINK); - else { - sprintf(STR1, "%ld", WITH->UU.i); - append(STR1, LINK); - } - break; - - case ne_rc: - if (LINK->desc->scaled) - append(realunit(STR1, WITH->UU.r, LINK->desc->units), LINK); - else { - sprintf(STR1, "%g", WITH->UU.r); - append(STR1, LINK); - } - break; - - case ne_sc: - if (*WITH->UU.s == '\0') - append("''", LINK); - else { - LINK->flag = false; - FORLIM = strlen(WITH->UU.s); - for (j = 0; j < FORLIM; j++) { - if (WITH->UU.s[j] < ' ' || WITH->UU.s[j] > '~') { - if (LINK->flag) - appendc('\'', LINK); - appendc('#', LINK); - sprintf(STR1, "%d", WITH->UU.s[j]); - append(STR1, LINK); - LINK->flag = false; - } else { - if (!LINK->flag) - appendc('\'', LINK); - appendc(WITH->UU.s[j], LINK); - if (WITH->UU.s[j] == '\'') - appendc('\'', LINK); - LINK->flag = true; +static void args(struct LOC_uncompile *LINK) +{ + long i1; + ne_nexrec *WITH; + long FORLIM; + + WITH = LINK->nex; + if (WITH->nargs == 0) + return; + appendc('(', LINK->LINK); + FORLIM = WITH->nargs; + for (i1 = 1; i1 <= FORLIM; i1++) { + if (i1 > 1) + appendc(',', LINK->LINK); + uncompile(WITH->UU.U99.pvals[WITH->UU.i - 1], 0, LINK->LINK); + } + appendc(')', LINK->LINK); +} + +static void func(char *name, struct LOC_uncompile *LINK) +{ + append(name, LINK->LINK); + args(LINK); +} + +static void uncompile(ne_nexrec *nex_, int prec, struct LOC_ne_uncompile *LINK) +{ + struct LOC_uncompile V; + ne_nexrec *nex2; + long j; + ne_nexrec *WITH; + char STR1[256]; + long FORLIM; + + V.LINK = LINK; + V.nex = nex_; + WITH = V.nex; + LINK->lastop = (ne_opkind)WITH->op; + switch ((ne_opkind)WITH->op) + { + + case ne_error: + append("error(", LINK); + appenderrname(V.nex, LINK); + appendc(')', LINK); + break; + + case ne_ic: + if (LINK->desc->scaled) + { + append(realunit(STR1, (double)WITH->UU.i, LINK->desc->units), LINK); + } + else + { + sprintf(STR1, "%ld", WITH->UU.i); + append(STR1, LINK); + } + break; + + case ne_rc: + if (LINK->desc->scaled) + { + append(realunit(STR1, WITH->UU.r, LINK->desc->units), LINK);} + else + { + sprintf(STR1, "%g", WITH->UU.r); + append(STR1, LINK); + } + break; + + case ne_sc: + if (*WITH->UU.s == '\0') + append("''", LINK); + else { + LINK->flag = false; + FORLIM = strlen(WITH->UU.s); + for (j = 0; j < FORLIM; j++) { + if (WITH->UU.s[j] < ' ' || WITH->UU.s[j] > '~') + { + if (LINK->flag) + appendc('\'', LINK); + appendc('#', LINK); + sprintf(STR1, "%d", WITH->UU.s[j]); + append(STR1, LINK); + LINK->flag = false; + } + else + { + if (!LINK->flag) + appendc('\'', LINK); + appendc(WITH->UU.s[j], LINK); + if (WITH->UU.s[j] == '\'') + appendc('\'', LINK); + LINK->flag = true; + } + } + if (LINK->flag) + appendc('\'', LINK); + } + break; + + case ne_ip: + case ne_rp: + case ne_sp: + case ne_rxp: + if (WITH->UU.U10.ips != NULL) + append(WITH->UU.U10.ips->s, LINK); + else + append("(var)", LINK); + break; + + case ne_if: + case ne_rf: + case ne_sf: + if (WITH->UU.U10.ips != NULL) + append(WITH->UU.U15.fps->s, LINK); + else + append("(func)", LINK); + args(&V); + break; + + case ne_itor: + case ne_rbool: + case ne_sbool: + uncompile(WITH->UU.U10.p1, prec, LINK); + break; + + case ne_iarg: + sprintf(STR1, "i_arg(%ld)", WITH->UU.i); + append(STR1, LINK); + break; + + case ne_rarg: + sprintf(STR1, "r_arg(%ld)", WITH->UU.i); + append(STR1, LINK); + break; + + case ne_sarg: + sprintf(STR1, "s_arg(%ld)", WITH->UU.i); + append(STR1, LINK); + break; + + case ne_ineg: + case ne_rneg: + if (neg_prec < prec) + appendc('(', LINK); + appendc('-', LINK); + uncompile(WITH->UU.U10.p1, (int)(neg_prec + 1), LINK); + if (neg_prec < prec) + appendc(')', LINK); + break; + + case ne_not: + if (not_prec < prec) + appendc('(', LINK); + appendc('~', LINK); + uncompile(WITH->UU.U10.p1, (int)(not_prec + 1), LINK); + if (not_prec < prec) + appendc(')', LINK); + break; + + case ne_lnot: + if (lnot_prec < prec) + appendc('(', LINK); + appendc('!', LINK); + uncompile(WITH->UU.U10.p1, (int)(lnot_prec + 1), LINK); + if (lnot_prec < prec) + appendc(')', LINK); + break; + + case ne_round: + func("round", &V); + break; + + case ne_trunc: + func("trunc", &V); + break; + + case ne_ln: + func("ln", &V); + break; + + case ne_exp: + func("exp", &V); + break; + + case ne_iabs: + case ne_rabs: + func("abs", &V); + break; + + case ne_sqrt: + func("sqrt", &V); + break; + + case ne_sin: + func("sin", &V); + break; + + case ne_cos: + func("cos", &V); + break; + + case ne_tan: + func("tan", &V); + break; + + case ne_arctan: + func("arctan", &V); + break; + + default: + j = numopersyms; + while (j >= 1 && (ne_opkind)opers[j - 1].iop != (ne_opkind)WITH->op && + (ne_opkind)opers[j - 1].rop != (ne_opkind)WITH->op && + (ne_opkind)opers[j - 1].sop != (ne_opkind)WITH->op) + j--; + if (opers[j - 1].lprec < prec) + appendc('(', LINK); + if (opers[j - 1].lprec == opers[j - 1].rprec) + uncompile(WITH->UU.U10.p1, opers[j - 1].lprec, LINK); + else + uncompile(WITH->UU.U10.p1, opers[j - 1].lprec + 1, LINK); + LINK->ch = opers[j - 1].name; + nex2 = WITH->UU.U10.p2; + switch (LINK->ch) + { + case '\001': + if (LINK->desc->doubleeq) + append("!=", LINK); + else + append("<>", LINK); + break; + + case '\002': + append("<=", LINK); + break; + + case '\003': + append(">=", LINK); + break; + + case '\004': + append("&&", LINK); + break; + + case '\005': + append("||", LINK); + break; + + case '\006': + append("<<", LINK); + break; + + case '\007': + append(">>", LINK); + break; + + case '\b': + append("!!", LINK); + break; + + case '?': + appendc(LINK->ch, LINK); + uncompile(WITH->UU.U10.p2, 0, LINK); + appendc(':', LINK); + nex2 = WITH->UU.U10.p3; + break; + + default: + if (LINK->ch == '=' && LINK->desc->doubleeq) + appendc(LINK->ch, LINK); + appendc(LINK->ch, LINK); + break; + } + + if (opers[j - 1].lprec == opers[j - 1].rprec) + uncompile(nex2, opers[j - 1].lprec + 1, LINK); + else + uncompile(nex2, opers[j - 1].lprec, LINK); + if (opers[j - 1].lprec < prec) + appendc(')', LINK); + break; } - } - if (LINK->flag) - appendc('\'', LINK); - } - break; - - case ne_ip: - case ne_rp: - case ne_sp: - case ne_rxp: - if (WITH->UU.U10.ips != NULL) - append(WITH->UU.U10.ips->s, LINK); - else - append("(var)", LINK); - break; - - case ne_if: - case ne_rf: - case ne_sf: - if (WITH->UU.U10.ips != NULL) - append(WITH->UU.U15.fps->s, LINK); - else - append("(func)", LINK); - args(&V); - break; - - case ne_itor: - case ne_rbool: - case ne_sbool: - uncompile(WITH->UU.U10.p1, prec, LINK); - break; - - case ne_iarg: - sprintf(STR1, "i_arg(%ld)", WITH->UU.i); - append(STR1, LINK); - break; - - case ne_rarg: - sprintf(STR1, "r_arg(%ld)", WITH->UU.i); - append(STR1, LINK); - break; - - case ne_sarg: - sprintf(STR1, "s_arg(%ld)", WITH->UU.i); - append(STR1, LINK); - break; - - case ne_ineg: - case ne_rneg: - if (neg_prec < prec) - appendc('(', LINK); - appendc('-', LINK); - uncompile(WITH->UU.U10.p1, (int)(neg_prec + 1), LINK); - if (neg_prec < prec) - appendc(')', LINK); - break; - - case ne_not: - if (not_prec < prec) - appendc('(', LINK); - appendc('~', LINK); - uncompile(WITH->UU.U10.p1, (int)(not_prec + 1), LINK); - if (not_prec < prec) - appendc(')', LINK); - break; - - case ne_lnot: - if (lnot_prec < prec) - appendc('(', LINK); - appendc('!', LINK); - uncompile(WITH->UU.U10.p1, (int)(lnot_prec + 1), LINK); - if (lnot_prec < prec) - appendc(')', LINK); - break; - - case ne_round: - func("round", &V); - break; - - case ne_trunc: - func("trunc", &V); - break; - - case ne_ln: - func("ln", &V); - break; - - case ne_exp: - func("exp", &V); - break; - - case ne_iabs: - case ne_rabs: - func("abs", &V); - break; - - case ne_sqrt: - func("sqrt", &V); - break; - - case ne_sin: - func("sin", &V); - break; - - case ne_cos: - func("cos", &V); - break; - - case ne_tan: - func("tan", &V); - break; - - case ne_arctan: - func("arctan", &V); - break; - - default: - j = numopersyms; - while (j >= 1 && (ne_opkind)opers[j - 1].iop != (ne_opkind)WITH->op && - (ne_opkind)opers[j - 1].rop != (ne_opkind)WITH->op && - (ne_opkind)opers[j - 1].sop != (ne_opkind)WITH->op) - j--; - if (opers[j - 1].lprec < prec) - appendc('(', LINK); - if (opers[j - 1].lprec == opers[j - 1].rprec) - uncompile(WITH->UU.U10.p1, opers[j - 1].lprec, LINK); - else - uncompile(WITH->UU.U10.p1, opers[j - 1].lprec + 1, LINK); - LINK->ch = opers[j - 1].name; - nex2 = WITH->UU.U10.p2; - switch (LINK->ch) { - - case '\001': - if (LINK->desc->doubleeq) - append("!=", LINK); - else - append("<>", LINK); - break; - - case '\002': - append("<=", LINK); - break; - - case '\003': - append(">=", LINK); - break; - - case '\004': - append("&&", LINK); - break; - - case '\005': - append("||", LINK); - break; - - case '\006': - append("<<", LINK); - break; - - case '\007': - append(">>", LINK); - break; - - case '\b': - append("!!", LINK); - break; - - case '?': - appendc(LINK->ch, LINK); - uncompile(WITH->UU.U10.p2, 0, LINK); - appendc(':', LINK); - nex2 = WITH->UU.U10.p3; - break; - - default: - if (LINK->ch == '=' && LINK->desc->doubleeq) - appendc(LINK->ch, LINK); - appendc(LINK->ch, LINK); - break; - } - if (opers[j - 1].lprec == opers[j - 1].rprec) - uncompile(nex2, opers[j - 1].lprec + 1, LINK); - else - uncompile(nex2, opers[j - 1].lprec, LINK); - if (opers[j - 1].lprec < prec) - appendc(')', LINK); - break; - } -} - - - -void ne_uncompile(nex, ex_, desc_) -ne_nexrec *nex; -char *ex_; -ne_desc *desc_; -{ - struct LOC_ne_uncompile V; - - V.ex = ex_; - V.desc = desc_; - V.desc->error = (unsigned)ne_noerror; - *V.ex = '\0'; - if (nex == NULL) { - append("(nil)", &V); - return; - } - uncompile(nex, 0, &V); - if (*V.desc->units != '\0' && (unsigned long)V.lastop < 32 && - ((1L << ((long)V.lastop)) & - ((1L << ((long)ne_ic)) | (1L << ((long)ne_rc)))) != 0) - append(V.desc->units, &V); } - -#define framesize 4 /*for na_outeralloc*/ - - - - - - - - -static void evalargs(nex) -ne_nexrec *nex; +void ne_uncompile(ne_nexrec *nex, char *ex_, ne_desc *desc_) { - long i; - char buf[256]; - long FORLIM; - -/* p2c: numex.text, line 2201: Note: Call to NA_OUTERALLOC [502] */ - na_outeralloc((void* *)(&ne_argarray), nex->nargs * 8L, (long)framesize); - FORLIM = nex->nargs; - for (i = 0; i < FORLIM; i++) { - if (nex->UU.U15.fp->nargs == 0) - ne_argarray[i].r = ne_reval(nex->UU.U99.pvals[i]); - else { - switch (nex->UU.U15.fp->UU.U99.ptypes[P_imin2(i + 1, - (long)nex->UU.U15.fp->nargs) - 1]) { + struct LOC_ne_uncompile V; + + V.ex = ex_; + V.desc = desc_; + V.desc->error = (unsigned)ne_noerror; + *V.ex = '\0'; + if (nex == NULL) + { + append("(nil)", &V); + return; + } + uncompile(nex, 0, &V); + if (*V.desc->units != '\0' && (unsigned long)V.lastop < 32 && + ((1L << ((long)V.lastop)) & ((1L << ((long)ne_ic)) | (1L << ((long)ne_rc)))) != 0) + append(V.desc->units, &V); +} - case ne_integer: - case ne_boolean: - ne_argarray[i].U1.i1 = ne_ieval(nex->UU.U99.pvals[i]); - break; - case ne_real: - ne_argarray[i].r = ne_reval(nex->UU.U99.pvals[i]); - break; +#define framesize 4 /*for na_outeralloc*/ - case ne_string: - ne_seval(buf, nex->UU.U99.pvals[i]); -/* p2c: numex.text, line 2215: Note: Call to NA_OUTERALLOC [502] */ - na_outeralloc((void* *)(&ne_argarray[i].U16.sp1), strlen(buf) + 1L, - (long)framesize); - strcpy(ne_argarray[i].U16.sp1, buf); - break; +static void evalargs(ne_nexrec *nex) +{ + long i; + char buf[256]; + long FORLIM; - default: - break; - } - } - } + na_outeralloc((void* *)(&ne_argarray), nex->nargs * 8L, (long)framesize); + FORLIM = nex->nargs; + for (i = 0; i < FORLIM; i++) + { + if (nex->UU.U15.fp->nargs == 0) + ne_argarray[i].r = ne_reval(nex->UU.U99.pvals[i]); + else { + switch (nex->UU.U15.fp->UU.U99.ptypes[P_imin2(i + 1, (long)nex->UU.U15.fp->nargs) - 1]) + { + + case ne_integer: + case ne_boolean: + ne_argarray[i].U1.i1 = ne_ieval(nex->UU.U99.pvals[i]); + break; + + case ne_real: + ne_argarray[i].r = ne_reval(nex->UU.U99.pvals[i]); + break; + + case ne_string: + ne_seval(buf, nex->UU.U99.pvals[i]); + na_outeralloc((void* *)(&ne_argarray[i].U16.sp1), strlen(buf) + 1L, (long)framesize); + strcpy(ne_argarray[i].U16.sp1, buf); + break; + + default: + break; + } + } + } } #undef framesize - int ne_condeval(ne_nexrec *nex) { - int Result = -1; - - TRY(try2); - Result = (ne_ieval(nex) != 0); - RECOVER(try2); - if (P_escapecode == ne_badescape) - return false; - else - _Escape(P_escapecode); - ENDTRY(try2); - return Result; + int Result = -1; + + TRY(try2); + Result = (ne_ieval(nex) != 0); + RECOVER(try2); + if (P_escapecode == ne_badescape) + return false; + else + _Escape(P_escapecode); + ENDTRY(try2); + return Result; } - long ne_ieval(ne_nexrec *nex) { - long Result, i1; - na_quadword *saveargarr; - ne_nexrec *WITH; - char STR1[256], STR2[256]; - - WITH = nex; - switch ((ne_opkind)nex->op) { - - case ne_ic: - Result = WITH->UU.i; - break; - - case ne_ip: - Result = *WITH->UU.U10.ip; - break; - - case ne_if: - if (WITH->UU.U15.fp->subnex) { - saveargarr = ne_argarray; - TRY(try3); - evalargs(nex); - switch ((int)types[(*WITH->UU.U15.fp->UU.nexp)->op]) { - - case ne_integer: - Result = ne_ieval(*WITH->UU.U15.fp->UU.nexp); - break; - - case ne_real: /*in case of $range off$*/ - Result = (long)floor(ne_reval(*WITH->UU.U15.fp->UU.nexp) + 0.5); - break; - - default: - P_escapecode = -9; - goto _Ltry3; - break; + long Result, i1; + na_quadword *saveargarr; + ne_nexrec *WITH; + char STR1[256], STR2[256]; + + WITH = nex; + switch ((ne_opkind)nex->op) + { + case ne_ic: + Result = WITH->UU.i; + break; + + case ne_ip: + Result = *WITH->UU.U10.ip; + break; + + case ne_if: + if (WITH->UU.U15.fp->subnex) + { + saveargarr = ne_argarray; + TRY(try3); + evalargs(nex); + switch ((int)types[(*WITH->UU.U15.fp->UU.nexp)->op]) + { + + case ne_integer: + Result = ne_ieval(*WITH->UU.U15.fp->UU.nexp); + break; + + case ne_real: /*in case of $range off$*/ + Result = (long)floor(ne_reval(*WITH->UU.U15.fp->UU.nexp) + 0.5); + break; + + default: + P_escapecode = -9; + goto _Ltry3; + break; + } + ne_argarray = saveargarr; + RECOVER2(try3,_Ltry3); + ne_argarray = saveargarr; + _Escape(P_escapecode); + ENDTRY(try3); + } + else + { + if (WITH->UU.U15.fp->UU.U5.ipr.link != NULL) + (*(void(*) (ne_nexrec *nex, long *res, void* _link)) WITH->UU.U15.fp->UU.U5.ipr.proc)(nex, &i1, + WITH->UU.U15.fp->UU.U5.ipr.link); + else + (*(void(*) (ne_nexrec *nex, long *res)) WITH->UU.U15.fp->UU.U5.ipr.proc)(nex, &i1); + Result = i1; + } + break; + + case ne_iarg: + if (ne_argarray == NULL) + Result = 0; + else + Result = ne_argarray[WITH->UU.i - 1].U1.i1; + break; + + case ne_iadd: + Result = ne_ieval(WITH->UU.U10.p1) + ne_ieval(WITH->UU.U10.p2); + break; + + case ne_isub: + Result = ne_ieval(WITH->UU.U10.p1) - ne_ieval(WITH->UU.U10.p2); + break; + + case ne_imul: + Result = ne_ieval(WITH->UU.U10.p1) * ne_ieval(WITH->UU.U10.p2); + break; + + case ne_idiv: + Result = ne_ieval(WITH->UU.U10.p1) / ne_ieval(WITH->UU.U10.p2); + break; + + case ne_ineg: + Result = -ne_ieval(WITH->UU.U10.p1); + break; + + case ne_imod: + Result = ne_ieval(WITH->UU.U10.p1) % ne_ieval(WITH->UU.U10.p2); + break; + + case ne_rbool: + TRY(try4); + Result = (ne_reval(WITH->UU.U10.p1) != 0); + RECOVER(try4); + if (P_escapecode != ne_badescape) + _Escape(P_escapecode); + Result = 0; + ENDTRY(try4); + break; + + case ne_sbool: + TRY(try5); + Result = (*ne_seval(STR1, WITH->UU.U10.p1) != '\0'); + RECOVER(try5); + if (P_escapecode != ne_badescape) + _Escape(P_escapecode); + Result = 0; + ENDTRY(try5); + break; + + case ne_ieq: + Result = (ne_ieval(WITH->UU.U10.p1) == ne_ieval(WITH->UU.U10.p2)); + break; + + case ne_ine: + Result = (ne_ieval(WITH->UU.U10.p1) != ne_ieval(WITH->UU.U10.p2)); + break; + + case ne_ilt: + Result = (ne_ieval(WITH->UU.U10.p1) < ne_ieval(WITH->UU.U10.p2)); + break; + + case ne_ile: + Result = (ne_ieval(WITH->UU.U10.p1) <= ne_ieval(WITH->UU.U10.p2)); + break; + + case ne_igt: + Result = (ne_ieval(WITH->UU.U10.p1) > ne_ieval(WITH->UU.U10.p2)); + break; + + case ne_ige: + Result = (ne_ieval(WITH->UU.U10.p1) >= ne_ieval(WITH->UU.U10.p2)); + break; + + case ne_req: + Result = (ne_reval(WITH->UU.U10.p1) == ne_reval(WITH->UU.U10.p2)); + break; + + case ne_rne: + Result = (ne_reval(WITH->UU.U10.p1) != ne_reval(WITH->UU.U10.p2)); + break; + + case ne_rlt: + Result = (ne_reval(WITH->UU.U10.p1) < ne_reval(WITH->UU.U10.p2)); + break; + + case ne_rle: + Result = (ne_reval(WITH->UU.U10.p1) <= ne_reval(WITH->UU.U10.p2)); + break; + + case ne_rgt: + Result = (ne_reval(WITH->UU.U10.p1) > ne_reval(WITH->UU.U10.p2)); + break; + + case ne_rge: + Result = (ne_reval(WITH->UU.U10.p1) >= ne_reval(WITH->UU.U10.p2)); + break; + + case ne_seq: + Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), ne_seval(STR2, WITH->UU.U10.p2)) == 0); + break; + + case ne_sne: + Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), ne_seval(STR2, WITH->UU.U10.p2)) != 0); + break; + + case ne_slt: + Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), ne_seval(STR2, WITH->UU.U10.p2)) < 0); + break; + + case ne_sle: + Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), ne_seval(STR2, WITH->UU.U10.p2)) <= 0); + break; + + case ne_sgt: + Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), ne_seval(STR2, WITH->UU.U10.p2)) > 0); + break; + + case ne_sge: + Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), ne_seval(STR2, WITH->UU.U10.p2)) >= 0); + break; + + case ne_not: + Result = ~ne_ieval(WITH->UU.U10.p1); + break; + + case ne_and: + Result = ne_ieval(WITH->UU.U10.p1) & ne_ieval(WITH->UU.U10.p2); + break; + + case ne_or: + Result = ne_ieval(WITH->UU.U10.p1) | ne_ieval(WITH->UU.U10.p2); + break; + + case ne_xor: + Result = ne_ieval(WITH->UU.U10.p1) ^ ne_ieval(WITH->UU.U10.p2); + break; + + case ne_lsh: + Result = ne_ieval(WITH->UU.U10.p1) << ne_ieval(WITH->UU.U10.p2); + break; + + case ne_rsh: + Result = ne_ieval(WITH->UU.U10.p1) >> ne_ieval(WITH->UU.U10.p2); + break; + + case ne_lnot: + Result = !ne_condeval(WITH->UU.U10.p1); + break; + + case ne_iand: + if (ne_condeval(WITH->UU.U10.p1)) + Result = ne_ieval(WITH->UU.U10.p2); + else + Result = 0; + break; + + case ne_ior: + TRY(try6); + i1 = ne_ieval(WITH->UU.U10.p1); + RECOVER(try6); + if (P_escapecode != ne_badescape) + _Escape(P_escapecode); + i1 = 0; + ENDTRY(try6); + if (i1 == 0) + Result = ne_ieval(WITH->UU.U10.p2); + else + Result = i1; + break; + + case ne_icond: + if (ne_condeval(WITH->UU.U10.p1)) + Result = ne_ieval(WITH->UU.U10.p2); + else + Result = ne_ieval(WITH->UU.U10.p3); + break; + + case ne_round: + Result = (long)floor(ne_reval(WITH->UU.U10.p1) + 0.5); + break; + + case ne_trunc: + Result = (long)ne_reval(WITH->UU.U10.p1); + break; + + case ne_iabs: + Result = labs(ne_ieval(WITH->UU.U10.p1)); + break; + + default: + _Escape(-9); + break; } - ne_argarray = saveargarr; - RECOVER2(try3,_Ltry3); - ne_argarray = saveargarr; - _Escape(P_escapecode); - ENDTRY(try3); - } else { - if (WITH->UU.U15.fp->UU.U5.ipr.link != NULL) - (*(void(*) (ne_nexrec *nex, long *res, void* _link)) - WITH->UU.U15.fp->UU.U5.ipr.proc)(nex, &i1, - WITH->UU.U15.fp->UU.U5.ipr.link); - else - (*(void(*) (ne_nexrec *nex, long *res)) - WITH->UU.U15.fp->UU.U5.ipr.proc)(nex, &i1); - Result = i1; - } - break; - - case ne_iarg: - if (ne_argarray == NULL) - Result = 0; - else - Result = ne_argarray[WITH->UU.i - 1].U1.i1; - break; - - case ne_iadd: - Result = ne_ieval(WITH->UU.U10.p1) + ne_ieval(WITH->UU.U10.p2); - break; - - case ne_isub: - Result = ne_ieval(WITH->UU.U10.p1) - ne_ieval(WITH->UU.U10.p2); - break; - - case ne_imul: - Result = ne_ieval(WITH->UU.U10.p1) * ne_ieval(WITH->UU.U10.p2); - break; - - case ne_idiv: - Result = ne_ieval(WITH->UU.U10.p1) / ne_ieval(WITH->UU.U10.p2); - break; - - case ne_ineg: - Result = -ne_ieval(WITH->UU.U10.p1); - break; - - case ne_imod: - Result = ne_ieval(WITH->UU.U10.p1) % ne_ieval(WITH->UU.U10.p2); -/* p2c: numex.text, line 2289: - * Note: Using % for possibly-negative arguments [317] */ - break; - - case ne_rbool: - TRY(try4); - Result = (ne_reval(WITH->UU.U10.p1) != 0); - RECOVER(try4); - if (P_escapecode != ne_badescape) - _Escape(P_escapecode); - Result = 0; - ENDTRY(try4); - break; - - case ne_sbool: - TRY(try5); - Result = (*ne_seval(STR1, WITH->UU.U10.p1) != '\0'); - RECOVER(try5); - if (P_escapecode != ne_badescape) - _Escape(P_escapecode); - Result = 0; - ENDTRY(try5); - break; - - case ne_ieq: - Result = (ne_ieval(WITH->UU.U10.p1) == ne_ieval(WITH->UU.U10.p2)); - break; - - case ne_ine: - Result = (ne_ieval(WITH->UU.U10.p1) != ne_ieval(WITH->UU.U10.p2)); - break; - - case ne_ilt: - Result = (ne_ieval(WITH->UU.U10.p1) < ne_ieval(WITH->UU.U10.p2)); - break; - - case ne_ile: - Result = (ne_ieval(WITH->UU.U10.p1) <= ne_ieval(WITH->UU.U10.p2)); - break; - - case ne_igt: - Result = (ne_ieval(WITH->UU.U10.p1) > ne_ieval(WITH->UU.U10.p2)); - break; - - case ne_ige: - Result = (ne_ieval(WITH->UU.U10.p1) >= ne_ieval(WITH->UU.U10.p2)); - break; - - case ne_req: - Result = (ne_reval(WITH->UU.U10.p1) == ne_reval(WITH->UU.U10.p2)); - break; - - case ne_rne: - Result = (ne_reval(WITH->UU.U10.p1) != ne_reval(WITH->UU.U10.p2)); - break; - - case ne_rlt: - Result = (ne_reval(WITH->UU.U10.p1) < ne_reval(WITH->UU.U10.p2)); - break; - - case ne_rle: - Result = (ne_reval(WITH->UU.U10.p1) <= ne_reval(WITH->UU.U10.p2)); - break; - - case ne_rgt: - Result = (ne_reval(WITH->UU.U10.p1) > ne_reval(WITH->UU.U10.p2)); - break; - - case ne_rge: - Result = (ne_reval(WITH->UU.U10.p1) >= ne_reval(WITH->UU.U10.p2)); - break; - - case ne_seq: - Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), - ne_seval(STR2, WITH->UU.U10.p2)) == 0); - break; - - case ne_sne: - Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), - ne_seval(STR2, WITH->UU.U10.p2)) != 0); - break; - - case ne_slt: - Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), - ne_seval(STR2, WITH->UU.U10.p2)) < 0); - break; - - case ne_sle: - Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), - ne_seval(STR2, WITH->UU.U10.p2)) <= 0); - break; - - case ne_sgt: - Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), - ne_seval(STR2, WITH->UU.U10.p2)) > 0); - break; - - case ne_sge: - Result = (strcmp(ne_seval(STR1, WITH->UU.U10.p1), - ne_seval(STR2, WITH->UU.U10.p2)) >= 0); - break; - - case ne_not: - Result = ~ne_ieval(WITH->UU.U10.p1); - break; - - case ne_and: - Result = ne_ieval(WITH->UU.U10.p1) & ne_ieval(WITH->UU.U10.p2); - break; - - case ne_or: - Result = ne_ieval(WITH->UU.U10.p1) | ne_ieval(WITH->UU.U10.p2); - break; - - case ne_xor: - Result = ne_ieval(WITH->UU.U10.p1) ^ ne_ieval(WITH->UU.U10.p2); - break; - - case ne_lsh: - Result = ne_ieval(WITH->UU.U10.p1) << ne_ieval(WITH->UU.U10.p2); -/* p2c: numex.text, line 2351: - * Note: Assuming count for NA_ASL is positive [504] */ - break; - - case ne_rsh: - Result = ne_ieval(WITH->UU.U10.p1) >> ne_ieval(WITH->UU.U10.p2); -/* p2c: numex.text, line 2353: - * Note: Assuming count for NA_ASL is negative [504] */ -/* p2c: numex.text, line 2353: - * Note: Assuming >> is an arithmetic shift [505] */ - break; - - case ne_lnot: - Result = !ne_condeval(WITH->UU.U10.p1); - break; - - case ne_iand: - if (ne_condeval(WITH->UU.U10.p1)) - Result = ne_ieval(WITH->UU.U10.p2); - else - Result = 0; - break; - - case ne_ior: - TRY(try6); - i1 = ne_ieval(WITH->UU.U10.p1); - RECOVER(try6); - if (P_escapecode != ne_badescape) - _Escape(P_escapecode); - i1 = 0; - ENDTRY(try6); - if (i1 == 0) - Result = ne_ieval(WITH->UU.U10.p2); - else - Result = i1; - break; - - case ne_icond: - if (ne_condeval(WITH->UU.U10.p1)) - Result = ne_ieval(WITH->UU.U10.p2); - else - Result = ne_ieval(WITH->UU.U10.p3); - break; - - case ne_round: - Result = (long)floor(ne_reval(WITH->UU.U10.p1) + 0.5); - break; - - case ne_trunc: - Result = (long)ne_reval(WITH->UU.U10.p1); - break; - - case ne_iabs: - Result = labs(ne_ieval(WITH->UU.U10.p1)); - break; - - default: - _Escape(-9); - break; - } - return Result; + return Result; } double ne_reval(ne_nexrec *nex) { - double Result, r1; - na_quadword *saveargarr; - ne_nexrec *WITH; - - WITH = nex; - switch ((ne_opkind)nex->op) { - - case ne_rc: - Result = WITH->UU.r; - break; - - case ne_rp: - Result = *WITH->UU.U11.rp; - break; - - case ne_rxp: - if (*WITH->UU.U11.rp == ne_badvalue) - _Escape(ne_badescape); - Result = *WITH->UU.U11.rp; - break; - - case ne_rf: - if (WITH->UU.U15.fp->subnex) { - saveargarr = ne_argarray; - TRY(try7); - evalargs(nex); - switch ((int)types[(*WITH->UU.U15.fp->UU.nexp)->op]) { - - case ne_integer: - Result = ne_ieval(*WITH->UU.U15.fp->UU.nexp); - break; - - case ne_real: /*in case of $range off$*/ - Result = ne_reval(*WITH->UU.U15.fp->UU.nexp); - break; - - default: - P_escapecode = -9; - goto _Ltry7; - break; + double Result, r1; + na_quadword *saveargarr; + ne_nexrec *WITH; + + WITH = nex; + switch ((ne_opkind)nex->op) + { + + case ne_rc: + Result = WITH->UU.r; + break; + + case ne_rp: + Result = *WITH->UU.U11.rp; + break; + + case ne_rxp: + if (*WITH->UU.U11.rp == ne_badvalue) + _Escape(ne_badescape); + Result = *WITH->UU.U11.rp; + break; + + case ne_rf: + if (WITH->UU.U15.fp->subnex) + { + saveargarr = ne_argarray; + TRY(try7); + evalargs(nex); + switch ((int)types[(*WITH->UU.U15.fp->UU.nexp)->op]) + { + + case ne_integer: + Result = ne_ieval(*WITH->UU.U15.fp->UU.nexp); + break; + + case ne_real: /*in case of $range off$*/ + Result = ne_reval(*WITH->UU.U15.fp->UU.nexp); + break; + + default: + P_escapecode = -9; + goto _Ltry7; + break; + } + ne_argarray = saveargarr; + RECOVER2(try7,_Ltry7); + ne_argarray = saveargarr; + _Escape(P_escapecode); + ENDTRY(try7); + } else + { + if (WITH->UU.U15.fp->UU.rpr.link != NULL) + (*(void(*) (ne_nexrec *nex, double *res, void* _link)) WITH->UU.U15.fp->UU.rpr.proc)(nex, &r1, + WITH->UU.U15.fp->UU.rpr.link); + else + (*(void(*) (ne_nexrec *nex, double *res)) WITH->UU.U15.fp->UU.rpr.proc)(nex, &r1); + Result = r1; + } + break; + + case ne_rarg: + if (ne_argarray == NULL) + Result = 0.0; + else + Result = ne_argarray[WITH->UU.i - 1].r; + break; + + case ne_radd: + Result = ne_reval(WITH->UU.U10.p1) + ne_reval(WITH->UU.U10.p2); + break; + + case ne_rsub: + Result = ne_reval(WITH->UU.U10.p1) - ne_reval(WITH->UU.U10.p2); + break; + + case ne_rmul: + Result = ne_reval(WITH->UU.U10.p1) * ne_reval(WITH->UU.U10.p2); + break; + + case ne_rdiv: + Result = ne_reval(WITH->UU.U10.p1) / ne_reval(WITH->UU.U10.p2); + break; + + case ne_rneg: + Result = -ne_reval(WITH->UU.U10.p1); + break; + + case ne_rpow: + Result = ma_ytox(ne_reval(WITH->UU.U10.p1), ne_reval(WITH->UU.U10.p2)); + break; + + case ne_itor: + Result = ne_ieval(WITH->UU.U10.p1); + break; + + case ne_ln: + Result = log(ne_reval(WITH->UU.U10.p1)); + break; + + case ne_exp: + Result = exp(ne_reval(WITH->UU.U10.p1)); + break; + + case ne_rabs: + Result = fabs(ne_reval(WITH->UU.U10.p1)); + break; + + case ne_sqrt: + Result = sqrt(ne_reval(WITH->UU.U10.p1)); + break; + + case ne_sin: + Result = sin(ne_reval(WITH->UU.U10.p1)); + break; + + case ne_cos: + Result = cos(ne_reval(WITH->UU.U10.p1)); + break; + + case ne_tan: + Result = tan(ne_reval(WITH->UU.U10.p1)); + break; + + case ne_arctan: + Result = atan(ne_reval(WITH->UU.U10.p1)); + break; + + case ne_rand: + TRY(try8); + r1 = ne_reval(WITH->UU.U10.p1); + RECOVER(try8); + if (P_escapecode != ne_badescape) + _Escape(P_escapecode); + r1 = 0.0; + ENDTRY(try8); + if (r1 != 0) + Result = ne_reval(WITH->UU.U10.p2); + else + Result = 0.0; + break; + + case ne_ror: + TRY(try9); + r1 = ne_reval(WITH->UU.U10.p1); + RECOVER(try9); + if (P_escapecode != ne_badescape) + _Escape(P_escapecode); + r1 = 0.0; + ENDTRY(try9); + if (r1 == 0) + Result = ne_reval(WITH->UU.U10.p2); + else + Result = r1; + break; + + case ne_rxor: + TRY(try10); + Result = ne_reval(WITH->UU.U10.p1); + RECOVER(try10); + if (P_escapecode != ne_badescape) + _Escape(P_escapecode); + Result = ne_reval(WITH->UU.U10.p2); + ENDTRY(try10); + break; + + case ne_rcond: + if (ne_condeval(WITH->UU.U10.p1)) + Result = ne_reval(WITH->UU.U10.p2); + else + Result = ne_reval(WITH->UU.U10.p3); + break; + + default: + Result = 0; + _Escape(-9); + break; } - ne_argarray = saveargarr; - RECOVER2(try7,_Ltry7); - ne_argarray = saveargarr; - _Escape(P_escapecode); - ENDTRY(try7); - } else { - if (WITH->UU.U15.fp->UU.rpr.link != NULL) - (*(void(*) (ne_nexrec *nex, double *res, void* _link)) - WITH->UU.U15.fp->UU.rpr.proc)(nex, &r1, - WITH->UU.U15.fp->UU.rpr.link); - else - (*(void(*) (ne_nexrec *nex, double *res)) - WITH->UU.U15.fp->UU.rpr.proc)(nex, &r1); - Result = r1; - } - break; - - case ne_rarg: - if (ne_argarray == NULL) - Result = 0.0; - else - Result = ne_argarray[WITH->UU.i - 1].r; - break; - - case ne_radd: - Result = ne_reval(WITH->UU.U10.p1) + ne_reval(WITH->UU.U10.p2); - break; - - case ne_rsub: - Result = ne_reval(WITH->UU.U10.p1) - ne_reval(WITH->UU.U10.p2); - break; - - case ne_rmul: - Result = ne_reval(WITH->UU.U10.p1) * ne_reval(WITH->UU.U10.p2); - break; - - case ne_rdiv: - Result = ne_reval(WITH->UU.U10.p1) / ne_reval(WITH->UU.U10.p2); - break; - - case ne_rneg: - Result = -ne_reval(WITH->UU.U10.p1); - break; - - case ne_rpow: - Result = ma_ytox(ne_reval(WITH->UU.U10.p1), ne_reval(WITH->UU.U10.p2)); - break; - - case ne_itor: - Result = ne_ieval(WITH->UU.U10.p1); - break; - - case ne_ln: - Result = log(ne_reval(WITH->UU.U10.p1)); - break; - - case ne_exp: - Result = exp(ne_reval(WITH->UU.U10.p1)); - break; - - case ne_rabs: - Result = fabs(ne_reval(WITH->UU.U10.p1)); - break; - - case ne_sqrt: - Result = sqrt(ne_reval(WITH->UU.U10.p1)); - break; - - case ne_sin: - Result = sin(ne_reval(WITH->UU.U10.p1)); - break; - - case ne_cos: - Result = cos(ne_reval(WITH->UU.U10.p1)); - break; - - case ne_tan: - Result = tan(ne_reval(WITH->UU.U10.p1)); - break; - - case ne_arctan: - Result = atan(ne_reval(WITH->UU.U10.p1)); - break; - - case ne_rand: - TRY(try8); - r1 = ne_reval(WITH->UU.U10.p1); - RECOVER(try8); - if (P_escapecode != ne_badescape) - _Escape(P_escapecode); - r1 = 0.0; - ENDTRY(try8); - if (r1 != 0) - Result = ne_reval(WITH->UU.U10.p2); - else - Result = 0.0; - break; - - case ne_ror: - TRY(try9); - r1 = ne_reval(WITH->UU.U10.p1); - RECOVER(try9); - if (P_escapecode != ne_badescape) - _Escape(P_escapecode); - r1 = 0.0; - ENDTRY(try9); - if (r1 == 0) - Result = ne_reval(WITH->UU.U10.p2); - else - Result = r1; - break; - - case ne_rxor: - TRY(try10); - Result = ne_reval(WITH->UU.U10.p1); - RECOVER(try10); - if (P_escapecode != ne_badescape) - _Escape(P_escapecode); - Result = ne_reval(WITH->UU.U10.p2); - ENDTRY(try10); - break; - - case ne_rcond: - if (ne_condeval(WITH->UU.U10.p1)) - Result = ne_reval(WITH->UU.U10.p2); - else - Result = ne_reval(WITH->UU.U10.p3); - break; - - default: - Result = 0; - _Escape(-9); - break; - } - return Result; -} - - -char *ne_seval(Result, nex) -char *Result; -ne_nexrec *nex; -{ - char s1[256]; - na_quadword *saveargarr; - ne_nexrec *WITH; - char STR1[256], STR2[256]; - - WITH = nex; - switch ((ne_opkind)nex->op) { - - case ne_sc: - strcpy(Result, WITH->UU.s); - break; - - case ne_sp: - strcpy(Result, *WITH->UU.U12.sp); - break; - - case ne_sf: - if (WITH->UU.U15.fp->subnex) { - saveargarr = ne_argarray; - TRY(try11); - evalargs(nex); - ne_seval(Result, *WITH->UU.U15.fp->UU.nexp); - ne_argarray = saveargarr; - RECOVER(try11); - ne_argarray = saveargarr; - _Escape(P_escapecode); - ENDTRY(try11); - } else { - if (WITH->UU.U15.fp->UU.spr.link != NULL) - (*(void(*) (ne_nexrec *nex, char *res, void* _link)) - WITH->UU.U15.fp->UU.spr.proc)(nex, s1, WITH->UU.U15.fp->UU.spr.link); - else - (*(void(*) (ne_nexrec *nex, char *res)) - WITH->UU.U15.fp->UU.spr.proc)(nex, s1); - strcpy(Result, s1); - } - break; - - case ne_sarg: - if (ne_argarray == NULL) - strcpy(Result, ""); - else - strcpy(Result, ne_argarray[WITH->UU.i - 1].U16.sp1); - break; - - case ne_sadd: - sprintf(Result, "%s%s", - ne_seval(STR1, WITH->UU.U10.p1), ne_seval(STR2, WITH->UU.U10.p2)); - break; - - case ne_sand: - TRY(try12); - ne_seval(s1, WITH->UU.U10.p1); - RECOVER(try12); - if (P_escapecode != ne_badescape) - _Escape(P_escapecode); - *s1 = '\0'; - ENDTRY(try12); - if (*s1 != '\0') - ne_seval(Result, WITH->UU.U10.p2); - else - strcpy(Result, ""); - break; - - case ne_sor: - TRY(try13); - ne_seval(s1, WITH->UU.U10.p1); - RECOVER(try13); - if (P_escapecode != ne_badescape) - _Escape(P_escapecode); - *s1 = '\0'; - ENDTRY(try13); - if (*s1 == '\0') - ne_seval(Result, WITH->UU.U10.p2); - else - strcpy(Result, s1); - break; - - case ne_scond: - if (ne_condeval(WITH->UU.U10.p1)) - ne_seval(Result, WITH->UU.U10.p2); - else - ne_seval(Result, WITH->UU.U10.p3); - break; - - default: - _Escape(-9); - break; - } - return Result; -} - - - - -ne_datatype ne_exprtype(nex) -ne_nexrec *nex; -{ - if (nex == NULL) - return ne_notype; - else - return (types[nex->op]); -} - - - - -void ne_evaluate(nex, res) -ne_nexrec *nex, *res; -{ - char STR1[256]; - - TRY(try14); - switch ((int)types[nex->op]) { - - case ne_notype: - *res = *nex; - break; - - case ne_integer: - res->op = (unsigned)ne_ic; - res->UU.i = ne_ieval(nex); - break; - - case ne_real: - res->op = (unsigned)ne_rc; - res->UU.r = ne_reval(nex); - break; - - case ne_string: - res->op = (unsigned)ne_sc; - res->UU.s = (char *)strdup(ne_seval(STR1, nex)); - break; - } - RECOVER(try14); - if (P_escapecode == -20) - _Escape(P_escapecode); - res->op = (unsigned)ne_error; - switch (P_escapecode) { - - case -3: - res->UU.err = (unsigned)ne_undef; - break; - - case -5: - res->UU.err = (unsigned)ne_divzero; - break; - - case -7: - res->UU.err = (unsigned)ne_underflow; - break; - - case ne_badescape: - res->UU.err = (unsigned)ne_badval; - break; - - default: - res->UU.err = (unsigned)ne_overflow; - break; - } - ENDTRY(try14); + return Result; +} + + +char *ne_seval(char *Result, ne_nexrec *nex) +{ + char s1[256]; + na_quadword *saveargarr; + ne_nexrec *WITH; + char STR1[256], STR2[256]; + + WITH = nex; + switch ((ne_opkind)nex->op) + { + + case ne_sc: + strcpy(Result, WITH->UU.s); + break; + + case ne_sp: + strcpy(Result, *WITH->UU.U12.sp); + break; + + case ne_sf: + if (WITH->UU.U15.fp->subnex) + { + saveargarr = ne_argarray; + TRY(try11); + evalargs(nex); + ne_seval(Result, *WITH->UU.U15.fp->UU.nexp); + ne_argarray = saveargarr; + RECOVER(try11); + ne_argarray = saveargarr; _Escape(P_escapecode); + ENDTRY(try11); + } + else + { + if (WITH->UU.U15.fp->UU.spr.link != NULL) + (*(void(*) (ne_nexrec *nex, char *res, void* _link)) WITH->UU.U15.fp->UU.spr.proc)(nex, s1, WITH->UU.U15.fp->UU.spr.link); + else + (*(void(*) (ne_nexrec *nex, char *res)) + WITH->UU.U15.fp->UU.spr.proc)(nex, s1); + strcpy(Result, s1); + } + break; + + case ne_sarg: + if (ne_argarray == NULL) + strcpy(Result, ""); + else + strcpy(Result, ne_argarray[WITH->UU.i - 1].U16.sp1); + break; + + case ne_sadd: + sprintf(Result, "%s%s", + ne_seval(STR1, WITH->UU.U10.p1), ne_seval(STR2, WITH->UU.U10.p2)); + break; + + case ne_sand: + TRY(try12); + ne_seval(s1, WITH->UU.U10.p1); + RECOVER(try12); + if (P_escapecode != ne_badescape) + _Escape(P_escapecode); + *s1 = '\0'; + ENDTRY(try12); + if (*s1 != '\0') + ne_seval(Result, WITH->UU.U10.p2); + else + strcpy(Result, ""); + break; + + case ne_sor: + TRY(try13); + ne_seval(s1, WITH->UU.U10.p1); + RECOVER(try13); + if (P_escapecode != ne_badescape) + _Escape(P_escapecode); + *s1 = '\0'; + ENDTRY(try13); + if (*s1 == '\0') + ne_seval(Result, WITH->UU.U10.p2); + else + strcpy(Result, s1); + break; + + case ne_scond: + if (ne_condeval(WITH->UU.U10.p1)) + ne_seval(Result, WITH->UU.U10.p2); + else + ne_seval(Result, WITH->UU.U10.p3); + break; + + default: + _Escape(-9); + break; + } + return Result; } - - - -static void faileval(nex, desc, esc) -ne_nexrec *nex; -ne_desc *desc; -long esc; +ne_datatype ne_exprtype(ne_nexrec *nex) { - desc->error = (unsigned)ne_noerror; - if (nex == NULL || (ne_opkind)nex->op != ne_error) - _Escape((int)esc); - desc->error = (unsigned)((ne_errorkind)nex->UU.err); - switch ((ne_errorkind)nex->UU.err) { - - case ne_underflow: - _Escape(-7); - break; - - case ne_divzero: - _Escape(-5); - break; - - case ne_strlong: - _Escape(-8); - break; - - default: - _Escape((int)esc); - break; - } + if (nex == NULL) + return ne_notype; + else + return (types[nex->op]); +} + +void ne_evaluate(ne_nexrec *nex, ne_nexrec *res) +{ + char STR1[256]; + + TRY(try14); + switch ((int)types[nex->op]) + { + case ne_notype: + *res = *nex; + break; + + case ne_integer: + res->op = (unsigned)ne_ic; + res->UU.i = ne_ieval(nex); + break; + + case ne_real: + res->op = (unsigned)ne_rc; + res->UU.r = ne_reval(nex); + break; + + case ne_string: + res->op = (unsigned)ne_sc; + res->UU.s = (char *)strdup(ne_seval(STR1, nex)); + break; + } + RECOVER(try14); + + if (P_escapecode == -20) + _Escape(P_escapecode); + res->op = (unsigned)ne_error; + + switch (P_escapecode) + { + + case -3: + res->UU.err = (unsigned)ne_undef; + break; + + case -5: + res->UU.err = (unsigned)ne_divzero; + break; + + case -7: + res->UU.err = (unsigned)ne_underflow; + break; + + case ne_badescape: + res->UU.err = (unsigned)ne_badval; + break; + + default: + res->UU.err = (unsigned)ne_overflow; + break; + } + ENDTRY(try14); +} + +static void faileval(ne_nexrec *nex, ne_desc *desc, long esc) +{ + desc->error = (unsigned)ne_noerror; + if (nex == NULL || (ne_opkind)nex->op != ne_error) + _Escape((int)esc); + desc->error = (unsigned)((ne_errorkind)nex->UU.err); + switch ((ne_errorkind)nex->UU.err) { + + case ne_underflow: + _Escape(-7); + break; + + case ne_divzero: + _Escape(-5); + break; + + case ne_strlong: + _Escape(-8); + break; + + default: + _Escape((int)esc); + break; + } } - -long ne_ievaluate(nex, desc) -ne_nexrec *nex; -ne_desc *desc; +long ne_ievaluate(ne_nexrec *nex, ne_desc *desc) { - if (integerp(nex)) - return (ne_ieval(nex)); - if (realp(nex)) - return ((long)floor(ne_reval(nex) + 0.5)); - faileval(nex, desc, -4L); + if (integerp(nex)) + return (ne_ieval(nex)); + if (realp(nex)) + return ((long)floor(ne_reval(nex) + 0.5)); + faileval(nex, desc, -4L); return 0L; /* should never happen */ } -double ne_revaluate(nex, desc) -ne_nexrec *nex; -ne_desc *desc; +double ne_revaluate(ne_nexrec *nex, ne_desc *desc) { - if (realp(nex)) - return (ne_reval(nex)); - if (integerp(nex)) - return (ne_ieval(nex)); - faileval(nex, desc, -6L); + if (realp(nex)) + return (ne_reval(nex)); + if (integerp(nex)) + return (ne_ieval(nex)); + faileval(nex, desc, -6L); return 0.0; /* should never happen */ } - -char *ne_sevaluate(Result, nex, desc) -char *Result; -ne_nexrec *nex; -ne_desc *desc; +char *ne_sevaluate(char *Result, ne_nexrec *nex, ne_desc *desc) { - if (stringp(nex)) - return (ne_seval(Result, nex)); - faileval(nex, desc, -8L); - return Result; + if (stringp(nex)) + return (ne_seval(Result, nex)); + faileval(nex, desc, -8L); + return Result; } - - - -long ne_ievalexpr(ex, desc) -char *ex; -ne_desc *desc; +long ne_ievalexpr(char *ex, ne_desc *desc) { - long Result; - ne_nexrec *nex; - long esc; - - ne_compile(ex, &nex, desc); - TRY(try15); - Result = ne_ievaluate(nex, desc); - ne_dispose(&nex); - RECOVER(try15); - esc = P_escapecode; - ne_dispose(&nex); - _Escape((int)esc); - ENDTRY(try15); - return Result; + long Result; + ne_nexrec *nex; + long esc; + + ne_compile(ex, &nex, desc); + TRY(try15); + Result = ne_ievaluate(nex, desc); + ne_dispose(&nex); + RECOVER(try15); + esc = P_escapecode; + ne_dispose(&nex); + _Escape((int)esc); + ENDTRY(try15); + return Result; } - -double ne_revalexpr(ex, desc) -char *ex; -ne_desc *desc; +double ne_revalexpr(char *ex, ne_desc *desc) { - double Result; - ne_nexrec *nex; - long esc; - - ne_compile(ex, &nex, desc); - TRY(try16); - Result = ne_revaluate(nex, desc); - ne_dispose(&nex); - RECOVER(try16); - esc = P_escapecode; - ne_dispose(&nex); - _Escape((int)esc); - ENDTRY(try16); - return Result; + double Result; + ne_nexrec *nex; + long esc; + + ne_compile(ex, &nex, desc); + TRY(try16); + Result = ne_revaluate(nex, desc); + ne_dispose(&nex); + RECOVER(try16); + esc = P_escapecode; + ne_dispose(&nex); + _Escape((int)esc); + ENDTRY(try16); + return Result; } - -char *ne_sevalexpr(Result, ex, desc) -char *Result, *ex; -ne_desc *desc; +char *ne_sevalexpr(char *Result, char *ex, ne_desc *desc) { - ne_nexrec *nex; - long esc; - - ne_compile(ex, &nex, desc); - TRY(try17); - ne_sevaluate(Result, nex, desc); - ne_dispose(&nex); - RECOVER(try17); - esc = P_escapecode; - ne_dispose(&nex); - _Escape((int)esc); - ENDTRY(try17); - return Result; + ne_nexrec *nex; + long esc; + + ne_compile(ex, &nex, desc); + TRY(try17); + ne_sevaluate(Result, nex, desc); + ne_dispose(&nex); + RECOVER(try17); + esc = P_escapecode; + ne_dispose(&nex); + _Escape((int)esc); + ENDTRY(try17); + + return Result; } - - - -void ne_makeintconst(sym, i) -na_strlist_t *sym; -long i; +void ne_makeintconst(na_strlist_t *sym, long i) { - sym->kind = ne_kind_intconst; - sym->value = (na_long)i; + sym->kind = ne_kind_intconst; + sym->value = (na_long)i; } - -void ne_makesrealconst(sym, r) -na_strlist_t *sym; -double r; +void ne_makesrealconst(na_strlist_t *sym, double r) { - sym->kind = ne_kind_srealconst; - sym->value = na_rtosr(r); + sym->kind = ne_kind_srealconst; + sym->value = na_rtosr(r); } - -void ne_makerealconst(sym, r) -na_strlist_t *sym; -double r; +void ne_makerealconst(na_strlist_t *sym, double r) { - double *rp; - - sym->kind = ne_kind_realconst; - rp = (double *)Malloc(sizeof(double)); - *rp = r; - sym->value = (void*)rp; + double *rp; + + sym->kind = ne_kind_realconst; + rp = (double *)Malloc(sizeof(double)); + *rp = r; + sym->value = (void*)rp; } -void ne_makestrconst(sym, s) -na_strlist_t *sym; -char *s; +void ne_makestrconst(na_strlist_t *sym, char *s) { - sym->kind = ne_kind_strconst; - *(char **)((char **)(&sym->value)) = (char *)strdup(s); + sym->kind = ne_kind_strconst; + *(char **)((char **)(&sym->value)) = (char *)strdup(s); } - -void ne_makeintvar(sym, i) -na_strlist_t *sym; -long *i; +void ne_makeintvar(na_strlist_t *sym, long *i) { - sym->kind = ne_kind_intptr; - sym->value = (void*)i; + sym->kind = ne_kind_intptr; + sym->value = (void*)i; } - -void ne_makerealvar(sym, r) -na_strlist_t *sym; -double *r; +void ne_makerealvar(na_strlist_t *sym, double *r) { - sym->kind = ne_kind_realptr; - sym->value = (void*)r; + sym->kind = ne_kind_realptr; + sym->value = (void*)r; } - -void ne_makerealxvar(sym, r) -na_strlist_t *sym; -double *r; +void ne_makerealxvar(na_strlist_t *sym, double *r) { - sym->kind = ne_kind_realxptr; - sym->value = (void*)r; + sym->kind = ne_kind_realxptr; + sym->value = (void*)r; } - -void ne_makestrvar(sym, s) -na_strlist_t *sym; -char *s; +void ne_makestrvar(na_strlist_t *sym, char *s) { - sym->kind = ne_kind_strvalue; - sym->value = (void*)s; + sym->kind = ne_kind_strvalue; + sym->value = (void*)s; } - -void ne_makestrptrvar(sym, sp) -na_strlist_t *sym; -char **sp; +void ne_makestrptrvar(na_strlist_t *sym, char **sp) { - sym->kind = ne_kind_strptr; - sym->value = (void*)sp; + sym->kind = ne_kind_strptr; + sym->value = (void*)sp; } - - -static void setupfunc(sym, fp, nargs, args) -na_strlist_t *sym; -ne_functionrec **fp; -long nargs; -ne_datatype *args; +static void setupfunc(na_strlist_t *sym, ne_functionrec **fp, long nargs, ne_datatype *args) { - long i; - -/* p2c: numex.text, line 2837: - * Note: No SpecialSizeOf form known for NE_FUNCTIONREC.1 [187] */ -/* p2c: numex.text, line 2837: - * Note: Suspicious mixture of sizes in NA_NEW [173] */ - *fp = (ne_functionrec *)Malloc(sizeof(ne_functionrec) + nargs * 2); - (*fp)->nargs = nargs; - for (i = 0; i < nargs; i++) - (*fp)->UU.U99.ptypes[i] = args[i]; - (*fp)->static_ = false; - (*fp)->minargs = nargs; - (*fp)->maxargs = nargs; - sym->value = (void*)(*fp); + long i; + + *fp = (ne_functionrec *)Malloc(sizeof(ne_functionrec) + nargs * 2); + (*fp)->nargs = nargs; + for (i = 0; i < nargs; i++) + (*fp)->UU.U99.ptypes[i] = args[i]; + (*fp)->static_ = false; + (*fp)->minargs = nargs; + (*fp)->maxargs = nargs; + sym->value = (void*)(*fp); } - -void ne_makeintmfunc(sym, nargs, args, pr) -na_strlist_t *sym; -long nargs; -ne_datatype *args; -_PROCEDURE pr; +void ne_makeintmfunc(na_strlist_t *sym, long nargs, ne_datatype *args, _PROCEDURE pr) { - ne_functionrec *fp; - - sym->kind = ne_kind_intfunc; - setupfunc(sym, &fp, nargs, args); - fp->subnex = false; - fp->UU.U5.ipr = pr; + ne_functionrec *fp; + + sym->kind = ne_kind_intfunc; + setupfunc(sym, &fp, nargs, args); + fp->subnex = false; + fp->UU.U5.ipr = pr; } - -void ne_makerealmfunc(sym, nargs, args, pr) -na_strlist_t *sym; -long nargs; -ne_datatype *args; -_PROCEDURE pr; +void ne_makerealmfunc(na_strlist_t *sym, long nargs, ne_datatype *args, _PROCEDURE pr) { - ne_functionrec *fp; - - sym->kind = ne_kind_realfunc; - setupfunc(sym, &fp, nargs, args); - fp->subnex = false; - fp->UU.rpr = pr; + ne_functionrec *fp; + + sym->kind = ne_kind_realfunc; + setupfunc(sym, &fp, nargs, args); + fp->subnex = false; + fp->UU.rpr = pr; } - -void ne_makestrmfunc(sym, nargs, args, pr) -na_strlist_t *sym; -long nargs; -ne_datatype *args; -_PROCEDURE pr; +void ne_makestrmfunc(na_strlist_t *sym, long nargs, ne_datatype *args, _PROCEDURE pr) { - ne_functionrec *fp; - - sym->kind = ne_kind_strfunc; - setupfunc(sym, &fp, nargs, args); - fp->subnex = false; - fp->UU.spr = pr; + ne_functionrec *fp; + + sym->kind = ne_kind_strfunc; + setupfunc(sym, &fp, nargs, args); + fp->subnex = false; + fp->UU.spr = pr; } -void ne_makeintfunc(sym, t1, t2, t3, pr) -na_strlist_t *sym; -ne_datatype t1, t2, t3; -_PROCEDURE pr; +void ne_makeintfunc(na_strlist_t *sym, ne_datatype t1, ne_datatype t2, ne_datatype t3, _PROCEDURE pr) { - ne_datatype args[3]; - - args[0] = t1; - args[1] = t2; - args[2] = t3; - ne_makeintmfunc(sym, - (long)((t1 != ne_notype) + (t2 != ne_notype) + (t3 != ne_notype)), args, - pr); + ne_datatype args[3]; + + args[0] = t1; + args[1] = t2; + args[2] = t3; + ne_makeintmfunc(sym, (long)((t1 != ne_notype) + (t2 != ne_notype) + (t3 != ne_notype)), args, pr); } - -void ne_makerealfunc(sym, t1, t2, t3, pr) -na_strlist_t *sym; -ne_datatype t1, t2, t3; -_PROCEDURE pr; +void ne_makerealfunc(na_strlist_t *sym, ne_datatype t1, ne_datatype t2, ne_datatype t3, _PROCEDURE pr) { - ne_datatype args[3]; - - args[0] = t1; - args[1] = t2; - args[2] = t3; - ne_makerealmfunc(sym, - (long)((t1 != ne_notype) + (t2 != ne_notype) + (t3 != ne_notype)), args, - pr); + ne_datatype args[3]; + + args[0] = t1; + args[1] = t2; + args[2] = t3; + ne_makerealmfunc(sym, (long)((t1 != ne_notype) + (t2 != ne_notype) + (t3 != ne_notype)), args, pr); } - -void ne_makestrfunc(sym, t1, t2, t3, pr) -na_strlist_t *sym; -ne_datatype t1, t2, t3; -_PROCEDURE pr; +void ne_makestrfunc(na_strlist_t *sym, ne_datatype t1, ne_datatype t2, ne_datatype t3, _PROCEDURE pr) { - ne_datatype args[3]; - - args[0] = t1; - args[1] = t2; - args[2] = t3; - ne_makestrmfunc(sym, - (long)((t1 != ne_notype) + (t2 != ne_notype) + (t3 != ne_notype)), args, - pr); + ne_datatype args[3]; + + args[0] = t1; + args[1] = t2; + args[2] = t3; + ne_makestrmfunc(sym, (long)((t1 != ne_notype) + (t2 != ne_notype) + (t3 != ne_notype)), args, pr); } - -void ne_makeintsfunc(sym, nargs, args, nex) -na_strlist_t *sym; -long nargs; -ne_datatype *args; -ne_nexrec **nex; +void ne_makeintsfunc(na_strlist_t *sym, long nargs, ne_datatype *args, ne_nexrec **nex) { - ne_functionrec *fp; - - sym->kind = ne_kind_intfunc; - setupfunc(sym, &fp, nargs, args); - fp->subnex = true; - fp->UU.nexp = nex; + ne_functionrec *fp; + + sym->kind = ne_kind_intfunc; + setupfunc(sym, &fp, nargs, args); + fp->subnex = true; + fp->UU.nexp = nex; } - -void ne_makerealsfunc(sym, nargs, args, nex) -na_strlist_t *sym; -long nargs; -ne_datatype *args; -ne_nexrec **nex; +void ne_makerealsfunc(na_strlist_t *sym, long nargs, ne_datatype *args, ne_nexrec **nex) { - ne_functionrec *fp; - - sym->kind = ne_kind_realfunc; - setupfunc(sym, &fp, nargs, args); - fp->subnex = true; - fp->UU.nexp = nex; + ne_functionrec *fp; + + sym->kind = ne_kind_realfunc; + setupfunc(sym, &fp, nargs, args); + fp->subnex = true; + fp->UU.nexp = nex; } - -void ne_makestrsfunc(sym, nargs, args, nex) -na_strlist_t *sym; -long nargs; -ne_datatype *args; -ne_nexrec **nex; +void ne_makestrsfunc(na_strlist_t *sym, long nargs, ne_datatype *args, ne_nexrec **nex) { - ne_functionrec *fp; - - sym->kind = ne_kind_strfunc; - setupfunc(sym, &fp, nargs, args); - fp->subnex = true; - fp->UU.nexp = nex; + ne_functionrec *fp; + + sym->kind = ne_kind_strfunc; + setupfunc(sym, &fp, nargs, args); + fp->subnex = true; + fp->UU.nexp = nex; } - -void ne_makeintarg(sym, i) -na_strlist_t *sym; -long i; +void ne_makeintarg(na_strlist_t *sym, long i) { - sym->kind = ne_kind_intarg; - sym->value = (na_long)i; + sym->kind = ne_kind_intarg; + sym->value = (na_long)i; } - -void ne_makerealarg(sym, i) -na_strlist_t *sym; -long i; +void ne_makerealarg(na_strlist_t *sym, long i) { - sym->kind = ne_kind_realarg; - sym->value = (na_long)i; + sym->kind = ne_kind_realarg; + sym->value = (na_long)i; } - -void ne_makestrarg(sym, i) -na_strlist_t *sym; -long i; +void ne_makestrarg(na_strlist_t *sym, long i) { - sym->kind = ne_kind_strarg; - sym->value = (na_long)i; + sym->kind = ne_kind_strarg; + sym->value = (na_long)i; } - - -void ne_setminargs(sym, minargs) -na_strlist_t *sym; -long minargs; +void ne_setminargs(na_strlist_t *sym, long minargs) { - ne_functionrec *fp; - - fp = (ne_functionrec *)sym->value; - fp->minargs = P_imin2((long)fp->nargs, minargs); + ne_functionrec *fp; + + fp = (ne_functionrec *)sym->value; + fp->minargs = P_imin2((long)fp->nargs, minargs); } - -void ne_setmaxargs(sym, maxargs) -na_strlist_t *sym; -long maxargs; +void ne_setmaxargs(na_strlist_t *sym, long maxargs) { - ne_functionrec *fp; - - fp = (ne_functionrec *)sym->value; - fp->maxargs = P_imin2(P_imax2((long)fp->nargs, maxargs), (long)ne_maxargs); + ne_functionrec *fp; + + fp = (ne_functionrec *)sym->value; + fp->maxargs = P_imin2(P_imax2((long)fp->nargs, maxargs), (long)ne_maxargs); } - -void ne_makestaticfunc(sym) -na_strlist_t *sym; +void ne_makestaticfunc(na_strlist_t *sym) { - ne_functionrec *fp; - - fp = (ne_functionrec *)sym->value; - fp->static_ = true; + ne_functionrec *fp; + + fp = (ne_functionrec *)sym->value; + fp->static_ = true; } - - -void ne_disposesym(sym) -na_strlist_t *sym; +void ne_disposesym(na_strlist_t *sym) { - double *rp; - ne_functionrec *fp; - - switch (sym->kind) { - - case ne_kind_realconst: - rp = (double *)sym->value; - Free(rp); - break; - - case ne_kind_intfunc: - case ne_kind_realfunc: - case ne_kind_strfunc: - fp = (ne_functionrec *)sym->value; -/* p2c: numex.text, line 3026: - * Note: No SpecialSizeOf form known for NE_FUNCTIONREC.1 [187] */ - Free(fp); - break; - } - sym->kind = '\0'; - sym->value = (na_long)0; + double *rp; + ne_functionrec *fp; + + switch (sym->kind) + { + + case ne_kind_realconst: + rp = (double *)sym->value; + Free(rp); + break; + + case ne_kind_intfunc: + case ne_kind_realfunc: + case ne_kind_strfunc: + fp = (ne_functionrec *)sym->value; + Free(fp); + break; + } + sym->kind = '\0'; + sym->value = (na_long)0; } - -void ne_disposesymtab(symtab) -na_strlist_t **symtab; +void ne_disposesymtab(na_strlist_t **symtab) { - na_strlist_t *l1; - - l1 = *symtab; - while (l1 != NULL) { - ne_disposesym(l1); - l1 = l1->next; - } - strlist_empty(symtab); + na_strlist_t *l1; + + l1 = *symtab; + while (l1 != NULL) + { + ne_disposesym(l1); + l1 = l1->next; + } + strlist_empty(symtab); } - - - - - - - - - - /* End. */ -- GitLab