@@ -43,7 +43,7 @@ #include <assert.h> /* Logging */ -#define PK_PRIVATE_LOGGING 1 +#define PK_PRIVATE_LOGGING 0 #include <pekoe/private/logging.h> /* ---------------------------------------------------------------- src/base.c @@ -416,8 +416,23 @@ PkParser *PkParserCreateWithTokenizer( #define TOKEN_STR(parser) PkTokenizerGetTokenCString(PARSER_TOKENIZER(parser)) #define NEXT_TOKEN(parser) PkTokenizerNextToken(PARSER_TOKENIZER(parser)) -#define COPY_POSITION(parser, pos) PkTokenizerCopySourcePositon(PARSER_TOKENIZER(parser), pos) -#define WRITE_POSITION(node, pos) (*NODE_POSITION(node) = *pos) + +PK_INLINE +void copyPosition1(PkParser *parser, PkSourcePosition *positionPtr) { + PkTokenizerCopySourcePositon(PARSER_TOKENIZER(parser), positionPtr); +} + +PK_INLINE +PkNode *copyPosition2(PkParser *parser, PkNode *node) { + copyPosition1(parser, NODE_POSITION(node)); + return node; +} + +PK_INLINE +PkNode *writePosition(PkSourcePosition *position, PkNode *node) { + *NODE_POSITION(node) = *position; + return node; +} /* ---------------------------------------------------------------- @@ -559,7 +574,7 @@ static void PkParserParseError(PkParser *parser, const char *format, ...) { description = PkStringCreateWithFormatAndArguments(format, args); va_end(args); - COPY_POSITION(parser, &position); + copyPosition1(parser, &position); PK_RELEASE(PARSER_LAST_ERROR(parser)); PARSER_LAST_ERROR(parser) = PkErrorCreateParseError( @@ -651,7 +666,8 @@ static int nextToken_(PkParser *parser) { return (PARSER_TOKEN_READ(parser) = t); } -static int nextToken(PkParser *parser) { +PK_INLINE +int nextToken(PkParser *parser) { const int t = nextToken_(parser); check_line_continuation(parser); return t; @@ -726,7 +742,7 @@ static PkNode *parse_expression(PkParser *parser, PkNode *lhs, int min_precedenc if (!op || op->precedence < min_precedence) break; t = nextToken(parser); - COPY_POSITION(parser, &pos); + copyPosition1(parser, &pos); PkAssert2(op->token == t, "Predected operator token is '%s', but actual token is '%s'", @@ -743,8 +759,6 @@ static PkNode *parse_expression(PkParser *parser, PkNode *lhs, int min_precedenc { /* the result of applying op with operands lhs and rhs */ PkNode *rhs = op->rhs_parser(parser); - PkNode *node; - if (op->after_rhs) op->after_rhs(parser); /* @@ -761,14 +775,10 @@ static PkNode *parse_expression(PkParser *parser, PkNode *lhs, int min_precedenc (rop->associativity != kRightAssociativity && rop->precedence == op->precedence)) { break; } - node = parse_expression(parser, rhs, rop->precedence); - rhs = node; + rhs = parse_expression(parser, rhs, rop->precedence); } - node = op->factory(t, lhs, rhs); - WRITE_POSITION(node, &pos); - - lhs = node; + lhs = writePosition(&pos, op->factory(t, lhs, rhs)); } } @@ -789,9 +799,11 @@ static PkNode *stmts(PkParser *parser) { } static PkNode *variable(PkParser *parser) { + PkSourcePosition pos; PkNode *lhs, *rhs; matchToken1(parser, kPkTokenIdentifier); + copyPosition1(parser, &pos); lhs = PkNodeCreateIdentifier(TOKEN_STR(parser)); if (lookahead(parser) == '=') { @@ -801,13 +813,15 @@ static PkNode *variable(PkParser *parser) { rhs = PkNodeCreateNull(); } - return PkNodeCreateVariable(lhs, rhs); + return writePosition(&pos, PkNodeCreateVariable(lhs, rhs)); } static PkNode *variables(PkParser *parser) { + PkSourcePosition pos; PkNode *stmt = PkNodeCreateList(); matchToken1(parser, kPkTokenVar); + copyPosition1(parser, &pos); PkNodeListAppendNode(stmt, variable(parser)); while (lookahead(parser) == ',') { @@ -816,7 +830,7 @@ static PkNode *variables(PkParser *parser) { } matchAtEndOfStatement(parser); - return stmt; + return writePosition(&pos, stmt); } static PkNode *assertion(PkParser *parser) { @@ -825,7 +839,7 @@ static PkNode *assertion(PkParser *parser) { /* consume tokens */ matchToken1(parser, kPkTokenAssert); - COPY_POSITION(parser, &pos); + copyPosition1(parser, &pos); exprArg = expr(parser); matchAtEndOfStatement(parser); @@ -838,31 +852,30 @@ static PkNode *assertion(PkParser *parser) { PkNodeListAppendNode(args, line); PkNodeListAppendNode(args, column); - return PkNodeCreateCall('(', PkNodeCreateIdentifier("__assert__"), args); + return writePosition(&pos, PkNodeCreateCall('(', PkNodeCreateIdentifier("__assert__"), args)); } static PkNode *return_stmt(PkParser *parser) { PkSourcePosition pos; - PkNode *body, *retNode; - int t; matchToken1(parser, kPkTokenReturn); - COPY_POSITION(parser, &pos); - - t = lookahead(parser); - body = (t == ';' || t == kPkTokenEOS) ? PkNodeCreateNull() - : expr(parser); - matchAtEndOfStatement(parser); - retNode = PkNodeCreateReturn(body); + copyPosition1(parser, &pos); - WRITE_POSITION(retNode, &pos); - return retNode; + { + const int t = lookahead(parser); + PkNode *body = (t == ';' || t == kPkTokenEOS) ? PkNodeCreateNull() + : expr(parser); + matchAtEndOfStatement(parser); + return writePosition(&pos, PkNodeCreateReturn(body)); + } } static PkNode *if_stmt(PkParser *parser) { + PkSourcePosition pos; PkNode *cond, *trueStmt, *falseStmt = NULL; matchToken1(parser, kPkTokenIf); + copyPosition1(parser, &pos); matchToken1(parser, '('); cond = expr(parser); matchToken1(parser, ')'); @@ -877,24 +890,26 @@ static PkNode *if_stmt(PkParser *parser) { falseStmt = PkNodeCreateEmptyStatement(); } - return PkNodeCreateIfStatement(cond, trueStmt, falseStmt); + return writePosition(&pos, PkNodeCreateIfStatement(cond, trueStmt, falseStmt)); } static PkNode *block(PkParser *parser) { + PkSourcePosition pos; PkNode *node; + copyPosition1(parser, &pos); matchToken1(parser, '{'); node = stmts(parser); matchToken1_(parser, '}'); - return PkNodeCreateBlock(node); + return writePosition(&pos, PkNodeCreateBlock(node)); } static PkNode *stmt(PkParser *parser) { switch(lookahead(parser)) { case ';': nextToken_(parser); - return PkNodeCreateEmptyStatement(); + return copyPosition2(parser, PkNodeCreateEmptyStatement()); case kPkTokenEOS: return PkNodeCreateEOS(); case '{': @@ -926,57 +941,43 @@ static PkNode *primary(PkParser *parser) { if (op != NULL) { const int t = nextToken(parser); - return PkNodeCreateUnaryOp(t, parse_expression( + + return copyPosition2(parser, PkNodeCreateUnaryOp(t, parse_expression( parser, - primary(parser), op->precedence)); + primary(parser), op->precedence))); } return atom(parser); } -static PkNode *parse_0(PkParser *parser, int token, PkNode *(*factory)(void)) { - PkNode *node; - - matchToken1(parser, token); - node = factory(); - COPY_POSITION(parser, NODE_POSITION(node)); - return node; -} - -static PkNode *parse_1(PkParser *parser, int token, PkNode *(*factory)(const char *)) { - PkNode *node; - +PK_INLINE +PkNode *parse_0(PkParser *parser, int token, PkNode *(*factory)(void)) { matchToken1(parser, token); - node = factory(TOKEN_STR(parser)); - COPY_POSITION(parser, NODE_POSITION(node)); - return node; + return copyPosition2(parser, factory()); } static PkNode *identifier(PkParser *parser) { - return parse_1(parser, kPkTokenIdentifier, PkNodeCreateIdentifier); + matchToken1(parser, kPkTokenIdentifier); + return copyPosition2(parser, PkNodeCreateIdentifier(TOKEN_STR(parser))); } static PkNode *string(PkParser *parser) { - PkSourcePosition pos; PkString *string; - PkNode *node; - COPY_POSITION(parser, &pos); matchToken1(parser, kPkTokenString); string = interpret_string(parser, TOKEN_STR(parser)); - node = PkNodeCreateString(string); - - WRITE_POSITION(node, &pos); - PkRelease(string); - return node; + PkAutorelease(string); + return copyPosition2(parser, PkNodeCreateString(string)); } static PkNode *array(PkParser *parser) { + PkSourcePosition pos; PkNode *node = PkNodeCreateArray(); int t; matchToken1(parser, '['); + copyPosition1(parser, &pos); t = lookahead(parser); while (t != ']') { @@ -989,17 +990,18 @@ static PkNode *array(PkParser *parser) { } matchToken1_(parser, ']'); - return node; + return writePosition(&pos, node); } static PkNode *object(PkParser *parser) { + PkSourcePosition pos; PkNode *node = PkNodeCreateObject(); int t; matchToken1(parser, '{'); + copyPosition1(parser, &pos); - t = lookahead(parser); - while (t != '}') { + while ((t = lookahead(parser)) != '}') { PkNode *name, *value; if (t != kPkTokenIdentifier && @@ -1023,11 +1025,10 @@ static PkNode *object(PkParser *parser) { t = lookahead(parser); if (t == '}') break; matchToken1(parser, ','); - t = lookahead(parser); } matchToken1_(parser, '}'); - return node; + return writePosition(&pos, node); } static PkNode *atom(PkParser *parser) { @@ -1041,27 +1042,23 @@ static PkNode *atom(PkParser *parser) { case kPkTokenIdentifier: node = identifier(parser); break; - case kPkTokenNumber: { - PkNumber *number; - PkError *error; - + case kPkTokenNumber: matchToken1(parser, kPkTokenNumber); - number = PkNumberParse(TOKEN_STR(parser), &error); + { + PkError *error; + PkNumber *number = PkNumberParse(TOKEN_STR(parser), &error); + + if (!number) { + PkAutorelease(error); + PkParserParseError(parser, + "ParseError: cannot convert string \"%s\" to number: %s", + TOKEN_STR(parser), + PKCSTR(PkErrorGetReason(error))); + } - if (!number) { - PkAutorelease(error); - PkParserParseError(parser, - "ParseError: cannot convert string \"%s\" to number: %s", - TOKEN_STR(parser), - PKCSTR(PkErrorGetReason(error))); + PkAutorelease(number); + return copyPosition2(parser, PkNodeCreateNumber(number)); } - - node = PkNodeCreateNumber(number); - PkRelease(number); - COPY_POSITION(parser, NODE_POSITION(node)); - - return node; - } case kPkTokenString: node = string(parser); break; @@ -1095,8 +1092,10 @@ static PkNode *atom(PkParser *parser) { } static PkNode *callargs(PkParser *parser) { - PkNode *args = PkNodeCreateList(); + PkSourcePosition pos; + PkNode *args = PkNodeCreateList(); + copyPosition1(parser, &pos); if (lookahead(parser) != ')') { PkNodeListAppendNode(args, expr(parser)); @@ -1106,12 +1105,14 @@ static PkNode *callargs(PkParser *parser) { } } - return args; + return writePosition(&pos, args); } static PkNode *funcargs(PkParser *parser) { - PkNode *args = PkNodeCreateList(); + PkSourcePosition pos; + PkNode *args = PkNodeCreateList(); + copyPosition1(parser, &pos); if (lookahead(parser) != ')') { PkNodeListAppendNode(args, identifier(parser)); @@ -1121,19 +1122,21 @@ static PkNode *funcargs(PkParser *parser) { } } - return args; + return writePosition(&pos, args); } static PkNode *function(PkParser *parser) { - PkNode *args; + PkSourcePosition pos; + PkNode *args; matchToken1(parser, kPkTokenFunction); + copyPosition1(parser, &pos); matchToken1(parser, '('); args = funcargs(parser); matchToken1(parser, ')'); - return PkNodeCreateFunction(args, block(parser)); + return writePosition(&pos, PkNodeCreateFunction(args, block(parser))); } static PkNode *parse(PkParser *parser, parser_proc proc, PkError **errorPtr) { src/parser.c b8c7eb7605663e9c3cfd90df34ddbd747550f24e Takanori Ishikawa takanori.ishikawa@gmail.com http://github.com/ishikawa/pekoe/commit/7675a5cb4547e318ab45e1d21a95c916011eb648 7675a5cb4547e318ab45e1d21a95c916011eb648 2009-07-02T08:55:52-07:00 2009-07-02T08:55:52-07:00 Refined copy/write node position fc86f398308ac3023c4670cbc139cfe9695290ec Takanori Ishikawa takanori.ishikawa@gmail.com