/* 

 * Motif

 *

 * Copyright (c) 1987-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

*/ 

/* 

 * HISTORY

*/ 

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$XConsortium: wmlresolve.c /main/9 1995/08/29 11:11:05 drk $"

#endif

#endif

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

/*

*  (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */

/*

 * This module contains all routines which perform semantic analysis of

 * the parsed WML specification. It is responsible for building all

 * ordered structures which can be directly translated into literal

 * code values for the various .h files. It is responsible for performing

 * inheritance of resources for all classes.

 *

 * Input:

 *	the ordered list of syntactic objects in wml_synobj_ptr

 *

 * Output:

 *

 */

#include "wml.h"

#if defined(__STDC__)

#include <stdlib.h>

#endif

#include <stdio.h>

/*

 * Routines used only in this module

 */

void wmlResolveGenerateSymK ();

void wmlResolveValidateClass ();

void wmlResolvePrintReport ();

void wmlResolveSymKDataType ();

void wmlResolveSymKChild ();

void wmlResolveSymKEnumVal ();

void wmlResolveSymKEnumSet ();

void wmlResolveSymKReason ();

void wmlResolveSymKArgument ();

void wmlResolveSymKRelated ();

void wmlResolveSymKClass ();

void wmlResolveSymKCtrlList ();

void wmlResolveSymKCharSet ();

void wmlResolveClassInherit ();

void wmlResolveClearRefPointers ();

void wmlResolveInitRefObj ();

void wmlResolveInitChildRefObj ();

void wmlResolvePrintClass ();

void wmlResolvePrintClassArgs ();

void wmlResolvePrintClassReasons ();

ObjectPtr wmlResolveFindObject ();

void wmlIssueReferenceError ();

void wmlIssueIllegalReferenceError ();

void wmlIssueError ();

/*

 * The control routine for semantic analysis. It calls the various phases.

 */

void wmlResolveDescriptors ()

{

/*

 * Perform the code assignment pass. This results in assignment of sym_k_...

 * codes to all entities. Also, all objects and cross-linking are validated.

 */

wmlResolveGenerateSymK ();

printf ("\nInitial validation and reference resolution complete");

/*

 * Perform class inheritance and validation

 */

wmlResolveValidateClass ();

printf ("\nClass validation and inheritance complete");

/*

 * Print a report

 */

if ( wml_err_count > 0 ) return;

wmlResolvePrintReport ();

}

/*

 * Routine to linearize and assign sym_k... literals for objects. Simply

 * a dispatching routine.

 */

void wmlResolveGenerateSymK ()

{

/*

 * Process the datatype objects

 */

wmlResolveSymKDataType ();

/*

 * Process the enumeration value and enumeration sets

 */

wmlResolveSymKEnumVal ();

wmlResolveSymKEnumSet ();

/*

 * Process the resources, producing argument and reason vectors.

 */

wmlResolveSymKReason ();

wmlResolveSymKArgument ();

/*

 * Bind related arguments

 */

wmlResolveSymKRelated ();

/*

 * Process the class definitions

 */

wmlResolveSymKClass ();

/*

 * Process the controls list definitions

 */

wmlResolveSymKCtrlList ();

/*

 * Process the charset objects

 */

wmlResolveSymKCharSet ();

/* Process the child definitions. */

wmlResolveSymKChild();

}

/*

 * Routine to linearize data types

 *

 * - Generate the wml_obj_datatype... vector of resolved data type objects,

 *   ordered lexicographically.

 *   Do name processing, and acquire links to any other objects named in

 *   the syntactic descriptor.

 */

void wmlResolveSymKDataType ()

{

WmlSynDataTypeDefPtr	cursyn;		/* current syntactic object */

WmlDataTypeDefPtr	newobj;		/* new resolved object */

int			ndx;		/* loop index */

/*

 * Initialize the object vector. Then process the syntactic vector,

 * processing each datatype object encountered (the vector is ordered).

 * create and append a resolved object for each one encountered. This

 * will be ordered as well.

 */

wmlInitHList (wml_obj_datatype_ptr, 50, TRUE);

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cursyn = (WmlSynDataTypeDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cursyn->validation != WmlDataTypeDefValid ) continue;

/*

 * Create and initialize new object. Append to resolved object vector.

 */

    newobj = (WmlDataTypeDefPtr) malloc (sizeof(WmlDataTypeDef));

    newobj->syndef = cursyn;

    cursyn->rslvdef = newobj;

    if ( cursyn->int_lit != NULL )

	newobj->tkname = cursyn->int_lit;

    else

	newobj->tkname = cursyn->name;

    wmlInsertInHList (wml_obj_datatype_ptr, newobj->tkname, (ObjectPtr)newobj);

/*

 * Validate any object references in the syntactic object

 */

    }

}

