/* 

 * 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: UilDB.c /main/11 1996/11/21 20:03:11 drk $"

#endif

#endif

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

/*

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

/*

 *++

 *  FACILITY:

 *

 *      UIL Bindary Database :

 *

 *  ABSTRACT:

 *

 *--

 */

/*

 * This file contains routines which change the internal tables of UIL based on

 * a binary data base parameter in the command line 

 */

/*

 *

 *  INCLUDE FILES

 *

 */

#ifndef X_NOT_STDC_ENV

#include <stdlib.h>

#include <unistd.h>

#endif

#include "UilDefI.h"

#define X_INCLUDE_PWD_H

#define XOS_USE_XT_LOCKING

#ifdef HAVE_X11_XOS_R_H

#include <X11/Xos_r.h>

#else

#include <Xm/Xmos_r.h>

#endif

#include <stdio.h>

/*

 *

 *  TABLE OF CONTENTS

 *

 *

 */

/*

 *

 *  DEFINE and MACRO DEFINITIONS

 *

 */

#define _check_read( __number_returned ) \

	if (( (__number_returned) != 1) || (feof(dbfile)) || (ferror(dbfile)) ) \

	{  diag_issue_diagnostic( d_bad_database, diag_k_no_source, diag_k_no_column ); } 

/*

 *

 *  EXTERNAL VARIABLE DECLARATIONS

 *

 */

/*

 *

 *  GLOBAL VARIABLE DECLARATIONS

 *

 */

/*

 *

 *  OWN VARIABLE DECLARATIONS

 *

 */

static FILE *dbfile;

static int  num_bits;

void db_incorporate()

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine incorporate the binary database passed in the command line.

 *

 *

 *  FORMAL PARAMETERS:

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *  SIDE EFFECTS:

 *

 *--

 */

/*

 *  External Functions

 */

/*

 *  Local variables

 */

