//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#ifndef RECORD_H
#define RECORD_H
+#include "llvm/Support/DataTypes.h"
#include <string>
#include <vector>
#include <map>
struct RecTy {
virtual ~RecTy() {}
- virtual void print(std::ostream &OS) const = 0;
+ virtual std::string getAsString() const = 0;
+ void print(std::ostream &OS) const { OS << getAsString(); }
void dump() const;
/// typeIsConvertibleTo - Return true if all values of 'this' type can be
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
- void print(std::ostream &OS) const { OS << "bit"; }
+ std::string getAsString() const { return "bit"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
class BitsRecTy : public RecTy {
unsigned Size;
public:
- BitsRecTy(unsigned Sz) : Size(Sz) {}
+ explicit BitsRecTy(unsigned Sz) : Size(Sz) {}
unsigned getNumBits() const { return Size; }
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
-
- void print(std::ostream &OS) const { OS << "bits<" << Size << ">"; }
+ std::string getAsString() const;
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
-
- void print(std::ostream &OS) const { OS << "int"; }
+ std::string getAsString() const { return "int"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
- void print(std::ostream &OS) const { OS << "string"; }
+ std::string getAsString() const { return "string"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
class ListRecTy : public RecTy {
RecTy *Ty;
public:
- ListRecTy(RecTy *T) : Ty(T) {}
+ explicit ListRecTy(RecTy *T) : Ty(T) {}
RecTy *getElementType() const { return Ty; }
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
- void print(std::ostream &OS) const;
+ std::string getAsString() const;
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
-
- void print(std::ostream &OS) const { OS << "code"; }
+ std::string getAsString() const { return "code"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
- void print(std::ostream &OS) const { OS << "dag"; }
+ std::string getAsString() const { return "dag"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
class RecordRecTy : public RecTy {
Record *Rec;
public:
- RecordRecTy(Record *R) : Rec(R) {}
+ explicit RecordRecTy(Record *R) : Rec(R) {}
Record *getRecord() const { return Rec; }
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
- void print(std::ostream &OS) const;
+ std::string getAsString() const;
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual bool isComplete() const { return true; }
/// print - Print out this value.
- virtual void print(std::ostream &OS) const = 0;
+ void print(std::ostream &OS) const { OS << getAsString(); }
+
+ /// getAsString - Convert this value to a string form.
+ virtual std::string getAsString() const = 0;
/// dump - Debugging method that may be called through a debugger, just
/// invokes print on cerr.
}
virtual bool isComplete() const { return false; }
- virtual void print(std::ostream &OS) const { OS << "?"; }
+ virtual std::string getAsString() const { return "?"; }
};
class BitInit : public Init {
bool Value;
public:
- BitInit(bool V) : Value(V) {}
+ explicit BitInit(bool V) : Value(V) {}
bool getValue() const { return Value; }
return Ty->convertValue(this);
}
- virtual void print(std::ostream &OS) const { OS << (Value ? "1" : "0"); }
+ virtual std::string getAsString() const { return Value ? "1" : "0"; }
};
/// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value.
class BitsInit : public Init {
std::vector<Init*> Bits;
public:
- BitsInit(unsigned Size) : Bits(Size) {}
+ explicit BitsInit(unsigned Size) : Bits(Size) {}
unsigned getNumBits() const { return Bits.size(); }
if (!getBit(i)->isComplete()) return false;
return true;
}
- virtual void print(std::ostream &OS) const;
+ virtual std::string getAsString() const;
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
/// IntInit - 7 - Represent an initalization by a literal integer value.
///
class IntInit : public Init {
- int Value;
+ int64_t Value;
public:
- IntInit(int V) : Value(V) {}
+ explicit IntInit(int64_t V) : Value(V) {}
- int getValue() const { return Value; }
+ int64_t getValue() const { return Value; }
virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
- virtual void print(std::ostream &OS) const { OS << Value; }
+ virtual std::string getAsString() const;
};
class StringInit : public Init {
std::string Value;
public:
- StringInit(const std::string &V) : Value(V) {}
+ explicit StringInit(const std::string &V) : Value(V) {}
const std::string &getValue() const { return Value; }
return Ty->convertValue(this);
}
- virtual void print(std::ostream &OS) const { OS << "\"" << Value << "\""; }
+ virtual std::string getAsString() const { return "\"" + Value + "\""; }
};
/// CodeInit - "[{...}]" - Represent a code fragment.
class CodeInit : public Init {
std::string Value;
public:
- CodeInit(const std::string &V) : Value(V) {}
+ explicit CodeInit(const std::string &V) : Value(V) {}
const std::string getValue() const { return Value; }
return Ty->convertValue(this);
}
- virtual void print(std::ostream &OS) const { OS << "[{" << Value << "}]"; }
+ virtual std::string getAsString() const { return "[{" + Value + "}]"; }
};
/// ListInit - [AL, AH, CL] - Represent a list of defs
class ListInit : public Init {
std::vector<Init*> Values;
public:
- ListInit(std::vector<Init*> &Vs) {
+ explicit ListInit(std::vector<Init*> &Vs) {
Values.swap(Vs);
}
///
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
- virtual void print(std::ostream &OS) const;
+ virtual std::string getAsString() const;
+
+ typedef std::vector<Init*>::iterator iterator;
+ typedef std::vector<Init*>::const_iterator const_iterator;
+
+ inline iterator begin() { return Values.begin(); }
+ inline const_iterator begin() const { return Values.begin(); }
+ inline iterator end () { return Values.end(); }
+ inline const_iterator end () const { return Values.end(); }
+
+ inline size_t size () const { return Values.size(); }
+ inline bool empty() const { return Values.empty(); }
};
/// BinOpInit - !op (X, Y) - Combine two inits.
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
- virtual void print(std::ostream &OS) const;
+ virtual std::string getAsString() const;
};
class TypedInit : public Init {
RecTy *Ty;
public:
- TypedInit(RecTy *T) : Ty(T) {}
+ explicit TypedInit(RecTy *T) : Ty(T) {}
RecTy *getType() const { return Ty; }
class VarInit : public TypedInit {
std::string VarName;
public:
- VarInit(const std::string &VN, RecTy *T) : TypedInit(T), VarName(VN) {}
+ explicit VarInit(const std::string &VN, RecTy *T)
+ : TypedInit(T), VarName(VN) {}
virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
///
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
- virtual void print(std::ostream &OS) const { OS << VarName; }
+ virtual std::string getAsString() const { return VarName; }
};
TypedInit *getVariable() const { return TI; }
unsigned getBitNum() const { return Bit; }
- virtual void print(std::ostream &OS) const {
- TI->print(OS); OS << "{" << Bit << "}";
- }
+ virtual std::string getAsString() const;
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
};
virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
unsigned Elt);
- virtual void print(std::ostream &OS) const {
- TI->print(OS); OS << "[" << Element << "]";
- }
+ virtual std::string getAsString() const;
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
};
class DefInit : public Init {
Record *Def;
public:
- DefInit(Record *D) : Def(D) {}
+ explicit DefInit(Record *D) : Def(D) {}
virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
virtual RecTy *getFieldType(const std::string &FieldName) const;
virtual Init *getFieldInit(Record &R, const std::string &FieldName) const;
- virtual void print(std::ostream &OS) const;
+ virtual std::string getAsString() const;
};
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
- virtual void print(std::ostream &OS) const {
- Rec->print(OS); OS << "." << FieldName;
+ virtual std::string getAsString() const {
+ return Rec->getAsString() + "." + FieldName;
}
};
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
- virtual void print(std::ostream &OS) const;
+ virtual std::string getAsString() const;
+
+ typedef std::vector<Init*>::iterator arg_iterator;
+ typedef std::vector<Init*>::const_iterator const_arg_iterator;
+ typedef std::vector<std::string>::iterator name_iterator;
+ typedef std::vector<std::string>::const_iterator const_name_iterator;
+
+ inline arg_iterator arg_begin() { return Args.begin(); }
+ inline const_arg_iterator arg_begin() const { return Args.begin(); }
+ inline arg_iterator arg_end () { return Args.end(); }
+ inline const_arg_iterator arg_end () const { return Args.end(); }
+
+ inline size_t arg_size () const { return Args.size(); }
+ inline bool arg_empty() const { return Args.empty(); }
+
+ inline name_iterator name_begin() { return ArgNames.begin(); }
+ inline const_name_iterator name_begin() const { return ArgNames.begin(); }
+ inline name_iterator name_end () { return ArgNames.end(); }
+ inline const_name_iterator name_end () const { return ArgNames.end(); }
+
+ inline size_t name_size () const { return ArgNames.size(); }
+ inline bool name_empty() const { return ArgNames.empty(); }
+
};
//===----------------------------------------------------------------------===//
std::vector<Record*> SuperClasses;
public:
- Record(const std::string &N) : Name(N) {}
+ explicit Record(const std::string &N) : Name(N) {}
~Record() {}
const std::string &getName() const { return Name; }
/// its value as a vector of integers, throwing an exception if the field does
/// not exist or if the value is not the right type.
///
- std::vector<int> getValueAsListOfInts(const std::string &FieldName) const;
+ std::vector<int64_t> getValueAsListOfInts(const std::string &FieldName) const;
/// getValueAsDef - This method looks up the specified field and returns its
/// value as a Record, throwing an exception if the field does not exist or if
bool getValueAsBit(const std::string &FieldName) const;
/// getValueAsInt - This method looks up the specified field and returns its
- /// value as an int, throwing an exception if the field does not exist or if
- /// the value is not the right type.
+ /// value as an int64_t, throwing an exception if the field does not exist or
+ /// if the value is not the right type.
///
- int getValueAsInt(const std::string &FieldName) const;
+ int64_t getValueAsInt(const std::string &FieldName) const;
/// getValueAsDag - This method looks up the specified field and returns its
/// value as an Dag, throwing an exception if the field does not exist or if
void dump() const;
};
+/// LessRecord - Sorting predicate to sort record pointers by name.
+///
+struct LessRecord {
+ bool operator()(const Record *Rec1, const Record *Rec2) const {
+ return Rec1->getName() < Rec2->getName();
+ }
+};
+
+/// LessRecordFieldName - Sorting predicate to sort record pointers by their
+/// name field.
+///
+struct LessRecordFieldName {
+ bool operator()(const Record *Rec1, const Record *Rec2) const {
+ return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
+ }
+};
+
+
std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK);
extern RecordKeeper Records;