Subversion Repositories tendra.SVN

/*

    		 Crown Copyright (c) 1997

    This TenDRA(r) Computer Program is subject to Copyright

    owned by the United Kingdom Secretary of State for Defence

    acting through the Defence Evaluation and Research Agency

    (DERA).  It is made available to Recipients with a

    royalty-free licence for its use, reproduction, transfer

    to other parties and amendment for any purpose not excluding

    product development provided that any such use et cetera

    shall be deemed to be acceptance of the following conditions:-

        (1) Its Recipients shall ensure that this Notice is

        reproduced upon any copies or amended versions of it;

        (2) Any amended version of it shall be clearly marked to

        show both the nature of and the organisation responsible

        for the relevant amendment or amendments;

        (3) Its onward transfer from a recipient to another

        party shall be deemed to be that party's acceptance of

        these conditions;

        (4) DERA gives no warranty or assurance as to its

        quality or suitability for any purpose and DERA accepts

        no liability whatsoever in relation to any use to which

        it may be put.

*/

/**** arg-data.c --- Command line argument data ADT.

 *

 ** Author: Steve Folkes <smf@hermes.mod.uk>

 *

 **** Commentary:

 *

 * This file implements the ADT that stores the information on the various

 * command line options that were given to the TDF linker.

 *

 **** Change Log:

 * $Log: arg-data.c,v $

 * Revision 1.1.1.1  1998/01/17  15:57:16  release

 * First version to be checked into rolling release.

 *

 * Revision 1.4  1995/09/22  08:36:58  smf

 * Fixed problems with incomplete structures (to shut "tcc" up).

 *

 * Revision 1.3  1995/07/07  15:31:54  smf

 * Updated to support TDF specification 4.0.

 *

 * Revision 1.2  1994/12/12  11:43:52  smf

 * Performing changes for 'CR94_178.sid+tld-update' - bringing in line with

 * OSSG C Coding Standards.

 *

 * Revision 1.1.1.1  1994/07/25  16:03:22  smf

 * Initial import of TDF linker 3.5 non shared files.

 *

**/

/****************************************************************************/

#include "arg-data.h"

#include "capsule.h"

#include "gen-errors.h"

#include "solve-cycles.h"

/*--------------------------------------------------------------------------*/

static void

shape_control_init PROTO_N ((control))

		   PROTO_T (ShapeControlP control)

{

    control->head = NIL (ShapeControlEntryP);

}

static ShapeControlEntryP

shape_control_find PROTO_N ((control, shape))

		   PROTO_T (ShapeControlP control X

			    CStringP      shape)

{

    NStringT           nstring;

    ShapeControlEntryP entry;

    nstring_copy_cstring (&nstring, shape);

    for (entry = control->head; entry; entry = entry->next) {

	if (nstring_equal (&nstring, &(entry->shape))) {

	    nstring_destroy (&nstring);

	    return (entry);

	}

    }

    entry             = ALLOCATE (ShapeControlEntryT);

    entry->next       = control->head;

    nstring_assign (&(entry->shape), &nstring);

    entry->all        = FALSE;

    name_key_list_init (&(entry->names));

    control->head     = entry;

    return (entry);

}

static void

shape_control_entry_add_name PROTO_N ((entry, name))

			     PROTO_T (ShapeControlEntryP entry X

				      CStringP           name)

{

    NameKeyT key;

    if (name_key_parse_cstring (&key, name)) {

	name_key_list_add (&(entry->names), &key);

    } else {

	E_illegal_external_name (name);

    }

}

static void

shape_control_entry_set PROTO_N ((entry))

			PROTO_T (ShapeControlEntryP entry)

{

    entry->all = TRUE;

}

/*--------------------------------------------------------------------------*/

static void

rename_control_init PROTO_N ((control))

		    PROTO_T (RenameControlP control)

{

    control->head = NIL (RenameControlEntryP);

}

static RenameControlEntryP

rename_control_find PROTO_N ((control, shape))

		    PROTO_T (RenameControlP control X

			     NStringP       shape)

{

    RenameControlEntryP entry;

    for (entry = control->head; entry; entry = entry->next) {

	if (nstring_equal (shape, &(entry->shape))) {

	    return (entry);

	}

    }

    entry             = ALLOCATE (RenameControlEntryT);

    entry->next       = control->head;

    nstring_copy (&(entry->shape), shape);

    name_key_pair_list_init (&(entry->names));

    control->head     = entry;

    return (entry);

}

static NameKeyPairListP

rename_control_entry_names PROTO_N ((entry))

			   PROTO_T (RenameControlEntryP entry)

{

    return (&(entry->names));

}

static void

rename_control_entry_parse_pair PROTO_N ((entry, from, to))

				PROTO_T (RenameControlEntryP entry X

					 CStringP            from X

					 CStringP            to)

