[splint.git] / src / lh.c

/*
** Splint - annotation-assisted static program checker
** Copyright (C) 1994-2002 University of Virginia,
**         Massachusetts Institute of Technology
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 2 of the License, or (at your
** option) any later version.
** 
** This program is distributed in the hope that it will be useful, but
** WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
** General Public License for more details.
** 
** The GNU General Public License is available from http://www.gnu.org/ or
** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
** MA 02111-1307, USA.
**
** For information on lclint: lclint-request@cs.virginia.edu
** To report a bug: lclint-bug@cs.virginia.edu
** For more information: http://www.splint.org
*/
/*
** lh.c
**
**  MODULE DESCRIPTION:
**
**      This module contains the I/O routines for writing out the .lh file
**	generated from the .lcl file.
**
**  AUTHORS:
**
**      Gary Feldman, Technical Languages and Environments, DECspec project
**      Yang Meng Tan, MIT.
**
**  CREATION DATE:  9 April 91
**
**	The lh.c module controls formatting policy.
*/

# include "lclintMacros.nf"
# include "llbasic.h"
# include "osd.h"
# include "lh.h"
# include "llmain.h"

/*@constant static char TABCH; @*/
# define TABCH 		'\1'

/*@constant static char TABINCH; @*/
# define TABINCH 	'\2'

/*@constant static char TABOUTCH; @*/
# define TABOUTCH	'\3'

/*
  # define TAB 		        fputc (TABCH, 	LhFile.f);
  # define TABIN		fputc (TABINCH, 	LhFile.f);
  # define TABOUT		fputc (TABOUTCH, LhFile.f);
*/

/*@private@*/ typedef struct
{
  /*:open:*/ /*@dependent@*/ /*@null@*/ /*@reldef@*/ FILE *f;
  /*@reldef@*/ cstring name;
} outFile;

static bool genLh;
static outFile LhFile;
static bool needIncludeBool = FALSE;

/*
**
**  FORWARD FUNCTIONS
**
*/

/* static int colpos (int startcol, cstring line); */

static cstring lhTypeSpecNode (lclTypeSpecNode p_typespec);
static /*@only@*/ cstring lhTypeExpr (/*@null@*/ typeExpr p_x);
static /*@only@*/ cstring lhDeclaratorNode (declaratorNode p_x);

static /*:open:*/ /*@dependent@*/ /*@null@*/ FILE *out_open (cstring name, cstring suffix)
     /*@modifies fileSystem@*/
{
  cstring fullname = cstring_concat (name, suffix);
  FILE *ret = fileTable_openFile (context_fileTable (), fullname, "w+");
  cstring_free (fullname);
  return ret;
}

/*@only@*/ cstring 
lhFunction (lclTypeSpecNode lclTypeSpec, declaratorNode declarator)
{
  cstring s;

  if (!genLh)
    return cstring_undefined;
  
  s = message ("extern %q\1%q;", lhTypeSpecNode (lclTypeSpec),
	       lhDeclaratorNode (declarator));
  
  return s;
}

static /*@only@*/ cstring
lhDeclaratorNode (declaratorNode x)
{
  return (lhTypeExpr (x->type));
}

