gered/picoc
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Stricter handling of semicolons at the end of statements.

Browse source 
git-svn-id: http://picoc.googlecode.com/svn/trunk@402 21eae674-98b7-11dd-bd71-f92a316d2d60
This commit is contained in:
zik.saleeba 2009-11-22 11:36:15 +00:00
parent 5e6ddfa7ff
commit fc348214c9
3 changed files with 27 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
expression.c
View file

@ -457,7 +457,8 @@ void ExpressionPrefixOperator(struct ParseState *Parser, struct ExpressionStack
if (TopValue->Typ == &FPType) if (TopValue->Typ == &FPType)
{ {
/* floating point prefix arithmetic */ /* floating point prefix arithmetic */
double ResultFP; double ResultFP = 0.0;
switch (Op) switch (Op)
{ {
case TokenPlus: ResultFP = TopValue->Val->FP; break; case TokenPlus: ResultFP = TopValue->Val->FP; break;
@ -1233,7 +1234,7 @@ void ExpressionParseFunctionCall(struct ParseState *Parser, struct ExpressionSta
for (Count = 0; Count < FuncValue->Val->FuncDef.NumParams; Count++) for (Count = 0; Count < FuncValue->Val->FuncDef.NumParams; Count++)
VariableDefine(Parser, FuncValue->Val->FuncDef.ParamName[Count], ParamArray[Count], NULL, TRUE); VariableDefine(Parser, FuncValue->Val->FuncDef.ParamName[Count], ParamArray[Count], NULL, TRUE);
if (ParseStatement(&FuncParser) != ParseResultOk) if (ParseStatement(&FuncParser, TRUE) != ParseResultOk)
ProgramFail(&FuncParser, "function body expected"); ProgramFail(&FuncParser, "function body expected");
if (FuncValue->Val->FuncDef.ReturnType != &VoidType && FuncParser.Mode == RunModeRun) if (FuncValue->Val->FuncDef.ReturnType != &VoidType && FuncParser.Mode == RunModeRun)

44
parse.c
View file

@ -11,19 +11,19 @@ void ParseCleanup()
} }
/* parse a statement, but only run it if Condition is TRUE */ /* parse a statement, but only run it if Condition is TRUE */
enum ParseResult ParseStatementMaybeRun(struct ParseState *Parser, int Condition) enum ParseResult ParseStatementMaybeRun(struct ParseState *Parser, int Condition, int CheckTrailingSemicolon)
{ {
if (Parser->Mode != RunModeSkip && !Condition) if (Parser->Mode != RunModeSkip && !Condition)
{ {
enum RunMode OldMode = Parser->Mode; enum RunMode OldMode = Parser->Mode;
int Result; int Result;
Parser->Mode = RunModeSkip; Parser->Mode = RunModeSkip;
Result = ParseStatement(Parser); Result = ParseStatement(Parser, CheckTrailingSemicolon);
Parser->Mode = OldMode; Parser->Mode = OldMode;
return Result; return Result;
} }
else else
return ParseStatement(Parser); return ParseStatement(Parser, CheckTrailingSemicolon);
} }
/* parse a function definition and store it for later */ /* parse a function definition and store it for later */
@ -96,7 +96,7 @@ struct Value *ParseFunctionDefinition(struct ParseState *Parser, struct ValueTyp
ProgramFail(Parser, "bad function definition"); ProgramFail(Parser, "bad function definition");
FuncBody = *Parser; FuncBody = *Parser;
if (ParseStatementMaybeRun(Parser, FALSE) != ParseResultOk) if (ParseStatementMaybeRun(Parser, FALSE, TRUE) != ParseResultOk)
ProgramFail(Parser, "function definition expected"); ProgramFail(Parser, "function definition expected");
FuncValue->Val->FuncDef.Body = FuncBody; FuncValue->Val->FuncDef.Body = FuncBody;
@ -253,7 +253,7 @@ void ParseFor(struct ParseState *Parser)
if (LexGetToken(Parser, NULL, TRUE) != TokenOpenBracket) if (LexGetToken(Parser, NULL, TRUE) != TokenOpenBracket)
ProgramFail(Parser, "'(' expected"); ProgramFail(Parser, "'(' expected");
if (ParseStatement(Parser) != ParseResultOk) if (ParseStatement(Parser, TRUE) != ParseResultOk)
ProgramFail(Parser, "statement expected"); ProgramFail(Parser, "statement expected");
ParserCopyPos(&PreConditional, Parser); ParserCopyPos(&PreConditional, Parser);
@ -263,13 +263,13 @@ void ParseFor(struct ParseState *Parser)
ProgramFail(Parser, "';' expected"); ProgramFail(Parser, "';' expected");
ParserCopyPos(&PreIncrement, Parser); ParserCopyPos(&PreIncrement, Parser);
ParseStatementMaybeRun(Parser, FALSE); ParseStatementMaybeRun(Parser, FALSE, FALSE);
if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket) if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket)
ProgramFail(Parser, "')' expected"); ProgramFail(Parser, "')' expected");
ParserCopyPos(&PreStatement, Parser); ParserCopyPos(&PreStatement, Parser);
if (ParseStatementMaybeRun(Parser, Condition) != ParseResultOk) if (ParseStatementMaybeRun(Parser, Condition, TRUE) != ParseResultOk)
ProgramFail(Parser, "statement expected"); ProgramFail(Parser, "statement expected");
if (Parser->Mode == RunModeContinue) if (Parser->Mode == RunModeContinue)
@ -280,7 +280,7 @@ void ParseFor(struct ParseState *Parser)
while (Condition && Parser->Mode == RunModeRun) while (Condition && Parser->Mode == RunModeRun)
{ {
ParserCopyPos(Parser, &PreIncrement); ParserCopyPos(Parser, &PreIncrement);
ParseStatement(Parser); ParseStatement(Parser, FALSE);
ParserCopyPos(Parser, &PreConditional); ParserCopyPos(Parser, &PreConditional);
Condition = ExpressionParseInt(Parser); Condition = ExpressionParseInt(Parser);
@ -288,7 +288,7 @@ void ParseFor(struct ParseState *Parser)
if (Condition) if (Condition)
{ {
ParserCopyPos(Parser, &PreStatement); ParserCopyPos(Parser, &PreStatement);
ParseStatement(Parser); ParseStatement(Parser, TRUE);
if (Parser->Mode == RunModeContinue) if (Parser->Mode == RunModeContinue)
Parser->Mode = RunModeRun; Parser->Mode = RunModeRun;
@ -312,14 +312,14 @@ enum RunMode ParseBlock(struct ParseState *Parser, int AbsorbOpenBrace, int Cond
/* condition failed - skip this block instead */ /* condition failed - skip this block instead */
enum RunMode OldMode = Parser->Mode; enum RunMode OldMode = Parser->Mode;
Parser->Mode = RunModeSkip; Parser->Mode = RunModeSkip;
while (ParseStatement(Parser) == ParseResultOk) while (ParseStatement(Parser, TRUE) == ParseResultOk)
{} {}
Parser->Mode = OldMode; Parser->Mode = OldMode;
} }
else else
{ {
/* just run it in its current mode */ /* just run it in its current mode */
while (ParseStatement(Parser) == ParseResultOk) while (ParseStatement(Parser, TRUE) == ParseResultOk)
{} {}
} }
@ -330,12 +330,11 @@ enum RunMode ParseBlock(struct ParseState *Parser, int AbsorbOpenBrace, int Cond
} }
/* parse a statement */ /* parse a statement */
enum ParseResult ParseStatement(struct ParseState *Parser) enum ParseResult ParseStatement(struct ParseState *Parser, int CheckTrailingSemicolon)
{ {
struct Value *CValue; struct Value *CValue;
struct Value *LexerValue; struct Value *LexerValue;
int Condition; int Condition;
int CheckTrailingSemicolon = TRUE;
struct ParseState PreState = *Parser; struct ParseState PreState = *Parser;
enum LexToken Token = LexGetToken(Parser, NULL, TRUE); enum LexToken Token = LexGetToken(Parser, NULL, TRUE);
@ -366,13 +365,13 @@ enum ParseResult ParseStatement(struct ParseState *Parser)
if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket) if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket)
ProgramFail(Parser, "')' expected"); ProgramFail(Parser, "')' expected");
if (ParseStatementMaybeRun(Parser, Condition) != ParseResultOk) if (ParseStatementMaybeRun(Parser, Condition, TRUE) != ParseResultOk)
ProgramFail(Parser, "statement expected"); ProgramFail(Parser, "statement expected");
if (LexGetToken(Parser, NULL, FALSE) == TokenElse) if (LexGetToken(Parser, NULL, FALSE) == TokenElse)
{ {
LexGetToken(Parser, NULL, TRUE); LexGetToken(Parser, NULL, TRUE);
if (ParseStatementMaybeRun(Parser, !Condition) != ParseResultOk) if (ParseStatementMaybeRun(Parser, !Condition, TRUE) != ParseResultOk)
ProgramFail(Parser, "statement expected"); ProgramFail(Parser, "statement expected");
} }
CheckTrailingSemicolon = FALSE; CheckTrailingSemicolon = FALSE;
@ -393,7 +392,7 @@ enum ParseResult ParseStatement(struct ParseState *Parser)
if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket) if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket)
ProgramFail(Parser, "')' expected"); ProgramFail(Parser, "')' expected");
if (ParseStatementMaybeRun(Parser, Condition) != ParseResultOk) if (ParseStatementMaybeRun(Parser, Condition, TRUE) != ParseResultOk)
ProgramFail(Parser, "statement expected"); ProgramFail(Parser, "statement expected");
if (Parser->Mode == RunModeContinue) if (Parser->Mode == RunModeContinue)
@ -415,7 +414,7 @@ enum ParseResult ParseStatement(struct ParseState *Parser)
do do
{ {
ParserCopyPos(Parser, &PreStatement); ParserCopyPos(Parser, &PreStatement);
if (ParseStatement(Parser) != ParseResultOk) if (ParseStatement(Parser, TRUE) != ParseResultOk)
ProgramFail(Parser, "statement expected"); ProgramFail(Parser, "statement expected");
if (Parser->Mode == RunModeContinue) if (Parser->Mode == RunModeContinue)
@ -590,8 +589,11 @@ enum ParseResult ParseStatement(struct ParseState *Parser)
return ParseResultError; return ParseResultError;
} }
if (CheckTrailingSemicolon && LexGetToken(Parser, NULL, FALSE) == TokenSemicolon) if (CheckTrailingSemicolon)
LexGetToken(Parser, NULL, TRUE); {
if (LexGetToken(Parser, NULL, TRUE) != TokenSemicolon)
ProgramFail(Parser, "';' expected");
}
return ParseResultOk; return ParseResultOk;
} }
@ -610,7 +612,7 @@ void Parse(const char *FileName, const char *Source, int SourceLen, int RunIt)
LexInitParser(&Parser, Source, Tokens, FileName, RunIt); LexInitParser(&Parser, Source, Tokens, FileName, RunIt);
do { do {
Ok = ParseStatement(&Parser); Ok = ParseStatement(&Parser, TRUE);
} while (Ok == ParseResultOk); } while (Ok == ParseResultOk);
if (Ok == ParseResultError) if (Ok == ParseResultError)
@ -635,7 +637,7 @@ void ParseInteractive()
do do
{ {
LexInteractiveStatementPrompt(); LexInteractiveStatementPrompt();
Ok = ParseStatement(&Parser); Ok = ParseStatement(&Parser, TRUE);
LexInteractiveCompleted(&Parser); LexInteractiveCompleted(&Parser);
} while (Ok == ParseResultOk); } while (Ok == ParseResultOk);

2
picoc.h
View file

@ -310,7 +310,7 @@ void LexInteractiveCompleted(struct ParseState *Parser);
void LexInteractiveStatementPrompt(); void LexInteractiveStatementPrompt();
/* parse.c */ /* parse.c */
enum ParseResult ParseStatement(struct ParseState *Parser); enum ParseResult ParseStatement(struct ParseState *Parser, int CheckTrailingSemicolon);
struct Value *ParseFunctionDefinition(struct ParseState *Parser, struct ValueType *ReturnType, char *Identifier, int IsProtoType); struct Value *ParseFunctionDefinition(struct ParseState *Parser, struct ValueType *ReturnType, char *Identifier, int IsProtoType);
void Parse(const char *FileName, const char *Source, int SourceLen, int RunIt); void Parse(const char *FileName, const char *Source, int SourceLen, int RunIt);
void ParseInteractive(); void ParseInteractive();