Implement global variables. Struct and Pointer initializers are not implemented...

[oota-llvm.git] / lib / AsmParser / Lexer.l

diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index 761c6b5e62378b8e14bc1e046feb8fcdcc9c39d5..5bbe672882a1e72a1a5823c5885826dc63102f35 100644 (file)
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -32,7 +32,7 @@
 
 
 // TODO: All of the static identifiers are figured out by the lexer, 
-// these should be hashed.
+// these should be hashed to reduce the lexer size
 
 
 // atoull - Convert an ascii string of decimal digits into the unsigned long
@@ -80,7 +80,6 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull = false) {
   return BOut;
 }
 
-
 #define YY_NEVER_INTERACTIVE 1
 %}
 
@@ -123,26 +122,37 @@ end             { return END; }
 true            { return TRUE;  }
 false           { return FALSE; }
 declare         { return DECLARE; }
+global          { return GLOBAL; }
+constant        { return CONSTANT; }
+const           { return CONST; }
+uninitialized   { return UNINIT; }
 implementation  { return IMPLEMENTATION; }
 \.\.\.          { return DOTDOTDOT; }
 string          { return STRING; }
-
-void            { llvmAsmlval.TypeVal = Type::VoidTy  ; return VOID;   }
-bool            { llvmAsmlval.TypeVal = Type::BoolTy  ; return BOOL;   }
-sbyte           { llvmAsmlval.TypeVal = Type::SByteTy ; return SBYTE;  }
-ubyte           { llvmAsmlval.TypeVal = Type::UByteTy ; return UBYTE;  }
-short           { llvmAsmlval.TypeVal = Type::ShortTy ; return SHORT;  }
-ushort          { llvmAsmlval.TypeVal = Type::UShortTy; return USHORT; }
-int             { llvmAsmlval.TypeVal = Type::IntTy   ; return INT;    }
-uint            { llvmAsmlval.TypeVal = Type::UIntTy  ; return UINT;   }
-long            { llvmAsmlval.TypeVal = Type::LongTy  ; return LONG;   }
-ulong           { llvmAsmlval.TypeVal = Type::ULongTy ; return ULONG;  }
-float           { llvmAsmlval.TypeVal = Type::FloatTy ; return FLOAT;  }
-double          { llvmAsmlval.TypeVal = Type::DoubleTy; return DOUBLE; }
-
-type            { llvmAsmlval.TypeVal = Type::TypeTy  ; return TYPE;   }
-
-label           { llvmAsmlval.TypeVal = Type::LabelTy ; return LABEL;  }
+null            { return NULL_TOK; }
+to              { return TO; }
+except          { return EXCEPT; }
+
+void            { llvmAsmlval.PrimType = Type::VoidTy  ; return VOID;   }
+bool            { llvmAsmlval.PrimType = Type::BoolTy  ; return BOOL;   }
+sbyte           { llvmAsmlval.PrimType = Type::SByteTy ; return SBYTE;  }
+ubyte           { llvmAsmlval.PrimType = Type::UByteTy ; return UBYTE;  }
+short           { llvmAsmlval.PrimType = Type::ShortTy ; return SHORT;  }
+ushort          { llvmAsmlval.PrimType = Type::UShortTy; return USHORT; }
+int             { llvmAsmlval.PrimType = Type::IntTy   ; return INT;    }
+uint            { llvmAsmlval.PrimType = Type::UIntTy  ; return UINT;   }
+long            { llvmAsmlval.PrimType = Type::LongTy  ; return LONG;   }
+ulong           { llvmAsmlval.PrimType = Type::ULongTy ; return ULONG;  }
+float           { llvmAsmlval.PrimType = Type::FloatTy ; return FLOAT;  }
+double          { llvmAsmlval.PrimType = Type::DoubleTy; return DOUBLE; }
+
+type            { llvmAsmlval.PrimType = Type::TypeTy  ; return TYPE;   }
+
+label           { llvmAsmlval.PrimType = Type::LabelTy ; return LABEL;  }
+opaque          { llvmAsmlval.TypeVal = 
+                   new PATypeHolder<Type>(OpaqueType::get());
+                  return OPAQUE; 
+                }
 
 
 not             { RET_TOK(UnaryOpVal, Not, NOT); }
@@ -159,7 +169,6 @@ setgt           { RET_TOK(BinaryOpVal, SetGT, SETGT); }
 setle           { RET_TOK(BinaryOpVal, SetLE, SETLE); }
 setge           { RET_TOK(BinaryOpVal, SetGE, SETGE); }
 
-to              { return TO; }
 phi             { RET_TOK(OtherOpVal, PHINode, PHI); }
 call            { RET_TOK(OtherOpVal, Call, CALL); }
 cast            { RET_TOK(OtherOpVal, Cast, CAST); }
@@ -169,6 +178,7 @@ shr             { RET_TOK(OtherOpVal, Shr, SHR); }
 ret             { RET_TOK(TermOpVal, Ret, RET); }
 br              { RET_TOK(TermOpVal, Br, BR); }
 switch          { RET_TOK(TermOpVal, Switch, SWITCH); }
+invoke          { RET_TOK(TermOpVal, Invoke, INVOKE); }
 
 
 malloc          { RET_TOK(MemOpVal, Malloc, MALLOC); }
@@ -226,6 +236,6 @@ getelementptr   { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
 {FPConstant}    { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
 
 [ \t\n]         { /* Ignore whitespace */ }
-.               { /*printf("'%s'", yytext);*/ return yytext[0]; }
+.               { return yytext[0]; }
 
 %%