[splint.git] / src / mtscanner.c

/*
** LCLint - annotation-assisted static program checker
** Copyright (C) 1994-2001 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
*/
/*
** mtscanner.c
**
** Because flex is so lame, we can't use two flex scanners at once.  Instead,
** we have to write a manual scanner.  Should look into some real parser 
** generator tools one day...
*/

# include "lclintMacros.nf"
# include "llbasic.h"
# include "mtgrammar.h"
# include "mtscanner.h"

static inputStream scanFile;  /* file to scan */
static mttok mtscanner_getNextToken (void);
static /*@only@*/ cstringTable tokenTable = cstringTable_undefined;
static bool isInitialized = FALSE;

/*@constant int MT_TOKENTABLESIZE@*/
# define MT_TOKENTABLESIZE 64

static void mtscanner_initMod (void)
{
  llassert (cstringTable_isUndefined (tokenTable));
  tokenTable = cstringTable_create (MT_TOKENTABLESIZE);

  cstringTable_insert (tokenTable, cstring_makeLiteral ("attribute"), MT_STATE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("global"), MT_GLOBAL);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("context"), MT_CONTEXT);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("oneof"), MT_ONEOF);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("defaults"), MT_DEFAULTS);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("default"), MT_DEFAULT);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("parameter"), MT_PARAMETER);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("result"), MT_RESULT);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("literal"), MT_LITERAL);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("null"), MT_NULL);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("reference"), MT_REFERENCE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("clause"), MT_CLAUSE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("annotations"), MT_ANNOTATIONS);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("merge"), MT_MERGE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("transfers"), MT_TRANSFERS);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("preconditions"), MT_PRECONDITIONS);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("postconditions"), MT_POSTCONDITIONS);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("losereference"), MT_LOSEREFERENCE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("error"), MT_ERROR);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("end"), MT_END);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("as"), MT_AS);

  /*
  ** C Types
  */

  cstringTable_insert (tokenTable, cstring_makeLiteral ("char"), MT_CHAR);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("int"), MT_INT);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("float"), MT_FLOAT);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("double"), MT_DOUBLE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("void"), MT_VOID);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("anytype"), MT_ANYTYPE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("integraltype"), MT_INTEGRALTYPE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("unsignedintegraltype"), MT_UNSIGNEDINTEGRALTYPE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("signedintegraltype"), MT_SIGNEDINTEGRALTYPE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("const"), MT_CONST);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("volatile"), MT_VOLATILE);

  /*
  ** Punctuation
  */

  cstringTable_insert (tokenTable, cstring_makeLiteral ("==>"), MT_ARROW);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("+"), MT_PLUS);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("*"), MT_STAR);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("{"), MT_LBRACE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("}"), MT_RBRACE);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("("), MT_LPAREN);
  cstringTable_insert (tokenTable, cstring_makeLiteral (")"), MT_RPAREN);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("["), MT_LBRACKET);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("]"), MT_RBRACKET);
  cstringTable_insert (tokenTable, cstring_makeLiteral (","), MT_COMMA);
  cstringTable_insert (tokenTable, cstring_makeLiteral ("|"), MT_BAR);

  isInitialized = TRUE;
}

void mtscanner_reset (inputStream sourceFile)
{
  if (!isInitialized) 
    {
      mtscanner_initMod ();
    }

  scanFile = sourceFile;
}

int mtlex (YYSTYPE *mtlval)
{
  llassert (isInitialized);

  /* This is important!  Bison expects this */

  /*@ignore@*/
  mtlval->tok = mtscanner_getNextToken ();
  DPRINTF (("Return token: %s", mttok_unparse (mtlval->tok)));
  llassert (fileloc_isDefined (mttok_getLoc (mtlval->tok)));
  return (mttok_getTok (mtlval->tok));
  /*@end@*/
}

