windows-xp/Source/XPSP1/NT/multimedia/media/tools/docfmt/ventura.c

/*	
	ventura.c - Module to output the data.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>

#include "types.h"
#include "docfmt.h"
#include "text.h"
#include "ventura.h"
#include "process.h"
#include "errstr.h"


int VenLineOut(FILE * fpoutfile, char * pch, int wState);

/*  Formatting codes to output for ventura word formatting.
 */
char	*pchVenparm="<MI>";
char	*pchVenfunc="<B>";
char	*pchVenelem="<B>";
char	*pchVendefault="<D>";


#define NUMFLAGTYPES	8
#define REGISTERS	0
#define REGRETURN	1
#define REGCONDITION	2
#define PARAMETERS	3
#define PARAMRETURN	4
#define FIELD1		5
#define FIELD2		6
#define FIELD3		7


/*  "output" modes for the line out routines.  These
 *  signify what sort of formatting should be done.
 */
#define TEXT	0x0
#define PARM	0x1
#define FUNC	0x2
#define STRUCT	0x3
#define ELEMENT 0x4

#define OLDSTYLE	0x80
#define NEWSTYLE	0x40

/* 
 * @doc	VENTURA
 * @api	void | VenturaBlockOut | Central entry point for outputing a
 * Ventura format outerlevel block.
 * 
 * @parm	aBlock * | pBlock | Pointer to block structure.
 * @parm	FILE * | ofile | Output file pointer.
 * 
 * @comm	Call this to get something output in ventura.
 * 
 */
void VenturaBlockOut( aBlock *pBlock, FILE *ofile)
{
  VenfuncOut(pBlock, ofile);
}



/*************************************************************
 *
 *			LINE OUT STUFF
 *
 *************************************************************/

/* @doc	INTERNAL
 * 
 * @func	void | VentextOut | This outputs the given text lines.  Uses
 * <f VenLineOut> to expand formatting codes.
 * 
 * @parm	FILE * | file | Specifies the output file.
 * @parm	aLine * | line | Specifies the text to output.
 * 
 * @xref	VenLineOut
 * 
 */
void VentextOut( FILE *file, aLine *line, BOOL fLineSeps )
{
  int	wMode = TEXT;
  
  for (; line != NULL; line = line->next) {
	  wMode = VenLineOut( file, line->text, wMode );
	  if (fLineSeps)
		  fprintf(file, "\n");
  }
  
  if (wMode != TEXT) {
	  fprintf(errfp, "Warning: Runaway formatting code with no close.\n");
	  fprintf(file, "<D>");		// is this right?
  }
}



/* @doc	INTERNAL
 * 
 * @func	void | VentextOutLnCol | This outputs the given text lines,
 * with each line separated by a newline.  If a new paragraph occurs, it is
 * prefixed by the column prefix code <p pColHead>.
 * 
 * @parm	FILE * | file | Specifies the output file.
 * @parm	aLine * | line | Specifies the text lines to output.
 * @parm	char * | pColHead | Column header string to prefix new
 * paragraphs with.
 * 
 * @comm	Uses <f VenLineOut> to expand formatting codes.
 * 
 * @xref	VentextOut, VenLineOut
 * 
 */
void VentextOutLnCol( FILE *file, aLine *line, char *pColHead )
{
	
  int	wMode = TEXT;
	
  for (; line != NULL; line = line->next) {
	if (*(line->text) == '\0') {
		/*  Print warning if a formatting code is being
		 *  continued across a para boundry.
		 */
		if (wMode != TEXT) {
			fprintf(errfp, "Warning:  formatting code"
				"crosses paragraph boundry.\n");
		}

		/* blank line, need new paragraph header  */
		fprintf(file, "\n%s", pColHead);
	}
	else {
		/* Otherwise, normal line, print the line as usual */
		wMode = VenLineOut(file, line->text, wMode);
		fprintf(file, "\n");
	}
  }
  
  if (wMode != TEXT) {
	  fprintf(errfp, "Warning: Runaway formatting code with no"
		  "close before para end.\n");
	  fprintf(file, "<D>\n");		// is this right?
  }

}


/* 
 * @doc	INTERNAL
 * 
 * @func	int | VenLineOut | Output the given text line, expanding any
 * character/word formatting control codes to the appropriate ventura
 * control codes.
 * 
 * @parm	FILE * | fpoutfile | Output file pointer.
 * @parm	char * | line | Specifies the text to output.
 * @parm	int | wState | Specifies the current line output
 * state, either TEXT, FUNC, STRUCTURE, or PARM.  This value should initially
 * be TEXT.
 *
 * @rdesc	Returns the line output state at the end of the text line.
 * This value should be passed to <f VenLineOut> on the next iteration
 * in order to continue the formatting code across a line break.
 *
 * @comm	Reads and expands both old <p>foobar<d> style function
 * parameters and <p foobar> new-style parameters.
 * 
 * This functions sends out character strings.  Use <f VentextOut> and
 * <f VentextOut> for printing the aLine text storage data structures.
 * 
 */
