Compile class definitions.

Document and fix code generation for try statements.
Use two bytes for all arguments.
Avoid duplicate entries in lists of constants and names.

1 files changed, 176 insertions, 27 deletions

diff --git a/Python/compile.c b/Python/compile.c
index 03a1e32..2f5fd69 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -1,4 +1,3 @@
-#define DEBUG
 /* Compile an expression node to intermediate code */
 
 #include <stdio.h>
@@ -174,7 +173,8 @@ com_addint(c, x)
 	struct compiling *c;
 	int x;
 {
-	com_addbyte(c, x);
+	com_addbyte(c, x & 0xff);
+	com_addbyte(c, x >> 8); /* XXX x should be positive */
 }
 
 static void
@@ -215,22 +215,10 @@ com_backpatch(c, anchor)
 	int prev;
 	for (;;) {
 		/* Make the JUMP instruction at anchor point to target */
-		prev = code[anchor];
-		dist = target - (anchor+1);
-		if (dist > 255 && lastanchor &&
-				code[lastanchor-1] == code[anchor-1]) {
-			/* Attempt to jump to a similar jump closer by */
-/* XXX Show that it works */
-fprintf(stderr, "com_backpatch: huge jump rescued (?)\n");
-			target = lastanchor-1;
-			dist = target - (anchor+1);
-			lastanchor = 0;
-		}
-		if (dist > 255) {
-			err_setstr(SystemError, "relative jump > 255 bytes");
-			c->c_errors++;
-		}
-		code[anchor] = dist;
+		prev = code[anchor] + (code[anchor+1] << 8);
+		dist = target - (anchor+2);
+		code[anchor] = dist & 0xff;
+		code[anchor+1] = dist >> 8;
 		if (!prev)
 			break;
 		lastanchor = anchor;
@@ -246,11 +234,16 @@ com_add(c, list, v)
 	object *list;
 	object *v;
 {
-	/* XXX Should look through list for object with same value */
-	int i = getlistsize(list);
+	int n = getlistsize(list);
+	int i;
+	for (i = n; --i >= 0; ) {
+		object *w = getlistitem(list, i);
+		if (cmpobject(v, w) == 0)
+			return i;
+	}
 	if (addlistitem(list, v) != 0)
 		c->c_errors++;
-	return i;
+	return n;
 }
 
 static int
@@ -926,6 +919,7 @@ com_assign(c, n, assigning)
 	/* Loop to avoid trivial recursion */
 	for (;;) {
 		switch (TYPE(n)) {
+		
 		case exprlist:
 		case testlist:
 			if (NCH(n) > 1) {
@@ -934,6 +928,7 @@ com_assign(c, n, assigning)
 			}
 			n = CHILD(n, 0);
 			break;
+		
 		case test:
 		case and_test:
 		case not_test:
@@ -945,6 +940,7 @@ com_assign(c, n, assigning)
 			}
 			n = CHILD(n, 0);
 			break;
+		
 		case comparison:
 			if (NCH(n) > 1) {
 				err_setstr(TypeError,
@@ -954,6 +950,7 @@ com_assign(c, n, assigning)
 			}
 			n = CHILD(n, 0);
 			break;
+		
 		case expr:
 			if (NCH(n) > 1) {
 				err_setstr(TypeError,
@@ -963,6 +960,7 @@ com_assign(c, n, assigning)
 			}
 			n = CHILD(n, 0);
 			break;
+		
 		case term:
 			if (NCH(n) > 1) {
 				err_setstr(TypeError,
@@ -972,6 +970,7 @@ com_assign(c, n, assigning)
 			}
 			n = CHILD(n, 0);
 			break;
+		
 		case factor: /* ('+'|'-') factor | atom trailer* */
 			if (TYPE(CHILD(n, 0)) != atom) { /* '+' | '-' */
 				err_setstr(TypeError,
@@ -991,6 +990,7 @@ com_assign(c, n, assigning)
 			}
 			n = CHILD(n, 0);
 			break;
+		
 		case atom:
 			switch (TYPE(CHILD(n, 0))) {
 			case LPAR:
@@ -1023,11 +1023,13 @@ com_assign(c, n, assigning)
 				return;
 			}
 			break;
+		
 		default:
 			fprintf(stderr, "node type %d\n", TYPE(n));
 			err_setstr(SystemError, "com_assign: bad node");
 			c->c_errors++;
 			return;
+		
 		}
 	}
 }
@@ -1065,6 +1067,7 @@ com_print_stmt(c, n)
 	}
 	if (TYPE(CHILD(n, NCH(n)-2)) != COMMA)
 		com_addbyte(c, PRINT_NEWLINE);
+		/* XXX Alternatively, LOAD_CONST '\n' and then PRINT_ITEM */
 }
 
 static void
@@ -1112,6 +1115,7 @@ com_import_stmt(c, n)
 		com_addbyte(c, POP_TOP);
 	}
 	else {
+		/* 'import' ... */
 		for (i = 1; i < NCH(n); i += 2) {
 			com_addopname(c, IMPORT_NAME, CHILD(n, i));
 			com_addopname(c, STORE_NAME, CHILD(n, i));
@@ -1197,6 +1201,91 @@ com_for_stmt(c, n)
 	com_backpatch(c, break_anchor);
 }
 
+/* Although 'execpt' and 'finally' clauses can be combined
+   syntactically, they are compiled separately.  In fact,
+	try: S
+	except E1: S1
+	except E2: S2
+	...
+	finally: Sf
+   is equivalent to
+	try:
+	    try: S
+	    except E1: S1
+	    except E2: S2
+	    ...
+	finally: Sf
+   meaning that the 'finally' clause is entered even if things
+   go wrong again in an exception handler.  Note that this is
+   not the case for exception handlers: at most one is entered.
+   
+   Code generated for "try: S finally: Sf" is as follows:
+   
+		SETUP_FINALLY	L
+		<code for S>
+		POP_BLOCK
+		LOAD_CONST	<nil>
+		LOAD_CONST	<nil>
+	L:	<code for Sf>
+		END_FINALLY
+   
+   The special instructions use the block stack.  Each block
+   stack entry contains the instruction that created it (here
+   SETUP_FINALLY), the level of the value stack at the time the
+   block stack entry was created, and a label (here L).
+   
+   SETUP_FINALLY:
+	Pushes the current value stack level and the label
+	onto the block stack.
+   POP_BLOCK:
+	Pops en entry from the block stack, and pops the value
+	stack until its level is the same as indicated on the
+	block stack.  (The label is ignored.)
+   END_FINALLY:
+	Pops two entries from the *value* stack and re-raises
+	the exception they specify.  If the top entry is nil,
+	no exception is raised.  If it is a number, a pseudo
+	exception is raised ('return' or 'break').  Otherwise,
+	a real exception (specified by a string) is raised.
+	The second entry popped from the is the value that goes
+	with the exception (or the return value).
+   
+   The block stack is unwound when an exception is raised:
+   when a SETUP_FINALLY entry is found, the exception is pushed
+   onto the value stack (and the exception condition is cleared),
+   and the interpreter jumps to the label gotten from the block
+   stack.
+   
+   Code generated for "try: S except E1, V1: S1 except E2, V2: S2 ...":
+   
+   Value stack		Label	Instruction	Argument
+   []				SETUP_EXCEPT	L1
+   []				<code for S>
+   []				POP_BLOCK
+   []				JUMP_FORWARD	L0
+   
+   [val, exc]		L1:	DUP
+   [val, exc, exc]		<evaluate E1>
+   [val, exc, exc, E1]		COMPARE_OP	EXC_MATCH
+   [val, exc, 1-or-0]		JUMP_IF_FALSE	L2
+   [val, exc, 1]		POP
+   [val, exc]			POP
+   [val]			<assign to V1>
+   []				<code for S1>
+   				JUMP_FORWARD	L0
+   
+   [val, exc, 0]	L2:	POP
+   [val, exc]			DUP
+   .............................etc.......................
+
+   [val, exc, 0]	Ln+1:	POP
+   [val, exc]	   		END_FINALLY	# re-raise exception
+   
+   []			L0:	<next statement>
+   
+   Of course, parts are not generated if Vi or Ei is not present.
+*/
+
 static void
 com_try_stmt(c, n)
 	struct compiling *c;
@@ -1206,6 +1295,7 @@ com_try_stmt(c, n)
 	int except_anchor = 0;
 	REQ(n, try_stmt);
 	/* 'try' ':' suite (except_clause ':' suite)* ['finally' ':' suite] */
+	
 	if (NCH(n) > 3 && TYPE(CHILD(n, NCH(n)-3)) != except_clause) {
 		/* Have a 'finally' clause */
 		com_addfwref(c, SETUP_FINALLY, &finally_anchor);
@@ -1226,12 +1316,18 @@ com_try_stmt(c, n)
 			i < NCH(n) && TYPE(ch = CHILD(n, i)) == except_clause;
 								i += 3) {
 			/* except_clause: 'except' [expr [',' expr]] */
-			int next_anchor = 0;
+			if (except_anchor == 0) {
+				err_setstr(TypeError,
+					"default 'except:' must be last");
+				c->c_errors++;
+				break;
+			}
+			except_anchor = 0;
 			if (NCH(ch) > 1) {
 				com_addbyte(c, DUP_TOP);
 				com_node(c, CHILD(ch, 1));
 				com_addoparg(c, COMPARE_OP, EXC_MATCH);
-				com_addfwref(c, JUMP_IF_FALSE, &next_anchor);
+				com_addfwref(c, JUMP_IF_FALSE, &except_anchor);
 				com_addbyte(c, POP_TOP);
 			}
 			com_addbyte(c, POP_TOP);
@@ -1241,8 +1337,10 @@ com_try_stmt(c, n)
 				com_addbyte(c, POP_TOP);
 			com_node(c, CHILD(n, i+2));
 			com_addfwref(c, JUMP_FORWARD, &end_anchor);
-			if (next_anchor)
-				com_backpatch(c, next_anchor);
+			if (except_anchor) {
+				com_backpatch(c, except_anchor);
+				com_addbyte(c, POP_TOP);
+			}
 		}
 		com_addbyte(c, END_FINALLY);
 		com_backpatch(c, end_anchor);
@@ -1297,18 +1395,49 @@ com_funcdef(c, n)
 }
 
 static void
