mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-13 20:32:21 +00:00
Convert 'struct' to 'class' in various places to adhere to the coding standards
and work better with VC++. Patch contributed by Morten Ofstad! git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@17281 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
3acd9181df
commit
1fca5ff62b
@ -39,7 +39,7 @@
|
||||
|
||||
namespace llvm {
|
||||
|
||||
struct Type;
|
||||
class Type;
|
||||
class DerivedType;
|
||||
|
||||
class AbstractTypeUser {
|
||||
|
@ -34,7 +34,7 @@ class AliasSet;
|
||||
class AliasSet {
|
||||
friend class AliasSetTracker;
|
||||
|
||||
struct PointerRec;
|
||||
class PointerRec;
|
||||
typedef std::pair<Value* const, PointerRec> HashNodePair;
|
||||
|
||||
class PointerRec {
|
||||
@ -116,7 +116,7 @@ class AliasSet {
|
||||
// Volatile - True if this alias set contains volatile loads or stores.
|
||||
bool Volatile : 1;
|
||||
|
||||
friend class ilist_traits<AliasSet>;
|
||||
friend struct ilist_traits<AliasSet>;
|
||||
AliasSet *getPrev() const { return Prev; }
|
||||
AliasSet *getNext() const { return Next; }
|
||||
void setPrev(AliasSet *P) { Prev = P; }
|
||||
|
@ -47,7 +47,7 @@ class DSNode {
|
||||
/// doubly-linked ilist in the DSGraph.
|
||||
///
|
||||
DSNode *Next, *Prev;
|
||||
friend class ilist_traits<DSNode>;
|
||||
friend struct ilist_traits<DSNode>;
|
||||
|
||||
/// Size - The current size of the node. This should be equal to the size of
|
||||
/// the current type record.
|
||||
|
@ -287,9 +287,9 @@ protected:
|
||||
Node *RootNode;
|
||||
public:
|
||||
class Node {
|
||||
friend class DominatorTree;
|
||||
friend class PostDominatorTree;
|
||||
friend class DominatorTreeBase;
|
||||
friend struct DominatorTree;
|
||||
friend struct PostDominatorTree;
|
||||
friend struct DominatorTreeBase;
|
||||
BasicBlock *TheBB;
|
||||
Node *IDom;
|
||||
std::vector<Node*> Children;
|
||||
|
@ -35,7 +35,7 @@
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class DominatorSet;
|
||||
struct DominatorSet;
|
||||
class LoopInfo;
|
||||
class PHINode;
|
||||
class Instruction;
|
||||
|
@ -45,7 +45,8 @@ template<> struct ilist_traits<Instruction>
|
||||
static iplist<Instruction> &getList(BasicBlock *BB);
|
||||
};
|
||||
|
||||
struct BasicBlock : public Value { // Basic blocks are data objects also
|
||||
class BasicBlock : public Value { // Basic blocks are data objects also
|
||||
public:
|
||||
typedef iplist<Instruction> InstListType;
|
||||
private :
|
||||
InstListType InstList;
|
||||
|
@ -24,7 +24,8 @@ namespace llvm {
|
||||
|
||||
// ilist_traits
|
||||
template <>
|
||||
class ilist_traits<MachineInstr> {
|
||||
struct ilist_traits<MachineInstr> {
|
||||
protected:
|
||||
// this is only set by the MachineBasicBlock owning the ilist
|
||||
friend class MachineBasicBlock;
|
||||
MachineBasicBlock* parent;
|
||||
@ -179,7 +180,7 @@ public:
|
||||
int getNumber() const { return Number; }
|
||||
|
||||
private: // Methods used to maintain doubly linked list of blocks...
|
||||
friend class ilist_traits<MachineBasicBlock>;
|
||||
friend struct ilist_traits<MachineBasicBlock>;
|
||||
|
||||
MachineBasicBlock *getPrev() const { return Prev; }
|
||||
MachineBasicBlock *getNext() const { return Next; }
|
||||
|
@ -29,7 +29,8 @@ class Value;
|
||||
class GlobalValue;
|
||||
class Function;
|
||||
|
||||
struct MachineCodeEmitter {
|
||||
class MachineCodeEmitter {
|
||||
public:
|
||||
virtual ~MachineCodeEmitter() {}
|
||||
|
||||
/// startFunction - This callback is invoked when the specified function is
|
||||
|
@ -31,7 +31,7 @@ class MachineConstantPool;
|
||||
|
||||
// ilist_traits
|
||||
template <>
|
||||
class ilist_traits<MachineBasicBlock> {
|
||||
struct ilist_traits<MachineBasicBlock> {
|
||||
// this is only set by the MachineFunction owning the ilist
|
||||
friend class MachineFunction;
|
||||
MachineFunction* Parent;
|
||||
|
@ -29,8 +29,8 @@ class MachineBasicBlock;
|
||||
class TargetMachine;
|
||||
class GlobalValue;
|
||||
|
||||
template <typename T> class ilist_traits;
|
||||
template <typename T> class ilist;
|
||||
template <typename T> struct ilist_traits;
|
||||
template <typename T> struct ilist;
|
||||
|
||||
typedef short MachineOpCode;
|
||||
|
||||
@ -417,7 +417,7 @@ class MachineInstr {
|
||||
|
||||
// Intrusive list support
|
||||
//
|
||||
friend class ilist_traits<MachineInstr>;
|
||||
friend struct ilist_traits<MachineInstr>;
|
||||
|
||||
public:
|
||||
MachineInstr(short Opcode, unsigned numOperands);
|
||||
|
@ -21,7 +21,7 @@
|
||||
|
||||
namespace llvm {
|
||||
|
||||
struct BasicBlock;
|
||||
class BasicBlock;
|
||||
class PointerType;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -1159,7 +1159,8 @@ public:
|
||||
/// UnwindInst - Immediately exit the current function, unwinding the stack
|
||||
/// until an invoke instruction is found.
|
||||
///
|
||||
struct UnwindInst : public TerminatorInst {
|
||||
class UnwindInst : public TerminatorInst {
|
||||
public:
|
||||
UnwindInst(Instruction *InsertBefore = 0)
|
||||
: TerminatorInst(Instruction::Unwind, InsertBefore) {
|
||||
}
|
||||
@ -1196,7 +1197,8 @@ struct UnwindInst : public TerminatorInst {
|
||||
/// presence of this instruction indicates some higher level knowledge that the
|
||||
/// end of the block cannot be reached.
|
||||
///
|
||||
struct UnreachableInst : public TerminatorInst {
|
||||
class UnreachableInst : public TerminatorInst {
|
||||
public:
|
||||
UnreachableInst(Instruction *InsertBefore = 0)
|
||||
: TerminatorInst(Instruction::Unreachable, InsertBefore) {
|
||||
}
|
||||
|
@ -38,7 +38,7 @@
|
||||
namespace llvm {
|
||||
|
||||
class Value;
|
||||
struct BasicBlock;
|
||||
class BasicBlock;
|
||||
class Function;
|
||||
class Module;
|
||||
class AnalysisUsage;
|
||||
@ -56,7 +56,7 @@ typedef const PassInfo* AnalysisID;
|
||||
/// constrained passes described below.
|
||||
///
|
||||
class Pass {
|
||||
friend class AnalysisResolver;
|
||||
friend struct AnalysisResolver;
|
||||
AnalysisResolver *Resolver; // AnalysisResolver this pass is owned by...
|
||||
const PassInfo *PassInfoCache;
|
||||
|
||||
@ -211,8 +211,8 @@ inline std::ostream &operator<<(std::ostream &OS, const Pass &P) {
|
||||
/// interprocedural optimizations and analyses. ModulePass's may do anything
|
||||
/// they want to the program.
|
||||
///
|
||||
struct ModulePass : public Pass {
|
||||
|
||||
class ModulePass : public Pass {
|
||||
public:
|
||||
/// runOnModule - Virtual method overriden by subclasses to process the module
|
||||
/// being operated on.
|
||||
virtual bool runOnModule(Module &M) = 0;
|
||||
@ -228,7 +228,8 @@ struct ModulePass : public Pass {
|
||||
/// not need to be run. This is useful for things like target information and
|
||||
/// "basic" versions of AnalysisGroups.
|
||||
///
|
||||
struct ImmutablePass : public ModulePass {
|
||||
class ImmutablePass : public ModulePass {
|
||||
public:
|
||||
/// initializePass - This method may be overriden by immutable passes to allow
|
||||
/// them to perform various initialization actions they require. This is
|
||||
/// primarily because an ImmutablePass can "require" another ImmutablePass,
|
||||
@ -255,7 +256,8 @@ private:
|
||||
/// 2. Optimizing a function does not cause the addition or removal of any
|
||||
/// functions in the module
|
||||
///
|
||||
struct FunctionPass : public ModulePass {
|
||||
class FunctionPass : public ModulePass {
|
||||
public:
|
||||
/// doInitialization - Virtual method overridden by subclasses to do
|
||||
/// any necessary per-module initialization.
|
||||
///
|
||||
|
@ -30,7 +30,7 @@ namespace llvm {
|
||||
class AnnotationID;
|
||||
class Annotation;
|
||||
class Annotable;
|
||||
class AnnotationManager;
|
||||
struct AnnotationManager;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
@ -39,7 +39,7 @@ class AnnotationManager;
|
||||
// freely around and passed byvalue with little or no overhead.
|
||||
//
|
||||
class AnnotationID {
|
||||
friend class AnnotationManager;
|
||||
friend struct AnnotationManager;
|
||||
unsigned ID;
|
||||
|
||||
AnnotationID(); // Default ctor is disabled
|
||||
|
@ -513,8 +513,8 @@ struct basic_parser : public basic_parser_impl {
|
||||
// parser<bool>
|
||||
//
|
||||
template<>
|
||||
struct parser<bool> : public basic_parser<bool> {
|
||||
|
||||
class parser<bool> : public basic_parser<bool> {
|
||||
public:
|
||||
// parse - Return true on error.
|
||||
bool parse(Option &O, const char *ArgName, const std::string &Arg, bool &Val);
|
||||
|
||||
@ -531,8 +531,8 @@ struct parser<bool> : public basic_parser<bool> {
|
||||
// parser<int>
|
||||
//
|
||||
template<>
|
||||
struct parser<int> : public basic_parser<int> {
|
||||
|
||||
class parser<int> : public basic_parser<int> {
|
||||
public:
|
||||
// parse - Return true on error.
|
||||
bool parse(Option &O, const char *ArgName, const std::string &Arg, int &Val);
|
||||
|
||||
@ -545,8 +545,8 @@ struct parser<int> : public basic_parser<int> {
|
||||
// parser<unsigned>
|
||||
//
|
||||
template<>
|
||||
struct parser<unsigned> : public basic_parser<unsigned> {
|
||||
|
||||
class parser<unsigned> : public basic_parser<unsigned> {
|
||||
public:
|
||||
// parse - Return true on error.
|
||||
bool parse(Option &O, const char *AN, const std::string &Arg, unsigned &Val);
|
||||
|
||||
@ -559,7 +559,8 @@ struct parser<unsigned> : public basic_parser<unsigned> {
|
||||
// parser<double>
|
||||
//
|
||||
template<>
|
||||
struct parser<double> : public basic_parser<double> {
|
||||
class parser<double> : public basic_parser<double> {
|
||||
public:
|
||||
// parse - Return true on error.
|
||||
bool parse(Option &O, const char *AN, const std::string &Arg, double &Val);
|
||||
|
||||
@ -572,7 +573,8 @@ struct parser<double> : public basic_parser<double> {
|
||||
// parser<float>
|
||||
//
|
||||
template<>
|
||||
struct parser<float> : public basic_parser<float> {
|
||||
class parser<float> : public basic_parser<float> {
|
||||
public:
|
||||
// parse - Return true on error.
|
||||
bool parse(Option &O, const char *AN, const std::string &Arg, float &Val);
|
||||
|
||||
@ -585,7 +587,8 @@ struct parser<float> : public basic_parser<float> {
|
||||
// parser<std::string>
|
||||
//
|
||||
template<>
|
||||
struct parser<std::string> : public basic_parser<std::string> {
|
||||
class parser<std::string> : public basic_parser<std::string> {
|
||||
public:
|
||||
// parse - Return true on error.
|
||||
bool parse(Option &O, const char *AN, const std::string &Arg,
|
||||
std::string &Value) {
|
||||
@ -687,8 +690,8 @@ public:
|
||||
// object in all cases that it is used.
|
||||
//
|
||||
template<class DataType>
|
||||
struct opt_storage<DataType,false,true> : public DataType {
|
||||
|
||||
class opt_storage<DataType,false,true> : public DataType {
|
||||
public:
|
||||
template<class T>
|
||||
void setValue(const T &V) { DataType::operator=(V); }
|
||||
|
||||
@ -701,7 +704,8 @@ struct opt_storage<DataType,false,true> : public DataType {
|
||||
// to get at the value.
|
||||
//
|
||||
template<class DataType>
|
||||
struct opt_storage<DataType, false, false> {
|
||||
class opt_storage<DataType, false, false> {
|
||||
public:
|
||||
DataType Value;
|
||||
|
||||
// Make sure we initialize the value with the default constructor for the
|
||||
@ -864,8 +868,8 @@ public:
|
||||
// object in all cases that it is used.
|
||||
//
|
||||
template<class DataType>
|
||||
struct list_storage<DataType, bool> : public std::vector<DataType> {
|
||||
|
||||
class list_storage<DataType, bool> : public std::vector<DataType> {
|
||||
public:
|
||||
template<class T>
|
||||
void addValue(const T &V) { push_back(V); }
|
||||
};
|
||||
|
@ -95,7 +95,7 @@ struct DefaultDOTGraphTraits {
|
||||
/// from DefaultDOTGraphTraits if you don't need to override everything.
|
||||
///
|
||||
template <typename Ty>
|
||||
class DOTGraphTraits : public DefaultDOTGraphTraits {};
|
||||
struct DOTGraphTraits : public DefaultDOTGraphTraits {};
|
||||
|
||||
} // End llvm namespace
|
||||
|
||||
|
@ -21,7 +21,7 @@ namespace sys {
|
||||
|
||||
/// Forward declare a class used for holding platform specific information
|
||||
/// that needs to be
|
||||
class MappedFileInfo;
|
||||
struct MappedFileInfo;
|
||||
|
||||
/// This class provides an abstraction for a memory mapped file in the
|
||||
/// operating system's filesystem. It provides platform independent operations
|
||||
|
@ -114,7 +114,8 @@ public:
|
||||
// This object is used to lazily calculate structure layout information for a
|
||||
// target machine, based on the TargetData structure.
|
||||
//
|
||||
struct StructLayout {
|
||||
class StructLayout {
|
||||
public:
|
||||
std::vector<uint64_t> MemberOffsets;
|
||||
uint64_t StructSize;
|
||||
unsigned StructAlignment;
|
||||
|
@ -27,7 +27,8 @@ class MachineFunction;
|
||||
/// The offset to the local area is the offset from the stack pointer on
|
||||
/// function entry to the first location where function data (local variables,
|
||||
/// spill locations) can be stored.
|
||||
struct TargetFrameInfo {
|
||||
class TargetFrameInfo {
|
||||
public:
|
||||
enum StackDirection {
|
||||
StackGrowsUp, // Adding to the stack increases the stack address
|
||||
StackGrowsDown // Adding to the stack decreases the stack address
|
||||
|
@ -61,7 +61,8 @@ const unsigned M_2_ADDR_FLAG = 1 << 15;
|
||||
// before control flow occurs.
|
||||
const unsigned M_TERMINATOR_FLAG = 1 << 16;
|
||||
|
||||
struct TargetInstrDescriptor {
|
||||
class TargetInstrDescriptor {
|
||||
public:
|
||||
const char * Name; // Assembly language mnemonic for the opcode.
|
||||
int numOperands; // Number of args; -1 if variable #args
|
||||
int resultPos; // Position of the result; -1 if no result
|
||||
|
@ -152,7 +152,8 @@ private:
|
||||
/// TargetSchedInfo - Common interface to machine information for
|
||||
/// instruction scheduling
|
||||
///
|
||||
struct TargetSchedInfo {
|
||||
class TargetSchedInfo {
|
||||
public:
|
||||
const TargetMachine& target;
|
||||
|
||||
unsigned maxNumIssueTotal;
|
||||
|
@ -18,7 +18,7 @@
|
||||
|
||||
namespace llvm {
|
||||
class BasicBlock;
|
||||
class DominatorSet;
|
||||
struct DominatorSet;
|
||||
class Function;
|
||||
class Loop;
|
||||
|
||||
|
@ -20,8 +20,8 @@
|
||||
namespace llvm {
|
||||
|
||||
class AllocaInst;
|
||||
class DominatorTree;
|
||||
class DominanceFrontier;
|
||||
struct DominatorTree;
|
||||
struct DominanceFrontier;
|
||||
class TargetData;
|
||||
class AliasSetTracker;
|
||||
|
||||
|
@ -35,7 +35,7 @@ class Use {
|
||||
Value *Val;
|
||||
User *U;
|
||||
Use *Prev, *Next;
|
||||
friend class ilist_traits<Use>;
|
||||
friend struct ilist_traits<Use>;
|
||||
public:
|
||||
inline Use(Value *v, User *user);
|
||||
inline Use(const Use &u);
|
||||
|
@ -27,7 +27,7 @@ namespace llvm {
|
||||
class Constant;
|
||||
class Argument;
|
||||
class Instruction;
|
||||
struct BasicBlock;
|
||||
class BasicBlock;
|
||||
class GlobalValue;
|
||||
class Function;
|
||||
class GlobalVariable;
|
||||
|
@ -29,7 +29,7 @@ namespace {
|
||||
#include "llvm/Instruction.def"
|
||||
|
||||
class InstCount : public FunctionPass, public InstVisitor<InstCount> {
|
||||
friend class InstVisitor<InstCount>;
|
||||
friend struct InstVisitor<InstCount>;
|
||||
|
||||
void visitFunction (Function &F) { ++TotalFuncs; }
|
||||
void visitBasicBlock(BasicBlock &BB) { ++TotalBlocks; }
|
||||
|
@ -66,7 +66,7 @@ namespace {
|
||||
|
||||
Instruction *InsertPt;
|
||||
|
||||
friend class SCEVVisitor<SCEVExpander, Value*>;
|
||||
friend struct SCEVVisitor<SCEVExpander, Value*>;
|
||||
public:
|
||||
SCEVExpander(ScalarEvolution &se, LoopInfo &li) : SE(se), LI(li) {}
|
||||
|
||||
|
@ -135,7 +135,7 @@ public:
|
||||
// The implementation of this class
|
||||
//
|
||||
private:
|
||||
friend class InstVisitor<SCCP>; // Allow callbacks from visitor
|
||||
friend struct InstVisitor<SCCP>; // Allow callbacks from visitor
|
||||
|
||||
// markConstant - Make a value be marked as "constant". If the value
|
||||
// is not already a constant, add it to the instruction work list so that
|
||||
|
@ -90,7 +90,8 @@ public:
|
||||
|
||||
typedef std::map<const Value*, const Type*> ValueTypeCache;
|
||||
|
||||
struct ValueMapCache {
|
||||
class ValueMapCache {
|
||||
public:
|
||||
// Operands mapped - Contains an entry if the first value (the user) has had
|
||||
// the second value (the operand) mapped already.
|
||||
//
|
||||
|
@ -24,7 +24,7 @@
|
||||
namespace llvm {
|
||||
class Value;
|
||||
class Constant;
|
||||
struct Type;
|
||||
class Type;
|
||||
|
||||
// Constant fold various types of instruction...
|
||||
Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy);
|
||||
|
@ -24,7 +24,7 @@
|
||||
namespace llvm {
|
||||
class Value;
|
||||
class Constant;
|
||||
struct Type;
|
||||
class Type;
|
||||
|
||||
// Constant fold various types of instruction...
|
||||
Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy);
|
||||
|
@ -630,7 +630,8 @@ public:
|
||||
// This pass manager is used to group together all of the BasicBlockPass's
|
||||
// into a single unit.
|
||||
//
|
||||
template<> struct PassManagerTraits<BasicBlock> : public BasicBlockPass {
|
||||
template<> class PassManagerTraits<BasicBlock> : public BasicBlockPass {
|
||||
public:
|
||||
// PassClass - The type of passes tracked by this PassManager
|
||||
typedef BasicBlockPass PassClass;
|
||||
|
||||
@ -683,7 +684,8 @@ template<> struct PassManagerTraits<BasicBlock> : public BasicBlockPass {
|
||||
// This pass manager is used to group together all of the FunctionPass's
|
||||
// into a single unit.
|
||||
//
|
||||
template<> struct PassManagerTraits<Function> : public FunctionPass {
|
||||
template<> class PassManagerTraits<Function> : public FunctionPass {
|
||||
public:
|
||||
// PassClass - The type of passes tracked by this PassManager
|
||||
typedef FunctionPass PassClass;
|
||||
|
||||
@ -726,7 +728,8 @@ template<> struct PassManagerTraits<Function> : public FunctionPass {
|
||||
//
|
||||
// This is the top level PassManager implementation that holds generic passes.
|
||||
//
|
||||
template<> struct PassManagerTraits<Module> : public ModulePass {
|
||||
template<> class PassManagerTraits<Module> : public ModulePass {
|
||||
public:
|
||||
// PassClass - The type of passes tracked by this PassManager
|
||||
typedef ModulePass PassClass;
|
||||
|
||||
|
@ -26,7 +26,7 @@ namespace llvm {
|
||||
|
||||
class Record;
|
||||
class RecordKeeper;
|
||||
class CodeGenRegister;
|
||||
struct CodeGenRegister;
|
||||
|
||||
/// getValueType - Return the MVT::ValueType that the specified TableGen record
|
||||
/// corresponds to.
|
||||
|
@ -22,7 +22,7 @@ namespace llvm {
|
||||
class StringInit;
|
||||
class IntInit;
|
||||
class ListInit;
|
||||
class CodeGenInstruction;
|
||||
struct CodeGenInstruction;
|
||||
|
||||
class InstrInfoEmitter : public TableGenBackend {
|
||||
RecordKeeper &Records;
|
||||
|
@ -24,7 +24,7 @@
|
||||
namespace llvm {
|
||||
|
||||
class DagInit;
|
||||
class Init;
|
||||
struct Init;
|
||||
class InstrSelectorEmitter;
|
||||
|
||||
/// NodeType - Represents Information parsed from the DagNode entries.
|
||||
|
@ -34,7 +34,7 @@ class DagRecTy;
|
||||
class RecordRecTy;
|
||||
|
||||
// Init subclasses...
|
||||
class Init;
|
||||
struct Init;
|
||||
class UnsetInit;
|
||||
class BitInit;
|
||||
class BitsInit;
|
||||
@ -107,7 +107,8 @@ inline std::ostream &operator<<(std::ostream &OS, const RecTy &Ty) {
|
||||
|
||||
/// BitRecTy - 'bit' - Represent a single bit
|
||||
///
|
||||
struct BitRecTy : public RecTy {
|
||||
class BitRecTy : public RecTy {
|
||||
public:
|
||||
Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
|
||||
Init *convertValue(BitInit *BI) { return (Init*)BI; }
|
||||
Init *convertValue(BitsInit *BI);
|
||||
@ -157,7 +158,8 @@ public:
|
||||
|
||||
/// IntRecTy - 'int' - Represent an integer value of no particular size
|
||||
///
|
||||
struct IntRecTy : public RecTy {
|
||||
class IntRecTy : public RecTy {
|
||||
public:
|
||||
Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
|
||||
Init *convertValue(IntInit *II) { return (Init*)II; }
|
||||
Init *convertValue(BitInit *BI);
|
||||
@ -177,7 +179,8 @@ struct IntRecTy : public RecTy {
|
||||
|
||||
/// StringRecTy - 'string' - Represent an string value
|
||||
///
|
||||
struct StringRecTy : public RecTy {
|
||||
class StringRecTy : public RecTy {
|
||||
public:
|
||||
Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
|
||||
Init *convertValue(StringInit *SI) { return (Init*)SI; }
|
||||
Init *convertValue(TypedInit *TI);
|
||||
@ -219,7 +222,8 @@ public:
|
||||
|
||||
/// CodeRecTy - 'code' - Represent an code fragment, function or method.
|
||||
///
|
||||
struct CodeRecTy : public RecTy {
|
||||
class CodeRecTy : public RecTy {
|
||||
public:
|
||||
Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
|
||||
Init *convertValue( CodeInit *CI) { return (Init*)CI; }
|
||||
Init *convertValue(TypedInit *TI);
|
||||
@ -234,7 +238,8 @@ struct CodeRecTy : public RecTy {
|
||||
|
||||
/// DagRecTy - 'dag' - Represent a dag fragment
|
||||
///
|
||||
struct DagRecTy : public RecTy {
|
||||
class DagRecTy : public RecTy {
|
||||
public:
|
||||
Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
|
||||
Init *convertValue( DagInit *CI) { return (Init*)CI; }
|
||||
Init *convertValue(TypedInit *TI);
|
||||
@ -343,7 +348,8 @@ inline std::ostream &operator<<(std::ostream &OS, const Init &I) {
|
||||
|
||||
/// UnsetInit - ? - Represents an uninitialized value
|
||||
///
|
||||
struct UnsetInit : public Init {
|
||||
class UnsetInit : public Init {
|
||||
public:
|
||||
virtual Init *convertInitializerTo(RecTy *Ty) {
|
||||
return Ty->convertValue(this);
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user