able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/media/tools/docfmt/rtf.c

2204 lines
47 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
RTF.c Output file to generate RTF for Windows 3.0 help system
10-06-1989 Matt Saettler
...
10-11-1989 MHS Block output instead of specific output
...
10-15-1989 MHS Autodoc
10-16-1989 MHS Added support for rtnregs
01-24-1990 MHS Added support for masm Callbacks
01-31-1990 MHS Added support for conditionals
03-12-1990 MHS added support for Structs/Unions
Copyright 1989, 1990 Microsoft Corp. All Rights Reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include "types.h"
#include "docfmt.h"
#include "process.h"
#include "RTF.h"
#include "errstr.h"
#include "misc.h"
#include "head.h"
#include "tail.h"
#define FUNCHELP 1
#define MSGHELP 2
#define CBHELP 3
#define FUNCDOC 4
#define MSGDOC 5
#define CBDOC 6
#define INTDOC 7
#define INTHELP 8
#define MASMDOC 9
#define MASMHELP 10
#define MASMCBDOC CBDOC // HACK HACK
#define MASMCBHELP CBHELP // PRETEND it is just another CB
#define STRUCTHELP 11
#define STRUCTDOC 12
#define UNIONHELP 13
#define UNIONDOC 14
void RTFLineOut(FILE * fpoutfile, char * pch);
void RTFGenIndex(FILE * file, files curfile);
void RTFParmOut(FILE *file, aParm *pparm, int hselect);
void copylines(FILE * phoutfile, char **lines);
void RTFRegOut(FILE *file, aReg *reg, int hselect);
void RTFFieldOut(FILE *file, aBlock *pBlock, int hselect);
void RTFOtherOut(FILE *file, aOther *other, int hselect);
void RTFCondOut(FILE *file, aCond *cond, int hselect);
void RTFSUOut1(FILE *file, aSU *SU, int hselect, int wType);
void RTFTypeOut1(FILE *file, aType *type, int hselect);
void RTFsubFieldOut1(FILE *file, aField *field , int hselect);
void RTFSUOut2(FILE *file, aSU *SU, int hselect, int wType);
void RTFTypeOut2(FILE *file, aType *type, int hselect);
void RTFsubFieldOut2(FILE *file, aField *field , int hselect);
void RTFDoneText( FILE *fpoutfile );
#define FLAGRTN 1
#define FLAGPARM 2
#define FLAGREG 3
void RTFFlagOut(FILE *file, aFlag *flag, int hselect, int flags);
void RTFDumpParms(FILE *file, aBlock *pBlock, int hselect);
void RTFDumpLevel(FILE *file, aLine *pLine, int hselect);
void RTFDumpX(FILE *file, char *ach);
int fSubBlock=0;
char *pchparm="<p>"; // 'old' style attributes
char *pchfunc="<f>";
char *pchdefault="<d>";
char *pchrtfparm="{\\i "; // attributes for parameter
char *pchrtffunc="{\\b "; // attributes for function
char *pchrtftype="{\\b "; // attributes for type
char *pchrtfmsg ="{ "; // attributes for message
char *pchrtfelem="{\\b "; // attributes for element
char *pchrtfnone ="{ "; // attributes for unknown style
char *pchrtfdefault="}"; // how to restore to default attributes
int blocksprocessed=0;
char *flagdoc ="\\par\n\\pard\\%s\\f26\\fs20\\li%d\\sa60\\sb60\\sl0\\fi%d\\tx5760\\tx6480\n";
char *sepsynhelp="\\tab\n";
char *sepsyndoc ="\\tab\n";
char *synhelp="\\pard\\plain\\f26\\fs20\\fi-1440\\sl0\\li1440\\tx1440\\tx3600\\tx5760\\tx6480\\par\n";
char *syndoc ="\\par\\pard\\plain\\f26\\fs20\\li0000\\sl0\\fi0000\\tx2160\\tx3240\\tx4320\\tx6480\n";
char *sephohelp="\\tab\n";
char *sephodoc ="\\par\n\\pard\\plain\\f26\\fs20\\li1080\\fi0000\\tx2160\\tx3240\\tx4320\\tx6480\n";
char *hcbhelp="\\pard\\plain\\f26\\fs20\\fi0000\\li0000\\tx1440\\tx6480\\par\n";
char *hcbdoc ="\\par\\pard\\plain\\f26\\fs20\\fi0000\\li0000\\tx1080\\tx4320\\tx6480\n";
char *ecbhelp="\\par\\pard\n";
char *ecbdoc ="\\par\\pard\n";
char *head0help="\\pard\\f26\\fs28\\fi0000\\li0000\\tx1440\\tx6480{\\b\n";
char *head0doc ="\\par\\pard\\brdrt\\brdrs\\f26\\fs28\\fi0000\\li0000\\tx1080\\tx4320\\tx6480\n\\v\\f26\\fs20 {\\tc \\plain{\\b \\f26\\fs20 ";
char *ehead0help="}";
char *ehead0doc ="}}\\plain\\f26\\fs20\\li0000\\sl0\\fi0000\n";
char *hohelp="\\par\\pard\\plain\\f26\\fs20\\fi-1440\\sl0\\li1440\\tx1440\\tx3600\\tx5760\\tx6480\n";
char *hodoc ="\\par\\pard\\plain\\f26\\fs20\\li0000\\sl0\\fi0000\\tx2160\\tx3240\\tx4320\\tx6480\n";
char *hparmhelp="\\par\\pard\\plain\\f26\\sl0\\sb60\\sa60\\fs20\\fi-2160\\li3600\\tx1440\\tx3600\\tx5760\\tx6480\n";
char *hparmdoc ="\\par\\pard\\sbys\\f26\\fs20\\ri3200\\li1080\\sl0\\fi0000\\tx2160\\tx3240\\tx4320\\tx6480\n";
char *sepreghelp="\\tab\n";
char *sepregdoc ="\\par\n\\pard\\sbys\\f26\\fs20\\li3240\\sl0\\fi0000\\tx2160\\tx3240\\tx4320\\tx6480\n";
char *hreghelp="\\par\\pard\\plain\\f26\\fs20\\fi-1440\\li3600\\tx1440\\tx3600\\tx5760\\tx6480\n";
char *hregdoc ="\\par\\pard\\sbys\\f26\\fs20\\ri3200\\li1080\\sl0\\fi0000\\tx2160\\tx3240\\tx4320\\tx6480\n";
char *hvalhelp="\\par\\pard\\plain\\f26\\sl0\\sb60\\sa60\\fs20\\fi-2160\\li5760\\tx5760\\tx6480\n";
char *sepvalhelp="\\tab\n";
char *hvaldoc="\\par\\pard\\plain\\f26\\sl0\\sb60\\sa60\\fs20\\fi-2160\\li5760\\tx5760\\tx6480\n";
char *sepvaldoc="\\tab\n";
char *sepparmhelp="\\tab\n";
char *sepparmdoc ="\\par\n\\pard\\sbys\\f26\\fs20\\li3240\\sl0\\fi0000\\tx2160\\tx3240\\tx4320\\tx6480\n";
char *hdeschelp="\\par\\pard\\plain\\f26\\fs20\\fi0000\\li1440\\tx1440\\tx3600\\tx5760\n";
char *hdescdoc ="\\par\\pard\\plain\\f26\\fs20\\fi0000\\li1080\\tx1080\\tx2160\\tx3240\\tx4320\n";
char *SUpar ="\\par\\pard\\plain\\f1\\fs20\\fi-3600\\li5760\\tx5760\n";
char *hSUelements="\\par\\pard\\plain\\f26\\fs20\\fi-3600\\li5760\\tx5760\\tx6480\n";
char *preg2a= "{\\b\\ulw Register}";
char *p2a= "{\\b\\ulw Type/Parameter}";
char *p2ahelp= "{\\b\\ulw Parameter}";
char *p2b= "{\\b\\ulw Description}\\par\n";
char *p2bhelp= "{\\b\\ulw Type/Description}\n";
char *p3a= "{\\b\\ulw Value}";
char *p3b= "{\\b\\ulw Meaning}\n";
///////////////////////////////////////////////////////////////////////////
char achindex[256];
struct _repl
{
char *from;
char *to;
int state;
int size;
};
char ach2[100];
#define DEFAULT 1
#define TYPE 15
#define ELEMENT 16
#define FUNC 17
#define MSG 18
#define PARM 19
struct _repl reps[]=
{
"<t>", "", TYPE, 0,
"<e>", "", ELEMENT, 0,
"<f>", "", FUNC, 0,
"<m>", "", MSG, 0,
"<p>", "", PARM, 0,
"<d>", "", DEFAULT, 0,
"<t", "", TYPE, 0,
"<e", "", ELEMENT, 0,
"<f", "", FUNC, 0,
"<m", "", MSG, 0,
"<p", "", PARM, 0,
// fence
NULL, NULL, 0, 0
};
static int state=0;
static int i=0;
void RTFtextOut( FILE * file,aLine * line);
/*
* @doc INTERNAL
*
* @func void | RTFtextOut | This outputs the given text lines.
*
* @parm aLine * | line | Specifies the text to output.
*/
void RTFtextOut( file, line )
FILE * file;
aLine * line;
{
assert(!state);
i=0;
while( line != NULL )
{
if(!line->next && !line->text[0])
break; // stop at trailing blank lines
RTFLineOut(file, line->text);
//
// Should we put out a trailing space?
//
// if the previous line ends in a word, or a <D> then splat on
// a space so words will not run together.
//
//
if(line->next)
{
int len;
char ch;
len = strlen(line->text);
ch = line->text[len-1];
if ( len>=2 && !state &&
( isalpha(ch) || isdigit(ch) || ch == '.' ||
(ch == '>' && line->text[len-2] == 'D')
)
)
fprintf( file, " ");
}
fprintf(file,"\n");
line = line->next;
}
RTFDoneText(file);
state=0;
}
void RTFDoneText( FILE *fpoutfile )
{
// IndexTag *pIndex;
// close off any processing that was in progress.
char *pch;
if(state)
{
achindex[i]=0;
// strip leading spaces.
i=0;
while(isspace(achindex[i]))
i++;
if(outputType==RTFHELP && state != PARM)
{
/* output crossreference if in HELP, but not for parameters */
if(state!=ELEMENT)
{
if((state == FUNC) || (state == TYPE))
fprintf( fpoutfile, "{\\b\\uldb\\f26\\fs20 ");
else
fprintf( fpoutfile, "{\\uldb\\f26\\fs20 ");
fprintf( fpoutfile, "%s", achindex + i);
fprintf( fpoutfile, "}{\\v\\f26\\fs20 ");
fprintf( fpoutfile, "%s",achindex + i);
fprintf( fpoutfile, "}\\plain\\f26\\fs20 ");
}
else
{
pch=achindex+i;
while(*pch) // just leave element name
{
if(*pch=='.')
{
pch++;
break;
}
pch++;
}
if(!*pch)
fprintf(errfp,"warning: bad element reference in %s\n",achindex);
fprintf( fpoutfile, "{\\uldb\\b\\f26\\fs20 ");
fprintf( fpoutfile, "%s", pch);
fprintf( fpoutfile, "}{\\v\\f26\\fs20 ");
pch=achindex+i;
while(*pch) // just leave struct name
{
if(*pch=='.')
{
*pch=0;
break;
}
pch++;
}
fprintf( fpoutfile, "%s",achindex + i);
fprintf( fpoutfile, "}\\plain\\f26\\fs20 ");
}
}
else
{
switch (state)
{
case PARM:
fprintf( fpoutfile, pchrtfparm );
break;
case FUNC:
fprintf( fpoutfile, pchrtffunc );
break;
case MSG:
fprintf( fpoutfile, pchrtfmsg );
break;
case TYPE:
fprintf( fpoutfile, pchrtftype );
break;
case ELEMENT:
fprintf( fpoutfile, pchrtfelem );
break;
default:
fprintf( fpoutfile, pchrtfnone );
break;
}
fprintf( fpoutfile,achindex +i);
fprintf( fpoutfile,pchrtfdefault);
}
state=0;
i=0;
}
}
#define ERRORMARK(w) for(j=0;j<w;j++) fprintf(errfp," "); fprintf(errfp,"^\n");
/*
* @doc INTERNAL
*
* @func void | RTFLineOut | This outputs the given text line.
*
* @parm char * | line | Specifies the text to output.
*/
void
RTFLineOut(FILE * fpoutfile, char * pch)
{
int j;
int k;
int flag;
char *pchs=pch;
// first time init
if(reps[0].size==0)
for(j=0;reps[j].from; j++)
reps[j].size=strlen(reps[j].from);
/* check for and process blank lines */
if(!*pch)
{
// need to set cur par sep formatting
// HACK. Doing a 'tab' should get us to column indent.
// (assumes fi is set to -x and tx at indent)
//
// the tab puts in a blank line also
if(fSubBlock) // if in sub-block
fprintf(fpoutfile, "\\par\\tab");
else
fprintf(fpoutfile, "\\par\\par\\tab");
}
while(*pch)
{
if(state)
{
// Handles <x>yyy<d> and <x yyy>
if(*pch!='>' && *pch!='<')
{
if(*pch!='\n')
achindex[i++]=*pch;
pch++;
}
else
{
RTFDoneText(fpoutfile);
if(*pch=='<')
{ // it was a <
pch++;
if(*pch=='d' || *pch=='D')
{
// it's OK, it's <d
pch++;
if(*pch!='>')
{
fprintf(errfp,
"non-fatal error: Badly formed formatting code in text: %s\n",pchs);
ERRORMARK(pch-pchs);
}
pch++;
}
else
{
// we don't know what it is. Skip it.
fprintf(errfp,
"non-fatal error: Unexpected formatting code in text: %s\n",pchs);
ERRORMARK(pch-pchs);
while(*pch && *pch!='>')
pch++;
if(*pch)
pch++;
}
}
else // it's just >
pch++;
}
continue;
}
if(*pch == '\t')
{
fprintf(fpoutfile," ");
pch++;
continue;
}
if(*pch == '\\')
{
pch++;
if (*pch == '|' || *pch == '@')
fprintf(fpoutfile, "%c", *pch);
else
{
pch--;
fprintf(fpoutfile,"\\%c",*pch); // output '\\'
}
pch++;
continue;
}
if(*pch == '{' || *pch == '}')
{
fprintf(fpoutfile,"\\%c",*pch);
pch++;
continue;
}
if(*pch=='<' && pch[1]!='<')
{
for(j=0; reps[j].from!=NULL; j++)
{
if(!strnicmp(pch,reps[j].from,reps[j].size))
{
if(reps[j].state==DEFAULT )
{
if(!state)
{
fprintf(errfp, "Ending without start. Ignored.\n");
}
else
{
// reset state and take care of business
RTFDoneText(fpoutfile);
}
}
state=reps[j].state;
pch+=reps[j].size;
break; // the for loop
}
}
if(reps[j].from==NULL) // we didn't find it in table
{
fprintf(errfp,
"non-fatal error: Unknown formatting code in text: %s\n",pch);
putc(*pch, fpoutfile);
pch++;
}
}
else
{
putc(*pch, fpoutfile);
pch++;
}
}
RTFDoneText(fpoutfile);
}
///////////////////////////////////////////////////////////////////////////
/*
* @doc INTERNAL
*
* @func void | RTFXrefOut | This outputs the given Xref lines.
* (lines are seperated by <new-line>)
*
* @parm aLine * | line | Specifies the text to output.
*/
void RTFXrefOut(FILE * file,aLine * line);
void RTFXrefOut( file, line )
FILE * file;
aLine * line;
{
char ach[80];
int i;
char *pch;
while( line != NULL )
{
pch=line->text;
while(isspace(*pch))
pch++;
while(*pch)
{
i=0;
while(*pch && !(*pch ==',' || isspace(*pch) ) )
ach[i++]=*pch++;
if(i>0)
{
ach[i]=0;
RTFDumpX(file, ach);
}
while(*pch && (*pch == ',' || isspace(*pch)))
{
pch++;
}
// if(*pch && outputType == RTFDOC )
// put commas between items
fprintf(file, ", ");
}
fprintf( file, "\n" );
line = line->next;
if(line)
fprintf( file, " ");
}
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFDumpX | This function outputs a Crossreference.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm char * | pch | Specifies the name of the Crossreference.
*
*/
void
RTFDumpX(FILE *file, char *pch)
{
if(outputType==RTFHELP)
{
fprintf( file, "{\\uldb\\f26\\fs20 ");
fprintf( file, "%s",pch);
fprintf( file, "}{\\v\\f26\\fs20 ");
fprintf( file, "%s",pch);
fprintf( file, "}\n\\plain\\f26\\fs20 ");
}
else
fprintf( file, "%s", pch);
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFtextOutLn | This outputs the given text lines.
* (lines are seperated by <new-line>)
*
* @parm FILE * | file | Specifies the output file.
*
* @parm aLine * | line | Specifies the text to output.
*/
void RTFtextOutLn( FILE * file,aLine * line);
void RTFtextOutLn( file, line )
FILE * file;
aLine * line;
{
RTFtextOut(file,line);
}
/*
* @doc INTERNAL
*
* @func void | RTFBlockOut | This outputs the block information in
* RTF Format.
*
* @parm aFuncBlock * | func | Specifies a pointer to the function
* information
*
* @parm FILE * | file | File to send output to.
*/
void RTFBlockOut(aBlock * pBlock, FILE * file)
{
aParm * parm;
aFlag * flag;
aBlock *pcurBlock;
aCond *cond;
int iblock ;
int hselect;
blocksprocessed++;
/* add to hselect the block type */
if( !pBlock || !file )
{
fprintf(errfp,"XXX:RTFBlockOut: parameter error\n");
return;
}
if( pBlock->blockType == FUNCTION)
hselect= (outputType == RTFHELP) ? FUNCHELP : FUNCDOC;
else if( pBlock->blockType == MESSAGE )
hselect= (outputType == RTFHELP) ? MSGHELP : MSGDOC;
else if( pBlock->blockType == CALLBACK )
hselect= (outputType == RTFHELP) ? CBHELP : CBDOC;
else if( pBlock->blockType == MASMBLOCK )
hselect= (outputType == RTFHELP) ? MASMHELP : MASMDOC;
else if( pBlock->blockType == MASMCBBLOCK )
hselect= (outputType == RTFHELP) ? MASMCBHELP : MASMCBDOC;
else if( pBlock->blockType == CALLBACK )
hselect= (outputType == RTFHELP) ? INTHELP : INTDOC;
else if( pBlock->blockType == STRUCTBLOCK )
hselect= (outputType == RTFHELP) ? STRUCTHELP : STRUCTDOC;
else if( pBlock->blockType == UNIONBLOCK )
hselect= (outputType == RTFHELP) ? UNIONHELP : UNIONDOC;
else
{
fprintf(errfp,"Unknown block type in RTFBlockOut\n");
return;
}
switch(hselect)
{
case FUNCHELP:
case MASMHELP:
case INTHELP:
case MSGHELP:
case STRUCTHELP:
case UNIONHELP:
fprintf( file, "\\par\\page K{\\footnote{\\up6 K} "); /* keyword */
RTFtextOut( file, pBlock->name );
fprintf( file, "} ${\\footnote{\\up6 $} "); /* section Title */
RTFtextOut( file, pBlock->name );
fprintf( file, "} +{\\footnote{\\up6 +} "); /* order */
fprintf( file, "T");
// RTFtextOut( file, pBlock->name );
fprintf( file, "} #{\\footnote{\\up6 #} "); /* make target */
RTFtextOut( file, pBlock->name );
fprintf( file, "}\n");
break;
}
/* process name */
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case MSGHELP:
case STRUCTHELP:
case UNIONHELP:
fprintf( file, head0help);
RTFtextOut( file, pBlock->name );
fprintf( file, ehead0help);
break;
case CBHELP:
case CBDOC:
/* nothing */
break;
case FUNCDOC:
case MSGDOC:
case INTDOC:
case MASMDOC:
case STRUCTDOC:
case UNIONDOC:
fprintf( file, head0doc);
RTFtextOut( file, pBlock->name );
fprintf( file, ehead0doc);
break;
}
if(pBlock->doclevel && dumplevels)
RTFDumpLevel(file, pBlock->doclevel, hselect);
if(outputType!= RTFHELP)
fprintf(file, "\\par\\pard\n"); // blank line
/* handle outputting syntax */
switch(hselect)
{
case CBHELP:
fprintf( file, synhelp );
fprintf( file, "{\\b %s}\\tab \n","Callback");
fprintf( file, " {\\b ");
RTFtextOut( file, pBlock->type );
fprintf( file, "}");
fprintf( file, " {\\i ");
RTFtextOut( file, pBlock->name );
fprintf( file, "}");
fprintf( file, "\\par\n" );
fprintf( file, sepsynhelp );
if( pBlock->parm )
{
parm = pBlock->parm;
while( parm )
{
fprintf( file, "{\\b ");
RTFtextOut( file, parm->type );
fprintf( file, "} " ); // << note the trailing space
fprintf( file, "{\\i ");
RTFtextOut( file, parm->name );
fprintf( file, ";}" ); // << note the ';'
parm = parm->next;
if( parm )
{
fprintf( file, "\\par\\tab\n" );
}
}
parm=NULL;
}
fprintf( file, "\\par\n" );
break;
case MASMHELP:
case INTHELP:
case FUNCHELP:
fprintf( file, synhelp );
fprintf( file, "{\\b %s}\n","Syntax" );
fprintf( file, sepsynhelp );
RTFDumpParms(file, pBlock, hselect);
fprintf( file, "\\par\n" );
break;
case UNIONHELP:
case STRUCTHELP:
case MSGHELP:
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
fprintf( file, syndoc );
fprintf( file, "{\\b %s}\n",
(hselect==CBDOC) ? "Callback" : "Syntax" );
fprintf( file, sepsyndoc );
RTFDumpParms(file, pBlock, hselect);
fprintf( file, "\\par\n" );
break;
case UNIONDOC:
case STRUCTDOC:
case MSGDOC:
break;
}
/* description block */
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case CBHELP:
case MSGHELP:
case UNIONHELP:
case STRUCTHELP:
fprintf( file, hdeschelp );
RTFtextOutLn( file, pBlock->desc );
fprintf( file, "\\par\n" );
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
case UNIONDOC:
case STRUCTDOC:
fprintf( file, hdescdoc );
RTFtextOutLn( file, pBlock->desc );
fprintf( file, "\\par\n" );
break;
}
if( pBlock->reg )
{
RTFRegOut( file, pBlock->reg, hselect);
if(pBlock->parm)
fprintf(errfp,"Warning: Block contains BOTH Registers and API parms.\n");
}
if( pBlock->parm )
{
RTFParmOut( file, pBlock->parm, hselect);
}
if( pBlock->field )
RTFFieldOut( file, pBlock, hselect);
if( pBlock->other)
RTFOtherOut( file, pBlock->other, hselect);
/* return description */
if( pBlock->rtndesc )
{
switch(hselect)
{
case FUNCHELP:
case MASMHELP:
case INTHELP:
case CBHELP:
case MSGHELP:
// leave extra blank line before return value
fprintf(file,"\n\\par");
fprintf( file, hohelp );
fprintf( file, "{\\b Return Value}" );
fprintf( file, sephohelp);
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
fprintf( file, hodoc );
fprintf( file, "{\\b Return Value}" );
fprintf( file, sephodoc);
break;
} // switch
RTFtextOutLn( file, pBlock->rtndesc );
if(pBlock->rtnflag)
{
RTFFlagOut(file, pBlock->rtnflag, hselect, FLAGRTN);
}
if(pBlock->rtnreg)
{
RTFRegOut(file, pBlock->rtnreg, hselect);
}
fprintf( file, "\\par\n" );
} // if rtndesc
else
if(pBlock->rtnflag)
fprintf(errfp,"XXX: Return flags without return desc\n");
for( cond = pBlock->cond; cond; cond = cond->next )
{
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case CBHELP:
case MSGHELP:
fprintf( file, hohelp );
fprintf( file, "{\\b Conditional}" );
fprintf( file, sephohelp);
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
fprintf( file, hodoc );
fprintf( file, "{\\b Conditional}" );
fprintf( file, sephodoc);
break;
}
RTFCondOut(file, cond, hselect);
fprintf( file, "\\par\n" );
}
if( pBlock->comment )
{
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case CBHELP:
case MSGHELP:
fprintf( file, hohelp );
fprintf( file, "{\\b Comments}" );
fprintf( file, sephohelp);
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
fprintf( file, hodoc );
fprintf( file, "{\\b Comments}" );
fprintf( file, sephodoc);
break;
}
RTFtextOutLn( file, pBlock->comment );
fprintf( file, "\\par\n" );
}
if( pBlock->uses )
{
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case CBHELP:
case MSGHELP:
fprintf( file, hohelp );
fprintf( file, "{\\b Uses}" );
fprintf( file, sephohelp);
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
fprintf( file, hodoc );
fprintf( file, "{\\b Uses}" );
fprintf( file, sephodoc);
break;
}
RTFtextOutLn( file, pBlock->uses );
fprintf( file, "\\par\n" );
}
if( pBlock->cb)
{
pcurBlock=pBlock->cb;
while(pcurBlock)
{
RTFBlockOut(pcurBlock, file );
pcurBlock=pcurBlock->next;
}
}
if( pBlock->xref )
{
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case CBHELP:
case MSGHELP:
fprintf( file, hohelp );
fprintf( file, "{\\b See Also}" );
fprintf( file, sephohelp);
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
fprintf( file, hodoc );
fprintf( file, "{\\b Related Functions}" );
fprintf( file, sephodoc);
break;
}
RTFXrefOut( file, pBlock->xref );
fprintf( file, "\\par\n" );
}
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFDumpLevel | This function outputs the DOC Level.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm aLine * | pLine | Specifies the list of Doc Levels.
*
* @parm int | hselect | Specifies the current mode of output.
*
* @flag FUNCHELP | Specifies the current block is a Function,
* and the mode is RTFHELP.
*
* @flag MSGHELP | Specifies the current block is a Message,
* and the mode is RTFHELP.
*
* @flag CBHELP | Specifies the current block is a Call Back,
* and the mode is RTFHELP.
*
* @flag FUNCDOC | Specifies the current block is a Function,
* and the mode is RTFDOC.
*
* @flag MSGDOC | Specifies the current block is a Message,
* and the mode is RTFDOC.
*
* @flag CBDOC | Specifies the current block is a Call Back,
* and the mode is RTFDOC.
*
* @flag INTDOC | Specifies the current block is an Interrupt,
* and the mode is RTFDOC.
*
* @flag INTHELP | Specifies the current block is an Interrupt,
* and the mode is RTFHELP.
*
* @flag MASMDOC | Specifies the current block is a MASM,
* and the mode is RTFDOC.
*
* @flag MASMHELP | Specifies the current block is a MASM,
* and the mode is RTFHELP.
*
*/
void
RTFDumpLevel(FILE *file, aLine *pLine, int hselect)
{
fprintf(file, "\\tab ");
while(pLine)
{
if(pLine->text)
{
fprintf( file, "{\\scaps %s}", pLine->text);
pLine=pLine->next;
if(pLine)
fprintf(file, ", ");
}
}
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFDumpParms | This functions outputs the Parameters
* for a declaration in the specfied mode to the output file.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm aLine * | pLine | Specifies the list of Doc Levels.
*
* @parm int | hselect | Specifies the current mode of output.
*
* @flag FUNCHELP | Specifies the current block is a Function,
* and the mode is RTFHELP.
*
* @flag MSGHELP | Specifies the current block is a Message,
* and the mode is RTFHELP.
*
* @flag CBHELP | Specifies the current block is a Call Back,
* and the mode is RTFHELP.
*
* @flag FUNCDOC | Specifies the current block is a Function,
* and the mode is RTFDOC.
*
* @flag MSGDOC | Specifies the current block is a Message,
* and the mode is RTFDOC.
*
* @flag CBDOC | Specifies the current block is a Call Back,
* and the mode is RTFDOC.
*
* @flag INTDOC | Specifies the current block is an Interrupt,
* and the mode is RTFDOC.
*
* @flag INTHELP | Specifies the current block is an Interrupt,
* and the mode is RTFHELP.
*
* @flag MASMDOC | Specifies the current block is a MASM,
* and the mode is RTFDOC.
*
* @flag MASMHELP | Specifies the current block is a MASM,
* and the mode is RTFHELP.
*
*/
void
RTFDumpParms(FILE *file, aBlock *pBlock, int hselect)
{
aParm *parm;
assert(hselect!=CBHELP);
fprintf( file, " {\\b ");
RTFtextOut( file, pBlock->type );
fprintf( file, "}");
fprintf( file, " {\\b ");
RTFtextOut( file, pBlock->name );
fprintf( file, "}");
switch(hselect)
{
case CBDOC:
if( pBlock->blockType == MASMCBBLOCK )
break;
case FUNCHELP:
case FUNCDOC:
fprintf( file, "(" );
break;
case CBHELP:
break;
}
if( pBlock->parm )
{
parm = pBlock->parm;
while( parm )
{
fprintf( file, "{\\i ");
RTFtextOut( file, parm->name );
fprintf( file, "}" );
parm = parm->next;
if( parm )
{
fprintf( file, ", " );
}
}
}
switch(hselect)
{
case CBDOC:
case CBHELP:
if( pBlock->blockType == MASMCBBLOCK )
break;
case FUNCHELP:
case FUNCDOC:
fprintf( file, ")" );
break;
}
return;
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFRegOut | This function outputs the specified Register
* structure in the specifed mode to the output file.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm aReg * | reg | Specifies the list of Registers.
*
* @parm int | hselect | Specifies the current mode of output.
*
* @flag FUNCHELP | Specifies the current block is a Function,
* and the mode is RTFHELP.
*
* @flag MSGHELP | Specifies the current block is a Message,
* and the mode is RTFHELP.
*
* @flag CBHELP | Specifies the current block is a Call Back,
* and the mode is RTFHELP.
*
* @flag FUNCDOC | Specifies the current block is a Function,
* and the mode is RTFDOC.
*
* @flag MSGDOC | Specifies the current block is a Message,
* and the mode is RTFDOC.
*
* @flag CBDOC | Specifies the current block is a Call Back,
* and the mode is RTFDOC.
*
* @flag INTDOC | Specifies the current block is an Interrupt,
* and the mode is RTFDOC.
*
* @flag INTHELP | Specifies the current block is an Interrupt,
* and the mode is RTFHELP.
*
* @flag MASMDOC | Specifies the current block is a MASM,
* and the mode is RTFDOC.
*
* @flag MASMHELP | Specifies the current block is a MASM,
* and the mode is RTFHELP.
*
*/
void
RTFRegOut(FILE *file, aReg *reg, int hselect)
{
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case CBHELP:
case MSGHELP:
fprintf( file, hreghelp );
fprintf( file, preg2a );
fprintf( file, sepreghelp);
fprintf( file, p2b );
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
fprintf( file, hregdoc );
fprintf( file, preg2a );
fprintf( file, sepregdoc);
fprintf( file, p2b );
break;
}
while( reg )
{
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case CBHELP:
case MSGHELP:
fprintf( file, hreghelp );
fprintf( file, "{\\i ");
RTFtextOut( file, reg->name );
fprintf( file, "} " );
fprintf( file, sepreghelp);
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
fprintf( file, hregdoc );
fprintf( file, "{\\i ");
RTFtextOut( file, reg->name );
fprintf( file, "} " );
fprintf( file, sepregdoc);
break;
}
RTFtextOutLn( file, reg->desc );
fprintf( file, "\n" );
if(reg->flag)
RTFFlagOut(file, reg->flag, hselect, FLAGREG);
fprintf( file, "\\par\n");
reg = reg->next;
}
}
void RTFFieldOut(FILE *file, aBlock *pBlock , int hselect)
{
aLine *tag;
aField *curfield;
aField *field;
field=pBlock->field;
tag=pBlock->tagname;
// recursively dump fields
// output structure definition
fprintf(file, "%stypedef struct %s \\{\n", SUpar, tag ? tag->text : "" );
fprintf(file, "%s",SUpar);
curfield=pBlock->field;
while(curfield)
{
switch(curfield->wType)
{
case FIELD_TYPE:
RTFTypeOut1(file, (aType *)curfield->ptr, hselect);
break;
case FIELD_STRUCT:
case FIELD_UNION:
RTFSUOut1(file, (aSU *)curfield->ptr,
hselect, curfield->wType);
break;
default:
assert(FALSE);
break;
}
curfield=curfield->next;
}
fprintf(file,"\\} %s;\\par",pBlock->name->text);
fprintf(file,"%s\\par The {\\b %s} structure contains the following fields:\\par\\par",
hdescdoc, pBlock->name->text);
fprintf(file,"%s{\\ul Field}\\tab{\\ul Description}\\par\n",hSUelements);
// output element definitions.
curfield=pBlock->field;
while(curfield)
{
switch(curfield->wType)
{
case FIELD_TYPE:
RTFTypeOut2(file, (aType *)curfield->ptr, hselect);
break;
case FIELD_STRUCT:
case FIELD_UNION:
RTFSUOut2(file, (aSU *)curfield->ptr, hselect, curfield->wType);
break;
default:
assert(FALSE);
break;
}
curfield=curfield->next;
}
}
void RTFsubFieldOut1(FILE *file, aField *field , int hselect)
{
aLine *tag;
aField *curfield;
// recursively dump fields
curfield=field;
while(curfield)
{
switch(curfield->wType)
{
case FIELD_TYPE:
RTFTypeOut1(file, (aType *)curfield->ptr, hselect);
break;
case FIELD_STRUCT:
case FIELD_UNION:
RTFSUOut1(file, (aSU *)curfield->ptr,
hselect, curfield->wType);
break;
default:
assert(FALSE);
break;
}
curfield=curfield->next;
}
}
void RTFSUOut1(FILE *file, aSU *SU, int hselect, int wType)
{
aSU *curSU;
int level;
for(level=SU->level ; level>0; level--)
fprintf(file, " "); // four spaces per indent.
fprintf(file, "%s \\{\\par\n", wType == FIELD_STRUCT ? "struct" : "union");
if(SU->field)
RTFsubFieldOut1(file, SU->field, hselect);
for(level=SU->level ; level>0; level--)
fprintf(file, " "); // four spaces per indent.
fprintf(file, "\\} %s;\\par\n",SU->name->text);
}
void RTFTypeOut1(FILE *file, aType *type, int hselect)
{
int level;
for(level=type->level +1 ; level>0; level--)
fprintf(file, " "); // four spaces per indent.
RTFtextOut(file, type->type);
fprintf(file,"\\tab ");
RTFtextOut(file, type->name);
fprintf( file, ";\\par\n" ); // note the ; <<<<
if(type->flag)
{
RTFFlagOut(file, type->flag, hselect, FLAGPARM);
fprintf(file, "%s", SUpar);
}
}
void RTFSUOut2(FILE *file, aSU *SU, int hselect, int wType)
{
aSU *curSU;
int level;
if(SU->field)
RTFsubFieldOut2(file, SU->field, hselect);
fprintf( file, "\\par\n" );
}
void RTFTypeOut2(FILE *file, aType *type, int hselect)
{
RTFtextOut(file, type->name);
fprintf(file,"\\tab ");
RTFtextOut(file, type->desc);
fprintf( file, "\\par\n" );
}
void RTFsubFieldOut2(FILE *file, aField *field , int hselect)
{
aLine *tag;
aField *curfield;
// recursively dump fields
curfield=field;
while(curfield)
{
switch(curfield->wType)
{
case FIELD_TYPE:
RTFTypeOut2(file, (aType *)curfield->ptr, hselect);
break;
case FIELD_STRUCT:
case FIELD_UNION:
RTFSUOut2(file, (aSU *)curfield->ptr, hselect, curfield->wType);
break;
default:
assert(FALSE);
break;
}
curfield=curfield->next;
}
}
void RTFOtherOut(FILE *file, aOther *other, int hselect)
{
aOther *curo;
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case CBHELP:
case MSGHELP:
// what are we doing here?
break;
case STRUCTHELP:
case UNIONHELP:
fprintf( file, hohelp );
fprintf( file, "{\\b Synonyms}" );
fprintf( file, sephohelp);
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
// what are we doing here?
break;
case STRUCTDOC:
case UNIONDOC:
fprintf( file, hodoc );
fprintf( file, "{\\b Other names}" );
fprintf( file, sephodoc);
break;
}
curo=other;
while(curo)
{
if(hselect == STRUCTHELP || hselect == UNIONHELP)
{
fprintf( file, "K{\\footnote{\\up6 K} "); /* make target */
RTFtextOut( file, curo->name);
fprintf( file, "}\n");
}
RTFtextOut( file, curo->type );
fprintf(file,"\\tab ");
RTFtextOut( file, curo->name);
if(curo->desc)
RTFtextOut( file, curo->desc);
fprintf( file, "\\par\n" );
curo=curo->next;
}
fprintf( file, "\\par\n" );
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFCondOut | This function outputs the specified Conditional
* structure in the specifed mode to the output file.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm aCond * | pCond | Specifies the list of Conditionals.
*
* @parm int | hselect | Specifies the current mode of output.
*
* @flag FUNCHELP | Specifies the current block is a Function,
* and the mode is RTFHELP.
*
* @flag MSGHELP | Specifies the current block is a Message,
* and the mode is RTFHELP.
*
* @flag CBHELP | Specifies the current block is a Call Back,
* and the mode is RTFHELP.
*
* @flag FUNCDOC | Specifies the current block is a Function,
* and the mode is RTFDOC.
*
* @flag MSGDOC | Specifies the current block is a Message,
* and the mode is RTFDOC.
*
* @flag CBDOC | Specifies the current block is a Call Back,
* and the mode is RTFDOC.
*
* @flag INTDOC | Specifies the current block is an Interrupt,
* and the mode is RTFDOC.
*
* @flag INTHELP | Specifies the current block is an Interrupt,
* and the mode is RTFHELP.
*
* @flag MASMDOC | Specifies the current block is a MASM,
* and the mode is RTFDOC.
*
* @flag MASMHELP | Specifies the current block is a MASM,
* and the mode is RTFHELP.
*
*/
void
RTFCondOut(FILE *file, aCond *cond, int hselect)
{
RTFtextOutLn( file, cond->desc );
fprintf( file, "\\par\n" );
RTFRegOut(file, cond->regs,hselect);
// fprintf( file, "\\par\n" );
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFParmOut | This function outputs the Parameters in the
* mode to the output file.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm aParm * | parm | Specifies the list of Parameters.
*
* @parm int | hselect | Specifies the current mode of output.
*
* @flag FUNCHELP | Specifies the current block is a Function,
* and the mode is RTFHELP.
*
* @flag MSGHELP | Specifies the current block is a Message,
* and the mode is RTFHELP.
*
* @flag CBHELP | Specifies the current block is a Call Back,
* and the mode is RTFHELP.
*
* @flag FUNCDOC | Specifies the current block is a Function,
* and the mode is RTFDOC.
*
* @flag MSGDOC | Specifies the current block is a Message,
* and the mode is RTFDOC.
*
* @flag CBDOC | Specifies the current block is a Call Back,
* and the mode is RTFDOC.
*
* @flag INTDOC | Specifies the current block is an Interrupt,
* and the mode is RTFDOC.
*
* @flag INTHELP | Specifies the current block is an Interrupt,
* and the mode is RTFHELP.
*
* @flag MASMDOC | Specifies the current block is a MASM,
* and the mode is RTFDOC.
*
* @flag MASMHELP | Specifies the current block is a MASM,
* and the mode is RTFHELP.
*
*/
void
RTFParmOut(FILE *file, aParm *parm, int hselect)
{
fSubBlock++;
switch(hselect)
{
case CBHELP: case MASMHELP:
case INTHELP: case FUNCHELP:
case MSGHELP:
fprintf( file, hparmhelp );
fprintf( file, p2ahelp );
fprintf( file, sepparmhelp);
fprintf( file, p2bhelp );
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
fprintf( file, hparmdoc );
fprintf( file, p2a );
fprintf( file, sepparmdoc);
fprintf( file, p2b );
break;
}
while( parm )
{
switch(hselect)
{
case MASMHELP:
case INTHELP:
case FUNCHELP:
case CBHELP:
case MSGHELP:
fprintf( file, hparmhelp );
fprintf( file, "{\\i ");
RTFtextOut( file, parm->name );
fprintf( file, "} " );
fprintf( file, sepparmhelp);
fprintf( file, "{\\b ");
RTFtextOut( file, parm->type );
fprintf( file, "} "); // << note ' '
break;
case INTDOC:
case MASMDOC:
case FUNCDOC:
case CBDOC:
case MSGDOC:
fprintf( file, hparmdoc );
fprintf( file, "{\\b ");
RTFtextOut( file, parm->type );
fprintf( file, "} {\\i ");
RTFtextOut( file, parm->name );
fprintf( file, "} " );
fprintf( file, sepparmdoc);
break;
}
fprintf( file, "\n" );
// RTFtextOutLn( file, parm->desc );
RTFtextOut( file, parm->desc );
if(parm->flag)
{
// fprintf(file, "\\par\n"); // blank line before flags
RTFFlagOut(file, parm->flag, hselect, FLAGPARM);
}
if(outputType!=RTFHELP)
fprintf( file, "\\par\n");
parm = parm->next;
}
fSubBlock--;
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFFlagOut | This function output a list of flags to
* the output file based on the current mode of output and where
* the flags are attached.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm aFlag * | flag | Specifies the list of flags.
*
* @parm int | hselect | Specifies the current mode of output.
*
* @flag FUNCHELP | Specifies the current block is a Function,
* and the mode is RTFHELP.
*
* @flag MSGHELP | Specifies the current block is a Message,
* and the mode is RTFHELP.
*
* @flag CBHELP | Specifies the current block is a Call Back,
* and the mode is RTFHELP.
*
* @flag FUNCDOC | Specifies the current block is a Function,
* and the mode is RTFDOC.
*
* @flag MSGDOC | Specifies the current block is a Message,
* and the mode is RTFDOC.
*
* @flag CBDOC | Specifies the current block is a Call Back,
* and the mode is RTFDOC.
*
* @flag INTDOC | Specifies the current block is an Interrupt,
* and the mode is RTFDOC.
*
* @flag INTHELP | Specifies the current block is an Interrupt,
* and the mode is RTFHELP.
*
* @flag MASMDOC | Specifies the current block is a MASM,
* and the mode is RTFDOC.
*
* @flag MASMHELP | Specifies the current block is a MASM,
* and the mode is RTFHELP.
*
* @parm int | flags | Specifies where the flags are attached.
*
* @flag FLAGPARM | Flags are attached to Parameters.
*
* @flag FLAGRTN | Flags are attached to Return Description.
*
* @flag FLAGREG | Flags are attached to Register Description.
*
*/
void
RTFFlagOut(FILE *file, aFlag *flag, int hselect, int flags)
{
int lih,lisep,fih,fisep;
char *parh,*parsep;
fSubBlock++;
assert(flag);
// everything should look more like this....
switch(hselect)
{
case MASMHELP:
case INTHELP:
case CBHELP:
case FUNCHELP:
case MSGHELP:
case UNIONHELP:
case STRUCTHELP:
if(flags==FLAGRTN)
{
fprintf( file, hparmhelp );
fprintf( file, p3a);
fprintf( file, sepparmhelp);
fprintf( file, p3b);
}
else
{
fprintf( file, hvalhelp );
fprintf( file, p3a);
fprintf( file, sepvalhelp);
fprintf( file, p3b);
}
// lih=5760;
// lisep=5760;
// fih=-2160;
// fisep=0;
// parh="plain";
// parsep="plain";
while( flag )
{
#if 1
fprintf(file,"\\par ");
#else
if(flags==FLAGRTN)
fprintf( file, hparmhelp );
else
fprintf( file, hvalhelp );
#endif
RTFtextOut( file, flag->name );
if(flags==FLAGRTN)
fprintf( file, sepparmhelp );
else
fprintf( file, sepvalhelp);
RTFtextOut( file, flag->desc );
// if(flag)
// fprintf( file, "\\par " );
flag = flag->next;
}
break;
case INTDOC:
case MASMDOC:
case CBDOC:
case FUNCDOC:
case MSGDOC:
case STRUCTDOC:
case UNIONDOC:
fprintf( file, hvaldoc );
fprintf( file, p3a);
fprintf( file, sepvaldoc);
fprintf( file, p3b);
// lih= (flags==FLAGRTN) ? 1080 : 2160;
// lisep=(flags==FLAGRTN) ? 3240 : 4320;
// fih=0;
// fisep=0;
// parh=(flags==FLAGRTN) ? "sbys\\ri3200" : "sbys\\ri4280";
// parsep="sbys";
while( flag )
{
fprintf( file, hvaldoc );
RTFtextOut( file, flag->name );
fprintf( file, sepvaldoc);
RTFtextOutLn( file, flag->desc );
fprintf( file, "\\par " );
flag = flag->next;
}
break;
}
fSubBlock--;
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFFileInit | This routine is called before a list of files
* in a log structure are processed.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm files | headfile | Specifies the list of files.
*
* @xref RTFGenIndex
*/
void
RTFFileInit(FILE * phoutfile, logentry *curlog)
{
files curfile;
files headfile;
copylines(phoutfile,headrtf);
if(outputType==RTFDOC)
{
fprintf(phoutfile,"{\\header \\pard \\qc\\ri-1800\\li-1800\\sl0 ");
fprintf(phoutfile,"\\plain \\ul\\sl240 \\plain \\f26\\fs20 "
"Microsoft Confidential\\plain \\par}\n");
fprintf(phoutfile,"{\\footer \\pard \\qc\\ri-1800\\li-1800\\sl0"
"\\plain \\f26\\fs20 Page \\chpgn \\par}\n");
}
else if(outputType==RTFHELP && !fMMUserEd)
{
fprintf(phoutfile,"\\plain\\f26\\fs20\n");
fprintf(phoutfile,"#{\\footnote \\pard \\sl240 \\plain \\f26 #\\plain \\f26 ");
fprintf(phoutfile,"%s_index}\n","");
fprintf(phoutfile,"${\\footnote \\pard \\sl240 \\plain \\f26 $\\plain \\f26 ");
fprintf(phoutfile,"%s Index}\n","");
fprintf(phoutfile,"\\plain\\f26\\fs20\\par\\par\n");
fprintf(phoutfile,"For information on how to use Help, press F1 or choose\n");
fprintf(phoutfile," Using Help from the Help menu.\\par\n");
headfile=curlog->outheadFile;
if(headfile)
{
fprintf(phoutfile,"\\plain\\f26\\fs24\\par\\par\n");
fprintf(phoutfile,"{\\b Functions Index}\n");
fprintf(phoutfile,"\\plain\\f26\\fs20\\par\\par\n");
curfile=headfile;
while(curfile)
{
if(curfile->name)
RTFGenIndex(phoutfile, curfile);
curfile=curfile->next;
}
fprintf(phoutfile,"\\plain\\f26\\fs20\\par\\par\n");
}
headfile=curlog->outheadMFile;
if(headfile)
{
fprintf(phoutfile,"\\plain\\f26\\fs24\\par\\par\n");
fprintf(phoutfile,"{\\b Messages Index}\n");
fprintf(phoutfile,"\\plain\\f26\\fs20\\par\\par\n");
curfile=headfile;
while(curfile)
{
if(curfile->name)
RTFGenIndex(phoutfile, curfile);
curfile=curfile->next;
}
fprintf(phoutfile,"\\plain\\f26\\fs20\\par\\par\n");
}
headfile=curlog->outheadSUFile;
if(headfile)
{
fprintf(phoutfile,"\\plain\\f26\\fs24\\par\\par\n");
fprintf(phoutfile,"{\\b Data Structures Index}\n");
fprintf(phoutfile,"\\plain\\f26\\fs20\\par\\par\n");
curfile=headfile;
while(curfile)
{
if(curfile->name)
RTFGenIndex(phoutfile, curfile);
curfile=curfile->next;
}
fprintf(phoutfile,"\\plain\\f26\\fs20\\par\\par\n");
}
fprintf(phoutfile,"\\par Entire contents Copyright 1990, "
"Microsoft Crop. All rights reserved.\\par\\par\n");
}
return;
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFGenIndex | This function outputs a reference to a block name.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm files | curfile | Specifies the file structure with the block name.
*
*/
void
RTFGenIndex(FILE * file, files curfile)
{
fprintf( file, "\\tab {\\uldb\\f26\\fs20 ");
fprintf( file, "%s",curfile->name);
fprintf( file, "}{\\v\\f26\\fs20 ");
fprintf( file, "%s",curfile->name);
fprintf( file, "}\\plain\\f26\\fs20\\par\n");
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFFileProcess | This function is called for each file that
* is being processed.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm files | curfile | Specifies the file.
*
*/
void
RTFFileProcess(FILE * phoutfile, files curfile)
{
copyfile(phoutfile,curfile->filename);
return;
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFFileDone | This function is called when all files in a list
* of files have been processed.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm files | headfile | Specifies the file.
*
*/
void
RTFFileDone(FILE * phoutfile, files headfile)
{
#if 0
if(blocksprocessed > 100 && outputType==RTFHELP)
{
fprintf( phoutfile, "\\par\\page K{\\footnote{\\up6 K} "); /* keyword */
fprintf( phoutfile, "mmGetCredits" );
fprintf( phoutfile, "} ${\\footnote{\\up6 $} "); /* section Title */
fprintf( phoutfile, "Credits" );
fprintf( phoutfile, "} +{\\footnote{\\up6 +} "); /* order */
fprintf( phoutfile, "CREDITS");
fprintf( phoutfile, "}\n");
fprintf( phoutfile, head0help);
fprintf( phoutfile, "Credits");
fprintf( phoutfile, ehead0help);
fprintf( phoutfile, "\\parAutomatic documentation Tool by\\par");
fprintf( phoutfile,
, " Russell Wiliams, Mark McCulley and Matt Saettler\\par\n");
fprintf( phoutfile, "\\par Windows SDK and Multimedia MDK documentation and generation program by Matt Saettler\n");
fprintf( phoutfile, "\\par Windows SDK layout and processing by Todd Laney and Matt Saettler\\par\n");
}
#endif
copylines(phoutfile,tailrtf);
return;
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFLogInit | This function is called before a list of log
* files are to be processed.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm logentry ** | pheadlog | Specifies the head of the log list.
*
*/
void
RTFLogInit(FILE * phoutfile, logentry * * pheadlog)
{
FILE *fp;
char achbuf[180];
int j;
if(outputType==RTFHELP)
{
j=findlshortname(outputFile);
strncpy(achbuf,outputFile,j);
achbuf[j]=0;
strcat(achbuf,".hpj");
fp=fopen(achbuf,"r");
if(!fp) // file doesn't exist
{
fp=fopen(achbuf,"w");
assert(fp);
fprintf(fp,"; HPJ file automagically generated by DOCFMT\n");
fprintf(fp,"[files]\n");
fprintf(fp," %s\n",outputFile);
}
fclose(fp);
}
return;
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFLogProcess | This function is called for each log to be processed.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm logentry * | curlog | Specifies the current log.
*
*/
void
RTFLogProcess(FILE * phoutfile, logentry * curlog)
{
return;
}
/*
* @doc INTERNAL RTF
*
* @func void | RTFLogDone | This function is called after a list of logs
* has been processed.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm logentry * | headlog | Specifies the head of the log list.
*
*/
void
RTFLogDone(FILE * phoutfile, logentry * headlog)
{
return;
}
/*
* @doc INTERNAL RTF
*
* @func void | copylines | This function appends the array of lines
* to the output file.
*
* @parm FILE * | file | Specifies the output file.
*
* @parm char ** | papch | Specifies the array of lines.
*
* @comm The list is terminated by a NULL pointer.
*
*/
void
copylines(FILE * phoutfile, char **lines)
{
assert(lines);
while(*lines)
{
fprintf(phoutfile, "%s",*lines);
lines++;
}
return;
}
Reference in a new issue Copy permalink