Moved the check module to the common dir.

Replaced the type constants by something more expandable.

git-svn-id: svn://svn.cc65.org/cc65/trunk@248 b7a2c559-68d2-44c3-8de9-860c34a00d81

diff --git a/src/cc65/asmcode.c b/src/cc65/asmcode.c
index 1b3706453eab4705311d276b8833286d611295fd..37e34fc55304a2b97a25aee5bbcca542d1a92fe9 100644 (file)
--- a/src/cc65/asmcode.c
+++ b/src/cc65/asmcode.c
@@ -33,8 +33,11 @@
 
 
 
-#include "asmline.h"
+/* common */
 #include "check.h"
+
+/* cc65 */
+#include "asmline.h"
 #include "global.h"
 #include "asmcode.h"
 
@@ -67,8 +70,8 @@ void AddCodeHint (const char* Hint)
 
 void AddEmptyLine (void)
 /* Add an empty line for formatting purposes */
-{                        
-    /* Use a somewhat weird construct to avoid that gcc complains about 
+{
+    /* Use a somewhat weird construct to avoid that gcc complains about
      * an empty format string.
      */
     static const char EmptyLine[] = "";

diff --git a/src/cc65/codegen.c b/src/cc65/codegen.c
index 09f6bb82fbb7ec8dc55146d27f1c385f50ff3f1a..7fcb122f1fe98f50d37c24a8f9e58dbad216b1d4 100644 (file)
--- a/src/cc65/codegen.c
+++ b/src/cc65/codegen.c
@@ -37,13 +37,13 @@
 #include <string.h>
 
 /* common */
+#include "check.h"
 #include "version.h"
 #include "xmalloc.h"
 
 /* cc65 */
 #include "asmcode.h"
 #include "asmlabel.h"
-#include "check.h"
 #include "cpu.h"
 #include "error.h"
 #include "global.h"
@@ -53,7 +53,7 @@
 #include "util.h"
 #include "codegen.h"
 
-                                                                            
+
 
 /*****************************************************************************/
 /*                                  Data                                    */

diff --git a/src/cc65/compile.c b/src/cc65/compile.c
index 1177c51e96363d5cc5144ad03feb53fc3661fcac..6eadc4a2125a43d836ef51e6d638e27baa673aec 100644 (file)
--- a/src/cc65/compile.c
+++ b/src/cc65/compile.c
@@ -35,8 +35,10 @@
 
 #include <stdlib.h>
 
-#include "../common/version.h"
-
+/* common */
+#include "version.h"
+         
+/* cc65 */
 #include "asmlabel.h"
 #include "codegen.h"
 #include "declare.h"
@@ -159,7 +161,7 @@ static void Parse (void)
                     * void types in non ANSI mode.
                     */
                            if (Size == 0) {
-                       if (!IsVoid (Decl.Type)) {
+                       if (!IsTypeVoid (Decl.Type)) {
                            if (!IsArray (Decl.Type)) {
                                /* Size is unknown and not an array */
                                Error (ERR_UNKNOWN_SIZE);
@@ -183,7 +185,7 @@ static void Parse (void)
                    ParseInit (Entry->Type);
                } else {
 
-                   if (IsVoid (Decl.Type)) {
+                   if (IsTypeVoid (Decl.Type)) {
                        /* We cannot declare variables of type void */
                        Error (ERR_ILLEGAL_TYPE);
                    } else if (Size == 0) {

diff --git a/src/cc65/datatype.c b/src/cc65/datatype.c
index 0d3edba74da19623636d7947965bfc5f042f0dee..c7070725735768c8e2b76e76a369d9011b9ef276 100644 (file)
--- a/src/cc65/datatype.c
+++ b/src/cc65/datatype.c
@@ -35,9 +35,11 @@
 
 #include <string.h>
 
-#include "../common/xmalloc.h"
-
+/* common */
 #include "check.h"
+#include "xmalloc.h"
+
+/* cc65 */
 #include "codegen.h"
 #include "datatype.h"
 #include "error.h"
@@ -60,7 +62,7 @@ type type_uint []     = { T_UINT,     T_END };
 type type_long []      = { T_LONG,     T_END };
 type type_ulong []     = { T_ULONG,    T_END };
 type type_void []      = { T_VOID,     T_END };
-type type_pschar []    = { T_PTR, T_CHAR, T_END };
+type type_pschar []    = { T_PTR, T_SCHAR, T_END };
 type type_puchar []    = { T_PTR, T_UCHAR, T_END };
 
 
@@ -150,7 +152,7 @@ void TypeFree (type* T)
 type GetDefaultChar (void)
 /* Return the default char type (signed/unsigned) depending on the settings */
 {
-    return SignedChars? T_CHAR : T_UCHAR;
+    return SignedChars? T_SCHAR : T_UCHAR;
 }
 
 
@@ -203,64 +205,86 @@ type* GetImplicitFuncType (void)
 
 
 
-void PrintType (FILE* F, const type* tarray)
+static type PrintTypeComp (FILE* F, type T, type Mask, const char* Name)
+/* Check for a specific component of the type. If it is there, print the
+ * name and remove it. Return the type with the component removed.
+ */
+{
+    if ((T & Mask) == Mask) {
+       fprintf (F, "%s ", Name);
+       T &= ~Mask;
+    }
+    return T;
+}
+
+
+
+void PrintType (FILE* F, const type* Type)
 /* Output translation of type array. */
 {
-    const type* p;
+    /* If the first field has const and/or volatile qualifiers, print and
+     * remove them.
+     */
+    type T = *Type++;
+    T = PrintTypeComp (F, T, T_QUAL_CONST, "const");
+    T = PrintTypeComp (F, T, T_QUAL_VOLATILE, "volatile");
 
-    for (p = tarray; *p != T_END; ++p) {
-       if (*p & T_UNSIGNED) {
-           fprintf (F, "unsigned ");
-       }
-       switch (*p) {
-           case T_VOID:
-               fprintf (F, "void\n");
-               break;
-           case T_CHAR:
-           case T_UCHAR:
+    /* Walk over the complete string */
+    do {
+
+       /* Check for the sizes */
+               T = PrintTypeComp (F, T, T_SIZE_SHORT, "short");
+       T = PrintTypeComp (F, T, T_SIZE_LONG, "long");
+       T = PrintTypeComp (F, T, T_SIZE_LONGLONG, "long long");
+
+       /* Signedness */
+       T = PrintTypeComp (F, T, T_SIGN_SIGNED, "signed");
+       T = PrintTypeComp (F, T, T_SIGN_UNSIGNED, "unsigned");
+
+       /* Now check the real type */
+       switch (T & T_MASK_TYPE) {
+           case T_TYPE_CHAR:
                fprintf (F, "char\n");
                break;
-           case T_INT:
-           case T_UINT:
+           case T_TYPE_INT:
                fprintf (F, "int\n");
                break;
-           case T_SHORT:
-           case T_USHORT:
-               fprintf (F, "short\n");
-               break;
-           case T_LONG:
-           case T_ULONG:
-               fprintf (F, "long\n");
-               break;
-           case T_FLOAT:
+           case T_TYPE_FLOAT:
                fprintf (F, "float\n");
                break;
-           case T_DOUBLE:
+           case T_TYPE_DOUBLE:
                fprintf (F, "double\n");
                break;
-           case T_PTR:
-               fprintf (F, "pointer to ");
+           case T_TYPE_VOID:
+               fprintf (F, "void\n");
+               break;
+           case T_TYPE_STRUCT:
+               fprintf (F, "struct %s\n", ((SymEntry*) DecodePtr (Type))->Name);
+               Type += DECODE_SIZE;
                break;
-           case T_ARRAY:
-                       fprintf (F, "array[%lu] of ", Decode (p + 1));
-               p += DECODE_SIZE;
+           case T_TYPE_UNION:
+               fprintf (F, "union %s\n", ((SymEntry*) DecodePtr (Type))->Name);
+               Type += DECODE_SIZE;
                break;
-           case T_STRUCT:
-               fprintf (F, "struct %s\n", ((SymEntry*) Decode (p + 1))->Name);
-               p += DECODE_SIZE;
+           case T_TYPE_ARRAY:
+                       fprintf (F, "array[%lu] of ", Decode (Type));
+               Type += DECODE_SIZE;
                break;
-           case T_UNION:
-               fprintf (F, "union %s\n", ((SymEntry*) Decode (p + 1))->Name);
-               p += DECODE_SIZE;
+           case T_TYPE_PTR:
+               fprintf (F, "pointer to ");
                break;
-           case T_FUNC:
+           case T_TYPE_FUNC:
                fprintf (F, "function returning ");
-               p += DECODE_SIZE;
+               Type += DECODE_SIZE;
                break;
            default:
-               fprintf (F, "unknown type: %04X\n", *p);
+               fprintf (F, "unknown type: %04X\n", T);
        }
-    }
+
+       /* Get the next type element */
+       T = *Type++;
+
+    } while (T != T_END);
 }
 
 
@@ -334,43 +358,53 @@ void CopyEncode (const type* Source, type* Target)
 
 
 
-unsigned SizeOf (const type* tarray)
+unsigned SizeOf (const type* T)
 /* Compute size of object represented by type array. */
 {
     SymEntry* Entry;
 
-    switch (*tarray) {
+    switch (*T) {
 
        case T_VOID:
            Error (ERR_ILLEGAL_SIZE);
            return 0;
 
-       case T_CHAR:
+       case T_SCHAR:
        case T_UCHAR:
            return 1;
 
-       case T_INT:
-       case T_UINT:
                case T_SHORT:
        case T_USHORT:
+       case T_INT:
+       case T_UINT:
        case T_PTR:
-        case T_ENUM:
            return 2;
 
         case T_LONG:
        case T_ULONG:
            return 4;
 
-       case T_ARRAY:
-           return (Decode (tarray + 1) * SizeOf (tarray + DECODE_SIZE + 1));
+       case T_LONGLONG:
+       case T_ULONGLONG:
+           return 8;
+
+        case T_ENUM:
+           return 2;
+
+       case T_FLOAT:
+       case T_DOUBLE:
+           return 4;
 
        case T_STRUCT:
        case T_UNION:
-                   Entry = DecodePtr (tarray+1);
+                   Entry = DecodePtr (T+1);
                    return Entry->V.S.Size;
 
+       case T_ARRAY:
+           return (Decode (T+ 1) * SizeOf (T + DECODE_SIZE + 1));
+
        default:
-           Internal ("Unknown type: %04X", *tarray);
+           Internal ("Unknown type in SizeOf: %04X", *T);
            return 0;
 
     }
@@ -378,17 +412,17 @@ unsigned SizeOf (const type* tarray)
 
 
 
-unsigned PSizeOf (const type* tptr)
+unsigned PSizeOf (const type* T)
 /* Compute size of pointer object. */
 {
     /* We are expecting a pointer expression */
-    CHECK (*tptr & T_POINTER);
+    CHECK ((*T & T_CLASS_PTR) != 0);
 
     /* Skip the pointer or array token itself */
-    if (*tptr == T_ARRAY) {
-               return SizeOf (tptr + DECODE_SIZE + 1);
+    if (*T == T_ARRAY) {
+               return SizeOf (T + DECODE_SIZE + 1);
     } else {
-       return SizeOf (tptr + 1);
+       return SizeOf (T + 1);
     }
 }
 
@@ -401,7 +435,7 @@ unsigned TypeOf (const type* Type)
 
     switch (*Type) {
 
-       case T_CHAR:
+       case T_SCHAR:
            return CF_CHAR;
 
        case T_UCHAR:
@@ -441,129 +475,130 @@ unsigned TypeOf (const type* Type)
 
 
 
-type* Indirect (type* Type)
+type* Indirect (type* T)
 /* Do one indirection for the given type, that is, return the type where the
  * given type points to.
  */
 {
     /* We are expecting a pointer expression */
-    CHECK (Type[0] & T_POINTER);
+    CHECK ((*T & T_MASK_CLASS) == T_CLASS_PTR);
 
     /* Skip the pointer or array token itself */
-    if (Type[0] == T_ARRAY) {
-               return Type + DECODE_SIZE + 1;
+    if (*T == T_ARRAY) {
+               return T + DECODE_SIZE + 1;
     } else {
-       return Type + 1;
+       return T + 1;
     }
 }
 
 
 
-int IsVoid (const type* Type)
+int IsTypeVoid (const type* T)
 /* Return true if this is a void type */
 {
-    return (Type[0] == T_VOID && Type[1] == T_END);
+    return (T[0] == T_VOID && T[1] == T_END);
 }
 
 
 
-int IsPtr (const type* Type)
+int IsPtr (const type* T)
 /* Return true if this is a pointer type */
 {
-    return (Type[0] & T_POINTER) != 0;
+    return (T[0] & T_MASK_CLASS) == T_CLASS_PTR;
 }
 
 
 
-int IsChar (const type* Type)
+int IsChar (const type* T)
 /* Return true if this is a character type */
 {
-    return (Type[0] == T_CHAR || Type[0] == T_UCHAR) && Type[1] == T_END;
+    return (T[0] & T_MASK_TYPE) == T_TYPE_CHAR && T[1] == T_END;
 }
 
 
 
-int IsInt (const type* Type)
+int IsInt (const type* T)
 /* Return true if this is an integer type */
 {
-    return (Type[0] & T_INTEGER) != 0;
+    return (T[0] & T_MASK_CLASS) == T_CLASS_INT;
 }
 
 
 
-int IsLong (const type* Type)
+int IsLong (const type* T)
 /* Return true if this is a long type (signed or unsigned) */
 {
-    return (Type[0] & T_LONG) == T_LONG;
+    return (T[0] & T_MASK_SIZE) == T_SIZE_LONG;
 }
 
 
 
-int IsUnsigned (const type* Type)
+int IsUnsigned (const type* T)
 /* Return true if this is an unsigned type */
 {
-    return (Type[0] & T_UNSIGNED) != 0;
+    return (T[0] & T_MASK_SIGN) == T_SIGN_UNSIGNED;
 }
 
 
 
-int IsStruct (const type* Type)
+int IsStruct (const type* T)
 /* Return true if this is a struct type */
 {
-    return (Type[0] == T_STRUCT || Type[0] == T_UNION);
+    return (T[0] & T_MASK_CLASS) == T_CLASS_STRUCT;
 }
 
 
 
-int IsFunc (const type* Type)
+int IsFunc (const type* T)
 /* Return true if this is a function type */
 {
-    return (Type[0] == T_FUNC);
+    return (T[0] == T_FUNC);
 }
 
 
 
-int IsFastCallFunc (const type* Type)
+int IsFastCallFunc (const type* T)
 /* Return true if this is a function type with __fastcall__ calling conventions */
 {
     FuncDesc* F;
-    CHECK (*Type == T_FUNC);
-    F = DecodePtr (Type+1);
+    CHECK (T[0] == T_FUNC);
+    F = DecodePtr (T+1);
     return (F->Flags & FD_FASTCALL) != 0;
 }
 
 
 
-int IsFuncPtr (const type* Type)
+int IsFuncPtr (const type* T)
 /* Return true if this is a function pointer */
 {
-    return (Type[0] == T_PTR && Type[1] == T_FUNC);
+    return (T[0] == T_PTR && T[1] == T_FUNC);
 }
 
 
 
-int IsArray (const type* Type)
+int IsArray (const type* T)
 /* Return true if this is an array type */
 {
-    return (Type[0] == T_ARRAY);
+    return (T[0] == T_ARRAY);
 }
 
 
 
-struct FuncDesc* GetFuncDesc (const type* Type)
+struct FuncDesc* GetFuncDesc (const type* T)
 /* Get the FuncDesc pointer from a function or pointer-to-function type */
 {
-    if (Type[0] == T_PTR) {
+    if (T[0] == T_PTR) {
        /* Pointer to function */
-       ++Type;
+       ++T;
     }
 
     /* Be sure it's a function type */
-    CHECK (Type[0] == T_FUNC);
+    CHECK (T[0] == T_FUNC);
 
     /* Decode the function descriptor and return it */
-    return DecodePtr (Type+1);
+    return DecodePtr (T+1);
 }
 
 
 
+

diff --git a/src/cc65/datatype.h b/src/cc65/datatype.h
index a9838c642797a5da26a37c42633dde72d1b73b4f..0d65ef289016be7fd9f79232dddfd7cd56272226 100644 (file)
--- a/src/cc65/datatype.h
+++ b/src/cc65/datatype.h
@@ -50,8 +50,8 @@
 
 
 // Basic data types
-enum type_t {
-    T_NONE                 = 0x0000,
+enum {
+    T_END          = 0x0000,
 
     // Basic types
     T_TYPE_NONE            = 0x0000,
@@ -97,61 +97,31 @@ enum type_t {
     T_MASK_QUAL            = 0x3000,
 
     // Types
-    T_CHAR                 = T_TYPE_CHAR     | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_NONE,
-    T_SCHAR        = T_TYPE_CHAR     | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_NONE,
-    T_UCHAR        = T_TYPE_CHAR     | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_NONE,
-    T_SHORT        = T_TYPE_INT      | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_SHORT,
-    T_USHORT        = T_TYPE_INT      | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_SHORT,
-    T_INT          = T_TYPE_INT      | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_NONE,
-    T_UINT         = T_TYPE_INT      | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_NONE,
-    T_LONG         = T_TYPE_INT      | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_LONG,
-    T_ULONG        = T_TYPE_INT      | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_LONG,
-    T_LONGLONG             = T_TYPE_INT      | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_LONGLONG,
-    T_ULONGLONG            = T_TYPE_INT      | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_LONGLONG,
-    T_ENUM         = T_TYPE_ENUM     | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_NONE,
-    T_FLOAT        = T_TYPE_FLOAT    | T_CLASS_FLOAT  | T_SIGN_NONE     | T_SIZE_NONE,
-    T_DOUBLE       = T_TYPE_DOUBLE   | T_CLASS_FLOAT  | T_SIGN_NONE     | T_SIZE_NONE,
-    T_VOID         = T_TYPE_VOID     | T_CLASS_NONE   | T_SIGN_NONE     | T_SIZE_NONE,
-    T_STRUCT        = T_TYPE_STRUCT   | T_CLASS_STRUCT | T_SIGN_NONE     | T_SIZE_NONE,
-    T_UNION         = T_TYPE_UNION    | T_CLASS_STRUCT | T_SIGN_NONE     | T_SIZE_NONE,
-    T_ARRAY        = T_TYPE_ARRAY    | T_CLASS_PTR    | T_SIGN_NONE     | T_SIZE_NONE,
-    T_PTR          = T_TYPE_PTR      | T_CLASS_PTR    | T_SIGN_NONE     | T_SIZE_NONE,
-    T_FUNC                 = T_TYPE_FUNC     | T_CLASS_FUNC   | T_SIGN_NONE     | T_SIZE_NONE,
+    T_CHAR             = T_TYPE_CHAR   | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_NONE,
+    T_SCHAR    = T_TYPE_CHAR   | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_NONE,
+    T_UCHAR    = T_TYPE_CHAR   | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_NONE,
+    T_SHORT    = T_TYPE_INT    | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_SHORT,
+    T_USHORT    = T_TYPE_INT    | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_SHORT,
+    T_INT      = T_TYPE_INT    | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_NONE,
+    T_UINT     = T_TYPE_INT    | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_NONE,
+    T_LONG     = T_TYPE_INT    | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_LONG,
+    T_ULONG    = T_TYPE_INT    | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_LONG,
+    T_LONGLONG         = T_TYPE_INT    | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_LONGLONG,
+    T_ULONGLONG        = T_TYPE_INT    | T_CLASS_INT    | T_SIGN_UNSIGNED | T_SIZE_LONGLONG,
+    T_ENUM             = T_TYPE_ENUM   | T_CLASS_INT    | T_SIGN_SIGNED   | T_SIZE_NONE,
+    T_FLOAT    = T_TYPE_FLOAT  | T_CLASS_FLOAT  | T_SIGN_NONE     | T_SIZE_NONE,
+    T_DOUBLE   = T_TYPE_DOUBLE | T_CLASS_FLOAT  | T_SIGN_NONE     | T_SIZE_NONE,
+    T_VOID     = T_TYPE_VOID   | T_CLASS_NONE   | T_SIGN_NONE     | T_SIZE_NONE,
+    T_STRUCT    = T_TYPE_STRUCT | T_CLASS_STRUCT | T_SIGN_NONE     | T_SIZE_NONE,
+    T_UNION     = T_TYPE_UNION  | T_CLASS_STRUCT | T_SIGN_NONE     | T_SIZE_NONE,
+    T_ARRAY    = T_TYPE_ARRAY  | T_CLASS_PTR    | T_SIGN_NONE     | T_SIZE_NONE,
+    T_PTR      = T_TYPE_PTR    | T_CLASS_PTR    | T_SIGN_NONE     | T_SIZE_NONE,
+    T_FUNC             = T_TYPE_FUNC   | T_CLASS_FUNC   | T_SIGN_NONE     | T_SIZE_NONE,
 
 };
 
 
 
-/* Data types */
-#define        T_END           0x0000
-#define T_CHAR                 0x0011
-#define T_INT                  0x0012
-#define        T_SHORT         0x0013
-#define T_LONG                 0x0014
-#define T_ENUM                 0x0015
-#define T_UCHAR                0x0019
-#define T_UINT                 0x001A
-#define T_USHORT               0x001B
-#define T_ULONG                0x001C
-
-#define T_FLOAT                0x0025
-#define T_DOUBLE               0x0026
-
-#define T_VOID                 0x0001          /* void parameter list */
-#define T_FUNC                 0x0002          /* Function */
-
-#define T_UNSIGNED             0x0008          /* Class */
-#define T_INTEGER              0x0010          /* Class */
-#define T_REAL                 0x0020          /* Class */
-#define T_POINTER              0x0040          /* Class */
-#define T_PTR                  0x0049
-#define T_ARRAY                0x004A
-#define T_STRUCT               0x0080
-#define T_UNION                0x0081
-#define T_SMASK                0x003F
-
-
-
 /* Forward for a symbol entry */
 struct SymEntry;
 
@@ -251,7 +221,7 @@ type* Indirect (type* Type);
  * given type points to.
  */
 
-int IsVoid (const type* Type);
+int IsTypeVoid (const type* Type);
 /* Return true if this is a void type */
 
 int IsPtr (const type* Type);

diff --git a/src/cc65/declare.c b/src/cc65/declare.c
index 8a8dda69171a04de06344c61667300147c969ebf..204355c2f6ab407488311c0983c2a6913a5bf1f2 100644 (file)
--- a/src/cc65/declare.c
+++ b/src/cc65/declare.c
@@ -840,7 +840,7 @@ void ParseDecl (const DeclSpec* Spec, Declaration* D, unsigned Mode)
     TypeCpy (D->T, Spec->Type);
 
     /* Check the size of the generated type */
-    if (!IsFunc (D->Type) && SizeOf (D->Type) >= 0x10000) {
+    if (!IsFunc (D->Type) && !IsTypeVoid (D->Type) && SizeOf (D->Type) >= 0x10000) {
        Error (ERR_ILLEGAL_SIZE);
     }
 }
@@ -886,7 +886,7 @@ static void ParseVoidInit (void)
        constexpr (&lval);
        switch (lval.e_tptr[0]) {
 
-           case T_CHAR:
+           case T_SCHAR:
            case T_UCHAR:
                if ((lval.e_flags & E_MCTYPE) == E_TCONST) {
                    /* Make it byte sized */
@@ -992,7 +992,7 @@ void ParseInit (type *tptr)
 
     switch (*tptr) {
 
-       case T_CHAR:
+       case T_SCHAR:
        case T_UCHAR:
            constexpr (&lval);
            if ((lval.e_flags & E_MCTYPE) == E_TCONST) {

diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index 48c284eb222fb73a71363a8b19671872bacc614d..995e042689ff7412a2e65a990af7fcad9740f9f8 100644 (file)
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -10,11 +10,13 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "../common/xmalloc.h"
+/* common */
+#include "check.h"
+#include "xmalloc.h"
 
+/* cc65 */
 #include "asmcode.h"
 #include "asmlabel.h"
-#include "check.h"
 #include "codegen.h"
 #include "datatype.h"
 #include "declare.h"
@@ -202,7 +204,7 @@ unsigned assignadjust (type* lhst, struct expent* rhs)
     rhs->e_tptr = lhst;
 
     /* First, do some type checking */
-    if (IsVoid (lhst) || IsVoid (rhst)) {
+    if (IsTypeVoid (lhst) || IsTypeVoid (rhst)) {
        /* If one of the sides are of type void, output a more apropriate
         * error message.
         */
@@ -948,7 +950,7 @@ static int arrayref (int k, struct expent* lval)
            /* Done */
            goto end_array;
 
-               } else if ((tptr2 = lval2.e_tptr) [0] & T_POINTER) {
+               } else if (IsPtr (tptr2 = lval2.e_tptr)) {
            /* Subscript is pointer, get element type */
            lval2.e_tptr = Indirect (tptr2);
 
@@ -1416,7 +1418,7 @@ static int typecast (struct expent* lval)
     }
 
     /* Do the actual cast. Special handling for void casts */
-    if (!IsVoid (Type)) {
+    if (!IsTypeVoid (Type)) {
        /* Mark the lhs as const to avoid a manipulation of TOS */
         g_typecast (TypeOf (Type) | CF_CONST, rflags);
     }

diff --git a/src/cc65/function.c b/src/cc65/function.c
index 7f26312d94ef6200f9a63a22acfcbf6f34a7fb71..d515bec886be295f5d3804a730f55c8b2bbce8fa 100644 (file)
--- a/src/cc65/function.c
+++ b/src/cc65/function.c
@@ -33,8 +33,10 @@
 
 
 
-#include "../common/xmalloc.h"
+/* common */
+#include "xmalloc.h"
 
+/* cc65 */
 #include "asmcode.h"
 #include "asmlabel.h"
 #include "codegen.h"
@@ -131,7 +133,7 @@ type* GetReturnType (Function* F)
 int HasVoidReturn (const Function* F)
 /* Return true if the function does not have a return value */
 {
-    return IsVoid (F->ReturnType);
+    return IsTypeVoid (F->ReturnType);
 }
 
 

diff --git a/src/cc65/input.c b/src/cc65/input.c
index d6c553d655ee372759cc4a666e77e22e60022df4..2e596ca63f97484a6982e4067d930d0c3135210f 100644 (file)
--- a/src/cc65/input.c
+++ b/src/cc65/input.c
@@ -37,10 +37,12 @@
 #include <string.h>
 #include <errno.h>
 
-#include "../common/xmalloc.h"
+/* common */
+#include "check.h"
+#include "xmalloc.h"
 
+/* cc65 */
 #include "asmcode.h"
-#include "check.h"
 #include "error.h"
 #include "global.h"
 #include "incpath.h"

diff --git a/src/cc65/litpool.c b/src/cc65/litpool.c
index 6243e38b5dbd50018a070ad91751420385c242c3..8886b67159e371bfa82baac0f8a8575350129fff 100644 (file)
--- a/src/cc65/litpool.c
+++ b/src/cc65/litpool.c
@@ -35,8 +35,11 @@
 
 #include <stdio.h>
 
-#include "asmlabel.h"
+/* common */
 #include "check.h"
+
+/* cc65 */
+#include "asmlabel.h"
 #include "ctrans.h"
 #include "codegen.h"
 #include "error.h"

diff --git a/src/cc65/make/gcc.mak b/src/cc65/make/gcc.mak
index e147918dc72dec84e13266b8c1c8eda19fe66f5a..5ec17501711a2465118a4c111de4da44c641512d 100644 (file)
--- a/src/cc65/make/gcc.mak
+++ b/src/cc65/make/gcc.mak
@@ -16,7 +16,6 @@ OBJS =        anonname.o      \
        asmcode.o       \
        asmlabel.o      \
        asmline.o       \
-       check.o         \
        codegen.o       \
        compile.o       \
        cpu.o           \

diff --git a/src/cc65/make/watcom.mak b/src/cc65/make/watcom.mak
index 122f3ac003daf790c75dd52c42874937b6ad6cc5..056b6ed1f8a85609f0ff121b03b793168f3fe7bd 100644 (file)
--- a/src/cc65/make/watcom.mak
+++ b/src/cc65/make/watcom.mak
@@ -71,7 +71,6 @@ OBJS =        anonname.obj    \
        asmcode.obj     \
        asmlabel.obj    \
        asmline.obj     \
-       check.obj       \
        codegen.obj     \
        compile.obj     \
        cpu.obj         \
@@ -128,7 +127,6 @@ FILE anonname.obj
 FILE asmcode.obj
 FILE asmlabel.obj
 FILE asmline.obj
-FILE check.obj
 FILE codegen.obj
 FILE compile.obj
 FILE cpu.obj

diff --git a/src/cc65/optimize.c b/src/cc65/optimize.c
index 48ce3fbb61233acae5c3c8dd4c2f05f0f501069d..19032a5287d2c439d9a20aa38a4c8ec5e4222f7c 100644 (file)
--- a/src/cc65/optimize.c
+++ b/src/cc65/optimize.c
@@ -40,12 +40,12 @@
 
 /* common */
 #include "attrib.h"
+#include "check.h"
 #include "xmalloc.h"
 
 /* cc65 */
 #include "asmlabel.h"
 #include "asmline.h"
-#include "check.h"
 #include "cpu.h"
 #include "error.h"
 #include "global.h"

diff --git a/src/cc65/segname.c b/src/cc65/segname.c
index a2e4b981db49f367ad3c53b7cdf113b23fdad73b..aa138d65c16ffc105abc7e8065c07932905f75b4 100644 (file)
--- a/src/cc65/segname.c
+++ b/src/cc65/segname.c
@@ -34,13 +34,13 @@
 
 
 #include <string.h>
-#include <ctype.h>                                           
+#include <ctype.h>
 
 /* common */
+#include "check.h"
 #include "xmalloc.h"
 
 /* cc65 */
-#include "check.h"
 #include "segname.h"
 
 

diff --git a/src/cc65/stdfunc.c b/src/cc65/stdfunc.c
index 23b2d7e140538c132bc256b36274d79553b8bd33..bc6faebf006964f7f0b46ab1cb1abb6d83b5e9a2 100644 (file)
--- a/src/cc65/stdfunc.c
+++ b/src/cc65/stdfunc.c
@@ -36,7 +36,10 @@
 #include <stdlib.h>
 #include <string.h>
 
+/* common */
 #include "check.h"
+
+/* cc65 */
 #include "codegen.h"
 #include "error.h"
 #include "global.h"

diff --git a/src/cc65/stmt.c b/src/cc65/stmt.c
index 1c79aca0cea159aac678106042fde49398374092..ff016ac10f0136893380d6b4c6ac6be46ad32567 100644 (file)
--- a/src/cc65/stmt.c
+++ b/src/cc65/stmt.c
@@ -306,7 +306,7 @@ static void cascadeswitch (struct expent* eval)
                    val = lval.e_const;
                    switch (*eval->e_tptr) {
 
-                       case T_CHAR:
+                       case T_SCHAR:
                            /* Signed char */
                            if (val < -128 || val > 127) {
                                Error (ERR_RANGE);

diff --git a/src/cc65/symtab.c b/src/cc65/symtab.c
index 86cbf41e5555ecc34afc2464dfaebe83a8223711..79fb1d50aee0d2aaef58c2098b0157f38aa03218 100644 (file)
--- a/src/cc65/symtab.c
+++ b/src/cc65/symtab.c
@@ -38,12 +38,14 @@
 #include <stdarg.h>
 #include <string.h>
 
-#include "../common/hashstr.h"
-#include "../common/xmalloc.h"
+/* common */
+#include "check.h"
+#include "hashstr.h"
+#include "xmalloc.h"
 
+/* cc65 */
 #include "asmcode.h"
 #include "asmlabel.h"
-#include "check.h"
 #include "codegen.h"
 #include "datatype.h"
 #include "declare.h"