Added line number to most compile-time error messages.

diff --git a/Python/compile.c b/Python/compile.c
index a9d597b2dec522caac25b978b9a61ab84468129a..60bfd6f3d279c27c37197df0a67f58c53fda62f2 100644 (file)
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -256,12 +256,43 @@ struct compiling {
        int c_nblocks;          /* current block stack level */
        char *c_filename;       /* filename of current node */
        char *c_name;           /* name of object (e.g. function) */
+       int c_lineno;           /* Current line number */
 #ifdef PRIVATE_NAME_MANGLING
        char *c_private;        /* for private name mangling */
 #endif
 };
 
 
+/* Error message including line number */
+
+static void
+com_error(c, exc, msg)
+       struct compiling *c;
+       object *exc;
+       char *msg;
+{
+       int n = strlen(msg);
+       object *v;
+       char buffer[30];
+       char *s;
+       if (c->c_lineno <= 1) {
+               /* Unknown line number or single interactive command */
+               err_setstr(exc, msg);
+               return;
+       }
+       sprintf(buffer, " (line %d)", c->c_lineno);
+       v = newsizedstringobject((char *)NULL, n + strlen(buffer));
+       if (v == NULL)
+               return; /* MemoryError, too bad */
+       s = GETSTRINGVALUE((stringobject *)v);
+       strcpy(s, msg);
+       strcat(s, buffer);
+       err_setval(exc, v);
+       DECREF(v);
+       c->c_errors++;
+}
+
+
 /* Interface to the block stack */
 
 static void
@@ -270,8 +301,7 @@ block_push(c, type)
        int type;
 {
        if (c->c_nblocks >= MAXBLOCKS) {
-               err_setstr(SystemError, "too many statically nested blocks");
-               c->c_errors++;
+               com_error(c, SystemError, "too many statically nested blocks");
        }
        else {
                c->c_block[c->c_nblocks++] = type;
@@ -286,8 +316,7 @@ block_pop(c, type)
        if (c->c_nblocks > 0)
                c->c_nblocks--;
        if (c->c_block[c->c_nblocks] != type && c->c_errors == 0) {
-               err_setstr(SystemError, "bad block pop");
-               c->c_errors++;
+               com_error(c, SystemError, "bad block pop");
        }
 }
 
@@ -343,6 +372,7 @@ com_init(c, filename)
        c->c_nblocks = 0;
        c->c_filename = filename;
        c->c_name = "?";
+       c->c_lineno = 0;
        return 1;
        
   fail_000:
@@ -391,8 +421,7 @@ com_addbyte(c, byte)
                fprintf(stderr, "XXX compiling bad byte: %d\n", byte);
                fatal("com_addbyte: byte out of range");
                */
-               err_setstr(SystemError, "com_addbyte: byte out of range");
-               c->c_errors++;
+               com_error(c, SystemError, "com_addbyte: byte out of range");
        }
        if (c->c_code == NULL)
                return;
@@ -421,6 +450,8 @@ com_addoparg(c, op, arg)
        int op;
        int arg;
 {
+       if (op == SET_LINENO)
+               c->c_lineno = arg;
        com_addbyte(c, op);
        com_addint(c, arg);
 }
@@ -592,8 +623,8 @@ com_addopname(c, op, n)
                for (i = 0; i < NCH(n); i += 2) {
                        char *s = STR(CHILD(n, i));
                        if (p + strlen(s) > buffer + (sizeof buffer) - 2) {
-                               err_setstr(MemoryError,
-                                          "dotted_name too long");
+                               com_error(c, MemoryError,
+                                         "dotted_name too long");
                                name = NULL;
                                break;
                        }
@@ -611,7 +642,8 @@ com_addopname(c, op, n)
 }
 
 static object *
