[deliverable/binutils-gdb.git] / binutils / mclex.c

/* mclex.c -- lexer for Windows mc files parser.
   Copyright 2007
   Free Software Foundation, Inc.

   Written by Kai Tietz, Onevision.

   This file is part of GNU Binutils.

   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.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
   02110-1301, USA.  */

/* This is a lexer used by the Windows rc file parser.
   It basically just recognized a bunch of keywords.  */

#include "sysdep.h"
#include "bfd.h"
#include "bucomm.h"
#include "libiberty.h"
#include "safe-ctype.h"
#include "windmc.h"
#include "mcparse.h"

#include <assert.h>

/* Exported globals.  */
bfd_boolean mclex_want_nl = FALSE;
bfd_boolean mclex_want_line = FALSE;
bfd_boolean mclex_want_filename = FALSE;

/* Local globals.  */
static unichar *input_stream = NULL;
static unichar *input_stream_pos = NULL;
static int input_line = 1;
static const char *input_filename = NULL;

void
mc_set_content (const unichar *src)
{
  if (!src)
    return;
  input_stream = input_stream_pos = unichar_dup (src);
}

void
mc_set_inputfile (const char *name)
{
  if (! name || *name == 0)
    input_filename = "-";
  else
    {
      const char *s1 = strrchr (name, '/');
      const char *s2 = strrchr (name, '\\');

      if (! s1)
	s1 = s2;
      if (s1 && s2 && s1 < s2)
	s1 = s2;
      if (! s1)
	s1 = name;
      else
	s1++;
      s1 = xstrdup (s1);
      input_filename = s1;
    }
}

static void
show_msg (const char *kind, const char *msg, va_list argp)
{
  fprintf (stderr, "In %s at line %d: %s: ", input_filename, input_line, kind);
  vfprintf (stderr, msg, argp);
  fprintf (stderr, ".\n");
}

void
mc_warn (const char *s, ...)
{
  va_list argp;
  va_start (argp, s);
  show_msg ("warning", s, argp);
  va_end (argp);
}

void
mc_fatal (const char *s, ...)
{
  va_list argp;
  va_start (argp, s);
  show_msg ("fatal", s, argp);
  va_end (argp);
  xexit (1);
}


int
yyerror (const char *s, ...)
{
  va_list argp;
  va_start (argp, s);
  show_msg ("parser", s, argp);
  va_end (argp);
  return 1;
}

static unichar *
get_diff (unichar *end, unichar *start)
{
  unichar *ret;
  unichar save = *end;

  *end = 0;
  ret = unichar_dup (start);
  *end = save;
  return ret;
}

static rc_uint_type
parse_digit (unichar ch)
{
  rc_uint_type base = 10, v = 0, c;

  if (ch == '0')
    {
      base = 8;
      switch (input_stream_pos[0])
	{
	case 'x': case 'X': base = 16; input_stream_pos++; break;
	case 'o': case 'O': base = 8; input_stream_pos++; break;
	case 'b': case 'B': base = 2; input_stream_pos++; break;
	}
    }
  else
    v = (rc_uint_type) (ch - '0');

  while ((ch = input_stream_pos[0]) != 0)
    {
      if (ch >= 'A' && ch <= 'F')
	c = (rc_uint_type) (ch - 'A') + 10;
      else if (ch >= 'a' && ch <= 'f')
	c = (rc_uint_type) (ch - 'a') + 10;
      else if (ch >= '0' && ch <= '9')
	c = (rc_uint_type) (ch - '0');
      else
	break;
      v *= base;
      v += c;
      ++input_stream_pos;
    }
  if (input_stream_pos[0] == 'U' || input_stream_pos[0] == 'u')
    input_stream_pos++;
  if (input_stream_pos[0] == 'L' || input_stream_pos[0] == 'l')
    input_stream_pos++;
  if (input_stream_pos[0] == 'L' || input_stream_pos[0] == 'l')
    input_stream_pos++;
  return v;
}

static mc_keyword *keyword_top = NULL;

const mc_keyword *
enum_facility (int e)
{
  mc_keyword *h = keyword_top;

  while (h != NULL)
    {
      while (h && strcmp (h->group_name, "facility") != 0)
	h = h->next;
      if (e == 0)
	return h;
      --e;
      if (h)
	h = h->next;
    }
  return h;
}

