1965 lines
49 KiB
C
1965 lines
49 KiB
C
/*
|
||
* CDE - Common Desktop Environment
|
||
*
|
||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||
*
|
||
* These libraries and programs are free software; you can
|
||
* redistribute them and/or modify them under the terms of the GNU
|
||
* Lesser General Public License as published by the Free Software
|
||
* Foundation; either version 2 of the License, or (at your option)
|
||
* any later version.
|
||
*
|
||
* These libraries and programs are distributed in the hope that
|
||
* they will be useful, but WITHOUT ANY WARRANTY; without even the
|
||
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||
* PURPOSE. See the GNU Lesser General Public License for more
|
||
* details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with these librararies and programs; if not, write
|
||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||
* Floor, Boston, MA 02110-1301 USA
|
||
*/
|
||
/*
|
||
* @OSF_COPYRIGHT@
|
||
* COPYRIGHT NOTICE
|
||
* Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
|
||
* ALL RIGHTS RESERVED (MOTIF). See the file named COPYRIGHT.MOTIF for
|
||
* the full copyright text.
|
||
*/
|
||
/*
|
||
* HISTORY
|
||
*/
|
||
#ifdef REV_INFO
|
||
#ifndef lint
|
||
static char rcsid[] = "$XConsortium: wmlouth.c /main/8 1995/08/29 11:10:46 drk $"
|
||
#endif
|
||
#endif
|
||
/*
|
||
* (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */
|
||
|
||
/*
|
||
* This module contains routines responsible for writing the .h files
|
||
* produced by WML. All files are written into the current directory.
|
||
*
|
||
* Input:
|
||
* The resolved objects
|
||
*
|
||
* Output:
|
||
* UilSymGen.h
|
||
* UilSymArTy.h
|
||
* UilSymChCl.h
|
||
* UilSymRArg.h
|
||
* UilUrmClas.h
|
||
* UilConst.h
|
||
* UilSymReas.h
|
||
* UilSymArTa.h
|
||
* UilSymChTa.h
|
||
* UilSymCtl.h
|
||
* UilSymNam.h
|
||
* UilSymEnum.h
|
||
* UilSymCSet.h
|
||
*/
|
||
|
||
|
||
#include "wml.h"
|
||
|
||
#if defined(__STDC__)
|
||
#include <string.h>
|
||
#endif
|
||
#include <stdio.h>
|
||
|
||
|
||
/*
|
||
* Routines used only in this module
|
||
*/
|
||
void wmlOutputUilSymGen ();
|
||
void wmlOutputUilSymArTy ();
|
||
void wmlOutputUilSymChCl ();
|
||
void wmlOutputUilSymRArg ();
|
||
void wmlOutputUilUrmClas ();
|
||
void wmlOutputUilConst ();
|
||
void wmlOutputUilSymReas ();
|
||
void wmlOutputUilSymArTa ();
|
||
void wmlOutputUilSymChTa ();
|
||
void wmlOutputUilSymCtl ();
|
||
void wmlOutputUilSymNam ();
|
||
void wmlOutputUilSymEnum ();
|
||
void wmlOutputUilSymCSet ();
|
||
|
||
/*
|
||
* globals
|
||
*/
|
||
|
||
static char *canned_warn =
|
||
"/*\n\
|
||
**\tThis file is automatically generated. Do not edit it by hand.\n\
|
||
**/\n";
|
||
|
||
/*
|
||
* Used to create masks for bytes in bit vectors. Accessed by bit numbers
|
||
* from 1 - 8.
|
||
*/
|
||
static char *bit_masks[] = {""
|
||
," | 1" /* bit 1 */
|
||
," | 2" /* bit 2 */
|
||
," | 4" /* bit 3 */
|
||
," | 8" /* bit 4 */
|
||
," | 16" /* bit 5 */
|
||
," | 32" /* bit 6 */
|
||
," | 64" /* bit 7 */
|
||
," | 128"}; /* bit 8 */
|
||
|
||
/*
|
||
* To pick up maximum code values
|
||
*/
|
||
static int max_object_code = 0;
|
||
static int max_reason_code = 0;
|
||
static int max_arg_code = 0;
|
||
static int max_enumset_code = 0;
|
||
static int max_enumval_code = 0;
|
||
static int max_charset_code = 0;
|
||
static int max_child_code = 0;
|
||
|
||
|
||
|
||
/*
|
||
* Output control routine, which simply outputs each .h file in turn.
|
||
*/
|
||
|
||
void wmlOutputHFiles ()
|
||
|
||
{
|
||
|
||
wmlOutputUilSymGen ();
|
||
wmlOutputUilSymArTy ();
|
||
wmlOutputUilSymChCl ();
|
||
wmlOutputUilSymRArg ();
|
||
wmlOutputUilUrmClas ();
|
||
wmlOutputUilConst ();
|
||
wmlOutputUilSymReas ();
|
||
wmlOutputUilSymArTa ();
|
||
wmlOutputUilSymChTa ();
|
||
wmlOutputUilSymCtl ();
|
||
wmlOutputUilSymNam ();
|
||
wmlOutputUilSymEnum ();
|
||
wmlOutputUilSymCSet ();
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymGen.h
|
||
*
|
||
* This file defines the sym_k... literals for UIL. Each set of literals
|
||
* typiclly increases monotonically from 1, with 0 used as en error value.
|
||
*
|
||
* sym_k_<class>_object
|
||
* <class> is widget class name in lexicographic order
|
||
* gadgets are not include.
|
||
*
|
||
* bit masks for table access
|
||
*
|
||
* sym_k_<reason>_reason
|
||
* literals specifying all reasons, lexicographically ordered
|
||
*
|
||
* sym_k_<argument>_arg
|
||
* literals for all arguments, lexicographically ordered.
|
||
* Constraints are included, and ordered with the arguments.
|
||
*
|
||
* sym_k_<child>_child
|
||
* literals for all automatic children, lexicographically ordered.
|
||
*
|
||
* sym_k_<enumset>_enumset
|
||
* literals naming each enumeration set, lexicographically ordered
|
||
*
|
||
* Fixed literals naming character set character sizes
|
||
* sym_k_<charset>_charset
|
||
* literals naming each character set, lexicographically ordered
|
||
*/
|
||
|
||
void wmlOutputUilSymGen ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"\n/* Define literals for objects */\n";
|
||
|
||
|
||
char *canned3 =
|
||
"\n/* Define literals for reasons */\n\n";
|
||
|
||
|
||
char *canned4 =
|
||
"\n/* Define literals for arguments */\n\n";
|
||
|
||
char *canned5 =
|
||
"\n/* Define literals for enumeration sets */\n\n";
|
||
|
||
char *canned6 =
|
||
"\n/* Define literals for enumeration values */\n\n";
|
||
|
||
char *canned7 =
|
||
"\n/* Define literals for character sets */\n\n";
|
||
|
||
char *canned8 =
|
||
"\n/* Define literals for automatic children */\n\n";
|
||
|
||
FILE *outfil; /* output file */
|
||
int ndx; /* loop index */
|
||
WmlClassDefPtr clsobj; /* class object */
|
||
WmlDataTypeDefPtr datobj; /* data type object */
|
||
WmlResourceDefPtr resobj; /* resource object */
|
||
WmlEnumSetDefPtr enumsetobj; /* enumeration set object */
|
||
WmlEnumValueDefPtr enumvalobj; /* enumeration value object */
|
||
WmlCharSetDefPtr charsetobj; /* character set object */
|
||
WmlChildDefPtr childobj; /* child object */
|
||
|
||
/*
|
||
* Open the output file. Write the canned header stuff
|
||
*/
|
||
outfil = fopen ("UilSymGen.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymGen.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
|
||
/*
|
||
* Write the sym_k..._object literals
|
||
*/
|
||
fprintf (outfil, canned1);
|
||
for ( ndx=0 ; ndx<wml_obj_class_ptr->cnt ; ndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, "#define sym_k_%s_object\t%d\n",
|
||
clsobj->tkname,
|
||
clsobj->sym_code);
|
||
if ( clsobj->sym_code > max_object_code )
|
||
max_object_code = clsobj->sym_code;
|
||
}
|
||
|
||
/*
|
||
* Define the sym_k_..._reason literals
|
||
*/
|
||
fprintf (outfil, canned3);
|
||
for ( ndx=0 ; ndx<wml_obj_reason_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_reason_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, "#define sym_k_%s_reason\t%d\n",
|
||
resobj->tkname,
|
||
resobj->sym_code);
|
||
if ( resobj->sym_code > max_reason_code )
|
||
max_reason_code = resobj->sym_code;
|
||
}
|
||
|
||
/*
|
||
* Define the sym_k_..._arg literals
|
||
*/
|
||
fprintf (outfil, canned4);
|
||
for ( ndx=0 ; ndx<wml_obj_arg_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, "#define sym_k_%s_arg\t%d\n",
|
||
resobj->tkname,
|
||
resobj->sym_code);
|
||
if ( resobj->sym_code > max_arg_code )
|
||
max_arg_code = resobj->sym_code;
|
||
}
|
||
|
||
/*
|
||
* Define the sym_k_..._enumset structs and literals
|
||
*/
|
||
fprintf (outfil, canned5);
|
||
for ( ndx=0 ; ndx<wml_obj_enumset_ptr->cnt ; ndx++ )
|
||
{
|
||
enumsetobj = (WmlEnumSetDefPtr) wml_obj_enumset_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, "#define sym_k_%s_enumset\t%d\n",
|
||
enumsetobj->tkname,
|
||
enumsetobj->sym_code);
|
||
if ( enumsetobj->sym_code > max_enumset_code )
|
||
max_enumset_code = enumsetobj->sym_code;
|
||
}
|
||
|
||
/*
|
||
* Define the sym_k_..._enumval literals
|
||
*/
|
||
fprintf (outfil, canned6);
|
||
for ( ndx=0 ; ndx<wml_obj_enumval_ptr->cnt ; ndx++ )
|
||
{
|
||
enumvalobj = (WmlEnumValueDefPtr) wml_obj_enumval_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, "#define sym_k_%s_enumval\t%d\n",
|
||
enumvalobj->syndef->name,
|
||
enumvalobj->sym_code);
|
||
if ( enumvalobj->sym_code > max_enumval_code )
|
||
max_enumval_code = enumvalobj->sym_code;
|
||
}
|
||
|
||
/*
|
||
* Define the sym_k_..._charsize literals
|
||
* Define the sym_k_..._charset literals
|
||
*/
|
||
fprintf (outfil, canned7);
|
||
for ( ndx=0 ; ndx<wml_obj_charset_ptr->cnt ; ndx++ )
|
||
{
|
||
charsetobj = (WmlCharSetDefPtr) wml_obj_charset_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, "#define sym_k_%s_charset\t%d\n",
|
||
charsetobj->syndef->name,
|
||
charsetobj->sym_code);
|
||
if ( charsetobj->sym_code > max_charset_code )
|
||
max_charset_code = charsetobj->sym_code;
|
||
}
|
||
|
||
/*
|
||
* Define the sym_k_..._child literals
|
||
*/
|
||
fprintf (outfil, canned8);
|
||
for ( ndx=0 ; ndx<wml_obj_child_ptr->cnt ; ndx++ )
|
||
{
|
||
childobj = (WmlChildDefPtr) wml_obj_child_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, "#define sym_k_%s_child\t%d\n",
|
||
childobj->syndef->name,
|
||
childobj->sym_code);
|
||
if ( childobj->sym_code > max_child_code )
|
||
max_child_code = childobj->sym_code;
|
||
}
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymGen.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymChCl.h
|
||
*
|
||
* A table of classes accessed by child type (sym_k_<child>_child, in
|
||
* the form
|
||
* ...
|
||
* sym_k_<class>_class,
|
||
*/
|
||
|
||
void wmlOutputUilSymChCl ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"/* Table of the class type of children\n\
|
||
The table is indexed by child with each entry the\n\
|
||
permitted class for that child.\n\
|
||
*/\n\
|
||
\n\
|
||
static unsigned char child_class_table_vec[] =\n\
|
||
{\n\
|
||
0,\n";
|
||
|
||
char *canned1a =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) unsigned char *child_class_table =\n\
|
||
\t child_class_table_vec;\n";
|
||
|
||
FILE *outfil; /* output file */
|
||
int ndx; /* loop index */
|
||
WmlClassDefPtr classobj; /* data type object */
|
||
WmlChildDefPtr childobj; /* resource object */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilSymChCl.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymChCL.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
|
||
/*
|
||
* Create table entries, similar to writing sym_k...
|
||
*/
|
||
fprintf (outfil, canned1);
|
||
for ( ndx=0 ; ndx<wml_obj_child_ptr->cnt ; ndx++ )
|
||
{
|
||
childobj = (WmlChildDefPtr) wml_obj_child_ptr->hvec[ndx].objptr;
|
||
classobj = childobj->class;
|
||
fprintf (outfil, " sym_k_%s_object,\n",
|
||
classobj->tkname);
|
||
}
|
||
fprintf (outfil, canned1a);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymChCl.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymArTy.h
|
||
*
|
||
* A table of data types accessed by argument type (sym_k_<arg>_arg, in
|
||
* the form
|
||
* ...
|
||
* sym_k_<data_type>_value,
|
||
*/
|
||
|
||
void wmlOutputUilSymArTy ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"/* Table of the types of arguments\n\
|
||
The table is indexed by argument with each entry the\n\
|
||
permitted type for that argument.\n\
|
||
*/\n\
|
||
\n\
|
||
static unsigned char argument_type_table_vec[] =\n\
|
||
{\n\
|
||
0,\n";
|
||
|
||
char *canned1a =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) unsigned char *argument_type_table =\n\
|
||
\t argument_type_table_vec;\n";
|
||
|
||
FILE *outfil; /* output file */
|
||
int ndx; /* loop index */
|
||
WmlDataTypeDefPtr datobj; /* data type object */
|
||
WmlResourceDefPtr resobj; /* resource object */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilSymArTy.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymArTy.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
|
||
/*
|
||
* Create table entries, similar to writing sym_k...
|
||
*/
|
||
fprintf (outfil, canned1);
|
||
for ( ndx=0 ; ndx<wml_obj_arg_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[ndx].objptr;
|
||
datobj = resobj->dtype_def;
|
||
fprintf (outfil, " sym_k_%s_value,\n",
|
||
datobj->tkname);
|
||
}
|
||
fprintf (outfil, canned1a);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymArTy.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymRArg.h
|
||
*
|
||
* Related argument table
|
||
*/
|
||
|
||
void wmlOutputUilSymRArg ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"/* Related argument table. Each non-zero entry is the code\n\
|
||
of the related argument.\n\
|
||
*/\n\
|
||
\n\
|
||
static unsigned short int related_argument_table_vec[] =\n\
|
||
{\n\
|
||
0,\n";
|
||
|
||
char *canned1a =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) unsigned short int *related_argument_table =\n\
|
||
\t\trelated_argument_table_vec;\n";
|
||
|
||
FILE *outfil; /* output file */
|
||
int ndx; /* loop index */
|
||
WmlResourceDefPtr resobj; /* resource object */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilSymRArg.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymRArg.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
|
||
/*
|
||
* Create table entries, similar to writing sym_k...
|
||
*/
|
||
fprintf (outfil, canned1);
|
||
for ( ndx=0 ; ndx<wml_obj_arg_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, " %d,\n",
|
||
resobj->related_code);
|
||
}
|
||
fprintf (outfil, canned1a);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymRArg.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilUrmClas.h
|
||
*
|
||
* Table of convenience function names indexed by the sym_k_<class> literal
|
||
* for both widgets and gadgets
|
||
* Table of resource names indexed by the sym_k_<argument>_arg and
|
||
* sym_k_<reason>_reason codes.
|
||
*/
|
||
|
||
void wmlOutputUilUrmClas ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"\n/* Define mapping of UIL widget types to convenience functions. */\n\
|
||
static char *uil_widget_funcs_vec[] = {\n\
|
||
\"\",\t /* NOT USED */\n";
|
||
|
||
char *canned2 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **uil_widget_funcs = uil_widget_funcs_vec;\n\
|
||
\n\
|
||
/* Define mapping of UIL widget classes to matching gadget class. */\n\
|
||
static unsigned short int uil_gadget_variants_vec[] = {\n\
|
||
0,\t /* NOT USED */\n";
|
||
|
||
char *canned3 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) unsigned short int *uil_gadget_variants =\n\
|
||
\t\tuil_gadget_variants_vec;\n\
|
||
\n\
|
||
/* Define mapping of dialog types to non-dialog URM widget classes. */\n\
|
||
static unsigned short int uil_urm_nondialog_class_vec[] = {\n\
|
||
0,\t/* NOT USED */\n";
|
||
|
||
char *canned4 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) unsigned short int *uil_urm_nondialog_class =\n\
|
||
\t\tuil_urm_nondialog_class_vec;\n\
|
||
\n\
|
||
/* Define mapping of widget controls to a (subtree) resource. */\n\
|
||
static unsigned short int uil_urm_subtree_resource_vec[] = {\n\
|
||
0,\t/* NOT USED */\n";
|
||
|
||
char *canned5 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) unsigned short int *uil_urm_subtree_resource =\n\
|
||
\t\tuil_urm_subtree_resource_vec;\n\
|
||
\n\
|
||
/* Define mapping of arguments to toolkit names. */\n\
|
||
static char *uil_argument_toolkit_names_vec[] = {\n\
|
||
\"\",\t /* NOT USED */\n";
|
||
|
||
char *canned6 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **uil_argument_toolkit_names =\n\
|
||
\t\tuil_argument_toolkit_names_vec;\n\
|
||
\n\
|
||
/* Define mapping of reasons to toolkit names. */\n\
|
||
static char *uil_reason_toolkit_names_vec[] = {\n\
|
||
\"\",\t/* NOT USED */\n";
|
||
|
||
char *canned7 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **uil_reason_toolkit_names =\n\
|
||
\t\tuil_reason_toolkit_names_vec;\n";
|
||
|
||
|
||
|
||
FILE *outfil; /* output file */
|
||
int ndx; /* loop index */
|
||
WmlClassDefPtr clsobj; /* class object */
|
||
WmlSynClassDefPtr synobj; /* syntactic object */
|
||
WmlClassDefPtr varobj; /* variant (widget) class object */
|
||
WmlResourceDefPtr resobj; /* argument/reason object */
|
||
WmlSynResourceDefPtr synres; /* arg/reason syntactic object */
|
||
WmlResourceDefPtr mapresobj; /* controls map to resource object */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilUrmClas.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilUrmClas.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
|
||
/*
|
||
* Write entries for widgets
|
||
*/
|
||
fprintf (outfil, canned1);
|
||
for ( ndx=0 ; ndx<wml_obj_class_ptr->cnt ; ndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[ndx].objptr;
|
||
if ( clsobj->sym_code == 0 ) continue;
|
||
synobj = clsobj->syndef;
|
||
if ( synobj->int_lit != NULL )
|
||
fprintf (outfil, " \"%s\",\n", synobj->convfunc);
|
||
else
|
||
fprintf (outfil, " \"%s\",\t\n", synobj->convfunc);
|
||
}
|
||
fprintf (outfil, canned2);
|
||
|
||
/*
|
||
* Write entries for gadget variants of widget classes
|
||
*/
|
||
for ( ndx=0 ; ndx<wml_obj_class_ptr->cnt ; ndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[ndx].objptr;
|
||
if ( clsobj->sym_code == 0 ) continue;
|
||
varobj = clsobj->variant;
|
||
synobj = clsobj->syndef;
|
||
if ( varobj==NULL || synobj->type==WmlClassTypeGadget )
|
||
fprintf (outfil, " 0,\n");
|
||
else
|
||
{
|
||
synobj = varobj->syndef;
|
||
if ( synobj->int_lit != NULL )
|
||
fprintf (outfil, " sym_k_%s_object,\n",
|
||
synobj->int_lit);
|
||
else
|
||
fprintf (outfil, " sym_k_%s_object,\n",
|
||
synobj->name);
|
||
}
|
||
}
|
||
fprintf (outfil, canned3);
|
||
|
||
/*
|
||
* Write entries for non-dialog widgets
|
||
*/
|
||
for ( ndx=0 ; ndx<wml_obj_class_ptr->cnt ; ndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[ndx].objptr;
|
||
if ( clsobj->sym_code == 0 ) continue;
|
||
varobj = clsobj->nondialog;
|
||
synobj = clsobj->syndef;
|
||
if ( varobj == NULL )
|
||
fprintf (outfil, " 0,\n");
|
||
else
|
||
{
|
||
synobj = varobj->syndef;
|
||
if ( synobj->int_lit != NULL )
|
||
fprintf (outfil, " sym_k_%s_object,\n",
|
||
synobj->int_lit);
|
||
else
|
||
fprintf (outfil, " sym_k_%s_object,\n",
|
||
synobj->name);
|
||
}
|
||
}
|
||
fprintf (outfil, canned4);
|
||
|
||
/*
|
||
* Write entries for the resource a widget's controls map to
|
||
*/
|
||
for ( ndx=0 ; ndx<wml_obj_class_ptr->cnt ; ndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[ndx].objptr;
|
||
if ( clsobj->sym_code == 0 ) continue;
|
||
synobj = clsobj->syndef;
|
||
mapresobj = clsobj->ctrlmapto;
|
||
if ( mapresobj == NULL )
|
||
fprintf (outfil, " 0,\n");
|
||
else
|
||
fprintf (outfil, " sym_k_%s_arg,\n", mapresobj->tkname);
|
||
}
|
||
fprintf (outfil, canned5);
|
||
|
||
/*
|
||
* Write entries for arguments
|
||
*/
|
||
for ( ndx=0 ; ndx<wml_obj_arg_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[ndx].objptr;
|
||
synres = resobj->syndef;
|
||
if ( resobj->sym_code == 0 ) continue;
|
||
fprintf (outfil, " %s,\n",
|
||
synres->resliteral);
|
||
}
|
||
fprintf (outfil, canned6);
|
||
|
||
/*
|
||
* Write entries for reasons
|
||
*/
|
||
for ( ndx=0 ; ndx<wml_obj_reason_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_reason_ptr->hvec[ndx].objptr;
|
||
synres = resobj->syndef;
|
||
if ( resobj->sym_code == 0 ) continue;
|
||
fprintf (outfil, " %s,\n",
|
||
synres->resliteral);
|
||
}
|
||
fprintf (outfil, canned7);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilUrmClas.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilConst.h
|
||
*
|
||
* A bit vector showing which arguments are constraints.
|
||
*/
|
||
|
||
void wmlOutputUilConst ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"/* Table indexed by argument indicating whether\n\
|
||
argument is a constraint (TRUE) or a regular\n\
|
||
argument (FALSE). Each entry is one bit.\n\
|
||
Index and mask macros are defined to simplify\n\
|
||
access to the table\n\
|
||
*/\n\
|
||
\n\
|
||
static unsigned char constraint_tab_vec[] = {\n";
|
||
|
||
char *canned1a =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) unsigned char *constraint_tab =\n\
|
||
\t\tconstraint_tab_vec;\n";
|
||
|
||
|
||
FILE *outfil; /* output file */
|
||
int ndx; /* loop index */
|
||
WmlResourceDefPtr resobj; /* resource object */
|
||
WmlSynResourceDefPtr synobj; /* syntactic object */
|
||
char maskbuf[100]; /* to constuct each mask */
|
||
int bitno; /* current bit number, from code */
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilConst.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilConst.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
|
||
/*
|
||
* Process the arguments in code order. We start with 1, and write out
|
||
* the mask after processing 8 codes.
|
||
*/
|
||
fprintf (outfil, canned1);
|
||
strcpy (maskbuf, "0");
|
||
for ( ndx=0 ; ndx<wml_obj_arg_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[ndx].objptr;
|
||
synobj = resobj->syndef;
|
||
bitno = resobj->sym_code % 8;
|
||
if ( bitno == 0 ) bitno = 8;
|
||
if ( synobj->type == WmlResourceTypeConstraint )
|
||
strcat (maskbuf, bit_masks[bitno]);
|
||
if ( bitno == 8 )
|
||
{
|
||
fprintf (outfil, "%s,\n", maskbuf);
|
||
strcpy (maskbuf, "0");
|
||
}
|
||
}
|
||
if ( bitno != 8 )
|
||
fprintf (outfil, "%s", maskbuf);
|
||
fprintf (outfil, canned1a);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilConst.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymReas.h
|
||
*
|
||
* This file defines the reasons supported by each class. For each
|
||
* reason, there is a bit vector with the bit for each supporting class
|
||
* turned on if the reason is supported. There is then a vector pointing
|
||
* to these bit vectors for all reasons. This vector is accessed by
|
||
* sym_k_..._reason to find the reasons bit vector, then by sym_k_..._object
|
||
* to check the bit.
|
||
*/
|
||
|
||
void wmlOutputUilSymReas ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"\n/*\n\
|
||
* Bit vectors for each reason. The entries in the vector correspond\n\
|
||
* to each class.\n\
|
||
*/\n";
|
||
|
||
char *bvechdr =
|
||
"\n\
|
||
/* sym_k_%s_reason */\n\
|
||
static unsigned char reason_class_vec%d[] =\n\
|
||
{\n";
|
||
|
||
char *canned2 =
|
||
"\n/*\n\
|
||
* Table of bit vectors accessed by sym_k_..._reason\n\
|
||
*/\n\
|
||
static unsigned char *allowed_reason_table_vec[] =\n\
|
||
{\n\
|
||
NULL,\t/* UNUSED */\n";
|
||
|
||
char *canned3 =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) unsigned char **allowed_reason_table =\n\
|
||
\t\tallowed_reason_table_vec;\n";
|
||
|
||
FILE *outfil; /* output file */
|
||
int resndx; /* outer loop index */
|
||
WmlResourceDefPtr resobj; /* current reason */
|
||
int clsndx; /* inner loop index */
|
||
WmlClassDefPtr clsobj; /* current class object */
|
||
WmlClassResDefPtr resref; /* class' resource reference */
|
||
int itemno; /* item in bye */
|
||
char maskbuf[500]; /* current mask buffer */
|
||
char itembuf[100]; /* for current item */
|
||
int donl; /* TRUE if append \n to mask */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilSymReas.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymReas.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
fprintf (outfil, canned1);
|
||
|
||
/*
|
||
* Generate the bit vectors for each class. Outer loop on the reason code,
|
||
* inner loop on the class code.
|
||
*/
|
||
for ( resndx=0 ; resndx<wml_obj_reason_ptr->cnt ; resndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_reason_ptr->hvec[resndx].objptr;
|
||
fprintf (outfil, bvechdr, resobj->tkname, resobj->sym_code);
|
||
|
||
/*
|
||
* inner loop on widget class.
|
||
*/
|
||
strcpy (maskbuf, " ");
|
||
for ( clsndx=0 ; clsndx<wml_obj_class_ptr->cnt ; clsndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[clsndx].objptr;
|
||
itemno = (clsobj->sym_code+1) % 8;
|
||
donl = FALSE;
|
||
resref = wmlResolveResIsMember (resobj, clsobj->reasons);
|
||
if ( resref != NULL )
|
||
if ( resref->exclude != WmlAttributeTrue )
|
||
{
|
||
sprintf (itembuf, " _BIT_MASK(sym_k_%s_object) |",
|
||
clsobj->tkname);
|
||
strcat (maskbuf, itembuf);
|
||
donl = TRUE;
|
||
}
|
||
if ( donl )
|
||
strcat (maskbuf, "\n ");
|
||
if ( itemno == 0 )
|
||
{
|
||
fprintf (outfil, "%s 0", maskbuf);
|
||
strcpy (maskbuf, ",");
|
||
}
|
||
}
|
||
if ( itemno != 0 )
|
||
fprintf (outfil, "%s 0};\n", maskbuf);
|
||
else
|
||
fprintf (outfil, "};\n");
|
||
}
|
||
|
||
/*
|
||
* Write the vector of vectors.
|
||
*/
|
||
fprintf (outfil, canned2);
|
||
for ( resndx=0 ; resndx<wml_obj_reason_ptr->cnt ; resndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_reason_ptr->hvec[resndx].objptr;
|
||
fprintf (outfil, " reason_class_vec%d,\n", resobj->sym_code);
|
||
}
|
||
fprintf (outfil, canned3);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymReas.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymArTa.h
|
||
*
|
||
* This file defines the arguments supported by each class. For each
|
||
* argument, there is a bit vector with the bit for each supporting class
|
||
* turned on if the argument is supported. There is then a vector pointing
|
||
* to these bit vectors for all arguments. This vector is accessed by
|
||
* sym_k_..._arg to find the arguments bit vector, then by sym_k_..._object
|
||
* to check the bit.
|
||
*/
|
||
|
||
void wmlOutputUilSymArTa ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"\n/*\n\
|
||
* Bit vectors for each argument. The entries in the vector correspond\n\
|
||
* to each class.\n\
|
||
*/\n";
|
||
|
||
char *bvechdr =
|
||
"\n\
|
||
/* sym_k_%s_arg */\n\
|
||
static unsigned char arg_class_vec%d[] =\n\
|
||
{\n";
|
||
|
||
char *canned2 =
|
||
"\n/*\n\
|
||
* Table of bit vectors accessed by sym_k_..._arg\n\
|
||
*/\n\
|
||
static unsigned char *allowed_argument_table_vec[] =\n\
|
||
{\n\
|
||
NULL,\t/* UNUSED */\n";
|
||
|
||
char *canned3 =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) unsigned char **allowed_argument_table =\n\
|
||
\t\tallowed_argument_table_vec;\n";
|
||
|
||
FILE *outfil; /* output file */
|
||
int resndx; /* outer loop index */
|
||
WmlResourceDefPtr resobj; /* current argument */
|
||
int clsndx; /* inner loop index */
|
||
WmlClassDefPtr clsobj; /* current class object */
|
||
WmlClassResDefPtr resref; /* class' resource reference */
|
||
int itemno; /* item in bye */
|
||
char maskbuf[500]; /* current mask buffer */
|
||
char itembuf[100]; /* for current item */
|
||
int donl; /* TRUE if append \n to mask */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilSymArTa.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymArTa.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
fprintf (outfil, canned1);
|
||
|
||
/*
|
||
* Generate the bit vectors for each class. Outer loop on the argument code,
|
||
* inner loop on the class code.
|
||
*/
|
||
for ( resndx=0 ; resndx<wml_obj_arg_ptr->cnt ; resndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[resndx].objptr;
|
||
fprintf (outfil, bvechdr, resobj->tkname, resobj->sym_code);
|
||
|
||
/*
|
||
* inner loop on widget class.
|
||
*/
|
||
strcpy (maskbuf, " ");
|
||
for ( clsndx=0 ; clsndx<wml_obj_class_ptr->cnt ; clsndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[clsndx].objptr;
|
||
itemno = (clsobj->sym_code+1) % 8;
|
||
donl = FALSE;
|
||
resref = wmlResolveResIsMember (resobj, clsobj->arguments);
|
||
if ( resref != NULL )
|
||
if ( resref->exclude != WmlAttributeTrue )
|
||
{
|
||
sprintf (itembuf, " _BIT_MASK(sym_k_%s_object) |",
|
||
clsobj->tkname);
|
||
strcat (maskbuf, itembuf);
|
||
donl = TRUE;
|
||
}
|
||
if ( donl )
|
||
strcat (maskbuf, "\n ");
|
||
if ( itemno == 0 )
|
||
{
|
||
fprintf (outfil, "%s 0", maskbuf);
|
||
strcpy (maskbuf, ",");
|
||
}
|
||
}
|
||
if ( itemno != 0 )
|
||
fprintf (outfil, "%s 0};\n", maskbuf);
|
||
else
|
||
fprintf (outfil, "};\n");
|
||
}
|
||
|
||
/*
|
||
* Write the vector of vectors.
|
||
*/
|
||
fprintf (outfil, canned2);
|
||
for ( resndx=0 ; resndx<wml_obj_arg_ptr->cnt ; resndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[resndx].objptr;
|
||
fprintf (outfil, " arg_class_vec%d,\n", resobj->sym_code);
|
||
}
|
||
fprintf (outfil, canned3);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymArTa.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymChTa.h
|
||
*
|
||
* This file defines the automatic children supported by each class. For each
|
||
* child, there is a bit vector with the bit for each supporting class
|
||
* turned on if the child is supported. There is then a vector pointing
|
||
* to these bit vectors for all children. This vector is accessed by
|
||
* sym_k_..._child to find the child's bit vector, then by sym_k_..._object
|
||
* to check the bit.
|
||
*/
|
||
|
||
void wmlOutputUilSymChTa ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"\n/*\n\
|
||
* Bit vectors for each child. The entries in the vector correspond\n\
|
||
* to each class.\n\
|
||
*/\n";
|
||
|
||
char *bvechdr =
|
||
"\n\
|
||
/* sym_k_%s_child */\n\
|
||
static unsigned char child_class_vec%d[] =\n\
|
||
{\n";
|
||
|
||
char *canned2 =
|
||
"\n/*\n\
|
||
* Table of bit vectors accessed by sym_k_..._child\n\
|
||
*/\n\
|
||
static unsigned char *allowed_child_table_vec[] =\n\
|
||
{\n\
|
||
NULL,\t/* UNUSED */\n";
|
||
|
||
char *canned3 =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) unsigned char **allowed_child_table =\n\
|
||
\t\tallowed_child_table_vec;\n";
|
||
|
||
FILE *outfil; /* output file */
|
||
int childndx; /* outer loop index */
|
||
WmlChildDefPtr childobj; /* current argument */
|
||
int clsndx; /* inner loop index */
|
||
WmlClassDefPtr clsobj; /* current class object */
|
||
WmlClassChildDefPtr childref; /* class' child reference */
|
||
int itemno; /* item in byte */
|
||
char maskbuf[500]; /* current mask buffer */
|
||
char itembuf[100]; /* for current item */
|
||
int donl; /* TRUE if append \n to mask */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilSymChTa.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymChTa.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
fprintf (outfil, canned1);
|
||
|
||
/*
|
||
* Generate the bit vectors for each class. Outer loop on the child code,
|
||
* inner loop on the class code.
|
||
*/
|
||
for ( childndx=0 ; childndx<wml_obj_child_ptr->cnt ; childndx++ )
|
||
{
|
||
childobj = (WmlChildDefPtr) wml_obj_child_ptr->hvec[childndx].objptr;
|
||
fprintf (outfil, bvechdr, childobj->tkname, childobj->sym_code);
|
||
|
||
/*
|
||
* inner loop on widget class.
|
||
*/
|
||
strcpy (maskbuf, " ");
|
||
for ( clsndx=0 ; clsndx<wml_obj_class_ptr->cnt ; clsndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[clsndx].objptr;
|
||
itemno = (clsobj->sym_code+1) % 8;
|
||
donl = FALSE;
|
||
childref = wmlResolveChildIsMember (childobj, clsobj->children);
|
||
if ( childref != NULL )
|
||
{
|
||
sprintf (itembuf, " _BIT_MASK(sym_k_%s_object) |", clsobj->tkname);
|
||
strcat (maskbuf, itembuf);
|
||
donl = TRUE;
|
||
}
|
||
if ( donl )
|
||
strcat (maskbuf, "\n ");
|
||
if ( itemno == 0 )
|
||
{
|
||
fprintf (outfil, "%s 0", maskbuf);
|
||
strcpy (maskbuf, ",");
|
||
}
|
||
}
|
||
if ( itemno != 0 )
|
||
fprintf (outfil, "%s 0};\n", maskbuf);
|
||
else
|
||
fprintf (outfil, "};\n");
|
||
}
|
||
|
||
/*
|
||
* Write the vector of vectors.
|
||
*/
|
||
fprintf (outfil, canned2);
|
||
for ( childndx=0 ; childndx<wml_obj_child_ptr->cnt ; childndx++ )
|
||
{
|
||
childobj = (WmlChildDefPtr) wml_obj_child_ptr->hvec[childndx].objptr;
|
||
fprintf (outfil, " child_class_vec%d,\n", childobj->sym_code);
|
||
}
|
||
fprintf (outfil, canned3);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymChTa.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymCtl.h
|
||
*
|
||
* This file defines the controls supported by each class. For each
|
||
* object, there is a bit vector with the bit for each supporting class
|
||
* turned on if the object is supported. There is then a vector pointing
|
||
* to these bit vectors for all objects. This vector is accessed by
|
||
* sym_k_..._object to find the objects bit vector, then by sym_k_..._object
|
||
* to check the bit.
|
||
*/
|
||
|
||
void wmlOutputUilSymCtl ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"\n/*\n\
|
||
* Bit vectors for each control. The entries in the vector correspond\n\
|
||
* to each class.\n\
|
||
*/\n";
|
||
|
||
char *bvechdr =
|
||
"\n\
|
||
/* sym_k_%s_object */\n\
|
||
static unsigned char object_class_vec%d[] =\n\
|
||
{\n";
|
||
|
||
char *canned2 =
|
||
"\n/*\n\
|
||
* Table of bit vectors accessed by sym_k_..._object\n\
|
||
*/\n\
|
||
static unsigned char *allowed_control_table_vec[] =\n\
|
||
{\n\
|
||
NULL,\t/* UNUSED */\n";
|
||
|
||
char *canned3 =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) unsigned char **allowed_control_table =\n\
|
||
\t\tallowed_control_table_vec;\n";
|
||
|
||
FILE *outfil; /* output file */
|
||
int ctlndx; /* outer loop index */
|
||
WmlClassDefPtr ctlobj; /* current class allowing controls */
|
||
int clsndx; /* inner loop index */
|
||
WmlClassDefPtr clsobj; /* current class object */
|
||
int itemno; /* item in bye */
|
||
char maskbuf[500]; /* current mask buffer */
|
||
char itembuf[100]; /* for current item */
|
||
int donl; /* TRUE if append \n to mask */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilSymCtl.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymCtl.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
fprintf (outfil, canned1);
|
||
|
||
/*
|
||
* Generate the bit vectors for each class. Outer loop on the class code,
|
||
* inner loop on the class code.
|
||
*/
|
||
for ( ctlndx=0 ; ctlndx<wml_obj_class_ptr->cnt ; ctlndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[ctlndx].objptr;
|
||
fprintf (outfil, bvechdr, clsobj->tkname, clsobj->sym_code);
|
||
|
||
/*
|
||
* inner loop on widget class.
|
||
*/
|
||
strcpy (maskbuf, " ");
|
||
for ( clsndx=0 ; clsndx<wml_obj_class_ptr->cnt ; clsndx++ )
|
||
{
|
||
ctlobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[clsndx].objptr;
|
||
itemno = (ctlobj->sym_code+1) % 8;
|
||
donl = FALSE;
|
||
if ( wmlResolveCtlIsMember(clsobj,ctlobj->controls) == TRUE)
|
||
{
|
||
sprintf (itembuf, " _BIT_MASK(sym_k_%s_object) |",
|
||
ctlobj->tkname);
|
||
strcat (maskbuf, itembuf);
|
||
donl = TRUE;
|
||
}
|
||
if ( donl )
|
||
strcat (maskbuf, "\n ");
|
||
if ( itemno == 0 )
|
||
{
|
||
fprintf (outfil, "%s 0", maskbuf);
|
||
strcpy (maskbuf, ",");
|
||
}
|
||
}
|
||
if ( itemno != 0 )
|
||
fprintf (outfil, "%s 0};\n", maskbuf);
|
||
else
|
||
fprintf (outfil, "};\n");
|
||
}
|
||
|
||
/*
|
||
* Write the vector of vectors.
|
||
*/
|
||
fprintf (outfil, canned2);
|
||
for ( ctlndx=0 ; ctlndx<wml_obj_class_ptr->cnt ; ctlndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[ctlndx].objptr;
|
||
fprintf (outfil, " object_class_vec%d,\n", clsobj->sym_code);
|
||
}
|
||
fprintf (outfil, canned3);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymCtl.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Predicate to indicate if a class object is in a controls list.
|
||
*/
|
||
|
||
int wmlResolveCtlIsMember (ctlobj, ctlref)
|
||
WmlClassDefPtr ctlobj;
|
||
WmlClassCtrlDefPtr ctlref;
|
||
|
||
{
|
||
|
||
while ( ctlref != NULL )
|
||
{
|
||
if ( ctlref->ctrl == ctlobj ) return TRUE;
|
||
ctlref = ctlref->next;
|
||
}
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymNam.h
|
||
*
|
||
* Tables of names of object indexed by their various sym_k_ literals.
|
||
*/
|
||
|
||
void wmlOutputUilSymNam ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"/* Define mapping of sym_k_..._object codes to widget names. */\n\
|
||
\n\
|
||
externaldef(uil_sym_glbl) int uil_max_object = %d;\n\
|
||
static char *uil_widget_names_vec[] = {\n\
|
||
\"\",\t/* NOT USED */\n";
|
||
|
||
char *canned2 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **uil_widget_names =\n\
|
||
\t\tuil_widget_names_vec;\n\
|
||
\n\n\
|
||
/* Define mapping of sym_k_..._arg codes to argument names. */\n\
|
||
\n\
|
||
externaldef(uil_sym_glbl) int uil_max_arg = %d;\n\
|
||
static char *uil_argument_names_vec[] = {\n\
|
||
\"\",\t/* NOT USED */\n";
|
||
|
||
char *canned3 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **uil_argument_names =\n\
|
||
\t\tuil_argument_names_vec;\n\
|
||
\n\n\
|
||
/* Define mapping of sym_k_..._reason to reason names. */\n\
|
||
\n\
|
||
externaldef(uil_sym_glbl) int uil_max_reason = %d;\n\
|
||
static char *uil_reason_names_vec[] = {\n\
|
||
\"\",\t/* NOT USED */\n";
|
||
|
||
char *canned4 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **uil_reason_names =\n\
|
||
\t\tuil_reason_names_vec;\n\
|
||
\n\n\
|
||
/* Define mapping of sym_k_..._enumval to enumeration value names. */\n\
|
||
\n\
|
||
externaldef(uil_sym_glbl) int uil_max_enumset = %d;\n\
|
||
externaldef(uil_sym_glbl) int uil_max_enumval = %d;\n\
|
||
static char *uil_enumval_names_vec[] = {\n\
|
||
\"\",\t/* NOT USED */\n";
|
||
|
||
char *canned5 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **uil_enumval_names =\n\
|
||
\t\tuil_enumval_names_vec;\n\
|
||
\n\n\
|
||
/* Define mapping of sym_k_..._charset to enumeration value names. */\n\
|
||
\n\
|
||
externaldef(uil_sym_glbl) int uil_max_charset = %d;\n\
|
||
static char *uil_charset_names_vec[] = {\n\
|
||
\"\",\t/* NOT USED */\n\
|
||
\"<userdefined>\",\n";
|
||
|
||
char *canned6 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **uil_charset_names =\n\
|
||
\t\tuil_charset_names_vec;\n\
|
||
\n\n\
|
||
/* Define mapping of sym_k_..._child codes to child names. */\n\
|
||
\n\
|
||
externaldef(uil_sym_glbl) int uil_max_child = %d;\n\
|
||
static char *uil_child_names_vec[] = {\n\
|
||
\"\",\t/* NOT USED */\n";
|
||
|
||
char *canned7 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **uil_child_names =\n\
|
||
\t\tuil_child_names_vec;\n";
|
||
|
||
|
||
FILE *outfil; /* output file */
|
||
int ndx; /* loop index */
|
||
WmlClassDefPtr clsobj; /* class object */
|
||
WmlClassDefPtr varobj; /* gadget class object */
|
||
WmlSynClassDefPtr synobj; /* syntactic object */
|
||
WmlResourceDefPtr resobj; /* argument/reason object */
|
||
WmlSynResourceDefPtr synres; /* arg/reason syntactic object */
|
||
WmlEnumValueDefPtr evobj; /* enumeration value object */
|
||
WmlSynEnumValueDefPtr synev; /* enumeration value syntactic obj */
|
||
WmlCharSetDefPtr csobj; /* character set object */
|
||
WmlSynCharSetDefPtr syncs; /* character set syntactic obj */
|
||
WmlChildDefPtr chobj; /* child object */
|
||
WmlSynChildDefPtr synch; /* child syntactic object */
|
||
|
||
/*
|
||
* Open the output file. Write canned header.
|
||
*/
|
||
outfil = fopen ( "UilSymNam.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymNam.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
|
||
/*
|
||
* Write entries for widgets
|
||
*/
|
||
fprintf (outfil, canned1, max_object_code);
|
||
for ( ndx=0 ; ndx<wml_obj_class_ptr->cnt ; ndx++ )
|
||
{
|
||
clsobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[ndx].objptr;
|
||
if ( clsobj->sym_code == 0 ) continue;
|
||
synobj = clsobj->syndef;
|
||
fprintf (outfil, " \"%s\",\n",
|
||
synobj->name);
|
||
}
|
||
|
||
/*
|
||
* Write entries for arguments
|
||
*/
|
||
fprintf (outfil, canned2, max_arg_code);
|
||
for ( ndx=0 ; ndx<wml_obj_arg_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[ndx].objptr;
|
||
synres = resobj->syndef;
|
||
if ( resobj->sym_code == 0 ) continue;
|
||
fprintf (outfil, " \"%s\",\n",
|
||
synres->name);
|
||
}
|
||
|
||
/*
|
||
* Write entries for reasons
|
||
*/
|
||
fprintf (outfil, canned3, max_reason_code);
|
||
for ( ndx=0 ; ndx<wml_obj_reason_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_reason_ptr->hvec[ndx].objptr;
|
||
synres = resobj->syndef;
|
||
if ( resobj->sym_code == 0 ) continue;
|
||
fprintf (outfil, " \"%s\",\n",
|
||
synres->name);
|
||
}
|
||
|
||
/*
|
||
* Write entries for enumeration values
|
||
*/
|
||
fprintf (outfil, canned4, max_enumset_code, max_enumval_code);
|
||
for ( ndx=0 ; ndx<wml_obj_enumval_ptr->cnt ; ndx++ )
|
||
{
|
||
evobj = (WmlEnumValueDefPtr) wml_obj_enumval_ptr->hvec[ndx].objptr;
|
||
synev = evobj->syndef;
|
||
if ( evobj->sym_code == 0 ) continue;
|
||
fprintf (outfil, " \"%s\",\n",
|
||
synev->name);
|
||
}
|
||
|
||
/*
|
||
* Write entries for character sets
|
||
*/
|
||
fprintf (outfil, canned5, max_charset_code);
|
||
for ( ndx=0 ; ndx<wml_obj_charset_ptr->cnt ; ndx++ )
|
||
{
|
||
csobj = (WmlCharSetDefPtr) wml_obj_charset_ptr->hvec[ndx].objptr;
|
||
syncs = csobj->syndef;
|
||
if ( csobj->sym_code == 0 ) continue;
|
||
fprintf (outfil, " \"%s\",\n",
|
||
syncs->name);
|
||
}
|
||
|
||
/*
|
||
* Write entries for children
|
||
*/
|
||
fprintf (outfil, canned6, max_child_code);
|
||
for ( ndx=0 ; ndx<wml_obj_child_ptr->cnt ; ndx++ )
|
||
{
|
||
chobj = (WmlChildDefPtr) wml_obj_child_ptr->hvec[ndx].objptr;
|
||
synch = chobj->syndef;
|
||
if ( chobj->sym_code == 0 ) continue;
|
||
fprintf (outfil, " \"%s\",\n",
|
||
synch->name);
|
||
}
|
||
fprintf (outfil, canned7);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymNam.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymEnum.h
|
||
*
|
||
* This file defines the enumeration sets recognized by UIL. There is an
|
||
* entry in this file for each enumeration set. The definitions are accessed
|
||
* by the sym_k_..._enumset code. Each consists of a structure containing
|
||
* a vector of enumeration value descriptors, each of which is the name
|
||
* of the value and its value.
|
||
*
|
||
* UilSymEnum.h contains:
|
||
* - Vectors of value descriptors for each table entry
|
||
* - The table itself.
|
||
* - A table given the sym_k_..._enumset code for each argument which
|
||
* has an enumeration set.
|
||
* - A table accessed by sym_k_..._enumval code giving the actual value
|
||
* for each enumeration value.
|
||
*
|
||
* The typedefs for the tables are in UilSymGen.h
|
||
*/
|
||
|
||
void wmlOutputUilSymEnum ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"\n\
|
||
/*\n\
|
||
* Enumeration value vectors for each enumeration set\n\
|
||
*/\n\
|
||
\n";
|
||
|
||
char *valhdr =
|
||
"\n\
|
||
static unsigned short int enum_value_vec%d[] =\n\
|
||
{\n";
|
||
|
||
char *canned3 =
|
||
"\n\
|
||
/*\n\
|
||
* Enumeration set descriptor table\n\
|
||
*/\n\
|
||
static UilEnumSetDescDef enum_set_table_vec[] =\n\
|
||
{\n\
|
||
{0,NULL},\n";
|
||
|
||
char *canned4 =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) UilEnumSetDescDef *enum_set_table =\n\
|
||
\t\tenum_set_table_vec;\n\
|
||
/*\n\
|
||
* Enumeration set table, accessed by sym_k_..._arg code. Each non-zero entry\n\
|
||
* is the sym_k_..._enumset code for the argument's enumeration set.\n\
|
||
*/\n\
|
||
static unsigned short int argument_enumset_table_vec[] =\n\
|
||
{\n\
|
||
0,\n";
|
||
|
||
char *canned5 =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) unsigned short int *argument_enumset_table =\n\
|
||
\t\targument_enumset_table_vec;\n\
|
||
/*\n\
|
||
* Enumeration value table, accessed by sym_k_..._enumval code. Each entry is\n\
|
||
* the actual value associated with the code.\n\
|
||
*/\n\
|
||
static int enumval_values_table_vec[] =\n\
|
||
{\n\
|
||
0,\n";
|
||
|
||
char *canned5a =
|
||
" };\n\
|
||
externaldef(uil_sym_glbl) int *enumval_values_table =\n\
|
||
\t\tenumval_values_table_vec;\n";
|
||
|
||
|
||
FILE *outfil; /* output file */
|
||
int ndx; /* loop index */
|
||
WmlEnumSetDefPtr enumsetobj; /* enumeration set object */
|
||
WmlEnumSetValDefPtr esvobj; /* current enum set value list element */
|
||
WmlEnumValueDefPtr evobj; /* current enumeration value object */
|
||
WmlResourceDefPtr resobj; /* resource object */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write the canned header stuff
|
||
*/
|
||
outfil = fopen ("UilSymEnum.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymEnum.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
|
||
/*
|
||
* Generate the enumeration value vectors for each enumeration set.
|
||
*/
|
||
fprintf (outfil, canned1);
|
||
for ( ndx=0 ; ndx<wml_obj_enumset_ptr->cnt ; ndx++ )
|
||
{
|
||
enumsetobj = (WmlEnumSetDefPtr) wml_obj_enumset_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, valhdr, enumsetobj->sym_code);
|
||
for ( esvobj=enumsetobj->values ; esvobj!=NULL ; esvobj=esvobj->next )
|
||
{
|
||
evobj = esvobj->value;
|
||
fprintf (outfil, " %d,\n",
|
||
evobj->sym_code);
|
||
}
|
||
fprintf (outfil, " };\n");
|
||
}
|
||
|
||
/*
|
||
* Generate the enumeration set tables
|
||
*/
|
||
fprintf (outfil, canned3);
|
||
for ( ndx=0 ; ndx<wml_obj_enumset_ptr->cnt ; ndx++ )
|
||
{
|
||
enumsetobj = (WmlEnumSetDefPtr) wml_obj_enumset_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, " {%d,enum_value_vec%d},\n",
|
||
enumsetobj->values_cnt,
|
||
enumsetobj->sym_code);
|
||
}
|
||
|
||
/*
|
||
* Create enumset table entries for arguments, similar to writing sym_k...
|
||
*/
|
||
fprintf (outfil, canned4);
|
||
for ( ndx=0 ; ndx<wml_obj_arg_ptr->cnt ; ndx++ )
|
||
{
|
||
resobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[ndx].objptr;
|
||
if ( resobj->enumset_def == NULL )
|
||
fprintf (outfil, " 0,\n");
|
||
else
|
||
fprintf (outfil, " %d,\n",
|
||
resobj->enumset_def->sym_code);
|
||
}
|
||
|
||
/*
|
||
* Create the enumval values table.
|
||
*/
|
||
fprintf (outfil, canned5);
|
||
for ( ndx=0 ; ndx<wml_obj_enumval_ptr->cnt ; ndx++ )
|
||
{
|
||
evobj = (WmlEnumValueDefPtr) wml_obj_enumval_ptr->hvec[ndx].objptr;
|
||
fprintf (outfil, " %s,\n", evobj->syndef->enumlit);
|
||
}
|
||
fprintf (outfil, canned5a);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymEnum.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Routine to write out UilSymCSet.h
|
||
*
|
||
* This file specifies the various attributes for the character sets
|
||
* recognized by UIL. There is a table for each of the following
|
||
* attributes:
|
||
* - Standards name associated with the character set
|
||
* - Writing direction, from XmSTRING_DIRECTION_...
|
||
* - Parsing direction, from XmSTRING_DIRECTION_...
|
||
* - Bytes per character, from sym_k_..._charsize (in UilSymGen.h)
|
||
* - A pair of tables for recognizing $LANG settings:
|
||
* o a table of all names under which a character set might
|
||
* be legally recognized (upper case).
|
||
* o the sym_k_..._charset code for each entry
|
||
* o a variable giving the number of entries in the table
|
||
*
|
||
* All tables are accessed by the sym_k_..._charset
|
||
*
|
||
*/
|
||
|
||
void wmlOutputUilSymCSet ()
|
||
|
||
{
|
||
|
||
char *canned1 =
|
||
"\n\
|
||
/*\n\
|
||
* Character set XmString name table, accessed by sym_k_..._charset code.\n\
|
||
* Each entry is the name which identifies the character set in a XmString.\n\
|
||
*/\n\
|
||
static char *charset_xmstring_names_table_vec[] =\n\
|
||
{\n\
|
||
0,\n\
|
||
\"<userdefined>\",\n";
|
||
|
||
char *canned2 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **charset_xmstring_names_table =\n\
|
||
\t\tcharset_xmstring_names_table_vec;\n\
|
||
/*\n\
|
||
* Character set writing direction table, accessed by sym_k_..._charset code.\n\
|
||
* Each entry is the XmSTRING_DIRECTION_... code which identifies the\n\
|
||
* writing direction for the character set in a XmString.\n\
|
||
*/\n\
|
||
static unsigned char charset_wrdirection_table_vec[] =\n\
|
||
{\n\
|
||
0,\n\
|
||
0,\t/* userdefined */\n";
|
||
|
||
char *canned3 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) unsigned char *charset_writing_direction_table =\n\
|
||
\t\tcharset_wrdirection_table_vec;\n\
|
||
/*\n\
|
||
* Character set parsing direction table, accessed by sym_k_..._charset code.\n\
|
||
* Each entry is the XmSTRING_DIRECTION_... code which identifies the\n\
|
||
* parsing direction for the character set in a XmString.\n\
|
||
*/\n\
|
||
static unsigned char charset_parsdirection_table_vec[] =\n\
|
||
{\n\
|
||
0,\n\
|
||
0,\t/* userdefined */\n";
|
||
|
||
char *canned4 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) unsigned char *charset_parsing_direction_table =\n\
|
||
\t\tcharset_parsdirection_table_vec;\n\
|
||
/*\n\
|
||
* Character set character size table, accessed by sym_k_..._charset code.\n\
|
||
* Each entry is the sym_k_..._charsize literal which names the character\n\
|
||
* size for the character set in a XmString.\n\
|
||
*/\n\
|
||
static unsigned char charset_charsize_table_vec[] =\n\
|
||
{\n\
|
||
0,\n\
|
||
0,\t/* userdefined */\n";
|
||
|
||
char *canned5 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) unsigned char *charset_character_size_table =\n\
|
||
\t\tcharset_charsize_table_vec;\n\
|
||
/*\n\
|
||
* All the names under which a character set may be legally named in a \n\
|
||
* $LANG variable (upper case).\n\
|
||
*/\n\
|
||
static char *charset_lang_names_table_vec[] =\n\
|
||
{\n";
|
||
|
||
char *canned6 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) char **charset_lang_names_table =\n\
|
||
\t\tcharset_lang_names_table_vec;\n\
|
||
/*\n\
|
||
* The sym_k_..._charset codes for charset_lang_names\n\
|
||
*/\n\
|
||
static unsigned short int charset_lang_codes_table_vec[] =\n\
|
||
{\n";
|
||
|
||
char *canned7 =
|
||
"};\n\
|
||
externaldef(uil_sym_glbl) unsigned short int *charset_lang_codes_table =\n\
|
||
\t\tcharset_lang_codes_table_vec;\n\
|
||
/*\n\
|
||
* The number of entries in charset_lang_..._table tables\n\
|
||
*/\n\
|
||
externaldef(uil_sym_glbl) unsigned short int charset_lang_table_max = %d;\n";
|
||
|
||
|
||
FILE *outfil; /* output file */
|
||
int ndx; /* loop index */
|
||
WmlCharSetDefPtr csobj; /* character set object */
|
||
WmlSynCharSetDefPtr syncs; /* character set syntactic obj */
|
||
int lang_max; /* max value for $LANG tables */
|
||
int alias_ndx; /* alias loop index */
|
||
char uname[200]; /* name converted to upper case */
|
||
|
||
|
||
/*
|
||
* Open the output file. Write the canned header stuff
|
||
*/
|
||
outfil = fopen ("UilSymCSet.h", "w");
|
||
if ( outfil == (FILE *) NULL )
|
||
{
|
||
printf ("\nCouldn't open UilSymCSet.h");
|
||
return;
|
||
}
|
||
fprintf (outfil, canned_warn);
|
||
|
||
/*
|
||
* Generate the standards name table
|
||
*/
|
||
fprintf (outfil, canned1);
|
||
for ( ndx=0 ; ndx<wml_obj_charset_ptr->cnt ; ndx++ )
|
||
{
|
||
csobj = (WmlCharSetDefPtr) wml_obj_charset_ptr->hvec[ndx].objptr;
|
||
syncs = csobj->syndef;
|
||
if ( csobj->sym_code == 0 ) continue;
|
||
if ((strcmp(syncs->xms_name, "XmFONTLIST_DEFAULT_TAG") == 0) ||
|
||
(strcmp(syncs->xms_name, "_MOTIF_DEFAULT_LOCALE") == 0))
|
||
fprintf (outfil, " %s,\t/* %s */\n",
|
||
syncs->xms_name, syncs->name);
|
||
else
|
||
fprintf (outfil, " \"%s\",\t/* %s */\n",
|
||
syncs->xms_name, syncs->name);
|
||
}
|
||
|
||
/*
|
||
* Generate the writing direction table
|
||
*/
|
||
fprintf (outfil, canned2);
|
||
for ( ndx=0 ; ndx<wml_obj_charset_ptr->cnt ; ndx++ )
|
||
{
|
||
csobj = (WmlCharSetDefPtr) wml_obj_charset_ptr->hvec[ndx].objptr;
|
||
syncs = csobj->syndef;
|
||
if ( csobj->sym_code == 0 ) continue;
|
||
switch ( syncs->direction )
|
||
{
|
||
case WmlCharSetDirectionLtoR:
|
||
fprintf (outfil, " XmSTRING_DIRECTION_L_TO_R,\t/* %s */\n",
|
||
syncs->name);
|
||
break;
|
||
case WmlCharSetDirectionRtoL:
|
||
fprintf (outfil, " XmSTRING_DIRECTION_R_TO_L,\t/* %s */\n",
|
||
syncs->name);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Generate the parsing direction table
|
||
*/
|
||
fprintf (outfil, canned3);
|
||
for ( ndx=0 ; ndx<wml_obj_charset_ptr->cnt ; ndx++ )
|
||
{
|
||
csobj = (WmlCharSetDefPtr) wml_obj_charset_ptr->hvec[ndx].objptr;
|
||
syncs = csobj->syndef;
|
||
if ( csobj->sym_code == 0 ) continue;
|
||
switch ( syncs->parsedirection )
|
||
{
|
||
case WmlCharSetDirectionLtoR:
|
||
fprintf (outfil, " XmSTRING_DIRECTION_L_TO_R,\t/* %s */\n",
|
||
syncs->name);
|
||
break;
|
||
case WmlCharSetDirectionRtoL:
|
||
fprintf (outfil, " XmSTRING_DIRECTION_R_TO_L,\t/* %s */\n",
|
||
syncs->name);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Generate the character size table
|
||
*/
|
||
fprintf (outfil, canned4);
|
||
for ( ndx=0 ; ndx<wml_obj_charset_ptr->cnt ; ndx++ )
|
||
{
|
||
csobj = (WmlCharSetDefPtr) wml_obj_charset_ptr->hvec[ndx].objptr;
|
||
syncs = csobj->syndef;
|
||
if ( csobj->sym_code == 0 ) continue;
|
||
switch ( syncs->charsize )
|
||
{
|
||
case WmlCharSizeOneByte:
|
||
fprintf (outfil, " sym_k_onebyte_charsize,\t/* %s */\n",
|
||
syncs->name);
|
||
break;
|
||
case WmlCharSizeTwoByte:
|
||
fprintf (outfil, " sym_k_twobyte_charsize,\t/* %s */\n",
|
||
syncs->name);
|
||
break;
|
||
case WmlCharSizeMixed1_2Byte:
|
||
fprintf (outfil, " sym_k_mixed1_2byte_charsize,\t/* %s */\n",
|
||
syncs->name);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Generate the $LANG name recognition table
|
||
*/
|
||
fprintf (outfil, canned5);
|
||
lang_max = 0;
|
||
for ( ndx=0 ; ndx<wml_obj_charset_ptr->cnt ; ndx++ )
|
||
{
|
||
csobj = (WmlCharSetDefPtr) wml_obj_charset_ptr->hvec[ndx].objptr;
|
||
syncs = csobj->syndef;
|
||
if ( csobj->sym_code == 0 ) continue;
|
||
strcpy (uname, syncs->name);
|
||
wmlUpperCaseString (uname);
|
||
fprintf (outfil, " \"%s\",\t/* %s */\n",
|
||
uname, syncs->name);
|
||
lang_max += 1;
|
||
strcpy (uname, syncs->xms_name);
|
||
wmlUpperCaseString (uname);
|
||
fprintf (outfil, " \"%s\",\t/* %s */\n",
|
||
uname, syncs->name);
|
||
lang_max += 1;
|
||
for ( alias_ndx=0 ; alias_ndx<syncs->alias_cnt ; alias_ndx++ )
|
||
{
|
||
strcpy (uname, syncs->alias_list[alias_ndx]);
|
||
wmlUpperCaseString (uname);
|
||
fprintf (outfil, " \"%s\",\t/* %s */\n",
|
||
uname, syncs->name);
|
||
lang_max += 1;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Generate the $LANG code lookup table, in upper case
|
||
*/
|
||
fprintf (outfil, canned6);
|
||
for ( ndx=0 ; ndx<wml_obj_charset_ptr->cnt ; ndx++ )
|
||
{
|
||
csobj = (WmlCharSetDefPtr) wml_obj_charset_ptr->hvec[ndx].objptr;
|
||
syncs = csobj->syndef;
|
||
if ( csobj->sym_code == 0 ) continue;
|
||
fprintf (outfil, " sym_k_%s_charset,\n", syncs->name);
|
||
fprintf (outfil, " sym_k_%s_charset,\n", syncs->name);
|
||
for ( alias_ndx=0 ; alias_ndx<syncs->alias_cnt ; alias_ndx++ )
|
||
fprintf (outfil, " sym_k_%s_charset,\n", syncs->name);
|
||
}
|
||
|
||
/*
|
||
* Generate the number of entries in the previous two tables
|
||
*/
|
||
fprintf (outfil, canned7, lang_max);
|
||
|
||
/*
|
||
* close the output file
|
||
*/
|
||
printf ("\nCreated UilSymCSet.h");
|
||
fclose (outfil);
|
||
|
||
}
|
||
|
||
|