bool isAnonymousStructOrUnion() const;
Expr *getBitWidth() const { return BitWidth; }
+ void setBitWidth(Expr *BW) { BitWidth = BW; }
+
// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) {
return D->getKind() >= FieldFirst && D->getKind() <= FieldLast;
setType(T);
}
+ /// \brief Construct an empty expression.
+ explicit Expr(StmtClass SC, EmptyShell) : Stmt(SC) { }
+
public:
QualType getType() const { return TR; }
void setType(QualType t) {
/// @endcode
bool isValueDependent() const { return ValueDependent; }
+ /// \brief Set whether this expression is value-dependent or not.
+ void setValueDependent(bool VD) { ValueDependent = VD; }
+
/// isTypeDependent - Determines whether this expression is
/// type-dependent (C++ [temp.dep.expr]), which means that its type
/// could change from one template instantiation to the next. For
/// @endcode
bool isTypeDependent() const { return TypeDependent; }
+ /// \brief Set whether this expression is type-dependent or not.
+ void setTypeDependent(bool TD) { TypeDependent = TD; }
+
/// SourceLocation tokens are not useful in isolation - they are low level
/// value objects created/interpreted by SourceManager. We assume AST
/// clients will have a pointer to the respective SourceManager.
DeclRefExpr(NamedDecl *d, QualType t, SourceLocation l, bool TD, bool VD) :
Expr(DeclRefExprClass, t, TD, VD), D(d), Loc(l) {}
+ /// \brief Construct an empty declaration reference expression.
+ explicit DeclRefExpr(EmptyShell Empty)
+ : Expr(DeclRefExprClass, Empty) { }
+
NamedDecl *getDecl() { return D; }
const NamedDecl *getDecl() const { return D; }
void setDecl(NamedDecl *NewD) { D = NewD; }
SourceLocation getLocation() const { return Loc; }
+ void setLocation(SourceLocation L) { Loc = L; }
virtual SourceRange getSourceRange() const { return SourceRange(Loc); }
static bool classof(const Stmt *T) {
assert(type->isIntegerType() && "Illegal type in IntegerLiteral");
}
+ /// \brief Construct an empty integer literal.
+ explicit IntegerLiteral(EmptyShell Empty)
+ : Expr(IntegerLiteralClass, Empty) { }
+
IntegerLiteral* Clone(ASTContext &C) const;
const llvm::APInt &getValue() const { return Value; }
/// \brief Retrieve the location of the literal.
SourceLocation getLocation() const { return Loc; }
+ void setValue(const llvm::APInt &Val) { Value = Val; }
+ void setLocation(SourceLocation Location) { Loc = Location; }
+
static bool classof(const Stmt *T) {
return T->getStmtClass() == IntegerLiteralClass;
}
CharacterLiteral(unsigned value, bool iswide, QualType type, SourceLocation l)
: Expr(CharacterLiteralClass, type), Value(value), Loc(l), IsWide(iswide) {
}
+
+ /// \brief Construct an empty character literal.
+ CharacterLiteral(EmptyShell Empty) : Expr(CharacterLiteralClass, Empty) { }
+
SourceLocation getLoc() const { return Loc; }
bool isWide() const { return IsWide; }
unsigned getValue() const { return Value; }
+ void setLocation(SourceLocation Location) { Loc = Location; }
+ void setWide(bool W) { IsWide = W; }
+ void setValue(unsigned Val) { Value = Val; }
+
static bool classof(const Stmt *T) {
return T->getStmtClass() == CharacterLiteralClass;
}
const_child_iterator child_end() const {
return const_child_iterator(const_cast<Stmt*>(this)->child_end());
}
-
+
+ /// \brief A placeholder type used to construct an empty shell of a
+ /// type, that will be filled in later (e.g., by some
+ /// de-serialization).
+ struct EmptyShell { };
+
void Emit(llvm::Serializer& S) const;
static Stmt* Create(llvm::Deserializer& D, ASTContext& C);
/// into a DeclContext via DeclContext::lookup.
DECL_CONTEXT_VISIBLE
};
+
+ /// \brief Record codes for each kind of statement or expression.
+ ///
+ /// These constants describe the records that describe statements
+ /// or expressions. These records can occur within either the type
+ /// or declaration blocks, so they begin with record values of
+ /// 100. Each constant describes a record for a specific
+ /// statement or expression class in the AST.
+ enum StmtCode {
+ /// \brief A NULL expression.
+ EXPR_NULL = 100,
+ /// \brief A DeclRefExpr record.
+ EXPR_DECL_REF,
+ /// \brief An IntegerLiteral record.
+ EXPR_INTEGER_LITERAL,
+ /// \brief A CharacterLiteral record.
+ EXPR_CHARACTER_LITERAL
+ };
/// @}
}
} // end namespace clang
/// \brief Read a signed integral value
llvm::APSInt ReadAPSInt(const RecordData &Record, unsigned &Idx);
+ /// \brief Reads an expression from the current stream position.
+ Expr *ReadExpr();
+
/// \brief Retrieve the AST context that this PCH reader
/// supplements.
ASTContext &getContext() { return Context; }
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include <queue>
-#include <vector>
namespace llvm {
class APInt;
/// data structures. This bitstream can be de-serialized via an
/// instance of the PCHReader class.
class PCHWriter {
+public:
+ typedef llvm::SmallVector<uint64_t, 64> RecordData;
+
+private:
/// \brief The bitstream writer used to emit this precompiled header.
llvm::BitstreamWriter &S;
/// record.
llvm::SmallVector<uint64_t, 16> ExternalDefinitions;
+ /// \brief Expressions that we've encountered while serializing a
+ /// declaration or type.
+ ///
+ /// The expressions in this queue will be emitted following the
+ /// declaration or type.
+ std::queue<Expr *> ExprsToEmit;
+
void WriteTargetTriple(const TargetInfo &Target);
void WriteLanguageOptions(const LangOptions &LangOpts);
void WriteSourceManagerBlock(SourceManager &SourceMgr);
void WriteIdentifierTable();
public:
- typedef llvm::SmallVector<uint64_t, 64> RecordData;
-
/// \brief Create a new precompiled header writer that outputs to
/// the given bitstream.
PCHWriter(llvm::BitstreamWriter &S);
/// \brief Emit a declaration name.
void AddDeclarationName(DeclarationName Name, RecordData &Record);
+
+ /// \brief Add the given expression to the queue of expressions to
+ /// emit.
+ void AddExpr(Expr *E) { ExprsToEmit.push(E); }
+
+ /// \brief Flush all of the expressions that have been added to the
+ /// queue via AddExpr().
+ void FlushExprs();
};
} // end namespace clang
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclGroup.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/StmtVisitor.h"
#include "clang/AST/Type.h"
#include "clang/Lex/MacroInfo.h"
#include "clang/Lex/Preprocessor.h"
void PCHDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
VisitValueDecl(ECD);
- // FIXME: read the initialization expression
+ if (Record[Idx++])
+ ECD->setInitExpr(Reader.ReadExpr());
ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
}
void PCHDeclReader::VisitFieldDecl(FieldDecl *FD) {
VisitValueDecl(FD);
FD->setMutable(Record[Idx++]);
- // FIXME: Read the bit width.
+ if (Record[Idx++])
+ FD->setBitWidth(Reader.ReadExpr());
}
void PCHDeclReader::VisitVarDecl(VarDecl *VD) {
VD->setPreviousDeclaration(
cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
VD->setTypeSpecStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
+ if (Record[Idx++])
+ VD->setInit(Reader.ReadExpr());
}
void PCHDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
return std::make_pair(LexicalOffset, VisibleOffset);
}
+//===----------------------------------------------------------------------===//
+// Statement/expression deserialization
+//===----------------------------------------------------------------------===//
+namespace {
+ class VISIBILITY_HIDDEN PCHStmtReader
+ : public StmtVisitor<PCHStmtReader, void> {
+ PCHReader &Reader;
+ const PCHReader::RecordData &Record;
+ unsigned &Idx;
+
+ public:
+ PCHStmtReader(PCHReader &Reader, const PCHReader::RecordData &Record,
+ unsigned &Idx)
+ : Reader(Reader), Record(Record), Idx(Idx) { }
+
+ void VisitExpr(Expr *E);
+ void VisitDeclRefExpr(DeclRefExpr *E);
+ void VisitIntegerLiteral(IntegerLiteral *E);
+ void VisitCharacterLiteral(CharacterLiteral *E);
+ };
+}
+
+void PCHStmtReader::VisitExpr(Expr *E) {
+ E->setType(Reader.GetType(Record[Idx++]));
+ E->setTypeDependent(Record[Idx++]);
+ E->setValueDependent(Record[Idx++]);
+}
+
+void PCHStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
+ VisitExpr(E);
+ E->setDecl(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
+ E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
+}
+
+void PCHStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
+ VisitExpr(E);
+ E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
+ E->setValue(Reader.ReadAPInt(Record, Idx));
+}
+
+void PCHStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
+ VisitExpr(E);
+ E->setValue(Record[Idx++]);
+ E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
+ E->setWide(Record[Idx++]);
+}
+
// FIXME: use the diagnostics machinery
static bool Error(const char *Str) {
std::fprintf(stderr, "%s\n", Str);
return Success;
}
+namespace {
+ /// \brief Helper class that saves the current stream position and
+ /// then restores it when destroyed.
+ struct VISIBILITY_HIDDEN SavedStreamPosition {
+ explicit SavedStreamPosition(llvm::BitstreamReader &Stream)
+ : Stream(Stream), Offset(Stream.GetCurrentBitNo()),
+ EndOfStream(Stream.AtEndOfStream()){ }
+
+ ~SavedStreamPosition() {
+ if (!EndOfStream)
+ Stream.JumpToBit(Offset);
+ }
+
+ private:
+ llvm::BitstreamReader &Stream;
+ uint64_t Offset;
+ bool EndOfStream;
+ };
+}
+
/// \brief Parse the record that corresponds to a LangOptions data
/// structure.
///
/// at the given offset in the bitstream. It is a helper routine for
/// GetType, which deals with reading type IDs.
QualType PCHReader::ReadTypeRecord(uint64_t Offset) {
+ // Keep track of where we are in the stream, then jump back there
+ // after reading this type.
+ SavedStreamPosition SavedPosition(Stream);
+
Stream.JumpToBit(Offset);
RecordData Record;
unsigned Code = Stream.ReadCode();
}
case pch::TYPE_VARIABLE_ARRAY: {
- // FIXME: implement this
- assert(false && "Unable to de-serialize variable-length array type");
- return QualType();
+ QualType ElementType = GetType(Record[0]);
+ ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
+ unsigned IndexTypeQuals = Record[2];
+ return Context.getVariableArrayType(ElementType, ReadExpr(),
+ ASM, IndexTypeQuals);
}
case pch::TYPE_VECTOR: {
return Context.getTypeDeclType(cast<TypedefDecl>(GetDecl(Record[0])));
case pch::TYPE_TYPEOF_EXPR:
- // FIXME: Deserialize TypeOfExprType
- assert(false && "Cannot de-serialize typeof(expr) from a PCH file");
- return QualType();
+ return Context.getTypeOfExprType(ReadExpr());
case pch::TYPE_TYPEOF: {
if (Record.size() != 1) {
/// \brief Read the declaration at the given offset from the PCH file.
Decl *PCHReader::ReadDeclRecord(uint64_t Offset, unsigned Index) {
+ // Keep track of where we are in the stream, then jump back there
+ // after reading this declaration.
+ SavedStreamPosition SavedPosition(Stream);
+
Decl *D = 0;
Stream.JumpToBit(Offset);
RecordData Record;
unsigned Code = Stream.ReadCode();
unsigned Idx = 0;
PCHDeclReader Reader(*this, Record, Idx);
+
switch ((pch::DeclCode)Stream.ReadRecord(Code, Record)) {
case pch::DECL_TRANSLATION_UNIT:
assert(Index == 0 && "Translation unit must be at index 0");
uint64_t Offset = DeclContextOffsets[DC].first;
assert(Offset && "DeclContext has no lexical decls in storage");
+ // Keep track of where we are in the stream, then jump back there
+ // after reading this context.
+ SavedStreamPosition SavedPosition(Stream);
+
// Load the record containing all of the declarations lexically in
// this context.
Stream.JumpToBit(Offset);
uint64_t Offset = DeclContextOffsets[DC].second;
assert(Offset && "DeclContext has no visible decls in storage");
+ // Keep track of where we are in the stream, then jump back there
+ // after reading this context.
+ SavedStreamPosition SavedPosition(Stream);
+
// Load the record containing all of the declarations visible in
// this context.
Stream.JumpToBit(Offset);
return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
}
+Expr *PCHReader::ReadExpr() {
+ RecordData Record;
+ unsigned Code = Stream.ReadCode();
+ unsigned Idx = 0;
+ PCHStmtReader Reader(*this, Record, Idx);
+ Stmt::EmptyShell Empty;
+
+ Expr *E = 0;
+ switch ((pch::StmtCode)Stream.ReadRecord(Code, Record)) {
+ case pch::EXPR_NULL:
+ E = 0;
+ break;
+
+ case pch::EXPR_DECL_REF:
+ E = new (Context) DeclRefExpr(Empty);
+ break;
+
+ case pch::EXPR_INTEGER_LITERAL:
+ E = new (Context) IntegerLiteral(Empty);
+ break;
+
+ case pch::EXPR_CHARACTER_LITERAL:
+ E = new (Context) CharacterLiteral(Empty);
+ break;
+
+ default:
+ assert(false && "Unhandled expression kind");
+ break;
+ }
+
+ if (E)
+ Reader.Visit(E);
+
+ assert(Idx == Record.size() && "Invalid deserialization of expression");
+
+ return E;
+}
+
DiagnosticBuilder PCHReader::Diag(unsigned DiagID) {
return Diag(SourceLocation(), DiagID);
}
#include "clang/AST/Decl.h"
#include "clang/AST/DeclContextInternals.h"
#include "clang/AST/DeclVisitor.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/StmtVisitor.h"
#include "clang/AST/Type.h"
#include "clang/Lex/MacroInfo.h"
#include "clang/Lex/Preprocessor.h"
void PCHTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
VisitArrayType(T);
- // FIXME: Serialize array size expression.
- assert(false && "Cannot serialize variable-length arrays");
+ Writer.AddExpr(T->getSizeExpr());
Code = pch::TYPE_VARIABLE_ARRAY;
}
}
void PCHTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
- // FIXME: serialize the typeof expression
- assert(false && "Cannot serialize typeof(expr)");
+ Writer.AddExpr(T->getUnderlyingExpr());
Code = pch::TYPE_TYPEOF_EXPR;
}
void PCHDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
VisitValueDecl(D);
- // FIXME: Writer.AddExprRef(D->getInitExpr());
+ Record.push_back(D->getInitExpr()? 1 : 0);
+ if (D->getInitExpr())
+ Writer.AddExpr(D->getInitExpr());
Writer.AddAPSInt(D->getInitVal(), Record);
Code = pch::DECL_ENUM_CONSTANT;
}
void PCHDeclWriter::VisitFieldDecl(FieldDecl *D) {
VisitValueDecl(D);
Record.push_back(D->isMutable());
- // FIXME: Writer.AddExprRef(D->getBitWidth());
+ Record.push_back(D->getBitWidth()? 1 : 0);
+ if (D->getBitWidth())
+ Writer.AddExpr(D->getBitWidth());
Code = pch::DECL_FIELD;
}
Record.push_back(D->isDeclaredInCondition());
Writer.AddDeclRef(D->getPreviousDeclaration(), Record);
Writer.AddSourceLocation(D->getTypeSpecStartLoc(), Record);
- // FIXME: emit initializer
+ Record.push_back(D->getInit()? 1 : 0);
+ if (D->getInit())
+ Writer.AddExpr(D->getInit());
Code = pch::DECL_VAR;
}
Record.push_back(VisibleOffset);
}
+//===----------------------------------------------------------------------===//
+// Statement/expression serialization
+//===----------------------------------------------------------------------===//
+namespace {
+ class VISIBILITY_HIDDEN PCHStmtWriter
+ : public StmtVisitor<PCHStmtWriter, void> {
+
+ PCHWriter &Writer;
+ PCHWriter::RecordData &Record;
+
+ public:
+ pch::StmtCode Code;
+
+ PCHStmtWriter(PCHWriter &Writer, PCHWriter::RecordData &Record)
+ : Writer(Writer), Record(Record) { }
+
+ void VisitExpr(Expr *E);
+ void VisitDeclRefExpr(DeclRefExpr *E);
+ void VisitIntegerLiteral(IntegerLiteral *E);
+ void VisitCharacterLiteral(CharacterLiteral *E);
+ };
+}
+
+void PCHStmtWriter::VisitExpr(Expr *E) {
+ Writer.AddTypeRef(E->getType(), Record);
+ Record.push_back(E->isTypeDependent());
+ Record.push_back(E->isValueDependent());
+}
+
+void PCHStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
+ VisitExpr(E);
+ Writer.AddDeclRef(E->getDecl(), Record);
+ Writer.AddSourceLocation(E->getLocation(), Record);
+ Code = pch::EXPR_DECL_REF;
+}
+
+void PCHStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
+ VisitExpr(E);
+ Writer.AddSourceLocation(E->getLocation(), Record);
+ Writer.AddAPInt(E->getValue(), Record);
+ Code = pch::EXPR_INTEGER_LITERAL;
+}
+
+void PCHStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
+ VisitExpr(E);
+ Record.push_back(E->getValue());
+ Writer.AddSourceLocation(E->getLoc(), Record);
+ Record.push_back(E->isWide());
+ Code = pch::EXPR_CHARACTER_LITERAL;
+}
+
//===----------------------------------------------------------------------===//
// PCHWriter Implementation
//===----------------------------------------------------------------------===//
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
- // FIXME: Need an actual encoding for the line directives; maybe
- // this should be an array?
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
return S.EmitAbbrev(Abbrev);
}
// Emit the serialized record.
S.EmitRecord(W.Code, Record);
+
+ // Flush any expressions that were written as part of this type.
+ FlushExprs();
}
/// \brief Write a block containing all of the types.
assert(W.Code && "Unhandled declaration kind while generating PCH");
S.EmitRecord(W.Code, Record);
+ // Flush any expressions that were written as part of this declaration.
+ FlushExprs();
+
// Note external declarations so that we can add them to a record
// in the PCH file later.
if (isa<FileScopeAsmDecl>(D))
break;
}
}
+
+/// \brief Flush all of the expressions that have been added to the
+/// queue via AddExpr().
+void PCHWriter::FlushExprs() {
+ RecordData Record;
+ PCHStmtWriter Writer(*this, Record);
+ while (!ExprsToEmit.empty()) {
+ Expr *E = ExprsToEmit.front();
+ ExprsToEmit.pop();
+
+ Record.clear();
+ if (!E) {
+ S.EmitRecord(pch::EXPR_NULL, Record);
+ continue;
+ }
+
+ Writer.Code = pch::EXPR_NULL;
+ Writer.Visit(E);
+ assert(Writer.Code != pch::EXPR_NULL &&
+ "Unhandled expression writing PCH file");
+ S.EmitRecord(Writer.Code, Record);
+ }
+}
enum Shape {
Square,
- Triangle,
+ Triangle = 17,
Rhombus,
Circle
};
-enum Shape aRoundShape = Circle;
+enum Shape aRoundShape;// FIXME: = Circle;
--- /dev/null
+// Test this without pch.
+// RUN: clang-cc -fblocks -include %S/exprs.h -fsyntax-only -verify %s
+
+// Test with pch.
+// RUN: clang-cc -emit-pch -fblocks -o %t %S/exprs.h &&
+// RUN: clang-cc -fblocks -include-pch %t -fsyntax-only -verify %s
+
+int integer;
+long long_integer;
+
+// DeclRefExpr
+int_decl_ref *int_ptr1 = &integer;
+enum_decl_ref *enum_ptr1 = &integer;
+// IntegerLiteralExpr
+integer_literal *int_ptr2 = &integer;
+long_literal *long_ptr1 = &long_integer;
+
+// CharacterLiteralExpr
+char_literal *int_ptr3 = &integer;
--- /dev/null
+// Header for PCH test exprs.c
+
+// DeclRefExpr
+int i = 17;
+enum Enum { Enumerator = 18 };
+typedef typeof(i) int_decl_ref;
+typedef typeof(Enumerator) enum_decl_ref;
+
+// IntegerLiteralExpr
+typedef typeof(17) integer_literal;
+typedef typeof(17l) long_literal;
+
+// CharacterLiteralExpr
+typedef typeof('a') char_literal;
// RUN: clang-cc -triple x86_64-apple-darwin9 -include-pch %t.pch -emit-llvm -o %t %s &&
// RUN: grep "@x = common global i32 0" %t | count 1 &&
-// FIXME below: should be i32 17, but we don't serialize y's value yet
-// RUN: grep "@y = common global i32 0" %t | count 1 &&
+// RUN: grep "@y = global i32 17" %t | count 1 &&
// RUN: grep "@z" %t | count 0 &&
// RUN: grep "@x2 = global i32 19" %t | count 1 &&
int x;
int x2;
-// FIXME: check this, once we actually serialize it
+// Definitions
int y = 17;
// Should not show up
return fun2->very_fun;
}
+int *int_ptr_fail = &fun->is_ptr; // expected-error{{address of bit-field requested}}
+
/* FIXME: DeclContexts aren't yet able to find "struct Nested" nested
within "struct S", so causing the following to fail. When not using
PCH, this works because Sema puts the nested struct onto the
struct Fun *fun;
struct Fun {
- int is_ptr;
+ int is_ptr : 1;
union {
void *ptr;
// TYPE_TYPEDEF
int_ptr_ptr ipp = &int_value_ptr;
-// FIXME: TYPE_TYPEOF_EXPR
+// TYPE_TYPEOF_EXPR
+typeof_17 *t17 = &int_value;
+struct S { int x, y; };
+typeof_17 t17_2 = (struct S){1, 2}; // expected-error{{incompatible type initializing}}
// TYPE_TYPEOF
int_ptr_ptr2 ipp2 = &int_value_ptr;
// TYPE_TYPEDEF
typedef int_ptr * int_ptr_ptr;
-// FIXME: TYPE_TYPEOF_EXPR
+// TYPE_TYPEOF_EXPR
+typedef typeof(17) typeof_17;
// TYPE_TYPEOF
typedef typeof(int_ptr *) int_ptr_ptr2;
float *fp = &ip; // expected-warning{{incompatible pointer types}}
// FIXME:variables.h expected-note{{previous}}
double z; // expected-error{{redefinition}}
-
+// FIXME:variables.h expected-note{{previous}}
+int z2 = 18; // expected-error{{redefinition}}
//double VeryHappy; // FIXME: xpected-error{{redefinition}}
float z;
-
+int z2 = 17;
#define MAKE_HAPPY(X) X##Happy
int MAKE_HAPPY(Very);
projects / clang / commitdiff