/*

 * Routine to linearize children

 *

 * - Generate the wml_obj_child... vector of resolved child objects,

 *   ordered lexicographically.  Assign sym_k_... values while doing so.

 *   Link child to its class. 

 */

void wmlResolveSymKChild ()

{

WmlSynChildDefPtr	cursyn;		/* current syntactic object */

WmlChildDefPtr		newobj;		/* new resolved object */

int			code;		/* assigned sym_k code value */

int			ndx;		/* loop index */

/*

 * Initialize the object vector. Then process the syntactic vector,

 * processing each child object encountered (the vector is ordered).

 * create and append a resolved object for each one encountered. This

 * will be ordered as well.

 */

wmlInitHList (wml_obj_child_ptr, 50, TRUE);

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cursyn = (WmlSynChildDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cursyn->validation != WmlChildDefValid ) continue;

/*

 * Create and initialize new object. Append to resolved object vector.

 */

    newobj = (WmlChildDefPtr) malloc (sizeof(WmlChildDef));

    newobj->syndef = cursyn;

    cursyn->rslvdef = newobj;

    newobj->tkname = cursyn->name;

    wmlInsertInHList (wml_obj_child_ptr, newobj->tkname, (ObjectPtr)newobj);

/* Link class to the resolved object. */

if (cursyn->class != NULL)

  newobj->class = (WmlClassDefPtr)

    wmlResolveFindObject(cursyn->class, WmlClassDefValid, cursyn->name);

  }

/*

 * All objects are in the vector. The order is the code order, so

 * process it again and assign codes to each object

 */

code = 1;

for ( ndx=0 ; ndx<wml_obj_child_ptr->cnt ; ndx++ )

    {

    newobj = (WmlChildDefPtr) wml_obj_child_ptr->hvec[ndx].objptr;

    newobj->sym_code = code;

    code += 1;

    }

}

/*

 * Routine to linearize and assign sym_k values to enumeration values

 *

 * - Generate the wml_obj_datatype... vector of resolved data type objects,

 *   ordered lexicographically. No sym_k_... values are needed for

 *   enumeration values, so don't assign any.

 */

void wmlResolveSymKEnumVal ()

{

WmlSynEnumSetDefPtr	cures;		/* current enumeration set */

WmlSynEnumSetValDefPtr	curesv;		/* current enum set value */

WmlSynEnumValueDefPtr	cursyn;		/* current syntactic object */

WmlEnumValueDefPtr	newobj;		/* new resolved object */

int			ndx;		/* loop index */

int			code;		/* sym_k_... code */

/*

 * Perform defaulting. Process all the enumeration sets, and define a

 * syntactic object for every enumeration value named in an enumeration set

 * which has no syntactic entry. If there is an error in a name, then

 * this error won't be detected until we attempt to compile the output .h files.

 */

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cures = (WmlSynEnumSetDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cures->validation != WmlEnumSetDefValid ) continue;

    for (curesv=cures->values ; curesv!=NULL ; curesv=curesv->next)

	if ( wmlFindInHList(wml_synobj_ptr,curesv->name) < 0 )

	    wmlCreateEnumValue (curesv->name);

    }

/*

 * Initialize the object vector. Then process the syntactic vector,

 * processing each enumeration value object encountered (the vector is ordered).

 * create and append a resolved object for each one encountered. This

 * will be ordered as well.

 */

wmlInitHList (wml_obj_enumval_ptr, 50, TRUE);

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cursyn = (WmlSynEnumValueDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cursyn->validation != WmlEnumValueDefValid ) continue;

/*

 * Create and initialize new object. Append to resolved object vector.

 */

    newobj = (WmlEnumValueDefPtr) malloc (sizeof(WmlEnumValueDef));

    newobj->syndef = cursyn;

    cursyn->rslvdef = newobj;

    wmlInsertInHList (wml_obj_enumval_ptr, cursyn->name, (ObjectPtr)newobj);

    }