-parsenumber(s)
+parsenumber(co, s)
+       struct compiling *co;
        char *s;
 {
        extern long mystrtol PROTO((const char *, char **, int));
@@ -637,8 +669,8 @@ parsenumber(s)
                x = mystrtol(s, &end, 0);
        if (*end == '\0') {
                if (errno != 0) {
-                       err_setstr(OverflowError,
-                                  "integer literal too large");
+                       com_error(co, OverflowError,
+                                 "integer literal too large");
                        return NULL;
                }
                return newintobject(x);
@@ -818,8 +850,7 @@ com_atom(c, n)
                com_addbyte(c, UNARY_CONVERT);
                break;
        case NUMBER:
-               if ((v = parsenumber(STR(ch))) == NULL) {
-                       c->c_errors++;
+               if ((v = parsenumber(c, STR(ch))) == NULL) {
                        i = 255;
                }
                else {
@@ -845,8 +876,7 @@ com_atom(c, n)
                break;
        default:
                fprintf(stderr, "node type %d\n", TYPE(ch));
-               err_setstr(SystemError, "com_atom: unexpected node type");
-               c->c_errors++;
+               com_error(c, SystemError, "com_atom: unexpected node type");
        }
 }
 
@@ -886,9 +916,8 @@ com_argument(c, n, inkeywords)
        REQ(n, argument); /* [test '='] test; really [ keyword '='] keyword */
        if (NCH(n) == 1) {
                if (inkeywords) {
-                       err_setstr(SyntaxError,
+                       com_error(c, SyntaxError,
                                   "non-keyword arg after keyword arg");
-                       c->c_errors++;
                }
                else {
                        com_node(c, CHILD(n, 0));
@@ -900,8 +929,7 @@ com_argument(c, n, inkeywords)
                m = CHILD(m, 0);
        } while (NCH(m) == 1);
        if (TYPE(m) != NAME) {
-               err_setstr(SyntaxError, "keyword can't be an expression");
-               c->c_errors++;
+               com_error(c, SyntaxError, "keyword can't be an expression");
        }
        else {
                object *v = newstringobject(STR(m));
@@ -938,8 +966,7 @@ com_call_function(c, n)
                                nk++;
                }
                if (na > 255 || nk > 255) {
-                       err_setstr(SyntaxError, "more than 255 arguments");
-                       c->c_errors++;
+                       com_error(c, SyntaxError, "more than 255 arguments");
                }
                com_addoparg(c, CALL_FUNCTION, na | (nk << 8));
        }
@@ -1071,9 +1098,8 @@ com_apply_trailer(c, n)
                com_subscriptlist(c, CHILD(n, 1), OP_APPLY);
                break;
        default:
-               err_setstr(SystemError,
-                       "com_apply_trailer: unknown trailer type");
-               c->c_errors++;
+               com_error(c, SystemError,
+                         "com_apply_trailer: unknown trailer type");
        }
 }
 
@@ -1141,9 +1167,8 @@ com_term(c, n)
                        op = BINARY_MODULO;
                        break;
                default:
-                       err_setstr(SystemError,
-                               "com_term: operator not *, / or %");
-                       c->c_errors++;
+                       com_error(c, SystemError,
+                                 "com_term: operator not *, / or %");
                        op = 255;
                }
                com_addbyte(c, op);
@@ -1169,9 +1194,8 @@ com_arith_expr(c, n)
                        op = BINARY_SUBTRACT;
                        break;
                default:
-                       err_setstr(SystemError,
-                               "com_arith_expr: operator not + or -");
-                       c->c_errors++;
+                       com_error(c, SystemError,
+                                 "com_arith_expr: operator not + or -");
                        op = 255;
                }
                com_addbyte(c, op);
@@ -1197,9 +1221,8 @@ com_shift_expr(c, n)
                        op = BINARY_RSHIFT;
                        break;
                default:
-                       err_setstr(SystemError,
-                               "com_shift_expr: operator not << or >>");
-                       c->c_errors++;
+                       com_error(c, SystemError,
+                                 "com_shift_expr: operator not << or >>");
                        op = 255;
                }
                com_addbyte(c, op);
@@ -1221,9 +1244,8 @@ com_and_expr(c, n)
                        op = BINARY_AND;
                }
                else {
-                       err_setstr(SystemError,
-                               "com_and_expr: operator not &");
-                       c->c_errors++;
+                       com_error(c, SystemError,
+                                 "com_and_expr: operator not &");
                        op = 255;
                }
                com_addbyte(c, op);
