PascalStrings("fpascal-strings",
llvm::cl::desc("Recognize and construct Pascal-style "
"string literals"));
+
+static llvm::cl::opt<bool>
+MSExtensions("fms-extensions",
+ llvm::cl::desc("Accept some non-standard constructs used in "
+ "Microsoft header files. "));
static llvm::cl::opt<bool>
WritableStrings("fwritable-strings",
Options.Trigraphs = 1; // -trigraphs or -ansi
Options.DollarIdents = 1; // FIXME: Really a target property.
Options.PascalStrings = PascalStrings;
+ Options.Microsoft = MSExtensions;
Options.WritableStrings = WritableStrings;
Options.LaxVectorConversions = LaxVectorConversions;
}
DefineBuiltinMacro(Buf, "__cplusplus=1");
DefineBuiltinMacro(Buf, "__private_extern__=extern");
}
-
+ if (PP.getLangOptions().Microsoft) {
+ DefineBuiltinMacro(Buf, "__stdcall=");
+ DefineBuiltinMacro(Buf, "__cdecl=");
+ DefineBuiltinMacro(Buf, "_cdecl=");
+ DefineBuiltinMacro(Buf, "__ptr64=");
+ DefineBuiltinMacro(Buf, "__forceinline=");
+ }
// FIXME: Should emit a #line directive here.
}
return Actions.ActOnTypeName(CurScope, DeclaratorInfo).Val;
}
+/// FuzzyParseMicrosoftDeclspec. The following construct is Microsoft's
+/// equivalent of GCC's __attribute__. The grammar below is taken from
+/// Microsoft's website. Unfortunately, it is incomplete. FIXME: If/when we
+/// parse this for real, we will need to get a real/current grammar.
+///
+/// decl-specifier:
+/// '__declspec' '(' extended-decl-modifier-seq ')'
+///
+/// extended-decl-modifier-seq:
+/// extended-decl-modifier opt
+/// extended-decl-modifier extended-decl-modifier-seq
+///
+/// extended-decl-modifier:
+/// align( # )
+/// allocate(" segname ")
+/// appdomain
+/// deprecated
+/// dllimport
+/// dllexport
+/// jitintrinsic
+/// naked
+/// noalias
+/// noinline
+/// noreturn
+/// nothrow
+/// novtable
+/// process
+/// property({get=get_func_name|,put=put_func_name})
+/// restrict
+/// selectany
+/// thread
+/// uuid(" ComObjectGUID ")
+///
+void Parser::FuzzyParseMicrosoftDeclspec() {
+ assert(Tok.is(tok::kw___declspec) && "Not an declspec!");
+ ConsumeToken();
+ do {
+ ConsumeAnyToken();
+ } while (ParenCount > 0 && Tok.isNot(tok::eof));
+ return;
+}
+
/// ParseAttributes - Parse a non-empty attributes list.
///
/// [GNU] attributes:
case tok::kw_typedef:
isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_typedef, Loc, PrevSpec);
break;
+ case tok::kw___w64: // ignore Microsoft specifier
+ break;
+ case tok::kw___declspec:
+ FuzzyParseMicrosoftDeclspec();
+ // Don't consume the next token, __declspec's can appear one after
+ // another. For example:
+ // __declspec(deprecated("comment1"))
+ // __declspec(deprecated("comment2")) extern unsigned int _winmajor;
+ continue;
case tok::kw_extern:
if (DS.isThreadSpecified())
Diag(Tok, diag::ext_thread_before, "extern");
break;
// type-specifiers
+ case tok::kw___int16:
case tok::kw_short:
isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec);
break;
+ case tok::kw___int64:
case tok::kw_long:
if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec);
case tok::kw_void:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec);
break;
+ case tok::kw___int8:
case tok::kw_char:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec);
break;
+ case tok::kw___int32:
case tok::kw_int:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec);
break;
Tok.is(tok::kw_union) ? DeclSpec::TST_union : DeclSpec::TST_struct;
SourceLocation StartLoc = ConsumeToken();
+ if (getLang().Microsoft && Tok.is(tok::kw___declspec))
+ FuzzyParseMicrosoftDeclspec();
+
// Parse the tag portion of this.
DeclTy *TagDecl;
if (ParseTag(TagDecl, TagType, StartLoc))
// If there are no declarators, issue a warning.
if (Tok.is(tok::semi)) {
- Diag(SpecQualLoc, diag::w_no_declarators);
+ if (!getLang().Microsoft) // MS allows unnamed struct/union fields.
+ Diag(SpecQualLoc, diag::w_no_declarators);
return;
}
break;
case tok::kw_asm:
- Res = ParseAsmStatement();
+ bool msAsm = false;
+ Res = ParseAsmStatement(msAsm);
+ if (msAsm) return Res;
SemiError = "asm statement";
break;
}
return Actions.ActOnReturnStmt(ReturnLoc, R.Val);
}
+Parser::StmtResult Parser::FuzzyParseMicrosoftAsmStatement() {
+ unsigned short savedBraceCount = BraceCount;
+ do {
+ ConsumeAnyToken();
+ } while (BraceCount > savedBraceCount && Tok.isNot(tok::eof));
+ return false;
+}
+
/// ParseAsmStatement - Parse a GNU extended asm statement.
/// [GNU] asm-statement:
/// 'asm' type-qualifier[opt] '(' asm-argument ')' ';'
/// asm-string-literal
/// asm-clobbers ',' asm-string-literal
///
-Parser::StmtResult Parser::ParseAsmStatement() {
+Parser::StmtResult Parser::ParseAsmStatement(bool &msAsm) {
assert(Tok.is(tok::kw_asm) && "Not an asm stmt");
SourceLocation AsmLoc = ConsumeToken();
+ if (Tok.is(tok::l_brace)) {
+ msAsm = true;
+ return FuzzyParseMicrosoftAsmStatement();
+ }
DeclSpec DS;
SourceLocation Loc = Tok.getLocation();
ParseTypeQualifierListOpt(DS);
DirectoryLookup::DirType OldDirType = HdrInfo.getFileDirFlavor(OldDeclFile);
DirectoryLookup::DirType NewDirType = HdrInfo.getFileDirFlavor(NewDeclFile);
- if (OldDirType == DirectoryLookup::ExternCSystemHeaderDir ||
- NewDirType == DirectoryLookup::ExternCSystemHeaderDir)
+ if ((OldDirType == DirectoryLookup::ExternCSystemHeaderDir ||
+ NewDirType == DirectoryLookup::ExternCSystemHeaderDir) ||
+ getLangOptions().Microsoft)
return New;
// TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
// Apple Extension.
KEYWORD(__private_extern__ , EXTC90|EXTC99|NOTCPP)
+// Microsoft Extensions.
+KEYWORD(__w64 , EXTC90|EXTC99|NOTCPP)
+KEYWORD(__declspec , EXTC90|EXTC99|NOTCPP)
+KEYWORD(__int8 , EXTC90|EXTC99|NOTCPP)
+KEYWORD(__int16 , EXTC90|EXTC99|NOTCPP)
+KEYWORD(__int32 , EXTC90|EXTC99|NOTCPP)
+KEYWORD(__int64 , EXTC90|EXTC99|NOTCPP)
+
// Alternate spelling for various tokens. There are GCC extensions in all
// languages, but should not be disabled in strict conformance mode.
ALIAS("__attribute__", __attribute)
return ConsumeBracket();
else if (isTokenBrace())
return ConsumeBrace();
+ else if (isTokenStringLiteral())
+ return ConsumeStringToken();
else
return ConsumeToken();
}
StmtResult ParseContinueStatement();
StmtResult ParseBreakStatement();
StmtResult ParseReturnStatement();
- StmtResult ParseAsmStatement();
+ StmtResult ParseAsmStatement(bool &msAsm);
+ StmtResult FuzzyParseMicrosoftAsmStatement();
StmtResult ParseObjCAtStatement(SourceLocation atLoc);
StmtResult ParseObjCTryStmt(SourceLocation atLoc, bool &processAtKeyword);
StmtResult ParseObjCThrowStmt(SourceLocation atLoc);
bool isTypeSpecifierQualifier() const;
TypeTy *ParseTypeName();
+ void FuzzyParseMicrosoftDeclspec();
AttributeList *ParseAttributes();
void ParseTypeofSpecifier(DeclSpec &DS);