const mc_keyword *
enum_severity (int e)
{
  mc_keyword *h = keyword_top;

  while (h != NULL)
    {
      while (h && strcmp (h->group_name, "severity") != 0)
	h = h->next;
      if (e == 0)
	return h;
      --e;
      if (h)
	h = h->next;
    }
  return h;
}

static void
mc_add_keyword_ascii (const char *sz, int rid, const char *grp, rc_uint_type nv, const char *sv)
{
  unichar *usz, *usv = NULL;
  rc_uint_type usz_len;

  unicode_from_codepage (&usz_len, &usz, sz, CP_ACP);
  if (sv)
    unicode_from_codepage (&usz_len, &usv, sv, CP_ACP);
  mc_add_keyword (usz, rid, grp, nv, usv);
}

void
mc_add_keyword (unichar *usz, int rid, const char *grp, rc_uint_type nv, unichar *sv)
{
  mc_keyword *p, *c, *n;
  size_t len = unichar_len (usz);

  c = keyword_top;
  p = NULL;
  while (c != NULL)
    {
      if (c->len > len)
	break;
      if (c->len == len)
	{
	  int e = memcmp (usz, c->usz, len * sizeof (unichar));

	  if (e < 0)
	    break;
	  if (! e)
	    {
	      if (! strcmp (grp, "keyword") || strcmp (c->group_name, grp) != 0)
		fatal (_("Duplicate symbol entered into keyword list."));
	      c->rid = rid;
	      c->nval = nv;
	      c->sval = (!sv ? NULL : unichar_dup (sv));
	      if (! strcmp (grp, "language"))
		{
		  const wind_language_t *lag = wind_find_language_by_id ((unsigned) nv);

		  if (lag == NULL)
		    fatal ("Language ident 0x%lx is not resolvable.\n", (long) nv);
		  memcpy (&c->lang_info, lag, sizeof (*lag));
		}
	      return;
	    }
	}
      c = (p = c)->next;
    }
  n = xmalloc (sizeof (mc_keyword));
  n->next = c;
  n->len = len;
  n->group_name = grp;
  n->usz = usz;
  n->rid = rid;
  n->nval = nv;
  n->sval = (!sv ? NULL : unichar_dup (sv));
  if (! strcmp (grp, "language"))
    {
      const wind_language_t *lag = wind_find_language_by_id ((unsigned) nv);
      if (lag == NULL)
	fatal ("Language ident 0x%lx is not resolvable.\n", (long) nv);
      memcpy (&n->lang_info, lag, sizeof (*lag));
    }
  if (! p)
    keyword_top = n;
  else
    p->next = n;
}

static int
mc_token (const unichar *t, size_t len)
{
  static int was_init = 0;
  mc_keyword *k;

  if (! was_init)
    {
      was_init = 1;
      mc_add_keyword_ascii ("OutputBase", MCOUTPUTBASE, "keyword", 0, NULL);
      mc_add_keyword_ascii ("MessageIdTypedef", MCMESSAGEIDTYPEDEF, "keyword", 0, NULL);
      mc_add_keyword_ascii ("SeverityNames", MCSEVERITYNAMES, "keyword", 0, NULL);
      mc_add_keyword_ascii ("FacilityNames", MCFACILITYNAMES, "keyword", 0, NULL);
      mc_add_keyword_ascii ("LanguageNames", MCLANGUAGENAMES, "keyword", 0, NULL);
      mc_add_keyword_ascii ("MessageId", MCMESSAGEID, "keyword", 0, NULL);
      mc_add_keyword_ascii ("Severity", MCSEVERITY, "keyword", 0, NULL);
      mc_add_keyword_ascii ("Facility", MCFACILITY, "keyword", 0, NULL);
      mc_add_keyword_ascii ("SymbolicName", MCSYMBOLICNAME, "keyword", 0, NULL);
      mc_add_keyword_ascii ("Language", MCLANGUAGE, "keyword", 0, NULL);
      mc_add_keyword_ascii ("Success", MCTOKEN, "severity", 0, NULL);
      mc_add_keyword_ascii ("Informational", MCTOKEN, "severity", 1, NULL);
      mc_add_keyword_ascii ("Warning", MCTOKEN, "severity", 2, NULL);
      mc_add_keyword_ascii ("Error", MCTOKEN, "severity", 3, NULL);
      mc_add_keyword_ascii ("System", MCTOKEN, "facility", 0xff, NULL);
      mc_add_keyword_ascii ("Application", MCTOKEN, "facility", 0xfff, NULL);
      mc_add_keyword_ascii ("English", MCTOKEN, "language", 0x409, "MSG00001");
  }
  k = keyword_top;
  if (!len || !t || *t == 0)
    return -1;
  while (k != NULL)
    {
      if (k->len > len)
	break;
      if (k->len == len)
	{
	  if (! memcmp (k->usz, t, len * sizeof (unichar)))
	    {
	      if (k->rid == MCTOKEN)
		yylval.tok = k;
	      return k->rid;
	    }
	}
      k = k->next;
    }
  return -1;
}

