cde/programs/dtinfo/DtMmdb/StyleSheet/defParser.C

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 // $TOG: defParser.C /main/5 1997/12/23 11:16:25 bill $
  24 #ifndef lint
  25 static const char defParsersccsid[] = "@(#)yaccpar      1.8 (Berkeley) 01/20/90";
  26 #endif
  27 #define defParserBYACC 1
  28 #include <stdio.h>
  29 #include <ctype.h>
  30 #include <sstream>
  31 #include <iostream>
  32 using namespace std;
  33 #include "Debug.h"
  34 #include "FeatureDefDictionary.h"
  35
  36 #ifdef alloca
  37 # undef alloca
  38 #endif
  39 #define alloca(x)       (malloc(x))
  40
  41 def_list_t* g_def_list = 0;
  42
  43 extern void defParsererror(char*);
  44 extern int defParserlex();
  45
  46 #undef defParserwrap
  47
  48 typedef union
  49 {
  50  unsigned char  charData;
  51  unsigned char* charPtrData;
  52  int            intData;
  53  float          realData;
  54  FeatureValue*  valueData;
  55
  56  defv_t*        valueListPtrData;
  57  TypeValues*    typeValuesPtrData;
  58  type_values_list_t*    typeValuesListPtrData;
  59
  60  def_list_t*    defListPtrData;
  61  FeatureDef*    defPtrData;
  62
  63 } defParserSTYPE;
  64 #define STAR 257
  65 #define COMMA 258
  66 #define COLON 259
  67 #define SEMI_COLON 260
  68 #define FSOPEN 261
  69 #define FSCLOSE 262
  70 #define OPER_parenopen 263
  71 #define OPER_parenclose 264
  72 #define INTEGER 265
  73 #define REAL 266
  74 #define NORMAL_STRING 267
  75 #define QUOTED_STRING 268
  76 #define REF_NAME 269
  77 #define TYPE 270
  78 #define ValueListOpt 271
  79 #define defParserERRCODE 256
  80 short defParserlhs[] = {                                        -1,
  81     0,   11,   11,    6,    6,    6,    6,    8,   10,    7,
  82     9,    1,    5,    5,    4,    4,    3,    3,    2,    2,
  83     2,
  84 };
  85 short defParserlen[] = {                                         2,
  86     1,    2,    1,    1,    1,    1,    1,    4,    4,    2,
  87     2,    1,    3,    1,    4,    1,    3,    1,    1,    1,
  88     1,
  89 };
  90 short defParserdefred[] = {                                      0,
  91     0,   12,    0,    0,    3,    6,    4,    7,    5,    0,
  92    11,    0,   10,    0,    2,    0,   14,    0,    0,    0,
  93     0,    9,    8,   19,   21,   20,   18,    0,   13,    0,
  94    15,   17,
  95 };
  96 short defParserdgoto[] = {                                       3,
  97     4,   27,   28,   17,   18,    5,    6,    7,    8,    9,
  98    10,
  99 };
 100 short defParsersindex[] = {                                   -256,
 101  -258,    0,    0, -240,    0,    0,    0,    0,    0, -256,
 102     0, -262,    0, -256,    0, -249,    0, -254, -257, -250,
 103  -262,    0,    0,    0,    0,    0,    0, -251,    0, -250,
 104     0,    0,
 105 };
 106 short defParserrindex[] = {                                      0,
 107     0,    0,    0,    0,    0,    0,    0,    0,    0,    9,
 108     0,    0,    0,    0,    0, -236,    0,    0,    0,    0,
 109     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 110     0,    0,
 111 };
 112 short defParsergindex[] = {                                      0,
 113     0,  -13,    0,    2,    0,   -7,    0,    0,    0,    0,
 114    11,
 115 };
 116 #define defParserTABLESIZE 25
 117 short defParsertable[] = {                                       1,
 118     1,   11,   15,   21,   23,   22,   30,   16,    1,    2,
 119     2,   15,   31,   20,   24,   25,   32,   26,   12,   13,
 120    14,   16,   29,   16,   19,
 121 };
 122 short defParsercheck[] = {                                     257,
 123   257,  260,   10,  258,  262,  260,  258,  270,    0,  267,
 124   267,   19,  264,  263,  265,  266,   30,  268,  259,  260,
 125   261,  258,   21,  260,   14,
 126 };
 127 #define defParserFINAL 3
 128 #ifndef defParserDEBUG
 129 #define defParserDEBUG 0
 130 #endif
 131 #define defParserMAXTOKEN 271
 132 #if defParserDEBUG
 133 char *defParsername[] = {
 134 "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 135 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 136 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 137 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 138 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 139 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 140 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"STAR","COMMA","COLON",
 141 "SEMI_COLON","FSOPEN","FSCLOSE","OPER_parenopen","OPER_parenclose","INTEGER",
 142 "REAL","NORMAL_STRING","QUOTED_STRING","REF_NAME","TYPE","ValueListOpt",
 143 };
 144 char *defParserrule[] = {
 145 "$accept : featureDef",
 146 "featureDef : DefList",
 147 "DefList : DefList Def",
 148 "DefList : Def",
 149 "Def : CompositeDef",
 150 "Def : PrimitiveDef",
 151 "Def : DefReference",
 152 "Def : WildCardDef",
 153 "CompositeDef : Name FSOPEN DefList FSCLOSE",
 154 "PrimitiveDef : Name COLON TypeValuesList SEMI_COLON",
 155 "DefReference : Name SEMI_COLON",
 156 "WildCardDef : STAR SEMI_COLON",
 157 "Name : NORMAL_STRING",
 158 "TypeValuesList : TypeValuesList COMMA TypeValues",
 159 "TypeValuesList : TypeValues",
 160 "TypeValues : TYPE OPER_parenopen ValueList OPER_parenclose",
 161 "TypeValues : TYPE",
 162 "ValueList : ValueList COMMA Value",
 163 "ValueList : Value",
 164 "Value : INTEGER",
 165 "Value : QUOTED_STRING",
 166 "Value : REAL",
 167 };
 168 #endif
 169 #define defParserclearin (defParserchar=(-1))
 170 #define defParsererrok (defParsererrflag=0)
 171 #ifdef defParserSTACKSIZE
 172 #ifndef defParserMAXDEPTH
 173 #define defParserMAXDEPTH defParserSTACKSIZE
 174 #endif
 175 #else
 176 #ifdef defParserMAXDEPTH
 177 #define defParserSTACKSIZE defParserMAXDEPTH
 178 #else
 179 #define defParserSTACKSIZE 500
 180 #define defParserMAXDEPTH 500
 181 #endif
 182 #endif
 183 int defParserdebug;
 184 int defParsernerrs;
 185 int defParsererrflag;
 186 int defParserchar;
 187 short *defParserssp;
 188 defParserSTYPE *defParservsp;
 189 defParserSTYPE defParserval;
 190 defParserSTYPE defParserlval;
 191 short defParserss[defParserSTACKSIZE];
 192 defParserSTYPE defParservs[defParserSTACKSIZE];
 193 #define defParserstacksize defParserSTACKSIZE
 194
 195 /*
 196 void defParsererror(char *errorstr)
 197 {
 198   cerr << errorstr ;
 199 }
 200 */
 201 #define defParserABORT goto defParserabort
 202 #define defParserACCEPT goto defParseraccept
 203 #define defParserERROR goto defParsererrlab
 204 #if defParserDEBUG
 205 #ifndef __cplusplus
 206 extern char *getenv(const char *);
 207 #endif
 208 #endif
 209 int
 210 defParserparse()
 211 {
 212     register int defParserm, defParsern, defParserstate;
 213 #if defParserDEBUG
 214     register char *defParsers;
 215
 216     if (defParsers = getenv("defParserDEBUG"))
 217     {
 218         defParsern = *defParsers;
 219         if (defParsern >= '0' && defParsern <= '9')
 220             defParserdebug = defParsern - '0';
 221     }
 222 #endif
 223
 224     defParsernerrs = 0;
 225     defParsererrflag = 0;
 226     defParserchar = (-1);
 227
 228     defParserssp = defParserss;
 229     defParservsp = defParservs;
 230     *defParserssp = defParserstate = 0;
 231
 232 defParserloop:
 233     if ((defParsern = defParserdefred[defParserstate])) goto defParserreduce;
 234     if (defParserchar < 0)
 235     {
 236         if ((defParserchar = defParserlex()) < 0) defParserchar = 0;
 237 #if defParserDEBUG
 238         if (defParserdebug)
 239         {
 240             defParsers = 0;
 241             if (defParserchar <= defParserMAXTOKEN) defParsers = defParsername[defParserchar];
 242             if (!defParsers) defParsers = "illegal-symbol";
 243             printf("defParserdebug: state %d, reading %d (%s)\n", defParserstate,
 244                     defParserchar, defParsers);
 245         }
 246 #endif
 247     }
 248     if ((defParsern = defParsersindex[defParserstate]) && (defParsern += defParserchar) >= 0 &&
 249             defParsern <= defParserTABLESIZE && defParsercheck[defParsern] == defParserchar)
 250     {
 251 #if defParserDEBUG
 252         if (defParserdebug)
 253             printf("defParserdebug: state %d, shifting to state %d\n",
 254                     defParserstate, defParsertable[defParsern]);
 255 #endif
 256         if (defParserssp >= defParserss + defParserstacksize - 1)
 257         {
 258             goto defParseroverflow;
 259         }
 260         *++defParserssp = defParserstate = defParsertable[defParsern];
 261         *++defParservsp = defParserlval;
 262         defParserchar = (-1);
 263         if (defParsererrflag > 0)  --defParsererrflag;
 264         goto defParserloop;
 265     }
 266     if ((defParsern = defParserrindex[defParserstate]) && (defParsern += defParserchar) >= 0 &&
 267             defParsern <= defParserTABLESIZE && defParsercheck[defParsern] == defParserchar)
 268     {
 269         defParsern = defParsertable[defParsern];
 270         goto defParserreduce;
 271     }
 272     if (defParsererrflag) goto defParserinrecovery;
 273 // Disable for now
 274 #if 0
 275 #ifdef lint
 276     goto defParsernewerror;
 277 #endif
 278 defParsernewerror:
 279 #endif /* 0 */
 280     defParsererror((char*)"syntax error");
 281 // Disable for now
 282 #if 0
 283 #ifdef lint
 284     goto defParsererrlab;
 285 #endif
 286 defParsererrlab:
 287 #endif /* 0 */
 288     ++defParsernerrs;
 289 defParserinrecovery:
 290     if (defParsererrflag < 3)
 291     {
 292         defParsererrflag = 3;
 293         for (;;)
 294         {
 295             if ((defParsern = defParsersindex[*defParserssp]) && (defParsern += defParserERRCODE) >= 0 &&
 296                     defParsern <= defParserTABLESIZE && defParsercheck[defParsern] == defParserERRCODE)
 297             {
 298 #if defParserDEBUG
 299                 if (defParserdebug)
 300                     printf("defParserdebug: state %d, error recovery shifting\
 301  to state %d\n", *defParserssp, defParsertable[defParsern]);
 302 #endif
 303                 if (defParserssp >= defParserss + defParserstacksize - 1)
 304                 {
 305                     goto defParseroverflow;
 306                 }
 307                 *++defParserssp = defParserstate = defParsertable[defParsern];
 308                 *++defParservsp = defParserlval;
 309                 goto defParserloop;
 310             }
 311             else
 312             {
 313 #if defParserDEBUG
 314                 if (defParserdebug)
 315                     printf("defParserdebug: error recovery discarding state %d\n",
 316                             *defParserssp);
 317 #endif
 318                 if (defParserssp <= defParserss) goto defParserabort;
 319                 --defParserssp;
 320                 --defParservsp;
 321             }
 322         }
 323     }
 324     else
 325     {
 326         if (defParserchar == 0) goto defParserabort;
 327 #if defParserDEBUG
 328         if (defParserdebug)
 329         {
 330             defParsers = 0;
 331             if (defParserchar <= defParserMAXTOKEN) defParsers = defParsername[defParserchar];
 332             if (!defParsers) defParsers = "illegal-symbol";
 333             printf("defParserdebug: state %d, error recovery discards token %d (%s)\n",
 334                     defParserstate, defParserchar, defParsers);
 335         }
 336 #endif
 337         defParserchar = (-1);
 338         goto defParserloop;
 339     }
 340 defParserreduce:
 341 #if defParserDEBUG
 342     if (defParserdebug)
 343         printf("defParserdebug: state %d, reducing by rule %d (%s)\n",
 344                 defParserstate, defParsern, defParserrule[defParsern]);
 345 #endif
 346     defParserm = defParserlen[defParsern];
 347     defParserval = defParservsp[1-defParserm];
 348     switch (defParsern)
 349     {
 350 case 1:
 351 {
 352            g_def_list = defParservsp[0].defListPtrData;
 353         }
 354 break;
 355 case 2:
 356 {
 357            defParserval.defListPtrData=defParservsp[-1].defListPtrData;
 358
 359            if ( defParservsp[0].defPtrData -> type() == FeatureDef::WILDCARD )
 360               defParserval.defListPtrData -> prepend(defParservsp[0].defPtrData);
 361            else
 362               defParserval.defListPtrData -> append(defParservsp[0].defPtrData);
 363         }
 364 break;
 365 case 3:
 366 {
 367            defParserval.defListPtrData=new def_list_t();
 368            defParserval.defListPtrData -> append(defParservsp[0].defPtrData);
 369         }
 370 break;
 371 case 4:
 372 {
 373            defParserval.defPtrData=defParservsp[0].defPtrData;
 374         }
 375 break;
 376 case 5:
 377 {
 378            defParserval.defPtrData=defParservsp[0].defPtrData;
 379         }
 380 break;
 381 case 6:
 382 {
 383            defParserval.defPtrData=defParservsp[0].defPtrData;
 384         }
 385 break;
 386 case 7:
 387 {
 388            defParserval.defPtrData=defParservsp[0].defPtrData;
 389         }
 390 break;
 391 case 8:
 392 {
 393            defParserval.defPtrData= new FeatureDefComposite((char*)defParservsp[-3].charPtrData, defParservsp[-1].defListPtrData);
 394                 delete defParservsp[-3].charPtrData;
 395         }
 396 break;
 397 case 9:
 398 {
 399            defParserval.defPtrData= new FeatureDefPrimitive((char*)defParservsp[-3].charPtrData, defParservsp[-1].typeValuesListPtrData);
 400                 delete defParservsp[-3].charPtrData;
 401         }
 402 break;
 403 case 10:
 404 {
 405            defParserval.defPtrData= new FeatureDefReference((char*)defParservsp[-1].charPtrData);
 406                 delete defParservsp[-1].charPtrData;
 407         }
 408 break;
 409 case 11:
 410 {
 411            defParserval.defPtrData= new FeatureDefWildCard("*");
 412         }
 413 break;
 414 case 12:
 415 {
 416           defParserval.charPtrData=defParservsp[0].charPtrData;
 417         }
 418 break;
 419 case 13:
 420 {
 421            defParserval.typeValuesListPtrData=defParservsp[-2].typeValuesListPtrData;
 422            defParserval.typeValuesListPtrData -> append(defParservsp[0].typeValuesPtrData);
 423         }
 424 break;
 425 case 14:
 426 {
 427            defParserval.typeValuesListPtrData=new type_values_list_t();
 428            defParserval.typeValuesListPtrData -> append(defParservsp[0].typeValuesPtrData);
 429         }
 430 break;
 431 case 15:
 432 {
 433                 defParserval.typeValuesPtrData=new TypeValues((char*)defParservsp[-3].charPtrData, defParservsp[-1].valueListPtrData);
 434                 delete defParservsp[-3].charPtrData;
 435         }
 436 break;
 437 case 16:
 438 {
 439                 defParserval.typeValuesPtrData=new TypeValues((char*)defParservsp[0].charPtrData, 0);
 440                 delete defParservsp[0].charPtrData;
 441         }
 442 break;
 443 case 17:
 444 {
 445            defParservsp[-2].valueListPtrData -> append(defParservsp[0].valueData);
 446            defParserval.valueListPtrData=defParservsp[-2].valueListPtrData;
 447         }
 448 break;
 449 case 18:
 450 {
 451            defParserval.valueListPtrData = new defv_t();
 452            defParserval.valueListPtrData -> append(defParservsp[0].valueData);
 453
 454         }
 455 break;
 456 case 19:
 457 {
 458            defParserval.valueData=new FeatureValueInt(defParservsp[0].intData);
 459         }
 460 break;
 461 case 20:
 462 {
 463            defParserval.valueData=new FeatureValueString((char*)defParservsp[0].charPtrData);
 464            delete defParservsp[0].charPtrData;
 465         }
 466 break;
 467 case 21:
 468 {
 469            defParserval.valueData=new FeatureValueReal(defParservsp[0].realData);
 470         }
 471 break;
 472     }
 473     defParserssp -= defParserm;
 474     defParserstate = *defParserssp;
 475     defParservsp -= defParserm;
 476     defParserm = defParserlhs[defParsern];
 477     if (defParserstate == 0 && defParserm == 0)
 478     {
 479 #if defParserDEBUG
 480         if (defParserdebug)
 481             printf("defParserdebug: after reduction, shifting from state 0 to\
 482  state %d\n", defParserFINAL);
 483 #endif
 484         defParserstate = defParserFINAL;
 485         *++defParserssp = defParserFINAL;
 486         *++defParservsp = defParserval;
 487         if (defParserchar < 0)
 488         {
 489             if ((defParserchar = defParserlex()) < 0) defParserchar = 0;
 490 #if defParserDEBUG
 491             if (defParserdebug)
 492             {
 493                 defParsers = 0;
 494                 if (defParserchar <= defParserMAXTOKEN) defParsers = defParsername[defParserchar];
 495                 if (!defParsers) defParsers = "illegal-symbol";
 496                 printf("defParserdebug: state %d, reading %d (%s)\n",
 497                         defParserFINAL, defParserchar, defParsers);
 498             }
 499 #endif
 500         }
 501         if (defParserchar == 0) goto defParseraccept;
 502         goto defParserloop;
 503     }
 504     if ((defParsern = defParsergindex[defParserm]) && (defParsern += defParserstate) >= 0 &&
 505             defParsern <= defParserTABLESIZE && defParsercheck[defParsern] == defParserstate)
 506         defParserstate = defParsertable[defParsern];
 507     else
 508         defParserstate = defParserdgoto[defParserm];
 509 #if defParserDEBUG
 510     if (defParserdebug)
 511         printf("defParserdebug: after reduction, shifting from state %d \
 512 to state %d\n", *defParserssp, defParserstate);
 513 #endif
 514     if (defParserssp >= defParserss + defParserstacksize - 1)
 515     {
 516         goto defParseroverflow;
 517     }
 518     *++defParserssp = defParserstate;
 519     *++defParservsp = defParserval;
 520     goto defParserloop;
 521 defParseroverflow:
 522     defParsererror((char*)"yacc stack overflow");
 523 defParserabort:
 524     return (1);
 525 defParseraccept:
 526     return (0);
 527 }