gc.c

/*
    gc.c - Part of macxx, a cross assembler family for various micro-processors
    Copyright (C) 2008 David Shepperd

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/******************************************************************************
Change Log

	05-03-2024	- Added support for TOC (Table of contents) file - TRG 

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

/**************************************************************************
 *
 * This module (wholly) contains the code to obtain the command string from
 * the user. The calling convention:
 *
 * if (!getcommand()) exit(FALSE);
 *
 * The routine returns a TRUE/FALSE flag indicating success/failure.
 * The output filename data structures are located contigiously in memory.
 * The input filename data structures may or may not be located
 * contigiously in memory and there may be a variable number of them.
 * You must use the .next pointer to chain through them.
 * There are 3 output files available.
 * 
 * OBJECT - the main output file, absolute format either binary (.OB)
 *	or ascii (.OL).
 * LIST - The listing file. Contains the assembled source and object code
 *	in a human readable format.
 * BINARY - make a binary object file
 * WORK - File to hold the intermediate code (normally maintained in memory,
 *	but if there is not enough memory to hold it, you may have to re-run
 *	the job using a work file.
 *
 * The remaining command qualifiers are: 
 * 
 * /CROSS - display a cross reference of section and symbol names in the
 * 	listing file (ignored if no listing is requested).
 * /DEBUG - displays various debug messages during the assembly procedure
 * 
 ***********************************************************************/

#include <errno.h>
#include "token.h"
#include "gc_struct.h"
#include "add_defs.h"

#if defined(M_XENIX) || defined(sun) || defined(M_UNIX) || defined(unix)
    #define OPT_DELIM '-'		/* UNIX(tm) uses dashes as option delimiters */
char opt_delim[] = "-";
#else
    #define OPT_DELIM '/'		/* everybody else uses slash */
char opt_delim[] = "/";
#endif

#include "memmgt.h"

char options[QUAL_MAX];
char **cmd_assems, **cmd_includes, **cmd_outputs;
FN_struct *cmd_fnds;
int cmd_assems_index, cmd_outputs_index;
static int cmd_assems_size, cmd_includes_size, cmd_outputs_size;
static int cmd_includes_index;

/*****************************************************************************
 * The following are the command line options to be obtained from user.
 *****************************************************************************/

#if !defined(MAC_PP)
    #if !defined(NO_XREF)
        #define xref_desc	qual_tbl[QUAL_CROSS]
    #endif
    #define bin_desc	qual_tbl[QUAL_BINARY]
    #define cmos_desc	qual_tbl[QUAL_CMOS]
    #define p816_desc	qual_tbl[QUAL_P816]
    #define miser_desc	qual_tbl[QUAL_MISER]
    #define tmp_desc	qual_tbl[QUAL_TEMP]
    #define rel_desc	qual_tbl[QUAL_RELATIVE]
    #define boff_desc	qual_tbl[QUAL_BOFF]
    #define green_desc  qual_tbl[QUAL_GRNHILL]
	#define predef_desc qual_tbl[QUAL_PREDEFINE]
#endif
#define ide_desc	qual_tbl[QUAL_IDE_SYNTAX]
#define obj_desc	qual_tbl[QUAL_OUTPUT]
#define lis_desc	qual_tbl[QUAL_LIST]
#define toc_desc	qual_tbl[QUAL_TOC]	/* By TRG 20240503 to support TOC */
#define deb_desc	qual_tbl[QUAL_DEBUG]
#define syml_desc	qual_tbl[QUAL_SYML]
#define opcl_desc	qual_tbl[QUAL_OPCL]
#define squeak_desc	qual_tbl[QUAL_SQUEAK]
#define incl_desc	qual_tbl[QUAL_INCLUDE]
#define assem_desc	qual_tbl[QUAL_ASSEM]

#ifdef VMS
    #define FILENAME_LEN 256	/* maximum length of filename in chars	*/
#else
    #define FILENAME_LEN 64		/* maximum length of filename in chars	*/