static /*@only@*/ cstring lhTypeExpr (/*@null@*/ typeExpr x)
{
  cstring s = cstring_undefined; /* print out types in order of appearance in source */
  paramNodeList params;
  int i;

  if (x != (typeExpr) 0)
    {
      cstring front = cstring_undefined;
      cstring back  = cstring_undefined;

      for (i = x->wrapped; i >= 1; i--)
	{
	  front = cstring_appendChar (front, '(');
	  back  = cstring_appendChar (back, ')');
	}

      switch (x->kind)
	{
	case TEXPR_BASE:
	  s = message ("%q%s", s, ltoken_getRawString (x->content.base));
	  break;
	case TEXPR_PTR:
	  s = message ("%q*%q", s, lhTypeExpr (x->content.pointer));
	  break;
	case TEXPR_ARRAY:
	  s = message ("%q%q[%q]", s, 
		       lhTypeExpr (x->content.array.elementtype),
		       termNode_unparse (x->content.array.size));
	  break;
	case TEXPR_FCN:
	  s = message ("%q%q (", s, lhTypeExpr (x->content.function.returntype));
	  params = x->content.function.args;

	  if (!paramNodeList_empty (params))
	    {
	      s = message ("%q%q", s, 
			   paramNodeList_unparseComments (x->content.function.args));
	    }

	  s = message ("%q)", s);
	  break;
	}
      s = message ("%q%q%q", front, s, back);
    }
  else
    {
      s = cstring_makeLiteral ("?");
    }

  return s;
}

extern void
lhForwardStruct (ltoken t)
{
  if (!genLh)
    return;

  lhOutLine (message ("struct %s;", ltoken_unparse (t)));
}


extern void
lhForwardUnion (ltoken t)
{
  if (!genLh)
    return;

  lhOutLine (message ("union %s;", ltoken_unparse (t)));
}

extern /*@only@*/ cstring 
lhType (typeNode t)
{
  if (!genLh)
    return cstring_undefined;

  if (t->kind == TK_EXPOSED)
    {
      exposedNode n = t->content.exposed;

      if (n != (exposedNode) 0)
	{
	  if (declaratorInvNodeList_size (n->decls) == 0)
	    {
	      /* 
	      ** Forward struct or union declaration
	      */

	      return (cstring_appendChar (lhTypeSpecNode (n->type), ';'));
	    }
	  else
	    {
	      cstring s = cstring_undefined;

	      declaratorInvNodeList_elements (n->decls, d)
		{
		  cstring name = declaratorNode_unparse (d->declarator);
		  cstring pname = declaratorNode_unparseCode (d->declarator); 
		  
		  s = message ("%q\n# ifndef EXPOSED_TYPE_%q\ntypedef %q %q;\n# endif\n", 
			       s, pname, lhTypeSpecNode (n->type), name);
		} end_declaratorInvNodeList_elements;
	      
	      return s;
	    }
	}
    }

  return cstring_undefined;
}

static /*@only@*/ cstring 
lhTypeSpecNode (lclTypeSpecNode typespec)
{
  if (!genLh)
    {
      return cstring_undefined;
    }

  return (lclTypeSpecNode_unparseComments (typespec));
}

/*@only@*/ cstring
lhVarDecl (lclTypeSpecNode lclTypeSpec, initDeclNodeList initDecls,
	   qualifierKind qualifier)
{
  bool first = TRUE;
  cstring s;

  if (!genLh)
    return cstring_undefined;

  s = cstring_makeLiteral ("extern");

  switch (qualifier)
    {
    case QLF_NONE:
      break;
    case QLF_CONST:
      s = message ("%q const", s);
      break;
    case QLF_VOLATILE:
      s = message ("%q volatile", s);
      break;
    default:			/* ignore it */
      break;
    }
  
  s = message ("%q %q\1", s, lhTypeSpecNode (lclTypeSpec));

  initDeclNodeList_elements (initDecls, i)
  {
    if (first)
      {
	s = message ("%q %q", s, declaratorNode_unparse (i->declarator));
	first = FALSE;
      }
    else
      {
	s = message ("%q, %q", s, declaratorNode_unparse (i->declarator));
      }
  } end_initDeclNodeList_elements;
  
  return (message ("%q;", s));
}