{

    int			return_num_items;

    _db_header		header;

    _db_globals		globals;

    db_open_file();

    return_num_items = fread (&globals, sizeof(_db_globals), 1, dbfile);

    _check_read (return_num_items);

    /*

     * Some heuristics to see if this is a reasonable database.

     * The magic numbers are about 10 times as big as the DXm database

     * for DECWindows V3. The diagnostic does a fatal exit.

     */

    if ( globals.uil_max_arg>5000 ||

	 globals.uil_max_charset>200 ||

	 globals.charset_lang_table_max>1000 ||

	 globals.uil_max_object>500 ||

	 globals.uil_max_reason>1000 ||

	 globals.uil_max_enumval>3000 ||

	 globals.uil_max_enumset>1000 ||

	 globals.key_k_keyword_count>10000 ||

	 globals.key_k_keyword_max_length>200 ||

	 globals.uil_max_child>250)

	diag_issue_diagnostic (d_bad_database,

			       diag_k_no_source,

			       diag_k_no_column);

    uil_max_arg = globals.uil_max_arg ;

    uil_max_charset = globals.uil_max_charset ;

    charset_lang_table_max = globals.charset_lang_table_max ;

    uil_max_object = globals.uil_max_object ;

    uil_max_reason = globals.uil_max_reason ;

    uil_max_enumval = globals.uil_max_enumval ;

    uil_max_enumset = globals.uil_max_enumset ;

    key_k_keyword_count = globals.key_k_keyword_count ;

    key_k_keyword_max_length = globals.key_k_keyword_max_length ;

    uil_max_child = globals.uil_max_child;

    num_bits = (uil_max_object +7) / 8;

    if (globals.version > DB_Compiled_Version) 

	diag_issue_diagnostic( d_future_version, diag_k_no_source, diag_k_no_column );

    for (;;) 

	{

	return_num_items = fread (&header, sizeof(_db_header), 1, dbfile);

	if (feof(dbfile)) break;

	_check_read (return_num_items);

	switch (header.table_id)

	    {

	    case Constraint_Tab:

		constraint_tab = (unsigned char *) XtMalloc (header.table_size);

		return_num_items = fread (constraint_tab, 

					     sizeof(unsigned char) * header.num_items,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Argument_Type_Table_Value:

		/*

		 * NOTE: The first entry is not used but we copy it anyway

		 */

		argument_type_table = (unsigned char *) XtMalloc (header.table_size);

		return_num_items = fread (argument_type_table,

					     sizeof(unsigned char) * header.num_items,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Child_Class_Table:

		/*

		 * NOTE: The first entry is not used but we copy it anyway

		 */

		child_class_table = 

		  (unsigned char *) XtMalloc (header.table_size);

		return_num_items = 

		  fread (child_class_table,

			 sizeof(unsigned char) * header.num_items, 1, dbfile);

		_check_read (return_num_items);

		break;

	    case Charset_Wrdirection_Table:

		charset_writing_direction_table = (unsigned char *) XtMalloc (header.table_size);

		return_num_items = fread (charset_writing_direction_table, 

					     sizeof(unsigned char) * header.num_items,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Charset_Parsdirection_Table:

		charset_parsing_direction_table = (unsigned char *) XtMalloc (header.table_size);

		return_num_items = fread (charset_parsing_direction_table, 

					     sizeof(unsigned char) * header.num_items,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Charset_Charsize_Table:

		charset_character_size_table = (unsigned char *) XtMalloc (header.table_size);

		return_num_items = fread (charset_character_size_table, 

					     sizeof(unsigned char) * header.num_items,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Key_Table:

	    case Key_Table_Case_Ins:

		db_read_ints_and_string (&header);

		break;

	    case Allowed_Argument_Table:

	    case Allowed_Child_Table:

	    case Allowed_Control_Table:

	    case Allowed_Reason_Table:

		db_read_char_table (&header);

		break;

	    case Charset_Xmstring_Names_Table:

	    case Charset_Lang_Names_Table:

	    case Uil_Widget_Names:

	    case Uil_Children_Names:

	    case Uil_Argument_Names:

	    case Uil_Reason_Names:

	    case Uil_Enumval_names:

	    case Uil_Charset_Names:

	    case Uil_Widget_Funcs:

	    case Uil_Argument_Toolkit_Names:

	    case Uil_Reason_Toolkit_Names:

		db_read_length_and_string (&header);

		break;

	    case Charset_Lang_Codes_Table:

		charset_lang_codes_table = (unsigned short int *) XtMalloc (header.table_size);

		return_num_items = fread (charset_lang_codes_table, 

					     header.table_size,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Argument_Enum_Set_Table:

		argument_enumset_table = (unsigned short int *) XtMalloc (header.table_size);

		return_num_items = fread (argument_enumset_table, 

					     header.table_size,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Related_Argument_Table:

		related_argument_table = (unsigned short int *) XtMalloc (header.table_size);

		return_num_items = fread (related_argument_table, 

					     header.table_size,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Uil_Gadget_Funcs:

		uil_gadget_variants = (unsigned short int *) XtMalloc (header.table_size);

		return_num_items = fread (uil_gadget_variants, 

					     header.table_size,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Uil_Urm_Nondialog_Class:

		uil_urm_nondialog_class = (unsigned short int *) XtMalloc (header.table_size);

		return_num_items = fread (uil_urm_nondialog_class, 

					     header.table_size,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Uil_Urm_Subtree_Resource:

		uil_urm_subtree_resource = (unsigned short int *) XtMalloc (header.table_size);

		return_num_items = fread (uil_urm_subtree_resource, 

					     header.table_size,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    case Enum_Set_Table:

		db_read_int_and_shorts(&header);

		break;

	    case Enumval_Values_Table:

		enumval_values_table = (int *) XtMalloc (header.table_size);

		return_num_items = fread (enumval_values_table, 

					     header.table_size,

					     1, dbfile);

		_check_read (return_num_items);

		break;

	    default:

		diag_issue_diagnostic( d_bad_database, diag_k_no_source, diag_k_no_column );

	    } /* end switch */

	} /* end for */

    fclose (dbfile);

    return;

}

void db_read_ints_and_string(header)

    _db_header_ptr   header;

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine reads in tables of integers and one string unsigned chars and places them into 

 *	memory. It will Malloc new space for the table. The tables supported

 *	this routine are:

 *

 *	    Key_Table:

 *	    Key_Table_Case_Ins:

 *

 *

 *  FORMAL PARAMETERS:

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *  SIDE EFFECTS:

 *

 *--

 */

{

/*

 *  External Functions

 */

/*

 *  Local variables

 */

	int			return_num_items, i, string_size=0;

	key_keytable_entry_type	*table;

	char			*string_table;

	switch (header->table_id)

	    {

	    /*

	     * NOTE: Calloc is used here to protect against bad

	     *	     pointers.

	     */

	    case Key_Table:

		key_table = (key_keytable_entry_type *) XtCalloc (1, header->table_size);

		table = key_table;

		break;

	    case Key_Table_Case_Ins:

		key_table_case_ins = (key_keytable_entry_type *) XtCalloc (1, header->table_size);

		table = key_table_case_ins;

		break;

	    default:

		diag_issue_internal_error ("Bad table_id in db_read_ints_and_string");

	    }

	/* 

	 * Get the entire table with one read. 

	 * Then loop through the table and up the length of the strings.

	 * Get all the strings with one read.

	 * Reassign the addresses

	 */

	return_num_items = fread(table, header->table_size, 1, dbfile);

	_check_read (return_num_items);

	for ( i=0 ; i<header->num_items; i++)

	    {

	    /*

	     * Add one for the null character on the string

	     */

	    string_size += table[i].b_length + 1;

	    };

	string_table = XtMalloc (sizeof (char) * string_size);

	return_num_items = fread(string_table, 

				    sizeof(unsigned char) * string_size,

				    1, dbfile);

	_check_read (return_num_items);

	for ( i=0 ; i<header->num_items; i++)

	    {

	    table[i].at_name = string_table;

	    string_table +=  table[i].b_length + 1; 

	    };

	return;

}

void db_read_char_table(header)

    _db_header_ptr   header;

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine reads in tables of unsigned chars and places them into 

 *	memory. It will Malloc new space for the table. The tables supported

 *	this routine are:

 *

 *	    Allowed_Argument_Table:

 *	    Allowed_Child_Table:

 *	    Allowed_Control_Table:

 *	    Allowed_Reason_Table:

 *

 *

 *  FORMAL PARAMETERS:

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *  SIDE EFFECTS:

 *

 *--

 */

{

/*

 *  External Functions

 */

/*

 *  Local variables

 */

	unsigned char	**ptr;

	int		return_num_items, i;

	unsigned char	*table;

	switch (header->table_id)

	    {

	    /*

	     * NOTE: Calloc is used here to protect against bad

	     *	     pointers.

	     */

	    case Allowed_Argument_Table:

		allowed_argument_table = (unsigned char **) XtCalloc (1, header->table_size);

		ptr = allowed_argument_table;

		break;

	    case Allowed_Child_Table:

		allowed_child_table = 

		  (unsigned char **) XtCalloc (1, header->table_size);

		ptr = allowed_child_table;

		break;

	    case Allowed_Control_Table:

		allowed_control_table = (unsigned char **) XtCalloc (1, header->table_size);

		ptr = allowed_control_table;

		break;

	    case Allowed_Reason_Table:

		allowed_reason_table = (unsigned char **) XtCalloc (1, header->table_size);

		ptr = allowed_reason_table;

		break;

	    default:

		diag_issue_internal_error ("Bad table_id in db_read_char_table");

	}

	/*

	 * Read in the entire table contents in one whack.

	 * Then go through the table and set the addresses

	 */

	table = (unsigned char *) XtMalloc (sizeof (unsigned char) * header->num_items * num_bits);

	return_num_items = fread(table, 

				    sizeof(char) * num_bits * header->num_items,

				    1, dbfile);

	_check_read (return_num_items);

	for ( i=1 ; i<=header->num_items; i++ )

	    {

	    ptr[i] = table;

	    table += num_bits;

	    };

	return;

}

void db_read_length_and_string(header)

    _db_header_ptr   header;

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine reads in length and strings of unsigned chars and places them into 

 *	memory. It will Malloc new space for the table. The tables supported

 *	this routine are:

 *

 *	    Charset_Xmstring_Names_Table:

 *	    Charset_Lang_Names_Table:

 *	    Uil_Widget_Names:

 *	    Uil_Children_Names:

 *	    Uil_Argument_Names:

 *	    Uil_Reason_Names:

 *	    Uil_Enumval_names:

 *	    Uil_Charset_Names:

 *	    Uil_Widget_Funcs:

 *	    Uil_Argument_Toolkit_Names:

 *	    Uil_Reason_Toolkit_Names:

 *

 *

 *  FORMAL PARAMETERS:

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *  SIDE EFFECTS:

 *

 *--

 */

{

/*

 *  External Functions

 */

/*

 *  Local variables

 */

	int		return_num_items, i, string_size=0;

	int		*lengths;

	char		*string_table;

	char		**table;

	switch (header->table_id)

	    {

	    /*

	     * NOTE: Calloc is used here because it might be possible to

	     *	     have a string of zero length, particularly for the

	     *	     first record. Ergo we Calloc to protect against bad

	     *	     pointers.

	     */

	    case Charset_Xmstring_Names_Table:

		charset_xmstring_names_table = (char **) XtCalloc (1, header->table_size);

		table = charset_xmstring_names_table;

		break;

	    case Charset_Lang_Names_Table:

		charset_lang_names_table = (char **) XtCalloc (1, header->table_size);

		table = charset_lang_names_table;

		break;

	    case Uil_Widget_Names:

		uil_widget_names = (char **) XtCalloc (1, header->table_size);

		table = uil_widget_names ;

		break;

	    case Uil_Children_Names:

		uil_child_names = (char **) XtCalloc (1, header->table_size);

		table = uil_child_names ;

		break;

	    case Uil_Argument_Names:

		uil_argument_names = (char **) XtCalloc (1, header->table_size);

		table = uil_argument_names;

		break;

	    case Uil_Reason_Names:

		uil_reason_names = (char **) XtCalloc (1, header->table_size);

		table = uil_reason_names;

		break;

	    case Uil_Enumval_names:

		uil_enumval_names = (char **) XtCalloc (1, header->table_size);

		table = uil_enumval_names;

		break;

	    case Uil_Charset_Names:

		uil_charset_names = (char **) XtCalloc (1, header->table_size);

		table = uil_charset_names;

		break;

	    case Uil_Widget_Funcs:

		uil_widget_funcs = (char **) XtCalloc (1, header->table_size);

		table = uil_widget_funcs;

		break;

	    case Uil_Argument_Toolkit_Names:

		uil_argument_toolkit_names = (char **) XtCalloc (1, header->table_size);

		table = uil_argument_toolkit_names;

		break;

	    case Uil_Reason_Toolkit_Names:

		uil_reason_toolkit_names = (char **) XtCalloc (1, header->table_size);

		table = uil_reason_toolkit_names;

		break;

	    default:

		diag_issue_internal_error ("Bad table_id in db_read_length_and_string");

	    }

	/* 

	 * Get the lengths of all the strings with one read.  

	 * Then loop through the table and up the length of the strings.

	 * Get all the strings with one read. 

	 * Reassign the addresses using the length table and string table.

	 * Cleanup by Freeing length table.

	 * 

	 * NOTE: In some tables the counting starts at 1 not 0 so you

	 *	 have to be carefull.

	 */

	lengths = (int *) XtMalloc (sizeof (int) * (header->num_items + 1));

	return_num_items = fread(lengths, 

				    sizeof(int) * (header->num_items + 1),

				    1, dbfile);

	_check_read (return_num_items);

	for ( i=0 ; i<=header->num_items; i++)

	    {

	    /*

	     * Add one for the null terminator

	     */

	    if (lengths[i])

		{

		string_size += lengths[i] + 1;

		}

	    }

	string_table = XtMalloc (sizeof (unsigned char) * string_size);

	return_num_items = fread(string_table, 

				    sizeof(unsigned char) * string_size,

				    1, dbfile);

	_check_read (return_num_items);

	for ( i=0 ; i<=header->num_items; i++)

	    {

	    if (lengths[i])

		{

		table[i] = string_table;

/* BEGIN HaL Fix CR 5618 */

		  if ((header->table_id == Uil_Widget_Names) &&

		      (strcmp(table[i], "user_defined") == 0))

		    uil_sym_user_defined_object = i;

/* END HaL Fix CR 5618 */

		string_table +=  lengths[i] + 1;

		}

	    }

	XtFree ((char *)lengths);

	return;

}

void db_read_int_and_shorts(header)

    _db_header_ptr   header;

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine reads in a structure consisting of one integer and a 

 *	pointer to a table of integer and places them into 

 *	memory. It will Malloc new space for the table. The tables supported

 *	this routine are:

 *

 *	    Enum_Set_Table:

 *

 *

 *  FORMAL PARAMETERS:

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *  SIDE EFFECTS:

 *

 *--

 */

{

/*

 *  External Functions

 */

/*

 *  Local variables

 */

	int			return_num_items, i, int_table_size=0;

	UilEnumSetDescDef	*table;

	unsigned short int 	*int_table;

	switch (header->table_id)

	    {

	    case Enum_Set_Table:

		enum_set_table = (UilEnumSetDescDef *) XtCalloc (1, header->table_size);

		table = enum_set_table;

		break;

	    default:

		diag_issue_internal_error ("Bad table_id in db_read_int_shorts");

	    }

	/* 

	 * Get the entire table with one read. 

	 * Then loop through the table and add up the number of ints in each int table.

	 * Get all the integer tables with one read.

	 * Reassign the addresses of the tables.

	 */

	return_num_items = fread(table, header->table_size, 1, dbfile);

	_check_read (return_num_items);

	for ( i=0 ; i<=header->num_items; i++)

	    {

	    int_table_size += table[i].values_cnt;

	    }

	int_table = (unsigned short int *) XtCalloc (1, sizeof (short) * int_table_size);

	return_num_items = fread(int_table, 

				    sizeof(short) * int_table_size,

				    1, dbfile);

	_check_read (return_num_items);

	for ( i=0 ; i<=header->num_items; i++)

	    {

	    if (table[i].values_cnt)

		{

		table[i].values = int_table;

		int_table += table[i].values_cnt;

		}

	    }

	return;

}

void db_open_file ()

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	This routine opens the binary database file in a platform-dependent way,

 *	performing i18n language switching in order to do so.

 *

 *	Per the latest agreement on semantics, this routine does:

 *		- first, try to open in the local directory (that is, with

 *		  no switching).

 *		- second, try language switching and open

 *

 *  FORMAL PARAMETERS:

 *

 *	name		A system-dependent string specifying the IDB file

 *			to be opened.

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *  SIDE EFFECTS:

 *

 *--

 */

{

/*

 *  External Functions

 */

/*

 *  Local variables

 */

	char			*resolvedname;		/* current resolved name */

	SubstitutionRec		subs[3];

	char			*wmdPath;

	/*

	 * Use XtFindFile instead of XtResolvePathName. XtResolvePathName requires a

	 * display which UIL doesn't have. At the current time there is no support for

	 * $LANG in the path string. If such support was deamed necessary, the %L, %l,

	 * %t, %c values would be set up as subs here using globals from the fetch of

	 * LANG variable used to determine the default codeset (or vice versa depending

	 * on which is called first) 

	 *

	 * If the last 4 characters of the file name are not .bdb

	 * then pass in the suffix of .bdb. If a file isn't found with the suffix passed

	 * in then try without the suffix.

	 */

	/*

	 * Make sure 'S' is the last one so we can remove the suffix for the first pass.

	 */

	subs[0].match = 'N';

	subs[0].substitution = Uil_cmd_z_command.ac_database;

	subs[1].match = 'T';

	subs[1].substitution = "wmd";

	subs[2].match = 'S';

	subs[2].substitution = ".wmd";

	wmdPath = init_wmd_path(Uil_cmd_z_command.ac_database);

	resolvedname = 0;

	/*

	 * Check and see if the .wmd suffix is already on the file. If not then try to

	 * resolve the pathname with .wmd suffix first. If that fails or the suffix is

	 * already on the file then just try to resolve the pathname.

	 */

	if ( strcmp (&Uil_cmd_z_command.ac_database[strlen(Uil_cmd_z_command.ac_database)-4],".wmd") != 0 ) 

		resolvedname = XtFindFile(wmdPath,

					      subs,

					      XtNumber(subs),

					      (XtFilePredicate)NULL);

	/*

	 * No .wmd suffix or a failure to resolve the pathname with the .wmd suffix

	 * Try without the suffix.

	 */

	subs[2].substitution = "";

	if (resolvedname == 0) 

		resolvedname = XtFindFile(wmdPath,

					      subs,

					      XtNumber(subs),

					      (XtFilePredicate)NULL);

	if (resolvedname == 0)

	    {

	    diag_issue_diagnostic( d_wmd_open,

				   diag_k_no_source, diag_k_no_column,

				   Uil_cmd_z_command.ac_database);

	    }

	dbfile = fopen (resolvedname, "r");

	/* If the file is not found, a fatal error is generated.	*/

	if (dbfile == NULL)

	    {

	    diag_issue_diagnostic( d_src_open,

				   diag_k_no_source, diag_k_no_column,

				   resolvedname);

	    }