Subversion Repositories NedoOS

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "mhmt-types.h"
#include "mhmt-parsearg.h"
#include "mhmt-globals.h"


struct argtbl default_arg_table[] =
{
        {"d",            ARG_MODE,   NULL},

        {"g",            ARG_GREEDY, NULL},

        {ARGSTR_MEGALZ,  ARG_PTYPE,  NULL},
        {ARGSTR_HRUM,    ARG_PTYPE,  NULL},
        {ARGSTR_HRUST,   ARG_PTYPE,  NULL},
        {ARGSTR_ZX7,     ARG_PTYPE,  NULL},

        {"zxh",          ARG_ZXHEAD, NULL},

        {ARGSTR_8,       ARG_WORD,   NULL},
        {ARGSTR_16,      ARG_WORD,   NULL},

        {"bend",         ARG_BIGEND, NULL},

        {ARGSTR_MW256,   ARG_MAXWIN, NULL},
        {ARGSTR_MW512,   ARG_MAXWIN, NULL},
        {ARGSTR_MW1024,  ARG_MAXWIN, NULL},
        {ARGSTR_MW2048,  ARG_MAXWIN, NULL},
        {ARGSTR_MW2176,  ARG_MAXWIN, NULL},
        {ARGSTR_MW4096,  ARG_MAXWIN, NULL},
        {ARGSTR_MW4352,  ARG_MAXWIN, NULL},
        {ARGSTR_MW8192,  ARG_MAXWIN, NULL},
        {ARGSTR_MW16384, ARG_MAXWIN, NULL},
        {ARGSTR_MW32768, ARG_MAXWIN, NULL},
        {ARGSTR_MW65536, ARG_MAXWIN, NULL},

        {ARGSTR_PB,      ARG_PREBIN, NULL},

        {NULL,           0,          NULL}
};