#endif

FN_struct output_files[OUT_FN_MAX]; /* declare space to keep output file specs */
FN_struct *next_inp;    /* pointer to next available file pointer */
FN_struct *last_inp;    /* pointer to last fnd used */
FN_struct *first_inp;   /* pointer to first fnd used */
FN_struct *fn_struct_pool; /* pointer to fn_struct pool */
int fn_struct_poolsize=0;   /* number of structs left in the pool */
int output_mode;        /* output mode */

#define DEFTYP(nam,string) char nam[] = {string};

DEFTYP(def_lis,".lis")
DEFTYP(def_toc,".toc")		/* By TRG 20240503 to support TOC */
DEFTYP(def_mac,".mac")
DEFTYP(def_MAC,".MAC")
#if !defined(MAC_PP)
DEFTYP(def_ol, ".ol")
DEFTYP(def_ob,".ob")
DEFTYP(def_tmp,".tmp")
DEFTYP(def_od,".od")
#else
DEFTYP(def_asm,".asm")
#endif
#undef DEFTYP

#if defined(MAC_PP)
    #define DEF_OUT def_asm
#else
    #if defined(VMS)
        #define DEF_OUT def_ob
    #else
        #define DEF_OUT def_ol
    #endif
#endif

extern int max_qual;
extern struct qual qual_tbl[];

static struct
{
    struct qual *qdesc;
    char *defext;
} fn_ptrs[] = {
#ifndef lint
    {qual_tbl+QUAL_OUTPUT,DEF_OUT},  /* /OBJECT=filename */
    {qual_tbl+QUAL_LIST,def_lis},    /* /LIS=filename */
    {qual_tbl+QUAL_TOC,def_toc},    /* /TOC=filename By TRG 20240503 to support TOC */
#if !defined(MAC_PP)
    {qual_tbl+QUAL_TEMP,def_tmp},    /* /TEMP=filename */
    {qual_tbl+QUAL_DEBUG,def_od}     /* /DEBUG=filename */
#else
    {0,0}
#endif
#else
    {0,0}
#endif
};

char *def_inp_ptr[] = {def_mac,def_MAC,NULL};
static char *def_out_ptr[] = {NULL,NULL};

/* The filenames are stored in free memory called fn_pool. The pool is */
/* managed by the fn_init routine by way of the following two variables */

int fn_pool_size=0;     /* records amount remaining in free pool */
char *fn_pool;          /* points to next char in free pool	 */

/***************************************************************************
 * FUNCTION fn_init:
 * This function initialises the fn_struct structure. It also adjusts the free
 * pool size if necessary.
 * The only required parameter is the pointer to the structure to be init'd
 * It always returns TRUE
 ***************************************************************************/

char *null_string="";   /* empty string */

void get_fn_pool( void )
{
    if (fn_pool_size < 2*FILENAME_LEN)
    { /* to save CPU time, the free pool */
        fn_pool_size = 1024;      /* a bunch of memory */
        fn_pool = (char *)MEM_alloc(fn_pool_size); /* the size required. It is assumed */
        misc_pool_used += fn_pool_size;
    }                    /* that most filenames will be short */
    return;
}

#if !defined(NO_XREF)
static FN_struct **xref_pool;   /* pointer to xref pool */
static int xref_pool_size=0;        /* size of xref free pool */

FN_struct **get_xref_pool( void )
{
    FN_struct **fn_ptr;
    if (xref_pool_size < XREF_BLOCK_SIZE)
    {
        int t;
        xref_pool_size = XREF_BLOCK_SIZE*256/sizeof(FN_struct **);
        t = xref_pool_size*sizeof(FN_struct **);
        xref_pool = (FN_struct **)MEM_alloc(t);
        misc_pool_used += t;
    }
    xref_pool_size -= XREF_BLOCK_SIZE;   /* dish them out n at a time */
    fn_ptr = xref_pool;
    xref_pool += XREF_BLOCK_SIZE;
    return(fn_ptr);
}
#endif

