diff --git a/expression.c b/expression.c
index adcf1a0..6681bd6 100644
--- a/expression.c
+++ b/expression.c
@@ -457,7 +457,8 @@ void ExpressionPrefixOperator(struct ParseState *Parser, struct ExpressionStack
             if (TopValue->Typ == &FPType)
             {
                 /* floating point prefix arithmetic */
-                double ResultFP;
+                double ResultFP = 0.0;
+                
                 switch (Op)
                 {
                     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++)
                 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");
         
             if (FuncValue->Val->FuncDef.ReturnType != &VoidType && FuncParser.Mode == RunModeRun)
diff --git a/parse.c b/parse.c
index 0208a8a..013b016 100644
--- a/parse.c
+++ b/parse.c
@@ -11,19 +11,19 @@ void ParseCleanup()
 }
 
 /* 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)
     {
         enum RunMode OldMode = Parser->Mode;
         int Result;
         Parser->Mode = RunModeSkip;
-        Result = ParseStatement(Parser);
+        Result = ParseStatement(Parser, CheckTrailingSemicolon);
         Parser->Mode = OldMode;
         return Result;
     }
     else
-        return ParseStatement(Parser);
+        return ParseStatement(Parser, CheckTrailingSemicolon);
 }
 
 /* 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");
         
         FuncBody = *Parser;
-        if (ParseStatementMaybeRun(Parser, FALSE) != ParseResultOk)
+        if (ParseStatementMaybeRun(Parser, FALSE, TRUE) != ParseResultOk)
             ProgramFail(Parser, "function definition expected");
 
         FuncValue->Val->FuncDef.Body = FuncBody;
@@ -253,7 +253,7 @@ void ParseFor(struct ParseState *Parser)
     if (LexGetToken(Parser, NULL, TRUE) != TokenOpenBracket)
         ProgramFail(Parser, "'(' expected");
                         
-    if (ParseStatement(Parser) != ParseResultOk)
+    if (ParseStatement(Parser, TRUE) != ParseResultOk)
         ProgramFail(Parser, "statement expected");
     
     ParserCopyPos(&PreConditional, Parser);
@@ -263,13 +263,13 @@ void ParseFor(struct ParseState *Parser)
         ProgramFail(Parser, "';' expected");
     
     ParserCopyPos(&PreIncrement, Parser);
-    ParseStatementMaybeRun(Parser, FALSE);
+    ParseStatementMaybeRun(Parser, FALSE, FALSE);
     
     if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket)
         ProgramFail(Parser, "')' expected");
     
     ParserCopyPos(&PreStatement, Parser);
-    if (ParseStatementMaybeRun(Parser, Condition) != ParseResultOk)
+    if (ParseStatementMaybeRun(Parser, Condition, TRUE) != ParseResultOk)
         ProgramFail(Parser, "statement expected");
     
     if (Parser->Mode == RunModeContinue)
@@ -280,7 +280,7 @@ void ParseFor(struct ParseState *Parser)
     while (Condition && Parser->Mode == RunModeRun)
     {
         ParserCopyPos(Parser, &PreIncrement);
-        ParseStatement(Parser);
+        ParseStatement(Parser, FALSE);
                         
         ParserCopyPos(Parser, &PreConditional);
         Condition = ExpressionParseInt(Parser);
@@ -288,7 +288,7 @@ void ParseFor(struct ParseState *Parser)
         if (Condition)
         {
             ParserCopyPos(Parser, &PreStatement);
-            ParseStatement(Parser);
+            ParseStatement(Parser, TRUE);
             
             if (Parser->Mode == RunModeContinue)
                 Parser->Mode = RunModeRun;                
@@ -312,14 +312,14 @@ enum RunMode ParseBlock(struct ParseState *Parser, int AbsorbOpenBrace, int Cond
         /* condition failed - skip this block instead */
         enum RunMode OldMode = Parser->Mode;
         Parser->Mode = RunModeSkip;
-        while (ParseStatement(Parser) == ParseResultOk)
+        while (ParseStatement(Parser, TRUE) == ParseResultOk)
         {}
         Parser->Mode = OldMode;
     }
     else
     { 
         /* 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 */
-enum ParseResult ParseStatement(struct ParseState *Parser)
+enum ParseResult ParseStatement(struct ParseState *Parser, int CheckTrailingSemicolon)
 {
     struct Value *CValue;
     struct Value *LexerValue;
     int Condition;
-    int CheckTrailingSemicolon = TRUE;
     struct ParseState PreState = *Parser;
     enum LexToken Token = LexGetToken(Parser, NULL, TRUE);
     
@@ -366,13 +365,13 @@ enum ParseResult ParseStatement(struct ParseState *Parser)
             if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket)
                 ProgramFail(Parser, "')' expected");
 
-            if (ParseStatementMaybeRun(Parser, Condition) != ParseResultOk)
+            if (ParseStatementMaybeRun(Parser, Condition, TRUE) != ParseResultOk)
                 ProgramFail(Parser, "statement expected");
             
             if (LexGetToken(Parser, NULL, FALSE) == TokenElse)
             {
                 LexGetToken(Parser, NULL, TRUE);
-                if (ParseStatementMaybeRun(Parser, !Condition) != ParseResultOk)
+                if (ParseStatementMaybeRun(Parser, !Condition, TRUE) != ParseResultOk)
                     ProgramFail(Parser, "statement expected");
             }
             CheckTrailingSemicolon = FALSE;
@@ -393,7 +392,7 @@ enum ParseResult ParseStatement(struct ParseState *Parser)
                     if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket)
                         ProgramFail(Parser, "')' expected");
                     