{

    NStringP shape = &(entry->shape);

    NameKeyT from_key;

    NameKeyT to_key;

    if (!name_key_parse_cstring (&from_key, from)) {

	E_illegal_external_name (from);

    } else if (!name_key_parse_cstring (&to_key, to)) {

	E_illegal_external_name (to);

    } else if (!name_key_pair_list_add (&(entry->names), &from_key, &to_key)) {

	E_multiply_renamed_name (shape, &from_key);

	name_key_destroy (&from_key);

	name_key_destroy (&to_key);

    }

}

/*--------------------------------------------------------------------------*/

void

shape_control_iter PROTO_N ((control, proc, closure))

		   PROTO_T (ShapeControlP control X

			    void        (*proc) PROTO_S ((NStringP, BoolT,

							  NameKeyListP,

							  GenericP)) X

			    GenericP      closure)

{

    ShapeControlEntryP entry;

    for (entry = control->head; entry; entry = entry->next) {

	(*proc) (&(entry->shape), entry->all, &(entry->names), closure);

    }

}

void

rename_control_iter PROTO_N ((control, proc, closure))

		    PROTO_T (RenameControlP control X

			     void         (*proc) PROTO_S ((NStringP,

							    NameKeyPairListP,

							    GenericP)) X

			     GenericP       closure)

{

    RenameControlEntryP entry;

    for (entry = control->head; entry; entry = entry->next) {

	(*proc) (&(entry->shape), &(entry->names), closure);

    }

}

/*--------------------------------------------------------------------------*/

void

arg_data_init PROTO_N ((arg_data, default_output_file))

	      PROTO_T (ArgDataP arg_data X

		       CStringP default_output_file)

{

    arg_data->all_hide_defined    = FALSE;

    arg_data->suppress_mult       = FALSE;

    shape_control_init (&(arg_data->hides));

    shape_control_init (&(arg_data->keeps));

    shape_control_init (&(arg_data->suppresses));

    rename_control_init (&(arg_data->renames));

    arg_data->extract_all         = FALSE;

    arg_data->extract_basename    = FALSE;

    arg_data->extract_match_base  = FALSE;

    arg_data->content_index       = FALSE;

    arg_data->content_size        = FALSE;

    arg_data->content_version     = FALSE;

    ostream_init (&(arg_data->debug_file));

    arg_data->default_output_file = default_output_file;

    arg_data->output_file         = NIL (CStringP);

    arg_data->num_library_files   = 0;

    arg_data->num_library_paths   = 0;

    cstring_list_init (&arg_data->library.list.file);

    cstring_list_init (&(arg_data->library.list.path));

    arg_data->unit_file           = NIL (CStringP);

    arg_data->num_files           = 0;

}

void

arg_data_set_all_hide_defd PROTO_N ((arg_data, enable))

			   PROTO_T (ArgDataP arg_data X

				    BoolT    enable)

{

    arg_data->all_hide_defined = enable;

}

BoolT

arg_data_get_all_hide_defd PROTO_N ((arg_data))

			   PROTO_T (ArgDataP arg_data)

{

    return (arg_data->all_hide_defined);

}

void

arg_data_set_suppress_mult PROTO_N ((arg_data, enable))

			   PROTO_T (ArgDataP arg_data X

				    BoolT    enable)

{

    arg_data->suppress_mult = enable;

}

BoolT

arg_data_get_suppress_mult PROTO_N ((arg_data))

			   PROTO_T (ArgDataP arg_data)

{

    return (arg_data->suppress_mult);

}

void

arg_data_add_hide PROTO_N ((arg_data, shape, name))

		  PROTO_T (ArgDataP arg_data X

			   CStringP shape X

			   CStringP name)

{

    ShapeControlEntryP entry = shape_control_find (&(arg_data->hides), shape);

    shape_control_entry_add_name (entry, name);

}

void

arg_data_add_hide_defined PROTO_N ((arg_data, shape))

			  PROTO_T (ArgDataP arg_data X

				   CStringP shape)

{

    ShapeControlEntryP entry = shape_control_find (&(arg_data->hides), shape);

    shape_control_entry_set (entry);

}

ShapeControlP

arg_data_get_hides PROTO_N ((arg_data))

		   PROTO_T (ArgDataP arg_data)

{

    return (&(arg_data->hides));

}

void

arg_data_add_keep PROTO_N ((arg_data, shape, name))

		  PROTO_T (ArgDataP arg_data X

			   CStringP shape X

			   CStringP name)

{

    ShapeControlEntryP entry = shape_control_find (&(arg_data->keeps), shape);

    shape_control_entry_add_name (entry, name);

}

void

