tools/wmc/y_tab.c

   1
   2 /*  A Bison parser, made from ./mcy.y
   3  by  GNU Bison version 1.25
   4   */
   5
   6 #define YYBISON 1  /* Identify Bison output.  */
   7
   8 #define tSEVNAMES       258
   9 #define tFACNAMES       259
  10 #define tLANNAMES       260
  11 #define tBASE   261
  12 #define tCODEPAGE       262
  13 #define tTYPEDEF        263
  14 #define tNL     264
  15 #define tSYMNAME        265
  16 #define tMSGEND 266
  17 #define tSEVERITY       267
  18 #define tFACILITY       268
  19 #define tLANGUAGE       269
  20 #define tMSGID  270
  21 #define tIDENT  271
  22 #define tLINE   272
  23 #define tFILE   273
  24 #define tCOMMENT        274
  25 #define tNUMBER 275
  26 #define tTOKEN  276
  27
  28 #line 23 "./mcy.y"
  29
  30
  31 #include <windows.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <assert.h>
  35
  36 #include "config.h"
  37
  38 #include "utils.h"
  39 #include "wmc.h"
  40 #include "lang.h"
  41
  42 static const char err_syntax[]  = "Syntax error";
  43 static const char err_number[]  = "Number expected";
  44 static const char err_ident[]   = "Identifier expected";
  45 static const char err_assign[]  = "'=' expected";
  46 static const char err_popen[]   = "'(' expected";
  47 static const char err_pclose[]  = "')' expected";
  48 static const char err_colon[]   = "':' expected";
  49 static const char err_msg[]     = "Message expected";
  50
  51 /* Scanner switches */
  52 int want_nl = 0;                /* Request next newlinw */
  53 int want_line = 0;              /* Request next complete line */
  54 int want_file = 0;              /* Request next ident as filename */
  55
  56 node_t *nodehead = NULL;        /* The list of all parsed elements */
  57 static node_t *nodetail = NULL;
  58 lan_blk_t *lanblockhead;        /* List of parsed elements transposed */
  59
  60 static int base = 16;           /* Current printout base to use (8, 10 or 16) */
  61 static WCHAR *cast = NULL;      /* Current typecast to use */
  62
  63 static int last_id = 0;         /* The last message ID parsed */
  64 static int last_sev = 0;        /* Last severity code parsed */
  65 static int last_fac = 0;        /* Last facility code parsed */
  66 static WCHAR *last_sym = NULL;/* Last alias symbol parsed */
  67 static int have_sev;            /* Set if severity parsed for current message */
  68 static int have_fac;            /* Set if facility parsed for current message */
  69 static int have_sym;            /* Set is symbol parsed for current message */
  70
  71 static cp_xlat_t *cpxlattab = NULL;     /* Codepage translation table */
  72 static int ncpxlattab = 0;
  73
  74 /* Prototypes */
  75 static WCHAR *merge(WCHAR *s1, WCHAR *s2);
  76 static lanmsg_t *new_lanmsg(lan_cp_t *lcp, WCHAR *msg);
  77 static msg_t *add_lanmsg(msg_t *msg, lanmsg_t *lanmsg);
  78 static msg_t *complete_msg(msg_t *msg, int id);
  79 static void add_node(node_e type, void *p);
  80 static void do_add_token(tok_e type, token_t *tok, const char *code);
  81 static void test_id(int id);
  82 static int check_languages(node_t *head);
  83 static lan_blk_t *block_messages(node_t *head);
  84 static void add_cpxlat(int lan, int cpin, int cpout);
  85 static cp_xlat_t *find_cpxlat(int lan);
  86
  87
  88 #line 83 "./mcy.y"
  89 typedef union {
  90         WCHAR           *str;
  91         unsigned        num;
  92         token_t         *tok;
  93         lanmsg_t        *lmp;
  94         msg_t           *msg;
  95         lan_cp_t        lcp;
  96 } YYSTYPE;
  97 #ifndef YYDEBUG
  98 #define YYDEBUG 1
  99 #endif
 100
 101 #include <stdio.h>
 102
 103 #ifndef __cplusplus
 104 #ifndef __STDC__
 105 #define const
 106 #endif
 107 #endif
 108
 109
 110
 111 #define YYFINAL         155
 112 #define YYFLAG          -32768
 113 #define YYNTBASE        27
 114
 115 #define YYTRANSLATE(x) ((unsigned)(x) <= 276 ? yytranslate[x] : 58)
 116
 117 static const char yytranslate[] = {     0,
 118      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 119      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 120      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 121      2,     2,     2,     2,     2,     2,     2,     2,     2,    23,
 122     24,     2,    26,     2,     2,     2,     2,     2,     2,     2,
 123      2,     2,     2,     2,     2,     2,     2,    25,     2,     2,
 124     22,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 125      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 126      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 127      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 128      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 129      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 130      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 131      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 132      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 133      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 134      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 135      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 136      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 137      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 138      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 139      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 140      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 141      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 142      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 143      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
 144      6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
 145     16,    17,    18,    19,    20,    21
 146 };
 147
 148 #if YYDEBUG != 0
 149 static const short yyprhs[] = {     0,
 150      0,     2,     4,     7,     9,    11,    13,    15,    21,    27,
 151     31,    34,    40,    46,    50,    53,    59,    65,    69,    72,
 152     78,    84,    88,    91,    95,    99,   102,   106,   110,   113,
 153    115,   118,   120,   125,   129,   132,   134,   137,   139,   144,
 154    148,   151,   152,   155,   158,   160,   163,   165,   173,   180,
 155    185,   189,   192,   193,   196,   199,   201,   204,   206,   212,
 156    218,   223,   227,   230,   232,   234,   235,   240,   244,   247,
 157    248,   250,   253,   256,   257,   260,   263,   266,   270,   274,
 158    277,   281,   285,   288,   292,   296,   299,   301,   304,   306,
 159    311,   317,   323,   328,   331,   333,   336,   338,   341,   343,
 160    345,   346,   347
 161 };
 162
 163 static const short yyrhs[] = {    28,
 164      0,    29,     0,    28,    29,     0,    30,     0,    42,     0,
 165     19,     0,     1,     0,     3,    22,    23,    31,    24,     0,
 166      3,    22,    23,    31,     1,     0,     3,    22,     1,     0,
 167      3,     1,     0,     4,    22,    23,    33,    24,     0,     4,
 168     22,    23,    33,     1,     0,     4,    22,     1,     0,     4,
 169      1,     0,     5,    22,    23,    36,    24,     0,     5,    22,
 170     23,    36,     1,     0,     5,    22,     1,     0,     5,     1,
 171      0,     7,    22,    23,    39,    24,     0,     7,    22,    23,
 172     39,     1,     0,     7,    22,     1,     0,     7,     1,     0,
 173      8,    22,    16,     0,     8,    22,     1,     0,     8,     1,
 174      0,     6,    22,    20,     0,     6,    22,     1,     0,     6,
 175      1,     0,    32,     0,    31,    32,     0,     1,     0,    54,
 176     22,    20,    35,     0,    54,    22,     1,     0,    54,     1,
 177      0,    34,     0,    33,    34,     0,     1,     0,    54,    22,
 178     20,    35,     0,    54,    22,     1,     0,    54,     1,     0,
 179      0,    25,    16,     0,    25,     1,     0,    37,     0,    36,
 180     37,     0,     1,     0,    54,    22,    20,    57,    25,    18,
 181     38,     0,    54,    22,    20,    57,    25,     1,     0,    54,
 182     22,    20,     1,     0,    54,    22,     1,     0,    54,     1,
 183      0,     0,    25,    20,     0,    25,     1,     0,    40,     0,
 184     39,    40,     0,     1,     0,    41,    22,    20,    25,    20,
 185      0,    41,    22,    20,    25,     1,     0,    41,    22,    20,
 186      1,     0,    41,    22,     1,     0,    41,     1,     0,    20,
 187      0,    21,     0,     0,    44,    46,    43,    50,     0,    15,
 188     22,    45,     0,    15,     1,     0,     0,    20,     0,    26,
 189     20,     0,    26,     1,     0,     0,    46,    48,     0,    46,
 190     49,     0,    46,    47,     0,    10,    22,    16,     0,    10,
 191     22,     1,     0,    10,     1,     0,    12,    22,    54,     0,
 192     12,    22,     1,     0,    12,     1,     0,    13,    22,    54,
 193      0,    13,    22,     1,     0,    13,     1,     0,    51,     0,
 194     50,    51,     0,     1,     0,    52,    56,    53,    11,     0,
 195     14,    55,    22,    54,     9,     0,    14,    55,    22,    54,
 196      1,     0,    14,    55,    22,     1,     0,    14,     1,     0,
 197     17,     0,    53,    17,     0,     1,     0,    53,     1,     0,
 198     16,     0,    21,     0,     0,     0,     0
 199 };
 200
 201 #endif
 202
 203 #if YYDEBUG != 0
 204 static const short yyrline[] = { 0,
 205    108,   115,   116,   119,   120,   121,   122,   125,   126,   127,
 206    128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
 207    138,   139,   140,   141,   142,   143,   144,   156,   157,   163,
 208    164,   165,   168,   175,   176,   182,   183,   184,   187,   194,
 209    195,   198,   199,   200,   206,   207,   208,   211,   219,   220,
 210    221,   222,   225,   226,   227,   233,   234,   235,   238,   248,
 211    249,   250,   251,   254,   255,   265,   265,   268,   273,   276,
 212    277,   278,   279,   282,   283,   284,   285,   288,   289,   290,
 213    293,   301,   302,   305,   313,   314,   320,   321,   322,   325,
 214    333,   362,   363,   364,   367,   368,   369,   370,   376,   377,
 215    380,   383,   386
 216 };
 217 #endif
 218
 219
 220 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
 221
 222 static const char * const yytname[] = {   "$","error","$undefined.","tSEVNAMES",
 223 "tFACNAMES","tLANNAMES","tBASE","tCODEPAGE","tTYPEDEF","tNL","tSYMNAME","tMSGEND",
 224 "tSEVERITY","tFACILITY","tLANGUAGE","tMSGID","tIDENT","tLINE","tFILE","tCOMMENT",
 225 "tNUMBER","tTOKEN","'='","'('","')'","':'","'+'","file","items","decl","global",
 226 "smaps","smap","fmaps","fmap","alias","lmaps","lmap","optcp","cmaps","cmap",
 227 "clan","msg","@1","msgid","id","sevfacsym","sym","sev","fac","bodies","body",
 228 "lang","lines","token","setnl","setline","setfile", NULL
 229 };
 230 #endif
 231
 232 static const short yyr1[] = {     0,
 233     27,    28,    28,    29,    29,    29,    29,    30,    30,    30,
 234     30,    30,    30,    30,    30,    30,    30,    30,    30,    30,
 235     30,    30,    30,    30,    30,    30,    30,    30,    30,    31,
 236     31,    31,    32,    32,    32,    33,    33,    33,    34,    34,
 237     34,    35,    35,    35,    36,    36,    36,    37,    37,    37,
 238     37,    37,    38,    38,    38,    39,    39,    39,    40,    40,
 239     40,    40,    40,    41,    41,    43,    42,    44,    44,    45,
 240     45,    45,    45,    46,    46,    46,    46,    47,    47,    47,
 241     48,    48,    48,    49,    49,    49,    50,    50,    50,    51,
 242     52,    52,    52,    52,    53,    53,    53,    53,    54,    54,
 243     55,    56,    57
 244 };
 245
 246 static const short yyr2[] = {     0,
 247      1,     1,     2,     1,     1,     1,     1,     5,     5,     3,
 248      2,     5,     5,     3,     2,     5,     5,     3,     2,     5,
 249      5,     3,     2,     3,     3,     2,     3,     3,     2,     1,
 250      2,     1,     4,     3,     2,     1,     2,     1,     4,     3,
 251      2,     0,     2,     2,     1,     2,     1,     7,     6,     4,
 252      3,     2,     0,     2,     2,     1,     2,     1,     5,     5,
 253      4,     3,     2,     1,     1,     0,     4,     3,     2,     0,
 254      1,     2,     2,     0,     2,     2,     2,     3,     3,     2,
 255      3,     3,     2,     3,     3,     2,     1,     2,     1,     4,
 256      5,     5,     4,     2,     1,     2,     1,     2,     1,     1,
 257      0,     0,     0
 258 };
 259
 260 static const short yydefact[] = {     0,
 261      7,     0,     0,     0,     0,     0,     0,     0,     6,     0,
 262      2,     4,     5,    74,    11,     0,    15,     0,    19,     0,
 263     29,     0,    23,     0,    26,     0,    69,    70,     3,    66,
 264     10,     0,    14,     0,    18,     0,    28,    27,    22,     0,
 265     25,    24,    71,     0,    68,     0,     0,     0,     0,    77,
 266     75,    76,    32,    99,   100,     0,    30,     0,    38,     0,
 267     36,     0,    47,     0,    45,     0,    58,    64,    65,     0,
 268     56,     0,    73,    72,    80,     0,    83,     0,    86,     0,
 269     89,     0,    67,    87,   102,     9,     8,    31,    35,     0,
 270     13,    12,    37,    41,     0,    17,    16,    46,    52,     0,
 271     21,    20,    57,    63,     0,    79,    78,    82,    81,    85,
 272     84,    94,     0,    88,     0,    34,    42,    40,    42,    51,
 273      0,    62,     0,     0,    97,    95,     0,     0,    33,    39,
 274     50,     0,    61,     0,    93,     0,    98,    90,    96,    44,
 275     43,     0,    60,    59,    92,    91,    49,    53,     0,    48,
 276     55,    54,     0,     0,     0
 277 };
 278
 279 static const short yydefgoto[] = {   153,
 280     10,    11,    12,    56,    57,    60,    61,   129,    64,    65,
 281    150,    70,    71,    72,    13,    49,    14,    45,    30,    50,
 282     51,    52,    83,    84,    85,   127,    58,   113,   115,   132
 283 };
 284
 285 static const short yypact[] = {   132,
 286 -32768,    18,    44,    46,    47,    48,    49,    50,-32768,   113,
 287 -32768,-32768,-32768,-32768,-32768,    11,-32768,    14,-32768,    19,
 288 -32768,    85,-32768,    20,-32768,   147,-32768,   -13,-32768,    87,
 289 -32768,    66,-32768,    80,-32768,    82,-32768,-32768,-32768,    64,
 290 -32768,-32768,-32768,   107,-32768,    51,    52,    53,     3,-32768,
 291 -32768,-32768,-32768,-32768,-32768,     7,-32768,    54,-32768,     8,
 292 -32768,    55,-32768,    17,-32768,    56,-32768,-32768,-32768,    15,
 293 -32768,    57,-32768,-32768,-32768,   148,-32768,    88,-32768,    90,
 294 -32768,    58,    -4,-32768,-32768,-32768,-32768,-32768,-32768,   109,
 295 -32768,-32768,-32768,-32768,   114,-32768,-32768,-32768,-32768,   121,
 296 -32768,-32768,-32768,-32768,   122,-32768,-32768,-32768,-32768,-32768,
 297 -32768,-32768,   -11,-32768,   129,-32768,    35,-32768,    35,-32768,
 298      0,-32768,     2,    91,-32768,-32768,   144,   149,-32768,-32768,
 299 -32768,    36,-32768,   123,-32768,     5,-32768,-32768,-32768,-32768,
 300 -32768,     4,-32768,-32768,-32768,-32768,-32768,    37,   124,-32768,
 301 -32768,-32768,    63,    93,-32768
 302 };
 303
 304 static const short yypgoto[] = {-32768,
 305 -32768,    78,-32768,-32768,    38,-32768,    42,   -55,-32768,    31,
 306 -32768,-32768,    61,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
 307 -32768,-32768,-32768,    43,-32768,-32768,   -34,-32768,-32768,-32768
 308 };
 309
 310
 311 #define YYLAST          165
 312
 313
 314 static const short yytable[] = {    62,
 315    131,    66,   133,    81,   147,   145,    43,    86,    91,    82,
 316    124,    31,    44,   146,    33,   101,    82,    96,    15,    35,
 317     39,   148,    54,    54,  -103,    62,   134,    55,    55,    66,
 318     87,    92,    54,    32,    68,    69,    34,    55,   102,    16,
 319     97,    36,    40,   109,    17,   111,    19,    21,    23,    25,
 320     27,    75,    77,    79,    89,    94,    99,   104,   112,   128,
 321    142,   149,   154,   130,    67,    18,    53,    20,    22,    24,
 322     26,    28,    76,    78,    80,    90,    95,   100,   105,  -101,
 323     59,    54,    63,    68,    69,    37,    55,    29,   108,   136,
 324    110,   135,   155,    88,    98,    54,    46,    54,    47,    48,
 325     55,    93,    55,    54,    38,    54,    54,    73,    55,   116,
 326     55,    55,    -1,     1,   118,     2,     3,     4,     5,     6,
 327      7,   120,   122,   143,   151,   114,    74,     8,   117,   125,
 328    103,     9,     1,   119,     2,     3,     4,     5,     6,     7,
 329    121,   123,   144,   152,   137,   126,     8,    41,   106,   140,
 330      9,     0,     0,     0,   138,     0,     0,     0,     0,     0,
 331    139,     0,    42,   107,   141
 332 };
 333
 334 static const short yycheck[] = {    34,
 335      1,    36,     1,     1,     1,     1,    20,     1,     1,    14,
 336     22,     1,    26,     9,     1,     1,    14,     1,     1,     1,
 337      1,    18,    16,    16,    25,    60,    25,    21,    21,    64,
 338     24,    24,    16,    23,    20,    21,    23,    21,    24,    22,
 339     24,    23,    23,    78,     1,    80,     1,     1,     1,     1,
 340      1,     1,     1,     1,     1,     1,     1,     1,     1,    25,
 341     25,    25,     0,   119,     1,    22,     1,    22,    22,    22,
 342     22,    22,    22,    22,    22,    22,    22,    22,    22,    22,
 343      1,    16,     1,    20,    21,     1,    21,    10,     1,   124,
 344      1,     1,     0,    56,    64,    16,    10,    16,    12,    13,
 345     21,    60,    21,    16,    20,    16,    16,     1,    21,     1,
 346     21,    21,     0,     1,     1,     3,     4,     5,     6,     7,
 347      8,     1,     1,     1,     1,    83,    20,    15,    20,     1,
 348     70,    19,     1,    20,     3,     4,     5,     6,     7,     8,
 349     20,    20,    20,    20,     1,    17,    15,     1,     1,     1,
 350     19,    -1,    -1,    -1,    11,    -1,    -1,    -1,    -1,    -1,
 351     17,    -1,    16,    16,    16
 352 };
 353 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 354 #line 3 "/usr/share/bison.simple"
 355
 356 /* Skeleton output parser for bison,
 357    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 358
 359    This program is free software; you can redistribute it and/or modify
 360    it under the terms of the GNU General Public License as published by
 361    the Free Software Foundation; either version 2, or (at your option)
 362    any later version.
 363
 364    This program is distributed in the hope that it will be useful,
 365    but WITHOUT ANY WARRANTY; without even the implied warranty of
 366    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 367    GNU General Public License for more details.
 368
 369    You should have received a copy of the GNU General Public License
 370    along with this program; if not, write to the Free Software
 371    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 372
 373 /* As a special exception, when this file is copied by Bison into a
 374    Bison output file, you may use that output file without restriction.
 375    This special exception was added by the Free Software Foundation
 376    in version 1.24 of Bison.  */
 377
 378 #ifndef alloca
 379 #ifdef __GNUC__
 380 #define alloca __builtin_alloca
 381 #else /* not GNU C.  */
 382 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
 383 #include <alloca.h>
 384 #else /* not sparc */
 385 #if defined (MSDOS) && !defined (__TURBOC__)
 386 #include <malloc.h>
 387 #else /* not MSDOS, or __TURBOC__ */
 388 #if defined(_AIX)
 389 #include <malloc.h>
 390  #pragma alloca
 391 #else /* not MSDOS, __TURBOC__, or _AIX */
 392 #ifdef __hpux
 393 #ifdef __cplusplus
 394 extern "C" {
 395 void *alloca (unsigned int);
 396 };
 397 #else /* not __cplusplus */
 398 void *alloca ();
 399 #endif /* not __cplusplus */
 400 #endif /* __hpux */
 401 #endif /* not _AIX */
 402 #endif /* not MSDOS, or __TURBOC__ */
 403 #endif /* not sparc.  */
 404 #endif /* not GNU C.  */
 405 #endif /* alloca not defined.  */
 406
 407 /* This is the parser code that is written into each bison parser
 408   when the %semantic_parser declaration is not specified in the grammar.
 409   It was written by Richard Stallman by simplifying the hairy parser
 410   used when %semantic_parser is specified.  */
 411
 412 /* Note: there must be only one dollar sign in this file.
 413    It is replaced by the list of actions, each action
 414    as one case of the switch.  */
 415
 416 #define yyerrok         (yyerrstatus = 0)
 417 #define yyclearin       (yychar = YYEMPTY)
 418 #define YYEMPTY         -2
 419 #define YYEOF           0
 420 #define YYACCEPT        return(0)
 421 #define YYABORT         return(1)
 422 #define YYERROR         goto yyerrlab1
 423 /* Like YYERROR except do call yyerror.
 424    This remains here temporarily to ease the
 425    transition to the new meaning of YYERROR, for GCC.
 426    Once GCC version 2 has supplanted version 1, this can go.  */
 427 #define YYFAIL          goto yyerrlab
 428 #define YYRECOVERING()  (!!yyerrstatus)
 429 #define YYBACKUP(token, value) \
 430 do                                                              \
 431   if (yychar == YYEMPTY && yylen == 1)                          \
 432     { yychar = (token), yylval = (value);                       \
 433       yychar1 = YYTRANSLATE (yychar);                           \
 434       YYPOPSTACK;                                               \
 435       goto yybackup;                                            \
 436     }                                                           \
 437   else                                                          \
 438     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 439 while (0)
 440
 441 #define YYTERROR        1
 442 #define YYERRCODE       256
 443
 444 #ifndef YYPURE
 445 #define YYLEX           yylex()
 446 #endif
 447
 448 #ifdef YYPURE
 449 #ifdef YYLSP_NEEDED
 450 #ifdef YYLEX_PARAM
 451 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
 452 #else
 453 #define YYLEX           yylex(&yylval, &yylloc)
 454 #endif
 455 #else /* not YYLSP_NEEDED */
 456 #ifdef YYLEX_PARAM
 457 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
 458 #else
 459 #define YYLEX           yylex(&yylval)
 460 #endif
 461 #endif /* not YYLSP_NEEDED */
 462 #endif
 463
 464 /* If nonreentrant, generate the variables here */
 465
 466 #ifndef YYPURE
 467
 468 int     yychar;                 /*  the lookahead symbol                */
 469 YYSTYPE yylval;                 /*  the semantic value of the           */
 470                                 /*  lookahead symbol                    */
 471
 472 #ifdef YYLSP_NEEDED
 473 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 474                                 /*  symbol                              */
 475 #endif
 476
 477 int yynerrs;                    /*  number of parse errors so far       */
 478 #endif  /* not YYPURE */
 479
 480 #if YYDEBUG != 0
 481 int yydebug;                    /*  nonzero means print parse trace     */
 482 /* Since this is uninitialized, it does not stop multiple parsers
 483    from coexisting.  */
 484 #endif
 485
 486 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 487
 488 #ifndef YYINITDEPTH
 489 #define YYINITDEPTH 200
 490 #endif
 491
 492 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 493     (effective only if the built-in stack extension method is used).  */
 494
 495 #if YYMAXDEPTH == 0
 496 #undef YYMAXDEPTH
 497 #endif
 498
 499 #ifndef YYMAXDEPTH
 500 #define YYMAXDEPTH 10000
 501 #endif
 502
 503 #ifndef YYPARSE_RETURN_TYPE
 504 #define YYPARSE_RETURN_TYPE int
 505 #endif
 506
 507 /* Prevent warning if -Wstrict-prototypes.  */
 508 #ifdef __GNUC__
 509 YYPARSE_RETURN_TYPE yyparse (void);
 510 #endif
 511 \f
 512 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 513 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
 514 #else                           /* not GNU C or C++ */
 515 #ifndef __cplusplus
 516
 517 /* This is the most reliable way to avoid incompatibilities
 518    in available built-in functions on various systems.  */
 519 static void
 520 __yy_memcpy (to, from, count)
 521      char *to;
 522      char *from;
 523      int count;
 524 {
 525   register char *f = from;
 526   register char *t = to;
 527   register int i = count;
 528
 529   while (i-- > 0)
 530     *t++ = *f++;
 531 }
 532
 533 #else /* __cplusplus */
 534
 535 /* This is the most reliable way to avoid incompatibilities
 536    in available built-in functions on various systems.  */
 537 static void
 538 __yy_memcpy (char *to, char *from, int count)
 539 {
 540   register char *f = from;
 541   register char *t = to;
 542   register int i = count;
 543
 544   while (i-- > 0)
 545     *t++ = *f++;
 546 }
 547
 548 #endif
 549 #endif
 550 \f
 551 #line 196 "/usr/share/bison.simple"
 552
 553 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 554    into yyparse.  The argument should have type void *.
 555    It should actually point to an object.
 556    Grammar actions can access the variable by casting it
 557    to the proper pointer type.  */
 558
 559 #ifdef YYPARSE_PARAM
 560 #ifdef __cplusplus
 561 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 562 #define YYPARSE_PARAM_DECL
 563 #else /* not __cplusplus */
 564 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
 565 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 566 #endif /* not __cplusplus */
 567 #else /* not YYPARSE_PARAM */
 568 #define YYPARSE_PARAM_ARG
 569 #define YYPARSE_PARAM_DECL
 570 #endif /* not YYPARSE_PARAM */
 571
 572 YYPARSE_RETURN_TYPE
 573 yyparse(YYPARSE_PARAM_ARG)
 574      YYPARSE_PARAM_DECL
 575 {
 576   register int yystate;
 577   register int yyn;
 578   register short *yyssp;
 579   register YYSTYPE *yyvsp;
 580   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
 581   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
 582
 583   short yyssa[YYINITDEPTH];     /*  the state stack                     */
 584   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
 585
 586   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
 587   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
 588
 589 #ifdef YYLSP_NEEDED
 590   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 591   YYLTYPE *yyls = yylsa;
 592   YYLTYPE *yylsp;
 593
 594 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 595 #else
 596 #define YYPOPSTACK   (yyvsp--, yyssp--)
 597 #endif
 598
 599   int yystacksize = YYINITDEPTH;
 600
 601 #ifdef YYPURE
 602   int yychar;
 603   YYSTYPE yylval;
 604   int yynerrs;
 605 #ifdef YYLSP_NEEDED
 606   YYLTYPE yylloc;
 607 #endif
 608 #endif
 609
 610   YYSTYPE yyval;                /*  the variable used to return         */
 611                                 /*  semantic values from the action     */
 612                                 /*  routines                            */
 613
 614   int yylen;
 615
 616 #if YYDEBUG != 0
 617   if (yydebug)
 618     fprintf(stderr, "Starting parse\n");
 619 #endif
 620
 621   yystate = 0;
 622   yyerrstatus = 0;
 623   yynerrs = 0;
 624   yychar = YYEMPTY;             /* Cause a token to be read.  */
 625
 626   /* Initialize stack pointers.
 627      Waste one element of value and location stack
 628      so that they stay on the same level as the state stack.
 629      The wasted elements are never initialized.  */
 630
 631   yyssp = yyss - 1;
 632   yyvsp = yyvs;
 633 #ifdef YYLSP_NEEDED
 634   yylsp = yyls;
 635 #endif
 636
 637 /* Push a new state, which is found in  yystate  .  */
 638 /* In all cases, when you get here, the value and location stacks
 639    have just been pushed. so pushing a state here evens the stacks.  */
 640 yynewstate:
 641
 642   *++yyssp = yystate;
 643
 644   if (yyssp >= yyss + yystacksize - 1)
 645     {
 646       /* Give user a chance to reallocate the stack */
 647       /* Use copies of these so that the &'s don't force the real ones into memory. */
 648       YYSTYPE *yyvs1 = yyvs;
 649       short *yyss1 = yyss;
 650 #ifdef YYLSP_NEEDED
 651       YYLTYPE *yyls1 = yyls;
 652 #endif
 653
 654       /* Get the current used size of the three stacks, in elements.  */
 655       int size = yyssp - yyss + 1;
 656
 657 #ifdef yyoverflow
 658       /* Each stack pointer address is followed by the size of
 659          the data in use in that stack, in bytes.  */
 660 #ifdef YYLSP_NEEDED
 661       /* This used to be a conditional around just the two extra args,
 662          but that might be undefined if yyoverflow is a macro.  */
 663       yyoverflow("parser stack overflow",
 664                  &yyss1, size * sizeof (*yyssp),
 665                  &yyvs1, size * sizeof (*yyvsp),
 666                  &yyls1, size * sizeof (*yylsp),
 667                  &yystacksize);
 668 #else
 669       yyoverflow("parser stack overflow",
 670                  &yyss1, size * sizeof (*yyssp),
 671                  &yyvs1, size * sizeof (*yyvsp),
 672                  &yystacksize);
 673 #endif
 674
 675       yyss = yyss1; yyvs = yyvs1;
 676 #ifdef YYLSP_NEEDED
 677       yyls = yyls1;
 678 #endif
 679 #else /* no yyoverflow */
 680       /* Extend the stack our own way.  */
 681       if (yystacksize >= YYMAXDEPTH)
 682         {
 683           yyerror("parser stack overflow");
 684           return 2;
 685         }
 686       yystacksize *= 2;
 687       if (yystacksize > YYMAXDEPTH)
 688         yystacksize = YYMAXDEPTH;
 689       yyss = (short *) _alloca (yystacksize * sizeof (*yyssp));
 690       __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
 691       yyvs = (YYSTYPE *) _alloca (yystacksize * sizeof (*yyvsp));
 692       __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
 693 #ifdef YYLSP_NEEDED
 694       yyls = (YYLTYPE *) _alloca (yystacksize * sizeof (*yylsp));
 695       __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
 696 #endif
 697 #endif /* no yyoverflow */
 698
 699       yyssp = yyss + size - 1;
 700       yyvsp = yyvs + size - 1;
 701 #ifdef YYLSP_NEEDED
 702       yylsp = yyls + size - 1;
 703 #endif
 704
 705 #if YYDEBUG != 0
 706       if (yydebug)
 707         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 708 #endif
 709
 710       if (yyssp >= yyss + yystacksize - 1)
 711         YYABORT;
 712     }
 713
 714 #if YYDEBUG != 0
 715   if (yydebug)
 716     fprintf(stderr, "Entering state %d\n", yystate);
 717 #endif
 718
 719   goto yybackup;
 720  yybackup:
 721
 722 /* Do appropriate processing given the current state.  */
 723 /* Read a lookahead token if we need one and don't already have one.  */
 724 /* yyresume: */
 725
 726   /* First try to decide what to do without reference to lookahead token.  */
 727
 728   yyn = yypact[yystate];
 729   if (yyn == YYFLAG)
 730     goto yydefault;
 731
 732   /* Not known => get a lookahead token if don't already have one.  */
 733
 734   /* yychar is either YYEMPTY or YYEOF
 735      or a valid token in external form.  */
 736
 737   if (yychar == YYEMPTY)
 738     {
 739 #if YYDEBUG != 0
 740       if (yydebug)
 741         fprintf(stderr, "Reading a token: ");
 742 #endif
 743       yychar = YYLEX;
 744     }
 745
 746   /* Convert token to internal form (in yychar1) for indexing tables with */
 747
 748   if (yychar <= 0)              /* This means end of input. */
 749     {
 750       yychar1 = 0;
 751       yychar = YYEOF;           /* Don't call YYLEX any more */
 752
 753 #if YYDEBUG != 0
 754       if (yydebug)
 755         fprintf(stderr, "Now at end of input.\n");
 756 #endif
 757     }
 758   else
 759     {
 760       yychar1 = YYTRANSLATE(yychar);
 761
 762 #if YYDEBUG != 0
 763       if (yydebug)
 764         {
 765           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 766           /* Give the individual parser a way to print the precise meaning
 767              of a token, for further debugging info.  */
 768 #ifdef YYPRINT
 769           YYPRINT (stderr, yychar, yylval);
 770 #endif
 771           fprintf (stderr, ")\n");
 772         }
 773 #endif
 774     }
 775
 776   yyn += yychar1;
 777   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 778     goto yydefault;
 779
 780   yyn = yytable[yyn];
 781
 782   /* yyn is what to do for this token type in this state.
 783      Negative => reduce, -yyn is rule number.
 784      Positive => shift, yyn is new state.
 785        New state is final state => don't bother to shift,
 786        just return success.
 787      0, or most negative number => error.  */
 788
 789   if (yyn < 0)
 790     {
 791       if (yyn == YYFLAG)
 792         goto yyerrlab;
 793       yyn = -yyn;
 794       goto yyreduce;
 795     }
 796   else if (yyn == 0)
 797     goto yyerrlab;
 798
 799   if (yyn == YYFINAL)
 800     YYACCEPT;
 801
 802   /* Shift the lookahead token.  */
 803
 804 #if YYDEBUG != 0
 805   if (yydebug)
 806     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 807 #endif
 808
 809   /* Discard the token being shifted unless it is eof.  */
 810   if (yychar != YYEOF)
 811     yychar = YYEMPTY;
 812
 813   *++yyvsp = yylval;
 814 #ifdef YYLSP_NEEDED
 815   *++yylsp = yylloc;
 816 #endif
 817
 818   /* count tokens shifted since error; after three, turn off error status.  */
 819   if (yyerrstatus) yyerrstatus--;
 820
 821   yystate = yyn;
 822   goto yynewstate;
 823
 824 /* Do the default action for the current state.  */
 825 yydefault:
 826
 827   yyn = yydefact[yystate];
 828   if (yyn == 0)
 829     goto yyerrlab;
 830
 831 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 832 yyreduce:
 833   yylen = yyr2[yyn];
 834   if (yylen > 0)
 835     yyval = yyvsp[1-yylen]; /* implement default value of the action */
 836
 837 #if YYDEBUG != 0
 838   if (yydebug)
 839     {
 840       int i;
 841
 842       fprintf (stderr, "Reducing via rule %d (line %d), ",
 843                yyn, yyrline[yyn]);
 844
 845       /* Print the symbols being reduced, and their result.  */
 846       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 847         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 848       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 849     }
 850 #endif
 851
 852
 853   switch (yyn) {
 854
 855 case 1:
 856 #line 108 "./mcy.y"
 857 {
 858                 if(!check_languages(nodehead))
 859                         xyyerror("No messages defined");
 860                 lanblockhead = block_messages(nodehead);
 861         ;
 862     break;}
 863 case 5:
 864 #line 120 "./mcy.y"
 865 { add_node(nd_msg, yyvsp[0].msg); ;
 866     break;}
 867 case 6:
 868 #line 121 "./mcy.y"
 869 { add_node(nd_comment, yyvsp[0].str); ;
 870     break;}
 871 case 7:
 872 #line 122 "./mcy.y"
 873 { xyyerror(err_syntax); /* `Catch all' error */ ;
 874     break;}
 875 case 9:
 876 #line 126 "./mcy.y"
 877 { xyyerror(err_pclose); ;
 878     break;}
 879 case 10:
 880 #line 127 "./mcy.y"
 881 { xyyerror(err_popen); ;
 882     break;}
 883 case 11:
 884 #line 128 "./mcy.y"
 885 { xyyerror(err_assign); ;
 886     break;}
 887 case 13:
 888 #line 130 "./mcy.y"
 889 { xyyerror(err_pclose); ;
 890     break;}
 891 case 14:
 892 #line 131 "./mcy.y"
 893 { xyyerror(err_popen); ;
 894     break;}
 895 case 15:
 896 #line 132 "./mcy.y"
 897 { xyyerror(err_assign); ;
 898     break;}
 899 case 17:
 900 #line 134 "./mcy.y"
 901 { xyyerror(err_pclose); ;
 902     break;}
 903 case 18:
 904 #line 135 "./mcy.y"
 905 { xyyerror(err_popen); ;
 906     break;}
 907 case 19:
 908 #line 136 "./mcy.y"
 909 { xyyerror(err_assign); ;
 910     break;}
 911 case 21:
 912 #line 138 "./mcy.y"
 913 { xyyerror(err_pclose); ;
 914     break;}
 915 case 22:
 916 #line 139 "./mcy.y"
 917 { xyyerror(err_popen); ;
 918     break;}
 919 case 23:
 920 #line 140 "./mcy.y"
 921 { xyyerror(err_assign); ;
 922     break;}
 923 case 24:
 924 #line 141 "./mcy.y"
 925 { cast = yyvsp[0].str; ;
 926     break;}
 927 case 25:
 928 #line 142 "./mcy.y"
 929 { xyyerror(err_number); ;
 930     break;}
 931 case 26:
 932 #line 143 "./mcy.y"
 933 { xyyerror(err_assign); ;
 934     break;}
 935 case 27:
 936 #line 144 "./mcy.y"
 937 {
 938                 switch(base)
 939                 {
 940                 case 8:
 941                 case 10:
 942                 case 16:
 943                         base = yyvsp[0].num;
 944                         break;
 945                 default:
 946                         xyyerror("Numberbase must be 8, 10 or 16");
 947                 }
 948         ;
 949     break;}
 950 case 28:
 951 #line 156 "./mcy.y"
 952 { xyyerror(err_number); ;
 953     break;}
 954 case 29:
 955 #line 157 "./mcy.y"
 956 { xyyerror(err_assign); ;
 957     break;}
 958 case 32:
 959 #line 165 "./mcy.y"
 960 { xyyerror(err_ident); ;
 961     break;}
 962 case 33:
 963 #line 168 "./mcy.y"
 964 {
 965                 yyvsp[-3].tok->token = yyvsp[-1].num;
 966                 yyvsp[-3].tok->alias = yyvsp[0].str;
 967                 if(yyvsp[-1].num & (~0x3))
 968                         xyyerror("Severity value out of range (0x%08x > 0x3)", yyvsp[-1].num);
 969                 do_add_token(tok_severity, yyvsp[-3].tok, "severity");
 970         ;
 971     break;}
 972 case 34:
 973 #line 175 "./mcy.y"
 974 { xyyerror(err_number); ;
 975     break;}
 976 case 35:
 977 #line 176 "./mcy.y"
 978 { xyyerror(err_assign); ;
 979     break;}
 980 case 38:
 981 #line 184 "./mcy.y"
 982 { xyyerror(err_ident); ;
 983     break;}
 984 case 39:
 985 #line 187 "./mcy.y"
 986 {
 987                 yyvsp[-3].tok->token = yyvsp[-1].num;
 988                 yyvsp[-3].tok->alias = yyvsp[0].str;
 989                 if(yyvsp[-1].num & (~0xfff))
 990                         xyyerror("Facility value out of range (0x%08x > 0xfff)", yyvsp[-1].num);
 991                 do_add_token(tok_facility, yyvsp[-3].tok, "facility");
 992         ;
 993     break;}
 994 case 40:
 995 #line 194 "./mcy.y"
 996 { xyyerror(err_number); ;
 997     break;}
 998 case 41:
 999 #line 195 "./mcy.y"
1000 { xyyerror(err_assign); ;
1001     break;}
1002 case 42:
1003 #line 198 "./mcy.y"
1004 { yyval.str = NULL; ;
1005     break;}
1006 case 43:
1007 #line 199 "./mcy.y"
1008 { yyval.str = yyvsp[0].str; ;
1009     break;}
1010 case 44:
1011 #line 200 "./mcy.y"
1012 { xyyerror(err_ident); ;
1013     break;}
1014 case 47:
1015 #line 208 "./mcy.y"
1016 { xyyerror(err_ident); ;
1017     break;}
1018 case 48:
1019 #line 211 "./mcy.y"
1020 {
1021                 yyvsp[-6].tok->token = yyvsp[-4].num;
1022                 yyvsp[-6].tok->alias = yyvsp[-1].str;
1023                 yyvsp[-6].tok->codepage = yyvsp[0].num;
1024                 do_add_token(tok_language, yyvsp[-6].tok, "language");
1025                 if(!find_language(yyvsp[-6].tok->token) && !find_cpxlat(yyvsp[-6].tok->token))
1026                         yywarning("Language 0x%x not built-in, using codepage %d; use explicit codepage to override", yyvsp[-6].tok->token, WMC_DEFAULT_CODEPAGE);
1027         ;
1028     break;}
1029 case 49:
1030 #line 219 "./mcy.y"
1031 { xyyerror("Filename expected"); ;
1032     break;}
1033 case 50:
1034 #line 220 "./mcy.y"
1035 { xyyerror(err_colon); ;
1036     break;}
1037 case 51:
1038 #line 221 "./mcy.y"
1039 { xyyerror(err_number); ;
1040     break;}
1041 case 52:
1042 #line 222 "./mcy.y"
1043 { xyyerror(err_assign); ;
1044     break;}
1045 case 53:
1046 #line 225 "./mcy.y"
1047 { yyval.num = 0; ;
1048     break;}
1049 case 54:
1050 #line 226 "./mcy.y"
1051 { yyval.num = yyvsp[0].num; ;
1052     break;}
1053 case 55:
1054 #line 227 "./mcy.y"
1055 { xyyerror("Codepage-number expected"); ;
1056     break;}
1057 case 58:
1058 #line 235 "./mcy.y"
1059 { xyyerror(err_ident); ;
1060     break;}
1061 case 59:
1062 #line 238 "./mcy.y"
1063 {
1064                 static const char err_nocp[] = "Codepage %d not builtin; cannot convert";
1065                 if(find_cpxlat(yyvsp[-4].num))
1066                         xyyerror("Codepage translation already defined for language 0x%x", yyvsp[-4].num);
1067 //              if(yyvsp[-2].num && !find_codepage(yyvsp[-2].num))
1068                 if(yyvsp[-2].num)\r
1069                         xyyerror(err_nocp, yyvsp[-2].num);
1070 //              if(yyvsp[0].num && !find_codepage(yyvsp[0].num))
1071                 if(yyvsp[0].num)\r
1072                         xyyerror(err_nocp, yyvsp[0].num);
1073                 add_cpxlat(yyvsp[-4].num, yyvsp[-2].num, yyvsp[0].num);
1074         ;
1075     break;}
1076 case 60:
1077 #line 248 "./mcy.y"
1078 { xyyerror(err_number); ;
1079     break;}
1080 case 61:
1081 #line 249 "./mcy.y"
1082 { xyyerror(err_colon); ;
1083     break;}
1084 case 62:
1085 #line 250 "./mcy.y"
1086 { xyyerror(err_number); ;
1087     break;}
1088 case 63:
1089 #line 251 "./mcy.y"
1090 { xyyerror(err_assign); ;
1091     break;}
1092 case 64:
1093 #line 254 "./mcy.y"
1094 { yyval.num = yyvsp[0].num; ;
1095     break;}
1096 case 65:
1097 #line 255 "./mcy.y"
1098 {
1099                 if(yyvsp[0].tok->type != tok_language)
1100                         xyyerror("Language name or code expected");
1101                 yyval.num = yyvsp[0].tok->token;
1102         ;
1103     break;}
1104 case 66:
1105 #line 265 "./mcy.y"
1106 { test_id(yyvsp[-1].num); ;
1107     break;}
1108 case 67:
1109 #line 265 "./mcy.y"
1110 { yyval.msg = complete_msg(yyvsp[0].msg, yyvsp[-3].num); ;
1111     break;}
1112 case 68:
1113 #line 268 "./mcy.y"
1114 {
1115                 if(yyvsp[0].num & (~0xffff))
1116                         xyyerror("Message ID value out of range (0x%08x > 0xffff)", yyvsp[0].num);
1117                 yyval.num = yyvsp[0].num;
1118         ;
1119     break;}
1120 case 69:
1121 #line 273 "./mcy.y"
1122 { xyyerror(err_assign); ;
1123     break;}
1124 case 70:
1125 #line 276 "./mcy.y"
1126 { yyval.num = ++last_id; ;
1127     break;}
1128 case 71:
1129 #line 277 "./mcy.y"
1130 { yyval.num = last_id = yyvsp[0].num; ;
1131     break;}
1132 case 72:
1133 #line 278 "./mcy.y"
1134 { yyval.num = last_id += yyvsp[0].num; ;
1135     break;}
1136 case 73:
1137 #line 279 "./mcy.y"
1138 { xyyerror(err_number); ;
1139     break;}
1140 case 74:
1141 #line 282 "./mcy.y"
1142 { have_sev = have_fac = have_sym = 0; ;
1143     break;}
1144 case 75:
1145 #line 283 "./mcy.y"
1146 { if(have_sev) xyyerror("Severity already defined"); have_sev = 1; ;
1147     break;}
1148 case 76:
1149 #line 284 "./mcy.y"
1150 { if(have_fac) xyyerror("Facility already defined"); have_fac = 1; ;
1151     break;}
1152 case 77:
1153 #line 285 "./mcy.y"
1154 { if(have_sym) xyyerror("Symbolname already defined"); have_sym = 1; ;
1155     break;}
1156 case 78:
1157 #line 288 "./mcy.y"
1158 { last_sym = yyvsp[0].str; ;
1159     break;}
1160 case 79:
1161 #line 289 "./mcy.y"
1162 { xyyerror(err_ident); ;
1163     break;}
1164 case 80:
1165 #line 290 "./mcy.y"
1166 { xyyerror(err_assign); ;
1167     break;}
1168 case 81:
1169 #line 293 "./mcy.y"
1170 {
1171                 token_t *tok = lookup_token(yyvsp[0].tok->name);
1172                 if(!tok)
1173                         xyyerror("Undefined severityname");
1174                 if(tok->type != tok_severity)
1175                         xyyerror("Identifier is not of class 'severity'");
1176                 last_sev = tok->token;
1177         ;
1178     break;}
1179 case 82:
1180 #line 301 "./mcy.y"
1181 { xyyerror(err_ident); ;
1182     break;}
1183 case 83:
1184 #line 302 "./mcy.y"
1185 { xyyerror(err_assign); ;
1186     break;}
1187 case 84:
1188 #line 305 "./mcy.y"
1189 {
1190                 token_t *tok = lookup_token(yyvsp[0].tok->name);
1191                 if(!tok)
1192                         xyyerror("Undefined facilityname");
1193                 if(tok->type != tok_facility)
1194                         xyyerror("Identifier is not of class 'facility'");
1195                 last_fac = tok->token;
1196         ;
1197     break;}
1198 case 85:
1199 #line 313 "./mcy.y"
1200 { xyyerror(err_ident); ;
1201     break;}
1202 case 86:
1203 #line 314 "./mcy.y"
1204 { xyyerror(err_assign); ;
1205     break;}
1206 case 87:
1207 #line 320 "./mcy.y"
1208 { yyval.msg = add_lanmsg(NULL, yyvsp[0].lmp); ;
1209     break;}
1210 case 88:
1211 #line 321 "./mcy.y"
1212 { yyval.msg = add_lanmsg(yyvsp[-1].msg, yyvsp[0].lmp); ;
1213     break;}
1214 case 89:
1215 #line 322 "./mcy.y"
1216 { xyyerror("'Language=...' (start of message text-definition) expected"); ;
1217     break;}
1218 case 90:
1219 #line 325 "./mcy.y"
1220 { yyval.lmp = new_lanmsg(&yyvsp[-3].lcp, yyvsp[-1].str); ;
1221     break;}
1222 case 91:
1223 #line 333 "./mcy.y"
1224 {
1225                 token_t *tok = lookup_token(yyvsp[-1].tok->name);
1226                 cp_xlat_t *cpx;
1227                 if(!tok)
1228                         xyyerror("Undefined language");
1229                 if(tok->type != tok_language)
1230                         xyyerror("Identifier is not of class 'language'");
1231                 if((cpx = find_cpxlat(tok->token)))
1232                 {
1233                         set_codepage(yyval.lcp.codepage = cpx->cpin);
1234                 }
1235                 else if(!tok->codepage)
1236                 {
1237                         const language_t *lan = find_language(tok->token);
1238                         if(!lan)
1239                         {
1240                                 /* Just set default; warning was given while parsing languagenames */
1241                                 set_codepage(yyval.lcp.codepage = WMC_DEFAULT_CODEPAGE);
1242                         }
1243                         else
1244                         {
1245                                 /* The default seems to be to use the DOS codepage... */
1246                                 set_codepage(yyval.lcp.codepage = lan->doscp);
1247                         }
1248                 }
1249                 else
1250                         set_codepage(yyval.lcp.codepage = tok->codepage);
1251                 yyval.lcp.language = tok->token;
1252         ;
1253     break;}
1254 case 92:
1255 #line 362 "./mcy.y"
1256 { xyyerror("Missing newline"); ;
1257     break;}
1258 case 93:
1259 #line 363 "./mcy.y"
1260 { xyyerror(err_ident); ;
1261     break;}
1262 case 94:
1263 #line 364 "./mcy.y"
1264 { xyyerror(err_assign); ;
1265     break;}
1266 case 95:
1267 #line 367 "./mcy.y"
1268 { yyval.str = yyvsp[0].str; ;
1269     break;}
1270 case 96:
1271 #line 368 "./mcy.y"
1272 { yyval.str = merge(yyvsp[-1].str, yyvsp[0].str); ;
1273     break;}
1274 case 97:
1275 #line 369 "./mcy.y"
1276 { xyyerror(err_msg); ;
1277     break;}
1278 case 98:
1279 #line 370 "./mcy.y"
1280 { xyyerror(err_msg); ;
1281     break;}
1282 case 99:
1283 #line 376 "./mcy.y"
1284 { yyval.tok = xmalloc(sizeof(token_t)); yyval.tok->name = yyvsp[0].str; ;
1285     break;}
1286 case 100:
1287 #line 377 "./mcy.y"
1288 { yyval.tok = yyvsp[0].tok; ;
1289     break;}
1290 case 101:
1291 #line 380 "./mcy.y"
1292 { want_nl = 1; ;
1293     break;}
1294 case 102:
1295 #line 383 "./mcy.y"
1296 { want_line = 1; ;
1297     break;}
1298 case 103:
1299 #line 386 "./mcy.y"
1300 { want_file = 1; ;
1301     break;}
1302 }
1303    /* the action file gets copied in in place of this dollarsign */
1304 #line 498 "/usr/share/bison.simple"
1305
1306   yyvsp -= yylen;
1307   yyssp -= yylen;
1308 #ifdef YYLSP_NEEDED
1309   yylsp -= yylen;
1310 #endif
1311
1312 #if YYDEBUG != 0
1313   if (yydebug)
1314     {
1315       short *ssp1 = yyss - 1;
1316       fprintf (stderr, "state stack now");
1317       while (ssp1 != yyssp)
1318         fprintf (stderr, " %d", *++ssp1);
1319       fprintf (stderr, "\n");
1320     }
1321 #endif
1322
1323   *++yyvsp = yyval;
1324
1325 #ifdef YYLSP_NEEDED
1326   yylsp++;
1327   if (yylen == 0)
1328     {
1329       yylsp->first_line = yylloc.first_line;
1330       yylsp->first_column = yylloc.first_column;
1331       yylsp->last_line = (yylsp-1)->last_line;
1332       yylsp->last_column = (yylsp-1)->last_column;
1333       yylsp->text = 0;
1334     }
1335   else
1336     {
1337       yylsp->last_line = (yylsp+yylen-1)->last_line;
1338       yylsp->last_column = (yylsp+yylen-1)->last_column;
1339     }
1340 #endif
1341
1342   /* Now "shift" the result of the reduction.
1343      Determine what state that goes to,
1344      based on the state we popped back to
1345      and the rule number reduced by.  */
1346
1347   yyn = yyr1[yyn];
1348
1349   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1350   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1351     yystate = yytable[yystate];
1352   else
1353     yystate = yydefgoto[yyn - YYNTBASE];
1354
1355   goto yynewstate;
1356
1357 yyerrlab:   /* here on detecting error */
1358
1359   if (! yyerrstatus)
1360     /* If not already recovering from an error, report this error.  */
1361     {
1362       ++yynerrs;
1363
1364 #ifdef YYERROR_VERBOSE
1365       yyn = yypact[yystate];
1366
1367       if (yyn > YYFLAG && yyn < YYLAST)
1368         {
1369           int size = 0;
1370           char *msg;
1371           int x, count;
1372
1373           count = 0;
1374           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
1375           for (x = (yyn < 0 ? -yyn : 0);
1376                x < (sizeof(yytname) / sizeof(char *)); x++)
1377             if (yycheck[x + yyn] == x)
1378               size += strlen(yytname[x]) + 15, count++;
1379           msg = (char *) malloc(size + 15);
1380           if (msg != 0)
1381             {
1382               strcpy(msg, "parse error");
1383
1384               if (count < 5)
1385                 {
1386                   count = 0;
1387                   for (x = (yyn < 0 ? -yyn : 0);
1388                        x < (sizeof(yytname) / sizeof(char *)); x++)
1389                     if (yycheck[x + yyn] == x)
1390                       {
1391                         strcat(msg, count == 0 ? ", expecting `" : " or `");
1392                         strcat(msg, yytname[x]);
1393                         strcat(msg, "'");
1394                         count++;
1395                       }
1396                 }
1397               yyerror(msg);
1398               free(msg);
1399             }
1400           else
1401             yyerror ("parse error; also virtual memory exceeded");
1402         }
1403       else
1404 #endif /* YYERROR_VERBOSE */
1405         yyerror("parse error");
1406     }
1407
1408   goto yyerrlab1;
1409 yyerrlab1:   /* here on error raised explicitly by an action */
1410
1411   if (yyerrstatus == 3)
1412     {
1413       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1414
1415       /* return failure if at end of input */
1416       if (yychar == YYEOF)
1417         YYABORT;
1418
1419 #if YYDEBUG != 0
1420       if (yydebug)
1421         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1422 #endif
1423
1424       yychar = YYEMPTY;
1425     }
1426
1427   /* Else will try to reuse lookahead token
1428      after shifting the error token.  */
1429
1430   yyerrstatus = 3;              /* Each real token shifted decrements this */
1431
1432   goto yyerrhandle;
1433
1434 yyerrdefault:  /* current state does not do anything special for the error token. */
1435
1436 #if 0
1437   /* This is wrong; only states that explicitly want error tokens
1438      should shift them.  */
1439   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1440   if (yyn) goto yydefault;
1441 #endif
1442
1443 yyerrpop:   /* pop the current state because it cannot handle the error token */
1444
1445   if (yyssp == yyss) YYABORT;
1446   yyvsp--;
1447   yystate = *--yyssp;
1448 #ifdef YYLSP_NEEDED
1449   yylsp--;
1450 #endif
1451
1452 #if YYDEBUG != 0
1453   if (yydebug)
1454     {
1455       short *ssp1 = yyss - 1;
1456       fprintf (stderr, "Error: state stack now");
1457       while (ssp1 != yyssp)
1458         fprintf (stderr, " %d", *++ssp1);
1459       fprintf (stderr, "\n");
1460     }
1461 #endif
1462
1463 yyerrhandle:
1464
1465   yyn = yypact[yystate];
1466   if (yyn == YYFLAG)
1467     goto yyerrdefault;
1468
1469   yyn += YYTERROR;
1470   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1471     goto yyerrdefault;
1472
1473   yyn = yytable[yyn];
1474   if (yyn < 0)
1475     {
1476       if (yyn == YYFLAG)
1477         goto yyerrpop;
1478       yyn = -yyn;
1479       goto yyreduce;
1480     }
1481   else if (yyn == 0)
1482     goto yyerrpop;
1483
1484   if (yyn == YYFINAL)
1485     YYACCEPT;
1486
1487 #if YYDEBUG != 0
1488   if (yydebug)
1489     fprintf(stderr, "Shifting error token, ");
1490 #endif
1491
1492   *++yyvsp = yylval;
1493 #ifdef YYLSP_NEEDED
1494   *++yylsp = yylloc;
1495 #endif
1496
1497   yystate = yyn;
1498   goto yynewstate;
1499 }
1500 #line 389 "./mcy.y"
1501
1502
1503 static WCHAR *merge(WCHAR *s1, WCHAR *s2)
1504 {
1505         int l1 = unistrlen(s1);
1506         int l2 = unistrlen(s2);
1507         s1 = xrealloc(s1, (l1 + l2 + 1) * sizeof(*s1));
1508         unistrcpy(s1+l1, s2);
1509         free(s2);
1510         return s1;
1511 }
1512
1513 static void do_add_token(tok_e type, token_t *tok, const char *code)
1514 {
1515         token_t *tp = lookup_token(tok->name);
1516         if(tp)
1517         {
1518                 if(tok->type != type)
1519                         yywarning("Type change in token");
1520                 if(tp != tok)
1521                         xyyerror("Overlapping token not the same");
1522                 /* else its already defined and changed */
1523                 if(tok->fixed)
1524                         xyyerror("Redefinition of %s", code);
1525                 tok->fixed = 1;
1526         }
1527         else
1528         {
1529                 add_token(type, tok->name, tok->token, tok->codepage, tok->alias, 1);
1530                 free(tok);
1531         }
1532 }
1533
1534 static lanmsg_t *new_lanmsg(lan_cp_t *lcp, WCHAR *msg)
1535 {
1536         lanmsg_t *lmp = (lanmsg_t *)xmalloc(sizeof(lanmsg_t));
1537         lmp->lan = lcp->language;
1538         lmp->cp  = lcp->codepage;
1539         lmp->msg = msg;
1540         lmp->len = unistrlen(msg) + 1;  /* Include termination */
1541         if(lmp->len > 4096)
1542                 yywarning("Message exceptionally long; might be a missing termination");
1543         return lmp;
1544 }
1545
1546 static msg_t *add_lanmsg(msg_t *msg, lanmsg_t *lanmsg)
1547 {
1548         int i;
1549         if(!msg)
1550                 msg = xmalloc(sizeof(msg_t));
1551         msg->msgs = xrealloc(msg->msgs, (msg->nmsgs+1) * sizeof(*(msg->msgs)));
1552         msg->msgs[msg->nmsgs] = lanmsg;
1553         msg->nmsgs++;
1554         for(i = 0; i < msg->nmsgs-1; i++)
1555         {
1556                 if(msg->msgs[i]->lan == lanmsg->lan)
1557                         xyyerror("Message for language 0x%x already defined", lanmsg->lan);
1558         }
1559         return msg;
1560 }
1561
1562 static int sort_lanmsg(const void *p1, const void *p2)
1563 {
1564         return (*(lanmsg_t **)p1)->lan - (*(lanmsg_t **)p2)->lan;
1565 }
1566
1567 static msg_t *complete_msg(msg_t *mp, int id)
1568 {
1569         assert(mp != NULL);
1570         mp->id = id;
1571         if(have_sym)
1572                 mp->sym = last_sym;
1573         else
1574                 xyyerror("No symbolic name defined for message id %d", id);
1575         mp->sev = last_sev;
1576         mp->fac = last_fac;
1577         qsort(mp->msgs, mp->nmsgs, sizeof(*(mp->msgs)), sort_lanmsg);
1578         mp->realid = id | (last_sev << 30) | (last_fac << 16);
1579         if(custombit)
1580                 mp->realid |= 1 << 29;
1581         mp->base = base;
1582         mp->cast = cast;
1583         return mp;
1584 }
1585
1586 static void add_node(node_e type, void *p)
1587 {
1588         node_t *ndp = (node_t *)xmalloc(sizeof(node_t));
1589         ndp->type = type;
1590         ndp->u.all = p;
1591
1592         if(nodetail)
1593         {
1594                 ndp->prev = nodetail;
1595                 nodetail->next = ndp;
1596                 nodetail = ndp;
1597         }
1598         else
1599         {
1600                 nodehead = nodetail = ndp;
1601         }
1602 }
1603
1604 static void test_id(int id)
1605 {
1606         node_t *ndp;
1607         for(ndp = nodehead; ndp; ndp = ndp->next)
1608         {
1609                 if(ndp->type != nd_msg)
1610                         continue;
1611                 if(ndp->u.msg->id == id && ndp->u.msg->sev == last_sev && ndp->u.msg->fac == last_fac)
1612                         xyyerror("MessageId %d with facility 0x%x and severity 0x%x already defined", id, last_fac, last_sev);
1613         }
1614 }
1615
1616 static int check_languages(node_t *head)
1617 {
1618         static char err_missing[] = "Missing definition for language 0x%x; MessageID %d, facility 0x%x, severity 0x%x";
1619         node_t *ndp;
1620         int nm = 0;
1621         msg_t *msg = NULL;
1622
1623         for(ndp = head; ndp; ndp = ndp->next)
1624         {
1625                 if(ndp->type != nd_msg)
1626                         continue;
1627                 if(!nm)
1628                 {
1629                         msg = ndp->u.msg;
1630                 }
1631                 else
1632                 {
1633                         int i;
1634                         msg_t *m1;
1635                         msg_t *m2;
1636                         if(ndp->u.msg->nmsgs > msg->nmsgs)
1637                         {
1638                                 m1 = ndp->u.msg;
1639                                 m2 = msg;
1640                         }
1641                         else
1642                         {
1643                                 m1 = msg;
1644                                 m2 = ndp->u.msg;
1645                         }
1646
1647                         for(i = 0; i < m1->nmsgs; i++)
1648                         {
1649                                 if(i > m2->nmsgs)
1650                                         error(err_missing, m1->msgs[i]->lan, m2->id, m2->fac, m2->sev);
1651                                 else if(m1->msgs[i]->lan < m2->msgs[i]->lan)
1652                                         error(err_missing, m1->msgs[i]->lan, m2->id, m2->fac, m2->sev);
1653                                 else if(m1->msgs[i]->lan > m2->msgs[i]->lan)
1654                                         error(err_missing, m2->msgs[i]->lan, m1->id, m1->fac, m1->sev);
1655                         }
1656                 }
1657                 nm++;
1658         }
1659         return nm;
1660 }
1661
1662 #define MSGRID(x)       ((*(msg_t **)(x))->realid)
1663 static int sort_msg(const void *p1, const void *p2)
1664 {
1665         return MSGRID(p1) > MSGRID(p2) ? 1 : (MSGRID(p1) == MSGRID(p2) ? 0 : -1);
1666         /* return (*(msg_t **)p1)->realid - (*(msg_t **)p1)->realid; */
1667 }
1668
1669 /*
1670  * block_messages() basically transposes the messages
1671  * from ID/language based list to a language/ID
1672  * based list.
1673  */
1674 static lan_blk_t *block_messages(node_t *head)
1675 {
1676         lan_blk_t *lbp;
1677         lan_blk_t *lblktail = NULL;
1678         lan_blk_t *lblkhead = NULL;
1679         msg_t **msgtab = NULL;
1680         node_t *ndp;
1681         int nmsg = 0;
1682         int i;
1683         int nl;
1684         int factor = unicodeout ? 2 : 1;
1685
1686         for(ndp = head; ndp; ndp = ndp->next)
1687         {
1688                 if(ndp->type != nd_msg)
1689                         continue;
1690                 msgtab = xrealloc(msgtab, (nmsg+1) * sizeof(*msgtab));
1691                 msgtab[nmsg++] = ndp->u.msg;
1692         }
1693
1694         assert(nmsg != 0);
1695         qsort(msgtab, nmsg, sizeof(*msgtab), sort_msg);
1696
1697         for(nl = 0; nl < msgtab[0]->nmsgs; nl++)        /* This should be equal for all after check_languages() */
1698         {
1699                 lbp = xmalloc(sizeof(lan_blk_t));
1700
1701                 if(!lblktail)
1702                 {
1703                         lblkhead = lblktail = lbp;
1704                 }
1705                 else
1706                 {
1707                         lblktail->next = lbp;
1708                         lbp->prev = lblktail;
1709                         lblktail = lbp;
1710                 }
1711                 lbp->nblk = 1;
1712                 lbp->blks = xmalloc(sizeof(*lbp->blks));
1713                 lbp->blks[0].idlo = msgtab[0]->realid;
1714                 lbp->blks[0].idhi = msgtab[0]->realid;
1715                 /* The plus 4 is the entry header; (+3)&~3 is DWORD alignment */
1716                 lbp->blks[0].size = ((factor * msgtab[0]->msgs[nl]->len + 3) & ~3) + 4;
1717                 lbp->blks[0].msgs = xmalloc(sizeof(*lbp->blks[0].msgs));
1718                 lbp->blks[0].nmsg = 1;
1719                 lbp->blks[0].msgs[0] = msgtab[0]->msgs[nl];
1720                 lbp->lan = msgtab[0]->msgs[nl]->lan;
1721
1722                 for(i = 1; i < nmsg; i++)
1723                 {
1724                         block_t *blk = &(lbp->blks[lbp->nblk-1]);
1725                         if(msgtab[i]->realid == blk->idhi+1)
1726                         {
1727                                 blk->size += ((factor * msgtab[i]->msgs[nl]->len + 3) & ~3) + 4;
1728                                 blk->idhi++;
1729                                 blk->msgs = xrealloc(blk->msgs, (blk->nmsg+1) * sizeof(*blk->msgs));
1730                                 blk->msgs[blk->nmsg++] = msgtab[i]->msgs[nl];
1731                         }
1732                         else
1733                         {
1734                                 lbp->nblk++;
1735                                 lbp->blks = xrealloc(lbp->blks, lbp->nblk * sizeof(*lbp->blks));
1736                                 blk = &(lbp->blks[lbp->nblk-1]);
1737                                 blk->idlo = msgtab[i]->realid;
1738                                 blk->idhi = msgtab[i]->realid;
1739                                 blk->size = ((factor * msgtab[i]->msgs[nl]->len + 3) & ~3) + 4;
1740                                 blk->msgs = xmalloc(sizeof(*blk->msgs));
1741                                 blk->nmsg = 1;
1742                                 blk->msgs[0] = msgtab[i]->msgs[nl];
1743                         }
1744                 }
1745         }
1746         free(msgtab);
1747         return lblkhead;
1748 }
1749
1750 static int sc_xlat(const void *p1, const void *p2)
1751 {
1752         return ((cp_xlat_t *)p1)->lan - ((cp_xlat_t *)p2)->lan;
1753 }
1754
1755 static void add_cpxlat(int lan, int cpin, int cpout)
1756 {
1757         cpxlattab = xrealloc(cpxlattab, (ncpxlattab+1) * sizeof(*cpxlattab));
1758         cpxlattab[ncpxlattab].lan   = lan;
1759         cpxlattab[ncpxlattab].cpin  = cpin;
1760         cpxlattab[ncpxlattab].cpout = cpout;
1761         ncpxlattab++;
1762         qsort(cpxlattab, ncpxlattab, sizeof(*cpxlattab), sc_xlat);
1763 }
1764
1765 static cp_xlat_t *find_cpxlat(int lan)
1766 {
1767         cp_xlat_t t;
1768
1769         if(!cpxlattab) return NULL;
1770
1771         t.lan = lan;
1772         return (cp_xlat_t *)bsearch(&t, cpxlattab, ncpxlattab, sizeof(*cpxlattab), sc_xlat);
1773 }
1774