// main argument parser, sets fields of "struct globals wrk",
// tries to detect all erroneous arguments.
ULONG parse_args(int argc, char* argv[])
{
        struct argtbl argstore[ARG_STORE_SIZE+1]; // last element is always stop-value



        struct argtbl * arg;

        ULONG inarg_pos; // position in argv[] array
        ULONG storearg_pos; // position in argstore[] array

        ULONG files_num; // number of filenames specified

        char * temp_filename;

        ULONG last_arg_type;

        ULONG maxwin;


        ULONG i;
        for(i=0;i<ARG_STORE_SIZE+1;i++)
        {
                argstore[i].name  = NULL;
                argstore[i].fname = NULL;
                argstore[i].type  = ARG_NOARG;
        }


        if( argc<2 )
        {
                printf("No arguments! Use \"mhmt -h\" or \"mhmt -help\" for help!\n");
                return 0L;
        }

        // shortcut for help request
        if( !cmp_str_nocase( argv[1]+1, "h" ) || !cmp_str_nocase( argv[1]+1, "help" ) )
                return ARG_PARSER_SHOWHELP;


        inarg_pos = 1;
        storearg_pos = 0;
        files_num = 0;

        // first find all arguments beginning with "-"
        while( inarg_pos<(ULONG)argc && *(argv[inarg_pos])=='-' )
        {
                arg=match_arg(argv[inarg_pos]+1); // search match...
                if( arg ) // match!
                {
                        if( storearg_pos>=ARG_STORE_SIZE )
                        {
                                printf("Too many arguments!\n");
                                return ARG_PARSER_ERROR|ARG_PARSER_SHOWHELP;
                        }

                        argstore[storearg_pos] = *arg;

                        if( arg->type == ARG_PREBIN )
                        {
                                if( inarg_pos>=(ULONG)(argc-1) )
                                {
                                        printf("\"-prebin\" has no filename!\n");
                                        return ARG_PARSER_ERROR|ARG_PARSER_SHOWHELP;
                                }

                                inarg_pos++;
                               
                                argstore[storearg_pos].fname = (char *)malloc( 1+strlen(argv[inarg_pos]) );
                                if( !argstore[storearg_pos].fname )
                                {
                                        printf("Cannot allocate memory for filename string!\n");
                                        return ARG_PARSER_ERROR;
                                }

                                strcpy( argstore[storearg_pos].fname, argv[inarg_pos] );
                        }

                        storearg_pos++;
                }
                else // argument does not match predefined set
                {
                        printf("Wrong arguments!\n");
                        return ARG_PARSER_ERROR|ARG_PARSER_SHOWHELP;
                }

                inarg_pos++;
        }

        // parse filenames then
        while( inarg_pos<(ULONG)argc )
        {
                if( files_num>=2 ) // there should be no more than two filenames
                {
                        printf("Too many filenames specified!\n");
                        return ARG_PARSER_ERROR|ARG_PARSER_SHOWHELP;
                }

                temp_filename = (char *)malloc( 1+strlen(argv[inarg_pos]) );
                if( !temp_filename )
                {
                        printf("Cannot allocate memory for filename string!\n");
                        return ARG_PARSER_ERROR;
                }

                strcpy( temp_filename, argv[inarg_pos] );

                if( files_num==0 )
                        wrk.fname_in = temp_filename;
                else // only files_num==1, because of condition in the beginning of current "while" cycle
                        wrk.fname_out = temp_filename;

                files_num++;
                inarg_pos++;
        }

        if( !files_num ) // there must be at least 1 filename specified
        {
                printf("No filenames specified!\n");
                return ARG_PARSER_ERROR|ARG_PARSER_SHOWHELP;
        }


        // now optional arguments (starting with "-") are stored in argstore[],
        // all needed filenames are also copied, go proceed configuring with
        // optional arguments

        // sort argument array (in increasing .type order) to ensure correct parsing
        sort_args( argstore, ARG_STORE_SIZE );

        storearg_pos = 0;
        last_arg_type = ARG_INIT; // there is no such value in argstore[].type
        while( argstore[storearg_pos].type != ARG_NOARG )
        {
                if( last_arg_type == argstore[storearg_pos].type )
                {
                        printf("Redundant arguments!\n");
                        return ARG_PARSER_ERROR|ARG_PARSER_SHOWHELP;
                }

                switch( argstore[storearg_pos].type )
                {
                case ARG_MODE:
                        wrk.mode = 1; // set depack mode
                        break;

                case ARG_GREEDY:
                        if( wrk.mode ) // since sorted, argument list causes parsing go from up to down in this "case" list
                        {
                                printf("No greedy mode specification for DEpacking!\n");
                                return ARG_PARSER_ERROR;
                        }
                        wrk.greedy = 1; // set greedy packing mode
                        break;

                case ARG_PTYPE:
                        if( !cmp_str_nocase( argstore[storearg_pos].name, ARGSTR_MEGALZ ) )
                        {
                                wrk.packtype = PK_MLZ;
                                wrk.zxheader = 0;
                                wrk.wordbit  = 0;
                                wrk.bigend   = 0;
                                wrk.fullbits = 0;
                                wrk.maxwin   = 4352;
                        }
                        else if( !cmp_str_nocase( argstore[storearg_pos].name, ARGSTR_HRUM ) )
                        {
                                wrk.packtype = PK_HRM;
                                wrk.zxheader = 0; // by default, there is NO ZX-HEADER if only -hrm or -hst specified
                                wrk.wordbit  = 1;
                                wrk.bigend   = 0;
                                wrk.fullbits = 1;
                                wrk.maxwin   = 4096;
                        }
                        else if( !cmp_str_nocase( argstore[storearg_pos].name, ARGSTR_HRUST ) )
                        {
                                wrk.packtype = PK_HST;
                                wrk.zxheader = 0; // by default, there is NO ZX-HEADER if only -hrm or -hst specified
                                wrk.wordbit  = 1;
                                wrk.bigend   = 0;
                                wrk.fullbits = 1;
                                wrk.maxwin   = 65536;
                        }
                        else if( !cmp_str_nocase( argstore[storearg_pos].name, ARGSTR_ZX7 ) )
                        {
                                wrk.packtype = PK_ZX7;
                                wrk.zxheader = 0;
                                wrk.wordbit  = 0;
                                wrk.bigend   = 0;
                                wrk.fullbits = 0;
                                wrk.maxwin   = 2176;
                        }
                        else // there shouldn't be this case, but nevertheless...
                        {
                                printf("Impossible error #1! Press any key to continue or \"SPACE\" to exit... :-)\n");
                                return ARG_PARSER_ERROR;
                        }
                        break;

                case ARG_ZXHEAD:
                        // ZX-header is not applicable for PK_MLZ type...
                        // also wrk.packtype has been already set before...
                        if( PK_MLZ==wrk.packtype )
                        {
                                printf("There couldn't be zx-header in megalz mode!\n");
                                return ARG_PARSER_ERROR;
                        }
                        wrk.zxheader = 1;
                        break;

                case ARG_WORD:
                        // whether bits must be grouped in words or in bytes
                        if( !cmp_str_nocase( argstore[storearg_pos].name, ARGSTR_8 ) )
                        {
                                if( wrk.zxheader ) // won't force byte-wise bits when there is a zx-header
                                {
                                        printf("There can be only 16bit grouping of bits when ZX-header is active!\n");
                                        return ARG_PARSER_ERROR;
                                }
                                wrk.wordbit = 0;
                        }
                        else if( !cmp_str_nocase( argstore[storearg_pos].name, ARGSTR_16 ) )
                        {
                                wrk.wordbit = 1;
                        }
                        else // there shouldn't be this case, but nevertheless...
                        {
                                printf("Impossible error #2! Press any key to continue or \"SPACE\" to exit... :-)\n");
                                return ARG_PARSER_ERROR;
                        }
                        break;

                case ARG_BIGEND:
                        // whether word-grouped bits must be big- or little-endian arranged
                        if( wrk.zxheader )
                        {
                                printf("There can be only little-endian arrangement of bits when ZX-header is active!\n");
                                return ARG_PARSER_ERROR;
                        }
                        wrk.bigend = 1;
                        break;

                case ARG_MAXWIN:
                        maxwin = get_maxwin( argstore[storearg_pos].name );
                        if( !maxwin ) // there shouldn't be this case, but nevertheless...
                        {
                                printf("Impossible error #3! Press any key to continue or \"SPACE\" to exit... :-)\n");
                                return ARG_PARSER_ERROR;
                        }

                        // wrk.maxwin is already initialized to the maximum value suitable for given packing type, so check new setting
                        if( maxwin > wrk.maxwin )
                        {
                                printf("Maximum window specified is too big for given packing type!\n");
                                return ARG_PARSER_ERROR;
                        }
                        wrk.maxwin = maxwin;
                        break;

                case ARG_PREBIN:
                        wrk.prebin = 1;
                        wrk.fname_prebin = argstore[storearg_pos].fname;
                        break;

                default:
                        // once again impossible error: we shouldn't be here since "while" loop condition...
                        printf("Impossible error #4! Press any key to continue or \"SPACE\" to exit... :-)\n");
                        return ARG_PARSER_ERROR;
                        break;
                }


                last_arg_type = argstore[storearg_pos++].type;
        }


        return ARG_PARSER_GO;
}


