static void
set_rs_shadow()
{
CELL c ;
STRING *sval ;
char *s ;
unsigned len ;
if (posix_space_flag && mawk_state == EXECUTION)
scan_code['\n'] = SC_UNEXPECTED ;
if (rs_shadow.type == SEP_STR)
free_STRING((STRING *) rs_shadow.ptr) ;
cast_for_split(cellcpy(&c, RS)) ;
switch (c.type)
{
case C_RE:
if ( (s = is_string_split(c.ptr, &len)) )
{
if (len == 1)
{
rs_shadow.type = SEP_CHAR ;
rs_shadow.c = s[0] ;
}
else
{
rs_shadow.type = SEP_STR ;
rs_shadow.ptr = (PTR) new_STRING(s) ;
}
}
else
{
rs_shadow.type = SEP_RE ;
rs_shadow.ptr = c.ptr ;
}
break ;
case C_SPACE:
rs_shadow.type = SEP_CHAR ;
rs_shadow.c = ' ' ;
break ;
case C_SNULL: /* RS becomes one or more blank lines */
if (mawk_state == EXECUTION) scan_code['\n'] = SC_SPACE ;
rs_shadow.type = SEP_MLR ;
sval = new_STRING("\n\n+") ;
rs_shadow.ptr = re_compile(sval) ;
free_STRING(sval) ;
break ;
default:
bozo("bad cell in set_rs_shadow") ;
}
}
void
field_assign(CELL * fp, CELL * cp)
{
CELL c;
int i, j;
/* the most common case first */
if (fp == field) {
cell_destroy(field);
cellcpy(fp, cp);
nf = -1;
return;
}
/* its not important to do any of this fast */
if (nf < 0)
split_field0();
#ifdef MSDOS
if (!SAMESEG(fp, field)) {
i = -1;
goto lm_dos_label;
}
#endif
switch (i = (int) (fp - field)) {
case NF_field:
cell_destroy(NF);
cellcpy(NF, cellcpy(&c, cp));
if (c.type != C_DOUBLE)
cast1_to_d(&c);
if ((j = d_to_i(c.dval)) < 0)
rt_error("negative value assigned to NF");
if (j > nf)
for (i = nf + 1; i <= j; i++) {
cp = field_ptr(i);
cell_destroy(cp);
cp->type = C_STRING;
cp->ptr = (PTR) & null_str;
null_str.ref_cnt++;
}
nf = j;
build_field0();
break;
case RS_field:
cell_destroy(RS);
cellcpy(RS, cp);
set_rs_shadow();
break;
case FS_field:
cell_destroy(FS);
cast_for_split(cellcpy(&fs_shadow, cellcpy(FS, cp)));
break;
case OFMT_field:
case CONVFMT_field:
/* If the user does something stupid with OFMT or CONVFMT,
we could crash.
We'll make an attempt to protect ourselves here. This is
why OFMT and CONVFMT are pseudo fields.
The ptrs of OFMT and CONVFMT always have a valid STRING,
even if assigned a DOUBLE or NOINIT
*/
free_STRING(string(fp));
cellcpy(fp, cp);
if (fp->type < C_STRING) /* !! */
fp->ptr = (PTR) new_STRING("%.6g");
else if (fp == CONVFMT) {
/* It's a string, but if it's really goofy and CONVFMT,
it could still damage us. Test it .
*/
char xbuff[512];
xbuff[256] = 0;
sprintf(xbuff, string(fp)->str, 3.1459);
if (xbuff[256])
rt_error("CONVFMT assigned unusable value");
}
break;
#ifdef MSDOS
lm_dos_label:
#endif
default: /* $1 or $2 or ... */
cell_destroy(fp);
cellcpy(fp, cp);
if (i < 0 || i > MAX_SPLIT)
i = field_addr_to_index(fp);
if (i > nf) {
for (j = nf + 1; j < i; j++) {
cp = field_ptr(j);
cell_destroy(cp);
cp->type = C_STRING;
cp->ptr = (PTR) & null_str;
null_str.ref_cnt++;
}
nf = i;
cell_destroy(NF);
NF->type = C_DOUBLE;
NF->dval = (double) i;
}
build_field0();
}
}
static void
set_rs_shadow(void)
{
CELL c;
STRING *sval;
char *s;
unsigned len;
if (posix_space_flag && mawk_state == EXECUTION)
scan_code['\n'] = SC_UNEXPECTED;
if (rs_shadow.type == SEP_STR) {
free_STRING((STRING *) rs_shadow.ptr);
}
cast_for_split(cellcpy(&c, RS));
switch (c.type) {
case C_RE:
if ((s = is_string_split(c.ptr, &len))) {
if (len == 1) {
rs_shadow.type = SEP_CHAR;
rs_shadow.c = s[0];
} else {
rs_shadow.type = SEP_STR;
rs_shadow.ptr = (PTR) new_STRING(s);
}
} else {
rs_shadow.type = SEP_RE;
rs_shadow.ptr = c.ptr;
}
break;
case C_SPACE:
rs_shadow.type = SEP_CHAR;
rs_shadow.c = ' ';
break;
case C_SNULL: /* RS becomes one or more blank lines */
if (mawk_state == EXECUTION)
scan_code['\n'] = SC_SPACE;
rs_shadow.type = SEP_MLR;
sval = new_STRING("\n\n+");
rs_shadow.ptr = re_compile(sval);
free_STRING(sval);
break;
case C_STRING:
/*
* Check for special case where we retained the cell as a string,
* bypassing regular-expression compiling.
*/
if (string(&c)->len == 1) {
rs_shadow.type = SEP_CHAR;
rs_shadow.c = string(&c)->str[0];
break;
}
/* FALLTHRU */
default:
bozo("bad cell in set_rs_shadow");
}
}
static void
process_cmdline(int argc, char **argv)
{
int i, j, nextarg;
char *optArg;
char *optNext;
PFILE dummy; /* starts linked list of filenames */
PFILE *tail = &dummy;
size_t length;
if (argc <= 1)
usage();
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] */
/*
* Check for "long" options and decide how to handle them.
*/
if (strlen(argv[i]) > 2 && !strncmp(argv[i], "--", (size_t) 2)) {
if (!allow_long_options(argv[i])) {
nextarg = i + 1;
continue;
}
}
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':
for (j = 0; j < (int) strlen(optArg); j = (int) (optNext - optArg)) {
switch (parse_w_opt(optArg + j, &optNext)) {
case W_VERSION:
print_version();
break;
#if USE_BINMODE
case W_BINMODE:
if (haveValue(optNext)) {
set_binmode(atoi(optNext + 1));
optNext = skipValue(optNext);
} else {
errmsg(0, "missing value for -W binmode");
mawk_exit(2);
}
break;
#endif
case W_DUMP:
dump_code_flag = 1;
break;
case W_EXEC:
if (pfile_name) {
errmsg(0, "-W exec is incompatible with -f");
mawk_exit(2);
} else if (nextarg == argc) {
no_program();
}
if (haveValue(optNext)) {
pfile_name = optNext + 1;
i = nextarg;
} else {
pfile_name = argv[nextarg];
i = nextarg + 1;
}
goto no_more_opts;
case W_INTERACTIVE:
interactive_flag = 1;
setbuf(stdout, (char *) 0);
break;
case W_POSIX_SPACE:
posix_space_flag = 1;
break;
case W_RANDOM:
if (haveValue(optNext)) {
int x = atoi(optNext + 1);
CELL c[2];
memset(c, 0, sizeof(c));
c[1].type = C_DOUBLE;
c[1].dval = (double) x;
/* c[1] is input, c[0] is output */
bi_srand(c + 1);
optNext = skipValue(optNext);
} else {
errmsg(0, "missing value for -W random");
mawk_exit(2);
}
break;
case W_SPRINTF:
if (haveValue(optNext)) {
int x = atoi(optNext + 1);
if (x > (int) sizeof(string_buff)) {
if (sprintf_buff != string_buff &&
sprintf_buff != 0) {
zfree(sprintf_buff,
(size_t) (sprintf_limit - sprintf_buff));
}
sprintf_buff = (char *) zmalloc((size_t) x);
sprintf_limit = sprintf_buff + x;
}
optNext = skipValue(optNext);
} else {
errmsg(0, "missing value for -W sprintf");
mawk_exit(2);
}
break;
case W_HELP:
/* FALLTHRU */
case W_USAGE:
usage();
/* NOTREACHED */
break;
case W_UNKNOWN:
errmsg(0, "vacuous option: -W %s", optArg + j);
break;
}
while (*optNext == '=') {
errmsg(0, "unexpected option value %s", optArg + j);
optNext = skipValue(optNext);
}
}
break;
case 'v':
if (!is_cmdline_assign(optArg)) {
errmsg(0, "improper assignment: -v %s", optArg);
mawk_exit(2);
}
break;
case 'F':
rm_escape(optArg, &length); /* recognize escape sequences */
cell_destroy(FS);
FS->type = C_STRING;
FS->ptr = (PTR) new_STRING1(optArg, length);
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 defined(MSDOS) && ! HAVE_REARGV /* reversed quotes */
{
char *p;
for (p = argv[i]; *p; p++)
if (*p == '\'')
*p = '\"';
}
#endif
scan_init(argv[i]);
/* #endif */
}
}
