/*------------------------------------------------------------------
* main program
*------------------------------------------------------------------*/
int main(
int argc,
char *argv[]
)
{
int i;
char dateStr[30];
struct tm *tm;
time_t t;
char *origParms;
/*---------------------------------------------------------------
* check for help
*---------------------------------------------------------------*/
if ((1 == argc) || ('?' == *(argv[1])))
Usage();
/*---------------------------------------------------------------
* get original parms
*---------------------------------------------------------------*/
origParms = malloc(1);
*origParms = 0;
for (i=0; i<argc; i++)
{
origParms = realloc(origParms,2 + strlen(origParms) + strlen(argv[i]));
strcat(origParms," ");
strcat(origParms,argv[i]);
}
/*---------------------------------------------------------------
* zero out info
*---------------------------------------------------------------*/
memset(&info,0,sizeof(info));
/*---------------------------------------------------------------
* get options
*---------------------------------------------------------------*/
GetOptions(&argc,argv,&info);
/*---------------------------------------------------------------
* buffer output
*---------------------------------------------------------------*/
/* setvbuf(info.oFile,NULL,_IOFBF,32000); */
/*---------------------------------------------------------------
* put filenames in a list
*---------------------------------------------------------------*/
info.fileList = ListCreate(sizeof(File),
(ListCompareFunc *)FileNameCompare,
cPostNoMem);
if (!info.fileList)
cPostError(1,"error creating list of files");
for (i=1; i<argc; i++)
FileSpecAdd(&info,info.fileList,argv[i]);
/*---------------------------------------------------------------
* check for no files to process
*---------------------------------------------------------------*/
if (!ListCount(info.fileList))
cPostError(1,"no files to process");
/*---------------------------------------------------------------
* intialize rest of info structure
*---------------------------------------------------------------*/
info.funcTree = ListCreate(sizeof(Function),
(ListCompareFunc *)FunctionNameCompare,
cPostNoMem);
if (!info.fileList)
cPostError(1,"error creating list of functions");
info.identHash = HashCreate(sizeof(char *),
1000,
(HashFunc *)IdentHash,
(ListCompareFunc *)IdentCompare,
cPostNoMem);
if (!info.identHash)
cPostError(1,"error creating global hash table");
/*---------------------------------------------------------------
* setup error termination processing
*---------------------------------------------------------------*/
atexit(RunAtExit);
signal(SIGINT, SignalHandler);
signal(SIGTERM, SignalHandler);
#if defined(OPSYS_OS2) || defined(OPSYS_OS2V2)
signal(SIGBREAK,SignalHandler);
#endif
/*---------------------------------------------------------------
* print header
*---------------------------------------------------------------*/
fprintf(info.oFile,"%%! PostScript file generated by %s %s\n\n",
PROGRAM_NAME,PROGRAM_VERS);
/*------------------------------------------------------------------
* a macro to write a line to the output file
*------------------------------------------------------------------*/
#define p(x) fprintf(info.oFile,"%s\n",x);
/*---------------------------------------------------------------
* write command line and environment variable setting
*---------------------------------------------------------------*/
#if defined(ECHO_COMMAND_LINE)
{
p("%%-----------------------------------------------------------------")
fprintf(info.oFile,"%%%% this file created with the command:\n");
fprintf(info.oFile,"%%%% %s\n",origParms);
fprintf(info.oFile,"%%%% the CPOST environment variable ");
if (!getenv(PROGRAM_ENVV))
fprintf(info.oFile,"is not set.\n");
else
{
fprintf(info.oFile,"is set to:\n");
fprintf(info.oFile,"%%%% %s\n",getenv(PROGRAM_ENVV));
}
p("%%-----------------------------------------------------------------")
p("");
}
#endif
/*---------------------------------------------------------------
* write wrapper prefix
*---------------------------------------------------------------*/
if (info.oWrapB && strlen(info.oWrapB))
processImbedFile(info.oWrapB);
/*---------------------------------------------------------------
* get the time
*---------------------------------------------------------------*/
t = time(NULL);
tm = localtime(&t);
strftime(dateStr,sizeof(dateStr)-1,"%m/%d/%y %H:%M:%S",tm);
p("%%-----------------------------------------------------------------")
p("%% runtime options and values")
p("%%-----------------------------------------------------------------")
p("")
fprintf(info.oFile,"/printDate (%s) def\n",dateStr);
fprintf(info.oFile,"/oSpace %d def\n",info.oSpace);
fprintf(info.oFile,"/oXlate { %d %d translate } def\n",info.oXlateX,info.oXlateY);
fprintf(info.oFile,"/oDuplex 1 %d eq def\n",info.oDuplex);
fprintf(info.oFile,"/oNumber 0 %d ne def\n",info.oSpace);
p("")
/*---------------------------------------------------------------
* write replaced header ...
*---------------------------------------------------------------*/
if (info.oRepHdr && strlen(info.oRepHdr))
{
processImbedFile(info.oImbed);
p("");
processImbedFile(info.oRepHdr);
p("");
}
/*---------------------------------------------------------------
* or default stuff
*---------------------------------------------------------------*/
else
{
for (i=0; i< sizeof(Header_1)/sizeof(char *); i++)
p(Header_1[i]);
p("");
processImbedFile(info.oImbed);
p("");
for (i=0; i< sizeof(Header_2)/sizeof(char *); i++)
p(Header_2[i]);
p("");
}
/*---------------------------------------------------------------
* read the files. make copies
*---------------------------------------------------------------*/
fprintf(stderr,"Pass 1\n");
ListIterate(info.fileList,(ListIterateFunc *)Pass1,&info);
/*---------------------------------------------------------------
* read the copies. write the output file
*---------------------------------------------------------------*/
fprintf(stderr,"Pass 2\n");
ListIterate(info.fileList,(ListIterateFunc *)Pass2,&info);
/*---------------------------------------------------------------*
* print trailing line feed
*---------------------------------------------------------------*/
fprintf(info.oFile,"\n");
/*---------------------------------------------------------------
* write wrapper suffix
*---------------------------------------------------------------*/
if (info.oWrapA && strlen(info.oWrapA))
processImbedFile(info.oWrapA);
/*---------------------------------------------------------------
* close file (another line feed for luck!)
*---------------------------------------------------------------*/
fprintf(info.oFile,"\n");
fclose(info.oFile);
AllDone = 1;
return 0;
}
static void
InteractDoneProc(SmsConn smsConn, SmPointer managerData, Bool cancelShutdown)
{
ClientRec *client = (ClientRec *) managerData;
List *cl;
if (verbose)
{
printf (
"Client Id = %s, received INTERACT DONE [Cancel Shutdown = %s]\n",
client->clientId, cancelShutdown ? "True" : "False");
}
if (cancelShutdown)
{
ListFreeAllButHead (WaitForInteractList);
ListFreeAllButHead (WaitForPhase2List);
}
if (cancelShutdown)
{
if (shutdownCancelled)
{
/* Shutdown was already cancelled */
return;
}
shutdownCancelled = True;
for (cl = ListFirst (RunningList); cl; cl = ListNext (cl))
{
client = (ClientRec *) cl->thing;
SmsShutdownCancelled (client->smsConn);
if (verbose)
{
printf ("Client Id = %s, sent SHUTDOWN CANCELLED\n",
client->clientId);
}
}
}
else
{
if ((cl = ListFirst (WaitForInteractList)) != NULL)
{
LetClientInteract (cl);
}
else
{
if (verbose)
{
printf ("\n");
printf ("Done interacting with all clients.\n");
printf ("\n");
}
if (ListCount (WaitForPhase2List) > 0)
{
StartPhase2 ();
}
}
}
}
static Bool
OkToEnterPhase2(void)
{
return (ListCount (WaitForPhase2List) == ListCount (WaitForSaveDoneList));
}
void
CloseDownClient(ClientRec *client)
{
int index_deleted = 0;
if (verbose) {
printf ("ICE Connection closed, IceConn fd = %d\n",
IceConnectionNumber (client->ice_conn));
printf ("\n");
}
SmsCleanUp (client->smsConn);
IceSetShutdownNegotiation (client->ice_conn, False);
IceCloseConnection (client->ice_conn);
client->ice_conn = NULL;
client->smsConn = NULL;
if (!shutdownInProgress && client_info_visible)
{
for (index_deleted = 0;
index_deleted < numClientListNames; index_deleted++)
{
if (clientListRecs[index_deleted] == client)
break;
}
}
ListSearchAndFreeOne (RunningList, (char *) client);
if (saveInProgress)
{
Status delStatus = ListSearchAndFreeOne (
WaitForSaveDoneList, (char *) client);
if (delStatus)
{
ListAddLast (FailedSaveList, (char *) client);
client->freeAfterBadSavePopup = True;
}
ListSearchAndFreeOne (WaitForInteractList, (char *) client);
ListSearchAndFreeOne (WaitForPhase2List, (char *) client);
if (delStatus && ListCount (WaitForSaveDoneList) == 0)
{
if (ListCount (FailedSaveList) > 0 && !checkpoint_from_signal)
PopupBadSave ();
else
FinishUpSave ();
}
else if (ListCount (WaitForInteractList) > 0 &&
OkToEnterInteractPhase ())
{
LetClientInteract (ListFirst (WaitForInteractList));
}
else if (!phase2InProgress &&
ListCount (WaitForPhase2List) > 0 && OkToEnterPhase2 ())
{
StartPhase2 ();
}
}
if (client->restartHint == SmRestartImmediately && !shutdownInProgress)
{
Clone (client, True /* use saved state */);
ListAddLast (RestartImmedList, (char *) client);
}
else if (client->restartHint == SmRestartAnyway)
{
ListAddLast (RestartAnywayList, (char *) client);
}
else if (!client->freeAfterBadSavePopup)
{
FreeClient (client, True /* free props */);
}
if (shutdownInProgress)
{
if (ListCount (RunningList) == 0)
EndSession (0);
}
else if (client_info_visible)
{
UpdateClientList ();
if (current_client_selected == index_deleted)
{
if (current_client_selected == numClientListNames)
current_client_selected--;
if (current_client_selected >= 0)
{
XawListHighlight (clientListWidget, current_client_selected);
ShowHint (clientListRecs[current_client_selected]);
if (client_prop_visible)
{
DisplayProps (clientListRecs[current_client_selected]);
}
}
}
else
{
if (index_deleted < current_client_selected)
current_client_selected--;
XawListHighlight (clientListWidget, current_client_selected);
}
}
}
static Bool
OkToEnterInteractPhase(void)
{
return ((ListCount (WaitForInteractList) +
ListCount (WaitForPhase2List)) == ListCount (WaitForSaveDoneList));
}
static INT_PTR LinkList_Main(WPARAM wParam, LPARAM)
{
HANDLE hContact = (HANDLE)wParam;
HWND hWnd = WindowList_Find(hWindowList, hContact);
if ( hWnd != NULL ) {
int len;
SetForegroundWindow(hWnd);
SetFocus(hWnd);
len = GetWindowTextLength(GetDlgItem(hWnd, IDC_MAIN));
PostMessage(GetDlgItem(hWnd, IDC_MAIN), EM_SETSEL, (WPARAM)len, (LPARAM)len);
return 0;
}
HANDLE hEvent = db_event_first(hContact);
if (hEvent == NULL) {
MessageBox(NULL, TXT_EMPTYHISTORY, TXT_PLUGINNAME, MB_OK | MB_ICONINFORMATION );
return 0;
}
int histCount = db_event_count(hContact), actCount = 0;
DBEVENTINFO dbe = { sizeof(dbe) };
dbe.cbBlob = db_event_getBlobSize(hEvent);
dbe.pBlob = (PBYTE)malloc(dbe.cbBlob+1);
db_event_get(hEvent, &dbe);
dbe.pBlob[dbe.cbBlob] = 0;
RECT DesktopRect;
GetWindowRect(GetDesktopWindow(), &DesktopRect);
HWND hWndProgress = CreateWindow(_T("Progressbar"), TranslateT("Processing history..."), WS_OVERLAPPED, CW_USEDEFAULT, CW_USEDEFAULT, 350, 45, NULL, NULL, hInst, NULL);
if ( hWndProgress == 0 ) {
free(dbe.pBlob);
MessageBox(NULL, TranslateT("Could not create window!"), TranslateT("Error"), MB_OK | MB_ICONEXCLAMATION );
return -1;
}
SetWindowPos(hWndProgress, HWND_TOP, (int)(DesktopRect.right*0.5)-175, (int)(DesktopRect.bottom*0.5)-22, 0, 0, SWP_NOSIZE);
ShowWindow(hWndProgress, SW_SHOW);
SetForegroundWindow(hWndProgress);
LISTELEMENT *listStart = (LISTELEMENT*)malloc(sizeof(LISTELEMENT));
ZeroMemory(listStart, sizeof(LISTELEMENT));
while( 1 ) {
if ( dbe.eventType == EVENTTYPE_URL || dbe.eventType == EVENTTYPE_MESSAGE ) {
// Call function to find URIs
if ( ExtractURI(&dbe, hEvent, listStart) < 0 ) {
free(dbe.pBlob);
RemoveList(listStart);
MessageBox(NULL, TranslateT("Could not allocate memory!"), TranslateT("Error"), MB_OK | MB_ICONEXCLAMATION);
return -1;
}
}
actCount++;
if ( ((int)(((float)actCount/histCount)*100.00)) % 10 == 0 )
SendMessage(hWndProgress, WM_COMMAND, 100, ((int)(((float)actCount/histCount)*100.00)));
hEvent = db_event_next(hEvent);
if ( hEvent == NULL )
break;
free(dbe.pBlob);
dbe.cbBlob = db_event_getBlobSize(hEvent);
dbe.pBlob = (PBYTE)malloc(dbe.cbBlob+1);
db_event_get(hEvent, &dbe);
dbe.pBlob[dbe.cbBlob] = 0;
}
free(dbe.pBlob);
SendMessage(hWndProgress, WM_CLOSE, 0, 0);
if ( ListCount(listStart) <= 0 ) {
RemoveList(listStart);
MessageBox(NULL, TXT_NOLINKINHISTORY, TXT_PLUGINNAME, MB_OK | MB_ICONINFORMATION);
return 0;
}
DIALOGPARAM *DlgParam = (DIALOGPARAM*)malloc(sizeof(DIALOGPARAM));
DlgParam->hContact = hContact;
DlgParam->listStart = listStart;
DlgParam->findMessage = 0;
DlgParam->chrg.cpMax = -1;
DlgParam->chrg.cpMin = -1;
HWND hWndMain = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_MAIN_DLG), NULL, MainDlgProc, (LPARAM)DlgParam);
if (hWndMain == 0) {
RemoveList(listStart);
MessageBox(NULL, TranslateT("Could not create window!"), TranslateT("Error"), MB_OK | MB_ICONEXCLAMATION );
return -1;
}
ShowWindow(hWndMain, SW_SHOW);
return 0;
}
int ListHubs(List **list)
{
AvahiClient *client = NULL;
AvahiServiceBrowser *sb = NULL;
int error;
hublist = ListNew(&CompareHosts, NULL, &free);
if (!hublist)
{
return -1;
}
spoll = NULL;
avahi_handle = NULL;
RegisterAtExitFunction(&AtExitDlClose);
if (loadavahi() == -1)
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Avahi was not found");
return -1;
}
if (!(spoll = avahi_simple_poll_new_ptr()))
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Failed to create simple poll object.");
if (spoll)
{
avahi_simple_poll_free_ptr(spoll);
}
return -1;
}
client = avahi_client_new_ptr(avahi_simple_poll_get_ptr(spoll), 0, client_callback, NULL, &error);
if (!client)
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Failed to create client %s", avahi_strerror_ptr(error));
if (client)
{
avahi_client_free_ptr(client);
}
if (spoll)
{
avahi_simple_poll_free_ptr(spoll);
}
return -1;
}
if (!(sb = avahi_service_browser_new_ptr(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_cfenginehub._tcp", NULL, 0, browse_callback, client)))
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Failed to create service browser: %s", avahi_strerror_ptr(avahi_client_errno_ptr(client)));
if (spoll)
{
avahi_simple_poll_free_ptr(spoll);
}
if (client)
{
avahi_client_free_ptr(client);
}
if (sb)
{
avahi_service_browser_free_ptr(sb);
}
return -1;
}
avahi_simple_poll_loop_ptr(spoll);
if (sb)
avahi_service_browser_free_ptr(sb);
if (client)
avahi_client_free_ptr(client);
if (spoll)
avahi_simple_poll_free_ptr(spoll);
*list = hublist;
return ListCount(*list);
}
//-----------------------------------------------------------------------------
int main(int argc, char *argv[]) {
LISTNODE Head;
LISTNODE AnotherHead;
ROOTLIST RootListHead;
String PutNamesHere;
String CurrentFileName;
SIGNATURE Signature;
ANNOTATEDFORMULA AnnotatedFormula;
ANNOTATEDFORMULA AnotherAnnotatedFormula;
ANNOTATEDFORMULA DuplicatedAnnotatedFormula;
FORMULA Literal;
FORMULA AnotherLiteral;
String SomeString;
char * SymbolUsage;
char * AnotherSymbolUsage;
char * VariablesStartHere;
int SymbolUsageLength = STRINGLENGTH;
int VarCount,QuantCount;
StatusType SubStatus;
TERM ANewTerm;
int Positive,Negative;
READFILE Stream;
ListStatisticsRecordType ListStatistics;
int Universals,Existentials;
int NumberRemoved;
ContextType Context;
LISTNODE Axioms;
LISTNODE Conjectures;
LISTNODE Target;
String FormulaName;
String OutputFileName;
int Result;
BTREENODE BTreeRoot;
BTREENODE * SearchResult;
TERMArray ArrayOfInfoTERMs;
int NumberOfTerms;
int Index;
SZSResultType SZS1,SZS2;
SZSOutputType SZSO1,SZSO2;
//----One signature for all testing
Signature = NewSignature();
//----Read from file or stdin
SetNeedForNonLogicTokens(1);
SetAllowFreeVariables(0);
//----Test duplicate arity warnings
SetWarnings(1);
if (argc > 1) {
Head = ParseFileOfFormulae(argv[1],NULL,Signature,1,NULL);
} else {
Head = ParseFILEOfFormulae(stdin,Signature,1,NULL);
}
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//-----------------------------------------------------------------------------
//----Test comparison of first two formula for being the same
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,1);
AnotherAnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,2);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
PrintAnnotatedTSTPNode(stdout,AnotherAnnotatedFormula,tptp,1);
if (SameFormulaInAnnotatedFormulae(AnnotatedFormula,
AnotherAnnotatedFormula,0,1)) {
printf("They are identical\n");
} else {
if (SameFormulaInAnnotatedFormulae(AnnotatedFormula,
AnotherAnnotatedFormula,1,1)) {
printf("They are renamings\n");
} else {
printf("They are quite different\n");
}
}
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test list duplication
AnotherHead = DuplicateListOfAnnotatedFormulae(Head,Signature);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,AnotherHead,tptp,1);
FreeListOfAnnotatedFormulae(&Head);
FreeListOfAnnotatedFormulae(&AnotherHead);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test reading header
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
SetNeedForNonLogicTokens(1);
Head = ParseFileOfHeader(argv[1]);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
FreeListOfAnnotatedFormulae(&Head);
return(EXIT_SUCCESS);
//----Test building root list
RootListHead = BuildRootList(Head);
PrintRootList(stdout,RootListHead);
FreeRootList(&RootListHead,1);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test randomization
RandomizeListOfAnnotatedFormulae(&Head,1);
printf("------------ Randomized ---------------\n");
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test getting root list
PrintListOfAnnotatedTSTPNodes(stdout,Signature,GetRootList(Head),tptp,1);
return(EXIT_SUCCESS);
//----Test vine of lemmas extraction
printf("---- Vine of lemmas ---\n");
RootListHead = BuildRootList(Head);
PrintRootList(stdout,RootListHead);
if (GetRootLemmaList(RootListHead->TheTree,&Axioms,0)) {
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Axioms,tptp,1);
FreeListOfAnnotatedFormulae(&Axioms);
} else {
printf("Could not extract vine of axioms\n");
}
FreeRootList(&RootListHead,1);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test dequoting
PrintSignature(Signature);
printf("---- Dequote ---\n");
DequoteSymbolsInSignature(Signature);
PrintSignature(Signature);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test aritizing
PrintSignature(Signature);
printf("---- Aritize ---\n");
AritizeSymbolsInSignature(Signature);
PrintSignature(Signature);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test expanding assumptions
printf("---- Expand assumptions ---\n");
ExpandListAssumptions(Head,Signature);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test formula duplication
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,1);
if (AnnotatedFormula != NULL) {
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
PrintVariableList(AnnotatedFormula->
AnnotatedFormulaUnion.AnnotatedTSTPFormula.FormulaWithVariables->Variables,
NULL);
PrintSignature(Signature);
DuplicatedAnnotatedFormula = DuplicateAnnotatedFormula(AnnotatedFormula,
Signature);
PrintAnnotatedTSTPNode(stdout,DuplicatedAnnotatedFormula,tptp,1);
PrintVariableList(DuplicatedAnnotatedFormula->
AnnotatedFormulaUnion.AnnotatedTSTPFormula.FormulaWithVariables->Variables,
NULL);
PrintSignature(Signature);
} else {
printf("Could not get formula dv\n");
}
return(EXIT_SUCCESS);
//----Test uninterpreting of integers
UninterpretIntegersInSignature(Signature);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
exit(EXIT_SUCCESS);
//----Test getting inference rule
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,1);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
if ((SymbolUsage = GetSource(AnnotatedFormula)) != NULL) {
printf("The source is ==%s==\n",SymbolUsage);
Free((void **)&SymbolUsage);
}
if ((SymbolUsage = GetSourceTerm(AnnotatedFormula,NULL)) != NULL) {
printf("The source term is ==%s==\n",SymbolUsage);
Free((void **)&SymbolUsage);
}
if ((SymbolUsage = GetInferenceRule(AnnotatedFormula,NULL)) != NULL) {
printf("The inference rule is ==%s==\n",SymbolUsage);
Free((void **)&SymbolUsage);
}
if ((SymbolUsage = GetParentNames(AnnotatedFormula,NULL)) != NULL) {
printf("The parents are ==%s==\n",SymbolUsage);
Free((void **)&SymbolUsage);
}
if ((SymbolUsage = GetSourceInfoTerm(AnnotatedFormula,"introduced","status",
NULL)) != NULL) {
printf("The status term is %s\n",SymbolUsage);
Free((void **)&SymbolUsage);
}
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test getting nested inference info
PrintAnnotatedTSTPNode(stdout,Head->AnnotatedFormula,tptp,1);
NumberOfTerms = 0;
ArrayOfInfoTERMs = GetInferenceInfoTERMs(Head->AnnotatedFormula,"assumptions",
&NumberOfTerms);
for (Index = 0; Index < NumberOfTerms; Index++) {
PrintTSTPTerm(stdout,ArrayOfInfoTERMs[Index],-1,1);
printf("\n");
}
if (ArrayOfInfoTERMs != NULL) {
Free((void **)&ArrayOfInfoTERMs);
}
return(EXIT_SUCCESS);
//----Test getting file source
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,1);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
if (GetSource(AnnotatedFormula) != NULL) {
printf("The source is %s\n",SomeString);
if ((SymbolUsage = GetFileSourceNameAndNode(AnnotatedFormula,NULL)) !=
NULL) {
printf("The file and node are %s\n",SymbolUsage);
Free((void **)&SymbolUsage);
} else {
printf("No file and node\n");
}
} else {
printf("No source for file and node\n");
}
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
exit(EXIT_SUCCESS);
//----Test useful info manipulation
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,1);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
AddUsefulInformationToAnnotatedFormula(AnnotatedFormula,Signature,
"useful(1)");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
AddUsefulInformationToAnnotatedFormula(AnnotatedFormula,Signature,
"useful([2,two,2],2-two)");
AddUsefulInformationToAnnotatedFormula(AnnotatedFormula,Signature,
"useful(3)");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
if ((SymbolUsage = GetUsefulInfoTerm(AnnotatedFormula,"useful",2,NULL)) !=
NULL) {
printf("The second useful term is %s\n",SymbolUsage);
Free((void **)&SymbolUsage);
}
UpdateUsefulInformationInAnnotatedFormula(AnnotatedFormula,Signature,
"useful(4)");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
AddUsefulInformationToAnnotatedFormula(AnnotatedFormula,Signature,
"useful(5)");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
RemoveUsefulInformationFromAnnotatedFormula(AnnotatedFormula,Signature,
"useful");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test sorting by useful info
SortByUsefulInfoField(&Head,"sortby",'f',0);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
exit(EXIT_SUCCESS);
//----Test binary trees
printf("---- Binary tree ----\n");
BTreeRoot = ListToBTree(Head);
PrintBTreeOfAnnotatedFormulae(BTreeRoot);
printf("---- Search for %s\n","pel55_5");
if ((SearchResult = GetNodeFromBTreeByAnnotatedFormulaName(&BTreeRoot,
"pel55_5")) == NULL) {
printf("Not found\n");
} else {
PrintAnnotatedTSTPNode(stdout,(*SearchResult)->AnnotatedFormula,tptp,1);
}
FreeBTreeOfAnnotatedFormulae(&BTreeRoot);
assert(BTreeRoot == NULL);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test negation or universal fofify
FOFifyList(Head,universal);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
PrintSignature(Signature);
return(EXIT_SUCCESS);
//----Look at the signature
PrintSignature(Signature);
FreeListOfAnnotatedFormulae(&Head);
FreeSignature(&Signature);
return(EXIT_SUCCESS);
//----Test external processing
AnotherHead = ApplyExternalProgram(Head,axiom,NULL,"cat %s",Signature);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,AnotherHead,tptp,1);
exit(EXIT_SUCCESS);
//----Test set relationships
AnotherHead = ParseFileOfFormulae(argv[2],NULL,Signature,1,NULL);
printf("-------------------\n");
PrintListOfAnnotatedTSTPNodes(stdout,Signature,AnotherHead,tptp,1);
printf("===================\n");
Head = MergeInListOfAnnotatedFormulaeByFields(&Head,&AnotherHead,1,0,1);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,tptp,1);
printf("-------------------\n");
PrintListOfAnnotatedTSTPNodes(stdout,Signature,AnotherHead,tptp,1);
exit(EXIT_SUCCESS);
//----Test getting by name
AnnotatedFormula = GetAnnotatedFormulaFromListByName(Head,"freddy");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
exit(EXIT_SUCCESS);
//----Testing redirected printing
PrintStringAnnotatedTSTPNode(SomeString,Head->AnnotatedFormula,tptp,1);
printf("==%s==\n",SomeString);
exit(EXIT_SUCCESS);
//----Test negation
AnnotatedFormula = Head->AnnotatedFormula;
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
if (DeDoubleNegate(AnnotatedFormula)) {
printf("Dedouble negated\n");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
}
Negate(AnnotatedFormula,1);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
return(EXIT_SUCCESS);
//----Test selection of nodes with status
Axioms = GetListOfAnnotatedFormulaeWithType(Head,axiom_like);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Axioms,tptp,1);
return(EXIT_SUCCESS);
//----Test use of SystemOnTPTP
if (SystemOnTPTPAvailable()) {
Axioms = GetListOfAnnotatedFormulaeWithType(Head,axiom_like);
printf("Axioms are ...\n");
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Axioms,tptp,1);
Conjectures = GetListOfAnnotatedFormulaeWithType(Head,conjecture);
Target = Conjectures;
while (Target != NULL) {
printf("Trying to prove %s\n",GetName(Target->AnnotatedFormula,
FormulaName));
// strcpy(OutputFileName,FormulaName);
// strcat(OutputFileName,".result");
// Result = SystemOnTPTP(Axioms,Conjectures->AnnotatedFormula,
//"E---0.9","Theorem",1,"Paradox---1.3","CounterTheorem",30,">>",1,"",
//OutputFileName,OutputFileName);
Result = SystemOnTPTP(Axioms,Conjectures->AnnotatedFormula,
"E---0.9","Theorem",1,"Paradox---1.3","CounterTheorem",30,"",1,"/tmp","output",
OutputFileName);
// Result = SystemOnTPTP(Axioms,Conjectures->AnnotatedFormula,
//"E---0.9","Theorem",1,"Paradox---1.3","CounterTheorem",30,"",0,NULL,NULL,NULL);
printf("The output file name is %s\n",OutputFileName);
switch (Result) {
case 1:
printf("%s is a theorem\n",FormulaName);
break;
case -1:
printf("%s is not a theorem\n",FormulaName);
break;
case 0:
printf("%s is unknown\n",FormulaName);
break;
default:
CodingError("SystemOnTPTP returned something weird");
break;
}
Target = Target->Next;
}
FreeListOfAnnotatedFormulae(&Axioms);
FreeListOfAnnotatedFormulae(&Conjectures);
}
return(EXIT_SUCCESS);
//----Test freeing
PrintSignature(Signature);
FreeListOfAnnotatedFormulae(&Head);
assert(Head == NULL);
PrintSignature(Signature);
RemovedUnusedSymbols(Signature);
printf("REMOVED THE UNUSED\n");
fflush(stdout);
PrintSignature(Signature);
FreeSignature(&Signature);
assert(Signature == NULL);
return(EXIT_SUCCESS);
//----Test Foreign output
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,dfg,1);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,kif,1);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,otter,1);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,Head,xml,1);
return(EXIT_SUCCESS);
//----Test read-free alternation
SetNeedForNonLogicTokens(0);
if ((Stream = OpenReadFile(argv[1],CurrentFileName)) == NULL) {
printf("Can't open file %s\n",argv[1]);
return(EXIT_FAILURE);
}
while (!CheckTokenType(Stream,endeof)) {
printf("Start ------------------\n");
AnnotatedFormula = ParseAndUseAnnotatedFormula(Stream,Signature);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
PrintSignature(Signature);
printf("Free ------------------\n");
FreeAnnotatedFormula(&AnnotatedFormula);
PrintSignature(Signature);
printf("End ------------------\n");
}
CloseReadFile(Stream);
return(EXIT_SUCCESS);
//----Test signature iterator
PrintSignatureTree(Signature->Predicates);
printf("===========\n");
ListSignatureBySearch(Signature->Predicates);
return(EXIT_SUCCESS);
//----Test freeing
PrintSignature(Signature);
FreeListOfAnnotatedFormulae(&Head);
assert(Head == NULL);
PrintSignature(Signature);
RemovedUnusedSymbols(Signature);
printf("REMOVED THE UNUSED\n");
fflush(stdout);
PrintSignature(Signature);
FreeSignature(&Signature);
assert(Signature == NULL);
return(EXIT_SUCCESS);
//----Test getting symbol usage in general
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,1);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
SymbolUsage = (char *)Malloc(sizeof(String));
if (GetAnnotatedFormulaSymbolUsage(AnnotatedFormula,&SymbolUsage,
&AnotherSymbolUsage) != NULL) {
printf("The total symbol usage is \n%s and the functors are \n%s\n",
SymbolUsage,AnotherSymbolUsage);
} else {
printf("No total symbol usage collected\n");
}
Free((void **)&SymbolUsage);
return(EXIT_SUCCESS);
//----Test internal formula copying
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,1);
if (AnnotatedFormula != NULL) {
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
PrintVariableList(AnnotatedFormula->
AnnotatedFormulaUnion.AnnotatedTSTPFormula.FormulaWithVariables->Variables,
NULL);
PrintSignature(Signature);
Literal = AnnotatedFormula->AnnotatedFormulaUnion.AnnotatedTSTPFormula.FormulaWithVariables->Formula->FormulaUnion.QuantifiedFormula.Formula->FormulaUnion.BinaryFormula.LHS;
Context.Signature = Signature;
Context.Variables = &(AnnotatedFormula->AnnotatedFormulaUnion.AnnotatedTSTPFormula.FormulaWithVariables->Variables);
AnotherLiteral = DuplicateInternalFormulaWithVariables(
Literal,Context);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
printf("duplicate is ...\n");
PrintTSTPFormula(stdout,AnnotatedFormula->Syntax,AnotherLiteral,0,1,
outermost,0);
printf("\n");
PrintVariableList(AnnotatedFormula->
AnnotatedFormulaUnion.AnnotatedTSTPFormula.FormulaWithVariables->Variables,
NULL);
PrintSignature(Signature);
} else {
printf("Could not get first formula\n");
}
return(EXIT_SUCCESS);
//----Test variable counting
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,1);
if (AnnotatedFormula != NULL) {
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,0);
VarCount = CountVariableUsageInFormula(AnnotatedFormula->
AnnotatedFormulaUnion.AnnotatedTSTPFormula.FormulaWithVariables->Formula,
AnnotatedFormula->AnnotatedFormulaUnion.AnnotatedTSTPFormula.
FormulaWithVariables->Variables,&QuantCount);
printf("First variable occurs %d times, plus quantified %d times\n",
VarCount,QuantCount);
} else {
printf("Could not get first formula\n");
}
return(EXIT_SUCCESS);
//----Test getting parents' names
if (AnnotatedFormula != NULL) {
printf("Parents are\n%s\n",GetParentNames(AnnotatedFormula,
PutNamesHere));
} else {
printf("Formula of that name not found\n");
}
return(EXIT_SUCCESS);
//----Test removal of vacuous quantifiers
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,1);
if (AnnotatedFormula != NULL) {
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,0);
PrintVariableList(AnnotatedFormula->
AnnotatedFormulaUnion.AnnotatedTSTPFormula.FormulaWithVariables->Variables,
NULL);
PrintSignature(Signature);
NumberRemoved = RemoveVacuousQuantifiersFromAnnotatedFormula(
AnnotatedFormula);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
PrintVariableList(AnnotatedFormula->
AnnotatedFormulaUnion.AnnotatedTSTPFormula.FormulaWithVariables->Variables,
NULL);
PrintSignature(Signature);
printf("%d removed\n",NumberRemoved);
} else {
printf("Could not get first formula\n");
}
return(EXIT_SUCCESS);
//----Test uniqueify variable names
AnnotatedFormula = GetAnnotatedFormulaFromListByName(Head,"dv");
if (AnnotatedFormula != NULL) {
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
PrintSignature(Signature);
UniqueifyVariableNames(AnnotatedFormula);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
PrintSignature(Signature);
} else {
printf("Could not get formula dv\n");
}
return(EXIT_SUCCESS);
//----Test freeing
FreeListOfAnnotatedFormulae(&Head);
assert(Head == NULL);
return(EXIT_SUCCESS);
//----Test reading another file
AnotherHead = ParseFileOfFormulae(argv[1],NULL,Signature,1,NULL);
PrintListOfAnnotatedTSTPNodes(stdout,Signature,AnotherHead,tptp,1);
return(EXIT_SUCCESS);
//----Test negation or universal fofify
AnnotatedFormula = GetAnnotatedFormulaFromListByName(Head,"22");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
if (DeDoubleNegate(AnnotatedFormula)) {
printf("Dedouble negated\n");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
}
FOFify(AnnotatedFormula,universal);
if (CheckAnnotatedFormula(AnnotatedFormula,tptp_cnf)) {
FOFify(AnnotatedFormula,universal);
} else {
Negate(AnnotatedFormula,1);
}
printf("negated (FOF) or fofified (CNF)\n");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
return(EXIT_SUCCESS);
//----Test stats
if (GetListStatistics(Head,Signature,&ListStatistics) != NULL) {
PrintListStatistics(stdout,ListStatistics);
} else {
printf("Could not get statistics\n");
}
FreeListOfAnnotatedFormulae(&Head);
assert(Head == NULL);
return(EXIT_SUCCESS);
AnnotatedFormula = GetAnnotatedFormulaFromListByName(Head,"pel47_14");
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
Universals = CountAnnotatedFormulaUniqueVariablesByUse(AnnotatedFormula,
-1,-1,universal);
Existentials = CountAnnotatedFormulaUniqueVariablesByUse(AnnotatedFormula,
-1,-1,existential);
printf("Universals = %d Existentials = %d\n",Universals,Existentials);
return(EXIT_SUCCESS);
//----Test parsing of strings
ANewTerm = ParseStringTerm("hello(there,my(BIG),friend)",nontype,
Signature,0);
printf("The term is ==");
PrintTSTPTerm(stdout,ANewTerm,-1,0);
printf("==\n");
//----Test getting inference status
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,10);
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
if (GetSource(AnnotatedFormula) != NULL) {
printf("The source is %s\n",SomeString);
if (GetInferenceInfoTerm(AnnotatedFormula,"status",SomeString) != NULL) {
printf("The status term is %s\n",SomeString);
} else {
printf("No status term\n");
}
} else {
printf("No source for status\n");
}
//----Test getting by count
printf("There are %d clauses\n",ListCount(Head,cnf_nodes));
AnnotatedFormula = GetAnnotatedFormulaFromListByNumber(Head,20);
GetName(AnnotatedFormula,PutNamesHere);
printf("Got the node for clause named %s\n",PutNamesHere);
printf("The status is %s\n",StatusToString(GetRole(AnnotatedFormula,
&SubStatus)));
if (SubStatus != nonstatus) {
printf("The substatus is %s\n",StatusToString(SubStatus));
} else {
printf("It has no substatus\n");
}
if (GetInferenceRule(AnnotatedFormula,SomeString) != NULL) {
printf("The inference rule is %s\n",SomeString);
} else {
printf("No inference rule found\n");
}
//----Print symbol extraction
PrintAnnotatedTSTPNode(stdout,AnnotatedFormula,tptp,1);
if (CountLiteralsOfPolarity(AnnotatedFormula,&Positive,&Negative)) {
printf("The clause has %d literals, %d positive, %d negative\n",
CountAnnotatedFormulaAtomsByPredicate(AnnotatedFormula,""),Positive,Negative);
}
if ((Literal = GetLiteralFromAnnotatedClauseByNumber(AnnotatedFormula,1))
!= NULL) {
printf("The literal is ");
PrintTSTPFormula(stdout,AnnotatedFormula->Syntax,Literal,0,1,none,0);
printf("\n");
SymbolUsage = (char *)Malloc(sizeof(String));
GetLiteralSymbolUsage(Literal,&SymbolUsage,&VariablesStartHere);
printf("The literal data is \n%s\n",SymbolUsage);
printf("The variables are \n%s\n",VariablesStartHere);
if ((AnotherLiteral = GetLiteralFromAnnotatedClauseByNumber(
AnnotatedFormula,2)) != NULL) {
printf("The literal is ");
PrintTSTPFormula(stdout,AnnotatedFormula->Syntax,AnotherLiteral,
0,1,none,0);
printf("\n");
AnotherSymbolUsage = (char *)Malloc(sizeof(String));
if (GetLiteralSymbolUsage(AnotherLiteral,&AnotherSymbolUsage,
NULL) != NULL) {
printf("The literal data is \n%s\n",AnotherSymbolUsage);
}
ExtendString(&SymbolUsage,AnotherSymbolUsage,&SymbolUsageLength);
NormalizeSymbolUsage(SymbolUsage);
printf("The combined data is \n%s\n",SymbolUsage);
Free((void **)&AnotherSymbolUsage);
} else {
printf("Could not get literal number 2\n");
}
Free((void **)&SymbolUsage);
} else {
printf("Could not get literal number 1\n");
}
FreeListOfAnnotatedFormulae(&Head);
assert(Head == NULL);
return(EXIT_SUCCESS);
//----Test SZS hierarchy
for (SZS1=SZS;SZS1<nonszsresult;SZS1++) {
printf("%s (%s,%s) %s\n",SZSResultToString(SZS1),
SZSResultToString(StringToSZSResult(SZSResultToString(SZS1))),
SZSResultToString(StringToSZSResult(SZSResultToUserString(SZS1))),
SZSResultToUserString(SZS1));
for (SZS2=SZS1;SZS2<nonszsresult;SZS2++) {
if (SZSIsA(SZS2,SZS1)) {
printf("%s isa %s\n",SZSResultToString(SZS2),
SZSResultToString(SZS1));
} else {
printf("%s nota %s\n",SZSResultToString(SZS2),
SZSResultToString(SZS1));
}
}
}
for (SZSO1=LDa;SZSO1<nonszsoutput;SZSO1++) {
printf("%s (%s,%s) %s\n",SZSOutputToString(SZSO1),
SZSOutputToString(StringToSZSOutput(SZSOutputToString(SZSO1))),
SZSOutputToString(StringToSZSOutput(SZSOutputToUserString(SZSO1))),
SZSOutputToUserString(SZSO1));
for (SZSO2=SZSO1;SZSO2<nonszsoutput;SZSO2++) {
if (SZSOutputIsA(SZSO2,SZSO1)) {
printf("%s isa %s\n",SZSOutputToString(SZSO2),
SZSOutputToString(SZSO1));
} else {
printf("%s nota %s\n",SZSOutputToString(SZSO2),
SZSOutputToString(SZSO1));
}
}
}
return(EXIT_SUCCESS);
}
int ListCopy( CBaseEntity *pList[], int listMax )
{
int count = MIN(listMax, ListCount() );
memcpy( pList, m_targetList.Base(), sizeof(CBaseEntity *) * count );
return count;
}
void
Clone(ClientRec *client, Bool useSavedState)
{
const char *cwd;
char *program;
char **args;
char **env;
char **pp;
char *p;
char *restart_service_prop;
char *restart_protocol;
char *restart_machine;
Bool run_local;
List *pl, *pj;
if (verbose)
{
printf ("Cloning id '%s', useSavedState = %d...\n",
client->clientId, useSavedState);
printf ("Host = %s\n", client->clientHostname);
}
cwd = ".";
env = NULL;
program = NULL;
args = NULL;
restart_service_prop = NULL;
for (pl = ListFirst (client->props); pl; pl = ListNext (pl))
{
Prop *pprop = (Prop *) pl->thing;
List *vl = ListFirst (pprop->values);
PropValue *pval = (PropValue *) vl->thing;
if (strcmp (pprop->name, SmProgram) == 0)
program = (char *) pval->value;
else if (strcmp (pprop->name, SmCurrentDirectory) == 0)
cwd = (char *) pval->value;
else if (strcmp (pprop->name, "_XC_RestartService") == 0)
restart_service_prop = (char *) pval->value;
else if (
(!useSavedState && strcmp (pprop->name, SmCloneCommand) == 0) ||
(useSavedState && strcmp (pprop->name, SmRestartCommand) == 0))
{
args = (char **) XtMalloc (
(ListCount (pprop->values) + 1) * sizeof (char *));
pp = args;
for (pj = ListFirst (pprop->values); pj; pj = ListNext (pj))
{
pval = (PropValue *) pj->thing;
*pp++ = (char *) pval->value;
}
*pp = NULL;
}
else if (strcmp (pprop->name, SmEnvironment) == 0)
{
env = (char **) XtMalloc (
(ListCount (pprop->values) + 3 + 1) * sizeof (char *));
pp = env;
for (pj = ListFirst (pprop->values); pj; pj = ListNext (pj))
{
pval = (PropValue *) pj->thing;
p = (char *) pval->value;
if ((display_env && strbw (p, "DISPLAY="))
|| (session_env && strbw (p, "SESSION_MANAGER="))
|| (audio_env && strbw (p, "AUDIOSERVER=")))
continue;
*pp++ = p;
}
if (display_env)
*pp++ = display_env;
if (session_env)
*pp++ = session_env;
if (audio_env)
*pp++ = audio_env;
*pp = NULL;
}
}
if (program && args)
{
if (verbose)
{
printf("\t%s\n", program);
printf("\t");
for (pp = args; *pp; pp++)
printf ("%s ", *pp);
printf("\n");
}
GetRestartInfo (restart_service_prop, client->clientHostname,
&run_local, &restart_protocol, &restart_machine);
if (run_local)
{
/*
* The client is being cloned on the local machine.
*/
char msg[256];
switch(fork()) {
case -1:
snprintf (msg, sizeof(msg),
"%s: Can't fork() %s", Argv[0], program);
add_log_text (msg);
perror (msg);
break;
case 0: /* kid */
chdir(cwd);
if(env) environ = env;
execvp(program, args);
snprintf (msg, sizeof(msg),
"%s: Can't execvp() %s", Argv[0], program);
perror (msg);
/*
* TODO : We would like to send this log information to the
* log window in the parent. This would require opening
* a pipe between the parent and child. The child would
* set close-on-exec. If the exec succeeds, the pipe will
* be closed. If it fails, the child can write a message
* to the parent.
*/
_exit(255);
default: /* parent */
break;
}
}
else if (!remote_allowed)
{
fprintf(stderr,
"Can't remote clone client ID '%s': only local supported\n",
client->clientId);
}
else
{
/*
* The client is being cloned on a remote machine.
*/
remote_start (restart_protocol, restart_machine,
program, args, cwd, env,
non_local_display_env, non_local_session_env);
}
if (restart_protocol)
XtFree (restart_protocol);
if (restart_machine)
XtFree (restart_machine);
}
else
{
#ifdef XKB
XkbStdBell(XtDisplay(topLevel),XtWindow(topLevel),0,XkbBI_Failure);
#else
XBell (XtDisplay (topLevel), 0);
#endif
fprintf(stderr, "Can't restart ID '%s': no program or no args\n",
client->clientId);
}
if (args)
XtFree ((char *)args);
if (env)
XtFree ((char *)env);
}
Status
Restart(int flag)
{
List *cl, *pl, *vl;
PendingClient *c;
Prop *prop;
const char *cwd;
char *program;
char **args;
char **env;
char **pp;
int cnt;
char *p;
char *restart_service_prop;
char *restart_protocol;
char *restart_machine;
Bool run_local;
Bool is_manager;
Bool ran_manager = 0;
for(cl = ListFirst(PendingList); cl; cl = ListNext(cl)) {
c = (PendingClient *)cl->thing;
if (verbose) {
printf("Restarting id '%s'...\n", c->clientId);
printf("Host = %s\n", c->clientHostname);
}
cwd = ".";
env = NULL;
program=NULL;
args=NULL;
restart_service_prop=NULL;
is_manager = 0;
for(pl = ListFirst(c->props); pl; pl = ListNext(pl)) {
prop = (Prop *)pl->thing;
if(!strcmp(prop->name, SmProgram)) {
vl = ListFirst(prop->values);
if(vl) program = ((PropValue *)vl->thing)->value;
if (CheckIsManager (program))
is_manager = 1;
} else if(!strcmp(prop->name, SmCurrentDirectory)) {
vl = ListFirst(prop->values);
if(vl) cwd = ((PropValue *)vl->thing)->value;
} else if(!strcmp(prop->name, "_XC_RestartService")) {
vl = ListFirst(prop->values);
if(vl) restart_service_prop =
((PropValue *)vl->thing)->value;
} else if(!strcmp(prop->name, SmRestartCommand)) {
cnt = ListCount(prop->values);
args = (char **)XtMalloc((cnt+1) * sizeof(char *));
pp = args;
for(vl = ListFirst(prop->values); vl; vl = ListNext(vl)) {
*pp++ = ((PropValue *)vl->thing)->value;
}
*pp = NULL;
} else if(!strcmp(prop->name, SmEnvironment)) {
cnt = ListCount(prop->values);
env = (char **)XtMalloc((cnt+3+1) * sizeof(char *));
pp = env;
for(vl = ListFirst(prop->values); vl; vl = ListNext(vl)) {
p = ((PropValue *)vl->thing)->value;
if((display_env && strbw(p, "DISPLAY="))
|| (session_env && strbw(p, "SESSION_MANAGER="))
|| (audio_env && strbw(p, "AUDIOSERVER="))
) continue;
*pp++ = p;
}
if(display_env) *pp++ = display_env;
if(session_env) *pp++ = session_env;
if(audio_env) *pp++ = audio_env;
*pp = NULL;
}
}
if(program && args) {
char logtext[256];
if ((flag == RESTART_MANAGERS && !is_manager) ||
(flag == RESTART_REST_OF_CLIENTS && is_manager))
{
if(args) XtFree((char *)args);
if(env) XtFree((char *)env);
continue;
}
if (flag == RESTART_MANAGERS && is_manager)
ran_manager = 1;
if (verbose) {
printf("\t%s\n", program);
printf("\t");
for(pp = args; *pp; pp++) printf("%s ", *pp);
printf("\n");
}
GetRestartInfo (restart_service_prop, c->clientHostname,
&run_local, &restart_protocol, &restart_machine);
if (run_local)
{
/*
* The client is being restarted on the local machine.
*/
snprintf (logtext, sizeof(logtext), "Restarting locally : ");
for (pp = args; *pp; pp++)
{
strcat (logtext, *pp);
strcat (logtext, " ");
}
strcat (logtext, "\n");
add_log_text (logtext);
switch(fork()) {
case -1:
snprintf (logtext, sizeof(logtext),
"%s: Can't fork() %s", Argv[0], program);
add_log_text (logtext);
perror (logtext);
break;
case 0: /* kid */
chdir(cwd);
if(env) environ = env;
execvp(program, args);
snprintf (logtext, sizeof(logtext),
"%s: Can't execvp() %s", Argv[0], program);
perror (logtext);
/*
* TODO : We would like to send this log information to the
* log window in the parent. This would require opening
* a pipe between the parent and child. The child would
* set close-on-exec. If the exec succeeds, the pipe will
* be closed. If it fails, the child can write a message
* to the parent.
*/
_exit(255);
default: /* parent */
break;
}
}
else if (!remote_allowed)
{
fprintf(stderr,
"Can't remote start client ID '%s': only local supported\n",
c->clientId);
}
else
{
/*
* The client is being restarted on a remote machine.
*/
snprintf (logtext, sizeof(logtext),
"Restarting remotely on %s : ", restart_machine);
for (pp = args; *pp; pp++)
{
strcat (logtext, *pp);
strcat (logtext, " ");
}
strcat (logtext, "\n");
add_log_text (logtext);
remote_start (restart_protocol, restart_machine,
program, args, cwd, env,
non_local_display_env, non_local_session_env);
}
if (restart_protocol)
XtFree (restart_protocol);
if (restart_machine)
XtFree (restart_machine);
} else {
fprintf(stderr, "Can't restart ID '%s': no program or no args\n",
c->clientId);
}
if(args) XtFree((char *)args);
if(env) XtFree((char *)env);
}
if (flag == RESTART_MANAGERS && !ran_manager)
return (0);
else
return (1);
}
/* If possible compress a point into a simpler format
* This looks for lists which consist of a single entry or
* lists which include all the components of a higher level type
*/
void PointFabricCompress(Point *point)
{
switch (point->Type) {
case POINT_TYPE_NONE:
break;
case POINT_TYPE_PORT:
break;
case POINT_TYPE_PORT_LIST:
{
PortData *portp;
LIST_ITERATOR head = ListHead(&point->u.portList);
ASSERT(head);
ASSERT(ListCount(&point->u.portList) >= 1);
portp = (PortData*)ListObj(head);
if (ListCount(&point->u.portList) == 1) {
/* degenerate case, simplify as a single port */
PointFabricDestroy(point);
PointInitSimple(point, POINT_TYPE_PORT, portp);
} else if (ListCount(&point->u.portList) == cl_qmap_count(&portp->nodep->Ports)) {
/* maybe we can consolidate to a single node */
LIST_ITERATOR i;
DLIST *pList = &point->u.portList;
for (i=ListHead(pList); portp && i != NULL; i = ListNext(pList, i)) {
if (portp->nodep != ((PortData*)ListObj(i))->nodep)
portp = NULL; /* not in same node, flag for below */
}
if (portp) {
/* degenerate case, simplify as a single node */
PointFabricDestroy(point);
PointInitSimple(point, POINT_TYPE_NODE, portp->nodep);
}
#if 0
} else {
// the likelihood of this is low for port oriented searches
// and it would present just the system image guide in the summary
// and may be less obvious to the user than a list of ports
/* maybe we can consolidate to a single system */
LIST_ITERATOR i;
DLIST *pList = &point->u.portList;
for (i=ListHead(pList); portp && i != NULL; i = ListNext(pList, i)) {
if (portp->nodep->systemp != ((PortData*)ListObj(i))->nodep->systemp)
portp = NULL; /* not in same system, flag for below */
}
if (portp) {
/* all ports are in same system. is it a complete list? */
/* count ports in the system */
uint32 count = 0;
cl_map_item_t *p;
for (p=cl_qmap_head(&portp->nodep->systemp->Nodes); p != cl_qmap_end(&portp->nodep->systemp->Nodes); p = cl_qmap_next(p)) {
NodeData *nodep = PARENT_STRUCT(p, NodeData, SystemNodesEntry);
count += cl_qmap_count(&nodep->Ports);
}
if (ListCount(&point->u.portList) != count)
portp = NULL; /* incomplete list, flag for below */
}
if (portp) {
/* degenerate case, simplify as a single system */
PointFabricDestroy(point);
PointInitSimple(point, POINT_TYPE_SYSTEM, portp->nodep->systemp);
}
#endif
}
break;
}
case POINT_TYPE_NODE:
break;
case POINT_TYPE_NODE_LIST:
{
NodeData *nodep;
LIST_ITERATOR head = ListHead(&point->u.nodeList);
ASSERT(head);
ASSERT(ListCount(&point->u.nodeList) >= 1);
nodep = (NodeData*)ListObj(head);
if (ListCount(&point->u.nodeList) == 1) {
/* degenerate case, simplify as a single node */
PointFabricDestroy(point);
PointInitSimple(point, POINT_TYPE_NODE, nodep);
} else if (ListCount(&point->u.nodeList) == cl_qmap_count(&nodep->systemp->Nodes)) {
/* maybe we can consolidate to a single system */
LIST_ITERATOR i;
DLIST *pList = &point->u.nodeList;
for (i=ListHead(pList); nodep && i != NULL; i = ListNext(pList, i)) {
if (nodep->systemp != ((NodeData*)ListObj(i))->systemp)
nodep = NULL; /* not in same system, flag for below */
}
if (nodep) {
/* degenerate case, simplify as a single system */
PointFabricDestroy(point);
PointInitSimple(point, POINT_TYPE_SYSTEM, nodep->systemp);
}
}
break;
}
#if !defined(VXWORKS) || defined(BUILD_DMC)
case POINT_TYPE_IOC:
break;
case POINT_TYPE_IOC_LIST:
{
IocData *iocp;
LIST_ITERATOR head = ListHead(&point->u.iocList);
ASSERT(head);
ASSERT(ListCount(&point->u.iocList) >= 1);
iocp = (IocData*)ListObj(head);
if (ListCount(&point->u.iocList) == 1) {
/* degenerate case, simplify as a single IOC */
PointFabricDestroy(point);
PointInitSimple(point, POINT_TYPE_IOC, iocp);
} else if (ListCount(&point->u.iocList) == QListCount(&iocp->ioup->Iocs)) {
/* maybe we can consolidate to a single node */
LIST_ITERATOR i;
DLIST *pList = &point->u.iocList;
for (i=ListHead(pList); iocp && i != NULL; i = ListNext(pList, i)) {
if (iocp->ioup != ((IocData*)ListObj(i))->ioup)
iocp = NULL; /* not in same iou, flag for below */
}
if (iocp) {
/* degenerate case, simplify as a single node */
PointFabricDestroy(point);
PointInitSimple(point, POINT_TYPE_NODE, iocp->ioup->nodep);
}
#if 0
} else {
// the likelihood of this is low for ioc oriented searches
// and it would present just the system image guide in the summary
// and may be less obvious to the user than a list of iocs
/* maybe we can consolidate to a single system */
LIST_ITERATOR i;
DLIST *pList = &point->u.iocList;
for (i=ListHead(pList); iocp && i != NULL; i = ListNext(pList, i)) {
if (iocp->ioup->nodep->systemp != ((IocData*)ListObj(i))->ioup->nodep->systemp)
iocp = NULL; /* not in same system, flag for below */
}
if (iocp) {
/* all IOCs are in same system. is it a complete list? */
/* count IOCs in the system */
uint32 count = 0;
cl_map_item_t *p;
for (p=cl_qmap_head(&iocp->ioup->nodep->systemp->Nodes); p != cl_qmap_end(&iocp->ioup->nodep->systemp->Nodes); p = cl_qmap_next(p)) {
NodeData *nodep = PARENT_STRUCT(p, NodeData, SystemNodesEntry);
if (nodep->ioup)
count += QListCount(&nodep->ioup->Iocs);
}
if (ListCount(&point->u.iocList) != count)
iocp = NULL; /* incomplete list, flag for below */
}
if (iocp) {
/* degenerate case, simplify as a single system */
PointFabricDestroy(point);
PointInitSimple(point, POINT_TYPE_SYSTEM, iocp->ioup->nodep->systemp);
}
#endif
}
break;
}
#endif
case POINT_TYPE_SYSTEM:
break;
}
}
