diff options
Diffstat (limited to 'shar/python-0.9.1-03-21.shar')
| -rw-r--r-- | shar/python-0.9.1-03-21.shar | 2944 |
1 files changed, 2944 insertions, 0 deletions
diff --git a/shar/python-0.9.1-03-21.shar b/shar/python-0.9.1-03-21.shar new file mode 100644 index 0000000..b2f6af5 --- /dev/null +++ b/shar/python-0.9.1-03-21.shar @@ -0,0 +1,2944 @@ +: This is a shell archive. +: Extract with 'sh this_file'. +: +: Extract part 01 first since it makes all directories +echo 'Start of pack.out, part 03 out of 21:' +if test -s 'src/compile.c' +then echo '*** I will not over-write existing file src/compile.c' +else +echo 'x - src/compile.c' +sed 's/^X//' > 'src/compile.c' << 'EOF' +X/*********************************************************** +XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The +XNetherlands. +X +X All Rights Reserved +X +XPermission to use, copy, modify, and distribute this software and its +Xdocumentation for any purpose and without fee is hereby granted, +Xprovided that the above copyright notice appear in all copies and that +Xboth that copyright notice and this permission notice appear in +Xsupporting documentation, and that the names of Stichting Mathematisch +XCentrum or CWI not be used in advertising or publicity pertaining to +Xdistribution of the software without specific, written prior permission. +X +XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +X +X******************************************************************/ +X +X/* Compile an expression node to intermediate code */ +X +X/* XXX TO DO: +X XXX Compute maximum needed stack sizes while compiling +X XXX Generate simple jump for break/return outside 'try...finally' +X XXX Include function name in code (and module names?) +X*/ +X +X#include "allobjects.h" +X +X#include "node.h" +X#include "token.h" +X#include "graminit.h" +X#include "compile.h" +X#include "opcode.h" +X#include "structmember.h" +X +X#include <ctype.h> +X +X#define OFF(x) offsetof(codeobject, x) +X +Xstatic struct memberlist code_memberlist[] = { +X {"co_code", T_OBJECT, OFF(co_code)}, +X {"co_consts", T_OBJECT, OFF(co_consts)}, +X {"co_names", T_OBJECT, OFF(co_names)}, +X {"co_filename", T_OBJECT, OFF(co_filename)}, +X {NULL} /* Sentinel */ +X}; +X +Xstatic object * +Xcode_getattr(co, name) +X codeobject *co; +X char *name; +X{ +X return getmember((char *)co, code_memberlist, name); +X} +X +Xstatic void +Xcode_dealloc(co) +X codeobject *co; +X{ +X XDECREF(co->co_code); +X XDECREF(co->co_consts); +X XDECREF(co->co_names); +X XDECREF(co->co_filename); +X DEL(co); +X} +X +Xtypeobject Codetype = { +X OB_HEAD_INIT(&Typetype) +X 0, +X "code", +X sizeof(codeobject), +X 0, +X code_dealloc, /*tp_dealloc*/ +X 0, /*tp_print*/ +X code_getattr, /*tp_getattr*/ +X 0, /*tp_setattr*/ +X 0, /*tp_compare*/ +X 0, /*tp_repr*/ +X 0, /*tp_as_number*/ +X 0, /*tp_as_sequence*/ +X 0, /*tp_as_mapping*/ +X}; +X +Xstatic codeobject *newcodeobject PROTO((object *, object *, object *, char *)); +X +Xstatic codeobject * +Xnewcodeobject(code, consts, names, filename) +X object *code; +X object *consts; +X object *names; +X char *filename; +X{ +X codeobject *co; +X int i; +X /* Check argument types */ +X if (code == NULL || !is_stringobject(code) || +X consts == NULL || !is_listobject(consts) || +X names == NULL || !is_listobject(names)) { +X err_badcall(); +X return NULL; +X } +X /* Make sure the list of names contains only strings */ +X for (i = getlistsize(names); --i >= 0; ) { +X object *v = getlistitem(names, i); +X if (v == NULL || !is_stringobject(v)) { +X err_badcall(); +X return NULL; +X } +X } +X co = NEWOBJ(codeobject, &Codetype); +X if (co != NULL) { +X INCREF(code); +X co->co_code = (stringobject *)code; +X INCREF(consts); +X co->co_consts = consts; +X INCREF(names); +X co->co_names = names; +X if ((co->co_filename = newstringobject(filename)) == NULL) { +X DECREF(co); +X co = NULL; +X } +X } +X return co; +X} +X +X +X/* Data structure used internally */ +Xstruct compiling { +X object *c_code; /* string */ +X object *c_consts; /* list of objects */ +X object *c_names; /* list of strings (names) */ +X int c_nexti; /* index into c_code */ +X int c_errors; /* counts errors occurred */ +X int c_infunction; /* set when compiling a function */ +X int c_loops; /* counts nested loops */ +X char *c_filename; /* filename of current node */ +X}; +X +X/* Prototypes */ +Xstatic int com_init PROTO((struct compiling *, char *)); +Xstatic void com_free PROTO((struct compiling *)); +Xstatic void com_done PROTO((struct compiling *)); +Xstatic void com_node PROTO((struct compiling *, struct _node *)); +Xstatic void com_addbyte PROTO((struct compiling *, int)); +Xstatic void com_addint PROTO((struct compiling *, int)); +Xstatic void com_addoparg PROTO((struct compiling *, int, int)); +Xstatic void com_addfwref PROTO((struct compiling *, int, int *)); +Xstatic void com_backpatch PROTO((struct compiling *, int)); +Xstatic int com_add PROTO((struct compiling *, object *, object *)); +Xstatic int com_addconst PROTO((struct compiling *, object *)); +Xstatic int com_addname PROTO((struct compiling *, object *)); +Xstatic void com_addopname PROTO((struct compiling *, int, node *)); +X +Xstatic int +Xcom_init(c, filename) +X struct compiling *c; +X char *filename; +X{ +X if ((c->c_code = newsizedstringobject((char *)NULL, 0)) == NULL) +X goto fail_3; +X if ((c->c_consts = newlistobject(0)) == NULL) +X goto fail_2; +X if ((c->c_names = newlistobject(0)) == NULL) +X goto fail_1; +X c->c_nexti = 0; +X c->c_errors = 0; +X c->c_infunction = 0; +X c->c_loops = 0; +X c->c_filename = filename; +X return 1; +X +X fail_1: +X DECREF(c->c_consts); +X fail_2: +X DECREF(c->c_code); +X fail_3: +X return 0; +X} +X +Xstatic void +Xcom_free(c) +X struct compiling *c; +X{ +X XDECREF(c->c_code); +X XDECREF(c->c_consts); +X XDECREF(c->c_names); +X} +X +Xstatic void +Xcom_done(c) +X struct compiling *c; +X{ +X if (c->c_code != NULL) +X resizestring(&c->c_code, c->c_nexti); +X} +X +Xstatic void +Xcom_addbyte(c, byte) +X struct compiling *c; +X int byte; +X{ +X int len; +X if (byte < 0 || byte > 255) { +X fprintf(stderr, "XXX compiling bad byte: %d\n", byte); +X abort(); +X err_setstr(SystemError, "com_addbyte: byte out of range"); +X c->c_errors++; +X } +X if (c->c_code == NULL) +X return; +X len = getstringsize(c->c_code); +X if (c->c_nexti >= len) { +X if (resizestring(&c->c_code, len+1000) != 0) { +X c->c_errors++; +X return; +X } +X } +X getstringvalue(c->c_code)[c->c_nexti++] = byte; +X} +X +Xstatic void +Xcom_addint(c, x) +X struct compiling *c; +X int x; +X{ +X com_addbyte(c, x & 0xff); +X com_addbyte(c, x >> 8); /* XXX x should be positive */ +X} +X +Xstatic void +Xcom_addoparg(c, op, arg) +X struct compiling *c; +X int op; +X int arg; +X{ +X com_addbyte(c, op); +X com_addint(c, arg); +X} +X +Xstatic void +Xcom_addfwref(c, op, p_anchor) +X struct compiling *c; +X int op; +X int *p_anchor; +X{ +X /* Compile a forward reference for backpatching */ +X int here; +X int anchor; +X com_addbyte(c, op); +X here = c->c_nexti; +X anchor = *p_anchor; +X *p_anchor = here; +X com_addint(c, anchor == 0 ? 0 : here - anchor); +X} +X +Xstatic void +Xcom_backpatch(c, anchor) +X struct compiling *c; +X int anchor; /* Must be nonzero */ +X{ +X unsigned char *code = (unsigned char *) getstringvalue(c->c_code); +X int target = c->c_nexti; +X int lastanchor = 0; +X int dist; +X int prev; +X for (;;) { +X /* Make the JUMP instruction at anchor point to target */ +X prev = code[anchor] + (code[anchor+1] << 8); +X dist = target - (anchor+2); +X code[anchor] = dist & 0xff; +X code[anchor+1] = dist >> 8; +X if (!prev) +X break; +X lastanchor = anchor; +X anchor -= prev; +X } +X} +X +X/* Handle constants and names uniformly */ +X +Xstatic int +Xcom_add(c, list, v) +X struct compiling *c; +X object *list; +X object *v; +X{ +X int n = getlistsize(list); +X int i; +X for (i = n; --i >= 0; ) { +X object *w = getlistitem(list, i); +X if (cmpobject(v, w) == 0) +X return i; +X } +X if (addlistitem(list, v) != 0) +X c->c_errors++; +X return n; +X} +X +Xstatic int +Xcom_addconst(c, v) +X struct compiling *c; +X object *v; +X{ +X return com_add(c, c->c_consts, v); +X} +X +Xstatic int +Xcom_addname(c, v) +X struct compiling *c; +X object *v; +X{ +X return com_add(c, c->c_names, v); +X} +X +Xstatic void +Xcom_addopname(c, op, n) +X struct compiling *c; +X int op; +X node *n; +X{ +X object *v; +X int i; +X char *name; +X if (TYPE(n) == STAR) +X name = "*"; +X else { +X REQ(n, NAME); +X name = STR(n); +X } +X if ((v = newstringobject(name)) == NULL) { +X c->c_errors++; +X i = 255; +X } +X else { +X i = com_addname(c, v); +X DECREF(v); +X } +X com_addoparg(c, op, i); +X} +X +Xstatic object * +Xparsenumber(s) +X char *s; +X{ +X extern long strtol(); +X extern double atof(); +X char *end = s; +X long x; +X x = strtol(s, &end, 0); +X if (*end == '\0') +X return newintobject(x); +X if (*end == '.' || *end == 'e' || *end == 'E') +X return newfloatobject(atof(s)); +X err_setstr(RuntimeError, "bad number syntax"); +X return NULL; +X} +X +Xstatic object * +Xparsestr(s) +X char *s; +X{ +X object *v; +X int len; +X char *buf; +X char *p; +X int c; +X if (*s != '\'') { +X err_badcall(); +X return NULL; +X } +X s++; +X len = strlen(s); +X if (s[--len] != '\'') { +X err_badcall(); +X return NULL; +X } +X if (strchr(s, '\\') == NULL) +X return newsizedstringobject(s, len); +X v = newsizedstringobject((char *)NULL, len); +X p = buf = getstringvalue(v); +X while (*s != '\0' && *s != '\'') { +X if (*s != '\\') { +X *p++ = *s++; +X continue; +X } +X s++; +X switch (*s++) { +X /* XXX This assumes ASCII! */ +X case '\\': *p++ = '\\'; break; +X case '\'': *p++ = '\''; break; +X case 'b': *p++ = '\b'; break; +X case 'f': *p++ = '\014'; break; /* FF */ +X case 't': *p++ = '\t'; break; +X case 'n': *p++ = '\n'; break; +X case 'r': *p++ = '\r'; break; +X case 'v': *p++ = '\013'; break; /* VT */ +X case 'E': *p++ = '\033'; break; /* ESC, not C */ +X case 'a': *p++ = '\007'; break; /* BEL, not classic C */ +X case '0': case '1': case '2': case '3': +X case '4': case '5': case '6': case '7': +X c = s[-1] - '0'; +X if ('0' <= *s && *s <= '7') { +X c = (c<<3) + *s++ - '0'; +X if ('0' <= *s && *s <= '7') +X c = (c<<3) + *s++ - '0'; +X } +X *p++ = c; +X break; +X case 'x': +X if (isxdigit(*s)) { +X sscanf(s, "%x", &c); +X *p++ = c; +X do { +X s++; +X } while (isxdigit(*s)); +X break; +X } +X /* FALLTHROUGH */ +X default: *p++ = '\\'; *p++ = s[-1]; break; +X } +X } +X resizestring(&v, (int)(p - buf)); +X return v; +X} +X +Xstatic void +Xcom_list_constructor(c, n) +X struct compiling *c; +X node *n; +X{ +X int len; +X int i; +X object *v, *w; +X if (TYPE(n) != testlist) +X REQ(n, exprlist); +X /* exprlist: expr (',' expr)* [',']; likewise for testlist */ +X len = (NCH(n) + 1) / 2; +X for (i = 0; i < NCH(n); i += 2) +X com_node(c, CHILD(n, i)); +X com_addoparg(c, BUILD_LIST, len); +X} +X +Xstatic void +Xcom_atom(c, n) +X struct compiling *c; +X node *n; +X{ +X node *ch; +X object *v; +X int i; +X REQ(n, atom); +X ch = CHILD(n, 0); +X switch (TYPE(ch)) { +X case LPAR: +X if (TYPE(CHILD(n, 1)) == RPAR) +X com_addoparg(c, BUILD_TUPLE, 0); +X else +X com_node(c, CHILD(n, 1)); +X break; +X case LSQB: +X if (TYPE(CHILD(n, 1)) == RSQB) +X com_addoparg(c, BUILD_LIST, 0); +X else +X com_list_constructor(c, CHILD(n, 1)); +X break; +X case LBRACE: +X com_addoparg(c, BUILD_MAP, 0); +X break; +X case BACKQUOTE: +X com_node(c, CHILD(n, 1)); +X com_addbyte(c, UNARY_CONVERT); +X break; +X case NUMBER: +X if ((v = parsenumber(STR(ch))) == NULL) { +X c->c_errors++; +X i = 255; +X } +X else { +X i = com_addconst(c, v); +X DECREF(v); +X } +X com_addoparg(c, LOAD_CONST, i); +X break; +X case STRING: +X if ((v = parsestr(STR(ch))) == NULL) { +X c->c_errors++; +X i = 255; +X } +X else { +X i = com_addconst(c, v); +X DECREF(v); +X } +X com_addoparg(c, LOAD_CONST, i); +X break; +X case NAME: +X com_addopname(c, LOAD_NAME, ch); +X break; +X default: +X fprintf(stderr, "node type %d\n", TYPE(ch)); +X err_setstr(SystemError, "com_atom: unexpected node type"); +X c->c_errors++; +X } +X} +X +Xstatic void +Xcom_slice(c, n, op) +X struct compiling *c; +X node *n; +X int op; +X{ +X if (NCH(n) == 1) { +X com_addbyte(c, op); +X } +X else if (NCH(n) == 2) { +X if (TYPE(CHILD(n, 0)) != COLON) { +X com_node(c, CHILD(n, 0)); +X com_addbyte(c, op+1); +X } +X else { +X com_node(c, CHILD(n, 1)); +X com_addbyte(c, op+2); +X } +X } +X else { +X com_node(c, CHILD(n, 0)); +X com_node(c, CHILD(n, 2)); +X com_addbyte(c, op+3); +X } +X} +X +Xstatic void +Xcom_apply_subscript(c, n) +X struct compiling *c; +X node *n; +X{ +X REQ(n, subscript); +X if (NCH(n) == 1 && TYPE(CHILD(n, 0)) != COLON) { +X /* It's a single subscript */ +X com_node(c, CHILD(n, 0)); +X com_addbyte(c, BINARY_SUBSCR); +X } +X else { +X /* It's a slice: [expr] ':' [expr] */ +X com_slice(c, n, SLICE); +X } +X} +X +Xstatic void +Xcom_call_function(c, n) +X struct compiling *c; +X node *n; /* EITHER testlist OR ')' */ +X{ +X if (TYPE(n) == RPAR) { +X com_addbyte(c, UNARY_CALL); +X } +X else { +X com_node(c, n); +X com_addbyte(c, BINARY_CALL); +X } +X} +X +Xstatic void +Xcom_select_member(c, n) +X struct compiling *c; +X node *n; +X{ +X com_addopname(c, LOAD_ATTR, n); +X} +X +Xstatic void +Xcom_apply_trailer(c, n) +X struct compiling *c; +X node *n; +X{ +X REQ(n, trailer); +X switch (TYPE(CHILD(n, 0))) { +X case LPAR: +X com_call_function(c, CHILD(n, 1)); +X break; +X case DOT: +X com_select_member(c, CHILD(n, 1)); +X break; +X case LSQB: +X com_apply_subscript(c, CHILD(n, 1)); +X break; +X default: +X err_setstr(SystemError, +X "com_apply_trailer: unknown trailer type"); +X c->c_errors++; +X } +X} +X +Xstatic void +Xcom_factor(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X REQ(n, factor); +X if (TYPE(CHILD(n, 0)) == PLUS) { +X com_factor(c, CHILD(n, 1)); +X com_addbyte(c, UNARY_POSITIVE); +X } +X else if (TYPE(CHILD(n, 0)) == MINUS) { +X com_factor(c, CHILD(n, 1)); +X com_addbyte(c, UNARY_NEGATIVE); +X } +X else { +X com_atom(c, CHILD(n, 0)); +X for (i = 1; i < NCH(n); i++) +X com_apply_trailer(c, CHILD(n, i)); +X } +X} +X +Xstatic void +Xcom_term(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X int op; +X REQ(n, term); +X com_factor(c, CHILD(n, 0)); +X for (i = 2; i < NCH(n); i += 2) { +X com_factor(c, CHILD(n, i)); +X switch (TYPE(CHILD(n, i-1))) { +X case STAR: +X op = BINARY_MULTIPLY; +X break; +X case SLASH: +X op = BINARY_DIVIDE; +X break; +X case PERCENT: +X op = BINARY_MODULO; +X break; +X default: +X err_setstr(SystemError, +X "com_term: term operator not *, / or %"); +X c->c_errors++; +X op = 255; +X } +X com_addbyte(c, op); +X } +X} +X +Xstatic void +Xcom_expr(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X int op; +X REQ(n, expr); +X com_term(c, CHILD(n, 0)); +X for (i = 2; i < NCH(n); i += 2) { +X com_term(c, CHILD(n, i)); +X switch (TYPE(CHILD(n, i-1))) { +X case PLUS: +X op = BINARY_ADD; +X break; +X case MINUS: +X op = BINARY_SUBTRACT; +X break; +X default: +X err_setstr(SystemError, +X "com_expr: expr operator not + or -"); +X c->c_errors++; +X op = 255; +X } +X com_addbyte(c, op); +X } +X} +X +Xstatic enum cmp_op +Xcmp_type(n) +X node *n; +X{ +X REQ(n, comp_op); +X /* comp_op: '<' | '>' | '=' | '>' '=' | '<' '=' | '<' '>' +X | 'in' | 'not' 'in' | 'is' | 'is' not' */ +X if (NCH(n) == 1) { +X n = CHILD(n, 0); +X switch (TYPE(n)) { +X case LESS: return LT; +X case GREATER: return GT; +X case EQUAL: return EQ; +X case NAME: if (strcmp(STR(n), "in") == 0) return IN; +X if (strcmp(STR(n), "is") == 0) return IS; +X } +X } +X else if (NCH(n) == 2) { +X int t2 = TYPE(CHILD(n, 1)); +X switch (TYPE(CHILD(n, 0))) { +X case LESS: if (t2 == EQUAL) return LE; +X if (t2 == GREATER) return NE; +X break; +X case GREATER: if (t2 == EQUAL) return GE; +X break; +X case NAME: if (strcmp(STR(CHILD(n, 1)), "in") == 0) +X return NOT_IN; +X if (strcmp(STR(CHILD(n, 0)), "is") == 0) +X return IS_NOT; +X } +X } +X return BAD; +X} +X +Xstatic void +Xcom_comparison(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X enum cmp_op op; +X int anchor; +X REQ(n, comparison); /* comparison: expr (comp_op expr)* */ +X com_expr(c, CHILD(n, 0)); +X if (NCH(n) == 1) +X return; +X +X /**************************************************************** +X The following code is generated for all but the last +X comparison in a chain: +X +X label: on stack: opcode: jump to: +X +X a <code to load b> +X a, b DUP_TOP +X a, b, b ROT_THREE +X b, a, b COMPARE_OP +X b, 0-or-1 JUMP_IF_FALSE L1 +X b, 1 POP_TOP +X b +X +X We are now ready to repeat this sequence for the next +X comparison in the chain. +X +X For the last we generate: +X +X b <code to load c> +X b, c COMPARE_OP +X 0-or-1 +X +X If there were any jumps to L1 (i.e., there was more than one +X comparison), we generate: +X +X 0-or-1 JUMP_FORWARD L2 +X L1: b, 0 ROT_TWO +X 0, b POP_TOP +X 0 +X L2: +X ****************************************************************/ +X +X anchor = 0; +X +X for (i = 2; i < NCH(n); i += 2) { +X com_expr(c, CHILD(n, i)); +X if (i+2 < NCH(n)) { +X com_addbyte(c, DUP_TOP); +X com_addbyte(c, ROT_THREE); +X } +X op = cmp_type(CHILD(n, i-1)); +X if (op == BAD) { +X err_setstr(SystemError, +X "com_comparison: unknown comparison op"); +X c->c_errors++; +X } +X com_addoparg(c, COMPARE_OP, op); +X if (i+2 < NCH(n)) { +X com_addfwref(c, JUMP_IF_FALSE, &anchor); +X com_addbyte(c, POP_TOP); +X } +X } +X +X if (anchor) { +X int anchor2 = 0; +X com_addfwref(c, JUMP_FORWARD, &anchor2); +X com_backpatch(c, anchor); +X com_addbyte(c, ROT_TWO); +X com_addbyte(c, POP_TOP); +X com_backpatch(c, anchor2); +X } +X} +X +Xstatic void +Xcom_not_test(c, n) +X struct compiling *c; +X node *n; +X{ +X REQ(n, not_test); /* 'not' not_test | comparison */ +X if (NCH(n) == 1) { +X com_comparison(c, CHILD(n, 0)); +X } +X else { +X com_not_test(c, CHILD(n, 1)); +X com_addbyte(c, UNARY_NOT); +X } +X} +X +Xstatic void +Xcom_and_test(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X int anchor; +X REQ(n, and_test); /* not_test ('and' not_test)* */ +X anchor = 0; +X i = 0; +X for (;;) { +X com_not_test(c, CHILD(n, i)); +X if ((i += 2) >= NCH(n)) +X break; +X com_addfwref(c, JUMP_IF_FALSE, &anchor); +X com_addbyte(c, POP_TOP); +X } +X if (anchor) +X com_backpatch(c, anchor); +X} +X +Xstatic void +Xcom_test(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X int anchor; +X REQ(n, test); /* and_test ('and' and_test)* */ +X anchor = 0; +X i = 0; +X for (;;) { +X com_and_test(c, CHILD(n, i)); +X if ((i += 2) >= NCH(n)) +X break; +X com_addfwref(c, JUMP_IF_TRUE, &anchor); +X com_addbyte(c, POP_TOP); +X } +X if (anchor) +X com_backpatch(c, anchor); +X} +X +Xstatic void +Xcom_list(c, n) +X struct compiling *c; +X node *n; +X{ +X /* exprlist: expr (',' expr)* [',']; likewise for testlist */ +X if (NCH(n) == 1) { +X com_node(c, CHILD(n, 0)); +X } +X else { +X int i; +X int len; +X len = (NCH(n) + 1) / 2; +X for (i = 0; i < NCH(n); i += 2) +X com_node(c, CHILD(n, i)); +X com_addoparg(c, BUILD_TUPLE, len); +X } +X} +X +X +X/* Begin of assignment compilation */ +X +Xstatic void com_assign_name PROTO((struct compiling *, node *, int)); +Xstatic void com_assign PROTO((struct compiling *, node *, int)); +X +Xstatic void +Xcom_assign_attr(c, n, assigning) +X struct compiling *c; +X node *n; +X int assigning; +X{ +X com_addopname(c, assigning ? STORE_ATTR : DELETE_ATTR, n); +X} +X +Xstatic void +Xcom_assign_slice(c, n, assigning) +X struct compiling *c; +X node *n; +X int assigning; +X{ +X com_slice(c, n, assigning ? STORE_SLICE : DELETE_SLICE); +X} +X +Xstatic void +Xcom_assign_subscript(c, n, assigning) +X struct compiling *c; +X node *n; +X int assigning; +X{ +X com_node(c, n); +X com_addbyte(c, assigning ? STORE_SUBSCR : DELETE_SUBSCR); +X} +X +Xstatic void +Xcom_assign_trailer(c, n, assigning) +X struct compiling *c; +X node *n; +X int assigning; +X{ +X char *name; +X REQ(n, trailer); +X switch (TYPE(CHILD(n, 0))) { +X case LPAR: /* '(' [exprlist] ')' */ +X err_setstr(TypeError, "can't assign to function call"); +X c->c_errors++; +X break; +X case DOT: /* '.' NAME */ +X com_assign_attr(c, CHILD(n, 1), assigning); +X break; +X case LSQB: /* '[' subscript ']' */ +X n = CHILD(n, 1); +X REQ(n, subscript); /* subscript: expr | [expr] ':' [expr] */ +X if (NCH(n) > 1 || TYPE(CHILD(n, 0)) == COLON) +X com_assign_slice(c, n, assigning); +X else +X com_assign_subscript(c, CHILD(n, 0), assigning); +X break; +X default: +X err_setstr(TypeError, "unknown trailer type"); +X c->c_errors++; +X } +X} +X +Xstatic void +Xcom_assign_tuple(c, n, assigning) +X struct compiling *c; +X node *n; +X int assigning; +X{ +X int i; +X if (TYPE(n) != testlist) +X REQ(n, exprlist); +X if (assigning) +X com_addoparg(c, UNPACK_TUPLE, (NCH(n)+1)/2); +X for (i = 0; i < NCH(n); i += 2) +X com_assign(c, CHILD(n, i), assigning); +X} +X +Xstatic void +Xcom_assign_list(c, n, assigning) +X struct compiling *c; +X node *n; +X int assigning; +X{ +X int i; +X if (assigning) +X com_addoparg(c, UNPACK_LIST, (NCH(n)+1)/2); +X for (i = 0; i < NCH(n); i += 2) +X com_assign(c, CHILD(n, i), assigning); +X} +X +Xstatic void +Xcom_assign_name(c, n, assigning) +X struct compiling *c; +X node *n; +X int assigning; +X{ +X REQ(n, NAME); +X com_addopname(c, assigning ? STORE_NAME : DELETE_NAME, n); +X} +X +Xstatic void +Xcom_assign(c, n, assigning) +X struct compiling *c; +X node *n; +X int assigning; +X{ +X /* Loop to avoid trivial recursion */ +X for (;;) { +X switch (TYPE(n)) { +X +X case exprlist: +X case testlist: +X if (NCH(n) > 1) { +X com_assign_tuple(c, n, assigning); +X return; +X } +X n = CHILD(n, 0); +X break; +X +X case test: +X case and_test: +X case not_test: +X if (NCH(n) > 1) { +X err_setstr(TypeError, +X "can't assign to operator"); +X c->c_errors++; +X return; +X } +X n = CHILD(n, 0); +X break; +X +X case comparison: +X if (NCH(n) > 1) { +X err_setstr(TypeError, +X "can't assign to operator"); +X c->c_errors++; +X return; +X } +X n = CHILD(n, 0); +X break; +X +X case expr: +X if (NCH(n) > 1) { +X err_setstr(TypeError, +X "can't assign to operator"); +X c->c_errors++; +X return; +X } +X n = CHILD(n, 0); +X break; +X +X case term: +X if (NCH(n) > 1) { +X err_setstr(TypeError, +X "can't assign to operator"); +X c->c_errors++; +X return; +X } +X n = CHILD(n, 0); +X break; +X +X case factor: /* ('+'|'-') factor | atom trailer* */ +X if (TYPE(CHILD(n, 0)) != atom) { /* '+' | '-' */ +X err_setstr(TypeError, +X "can't assign to operator"); +X c->c_errors++; +X return; +X } +X if (NCH(n) > 1) { /* trailer present */ +X int i; +X com_node(c, CHILD(n, 0)); +X for (i = 1; i+1 < NCH(n); i++) { +X com_apply_trailer(c, CHILD(n, i)); +X } /* NB i is still alive */ +X com_assign_trailer(c, +X CHILD(n, i), assigning); +X return; +X } +X n = CHILD(n, 0); +X break; +X +X case atom: +X switch (TYPE(CHILD(n, 0))) { +X case LPAR: +X n = CHILD(n, 1); +X if (TYPE(n) == RPAR) { +X /* XXX Should allow () = () ??? */ +X err_setstr(TypeError, +X "can't assign to ()"); +X c->c_errors++; +X return; +X } +X break; +X case LSQB: +X n = CHILD(n, 1); +X if (TYPE(n) == RSQB) { +X err_setstr(TypeError, +X "can't assign to []"); +X c->c_errors++; +X return; +X } +X com_assign_list(c, n, assigning); +X return; +X case NAME: +X com_assign_name(c, CHILD(n, 0), assigning); +X return; +X default: +X err_setstr(TypeError, +X "can't assign to constant"); +X c->c_errors++; +X return; +X } +X break; +X +X default: +X fprintf(stderr, "node type %d\n", TYPE(n)); +X err_setstr(SystemError, "com_assign: bad node"); +X c->c_errors++; +X return; +X +X } +X } +X} +X +Xstatic void +Xcom_expr_stmt(c, n) +X struct compiling *c; +X node *n; +X{ +X REQ(n, expr_stmt); /* exprlist ('=' exprlist)* NEWLINE */ +X com_node(c, CHILD(n, NCH(n)-2)); +X if (NCH(n) == 2) { +X com_addbyte(c, PRINT_EXPR); +X } +X else { +X int i; +X for (i = 0; i < NCH(n)-3; i+=2) { +X if (i+2 < NCH(n)-3) +X com_addbyte(c, DUP_TOP); +X com_assign(c, CHILD(n, i), 1/*assign*/); +X } +X } +X} +X +Xstatic void +Xcom_print_stmt(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X REQ(n, print_stmt); /* 'print' (test ',')* [test] NEWLINE */ +X for (i = 1; i+1 < NCH(n); i += 2) { +X com_node(c, CHILD(n, i)); +X com_addbyte(c, PRINT_ITEM); +X } +X if (TYPE(CHILD(n, NCH(n)-2)) != COMMA) +X com_addbyte(c, PRINT_NEWLINE); +X /* XXX Alternatively, LOAD_CONST '\n' and then PRINT_ITEM */ +X} +X +Xstatic void +Xcom_return_stmt(c, n) +X struct compiling *c; +X node *n; +X{ +X REQ(n, return_stmt); /* 'return' [testlist] NEWLINE */ +X if (!c->c_infunction) { +X err_setstr(TypeError, "'return' outside function"); +X c->c_errors++; +X } +X if (NCH(n) == 2) +X com_addoparg(c, LOAD_CONST, com_addconst(c, None)); +X else +X com_node(c, CHILD(n, 1)); +X com_addbyte(c, RETURN_VALUE); +X} +X +Xstatic void +Xcom_raise_stmt(c, n) +X struct compiling *c; +X node *n; +X{ +X REQ(n, raise_stmt); /* 'raise' expr [',' expr] NEWLINE */ +X com_node(c, CHILD(n, 1)); +X if (NCH(n) > 3) +X com_node(c, CHILD(n, 3)); +X else +X com_addoparg(c, LOAD_CONST, com_addconst(c, None)); +X com_addbyte(c, RAISE_EXCEPTION); +X} +X +Xstatic void +Xcom_import_stmt(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X REQ(n, import_stmt); +X /* 'import' NAME (',' NAME)* NEWLINE | +X 'from' NAME 'import' ('*' | NAME (',' NAME)*) NEWLINE */ +X if (STR(CHILD(n, 0))[0] == 'f') { +X /* 'from' NAME 'import' ... */ +X REQ(CHILD(n, 1), NAME); +X com_addopname(c, IMPORT_NAME, CHILD(n, 1)); +X for (i = 3; i < NCH(n); i += 2) +X com_addopname(c, IMPORT_FROM, CHILD(n, i)); +X com_addbyte(c, POP_TOP); +X } +X else { +X /* 'import' ... */ +X for (i = 1; i < NCH(n); i += 2) { +X com_addopname(c, IMPORT_NAME, CHILD(n, i)); +X com_addopname(c, STORE_NAME, CHILD(n, i)); +X } +X } +X} +X +Xstatic void +Xcom_if_stmt(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X int anchor = 0; +X REQ(n, if_stmt); +X /*'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] */ +X for (i = 0; i+3 < NCH(n); i+=4) { +X int a = 0; +X node *ch = CHILD(n, i+1); +X if (i > 0) +X com_addoparg(c, SET_LINENO, ch->n_lineno); +X com_node(c, CHILD(n, i+1)); +X com_addfwref(c, JUMP_IF_FALSE, &a); +X com_addbyte(c, POP_TOP); +X com_node(c, CHILD(n, i+3)); +X com_addfwref(c, JUMP_FORWARD, &anchor); +X com_backpatch(c, a); +X com_addbyte(c, POP_TOP); +X } +X if (i+2 < NCH(n)) +X com_node(c, CHILD(n, i+2)); +X com_backpatch(c, anchor); +X} +X +Xstatic void +Xcom_while_stmt(c, n) +X struct compiling *c; +X node *n; +X{ +X int break_anchor = 0; +X int anchor = 0; +X int begin; +X REQ(n, while_stmt); /* 'while' test ':' suite ['else' ':' suite] */ +X com_addfwref(c, SETUP_LOOP, &break_anchor); +X begin = c->c_nexti; +X com_addoparg(c, SET_LINENO, n->n_lineno); +X com_node(c, CHILD(n, 1)); +X com_addfwref(c, JUMP_IF_FALSE, &anchor); +X com_addbyte(c, POP_TOP); +X c->c_loops++; +X com_node(c, CHILD(n, 3)); +X c->c_loops--; +X com_addoparg(c, JUMP_ABSOLUTE, begin); +X com_backpatch(c, anchor); +X com_addbyte(c, POP_TOP); +X com_addbyte(c, POP_BLOCK); +X if (NCH(n) > 4) +X com_node(c, CHILD(n, 6)); +X com_backpatch(c, break_anchor); +X} +X +Xstatic void +Xcom_for_stmt(c, n) +X struct compiling *c; +X node *n; +X{ +X object *v; +X int break_anchor = 0; +X int anchor = 0; +X int begin; +X REQ(n, for_stmt); +X /* 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite] */ +X com_addfwref(c, SETUP_LOOP, &break_anchor); +X com_node(c, CHILD(n, 3)); +X v = newintobject(0L); +X if (v == NULL) +X c->c_errors++; +X com_addoparg(c, LOAD_CONST, com_addconst(c, v)); +X XDECREF(v); +X begin = c->c_nexti; +X com_addoparg(c, SET_LINENO, n->n_lineno); +X com_addfwref(c, FOR_LOOP, &anchor); +X com_assign(c, CHILD(n, 1), 1/*assigning*/); +X c->c_loops++; +X com_node(c, CHILD(n, 5)); +X c->c_loops--; +X com_addoparg(c, JUMP_ABSOLUTE, begin); +X com_backpatch(c, anchor); +X com_addbyte(c, POP_BLOCK); +X if (NCH(n) > 8) +X com_node(c, CHILD(n, 8)); +X com_backpatch(c, break_anchor); +X} +X +X/* Although 'execpt' and 'finally' clauses can be combined +X syntactically, they are compiled separately. In fact, +X try: S +X except E1: S1 +X except E2: S2 +X ... +X finally: Sf +X is equivalent to +X try: +X try: S +X except E1: S1 +X except E2: S2 +X ... +X finally: Sf +X meaning that the 'finally' clause is entered even if things +X go wrong again in an exception handler. Note that this is +X not the case for exception handlers: at most one is entered. +X +X Code generated for "try: S finally: Sf" is as follows: +X +X SETUP_FINALLY L +X <code for S> +X POP_BLOCK +X LOAD_CONST <nil> +X L: <code for Sf> +X END_FINALLY +X +X The special instructions use the block stack. Each block +X stack entry contains the instruction that created it (here +X SETUP_FINALLY), the level of the value stack at the time the +X block stack entry was created, and a label (here L). +X +X SETUP_FINALLY: +X Pushes the current value stack level and the label +X onto the block stack. +X POP_BLOCK: +X Pops en entry from the block stack, and pops the value +X stack until its level is the same as indicated on the +X block stack. (The label is ignored.) +X END_FINALLY: +X Pops a variable number of entries from the *value* stack +X and re-raises the exception they specify. The number of +X entries popped depends on the (pseudo) exception type. +X +X The block stack is unwound when an exception is raised: +X when a SETUP_FINALLY entry is found, the exception is pushed +X onto the value stack (and the exception condition is cleared), +X and the interpreter jumps to the label gotten from the block +X stack. +X +X Code generated for "try: S except E1, V1: S1 except E2, V2: S2 ...": +X (The contents of the value stack is shown in [], with the top +X at the right; 'tb' is trace-back info, 'val' the exception's +X associated value, and 'exc' the exception.) +X +X Value stack Label Instruction Argument +X [] SETUP_EXCEPT L1 +X [] <code for S> +X [] POP_BLOCK +X [] JUMP_FORWARD L0 +X +X [tb, val, exc] L1: DUP ) +X [tb, val, exc, exc] <evaluate E1> ) +X [tb, val, exc, exc, E1] COMPARE_OP EXC_MATCH ) only if E1 +X [tb, val, exc, 1-or-0] JUMP_IF_FALSE L2 ) +X [tb, val, exc, 1] POP ) +X [tb, val, exc] POP +X [tb, val] <assign to V1> (or POP if no V1) +X [tb] POP +X [] <code for S1> +X JUMP_FORWARD L0 +X +X [tb, val, exc, 0] L2: POP +X [tb, val, exc] DUP +X .............................etc....................... +X +X [tb, val, exc, 0] Ln+1: POP +X [tb, val, exc] END_FINALLY # re-raise exception +X +X [] L0: <next statement> +X +X Of course, parts are not generated if Vi or Ei is not present. +X*/ +X +Xstatic void +Xcom_try_stmt(c, n) +X struct compiling *c; +X node *n; +X{ +X int finally_anchor = 0; +X int except_anchor = 0; +X REQ(n, try_stmt); +X /* 'try' ':' suite (except_clause ':' suite)* ['finally' ':' suite] */ +X +X if (NCH(n) > 3 && TYPE(CHILD(n, NCH(n)-3)) != except_clause) { +X /* Have a 'finally' clause */ +X com_addfwref(c, SETUP_FINALLY, &finally_anchor); +X } +X if (NCH(n) > 3 && TYPE(CHILD(n, 3)) == except_clause) { +X /* Have an 'except' clause */ +X com_addfwref(c, SETUP_EXCEPT, &except_anchor); +X } +X com_node(c, CHILD(n, 2)); +X if (except_anchor) { +X int end_anchor = 0; +X int i; +X node *ch; +X com_addbyte(c, POP_BLOCK); +X com_addfwref(c, JUMP_FORWARD, &end_anchor); +X com_backpatch(c, except_anchor); +X for (i = 3; +X i < NCH(n) && TYPE(ch = CHILD(n, i)) == except_clause; +X i += 3) { +X /* except_clause: 'except' [expr [',' expr]] */ +X if (except_anchor == 0) { +X err_setstr(TypeError, +X "default 'except:' must be last"); +X c->c_errors++; +X break; +X } +X except_anchor = 0; +X com_addoparg(c, SET_LINENO, ch->n_lineno); +X if (NCH(ch) > 1) { +X com_addbyte(c, DUP_TOP); +X com_node(c, CHILD(ch, 1)); +X com_addoparg(c, COMPARE_OP, EXC_MATCH); +X com_addfwref(c, JUMP_IF_FALSE, &except_anchor); +X com_addbyte(c, POP_TOP); +X } +X com_addbyte(c, POP_TOP); +X if (NCH(ch) > 3) +X com_assign(c, CHILD(ch, 3), 1/*assigning*/); +X else +X com_addbyte(c, POP_TOP); +X com_addbyte(c, POP_TOP); +X com_node(c, CHILD(n, i+2)); +X com_addfwref(c, JUMP_FORWARD, &end_anchor); +X if (except_anchor) { +X com_backpatch(c, except_anchor); +X com_addbyte(c, POP_TOP); +X } +X } +X com_addbyte(c, END_FINALLY); +X com_backpatch(c, end_anchor); +X } +X if (finally_anchor) { +X node *ch; +X com_addbyte(c, POP_BLOCK); +X com_addoparg(c, LOAD_CONST, com_addconst(c, None)); +X com_backpatch(c, finally_anchor); +X ch = CHILD(n, NCH(n)-1); +X com_addoparg(c, SET_LINENO, ch->n_lineno); +X com_node(c, ch); +X com_addbyte(c, END_FINALLY); +X } +X} +X +Xstatic void +Xcom_suite(c, n) +X struct compiling *c; +X node *n; +X{ +X REQ(n, suite); +X /* simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT */ +X if (NCH(n) == 1) { +X com_node(c, CHILD(n, 0)); +X } +X else { +X int i; +X for (i = 0; i < NCH(n); i++) { +X node *ch = CHILD(n, i); +X if (TYPE(ch) == stmt) +X com_node(c, ch); +X } +X } +X} +X +Xstatic void +Xcom_funcdef(c, n) +X struct compiling *c; +X node *n; +X{ +X object *v; +X REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */ +X v = (object *)compile(n, c->c_filename); +X if (v == NULL) +X c->c_errors++; +X else { +X int i = com_addconst(c, v); +X com_addoparg(c, LOAD_CONST, i); +X com_addbyte(c, BUILD_FUNCTION); +X com_addopname(c, STORE_NAME, CHILD(n, 1)); +X DECREF(v); +X } +X} +X +Xstatic void +Xcom_bases(c, n) +X struct compiling *c; +X node *n; +X{ +X int i, nbases; +X REQ(n, baselist); +X /* +X baselist: atom arguments (',' atom arguments)* +X arguments: '(' [testlist] ')' +X */ +X for (i = 0; i < NCH(n); i += 3) +X com_node(c, CHILD(n, i)); +X com_addoparg(c, BUILD_TUPLE, (NCH(n)+1) / 3); +X} +X +Xstatic void +Xcom_classdef(c, n) +X struct compiling *c; +X node *n; +X{ +X object *v; +X REQ(n, classdef); +X /* +X classdef: 'class' NAME parameters ['=' baselist] ':' suite +X baselist: atom arguments (',' atom arguments)* +X arguments: '(' [testlist] ')' +X */ +X if (NCH(n) == 7) +X com_bases(c, CHILD(n, 4)); +X else +X com_addoparg(c, LOAD_CONST, com_addconst(c, None)); +X v = (object *)compile(n, c->c_filename); +X if (v == NULL) +X c->c_errors++; +X else { +X int i = com_addconst(c, v); +X com_addoparg(c, LOAD_CONST, i); +X com_addbyte(c, BUILD_FUNCTION); +X com_addbyte(c, UNARY_CALL); +X com_addbyte(c, BUILD_CLASS); +X com_addopname(c, STORE_NAME, CHILD(n, 1)); +X DECREF(v); +X } +X} +X +Xstatic void +Xcom_node(c, n) +X struct compiling *c; +X node *n; +X{ +X switch (TYPE(n)) { +X +X /* Definition nodes */ +X +X case funcdef: +X com_funcdef(c, n); +X break; +X case classdef: +X com_classdef(c, n); +X break; +X +X /* Trivial parse tree nodes */ +X +X case stmt: +X case flow_stmt: +X com_node(c, CHILD(n, 0)); +X break; +X +X case simple_stmt: +X case compound_stmt: +X com_addoparg(c, SET_LINENO, n->n_lineno); +X com_node(c, CHILD(n, 0)); +X break; +X +X /* Statement nodes */ +X +X case expr_stmt: +X com_expr_stmt(c, n); +X break; +X case print_stmt: +X com_print_stmt(c, n); +X break; +X case del_stmt: /* 'del' exprlist NEWLINE */ +X com_assign(c, CHILD(n, 1), 0/*delete*/); +X break; +X case pass_stmt: +X break; +X case break_stmt: +X if (c->c_loops == 0) { +X err_setstr(TypeError, "'break' outside loop"); +X c->c_errors++; +X } +X com_addbyte(c, BREAK_LOOP); +X break; +X case return_stmt: +X com_return_stmt(c, n); +X break; +X case raise_stmt: +X com_raise_stmt(c, n); +X break; +X case import_stmt: +X com_import_stmt(c, n); +X break; +X case if_stmt: +X com_if_stmt(c, n); +X break; +X case while_stmt: +X com_while_stmt(c, n); +X break; +X case for_stmt: +X com_for_stmt(c, n); +X break; +X case try_stmt: +X com_try_stmt(c, n); +X break; +X case suite: +X com_suite(c, n); +X break; +X +X /* Expression nodes */ +X +X case testlist: +X com_list(c, n); +X break; +X case test: +X com_test(c, n); +X break; +X case and_test: +X com_and_test(c, n); +X break; +X case not_test: +X com_not_test(c, n); +X break; +X case comparison: +X com_comparison(c, n); +X break; +X case exprlist: +X com_list(c, n); +X break; +X case expr: +X com_expr(c, n); +X break; +X case term: +X com_term(c, n); +X break; +X case factor: +X com_factor(c, n); +X break; +X case atom: +X com_atom(c, n); +X break; +X +X default: +X fprintf(stderr, "node type %d\n", TYPE(n)); +X err_setstr(SystemError, "com_node: unexpected node type"); +X c->c_errors++; +X } +X} +X +Xstatic void com_fplist PROTO((struct compiling *, node *)); +X +Xstatic void +Xcom_fpdef(c, n) +X struct compiling *c; +X node *n; +X{ +X REQ(n, fpdef); /* fpdef: NAME | '(' fplist ')' */ +X if (TYPE(CHILD(n, 0)) == LPAR) +X com_fplist(c, CHILD(n, 1)); +X else +X com_addopname(c, STORE_NAME, CHILD(n, 0)); +X} +X +Xstatic void +Xcom_fplist(c, n) +X struct compiling *c; +X node *n; +X{ +X REQ(n, fplist); /* fplist: fpdef (',' fpdef)* */ +X if (NCH(n) == 1) { +X com_fpdef(c, CHILD(n, 0)); +X } +X else { +X int i; +X com_addoparg(c, UNPACK_TUPLE, (NCH(n)+1)/2); +X for (i = 0; i < NCH(n); i += 2) +X com_fpdef(c, CHILD(n, i)); +X } +X} +X +Xstatic void +Xcom_file_input(c, n) +X struct compiling *c; +X node *n; +X{ +X int i; +X REQ(n, file_input); /* (NEWLINE | stmt)* ENDMARKER */ +X for (i = 0; i < NCH(n); i++) { +X node *ch = CHILD(n, i); +X if (TYPE(ch) != ENDMARKER && TYPE(ch) != NEWLINE) +X com_node(c, ch); +X } +X} +X +X/* Top-level compile-node interface */ +X +Xstatic void +Xcompile_funcdef(c, n) +X struct compiling *c; +X node *n; +X{ +X node *ch; +X REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */ +X ch = CHILD(n, 2); /* parameters: '(' [fplist] ')' */ +X ch = CHILD(ch, 1); /* ')' | fplist */ +X if (TYPE(ch) == RPAR) +X com_addbyte(c, REFUSE_ARGS); +X else { +X com_addbyte(c, REQUIRE_ARGS); +X com_fplist(c, ch); +X } +X c->c_infunction = 1; +X com_node(c, CHILD(n, 4)); +X c->c_infunction = 0; +X com_addoparg(c, LOAD_CONST, com_addconst(c, None)); +X com_addbyte(c, RETURN_VALUE); +X} +X +Xstatic void +Xcompile_node(c, n) +X struct compiling *c; +X node *n; +X{ +X com_addoparg(c, SET_LINENO, n->n_lineno); +X +X switch (TYPE(n)) { +X +X case single_input: /* One interactive command */ +X /* NEWLINE | simple_stmt | compound_stmt NEWLINE */ +X com_addbyte(c, REFUSE_ARGS); +X n = CHILD(n, 0); +X if (TYPE(n) != NEWLINE) +X com_node(c, n); +X com_addoparg(c, LOAD_CONST, com_addconst(c, None)); +X com_addbyte(c, RETURN_VALUE); +X break; +X +X case file_input: /* A whole file, or built-in function exec() */ +X com_addbyte(c, REFUSE_ARGS); +X com_file_input(c, n); +X com_addoparg(c, LOAD_CONST, com_addconst(c, None)); +X com_addbyte(c, RETURN_VALUE); +X break; +X +X case expr_input: /* Built-in function eval() */ +X com_addbyte(c, REFUSE_ARGS); +X com_node(c, CHILD(n, 0)); +X com_addbyte(c, RETURN_VALUE); +X break; +X +X case eval_input: /* Built-in function input() */ +X com_addbyte(c, REFUSE_ARGS); +X com_node(c, CHILD(n, 0)); +X com_addbyte(c, RETURN_VALUE); +X break; +X +X case funcdef: /* A function definition */ +X compile_funcdef(c, n); +X break; +X +X case classdef: /* A class definition */ +X /* 'class' NAME parameters ['=' baselist] ':' suite */ +X com_addbyte(c, REFUSE_ARGS); +X com_node(c, CHILD(n, NCH(n)-1)); +X com_addbyte(c, LOAD_LOCALS); +X com_addbyte(c, RETURN_VALUE); +X break; +X +X default: +X fprintf(stderr, "node type %d\n", TYPE(n)); +X err_setstr(SystemError, "compile_node: unexpected node type"); +X c->c_errors++; +X } +X} +X +Xcodeobject * +Xcompile(n, filename) +X node *n; +X char *filename; +X{ +X struct compiling sc; +X codeobject *co; +X if (!com_init(&sc, filename)) +X return NULL; +X compile_node(&sc, n); +X com_done(&sc); +X if (sc.c_errors == 0) +X co = newcodeobject(sc.c_code, sc.c_consts, sc.c_names, filename); +X else +X co = NULL; +X com_free(&sc); +X return co; +X} +EOF +fi +if test -s 'src/graminit.c' +then echo '*** I will not over-write existing file src/graminit.c' +else +echo 'x - src/graminit.c' +sed 's/^X//' > 'src/graminit.c' << 'EOF' +X/*********************************************************** +XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The +XNetherlands. +X +X All Rights Reserved +X +XPermission to use, copy, modify, and distribute this software and its +Xdocumentation for any purpose and without fee is hereby granted, +Xprovided that the above copyright notice appear in all copies and that +Xboth that copyright notice and this permission notice appear in +Xsupporting documentation, and that the names of Stichting Mathematisch +XCentrum or CWI not be used in advertising or publicity pertaining to +Xdistribution of the software without specific, written prior permission. +X +XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +X +X******************************************************************/ +X +X#include "pgenheaders.h" +X#include "grammar.h" +Xstatic arc arcs_0_0[3] = { +X {2, 1}, +X {3, 1}, +X {4, 2}, +X}; +Xstatic arc arcs_0_1[1] = { +X {0, 1}, +X}; +Xstatic arc arcs_0_2[1] = { +X {2, 1}, +X}; +Xstatic state states_0[3] = { +X {3, arcs_0_0}, +X {1, arcs_0_1}, +X {1, arcs_0_2}, +X}; +Xstatic arc arcs_1_0[3] = { +X {2, 0}, +X {6, 0}, +X {7, 1}, +X}; +Xstatic arc arcs_1_1[1] = { +X {0, 1}, +X}; +Xstatic state states_1[2] = { +X {3, arcs_1_0}, +X {1, arcs_1_1}, +X}; +Xstatic arc arcs_2_0[1] = { +X {9, 1}, +X}; +Xstatic arc arcs_2_1[1] = { +X {2, 2}, +X}; +Xstatic arc arcs_2_2[1] = { +X {0, 2}, +X}; +Xstatic state states_2[3] = { +X {1, arcs_2_0}, +X {1, arcs_2_1}, +X {1, arcs_2_2}, +X}; +Xstatic arc arcs_3_0[1] = { +X {9, 1}, +X}; +Xstatic arc arcs_3_1[1] = { +X {7, 2}, +X}; +Xstatic arc arcs_3_2[1] = { +X {0, 2}, +X}; +Xstatic state states_3[3] = { +X {1, arcs_3_0}, +X {1, arcs_3_1}, +X {1, arcs_3_2}, +X}; +Xstatic arc arcs_4_0[1] = { +X {12, 1}, +X}; +Xstatic arc arcs_4_1[1] = { +X {13, 2}, +X}; +Xstatic arc arcs_4_2[1] = { +X {14, 3}, +X}; +Xstatic arc arcs_4_3[1] = { +X {15, 4}, +X}; +Xstatic arc arcs_4_4[1] = { +X {16, 5}, +X}; +Xstatic arc arcs_4_5[1] = { +X {0, 5}, +X}; +Xstatic state states_4[6] = { +X {1, arcs_4_0}, +X {1, arcs_4_1}, +X {1, arcs_4_2}, +X {1, arcs_4_3}, +X {1, arcs_4_4}, +X {1, arcs_4_5}, +X}; +Xstatic arc arcs_5_0[1] = { +X {17, 1}, +X}; +Xstatic arc arcs_5_1[2] = { +X {18, 2}, +X {19, 3}, +X}; +Xstatic arc arcs_5_2[1] = { +X {19, 3}, +X}; +Xstatic arc arcs_5_3[1] = { +X {0, 3}, +X}; +Xstatic state states_5[4] = { +X {1, arcs_5_0}, +X {2, arcs_5_1}, +X {1, arcs_5_2}, +X {1, arcs_5_3}, +X}; +Xstatic arc arcs_6_0[1] = { +X {20, 1}, +X}; +Xstatic arc arcs_6_1[2] = { +X {21, 0}, +X {0, 1}, +X}; +Xstatic state states_6[2] = { +X {1, arcs_6_0}, +X {2, arcs_6_1}, +X}; +Xstatic arc arcs_7_0[2] = { +X {13, 1}, +X {17, 2}, +X}; +Xstatic arc arcs_7_1[1] = { +X {0, 1}, +X}; +Xstatic arc arcs_7_2[1] = { +X {18, 3}, +X}; +Xstatic arc arcs_7_3[1] = { +X {19, 1}, +X}; +Xstatic state states_7[4] = { +X {2, arcs_7_0}, +X {1, arcs_7_1}, +X {1, arcs_7_2}, +X {1, arcs_7_3}, +X}; +Xstatic arc arcs_8_0[2] = { +X {3, 1}, +X {4, 1}, +X}; +Xstatic arc arcs_8_1[1] = { +X {0, 1}, +X}; +Xstatic state states_8[2] = { +X {2, arcs_8_0}, +X {1, arcs_8_1}, +X}; +Xstatic arc arcs_9_0[6] = { +X {22, 1}, +X {23, 1}, +X {24, 1}, +X {25, 1}, +X {26, 1}, +X {27, 1}, +X}; +Xstatic arc arcs_9_1[1] = { +X {0, 1}, +X}; +Xstatic state states_9[2] = { +X {6, arcs_9_0}, +X {1, arcs_9_1}, +X}; +Xstatic arc arcs_10_0[1] = { +X {28, 1}, +X}; +Xstatic arc arcs_10_1[2] = { +X {29, 0}, +X {2, 2}, +X}; +Xstatic arc arcs_10_2[1] = { +X {0, 2}, +X}; +Xstatic state states_10[3] = { +X {1, arcs_10_0}, +X {2, arcs_10_1}, +X {1, arcs_10_2}, +X}; +Xstatic arc arcs_11_0[1] = { +X {30, 1}, +X}; +Xstatic arc arcs_11_1[2] = { +X {31, 2}, +X {2, 3}, +X}; +Xstatic arc arcs_11_2[2] = { +X {21, 1}, +X {2, 3}, +X}; +Xstatic arc arcs_11_3[1] = { +X {0, 3}, +X}; +Xstatic state states_11[4] = { +X {1, arcs_11_0}, +X {2, arcs_11_1}, +X {2, arcs_11_2}, +X {1, arcs_11_3}, +X}; +Xstatic arc arcs_12_0[1] = { +X {32, 1}, +X}; +Xstatic arc arcs_12_1[1] = { +X {28, 2}, +X}; +Xstatic arc arcs_12_2[1] = { +X {2, 3}, +X}; +Xstatic arc arcs_12_3[1] = { +X {0, 3}, +X}; +Xstatic state states_12[4] = { +X {1, arcs_12_0}, +X {1, arcs_12_1}, +X {1, arcs_12_2}, +X {1, arcs_12_3}, +X}; +Xstatic arc arcs_13_0[1] = { +X {33, 1}, +X}; +Xstatic arc arcs_13_1[1] = { +X {2, 2}, +X}; +Xstatic arc arcs_13_2[1] = { +X {0, 2}, +X}; +Xstatic state states_13[3] = { +X {1, arcs_13_0}, +X {1, arcs_13_1}, +X {1, arcs_13_2}, +X}; +Xstatic arc arcs_14_0[3] = { +X {34, 1}, +X {35, 1}, +X {36, 1}, +X}; +Xstatic arc arcs_14_1[1] = { +X {0, 1}, +X}; +Xstatic state states_14[2] = { +X {3, arcs_14_0}, +X {1, arcs_14_1}, +X}; +Xstatic arc arcs_15_0[1] = { +X {37, 1}, +X}; +Xstatic arc arcs_15_1[1] = { +X {2, 2}, +X}; +Xstatic arc arcs_15_2[1] = { +X {0, 2}, +X}; +Xstatic state states_15[3] = { +X {1, arcs_15_0}, +X {1, arcs_15_1}, +X {1, arcs_15_2}, +X}; +Xstatic arc arcs_16_0[1] = { +X {38, 1}, +X}; +Xstatic arc arcs_16_1[2] = { +X {9, 2}, +X {2, 3}, +X}; +Xstatic arc arcs_16_2[1] = { +X {2, 3}, +X}; +Xstatic arc arcs_16_3[1] = { +X {0, 3}, +X}; +Xstatic state states_16[4] = { +X {1, arcs_16_0}, +X {2, arcs_16_1}, +X {1, arcs_16_2}, +X {1, arcs_16_3}, +X}; +Xstatic arc arcs_17_0[1] = { +X {39, 1}, +X}; +Xstatic arc arcs_17_1[1] = { +X {40, 2}, +X}; +Xstatic arc arcs_17_2[2] = { +X {21, 3}, +X {2, 4}, +X}; +Xstatic arc arcs_17_3[1] = { +X {40, 5}, +X}; +Xstatic arc arcs_17_4[1] = { +X {0, 4}, +X}; +Xstatic arc arcs_17_5[1] = { +X {2, 4}, +X}; +Xstatic state states_17[6] = { +X {1, arcs_17_0}, +X {1, arcs_17_1}, +X {2, arcs_17_2}, +X {1, arcs_17_3}, +X {1, arcs_17_4}, +X {1, arcs_17_5}, +X}; +Xstatic arc arcs_18_0[2] = { +X {41, 1}, +X {42, 2}, +X}; +Xstatic arc arcs_18_1[1] = { +X {13, 3}, +X}; +Xstatic arc arcs_18_2[1] = { +X {13, 4}, +X}; +Xstatic arc arcs_18_3[2] = { +X {21, 1}, +X {2, 5}, +X}; +Xstatic arc arcs_18_4[1] = { +X {41, 6}, +X}; +Xstatic arc arcs_18_5[1] = { +X {0, 5}, +X}; +Xstatic arc arcs_18_6[2] = { +X {43, 7}, +X {13, 8}, +X}; +Xstatic arc arcs_18_7[1] = { +X {2, 5}, +X}; +Xstatic arc arcs_18_8[2] = { +X {21, 9}, +X {2, 5}, +X}; +Xstatic arc arcs_18_9[1] = { +X {13, 8}, +X}; +Xstatic state states_18[10] = { +X {2, arcs_18_0}, +X {1, arcs_18_1}, +X {1, arcs_18_2}, +X {2, arcs_18_3}, +X {1, arcs_18_4}, +X {1, arcs_18_5}, +X {2, arcs_18_6}, +X {1, arcs_18_7}, +X {2, arcs_18_8}, +X {1, arcs_18_9}, +X}; +Xstatic arc arcs_19_0[6] = { +X {44, 1}, +X {45, 1}, +X {46, 1}, +X {47, 1}, +X {11, 1}, +X {48, 1}, +X}; +Xstatic arc arcs_19_1[1] = { +X {0, 1}, +X}; +Xstatic state states_19[2] = { +X {6, arcs_19_0}, +X {1, arcs_19_1}, +X}; +Xstatic arc arcs_20_0[1] = { +X {49, 1}, +X}; +Xstatic arc arcs_20_1[1] = { +X {31, 2}, +X}; +Xstatic arc arcs_20_2[1] = { +X {15, 3}, +X}; +Xstatic arc arcs_20_3[1] = { +X {16, 4}, +X}; +Xstatic arc arcs_20_4[3] = { +X {50, 1}, +X {51, 5}, +X {0, 4}, +X}; +Xstatic arc arcs_20_5[1] = { +X {15, 6}, +X}; +Xstatic arc arcs_20_6[1] = { +X {16, 7}, +X}; +Xstatic arc arcs_20_7[1] = { +X {0, 7}, +X}; +Xstatic state states_20[8] = { +X {1, arcs_20_0}, +X {1, arcs_20_1}, +X {1, arcs_20_2}, +X {1, arcs_20_3}, +X {3, arcs_20_4}, +X {1, arcs_20_5}, +X {1, arcs_20_6}, +X {1, arcs_20_7}, +X}; +Xstatic arc arcs_21_0[1] = { +X {52, 1}, +X}; +Xstatic arc arcs_21_1[1] = { +X {31, 2}, +X}; +Xstatic arc arcs_21_2[1] = { +X {15, 3}, +X}; +Xstatic arc arcs_21_3[1] = { +X {16, 4}, +X}; +Xstatic arc arcs_21_4[2] = { +X {51, 5}, +X {0, 4}, +X}; +Xstatic arc arcs_21_5[1] = { +X {15, 6}, +X}; +Xstatic arc arcs_21_6[1] = { +X {16, 7}, +X}; +Xstatic arc arcs_21_7[1] = { +X {0, 7}, +X}; +Xstatic state states_21[8] = { +X {1, arcs_21_0}, +X {1, arcs_21_1}, +X {1, arcs_21_2}, +X {1, arcs_21_3}, +X {2, arcs_21_4}, +X {1, arcs_21_5}, +X {1, arcs_21_6}, +X {1, arcs_21_7}, +X}; +Xstatic arc arcs_22_0[1] = { +X {53, 1}, +X}; +Xstatic arc arcs_22_1[1] = { +X {28, 2}, +X}; +Xstatic arc arcs_22_2[1] = { +X {54, 3}, +X}; +Xstatic arc arcs_22_3[1] = { +X {28, 4}, +X}; +Xstatic arc arcs_22_4[1] = { +X {15, 5}, +X}; +Xstatic arc arcs_22_5[1] = { +X {16, 6}, +X}; +Xstatic arc arcs_22_6[2] = { +X {51, 7}, +X {0, 6}, +X}; +Xstatic arc arcs_22_7[1] = { +X {15, 8}, +X}; +Xstatic arc arcs_22_8[1] = { +X {16, 9}, +X}; +Xstatic arc arcs_22_9[1] = { +X {0, 9}, +X}; +Xstatic state states_22[10] = { +X {1, arcs_22_0}, +X {1, arcs_22_1}, +X {1, arcs_22_2}, +X {1, arcs_22_3}, +X {1, arcs_22_4}, +X {1, arcs_22_5}, +X {2, arcs_22_6}, +X {1, arcs_22_7}, +X {1, arcs_22_8}, +X {1, arcs_22_9}, +X}; +Xstatic arc arcs_23_0[1] = { +X {55, 1}, +X}; +Xstatic arc arcs_23_1[1] = { +X {15, 2}, +X}; +Xstatic arc arcs_23_2[1] = { +X {16, 3}, +X}; +Xstatic arc arcs_23_3[3] = { +X {56, 1}, +X {57, 4}, +X {0, 3}, +X}; +Xstatic arc arcs_23_4[1] = { +X {15, 5}, +X}; +Xstatic arc arcs_23_5[1] = { +X {16, 6}, +X}; +Xstatic arc arcs_23_6[1] = { +X {0, 6}, +X}; +Xstatic state states_23[7] = { +X {1, arcs_23_0}, +X {1, arcs_23_1}, +X {1, arcs_23_2}, +X {3, arcs_23_3}, +X {1, arcs_23_4}, +X {1, arcs_23_5}, +X {1, arcs_23_6}, +X}; +Xstatic arc arcs_24_0[1] = { +X {58, 1}, +X}; +Xstatic arc arcs_24_1[2] = { +X {40, 2}, +X {0, 1}, +X}; +Xstatic arc arcs_24_2[2] = { +X {21, 3}, +X {0, 2}, +X}; +Xstatic arc arcs_24_3[1] = { +X {40, 4}, +X}; +Xstatic arc arcs_24_4[1] = { +X {0, 4}, +X}; +Xstatic state states_24[5] = { +X {1, arcs_24_0}, +X {2, arcs_24_1}, +X {2, arcs_24_2}, +X {1, arcs_24_3}, +X {1, arcs_24_4}, +X}; +Xstatic arc arcs_25_0[2] = { +X {3, 1}, +X {2, 2}, +X}; +Xstatic arc arcs_25_1[1] = { +X {0, 1}, +X}; +Xstatic arc arcs_25_2[1] = { +X {59, 3}, +X}; +Xstatic arc arcs_25_3[2] = { +X {2, 3}, +X {6, 4}, +X}; +Xstatic arc arcs_25_4[3] = { +X {6, 4}, +X {2, 4}, +X {60, 1}, +X}; +Xstatic state states_25[5] = { +X {2, arcs_25_0}, +X {1, arcs_25_1}, +X {1, arcs_25_2}, +X {2, arcs_25_3}, +X {3, arcs_25_4}, +X}; +Xstatic arc arcs_26_0[1] = { +X {61, 1}, +X}; +Xstatic arc arcs_26_1[2] = { +X {62, 0}, +X {0, 1}, +X}; +Xstatic state states_26[2] = { +X {1, arcs_26_0}, +X {2, arcs_26_1}, +X}; +Xstatic arc arcs_27_0[1] = { +X {63, 1}, +X}; +Xstatic arc arcs_27_1[2] = { +X {64, 0}, +X {0, 1}, +X}; +Xstatic state states_27[2] = { +X {1, arcs_27_0}, +X {2, arcs_27_1}, +X}; +Xstatic arc arcs_28_0[2] = { +X {65, 1}, +X {66, 2}, +X}; +Xstatic arc arcs_28_1[1] = { +X {63, 2}, +X}; +Xstatic arc arcs_28_2[1] = { +X {0, 2}, +X}; +Xstatic state states_28[3] = { +X {2, arcs_28_0}, +X {1, arcs_28_1}, +X {1, arcs_28_2}, +X}; +Xstatic arc arcs_29_0[1] = { +X {40, 1}, +X}; +Xstatic arc arcs_29_1[2] = { +X {67, 0}, +X {0, 1}, +X}; +Xstatic state states_29[2] = { +X {1, arcs_29_0}, +X {2, arcs_29_1}, +X}; +Xstatic arc arcs_30_0[6] = { +X {68, 1}, +X {69, 2}, +X {29, 3}, +X {54, 3}, +X {65, 4}, +X {70, 5}, +X}; +Xstatic arc arcs_30_1[3] = { +X {29, 3}, +X {69, 3}, +X {0, 1}, +X}; +Xstatic arc arcs_30_2[2] = { +X {29, 3}, +X {0, 2}, +X}; +Xstatic arc arcs_30_3[1] = { +X {0, 3}, +X}; +Xstatic arc arcs_30_4[1] = { +X {54, 3}, +X}; +Xstatic arc arcs_30_5[2] = { +X {65, 3}, +X {0, 5}, +X}; +Xstatic state states_30[6] = { +X {6, arcs_30_0}, +X {3, arcs_30_1}, +X {2, arcs_30_2}, +X {1, arcs_30_3}, +X {1, arcs_30_4}, +X {2, arcs_30_5}, +X}; +Xstatic arc arcs_31_0[1] = { +X {71, 1}, +X}; +Xstatic arc arcs_31_1[3] = { +X {72, 0}, +X {73, 0}, +X {0, 1}, +X}; +Xstatic state states_31[2] = { +X {1, arcs_31_0}, +X {3, arcs_31_1}, +X}; +Xstatic arc arcs_32_0[1] = { +X {74, 1}, +X}; +Xstatic arc arcs_32_1[4] = { +X {43, 0}, +X {75, 0}, +X {76, 0}, +X {0, 1}, +X}; +Xstatic state states_32[2] = { +X {1, arcs_32_0}, +X {4, arcs_32_1}, +X}; +Xstatic arc arcs_33_0[3] = { +X {72, 1}, +X {73, 1}, +X {77, 2}, +X}; +Xstatic arc arcs_33_1[1] = { +X {74, 3}, +X}; +Xstatic arc arcs_33_2[2] = { +X {78, 2}, +X {0, 2}, +X}; +Xstatic arc arcs_33_3[1] = { +X {0, 3}, +X}; +Xstatic state states_33[4] = { +X {3, arcs_33_0}, +X {1, arcs_33_1}, +X {2, arcs_33_2}, +X {1, arcs_33_3}, +X}; +Xstatic arc arcs_34_0[7] = { +X {17, 1}, +X {79, 2}, +X {81, 3}, +X {83, 4}, +X {13, 5}, +X {84, 5}, +X {85, 5}, +X}; +Xstatic arc arcs_34_1[2] = { +X {9, 6}, +X {19, 5}, +X}; +Xstatic arc arcs_34_2[2] = { +X {9, 7}, +X {80, 5}, +X}; +Xstatic arc arcs_34_3[1] = { +X {82, 5}, +X}; +Xstatic arc arcs_34_4[1] = { +X {9, 8}, +X}; +Xstatic arc arcs_34_5[1] = { +X {0, 5}, +X}; +Xstatic arc arcs_34_6[1] = { +X {19, 5}, +X}; +Xstatic arc arcs_34_7[1] = { +X {80, 5}, +X}; +Xstatic arc arcs_34_8[1] = { +X {83, 5}, +X}; +Xstatic state states_34[9] = { +X {7, arcs_34_0}, +X {2, arcs_34_1}, +X {2, arcs_34_2}, +X {1, arcs_34_3}, +X {1, arcs_34_4}, +X {1, arcs_34_5}, +X {1, arcs_34_6}, +X {1, arcs_34_7}, +X {1, arcs_34_8}, +X}; +Xstatic arc arcs_35_0[3] = { +X {17, 1}, +X {79, 2}, +X {87, 3}, +X}; +Xstatic arc arcs_35_1[2] = { +X {9, 4}, +X {19, 5}, +X}; +Xstatic arc arcs_35_2[1] = { +X {86, 6}, +X}; +Xstatic arc arcs_35_3[1] = { +X {13, 5}, +X}; +Xstatic arc arcs_35_4[1] = { +X {19, 5}, +X}; +Xstatic arc arcs_35_5[1] = { +X {0, 5}, +X}; +Xstatic arc arcs_35_6[1] = { +X {80, 5}, +X}; +Xstatic state states_35[7] = { +X {3, arcs_35_0}, +X {2, arcs_35_1}, +X {1, arcs_35_2}, +X {1, arcs_35_3}, +X {1, arcs_35_4}, +X {1, arcs_35_5}, +X {1, arcs_35_6}, +X}; +Xstatic arc arcs_36_0[2] = { +X {40, 1}, +X {15, 2}, +X}; +Xstatic arc arcs_36_1[2] = { +X {15, 2}, +X {0, 1}, +X}; +Xstatic arc arcs_36_2[2] = { +X {40, 3}, +X {0, 2}, +X}; +Xstatic arc arcs_36_3[1] = { +X {0, 3}, +X}; +Xstatic state states_36[4] = { +X {2, arcs_36_0}, +X {2, arcs_36_1}, +X {2, arcs_36_2}, +X {1, arcs_36_3}, +X}; +Xstatic arc arcs_37_0[1] = { +X {40, 1}, +X}; +Xstatic arc arcs_37_1[2] = { +X {21, 2}, +X {0, 1}, +X}; +Xstatic arc arcs_37_2[2] = { +X {40, 1}, +X {0, 2}, +X}; +Xstatic state states_37[3] = { +X {1, arcs_37_0}, +X {2, arcs_37_1}, +X {2, arcs_37_2}, +X}; +Xstatic arc arcs_38_0[1] = { +X {31, 1}, +X}; +Xstatic arc arcs_38_1[2] = { +X {21, 2}, +X {0, 1}, +X}; +Xstatic arc arcs_38_2[2] = { +X {31, 1}, +X {0, 2}, +X}; +Xstatic state states_38[3] = { +X {1, arcs_38_0}, +X {2, arcs_38_1}, +X {2, arcs_38_2}, +X}; +Xstatic arc arcs_39_0[1] = { +X {88, 1}, +X}; +Xstatic arc arcs_39_1[1] = { +X {13, 2}, +X}; +Xstatic arc arcs_39_2[1] = { +X {14, 3}, +X}; +Xstatic arc arcs_39_3[2] = { +X {29, 4}, +X {15, 5}, +X}; +Xstatic arc arcs_39_4[1] = { +X {89, 6}, +X}; +Xstatic arc arcs_39_5[1] = { +X {16, 7}, +X}; +Xstatic arc arcs_39_6[1] = { +X {15, 5}, +X}; +Xstatic arc arcs_39_7[1] = { +X {0, 7}, +X}; +Xstatic state states_39[8] = { +X {1, arcs_39_0}, +X {1, arcs_39_1}, +X {1, arcs_39_2}, +X {2, arcs_39_3}, +X {1, arcs_39_4}, +X {1, arcs_39_5}, +X {1, arcs_39_6}, +X {1, arcs_39_7}, +X}; +Xstatic arc arcs_40_0[1] = { +X {77, 1}, +X}; +Xstatic arc arcs_40_1[1] = { +X {90, 2}, +X}; +Xstatic arc arcs_40_2[2] = { +X {21, 0}, +X {0, 2}, +X}; +Xstatic state states_40[3] = { +X {1, arcs_40_0}, +X {1, arcs_40_1}, +X {2, arcs_40_2}, +X}; +Xstatic arc arcs_41_0[1] = { +X {17, 1}, +X}; +Xstatic arc arcs_41_1[2] = { +X {9, 2}, +X {19, 3}, +X}; +Xstatic arc arcs_41_2[1] = { +X {19, 3}, +X}; +Xstatic arc arcs_41_3[1] = { +X {0, 3}, +X}; +Xstatic state states_41[4] = { +X {1, arcs_41_0}, +X {2, arcs_41_1}, +X {1, arcs_41_2}, +X {1, arcs_41_3}, +X}; +Xstatic dfa dfas[42] = { +X {256, "single_input", 0, 3, states_0, +X "\004\060\002\100\343\006\262\000\000\203\072\001"}, +X {257, "file_input", 0, 2, states_1, +X "\204\060\002\100\343\006\262\000\000\203\072\001"}, +X {258, "expr_input", 0, 3, states_2, +X "\000\040\002\000\000\000\000\000\002\203\072\000"}, +X {259, "eval_input", 0, 3, states_3, +X "\000\040\002\000\000\000\000\000\002\203\072\000"}, +X {260, "funcdef", 0, 6, states_4, +X "\000\020\000\000\000\000\000\000\000\000\000\000"}, +X {261, "parameters", 0, 4, states_5, +X "\000\000\002\000\000\000\000\000\000\000\000\000"}, +X {262, "fplist", 0, 2, states_6, +X "\000\040\002\000\000\000\000\000\000\000\000\000"}, +X {263, "fpdef", 0, 4, states_7, +X "\000\040\002\000\000\000\000\000\000\000\000\000"}, +X {264, "stmt", 0, 2, states_8, +X "\000\060\002\100\343\006\262\000\000\203\072\001"}, +X {265, "simple_stmt", 0, 2, states_9, +X "\000\040\002\100\343\006\000\000\000\203\072\000"}, +X {266, "expr_stmt", 0, 3, states_10, +X "\000\040\002\000\000\000\000\000\000\203\072\000"}, +X {267, "print_stmt", 0, 4, states_11, +X "\000\000\000\100\000\000\000\000\000\000\000\000"}, +X {268, "del_stmt", 0, 4, states_12, +X "\000\000\000\000\001\000\000\000\000\000\000\000"}, +X {269, "pass_stmt", 0, 3, states_13, +X "\000\000\000\000\002\000\000\000\000\000\000\000"}, +X {270, "flow_stmt", 0, 2, states_14, +X "\000\000\000\000\340\000\000\000\000\000\000\000"}, +X {271, "break_stmt", 0, 3, states_15, +X "\000\000\000\000\040\000\000\000\000\000\000\000"}, +X {272, "return_stmt", 0, 4, states_16, +X "\000\000\000\000\100\000\000\000\000\000\000\000"}, +X {273, "raise_stmt", 0, 6, states_17, +X "\000\000\000\000\200\000\000\000\000\000\000\000"}, +X {274, "import_stmt", 0, 10, states_18, +X "\000\000\000\000\000\006\000\000\000\000\000\000"}, +X {275, "compound_stmt", 0, 2, states_19, +X "\000\020\000\000\000\000\262\000\000\000\000\001"}, +X {276, "if_stmt", 0, 8, states_20, +X "\000\000\000\000\000\000\002\000\000\000\000\000"}, +X {277, "while_stmt", 0, 8, states_21, +X "\000\000\000\000\000\000\020\000\000\000\000\000"}, +X {278, "for_stmt", 0, 10, states_22, +X "\000\000\000\000\000\000\040\000\000\000\000\000"}, +X {279, "try_stmt", 0, 7, states_23, +X "\000\000\000\000\000\000\200\000\000\000\000\000"}, +X {280, "except_clause", 0, 5, states_24, +X "\000\000\000\000\000\000\000\004\000\000\000\000"}, +X {281, "suite", 0, 5, states_25, +X "\004\040\002\100\343\006\000\000\000\203\072\000"}, +X {282, "test", 0, 2, states_26, +X "\000\040\002\000\000\000\000\000\002\203\072\000"}, +X {283, "and_test", 0, 2, states_27, +X "\000\040\002\000\000\000\000\000\002\203\072\000"}, +X {284, "not_test", 0, 3, states_28, +X "\000\040\002\000\000\000\000\000\002\203\072\000"}, +X {285, "comparison", 0, 2, states_29, +X "\000\040\002\000\000\000\000\000\000\203\072\000"}, +X {286, "comp_op", 0, 6, states_30, +X "\000\000\000\040\000\000\100\000\162\000\000\000"}, +X {287, "expr", 0, 2, states_31, +X "\000\040\002\000\000\000\000\000\000\203\072\000"}, +X {288, "term", 0, 2, states_32, +X "\000\040\002\000\000\000\000\000\000\203\072\000"}, +X {289, "factor", 0, 4, states_33, +X "\000\040\002\000\000\000\000\000\000\203\072\000"}, +X {290, "atom", 0, 9, states_34, +X "\000\040\002\000\000\000\000\000\000\200\072\000"}, +X {291, "trailer", 0, 7, states_35, +X "\000\000\002\000\000\000\000\000\000\200\200\000"}, +X {292, "subscript", 0, 4, states_36, +X "\000\240\002\000\000\000\000\000\000\203\072\000"}, +X {293, "exprlist", 0, 3, states_37, +X "\000\040\002\000\000\000\000\000\000\203\072\000"}, +X {294, "testlist", 0, 3, states_38, +X "\000\040\002\000\000\000\000\000\002\203\072\000"}, +X {295, "classdef", 0, 8, states_39, +X "\000\000\000\000\000\000\000\000\000\000\000\001"}, +X {296, "baselist", 0, 3, states_40, +X "\000\040\002\000\000\000\000\000\000\200\072\000"}, +X {297, "arguments", 0, 4, states_41, +X "\000\000\002\000\000\000\000\000\000\000\000\000"}, +X}; +Xstatic label labels[91] = { +X {0, "EMPTY"}, +X {256, 0}, +X {4, 0}, +X {265, 0}, +X {275, 0}, +X {257, 0}, +X {264, 0}, +X {0, 0}, +X {258, 0}, +X {294, 0}, +X {259, 0}, +X {260, 0}, +X {1, "def"}, +X {1, 0}, +X {261, 0}, +X {11, 0}, +X {281, 0}, +X {7, 0}, +X {262, 0}, +X {8, 0}, +X {263, 0}, +X {12, 0}, +X {266, 0}, +X {267, 0}, +X {269, 0}, +X {268, 0}, +X {270, 0}, +X {274, 0}, +X {293, 0}, +X {22, 0}, +X {1, "print"}, +X {282, 0}, +X {1, "del"}, +X {1, "pass"}, +X {271, 0}, +X {272, 0}, +X {273, 0}, +X {1, "break"}, +X {1, "return"}, +X {1, "raise"}, +X {287, 0}, +X {1, "import"}, +X {1, "from"}, +X {16, 0}, +X {276, 0}, +X {277, 0}, +X {278, 0}, +X {279, 0}, +X {295, 0}, +X {1, "if"}, +X {1, "elif"}, +X {1, "else"}, +X {1, "while"}, +X {1, "for"}, +X {1, "in"}, +X {1, "try"}, +X {280, 0}, +X {1, "finally"}, +X {1, "except"}, +X {5, 0}, +X {6, 0}, +X {283, 0}, +X {1, "or"}, +X {284, 0}, +X {1, "and"}, +X {1, "not"}, +X {285, 0}, +X {286, 0}, +X {20, 0}, +X {21, 0}, +X {1, "is"}, +X {288, 0}, +X {14, 0}, +X {15, 0}, +X {289, 0}, +X {17, 0}, +X {24, 0}, +X {290, 0}, +X {291, 0}, +X {9, 0}, +X {10, 0}, +X {26, 0}, +X {27, 0}, +X {25, 0}, +X {2, 0}, +X {3, 0}, +X {292, 0}, +X {23, 0}, +X {1, "class"}, +X {296, 0}, +X {297, 0}, +X}; +Xgrammar gram = { +X 42, +X dfas, +X {91, labels}, +X 256 +X}; +EOF +fi +if test -s 'src/objimpl.h' +then echo '*** I will not over-write existing file src/objimpl.h' +else +echo 'x - src/objimpl.h' +sed 's/^X//' > 'src/objimpl.h' << 'EOF' +X/*********************************************************** +XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The +XNetherlands. +X +X All Rights Reserved +X +XPermission to use, copy, modify, and distribute this software and its +Xdocumentation for any purpose and without fee is hereby granted, +Xprovided that the above copyright notice appear in all copies and that +Xboth that copyright notice and this permission notice appear in +Xsupporting documentation, and that the names of Stichting Mathematisch +XCentrum or CWI not be used in advertising or publicity pertaining to +Xdistribution of the software without specific, written prior permission. +X +XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +X +X******************************************************************/ +X +X/* +X123456789-123456789-123456789-123456789-123456789-123456789-123456789-12 +X +XAdditional macros for modules that implement new object types. +XYou must first include "object.h". +X +XNEWOBJ(type, typeobj) allocates memory for a new object of the given +Xtype; here 'type' must be the C structure type used to represent the +Xobject and 'typeobj' the address of the corresponding type object. +XReference count and type pointer are filled in; the rest of the bytes of +Xthe object are *undefined*! The resulting expression type is 'type *'. +XThe size of the object is actually determined by the tp_basicsize field +Xof the type object. +X +XNEWVAROBJ(type, typeobj, n) is similar but allocates a variable-size +Xobject with n extra items. The size is computer as tp_basicsize plus +Xn * tp_itemsize. This fills in the ob_size field as well. +X*/ +X +Xextern object *newobject PROTO((typeobject *)); +Xextern varobject *newvarobject PROTO((typeobject *, unsigned int)); +X +X#define NEWOBJ(type, typeobj) ((type *) newobject(typeobj)) +X#define NEWVAROBJ(type, typeobj, n) ((type *) newvarobject(typeobj, n)) +X +Xextern int StopPrint; /* Set when printing is interrupted */ +EOF +fi +echo 'Part 03 out of 21 of pack.out complete.' +exit 0 |