static void skipComments (void)
{
  int tchar;
  bool gotone = FALSE;
  tchar = inputStream_peekChar (scanFile);

  if (tchar == (int) '/' && inputStream_peekNChar (scanFile, 1) == (int) '*') 
    {
      check ((int) '/' == inputStream_nextChar (scanFile));
      check ((int) '*' == inputStream_nextChar (scanFile));
      
      while ((tchar = inputStream_nextChar (scanFile)) != EOF) 
	{
	  if (tchar == (int) '*' && inputStream_peekChar (scanFile) == (int) '/')
	    {
	      tchar = inputStream_nextChar (scanFile);
	      break;
	    }
	}

      if (tchar == EOF)
	{
	  llfatalerror 
	    (cstring_makeLiteral ("Reached end of metastate file inside comment."));
	  BADBRANCH;
	}
      else
	{
	  check ((int) '/' == tchar);
	  gotone = TRUE;
	}
    }

  if (isspace (tchar)) 
    {
      while (isspace (inputStream_peekChar (scanFile)))
	{
	  tchar = inputStream_nextChar (scanFile);
	}

      gotone = TRUE;
    }

  if (gotone)
    {
      /* If there was a comment or whitespace, need to skip again... */
      skipComments ();
    }
}

static mttok mtscanner_getNextToken ()
{
  int tchar;
  int mtcode;
  cstring tok;
  mttok res;
  fileloc loc;

  skipComments ();
  loc = fileloc_copy (g_currentloc);
  tchar = inputStream_nextChar (scanFile);

  if (tchar == EOF) 
    {
      return mttok_create (EOF, cstring_undefined, loc);
    }

  tok = cstring_newEmpty ();

  DPRINTF (("tchar: %c", (char) tchar));

  if (tchar == (int) '\"') 
    {
      bool escaped = FALSE;

      /* String literal */
      while ((tchar = inputStream_peekChar (scanFile)) != EOF) {
	if (escaped) {
	  escaped = FALSE;
	} else if (tchar == (int) '\\') {
	  escaped = TRUE;
	} else if (tchar == (int) '\"') {
	  break;
	} else {
	  ;
	}

	tok = cstring_appendChar (tok, (char) tchar);
	check (tchar == inputStream_nextChar (scanFile));
      }

      if (tchar == EOF)
	{
	  llfatalerror 
	    (cstring_makeLiteral ("Reached end of metastate file inside string literal."));
	}
      else
	{
	  check ((int) '\"' == inputStream_nextChar (scanFile));
	  return mttok_create (MT_STRINGLIT, tok, loc);
	}
    }
  
  tok = cstring_appendChar (tok, (char) tchar);

  DPRINTF (("tok: %s", tok));

  if (isalpha (tchar)) 
    {
      while ((tchar = inputStream_peekChar (scanFile)) != EOF) {
	if (!isalnum (tchar) && (tchar != (int) '_') && (tchar != (int) '$')) {
	  break;
	}
	
	tok = cstring_appendChar (tok, (char) tchar);
	check (tchar == inputStream_nextChar (scanFile));
      }

      mtcode = cstringTable_lookup (tokenTable, tok);

      if (mtcode == NOT_FOUND) {
	DPRINTF (("Returning identifier: %s", tok));
	return mttok_create (MT_IDENT, tok, loc);
      }
    } 
  else 
    {
      /* Read until next space */
      DPRINTF (("Here we are: %s", tok));

      while ((tchar = inputStream_peekChar (scanFile)) != EOF) {
	if (isspace (tchar) || isalnum (tchar)) {
	  break;
	}
	
	tok = cstring_appendChar (tok, (char) tchar);
	DPRINTF (("Here we are: %s", tok));
	check (tchar == inputStream_nextChar (scanFile));
      }

      DPRINTF (("Here we are: [%s]", tok));
      mtcode = cstringTable_lookup (tokenTable, tok);
      
      if (mtcode == NOT_FOUND) {
	mtcode = MT_BADTOK;
      }
    }
  
  DPRINTF (("Read %s / %d", tok, mtcode));
  cstring_free (tok);

  res = mttok_create (mtcode, cstring_undefined, loc);
  DPRINTF (("Return token: %s", mttok_unparse (res)));
  return res;
}