extern void
lhCleanup (void)
   /*@modifies fileSystem@*/
{
  if (!genLh)
    {
      return;
    }
  else
    {
      FILE *f;
      int c, col = 0, tabcol = 0;
      cstring fullname;

      f = out_open (LhFile.name, LH_EXTENSION);
      llassert (LhFile.f != NULL);
      
      fullname = cstring_concat (LhFile.name, LHTMP_EXTENSION);

      if (f == NULL)
	{
	  /*@i25534  check this!  does it report the right filename? */
	  lldiagmsg (message ("Cannot open lh file for output: %s", 
			      fullname));
	}
      else
	{
	  fprintf (f, "/* Output from %s */\n", LCL_PARSE_VERSION);

	  rewind (LhFile.f);

	  while (EOF != (c = getc (LhFile.f)))
	    {
	      switch (c)
		{
		case TABCH:
		  if (col == 0)
		    {
		      if (tabcol > 0)
			fprintf (f, "%*s", tabcol, "");
		    }
		  else
		    {
		      check (fputc (' ', f) == (int) ' ');
		    }
		  /*@switchbreak@*/ break;
		  
		case TABINCH:
		  tabcol += 4;
		  /*@switchbreak@*/ break;
		  
		case TABOUTCH:
		  tabcol -= 4;
		  /*@switchbreak@*/ break;
		  
		case '\n':
		  col = 0;
		  check (fputc (c, f) == (int) c);
		  /*@switchbreak@*/ break;
		  
		default:
		  col++;
		  check (fputc (c, f) == (int) c);
		  /*@switchbreak@*/ break;
		}
	    }

	  check (fileTable_closeFile (context_fileTable (), f));
	  check (fileTable_closeFile (context_fileTable (), LhFile.f));

	  (void) osd_unlink (fullname);
	  LhFile.f = NULL;
	}
      
      cstring_free (fullname);
    }
}

/* Write an #include of bool.h if we have't done so already.  */
extern void
lhIncludeBool (void)
{
  needIncludeBool = TRUE;
}

/*
**++
**  FUNCTIONAL DESCRIPTION:
**
**      Initialize the .lh file processing.
**
**  FORMAL PARAMETERS:
**
**      source * f: The source file, from which we compute the name of
**	the .lh file.
**
**	bool outputLh: If true, produce a .lh file, otherwise don't.
**
**  RETURN VALUE:
**
**      None
**
**  SIDE EFFECTS:
**
**      The .lh file may be opened.
**
**
**--
*/

void lhInit (inputStream  f) /*@globals undef LhFile; @*/
{
  static bool lherror = FALSE;
  
  genLh = context_msgLh ();
  needIncludeBool = FALSE;

  if (!genLh)
    {
      return;
    }
  
  LhFile.name = LSLRootName (inputStream_fileName (f));
  LhFile.f = out_open (LhFile.name, LHTMP_EXTENSION);

  if (LhFile.f == NULL)
    {
      genLh = FALSE;
      if (!lherror)
	{
	  lclplainerror (message ("Cannot write temporary %s file: %s%s", 
				  LH_EXTENSION,
				  LhFile.name,
				  LHTMP_EXTENSION));
	  lherror = TRUE;
	}
    } 
} 

void lhOutLine (/*@only@*/ cstring s)
{
  if (genLh)
    {
      llassert (LhFile.f != NULL);

      if (cstring_length (s) > 0) 
	{
	  check (fputs (cstring_toCharsSafe (s), LhFile.f) != EOF); 
	}

      check (fputc ('\n', LhFile.f) == (int) '\n'); 
    }

  cstring_free (s);
}

