~ubuntu-branches/ubuntu/saucy/mawk/saucy

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

init.c

copyright 1991, Michael D. Brennan

This is a source file for mawk, an implementation of

the AWK programming language.

Mawk is distributed without warranty under the terms of

the GNU General Public License, version 2, 1991.

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

/* $Log: init.c,v $

 * Revision 1.11  1995/08/20  17:35:21  mike

 * include <stdlib.h> for MSC, needed for environ decl

 *

 * Revision 1.10  1995/06/09  22:51:50  mike

 * silently exit(0) if no program

 *

 * Revision 1.9  1995/06/06  00:18:30  mike

 * change mawk_exit(1) to mawk_exit(2)

 *

 * Revision 1.8  1994/12/14  14:40:34  mike

 * -Wi option

 *

 * Revision 1.7  1994/12/11  22:43:20  mike

 * don't assume **environ is writable

 *

 * Revision 1.6  1994/12/11  22:14:16  mike

 * remove THINK_C #defines.  Not a political statement, just no indication

 * that anyone ever used it.

 *

 * Revision 1.5  1994/10/08  19:15:45  mike

 * remove SM_DOS

 *

 * Revision 1.4  1994/03/11  02:23:49  mike

 * -We option

 *

 * Revision 1.3  1993/07/17  00:45:14  mike

 * indent

 *

 * Revision 1.2	 1993/07/04  12:52:00  mike

 * start on autoconfig changes

 *

 * Revision 5.5	 1993/01/07  02:50:33  mike

 * relative vs absolute code

 *

 * Revision 5.4	 1992/12/24  01:58:19  mike

 * 1.1.2d changes for MsDOS

 *

 * Revision 5.3	 1992/07/10  16:17:10  brennan

 * MsDOS: remove NO_BINMODE macro

 *

 * Revision 5.2	 1992/01/09  08:46:14  brennan

 * small change for MSC

 *

 * Revision 5.1	 91/12/05  07:56:07  brennan

 * 1.1 pre-release

 *

*/

/* init.c */

#include "mawk.h"

#include "code.h"

#include "memory.h"

#include "symtype.h"

#include "init.h"

#include "bi_vars.h"

#include "field.h"

#ifdef MSDOS

#include <fcntl.h>

#ifdef MSDOS_MSC

#include <stdlib.h>

#endif

#endif

static void PROTO(process_cmdline, (int, char **)) ;

static void PROTO(set_ARGV, (int, char **, int)) ;

static void PROTO(bad_option, (char *)) ;

static void PROTO(no_program, (void)) ;

extern void PROTO(print_version, (void)) ;

extern int PROTO(is_cmdline_assign, (char *)) ;

#if  MSDOS

void PROTO(stdout_init, (void)) ;

#if  HAVE_REARGV

void PROTO(reargv, (int *, char ***)) ;

#endif

#endif

char *progname ;

short interactive_flag = 0 ;

#ifndef	 SET_PROGNAME

#define	 SET_PROGNAME() \

   {char *p = strrchr(argv[0],'/') ;\

    progname = p ? p+1 : argv[0] ; }

#endif

void

initialize(argc, argv)

int argc ; char **argv ;

{

   SET_PROGNAME() ;

   bi_vars_init() ;		 /* load the builtin variables */

   bi_funct_init() ;		 /* load the builtin functions */

   kw_init() ;			 /* load the keywords */

   field_init() ;

#if   MSDOS

   {

      char *p = getenv("MAWKBINMODE") ;

      if (p)  set_binmode(atoi(p)) ;

   }

#endif

   process_cmdline(argc, argv) ;

   code_init() ;

   fpe_init() ;

   set_stderr() ;

#if  MSDOS

   stdout_init() ;

#endif

}

int dump_code_flag ;		 /* if on dump internal code */

short posix_space_flag ;

#ifdef	 DEBUG

int dump_RE ;			 /* if on dump compiled REs  */

#endif

static void

bad_option(s)

   char *s ;

{

   errmsg(0, "not an option: %s", s) ; mawk_exit(2) ; 

}

static void

no_program()

{

   mawk_exit(0) ;

}

static void

process_cmdline(argc, argv)

   int argc ;

   char **argv ;