int VenLineOut(FILE * fpoutfile, char * pch, int wState)
{

    /* 
     * <p> is parm
     * <f> is function
     * <t> is struct/union reference
     * <e> is structure element reference
     * <m> is message
     * <d> is return to default
     * <p foobar> is param
     * <f foobar> is function
     * <t foobar> is structure/union
     */

    BOOL	iStyle;
    char	chFormat;
	char	*pchTemp;
	
    /*  Loop over all chars on line  */
    while(*pch) {
	/*  Convert tabs into spaces.  */
	if(*pch == '\t')
	    *pch=' ';

        /*  Skip non-printing chars  */
	if (((*pch) & 0x80) || (*pch < ' ')) {
	    pch++;
	    continue;
	}

	
	/*  Check and see if this is a formatting prefix character.
	 */
	if (*pch == '<') {
		pch++;
		if (!*pch)
			/*  Warning!  Unexpected EOS  */
			continue;
		
		chFormat = *pch;
		
		/*  Move the character pointer to the characters following
		 *  the formatting, and determine the type of formatting code
		 *  in use, old or new style.
		 */
		pch++;	// skip the formatting character
		if (*pch == '>') {
			pch++;
			iStyle = OLDSTYLE;
		}
		else {
			/*  For a new style formatting code, there must be
			 *  either a EOL or whitespace following the code
			 *  character.  Make sure this is the case.  If not,
			 *  then this isn't a formatting code, so
			 *  just print the characters out.
			 */
			if (*pch && !isspace(*pch)) {
				fprintf(errfp,"Warning: New-style formatting "
		"code without whitespace.\nCode ignored but text printed.\n");
				/*  Write out the characters, but
				 *  don't enter a formatting state.
				 */
				putc('<', fpoutfile);
				putc(chFormat, fpoutfile);
				continue;	// the while (*pch)
			}

			/*  Otherwise, this a new style def.  Suck
			 *  up any whitespace present.
			 */
			iStyle = NEWSTYLE;
			/*  Chew up whitespace  */
			while (*pch && isspace(*pch))
				pch++;
		}
		
		/*  Now I'm pointing to the start of the string
		 *  that the formatting should be applied to.
		 *  Check that a formatting code is not already
		 *  in effect, cancel it if so.
		 */
		if (!(chFormat == 'd' || chFormat == 'D') && wState != TEXT) {
			fprintf(errfp, "Error:  Nested formatting codes.\n");
			fprintf(fpoutfile, "<D>");	// HACK HACK!
			wState = TEXT;
		}


		/*  Now setup the output state as appropriate, setting
		 *  the wState variable and outputting any leader chars
		 *  required.
		 */
		switch (chFormat) {
		  case 'P':
		  case 'p':
			  
			/*  Parameter formatting.  Output the
			 *  leader codes and setup wState.
			 */
			wState = iStyle | PARM;
			fprintf(fpoutfile, pchVenparm);
			break;
			
		  case 'E':
		  case 'e':
			  
			/*  Data structure element formatting.  Output the
			 *  leader codes and setup wState.
			 */
			wState = iStyle | ELEMENT;
			fprintf(fpoutfile, pchVenelem);

			/*  Skip over the structure notation (struct.element).
			 */
			pchTemp = pch;
			while (*pchTemp++ != '>') {
				if (*pchTemp == '.')
					pch = ++pchTemp;
			}
			break;
			
		  case 'F':
		  case 'f':
			/*  Function formatting.  Output & setup state */
			wState = iStyle | FUNC;
			fprintf(fpoutfile, pchVenfunc);
			break;

		  case 'D':
		  case 'd':
			if (iStyle == NEWSTYLE) {
				fprintf(errfp,"Error: <d foobar> encountered."
				     " <d> is the only valid use for <d>.\n");
				/*  Here, just print the <d_ anyway.  Then
				 *  set no mode, continue.
				 */
				fprintf(fpoutfile, "<d ");
			}
			else {
				/*  Oldstyle end of formatting encountered.
				 *  Cancel the current mode, output
				 *  a return-to-normal code (ventura is nice
				 *  for this one thing, being consistent in
				 *  what constitues return-to-normal!)
				 */
				wState = TEXT;	// reset mode
				fprintf(fpoutfile, "<D>");
			}
			break;
			
		  case 'T':
		  case 't':
			  
		  case 'M':
		  case 'm':
			  
			/*  Structure definition   */
			wState = iStyle | STRUCT;
			fprintf(fpoutfile, pchVenfunc);
			break;
			
		  default:
			/*  Unrecognized code.  Barf.
			 */
			fprintf(errfp, "Error: unrecognized"
				" formatting code.\n");
			
			/*  Simulate the output and set no mode  */
			if (iStyle == NEWSTYLE)
				fprintf(fpoutfile, "<%c ", chFormat);
			else
				fprintf(fpoutfile, "<%c>", chFormat);
			break;
		}	// switch for '<' formating codes
	}	// if *pch == '<'
	
	/*  If the character is a new-style close end formatting
	 *  indicator, clear the current mode to text and send out the
	 *  the ventura return-to-default code.
	 *
	 *  If there is no current mode, then just output the chracter?
	 */
		
	else if (*pch == '>') {
		if (wState != TEXT) {
			
			if (wState & OLDSTYLE) {
				fprintf(errfp, "Warning: new style close in "
		"oldstyle formatting.\nIgnoring close, writing char.\n");
				putc(*pch, fpoutfile);
			}
			else {
				/*  Cancel the current mode  */
				fprintf(fpoutfile, "<D>");
				wState = TEXT;
			}
		}
		else {
			fprintf(errfp, "Warning: Standalone '>' "
				"encountered.\n");
			putc(*pch, fpoutfile);
		}
		
		pch++;	// skip the '>'
		
	}
	else {
		/*  Just print the character  */
		putc(*pch, fpoutfile);
		pch++;
	}
	
    }	// while (*pch);
    
    /*  We're done!  Return the current output state  */
    return wState;

}



