910 lines
17 KiB
C
910 lines
17 KiB
C
|
/*
|
||
|
|
process.c - Process the log files.
|
||
|
|
|
||
|
|
Copyright (c) 1989, Microsoft. All Rights Reserved.
|
||
|
|
|
||
|
|
10-07-89 Matt Saettler
|
||
|
|
10-10-89 Update for log,aBlock,EXTFile,files structures
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <malloc.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <assert.h>
|
||
|
|
#include <search.h>
|
||
|
|
|
||
|
|
#include "types.h"
|
||
|
|
#include "docfmt.h"
|
||
|
|
#include "ventura.h"
|
||
|
|
#include "rtf.h"
|
||
|
|
#include "process.h"
|
||
|
|
#include "misc.h"
|
||
|
|
#include "errstr.h"
|
||
|
|
|
||
|
|
void dumptable(int numfiles, files * ptable);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL
|
||
|
|
*
|
||
|
|
* @func void | processLog | This function processes all the Log files.
|
||
|
|
*
|
||
|
|
* @xref readLog, initLogs, processLogs, doneLogs
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
processLog(void)
|
||
|
|
{
|
||
|
|
logentry *cur_log;
|
||
|
|
FILE *fpout;
|
||
|
|
|
||
|
|
if(!head_log)
|
||
|
|
return;
|
||
|
|
|
||
|
|
cur_log=head_log;
|
||
|
|
while(cur_log)
|
||
|
|
{
|
||
|
|
readLog(cur_log);
|
||
|
|
cur_log=cur_log->next;
|
||
|
|
}
|
||
|
|
|
||
|
|
fpout=fopen(outputFile,"w");
|
||
|
|
if(!fpout)
|
||
|
|
return;
|
||
|
|
|
||
|
|
cur_log=head_log;
|
||
|
|
|
||
|
|
initLogs(fpout, &head_log);
|
||
|
|
|
||
|
|
while(cur_log)
|
||
|
|
{
|
||
|
|
if(verbose>1) fprintf(errfp," Processing Log file: %s\n",cur_log->pchlogname);
|
||
|
|
processLogs(fpout, cur_log);
|
||
|
|
cur_log=cur_log->next;
|
||
|
|
}
|
||
|
|
doneLogs(fpout, head_log);
|
||
|
|
|
||
|
|
fclose(fpout);
|
||
|
|
if(verbose) fprintf(errfp,"%s is complete.\n",outputFile);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
* @doc INTERNAL
|
||
|
|
*
|
||
|
|
* @func void | processLogs | This functions processes all the files within
|
||
|
|
* the specified log file structure.
|
||
|
|
*
|
||
|
|
* @parm FILE * | fpout | This is the output file to process the files
|
||
|
|
* to.
|
||
|
|
*
|
||
|
|
* @parm logentry * | cur_log | This is the current log file to process.
|
||
|
|
*
|
||
|
|
* @xref initFiles, processFiles, doneFiles
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
processLogs(FILE *fpout, logentry * cur_log)
|
||
|
|
{
|
||
|
|
initFiles(fpout, cur_log);
|
||
|
|
|
||
|
|
if(cur_log->outheadMFile)
|
||
|
|
processFiles(fpout, cur_log->outheadMFile);
|
||
|
|
|
||
|
|
processFiles(fpout, cur_log->outheadFile);
|
||
|
|
|
||
|
|
if(cur_log->outheadSUFile)
|
||
|
|
processFiles(fpout, cur_log->outheadSUFile);
|
||
|
|
|
||
|
|
doneFiles(fpout, cur_log->outheadFile);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL
|
||
|
|
*
|
||
|
|
* @func void | cleanLogs | This function removes the log files structure
|
||
|
|
* from memory and removes any files if the fCleanFiles flag is TRUE.
|
||
|
|
*
|
||
|
|
* @parm logentry * | cur_log | This specifies the log file structure to remove.
|
||
|
|
*
|
||
|
|
* @xref cleanFile, cleanLogs
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
cleanLogs(logentry *cur_log)
|
||
|
|
{
|
||
|
|
if(!cur_log)
|
||
|
|
return;
|
||
|
|
|
||
|
|
cleanFile(cur_log->outheadFile);
|
||
|
|
cleanFile(cur_log->outheadMFile);
|
||
|
|
cleanFile(cur_log->outheadSUFile);
|
||
|
|
|
||
|
|
// structs go here...
|
||
|
|
|
||
|
|
cleanLogs(cur_log->next); /* recursive !! */
|
||
|
|
|
||
|
|
if(fCleanFiles)
|
||
|
|
unlink(cur_log->pchlogname);
|
||
|
|
|
||
|
|
my_free(cur_log->pchlogname);
|
||
|
|
|
||
|
|
my_free(cur_log);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func void | readLog | This function reads the logfile and creates
|
||
|
|
* the logfile structure.
|
||
|
|
*
|
||
|
|
* @parm logentry * | cur_log | This specifies the logfile structure to
|
||
|
|
* fill. The filename has been filled in.
|
||
|
|
*
|
||
|
|
* @xref parseFile
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
readLog(logentry *cur_log)
|
||
|
|
{
|
||
|
|
FILE * tFile;
|
||
|
|
files curFile;
|
||
|
|
files curMFile;
|
||
|
|
files curSUFile;
|
||
|
|
files curTFile;
|
||
|
|
|
||
|
|
tFile = fopen(cur_log->pchlogname, "r");
|
||
|
|
if(tFile == NULL)
|
||
|
|
{
|
||
|
|
error(ERROR9, "xxx", cur_log->pchlogname );
|
||
|
|
Usage();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
cur_log->outheadFile=NULL;
|
||
|
|
cur_log->outheadMFile=NULL;
|
||
|
|
cur_log->outheadSUFile=NULL;
|
||
|
|
|
||
|
|
fscanf(tFile, "%d\n",&cur_log->outputType);
|
||
|
|
|
||
|
|
curTFile=(files)clear_alloc(sizeof (struct strfile) );
|
||
|
|
|
||
|
|
curMFile=NULL;
|
||
|
|
curSUFile=NULL;
|
||
|
|
curFile=NULL;
|
||
|
|
curFile=cur_log->outheadFile;
|
||
|
|
while(parseFile(tFile, curTFile))
|
||
|
|
{
|
||
|
|
if(curTFile->blockType==MESSAGE && fSortMessage)
|
||
|
|
{
|
||
|
|
if(curMFile==NULL)
|
||
|
|
{
|
||
|
|
cur_log->outheadMFile=curTFile;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
curMFile->next=curTFile;
|
||
|
|
}
|
||
|
|
curMFile=curTFile;
|
||
|
|
}
|
||
|
|
else if( (curTFile->blockType==STRUCTBLOCK) ||
|
||
|
|
(curTFile->blockType==STRUCTBLOCK))
|
||
|
|
{
|
||
|
|
if(curSUFile==NULL)
|
||
|
|
{
|
||
|
|
cur_log->outheadSUFile=curTFile;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
curSUFile->next=curTFile;
|
||
|
|
}
|
||
|
|
curSUFile=curTFile;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(curFile==NULL)
|
||
|
|
{
|
||
|
|
cur_log->outheadFile=curTFile;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
curFile->next=curTFile;
|
||
|
|
}
|
||
|
|
curFile=curTFile;
|
||
|
|
}
|
||
|
|
curTFile=(files)clear_alloc(sizeof (struct strfile) );
|
||
|
|
}
|
||
|
|
my_free(curTFile);
|
||
|
|
curFile->next=NULL;
|
||
|
|
|
||
|
|
#ifdef MMWIN // This causes GP fault
|
||
|
|
curMFile->next=NULL; // just to be sure.
|
||
|
|
curSUFile->next=NULL; // just to be sure.
|
||
|
|
#endif
|
||
|
|
|
||
|
|
fclose( tFile );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func int | initLogs | This function is called at the beginning of
|
||
|
|
* processing the list of logs.
|
||
|
|
*
|
||
|
|
* @parm FILE * | phoutfile | This functions specifies the output file handle.
|
||
|
|
*
|
||
|
|
* @parm logentry **| phead_log | This specifies the pointer to the list of
|
||
|
|
* log files to be processed. The head value may be modified due to sorting,
|
||
|
|
* etc., by the output LogInit routine <f VenLogInit> or <f RTFLogInit>.
|
||
|
|
*
|
||
|
|
* @rdesc The return value is TRUE if the operation succeds.
|
||
|
|
*
|
||
|
|
* @xref VenLogInit, RTFLogInit
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
int
|
||
|
|
initLogs(FILE *phoutfile, logentry **phead_log)
|
||
|
|
{
|
||
|
|
switch(head_log->outputType)
|
||
|
|
{
|
||
|
|
case VENTURA:
|
||
|
|
VenLogInit(phoutfile, phead_log);
|
||
|
|
break;
|
||
|
|
case RTFDOC:
|
||
|
|
case RTFHELP:
|
||
|
|
RTFLogInit(phoutfile, phead_log);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
fprintf(stderr, "Unknown Output Type");
|
||
|
|
break;
|
||
|
|
|
||
|
|
}
|
||
|
|
return(TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func int |initFiles| This function is called before processing each
|
||
|
|
* log file.
|
||
|
|
*
|
||
|
|
* @parm FILE *|phoutfile| This parmameter specifies the output file.
|
||
|
|
*
|
||
|
|
* @parm logentry * | curlog | This is the log file containing the files
|
||
|
|
* to be processed.
|
||
|
|
*
|
||
|
|
* @rdesc The return value is TRUE if the initialization was successful.
|
||
|
|
*
|
||
|
|
* @comm The files are sorted by function name
|
||
|
|
*
|
||
|
|
* @xref VenFileInit, RTFFileInit
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
int
|
||
|
|
initFiles(FILE *phoutfile, logentry *curlog)
|
||
|
|
{
|
||
|
|
files curFile;
|
||
|
|
int i;
|
||
|
|
files *ptable;
|
||
|
|
int numFiles;
|
||
|
|
|
||
|
|
numFiles=0;
|
||
|
|
curFile=curlog->outheadFile;
|
||
|
|
if(!curFile)
|
||
|
|
goto nofiles;
|
||
|
|
|
||
|
|
while(curFile)
|
||
|
|
{
|
||
|
|
numFiles++;
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
/* sort the list */
|
||
|
|
|
||
|
|
|
||
|
|
ptable=(files *)clear_alloc( sizeof (struct s_log) * (numFiles + 1) );
|
||
|
|
|
||
|
|
curFile=curlog->outheadFile;
|
||
|
|
for(i=0;i<numFiles; i++)
|
||
|
|
{
|
||
|
|
ptable[i]=curFile;
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* dumptable(numFiles, ptable); */
|
||
|
|
|
||
|
|
qsort( ptable, numFiles, sizeof (files *), filecmp);
|
||
|
|
|
||
|
|
/* dumptable(numFiles, ptable); */
|
||
|
|
|
||
|
|
curlog->outheadFile=ptable[0];
|
||
|
|
|
||
|
|
curFile=curlog->outheadFile;
|
||
|
|
|
||
|
|
|
||
|
|
for(i=0;i<numFiles; i++)
|
||
|
|
{
|
||
|
|
curFile->next=ptable[i];
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
curFile->next=NULL;
|
||
|
|
|
||
|
|
my_free(ptable);
|
||
|
|
|
||
|
|
nofiles:
|
||
|
|
|
||
|
|
////////////////////////////////////////////////////////////////
|
||
|
|
// sort messages
|
||
|
|
|
||
|
|
numFiles=0;
|
||
|
|
curFile=curlog->outheadMFile;
|
||
|
|
if(!curFile)
|
||
|
|
goto nomessages;
|
||
|
|
|
||
|
|
while(curFile)
|
||
|
|
{
|
||
|
|
numFiles++;
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
/* sort the list */
|
||
|
|
|
||
|
|
|
||
|
|
ptable=(files *)clear_alloc( sizeof (struct s_log) * (numFiles + 1) );
|
||
|
|
|
||
|
|
curFile=curlog->outheadMFile;
|
||
|
|
for(i=0;i<numFiles; i++)
|
||
|
|
{
|
||
|
|
ptable[i]=curFile;
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* dumptable(numFiles, ptable); */
|
||
|
|
|
||
|
|
qsort( ptable, numFiles, sizeof (files *), filecmp);
|
||
|
|
|
||
|
|
/* dumptable(numFiles, ptable); */
|
||
|
|
|
||
|
|
curlog->outheadMFile=ptable[0];
|
||
|
|
|
||
|
|
curFile=curlog->outheadMFile;
|
||
|
|
|
||
|
|
|
||
|
|
for(i=0;i<numFiles; i++)
|
||
|
|
{
|
||
|
|
curFile->next=ptable[i];
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
curFile->next=NULL;
|
||
|
|
|
||
|
|
my_free(ptable);
|
||
|
|
|
||
|
|
nomessages:
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
////////////////////////////////////////////////////////////////
|
||
|
|
// sort structs/unions
|
||
|
|
|
||
|
|
numFiles=0;
|
||
|
|
curFile=curlog->outheadSUFile;
|
||
|
|
if(!curFile)
|
||
|
|
goto nosu;
|
||
|
|
|
||
|
|
while(curFile)
|
||
|
|
{
|
||
|
|
numFiles++;
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
/* sort the list */
|
||
|
|
|
||
|
|
|
||
|
|
ptable=(files *)clear_alloc( sizeof (struct s_log) * (numFiles + 1) );
|
||
|
|
|
||
|
|
curFile=curlog->outheadSUFile;
|
||
|
|
for(i=0;i<numFiles; i++)
|
||
|
|
{
|
||
|
|
ptable[i]=curFile;
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* dumptable(numFiles, ptable); */
|
||
|
|
|
||
|
|
qsort( ptable, numFiles, sizeof (files *), filecmp);
|
||
|
|
|
||
|
|
/* dumptable(numFiles, ptable); */
|
||
|
|
|
||
|
|
curlog->outheadSUFile=ptable[0];
|
||
|
|
|
||
|
|
curFile=curlog->outheadSUFile;
|
||
|
|
|
||
|
|
|
||
|
|
for(i=0;i<numFiles; i++)
|
||
|
|
{
|
||
|
|
curFile->next=ptable[i];
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
curFile->next=NULL;
|
||
|
|
|
||
|
|
my_free(ptable);
|
||
|
|
|
||
|
|
nosu:
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////
|
||
|
|
// Init file/section output
|
||
|
|
|
||
|
|
// this is a little out of design because we now have multiple
|
||
|
|
// files (text and messages and soon structs...
|
||
|
|
|
||
|
|
switch(outputType)
|
||
|
|
{
|
||
|
|
case VENTURA:
|
||
|
|
VenFileInit(phoutfile, curlog);
|
||
|
|
break;
|
||
|
|
case RTFDOC:
|
||
|
|
case RTFHELP:
|
||
|
|
RTFFileInit(phoutfile, curlog);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
fprintf(stderr, "Unknown Output Type");
|
||
|
|
break;
|
||
|
|
|
||
|
|
}
|
||
|
|
return(TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func void|dumptable| This is a debug function to dump the list of
|
||
|
|
* files.
|
||
|
|
*
|
||
|
|
* @parm int| numfiles | Specifies the nmber of entries in the table.
|
||
|
|
*
|
||
|
|
* @parm files * | ptable | Specifies the table to dump.
|
||
|
|
*
|
||
|
|
* @xref initFiles
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
dumptable(int numfiles, files * ptable)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
for(i=0;i<numfiles;i++)
|
||
|
|
fprintf(stderr, "%s\t\t%s\n",ptable[i]->name,ptable[i]->filename);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func int | filecmp | This routine is used in the qsort. It does a
|
||
|
|
* case insensitive compare of the names.
|
||
|
|
*
|
||
|
|
* @parm files * | f1 | This is the first file to compare.
|
||
|
|
*
|
||
|
|
* @parm files * | f2 | This is the second file to compare.
|
||
|
|
*
|
||
|
|
* @rdesc The return is the same as <f strcmp>. See <f qsort>.
|
||
|
|
*
|
||
|
|
* @xref qsort, strcmp, initFiles
|
||
|
|
*/
|
||
|
|
int
|
||
|
|
filecmp(files * f1, files * f2)
|
||
|
|
{
|
||
|
|
int order;
|
||
|
|
|
||
|
|
order=stricmp((*f1)->name,(*f2)->name);
|
||
|
|
|
||
|
|
return(order);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func int | processFiles | This routine processes all the files in
|
||
|
|
* a log file structure by calling the appropriate file output routine.
|
||
|
|
*
|
||
|
|
* @parm FILE * | phoutfile | This is the output file handle.
|
||
|
|
*
|
||
|
|
* @parm files |headFile| This is the head of the list of files to process.
|
||
|
|
*
|
||
|
|
* @xref VenFileProcess, RTFFileProcess
|
||
|
|
*/
|
||
|
|
int
|
||
|
|
processFiles(FILE * phoutfile, files headFile)
|
||
|
|
{
|
||
|
|
|
||
|
|
files curFile;
|
||
|
|
|
||
|
|
curFile=headFile;
|
||
|
|
while(curFile && curFile->name)
|
||
|
|
{
|
||
|
|
if(verbose>1) fprintf(errfp," Copying Block %s\n",curFile->name);
|
||
|
|
|
||
|
|
switch(outputType)
|
||
|
|
{
|
||
|
|
case VENTURA:
|
||
|
|
VenFileProcess(phoutfile, curFile);
|
||
|
|
break;
|
||
|
|
case RTFDOC:
|
||
|
|
case RTFHELP:
|
||
|
|
RTFFileProcess(phoutfile, curFile);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
fprintf(stderr, "Unknown Output Type");
|
||
|
|
break;
|
||
|
|
|
||
|
|
}
|
||
|
|
curFile=curFile->next;
|
||
|
|
}
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func int | parseFile | This routine parses a file structure from a log file.
|
||
|
|
*
|
||
|
|
* @parm FILE * | pfh | The input file handle of the log file.
|
||
|
|
*
|
||
|
|
* @parm files | curFile| The file structure to place the data from the file.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
int
|
||
|
|
parseFile(FILE * pfh, files curFile)
|
||
|
|
{
|
||
|
|
char achbuf[80];
|
||
|
|
|
||
|
|
if(fscanf(pfh,"%d ",&(curFile->blockType)) == EOF)
|
||
|
|
return(FALSE);
|
||
|
|
|
||
|
|
if(fscanf(pfh, "%s",achbuf) == EOF)
|
||
|
|
return(FALSE);
|
||
|
|
|
||
|
|
curFile->name=cp_alloc(achbuf);
|
||
|
|
|
||
|
|
if(fscanf(pfh, " %s\n",achbuf) == EOF)
|
||
|
|
return(FALSE);
|
||
|
|
|
||
|
|
curFile->filename=cp_alloc(achbuf);
|
||
|
|
|
||
|
|
return(TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func void | doneLogs | This function is called after all the logs
|
||
|
|
* in the list have been processed.
|
||
|
|
*
|
||
|
|
* @parm FILE *|phoutfile| Specifies the output file.
|
||
|
|
*
|
||
|
|
* @parm logentry * | headLog | Specifies the head of the list of log structure.
|
||
|
|
*
|
||
|
|
* @xref VenLogDone, RTFLogDone, cleanLogs
|
||
|
|
*
|
||
|
|
* @comm If the fCleanFiles flag is set, then the log files are cleaned.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
doneLogs(FILE *phoutfile, logentry *headLog)
|
||
|
|
{
|
||
|
|
switch(outputType)
|
||
|
|
{
|
||
|
|
case VENTURA:
|
||
|
|
VenLogDone(phoutfile, headLog);
|
||
|
|
break;
|
||
|
|
case RTFDOC:
|
||
|
|
case RTFHELP:
|
||
|
|
RTFLogDone(phoutfile, headLog);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
fprintf(stderr, "Unknown Output Type");
|
||
|
|
break;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
if(fCleanFiles)
|
||
|
|
cleanLogs(headLog);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func void | doneFiles | This function is called when all the files
|
||
|
|
* in the current log have been processed.
|
||
|
|
*
|
||
|
|
* @parm FILE *|phoutfile| Specifies the output file.
|
||
|
|
*
|
||
|
|
* @parm files | headFile| Specifies the list of files that have been processed.
|
||
|
|
*
|
||
|
|
* @xref VenFileDone, RTFFileDone
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
doneFiles(FILE *phoutfile, files headFile)
|
||
|
|
{
|
||
|
|
switch(outputType)
|
||
|
|
{
|
||
|
|
case VENTURA:
|
||
|
|
VenFileDone(phoutfile, headFile);
|
||
|
|
break;
|
||
|
|
case RTFDOC:
|
||
|
|
case RTFHELP:
|
||
|
|
RTFFileDone(phoutfile, headFile);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
fprintf(stderr, "Unknown Output Type");
|
||
|
|
break;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func int | cleanFile | This function removes all the memory and
|
||
|
|
* DOS files associated with the files data structure.
|
||
|
|
*
|
||
|
|
* @parm files | headFile| Specifies the list of files to be cleaned.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
int
|
||
|
|
cleanFile(files headFile)
|
||
|
|
{
|
||
|
|
files curFile;
|
||
|
|
files tcurFile;
|
||
|
|
|
||
|
|
curFile=headFile;
|
||
|
|
|
||
|
|
while(curFile && curFile->name)
|
||
|
|
{
|
||
|
|
unlink(curFile->filename);
|
||
|
|
my_free(curFile->filename);
|
||
|
|
my_free(curFile->name);
|
||
|
|
|
||
|
|
tcurFile=curFile->next;
|
||
|
|
my_free(curFile);
|
||
|
|
|
||
|
|
curFile=tcurFile;
|
||
|
|
}
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func void | copyfile | This function appends the specified file name
|
||
|
|
* to the specified output file.
|
||
|
|
*
|
||
|
|
* @parm FILE *|phoutfile| Specifies the output file.
|
||
|
|
*
|
||
|
|
* @parm char *| pchfilename| Specifies the input file.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
copyfile(FILE *phoutfile, char *pchfilename)
|
||
|
|
{
|
||
|
|
FILE *fpin;
|
||
|
|
int i;
|
||
|
|
char *pch;
|
||
|
|
|
||
|
|
pch=findfile(pchfilename);
|
||
|
|
if(!pch)
|
||
|
|
return;
|
||
|
|
fpin=fopen(pch,"r");
|
||
|
|
if(!fpin)
|
||
|
|
return;
|
||
|
|
|
||
|
|
while((i=fgetc(fpin))!=EOF)
|
||
|
|
fputc(i,phoutfile);
|
||
|
|
|
||
|
|
fclose(fpin);
|
||
|
|
|
||
|
|
return;
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func char * | findfile | This function tries to find the specified
|
||
|
|
* file. It searches directories in this order: current, PATH, INIT
|
||
|
|
* and finally INCLUDE.
|
||
|
|
*
|
||
|
|
* @parm char * |pch| Specifies the filename to find.
|
||
|
|
*
|
||
|
|
* @rdesc This function returns a pointer to the complete file/path
|
||
|
|
* of the specified file. Just the file name is returned if it is
|
||
|
|
* found in the current directory. NULL is returned if the file cannot
|
||
|
|
* be found.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
char *
|
||
|
|
findfile(char * pch)
|
||
|
|
{
|
||
|
|
FILE *fp;
|
||
|
|
static char ach[128];
|
||
|
|
static char *pchmode="r";
|
||
|
|
|
||
|
|
strcpy(ach,pch);
|
||
|
|
fp=fopen(ach, pchmode);
|
||
|
|
if(fp)
|
||
|
|
{
|
||
|
|
fclose(fp);
|
||
|
|
return(ach);
|
||
|
|
}
|
||
|
|
|
||
|
|
_searchenv(pch,"PATH",ach);
|
||
|
|
fp=fopen(ach, pchmode);
|
||
|
|
if(fp)
|
||
|
|
{
|
||
|
|
fclose(fp);
|
||
|
|
return(ach);
|
||
|
|
}
|
||
|
|
|
||
|
|
_searchenv(pch,"INIT",ach);
|
||
|
|
fp=fopen(ach, pchmode);
|
||
|
|
if(fp)
|
||
|
|
{
|
||
|
|
fclose(fp);
|
||
|
|
return(ach);
|
||
|
|
}
|
||
|
|
|
||
|
|
_searchenv(pch,"INCLUDE",ach);
|
||
|
|
fp=fopen(ach, pchmode);
|
||
|
|
if(fp)
|
||
|
|
{
|
||
|
|
fclose(fp);
|
||
|
|
return(ach);
|
||
|
|
}
|
||
|
|
|
||
|
|
return(NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func logentry * | add_logtoprocess | This function adds the specified
|
||
|
|
* log file name to the list of logs to be processed.
|
||
|
|
*
|
||
|
|
* @parm char * | pch| Specifies log file name to bo added.
|
||
|
|
*
|
||
|
|
* @rdesc The return value specifies the logentry that was created
|
||
|
|
* for the specified log file.
|
||
|
|
*
|
||
|
|
* @xref newlog
|
||
|
|
*/
|
||
|
|
logentry *
|
||
|
|
add_logtoprocess(char *pch)
|
||
|
|
{
|
||
|
|
logentry *cur_log;
|
||
|
|
cur_log=newlog(&head_log);
|
||
|
|
cur_log->pchlogname=cp_alloc(pch);
|
||
|
|
return(cur_log);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func logentry * | newlog | This function creates a new log entry
|
||
|
|
* in the specified list of logs.
|
||
|
|
*
|
||
|
|
* @parm logentry ** | start_log| Specifies the head of head of the list
|
||
|
|
* of logs.
|
||
|
|
*
|
||
|
|
* @rdesc The return value specifies the logentry that was added.
|
||
|
|
*
|
||
|
|
* @comm The new log structure is added at the head of the list.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
logentry *
|
||
|
|
newlog(logentry **start_log)
|
||
|
|
{
|
||
|
|
logentry * cur_log;
|
||
|
|
logentry * tmp_log;
|
||
|
|
|
||
|
|
cur_log=(logentry *)clear_alloc(sizeof(struct s_log));
|
||
|
|
|
||
|
|
if(!*start_log)
|
||
|
|
{
|
||
|
|
*start_log=cur_log;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
tmp_log=*start_log;
|
||
|
|
while(tmp_log->next)
|
||
|
|
tmp_log=tmp_log->next;
|
||
|
|
|
||
|
|
tmp_log->next=cur_log;
|
||
|
|
}
|
||
|
|
return(cur_log);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func fileentry * | add_filetoprocess | This function adds an input
|
||
|
|
* file to process to a log structure.
|
||
|
|
*
|
||
|
|
* @parm char * |pch| Specifies the filename to be added.
|
||
|
|
*
|
||
|
|
* @parm logentry *|curlog| Specifies the log structure.
|
||
|
|
*
|
||
|
|
* @rdesc The return value is the new file structure that is created
|
||
|
|
* to hold the file entry in the log structure.
|
||
|
|
*
|
||
|
|
* @xref newfile
|
||
|
|
*/
|
||
|
|
fileentry *
|
||
|
|
add_filetoprocess(char *pch, logentry *curlog)
|
||
|
|
{
|
||
|
|
fileentry *cur_file;
|
||
|
|
cur_file=newfile(&(curlog->inheadFile));
|
||
|
|
cur_file->filename=cp_alloc(pch);
|
||
|
|
cur_file->logfile=curlog;
|
||
|
|
return(cur_file);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL PROCESS
|
||
|
|
*
|
||
|
|
* @func fileentry * | newfile | This function creates a new file entry
|
||
|
|
* in a list of files. It is similar to <f newlog>.
|
||
|
|
*
|
||
|
|
* @parm fileentry **|start_file| Specifies the head of the list of files.
|
||
|
|
*
|
||
|
|
* @rdesc The return value specifies the new file structure that was created
|
||
|
|
* to hold the new file entry.
|
||
|
|
*
|
||
|
|
* @comm This routine inserts at the head of the list.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
fileentry *
|
||
|
|
newfile(fileentry **start_file)
|
||
|
|
{
|
||
|
|
fileentry * cur_file;
|
||
|
|
fileentry * tmp_file;
|
||
|
|
|
||
|
|
cur_file=(fileentry *)clear_alloc(sizeof(struct strfile));
|
||
|
|
|
||
|
|
if(!*start_file)
|
||
|
|
{
|
||
|
|
*start_file=cur_file;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
tmp_file=*start_file;
|
||
|
|
while(tmp_file->next)
|
||
|
|
tmp_file=tmp_file->next;
|
||
|
|
|
||
|
|
tmp_file->next=cur_file;
|
||
|
|
}
|
||
|
|
return(cur_file);
|
||
|
|
|
||
|
|
}
|