Implemented typedef

git-svn-id: http://picoc.googlecode.com/svn/trunk@421 21eae674-98b7-11dd-bd71-f92a316d2d60

parse.c

@@ -344,14 +344,34 @@ enum RunMode ParseBlock(struct ParseState *Parser, int AbsorbOpenBrace, int Cond
     return Parser->Mode;
 }
 
+/* parse a typedef declaration */
+void ParseTypedef(struct ParseState *Parser)
+{
+    struct ValueType *Typ;
+    struct ValueType **TypPtr;
+    char *TypeName;
+    struct Value InitValue;
+    
+    TypeParse(Parser, &Typ, &TypeName);
+    
+    if (Parser->Mode == RunModeRun)
+    {
+        TypPtr = &Typ;
+        InitValue.Typ = &TypeType;
+        InitValue.Val = (union AnyValue *)TypPtr;
+        VariableDefine(Parser, TypeName, &InitValue, NULL, FALSE);
+    }
+}
+
 /* parse a statement */
 enum ParseResult ParseStatement(struct ParseState *Parser, int CheckTrailingSemicolon)
 {
     struct Value *CValue;
     struct Value *LexerValue;
+    struct Value *VarValue;
     int Condition;
     struct ParseState PreState = *Parser;
-    enum LexToken Token = LexGetToken(Parser, NULL, TRUE);
+    enum LexToken Token = LexGetToken(Parser, &LexerValue, TRUE);
     
     switch (Token)
     {
@@ -359,6 +379,19 @@ enum ParseResult ParseStatement(struct ParseState *Parser, int CheckTrailingSemi
             return ParseResultEOF;
             
         case TokenIdentifier:
+            /* might be a typedef-typed variable declaration or it might be an expression */
+            if (VariableDefined(LexerValue->Val->Identifier))
+            {
+                VariableGet(Parser, LexerValue->Val->Identifier, &VarValue);
+                if (VarValue->Typ->Base == Type_Type)
+                {
+                    *Parser = PreState;
+                    ParseDeclaration(Parser, Token);
+                    break;
+                }
+            }
+            /* else fallthrough to expression */
+            
         case TokenAsterisk: 
         case TokenAmpersand: 
         case TokenIncrement: 
@@ -583,6 +616,10 @@ enum ParseResult ParseStatement(struct ParseState *Parser, int CheckTrailingSemi
                 ExpressionParse(Parser, &CValue);
             break;
 
+        case TokenTypedef:
+            ParseTypedef(Parser);
+            break;
+                
         case TokenDelete:
         {
             /* try it as a function or variable name to delete */

tests/39_typedef.c

@@ -0,0 +1,22 @@
+typedef int MyInt;
+
+MyInt a = 1;
+printf("%d\n", a);
+
+struct FunStruct
+{
+    int i;
+    int j;
+};
+
+typedef struct FunStruct MyFunStruct;
+
+MyFunStruct b;
+b.i = 12;
+b.j = 34;
+printf("%d,%d\n", b.i, b.j);
+
+typedef MyFunStruct *MoreFunThanEver;
+
+MoreFunThanEver c = &b;
+printf("%d,%d\n", c->i, c->j);

tests/39_typedef.expect

@@ -0,0 +1,3 @@
+1
+12,34
+12,34

tests/Makefile

@@ -31,7 +31,8 @@ TESTS=	00_assignment.test \
 	35_sizeof.test \
 	36_array_initialisers.test \
         37_sprintf.test \
-	38_multiple_array_index.test
+	38_multiple_array_index.test \
+	39_typedef.test
 
 %.test: %.expect %.c
 	@echo Test: $*...

type.c

@@ -315,14 +315,16 @@ void TypeParseEnum(struct ParseState *Parser, struct ValueType **Typ)
 int TypeParseFront(struct ParseState *Parser, struct ValueType **Typ)
 {
     struct ParseState Before = *Parser;
-    enum LexToken Token = LexGetToken(Parser, NULL, TRUE);
+    struct Value *LexerValue;
+    enum LexToken Token = LexGetToken(Parser, &LexerValue, TRUE);
     int Unsigned = FALSE;
+    struct Value *VarValue;
     *Typ = NULL;
 
     /* handle signed/unsigned with no trailing type */
     if (Token == TokenSignedType || Token == TokenUnsignedType)
     {
-        enum LexToken FollowToken = LexGetToken(Parser, NULL, FALSE);
+        enum LexToken FollowToken = LexGetToken(Parser, &LexerValue, FALSE);
         Unsigned = (Token == TokenUnsignedType);
         
         if (FollowToken != TokenIntType && FollowToken != TokenLongType && FollowToken != TokenShortType && FollowToken != TokenCharType)
@@ -335,7 +337,7 @@ int TypeParseFront(struct ParseState *Parser, struct ValueType **Typ)
             return TRUE;
         }
         
-        Token = LexGetToken(Parser, NULL, TRUE);
+        Token = LexGetToken(Parser, &LexerValue, TRUE);
     }
     
     switch (Token)
@@ -363,6 +365,12 @@ int TypeParseFront(struct ParseState *Parser, struct ValueType **Typ)
             TypeParseEnum(Parser, Typ);
             break;
         
+        case TokenIdentifier:
+            /* we already know it's a typedef-defined type because we got here */
+            VariableGet(Parser, LexerValue->Val->Identifier, &VarValue);
+            *Typ = VarValue->Val->Typ;
+            break;
+
         default: *Parser = Before; return FALSE;
     }