@@ -1245,9 +1267,8 @@ com_xor_expr(c, n)
                        op = BINARY_XOR;
                }
                else {
-                       err_setstr(SystemError,
-                               "com_xor_expr: operator not ^");
-                       c->c_errors++;
+                       com_error(c, SystemError,
+                                 "com_xor_expr: operator not ^");
                        op = 255;
                }
                com_addbyte(c, op);
@@ -1269,9 +1290,8 @@ com_expr(c, n)
                        op = BINARY_OR;
                }
                else {
-                       err_setstr(SystemError,
-                               "com_expr: expr operator not |");
-                       c->c_errors++;
+                       com_error(c, SystemError,
+                                 "com_expr: expr operator not |");
                        op = 255;
                }
                com_addbyte(c, op);
@@ -1366,9 +1386,8 @@ com_comparison(c, n)
                }
                op = cmp_type(CHILD(n, i-1));
                if (op == BAD) {
-                       err_setstr(SystemError,
-                               "com_comparison: unknown comparison op");
-                       c->c_errors++;
+                       com_error(c, SystemError,
+                                 "com_comparison: unknown comparison op");
                }
                com_addoparg(c, COMPARE_OP, op);
                if (i+2 < NCH(n)) {
@@ -1504,8 +1523,7 @@ com_assign_trailer(c, n, assigning)
        REQ(n, trailer);
        switch (TYPE(CHILD(n, 0))) {
        case LPAR: /* '(' [exprlist] ')' */
-               err_setstr(SyntaxError, "can't assign to function call");
-               c->c_errors++;
+               com_error(c, SyntaxError, "can't assign to function call");
                break;
        case DOT: /* '.' NAME */
                com_assign_attr(c, CHILD(n, 1), assigning);
@@ -1514,8 +1532,7 @@ com_assign_trailer(c, n, assigning)
                com_subscriptlist(c, CHILD(n, 1), assigning);
                break;
        default:
-               err_setstr(SystemError, "unknown trailer type");
-               c->c_errors++;
+               com_error(c, SystemError, "unknown trailer type");
        }
 }
 
@@ -1588,9 +1605,8 @@ com_assign(c, n, assigning)
                case term:
                case factor:
                        if (NCH(n) > 1) {
-                               err_setstr(SyntaxError,
-                                       "can't assign to operator");
-                               c->c_errors++;
+                               com_error(c, SyntaxError,
+                                         "can't assign to operator");
                                return;
                        }
                        n = CHILD(n, 0);
@@ -1599,9 +1615,8 @@ com_assign(c, n, assigning)
                case power: /* atom trailer* ('**' power)* */
 /* ('+'|'-'|'~') factor | atom trailer* */
                        if (TYPE(CHILD(n, 0)) != atom) {
-                               err_setstr(SyntaxError,
-                                       "can't assign to operator");
-                               c->c_errors++;
+                               com_error(c, SyntaxError,
+                                         "can't assign to operator");
                                return;
                        }
                        if (NCH(n) > 1) { /* trailer or exponent present */
@@ -1609,9 +1624,8 @@ com_assign(c, n, assigning)
                                com_node(c, CHILD(n, 0));
                                for (i = 1; i+1 < NCH(n); i++) {
                                        if (TYPE(CHILD(n, i)) == DOUBLESTAR) {
-                                               err_setstr(SyntaxError,
-                                                       "can't assign to operator");
-                                               c->c_errors++;
+                                               com_error(c, SyntaxError,
+                                                 "can't assign to operator");
                                                return;
                                        }
                                        com_apply_trailer(c, CHILD(n, i));
@@ -1629,18 +1643,16 @@ com_assign(c, n, assigning)
                                n = CHILD(n, 1);
                                if (TYPE(n) == RPAR) {
                                        /* XXX Should allow () = () ??? */
-                                       err_setstr(SyntaxError,
-                                               "can't assign to ()");
-                                       c->c_errors++;
+                                       com_error(c, SyntaxError,
+                                                 "can't assign to ()");
                                        return;
                                }
                                break;
                        case LSQB:
                                n = CHILD(n, 1);
                                if (TYPE(n) == RSQB) {
-                                       err_setstr(SyntaxError,
-                                               "can't assign to []");
-                                       c->c_errors++;
+                                       com_error(c, SyntaxError,
+                                                 "can't assign to []");
                                        return;
                                }
                                com_assign_list(c, n, assigning);
@@ -1649,22 +1661,19 @@ com_assign(c, n, assigning)
                                com_assign_name(c, CHILD(n, 0), assigning);
                                return;
                        default:
-                               err_setstr(SyntaxError,
-                                               "can't assign to literal");
-                               c->c_errors++;
+                               com_error(c, SyntaxError,
+                                         "can't assign to literal");
                                return;
                        }
                        break;
 
                case lambdef:
-                       err_setstr(SyntaxError, "can't assign to lambda");
-                       c->c_errors++;
+                       com_error(c, SyntaxError, "can't assign to lambda");
                        return;
                
                default:
                        fprintf(stderr, "node type %d\n", TYPE(n));
-                       err_setstr(SystemError, "com_assign: bad node");
-                       c->c_errors++;
+                       com_error(c, SystemError, "com_assign: bad node");
                        return;
                
                }
