1018 lines
23 KiB
C
1018 lines
23 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: UilDB.c /main/11 1996/11/21 20:03:11 drk $"
|
||
#endif
|
||
#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 <Mrm/MrmAppl.h>
|
||
#include <Mrm/Mrm.h>
|
||
|
||
#include "UilDefI.h"
|
||
|
||
#define X_INCLUDE_PWD_H
|
||
#define XOS_USE_XT_LOCKING
|
||
#include <X11/Xos_r.h>
|
||
#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);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
|
||
String get_root_dir_name()
|
||
{
|
||
int uid;
|
||
_Xgetpwparams pwd_buf;
|
||
struct passwd *pwd_value;
|
||
static char *ptr = NULL;
|
||
char *outptr;
|
||
|
||
if (ptr == NULL)
|
||
{
|
||
if((ptr = (char *)getenv("HOME")) == NULL)
|
||
{
|
||
if((ptr = (char *)getenv(USER_VAR)) != NULL)
|
||
{
|
||
pwd_value = _XGetpwnam(ptr, pwd_buf);
|
||
}
|
||
else
|
||
{
|
||
uid = getuid();
|
||
pwd_value = _XGetpwuid(uid, pwd_buf);
|
||
}
|
||
if (pwd_value != NULL)
|
||
{
|
||
ptr = pwd_value->pw_dir;
|
||
}
|
||
else
|
||
{
|
||
ptr = "";
|
||
}
|
||
}
|
||
}
|
||
|
||
outptr = XtMalloc (strlen(ptr) + 2);
|
||
strcpy (outptr, ptr);
|
||
strcat (outptr, "/");
|
||
return outptr;
|
||
}
|
||
|
||
/*
|
||
* XAPPLRES_DEFAULT and UIDPATH_DEFAULT are intentionally split to support
|
||
* SCCS. DO NOT reformat the lines else %-N-%-S could be converted by SCCS into
|
||
* something totally bizarre causing MrmOpenHierarchy failures.
|
||
*/
|
||
|
||
/* The following are usually defined in the Makefile */
|
||
|
||
#ifndef LIBDIR
|
||
#define LIBDIR "/usr/lib/X11"
|
||
#endif
|
||
#ifndef INCDIR
|
||
#define INCDIR "/usr/include/X11"
|
||
#endif
|
||
|
||
static char libdir[] = LIBDIR;
|
||
static char incdir[] = INCDIR;
|
||
|
||
static char XAPPLRES_DEFAULT[] = "\
|
||
%%N\
|
||
%%S:\
|
||
%s/%%T/%%N\
|
||
%%S:\
|
||
%s%%T/%%N\
|
||
%%S:\
|
||
%s%%N\
|
||
%%S:\
|
||
%s/%%T/%%N\
|
||
%%S:\
|
||
%s/%%T/%%N\
|
||
%%S";
|
||
|
||
static char WMDPATH_DEFAULT[] = "\
|
||
%%N\
|
||
%%S:\
|
||
%s%%T/%%N\
|
||
%%S:\
|
||
%s%%N\
|
||
%%S:\
|
||
%s/%%L/%%T/%%N\
|
||
%%S:\
|
||
%s/%%T/%%N\
|
||
%%S";
|
||
|
||
static char ABSOLUTE_PATH[] = "\
|
||
%N\
|
||
%S";
|
||
|
||
String init_wmd_path(filename)
|
||
String filename ;
|
||
{
|
||
String path;
|
||
String old_path;
|
||
String homedir;
|
||
String wmd_path;
|
||
|
||
|
||
if (filename[0] == '/')
|
||
{
|
||
wmd_path = XtMalloc(strlen(ABSOLUTE_PATH));
|
||
strcpy (wmd_path, ABSOLUTE_PATH);
|
||
}
|
||
else
|
||
{
|
||
path = (char *)getenv ("WMDPATH");
|
||
if (path == NULL)
|
||
{
|
||
homedir = get_root_dir_name();
|
||
old_path = (char *)getenv ("XAPPLRESDIR");
|
||
if (old_path == NULL)
|
||
{
|
||
wmd_path = XtCalloc(1, 2*strlen(homedir) +
|
||
strlen(libdir) + strlen(incdir) +
|
||
strlen(WMDPATH_DEFAULT));
|
||
sprintf( wmd_path, WMDPATH_DEFAULT,
|
||
homedir, homedir, libdir, incdir);
|
||
}
|
||
else
|
||
{
|
||
wmd_path = XtCalloc(1, 1*strlen(old_path) + 2*strlen(homedir) +
|
||
strlen(libdir) + strlen(incdir) +
|
||
strlen(XAPPLRES_DEFAULT));
|
||
sprintf(wmd_path, XAPPLRES_DEFAULT,
|
||
old_path,
|
||
homedir, homedir, libdir, incdir);
|
||
}
|
||
XtFree (homedir);
|
||
}
|
||
else
|
||
{
|
||
wmd_path = XtMalloc(strlen(path) + 1);
|
||
strcpy (wmd_path, path);
|
||
free (path);
|
||
}
|
||
}
|
||
return (wmd_path);
|
||
}
|