void lhExternals (interfaceNodeList x)
{
  if (genLh)
    {
      llassert (LhFile.f != NULL);

      /*
      ** Need to make sure all standard library includes come first.
      */

      interfaceNodeList_elements (x, el)
	{
	  if (el->kind == INF_IMPORTS)
	    {
	      importNodeList imps = el->content.imports;

	      importNodeList_elements (imps, il)
		{
		  if (il->kind == IMPBRACKET)
		    {
		      lhOutLine (message ("# include <%s.h>", 
					  ltoken_getRawString (il->val)));
		    }
		} end_importNodeList_elements ;
	    }
	} end_interfaceNodeList_elements;

      lhOutLine (cstring_makeLiteral ("# include \"bool.h\""));
      
      interfaceNodeList_elements (x, el)
	{
	  if (el->kind == INF_IMPORTS)
	    {
	      importNodeList imps = el->content.imports;

	      importNodeList_elements (imps, il)
		{
		  if (il->kind != IMPBRACKET)
		    {
		      lhOutLine (message ("# include \"%s.h\"", 
					  ltoken_getRawString (il->val)));
		    }
		} end_importNodeList_elements ;
	    }
	} end_interfaceNodeList_elements;

      lhOutLine (cstring_undefined);
    }
}
Commit	Line	Data
616915dd	1	/*
11db3170	2	** Splint - annotation-assisted static program checker
77d37419	3	** Copyright (C) 1994-2002 University of Virginia,
616915dd	4	** Massachusetts Institute of Technology
	5	**
	6	** This program is free software; you can redistribute it and/or modify it
	7	** under the terms of the GNU General Public License as published by the
	8	** Free Software Foundation; either version 2 of the License, or (at your
	9	** option) any later version.
	10	**
	11	** This program is distributed in the hope that it will be useful, but
	12	** WITHOUT ANY WARRANTY; without even the implied warranty of
	13	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	** General Public License for more details.
	15	**
	16	** The GNU General Public License is available from http://www.gnu.org/ or
	17	** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	18	** MA 02111-1307, USA.
	19	**
	20	** For information on lclint: lclint-request@cs.virginia.edu
	21	** To report a bug: lclint-bug@cs.virginia.edu
11db3170	22	** For more information: http://www.splint.org
616915dd	23	*/
	24	/*
	25	** lh.c
	26	**
	27	** MODULE DESCRIPTION:
	28	**
	29	** This module contains the I/O routines for writing out the .lh file
	30	** generated from the .lcl file.
	31	**
	32	** AUTHORS:
	33	**
	34	** Gary Feldman, Technical Languages and Environments, DECspec project
	35	** Yang Meng Tan, MIT.
	36	**
	37	** CREATION DATE: 9 April 91
	38	**
	39	** The lh.c module controls formatting policy.
	40	*/
	41
	42	# include "lclintMacros.nf"
	43	# include "llbasic.h"
	44	# include "osd.h"
616915dd	45	# include "lh.h"
	46	# include "llmain.h"
	47
	48	/@constant static char TABCH; @/
	49	# define TABCH '\1'
	50
	51	/@constant static char TABINCH; @/
	52	# define TABINCH '\2'
	53
	54	/@constant static char TABOUTCH; @/
	55	# define TABOUTCH '\3'
	56
616915dd	57	/*
	58	# define TAB fputc (TABCH, LhFile.f);
	59	# define TABIN fputc (TABINCH, LhFile.f);
	60	# define TABOUT fputc (TABOUTCH, LhFile.f);
	61	*/
	62
28bf4b0b	63	/@private@/ typedef struct
616915dd	64	{
15b3d2b2	65	/:open:/ /@dependent@/ /@null@/ /@reldef@/ FILE *f;
28bf4b0b	66	/@reldef@/ cstring name;
616915dd	67	} outFile;
	68
	69	static bool genLh;
	70	static outFile LhFile;
	71	static bool needIncludeBool = FALSE;
	72
	73	/*
	74	**
	75	** FORWARD FUNCTIONS
	76	**
	77	*/
	78
	79	/* static int colpos (int startcol, cstring line); */
	80
	81	static cstring lhTypeSpecNode (lclTypeSpecNode p_typespec);
	82	static /@only@/ cstring lhTypeExpr (/@null@/ typeExpr p_x);
	83	static /@only@/ cstring lhDeclaratorNode (declaratorNode p_x);
	84
