void OverlapIndexSubtermTreePrint(FILE* out, SubtermTree_p root)
{
SubtermOcc_p data;
if(root)
{
OverlapIndexSubtermTreePrint(out, root->lson);
data = root->key;
fprintf(out, "Node: %p data=%p\n", root, data);
fprintf(out, "Key: %ld = ", data->term->entry_no);
if(data->pl.pos.clauses)
{
ClauseTPos_p clause_tpos = data->pl.pos.clauses->key;
Clause_p clause = clause_tpos->clause;
if(clause->literals)
{
TermPrint(out, data->term, clause->literals->bank->sig, DEREF_ALWAYS);
}
fprintf(out, "\n");
OverlapIndexClauseTreePrint(out, data->pl.pos.clauses);
}
else
{
fprintf(out, "\nlson=%p, rson=%p\n\n", root->lson, root->rson);
}
OverlapIndexSubtermTreePrint(out, root->rson);
}
}
BOOL LibMain(
HANDLE hModule,
DWORD dwReason,
LPVOID lpRes)
{
switch (dwReason)
{
case ( DLL_THREAD_ATTACH ) :
{
//
// Threads can only enter the comdlg32 dll from the
// Get{Open,Save}FileName apis, so the TLS lpCurDir alloc is
// done inside the InitFileDlg routine in fileopen.c
//
return (TRUE);
break;
}
case ( DLL_THREAD_DETACH ) :
{
LPTSTR lpCurDir;
LPDWORD lpCurThread;
LPDWORD lpExtError;
if (lpCurDir = (LPTSTR)TlsGetValue(g_tlsiCurDir))
{
LocalFree(lpCurDir);
TlsSetValue(g_tlsiCurDir, NULL);
}
if (lpCurThread = (LPDWORD)TlsGetValue(g_tlsiCurThread))
{
LocalFree(lpCurThread);
TlsSetValue(g_tlsiCurThread, NULL);
}
if (lpExtError = (LPDWORD)TlsGetValue(g_tlsiExtError))
{
LocalFree(lpExtError);
TlsSetValue(g_tlsiExtError, NULL);
}
return (TRUE);
}
case ( DLL_PROCESS_ATTACH ) :
{
g_hinst = (HANDLE)hModule;
if (!FInitColor(g_hinst) || !FInitFile(g_hinst))
{
goto CantInit;
}
DisableThreadLibraryCalls(hModule);
//
// msgHELP is sent whenever a help button is pressed in one of
// the common dialogs (provided an owner was declared and the
// call to RegisterWindowMessage doesn't fail.
//
msgHELPA = RegisterWindowMessageA((LPSTR)szCommdlgHelpA);
msgHELPW = RegisterWindowMessageW((LPWSTR)szCommdlgHelpW);
//
// Need a semaphore locally for managing array of disk info.
//
InitializeCriticalSection(&g_csLocal);
//
// Need a semaphore for control access to CreateThread.
//
InitializeCriticalSection(&g_csNetThread);
//
// Need a semaphore for access to extended error info.
//
InitializeCriticalSection(&g_csExtError);
//
// Allocate a tls index for curdir so we can make it per-thread.
//
if ((g_tlsiCurDir = TlsAlloc()) == 0xFFFFFFFF)
{
StoreExtendedError(CDERR_INITIALIZATION);
goto CantInit;
}
//
// Allocate a tls index for curthread so we can give each a
// number.
//
if ((g_tlsiCurThread = TlsAlloc()) == 0xFFFFFFFF)
{
StoreExtendedError(CDERR_INITIALIZATION);
goto CantInit;
}
//
// Allocate a tls index for extended error.
//
if ((g_tlsiExtError = TlsAlloc()) == 0xFFFFFFFF)
{
StoreExtendedError(CDERR_INITIALIZATION);
goto CantInit;
}
dwNumDisks = 0;
//
// NetEnumBuf allocated in ListNetDrivesHandler.
//
cbNetEnumBuf = WNETENUM_BUFFSIZE;
hMPR = NULL;
hLNDEvent = NULL;
return (TRUE);
break;
}
case ( DLL_PROCESS_DETACH ) :
{
//
// We only want to do our clean up work if we are being called
// with freelibrary, not if the process is ending.
//
if (lpRes == NULL)
{
TermFile();
TermPrint();
TermColor();
TermFont();
TlsFree(g_tlsiCurDir);
TlsFree(g_tlsiCurThread);
TlsFree(g_tlsiExtError);
DeleteCriticalSection(&g_csLocal);
DeleteCriticalSection(&g_csNetThread);
DeleteCriticalSection(&g_csExtError);
}
return (TRUE);
break;
}
}
CantInit:
return (FALSE);
lpRes;
}
int main(int argc, const char **argv)
{
const char *grammarFilename = NULL;
const char *inputFilename = NULL;
char *grammarStr = NULL;
char *inputStr = NULL;
int useBuiltinGrammar = 0;
int showGrammar = 0;
int exprAsTree = 0;
Grammar *builtGrammar = NULL;
Term *inputTerm = NULL;
for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i],"-b") || !strcmp(argv[i],"--builtin"))
useBuiltinGrammar = 1;
else if (!strcmp(argv[i],"-g") || !strcmp(argv[i],"--grammar"))
showGrammar = 1;
else if (!strcmp(argv[i],"-e") || !strcmp(argv[i],"--exprtree"))
exprAsTree = 1;
else if (!strcmp(argv[i],"-h") || !strcmp(argv[i],"--help"))
usage();
else if ((strlen(argv[i]) > 1) && argv[i][0] == '-')
usage();
else if ((grammarFilename == NULL) && !useBuiltinGrammar)
grammarFilename = argv[i];
else if ((inputFilename == NULL) && !showGrammar)
inputFilename = argv[i];
else
usage();
}
Grammar *flatGrammar = GrammarNewBuiltin();
inputStr = maybeReadFile(inputFilename);
grammarStr = maybeReadFile(grammarFilename);
if (grammarStr != NULL) {
builtGrammar = grammarFromStr(flatGrammar,grammarFilename,grammarStr);
if (builtGrammar == NULL) {
fprintf(stderr,"Cannot build grammar\n");
exit(1);
}
}
Grammar *useGrammar = NULL;
if (useBuiltinGrammar)
useGrammar = flatGrammar;
else if (builtGrammar != NULL)
useGrammar = builtGrammar;
else
usage();
if (inputStr != NULL) {
const char *firstRuleName = GrammarFirstRuleName(useGrammar);
inputTerm = parse(useGrammar,firstRuleName,inputStr,0,strlen(inputStr));
if (inputTerm == NULL) {
fprintf(stderr,"%s: Parse failed\n",inputFilename);
exit(1);
}
}
if (showGrammar) {
GrammarPrint(useGrammar,exprAsTree);
}
else if (inputTerm != NULL) {
TermPrint(inputTerm,inputStr,"");
}
else {
usage();
}
free(grammarStr);
free(inputStr);
GrammarFree(flatGrammar);
if (builtGrammar != NULL)
GrammarFree(builtGrammar);
return 0;
}
