/* 

 * 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[] = "$TOG: UilSymStor.c /main/15 1997/03/12 15:21:44 dbl $"

#endif

#endif

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

/*

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

/*

**++

**  FACILITY:

**

**      User Interface Language Compiler (UIL)

**

**  ABSTRACT:

**

**      This module contains the procedures for managing memory for

**	the compiler. 

**

**--

**/

/*

**

**  INCLUDE FILES

**

**/

#include <Xm/Xm.h>

#include <ctype.h>

#include "UilDefI.h"

/*

**

**  DEFINE and MACRO DEFINITIONS

**

**/

/*

**

**  EXTERNAL VARIABLE DECLARATIONS

**

**/

/*

**

**  GLOBAL VARIABLE DECLARATIONS

**

**/

externaldef(uil_comp_glbl) sym_name_entry_type

	*sym_az_hash_table[ sym_k_hash_table_limit];

externaldef(uil_comp_glbl) sym_value_entry_type

	*sym_az_error_value_entry = NULL;

externaldef(uil_comp_glbl) sym_external_def_entry_type

	*sym_az_external_def_chain;

externaldef(uil_comp_glbl) sym_forward_ref_entry_type

	*sym_az_forward_ref_chain;

externaldef(uil_comp_glbl) sym_val_forward_ref_entry_type

	*sym_az_val_forward_ref_chain;

externaldef(uil_comp_glbl) sym_module_entry_type

	*sym_az_module_entry;

externaldef(uil_comp_glbl) sym_root_entry_type

	*sym_az_root_entry;

externaldef(uil_comp_glbl) sym_section_entry_type

	*sym_az_current_section_entry;

externaldef(uil_comp_glbl) sym_entry_type

	*sym_az_entry_list_header;

/*

 * These lists save the allocated and freed symbol table nodes.

 */

externaldef(uil_comp_glbl) URMPointerListPtr	sym_az_allocated_nodes;

externaldef(uil_comp_glbl) URMPointerListPtr	sym_az_freed_nodes;

/*

**

**  OWN VARIABLE DECLARATIONS

**

**/

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This routine intializes the compiler's memory allocation system.

**

**  FORMAL PARAMETERS:

**

**      none

**

**  IMPLICIT INPUTS:

**

**      none

**

**  IMPLICIT OUTPUTS:

**

**	sym_az_last_location		ptr to last byte avail for allocation

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      first symbol table buffer is allocated

**

**--

**/

void

sym_initialize_storage(void)

