[splint.git] / src / lh.c

/*
** LCLint - annotation-assisted static program checker
** Copyright (C) 1994-2000 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://lclint.cs.virginia.edu
*/
/*
** 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 "herald.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'

/*@constant static observer char *LHTMP_SUFFIX; @*/
# define LHTMP_SUFFIX ".lh_tmp"

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

typedef struct
{
  /*@dependent@*/ /*@null@*/ /*@reldef@*/ FILE *f;
  /*@reldef@*/ char *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 /*@dependent@*/ /*@null@*/ FILE *out_open (char *name, char *suffix) /*@modifies fileSystem@*/
{
  char *fullname = (char *)
    mstring_create (size_toInt (strlen (name) + strlen (suffix)));
  FILE *ret;

  strcpy (fullname, name);
  strcat (fullname, suffix);
  ret = fopen (fullname, "w+");
  sfree (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;
      char *fullname;

      
      fullname = mstring_create 
	(size_toInt (strlen (LhFile.name) + strlen (LHTMP_SUFFIX)));

      f = out_open (LhFile.name, LH_SUFFIX);
      llassert (LhFile.f != NULL);

      strcpy (fullname, LhFile.name);
      strcat (fullname, LHTMP_SUFFIX);

      if (f == NULL)
	{
	  lldiagmsg (message ("Cannot open lh file for output: %s", 
			      cstring_fromChars (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 (fclose (f) == 0);
	  check (fclose (LhFile.f) == 0);

	  (void) osd_unlink (fullname);
	  LhFile.f = NULL;
	}
      
      sfree (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 (tsource * f) /*@globals undef LhFile; @*/
{
  static bool lherror = FALSE;
  
  genLh = context_msgLh ();
  needIncludeBool = FALSE;

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

  if (LhFile.f == NULL)
    {
      genLh = FALSE;
      if (!lherror)
	{
	  lclplainerror (message ("Cannot write .lh file: %s.lh", 
				  cstring_fromChars (LhFile.name)));
	  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	/*
	2	** LCLint - annotation-assisted static program checker
	3	** Copyright (C) 1994-2000 University of Virginia,
	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
	22	** For more information: http://lclint.cs.virginia.edu
	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"
	45	# include "herald.h"
	46	# include "lh.h"
	47	# include "llmain.h"
	48
	49	/@constant static char TABCH; @/
	50	# define TABCH '\1'
	51
	52	/@constant static char TABINCH; @/
	53	# define TABINCH '\2'
	54
	55	/@constant static char TABOUTCH; @/
	56	# define TABOUTCH '\3'
	57
	58	/@constant static observer char LHTMP_SUFFIX; @*/
	59	# define LHTMP_SUFFIX ".lh_tmp"
	60
	61	/*
	62	# define TAB fputc (TABCH, LhFile.f);
	63	# define TABIN fputc (TABINCH, LhFile.f);
	64	# define TABOUT fputc (TABOUTCH, LhFile.f);
65	*/
66
67	typedef struct
68	{
69	/@dependent@/ /@null@/ /@reldef@/ FILE *f;
70	/@reldef@/ char *name;
71	} outFile;
72
73	static bool genLh;
74	static outFile LhFile;
75	static bool needIncludeBool = FALSE;
76
77	/*
78	**
79	** FORWARD FUNCTIONS
80	**
81	*/
82
83	/* static int colpos (int startcol, cstring line); */
84
85	static cstring lhTypeSpecNode (lclTypeSpecNode p_typespec);
86	static /@only@/ cstring lhTypeExpr (/@null@/ typeExpr p_x);
87	static /@only@/ cstring lhDeclaratorNode (declaratorNode p_x);
88
89	static /@dependent@/ /@null@/ FILE out_open (char name, char suffix) /@modifies fileSystem@*/
90	{
91	char fullname = (char )
92	mstring_create (size_toInt (strlen (name) + strlen (suffix)));
93	FILE *ret;
94
95	strcpy (fullname, name);
96	strcat (fullname, suffix);
97	ret = fopen (fullname, "w+");
98	sfree (fullname);
99	return ret;
100	}
101
102	/@only@/ cstring
103	lhFunction (lclTypeSpecNode lclTypeSpec, declaratorNode declarator)
104	{
105	cstring s;
106
107	if (!genLh)
108	return cstring_undefined;
109
110	s = message ("extern %q\1%q;", lhTypeSpecNode (lclTypeSpec),
111	lhDeclaratorNode (declarator));
112
113	return s;
114	}
115
116	static /@only@/ cstring
117	lhDeclaratorNode (declaratorNode x)
118	{
119	return (lhTypeExpr (x->type));
120	}
121
122	static /@only@/ cstring lhTypeExpr (/@null@/ typeExpr x)
123	{
124	cstring s = cstring_undefined; /* print out types in order of appearance in source */
125	paramNodeList params;
126	int i;
127
128	if (x != (typeExpr) 0)
129	{
130	cstring front = cstring_undefined;
131	cstring back = cstring_undefined;
132
133	for (i = x->wrapped; i >= 1; i--)
134	{
135	front = cstring_appendChar (front, '(');
136	back = cstring_appendChar (back, ')');
137	}
138
139	switch (x->kind)
140	{
141	case TEXPR_BASE:
142	s = message ("%q%s", s, ltoken_getRawString (x->content.base));
143	break;
144	case TEXPR_PTR:
145	s = message ("%q*%q", s, lhTypeExpr (x->content.pointer));
146	break;
147	case TEXPR_ARRAY:
148	s = message ("%q%q[%q]", s,
149	lhTypeExpr (x->content.array.elementtype),
150	termNode_unparse (x->content.array.size));
151	break;
152	case TEXPR_FCN:
153	s = message ("%q%q (", s, lhTypeExpr (x->content.function.returntype));
154	params = x->content.function.args;
155
156	if (!paramNodeList_empty (params))
157	{
158	s = message ("%q%q", s,
159	paramNodeList_unparseComments (x->content.function.args));
160	}
161
162	s = message ("%q)", s);
163	break;
164	}
165	s = message ("%q%q%q", front, s, back);
166	}
167	else
168	{
169	s = cstring_makeLiteral ("?");
170	}
171
172	return s;
173	}
174
175	extern void
176	lhForwardStruct (ltoken t)
177	{
178	if (!genLh)
179	return;
180
181	lhOutLine (message ("struct %s;", ltoken_unparse (t)));
182	}
183
184
185	extern void
186	lhForwardUnion (ltoken t)
187	{
188	if (!genLh)
189	return;
190
191	lhOutLine (message ("union %s;", ltoken_unparse (t)));
192	}
193
194	extern /@only@/ cstring
195	lhType (typeNode t)
196	{
197	if (!genLh)
198	return cstring_undefined;
199
200	if (t->kind == TK_EXPOSED)
201	{
202	exposedNode n = t->content.exposed;
203
204	if (n != (exposedNode) 0)
205	{
206	if (declaratorInvNodeList_size (n->decls) == 0)
207	{
208	/*
209	** Forward struct or union declaration
210	*/
211
212	return (cstring_appendChar (lhTypeSpecNode (n->type), ';'));
213	}
214	else
215	{
216	cstring s = cstring_undefined;
217
218	declaratorInvNodeList_elements (n->decls, d)
219	{
220	cstring name = declaratorNode_unparse (d->declarator);
221	cstring pname = declaratorNode_unparseCode (d->declarator);
222
223	s = message ("%q\n# ifndef EXPOSED_TYPE_%q\ntypedef %q %q;\n# endif\n",
224	s, pname, lhTypeSpecNode (n->type), name);
225	} end_declaratorInvNodeList_elements;
226
227	return s;
228	}
229	}
230	}
231
232	return cstring_undefined;
233	}
234
235	static /@only@/ cstring
236	lhTypeSpecNode (lclTypeSpecNode typespec)
237	{
238	if (!genLh)
239	{
240	return cstring_undefined;
241	}
242
243	return (lclTypeSpecNode_unparseComments (typespec));
244	}
245
246	/@only@/ cstring
247	lhVarDecl (lclTypeSpecNode lclTypeSpec, initDeclNodeList initDecls,
248	qualifierKind qualifier)
249	{
250	bool first = TRUE;
251	cstring s;
252
253	if (!genLh)
254	return cstring_undefined;
255
256	s = cstring_makeLiteral ("extern");
257
258	switch (qualifier)
259	{
260	case QLF_NONE:
261	break;
262	case QLF_CONST:
263	s = message ("%q const", s);
264	break;
265	case QLF_VOLATILE:
266	s = message ("%q volatile", s);
267	break;
268	default: /* ignore it */
269	break;
270	}
271
272	s = message ("%q %q\1", s, lhTypeSpecNode (lclTypeSpec));
273
274	initDeclNodeList_elements (initDecls, i)
275	{
276	if (first)
277	{
278	s = message ("%q %q", s, declaratorNode_unparse (i->declarator));
279	first = FALSE;
280	}
281	else
282	{
283	s = message ("%q, %q", s, declaratorNode_unparse (i->declarator));
284	}
285	} end_initDeclNodeList_elements;
286
287	return (message ("%q;", s));
288	}
289
290	extern void
291	lhCleanup (void)
292	/@modifies fileSystem@/
293	{
294	if (!genLh)
295	{
296	return;
297	}
298	else
299	{
300	FILE *f;
301	int c, col = 0, tabcol = 0;
302	char *fullname;
303
304
305	fullname = mstring_create
306	(size_toInt (strlen (LhFile.name) + strlen (LHTMP_SUFFIX)));
307
308	f = out_open (LhFile.name, LH_SUFFIX);
309	llassert (LhFile.f != NULL);
310
311	strcpy (fullname, LhFile.name);
312	strcat (fullname, LHTMP_SUFFIX);
313
314	if (f == NULL)
315	{
316	lldiagmsg (message ("Cannot open lh file for output: %s",
317	cstring_fromChars (fullname)));
318	}
319	else
320	{
321	fprintf (f, "/* Output from %s */\n", LCL_PARSE_VERSION);
322
323	rewind (LhFile.f);
324
325	while (EOF != (c = getc (LhFile.f)))
326	{
327	switch (c)
328	{
329	case TABCH:
330	if (col == 0)
331	{
332	if (tabcol > 0)
333	fprintf (f, "%*s", tabcol, "");
334	}
335	else
336	{
337	check (fputc (' ', f) == (int) ' ');
338	}
339	/@switchbreak@/ break;
340
341	case TABINCH:
342	tabcol += 4;
343	/@switchbreak@/ break;
344
345	case TABOUTCH:
346	tabcol -= 4;
347	/@switchbreak@/ break;
348
349	case '\n':
350	col = 0;
351	check (fputc (c, f) == (int) c);
352	/@switchbreak@/ break;
353
354	default:
355	col++;
356	check (fputc (c, f) == (int) c);
357	/@switchbreak@/ break;
358	}
359	}
360
361	check (fclose (f) == 0);
362	check (fclose (LhFile.f) == 0);
363
364	(void) osd_unlink (fullname);
365	LhFile.f = NULL;
366	}
367
368	sfree (fullname);
369	}
370	}
371
372	/* Write an #include of bool.h if we have't done so already. */
373	extern void
374	lhIncludeBool (void)
375	{
376	needIncludeBool = TRUE;
377	}
378
379	/*
380	**++
381	** FUNCTIONAL DESCRIPTION:
382	**
383	** Initialize the .lh file processing.
384	**
385	** FORMAL PARAMETERS:
386	**
387	** source * f: The source file, from which we compute the name of
388	** the .lh file.
389	**
390	** bool outputLh: If true, produce a .lh file, otherwise don't.
391	**
392	** RETURN VALUE:
393	**
394	** None
395	**
396	** SIDE EFFECTS:
397	**
398	** The .lh file may be opened.
399	**
400	**
401	**--
402	*/
403
404	void lhInit (tsource * f) /@globals undef LhFile; @/
405	{
406	static bool lherror = FALSE;
407
408	genLh = context_msgLh ();
409	needIncludeBool = FALSE;
410
411	if (!genLh)
412	{
413	return;
414	}
415
416	LhFile.name = LSLRootName (tsource_fileName (f));
417	LhFile.f = out_open (LhFile.name, LHTMP_SUFFIX);
418
419	if (LhFile.f == NULL)
420	{
421	genLh = FALSE;
422	if (!lherror)
423	{
424	lclplainerror (message ("Cannot write .lh file: %s.lh",
425	cstring_fromChars (LhFile.name)));
426	lherror = TRUE;
427	}
428	}
429	}
430
431	void lhOutLine (/@only@/ cstring s)
432	{
433	if (genLh)
434	{
435	llassert (LhFile.f != NULL);
436
437	if (cstring_length (s) > 0)
438	{
439	check (fputs (cstring_toCharsSafe (s), LhFile.f) != EOF);
440	}
441
442	check (fputc ('\n', LhFile.f) == (int) '\n');
443	}
444
445	cstring_free (s);
446	}
447
448	void lhExternals (interfaceNodeList x)
449	{
450	if (genLh)
451	{
452	llassert (LhFile.f != NULL);
453
454	/*
455	** Need to make sure all standard library includes come first.
456	*/
457
458	interfaceNodeList_elements (x, el)
459	{
460	if (el->kind == INF_IMPORTS)
461	{
462	importNodeList imps = el->content.imports;
463
464	importNodeList_elements (imps, il)
465	{
466	if (il->kind == IMPBRACKET)
467	{
468	lhOutLine (message ("# include <%s.h>",
469	ltoken_getRawString (il->val)));
470	}
471	} end_importNodeList_elements ;
472	}
473	} end_interfaceNodeList_elements;
474
475	lhOutLine (cstring_makeLiteral ("# include \"bool.h\""));
476
477	interfaceNodeList_elements (x, el)
478	{
479	if (el->kind == INF_IMPORTS)
480	{
481	importNodeList imps = el->content.imports;
482
483	importNodeList_elements (imps, il)
484	{
485	if (il->kind != IMPBRACKET)
486	{
487	lhOutLine (message ("# include \"%s.h\"",
488	ltoken_getRawString (il->val)));
489	}
490	} end_importNodeList_elements ;
491	}
492	} end_interfaceNodeList_elements;
493
494	lhOutLine (cstring_undefined);
495	}
496	}
497
498
499