{

   int i, nextarg ;

   char *optarg ;

   PFILE dummy ;		 /* starts linked list of filenames */

   PFILE *tail = &dummy ;

   for (i = 1; i < argc && argv[i][0] == '-'; i = nextarg)

   {

      if (argv[i][1] == 0)	/* -  alone */

      {

	 if (!pfile_name) no_program() ;

	 break ;		 /* the for loop */

      }

      /* safe to look at argv[i][2] */

      if (argv[i][2] == 0)

      {

	 if (i == argc - 1 && argv[i][1] != '-')

	 {

	    if (strchr("WFvf", argv[i][1]))

	    {

	       errmsg(0, "option %s lacks argument", argv[i]) ;

	       mawk_exit(2) ;

	    }

	    bad_option(argv[i]) ;

	 }

	 optarg = argv[i + 1] ;

	 nextarg = i + 2 ;

      }

      else  /* argument glued to option */

      {

	 optarg = &argv[i][2] ;

	 nextarg = i + 1 ;

      }

      switch (argv[i][1])

      {

	 case 'W':

	    if (optarg[0] >= 'a' && optarg[0] <= 'z')

	       optarg[0] += 'A' - 'a' ;

	    if (optarg[0] == 'V')  print_version() ;

	    else if (optarg[0] == 'D')

	    {

	       dump_code_flag = 1 ;

	    }

	    else if (optarg[0] == 'S')

	    {

	       char *p = strchr(optarg, '=') ;

	       int x = p ? atoi(p + 1) : 0 ;

	       if (x > SPRINTF_SZ)

	       {

		  sprintf_buff = (char *) zmalloc(x) ;

		  sprintf_limit = sprintf_buff + x ;

	       }

	    }

#if  MSDOS

	    else if (optarg[0] == 'B')

	    {

	       char *p = strchr(optarg, '=') ;

	       int x = p ? atoi(p + 1) : 0 ;

	       set_binmode(x) ;

	    }

#endif

	    else if (optarg[0] == 'P')

	    {

	       posix_space_flag = 1 ;

	    }

	    else if (optarg[0] == 'E')

	    {

	       if ( pfile_name )

	       {

		  errmsg(0, "-W exec is incompatible with -f") ;

		  mawk_exit(2) ;

	       }

	       else if ( nextarg == argc ) no_program() ;

	       pfile_name = argv[nextarg] ;

	       i = nextarg + 1 ;

	       goto no_more_opts ;

	    }

	    else if (optarg[0] == 'I')

	    {

	       interactive_flag = 1 ;

	       setbuf(stdout,(char*)0) ;

	    }

	    else  errmsg(0, "vacuous option: -W %s", optarg) ;

	    break ;

	 case 'v':

	    if (!is_cmdline_assign(optarg))

	    {

	       errmsg(0, "improper assignment: -v %s", optarg) ;

	       mawk_exit(2) ;

	    }

	    break ;

	 case 'F':

	    rm_escape(optarg) ;	 /* recognize escape sequences */

	    cell_destroy(FS) ;

	    FS->type = C_STRING ;

	    FS->ptr = (PTR) new_STRING(optarg) ;

	    cast_for_split(cellcpy(&fs_shadow, FS)) ;

	    break ;

	 case '-':

	    if (argv[i][2] != 0)  bad_option(argv[i]) ;

	    i++ ;

	    goto no_more_opts ;

	 case 'f':

	    /* first file goes in pfile_name ; any more go

	       on a list */

	    if (!pfile_name)  pfile_name = optarg ;

	    else

	    {

	       tail = tail->link = ZMALLOC(PFILE) ;

	       tail->fname = optarg ;

	    }

	    break ;

	 default:

	    bad_option(argv[i]) ;

      }

   }

 no_more_opts:

   tail->link = (PFILE *) 0 ;

   pfile_list = dummy.link ;

   if (pfile_name)

   {

      set_ARGV(argc, argv, i) ;

      scan_init((char *) 0) ;

   }

   else	 /* program on command line */

   {

      if (i == argc)  no_program() ;

      set_ARGV(argc, argv, i + 1) ;

#if  MSDOS && ! HAVE_REARGV	/* reversed quotes */

      {

	 char *p ;

	 for (p = argv[i]; *p; p++)

	    if (*p == '\'')  *p = '\"' ;

      }

#endif

      scan_init(argv[i]) ;

/* #endif  */

   }

}

static void

set_ARGV(argc, argv, i)

int argc ; char **argv ;

   int i ;			 /* argv[i] = ARGV[i] */

{

   SYMTAB *st_p ;

   CELL argi ;

   register CELL *cp ;

   st_p = insert("ARGV") ;

   st_p->type = ST_ARRAY ;

   Argv = st_p->stval.array = new_ARRAY() ;

   argi.type = C_DOUBLE ;

   argi.dval = 0.0 ;

   cp = array_find(st_p->stval.array, &argi, CREATE) ;

   cp->type = C_STRING ;

   cp->ptr = (PTR) new_STRING(progname) ;

   /* ARGV[0] is set, do the rest

     The type of ARGV[1] ... should be C_MBSTRN

     because the user might enter numbers from the command line */

   for (argi.dval = 1.0; i < argc; i++, argi.dval += 1.0)

   {

      cp = array_find(st_p->stval.array, &argi, CREATE) ;

      cp->type = C_MBSTRN ;

      cp->ptr = (PTR) new_STRING(argv[i]) ;

   }

   ARGC->type = C_DOUBLE ;

   ARGC->dval = argi.dval ;

}

/*----- ENVIRON ----------*/

void

load_environ(ENV)

   ARRAY ENV ;

{

   CELL c ;

#ifndef	 MSDOS_MSC		/* MSC declares it near */

   extern char **environ ;

#endif

   register char **p = environ ; /* walks environ */

   char *s ;			 /* looks for the '=' */

   CELL *cp ;			 /* pts at ENV[&c] */

   c.type = C_STRING ;

   while (*p)

   {

      if (s = strchr(*p, '='))	/* shouldn't fail */

      {

	 int len = s - *p ;

	 c.ptr = (PTR) new_STRING0(len) ;

	 memcpy(string(&c)->str, *p, len) ;

	 s++ ;

	 cp = array_find(ENV, &c, CREATE) ;

	 cp->type = C_MBSTRN ;

	 cp->ptr = (PTR) new_STRING(s) ;

	 free_STRING(string(&c)) ;

      }

      p++ ;

   }

}