This loop executed exactly one time, turn it into straightline code

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

diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l
index c8e7b270126763e2b576d2f7339746c571c9d47d..7776c90a90a1c3ef8d17f91c2754f343b35b7e1f 100644 (file)
--- a/lib/AsmParser/Lexer.l
+++ b/lib/AsmParser/Lexer.l
@@ -1,8 +1,8 @@
-/*===-- Lexer.l - Scanner for llvm assembly files ----------------*- C++ -*--=//
+/*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
 //
 //  This file implements the flex scanner for LLVM assembly languages files.
 //
-//===------------------------------------------------------------------------=*/
+//===----------------------------------------------------------------------===*/
 
 %option prefix="llvmAsm"
 %option yylineno
@@ -19,9 +19,6 @@
 
 %{
 #include "ParserInternals.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/Method.h"
-#include "llvm/Module.h"
 #include <list>
 #include "llvmAsmParser.h"
 #include <ctype.h>
@@ -39,19 +36,47 @@
 // long representation... this does not have to do input error checking, 
 // because we know that the input will be matched by a suitable regex...
 //
-uint64_t atoull(const char *Buffer) {
+static uint64_t atoull(const char *Buffer) {
   uint64_t Result = 0;
   for (; *Buffer; Buffer++) {
     uint64_t OldRes = Result;
     Result *= 10;
     Result += *Buffer-'0';
-    if (Result < OldRes) {  // Uh, oh, overflow detected!!!
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
       ThrowException("constant bigger than 64 bits detected!");
-    }
   }
   return Result;
 }
 
+// HexToFP - Convert the ascii string in hexidecimal format to the floating
+// point representation of it.
+//
+static double HexToFP(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; ++Buffer) {
+    uint64_t OldRes = Result;
+    Result *= 16;
+    char C = *Buffer;
+    if (C >= '0' && C <= '9')
+      Result += C-'0';
+    else if (C >= 'A' && C <= 'F')
+      Result += C-'A'+10;
+    else if (C >= 'a' && C <= 'f')
+      Result += C-'a'+10;
+
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      ThrowException("constant bigger than 64 bits detected!");
+  }
+
+  assert(sizeof(double) == sizeof(Result) &&
+         "Data sizes incompatible on this target!");
+  // Behave nicely in the face of C TBAA rules... see:
+  // http://www.nullstone.com/htmls/category/aliastyp.htm
+  //
+  char *ProxyPointer = (char*)&Result;
+  return *(double*)ProxyPointer;   // Cast Hex constant to double
+}
+
 
 // UnEscapeLexed - Run through the specified buffer and change \xx codes to the
 // appropriate character.  If AllowNull is set to false, a \00 value will cause
@@ -60,7 +85,7 @@ uint64_t atoull(const char *Buffer) {
 // If AllowNull is set to true, the return value of the function points to the
 // last character of the string in memory.
 //
-char *UnEscapeLexed(char *Buffer, bool AllowNull = false) {
+char *UnEscapeLexed(char *Buffer, bool AllowNull) {
   char *BOut = Buffer;
   for (char *BIn = Buffer; *BIn; ) {
     if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
@@ -89,10 +114,10 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull = false) {
 Comment    ;.*
 
 /* Variable(Value) identifiers start with a % sign */
-VarID       %[a-zA-Z$._][a-zA-Z$._0-9]*
+VarID       %[-a-zA-Z$._][-a-zA-Z$._0-9]*
 
 /* Label identifiers end with a colon */
-Label       [a-zA-Z$._0-9]+:
+Label       [-a-zA-Z$._0-9]+:
 
 /* Quoted names can contain any character except " and \ */
 StringConstant \"[^\"]+\"
@@ -110,28 +135,34 @@ PInteger   [0-9]+
 NInteger  -[0-9]+
 
 /* FPConstant - A Floating point constant.
-   TODO: Expand lexer to support 10e50 FP constant notation */
+ */
 FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
 
+/* HexFPConstant - Floating point constant represented in IEEE format as a
+ *  hexadecimal number for when exponential notation is not precise enough.
+ */
+HexFPConstant 0x[0-9A-Fa-f]+
 %%
 
 {Comment}       { /* Ignore comments for now */ }
 
 begin           { return BEGINTOK; }
-end             { return END; }
+end             { return ENDTOK; }
 true            { return TRUE;  }
 false           { return FALSE; }
 declare         { return DECLARE; }
 global          { return GLOBAL; }
 constant        { return CONSTANT; }
 const           { return CONST; }
-uninitialized   { return UNINIT; }
+internal        { return INTERNAL; }
+uninitialized   { return EXTERNAL; }    /* Deprecated, turn into external */
+external        { return EXTERNAL; }
 implementation  { return IMPLEMENTATION; }
 \.\.\.          { return DOTDOTDOT; }
-string          { return STRING; }
 null            { return NULL_TOK; }
 to              { return TO; }
 except          { return EXCEPT; }
+not             { return NOT; }  /* Deprecated, turned into XOR */
 
 void            { llvmAsmlval.PrimType = Type::VoidTy  ; return VOID;   }
 bool            { llvmAsmlval.PrimType = Type::BoolTy  ; return BOOL;   }
@@ -145,17 +176,9 @@ 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); }
+opaque          { return OPAQUE; }
 
 add             { RET_TOK(BinaryOpVal, Add, ADD); }
 sub             { RET_TOK(BinaryOpVal, Sub, SUB); }
@@ -237,6 +260,7 @@ getelementptr   { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
                 }
 
 {FPConstant}    { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
+{HexFPConstant} { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
 
 [ \t\n]         { /* Ignore whitespace */ }
 .               { return yytext[0]; }