/****************************************************
 *
 *			XREFS
 *
 ****************************************************/

/* 
 * @doc	INTERNAL
 * @func	void | VenDoXrefs | Process and print the cross reference
 * list for a function or message block.
 * 
 * @parm	FILE * | file | Specifies the output file.
 * @parm	aLine * | line | The line of cross references to print.
 * 
 */
void VenDoXrefs( FILE *file, aLine *line)
{
  char	ach[80];
  int	i;
  char	*p;

  
  if (line == NULL) {
	  fprintf(errfp, "NULL line passed to VenDoXrefs\n");
	  return;
  }
  
  /*  Header line  */
  fprintf( file, "@HO = See Also\n\n" );  
  
  while (line != NULL) {
    /* skip whitespace */
    for (p = line->text; isspace(*p); p++);
    
    while (*p) {
	i = 0;
	while (*p && !(*p == ',' || isspace(*p)))
		ach[i++] = *p++;
	
	if (i > 0) {
		ach[i] = '\0';
		fprintf(file, "%s", ach);
	}

	while (*p && (*p == ',' || isspace(*p)))
		p++;
	if (*p)
		fprintf(file, ", ");
    }  /* while *p  */
    
    fprintf(file, "\n");
    line = line->next;
    if (line)
	    fprintf(file, " ");

  }	/* while line != NULL */
  
  fprintf(file, "\n");

}


/****************************************************
 *
 *			FLAGS
 *
 ****************************************************/

/* 
 * @doc	INTERNAL
 *
 * @func	void | VenDoFlagList | Print the flag list of a parameter,
 * register, or return description.
 * 
 * @parm	aFlag * | flag | Pointer to flag list to be printed.
 *
 * @parm	FILE * | file | Specifies the file to print to.
 *
 * @parm	WORD | wType | This parameter may be one of the following,
 * depending on the type of flag list being produced:
 *
 *   @flag	REGISTERS | This is a normal input register declaration, below
 *		a ASM or ASM callback function declaration.
 *   @flag	REGRETURN | This is a register return declaration beneath
 *		a return description.  This is not part of a conditional
 *		block.
 *   @flag	REGCONDITION | This is a register return declaration beneath
 *		a return conditional block.
 *   @flag	PARAMETERS | This is a normal parameter declaration beneath
 *		an API, or API Callback function or Message declaration.
 *   @flag	PARAMRETURN | This is a return flag list declaration beneath
 *		a return block in an API or API callback, or a Message return.
 */
