cde/osf/wml/Uil.y

   1 /*
   2  *  @OSF_COPYRIGHT@
   3  *  COPYRIGHT NOTICE
   4  *  Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
   5  *  ALL RIGHTS RESERVED (MOTIF). See the file named COPYRIGHT.MOTIF for
   6  *  the full copyright text.
   7 */
   8 /*
   9  * HISTORY
  10 */
  11 /* "$TOG: Uil.y /main/11 1998/01/23 15:05:38 mgreess $" */
  12 /*
  13 *  (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */
  14
  15 /*
  16 **++
  17 **  FACILITY:
  18 **
  19 **      DECwindows Toolkit User Interface Language Compiler (UIL)
  20 **
  21 **  ABSTRACT:
  22 **
  23 **      YACC Grammar for UIL
  24 **--
  25 **/
  26
  27 %{
  28
  29
  30         /* Begin user declarations section */
  31
  32 #include "UilDefI.h"
  33 #include "UilCompGl.h"
  34
  35 #define         YYSTYPE         yystype
  36
  37 #define         YYDEBUG         1
  38
  39 /*   Declare and initialize stack entry for epsilon productions.    */
  40
  41 YYSTYPE         gz_yynullval = {NULL,0,0,0,0};
  42
  43 /*   Declare token to aid in saving source context      */
  44
  45 YYSTYPE         prev_yylval;
  46
  47         /* End user declarations section */
  48
  49 %}
  50
  51 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  52  *     token name                       token value       token class         *
  53  *     ----------                       -----------       -----------         *
  54  *----------------------------------------------------------------------------*
  55  */
  56
  57 /*
  58 **      terminals of the language
  59 **
  60 **      NOTE: the tags which appear in comments at the end of each token
  61 **      definition name the token class for the token. These name the
  62 **      the .dat file processed by WML while constructing token tables.
  63 **      Thus the output of WML and these tags must match, e.g. for
  64 **      the token tag 'special' the file 'special.dat' must exist.
  65 */
  66
  67 /*    end of file indicator    */
  68
  69 %token  UILEOF                                  0       /* unused */
  70
  71 /*    names    */
  72
  73 %token  NAME                                    1       /* identifier */
  74 %token  FONT_NAME                               2       /* font */
  75 %token  COLOR_NAME                              3       /* color */
  76 %token  ARGUMENT_NAME                           4       /* argument */
  77 %token  REASON_NAME                             5       /* reason */
  78 %token  CHARSET_NAME                            6       /* charset */
  79 %token  ENUMVAL_NAME                            7       /* enumval */
  80 %token  CLASS_NAME                              8       /* class */
  81 %token  CHILD_NAME                              96      /* child */
  82
  83 /*    Literals    */
  84
  85 %token  UNS_FLOAT_LITERAL                       9       /* literal */
  86 %token  COMP_STRING                             10      /* literal */
  87 %token  CHAR_8_LITERAL                          11      /* literal */
  88 %token  UNS_INT_LITERAL                         12      /* literal */
  89
  90 /*    Special characters.  Treat these as tokens rather than literals, so
  91  *    that we can assign token numbers to them rather than have YACC use
  92  *    the ASCII value as the token number.
  93  */
  94
  95 %token  LEFT_PAREN                              13      /* special */
  96 %token  RIGHT_PAREN                             14      /* special */
  97 %token  COLON                                   15      /* special */
  98 %token  SEMICOLON                               16      /* special */
  99 %token  LEFT_BRACE                              17      /* special */
 100 %token  RIGHT_BRACE                             18      /* special */
 101 %token  COMMA                                   19      /* special */
 102 %token  EQUAL_SIGN                              20      /* special */
 103 %token  NOT                                     21      /* special */
 104 %token  PLUS                                    22      /* special */
 105 %token  MINUS                                   23      /* special */
 106 %token  AND                                     24      /* special */
 107 %token  OR                                      25      /* special */
 108 %token  XOR                                     26      /* special */
 109 %token  MULTIPLY                                27      /* special */
 110 %token  DIVIDE                                  28      /* special */
 111 %token  LEFT_SHIFT                              29      /* special */
 112 %token  RIGHT_SHIFT                             30      /* special */
 113
 114 /*    Reserved words    */
 115
 116 %token  LIST                                    31      /* reserved */
 117 %token  IDENTIFIER                              32      /* reserved */
 118 %token  END                                     33      /* reserved */
 119 %token  MODULE                                  34      /* reserved */
 120 %token  UILTRUE                                 35      /* reserved */
 121 %token  UILFALSE                                36      /* reserved */
 122 %token  INCLUDE                                 37      /* reserved */
 123 %token  MACRO                                   38      /* reserved */
 124 %token  ON                                      39      /* reserved */
 125 %token  OFF                                     40      /* reserved */
 126 %token  VALUE                                   41      /* reserved */
 127 %token  ARGUMENTS                               42      /* reserved */
 128 %token  CALLBACKS                               43      /* reserved */
 129 %token  PROCEDURES                              44      /* reserved */
 130 %token  CONTROLS                                45      /* reserved */
 131 %token  PROCEDURE                               46      /* reserved */
 132 %token  OBJECT                                  47      /* reserved */
 133
 134 /*    Declaratives    */
 135
 136 %token  OBJECTS                                 48      /* keyword */
 137 %token  WIDGET                                  49      /* reserved */
 138 %token  GADGET                                  50      /* reserved */
 139
 140 %token  FONT                                    51      /* keyword */
 141 %token  ARGUMENT                                52      /* keyword */
 142 %token  REASON                                  53      /* keyword */
 143 %token  PIXMAP                                  54      /* keyword */
 144 %token  COLOR                                   55      /* keyword */
 145
 146 %token  NAMES                                   56      /* keyword */
 147 %token  CHARACTER_SET                           57      /* keyword */
 148 %token  CASE_SENSITIVE                          58      /* keyword */
 149 %token  CASE_INSENSITIVE                        59      /* keyword */
 150
 151 %token  VERSION                                 60      /* keyword */
 152
 153 %token  MANAGED                                 61      /* keyword */
 154 %token  UNMANAGED                               62      /* keyword */
 155
 156 %token  PRIVATE                                 63      /* reserved */
 157 %token  IMPORTED                                64      /* keyword */
 158 %token  EXPORTED                                65      /* reserved */
 159
 160 %token  UILFILE                                 66      /* keyword */
 161
 162 %token  STRING_TABLE                            67      /* keyword */
 163 %token  TRANSLATION_TABLE                       68      /* keyword */
 164 %token  COMPOUND_STRING                         69      /* keyword */
 165 %token  FONT_TABLE                              70      /* keyword */
 166
 167 %token  ANY                                     71      /* keyword */
 168 %token  STRING                                  72      /* keyword */
 169 %token  BOOLEAN                                 73      /* keyword */
 170 %token  ICON                                    74      /* keyword */
 171 %token  RIGHT_TO_LEFT                           75      /* keyword */
 172 %token  BACKGROUND                              76      /* keyword */
 173 %token  FOREGROUND                              77      /* keyword */
 174 %token  COLOR_TABLE                             78      /* keyword */
 175 %token  FLOAT                                   79      /* keyword */
 176 %token  INTEGER                                 80      /* keyword */
 177 %token  CLASS_REC_NAME                          81      /* keyword */
 178 %token  ASCIZ_TABLE                             82      /* keyword */
 179 %token  INTEGER_TABLE                           83      /* keyword */
 180 %token  ASCIZ_STRING_TABLE                      84      /* keyword */
 181 %token  COMPOUND_STRING_TABLE                   85      /* keyword */
 182 %token  XBITMAPFILE                             86      /* keyword */
 183 %token  SEPARATE                                87      /* keyword */
 184 %token  SIXTEEN_BIT                             88      /* keyword */
 185 %token  POUND                                   89      /* special */
 186 %token  KEYSYM                                  90      /* keyword */
 187 %token  SINGLE_FLOAT                            91      /* keyword */
 188 %token  RGB                                     92      /* keyword */
 189 %token  WIDE_CHARACTER                          93      /* keyword */
 190 %token  LOC_STRING                              94      /* literal */ /* New for 1.2 */
 191 %token  FONTSET                                 95      /* keyword */
 192 %token  COMPOUND_STRING_COMPONENT               97      /* keyword */
 193
 194 %token  PIX                                     115
 195 %token  PIXEL                                   103
 196 %token  PIXELS                                  104
 197 %token  IN                                      98
 198 %token  INCH                                    105
 199 %token  INCHES                                  106
 200 %token  CM                                      99
 201 %token  CENTIMETER                              107
 202 %token  CENTIMETERS                             108
 203 %token  MM                                      100
 204 %token  MILLIMETER                              109
 205 %token  MILLIMETERS                             110
 206 %token  PT                                      101
 207 %token  POINT                                   111
 208 %token  POINTS                                  112
 209 %token  FU                                      102
 210 %token  FONT_UNIT                               113
 211 %token  FONT_UNITS                              114
 212
 213 %start module_block
 214
 215 %%
 216
 217 \f
 218
 219 /*
 220 **      productions of the grammar
 221 */
 222
 223
 224 /*      module structure        */
 225
 226 module_block
 227     : module_header
 228         { sar_save_module_source (); }
 229       module_declaration_list END MODULE SEMICOLON
 230     ;
 231
 232 module_header
 233     : /* empty */                               { sar_create_root ( &$$ ); }
 234       MODULE id                                 { sar_create_module( &$$, &$3, &$2 ); }
 235         opt_module_clauses
 236     ;
 237
 238 opt_module_clauses
 239     : /* empty */
 240     | module_clauses
 241     ;
 242
 243 module_clauses
 244     : module_clause
 245     | module_clauses module_clause
 246     ;
 247
 248 module_clause
 249     : VERSION EQUAL_SIGN character_8_value              { sar_process_module_version(  &$3 , &$1 ); }
 250     | NAMES EQUAL_SIGN sensitivity_value                { sar_process_module_sensitivity( &$3 , &$1 ); }
 251     | CHARACTER_SET EQUAL_SIGN valid_charset            { sar_process_module_charset( &$3 , &$1 ); }
 252     | OBJECTS { sar_make_def_obj (&$1); } EQUAL_SIGN variant_spec
 253     ;
 254
 255 sensitivity_value
 256     : CASE_SENSITIVE
 257     | CASE_INSENSITIVE
 258     ;
 259
 260 variant_spec
 261     : LEFT_BRACE RIGHT_BRACE
 262     | LEFT_BRACE variant_list RIGHT_BRACE
 263     | error { lex_issue_error (RIGHT_BRACE); } RIGHT_BRACE
 264     ;
 265
 266 variant_list
 267     : variant_clause SEMICOLON
 268     | variant_list variant_clause SEMICOLON
 269     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 270     ;
 271
 272 variant_clause
 273     : CLASS_NAME { sar_make_def_obj (&$1); }
 274       EQUAL_SIGN variant                                { sar_process_module_variant (&$1, &$4); $$ = gz_yynullval; }
 275     ;
 276
 277 variant
 278     : WIDGET                                            { $$ = gz_yynullval; $$.b_type = sym_k_widget_entry; }
 279     | GADGET                                            { $$ = gz_yynullval; $$.b_type = sym_k_gadget_entry; }
 280     ;
 281
 282 module_declaration_list
 283     : /* empty */
 284     | module_declaration_list module_declaration
 285     ;
 286
 287 module_declaration
 288     : value_declaration
 289     | identifier_declaration
 290     | procedure_declaration
 291     | object_declaration
 292     | list_declaration
 293     | include_directive
 294     ;
 295
 296 \f
 297
 298 /*      VALUE declaration           */
 299
 300 value_declaration
 301     : VALUE { $$ = $1; sar_save_section_source (&$1, sym_k_value_section); } value_declaration_list
 302     ;
 303
 304 value_declaration_list
 305     : value_decl
 306     | value_declaration_list value_decl
 307     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 308     ;
 309
 310 value_decl
 311     : id COLON value_definition SEMICOLON               { sar_bind_value_name( &$1, &$3, &$4 ); }
 312     ;
 313
 314 value_definition
 315   : EXPORTED private_value                              { $$ = $2; $$.b_flags |= sym_m_exported; $$.b_flags &= ~sym_m_private; }
 316     | PRIVATE private_value_plus                        { $$ = $2; $$.b_flags |= sym_m_private; $$.b_flags &= ~sym_m_exported; }
 317     | private_value_plus                                { $$ = $1; $$.b_flags |= sym_m_private; $$.b_flags &= ~sym_m_exported; }
 318     | IMPORTED value_type                               { sar_import_value_entry( &$$, &$2 ); }
 319     ;
 320
 321 value_type
 322     : INTEGER                   { $$ = $1; $$.b_type = sym_k_integer_value; }
 323     | STRING                    { $$ = $1; $$.b_type = sym_k_char_8_value; }
 324     | PIXMAP                    { $$ = $1; $$.b_type = sym_k_pixmap_value; }
 325     | FLOAT                     { $$ = $1; $$.b_type = sym_k_float_value; }
 326     | BOOLEAN                   { $$ = $1; $$.b_type = sym_k_bool_value; }
 327     | FONT                      { $$ = $1; $$.b_type = sym_k_font_value; }
 328     | REASON                    { $$ = $1; $$.b_type = sym_k_reason_value; }
 329     | ARGUMENT                  { $$ = $1; $$.b_type = sym_k_argument_value; }
 330     | COLOR                     { $$ = $1; $$.b_type = sym_k_color_value; }
 331     | string_table_type         { $$ = $1; $$.b_type = sym_k_string_table_value; }
 332     | asciz_table_type          { $$ = $1; $$.b_type = sym_k_asciz_table_value; }
 333     | INTEGER_TABLE             { $$ = $1; $$.b_type = sym_k_integer_table_value; }
 334     | TRANSLATION_TABLE         { $$ = $1; $$.b_type = sym_k_trans_table_value; }
 335     | FONT_TABLE                { $$ = $1; $$.b_type = sym_k_font_table_value; }
 336     | ICON                      { $$ = $1; $$.b_type = sym_k_icon_value; }
 337     | COMPOUND_STRING           { $$ = $1; $$.b_type = sym_k_compound_string_value; }
 338     | COMPOUND_STRING_COMPONENT { $$ = $1; $$.b_type = sym_k_compound_string_value; }
 339     | CLASS_REC_NAME            { $$ = $1; $$.b_type = sym_k_class_rec_name_value; }
 340     | XBITMAPFILE               { $$ = $1; $$.b_type = sym_k_xbitmapfile_value; }
 341     | KEYSYM                    { $$ = $1; $$.b_type = sym_k_keysym_value; }
 342     | SINGLE_FLOAT              { $$ = $1; $$.b_type = sym_k_single_float_value; }
 343     | RGB                       { $$ = $1; $$.b_type = sym_k_rgb_value; }
 344     | WIDE_CHARACTER            { $$ = $1; $$.b_type = sym_k_wchar_string_value; }
 345     | FONTSET                   { $$ = $1; $$.b_type = sym_k_fontset_value; }
 346     | WIDGET                    { $$ = $1; $$.b_type = sym_k_widget_ref_value; }
 347     ;
 348
 349 /* Seperately defined for fixing CR 5888 */
 350 arg_value_type
 351     : INTEGER                   { $$ = $1; $$.b_type = sym_k_integer_value; }
 352     | STRING                    { $$ = $1; $$.b_type = sym_k_char_8_value; }
 353     | PIXMAP                    { $$ = $1; $$.b_type = sym_k_pixmap_value; }
 354     | FLOAT                     { $$ = $1; $$.b_type = sym_k_float_value; }
 355     | BOOLEAN                   { $$ = $1; $$.b_type = sym_k_bool_value; }
 356     | FONT                      { $$ = $1; $$.b_type = sym_k_font_value; }
 357     | REASON                    { $$ = $1; $$.b_type = sym_k_reason_value; }
 358     | COLOR                     { $$ = $1; $$.b_type = sym_k_color_value; }
 359     | string_table_type         { $$ = $1; $$.b_type = sym_k_string_table_value; }
 360     | asciz_table_type          { $$ = $1; $$.b_type = sym_k_asciz_table_value; }
 361     | INTEGER_TABLE             { $$ = $1; $$.b_type = sym_k_integer_table_value; }
 362     | TRANSLATION_TABLE         { $$ = $1; $$.b_type = sym_k_trans_table_value; }
 363     | FONT_TABLE                { $$ = $1; $$.b_type = sym_k_font_table_value; }
 364     | ICON                      { $$ = $1; $$.b_type = sym_k_icon_value; }
 365     | COMPOUND_STRING           { $$ = $1; $$.b_type = sym_k_compound_string_value; }
 366     | KEYSYM                    { $$ = $1; $$.b_type = sym_k_keysym_value; }
 367     | SINGLE_FLOAT              { $$ = $1; $$.b_type = sym_k_single_float_value; }
 368     | WIDE_CHARACTER            { $$ = $1; $$.b_type = sym_k_wchar_string_value; }
 369     | FONTSET                   { $$ = $1; $$.b_type = sym_k_fontset_value; }
 370     | WIDGET                    { $$ = $1; $$.b_type = sym_k_widget_ref_value; }
 371 /* End for fixing CR 5888 */
 372
 373 string_table_type
 374     : STRING_TABLE
 375     | COMPOUND_STRING_TABLE
 376     ;
 377
 378 asciz_table_type
 379     : ASCIZ_TABLE
 380     | ASCIZ_STRING_TABLE
 381     ;
 382 \f
 383
 384 /*      PROCEDURE declaration       */
 385
 386 procedure_declaration
 387     : PROCEDURE { $$ = $1; sar_save_section_source (&$1, sym_k_procedure_section); } procedure_declaration_list
 388     ;
 389
 390 procedure_declaration_list
 391     : procedure_decl
 392     | procedure_declaration_list procedure_decl
 393     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 394     ;
 395
 396 procedure_decl
 397     : id opt_formal_parameters opt_class SEMICOLON      { sar_create_procedure( &$1, &$2, &$3, &$4 );}
 398     ;
 399
 400 opt_formal_parameters
 401     : /* empty */                                       { $$ = gz_yynullval; }
 402     | LEFT_PAREN formal_parameter_type RIGHT_PAREN      { $$ = $2; }
 403     ;
 404
 405 formal_parameter_type
 406     : /* empty */                                       { $$ = gz_yynullval; $$.b_type = sym_k_no_value; }
 407     | value_type
 408     | ANY                                               { $$ = $1; $$.b_type =
 409 sym_k_any_value; }
 410     | CLASS_NAME
 411         { YYSTYPE temp[2];
 412           temp[0] = gz_yynullval;
 413           sar_create_object(&temp[0], sym_k_widget_entry);
 414           temp[1] = $1; sar_set_object_class(&temp[1]);
 415           sar_verify_object(&temp[1]);
 416           $$ = temp[0];
 417         }
 418     ;
 419
 420 opt_class
 421     : /* empty */                                       { $$.b_flags = sym_m_private; }
 422 /*
 423     | EXPORTED                                          { $$.b_flags = sym_m_exported; }
 424     | PRIVATE                                           { $$.b_flags = sym_m_private; }
 425     | IMPORTED                                          { $$.b_flags = sym_m_imported; }
 426 */
 427     ;
 428
 429 \f
 430
 431 /*      IDENTIFIER declaration      */
 432
 433 identifier_declaration
 434     : IDENTIFIER { $$ = $1; sar_save_section_source (&$1, sym_k_identifier_section); } identifier_declaration_list
 435     ;
 436
 437 identifier_declaration_list
 438     : identifier_decl
 439     | identifier_declaration_list identifier_decl
 440     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 441     ;
 442
 443 identifier_decl
 444     : id SEMICOLON                                      { sar_create_identifier ( &$1, &$2 ); }
 445     ;
 446
 447 \f
 448
 449 /*    Directives.    */
 450
 451 /*    Include Directive    */
 452
 453 include_directive
 454     : INCLUDE UILFILE character_8_value SEMICOLON       { sar_include_file (&$3, &$1, &$4); }
 455     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 456     ;
 457
 458 \f
 459
 460 /*      OBJECT declaration      */
 461
 462 object_declaration
 463     : OBJECT { $$ = $1; sar_save_section_source (&$1, sym_k_object_section); } object_decl_list
 464     ;
 465
 466 object_decl_list
 467     : object_decl SEMICOLON                             { $$ = $1; sar_save_src_semicolon_pos (&$2 ); }
 468     | object_decl_list object_decl SEMICOLON            { $$ = $1; sar_save_src_semicolon_pos (&$3 ); }
 469     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 470     ;
 471
 472 object_decl
 473     : id
 474         { sar_create_object (&$1, sym_k_widget_entry);
 475           sar_link_section (&$1); $$ = gz_yynullval;}
 476       COLON object_definition
 477         { $$ = gz_yynullval; }
 478     ;
 479
 480 object_definition
 481     : EXPORTED
 482         { sar_set_object_flags (&$1, sym_m_exported); }
 483       object_specification
 484     | PRIVATE
 485         { sar_set_object_flags (&$1, sym_m_private); }
 486       object_specification
 487     | epsilon_production
 488         { sar_set_object_flags (&$1, sym_m_exported); }
 489       object_specification
 490     | IMPORTED
 491         { sar_set_object_flags (&$1, sym_m_imported); }
 492       CLASS_NAME
 493         { sar_set_object_class (&$3); }
 494 /*
 495  * Fix for CR 5440 - Call opt_create_proc_ref to check for creation procedures
 496  *                   for imported user_defined widgets.
 497  */
 498       opt_create_proc_ref
 499 /*
 500  * End fix for CR 5440
 501  */
 502       epsilon_production
 503         { sar_verify_object (&$1); }
 504     ;
 505
 506 control_object_definition
 507     : EXPORTED
 508         { sar_set_object_flags (&$1, sym_m_exported); }
 509       object_specification
 510     | PRIVATE
 511         { sar_set_object_flags (&$1, sym_m_private); }
 512       object_specification
 513     | MANAGED
 514         { sar_set_object_flags (& $1, (sym_m_managed | sym_m_exported)); }
 515       object_specification
 516     | UNMANAGED
 517         { sar_unset_object_flags (& $1, sym_m_managed), sar_set_object_flags (& $1, sym_m_exported); }
 518       object_specification
 519     | epsilon_production
 520         { sar_set_object_flags (&$1, sym_m_exported); }
 521       object_specification
 522     | IMPORTED
 523         { sar_set_object_flags (&$1, sym_m_imported); }
 524       CLASS_NAME
 525         { sar_set_object_class (&$3); }
 526       epsilon_production
 527         { sar_verify_object (&$1); }
 528     ;
 529
 530 object_specification
 531     : CLASS_NAME
 532         { sar_set_object_class (&$1); }
 533       opt_create_proc_ref
 534       opt_variant
 535       object_spec
 536         { sar_verify_object (&$1); }
 537     ;
 538
 539 opt_variant
 540     : epsilon_production
 541         { sar_set_object_variant (&$1); }
 542     | variant
 543         { sar_set_object_variant (&$1); }
 544     ;
 545
 546 control_object_specification
 547     : CLASS_NAME
 548         { sar_set_object_class (&$1); $$ = gz_yynullval;}
 549       opt_create_proc_ref
 550       opt_variant
 551       control_object_spec
 552         { sar_verify_object (&$1); }
 553     ;
 554
 555 opt_create_proc_ref
 556     : epsilon_production
 557     | PROCEDURE id_ref opt_parens
 558         { sar_process_proc_ref (&$2, &gz_yynullval, sym_k_object_proc);
 559           sar_save_user_proc_ref_src ( &$1, &$2, &$3 ); }
 560     ;
 561
 562 opt_parens
 563     : epsilon_production
 564     | LEFT_PAREN RIGHT_PAREN { $$ = $2; }
 565     ;
 566
 567
 568 \f
 569
 570 /*      object specification.    */
 571
 572 object_spec
 573     : id_ref
 574         { sar_object_reference (&$1); }
 575     | LEFT_BRACE RIGHT_BRACE
 576     | LEFT_BRACE object_feature_list RIGHT_BRACE
 577     | error { lex_issue_error (RIGHT_BRACE); } RIGHT_BRACE
 578     ;
 579
 580 control_object_spec
 581     : id_ref
 582         { sar_object_reference (&$1); }
 583     | LEFT_BRACE RIGHT_BRACE
 584       epsilon_production
 585         { sar_set_object_flags (&$1, sym_m_exported); }
 586     | LEFT_BRACE object_feature_list RIGHT_BRACE
 587       epsilon_production
 588         { sar_set_object_flags (&$1, sym_m_exported); }
 589     | error { lex_issue_error (RIGHT_BRACE); } RIGHT_BRACE
 590     ;
 591
 592 child_object_spec
 593     : LEFT_BRACE RIGHT_BRACE
 594       epsilon_production
 595         { sar_set_object_flags (&$1, sym_m_private); }
 596     | LEFT_BRACE object_feature_list RIGHT_BRACE
 597       epsilon_production
 598         { sar_set_object_flags (&$1, sym_m_private); }
 599     | error { lex_issue_error (RIGHT_BRACE); } RIGHT_BRACE
 600     ;
 601
 602 object_feature_list
 603     : object_feature
 604     | object_feature_list object_feature
 605     ;
 606
 607 object_feature
 608     : argument_list_def SEMICOLON
 609         { sar_save_list_end ( &$2); sar_save_feature (&$1); $$ = gz_yynullval; }
 610     | callback_list_def SEMICOLON
 611         { sar_save_list_end ( &$2); sar_save_feature (&$1); $$ = gz_yynullval; }
 612     | control_list_def SEMICOLON
 613         { sar_save_list_end ( &$2); sar_save_feature (&$1);
 614 sar_update_parent_list (&$1); $$ = gz_yynullval; }
 615     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 616     ;
 617
 618 epsilon_production
 619     : /* empty */
 620         { $$ = gz_yynullval; }
 621     ;
 622
 623 \f
 624
 625 /*      LIST declaration        */
 626
 627 list_declaration
 628     : LIST { $$ = $1; sar_save_section_source (&$1, sym_k_list_section); }
 629         list_decl_list
 630     ;
 631
 632 list_decl_list
 633     : list_decl SEMICOLON { $$ = $1; sar_save_src_semicolon_pos (&$2 ); }
 634     | list_decl_list list_decl SEMICOLON { $$ = $1; sar_save_src_semicolon_pos (&$3 ); }
 635     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 636     ;
 637
 638 list_decl
 639     : id
 640         { sar_create_object (&$1, sym_k_list_entry);
 641 sar_link_section (&$1); $$ = gz_yynullval;}
 642       COLON list_specification
 643         { $$ = gz_yynullval; }
 644     ;
 645
 646 list_specification
 647     : control_list_specification
 648     | argument_list_specification
 649     | callback_list_specification
 650     | procedure_list_specification
 651     ;
 652
 653 control_list_specification
 654     : control_list_type
 655         { $$ = gz_yynullval; sar_set_list_type (&$1); }
 656       control_list_spec
 657         { sar_verify_object (&$1); }
 658     ;
 659
 660 argument_list_specification
 661     : argument_list_type
 662         { $$ = gz_yynullval; sar_set_list_type (&$1); }
 663       argument_list_spec
 664         { sar_verify_object (&$1); }
 665     ;
 666
 667 callback_list_specification
 668     : callback_list_type
 669         { $$ = gz_yynullval; sar_set_list_type (&$1); }
 670       callback_list_spec
 671         { sar_verify_object (&$1); }
 672     ;
 673
 674 procedure_list_specification
 675     : procedure_list_type
 676         { $$ = gz_yynullval; sar_set_list_type (&$1); }
 677       procedure_list_spec
 678         { sar_verify_object (&$1); }
 679     ;
 680
 681 argument_list_type
 682     : ARGUMENTS
 683         { $$ = gz_yynullval; $$.b_type = sym_k_argument_list; }
 684     ;
 685
 686 callback_list_type
 687     : CALLBACKS
 688         { $$ = gz_yynullval; $$.b_type = sym_k_callback_list; }
 689     ;
 690
 691 procedure_list_type
 692     : PROCEDURES
 693         { $$ = gz_yynullval; $$.b_type = sym_k_proc_ref_list; }
 694     ;
 695 control_list_type
 696     : CONTROLS
 697         { $$ = gz_yynullval; $$.b_type = sym_k_control_list; }
 698     ;
 699
 700 argument_list_spec
 701     : id_ref { sar_object_reference (&$1); }
 702     | LEFT_BRACE RIGHT_BRACE
 703     | LEFT_BRACE argument_list_clause_list RIGHT_BRACE
 704     | error { lex_issue_error (RIGHT_BRACE); } RIGHT_BRACE
 705     ;
 706
 707 callback_list_spec
 708     : id_ref { sar_object_reference (&$1); }
 709     | LEFT_BRACE RIGHT_BRACE
 710     | LEFT_BRACE callback_list_clause_list RIGHT_BRACE
 711     | error { lex_issue_error (RIGHT_BRACE); } RIGHT_BRACE
 712     ;
 713
 714 procedure_list_spec
 715     : id_ref
 716         { sar_object_reference (&$1); }
 717     | LEFT_BRACE RIGHT_BRACE
 718     | LEFT_BRACE procedure_list_clause_list RIGHT_BRACE
 719     | error { lex_issue_error (RIGHT_BRACE); } RIGHT_BRACE
 720     ;
 721
 722 control_list_spec
 723     : id_ref { sar_object_reference (&$1); }
 724     | LEFT_BRACE RIGHT_BRACE
 725     | LEFT_BRACE control_list_clause_list RIGHT_BRACE
 726     | error { lex_issue_error (RIGHT_BRACE); } RIGHT_BRACE
 727     ;
 728
 729 argument_list_clause_list
 730     : argument_list_clause
 731     | argument_list_clause_list argument_list_clause
 732     ;
 733
 734 callback_list_clause_list
 735     : callback_list_clause
 736     | callback_list_clause_list callback_list_clause
 737     ;
 738
 739 procedure_list_clause_list
 740     : procedure_list_clause
 741     | procedure_list_clause_list procedure_list_clause
 742     ;
 743
 744 control_list_clause_list
 745     : control_list_clause
 746     | control_list_clause_list control_list_clause
 747     ;
 748
 749 argument_list_clause
 750     : argument_list_def SEMICOLON
 751         { sar_save_src_entry_end (&$2, &$1); sar_add_list_entry (&$1); $$ = gz_yynullval; }
 752     | argument_list_item SEMICOLON
 753         { sar_save_src_entry_end (&$2, &$1); sar_add_list_entry (&$1); $$ = gz_yynullval; }
 754     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 755     ;
 756
 757 callback_list_clause
 758     : callback_list_def SEMICOLON
 759         { sar_save_src_entry_end (&$2, &$1); sar_add_list_entry (&$1); $$ = gz_yynullval; }
 760     | callback_list_item SEMICOLON
 761         { sar_save_src_entry_end (&$2, &$1); sar_add_list_entry (&$1); $$ = gz_yynullval; }
 762     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 763     ;
 764
 765 procedure_list_clause
 766     : procedure_list_def SEMICOLON
 767         { sar_save_src_entry_end (&$2, &$1); sar_add_list_entry (&$1); $$ = gz_yynullval; }
 768     | procedure_list_def_ref SEMICOLON
 769         { sar_save_src_entry_end (&$2, &$1); sar_add_list_entry (&$1); $$ = gz_yynullval; }
 770     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 771     ;
 772
 773 control_list_clause
 774     : control_list_def SEMICOLON
 775         { sar_save_src_entry_end (&$2, &$1); sar_add_list_entry (&$1); $$ = gz_yynullval; }
 776     | control_list_item SEMICOLON
 777         { sar_save_src_entry_end (&$2, &$1); sar_add_list_entry (&$1); $$ = gz_yynullval; }
 778     | error { lex_issue_error (SEMICOLON); } SEMICOLON
 779     ;
 780
 781 control_list_def
 782     : epsilon_production
 783         { $$ = gz_yynullval; sar_create_object (&$1, sym_k_list_entry); }
 784       control_list_specification
 785         { $$ = $1; }
 786     ;
 787
 788 argument_list_def
 789     : epsilon_production
 790         { $$ = gz_yynullval; sar_create_object (&$1, sym_k_list_entry); }
 791       argument_list_specification
 792         { $$ = $1; }
 793     ;
 794
 795 callback_list_def
 796     : epsilon_production
 797         { $$ = gz_yynullval; sar_create_object (&$1, sym_k_list_entry); }
 798       callback_list_specification
 799         { $$ = $1; }
 800     ;
 801
 802 procedure_list_def
 803     : epsilon_production
 804         { $$ = gz_yynullval; sar_create_object (&$1, sym_k_list_entry); }
 805       procedure_list_specification
 806         { $$ = $1; }
 807     ;
 808
 809 control_list_item
 810
 811 /*      Control item    */
 812
 813     : opt_managed control_item
 814         { sar_save_control_item (&$1, &$2); $$ = $1; }
 815
 816     | id
 817         { sar_create_object (& $1, sym_k_widget_entry); $1.b_flags = sym_m_managed; $$ = gz_yynullval;}
 818       COLON
 819       control_object_definition
 820         { sar_save_control_widget (& $1, & $2); $$ = $1; }
 821 /* Child */
 822     | CHILD_NAME opt_child_managed
 823         { sar_create_child (& $1); $1.b_flags = sym_m_managed;
 824           $$ = gz_yynullval; }
 825       child_object_spec
 826         { sar_save_control_widget (& $1, & $2); $$ = $1; }
 827     | CHILD_NAME UNMANAGED
 828         { sar_create_child (& $1); $$ = gz_yynullval; }
 829       child_object_spec
 830         { sar_save_control_widget (& $1, & $3); $$ = $1; }
 831     ;
 832
 833 opt_child_managed
 834     : epsilon_production
 835     | MANAGED
 836     ;
 837
 838
 839 argument_list_item
 840
 841 /*      Argument value pair     */
 842
 843     : value EQUAL_SIGN value
 844         { sar_save_argument_pair (&$1, &$3, &$2); $$ = $1; }
 845
 846 /*      Argument widget pair    */
 847
 848     | value EQUAL_SIGN CLASS_NAME id_ref
 849         { YYSTYPE temp [2];
 850           temp [0] = gz_yynullval;
 851           sar_create_object (&temp [0], sym_k_widget_entry);
 852           temp [1] = $3; sar_set_object_class (&temp [1]);
 853           temp [1] = $4; sar_object_reference (&temp [1]);
 854           sar_verify_object (&temp [1]);
 855           sar_save_argument_pair (&$1, &temp [0], &$2); $$ = $1; }
 856     ;
 857
 858 callback_list_item
 859
 860 /*      Callback reason binding         */
 861
 862     : value EQUAL_SIGN procedure_reference
 863         { sar_save_reason_binding (&$1, &$3, &$2); $$ = $1; }
 864     | value EQUAL_SIGN procedure_list_def
 865         { sar_save_reason_binding (&$1, &$3, &$2); $$ = $1; }
 866     ;
 867
 868 control_item
 869     : epsilon_production
 870         { sar_create_object (&$1, sym_k_widget_entry); $$ = gz_yynullval; }
 871       control_object_specification
 872         { $$ = $1; }
 873     ;
 874
 875 opt_managed
 876     : epsilon_production
 877         { $$.b_flags = sym_m_managed; }
 878     | MANAGED
 879         { $$ = gz_yynullval; $$.b_flags = sym_m_managed; }
 880     | UNMANAGED
 881         { $$ = gz_yynullval; }
 882     ;
 883
 884 procedure_reference
 885     : PROCEDURE id_ref opt_procedure_argument
 886         { sar_process_proc_ref (&$2, &$3, sym_k_callback_proc); $$ = $2; }
 887     ;
 888
 889 procedure_list_def_ref
 890     : id_ref opt_procedure_argument
 891         { sar_process_proc_ref (&$1, &$2, sym_k_callback_proc); $$ = $1; }
 892     ;
 893
 894 opt_procedure_argument
 895     : epsilon_production
 896     | LEFT_PAREN value RIGHT_PAREN
 897         { $$ = $2; }
 898     | LEFT_PAREN CLASS_NAME id_ref RIGHT_PAREN
 899         { YYSTYPE temp [2];
 900           temp [0] = gz_yynullval;
 901           sar_create_object (&temp [0], sym_k_widget_entry);
 902           temp [1] = $2; sar_set_object_class (&temp [1]);
 903           temp [1] = $3; sar_object_reference (&temp [1]);
 904           sar_verify_object (&temp [1]);
 905           $$ = temp [0]; }
 906     | LEFT_PAREN RIGHT_PAREN
 907         { $$ = gz_yynullval; }
 908     ;
 909
 910 \f
 911
 912 /*      definition of an id     */
 913
 914 id
 915     : NAME
 916     | FONT_NAME
 917     | COLOR_NAME
 918     | ARGUMENT_NAME
 919     | REASON_NAME
 920     | ENUMVAL_NAME
 921     | CHILD_NAME
 922     | keyword                                           { sar_map_keyword_to_name( &$$, &$1); }
 923     ;
 924
 925 /*      reference of an id      */
 926
 927 id_ref
 928     : id
 929         { sar_process_id_ref (&$1); $$ = $1; }
 930     ;
 931
 932 keyword
 933     : STRING
 934     | BOOLEAN
 935     | FLOAT
 936     | INTEGER
 937     | FONT
 938     | ARGUMENT
 939     | REASON
 940     | PIXMAP
 941     | COLOR
 942
 943     | NAMES
 944     | CASE_SENSITIVE
 945     | CASE_INSENSITIVE
 946
 947     | VERSION
 948
 949     | MANAGED
 950     | UNMANAGED
 951
 952     | UILFILE
 953
 954     | string_table_type
 955     | asciz_table_type
 956     | INTEGER_TABLE
 957     | TRANSLATION_TABLE
 958     | COMPOUND_STRING
 959     | COMPOUND_STRING_COMPONENT
 960     | CLASS_REC_NAME
 961     | FONT_TABLE
 962     | RIGHT_TO_LEFT
 963     | CHARACTER_SET
 964     | COLOR_TABLE
 965     | ICON
 966     | BACKGROUND
 967     | FOREGROUND
 968     | XBITMAPFILE
 969     | SEPARATE
 970
 971     | ANY
 972
 973     | IMPORTED
 974     | OBJECTS
 975     | KEYSYM
 976     | SINGLE_FLOAT
 977     | RGB
 978     | WIDE_CHARACTER
 979     | FONTSET
 980     ;
 981
 982 \f
 983
 984 /*    values    */
 985
 986 character_8_value    : value
 987                {
 988                  $$ = $1;
 989                  if (($$.b_type != sym_k_error_value) &&
 990                      ($$.b_type != sym_k_any_value) &&
 991                     (($$.b_flags &sym_m_forward_ref) == 0))
 992                        {
 993                         if (($$.b_type != sym_k_char_8_value) &&
 994                             ($$.b_type != sym_k_localized_string_value))
 995                             sar_value_type_error( &$$, sym_k_char_8_value );
 996                         if (($$.b_flags &sym_m_private) == 0)
 997                             sar_private_error( &$$ );
 998                        }
 999                 }