/*

 * All objects are in the vector. That order is the code order, so

 * process it again and assign codes to each object

 */

code = 1;

for ( ndx=0 ; ndx<wml_obj_enumval_ptr->cnt ; ndx++ )

    {

    newobj = (WmlEnumValueDefPtr) wml_obj_enumval_ptr->hvec[ndx].objptr;

    newobj->sym_code = code;

    code += 1;

    }

}

/*

 * Routine to linearize and assign sym_k values to enumeration sets

 *

 * - Generate the wml_obj_datatype... vector of resolved data type objects,

 *   ordered lexicographically. No sym_k_... values are needed for

 *   enumeration values, so don't assign any.

 */

void wmlResolveSymKEnumSet ()

{

WmlSynEnumSetDefPtr	cursyn;		/* current syntactic object */

WmlEnumSetDefPtr	newobj;		/* new resolved object */

int			ndx;		/* loop index */

int			code;		/* sym_k_... code */

WmlSynEnumSetValDefPtr	esvelm;		/* current syntactic list element */

WmlEnumValueDefPtr	evobj;		/* current enumeration value */

WmlEnumSetValDefPtr	esvobj;		/* current list element */

/*

 * Initialize the object vector. Then process the syntactic vector,

 * processing each enumeration set object encountered (the vector is ordered).

 * create and append a resolved object for each one encountered. This

 * will be ordered as well.

 */

wmlInitHList (wml_obj_enumset_ptr, 20, TRUE);

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cursyn = (WmlSynEnumSetDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cursyn->validation != WmlEnumSetDefValid ) continue;

/*

 * Create and initialize new object. Append to resolved object vector.

 */

    newobj = (WmlEnumSetDefPtr) malloc (sizeof(WmlEnumSetDef));

    newobj->syndef = cursyn;

    cursyn->rslvdef = newobj;

    newobj->tkname = cursyn->name;

    newobj->dtype_def = (WmlDataTypeDefPtr)

	wmlResolveFindObject (cursyn->datatype,

			      WmlDataTypeDefValid,

			      cursyn->name);

    wmlInsertInHList (wml_obj_enumset_ptr, newobj->tkname, (ObjectPtr)newobj);

    }

/*

 * All objects are in the vector. That order is the code order, so

 * process it again and assign codes to each object. Simultaneously construct

 * a vector of resolved enumeration values, and count them.

 */

code = 1;

for ( ndx=0 ; ndx<wml_obj_enumset_ptr->cnt ; ndx++ )

    {

    newobj = (WmlEnumSetDefPtr) wml_obj_enumset_ptr->hvec[ndx].objptr;

    newobj->sym_code = code;

    code += 1;

/*

 * Validate and construct a resolved enumeration value list

 */

    cursyn = newobj->syndef;

    newobj->values_cnt = 0;

    newobj->values = NULL;

    for ( esvelm=cursyn->values ; esvelm!=NULL ; esvelm=esvelm->next )

	{

	evobj = (WmlEnumValueDefPtr)

	    wmlResolveFindObject (esvelm->name,

				  WmlEnumValueDefValid,

				  cursyn->name);

	if ( evobj == NULL ) continue;

	esvobj = (WmlEnumSetValDefPtr) malloc (sizeof(WmlEnumSetValDef));

	esvobj->value = evobj;

	esvobj->next = newobj->values;

	newobj->values = esvobj;

	newobj->values_cnt += 1;

	}

    }

}

/*

 * Routine to linearize and assign sym_k values to reasons.

 *

 * - Generate the wml_obj_reason... vector of resolved reason objects,

 *   ordered lexicographically. Assign a sym_k_... value as this is done.

 *   Do name processing, and acquire links to any other objects named in

 *   the syntactic descriptor.

 */

void wmlResolveSymKReason ()