void VenDoFlagList( aFlag *flag, FILE *file, int wType )
{
  static char *aszFlagNameOut[NUMFLAGTYPES] = {
	"@RFLAG = ",		// registers
	"@RFLAG = ",		// reg return
	"@RFLAG = ",		// reg condition return
	"@FLAG = ",		// param flag
	"@PARM = ",		// param return
	"@FLAG = ",		// level 1 field
	"@L2FLAG = ",		// level 2 field
	"@L3FLAG = ",		// level 3 field
  };

  static char *aszFlagDescOut[NUMFLAGTYPES] = {
	"@RFLDESC = ",		// registers
	"@RFLDESC = ",		// reg return
	"@RFLDESC = ",		// reg condition return
	"@FLDESC = ",		// param flag
	"@PDESC = ",		// param return
	"@FLDESC = ",		// level 1 field
	"@L2FLDESC = ",		// level 2 field
	"@L3FLDESC = ",		// level 3 field
  };

  if (!flag) {
	  fprintf(errfp, "Warning:  NULL Flag sent to VenDoFlaglist\n");
	  return;
  }

  assert(wType < NUMFLAGTYPES);
  
  /*  loop over the flag list  */
  for ( ; flag != NULL; flag = flag->next) {
	/*  Do flag name  */
	fprintf(file, aszFlagNameOut[wType]);
	VentextOut( file, flag->name, FALSE );
	fprintf( file, "\n\n" );

	/* Do the description */
	fprintf(file, aszFlagDescOut[wType]);
	VentextOutLnCol(file, flag->desc, aszFlagNameOut[wType]);

	fprintf( file, "\n" );
  }  // for flag list

}



/****************************************************
 *
 *			PARMS
 *
 ****************************************************/

/* 
 * @doc	INTERNAL
 * @func	void | VenDoParmList | Print the parameter list of a function
 * block.
 * 
 * @parm	aBlock * | pBlock | Specifies the enclosing block of the
 * parameter list.
 * @parm	aParm * | parm | The parameter list to print.
 * @parm	FILE * | file | Specifies the file to use for output.
 * 
 * @comm	Prints the given parameter list.  If parameters within the
 * list contain a flag list, the flag list is printed using
 * <f VenDoFlagList>.
 * 
 * @xref	VenDoFlagList
 * 
 */	
void VenDoParmList( aBlock *pBlock, aParm *parm, FILE *file )
{

  if (!parm) {
	  fprintf(file, "None\n\n");
  }
  else {
	  /*  Loop over the parameter list of the message  */
	  for (; parm != NULL; parm = parm->next) {
		  /*  Print first col, param type and name  */
		  fprintf( file, "@PARM = " );

		  VentextOut( file, parm->type, FALSE );

		  fprintf( file, "<_><MI>");
		  VentextOut( file, parm->name, FALSE );
		  fprintf( file, "<D>\n\n" );

		  /*  Do second column, the description  */
		  fprintf( file, "@PDESC = " );
		  VentextOutLnCol( file, parm->desc, "@PDESC = ");
		  // VentextOutLnCol( file, parm->desc, "@PDESC");
		  fprintf( file, "\n" );

		  /* Print the parameter's flags, if any */
		  if (parm->flag != NULL) {
			  VenDoFlagList(parm->flag, file, PARAMETERS);
		  }
	  }  // for parm list
  }
  
  /*  Close off the parameter list  */
  fprintf(file, "@LE = \n\n");
	  
}


/****************************************************
 *
 *		REGS AND CONDITIONALS
 *
 ****************************************************/


/* 
 * @doc	INTERNAL
 * @func	void | VenDoRegList | Print a register list.
 *
 * @parm	aBlock * | pBlock | Specifies the enclosing block of the
 * parameter list.
 * @parm	aReg * | reg | The register list to print.
 * @parm	FILE * | file | Specifies the file to use for output.
 *
 * @parm	WORD | wType | This parameter may be one of the following,
 * depending on the type of register list being produced:
 *
 *   @flag	REGISTERS | This is a normal input register declaration, below
 *		a ASM or ASM callback function declaration.
 *   @flag	REGRETURN | This is a register return declaration beneath
 *		a return description.  This is not part of a conditional
 *		block.
 *   @flag	REGCONDITION | This is a register return declaration beneath
 *		a return conditional block.
 *
 * @comm	Prints the given register list.  If registers within the
 * list contain a flag list, the flag list is printed using
 * <f VenDoFlagList>.
 * 
 * @xref	VenDoFlagList
 * 
 */	
