/*
- * Copyright 2001-2006 Adrian Thurston <thurston@cs.queensu.ca>
+ * Copyright 2001-2006 Adrian Thurston <thurston@complang.org>
*/
/* This file is part of Ragel.
Action *action;
};
+struct ConditionTest
+{
+ ConditionTest( const InputLoc &loc, AugType type, Action *action, bool sense ) :
+ loc(loc), type(type), action(action), sense(sense) { }
+
+ InputLoc loc;
+ AugType type;
+ Action *action;
+ bool sense;
+};
+
struct Token
{
char *data;
int length;
InputLoc loc;
- void prepareLitString( Token &result, bool &caseInsensitive );
void append( const Token &other );
- void set( char *str, int len );
+ void set( const char *str, int len );
};
+char *prepareLitString( const InputLoc &loc, const char *src, long length,
+ long &resLen, bool &caseInsensitive );
+
/* Store the value and type of a priority augmentation. */
struct PriorityAug
{
*/
struct VarDef
{
- VarDef( char *name, JoinOrLm *joinOrLm )
- : name(name), joinOrLm(joinOrLm) { }
+ VarDef( const char *name, JoinOrLm *joinOrLm )
+ : name(name), joinOrLm(joinOrLm), isExport(false) { }
/* Parse tree traversal. */
FsmAp *walk( ParseData *pd );
void makeNameTree( const InputLoc &loc, ParseData *pd );
void resolveNameRefs( ParseData *pd );
- char *name;
+ const char *name;
JoinOrLm *joinOrLm;
+ bool isExport;
};
FsmAp *walk( ParseData *pd );
void makeNameTree( ParseData *pd );
void resolveNameRefs( ParseData *pd );
- void runLonestMatch( ParseData *pd, FsmAp *graph );
- Action *newAction( ParseData *pd, const InputLoc &loc, char *name,
+ void transferScannerLeavingActions( FsmAp *graph );
+ void runLongestMatch( ParseData *pd, FsmAp *graph );
+ Action *newAction( ParseData *pd, const InputLoc &loc, const char *name,
InlineList *inlineList );
void makeActions( ParseData *pd );
void findName( ParseData *pd );
InputLoc loc;
LmPartList *longestMatchList;
- char *name;
+ const char *name;
Action *lmActSelect;
bool lmSwitchHandlesError;
};
JoinOrLm( Join *join ) :
- join(join), type(JoinType) {}
+ join(join), longestMatch(0), type(JoinType) {}
JoinOrLm( LongestMatch *longestMatch ) :
- longestMatch(longestMatch), type(LongestMatchType) {}
+ join(0), longestMatch(longestMatch), type(LongestMatchType) {}
FsmAp *walk( ParseData *pd );
void makeNameTree( ParseData *pd );
PriorDesc *priorDescs;
Vector<Label> labels;
Vector<EpsilonLink> epsilonLinks;
- Vector<ParserAction> conditions;
+ Vector<ConditionTest> conditions;
FactorWithRep *factorWithRep;
};
factorWithNeg(0), lowerRep(lowerRep),
upperRep(upperRep), type(type) { }
- FactorWithRep( const InputLoc &loc, FactorWithNeg *factorWithNeg )
- : loc(loc), factorWithNeg(factorWithNeg), type(FactorWithNegType) { }
+ FactorWithRep( FactorWithNeg *factorWithNeg )
+ : factorWithNeg(factorWithNeg), type(FactorWithNegType) { }
~FactorWithRep();
FactorWithNeg( const InputLoc &loc, FactorWithNeg *factorWithNeg, Type type) :
loc(loc), factorWithNeg(factorWithNeg), factor(0), type(type) { }
- FactorWithNeg( const InputLoc &loc, Factor *factor ) :
- loc(loc), factorWithNeg(0), factor(factor), type(FactorType) { }
+ FactorWithNeg( Factor *factor ) :
+ factorWithNeg(0), factor(factor), type(FactorType) { }
~FactorWithNeg();
reItem(reItem), type(OrExprType) { }
/* Construct with a regular expression. */
- Factor( RegExpr *regExp ) :
- regExp(regExp), type(RegExprType) { }
+ Factor( RegExpr *regExpr ) :
+ regExpr(regExpr), type(RegExprType) { }
/* Construct with a reference to a var def. */
Factor( const InputLoc &loc, VarDef *varDef ) :
Literal *literal;
Range *range;
ReItem *reItem;
- RegExpr *regExp;
+ RegExpr *regExpr;
VarDef *varDef;
Join *join;
LongestMatch *longestMatch;
~Range();
FsmAp *walk( ParseData *pd );
- bool verifyRangeFsm( FsmAp *rangeEnd );
Literal *lowerLit;
Literal *upperLit;
/* Constructors. */
RegExpr() :
type(Empty), caseInsensitive(false) { }
- RegExpr(RegExpr *regExp, ReItem *item) :
- regExp(regExp), item(item),
+ RegExpr(RegExpr *regExpr, ReItem *item) :
+ regExpr(regExpr), item(item),
type(RecurseItem), caseInsensitive(false) { }
~RegExpr();
FsmAp *walk( ParseData *pd, RegExpr *rootRegex );
- RegExpr *regExp;
+ RegExpr *regExpr;
ReItem *item;
RegExpType type;
bool caseInsensitive;