{

WmlSynResourceDefPtr	cursyn;		/* current syntactic object */

WmlResourceDefPtr	newobj;		/* new resolved object */

int			ndx;		/* loop index */

int			code;		/* assigned sym_k code value */

char			errmsg[300];

/*

 * Initialize the object vector. Then process the syntactic vector,

 * processing each reason resource object encountered (the vector is ordered).

 * create and append a resolved object for each one encountered. This

 * will be ordered as well.

 */

wmlInitHList (wml_obj_reason_ptr, 100, TRUE);

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cursyn = (WmlSynResourceDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cursyn->validation != WmlResourceDefValid ) continue;

    if ( cursyn->type != WmlResourceTypeReason ) continue;

    newobj = (WmlResourceDefPtr) malloc (sizeof(WmlResourceDef));

/*

 * Create and initialize new object. Append to resolved object vector.

 */

    newobj->syndef = cursyn;

    cursyn->rslvdef = newobj;

    if ( cursyn->int_lit != NULL )

	newobj->tkname = cursyn->int_lit;

    else

	newobj->tkname = cursyn->name;

    newobj->dtype_def = NULL;

    newobj->enumset_def = NULL;

    newobj->related_code = 0;

    wmlInsertInHList (wml_obj_reason_ptr, newobj->tkname, (ObjectPtr)newobj);

/*

 * Validate any object references in the syntactic object

 * Reason can't bind to some objects.

 */

    if ( cursyn->datatype != NULL )

	wmlIssueIllegalReferenceError (cursyn->name, "DataType");

    }

/*

 * All objects are in the vector. That order is the code order, so

 * process it again and assign codes to each object

 */

code = 1;

for ( ndx=0 ; ndx<wml_obj_reason_ptr->cnt ; ndx++ )

    {

    newobj = (WmlResourceDefPtr) wml_obj_reason_ptr->hvec[ndx].objptr;

    newobj->sym_code = code;

    code += 1;

    }

}

/*

 * Routine to linearize and assign sym_k values to arguments.

 *

 * - Generate the wml_obj_arg... vector of resovled reason objects,

 *   ordered lexicographically. Assign a sym_k_... values while doing so.

 *   validate the data type for each argument, and link it to its data type

 *   object.

 *   Do name processing, and acquire links to any other objects named in

 *   the syntactic descriptor.

 */

void wmlResolveSymKArgument ()

{

WmlSynResourceDefPtr	cursyn;		/* current syntactic object */

WmlResourceDefPtr	newobj;		/* new resolved object */

int			ndx;		/* loop index */

int			code;		/* assigned sym_k code value */

char			errmsg[300];

/*

 * Initialize the object vector. Then process the syntactic vector,

 * processing each reason resource object encountered (the vector is ordered).

 * create and append a resolved object for each one encountered. This

 * will be ordered as well.

 */

wmlInitHList (wml_obj_arg_ptr, 500, TRUE);

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cursyn = (WmlSynResourceDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cursyn->validation != WmlResourceDefValid ) continue;

    if ( cursyn->type == WmlResourceTypeReason ) continue;

    newobj = (WmlResourceDefPtr) malloc (sizeof(WmlResourceDef));

/*

 * Create and initialize new object. Append to resolved object vector.

 */

    newobj->syndef = cursyn;

    cursyn->rslvdef = newobj;

    if ( cursyn->int_lit != NULL )

	newobj->tkname = cursyn->int_lit;

    else

	newobj->tkname = cursyn->name;

    newobj->related_code = 0;

    newobj->enumset_def = NULL;

    wmlInsertInHList (wml_obj_arg_ptr, newobj->tkname, (ObjectPtr)newobj);

/*

 * Validate any object references in the syntactic object

 */

    newobj->dtype_def = (WmlDataTypeDefPtr)

	wmlResolveFindObject (cursyn->datatype,

			      WmlDataTypeDefValid,

			      cursyn->name);

    if ( cursyn->enumset != NULL )

	newobj->enumset_def = (WmlEnumSetDefPtr)

	    wmlResolveFindObject (cursyn->enumset,

				  WmlEnumSetDefValid,

				  cursyn->name);

    }

/*

 * All objects are in the vector. The order is the code order, so

 * process it again and assign codes to each object

 */

code = 1;

for ( ndx=0 ; ndx<wml_obj_arg_ptr->cnt ; ndx++ )

    {

    newobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[ndx].objptr;

    newobj->sym_code = code;

    code += 1;

    }

}

/*

 * Routine to resolve related argument references.

 *

 * Search the argument vector for any argument with its related

 * argument set. Find the related argument, and bind the relation.

 * The binding only goes one way.

 */

void wmlResolveSymKRelated ()