15b3d2b2	85	static /:open:/ /@dependent@/ /@null@/ FILE *out_open (cstring name, cstring suffix)
28bf4b0b	86	/@modifies fileSystem@/
616915dd	87	{
28bf4b0b	88	cstring fullname = cstring_concat (name, suffix);
dfd82dce	89	FILE *ret = fileTable_openFile (context_fileTable (), fullname, "w+");
28bf4b0b	90	cstring_free (fullname);
616915dd	91	return ret;
	92	}
	93
	94	/@only@/ cstring
	95	lhFunction (lclTypeSpecNode lclTypeSpec, declaratorNode declarator)
	96	{
	97	cstring s;
	98
	99	if (!genLh)
	100	return cstring_undefined;
	101
	102	s = message ("extern %q\1%q;", lhTypeSpecNode (lclTypeSpec),
	103	lhDeclaratorNode (declarator));
	104
	105	return s;
	106	}
	107
	108	static /@only@/ cstring
	109	lhDeclaratorNode (declaratorNode x)
	110	{
	111	return (lhTypeExpr (x->type));
	112	}
	113
	114	static /@only@/ cstring lhTypeExpr (/@null@/ typeExpr x)
	115	{
	116	cstring s = cstring_undefined; /* print out types in order of appearance in source */
	117	paramNodeList params;
	118	int i;
	119
	120	if (x != (typeExpr) 0)
	121	{
	122	cstring front = cstring_undefined;
	123	cstring back = cstring_undefined;
	124
	125	for (i = x->wrapped; i >= 1; i--)
	126	{
	127	front = cstring_appendChar (front, '(');
	128	back = cstring_appendChar (back, ')');
	129	}
	130
	131	switch (x->kind)
	132	{
	133	case TEXPR_BASE:
	134	s = message ("%q%s", s, ltoken_getRawString (x->content.base));
	135	break;
	136	case TEXPR_PTR:
	137	s = message ("%q*%q", s, lhTypeExpr (x->content.pointer));
	138	break;
	139	case TEXPR_ARRAY:
	140	s = message ("%q%q[%q]", s,
	141	lhTypeExpr (x->content.array.elementtype),
	142	termNode_unparse (x->content.array.size));
	143	break;
	144	case TEXPR_FCN:
	145	s = message ("%q%q (", s, lhTypeExpr (x->content.function.returntype));
	146	params = x->content.function.args;
	147
	148	if (!paramNodeList_empty (params))
	149	{
	150	s = message ("%q%q", s,
	151	paramNodeList_unparseComments (x->content.function.args));
	152	}
	153
	154	s = message ("%q)", s);
155	break;
156	}
157	s = message ("%q%q%q", front, s, back);
158	}
159	else
160	{
161	s = cstring_makeLiteral ("?");
162	}
163
164	return s;
165	}
166
167	extern void
168	lhForwardStruct (ltoken t)
169	{
170	if (!genLh)
171	return;
172
173	lhOutLine (message ("struct %s;", ltoken_unparse (t)));
174	}
175
176
177	extern void
178	lhForwardUnion (ltoken t)
179	{
180	if (!genLh)
181	return;
182
183	lhOutLine (message ("union %s;", ltoken_unparse (t)));
184	}
185
186	extern /@only@/ cstring
187	lhType (typeNode t)
188	{
189	if (!genLh)
190	return cstring_undefined;
191
192	if (t->kind == TK_EXPOSED)
193	{
194	exposedNode n = t->content.exposed;
195
196	if (n != (exposedNode) 0)
197	{
198	if (declaratorInvNodeList_size (n->decls) == 0)
199	{
200	/*
201	** Forward struct or union declaration
202	*/
203
204	return (cstring_appendChar (lhTypeSpecNode (n->type), ';'));
205	}
206	else
207	{
208	cstring s = cstring_undefined;
209
210	declaratorInvNodeList_elements (n->decls, d)
211	{
212	cstring name = declaratorNode_unparse (d->declarator);
213	cstring pname = declaratorNode_unparseCode (d->declarator);
214
215	s = message ("%q\n# ifndef EXPOSED_TYPE_%q\ntypedef %q %q;\n# endif\n",
216	s, pname, lhTypeSpecNode (n->type), name);
217	} end_declaratorInvNodeList_elements;
218
219	return s;
220	}
221	}
222	}
223
224	return cstring_undefined;
225	}
226
227	static /@only@/ cstring
228	lhTypeSpecNode (lclTypeSpecNode typespec)
229	{
230	if (!genLh)
231	{
232	return cstring_undefined;
233	}
234
235	return (lclTypeSpecNode_unparseComments (typespec));
236	}
237
238	/@only@/ cstring
239	lhVarDecl (lclTypeSpecNode lclTypeSpec, initDeclNodeList initDecls,
240	qualifierKind qualifier)
241	{
242	bool first = TRUE;
243	cstring s;
244
245	if (!genLh)
246	return cstring_undefined;
247
248	s = cstring_makeLiteral ("extern");
249
250	switch (qualifier)
251	{
252	case QLF_NONE:
253	break;
254	case QLF_CONST:
255	s = message ("%q const", s);
256	break;
257	case QLF_VOLATILE:
258	s = message ("%q volatile", s);
259	break;
260	default: /* ignore it */
261	break;
262	}
263
264	s = message ("%q %q\1", s, lhTypeSpecNode (lclTypeSpec));
265
266	initDeclNodeList_elements (initDecls, i)
267	{
268	if (first)
269	{
270	s = message ("%q %q", s, declaratorNode_unparse (i->declarator));
271	first = FALSE;
272	}
273	else
274	{
275	s = message ("%q, %q", s, declaratorNode_unparse (i->declarator));
276	}
277	} end_initDeclNodeList_elements;
278
279	return (message ("%q;", s));
280	}
281
282	extern void
283	lhCleanup (void)
284	/@modifies fileSystem@/
285	{
286	if (!genLh)
287	{
288	return;
289	}
290	else
291	{
292	FILE *f;
293	int c, col = 0, tabcol = 0;
28bf4b0b	294	cstring fullname;
616915dd	295
28bf4b0b	296	f = out_open (LhFile.name, LH_EXTENSION);
616915dd	297	llassert (LhFile.f != NULL);
28bf4b0b	298
28bf4b0b	299	fullname = cstring_concat (LhFile.name, LHTMP_EXTENSION);
616915dd	300
	301	if (f == NULL)
	302	{
28bf4b0b	303	/@i25534 check this! does it report the right filename? /
616915dd	304	lldiagmsg (message ("Cannot open lh file for output: %s",
28bf4b0b	305	fullname));
616915dd	306	}
	307	else
	308	{
	309	fprintf (f, "/* Output from %s */\n", LCL_PARSE_VERSION);
	310
	311	rewind (LhFile.f);
	312
	313	while (EOF != (c = getc (LhFile.f)))
	314	{
	315	switch (c)
	316	{
	317	case TABCH:
	318	if (col == 0)
	319	{
	320	if (tabcol > 0)
	321	fprintf (f, "%*s", tabcol, "");
	322	}
	323	else
	324	{
	325	check (fputc (' ', f) == (int) ' ');
	326	}
	327	/@switchbreak@/ break;
	328
	329	case TABINCH:
	330	tabcol += 4;
	331	/@switchbreak@/ break;
	332
	333	case TABOUTCH:
	334	tabcol -= 4;
	335	/@switchbreak@/ break;
	336
	337	case '\n':
	338	col = 0;
	339	check (fputc (c, f) == (int) c);
	340	/@switchbreak@/ break;
	341
	342	default:
	343	col++;
	344	check (fputc (c, f) == (int) c);
	345	/@switchbreak@/ break;
	346	}
	347	}
	348
dfd82dce	349	check (fileTable_closeFile (context_fileTable (), f));
dfd82dce	350	check (fileTable_closeFile (context_fileTable (), LhFile.f));
616915dd	351
	352	(void) osd_unlink (fullname);
	353	LhFile.f = NULL;
	354	}
	355
28bf4b0b	356	cstring_free (fullname);
616915dd	357	}
	358	}
	359
	360	/* Write an #include of bool.h if we have't done so already. */
	361	extern void
	362	lhIncludeBool (void)
	363	{
	364	needIncludeBool = TRUE;
	365	}
	366
	367	/*
	368	**++
	369	** FUNCTIONAL DESCRIPTION:
	370	**
	371	** Initialize the .lh file processing.
	372	**
	373	** FORMAL PARAMETERS:
	374	**
	375	** source * f: The source file, from which we compute the name of
	376	** the .lh file.
	377	**
	378	** bool outputLh: If true, produce a .lh file, otherwise don't.
	379	**
	380	** RETURN VALUE:
	381	**
	382	** None
	383	**
	384	** SIDE EFFECTS:
	385	**
	386	** The .lh file may be opened.
	387	**
	388	**
	389	**--
	390	*/
	391
