/* */
/* */
/* */
-/* (C) 2000 Ullrich von Bassewitz */
+/* (C) 2000-2001 Ullrich von Bassewitz */
/* Wacholderweg 14 */
/* D-70597 Stuttgart */
/* EMail: uz@musoftware.de */
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;
/*****************************************************************************/
-/* Code */
+/* Code */
/*****************************************************************************/
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 (""));
* 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 */
*/
if (Preprocessing) {
/* Illegal expression in PP mode */
- Error (ERR_CPP_EXPR_EXPECTED);
+ Error ("Preprocessor expression expected");
/* Skip the token for error recovery */
NextToken ();
/* 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 {
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
} 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);
} else {
/* Illegal primary. */
- Error (ERR_EXPR_EXPECTED);
+ Error ("Expression expected");
N = GetIntNode (0);
}
/* 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
*/
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
*/
/* 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);
}
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);
NT = NT_STRUCT_ACCESS;
}
if (!IsClassStruct (StructType)) {
- Error (ERR_STRUCT_EXPECTED);
+ Error ("Struct expected");
return GetIntNode (0);
}
NextToken ();
if (CurTok.Tok != TOK_IDENT) {
/* Print an error */
- Error (ERR_IDENT_EXPECTED);
+ Error ("Identifier expected");
/* Return an integer expression instead */
return GetIntNode (0);
}
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);
}
if (!IsTypeFunc (Left->Type) && !IsTypeFuncPtr (Left->Type)) {
/* Call to non function */
- Error (ERR_ILLEGAL_FUNC_CALL);
+ Error ("Illegal function call");
/* Free the old tree */
FreeExprTree (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.
/* 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 */
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
static ExprNode* PostfixExpr (void)
+/* Handle a postfix expression */
{
/* Get the lower level expression */
ExprNode* Root = Primary ();
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
if (!IsClassInt (Op->Type) && !IsClassFloat (Op->Type)) {
/* Output diagnostic */
- Error (ERR_SYNTAX);
+ Error ("Syntax error");
/* Free the errorneous node */
FreeExprTree (Op);
if (!IsClassInt (Op->Type)) {
/* Display diagnostic */
- Error (ERR_OP_NOT_ALLOWED);
+ Error ("Operation not allowed on this type");
/* Free the errorneous node */
FreeExprTree (Op);
ExprNode* Root;
/* Print diagnostics */
- Error (ERR_ILLEGAL_ADDRESS);
+ Error ("Cannot take address of rvalue");
/* Free the problematic tree */
FreeExprTree (Op);
static ExprNode* DoIndirect (void)
-/* Handle the indirection operaror * */
+/* Handle the indirection operator * */
{
ExprNode* Op;
type* ResultType;
if (!IsClassPtr (Op->Type)) {
/* Print diagnostics */
- Error (ERR_ILLEGAL_INDIRECT);
+ Error ("Illegal indirection");
/* Free the problematic tree */
FreeExprTree (Op);
} else {
/* Must be casted. Setup the expression tree and return the new node */
- Root = AllocExprNode (NT_BOOL_NOT, TargetType, RVALUE);
+ Root = AllocExprNode (NT_TYPECAST, TargetType, RVALUE);
SetLeftNode (Root, Op);
return Root;
/* Check the type of the left operand */
if (!IsClassInt (Left->Type) && !IsClassFloat (Left->Type)) {
- MError ("Invalid left operand to binary operator `*'");
+ Error ("Invalid left operand to binary operator `*'");
FreeExprTree (Left);
Left = GetIntNode (0);
}
/* Check the type of the right operand */
if (!IsClassInt (Right->Type) && !IsClassFloat (Right->Type)) {
- MError ("Invalid right operand to binary operator `*'");
+ Error ("Invalid right operand to binary operator `*'");
FreeExprTree (Right);
Right = GetIntNode (0);
}
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 */
FreeExprTree (Right);
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 */
FreeExprTree (Right);
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 */
FreeExprTree (Right);
-
projects / cc65 / blobdiff