int
yylex (void)
{
  unichar *start_token;
  unichar ch;

  if (! input_stream_pos)
    {
      fatal ("Input stream not setuped.\n");
      return -1;
    }
  if (mclex_want_line)
    {
      start_token = input_stream_pos;
      if (input_stream_pos[0] == '.'
	  && (input_stream_pos[1] == '\n'
	      || (input_stream_pos[1] == '\r' && input_stream_pos[2] == '\n')))
      {
	mclex_want_line = FALSE;
	while (input_stream_pos[0] != 0 && input_stream_pos[0] != '\n')
	  ++input_stream_pos;
	if (input_stream_pos[0] == '\n')
	  ++input_stream_pos;
	return MCENDLINE;
      }
      while (input_stream_pos[0] != 0 && input_stream_pos[0] != '\n')
	++input_stream_pos;
      if (input_stream_pos[0] == '\n')
	++input_stream_pos;
      yylval.ustr = get_diff (input_stream_pos, start_token);
      return MCLINE;
    }
  while ((ch = input_stream_pos[0]) <= 0x20)
    {
      if (ch == 0)
	return -1;
      ++input_stream_pos;
      if (ch == '\n')
	input_line += 1;
      if (mclex_want_nl && ch == '\n')
	{
	  mclex_want_nl = FALSE;
	  return NL;
	}
    }
  start_token = input_stream_pos;
  ++input_stream_pos;
  if (mclex_want_filename)
    {
      mclex_want_filename = FALSE;
      if (ch == '"')
	{
	  start_token++;
	  while ((ch = input_stream_pos[0]) != 0)
	    {
	      if (ch == '"')
		break;
	      ++input_stream_pos;
	    }
	  yylval.ustr = get_diff (input_stream_pos, start_token);
	  if (ch == '"')
	    ++input_stream_pos;
	}
      else
	{
	  while ((ch = input_stream_pos[0]) != 0)
	    {
	      if (ch <= 0x20 || ch == ')')
		break;
	      ++input_stream_pos;
	    }
	  yylval.ustr = get_diff (input_stream_pos, start_token);
	}
      return MCFILENAME;
    }
  switch (ch)
  {
  case ';':
    ++start_token;
    while (input_stream_pos[0] != '\n' && input_stream_pos[0] != 0)
      ++input_stream_pos;
    if (input_stream_pos[0] == '\n')
      input_stream_pos++;
    yylval.ustr = get_diff (input_stream_pos, start_token);
    return MCCOMMENT;
  case '=':
    return '=';
  case '(':
    return '(';
  case ')':
    return ')';
  case '+':
    return '+';
  case ':':
    return ':';
  case '0': case '1': case '2': case '3': case '4':
  case '5': case '6': case '7': case '8': case '9':
    yylval.ival = parse_digit (ch);
    return MCNUMBER;
  default:
    if (ch >= 0x40)
      {
	int ret;
	while (input_stream_pos[0] >= 0x40 || (input_stream_pos[0] >= '0' && input_stream_pos[0] <= '9'))
	  ++input_stream_pos;
	ret = mc_token (start_token, (size_t) (input_stream_pos - start_token));
	if (ret != -1)
	  return ret;
	yylval.ustr = get_diff (input_stream_pos, start_token);
	return MCIDENT;
      }
    yyerror ("illegal character 0x%x.", ch);
  }
  return -1;
}
Commit	Line	Data
692ed3e7 NC	1	/* mclex.c -- lexer for Windows mc files parser.
	2	Copyright 2007
	3	Free Software Foundation, Inc.
	4
	5	Written by Kai Tietz, Onevision.
	6
	7	This file is part of GNU Binutils.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
	21	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
	22	02110-1301, USA. */
	23
	24	/* This is a lexer used by the Windows rc file parser.
	25	It basically just recognized a bunch of keywords. */
	26
	27	#include "sysdep.h"
	28	#include "bfd.h"
	29	#include "bucomm.h"
	30	#include "libiberty.h"
	31	#include "safe-ctype.h"
	32	#include "windmc.h"
	33	#include "mcparse.h"
	34
	35	#include <assert.h>
	36
	37	/* Exported globals. */
	38	bfd_boolean mclex_want_nl = FALSE;
	39	bfd_boolean mclex_want_line = FALSE;
	40	bfd_boolean mclex_want_filename = FALSE;
	41
	42	/* Local globals. */
	43	static unichar *input_stream = NULL;
	44	static unichar *input_stream_pos = NULL;
	45	static int input_line = 1;
	46	static const char *input_filename = NULL;
	47
	48	void
	49	mc_set_content (const unichar *src)
	50	{
	51	if (!src)
	52	return;
	53	input_stream = input_stream_pos = unichar_dup (src);
	54	}
	55
	56	void
	57	mc_set_inputfile (const char *name)
	58	{
	59	if (! name \|\| *name == 0)
	60	input_filename = "-";
	61	else
	62	{
	63	const char *s1 = strrchr (name, '/');
	64	const char *s2 = strrchr (name, '\\');
65
66	if (! s1)
67	s1 = s2;
68	if (s1 && s2 && s1 < s2)
69	s1 = s2;
70	if (! s1)
71	s1 = name;
72	else
73	s1++;
74	s1 = xstrdup (s1);
75	input_filename = s1;
76	}
77	}
78
79	static void
80	show_msg (const char kind, const char msg, va_list argp)
81	{
82	fprintf (stderr, "In %s at line %d: %s: ", input_filename, input_line, kind);
83	vfprintf (stderr, msg, argp);
84	fprintf (stderr, ".\n");
85	}
86
87	void
88	mc_warn (const char *s, ...)
89	{
90	va_list argp;
91	va_start (argp, s);
92	show_msg ("warning", s, argp);
93	va_end (argp);
94	}
95
96	void
97	mc_fatal (const char *s, ...)
98	{
99	va_list argp;
100	va_start (argp, s);
101	show_msg ("fatal", s, argp);
102	va_end (argp);
103	xexit (1);
104	}
105
106
107	int
108	yyerror (const char *s, ...)
109	{
110	va_list argp;
111	va_start (argp, s);
112	show_msg ("parser", s, argp);
113	va_end (argp);
114	return 1;
115	}
116
117	static unichar *
118	get_diff (unichar end, unichar start)
119	{
120	unichar *ret;
121	unichar save = *end;
122
123	*end = 0;
124	ret = unichar_dup (start);
125	*end = save;
126	return ret;
127	}
128
129	static rc_uint_type
130	parse_digit (unichar ch)
131	{
132	rc_uint_type base = 10, v = 0, c;
133
134	if (ch == '0')
135	{
136	base = 8;
137	switch (input_stream_pos[0])
138	{
139	case 'x': case 'X': base = 16; input_stream_pos++; break;
140	case 'o': case 'O': base = 8; input_stream_pos++; break;
141	case 'b': case 'B': base = 2; input_stream_pos++; break;
142	}
143	}
144	else
145	v = (rc_uint_type) (ch - '0');
146
147	while ((ch = input_stream_pos[0]) != 0)
148	{
149	if (ch >= 'A' && ch <= 'F')
150	c = (rc_uint_type) (ch - 'A') + 10;
151	else if (ch >= 'a' && ch <= 'f')
152	c = (rc_uint_type) (ch - 'a') + 10;
153	else if (ch >= '0' && ch <= '9')
154	c = (rc_uint_type) (ch - '0');
155	else
156	break;
157	v *= base;
158	v += c;
159	++input_stream_pos;
160	}
161	if (input_stream_pos[0] == 'U' \|\| input_stream_pos[0] == 'u')
162	input_stream_pos++;
163	if (input_stream_pos[0] == 'L' \|\| input_stream_pos[0] == 'l')
164	input_stream_pos++;
165	if (input_stream_pos[0] == 'L' \|\| input_stream_pos[0] == 'l')
166	input_stream_pos++;
167	return v;
168	}
169
170	static mc_keyword *keyword_top = NULL;
171
172	const mc_keyword *
173	enum_facility (int e)
174	{
175	mc_keyword *h = keyword_top;
176
177	while (h != NULL)
178	{
179	while (h && strcmp (h->group_name, "facility") != 0)
180	h = h->next;
181	if (e == 0)
182	return h;
183	--e;
184	if (h)
185	h = h->next;
186	}
187	return h;
188	}
189
190	const mc_keyword *
191	enum_severity (int e)
192	{
193	mc_keyword *h = keyword_top;
194
195	while (h != NULL)
196	{
197	while (h && strcmp (h->group_name, "severity") != 0)
198	h = h->next;
199	if (e == 0)
200	return h;
201	--e;
202	if (h)
203	h = h->next;
204	}
205	return h;
206	}
207
208	static void
209	mc_add_keyword_ascii (const char sz, int rid, const char grp, rc_uint_type nv, const char *sv)
210	{
211	unichar usz, usv = NULL;
212	rc_uint_type usz_len;
213
214	unicode_from_codepage (&usz_len, &usz, sz, CP_ACP);
215	if (sv)
216	unicode_from_codepage (&usz_len, &usv, sv, CP_ACP);
217	mc_add_keyword (usz, rid, grp, nv, usv);
218	}
219
220	void
221	mc_add_keyword (unichar usz, int rid, const char grp, rc_uint_type nv, unichar *sv)
222	{
223	mc_keyword p, c, *n;
224	size_t len = unichar_len (usz);
225
226	c = keyword_top;
227	p = NULL;
228	while (c != NULL)
229	{
230	if (c->len > len)
231	break;
232	if (c->len == len)
233	{
234	int e = memcmp (usz, c->usz, len * sizeof (unichar));
235
236	if (e < 0)
237	break;
238	if (! e)
239	{
240	if (! strcmp (grp, "keyword") \|\| strcmp (c->group_name, grp) != 0)
241	fatal (_("Duplicate symbol entered into keyword list."));
242	c->rid = rid;
243	c->nval = nv;
244	c->sval = (!sv ? NULL : unichar_dup (sv));
245	if (! strcmp (grp, "language"))
246	{
247	const wind_language_t *lag = wind_find_language_by_id ((unsigned) nv);
248
249	if (lag == NULL)
250	fatal ("Language ident 0x%lx is not resolvable.\n", (long) nv);
251	memcpy (&c->lang_info, lag, sizeof (*lag));
252	}
253	return;
254	}
255	}
256	c = (p = c)->next;
257	}
258	n = xmalloc (sizeof (mc_keyword));
259	n->next = c;
260	n->len = len;
261	n->group_name = grp;
262	n->usz = usz;
263	n->rid = rid;
264	n->nval = nv;
265	n->sval = (!sv ? NULL : unichar_dup (sv));
266	if (! strcmp (grp, "language"))
267	{
268	const wind_language_t *lag = wind_find_language_by_id ((unsigned) nv);
269	if (lag == NULL)
270	fatal ("Language ident 0x%lx is not resolvable.\n", (long) nv);
271	memcpy (&n->lang_info, lag, sizeof (*lag));
272	}
273	if (! p)
274	keyword_top = n;
275	else
276	p->next = n;
277	}
278
279	static int
280	mc_token (const unichar *t, size_t len)
281	{
282	static int was_init = 0;
283	mc_keyword *k;
284
285	if (! was_init)
286	{
287	was_init = 1;
288	mc_add_keyword_ascii ("OutputBase", MCOUTPUTBASE, "keyword", 0, NULL);
289	mc_add_keyword_ascii ("MessageIdTypedef", MCMESSAGEIDTYPEDEF, "keyword", 0, NULL);
290	mc_add_keyword_ascii ("SeverityNames", MCSEVERITYNAMES, "keyword", 0, NULL);
291	mc_add_keyword_ascii ("FacilityNames", MCFACILITYNAMES, "keyword", 0, NULL);
292	mc_add_keyword_ascii ("LanguageNames", MCLANGUAGENAMES, "keyword", 0, NULL);
293	mc_add_keyword_ascii ("MessageId", MCMESSAGEID, "keyword", 0, NULL);
294	mc_add_keyword_ascii ("Severity", MCSEVERITY, "keyword", 0, NULL);
295	mc_add_keyword_ascii ("Facility", MCFACILITY, "keyword", 0, NULL);
296	mc_add_keyword_ascii ("SymbolicName", MCSYMBOLICNAME, "keyword", 0, NULL);
297	mc_add_keyword_ascii ("Language", MCLANGUAGE, "keyword", 0, NULL);
298	mc_add_keyword_ascii ("Success", MCTOKEN, "severity", 0, NULL);
299	mc_add_keyword_ascii ("Informational", MCTOKEN, "severity", 1, NULL);
300	mc_add_keyword_ascii ("Warning", MCTOKEN, "severity", 2, NULL);
301	mc_add_keyword_ascii ("Error", MCTOKEN, "severity", 3, NULL);
302	mc_add_keyword_ascii ("System", MCTOKEN, "facility", 0xff, NULL);
303	mc_add_keyword_ascii ("Application", MCTOKEN, "facility", 0xfff, NULL);
304	mc_add_keyword_ascii ("English", MCTOKEN, "language", 0x409, "MSG00001");
305	}
306	k = keyword_top;
307	if (!len \|\| !t \|\| *t == 0)
308	return -1;
309	while (k != NULL)
310	{
311	if (k->len > len)
312	break;
313	if (k->len == len)
314	{
315	if (! memcmp (k->usz, t, len * sizeof (unichar)))
316	{
317	if (k->rid == MCTOKEN)
318	yylval.tok = k;
319	return k->rid;
320	}
321	}
322	k = k->next;
323	}
324	return -1;
325	}
326
327	int
328	yylex (void)
329	{
330	unichar *start_token;
331	unichar ch;
332
333	if (! input_stream_pos)
334	{
335	fatal ("Input stream not setuped.\n");
336	return -1;
337	}
338	if (mclex_want_line)
339	{
340	start_token = input_stream_pos;
341	if (input_stream_pos[0] == '.'
342	&& (input_stream_pos[1] == '\n'
343	\|\| (input_stream_pos[1] == '\r' && input_stream_pos[2] == '\n')))
344	{
345	mclex_want_line = FALSE;
346	while (input_stream_pos[0] != 0 && input_stream_pos[0] != '\n')
347	++input_stream_pos;
348	if (input_stream_pos[0] == '\n')
349	++input_stream_pos;
350	return MCENDLINE;
351	}
352	while (input_stream_pos[0] != 0 && input_stream_pos[0] != '\n')
353	++input_stream_pos;
354	if (input_stream_pos[0] == '\n')
355	++input_stream_pos;
356	yylval.ustr = get_diff (input_stream_pos, start_token);
357	return MCLINE;
358	}
359	while ((ch = input_stream_pos[0]) <= 0x20)
360	{
361	if (ch == 0)
362	return -1;
363	++input_stream_pos;
364	if (ch == '\n')
365	input_line += 1;
366	if (mclex_want_nl && ch == '\n')
367	{
368	mclex_want_nl = FALSE;
369	return NL;
370	}
371	}
372	start_token = input_stream_pos;
373	++input_stream_pos;
374	if (mclex_want_filename)
375	{
376	mclex_want_filename = FALSE;
377	if (ch == '"')
378	{
379	start_token++;
380	while ((ch = input_stream_pos[0]) != 0)
381	{
382	if (ch == '"')
383	break;
384	++input_stream_pos;
385	}
386	yylval.ustr = get_diff (input_stream_pos, start_token);
387	if (ch == '"')
388	++input_stream_pos;
389	}
390	else
391	{
392	while ((ch = input_stream_pos[0]) != 0)
393	{
394	if (ch <= 0x20 \|\| ch == ')')
395	break;
396	++input_stream_pos;
397	}
398	yylval.ustr = get_diff (input_stream_pos, start_token);
399	}
400	return MCFILENAME;
401	}
402	switch (ch)
403	{
404	case ';':
405	++start_token;
406	while (input_stream_pos[0] != '\n' && input_stream_pos[0] != 0)
407	++input_stream_pos;
408	if (input_stream_pos[0] == '\n')
409	input_stream_pos++;
410	yylval.ustr = get_diff (input_stream_pos, start_token);
411	return MCCOMMENT;
412	case '=':
413	return '=';
414	case '(':
415	return '(';
416	case ')':
417	return ')';
418	case '+':
419	return '+';
420	case ':':
421	return ':';
422	case '0': case '1': case '2': case '3': case '4':
423	case '5': case '6': case '7': case '8': case '9':
424	yylval.ival = parse_digit (ch);
425	return MCNUMBER;
426	default:
427	if (ch >= 0x40)
428	{
429	int ret;
430	while (input_stream_pos[0] >= 0x40 \|\| (input_stream_pos[0] >= '0' && input_stream_pos[0] <= '9'))
431	++input_stream_pos;
432	ret = mc_token (start_token, (size_t) (input_stream_pos - start_token));
433	if (ret != -1)
434	return ret;
435	yylval.ustr = get_diff (input_stream_pos, start_token);
436	return MCIDENT;
437	}
438	yyerror ("illegal character 0x%x.", ch);
439	}
440	return -1;
441	}