void VenDoRegList( aBlock *pBlock, aReg *reg, FILE *file, int wType)
{
  static char *aszRegNameOut[] = {
	"@RNAME = ",		// registers
	"@RNAME = ",		// reg return
	"@RNAME = ",		// reg condition return
  };

  static char *aszRegDescOut[] = {
	"@RDESC = ",		// registers
	"@RDESC = ",		// reg return
	"@RDESC = ",		// reg condition return
  };
	
  assert(wType == REGISTERS || wType == REGRETURN || wType == REGCONDITION);
	
  if (reg == NULL) {
	  fprintf(file, "None\n\n");
  }
  else {
	  /*  Loop over the register list of the message  */
	  for (; reg != NULL; reg = reg->next) {
		  /*  Print first col, reg name  */
		  fprintf( file, aszRegNameOut[wType]);
		  
		  /*  Print the register name  */
		  fprintf( file, "<B>" );
		  VentextOut( file, reg->name, FALSE );
		  fprintf( file, "<D>\n\n" );

		  /*  Do second column, the description  */
		  fprintf( file, aszRegDescOut[wType] );
		  VentextOutLnCol( file, reg->desc, aszRegDescOut[wType] );
		  fprintf( file, "\n" );

		  /* Print the parameter's flags, if any */
		  if (reg->flag != NULL) {
			  VenDoFlagList(reg->flag, file, wType);
		  }
	  }  // for reg list
  }
  
  fprintf(file, "@LE = \n\n");

}



/* 
 * @doc	INTERNAL
 * 
 * @func	void | VenDoCondList | Print a conditional register list.
 * 
 * @parm	aBlock * | pBlock | Specifies the enclosing block of the
 * register list.
 * 
 * @parm	aCond * | cond | The conditional list to print.
 * 
 * @parm	FILE * | file | Specifies the file to use for output.
 * 
 * @comm	Prints the given conditional list.  For each conditional
 * block, the text is printed, followed by the the list of registers
 * (and their associated tags) for the conditional block.
 * 
 * @xref	VenDoRegList, VenDoFlagList
 * 
 */	
void VenDoCondList( aBlock *pBlock, aCond *cond, FILE *file)
{
	
  assert(cond != NULL);

  /*  Loop over the register list of the message  */
  for (; cond != NULL; cond = cond->next) {
	  
	  /*  Print out the conditional tag text..  */
	  fprintf( file, "@COND = ");
	  VentextOutLnCol(file, cond->desc, "@COND = ");
	  
	  fprintf( file, "\n");
	  
	  /*  Now print the conditional's registers (and subseqent flags) */
	  VenDoRegList(pBlock, cond->regs, file, REGCONDITION);
	  
  }  // for conditional list

  fprintf(file, "@LE = \n\n");

}


/*******************************************************
 *
 *			STRUCTS
 *
 *******************************************************/
	  
	  
/* 
 * VenPrintFieldText(aType *type, FILE *file)
 * 
 * Prints the text of a field for a structure courier dump.  This proc
 * only prints the name and type of structure fields at the appropriate
 * indent levels.
 * 
 */
void VenPrintFieldText(aType *type, FILE *file)
{
  int	i;
  
  for (i = type->level + 1; i > 0; i--)
	  fprintf(file, "    ");
  
  VentextOut(file, type->type, FALSE);
  fprintf(file, "  ");

  VentextOut(file, type->name, FALSE);

  fprintf(file, ";<R>\n");

  /*  Flags?  */
}


/* 
 * VenPrintSubstructText(aSU *su, file, wType)
 * 
 * Prints a courier dump of a sub-structure or sub-union at the
 * appropriate indent level.  Does not print any description text.
 * 
 * wType must indicate whether this is a union or structure, being
 * either FIELD_STRUCT or FIELD_UNION.
 * 
 */
void VenPrintSubstructText(aSU *su, FILE *file, int wType)
{
  int		i;
  aField	*field;
  
  
  /*  Do struct/union and brace of sub-structure  */
  for (i = su->level; i > 0; i--)
	  fprintf(file, "    ");
  
  fprintf(file, "%s {<R>\n", wType == FIELD_STRUCT ? "struct" : "union");
  
  field = su->field;
  if (field) {
    while (field) {
	switch (field->wType) {
		case FIELD_TYPE:
			VenPrintFieldText((aType *) field->ptr, file);
			break;
			
		case FIELD_STRUCT:
		case FIELD_UNION:
			VenPrintSubstructText((aSU *) field->ptr,
					file, field->wType);
			break;
	}
	field = field->next;
    }
  }

  /*  Do closing brace and title of sub-structure  */
  for (i = su->level; i > 0; i--)
	  fprintf(file, "    ");
  
  fprintf(file, "} %s;<R>\n", su->name->text);
  
}



/* 
 * VenPrintStructText(pBlock, file, wType)
 * 
 * Prints a courier dump of the text of a structure/union outerlevel
 * block.  Does not print any description fields or flags.
 * 
 * wType indicates whether the block is a structure or union, either
 * FIELD_STRUCT or FIELD_UNION.
 * 
 */