ctype mtscanner_lookupType (mttok tok)
{
  cstring tname;
  uentry ue;

  llassert (mttok_isIdentifier (tok));
  tname = mttok_observeText (tok);

  DPRINTF (("Lookup type:  %s", tname));

  ue = usymtab_lookupSafe (tname);

  if (uentry_isValid (ue) && uentry_isDatatype (ue))
    {
      DPRINTF (("Found it: %s / %s", uentry_unparse (ue),
		ctype_unparse (uentry_getAbstractType (ue))));
    
      return uentry_getAbstractType (ue);
    }
  else
    {
      ctype ct;
      ue = uentry_makeDatatype (tname, ctype_unknown, MAYBE, MAYBE, mttok_stealLoc (tok));
      DPRINTF (("Making mts entry: %s", uentry_unparse (ue)));
      ct = usymtab_supForwardTypeEntry (ue);
      DPRINTF (("Type: %s", ctype_unparse (ct)));
      return ct;
    }
}
Commit	Line	Data
28bf4b0b	1	/*
	2	** LCLint - annotation-assisted static program checker
	3	** Copyright (C) 1994-2001 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	** mtscanner.c
	26	**
	27	** Because flex is so lame, we can't use two flex scanners at once. Instead,
	28	** we have to write a manual scanner. Should look into some real parser
	29	** generator tools one day...
	30	*/
	31
	32	# include "lclintMacros.nf"