28bf4b0b	392	void lhInit (inputStream f) /@globals undef LhFile; @/
616915dd	393	{
	394	static bool lherror = FALSE;
	395
	396	genLh = context_msgLh ();
	397	needIncludeBool = FALSE;
	398
	399	if (!genLh)
	400	{
	401	return;
	402	}
	403
28bf4b0b	404	LhFile.name = LSLRootName (inputStream_fileName (f));
28bf4b0b	405	LhFile.f = out_open (LhFile.name, LHTMP_EXTENSION);
616915dd	406
	407	if (LhFile.f == NULL)
	408	{
	409	genLh = FALSE;
	410	if (!lherror)
	411	{
28bf4b0b	412	lclplainerror (message ("Cannot write temporary %s file: %s%s",
	413	LH_EXTENSION,
	414	LhFile.name,
	415	LHTMP_EXTENSION));
616915dd	416	lherror = TRUE;
	417	}
	418	}
	419	}
	420
	421	void lhOutLine (/@only@/ cstring s)
	422	{
	423	if (genLh)
	424	{
	425	llassert (LhFile.f != NULL);
	426
	427	if (cstring_length (s) > 0)
	428	{
	429	check (fputs (cstring_toCharsSafe (s), LhFile.f) != EOF);
	430	}
	431
	432	check (fputc ('\n', LhFile.f) == (int) '\n');
	433	}
	434
	435	cstring_free (s);
	436	}
	437
	438	void lhExternals (interfaceNodeList x)
	439	{
	440	if (genLh)
	441	{
	442	llassert (LhFile.f != NULL);
	443
	444	/*
	445	** Need to make sure all standard library includes come first.
	446	*/
	447
	448	interfaceNodeList_elements (x, el)
	449	{
	450	if (el->kind == INF_IMPORTS)
	451	{
	452	importNodeList imps = el->content.imports;
	453
	454	importNodeList_elements (imps, il)
	455	{
	456	if (il->kind == IMPBRACKET)
	457	{
	458	lhOutLine (message ("# include <%s.h>",
	459	ltoken_getRawString (il->val)));
	460	}
	461	} end_importNodeList_elements ;
	462	}
	463	} end_interfaceNodeList_elements;
	464
	465	lhOutLine (cstring_makeLiteral ("# include \"bool.h\""));
	466
	467	interfaceNodeList_elements (x, el)
	468	{
	469	if (el->kind == INF_IMPORTS)
	470	{
	471	importNodeList imps = el->content.imports;
	472
	473	importNodeList_elements (imps, il)
	474	{
	475	if (il->kind != IMPBRACKET)
	476	{
	477	lhOutLine (message ("# include \"%s.h\"",
	478	ltoken_getRawString (il->val)));
	479	}
480	} end_importNodeList_elements ;
481	}
482	} end_interfaceNodeList_elements;
483
484	lhOutLine (cstring_undefined);
485	}
486	}
487
488
489