void VenPrintStructText(aBlock *pBlock, FILE *file)
{
  aField	*curf;
  aLine		*tag;

  curf = pBlock->field;
  tag = pBlock->tagname;
  
  fprintf(file, "@EX = typedef %s ", 
	  pBlock->blockType == STRUCTBLOCK ? "struct" : "union");
  if (tag)
	  fprintf(file, "%s ", tag->text);
  
  fprintf(file, "{<R>\n");
  
  while (curf) {
    switch (curf->wType) {
	case FIELD_TYPE:
		VenPrintFieldText((aType *) curf->ptr, file);
		break;
		
	case FIELD_STRUCT:
	case FIELD_UNION:
		VenPrintSubstructText((aSU *) curf->ptr, file, curf->wType);
		break;
		
	default:
		assert(FALSE);
		break;
    }
    curf = curf->next;
  }
  fprintf(file, "} %s;\n\n", pBlock->name->text);
  
  /*  Now print out the othernames?  */
}


/*********  DESCRIPTION DUMPS  ************/

#define NUMFIELDLEVELS 3

char *aachFieldNameTags[NUMFIELDLEVELS] = {
	"@PARM = ", "@L2PARM = ", "@L3PARM = "
};
char *aachFieldDescTags[NUMFIELDLEVELS] = {
	"@PDESC = ", "@L2PDESC = ", "@L3PDESC = "
};

int aiFlagTypes[NUMFIELDLEVELS] = { FIELD1, FIELD2, FIELD3 };


/* 
 * @doc	INTERNAL
 * 
 * @api	void | VenPrintFieldDesc | This function prints the
 * descriptions of a field entry in a structure.  The printout is done
 * using the standard @parm tags (and associated flag tags).
 * 
 * @parm	aType * | type | Points to a type structure which contains
 * the field information.
 * 
 * @parm	FILE * | file | Specifies the output file.
 * 
 * @comm	Use this function to output the names/descriptions of fields.
 * Use <f VenPrintFieldText> to output a similated text dump of the
 * structure definition.
 * 
 * Note that the use of this function requires an @LE tag be output when
 * the list of parameters has been ended.
 * 
 */
void VenPrintFieldDesc(aType *type, FILE *file)
{
  int level;

  level = type->level;
  if (level >= NUMFIELDLEVELS)
	  level = NUMFIELDLEVELS - 1;

  /*  Print the field type and name in the first column, formatted */
  fprintf(file, "%s<B>", aachFieldNameTags[level]);
  VentextOut(file, type->name, FALSE);
  fprintf(file, "<D>\n\n");
#if 0
  /*  Print parameter type above?  */
  fprintf(file, "<_><MI>");
  VentextOut(file, type->name, FALSE);
  fprintf(file, "\n\n");
#endif

  /*  Do the second column, description text  */
  fprintf(file, aachFieldDescTags[level]);
  VentextOutLnCol(file, type->desc, aachFieldDescTags[level]);
  putc('\n', file);

  /*  Do the flag list, if any  */
  if (type->flag != NULL) {
	  VenDoFlagList(type->flag, file, aiFlagTypes[level]);
  }
  
  /*  Now, somewhere, a @LE = needs to be output!  */
  
}




void VenPrintSubstructDesc(aSU *su, FILE *file, int wType)
{
  aField	*field;
  int level;
  int levelStruct;
  
  /*  Limit level to the number of nesting levels supported by Ventura  */
  level = min(NUMFIELDLEVELS - 1, su->level);

  levelStruct = level - 1;
  
  /*  For the sub-structure, print out a little blurb for
   *  the sub-structure/union itself, as well as the optional
   *  description text that may come with a sub-structure.
   */
  
  fprintf(file, aachFieldNameTags[levelStruct]);
  fprintf(file, "<B>%s<D>\n\n", su->name->text);

  if (su->desc) {
	  fprintf(file, aachFieldDescTags[levelStruct]);
	  VentextOutLnCol(file, su->desc, aachFieldDescTags[levelStruct]);
	  putc('\n', file);
  }

  /*  Now print the sub-fields  */
  fprintf(file, aachFieldDescTags[levelStruct]);
  fprintf(file, "The following sub-fields are contained in %s <B>%s<D>:\n\n",
	  wType == FIELD_STRUCT ? "structure" : "union",
	  su->name->text);

  /*  Now do each field of the sub-structure  */
  field = su->field;
  if (field) {
    while (field) {
	switch (field->wType) {
		case FIELD_TYPE:
			VenPrintFieldDesc((aType *) field->ptr, file);
			break;

		case FIELD_STRUCT:
		case FIELD_UNION:
			VenPrintSubstructDesc((aSU *) field->ptr,
					file, field->wType);
			break;
	}
	field = field->next;
    }
  }

  /*  Print a closing blurb  */
  fprintf(file, aachFieldNameTags[levelStruct]);
  fprintf(file, "End of sub-fields for %s %s.\n\n",
	  wType == FIELD_STRUCT ? "structure" : "union", su->name->text);

}