@@ -1717,8 +1726,7 @@ com_return_stmt(c, n)
 {
        REQ(n, return_stmt); /* 'return' [testlist] */
        if (!c->c_infunction) {
-               err_setstr(SyntaxError, "'return' outside function");
-               c->c_errors++;
+               com_error(c, SyntaxError, "'return' outside function");
        }
        if (NCH(n) < 2)
                com_addoparg(c, LOAD_CONST, com_addconst(c, None));
@@ -1787,8 +1795,7 @@ com_global_stmt(c, n)
                        s = buffer;
 #endif
                if (dictlookup(c->c_locals, s) != NULL) {
-                       err_setstr(SyntaxError, "name is local and global");
-                       c->c_errors++;
+                       com_error(c, SyntaxError, "name is local and global");
                }
                else if (dictinsert(c->c_globals, s, None) != 0)
                        c->c_errors++;
@@ -1805,8 +1812,7 @@ com_newlocal_o(c, nameval)
        if (getlistsize(c->c_varnames) != c->c_nlocals) {
                /* This is usually caused by an error on a previous call */
                if (c->c_errors == 0) {
-                       err_setstr(SystemError, "mixed up var name/index");
-                       c->c_errors++;
+                       com_error(c, SystemError, "mixed up var name/index");
                }
                return 0;
        }
@@ -2110,9 +2116,8 @@ com_try_except(c, n)
             i += 3) {
                /* except_clause: 'except' [expr [',' expr]] */
                if (except_anchor == 0) {
-                       err_setstr(SyntaxError,
-                               "default 'except:' must be last");
-                       c->c_errors++;
+                       com_error(c, SyntaxError,
+                                 "default 'except:' must be last");
                        break;
                }
                except_anchor = 0;
@@ -2272,8 +2277,7 @@ com_continue_stmt(c, n)
                com_addoparg(c, JUMP_ABSOLUTE, c->c_begin);
        }
        else {
-               err_setstr(SyntaxError, "'continue' not properly in loop");
-               c->c_errors++;
+               com_error(c, SyntaxError, "'continue' not properly in loop");
        }
        /* XXX Could allow it inside a 'finally' clause
           XXX if we could pop the exception still on the stack */
@@ -2459,8 +2463,7 @@ com_node(c, n)
                break;
        case break_stmt:
                if (c->c_loops == 0) {
-                       err_setstr(SyntaxError, "'break' outside loop");
-                       c->c_errors++;
+                       com_error(c, SyntaxError, "'break' outside loop");
                }
                com_addbyte(c, BREAK_LOOP);
                break;
@@ -2553,8 +2556,7 @@ com_node(c, n)
        
        default:
                fprintf(stderr, "node type %d\n", TYPE(n));
-               err_setstr(SystemError, "com_node: unexpected node type");
-               c->c_errors++;
+               com_error(c, SystemError, "com_node: unexpected node type");
        }
 }
 
@@ -2827,8 +2829,8 @@ compile_node(c, n)
        
        default:
                fprintf(stderr, "node type %d\n", TYPE(n));
-               err_setstr(SystemError, "compile_node: unexpected node type");
-               c->c_errors++;
+               com_error(c, SystemError,
+                         "compile_node: unexpected node type");
        }
 }