int fn_init(FN_struct *pointer)
{
    get_fn_pool();           /* get some free space in the pool */
#ifdef VMS
    pointer->d_length = FILENAME_LEN;    /* area length */
    pointer->s_type = DSC$K_DTYPE_T; /* string type (text) */
    pointer->s_class = DSC$K_CLASS_S;    /* string class (string) */
#endif
    pointer->fn_buff = fn_pool;      /* pointer to buffer */
    pointer->fn_name_only = null_string; /* assume no filename */
    pointer->fn_next = 0;        /* pointer to next structure */
    pointer->fn_present = 0;     /* flag indicating filename present */
    pointer->fn_line = 0;        /* start at line number 0 */
	pointer->fn_virt_line = 0;	/* start virtual line number at 0 too */
    *fn_pool = 0;            /* make sure array starts with 0 */
    pointer->macro_level = 0;        /* and there's no macro level */
    return(TRUE);            /* always return TRUE */
}

/**************************************************************************
 * Get a file descriptor structure.
 */
FN_struct *get_fn_struct(void)
/*
 * At entry:
 * 	no requirements
 * At exit:
 *	returns pointer to blank file descriptor structure init'd
 */
{
    if (fn_struct_poolsize <= 0)
    {   /* get some memory to hold the structs */
        int t = 16;
        fn_struct_pool = 
        (FN_struct *)MEM_alloc((int)sizeof(FN_struct)*t);
        fn_struct_poolsize = t;
        misc_pool_used += t*sizeof(FN_struct);
    }
    fn_init(fn_struct_pool);
    fn_struct_pool->fn_nam = NULL;
    --fn_struct_poolsize;
    return(fn_struct_pool++);
}

/* int gc_err; */

#if 0
    #if !defined(GCC)
extern int mkstemp( char *template );
    #endif
static char temp_filename[ 16 ];
#endif

FILE_name *image_name;

static int process_outfile(FN_struct *fnd, struct qual *desc_ptr, char **defname, int outn) {
    int erc = 0;
    fn_init(fnd);            /* destination and initialise it  */
    if (desc_ptr != 0 && desc_ptr->present && !desc_ptr->negated)
    {  /* is the option there? */
        fnd->fn_present = 1;  /* signal filename present */
        if (desc_ptr->value != 0)
        {
            FILE_name *fnamp;
            char *tdefname;

            fnd->fn_buff = desc_ptr->value;
            if (add_defs(desc_ptr->value,(char **)0,(char **)0,
                         ADD_DEFS_SYNTAX,&fnamp) == 0)
            {
                if (strlen(fnamp->name_only) == 0)
                {    /* if no name */
                    tdefname = (char *)MEM_alloc(strlen(fnamp->path)+strlen(*defname)+1);
                    if (tdefname == 0)
                    {
                        perror("out of memory parsing output filenames");
                        EXIT_FALSE;
                    }
                    strcpy(tdefname,fnamp->path);
                    strcat(tdefname, *defname);
                    MEM_free((char *)fnamp);
                    fnd->fn_buff = tdefname;
                }
            }
        }
        else
        {
            if (outn == OUT_FN_TMP)
            {
#if 1
                err_msg( MSG_FATAL, "Sorry, TEMP option is no longer supported, did you mean TOC\n" );	/* By TRG 20240503 to support TOC */
                return 1;
#else
                strcpy( temp_filename, "MACXXXXXX" );
                mkstemp( temp_filename ); /* create a dummy filename */
                fnd->fn_buff = temp_filename;
                def_out_ptr[0] = 0;
#endif
            }
            else
            {
                fnd->fn_buff = *defname;
            }
        }
        erc = add_defs(fnd->fn_buff,def_out_ptr,(char **)0,
                       ADD_DEFS_OUTPUT,&fnd->fn_nam); /* get user's defaults */
        if (erc == 0)
        {
            fnd->fn_name_only = fnd->fn_nam->name_type;
            fnd->fn_buff = fnd->fn_nam->full_name;
        }
        else
        {
            sprintf(emsg,"Unable to parse output filename \"%s\": %s",
                    fnd->fn_buff,error2str(errno));
            err_msg(MSG_FATAL,emsg);
        }
        if (fnd->fn_nam) *defname = fnd->fn_nam->name_only;
    }
    return erc;
}