// sort arguments
void sort_args( struct argtbl * args, ULONG argsize )
{
        struct argtbl temp;
        LONG i,j;

        // simple bubble sort since there are not too many arguments
        for( i=(argsize-2); i>=0; i-- )
        {
                for( j=0; j<=i; j++ )
                {
                        if( args[j].type > args[j+1].type )
                        {
                                temp      = args[j];
                                args[j]   = args[j+1];
                                args[j+1] = temp;
                        }
                }
        }
}


// get maxwin string into number, returns 0 if no match
LONG get_maxwin( char * txtmaxwin )
{
        static char * strings[] =
        {
                ARGSTR_MW256,
                ARGSTR_MW512,
                ARGSTR_MW1024,
                ARGSTR_MW2048,
                ARGSTR_MW4096,
                ARGSTR_MW4352,
                ARGSTR_MW8192,
                ARGSTR_MW16384,
                ARGSTR_MW32768,
                ARGSTR_MW65536,
                NULL
        };

        static LONG sizes[] =
        {
                256,
                512,
                1024,
                2048,
                4096,
                4352,
                8192,
                16384,
                32768,
                65536,
                0
        };

        ULONG i;


        i=0;
        while( strings[i] )
        {
                if( !cmp_str_nocase( strings[i], txtmaxwin ) )
                {
                        return sizes[i];
                }

                i++;
        }

        return 0;
}





// finds matching arg in default_arg_table,
// returns ptr to the found element or NULL if not found
struct argtbl * match_arg(char * argument)
{
        struct argtbl * test_arg = default_arg_table;


        while( test_arg->name && cmp_str_nocase(test_arg->name,argument) )
                test_arg++;

        return (test_arg->name)?test_arg:NULL;
}


// compares two char strings, ignoring case (uppercase by default)
// returns 0, if equal, -1 if left lower than right, and +1 otherwise
LONG cmp_str_nocase(char * left, char * right)
{

        LONG order=0;

        UBYTE leftchar,rightchar;
        UBYTE leftadd,rightadd;

        do
        {
                leftchar  = (UBYTE)*left;
                rightchar = (UBYTE)*right;

                leftadd  = 0;
                rightadd = 0;

                left++;
                right++;

                if( leftchar  >= (UBYTE)'a' ) leftadd  = (UBYTE)('A'-'a');
                if( rightchar >= (UBYTE)'a' ) rightadd = (UBYTE)('A'-'a');

                if( leftchar  > (UBYTE)'z' ) leftadd  = 0;
                if( rightchar > (UBYTE)'z' ) rightadd = 0;

                leftchar  += leftadd;
                rightchar += rightadd;

                if( leftchar<rightchar ) order = (-1);
                if( leftchar>rightchar ) order = (+1);

        } while( (!order) && leftchar && rightchar );

        return order;
}