-                    if (ParseStatementMaybeRun(Parser, Condition) != ParseResultOk)
+                    if (ParseStatementMaybeRun(Parser, Condition, TRUE) != ParseResultOk)
                         ProgramFail(Parser, "statement expected");
                     
                     if (Parser->Mode == RunModeContinue)
@@ -415,7 +414,7 @@ enum ParseResult ParseStatement(struct ParseState *Parser)
                 do
                 {
                     ParserCopyPos(Parser, &PreStatement);
-                    if (ParseStatement(Parser) != ParseResultOk)
+                    if (ParseStatement(Parser, TRUE) != ParseResultOk)
                         ProgramFail(Parser, "statement expected");
                 
                     if (Parser->Mode == RunModeContinue)
@@ -590,8 +589,11 @@ enum ParseResult ParseStatement(struct ParseState *Parser)
             return ParseResultError;
     }
     
-    if (CheckTrailingSemicolon && LexGetToken(Parser, NULL, FALSE) == TokenSemicolon)
-        LexGetToken(Parser, NULL, TRUE);
+    if (CheckTrailingSemicolon)
+    {
+        if (LexGetToken(Parser, NULL, TRUE) != TokenSemicolon)
+            ProgramFail(Parser, "';' expected");
+    }
     
     return ParseResultOk;
 }
@@ -610,7 +612,7 @@ void Parse(const char *FileName, const char *Source, int SourceLen, int RunIt)
     LexInitParser(&Parser, Source, Tokens, FileName, RunIt);
 
     do {
-        Ok = ParseStatement(&Parser);
+        Ok = ParseStatement(&Parser, TRUE);
     } while (Ok == ParseResultOk);
     
     if (Ok == ParseResultError)
@@ -635,7 +637,7 @@ void ParseInteractive()
     do
     {
         LexInteractiveStatementPrompt();
-        Ok = ParseStatement(&Parser);
+        Ok = ParseStatement(&Parser, TRUE);
         LexInteractiveCompleted(&Parser);
         
     } while (Ok == ParseResultOk);
diff --git a/picoc.h b/picoc.h
index 11e82ec..9295252 100644
--- a/picoc.h
+++ b/picoc.h
@@ -310,7 +310,7 @@ void LexInteractiveCompleted(struct ParseState *Parser);
 void LexInteractiveStatementPrompt();
 
 /* 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);
 void Parse(const char *FileName, const char *Source, int SourceLen, int RunIt);
 void ParseInteractive();