Merge with /home/wd/git/u-boot/custodian/u-boot-testing

1 files changed, 0 insertions, 428 deletions

diff --git a/board/MAI/bios_emulator/scitech/src/common/cmdline.c b/board/MAI/bios_emulator/scitech/src/common/cmdline.c
deleted file mode 100644
index 531e5e1312..0000000000
--- a/board/MAI/bios_emulator/scitech/src/common/cmdline.c
+++ /dev/null
@@ -1,428 +0,0 @@
-/****************************************************************************
-*
-*  ========================================================================
-*
-*    The contents of this file are subject to the SciTech MGL Public
-*    License Version 1.0 (the "License"); you may not use this file
-*    except in compliance with the License. You may obtain a copy of
-*    the License at http://www.scitechsoft.com/mgl-license.txt
-*
-*    Software distributed under the License is distributed on an
-*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-*    implied. See the License for the specific language governing
-*    rights and limitations under the License.
-*
-*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
-*
-*    The Initial Developer of the Original Code is SciTech Software, Inc.
-*    All Rights Reserved.
-*
-*  ========================================================================
-*
-* Language:     ANSI C
-* Environment:  any
-*
-* Description:  This module contains code to parse the command line,
-*               extracting options and parameters in standard System V
-*               style.
-*
-****************************************************************************/
-
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include "cmdline.h"
-
-/*------------------------- Global variables ------------------------------*/
-
-int     nextargv    =   1;          /* Index into argv array            */
-char    *nextchar   =   NULL;       /* Pointer to next character        */
-
-/*-------------------------- Implementation -------------------------------*/
-
-#define IS_SWITCH_CHAR(c)       ((c) == '-')
-#define IS_NOT_SWITCH_CHAR(c)   ((c) != '-')
-
-/****************************************************************************
-DESCRIPTION:
-Parse the command line for specific options
-
-HEADER:
-cmdline.h
-
-PARAMETERS:
-argc        - Value passed to program through argc variable
-argv        - Pointer to the argv array passed to the program
-format      - A string representing the expected format of the command line
-argument    - Pointer to optional argument on command line
-
-RETURNS:
-Character code representing the next option parsed from the command line by
-getcmdopt. Returns ALLDONE (-1) when there are no more parameters to be parsed
-on the command line, PARAMETER (-2) when the argument being parsed is a
-parameter and not an option switch and lastly INVALID (-3) if an error
-occured while parsing the command line.
-
-REMARKS:
-Function to parse the command line option switches in UNIX System V style.
-When getcmdopt is called, it returns the character code of the next valid
-option that is parsed from the command line as specified by the Format
-string. The format string should be in the following form:
-
-    "abcd:e:f:"
-
-where a,b and c represent single switch style options and the character
-code returned by getcmdopt is the only value returned. Also d, e and f
-represent options that expect arguments immediately after them on the
-command line. The argument that follows the option on the command line is
-returned via a reference in the pointer argument. Thus a valid command line
-for this format string might be:
-
-    myprogram -adlines -b -f format infile outfile
-
-where a and b will be returned as single character options with no argument,
-while d is returned with the argument lines and f is returned with the
-argument format.
-
-When getcmdopt returns with PARAMETER (we attempted to parse a paramter, not
-an option), the global variable NextArgv will hold an index in the argv
-array to the argument on the command line AFTER the options, ie in the
-above example the string 'infile'. If the parameter is successfully used,
-NextArgv should be incremented and getcmdopt can be called again to parse any
-more options. Thus you can also have options interspersed throught the
-command line. eg:
-
-    myprogram -adlines infile -b outfile -f format
-
-can be made to be a valid form of the above command line.
-****************************************************************************/
-int getcmdopt(
-    int argc,
-    char **argv,
-    char *format,
-    char **argument)
-{
-    char    ch;
-    char    *formatchar;
-
-    if (argc > nextargv) {
-	if (nextchar == NULL) {
-	    nextchar = argv[nextargv];      /* Index next argument      */
-	    if (nextchar == NULL) {
-		nextargv++;
-		return ALLDONE;             /* No more options          */
-		}
-	    if (IS_NOT_SWITCH_CHAR(*nextchar)) {
-		nextchar = NULL;
-		return PARAMETER;           /* We have a parameter      */
-		}
-	    nextchar++;                     /* Move past switch operator */
-	    if (IS_SWITCH_CHAR(*nextchar)) {
-		nextchar = NULL;
-		return INVALID;             /* Ignore rest of line      */
-		}
-	    }
-	if ((ch = *(nextchar++)) == 0) {
-	    nextchar = NULL;
-	    return INVALID;                 /* No options on line       */
-	    }
-
-	if (ch == ':' ||  (formatchar = strchr(format, ch)) == NULL)
-	    return INVALID;
-
-	if (*(++formatchar) == ':') {   /* Expect an argument after option */
-	    nextargv++;
-	    if (*nextchar == 0) {
-		if (argc <= nextargv)
-		    return INVALID;
-		nextchar = argv[nextargv++];
-		}
-	    *argument = nextchar;
-	    nextchar = NULL;
-	    }
-	else {                      /* We have a switch style option    */
-	    if (*nextchar == 0) {
-		nextargv++;
-		nextchar = NULL;
-		}
-	    *argument = NULL;
-	    }
-	return ch;                  /* return the option specifier      */
-	}
-    nextchar = NULL;
-    nextargv++;
-    return ALLDONE;                 /* no arguments on command line     */
-}
-
-/****************************************************************************
-PARAMETERS:
-optarr      - Description for the option we are parsing
-argument    - String to parse
-
-RETURNS:
-INVALID on error, ALLDONE on success.
-
-REMARKS:
-Parses the argument string depending on the type of argument that is
-expected, filling in the argument for that option. Note that to parse a
-string, we simply return a pointer to argument.
-****************************************************************************/
-static int parse_option(
-    Option *optarr,
-    char *argument)
-{
-    int     num_read;
-
-    switch ((int)(optarr->type)) {
-	case OPT_INTEGER:
-	    num_read = sscanf(argument,"%d",(int*)optarr->arg);
-	    break;
-	case OPT_HEX:
-	    num_read = sscanf(argument,"%x",(int*)optarr->arg);
-	    break;
-	case OPT_OCTAL:
-	    num_read = sscanf(argument,"%o",(int*)optarr->arg);
-	    break;
-	case OPT_UNSIGNED:
-	    num_read = sscanf(argument,"%u",(uint*)optarr->arg);
-	    break;
-	case OPT_LINTEGER:
-	    num_read = sscanf(argument,"%ld",(long*)optarr->arg);
-	    break;
-	case OPT_LHEX:
-	    num_read = sscanf(argument,"%lx",(long*)optarr->arg);
-	    break;
-	case OPT_LOCTAL:
-	    num_read = sscanf(argument,"%lo",(long*)optarr->arg);
-	    break;
-	case OPT_LUNSIGNED:
-	    num_read = sscanf(argument,"%lu",(ulong*)optarr->arg);
-	    break;
-	case OPT_FLOAT:
-	    num_read = sscanf(argument,"%f",(float*)optarr->arg);
-	    break;
-	case OPT_DOUBLE:
-	    num_read = sscanf(argument,"%lf",(double*)optarr->arg);
-	    break;
-	case OPT_LDOUBLE:
-	    num_read = sscanf(argument,"%Lf",(long double*)optarr->arg);
-	    break;
-	case OPT_STRING:
-	    num_read = 1;           /* This always works    */
-	    *((char**)optarr->arg) = argument;
-	    break;
-	default:
-	    return INVALID;
-	}
-
-    if (num_read == 0)
-	return INVALID;
-    else
-	return ALLDONE;
-}
-
-/****************************************************************************
-HEADER:
-cmdline.h
-
-PARAMETERS:
-argc        - Number of arguments on command line
-argv        - Array of command line arguments
-num_opt     - Number of options in option array
-optarr      - Array to specify how to parse the command line
-do_param    - Routine to handle a command line parameter
-
-RETURNS:
-ALLDONE, INVALID or HELP
-
-REMARKS:
-Function to parse the command line according to a table of options. This
-routine calls getcmdopt above to parse each individual option and attempts
-to parse each option into a variable of the specified type. The routine
-can parse integers and long integers in either decimal, octal, hexadecimal
-notation, unsigned integers and unsigned longs, strings and option switches.
-Option switches are simply boolean variables that get turned on if the
-switch was parsed.
-
-Parameters are extracted from the command line by calling a user supplied
-routine do_param() to handle each parameter as it is encountered. The
-routine do_param() should accept a pointer to the parameter on the command
-line and an integer representing how many parameters have been encountered
-(ie: 1 if this is the first parameter, 10 if it is the 10th etc), and return
-ALLDONE upon successfully parsing it or INVALID if the parameter was invalid.
-
-We return either ALLDONE if all the options were successfully parsed,
-INVALID if an invalid option was encountered or HELP if any of -h, -H or
--? were present on the command line.
-****************************************************************************/
-int getargs(
-    int argc,
-    char *argv[],
-    int num_opt,
-    Option optarr[],
-    int (*do_param)(
-	char *param,
-	int num))
-{
-    int     i,opt;
-    char    *argument;
-    int     param_num = 1;
-    char    cmdstr[MAXARG*2 + 4];
-
-    /* Build the command string from the array of options   */
-
-    strcpy(cmdstr,"hH?");
-    for (i = 0,opt = 3; i < num_opt; i++,opt++) {
-	cmdstr[opt] = optarr[i].opt;
-	if (optarr[i].type != OPT_SWITCH) {
-	    cmdstr[++opt] = ':';
-	    }
-	}
-    cmdstr[opt] = '\0';
-
-    for (;;) {
-	opt = getcmdopt(argc,argv,cmdstr,&argument);
-	switch (opt) {
-	    case 'H':
-	    case 'h':
-	    case '?':
-		return HELP;
-	    case ALLDONE:
-		return ALLDONE;
-	    case INVALID:
-		return INVALID;
-	    case PARAMETER:
-		if (do_param == NULL)
-		    return INVALID;
-		if (do_param(argv[nextargv],param_num) == INVALID)
-		    return INVALID;
-		nextargv++;
-		param_num++;
-		break;
-	    default:
-
-		/* Search for the option in the option array. We are
-		 * guaranteed to find it.
-		 */
-
-		for (i = 0; i < num_opt; i++) {
-		    if (optarr[i].opt == opt)
-			break;
-		    }
-		if (optarr[i].type == OPT_SWITCH)
-		    *((ibool*)optarr[i].arg) = true;
-		else {
-		    if (parse_option(&optarr[i],argument) == INVALID)
-			return INVALID;
-		    }
-		break;
-	    }
-	}
-}
-
-/****************************************************************************
-HEADER:
-cmdline.h
-
-PARAMETERS:
-num_opt - Number of options in the table
-optarr  - Table of option descriptions
-
-REMARKS:
-Prints the description of each option in a standard format to the standard
-output device. The description for each option is obtained from the table
-of options.
-****************************************************************************/
-void print_desc(
-    int num_opt,
-    Option optarr[])
-{
-    int     i;
-
-    for (i = 0; i < num_opt; i++) {
-	if (optarr[i].type == OPT_SWITCH)
-	    printf("  -%c       %s\n",optarr[i].opt,optarr[i].desc);
-	else
-	    printf("  -%c<arg>  %s\n",optarr[i].opt,optarr[i].desc);
-	}
-}
-
-/****************************************************************************
-HEADER:
-cmdline.h
-
-PARAMETERS:
-moduleName  - Module name for program
-cmdLine     - Command line to parse
-pargc       - Pointer to 'argc' parameter
-pargv       - Pointer to 'argv' parameter
-maxArgc     - Maximum argv array index
-
-REMARKS:
-Parses a command line from a single string into the C style 'argc' and
-'argv' format. Most useful for Windows programs where the command line
-is passed in verbatim.
-****************************************************************************/
-int parse_commandline(
-    char *moduleName,
-    char *cmdLine,
-    int *pargc,
-    char *argv[],
-    int maxArgv)
-{
-    static char str[512];
-    static char filename[260];
-    char        *prevWord = NULL;
-    ibool        inQuote = FALSE;
-    ibool        noStrip = FALSE;
-    int         argc;
-
-    argc = 0;
-    strcpy(filename,moduleName);
-    argv[argc++] = filename;
-    cmdLine = strncpy(str, cmdLine, sizeof(str)-1);
-    while (*cmdLine) {
-	switch (*cmdLine) {
-	    case '"' :
-		if (prevWord != NULL) {
-		    if (inQuote) {
-			if (!noStrip)
-			    *cmdLine = '\0';
-			argv [argc++] = prevWord;
-			prevWord = NULL;
-			}
-		    else
-			noStrip = TRUE;
-		    }
-		inQuote = !inQuote;
-		break;
-	    case ' ' :
-	    case '\t' :
-		if (!inQuote) {
-		    if (prevWord != NULL) {
-			*cmdLine = '\0';
-			argv [argc++] = prevWord;
-			prevWord = NULL;
-			noStrip = FALSE;
-			}
-		    }
-		break;
-	    default :
-		if (prevWord == NULL)
-		    prevWord = cmdLine;
-		break;
-		}
-	if (argc >= maxArgv - 1)
-	    break;
-	cmdLine++;
-	}
-
-    if ((prevWord != NULL || (inQuote && prevWord != NULL)) && argc < maxArgv - 1) {
-	*cmdLine = '\0';
-	argv [argc++] = prevWord;
-	}
-    argv[argc] = NULL;
-
-    /* Return updated parameters */
-    return (*pargc = argc);
-}