{

int		i;

/*

 * Initialize the name hash table

 */

for (i=0; i

    sym_az_hash_table[ i ] = NULL;

/* 

 * Set forward reference, external definition, and symbol table header

 * chains to null.

 */

sym_az_forward_ref_chain = NULL;

sym_az_val_forward_ref_chain = NULL;

sym_az_external_def_chain = NULL;

sym_az_entry_list_header = NULL;

sym_az_module_entry = NULL;

/*

 * Acquire pointer lists to access allocated and freed nodes

 */

UrmPlistInit (1000, &sym_az_allocated_nodes);

UrmPlistInit (100, &sym_az_freed_nodes);

/*

 * Allocate a value entry for an error value and give it a name.  Giving it

 * name assures that it is not freed.  The name used is one that will not

 * conflict with a user name.

 */

if ( sym_az_error_value_entry == NULL )

    sym_az_error_value_entry = (sym_value_entry_type *)

	sem_allocate_node (sym_k_value_entry, sym_k_value_entry_size);

sym_az_error_value_entry->b_type = sym_k_error_value;

sym_az_error_value_entry->obj_header.b_flags = 

    (sym_m_private | sym_m_builtin);

sym_az_error_value_entry->obj_header.az_name =

    sym_insert_name( 9, "#error...");

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**	This routine cleans up the compiler's memory allocation system, and

**	frees all memory used by the symbol table.

**

**  FORMAL PARAMETERS:

**

**      freealloc		TRUE if allocated nodes are to be freed.

**				Otherwise, free only freed nodes.

**

**  IMPLICIT INPUTS:

**

**      sym_az_entry_list_header	ptr to list of symbol entries

**

**  IMPLICIT OUTPUTS:

**

**      sym_az_entry_list_header	ptr to list of symbol entries

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**	all symbol table memory is freed.

**

**--

**/

void

Uil_sym_cleanup_storage (boolean freealloc)

{

if ( freealloc )

    if ( sym_az_allocated_nodes != NULL )

	UrmPlistFreeContents (sym_az_allocated_nodes);

else

    if ( sym_az_freed_nodes != NULL )

	UrmPlistFreeContents (sym_az_freed_nodes);

if ( sym_az_allocated_nodes != NULL )

    UrmPlistFree (sym_az_allocated_nodes);

if ( sym_az_freed_nodes != NULL )

    UrmPlistFree (sym_az_freed_nodes);

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This routine adds an object to the external definition chain.

**

**  FORMAL PARAMETERS:

**

**      az_name		name of object to be placed on the chain

**

**  IMPLICIT INPUTS:

**

**      sym_az_external_def_chain	head of the external definition chain

**

**  IMPLICIT OUTPUTS:

**

**      sym_az_external_def_chain	head of the external definition chain

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      none

**

**--

**/

void

sym_make_external_def( XmConst sym_name_entry_type *az_name )

{

    sym_external_def_entry_type   *external_entry;

    /* allocate an external definition entry */

    external_entry = (sym_external_def_entry_type *)

	sem_allocate_node (sym_k_external_def_entry,

			   sym_k_external_def_entry_size);

    /* fill in the entry */

    external_entry->az_name = (sym_name_entry_type *)az_name;

    /* place on the front of the chain */

    external_entry->az_next_object = sym_az_external_def_chain;

    sym_az_external_def_chain = external_entry;

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This routine adds a reference to the forward reference chain.

**	This routine is used for widget and gadget forward references only.

**	

**

**  FORMAL PARAMETERS:

**

**      az_id_frame	parse stack frame for id being referenced

**	l_widget_type	type of object being referenced

**      az_object	ptr to the location that needs to be updated

**			when the object is resolved

**

**  IMPLICIT INPUTS:

**

**      sym_az_forward_ref_chain    head of the forward reference chain

**

**  IMPLICIT OUTPUTS:

**

**      sym_az_forward_ref_chain    head of the forward reference chain

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      none

**

**--

**/

void

sym_make_forward_ref(XmConst yystype *az_id_frame,

		     XmConst int     l_widget_type,

		     XmConst char    *a_location)

{

    sym_forward_ref_entry_type   *fwd_ref_entry;

    _assert( (az_id_frame->b_tag == sar_k_token_frame) &&

	     (az_id_frame->value.az_symbol_entry->header.b_tag == 

		sym_k_name_entry), "arg1 not an id frame" );

    /* allocate an external definition entry */

    fwd_ref_entry = (sym_forward_ref_entry_type *)

	sem_allocate_node (sym_k_forward_ref_entry,

			   sym_k_forward_ref_entry_size);

    /* fill in the entry */

    _sar_save_source_pos (&fwd_ref_entry->header, az_id_frame);

    fwd_ref_entry->header.b_type = l_widget_type;

    fwd_ref_entry->az_name =

	(sym_name_entry_type *) az_id_frame->value.az_symbol_entry;

    fwd_ref_entry->a_update_location = (char *)a_location;

    /* place on the front of the chain */

    fwd_ref_entry->az_next_ref = sym_az_forward_ref_chain;

    sym_az_forward_ref_chain = fwd_ref_entry;

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This routine adds a reference to the values forward reference chain.

**	This routine is used for value forward references only.

**	

**

**  FORMAL PARAMETERS:

**

**      az_id_frame	parse stack frame for id being referenced

**      az_object	ptr to the location that needs to be updated

**			when the object is resolved

**

**  IMPLICIT INPUTS:

**

**      sym_az_val_forward_ref_chain    head of the forward reference chain

**

**  IMPLICIT OUTPUTS:

**

**      sym_az_val_forward_ref_chain    head of the forward reference chain

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      none

**

**--

**/

void

sym_make_value_forward_ref (XmConst yystype  *az_value_frame,

			    XmConst char *a_location,

			    XmConst unsigned char fwd_ref_flags )

{

    sym_val_forward_ref_entry_type   *fwd_ref_entry;

    /* allocate an external definition entry */

    fwd_ref_entry = (sym_val_forward_ref_entry_type *)

	sem_allocate_node (sym_k_val_forward_ref_entry,

			   sym_k_val_forward_ref_entry_size);

    /* fill in the entry */

    _sar_save_source_pos (&fwd_ref_entry->header, az_value_frame);

    switch (fwd_ref_flags)

	{

	case sym_k_patch_add:

	    fwd_ref_entry->az_name =

		((sym_value_entry_type *)

		 az_value_frame->value.az_symbol_entry)->obj_header.az_name;

	    break;

	case sym_k_patch_list_add:

	    fwd_ref_entry->az_name = 

		(sym_name_entry_type *)az_value_frame->value.az_symbol_entry;

	    break;

	default:

	    _assert(FALSE, "Illegal forward reference");

	};

    fwd_ref_entry->a_update_location = (char *)a_location;

    fwd_ref_entry->fwd_ref_flags = fwd_ref_flags;

    /* place on the front of the chain */

    fwd_ref_entry->az_next_ref = sym_az_val_forward_ref_chain;

    sym_az_val_forward_ref_chain = fwd_ref_entry;

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This procedure recursively goes through the symbol table, dumping

**	each node accessible from the root node.

**

**  FORMAL PARAMETERS:

**

**      none

**

**  IMPLICIT INPUTS:

**

**

**  IMPLICIT OUTPUTS:

**

**      none

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      symbol table is dump with the debug output

**

**--

**/

void

UilDumpSymbolTable ( sym_entry_type *node_entry )

{

sym_value_entry_type		*val_node;

sym_widget_entry_type		*widget_node;

sym_module_entry_type		*module_node;

sym_list_entry_type		*list_node;

sym_obj_entry_type		*list_entry;

sym_root_entry_type		*root_node;

sym_include_file_entry_type	*ifile_node;

sym_section_entry_type		*section_node;

/*

 * No action on null node. Else dump and processing is based on the kind

 * of the current node.

 */

if ( node_entry == NULL ) return;

sym_dump_symbol (node_entry);

switch ( node_entry->header.b_tag )

    {

    case sym_k_value_entry:

        val_node = (sym_value_entry_type *) node_entry;

	UilDumpSymbolTable ((sym_entry_type *)val_node->az_charset_value);

	UilDumpSymbolTable ((sym_entry_type *)val_node->az_first_table_value);

	UilDumpSymbolTable ((sym_entry_type *)val_node->az_next_table_value);

	UilDumpSymbolTable ((sym_entry_type *)val_node->az_exp_op1);

	UilDumpSymbolTable ((sym_entry_type *)val_node->az_exp_op2);

	break;

    case sym_k_widget_entry:

    case sym_k_gadget_entry:

    case sym_k_child_entry:

	widget_node = (sym_widget_entry_type *) node_entry;

	UilDumpSymbolTable ((sym_entry_type *)widget_node->az_callbacks);

	UilDumpSymbolTable ((sym_entry_type *)widget_node->az_arguments);

	UilDumpSymbolTable ((sym_entry_type *)widget_node->az_controls);

	UilDumpSymbolTable ((sym_entry_type *)widget_node->az_create_proc);

	break;

    case sym_k_module_entry:

	module_node = (sym_module_entry_type *) node_entry;

	UilDumpSymbolTable ((sym_entry_type *)module_node->az_version);

	UilDumpSymbolTable ((sym_entry_type *)module_node->az_character_set);

	UilDumpSymbolTable ((sym_entry_type *)module_node->az_case_sense);

	UilDumpSymbolTable ((sym_entry_type *)module_node->az_def_obj);

	break;

    case sym_k_list_entry:

	/*

	 * Sublists (nested lists) are not processed recursively to

	 * pick up definitions, since all named lists are picked up

	 * in their list sections. We assume no list of interest to

	 * us can possibly be encountered only in a nested list reference.

	 */

	list_node = (sym_list_entry_type *) node_entry;

	for (list_entry=(sym_obj_entry_type *)

	         list_node->obj_header.az_next;

	     list_entry!=NULL;

	     list_entry=(sym_obj_entry_type *)

	         list_entry->obj_header.az_next)

	    UilDumpSymbolTable ((sym_entry_type *)list_entry);

	break;

    case sym_k_root_entry:

	root_node = (sym_root_entry_type *) node_entry;

	UilDumpSymbolTable ((sym_entry_type *)root_node->module_hdr);

	UilDumpSymbolTable ((sym_entry_type *)root_node->sections);

	break;

    case sym_k_include_file_entry:

	ifile_node = (sym_include_file_entry_type *) node_entry;

	UilDumpSymbolTable ((sym_entry_type *)ifile_node->sections);

	break;

    case sym_k_section_entry:

	section_node = (sym_section_entry_type *) node_entry;

	switch ( section_node->header.b_type )

	    {

	    case sym_k_section_tail:

		break;

	    default:

		UilDumpSymbolTable ((sym_entry_type *)section_node->next);

		UilDumpSymbolTable ((sym_entry_type *)section_node->entries);

		break;

	    }

	break;

    }

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This procedure dumps the symbol table.

**

**  FORMAL PARAMETERS:

**

**      none

**

**  IMPLICIT INPUTS:

**

**

**  IMPLICIT OUTPUTS:

**

**      none

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      symbol table is dump with the debug output

**

**--

**/

void

sym_dump_symbols( void )

{

int				ndx;

sym_entry_type			*cur_entry;

/*

 * Loop over all entries which have been allocated. They are in

 * allocation order (this will include deleted entries).

 */

_debug_output( "\nSymbol Table Dump: \n\n" );

for ( ndx=0 ; ndx

    {

    cur_entry = (sym_entry_type *) UrmPlistPtrN (sym_az_allocated_nodes, ndx);

    sym_dump_symbol (cur_entry);

    }

_debug_output ("\n\n");

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This procedure dumps a symbol node.

**

**  FORMAL PARAMETERS:

**

**      az_symbol_entry			symbol node to be dumped

**

**  IMPLICIT INPUTS:

**

**

**  IMPLICIT OUTPUTS:

**

**      none

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      symbol is dumped to the debug output

**

**--

**/

void

sym_dump_symbol (sym_entry_type *az_symbol_entry)

{

    switch (az_symbol_entry->header.b_tag) {

	case sym_k_name_entry:

		sym_dump_name((sym_name_entry_type *) az_symbol_entry );

		break;

	case sym_k_module_entry:

		sym_dump_module((sym_module_entry_type *) az_symbol_entry );

		break;

	case sym_k_value_entry:

		sym_dump_value((sym_value_entry_type *) az_symbol_entry );

		break;

	case sym_k_widget_entry:

	case sym_k_gadget_entry:

	case sym_k_child_entry:

		sym_dump_widget((sym_widget_entry_type *) az_symbol_entry );

		break;

	case sym_k_forward_ref_entry:

		sym_dump_forward_ref((sym_forward_ref_entry_type *) az_symbol_entry );

		break;

	case sym_k_external_def_entry:

		sym_dump_external_def((sym_external_def_entry_type *) az_symbol_entry );

		break;

	case sym_k_proc_def_entry:

		sym_dump_proc_def((sym_proc_def_entry_type *) az_symbol_entry );

		break;

	case sym_k_proc_ref_entry:

		sym_dump_proc_ref((sym_proc_ref_entry_type *) az_symbol_entry );

		break;

	case sym_k_control_entry:

		sym_dump_control((sym_control_entry_type *) az_symbol_entry );

		break;

	case sym_k_argument_entry:

		sym_dump_argument((sym_argument_entry_type *) az_symbol_entry );

		break;

	case sym_k_callback_entry:

		sym_dump_callback((sym_callback_entry_type *) az_symbol_entry );

		break;

	case sym_k_list_entry:

		sym_dump_list((sym_list_entry_type *) az_symbol_entry );

		break;

	case sym_k_color_item_entry:

		sym_dump_color_item((sym_color_item_entry_type *) az_symbol_entry );

		break;

	case sym_k_parent_list_entry:

		sym_dump_parent_list_item((sym_parent_list_type *) az_symbol_entry );

		break;

	case sym_k_include_file_entry:

		sym_dump_include_file ((sym_include_file_entry_type *)az_symbol_entry);

		break;

	case sym_k_section_entry:

		sym_dump_section ((sym_section_entry_type *)az_symbol_entry);

		break;

	case sym_k_def_obj_entry:

		sym_dump_object_variant ((sym_def_obj_entry_type *)az_symbol_entry);

		break;

	case sym_k_root_entry:

		sym_dump_root_entry ((sym_root_entry_type *)az_symbol_entry);

		break;

	default:

	    {

		int	    *l_array;

		int	    i;

		_debug_output("%x  unknown type: %d  size: %d  byte: %x\n", 

			      az_symbol_entry,

			      az_symbol_entry->header.b_tag,

			      az_symbol_entry->header.w_node_size,

			      az_symbol_entry->header.b_type );

		l_array = (int *) az_symbol_entry->b_value;

		for (i=0;  i<(int)(az_symbol_entry->header.w_node_size-1);  i++)

		    _debug_output( "\t%x", l_array[ i ] );

		_debug_output("\n");

		break;

	    }

	}

    sym_dump_source_info(( sym_entry_header_type *)az_symbol_entry);

    _debug_output("\n");

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This function dumps an object entry in the symbol table

**

**  FORMAL PARAMETERS:

**

**      az_widget_entry	    pointer to the object

**

**  IMPLICIT INPUTS:

**

**      none

**

**  IMPLICIT OUTPUTS:

**

**      none

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      symbolic representation of the object appears as part of the

**	debug output

**

**--

**/

void

sym_dump_widget( XmConst sym_widget_entry_type *az_widget_entry )

{

    sym_dump_obj_header ((sym_obj_entry_type *)az_widget_entry);

    _debug_output (

	"  %s %s  controls: %x  callbacks: %x  arguments: %x  parent_list: %x\n", 

	    diag_object_text( az_widget_entry->header.b_type),

	    diag_tag_text( az_widget_entry->header.b_tag ),

	    az_widget_entry->az_controls,

	    az_widget_entry->az_callbacks,

	    az_widget_entry->az_arguments,

        az_widget_entry->parent_list);

    if (az_widget_entry->az_create_proc != NULL) {

	_debug_output ("  create proc: %x\n",

			az_widget_entry->az_create_proc);

    }

    /* preserve comments */

    _debug_output ("\n Comment: %s\n", az_widget_entry->obj_header.az_comment);

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This function dumps an argument entry in the symbol table

**

**  FORMAL PARAMETERS:

**

**      az_argument_entry	pointer to the argument

**

**  IMPLICIT INPUTS:

**

**      none

**

**  IMPLICIT OUTPUTS:

**

**      none

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      symbolic representation of the name appears as part of the

**	debug output

**

**--

**/

void

sym_dump_argument( XmConst sym_argument_entry_type *az_argument_entry )

{

    sym_dump_obj_header ((sym_obj_entry_type *)az_argument_entry);

    _debug_output ( "  arg name: %x  arg value: %x\n", 

	az_argument_entry->az_arg_name,

	az_argument_entry->az_arg_value );

}

/*

**++

**  FUNCTIONAL DESCRIPTION:

**

**      This function dumps a control entry in the symbol table

**

**  FORMAL PARAMETERS:

**

**      az_control_entry	pointer to the control

**

**  IMPLICIT INPUTS:

**

**      none

**

**  IMPLICIT OUTPUTS:

**

**      none

**

**  FUNCTION VALUE:

**

**      void

**

**  SIDE EFFECTS:

**

**      symbolic representation of the name appears as part of the

**	debug output

**

**--

**/

void

sym_dump_control( XmConst sym_control_entry_type *az_control_entry )

{

    sym_dump_obj_header ((sym_obj_entry_type *)az_control_entry);