void Visualize() {
printf("\nGenerating visualization for %s...", kDBName);
Stopwatch();
//printf("\nPreparing tree");
PrepareTree(&GameTree);
//printf("\nPreparing file");
PrepareDOTFile();
//printf("\nFilling tree");
PopulateEdgelist(&GameTree);
//printf("\nWriting file");
Write(DOTFile, &GameTree);
//printf("\nClosing file");
CloseDOTFile(DOTFile);
//printf("\nCleaning up tree");
CleanupTree(&GameTree);
printf("done in %u seconds!", Stopwatch());
printf("\nVisualization saved to directory \"visualization\\m%s\"", kDBName);
printf("\nPlease use Graphviz's 'dot' tool to render the DOT files as images.\n");
return;
}
int Compile(unsigned char* string, int len, unsigned char *fileName, wchar_t *fileNameW) {
Token *tokens;
int numTokens;
int numErrors = Tokenize(string, len, tokens, numTokens, fileNameW);
if (numErrors) {
CleanupTokens(tokens, numTokens);
return 0;
}
/* Token test[100];
test[0].type = ONE;
test[1].type = PLUS;
test[2].type = ONE;
test[3].type = DOLLAR;
// TreeNode *t = ParseScript(test, 4);
//*/
ParseTree *tree = ParseScript(tokens, numTokens);
if (!tree) {
return 0;
}
TempCode * tempCode = GenTempCode(tree);
CleanupTree(tree);
if (!tempCode) {
return 0;
}
if (!GenCode(tempCode, string, len, fileName)) {
return 0;
}
return 1;
}
void CleanupTree(ParseTree *t) {
if (t->val) free(t->val);
for (int i=0; i<t->numChildren; i++) {
if (t->children[i])
CleanupTree(t->children[i]);
}
free(t);
}
void CEquipmentLocationDialog::OnOK()
{
TBTreeStateMgr::SaveTreeState(_T("EquipmentLocation"),&m_ctlEquipmentTree);
CleanupTree();
m_ctlCarsList.SaveState("State","EquipmentLoocationDialog_m_ctlCarsList");
CDialog::OnOK();
}
ParseTree * ParseScript(Token *tokens, int numTokens) {
int i;
if (numTokens == 1) {
CleanupTokens(tokens, numTokens);
return 0;
}
if (!actionTable) {
int numSets = 0;
ItemSet **set = (ItemSet**) malloc(sizeof(ItemSet*)*1000);
ItemSet **newSets = (ItemSet**) malloc(sizeof(ItemSet*)*1000);
if (!set || !newSets) {
free(set);
free(newSets);
return 0;
}
int changed = 1;
int *followSets = (int*) calloc(1, PARSER_NONE * sizeof(int) * PARSER_NONE);
int *firstSets = (int*) calloc(1, PARSER_NONE * sizeof(int) * PARSER_NONE);
for (i=0; i<PARSER_SCRIPT; i++) {
firstSets[PARSER_NONE*i+i] = 1;
}
while (changed) {
changed = 0;
for (int r = 0; r<NUM_RULES; r++) {
int R = rules[r].result;
int F = rules[r].terms[0];
for (i=0; i<PARSER_NONE;i++) {
if (firstSets[F*PARSER_NONE+i] && !firstSets[R*PARSER_NONE+i]) {
firstSets[R*PARSER_NONE+i] = 1;
changed = 1;
}
}
}
}
changed = 1;
while (changed) {
changed = 0;
for (int r = 0; r<NUM_RULES; r++) {
for (int p=0; p<rules[r].numTerms-1; p++) {
ScriptTokenType F = rules[r].terms[p];
ScriptTokenType S = rules[r].terms[p+1];
for (i=0; i<PARSER_NONE;i++) {
if (firstSets[S*PARSER_NONE+i] && !followSets[F*PARSER_NONE+i]) {
followSets[F*PARSER_NONE+i] = 1;
changed = 1;
}
}
}
ScriptTokenType F = rules[r].terms[rules[r].numTerms-1];
ScriptTokenType S = rules[r].result;
for (i=0; i<PARSER_NONE;i++) {
if (followSets[S*PARSER_NONE+i] && !followSets[F*PARSER_NONE+i]) {
followSets[F*PARSER_NONE+i] = 1;
changed = 1;
}
}
}
}
set[numSets++] = (ItemSet *) malloc(sizeof(ItemSet));
set[0]->numItems = 1;
set[0]->items[0].position = 0;
set[0]->items[0].rule = 0;
int closureId = 0;
int closureNotes[sizeof(rules) / sizeof(Rule)];
for (i=0; i<sizeof(closureNotes)/sizeof(int);i++)
closureNotes[i] = -1;
//memset(closureNotes, -1, sizeof(closureNotes));
CalcClosure(&set[0], closureNotes, closureId++);
for (i=0; i<numSets; i++) {
int numNewSets = 0;
int j;
for (j=0; j<set[i]->numItems; j++) {
set[i]->items[j].transition = -1;
if (set[i]->items[j].position != rules[set[i]->items[j].rule].numTerms) {
int q;
for (q=0; q<numNewSets; q++) {
if (rules[set[i]->items[j].rule].terms[set[i]->items[j].position] == rules[newSets[q]->items[0].rule].terms[newSets[q]->items[0].position-1]) {
srealloc(newSets[q] , sizeof(ItemSet) + sizeof(Item) * newSets[q]->numItems);
break;
}
}
if (q==numNewSets) {
newSets[q] = (ItemSet*) malloc(sizeof(ItemSet));
newSets[q]->numItems = 0;
numNewSets++;
}
newSets[q]->items[newSets[q]->numItems].position = set[i]->items[j].position+1;
newSets[q]->items[newSets[q]->numItems].rule = set[i]->items[j].rule;
newSets[q]->items[newSets[q]->numItems].transition = j;
newSets[q]->numItems++;
}
}
for (j=0; j<numNewSets; j++) {
CalcClosure(&newSets[j], closureNotes, closureId++);
int q = 0;
for (q = 0; q<numSets; q++) {
int match = 0;
if (set[q]->numItems == newSets[j]->numItems)
while (match < newSets[j]->numItems) {
int f;
for (f = 0; f<set[q]->numItems; f++) {
if (set[q]->items[f].rule == newSets[j]->items[match].rule &&
set[q]->items[f].position == newSets[j]->items[match].position)
break;
}
if (f == set[q]->numItems) break;
match++;
}
if (match == newSets[j]->numItems) break;
}
for (int w=0; w<newSets[j]->numItems; w++)
if (newSets[j]->items[w].transition >= 0)
set[i]->items[newSets[j]->items[w].transition].transition = q;
if (q<numSets) {
free(newSets[j]);
}
else {
set[numSets++] = newSets[j];
}
}
}
free(newSets);
actionTable = (int*) malloc(sizeof(int) * numSets*PARSER_NONE);
for (i=numSets*PARSER_NONE-1; i>=0;i--) {
actionTable[i] = -1;
}
for (i=0; i<numSets; i++) {
int reduce = 0;
for (int w=0; w<set[i]->numItems; w++) {
if (set[i]->items[w].position < rules[set[i]->items[w].rule].numTerms) {
int term = rules[set[i]->items[w].rule].terms[set[i]->items[w].position];
if (actionTable[i*PARSER_NONE+term]>=0&& (actionTable[i*PARSER_NONE+term]&0xFFFFFF)-set[i]->items[w].transition !=0) {
i=i;
}
actionTable[i*PARSER_NONE+term] = set[i]->items[w].transition;
if (term < PARSER_SCRIPT) {
if (term != TOKEN_END)
actionTable[i*PARSER_NONE+term] |= SHIFT;
else
actionTable[i*PARSER_NONE+term] = ACCEPT;
}
/*
if (rules[set[i]->items[w].rule].terms[set[i]->items[w].position] < S) {
actionTable[i*PARSER_NONE+set[i]->items[w].rule] = set[i]->items[w].transition;
else
actionTable[i*PARSER_NONE+set[i]->items[w].rule] |= SHIFT;
}//*/
}
else {
/*if (reduce && reduce != set[i]->items[w].rule) {
reduce = reduce;
}
reduce = set[i]->items[w].rule;
//*/
reduce = set[i]->items[w].rule;
for (int x = 0; x<PARSER_SCRIPT; x++) {
if (followSets[rules[reduce].result*PARSER_NONE+x]) {
if (actionTable[x+i*PARSER_NONE] == -1) {
actionTable[x+i*PARSER_NONE] = REDUCE | reduce;
}
else {
i=i;
}
}
}
}
}
/*if (reduce) {
for (int w = 0; w<PARSER_SCRIPT; w++) {
if (actionTable[w+i*PARSER_NONE] == -1) {
actionTable[w+i*PARSER_NONE] = REDUCE | reduce;
}
}
}*/
}
free(followSets);
free(firstSets);
for (i=0; i<numSets; i++) {
free(set[i]);
}
free(set);
}
int maxStackSize = 1000;
int *stack = (int*) malloc(sizeof(int) * 1000);
//int output[1000];
stack[0] = 0;
//int outputLen = 0;
int stackSize = 1;
int pos = 0;
int accept = 0;
int ParseTrees = 0;
int maxParseTrees = 1000;
ParseTree **tree = (ParseTree**) malloc(sizeof(ParseTree*) * 1000);
int error = 0;
while (pos < numTokens && stackSize > 0) {
int row = stack[stackSize-1];
ScriptTokenType token = tokens[pos].type;
int i = actionTable[token+row*PARSER_NONE];
if (i==-1) {
if (pos && !tokens[pos].line) {
ParseError(tokens+pos-1);
}
else {
ParseError(tokens+pos);
}
error = 1;
break;
}
else if ((i&ACTION_MASK) == SHIFT) {
i &= ~SHIFT;
if (stackSize == maxStackSize) {
if (!srealloc(stack, sizeof(int) * (maxStackSize*=2))) {
ParseError(tokens+pos);
error = 1;
break;
}
}
if (ParseTrees == maxParseTrees) {
if (!srealloc(tree, sizeof(ParseTree*) * (maxParseTrees*=2))) {
ParseError(tokens+pos);
error = 1;
break;
}
}
stack[stackSize++] = i;
tree[ParseTrees] = (ParseTree*) calloc(1, sizeof(ParseTree));
if (!tree[ParseTrees]) {
ParseError(tokens+pos);
error = 1;
break;
}
{
tree[ParseTrees]->line = tokens[pos].line;
tree[ParseTrees]->pos = tokens[pos].pos;
tree[ParseTrees]->start = tokens[pos].start;
}
// Temporary node. Will be eaten by another.
tree[ParseTrees]->type = NODE_LEAF;
tree[ParseTrees]->numChildren = 0;
tree[ParseTrees]->intVal = tokens[pos].intVal;
tree[ParseTrees++]->val = tokens[pos].val;
tokens[pos].val = 0;
pos++;
}
else if ((i&ACTION_MASK) == REDUCE) {
i &= ~REDUCE;
// output[outputLen++] = i;
ParseTree *children[5] = {0,0,0,0,0};
int numChildren = 0;
int nline;
unsigned char *npos;
unsigned char *nstart;
for (int j = 0; j<rules[i].numTerms; j++) {
if (j == rules[i].operatorPos) {
nline = tree[ParseTrees - rules[i].numTerms+j]->line;
npos = tree[ParseTrees - rules[i].numTerms+j]->pos;
nstart = tree[ParseTrees - rules[i].numTerms+j]->start;
}
if (rules[i].terms[j] <= TOKEN_IDENTIFIER || rules[i].terms[j]>=TOKEN_END) {
children[numChildren++] = tree[ParseTrees - rules[i].numTerms+j];
}
else {
free(tree[ParseTrees - rules[i].numTerms+j]);
tree[ParseTrees - rules[i].numTerms+j] = 0;
}
}
ParseTrees -= rules[i].numTerms;
if (rules[i].nodeType == NODE_NONE) {
tree[ParseTrees] = children[0];
}
else {
if (numChildren && children[0]->type == NODE_LEAF) {
tree[ParseTrees] = children[0];
}
else {
tree[ParseTrees] = (ParseTree*) calloc(1, sizeof(ParseTree));
if (!tree[ParseTrees]) {
ParseError(tokens+pos);
error = 1;
break;
}
tree[ParseTrees]->children[0] = children[0];
}
tree[ParseTrees]->numChildren = numChildren;
tree[ParseTrees]->children[1] = children[1];
tree[ParseTrees]->children[2] = children[2];
tree[ParseTrees]->children[3] = children[3];
tree[ParseTrees]->children[4] = children[4];
tree[ParseTrees]->type = rules[i].nodeType;
}
tree[ParseTrees]->line = nline;
tree[ParseTrees]->pos = npos;
tree[ParseTrees]->start = nstart;
ParseTrees++;
stackSize -= rules[i].numTerms;
if (stackSize <= 0) {
ParseError(tokens+pos);
error = 1;
break;
}
else {
int w = rules[i].result;
int t = actionTable[stack[stackSize-1]*PARSER_NONE + w];
if (t >= 0 && t < 0x1000000) {
stack[stackSize++] = t;
}
else {
ParseError(tokens+pos);
error = 1;
break;
}
}
}
else if (i == ACCEPT) {
accept = 1;
break;
}
else {
ParseError(tokens+pos);
error = 1;
break;
}
}
free(stack);
CleanupTokens(tokens, numTokens);
if (error) {
for (int i=0; i<ParseTrees; i++) {
CleanupTree(tree[i]);
}
free(tree);
return 0;
}
ParseTree *out = tree[0];
free(tree);
return out;
}
/*
* Process Response files on the command line
* Returns true if it allocated a new argv array that must be freed later
*/
void ConsoleArgs::ProcessResponseArgs()
{
HRESULT hr;
b_tree *response_files = NULL;
WCHAR szFilename[MAX_PATH];
WCAllocBuffer textBuffer;
for (WStrList * listCurArg = m_listArgs;
listCurArg != NULL && !m_output->HadFatalError();
listCurArg = listCurArg->next)
{
WCHAR * szArg = listCurArg->arg;
// Skip everything except Response files
if (szArg == NULL || szArg[0] != '@')
continue;
if (wcslen(szArg) == 1) {
m_output->ShowErrorIdString( ERR_NoFileSpec, ERROR_ERROR, szArg);
goto CONTINUE;
}
// Check for duplicates
if (!GetFullFileName( RemoveQuotes(WCBuffer::CreateFrom(&szArg[1])), szFilename, false))
continue;
hr = TreeAdd(&response_files, szFilename);
if (hr == E_OUTOFMEMORY) {
m_output->ShowErrorId(FTL_NoMemory, ERROR_FATAL);
goto CONTINUE;
} else if (hr == S_FALSE) {
m_output->ShowErrorIdString(ERR_DuplicateResponseFile, ERROR_ERROR, szFilename);
goto CONTINUE;
}
FileType fileType;
textBuffer.Clear();
if (FAILED(hr = ReadTextFile(szFilename, NULL, textBuffer, &fileType)) || hr == S_FALSE)
{
if (hr == E_OUTOFMEMORY) {
m_output->ShowErrorId(FTL_NoMemory, ERROR_FATAL);
} else if (FAILED(hr)) {
if (fileType == ftBinary)
m_output->ShowErrorIdString(ERR_BinaryFile, ERROR_ERROR, szFilename);
else
m_output->ShowErrorIdString(ERR_OpenResponseFile, ERROR_ERROR, szFilename, m_output->ErrorHR(hr));
}
goto CONTINUE;
}
TextToArgs( textBuffer, &listCurArg->next);
CONTINUE: // remove the response file argument, and continue to the next.
listCurArg->arg = NULL;
VSFree(szArg);
}
CleanupTree(response_files);
}