/************************************************************************
 * FUNCTION getcommand:
 * The main routine in this module. It requires 2 inputs declared extern:
 */
extern int gc_argc;      /* arg count */
extern char **gc_argv;   /* arg value */
/*
 *************************************************************************/
static void add_def_obj(void)
{
	if (cmd_outputs_index >= cmd_outputs_size)
	{
		if (cmd_outputs)
		{
			cmd_outputs_size += cmd_outputs_size/2;
		}
		else
		{
			cmd_outputs_size = 16;
		}
		cmd_outputs = (char **)MEM_realloc((char *)cmd_outputs, cmd_outputs_size*sizeof(char *));
		memset((char *)(cmd_outputs+cmd_outputs_index), 0, (cmd_outputs_size-cmd_outputs_index)*sizeof(char *));
	}
	cmd_outputs[cmd_outputs_index++] = obj_desc.value;
}

int getcommand(void)
{
    char c,*s;
    int i,rms_errors=0;
    FN_struct *fnd;
    struct qual *desc_ptr;
    char **argv;

    argv = gc_argv;
	gc_pass = 1;
    add_defs(*argv,(char **)0,(char **)0,ADD_DEFS_SYNTAX,&image_name);
    s = *++argv;
    for (i=1; i < gc_argc;i++,s= *++argv)
    {
        while ( (c = *s) )
        {
            if (c == OPT_DELIM)
            {
#if !defined(VMS)
                c = *(s+1);
                if (c == 0 || c == OPT_DELIM)
                {
                    last_inp = next_inp;     /* record the pointer to this one */
                    next_inp = get_fn_struct();      /* get a fn structure */
                    next_inp->fn_buff = "NONAME.mac";    /* make the filename special */
                    next_inp->r_length = strlen(next_inp->fn_buff);
                    next_inp->fn_stdin = 1;      /* signal file is from stdin */
                    if (last_inp) last_inp->fn_next = next_inp; /* link last one to this one */
                    if (!first_inp) first_inp = next_inp;    /* record the first structure addr */
                    ++s;
                    if (c == OPT_DELIM) ++s;
                    continue;
                }
#endif
                s = do_option(s);
                if (assem_desc.present)
                {
                    if (cmd_assems_index >= cmd_assems_size)
                    {
                        if (cmd_assems)
                        {
                            cmd_assems_size += cmd_assems_size/2;
                        }
                        else
                        {
                            cmd_assems_size = 16;
                        }
                        cmd_assems = (char **)MEM_realloc((char *)cmd_assems, cmd_assems_size*sizeof(char *));
                        memset((char *)(cmd_assems+cmd_assems_index), 0, (cmd_assems_size-cmd_assems_index)*sizeof(char *));
                    }
                    cmd_assems[cmd_assems_index++] = assem_desc.value;
                    assem_desc.value = 0;
                    assem_desc.present = 0;
                }
                if (incl_desc.present)
                {
                    if (cmd_includes_index >= cmd_includes_size)
                    {
                        if (cmd_includes)
                        {
                            cmd_includes_size += cmd_includes_size/2;
                        }
                        else
                        {
                            cmd_includes_size = 16;
                        }
                        cmd_includes = (char **)MEM_realloc((char *)cmd_includes, cmd_includes_size*sizeof(char *));
                        memset((char *)(cmd_includes+cmd_includes_index), 0, (cmd_includes_size-cmd_includes_index)*sizeof(char *));
                    }
                    cmd_includes[cmd_includes_index++] = incl_desc.value;
                    incl_desc.value = 0;
                    incl_desc.present = 0;
                }
                if (obj_desc.present)
                {
					add_def_obj();
					obj_desc.value = 0;
					obj_desc.present = 0;
                }
                continue;
            }
            else if (c == ' ' || c == '\t' || c == ',')
            {
                ++s;        /* means skip it */
                continue;
            }
            else
            {
                char *beg;
                int len;
                last_inp = next_inp;        /* record the pointer to this one */
                next_inp = get_fn_struct();     /* get a fn structure */
                if (last_inp) last_inp->fn_next = next_inp; /* link last one to this one */
                if (!first_inp) first_inp = next_inp;   /* record the first structure addr */
                beg = s;
                while (1)
                {
                    c = *s++;
                    if (c == OPT_DELIM || c == ' ' || c == '\t' ||
                        c == ',' || c == 0)
                    {
                        --s;
                        break;
                    }
                }
                next_inp->r_length = len = s-beg;
                if (len > 0)
                {
                    if ((next_inp->fn_buff = (char *)MEM_alloc(len+1)) == 0)
                    {
                        perror("Out of memory during input filename token parsing");
                        EXIT_FALSE;
                    }
                    strncpy(next_inp->fn_buff,beg,len);
                    next_inp->fn_buff[len] = 0;
                }
                else
                {
                    next_inp->fn_buff = "";      /* make the filename null */
                }
            }              /* --if not delimter */
        }                 /* --while() */
    }                    /* --for() */
    squeak = squeak_desc.present;
    debug = deb_desc.present;
    if ((fnd = first_inp) == 0)
    {
        sprintf(emsg,"No files input.\n");
        err_msg(MSG_FATAL,emsg);
		gc_pass = 0;
        return FALSE;
    }
#if !defined(MAC_PP)
#if !defined(NO_XREF)
    if (options[QUAL_CROSS])
		lis_desc.present = 1;   /* cross defaults to /LIS */
#endif
    if (!boff_desc.present)
		options[QUAL_BOFF] = 1;  /* default to global branch offset testing */
    if (!rel_desc.present)
		options[QUAL_RELATIVE] = 1;
#if defined(VMS)
    if (!bin_desc.present)
		options[QUAL_BINARY] = 1; /* default to binary mode */
#endif
#if !defined(SUN)
    if (!miser_desc.present)
		options[QUAL_MISER] = 1;    /* default to miser mode */
#endif
	if ( !predef_desc.present || (predef_desc.present && !predef_desc.negated) )
		options[QUAL_PREDEFINE] = 1;
#endif	/* !defined(MAC_PP) */
#if 0
	if ( !ide_desc.present )
		options[QUAL_IDE_SYNTAX] = 1;	/* Default to IDE error syntax */
	if ( options[QUAL_IDE_SYNTAX] )
		options[QUAL_ABBREV] = 0;		/* Cannot have both ABBREV and IDE */
#endif
	if ( syml_desc.present )
	{
		if ( (int)syml_desc.value < 6 || (int)syml_desc.value > 16 )
		{
			sprintf(emsg, "Value on -symbol_length has to be 6 <= n <= 16. Value of %d ignored.", (int)syml_desc.value);
			err_msg(MSG_WARN, emsg);
			++gc_err;
		}
		max_symbol_length = (int)syml_desc.value;
	}
    if (opcl_desc.present)
	{
		if ( (int)opcl_desc.value < 6 || (int)opcl_desc.value > 16 )
		{
			sprintf(emsg, "Value on -opcode_length has to be 6 <= n <= 16. Value of %d ignored.", (int)opcl_desc.value);
			err_msg(MSG_WARN, emsg);
			++gc_err;
		}
        max_opcode_length = (int)opcl_desc.value;
	}
    while (fnd != 0)
    {
        int err;
        err = add_defs(fnd->fn_buff,def_inp_ptr,(char **)0,
                       fnd->fn_stdin?ADD_DEFS_SYNTAX:ADD_DEFS_INPUT,&fnd->fn_nam);
        if (err != 0)
        {
            sprintf(emsg,"Unable to parse input filename \"%s\": %s",
                    fnd->fn_buff,error2str(errno));
            err_msg(MSG_FATAL,emsg);
            rms_errors += err;
        }
        if (fnd->fn_nam)
        {
            fnd->fn_buff = fnd->fn_nam->full_name;
            fnd->fn_name_only = fnd->fn_nam->name_type;
#if 0
			printf("getcommand(): fnd=%p, fnd->fn_nam=%p, fnd->fn_nam->relative_name_only=%p '%s'\n",
				   (void *)fnd,
				   (void *)fnd->fn_nam,
				   fnd->fn_nam->relative_name,
				   fnd->fn_nam->relative_name
				   );
#endif
        }
        else
        {
            fnd->fn_name_only = fnd->fn_buff;
			printf("getcommand(): fnd=%p, fnd->fn_nam=NULL\n", (void *)fnd);
        }
        fnd = fnd->fn_next;
    }
#if !defined(MAC_PP)
    output_mode = options[QUAL_BINARY]*2 + 1;
#endif
    if (!rms_errors)
    {
        char *defname, *objdefname;
		if ( cmd_outputs_index == 0 )
		{
			add_def_obj();
		}
        defname = first_inp->fn_nam->name_only;   /* use the first file's name */

#if OUT_FN_OBJ != 0
        Phfffftt, You need to redo this code since OUT_FN_obj is not 0
#endif

        if (cmd_outputs_index > 0)
        {
            cmd_fnds = (FN_struct *)MEM_alloc(cmd_outputs_index*sizeof(FN_struct));
            desc_ptr=fn_ptrs[0].qdesc; /* get pointer to parameter descriptor */
            desc_ptr->present = 1;     /* there's at least one */
            objdefname = defname;
            for (i=0; i<cmd_outputs_index; ++i)
            {
                desc_ptr->value = cmd_outputs[i];
                if (i)
                {
                    def_out_ptr[0] = 0;
                    if (desc_ptr->value == 0 || strlen(desc_ptr->value) < 1)
                    {
                        char *th, numth[32];
                        switch (i)
                        {
                        case 5:  th = "sixth"; break;
                        case 4:  th = "fifth"; break;
                        case 3:  th = "fourth"; break;
                        case 2:  th = "third"; break;
                        case 1:  th = "second"; break;
                        default:
                            snprintf(numth, sizeof(numth), "%d'th", i+1);
                            th = numth;
                            break;
                        }
                        sprintf(emsg, "No filename provided on %s OUTPUT option", th);
                        err_msg(MSG_FATAL, emsg);
                        ++gc_err;
                        continue;
                    }
                }
                else
                {
#ifndef MAC_PP
                    def_out_ptr[0] = (output_mode > 1) ? def_ob : def_ol;
#else
                    def_out_ptr[0] = def_asm;
#endif
                }
                fnd = cmd_fnds + i;
                rms_errors += process_outfile(fnd, desc_ptr, &objdefname, 0);
                if (i==0) defname = objdefname;
                objdefname = 0;
            }
            output_files[0] = cmd_fnds[0];
        }
        for (i=1;i<OUT_FN_MAX;i++)
        {
            desc_ptr=fn_ptrs[i].qdesc; /* get pointer to parameter descriptor */
            if (desc_ptr == 0) break;  /* reached the end */
            fnd = &output_files[i];    /* get pointer to fn_struct struct of  */
            def_out_ptr[0] = fn_ptrs[i].defext;
            rms_errors += process_outfile(fnd, desc_ptr, &defname, i);
        }
    }
	gc_pass = 0;
    if (gc_err || rms_errors) return FALSE;  /* exit false if errors */
    return TRUE;             /* exit true if no errors */
}