void VenDoStructDescriptions(aBlock *pBlock, FILE *file)
{
  aField	*cur;
  
  /*  Look through the field list, printing each field as it is
   *  encountered using @parm tags...
   */

  fprintf(file, "@HO = Fields\n\n");

  fprintf(file, "The <b>%s<d> %s has the following fields:\n\n",
		pBlock->name->text,
		pBlock->blockType == STRUCTBLOCK ? "structure" : "union");

  /*  Dump the structure  */
  cur = pBlock->field;
  if (cur == NULL) {
	fprintf(file, "None\n\n");
	return;
  }

  while (cur) {
    switch (cur->wType) {
	case FIELD_TYPE:
		VenPrintFieldDesc((aType *) cur->ptr, file);
		break;
		
	case FIELD_STRUCT:
	case FIELD_UNION:
		VenPrintSubstructDesc((aSU *) cur->ptr, file, cur->wType);
		break;
		
	default:
		assert(FALSE);
		break;
    }
    cur = cur->next;
  }

  /*  Close off the param list  */
  fprintf(file, "@LE = \n\n");

  /*  Print out othertypes?  */
  
}

	  


	  
/*********************************************************
 *
 *			DOC BLOCK
 *
 *********************************************************/

/* 
 * @doc	INTERNAL
 * @func	void | VenfuncOut | This outputs the function information.
 * 
 * @parm	aBlock * | func | Specifies a pointer to the function
 * information.  The type of the block is determined by looking at the
 * blocktype field.
 * 
 * @parm	FILE * | file | Specifies the output file.
 * 
 * @comm	This function may be called recursively to deal with callback
 * procedures.  It handles most anything.
 * 
 */
