URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [binutils/] [mclex.c] - Blame information for rev 855

Go to most recent revision | Details | Compare with Previous | View Log


/* 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 3 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;
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [binutils/] [mclex.c] - Blame information for rev 855

Line No.	Rev	Author	Line
1	205	julius	`/* 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 3 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			`}`