return Result;
}
-
-// HexToFP - Convert the ascii string in hexidecimal format to the floating
+// HexToFP - Convert the ascii string in hexadecimal format to the floating
// point representation of it.
//
static double HexToFP(const char *Buffer) {
return BitsToDouble(HexIntToVal(Buffer)); // Cast Hex constant to double
}
+static void HexToIntPair(const char *Buffer, uint64_t Pair[2]) {
+ Pair[0] = 0;
+ for (int i=0; i<16; i++, Buffer++) {
+ assert(*Buffer);
+ Pair[0] *= 16;
+ char C = *Buffer;
+ if (C >= '0' && C <= '9')
+ Pair[0] += C-'0';
+ else if (C >= 'A' && C <= 'F')
+ Pair[0] += C-'A'+10;
+ else if (C >= 'a' && C <= 'f')
+ Pair[0] += C-'a'+10;
+ }
+ Pair[1] = 0;
+ for (int i=0; i<16 && *Buffer; i++, Buffer++) {
+ Pair[1] *= 16;
+ char C = *Buffer;
+ if (C >= '0' && C <= '9')
+ Pair[1] += C-'0';
+ else if (C >= 'A' && C <= 'F')
+ Pair[1] += C-'A'+10;
+ else if (C >= 'a' && C <= 'f')
+ Pair[1] += C-'a'+10;
+ }
+ if (*Buffer)
+ GenerateError("constant bigger than 128 bits detected!");
+}
// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
// appropriate character.
-char *UnEscapeLexed(char *Buffer) {
+char *UnEscapeLexed(char *Buffer, char* EndBuffer) {
char *BOut = Buffer;
for (char *BIn = Buffer; *BIn; ) {
- if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
- char Tmp = BIn[3]; BIn[3] = 0; // Terminate string
- *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number
- BIn[3] = Tmp; // Restore character
- BIn += 3; // Skip over handled chars
- ++BOut;
+ if (BIn[0] == '\\') {
+ if (BIn < EndBuffer-1 && BIn[1] == '\\') {
+ *BOut++ = '\\'; // Two \ becomes one
+ BIn += 2;
+ } else if (BIn < EndBuffer-2 && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
+ char Tmp = BIn[3]; BIn[3] = 0; // Terminate string
+ *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number
+ BIn[3] = Tmp; // Restore character
+ BIn += 3; // Skip over handled chars
+ ++BOut;
+ } else {
+ *BOut++ = *BIn++;
+ }
} else {
*BOut++ = *BIn++;
}
PInteger [0-9]+
NInteger -[0-9]+
-/* FPConstant - A Floating point constant.
+/* FPConstant - A Floating point constant. Float and double only.
*/
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.
+ * Float and double only.
*/
HexFPConstant 0x[0-9A-Fa-f]+
+/* F80HexFPConstant - x87 long double in hexadecimal format (10 bytes)
+ */
+HexFP80Constant 0xK[0-9A-Fa-f]+
+
+/* F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes)
+ */
+HexFP128Constant 0xL[0-9A-Fa-f]+
+
+/* PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes)
+ */
+HexPPC128Constant 0xM[0-9A-Fa-f]+
+
/* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
* it to deal with 64 bit numbers.
*/
HexIntConstant [us]0x[0-9A-Fa-f]+
+/* WSNL - shorthand for whitespace followed by newline */
+WSNL [ \r\t]*$
%%
{Comment} { /* Ignore comments for now */ }
x86_stdcallcc { return X86_STDCALLCC_TOK; }
x86_fastcallcc { return X86_FASTCALLCC_TOK; }
+signext { return SIGNEXT; }
+zeroext { return ZEROEXT; }
inreg { return INREG; }
sret { return SRET; }
nounwind { return NOUNWIND; }
noreturn { return NORETURN; }
+noalias { return NOALIAS; }
+byval { return BYVAL; }
+nest { return NEST; }
+sext{WSNL} { // For auto-upgrade only, drop in LLVM 3.0
+ return SIGNEXT; }
+zext{WSNL} { // For auto-upgrade only, drop in LLVM 3.0
+ return ZEROEXT; }
void { RET_TY(Type::VoidTy, VOID); }
float { RET_TY(Type::FloatTy, FLOAT); }
double { RET_TY(Type::DoubleTy,DOUBLE);}
+x86_fp80 { RET_TY(Type::X86_FP80Ty, X86_FP80);}
+fp128 { RET_TY(Type::FP128Ty, FP128);}
+ppc_fp128 { RET_TY(Type::PPC_FP128Ty, PPC_FP128);}
label { RET_TY(Type::LabelTy, LABEL); }
type { return TYPE; }
opaque { return OPAQUE; }
}
{QuoteLabel} {
yytext[yyleng-2] = 0; // nuke colon, end quote
- const char* EndChar = UnEscapeLexed(yytext+1);
+ const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
llvmAsmlval.StrVal =
new std::string(yytext+1, EndChar - yytext - 1);
return LABELSTR;
}
{StringConstant} { yytext[yyleng-1] = 0; // nuke end quote
- const char* EndChar = UnEscapeLexed(yytext+1);
+ const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
llvmAsmlval.StrVal =
new std::string(yytext+1, EndChar - yytext - 1);
return STRINGCONSTANT;
}
{AtStringConstant} {
yytext[yyleng-1] = 0; // nuke end quote
- const char* EndChar = UnEscapeLexed(yytext+2);
+ const char* EndChar =
+ UnEscapeLexed(yytext+2, yytext+yyleng);
llvmAsmlval.StrVal =
new std::string(yytext+2, EndChar - yytext - 2);
return ATSTRINGCONSTANT;
}
{PctStringConstant} {
yytext[yyleng-1] = 0; // nuke end quote
- const char* EndChar = UnEscapeLexed(yytext+2);
+ const char* EndChar =
+ UnEscapeLexed(yytext+2, yytext+yyleng);
llvmAsmlval.StrVal =
new std::string(yytext+2, EndChar - yytext - 2);
return PCTSTRINGCONSTANT;
return GLOBALVAL_ID;
}
-{FPConstant} { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
-{HexFPConstant} { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
+{FPConstant} { llvmAsmlval.FPVal = new APFloat(atof(yytext)); return FPVAL; }
+{HexFPConstant} { llvmAsmlval.FPVal = new APFloat(HexToFP(yytext+2));
+ return FPVAL;
+ }
+{HexFP80Constant} { uint64_t Pair[2];
+ HexToIntPair(yytext+3, Pair);
+ llvmAsmlval.FPVal = new APFloat(APInt(80, 2, Pair));
+ return FPVAL;
+ }
+{HexFP128Constant} { uint64_t Pair[2];
+ HexToIntPair(yytext+3, Pair);
+ llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair), true);
+ return FPVAL;
+ }
+{HexPPC128Constant} { uint64_t Pair[2];
+ HexToIntPair(yytext+3, Pair);
+ llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair));
+ return FPVAL;
+ }
<<EOF>> {
/* Make sure to free the internal buffers for flex when we are
projects / oota-llvm.git / blobdiff