arg_data_add_keep_all PROTO_N ((arg_data, shape))

		      PROTO_T (ArgDataP arg_data X

			       CStringP shape)

{

    ShapeControlEntryP entry = shape_control_find (&(arg_data->keeps), shape);

    shape_control_entry_set (entry);

}

ShapeControlP

arg_data_get_keeps PROTO_N ((arg_data))

		   PROTO_T (ArgDataP arg_data)

{

    return (&(arg_data->keeps));

}

void

arg_data_add_suppress PROTO_N ((arg_data, shape, name))

		      PROTO_T (ArgDataP arg_data X

			       CStringP shape X

			       CStringP name)

{

    ShapeControlEntryP entry = shape_control_find (&(arg_data->suppresses),

						   shape);

    shape_control_entry_add_name (entry, name);

}

void

arg_data_add_suppress_all PROTO_N ((arg_data, shape))

			  PROTO_T (ArgDataP arg_data X

				   CStringP shape)

{

    ShapeControlEntryP entry = shape_control_find (&(arg_data->suppresses),

						   shape);

    shape_control_entry_set (entry);

}

ShapeControlP

arg_data_get_suppresses PROTO_N ((arg_data))

			PROTO_T (ArgDataP arg_data)

{

    return (&(arg_data->suppresses));

}

void

arg_data_add_rename PROTO_N ((arg_data, shape, from, to))

		    PROTO_T (ArgDataP arg_data X

			     NStringP shape X

			     NameKeyP from X

			     NameKeyP to)

{

    RenameControlEntryP entry;

    NameKeyPairListP    names;

    entry = rename_control_find (&(arg_data->renames), shape);

    names = rename_control_entry_names (entry);

    if (!name_key_pair_list_add (names, from, to)) {

	E_multiply_renamed_name (shape, from);

	name_key_destroy (from);

	name_key_destroy (to);

    }

}

void

arg_data_parse_rename PROTO_N ((arg_data, shape, from, to))

		      PROTO_T (ArgDataP arg_data X

			       CStringP shape X

			       CStringP from X

			       CStringP to)

{

    NStringT            nstring;

    RenameControlEntryP entry;

    nstring_copy_cstring (&nstring, shape);

    entry = rename_control_find (&(arg_data->renames), &nstring);

    nstring_destroy (&nstring);

    rename_control_entry_parse_pair (entry, from, to);

}

RenameControlP

arg_data_get_renames PROTO_N ((arg_data))

		     PROTO_T (ArgDataP arg_data)

{

    return (&(arg_data->renames));

}

void

arg_data_set_extract_all PROTO_N ((arg_data, enable))

			 PROTO_T (ArgDataP arg_data X

				  BoolT    enable)

{

    arg_data->extract_all = enable;

}

BoolT

arg_data_get_extract_all PROTO_N ((arg_data))

			 PROTO_T (ArgDataP arg_data)

{

    return (arg_data->extract_all);

}

void

arg_data_set_extract_basename PROTO_N ((arg_data, enable))

			      PROTO_T (ArgDataP arg_data X

				       BoolT    enable)

{

    arg_data->extract_basename = enable;

}

BoolT

arg_data_get_extract_basename PROTO_N ((arg_data))

			      PROTO_T (ArgDataP arg_data)

{

    return (arg_data->extract_basename);

}

void

arg_data_set_extract_match_base PROTO_N ((arg_data, enable))

				PROTO_T (ArgDataP arg_data X

					 BoolT    enable)

{

    arg_data->extract_match_base = enable;

}

BoolT

arg_data_get_extract_match_base PROTO_N ((arg_data))

				PROTO_T (ArgDataP arg_data)

{

    return (arg_data->extract_match_base);

}

void

arg_data_set_content_index PROTO_N ((arg_data, enable))

			   PROTO_T (ArgDataP arg_data X

				    BoolT    enable)

{

    arg_data->content_index = enable;

}

BoolT

arg_data_get_content_index PROTO_N ((arg_data))

			   PROTO_T (ArgDataP arg_data)

{

    return (arg_data->content_index);

}

void

arg_data_set_content_size PROTO_N ((arg_data, enable))

			  PROTO_T (ArgDataP arg_data X

				   BoolT    enable)

{

    arg_data->content_size = enable;

}

BoolT

arg_data_get_content_size PROTO_N ((arg_data))

			  PROTO_T (ArgDataP arg_data)

{

    return (arg_data->content_size);

}

void

arg_data_set_content_version PROTO_N ((arg_data, enable))

    			     PROTO_T (ArgDataP arg_data X

				      BoolT    enable)

{

    arg_data->content_version = enable;

}

BoolT

arg_data_get_content_version PROTO_N ((arg_data))

    			     PROTO_T (ArgDataP arg_data)

{

    return (arg_data->content_version);

}

void

