mirror of
https://github.com/RPCS3/llvm.git
synced 2024-12-04 01:42:09 +00:00
ea3e5e56fd
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21441 91177308-0d34-0410-b5e6-96231b3b80d8
312 lines
8.6 KiB
C
312 lines
8.6 KiB
C
/* $Id$ */
|
|
|
|
#define MAX_ARITY 2
|
|
|
|
typedef int ItemSetNum;
|
|
typedef int OperatorNum;
|
|
typedef int NonTerminalNum;
|
|
typedef int RuleNum;
|
|
typedef int ArityNum;
|
|
typedef int ERuleNum;
|
|
|
|
extern NonTerminalNum last_user_nonterminal;
|
|
extern NonTerminalNum max_nonterminal;
|
|
extern RuleNum max_rule;
|
|
extern ERuleNum max_erule_num;
|
|
extern int max_arity;
|
|
|
|
#ifdef __STDC__
|
|
#define ARGS(x) x
|
|
#else
|
|
#define ARGS(x) ()
|
|
#endif
|
|
|
|
#ifndef NOLEX
|
|
#define DELTAWIDTH 4
|
|
typedef short DeltaCost[DELTAWIDTH];
|
|
typedef short *DeltaPtr;
|
|
extern void ASSIGNCOST ARGS((DeltaPtr, DeltaPtr));
|
|
extern void ADDCOST ARGS((DeltaPtr, DeltaPtr));
|
|
extern void MINUSCOST ARGS((DeltaPtr, DeltaPtr));
|
|
extern void ZEROCOST ARGS((DeltaPtr));
|
|
extern int LESSCOST ARGS((DeltaPtr, DeltaPtr));
|
|
extern int EQUALCOST ARGS((DeltaPtr, DeltaPtr));
|
|
#define PRINCIPLECOST(x) (x[0])
|
|
#else
|
|
#define DELTAWIDTH 1
|
|
typedef int DeltaCost;
|
|
typedef int DeltaPtr;
|
|
#define ASSIGNCOST(l, r) ((l) = (r))
|
|
#define ADDCOST(l, r) ((l) += (r))
|
|
#define MINUSCOST(l, r) ((l) -= (r))
|
|
#define ZEROCOST(x) ((x) = 0)
|
|
#define LESSCOST(l, r) ((l) < (r))
|
|
#define EQUALCOST(l, r) ((l) == (r))
|
|
#define PRINCIPLECOST(x) (x)
|
|
#endif /* NOLEX */
|
|
#define NODIVERGE(c,state,nt,base) if (prevent_divergence > 0) CHECKDIVERGE(c,state,nt,base);
|
|
|
|
struct list {
|
|
void *x;
|
|
struct list *next;
|
|
};
|
|
typedef struct list *List;
|
|
|
|
struct intlist {
|
|
int x;
|
|
struct intlist *next;
|
|
};
|
|
typedef struct intlist *IntList;
|
|
|
|
struct operator {
|
|
char *name;
|
|
unsigned int ref:1;
|
|
OperatorNum num;
|
|
ItemSetNum baseNum;
|
|
ItemSetNum stateCount;
|
|
ArityNum arity;
|
|
struct table *table;
|
|
};
|
|
typedef struct operator *Operator;
|
|
|
|
struct nonterminal {
|
|
char *name;
|
|
NonTerminalNum num;
|
|
ItemSetNum baseNum;
|
|
ItemSetNum ruleCount;
|
|
struct plankMap *pmap;
|
|
|
|
struct rule *sampleRule; /* diagnostic---gives "a" rule that with this lhs */
|
|
};
|
|
typedef struct nonterminal *NonTerminal;
|
|
|
|
struct pattern {
|
|
NonTerminal normalizer;
|
|
Operator op; /* NULL if NonTerm -> NonTerm */
|
|
NonTerminal children[MAX_ARITY];
|
|
};
|
|
typedef struct pattern *Pattern;
|
|
|
|
struct rule {
|
|
DeltaCost delta;
|
|
ERuleNum erulenum;
|
|
RuleNum num;
|
|
RuleNum newNum;
|
|
NonTerminal lhs;
|
|
Pattern pat;
|
|
unsigned int used:1;
|
|
};
|
|
typedef struct rule *Rule;
|
|
|
|
struct item {
|
|
DeltaCost delta;
|
|
Rule rule;
|
|
};
|
|
typedef struct item Item;
|
|
|
|
typedef short *Relevant; /* relevant non-terminals */
|
|
|
|
typedef Item *ItemArray;
|
|
|
|
struct item_set { /* indexed by NonTerminal */
|
|
ItemSetNum num;
|
|
ItemSetNum newNum;
|
|
Operator op;
|
|
struct item_set *kids[2];
|
|
struct item_set *representative;
|
|
Relevant relevant;
|
|
ItemArray virgin;
|
|
ItemArray closed;
|
|
};
|
|
typedef struct item_set *Item_Set;
|
|
|
|
#define DIM_MAP_SIZE (1 << 8)
|
|
#define GLOBAL_MAP_SIZE (1 << 15)
|
|
|
|
struct mapping { /* should be a hash table for TS -> int */
|
|
List *hash;
|
|
int hash_size;
|
|
int max_size;
|
|
ItemSetNum count;
|
|
Item_Set *set; /* map: int <-> Item_Set */
|
|
};
|
|
typedef struct mapping *Mapping;
|
|
|
|
struct index_map {
|
|
ItemSetNum max_size;
|
|
Item_Set *class;
|
|
};
|
|
typedef struct index_map Index_Map;
|
|
|
|
struct dimension {
|
|
Relevant relevant;
|
|
Index_Map index_map;
|
|
Mapping map;
|
|
ItemSetNum max_size;
|
|
struct plankMap *pmap;
|
|
};
|
|
typedef struct dimension *Dimension;
|
|
|
|
|
|
struct table {
|
|
Operator op;
|
|
List rules;
|
|
Relevant relevant;
|
|
Dimension dimen[MAX_ARITY]; /* 1 for each dimension */
|
|
Item_Set *transition; /* maps local indices to global
|
|
itemsets */
|
|
};
|
|
typedef struct table *Table;
|
|
|
|
struct relation {
|
|
Rule rule;
|
|
DeltaCost chain;
|
|
NonTerminalNum nextchain;
|
|
DeltaCost sibling;
|
|
int sibFlag;
|
|
int sibComputed;
|
|
};
|
|
typedef struct relation *Relation;
|
|
|
|
struct queue {
|
|
List head;
|
|
List tail;
|
|
};
|
|
typedef struct queue *Queue;
|
|
|
|
struct plank {
|
|
char *name;
|
|
List fields;
|
|
int width;
|
|
};
|
|
typedef struct plank *Plank;
|
|
|
|
struct except {
|
|
short index;
|
|
short value;
|
|
};
|
|
typedef struct except *Exception;
|
|
|
|
struct plankMap {
|
|
List exceptions;
|
|
int offset;
|
|
struct stateMap *values;
|
|
};
|
|
typedef struct plankMap *PlankMap;
|
|
|
|
struct stateMap {
|
|
char *fieldname;
|
|
Plank plank;
|
|
int width;
|
|
short *value;
|
|
};
|
|
typedef struct stateMap *StateMap;
|
|
|
|
struct stateMapTable {
|
|
List maps;
|
|
};
|
|
|
|
extern void CHECKDIVERGE ARGS((DeltaPtr, Item_Set, int, int));
|
|
extern void zero ARGS((Item_Set));
|
|
extern ItemArray newItemArray ARGS((void));
|
|
extern ItemArray itemArrayCopy ARGS((ItemArray));
|
|
extern Item_Set newItem_Set ARGS((Relevant));
|
|
extern void freeItem_Set ARGS((Item_Set));
|
|
extern Mapping newMapping ARGS((int));
|
|
extern NonTerminal newNonTerminal ARGS((char *));
|
|
extern int nonTerminalName ARGS((char *, int));
|
|
extern Operator newOperator ARGS((char *, OperatorNum, ArityNum));
|
|
extern Pattern newPattern ARGS((Operator));
|
|
extern Rule newRule ARGS((DeltaPtr, ERuleNum, NonTerminal, Pattern));
|
|
extern List newList ARGS((void *, List));
|
|
extern IntList newIntList ARGS((int, IntList));
|
|
extern int length ARGS((List));
|
|
extern List appendList ARGS((void *, List));
|
|
extern Table newTable ARGS((Operator));
|
|
extern Queue newQ ARGS((void));
|
|
extern void addQ ARGS((Queue, Item_Set));
|
|
extern Item_Set popQ ARGS((Queue));
|
|
extern int equivSet ARGS((Item_Set, Item_Set));
|
|
extern Item_Set decode ARGS((Mapping, ItemSetNum));
|
|
extern Item_Set encode ARGS((Mapping, Item_Set, int *));
|
|
extern void build ARGS((void));
|
|
extern Item_Set *transLval ARGS((Table, int, int));
|
|
|
|
typedef void * (*ListFn) ARGS((void *));
|
|
extern void foreachList ARGS((ListFn, List));
|
|
extern void reveachList ARGS((ListFn, List));
|
|
|
|
extern void addToTable ARGS((Table, Item_Set));
|
|
|
|
extern void closure ARGS((Item_Set));
|
|
extern void trim ARGS((Item_Set));
|
|
extern void findChainRules ARGS((void));
|
|
extern void findAllPairs ARGS((void));
|
|
extern void addRelevant ARGS((Relevant, NonTerminalNum));
|
|
|
|
extern void *zalloc ARGS((unsigned int));
|
|
extern void zfree ARGS((void *));
|
|
|
|
extern NonTerminal start;
|
|
extern List rules;
|
|
extern List chainrules;
|
|
extern List operators;
|
|
extern List leaves;
|
|
extern List nonterminals;
|
|
extern List grammarNts;
|
|
extern Queue globalQ;
|
|
extern Mapping globalMap;
|
|
extern int exceptionTolerance;
|
|
extern int prevent_divergence;
|
|
extern int principleCost;
|
|
extern int lexical;
|
|
extern struct rule stub_rule;
|
|
extern Relation *allpairs;
|
|
extern Item_Set *sortedStates;
|
|
extern Item_Set errorState;
|
|
|
|
extern void dumpRelevant ARGS((Relevant));
|
|
extern void dumpOperator ARGS((Operator, int));
|
|
extern void dumpOperator_s ARGS((Operator));
|
|
extern void dumpOperator_l ARGS((Operator));
|
|
extern void dumpNonTerminal ARGS((NonTerminal));
|
|
extern void dumpRule ARGS((Rule));
|
|
extern void dumpRuleList ARGS((List));
|
|
extern void dumpItem ARGS((Item *));
|
|
extern void dumpItem_Set ARGS((Item_Set));
|
|
extern void dumpMapping ARGS((Mapping));
|
|
extern void dumpQ ARGS((Queue));
|
|
extern void dumpIndex_Map ARGS((Index_Map *));
|
|
extern void dumpDimension ARGS((Dimension));
|
|
extern void dumpPattern ARGS((Pattern));
|
|
extern void dumpTable ARGS((Table, int));
|
|
extern void dumpTransition ARGS((Table));
|
|
extern void dumpCost ARGS((DeltaCost));
|
|
extern void dumpAllPairs ARGS((void));
|
|
extern void dumpRelation ARGS((Relation));
|
|
extern void dumpSortedStates ARGS((void));
|
|
extern void dumpSortedRules ARGS((void));
|
|
extern int debugTrim;
|
|
|
|
#ifdef DEBUG
|
|
#define debug(a,b) if (a) b
|
|
#else
|
|
#define debug(a,b)
|
|
#endif
|
|
extern int debugTables;
|
|
|
|
#define TABLE_INCR 8
|
|
#define STATES_INCR 64
|
|
|
|
#ifdef NDEBUG
|
|
#define assert(c) ((void) 0)
|
|
#else
|
|
#define assert(c) ((void) ((c) || fatal(__FILE__,__LINE__)))
|
|
#endif
|
|
|
|
extern void doStart ARGS((char *));
|
|
extern void exit ARGS((int));
|
|
extern int fatal ARGS((const char *, int));
|
|
extern void yyerror ARGS((const char *));
|
|
extern void yyerror1 ARGS((const char *));
|