cde/osf/wml/wml.h

   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 /*
  24  *  @OSF_COPYRIGHT@
  25  *  COPYRIGHT NOTICE
  26  *  Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
  27  *  ALL RIGHTS RESERVED (MOTIF). See the file named COPYRIGHT.MOTIF for
  28  *  the full copyright text.
  29 */
  30 /*
  31  * HISTORY
  32 */
  33 /*   $XConsortium: wml.h /main/9 1995/08/29 11:10:33 drk $ */
  34 /*
  35 *  (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */
  36
  37 /*
  38  * This file contains the structure and literal definitions required
  39  * by the WML processor
  40  */
  41
  42 #if defined(__STDC__)
  43 #include <stddef.h>
  44 #else
  45 #include <stdio.h>
  46 #endif
  47
  48 #define TRUE            1
  49 #define FALSE           0
  50 #define SUCCESS         1
  51 #define FAILURE         0
  52
  53 /*
  54  * Generic object pointer
  55  */
  56 typedef char    *ObjectPtr;
  57
  58
  59 /*
  60  * True and False for attributes, so setting is explicit
  61  */
  62 #define WmlAttributeUnspecified         0
  63 #define WmlAttributeTrue                1
  64 #define WmlAttributeFalse               2
  65
  66 /*
  67  * Values of character set direction
  68  */
  69 #define WmlCharSetDirectionLtoR         1
  70 #define WmlCharSetDirectionRtoL         2
  71
  72 /*
  73  * Values of character set character size
  74  */
  75 #define WmlCharSizeOneByte              1
  76 #define WmlCharSizeTwoByte              2
  77 #define WmlCharSizeMixed1_2Byte         3
  78
  79
  80 /*
  81  * Upper case and lower case converters
  82  */
  83 #define _upper(c)       ((c) >= 'a' && (c) <= 'z' ? (c) & 0x5F:(c))
  84 #define _lower(c)       ((c) >= 'A' && (c) <= 'Z' ? (c) | 0x20:(c))
  85
  86
  87 /*
  88  * The Uil token classes which are dealt with WML. Matched to definitions
  89  * in UilKeyDef.h, although this isn't required.
  90  */
  91 #define WmlTokenClassArgument   1
  92 #define WmlTokenClassCharset    2
  93 #define WmlTokenClassColor      3
  94 #define WmlTokenClassEnumval    4
  95 #define WmlTokenClassFont       5
  96 #define WmlTokenClassIdentifier 6
  97 #define WmlTokenClassKeyword    7
  98 #define WmlTokenClassLiteral    8
  99 #define WmlTokenClassReason     9
 100 #define WmlTokenClassReserved   10
 101 #define WmlTokenClassSpecial    11
 102 #define WmlTokenClassUnused     12
 103 #define WmlTokenClassClass      13
 104 #define WmlTokenClassChild      14
 105
 106
 107 \f
 108 /*
 109  * Structures for WML objects. Two kinds are created for each object
 110  * recognized and built as a WML description is read:
 111  *      - A syntactic descriptor, which captures the information parse
 112  *        from the input in pretty much its raw form
 113  *      - A semantically resolved descriptor, in which pointers to
 114  *        other descriptors have been resolved, ordering is done,
 115  *        superclass inheritance is complete, etc.
 116  */
 117
 118 /*
 119  * Syntactic structures. These are constructred during input parse.
 120  */
 121
 122
 123 /*
 124  * A dummy holding only a header. Allows access to the validation field.
 125  */
 126 typedef struct
 127     {
 128     int                 validation;     /* a unique validation code */
 129     ObjectPtr           rslvdef;        /* the resolved object pointer */
 130     } WmlSynDef, *WmlSynDefPtr;
 131
 132
 133
 134 /*
 135  * A class resource descriptor. This a subset of a full resource descriptor,
 136  * which captures those elements which can be overridden in a class declaration
 137  */
 138 #define WmlClassResDefValid     871253
 139
 140 typedef struct WmlSynClassResDefStruct
 141     {
 142     int                 validation;     /* WmlClassResDefValid */
 143     struct WmlSynClassResDefStruct
 144                         *next;          /* next descriptor in chain */
 145     char                *name;          /* resource name */
 146     char                *type;          /* override type name */
 147     char                *dflt;          /* override default value */
 148     short int           exclude;        /* WmlAttributeTrue if to be excluded */
 149     } WmlSynClassResDef, *WmlSynClassResDefPtr;
 150
 151 /*
 152  * A class child descriptor.
 153  */
 154 #define WmlClassChildDefValid   780344
 155
 156 typedef struct WmlSynClassChildDefStruct
 157     {
 158     int                 validation;     /* WmlClassChildDefValid */
 159     struct WmlSynClassChildDefStruct
 160                         *next;          /* next descriptor in chain */
 161     char                *name;          /* child name */
 162     } WmlSynClassChildDef, *WmlSynClassChildDefPtr;
 163
 164
 165 /*
 166  * A class controls descriptor. It contains elements which can be added
 167  * to a controls reference.
 168  */
 169
 170 #define WmlClassCtrlDefValid    7132320
 171
 172 typedef struct WmlSynClassCtrlDefStruct
 173     {
 174     int                 validation;     /* WmlClassCtrlDefValid */
 175     struct WmlSynClassCtrlDefStruct
 176                         *next;          /* next descriptor in chain */
 177     char                *name;          /* controlled class name */
 178     } WmlSynClassCtrlDef, *WmlSynClassCtrlDefPtr;
 179
 180
 181 /*
 182  * A class structure. One exists for each Class statement in a WML
 183  * description.
 184  */
 185 #define WmlClassDefValid        93741
 186
 187 #define WmlClassTypeMetaclass   1
 188 #define WmlClassTypeWidget      2
 189 #define WmlClassTypeGadget      3
 190
 191 typedef struct WmlSynClassDefStruct
 192     {
 193     int                 validation;     /* WmlClassDefValid */
 194     struct WmlClassDefStruct
 195                         *rslvdef;       /* resolved definition */
 196     short int           type;           /* from WmlClassType... */
 197     short int           dialog;         /* TRUE if a dialog class (has
 198                                            window manager decoration, etc) */
 199     char                *name;          /* class name */
 200     char                *superclass;    /* superclass name */
 201     char                *parentclass;   /* parentclass name */
 202     char                *widgetclass;   /* widget class name */
 203     char                *int_lit;       /* internal literal name */
 204     char                *convfunc;      /* convenience function name */
 205     char                *docname;       /* name for docs */
 206     char                *ctrlmapto;     /* resource controls map to */
 207     WmlSynClassCtrlDefPtr
 208                         controls;       /* list of controlled classes */
 209     WmlSynClassResDefPtr
 210                         resources;      /* list of resources from input */
 211     WmlSynClassChildDefPtr
 212                         children;       /* list of automatic children */
 213     } WmlSynClassDef, *WmlSynClassDefPtr;
 214
 215
 216 /*
 217  * A controls list structure. One is created for each ControlsList statement
 218  * in a WML description.
 219  */
 220 #define WmlCtrlListDefValid     621298
 221
 222 typedef struct WmlSynCtrlListDefStruct
 223     {
 224     int                 validation;     /* WmlCtrlListDefValid */
 225     struct WmlCtrlListDefStruct
 226                         *rslvdef;       /* resolved definition */
 227     char                *name;          /* controls list name */
 228     WmlSynClassCtrlDefPtr
 229                         controls;       /* list of controlled classes */
 230     } WmlSynCtrlListDef, *WmlSynCtrlListDefPtr;
 231
 232
 233 /*
 234  * A resource descriptor. One is created for each Resource statement
 235  * in a WML description
 236  */
 237 #define WmlResourceDefValid     310538
 238
 239 #define WmlResourceTypeArgument         1
 240 #define WmlResourceTypeReason           2
 241 #define WmlResourceTypeConstraint       3
 242 #define WmlResourceTypeSubResource      4
 243
 244 typedef struct WmlSynResourceDefStruct
 245     {
 246     int                 validation;     /* WmlResourceDefValid */
 247     struct WmlResourceDefStruct
 248                         *rslvdef;       /* resolved definition */
 249     short int           type;           /* from WmlResourceType... */
 250     char                *name;          /* resource name */
 251     char                *datatype;      /* resource data type */
 252     char                *int_lit;       /* internal literal name */
 253     char                *resliteral;    /* resource name literal */
 254     char                *enumset;       /* enumeration set name */
 255     char                *docname;       /* name for docs */
 256     char                *related;       /* names related resource */
 257     char                *dflt;          /* default value */
 258     short int           xrm_support;    /* WmlAttributeTrue if can be
 259                                            Xrm resource */
 260     short int           alias_cnt;      /* alias count */
 261     char                **alias_list;   /* vector of aliass */
 262     } WmlSynResourceDef, *WmlSynResourceDefPtr;
 263
 264 /*
 265  * A child descriptor. One is created for each Child statement
 266  * in a WML description
 267  */
 268 #define WmlChildDefValid        229629
 269
 270 typedef struct WmlSynChildDefStruct
 271     {
 272     int                 validation;     /* WmlResourceDefValid */
 273     struct WmlChildDefStruct
 274                         *rslvdef;       /* resolved definition */
 275     char                *name;          /* child name */
 276     char                *class;         /* child class */
 277     } WmlSynChildDef, *WmlSynChildDefPtr;
 278
 279
 280 /*
 281  * A datatype descriptor
 282  */
 283 #define WmlDataTypeDefValid     714210
 284
 285 typedef struct WmlSynDataTypeDefStruct
 286     {
 287     int                 validation;     /* WmlDataTypeDefValid */
 288     struct WmlDataTypeDefStruct
 289                         *rslvdef;       /* resolved definition */
 290     char                *name;          /* data type name */
 291     char                *int_lit;       /* internal literal name */
 292     char                *docname;       /* name for docs */
 293     short int           xrm_support;    /* WmlAttributeTrue if can be
 294                                            Xrm resource */
 295     } WmlSynDataTypeDef, *WmlSynDataTypeDefPtr;
 296
 297
 298 /*
 299  * An enumeration set values descriptor, as it occurs in the list for
 300  * an enumeration set descriptor.
 301  */
 302 typedef struct WmlSynEnumSetValDefStruct
 303     {
 304     int                 validation;     /* WmlEnumValueDefValid */
 305     struct WmlSynEnumSetValDefStruct
 306                         *next;          /* next descriptor in chain */
 307     char                *name;          /* enumeration value name */
 308     } WmlSynEnumSetValDef, *WmlSynEnumSetValDefPtr;
 309
 310
 311 /*
 312  * An enumeration set descriptor
 313  */
 314 #define WmlEnumSetDefValid      931184
 315
 316 typedef struct WmlSynEnumSetDefStruct
 317     {
 318     int                 validation;     /* WmlEnumSetDefValid */
 319     struct WmlEnumSetDefStruct
 320                         *rslvdef;       /* resolved definition */
 321     char                *name;          /* enumeration set name */
 322     char                *datatype;      /* enumeration set data type */
 323     WmlSynEnumSetValDefPtr
 324                         values;         /* list of values in set */
 325     } WmlSynEnumSetDef, *WmlSynEnumSetDefPtr;
 326
 327
 328
 329 /*
 330  * An enumeration value descriptor
 331  */
 332 #define WmlEnumValueDefValid    172938
 333
 334 typedef struct WmlSynEnumValueDefStruct
 335     {
 336     int                 validation;     /* WmlEnumValueDefValid */
 337     struct WmlEnumValueDefStruct
 338                         *rslvdef;       /* resolved definition */
 339     char                *name;          /* enumeration value name */
 340     char                *enumlit;       /* name of defining literal */
 341     } WmlSynEnumValueDef, *WmlSynEnumValueDefPtr;
 342
 343
 344 /*
 345  * A charset descriptor
 346  */
 347 #define WmlCharSetDefValid      110983
 348
 349 typedef struct WmlSynCharSetDefStruct
 350     {
 351     int                 validation;     /* WmlCharSetDefValid */
 352     struct WmlCharSetDefStruct
 353                         *rslvdef;       /* resolved definition */
 354     char                *name;          /* data type name */
 355     char                *int_lit;       /* internal literal name */
 356     char                *xms_name;      /* identifying XmString name */
 357     short int           direction;      /* WmlCharSetDirection... */
 358     short int           parsedirection; /* WmlCharSetDirection... */
 359     short int           charsize;       /* WmlCharSize... */
 360     short int           alias_cnt;      /* alias count */
 361     char                **alias_list;   /* vector of aliases */
 362     } WmlSynCharSetDef, *WmlSynCharSetDefPtr;
 363
 364
 365 \f
 366 /*
 367  * Data structures constructed during semantic validation. Each points
 368  * as required to syntactic data structures. These are typically accessed
 369  * from ordered pointer vectors.
 370  */
 371
 372
 373 /*
 374  * A datatype descriptor. It extends the syntactic element by assigning
 375  * a code to the descriptor.
 376  */
 377 typedef struct WmlDataTypeDefStruct
 378     {
 379     struct WmlSynDataTypeDefStruct
 380                         *syndef;        /* syntactic definition */
 381     char                *tkname;        /* name for generating literals */
 382     } WmlDataTypeDef, *WmlDataTypeDefPtr;
 383
 384
 385 /*
 386  * A charset descriptor. It extends the syntactic element by assigning
 387  * a code to the descriptor.
 388  */
 389 typedef struct WmlCharSetDefStruct
 390     {
 391     struct WmlSynCharSetDefStruct
 392                         *syndef;        /* syntactic definition */
 393     char                *tkname;        /* name for generating literals */
 394     short int           sym_code;       /* code value for literals */
 395     } WmlCharSetDef, *WmlCharSetDefPtr;
 396
 397 /*
 398  * A child descriptor. It extends the syntactic element by assigning
 399  * a code and a pointer to the class to the descriptor.
 400  */
 401 typedef struct WmlChildDefStruct
 402     {
 403     struct WmlSynChildDefStruct
 404                         *syndef;        /* syntactic definition */
 405     char                *tkname;        /* name for generating literals */
 406     short int           sym_code;       /* code value for literals */
 407     struct WmlClassDefStruct
 408                         *class;         /* class structure */
 409     struct WmlClassChildDefStruct
 410                         *ref_ptr;       /* used dynamically for search */
 411     } WmlChildDef, *WmlChildDefPtr;
 412
 413 /*
 414  * An element in the values list of an enumeration set. These elements have
 415  * separate lists in order to deal with the possibility of an enumeration
 416  * value which is a member of more than one list.
 417  */
 418 typedef struct WmlEnumSetValDefStruct
 419     {
 420     struct WmlEnumSetValDefStruct
 421                         *next;          /* next value in list */
 422     struct WmlEnumValueDefStruct
 423                         *value;         /* value descriptor for element */
 424     } WmlEnumSetValDef, *WmlEnumSetValDefPtr;
 425
 426
 427 /*
 428  * A resolved enumeration set descriptor
 429  */
 430 typedef struct WmlEnumSetDefStruct
 431     {
 432     struct WmlSynEnumSetDefStruct
 433                         *syndef;        /* syntactic definition */
 434     char                *tkname;        /* name for generating literals */
 435     short int           sym_code;       /* code value for literals */
 436     WmlDataTypeDefPtr   dtype_def;      /* data type */
 437     short int           values_cnt;     /* count of # of values in set */
 438     WmlEnumSetValDefPtr
 439                         values;         /* list of values in set */
 440     } WmlEnumSetDef, *WmlEnumSetDefPtr;
 441
 442
 443 /*
 444  * A resolved enumeration value descriptor
 445  */
 446 typedef struct WmlEnumValueDefStruct
 447     {
 448     struct WmlSynEnumValueDefStruct
 449                         *syndef;        /* syntactic definition */
 450     short int           sym_code;       /* code value for literals */
 451     } WmlEnumValueDef, *WmlEnumValueDefPtr;
 452
 453
 454 /*
 455  * A resource descriptor
 456  */
 457 typedef struct WmlResourceDefStruct
 458     {
 459     struct WmlSynResourceDefStruct
 460                         *syndef;        /* syntactic definition */
 461     char                *tkname;        /* name for generating literals */
 462     short int           sym_code;       /* code value for literals */
 463     WmlDataTypeDefPtr   dtype_def;      /* data type for base definition */
 464     WmlEnumSetDefPtr    enumset_def;    /* enumeration set if specified */
 465     short int           related_code;   /* if non-0, the sym_code for the
 466                                            related (count) argument */
 467     short int           xrm_support;    /* if AttributeTrue, then the resource
 468                                            can be set in Xrm. Resolved
 469                                            from either explicit setting or
 470                                            data type setting */
 471     struct WmlClassDefStruct
 472                         *ref_class;     /* used for membership sort */
 473     struct WmlClassResDefStruct
 474                         *ref_ptr;       /* used dynamically for search */
 475     } WmlResourceDef, *WmlResourceDefPtr;
 476
 477
 478 /*
 479  * A resource descriptor with overrides which is a member of the resource
 480  * list of a class descriptor.
 481  */
 482 typedef struct WmlClassResDefStruct
 483     {
 484     struct WmlClassResDefStruct
 485                         *next;          /* next resource in list */
 486     WmlResourceDefPtr   act_resource;   /* actual resource descriptor */
 487     WmlDataTypeDefPtr   over_dtype;     /* overriding data type */
 488     char                *dflt;          /* overriding default */
 489     int                 exclude;        /* WmlAttributeTrue if to be excluded */
 490     } WmlClassResDef, *WmlClassResDefPtr;
 491
 492 /*
 493  * A child descriptor which is a member of the children
 494  * list of a class descriptor.
 495  */
 496 typedef struct WmlClassChildDefStruct
 497     {
 498     struct WmlClassChildDefStruct
 499                         *next;          /* next child in list */
 500     WmlChildDefPtr      act_child;      /* actual child descriptor */
 501   } WmlClassChildDef, *WmlClassChildDefPtr;
 502
 503
 504 /*
 505  * An element for the controls list of a resolved class descriptor
 506  */
 507 typedef struct WmlClassCtrlDefStruct
 508     {
 509     struct WmlClassCtrlDefStruct
 510                         *next;          /* next control in list */
 511     struct WmlClassDefStruct
 512                         *ctrl;          /* class being controlled */
 513     } WmlClassCtrlDef, *WmlClassCtrlDefPtr;
 514
 515
 516
 517 /*
 518  * A resolved class descriptor. It has a pointer to its superclass, and
 519  * a resource list consisting of its inherited resources followed by
 520  * its own resources.
 521  */
 522 typedef struct WmlClassDefStruct
 523     {
 524     struct WmlSynClassDefStruct
 525                         *syndef;        /* syntactic definition */
 526     struct WmlClassDefStruct
 527                         *superclass;    /* superclass structure */
 528     struct WmlClassDefStruct
 529                         *parentclass;   /* parentclass structure */
 530     char                *tkname;        /* name to be used in literals.
 531                                            int_lit or name if no int_lit */
 532     short int           sym_code;       /* code value for literals */
 533     short int           inherit_done;   /* TRUE when inheritance complete */
 534     WmlClassResDefPtr   arguments;      /* linked argument list */
 535     WmlClassResDefPtr   reasons;        /* lined reason list */
 536     WmlClassCtrlDefPtr  controls;       /* list of controlled classes.
 537                                            Controls list references will
 538                                            be expanded into this list. */
 539     WmlClassChildDefPtr children;       /* list of automatic children */
 540     struct WmlClassDefStruct
 541                         *variant;       /* the gadget class for a widget */
 542     struct WmlClassDefStruct
 543                         *nondialog;     /* the non-dialog ancestor of a
 544                                            dialog widget */
 545     WmlResourceDefPtr   ctrlmapto;      /* the resource controls map to */
 546     struct WmlClassCtrlDefStruct
 547                         *ref_ptr;       /* used dynamically for search */
 548     } WmlClassDef, *WmlClassDefPtr;
 549
 550
 551 /*
 552  * A resolved controls list descriptor.
 553  */
 554 typedef struct WmlCtrlListDefStruct
 555    {
 556    struct WmlSynCtrlListDefStruct
 557                         *syndef;        /* syntactic definition */
 558    WmlClassCtrlDefPtr   controls;       /* list of controlled classes */
 559    } WmlCtrlListDef, *WmlCtrlListDefPtr;
 560
 561
 562 \f
 563 /*
 564  * Data structures used to locate and order objects in various ways.
 565  */
 566
 567 /*
 568  * Token structure used to create ordered token lists for generation of
 569  * UilKeyTab.h. The token string is in the order vector.
 570  */
 571 typedef struct WmlKeyWTokenStruct
 572     {
 573     int                 class;          /* token class, WmlTokenClass... */
 574     ObjectPtr           objdef;         /* object definition (resolved) */
 575     } WmlKeyWToken, *WmlKeyWTokenPtr;
 576
 577
 578 /*
 579  * A grammar token as obtained from the UIL grammar file (Uil.y)
 580  */
 581 typedef struct WmlGrammarTokenStruct
 582     {
 583     int                 class;          /* token class, WmlTokenClass... */
 584     char                *token;         /* token name (literal) */
 585     int                 val;            /* token id as value */
 586     } WmlGrammarToken, *WmlGrammarTokenPtr;
 587
 588
 589 /*
 590  * A list element which allows association of a name with an object.
 591  * Typically used to construct ordered lists.
 592  */
 593 typedef struct
 594     {
 595     char                *objname;       /* object name */
 596     ObjectPtr           objptr;         /* the object */
 597     } ObjectHandleDef, *ObjectHandleDefPtr;
 598
 599 /*
 600  * A dynamic handle element list, extensible by malloc'ing more space.
 601  */
 602 typedef struct
 603     {
 604     int                 cnt;            /* # entries in use */
 605     int                 max;            /* max # entries available */
 606     int                 ordered;        /* TRUE if list is lexicographically
 607                                            ordered by object name */
 608     ObjectHandleDefPtr  hvec;           /* vector of handle entries */
 609     } DynamicHandleListDef, *DynamicHandleListDefPtr;
 610
 611
 612 \f
 613 /*
 614  * Global declarations
 615  */
 616
 617 /*
 618  * Defined in wml.c
 619  */
 620 extern int              wml_err_count;          /* total errors */
 621 extern int              wml_line_count;         /* lines read from input */
 622 extern DynamicHandleListDefPtr
 623                         wml_synobj_ptr;         /* syntactic object list */
 624
 625 extern DynamicHandleListDefPtr  wml_obj_datatype_ptr;
 626 extern DynamicHandleListDefPtr  wml_obj_enumval_ptr;
 627 extern DynamicHandleListDefPtr  wml_obj_enumset_ptr;
 628 extern DynamicHandleListDefPtr  wml_obj_reason_ptr;
 629 extern DynamicHandleListDefPtr  wml_obj_arg_ptr;
 630 extern DynamicHandleListDefPtr  wml_obj_child_ptr;
 631 extern DynamicHandleListDefPtr  wml_obj_allclass_ptr;
 632 extern DynamicHandleListDefPtr  wml_obj_class_ptr;
 633 extern DynamicHandleListDefPtr  wml_obj_ctrlist_ptr;
 634 extern DynamicHandleListDefPtr  wml_obj_charset_ptr;
 635
 636 extern DynamicHandleListDefPtr  wml_tok_sens_ptr;
 637 extern DynamicHandleListDefPtr  wml_tok_insens_ptr;
 638
 639
 640
 641
 642 /*
 643  * Defined in wmlutils.c
 644  */
 645 extern char *wmlAllocateString ();              /* dynamic string copy */
 646 extern void wmlUpperCaseString ();              /* convert to upper case */
 647 extern void wmlInitHList ();                    /* init dynamic list */
 648 extern void wmlResizeHList ();                  /* resize a list */
 649 extern void wmlClearHList ();                   /* clear a list for reuse */
 650 extern int wmlFindInHList ();                   /* find name in list */
 651 extern void wmlInsertInHList ();                /* generic list insert */
 652 extern void wmlInsertInKeyList ();              /* specialized list insert */
 653 extern WmlClassResDefPtr wmlResolveResIsMember ();
 654                                                 /* is resource in class? */
 655 extern WmlClassChildDefPtr wmlResolveChildIsMember ();
 656                                                 /* is child in class? */
 657
 658 /*
 659  * Defined in wmlsynbld.c
 660  */
 661 extern char             yystringval[];          /* any string value */
 662 extern char             yynameval[];            /* any name (identifier) */
 663 extern int              yytknval1;              /* terminal token value 1 */
 664 extern int              yytknval2;              /* terminal token value 2 */
 665 extern ObjectPtr        wml_cur_obj;            /* object being constructed */
 666 extern ObjectPtr        wml_cur_subobj;         /* current subobject */
 667 extern void wmlCreateClass ();
 668 extern void wmlAddClassAttribute ();
 669 extern void wmlAddClassResource ();
 670 extern void wmlAddClassResourceAttribute ();
 671 extern void wmlAddClassControl ();
 672 extern void wmlAddCtrList ();
 673 extern void wmlCreateResource ();
 674 extern void wmlCreateDatatype ();
 675 extern void wmlAddResourceAttribute ();
 676 extern void wmlAddDatatypeAttribute ();
 677 extern void wmlAddCtrListControl ();
 678 extern void wmlCreateEnumSet ();
 679 extern void wmlAddEnumSetValue ();
 680 extern void wmlCreateEnumValue ();
 681 extern void wmlAddEnumValueAttribute ();
 682 extern void wmlCreateCharset ();
 683 extern void wmlAddCharsetAttribute ();
 684 extern void LexIssueError ();
 685
 686
 687 /*
 688  * Defined in wmlresolve.c
 689  */
 690 extern void wmlResolveDescriptors ();
 691 extern void wmlMarkReferencePointers ();
 692
 693
 694 /*
 695  * Defined in wmlouth.c
 696  */
 697 extern void wmlOutputHFiles ();
 698
 699
 700 /*
 701  * Defined in wmloutdat.c
 702  */
 703 extern void wmlOutputDatFiles ();
 704
 705 /*
 706  * Define in wmloutp1 or wmloutp2
 707  */
 708 extern void wmlOutput ();