6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-14 11:32:34 +00:00
Code Issues Projects Releases Wiki Activity

Switching TargetMachineRegistry to use the new generic Registry.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@43094 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Gordon Henriksen 2007-10-17 21:28:48 +00:00
parent 9080aaba0b
commit 4b2b9402c5
8 changed files with 115 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
include/llvm/Target/TargetMachineRegistry.h
View File

@ -17,52 +17,49 @@
#ifndef LLVM_TARGET_TARGETMACHINEREGISTRY_H #ifndef LLVM_TARGET_TARGETMACHINEREGISTRY_H
#define LLVM_TARGET_TARGETMACHINEREGISTRY_H #define LLVM_TARGET_TARGETMACHINEREGISTRY_H
#include "llvm/Support/CommandLine.h" #include "llvm/Support/Registry.h"
namespace llvm { namespace llvm {
class Module; class Module;
class TargetMachine; class TargetMachine;
struct TargetMachineRegistry { struct TargetMachineRegistryEntry {
struct Entry;
/// TargetMachineRegistry::getList - This static method returns the list of
/// target machines that are registered with the system.
static const Entry *getList() { return List; }
/// getClosestStaticTargetForModule - Given an LLVM module, pick the best
/// target that is compatible with the module. If no close target can be
/// found, this returns null and sets the Error string to a reason.
static const Entry *getClosestStaticTargetForModule(const Module &M,
std::string &Error);
/// getClosestTargetForJIT - Pick the best target that is compatible with
/// the current host. If no close target can be found, this returns null
/// and sets the Error string to a reason.
static const Entry *getClosestTargetForJIT(std::string &Error);
/// Entry - One instance of this struct is created for each target that is
/// registered.
struct Entry {
const char *Name; const char *Name;
const char *ShortDesc; const char *ShortDesc;
TargetMachine *(*CtorFn)(const Module &, const std::string &); TargetMachine *(*CtorFn)(const Module &, const std::string &);
unsigned (*ModuleMatchQualityFn)(const Module &M); unsigned (*ModuleMatchQualityFn)(const Module &M);
unsigned (*JITMatchQualityFn)(); unsigned (*JITMatchQualityFn)();
const Entry *getNext() const { return Next; } public:
TargetMachineRegistryEntry(const char *N, const char *SD,
protected:
Entry(const char *N, const char *SD,
TargetMachine *(*CF)(const Module &, const std::string &), TargetMachine *(*CF)(const Module &, const std::string &),
unsigned (*MMF)(const Module &M), unsigned (*JMF)()); unsigned (*MMF)(const Module &M),
private: unsigned (*JMF)())
const Entry *Next; // Next entry in the linked list. : Name(N), ShortDesc(SD), CtorFn(CF), ModuleMatchQualityFn(MMF),
JITMatchQualityFn(JMF) {}
}; };
private: template<>
static const Entry *List; class RegistryTraits<TargetMachine> {
public:
typedef TargetMachineRegistryEntry entry;
static const char *nameof(const entry &Entry) { return Entry.Name; }
static const char *descof(const entry &Entry) { return Entry.ShortDesc; }
};
struct TargetMachineRegistry : Registry<TargetMachine> {
/// getClosestStaticTargetForModule - Given an LLVM module, pick the best
/// target that is compatible with the module. If no close target can be
/// found, this returns null and sets the Error string to a reason.
static const entry *getClosestStaticTargetForModule(const Module &M,
std::string &Error);
/// getClosestTargetForJIT - Pick the best target that is compatible with
/// the current host. If no close target can be found, this returns null
/// and sets the Error string to a reason.
static const entry *getClosestTargetForJIT(std::string &Error);
}; };
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
@ -77,51 +74,23 @@ namespace llvm {
/// flavour. /// flavour.
template<class TargetMachineImpl> template<class TargetMachineImpl>
struct RegisterTarget : public TargetMachineRegistry::Entry { struct RegisterTarget {
RegisterTarget(const char *Name, const char *ShortDesc) : RegisterTarget(const char *Name, const char *ShortDesc)
TargetMachineRegistry::Entry(Name, ShortDesc, &Allocator, : Entry(Name, ShortDesc, &Allocator,
&TargetMachineImpl::getModuleMatchQuality, &TargetMachineImpl::getModuleMatchQuality,
&TargetMachineImpl::getJITMatchQuality) { &TargetMachineImpl::getJITMatchQuality),
} Node(Entry)
{}
private: private:
TargetMachineRegistry::entry Entry;
TargetMachineRegistry::node Node;
static TargetMachine *Allocator(const Module &M, const std::string &FS) { static TargetMachine *Allocator(const Module &M, const std::string &FS) {
return new TargetMachineImpl(M, FS); return new TargetMachineImpl(M, FS);
} }
}; };
/// TargetRegistrationListener - This class allows code to listen for targets
/// that are dynamically registered, and be notified of it when they are.
class TargetRegistrationListener {
TargetRegistrationListener **Prev, *Next;
public:
TargetRegistrationListener();
virtual ~TargetRegistrationListener();
TargetRegistrationListener *getNext() const { return Next; }
virtual void targetRegistered(const TargetMachineRegistry::Entry *E) = 0;
};
//===--------------------------------------------------------------------===//
/// TargetNameParser - This option can be used to provide a command line
/// option to choose among the various registered targets (commonly -march).
class TargetNameParser : public TargetRegistrationListener,
public cl::parser<const TargetMachineRegistry::Entry*> {
public:
void initialize(cl::Option &O) {
for (const TargetMachineRegistry::Entry *E =
TargetMachineRegistry::getList(); E; E = E->getNext())
Values.push_back(std::make_pair(E->Name,
std::make_pair(E, E->ShortDesc)));
cl::parser<const TargetMachineRegistry::Entry*>::initialize(O);
}
virtual void targetRegistered(const TargetMachineRegistry::Entry *E) {
Values.push_back(std::make_pair(E->Name,
std::make_pair(E, E->ShortDesc)));
}
};
} }
#endif #endif

5
lib/ExecutionEngine/JIT/TargetSelect.cpp
View File

@ -20,7 +20,8 @@
#include "llvm/Target/TargetMachineRegistry.h" #include "llvm/Target/TargetMachineRegistry.h"
using namespace llvm; using namespace llvm;
static cl::opt<const TargetMachineRegistry::Entry*, false, TargetNameParser> static cl::opt<const TargetMachineRegistry::entry*, false,
TargetMachineRegistry::Parser>
MArch("march", cl::desc("Architecture to generate assembly for:")); MArch("march", cl::desc("Architecture to generate assembly for:"));
static cl::opt<std::string> static cl::opt<std::string>
@ -39,7 +40,7 @@ MAttrs("mattr",
/// for the current target. Otherwise, return null. /// for the current target. Otherwise, return null.
/// ///
ExecutionEngine *JIT::create(ModuleProvider *MP, std::string *ErrorStr) { ExecutionEngine *JIT::create(ModuleProvider *MP, std::string *ErrorStr) {
const TargetMachineRegistry::Entry *TheArch = MArch; const TargetMachineRegistry::entry *TheArch = MArch;
if (TheArch == 0) { if (TheArch == 0) {
std::string Error; std::string Error;
TheArch = TargetMachineRegistry::getClosestTargetForJIT(Error); TheArch = TargetMachineRegistry::getClosestTargetForJIT(Error);

2
lib/Target/CBackend/CBackend.cpp
View File

@ -2684,7 +2684,7 @@ std::string CWriter::InterpretASMConstraint(InlineAsm::ConstraintInfo& c) {
//Grab the translation table from TargetAsmInfo if it exists //Grab the translation table from TargetAsmInfo if it exists
if (!TAsm) { if (!TAsm) {
std::string E; std::string E;
const TargetMachineRegistry::Entry* Match = const TargetMachineRegistry::entry* Match =
TargetMachineRegistry::getClosestStaticTargetForModule(*TheModule, E); TargetMachineRegistry::getClosestStaticTargetForModule(*TheModule, E);
if (Match) { if (Match) {
//Per platform Target Machines don't exist, so create it //Per platform Target Machines don't exist, so create it

55
lib/Target/TargetMachineRegistry.cpp
View File

@ -18,44 +18,23 @@
#include <algorithm> #include <algorithm>
using namespace llvm; using namespace llvm;
/// List - This is the main list of all of the registered target machines. template<> Registry<TargetMachine>::node *Registry<TargetMachine>::Head = 0;
const TargetMachineRegistry::Entry *TargetMachineRegistry::List = 0; template<> Registry<TargetMachine>::node *Registry<TargetMachine>::Tail = 0;
template<> Registry<TargetMachine>::listener *Registry<TargetMachine>::
/// Listeners - All of the listeners registered to get notified when new targets ListenerHead = 0;
/// are loaded. template<> Registry<TargetMachine>::listener *Registry<TargetMachine>::
static TargetRegistrationListener *Listeners = 0; ListenerTail = 0;
TargetMachineRegistry::Entry::Entry(const char *N, const char *SD,
TargetMachine *(*CF)(const Module &,const std::string &),
unsigned (*MMF)(const Module &M), unsigned (*JMF)())
: Name(N), ShortDesc(SD), CtorFn(CF), ModuleMatchQualityFn(MMF),
JITMatchQualityFn(JMF), Next(List) {
List = this;
for (TargetRegistrationListener *L = Listeners; L; L = L->getNext())
L->targetRegistered(this);
}
TargetRegistrationListener::TargetRegistrationListener() {
Next = Listeners;
if (Next) Next->Prev = &Next;
Prev = &Listeners;
Listeners = this;
}
TargetRegistrationListener::~TargetRegistrationListener() {
*Prev = Next;
}
/// getClosestStaticTargetForModule - Given an LLVM module, pick the best target /// getClosestStaticTargetForModule - Given an LLVM module, pick the best target
/// that is compatible with the module. If no close target can be found, this /// that is compatible with the module. If no close target can be found, this
/// returns null and sets the Error string to a reason. /// returns null and sets the Error string to a reason.
const TargetMachineRegistry::Entry * const TargetMachineRegistry::entry *
TargetMachineRegistry::getClosestStaticTargetForModule(const Module &M, TargetMachineRegistry::getClosestStaticTargetForModule(const Module &M,
std::string &Error) { std::string &Error) {
std::vector<std::pair<unsigned, const Entry *> > UsableTargets; std::vector<std::pair<unsigned, const entry *> > UsableTargets;
for (const Entry *E = getList(); E; E = E->getNext()) for (iterator I = begin(), E = end(); I != E; ++I)
if (unsigned Qual = E->ModuleMatchQualityFn(M)) if (unsigned Qual = I->ModuleMatchQualityFn(M))
UsableTargets.push_back(std::make_pair(Qual, E)); UsableTargets.push_back(std::make_pair(Qual, &*I));
if (UsableTargets.empty()) { if (UsableTargets.empty()) {
Error = "No available targets are compatible with this module"; Error = "No available targets are compatible with this module";
@ -78,12 +57,12 @@ TargetMachineRegistry::getClosestStaticTargetForModule(const Module &M,
/// getClosestTargetForJIT - Pick the best target that is compatible with /// getClosestTargetForJIT - Pick the best target that is compatible with
/// the current host. If no close target can be found, this returns null /// the current host. If no close target can be found, this returns null
/// and sets the Error string to a reason. /// and sets the Error string to a reason.
const TargetMachineRegistry::Entry * const TargetMachineRegistry::entry *
TargetMachineRegistry::getClosestTargetForJIT(std::string &Error) { TargetMachineRegistry::getClosestTargetForJIT(std::string &Error) {
std::vector<std::pair<unsigned, const Entry *> > UsableTargets; std::vector<std::pair<unsigned, const entry *> > UsableTargets;
for (const Entry *E = getList(); E; E = E->getNext()) for (iterator I = begin(), E = end(); I != E; ++I)
if (unsigned Qual = E->JITMatchQualityFn()) if (unsigned Qual = I->JITMatchQualityFn())
UsableTargets.push_back(std::make_pair(Qual, E)); UsableTargets.push_back(std::make_pair(Qual, &*I));
if (UsableTargets.empty()) { if (UsableTargets.empty()) {
Error = "No JIT is available for this host"; Error = "No JIT is available for this host";
@ -93,7 +72,7 @@ TargetMachineRegistry::getClosestTargetForJIT(std::string &Error) {
// Otherwise, take the best target. If there is a tie, just pick one. // Otherwise, take the best target. If there is a tie, just pick one.
unsigned MaxQual = UsableTargets.front().first; unsigned MaxQual = UsableTargets.front().first;
const Entry *MaxQualTarget = UsableTargets.front().second; const entry *MaxQualTarget = UsableTargets.front().second;
for (unsigned i = 1, e = UsableTargets.size(); i != e; ++i) for (unsigned i = 1, e = UsableTargets.size(); i != e; ++i)
if (UsableTargets[i].first > MaxQual) { if (UsableTargets[i].first > MaxQual) {

3
tools/llc/llc.cpp
View File

@ -57,7 +57,8 @@ static cl::opt<bool> Fast("fast",
static cl::opt<std::string> static cl::opt<std::string>
TargetTriple("mtriple", cl::desc("Override target triple for module")); TargetTriple("mtriple", cl::desc("Override target triple for module"));
static cl::opt<const TargetMachineRegistry::Entry*, false, TargetNameParser> static cl::opt<const TargetMachineRegistry::entry*, false,
TargetMachineRegistry::Parser>
MArch("march", cl::desc("Architecture to generate code for:")); MArch("march", cl::desc("Architecture to generate code for:"));
static cl::opt<std::string> static cl::opt<std::string>

2
tools/lto/lto.cpp
View File

@ -217,7 +217,7 @@ LTO::getTarget (Module *M) {
return; return;
std::string Err; std::string Err;
const TargetMachineRegistry::Entry* March = const TargetMachineRegistry::entry* March =
TargetMachineRegistry::getClosestStaticTargetForModule(*M, Err); TargetMachineRegistry::getClosestStaticTargetForModule(*M, Err);
if (March == 0) if (March == 0)

86
utils/TableGen/FileLexer.cpp.cvs
View File

@ -502,7 +502,7 @@ goto find_rule; \
#define YY_MORE_ADJ 0 #define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET #define YY_RESTORE_YY_MORE_OFFSET
char *yytext; char *yytext;
#line 1 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 1 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
#define INITIAL 0 #define INITIAL 0
/*===-- FileLexer.l - Scanner for TableGen Files ----------------*- C++ -*-===// /*===-- FileLexer.l - Scanner for TableGen Files ----------------*- C++ -*-===//
// //
@ -518,9 +518,9 @@ char *yytext;
// //
//===----------------------------------------------------------------------===*/ //===----------------------------------------------------------------------===*/
#define YY_NEVER_INTERACTIVE 1 #define YY_NEVER_INTERACTIVE 1
#define comment 1 #define in_comment 1
#line 30 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 30 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
#include "llvm/Config/config.h" #include "llvm/Config/config.h"
#include "llvm/Support/Streams.h" #include "llvm/Support/Streams.h"
#include "Record.h" #include "Record.h"
@ -817,7 +817,7 @@ YY_DECL
register char *yy_cp, *yy_bp; register char *yy_cp, *yy_bp;
register int yy_act; register int yy_act;
#line 185 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 185 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
#line 824 "Lexer.cpp" #line 824 "Lexer.cpp"
@ -913,185 +913,185 @@ do_action: /* This label is used only to access EOF actions. */
{ /* beginning of action switch */ { /* beginning of action switch */
case 1: case 1:
YY_RULE_SETUP YY_RULE_SETUP
#line 187 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 187 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ /* Ignore comments */ } { /* Ignore comments */ }
YY_BREAK YY_BREAK
case 2: case 2:
YY_RULE_SETUP YY_RULE_SETUP
#line 189 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 189 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ HandleInclude(yytext); } { HandleInclude(yytext); }
YY_BREAK YY_BREAK
case 3: case 3:
YY_RULE_SETUP YY_RULE_SETUP
#line 190 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 190 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ Filelval.StrVal = new std::string(yytext+2, yytext+yyleng-2); { Filelval.StrVal = new std::string(yytext+2, yytext+yyleng-2);
return CODEFRAGMENT; } return CODEFRAGMENT; }
YY_BREAK YY_BREAK
case 4: case 4:
YY_RULE_SETUP YY_RULE_SETUP
#line 193 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 193 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return INT; } { return INT; }
YY_BREAK YY_BREAK
case 5: case 5:
YY_RULE_SETUP YY_RULE_SETUP
#line 194 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 194 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return BIT; } { return BIT; }
YY_BREAK YY_BREAK
case 6: case 6:
YY_RULE_SETUP YY_RULE_SETUP
#line 195 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 195 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return BITS; } { return BITS; }
YY_BREAK YY_BREAK
case 7: case 7:
YY_RULE_SETUP YY_RULE_SETUP
#line 196 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 196 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return STRING; } { return STRING; }
YY_BREAK YY_BREAK
case 8: case 8:
YY_RULE_SETUP YY_RULE_SETUP
#line 197 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 197 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return LIST; } { return LIST; }
YY_BREAK YY_BREAK
case 9: case 9:
YY_RULE_SETUP YY_RULE_SETUP
#line 198 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 198 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return CODE; } { return CODE; }
YY_BREAK YY_BREAK
case 10: case 10:
YY_RULE_SETUP YY_RULE_SETUP
#line 199 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 199 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return DAG; } { return DAG; }
YY_BREAK YY_BREAK
case 11: case 11:
YY_RULE_SETUP YY_RULE_SETUP
#line 201 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 201 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return CLASS; } { return CLASS; }
YY_BREAK YY_BREAK
case 12: case 12:
YY_RULE_SETUP YY_RULE_SETUP
#line 202 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 202 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return DEF; } { return DEF; }
YY_BREAK YY_BREAK
case 13: case 13:
YY_RULE_SETUP YY_RULE_SETUP
#line 203 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 203 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return DEFM; } { return DEFM; }
YY_BREAK YY_BREAK
case 14: case 14:
YY_RULE_SETUP YY_RULE_SETUP
#line 204 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 204 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return MULTICLASS; } { return MULTICLASS; }
YY_BREAK YY_BREAK
case 15: case 15:
YY_RULE_SETUP YY_RULE_SETUP
#line 205 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 205 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return FIELD; } { return FIELD; }
YY_BREAK YY_BREAK
case 16: case 16:
YY_RULE_SETUP YY_RULE_SETUP
#line 206 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 206 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return LET; } { return LET; }
YY_BREAK YY_BREAK
case 17: case 17:
YY_RULE_SETUP YY_RULE_SETUP
#line 207 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 207 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return IN; } { return IN; }
YY_BREAK YY_BREAK
case 18: case 18:
YY_RULE_SETUP YY_RULE_SETUP
#line 209 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 209 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return CONCATTOK; } { return CONCATTOK; }
YY_BREAK YY_BREAK
case 19: case 19:
YY_RULE_SETUP YY_RULE_SETUP
#line 210 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 210 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return SRATOK; } { return SRATOK; }
YY_BREAK YY_BREAK
case 20: case 20:
YY_RULE_SETUP YY_RULE_SETUP
#line 211 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 211 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return SRLTOK; } { return SRLTOK; }
YY_BREAK YY_BREAK
case 21: case 21:
YY_RULE_SETUP YY_RULE_SETUP
#line 212 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 212 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return SHLTOK; } { return SHLTOK; }
YY_BREAK YY_BREAK
case 22: case 22:
YY_RULE_SETUP YY_RULE_SETUP
#line 213 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 213 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return STRCONCATTOK; } { return STRCONCATTOK; }
YY_BREAK YY_BREAK
case 23: case 23:
YY_RULE_SETUP YY_RULE_SETUP
#line 216 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 216 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ Filelval.StrVal = new std::string(yytext, yytext+yyleng); { Filelval.StrVal = new std::string(yytext, yytext+yyleng);
return ID; } return ID; }
YY_BREAK YY_BREAK
case 24: case 24:
YY_RULE_SETUP YY_RULE_SETUP
#line 218 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 218 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ Filelval.StrVal = new std::string(yytext+1, yytext+yyleng); { Filelval.StrVal = new std::string(yytext+1, yytext+yyleng);
return VARNAME; } return VARNAME; }
YY_BREAK YY_BREAK
case 25: case 25:
YY_RULE_SETUP YY_RULE_SETUP
#line 221 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 221 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ Filelval.StrVal = new std::string(yytext+1, yytext+yyleng-1); { Filelval.StrVal = new std::string(yytext+1, yytext+yyleng-1);
return STRVAL; } return STRVAL; }
YY_BREAK YY_BREAK
case 26: case 26:
YY_RULE_SETUP YY_RULE_SETUP
#line 224 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 224 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ Filelval.IntVal = ParseInt(Filetext); return INTVAL; } { Filelval.IntVal = ParseInt(Filetext); return INTVAL; }
YY_BREAK YY_BREAK
case 27: case 27:
YY_RULE_SETUP YY_RULE_SETUP
#line 226 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 226 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ /* Ignore whitespace */ } { /* Ignore whitespace */ }
YY_BREAK YY_BREAK
case 28: case 28:
YY_RULE_SETUP YY_RULE_SETUP
#line 229 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 229 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ BEGIN(comment); CommentDepth++; } { BEGIN(in_comment); CommentDepth++; }
YY_BREAK YY_BREAK
case 29: case 29:
YY_RULE_SETUP YY_RULE_SETUP
#line 230 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 230 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{} /* eat anything that's not a '*' or '/' */ {} /* eat anything that's not a '*' or '/' */
YY_BREAK YY_BREAK
case 30: case 30:
YY_RULE_SETUP YY_RULE_SETUP
#line 231 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 231 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{} /* eat up '*'s not followed by '/'s */ {} /* eat up '*'s not followed by '/'s */
YY_BREAK YY_BREAK
case 31: case 31:
YY_RULE_SETUP YY_RULE_SETUP
#line 232 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 232 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ ++CommentDepth; } { ++CommentDepth; }
YY_BREAK YY_BREAK
case 32: case 32:
YY_RULE_SETUP YY_RULE_SETUP
#line 233 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 233 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{} /* eat up /'s not followed by *'s */ {} /* eat up /'s not followed by *'s */
YY_BREAK YY_BREAK
case 33: case 33:
YY_RULE_SETUP YY_RULE_SETUP
#line 234 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 234 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ if (!--CommentDepth) { BEGIN(INITIAL); } } { if (!--CommentDepth) { BEGIN(INITIAL); } }
YY_BREAK YY_BREAK
case YY_STATE_EOF(comment): case YY_STATE_EOF(in_comment):
#line 235 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 235 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ err() << "Unterminated comment!\n"; exit(1); } { err() << "Unterminated comment!\n"; exit(1); }
YY_BREAK YY_BREAK
case 34: case 34:
YY_RULE_SETUP YY_RULE_SETUP
#line 237 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 237 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
{ return Filetext[0]; } { return Filetext[0]; }
YY_BREAK YY_BREAK
case 35: case 35:
YY_RULE_SETUP YY_RULE_SETUP
#line 239 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 239 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"
YY_FATAL_ERROR( "flex scanner jammed" ); YY_FATAL_ERROR( "flex scanner jammed" );
YY_BREAK YY_BREAK
#line 1098 "Lexer.cpp" #line 1098 "Lexer.cpp"
@ -1978,6 +1978,6 @@ int main()
return 0; return 0;
} }
#endif #endif
#line 239 "/Volumes/ProjectsDisk/cvs/llvm/utils/TableGen/FileLexer.l" #line 239 "/Users/malichus/Source/llvm/src/llvm/utils/TableGen/FileLexer.l"

16
utils/TableGen/FileLexer.l.cvs
View File

@ -24,7 +24,7 @@
%option noreject %option noreject
%option noyymore %option noyymore
%x comment %x in_comment
%{ %{
#include "llvm/Config/config.h" #include "llvm/Config/config.h"
@ -226,13 +226,13 @@ ${Identifier} { Filelval.StrVal = new std::string(yytext+1, yytext+yyleng);
[ \t\n\r]+ { /* Ignore whitespace */ } [ \t\n\r]+ { /* Ignore whitespace */ }
"/*" { BEGIN(comment); CommentDepth++; } "/*" { BEGIN(in_comment); CommentDepth++; }
<comment>[^*/]* {} /* eat anything that's not a '*' or '/' */ <in_comment>[^*/]* {} /* eat anything that's not a '*' or '/' */
<comment>"*"+[^*/]* {} /* eat up '*'s not followed by '/'s */ <in_comment>"*"+[^*/]* {} /* eat up '*'s not followed by '/'s */
<comment>"/*" { ++CommentDepth; } <in_comment>"/*" { ++CommentDepth; }
<comment>"/"+[^*/]* {} /* eat up /'s not followed by *'s */ <in_comment>"/"+[^*/]* {} /* eat up /'s not followed by *'s */
<comment>"*"+"/" { if (!--CommentDepth) { BEGIN(INITIAL); } } <in_comment>"*"+"/" { if (!--CommentDepth) { BEGIN(INITIAL); } }
<comment><<EOF>> { err() << "Unterminated comment!\n"; exit(1); } <in_comment><<EOF>> { err() << "Unterminated comment!\n"; exit(1); }
. { return Filetext[0]; } . { return Filetext[0]; }