X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fcc65%2Fparser.c;h=ec1dfcc43941a6bac49116d27103676969179b81;hb=c130e597b013e37c94afd6651be1e8859ba7e5ac;hp=1d22b397c33146f55b46607cafc02ba3f751b0bb;hpb=8a79129caa69771e1e710771eec59a6598643766;p=cc65 diff --git a/src/cc65/parser.c b/src/cc65/parser.c index 1d22b397c..ec1dfcc43 100644 --- a/src/cc65/parser.c +++ b/src/cc65/parser.c @@ -6,7 +6,7 @@ /* */ /* */ /* */ -/* (C) 2000 Ullrich von Bassewitz */ +/* (C) 2000-2001 Ullrich von Bassewitz */ /* Wacholderweg 14 */ /* D-70597 Stuttgart */ /* EMail: uz@musoftware.de */ @@ -79,9 +79,7 @@ ExprNode* Expression (void); static int IsTypeExpr (void) -/* Return true if some sort of variable or type is waiting (helper for cast - * and sizeof() in hie10). - */ +/* Return true if some sort of variable or type is waiting */ { SymEntry* Entry; @@ -137,7 +135,7 @@ static ExprNode* GetIntNode (int Value) /*****************************************************************************/ -/* Code */ +/* Code */ /*****************************************************************************/ @@ -164,7 +162,7 @@ ExprNode* DoAsm (void) if (CurTok.Tok != TOK_SCONST) { /* Print an error */ - Error (ERR_STRLIT_EXPECTED); + Error ("String literal expected"); /* To be on the safe side later, insert an empty asm string */ AppendItem (N, xstrdup ("")); @@ -179,7 +177,7 @@ ExprNode* DoAsm (void) * will fail if the next token is also a string token, but that's a * syntax error anyway, because we expect a right paren. */ - ResetLiteralOffs (CurTok.IVal); + ResetLiteralPoolOffs (CurTok.IVal); } /* Skip the string token */ @@ -238,7 +236,7 @@ static ExprNode* Primary (void) */ if (Preprocessing) { /* Illegal expression in PP mode */ - Error (ERR_CPP_EXPR_EXPECTED); + Error ("Preprocessor expression expected"); /* Skip the token for error recovery */ NextToken (); @@ -266,19 +264,20 @@ static ExprNode* Primary (void) /* Check for illegal symbol types */ if ((Sym->Flags & SC_LABEL) == SC_LABEL) { /* Cannot use labels in expressions */ - Error (ERR_SYMBOL_KIND); + Error ("Cannot use a label in an expression"); return GetIntNode (0); } else if (Sym->Flags & SC_TYPE) { /* Cannot use type symbols */ - Error (ERR_VAR_IDENT_EXPECTED); + Error ("Cannot use a type in an expression"); /* Assume an int type to make lval valid */ return GetIntNode (0); } - /* Handle enum values as constant integers */ - if ((Sym->Flags & SC_ENUM) == SC_ENUM) { + /* Handle constants including enum values */ + if ((Sym->Flags & SC_CONST) == SC_CONST) { - N = GetIntNode (Sym->V.EnumVal); + N = AllocExprNode (NT_CONST, Sym->Type, RVALUE); + N->IVal = Sym->V.ConstVal; } else { @@ -307,7 +306,7 @@ static ExprNode* Primary (void) if (CurTok.Tok == TOK_LPAREN) { /* Warn about the use of a function without prototype */ - Warning (WARN_FUNC_WITHOUT_PROTO); + Warning ("Function call without a prototype"); /* Declare a function returning int. For that purpose, prepare * a function signature for a function having an empty param @@ -320,7 +319,7 @@ static ExprNode* Primary (void) } else { /* Print an error about an undeclared variable */ - Error (ERR_UNDEFINED_SYMBOL, Ident); + Error ("Undefined symbiol: `%s'", Ident); /* Undeclared Variable */ Sym = AddLocalSym (Ident, type_int, SC_AUTO | SC_REF, 0); @@ -370,7 +369,7 @@ static ExprNode* Primary (void) } else { /* Illegal primary. */ - Error (ERR_EXPR_EXPECTED); + Error ("Expression expected"); N = GetIntNode (0); } @@ -396,15 +395,13 @@ static ExprNode* DoArray (ExprNode* Left) Right = Expression (); /* Check the types. As special "C" feature, accept a reversal of base and - * index types: - * char C = 3["abcdefg"]; - * is legal C! + * index types: char C = 3["abcdefg"] is legal C! */ if (IsClassPtr (Left->Type)) { /* Right side must be some sort of integer */ if (!IsClassInt (Right->Type)) { /* Print an error */ - Error (ERR_CANNOT_SUBSCRIPT); + Error ("Invalid subscript"); /* To avoid problems later, create a new, legal subscript * expression */ @@ -415,9 +412,9 @@ static ExprNode* DoArray (ExprNode* Left) ExprNode* Tmp; /* Left side must be some sort of integer */ - if (!IsClassInt (Right->Type)) { + if (!IsClassInt (Left->Type)) { /* Print an error */ - Error (ERR_CANNOT_SUBSCRIPT); + Error ("Invalid subscript"); /* To avoid problems later, create a new, legal subscript * expression */ @@ -433,7 +430,7 @@ static ExprNode* DoArray (ExprNode* Left) /* Invalid array expression. Skip the closing bracket, then return * an integer instead of the array expression to be safe later. */ - Error (ERR_CANNOT_SUBSCRIPT); + Error ("Invalid subscript"); ConsumeRBrack (); return GetIntNode (0); } @@ -475,7 +472,7 @@ static ExprNode* DoStruct (ExprNode* Left) if (CurTok.Tok == TOK_PTR_REF) { NT = NT_STRUCTPTR_ACCESS; if (!IsTypePtr (StructType)) { - Error (ERR_STRUCT_PTR_EXPECTED); + Error ("Struct pointer expected"); return GetIntNode (0); } StructType = Indirect (StructType); @@ -483,7 +480,7 @@ static ExprNode* DoStruct (ExprNode* Left) NT = NT_STRUCT_ACCESS; } if (!IsClassStruct (StructType)) { - Error (ERR_STRUCT_EXPECTED); + Error ("Struct expected"); return GetIntNode (0); } @@ -491,7 +488,7 @@ static ExprNode* DoStruct (ExprNode* Left) NextToken (); if (CurTok.Tok != TOK_IDENT) { /* Print an error */ - Error (ERR_IDENT_EXPECTED); + Error ("Identifier expected"); /* Return an integer expression instead */ return GetIntNode (0); } @@ -502,7 +499,7 @@ static ExprNode* DoStruct (ExprNode* Left) Field = FindStructField (StructType, Ident); if (Field == 0) { /* Struct field not found */ - Error (ERR_STRUCT_FIELD_MISMATCH, Ident); + Error ("Struct/union has no field named `%s'", Ident); /* Return an integer expression instead */ return GetIntNode (0); } @@ -541,10 +538,10 @@ static ExprNode* DoFunctionCall (ExprNode* Left) if (!IsTypeFunc (Left->Type) && !IsTypeFuncPtr (Left->Type)) { /* Call to non function */ - Error (ERR_ILLEGAL_FUNC_CALL); + Error ("Illegal function call"); - /* Free the old node */ - FreeExprNode (Left); + /* Free the old tree */ + FreeExprTree (Left); /* Return something safe */ return GetIntNode (0); @@ -590,9 +587,9 @@ static ExprNode* DoFunctionCall (ExprNode* Left) } } else if (!Ellipsis) { /* Too many arguments. Do we have an open param list? */ - if ((Func->Flags & FD_ELLIPSIS) == 0) { + if ((Func->Flags & FD_VARIADIC) == 0) { /* End of param list reached, no ellipsis */ - Error (ERR_TOO_MANY_FUNC_ARGS); + Error ("Too many function arguments"); } /* Assume an ellipsis even in case of errors to avoid an error * message for each other argument. @@ -617,7 +614,7 @@ static ExprNode* DoFunctionCall (ExprNode* Left) /* Check if we had enough parameters */ if (ParamCount < Func->ParamCount) { - Error (ERR_TOO_FEW_FUNC_ARGS); + Error ("Too few function arguments"); } /* Return the function call node */ @@ -641,7 +638,7 @@ static ExprNode* DoPostIncDec (ExprNode* Left) if (Left->LValue == 0) { /* Print a diagnostics */ - Error (ERR_LVALUE_EXPECTED); + Error ("lvalue expected"); /* It is safe to return the operand expression and probably better * than returning an int, since the operand expression already has @@ -662,6 +659,7 @@ static ExprNode* DoPostIncDec (ExprNode* Left) static ExprNode* PostfixExpr (void) +/* Handle a postfix expression */ { /* Get the lower level expression */ ExprNode* Root = Primary (); @@ -723,7 +721,7 @@ static ExprNode* DoPreIncDec (void) if (Op->LValue == 0) { /* Print a diagnostics */ - Error (ERR_LVALUE_EXPECTED); + Error ("lvalue expected"); /* It is safe to return the operand expression and probably better * than returning an int, since the operand expression already has @@ -759,11 +757,11 @@ static ExprNode* DoUnaryPlusMinus (void) /* Type check */ if (!IsClassInt (Op->Type) && !IsClassFloat (Op->Type)) { - /* Display diagnostic */ - Error (ERR_SYNTAX); + /* Output diagnostic */ + Error ("Syntax error"); /* Free the errorneous node */ - FreeExprNode (Op); + FreeExprTree (Op); /* Return something that makes sense later */ return GetIntNode (0); @@ -819,10 +817,10 @@ static ExprNode* DoComplement (void) if (!IsClassInt (Op->Type)) { /* Display diagnostic */ - Error (ERR_OP_NOT_ALLOWED); + Error ("Operation not allowed on this type"); /* Free the errorneous node */ - FreeExprNode (Op); + FreeExprTree (Op); /* Return something that makes sense later */ return GetIntNode (0); @@ -892,10 +890,10 @@ static ExprNode* DoAddress (void) ExprNode* Root; /* Print diagnostics */ - Error (ERR_ILLEGAL_ADDRESS); + Error ("Cannot take address of rvalue"); - /* Free the problematic node */ - FreeExprNode (Op); + /* Free the problematic tree */ + FreeExprTree (Op); /* Return something that is safe later */ Root = AllocExprNode (NT_CONST, PointerTo (type_void), 0); @@ -910,7 +908,7 @@ static ExprNode* DoAddress (void) static ExprNode* DoIndirect (void) -/* Handle the indirection operaror * */ +/* Handle the indirection operator * */ { ExprNode* Op; type* ResultType; @@ -926,10 +924,10 @@ static ExprNode* DoIndirect (void) if (!IsClassPtr (Op->Type)) { /* Print diagnostics */ - Error (ERR_ILLEGAL_INDIRECT); + Error ("Illegal indirection"); - /* Free the problematic node */ - FreeExprNode (Op); + /* Free the problematic tree */ + FreeExprTree (Op); /* Return something that is safe later ### */ return GetIntNode (0); @@ -980,7 +978,7 @@ static ExprNode* DoSizeOf (void) Size = SizeOf (N->Type); /* Free the node */ - FreeExprNode (N); + FreeExprTree (N); } @@ -1021,8 +1019,8 @@ static ExprNode* DoTypeCast (void) } else { - /* Must be casted. Setup the expression tree and return the new node */ - Root = AllocExprNode (NT_BOOL_NOT, TargetType, RVALUE); + /* Must be casted. Setup the expression tree and return the new node */ + Root = AllocExprNode (NT_TYPECAST, TargetType, RVALUE); SetLeftNode (Root, Op); return Root; @@ -1049,7 +1047,7 @@ static ExprNode* UnaryExpr (void) case TOK_PLUS: case TOK_MINUS: - return DoUnaryPlusMinus (); + return DoUnaryPlusMinus (); case TOK_COMP: return DoComplement (); @@ -1066,18 +1064,55 @@ static ExprNode* UnaryExpr (void) case TOK_SIZEOF: return DoSizeOf (); - default: - /* Type cast */ - return DoTypeCast (); + default: + /* Type cast */ + return DoTypeCast (); - } + } } else { - /* Call the lower level */ - return PostfixExpr (); + /* Call the lower level */ + return PostfixExpr (); + + } +} + + + +static ExprNode* DoMul (ExprNode* Left) +/* Handle multiplication */ +{ + type TargetType[MAXTYPELEN]; + ExprNode* Right; + ExprNode* Root; + + /* Check the type of the left operand */ + if (!IsClassInt (Left->Type) && !IsClassFloat (Left->Type)) { + Error ("Invalid left operand to binary operator `*'"); + FreeExprTree (Left); + Left = GetIntNode (0); + } + + /* Skip the operator token */ + NextToken (); + + /* Read the right expression */ + Right = UnaryExpr (); + /* Check the type of the right operand */ + if (!IsClassInt (Right->Type) && !IsClassFloat (Right->Type)) { + Error ("Invalid right operand to binary operator `*'"); + FreeExprTree (Right); + Right = GetIntNode (0); } + + /* Make the root node */ + Root = AllocExprNode (NT_BOOL_NOT, TargetType, RVALUE); + SetLeftNode (Root, Left); + SetRightNode (Root, Right); + + return Root; } @@ -1094,6 +1129,7 @@ static ExprNode* MultExpr (void) switch (CurTok.Tok) { case TOK_MUL: + Root = DoMul (Root); break; case TOK_DIV: @@ -1259,11 +1295,11 @@ static ExprNode* AndExpr (void) if (!IsClassInt (Left->Type) || !IsClassInt (Right->Type)) { /* Print a diagnostic */ - Error (ERR_OP_NOT_ALLOWED); + Error ("Operation not allowed for these types"); /* Remove the unneeded nodes */ - FreeExprNode (Right); - FreeExprNode (Left); + FreeExprTree (Right); + FreeExprTree (Left); /* Create something safe */ Root = GetIntNode (0); @@ -1277,8 +1313,8 @@ static ExprNode* AndExpr (void) int Result = GetBoolRep (Left) & GetBoolRep (Right); /* Remove the unneeded nodes */ - FreeExprNode (Right); - FreeExprNode (Left); + FreeExprTree (Right); + FreeExprTree (Left); /* Create a constant result */ Root = GetIntNode (Result); @@ -1322,11 +1358,11 @@ static ExprNode* XorExpr (void) if (!IsClassInt (Left->Type) || !IsClassInt (Right->Type)) { /* Print a diagnostic */ - Error (ERR_OP_NOT_ALLOWED); + Error ("Operation not allowed for these types"); /* Remove the unneeded nodes */ - FreeExprNode (Right); - FreeExprNode (Left); + FreeExprTree (Right); + FreeExprTree (Left); /* Create something safe */ Root = GetIntNode (0); @@ -1340,8 +1376,8 @@ static ExprNode* XorExpr (void) int Result = GetBoolRep (Left) ^ GetBoolRep (Right); /* Remove the unneeded nodes */ - FreeExprNode (Right); - FreeExprNode (Left); + FreeExprTree (Right); + FreeExprTree (Left); /* Create a constant result */ Root = GetIntNode (Result); @@ -1385,11 +1421,11 @@ static ExprNode* OrExpr (void) if (!IsClassInt (Left->Type) || !IsClassInt (Right->Type)) { /* Print a diagnostic */ - Error (ERR_OP_NOT_ALLOWED); + Error ("Operation not allowed for these types"); /* Remove the unneeded nodes */ - FreeExprNode (Right); - FreeExprNode (Left); + FreeExprTree (Right); + FreeExprTree (Left); /* Create something safe */ Root = GetIntNode (0); @@ -1403,8 +1439,8 @@ static ExprNode* OrExpr (void) int Result = GetBoolRep (Left) | GetBoolRep (Right); /* Remove the unneeded nodes */ - FreeExprNode (Right); - FreeExprNode (Left); + FreeExprTree (Right); + FreeExprTree (Left); /* Create a constant result */ Root = GetIntNode (Result); @@ -1451,8 +1487,8 @@ static ExprNode* BoolAndExpr (void) int Result = GetBoolRep (Left) && GetBoolRep (Right); /* Remove the unneeded nodes */ - FreeExprNode (Right); - FreeExprNode (Left); + FreeExprTree (Right); + FreeExprTree (Left); /* Create a constant result */ Root = GetIntNode (Result); @@ -1499,8 +1535,8 @@ static ExprNode* BoolOrExpr (void) int Result = GetBoolRep (Left) && GetBoolRep (Right); /* Remove the unneeded nodes */ - FreeExprNode (Right); - FreeExprNode (Left); + FreeExprTree (Right); + FreeExprTree (Left); /* Create a constant result */ Root = GetIntNode (Result); @@ -1571,4 +1607,3 @@ static ExprNode* ConditionalExpr (void) -