b7b694d6	33	# include "llbasic.h"
28bf4b0b	34	# include "mtgrammar.h"
	35	# include "mtscanner.h"
	36
	37	static inputStream scanFile; /* file to scan */
	38	static mttok mtscanner_getNextToken (void);
	39	static /@only@/ cstringTable tokenTable = cstringTable_undefined;
	40	static bool isInitialized = FALSE;
	41
	42	/@constant int MT_TOKENTABLESIZE@/
	43	# define MT_TOKENTABLESIZE 64
	44
	45	static void mtscanner_initMod (void)
	46	{
	47	llassert (cstringTable_isUndefined (tokenTable));
	48	tokenTable = cstringTable_create (MT_TOKENTABLESIZE);
	49
e26e911c	50	cstringTable_insert (tokenTable, cstring_makeLiteral ("attribute"), MT_STATE);
28bf4b0b	51	cstringTable_insert (tokenTable, cstring_makeLiteral ("global"), MT_GLOBAL);
	52	cstringTable_insert (tokenTable, cstring_makeLiteral ("context"), MT_CONTEXT);
	53	cstringTable_insert (tokenTable, cstring_makeLiteral ("oneof"), MT_ONEOF);
	54	cstringTable_insert (tokenTable, cstring_makeLiteral ("defaults"), MT_DEFAULTS);
	55	cstringTable_insert (tokenTable, cstring_makeLiteral ("default"), MT_DEFAULT);
	56	cstringTable_insert (tokenTable, cstring_makeLiteral ("parameter"), MT_PARAMETER);
b072092f	57	cstringTable_insert (tokenTable, cstring_makeLiteral ("result"), MT_RESULT);
12f2ffe9	58	cstringTable_insert (tokenTable, cstring_makeLiteral ("literal"), MT_LITERAL);
12f2ffe9	59	cstringTable_insert (tokenTable, cstring_makeLiteral ("null"), MT_NULL);
28bf4b0b	60	cstringTable_insert (tokenTable, cstring_makeLiteral ("reference"), MT_REFERENCE);
	61	cstringTable_insert (tokenTable, cstring_makeLiteral ("clause"), MT_CLAUSE);
	62	cstringTable_insert (tokenTable, cstring_makeLiteral ("annotations"), MT_ANNOTATIONS);
	63	cstringTable_insert (tokenTable, cstring_makeLiteral ("merge"), MT_MERGE);
	64	cstringTable_insert (tokenTable, cstring_makeLiteral ("transfers"), MT_TRANSFERS);
	65	cstringTable_insert (tokenTable, cstring_makeLiteral ("preconditions"), MT_PRECONDITIONS);
	66	cstringTable_insert (tokenTable, cstring_makeLiteral ("postconditions"), MT_POSTCONDITIONS);
	67	cstringTable_insert (tokenTable, cstring_makeLiteral ("losereference"), MT_LOSEREFERENCE);
	68	cstringTable_insert (tokenTable, cstring_makeLiteral ("error"), MT_ERROR);
	69	cstringTable_insert (tokenTable, cstring_makeLiteral ("end"), MT_END);
	70	cstringTable_insert (tokenTable, cstring_makeLiteral ("as"), MT_AS);
	71
	72	/*
	73	** C Types
	74	*/
	75
	76	cstringTable_insert (tokenTable, cstring_makeLiteral ("char"), MT_CHAR);
	77	cstringTable_insert (tokenTable, cstring_makeLiteral ("int"), MT_INT);
	78	cstringTable_insert (tokenTable, cstring_makeLiteral ("float"), MT_FLOAT);
	79	cstringTable_insert (tokenTable, cstring_makeLiteral ("double"), MT_DOUBLE);
	80	cstringTable_insert (tokenTable, cstring_makeLiteral ("void"), MT_VOID);
	81	cstringTable_insert (tokenTable, cstring_makeLiteral ("anytype"), MT_ANYTYPE);
	82	cstringTable_insert (tokenTable, cstring_makeLiteral ("integraltype"), MT_INTEGRALTYPE);
	83	cstringTable_insert (tokenTable, cstring_makeLiteral ("unsignedintegraltype"), MT_UNSIGNEDINTEGRALTYPE);
	84	cstringTable_insert (tokenTable, cstring_makeLiteral ("signedintegraltype"), MT_SIGNEDINTEGRALTYPE);
	85	cstringTable_insert (tokenTable, cstring_makeLiteral ("const"), MT_CONST);
	86	cstringTable_insert (tokenTable, cstring_makeLiteral ("volatile"), MT_VOLATILE);
	87
	88	/*
	89	** Punctuation
	90	*/
	91
	92	cstringTable_insert (tokenTable, cstring_makeLiteral ("==>"), MT_ARROW);
	93	cstringTable_insert (tokenTable, cstring_makeLiteral ("+"), MT_PLUS);
	94	cstringTable_insert (tokenTable, cstring_makeLiteral ("*"), MT_STAR);
	95	cstringTable_insert (tokenTable, cstring_makeLiteral ("{"), MT_LBRACE);
	96	cstringTable_insert (tokenTable, cstring_makeLiteral ("}"), MT_RBRACE);
	97	cstringTable_insert (tokenTable, cstring_makeLiteral ("("), MT_LPAREN);
	98	cstringTable_insert (tokenTable, cstring_makeLiteral (")"), MT_RPAREN);
	99	cstringTable_insert (tokenTable, cstring_makeLiteral ("["), MT_LBRACKET);
	100	cstringTable_insert (tokenTable, cstring_makeLiteral ("]"), MT_RBRACKET);
	101	cstringTable_insert (tokenTable, cstring_makeLiteral (","), MT_COMMA);
	102	cstringTable_insert (tokenTable, cstring_makeLiteral ("\|"), MT_BAR);
	103
	104	isInitialized = TRUE;
	105	}
	106
	107	void mtscanner_reset (inputStream sourceFile)
	108	{
	109	if (!isInitialized)
	110	{
	111	mtscanner_initMod ();
	112	}
	113
	114	scanFile = sourceFile;
	115	}
	116
	117	int mtlex (YYSTYPE *mtlval)
	118	{
	119	llassert (isInitialized);
	120
	121	/* This is important! Bison expects this */
	122
	123	/@ignore@/
124	mtlval->tok = mtscanner_getNextToken ();
125	DPRINTF (("Return token: %s", mttok_unparse (mtlval->tok)));
126	llassert (fileloc_isDefined (mttok_getLoc (mtlval->tok)));
127	return (mttok_getTok (mtlval->tok));
128	/@end@/
129	}
130
131	static void skipComments (void)
132	{
133	int tchar;
134	bool gotone = FALSE;
135	tchar = inputStream_peekChar (scanFile);
136
137	if (tchar == (int) '/' && inputStream_peekNChar (scanFile, 1) == (int) '*')
138	{
139	check ((int) '/' == inputStream_nextChar (scanFile));
140	check ((int) '*' == inputStream_nextChar (scanFile));
141
142	while ((tchar = inputStream_nextChar (scanFile)) != EOF)
143	{
144	if (tchar == (int) '*' && inputStream_peekChar (scanFile) == (int) '/')
145	{
146	tchar = inputStream_nextChar (scanFile);
147	break;
148	}
149	}
150
151	if (tchar == EOF)
152	{
153	llfatalerror
154	(cstring_makeLiteral ("Reached end of metastate file inside comment."));
155	BADBRANCH;
156	}
157	else
158	{
159	check ((int) '/' == tchar);
160	gotone = TRUE;
161	}
162	}
163
164	if (isspace (tchar))
165	{
166	while (isspace (inputStream_peekChar (scanFile)))
167	{
168	tchar = inputStream_nextChar (scanFile);
169	}
170
171	gotone = TRUE;
172	}
173
174	if (gotone)
175	{
176	/* If there was a comment or whitespace, need to skip again... */
177	skipComments ();
178	}
179	}
180
181	static mttok mtscanner_getNextToken ()
182	{
183	int tchar;
184	int mtcode;
185	cstring tok;
186	mttok res;
187	fileloc loc;
188
189	skipComments ();
190	loc = fileloc_copy (g_currentloc);
191	tchar = inputStream_nextChar (scanFile);
192
193	if (tchar == EOF)
194	{
195	return mttok_create (EOF, cstring_undefined, loc);
196	}
197
198	tok = cstring_newEmpty ();
199
200	DPRINTF (("tchar: %c", (char) tchar));
201
202	if (tchar == (int) '\"')
203	{
204	bool escaped = FALSE;
205
206	/* String literal */
207	while ((tchar = inputStream_peekChar (scanFile)) != EOF) {
208	if (escaped) {
209	escaped = FALSE;
210	} else if (tchar == (int) '\\') {
211	escaped = TRUE;
212	} else if (tchar == (int) '\"') {
213	break;
214	} else {
215	;
216	}
217
218	tok = cstring_appendChar (tok, (char) tchar);
219	check (tchar == inputStream_nextChar (scanFile));
220	}
221
222	if (tchar == EOF)
223	{
224	llfatalerror
225	(cstring_makeLiteral ("Reached end of metastate file inside string literal."));
226	}
227	else
228	{
229	check ((int) '\"' == inputStream_nextChar (scanFile));
230	return mttok_create (MT_STRINGLIT, tok, loc);
231	}
232	}
233
234	tok = cstring_appendChar (tok, (char) tchar);
235
236	DPRINTF (("tok: %s", tok));
237
238	if (isalpha (tchar))
239	{
240	while ((tchar = inputStream_peekChar (scanFile)) != EOF) {
241	if (!isalnum (tchar) && (tchar != (int) '_') && (tchar != (int) '$')) {
242	break;
243	}
244
245	tok = cstring_appendChar (tok, (char) tchar);
246	check (tchar == inputStream_nextChar (scanFile));
247	}
248
249	mtcode = cstringTable_lookup (tokenTable, tok);
250
251	if (mtcode == NOT_FOUND) {
252	DPRINTF (("Returning identifier: %s", tok));
253	return mttok_create (MT_IDENT, tok, loc);
254	}
255	}
256	else
257	{
258	/* Read until next space */
259	DPRINTF (("Here we are: %s", tok));
260
261	while ((tchar = inputStream_peekChar (scanFile)) != EOF) {
262	if (isspace (tchar) \|\| isalnum (tchar)) {
263	break;
264	}
265
266	tok = cstring_appendChar (tok, (char) tchar);
267	DPRINTF (("Here we are: %s", tok));
268	check (tchar == inputStream_nextChar (scanFile));
269	}
270
271	DPRINTF (("Here we are: [%s]", tok));
272	mtcode = cstringTable_lookup (tokenTable, tok);
273
274	if (mtcode == NOT_FOUND) {
275	mtcode = MT_BADTOK;
276	}
277	}
278
279	DPRINTF (("Read %s / %d", tok, mtcode));
280	cstring_free (tok);
281
282	res = mttok_create (mtcode, cstring_undefined, loc);
283	DPRINTF (("Return token: %s", mttok_unparse (res)));
284	return res;
285	}
286
287	ctype mtscanner_lookupType (mttok tok)
288	{
289	cstring tname;
290	uentry ue;
291
292	llassert (mttok_isIdentifier (tok));
293	tname = mttok_observeText (tok);
294
295	DPRINTF (("Lookup type: %s", tname));
296
297	ue = usymtab_lookupSafe (tname);
298
299	if (uentry_isValid (ue) && uentry_isDatatype (ue))
300	{
301	DPRINTF (("Found it: %s / %s", uentry_unparse (ue),
302	ctype_unparse (uentry_getAbstractType (ue))));
303
304	return uentry_getAbstractType (ue);
305	}
306	else
307	{
308	ctype ct;
309	ue = uentry_makeDatatype (tname, ctype_unknown, MAYBE, MAYBE, mttok_stealLoc (tok));
310	DPRINTF (("Making mts entry: %s", uentry_unparse (ue)));
311	ct = usymtab_supForwardTypeEntry (ue);
312	DPRINTF (("Type: %s", ctype_unparse (ct)));
313	return ct;
314	}
315	}