{

WmlResourceDefPtr	srcobj;		/* object with related reference */

WmlResourceDefPtr	dstobj;		/* other object in binding */

WmlSynResourceDefPtr	srcsynobj;	/* source syntactic object */

int			ndx;		/* loop index */

/*

 * Scan all arguments for related argument bindings.

 */

for ( ndx=0 ; ndx<wml_obj_arg_ptr->cnt ; ndx++ )

    {

    srcobj = (WmlResourceDefPtr) wml_obj_arg_ptr->hvec[ndx].objptr;

    srcsynobj = srcobj->syndef;

    if ( srcsynobj->related != NULL )

	{

	dstobj = (WmlResourceDefPtr)

	    wmlResolveFindObject (srcsynobj->related,

				  WmlResourceDefValid,

				  srcsynobj->name);

	if ( dstobj != NULL )

	    srcobj->related_code = dstobj->sym_code;

	}

    }

}

/*

 * Routine to linearize and assign sym_k values to classes

 *

 * There are two linearizations of classes:

 *	- all classes in wml_obj_allclass...

 *	- all widgets and gadgets in wml_obj_class...

 * Create and linearize all class objects into these vectors. Assign sym_k

 * codes. Link all subclasses to their superclasses. Perform name processing

 * and link to any other named object.

 *

 * Resources are not inherited and linked at this time.

 */

void wmlResolveSymKClass ()

{

WmlSynClassDefPtr	cursyn;		/* current syntactic object */

WmlClassDefPtr		newobj;		/* new resolved object */

int			ndx;		/* loop index */

int			code;		/* assigned sym_k code value */

char			errmsg[300];

/*

 * Initialize the object vectors. Then process the syntactic vector,

 * processing each class object encountered (the vector is ordered).

 * create and append a resolved object for each one encountered. This

 * will be ordered as well.

 */

wmlInitHList (wml_obj_allclass_ptr, 200, TRUE);

wmlInitHList (wml_obj_class_ptr, 200, TRUE);

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cursyn = (WmlSynClassDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cursyn->validation != WmlClassDefValid ) continue;

/*

 * Create and initialize new object. Append to resolved object vector.

 */

    newobj = (WmlClassDefPtr) malloc (sizeof(WmlClassDef));

    newobj->syndef = cursyn;

    cursyn->rslvdef = newobj;

    newobj->superclass = NULL;

    newobj->parentclass = NULL;

    if ( cursyn->int_lit != NULL )

	newobj->tkname = cursyn->int_lit;

    else

	newobj->tkname = cursyn->name;

    newobj->inherit_done = FALSE;

    newobj->arguments = NULL;

    newobj->reasons = NULL;

    newobj->controls = NULL;

    newobj->children = NULL;

    newobj->variant = NULL;

    newobj->nondialog = NULL;

    newobj->ctrlmapto = NULL;

    switch ( cursyn->type )

	{

	case WmlClassTypeMetaclass:

	    wmlInsertInHList

		(wml_obj_allclass_ptr, newobj->tkname, (ObjectPtr)newobj);

	    break;

	case WmlClassTypeGadget:

	case WmlClassTypeWidget:

	    wmlInsertInHList

		(wml_obj_allclass_ptr, newobj->tkname, (ObjectPtr)newobj);

	    wmlInsertInHList

		(wml_obj_class_ptr, newobj->tkname, (ObjectPtr)newobj);

	    break;

	}

/*

 * Require a convenience function name

 */

    if ( cursyn->type != WmlClassTypeMetaclass )

	if ( cursyn->convfunc == NULL )

	    {

	    sprintf (errmsg, "Class %s does not have a convenience function",

		     cursyn->name);

	    wmlIssueError (errmsg);

	    }	

/*

 * Validate any object references in the syntactic object

 */

    if ( cursyn->ctrlmapto != NULL )

	newobj->ctrlmapto = (WmlResourceDefPtr)

	    wmlResolveFindObject (cursyn->ctrlmapto,

				  WmlResourceDefValid,

				  cursyn->name);

    }

/*

 * All objects are in the vector. That order is the code order, so

 * process it again and assign codes to each object

 */

code = 1;

for ( ndx=0 ; ndx<wml_obj_class_ptr->cnt ; ndx++ )

    {

    newobj = (WmlClassDefPtr) wml_obj_class_ptr->hvec[ndx].objptr;

    newobj->sym_code = code;

    code += 1;

    }

}

/*

 * Routine to validate controls lists

 *

 * Construct and linearize resolved controls lists. The linearized list

 * is used to resolve references.

 */

void wmlResolveSymKCtrlList ()

