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