+com_bases(c, n)
+	struct compiling *c;
+	node *n;
+{
+	int i, nbases;
+	REQ(n, baselist);
+	/*
+	baselist: atom arguments (',' atom arguments)*
+	arguments: '(' [testlist] ')'
+	*/
+	for (i = 0; i < NCH(n); i += 3)
+		com_node(c, CHILD(n, i));
+	com_addoparg(c, BUILD_TUPLE, (NCH(n)+1) / 3);
+}
+
+static void
 com_classdef(c, n)
 	struct compiling *c;
 	node *n;
 {
+	object *v;
 	REQ(n, classdef);
 	/*
 	classdef: 'class' NAME parameters ['=' baselist] ':' suite
 	baselist: atom arguments (',' atom arguments)*
 	arguments: '(' [testlist] ')'
 	*/
-	err_setstr(SystemError, "can't compile 'class' yet");
-	c->c_errors++;
+	if (NCH(n) == 7)
+		com_bases(c, CHILD(n, 4));
+	else
+		com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+	v = (object *)compile(n);
+	if (v == NULL)
+		c->c_errors++;
+	else {
+		int i = com_addconst(c, v);
+		com_addoparg(c, LOAD_CONST, i);
+		com_addbyte(c, BUILD_FUNCTION);
+		com_addbyte(c, UNARY_CALL);
+		com_addbyte(c, BUILD_CLASS);
+		com_addopname(c, STORE_NAME, CHILD(n, 1));
+		DECREF(v);
+	}
 }
 
 static void
@@ -1485,6 +1614,22 @@ compile_funcdef(c, n)
 }
 
 static void
+compile_classdef(c, n)
+	struct compiling *c;
+	node *n;
+{
+	node *ch;
+	REQ(n, classdef);
+	/*
+	classdef: 'class' NAME parameters ['=' baselist] ':' suite
+	*/
+	com_addbyte(c, REFUSE_ARGS);
+	com_node(c, CHILD(n, NCH(n)-1));
+	com_addbyte(c, LOAD_LOCALS);
+	com_addbyte(c, RETURN_VALUE);
+}
+
+static void
 compile_node(c, n)
 	struct compiling *c;
 	node *n;
@@ -1511,6 +1656,10 @@ compile_node(c, n)
 		compile_funcdef(c, n);
 		break;
 	
+	case classdef:
+		compile_classdef(c, n);
+		break;
+	
 	default:
 		fprintf(stderr, "node type %d\n", TYPE(n));
 		err_setstr(SystemError, "compile_node: unexpected node type");