{

WmlSynCtrlListDefPtr	cursyn;		/* current syntactic object */

WmlCtrlListDefPtr	newobj;		/* new resolved object */

WmlSynClassCtrlDefPtr	refptr;		/* current controls reference */

WmlClassCtrlDefPtr	ctrlobj;	/* resolved control reference */

WmlClassDefPtr		classobj;	/* the controlled class */

int			ndx;		/* loop index */

/*

 * Process each control list. Construct a resolved control list for each

 */

wmlInitHList (wml_obj_ctrlist_ptr, 20, TRUE);

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cursyn = (WmlSynCtrlListDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cursyn->validation != WmlCtrlListDefValid ) continue;

/*

 * Create and initialize new object. Append to resolved object vector.

 */

    newobj = (WmlCtrlListDefPtr) malloc (sizeof(WmlCtrlListDef));

    newobj->syndef = cursyn;

    cursyn->rslvdef = newobj;

    newobj->controls = NULL;

    wmlInsertInHList (wml_obj_ctrlist_ptr, cursyn->name, (ObjectPtr)newobj);

/*

 * Validate and construct a resolved controls reference list.

 */

    for ( refptr=cursyn->controls ; refptr!=NULL ; refptr=refptr->next )

	{

	classobj = (WmlClassDefPtr)

	    wmlResolveFindObject (refptr->name,

				  WmlClassDefValid,

				  cursyn->name);

	if ( classobj == NULL ) continue;

	ctrlobj = (WmlClassCtrlDefPtr) malloc (sizeof(WmlClassCtrlDef));

	ctrlobj->next = newobj->controls;

	newobj->controls = ctrlobj;

	ctrlobj->ctrl = classobj;

	}

    }

}

/*

 * Routine to linearize and assign sym_k values to character sets

 *

 * - Generate the wml_obj_charset... vector of resolved data type objects,

 *   ordered lexicographically. Assign a sym_k... value as this is done.

 *   Do name processing, and acquire links to any other objects named in

 *   the syntactic descriptor.

 */

void wmlResolveSymKCharSet ()

{

WmlSynCharSetDefPtr	cursyn;		/* current syntactic object */

WmlCharSetDefPtr	newobj;		/* new resolved object */

int			ndx;		/* loop index */

int			code;		/* assigned sym_k code value */

char			errmsg[300];

/*

 * Initialize the object vector. Then process the syntactic vector,

 * processing each charset object encountered (the vector is ordered).

 * create and append a resolved object for each one encountered. This

 * will be ordered as well.

 */

wmlInitHList (wml_obj_charset_ptr, 50, TRUE);

for ( ndx=0 ; ndx<wml_synobj_ptr->cnt ; ndx++ )

    {

    cursyn = (WmlSynCharSetDefPtr) wml_synobj_ptr->hvec[ndx].objptr;

    if ( cursyn->validation != WmlCharSetDefValid ) continue;

/*

 * Create and initialize new object. Append to resolved object vector.

 */

    newobj = (WmlCharSetDefPtr) malloc (sizeof(WmlCharSetDef));

    newobj->syndef = cursyn;

    cursyn->rslvdef = newobj;

    if ( cursyn->int_lit != NULL )

	newobj->tkname = cursyn->int_lit;

    else

	newobj->tkname = cursyn->name;

    wmlInsertInHList (wml_obj_charset_ptr, newobj->tkname, (ObjectPtr)newobj);

/*

 * Parsing direction defaults to writing direction if unspecified

 */

    if ( cursyn->parsedirection == WmlAttributeUnspecified )

	cursyn->parsedirection = cursyn->direction;

/*

 * Require StandardsName attribute for character set

 */

    if ( cursyn->xms_name == NULL )

	{

	sprintf (errmsg, "CharacterSet %s does not have a StandardsName",

		 cursyn->name);

	wmlIssueError (errmsg);

	}	

    }

/*

 * All objects are in the vector. That order is the code order, so

 * process it again and assign codes to each object. We start at code

 * 2 since 1 is reserved for sym_k_userdefined_charset

 */

code = 2;

for ( ndx=0 ; ndx<wml_obj_charset_ptr->cnt ; ndx++ )

    {

    newobj = (WmlCharSetDefPtr) wml_obj_charset_ptr->hvec[ndx].objptr;

    newobj->sym_code = code;

    code += 1;

    }

}