void VenfuncOut( aBlock *func, FILE *file )
{
  aParm		*parm;
  aBlock	*pCb;
  int		type;

  /*  Pointer to tag header type - depends on block type  */
  char		*pIntHeader;
  static char	achCbHeader[] = "@HU =";
  static char	achFuncHeader[] = "@HO =";

  if( func == NULL || file == NULL) {
	  fprintf(errfp, "Bogus params to VenFuncOut!\n");
	  return;
  }

  /* Get the blocktype for this block, do different things according to
   * type.
   */
  type = func->blockType;

  /*
   *  DO THE BLOCK HEADER
   */
  switch (type) {
    case FUNCTION:
	/*  use interior headers of normal level  */  
	pIntHeader = achFuncHeader;

	/* Block header */
	fprintf(file, "@HR = ");
	VentextOut(file, func->name, FALSE);
	fprintf(file, "\n\n");

	/*  Setup API description  */
	fprintf( file, "@HO = Syntax\n\n" );

	VentextOut( file, func->type, FALSE );
	fprintf( file, "<_><B>" );
	VentextOut( file, func->name, FALSE );
	fprintf( file, "<D>" );

DoFunctionBlockHeader:
	/*  Print the function header line, with parameters  */
	fprintf(file, "(");
	for (parm = func->parm; parm != NULL; ) {
		fprintf(file, "<MI>");
		VentextOut(file, parm->name, FALSE);
		fprintf(file, "<D>");
		/* Advance */
		parm = parm->next;
		if (parm != NULL) 
			fprintf(file, ", ");
	}
	fprintf(file, ")\n\n");
	// fprintf(file, "\n\n");

	break;
	
    case CALLBACK:
	/* Use callback interior header styles */
	pIntHeader = achCbHeader;

	/* Print function header setup */
	fprintf(file, "@HO = Callback\n\n");
	VentextOut(file, func->type, FALSE);
	fprintf(file, "<_><B>");
	VentextOut(file, func->name, FALSE);
	fprintf(file, "<D>");

	/* Get the parameter list done the same way as with a normal
	 * function.  Cheat by using a goto to the above code.
	 */
	goto DoFunctionBlockHeader;
	break;

    case MESSAGE:
	pIntHeader = achFuncHeader;
	
	/*  Print message header setup  */
	fprintf(file, "@HR = ");
	VentextOut(file, func->name, FALSE);
	fprintf(file, "\n\n");

//	fprintf(file, "@HO = Description\n\n");
	
	break;
	
    case MASMBLOCK:
	pIntHeader = achFuncHeader;
	
	/*  Print MASM block header setup  */
	fprintf(file, "@HR = ");
	VentextOut(file, func->name, FALSE);
	fprintf(file, "\n\n");
	
	break;

    case MASMCBBLOCK:
	pIntHeader = achCbHeader;
	
	/*  Print MASM block header setup  */
	fprintf(file, "@HO = Callback\n\n");
	
	/*  BOLD THE CALLBACK NAME?  */
	fprintf(file, "<B>");
	VentextOut(file, func->name, FALSE);
	fprintf(file, "<D>\n\n");

	break;

	
    case STRUCTBLOCK:
    case UNIONBLOCK:
	pIntHeader = achFuncHeader;
	
	/*  Print message header setup  */
	fprintf(file, "@HR = ");
	VentextOut(file, func->name, FALSE);
	fprintf(file, "\n\n");
	
//	fprintf(file, "@HO = Description\n\n");

	break;
	
	
//    case UNIONBLOCK:
//	break;
	
    default:
	fprintf(errfp, "Ventura:  Unknown block type\n");
	return;

  }  // switch type


	
  /*
   *  DO DESCRIPTION
   */
  if (func->desc != NULL) {
	  VentextOut( file, func->desc, TRUE );
	  fprintf( file, "\n" );
  }


  /*
   *  DO STRUCTURE/UNION FIELDS
   */
  if (func->field != NULL) {
	/*  Print structure dump in courier  */
	VenPrintStructText(func, file);
	
	/*  Print out the fields with descriptions & flags in table
	 *  format.
	 */
	VenDoStructDescriptions(func, file);
  }
  
  if (func->other) {
	/*  RTFOtherOut(file, func->other);
	 */
	  
  }
  
  /*
   *  DO PARAMETER OR REGISTER LISTS
   */
  switch (type) {
    case FUNCTION:
    case CALLBACK:
    case MESSAGE:
	fprintf(file, "%s Parameters\n\n", pIntHeader);
	VenDoParmList(func, func->parm, file);
	assert(func->reg == NULL);
	break;
	
    case MASMBLOCK:
    case MASMCBBLOCK:
	fprintf(file, "%s Registers\n\n", pIntHeader);
	/*  Print the register list in input register declaration format  */
	VenDoRegList(func, func->reg, file, REGISTERS);
	assert(func->parm == NULL);
	break;

  }
  

  /*
   *  DO RETURN DESCRIPTION
   */
  if( func->rtndesc != NULL ) {
	  fprintf( file, "%s Return Value\n\n", pIntHeader );

	  /*  Print the return description text  */
	  VentextOut(file, func->rtndesc, TRUE);
	  fprintf(file, "\n");

	  switch (type) {
	    case MESSAGE:
	    case FUNCTION:
	    case CALLBACK:
		if (func->rtnflag != NULL) {
			VenDoFlagList(func->rtnflag, file, PARAMRETURN);
			fprintf(file, "@LE = \n\n");
		}
		break;
	    case MASMBLOCK:
	    case MASMCBBLOCK:
		/*  Process any available register tags  */
		if (func->rtnreg != NULL) {
			VenDoRegList(func, func->rtnreg, file, REGRETURN);
		}
		
		/*  Now do the conditional list  */
		if (func->cond != NULL) {
			VenDoCondList(func, func->cond, file);
		}
		
		break;
	    default:
		assert(0);
		break;
		
	  }	// switch
  }

  /*
   *  DO USES TAG
   */
  if (func->uses != NULL) {
	  fprintf(file, "%s Uses\n\n", pIntHeader);
	  VentextOut(file, func->uses, TRUE);
	  fprintf(file, "\n@LE = \n\n");
  }
  
  /*
   *  DO COMMENT BLOCK
   */
  if( func->comment != NULL ) {
	fprintf( file, "%s Comments\n\n", pIntHeader );
	VentextOut( file, func->comment, TRUE );
	fprintf( file, "\n" );
  }
  
  
  /*
   *  DO ANY CALLBACKS
   */
  for (pCb = func->cb; pCb != NULL; pCb = pCb->next) {
	  VenfuncOut( pCb, file );
  }

  /*
   *  DO CROSS REFERENCES
   */
  if (func->xref != NULL) {
	  VenDoXrefs(file, func->xref);
  }

  /*  Done.  Whew!  */
}



/****************************************************
 *
 *	RANDOM STUFF TO SUPPORT RTF FILES
 *
 ****************************************************/


void
VenFileInit(FILE * phoutfile, logentry *curlog)
{

    return;
}

void
VenFileProcess(FILE * phoutfile, files curfile)
{
    copyfile(phoutfile,curfile->filename);
    return;

}

	
void
VenFileDone(FILE * phoutfile, files headfile)
{
    return;
}


void
VenLogInit(FILE * phoutfile, logentry * * pheadlog)
{
    return;
}

void
VenLogProcess(FILE * phoutfile, logentry * curlog)
{
    return;
}

void
VenLogDone(FILE * phoutfile, logentry * headlog)
{
    return;
}