1000     ;
1001
1002 private_value
1003     : value                                                     { $$ = $1;
1004                                                                   if ($$.b_type != sym_k_error_value)
1005                                                                   {
1006                                                                     if ((($$.b_flags &sym_m_private) == 0) &&
1007                                                                         (($$.b_flags &sym_m_forward_ref) == 0))
1008                                                                         sar_private_error( &$$ );
1009                                                                   }
1010                                                                 }
1011      ;
1012
1013  /* BEGIN HaL fix CR 5427 */
1014
1015  private_value_plus
1016      : non_export_value                                         { $$ = $1;
1017                                                                   if ($$.b_type != sym_k_error_value)
1018                                                                   {
1019                                                                     if ((($$.b_flags &sym_m_private) == 0) &&
1020                                                                         (($$.b_flags &sym_m_forward_ref) == 0))
1021                                                                         sar_private_error( &$$ );
1022                                                                   }
1023                                                         }
1024     ;
1025      | value                                                    { $$ = $1;
1026                                                                   if ($$.b_type != sym_k_error_value)
1027                                                                   {
1028                                                                     if ((($$.b_flags &sym_m_private) == 0) &&
1029                                                                         (($$.b_flags &sym_m_forward_ref) == 0))
1030                                                                         sar_private_error( &$$ );
1031                                                                   }
1032                                                                 }
1033
1034  non_export_value
1035      : COLOR_TABLE LEFT_PAREN color_list RIGHT_PAREN            { sar_make_color_table( &$$, &$3, &$1); }
1036
1037  /* END HaL fix CR 5427 */
1038
1039
1040 value
1041     : value_1
1042     | value OR value_1                                          { $$ = $2; sar_binary_op( &$$, &$1, &$3 ); }
1043     | value XOR value_1                                         { $$ = $2; sar_binary_op( &$$, &$1, &$3 ); }
1044     ;
1045
1046 value_1
1047     : value_2
1048     | value_1 AND value_2                                       { $$ = $2; sar_binary_op( &$$, &$1, &$3 ); }
1049     ;
1050
1051 value_2
1052     : value_3
1053     | value_2 LEFT_SHIFT value_3                                { $$ = $2; sar_binary_op( &$$, &$1, &$3 ); }
1054     | value_2 RIGHT_SHIFT value_3                               { $$ = $2; sar_binary_op( &$$, &$1, &$3 ); }
1055     ;
1056
1057 value_3
1058     : value_4
1059     | value_3 PLUS value_4                                      { $$ = $2; sar_binary_op( &$$, &$1, &$3 ); }
1060     | value_3 MINUS value_4                                     { $$ = $2; sar_binary_op( &$$, &$1, &$3 ); }
1061     ;
1062
1063 value_4
1064     : value_5
1065     | value_4 MULTIPLY value_5                                  { $$ = $2; sar_binary_op( &$$, &$1, &$3 ); }
1066     | value_4 DIVIDE value_5                                    { $$ = $2; sar_binary_op( &$$, &$1, &$3 ); }
1067     ;
1068
1069 value_5
1070     : value_6
1071     | MINUS value_5                                             { $$ = $1; sar_unary_op( &$$, &$2 ); }
1072     | NOT value_5                                               { $$ = $1; sar_unary_op( &$$, &$2 ); }
1073     | PLUS value_5                                              { $$ = $1; sar_unary_op( &$$, &$2 ); }
1074     ;
1075
1076 value_6
1077     : operand
1078     | LEFT_PAREN value RIGHT_PAREN                              { $$ = $2; }
1079     ;
1080
1081 operand
1082     : UNS_INT_LITERAL                                           { sar_make_private_value( &$$, &$1, sym_k_integer_value,
1083                                                                   &$1, XmPIXELS); }
1084     | UNS_INT_LITERAL units_specification                       { sar_make_private_value( &$$, &$1, sym_k_integer_value,
1085                                                                   &$1, sar_get_units_type(&$2)); }
1086     | optional_charset CHAR_8_LITERAL                           { /* Don't use FALSE because it is a token not a Boolean! */
1087                                                                   Uil_lex_l_charset_specified = 0;
1088                                                                   sar_make_private_value( &$$, &$2, sym_k_char_8_value,
1089                                                                   &$2, 0); }
1090     | id                                                        { sar_process_id( &$$, &$1 );}
1091     | UNS_FLOAT_LITERAL                                         { sar_make_private_value( &$$, &$1, sym_k_float_value,
1092                                                                   &$1, XmPIXELS); }
1093     | UNS_FLOAT_LITERAL units_specification                     { sar_make_private_value( &$$, &$1, sym_k_float_value,
1094                                                                   &$1, sar_get_units_type(&$2)); }
1095     | PIXMAP LEFT_PAREN character_8_value RIGHT_PAREN           { sar_value_not_implemented( &$$, &$1, "pixmap literal" ); }
1096     | FONT LEFT_PAREN font_spec RIGHT_PAREN                     { $$ = $3; }
1097     | FONTSET LEFT_PAREN fontset_spec RIGHT_PAREN               { $$ = $3; }
1098     | COLOR LEFT_PAREN color_spec RIGHT_PAREN                   { $$ = $3; }
1099     | REASON LEFT_PAREN character_8_value RIGHT_PAREN           { sar_make_private_value(&$$, &$3, sym_k_reason_value,
1100                                                                   &$1, 0); }
1101     | CLASS_REC_NAME LEFT_PAREN character_8_value RIGHT_PAREN   { sar_make_private_value(&$$, &$3, sym_k_class_rec_name_value,
1102                                                                                          &$1, 0); }
1103     | ARGUMENT LEFT_PAREN character_8_value opt_arg_type RIGHT_PAREN
1104                                                                 { sar_make_private_value
1105                                                                       ( &$$, &$3, sym_k_argument_value, &$1, $4.b_type ); }
1106     | UILTRUE                                                   { sar_make_private_value( &$$, &$1, sym_k_bool_value,
1107                                                                   &$1, 0); }
1108     | UILFALSE                                                  { sar_make_private_value( &$$, &$1, sym_k_bool_value,
1109                                                                   &$1, 0); }
1110     | ON                                                        { sar_make_private_value( &$$, &$1, sym_k_bool_value,
1111                                                                   &$1, 0); }
1112     | OFF                                                       { sar_make_private_value( &$$, &$1, sym_k_bool_value,
1113                                                                   &$1, 0); }
1114     | optional_charset COMP_STRING                              { /* Don't use FALSE because it is a token not a Boolean! */
1115                                                                   Uil_lex_l_charset_specified = 0;
1116                                                                   sar_make_private_value
1117                                                                       ( &$$, &$2, sym_k_compound_string_value, &$2, 0); }
1118     | string_table_type LEFT_PAREN comp_str_list RIGHT_PAREN    { sar_make_private_value( &$$, &$3, sym_k_string_table_value,
1119                                                                   &$1, 0); }
1120     | asciz_table_type LEFT_PAREN asciz_list RIGHT_PAREN        { sar_make_private_value( &$$, &$3, sym_k_asciz_table_value,
1121                                                                   &$1, 0); }
1122     | INTEGER_TABLE LEFT_PAREN integer_list RIGHT_PAREN         { sar_make_private_value( &$$, &$3, sym_k_integer_table_value,
1123                                                                   &$1, 0); }
1124     | TRANSLATION_TABLE LEFT_PAREN string_list RIGHT_PAREN      { sar_make_private_value( &$$, &$3, sym_k_trans_table_value,
1125                                                                   &$1, 0); }
1126     | COMPOUND_STRING LEFT_PAREN comp_str_result RIGHT_PAREN    { $$ = $3; }
1127     | COMPOUND_STRING_COMPONENT LEFT_PAREN comp_str_comp_result RIGHT_PAREN     { $$ = $3; }
1128     | FONT_TABLE LEFT_PAREN font_list RIGHT_PAREN               { $$ = $3; }
1129     | ICON LEFT_PAREN icon_spec RIGHT_PAREN                     { $$ = $3; }
1130     | FLOAT LEFT_PAREN value RIGHT_PAREN                        { $$ = $1; sar_unary_op( &$$, &$3 ); }
1131     | INTEGER LEFT_PAREN value RIGHT_PAREN                      { $$ = $1; sar_unary_op( &$$, &$3 ); }
1132
1133     | XBITMAPFILE LEFT_PAREN character_8_value RIGHT_PAREN      { sar_make_private_value(&$$, &$3, sym_k_xbitmapfile_value,
1134                                                                                          &$1, 0); }
1135
1136     | KEYSYM LEFT_PAREN character_8_value RIGHT_PAREN           { sar_make_private_value(&$$, &$3, sym_k_keysym_value,
1137                                                                                          &$1, 0); }
1138
1139     | SINGLE_FLOAT      LEFT_PAREN value RIGHT_PAREN            { $$ = $1; sar_unary_op( &$$, &$3 ); }
1140
1141     | RGB LEFT_PAREN rgb_list RIGHT_PAREN                       { sar_make_private_value( & $$, & $3, sym_k_rgb_value,
1142                                                                   &$1, 0); }
1143     | WIDE_CHARACTER LEFT_PAREN wchar_str_result RIGHT_PAREN    { $$ = $3; }
1144     | LOC_STRING                                                { sar_make_private_value(&$$, &$1, sym_k_localized_string_value,
1145                                                                   &$1, 0); }
1146     ;
1147
1148 string_list
1149     : /* empty */
1150         { $$ = gz_yynullval; }
1151     | string_list_2
1152         { $$ = $1; }
1153     ;
1154
1155 string_list_2
1156     : private_value
1157         { sar_append_table_value (&$1, &gz_yynullval, sym_k_trans_table_value, &$1); $$ = $1; }
1158     | string_list_2 COMMA private_value
1159         { sar_append_table_value (&$3, &$1, sym_k_trans_table_value, &$2); $$ = $3; }
1160     ;
1161
1162 asciz_list
1163     : /* empty */
1164         { $$ = gz_yynullval; }
1165     | asciz_list_2
1166         { $$ = $1; }
1167     ;
1168
1169 asciz_list_2
1170     : private_value
1171         { sar_append_table_value (&$1, &gz_yynullval, sym_k_asciz_table_value, &$1); $$ = $1; }
1172     | asciz_list_2 COMMA private_value
1173         { sar_append_table_value (&$3, &$1, sym_k_asciz_table_value, &$2); $$ = $3; }
1174     ;
1175
1176 integer_list
1177     : /* empty */
1178         { $$ = gz_yynullval; }
1179     | integer_list_2
1180         { $$ = $1; }
1181     ;
1182
1183 integer_list_2
1184     : private_value
1185         { sar_append_table_value (&$1, &gz_yynullval, sym_k_integer_table_value, &$1); $$ = $1; }
1186     | integer_list_2 COMMA private_value
1187         { sar_append_table_value (&$3, &$1, sym_k_integer_table_value, &$2); $$ = $3; }
1188     ;
1189
1190 /* RAP rgb data type */
1191 rgb_list
1192   : private_value COMMA private_value COMMA private_value
1193 {sar_append_table_value(&$1, & gz_yynullval, sym_k_integer_table_value, & $1);
1194      sar_append_table_value(& $3, & $1, sym_k_integer_table_value, & $2);
1195      sar_append_table_value(& $5, & $3, sym_k_integer_table_value, & $4);
1196      $$ = $5;}
1197   ;
1198
1199
1200 comp_str_list
1201     : /* empty */
1202         { $$ = gz_yynullval; }
1203     | comp_str_list_2
1204         { $$ = $1; }
1205     ;
1206
1207 comp_str_list_2
1208     : private_value
1209         { sar_append_table_value (&$1, &gz_yynullval, sym_k_string_table_value, &$1); $$ = $1; }
1210     | comp_str_list_2 COMMA private_value
1211         { sar_append_table_value (&$3, &$1, sym_k_string_table_value, &$2); $$ = $3; }
1212     ;
1213
1214 opt_arg_type
1215     : /* empty */                                       { $$ = gz_yynullval; $$.b_type = sym_k_any_value; }
1216     | COMMA arg_value_type                                      { $$ = gz_yynullval; $$.b_type = $2.b_type; }
1217     | COMMA ANY                                         { $$ = gz_yynullval; $$.b_type = sym_k_any_value; }
1218     ;
1219
1220 comp_str_result
1221     : private_value                                     { sar_make_comp_str( &$$, &$1, &gz_yynullval, &$-1 ); }
1222     | private_value comp_str_attrs                      { sar_make_comp_str( &$$, &$1, &$2, &$-1 ); }
1223     ;
1224
1225 comp_str_comp_result
1226     : ENUMVAL_NAME      { sar_make_comp_str_comp(&$$, &$1, &gz_yynullval, &$-1 ); }
1227     | ENUMVAL_NAME COMMA ENUMVAL_NAME   { sar_make_comp_str_comp( &$$, &$1, &$3, &$-1 ); }
1228     | ENUMVAL_NAME COMMA CHAR_8_LITERAL { sar_make_comp_str_comp( &$$, &$1, &$3, &$-1 ); }
1229     | ENUMVAL_NAME COMMA LOC_STRING     { sar_make_comp_str_comp( &$$, &$1, &$3, &$-1 ); }
1230     | ENUMVAL_NAME COMMA CHARSET_NAME   { sar_make_comp_str_comp( &$$, &$1, &$3, &$-1 ); }
1231     ;
1232
1233 comp_str_attrs
1234     : COMMA comp_str_attr                               { sar_chk_comp_str_attr( &$$, &$2, &gz_yynullval ); }
1235     | comp_str_attrs COMMA comp_str_attr                { sar_chk_comp_str_attr( &$$, &$3, &$1 ); }
1236     ;
1237
1238 comp_str_attr
1239     : CHARACTER_SET EQUAL_SIGN valid_charset            { $$.b_type = $1.b_type;
1240                                                           $$.b_tag = $3.b_tag;
1241                                                           $$.value.az_keyword_entry = $3.value.az_keyword_entry;
1242                                                           $$.value.az_symbol_entry = $3.value.az_symbol_entry; }
1243     | RIGHT_TO_LEFT EQUAL_SIGN private_value            { $$.b_type = $1.b_type;
1244                                                           $$.value.az_symbol_entry = $3.value.az_symbol_entry; }
1245     | SEPARATE EQUAL_SIGN private_value                 { $$.b_type = $1.b_type;
1246                                                           $$.value.az_symbol_entry = $3.value.az_symbol_entry; }
1247     ;
1248
1249 wchar_str_result
1250     : private_value                                     { sar_make_wchar_str( &$$, &$1, &gz_yynullval, &$-1 ); }
1251     ;
1252
1253 font_spec
1254     : character_8_value COMMA CHARACTER_SET EQUAL_SIGN valid_charset
1255                                                         { sar_make_font( &$$, &$5, &$1, &$-1 ); }
1256     | character_8_value                                 { sar_make_font( &$$, &gz_yynullval, &$1, &$-1 ); }
1257     ;
1258
1259 fontset_spec
1260     : character_8_value COMMA CHARACTER_SET EQUAL_SIGN valid_charset
1261                                                         { sar_make_fontset( &$$, &$5, &$1, &$-1 ); }
1262     | character_8_value                                 { sar_make_fontset( &$$, &gz_yynullval, &$1, &$-1 ); }
1263     ;
1264
1265 font_list
1266     : font_item                                         { sar_make_font_table( &$$, &$1, &gz_yynullval, &$-1 ); }
1267     | font_list COMMA font_item                         { sar_make_font_table( &$$, &$3, &$1, &$-1 ); }
1268     ;
1269
1270 /*
1271 ** THIS PRODUCTION DOESN'T LOOK RIGHT!!!!!!!!!!!!!!!!!!!!!!
1272 */
1273 font_item
1274     : valid_charset EQUAL_SIGN private_value            { sar_make_font_item( &$$, &$1, &$3 ); }
1275     | private_value                                     { sar_make_font_item( &$$, &gz_yynullval, &$1 ); }
1276     ;
1277
1278 optional_charset
1279     : POUND valid_charset                               { /* Don't use TRUE because it is a token not a Boolean! */
1280                                                           $$ = $2;
1281                                                           Uil_lex_l_charset_specified = 1;}
1282     | epsilon_production
1283     ;
1284
1285
1286 valid_charset
1287     : CHARSET_NAME                                      { sar_charset_verify (&$1); $$ = $1; }
1288     | CHARACTER_SET LEFT_PAREN charset_info RIGHT_PAREN { $$ = $3; }
1289     | NAME                      { sar_make_fallback_charset(&$1);
1290                                   $$ = $1; }
1291
1292     ;
1293
1294 charset_info
1295     : character_8_value                                 { sar_make_private_value(&$$, &$1, sym_k_char_8_value,
1296                                                           &$1, 0);
1297                                                           sar_make_charset (&$$, &$$, &gz_yynullval, &$1); }
1298     | character_8_value charset_attrs                   { sar_make_private_value(&$$, &$1, sym_k_char_8_value,
1299                                                           &$1, 0);
1300                                                           sar_make_charset (&$$, &$$, &$2, &$1); }
1301     ;
1302
1303 charset_attrs
1304     : COMMA charset_attr                                { sar_chk_charset_attr( &$$, &$2, &gz_yynullval ); }
1305     | charset_attrs COMMA charset_attr                  { sar_chk_charset_attr( &$$, &$3, &$1 ); }
1306     ;
1307
1308 charset_attr
1309     : RIGHT_TO_LEFT EQUAL_SIGN private_value            { $$.b_type = $1.b_type;
1310                                                           if ($3.b_type != sym_k_bool_value)
1311                                                               sar_value_type_error( &$3, sym_k_bool_value );
1312                                                           $$.value.az_symbol_entry = $3.value.az_symbol_entry; }
1313     | SIXTEEN_BIT EQUAL_SIGN private_value              { $$.b_type = $1.b_type;
1314                                                           if ($3.b_type != sym_k_bool_value)
1315                                                               sar_value_type_error( &$3, sym_k_bool_value );
1316                                                           $$.value.az_symbol_entry = $3.value.az_symbol_entry; }
1317     ;
1318
1319 color_list
1320     : color_item                                        { sar_append_color_item( &$$, &$1, &gz_yynullval ); }
1321     | color_list COMMA color_item                       { sar_append_color_item( &$$, &$3, &$1 ); }
1322     ;
1323
1324 color_item
1325     : BACKGROUND COLOR EQUAL_SIGN character_8_value     { sar_make_color_item( &$$, &$1, &$4 ); }
1326     | FOREGROUND COLOR EQUAL_SIGN character_8_value     { sar_make_color_item( &$$, &$1, &$4 ); }
1327     | value EQUAL_SIGN character_8_value                { sar_make_color_item( &$$, &$1, &$3 ); }
1328     ;
1329
1330 color_spec
1331     : character_8_value                                 { sar_make_color( &$$, &$1, &gz_yynullval, &$-1 ); }
1332     | character_8_value COMMA mono_color_spec           { sar_make_color( &$$, &$1, &$3, &$-1 ); }
1333     ;
1334
1335 mono_color_spec
1336     : BACKGROUND
1337     | FOREGROUND
1338     ;
1339
1340 icon_spec
1341     : icon_rows                                         { sar_make_icon( &$$, &$1, &gz_yynullval, &$-1); }
1342     | COLOR_TABLE EQUAL_SIGN private_value COMMA icon_rows
1343                                                         { sar_make_icon( &$$, &$5, &$3, &$-1 ); }
1344     ;
1345
1346 icon_rows
1347     : private_value
1348                                 { sar_append_table_value (&$1, &gz_yynullval, sym_k_icon_value, &$1); $$ = $1; }
1349     | icon_rows COMMA private_value
1350                                 { sar_append_table_value (&$3, &$1, sym_k_icon_value, &$2); $$ = $3; }
1351     ;
1352
1353 units_specification
1354     : PIX
1355         { $$ = $1; }
1356     | PIXEL
1357         { $$ = $1; }
1358     | PIXELS
1359         { $$ = $1; }
1360     | IN
1361         { $$ = $1; }
1362     | INCH
1363         { $$ = $1; }
1364     | INCHES
1365         { $$ = $1; }
1366     | CM
1367         { $$ = $1; }
1368     | CENTIMETER
1369         { $$ = $1; }
1370     | CENTIMETERS
1371         { $$ = $1; }
1372     | MM
1373         { $$ = $1; }
1374     | MILLIMETER
1375         { $$ = $1; }
1376     | MILLIMETERS
1377         { $$ = $1; }
1378     | PT
1379         { $$ = $1; }
1380     | POINT
1381         { $$ = $1; }
1382     | POINTS
1383         { $$ = $1; }
1384     | FU
1385         { $$ = $1; }
1386     | FONT_UNIT
1387         { $$ = $1; }
1388     | FONT_UNITS
1389         { $$ = $1; }
1390     ;
1391
1392 %%
1393
1394 /*    Dummy error routine for the parser.  We will output our own
1395       error messages.    */
1396
1397 int yyerror (s)
1398 char    * s;
1399 {
1400         return 0;
1401 }
1402
1403
1404