arg_data_set_debug_file PROTO_N ((arg_data, debug_file))

			PROTO_T (ArgDataP arg_data X

				 CStringP debug_file)

{

    if (ostream_is_open (&(arg_data->debug_file))) {

	E_tld_multiple_debug_files ();

	UNREACHED;

    }

    if (!ostream_open (&(arg_data->debug_file), debug_file)) {

	E_tld_cannot_open_debug_file (debug_file);

	UNREACHED;

    }

}

OStreamP

arg_data_get_debug_file PROTO_N ((arg_data))

			PROTO_T (ArgDataP arg_data)

{

    return (&(arg_data->debug_file));

}

void

arg_data_set_output_file PROTO_N ((arg_data, output_file))

			 PROTO_T (ArgDataP arg_data X

				  CStringP output_file)

{

    if (arg_data->output_file) {

	E_tld_multiple_output_files ();

	UNREACHED;

    }

    arg_data->output_file = output_file;

}

CStringP

arg_data_get_output_file PROTO_N ((arg_data))

			 PROTO_T (ArgDataP arg_data)

{

    if (arg_data->output_file) {

	return (arg_data->output_file);

    } else {

	return (arg_data->default_output_file);

    }

}

void

arg_data_add_library_file PROTO_N ((arg_data, library_file))

			  PROTO_T (ArgDataP arg_data X

				   CStringP library_file)

{

    CStringListP libraries = &(arg_data->library.list.file);

    if (!cstring_list_contains (libraries, library_file)) {

	arg_data->num_library_files ++;

	cstring_list_append (libraries, library_file);

    }

}

void

arg_data_add_library_path PROTO_N ((arg_data, directory))

			  PROTO_T (ArgDataP arg_data X

				   CStringP directory)

{

    arg_data->num_library_paths ++;

    cstring_list_append (&(arg_data->library.list.path), directory);

}

void

arg_data_vector_libraries PROTO_N ((arg_data))

			  PROTO_T (ArgDataP arg_data)

{

    unsigned          num_files = arg_data->num_library_files;

    unsigned          num_paths = arg_data->num_library_paths;

    CStringP         *files     = ALLOCATE_VECTOR (CStringP, num_files);

    CStringP         *paths     = ALLOCATE_VECTOR (CStringP, num_paths);

    CStringListEntryP entry;

    unsigned          i;

    for (i = 0, entry = cstring_list_head (&(arg_data->library.list.file));

	 i < num_files; i ++, entry = cstring_list_entry_deallocate (entry)) {

	files [i] = cstring_list_entry_string (entry);

    }

    for (i = 0, entry = cstring_list_head (&(arg_data->library.list.path));

	 i < num_paths; i ++, entry = cstring_list_entry_deallocate (entry)) {

	paths [i] = cstring_list_entry_string (entry);

    }

    arg_data->library.vector.file = files;

    arg_data->library.vector.path = paths;

}

unsigned

arg_data_num_library_files PROTO_N ((arg_data))

			   PROTO_T (ArgDataP arg_data)

{

    return (arg_data->num_library_files);

}

unsigned

arg_data_num_library_paths PROTO_N ((arg_data))

			   PROTO_T (ArgDataP arg_data)

{

    return (arg_data->num_library_paths);

}

CStringP *

arg_data_library_files PROTO_N ((arg_data))

		       PROTO_T (ArgDataP arg_data)

{

    return (arg_data->library.vector.file);

}

CStringP *

arg_data_library_paths PROTO_N ((arg_data))

		       PROTO_T (ArgDataP arg_data)

{

    return (arg_data->library.vector.path);

}

void

arg_data_set_unit_file PROTO_N ((arg_data, unit_file))

		       PROTO_T (ArgDataP arg_data X

				CStringP unit_file)

{

    if (arg_data->unit_file) {

	E_tld_multiple_unit_files ();

	UNREACHED;

    }

    arg_data->unit_file = unit_file;

    capsule_read_unit_set_file (unit_file);

}

void

arg_data_set_files PROTO_N ((arg_data, num_files, files))

		   PROTO_T (ArgDataP  arg_data X

			    int       num_files X

			    CStringP *files)

{

    arg_data->num_files = (unsigned) num_files;

    arg_data->files     = files;

}

unsigned

arg_data_get_num_files PROTO_N ((arg_data))

		       PROTO_T (ArgDataP arg_data)

{

    return (arg_data->num_files);

}

CStringP *

arg_data_get_files PROTO_N ((arg_data))

		   PROTO_T (ArgDataP arg_data)

{

    return (arg_data->files);

}

/*

 * Local variables(smf):

 * eval: (include::add-path-entry "../os-interface" "../library" "../tdf")

 * eval: (include::add-path-entry "../generated")

 * End:

**/