472 lines
12 KiB
C
472 lines
12 KiB
C
/*
|
|
* $Id$
|
|
*
|
|
Copyright (c) 2006-2019 Chung, Hyung-Hwan. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "hawk-prv.h"
|
|
|
|
static int split_record (hawk_rtx_t* run);
|
|
static int recomp_record_fields (hawk_rtx_t* run, hawk_oow_t lv, const hawk_oocs_t* str);
|
|
|
|
int hawk_rtx_setrec (hawk_rtx_t* rtx, hawk_oow_t idx, const hawk_oocs_t* str)
|
|
{
|
|
hawk_val_t* v;
|
|
|
|
if (idx == 0)
|
|
{
|
|
if (str->ptr == HAWK_OOECS_PTR(&rtx->inrec.line) &&
|
|
str->len == HAWK_OOECS_LEN(&rtx->inrec.line))
|
|
{
|
|
if (hawk_rtx_clrrec(rtx, 1) <= -1) return -1;
|
|
}
|
|
else
|
|
{
|
|
if (hawk_rtx_clrrec(rtx, 0) <= -1) return -1;
|
|
|
|
if (hawk_ooecs_ncpy(&rtx->inrec.line, str->ptr, str->len) == (hawk_oow_t)-1)
|
|
{
|
|
hawk_rtx_clrrec (rtx, 0);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
v = hawk_rtx_makenstrvalwithoocs(rtx, str);
|
|
if (v == HAWK_NULL)
|
|
{
|
|
hawk_rtx_clrrec (rtx, 0);
|
|
return -1;
|
|
}
|
|
|
|
HAWK_ASSERT (HAWK_RTX_GETVALTYPE (rtx, rtx->inrec.d0) == HAWK_VAL_NIL);
|
|
/* d0 should be cleared before the next line is reached
|
|
* as it doesn't call hawk_rtx_refdownval on rtx->inrec.d0 */
|
|
rtx->inrec.d0 = v;
|
|
hawk_rtx_refupval (rtx, v);
|
|
|
|
if (split_record(rtx) <= -1)
|
|
{
|
|
hawk_rtx_clrrec (rtx, 0);
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (recomp_record_fields(rtx, idx, str) <= -1)
|
|
{
|
|
hawk_rtx_clrrec (rtx, 0);
|
|
return -1;
|
|
}
|
|
|
|
/* recompose $0 */
|
|
v = hawk_rtx_makestrvalwithoocs (rtx, HAWK_OOECS_OOCS(&rtx->inrec.line));
|
|
if (v == HAWK_NULL)
|
|
{
|
|
hawk_rtx_clrrec (rtx, 0);
|
|
return -1;
|
|
}
|
|
|
|
hawk_rtx_refdownval (rtx, rtx->inrec.d0);
|
|
rtx->inrec.d0 = v;
|
|
hawk_rtx_refupval (rtx, v);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int split_record (hawk_rtx_t* rtx)
|
|
{
|
|
hawk_oocs_t tok;
|
|
hawk_ooch_t* p, * px;
|
|
hawk_oow_t len, nflds;
|
|
hawk_val_t* v, * fs;
|
|
hawk_val_type_t fsvtype;
|
|
hawk_ooch_t* fs_ptr, * fs_free;
|
|
hawk_oow_t fs_len;
|
|
int how;
|
|
|
|
/* inrec should be cleared before split_record is called */
|
|
HAWK_ASSERT (rtx->inrec.nflds == 0);
|
|
|
|
/* get FS */
|
|
fs = hawk_rtx_getgbl (rtx, HAWK_GBL_FS);
|
|
fsvtype = HAWK_RTX_GETVALTYPE (rtx, fs);
|
|
if (fsvtype == HAWK_VAL_NIL)
|
|
{
|
|
fs_ptr = HAWK_T(" ");
|
|
fs_len = 1;
|
|
fs_free = HAWK_NULL;
|
|
}
|
|
else if (fsvtype == HAWK_VAL_STR)
|
|
{
|
|
fs_ptr = ((hawk_val_str_t*)fs)->val.ptr;
|
|
fs_len = ((hawk_val_str_t*)fs)->val.len;
|
|
fs_free = HAWK_NULL;
|
|
}
|
|
else
|
|
{
|
|
fs_ptr = hawk_rtx_valtooocstrdup(rtx, fs, &fs_len);
|
|
if (fs_ptr == HAWK_NULL) return -1;
|
|
fs_free = fs_ptr;
|
|
}
|
|
|
|
/* scan the input record to count the fields */
|
|
if (fs_len == 5 && fs_ptr[0] == HAWK_T('?'))
|
|
{
|
|
if (hawk_ooecs_ncpy(&rtx->inrec.linew, HAWK_OOECS_PTR(&rtx->inrec.line), HAWK_OOECS_LEN(&rtx->inrec.line)) == (hawk_oow_t)-1)
|
|
{
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
return -1;
|
|
}
|
|
|
|
px = HAWK_OOECS_PTR(&rtx->inrec.linew);
|
|
how = 1;
|
|
}
|
|
else
|
|
{
|
|
px = HAWK_OOECS_PTR(&rtx->inrec.line);
|
|
how = (fs_len <= 1)? 0: 2;
|
|
}
|
|
|
|
p = px;
|
|
len = HAWK_OOECS_LEN(&rtx->inrec.line);
|
|
|
|
#if 0
|
|
nflds = 0;
|
|
while (p != HAWK_NULL)
|
|
{
|
|
switch (how)
|
|
{
|
|
case 0:
|
|
p = hawk_rtx_strxntok (rtx, p, len, fs_ptr, fs_len, &tok);
|
|
break;
|
|
|
|
case 1:
|
|
break;
|
|
|
|
default:
|
|
p = hawk_rtx_strxntokbyrex(
|
|
rtx,
|
|
HAWK_OOECS_PTR(&rtx->inrec.line),
|
|
HAWK_OOECS_LEN(&rtx->inrec.line),
|
|
p, len,
|
|
rtx->gbl.fs[rtx->gbl.ignorecase], &tok
|
|
);
|
|
if (p == HAWK_NULL && hawk_rtx_geterrnum(rtx) != HAWK_ENOERR)
|
|
{
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (nflds == 0 && p == HAWK_NULL && tok.len == 0)
|
|
{
|
|
/* there are no fields. it can just return here
|
|
* as hawk_rtx_clrrec has been called before this */
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
return 0;
|
|
}
|
|
|
|
HAWK_ASSERT ((tok.ptr != HAWK_NULL && tok.len > 0) || tok.len == 0);
|
|
|
|
nflds++;
|
|
len = HAWK_OOECS_LEN(&rtx->inrec.line) - (p - HAWK_OOECS_PTR(&rtx->inrec.line));
|
|
}
|
|
|
|
/* allocate space */
|
|
if (nflds > rtx->inrec.maxflds)
|
|
{
|
|
void* tmp = hawk_rtx_allocmem(rtx, HAWK_SIZEOF(*rtx->inrec.flds) * nflds);
|
|
if (!tmp)
|
|
{
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
return -1;
|
|
}
|
|
|
|
if (rtx->inrec.flds) hawk_rtx_freemem (rtx, rtx->inrec.flds);
|
|
rtx->inrec.flds = tmp;
|
|
rtx->inrec.maxflds = nflds;
|
|
}
|
|
|
|
/* scan again and split it */
|
|
if (how == 1)
|
|
{
|
|
if (hawk_ooecs_ncpy(&rtx->inrec.linew, HAWK_OOECS_PTR(&rtx->inrec.line), HAWK_OOECS_LEN(&rtx->inrec.line)) == (hawk_oow_t)-1)
|
|
{
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
return -1;
|
|
}
|
|
px = HAWK_OOECS_PTR(&rtx->inrec.linew):
|
|
}
|
|
else
|
|
{
|
|
px = HAWK_OOECS_PTR(&rtx->inrec.line);
|
|
}
|
|
|
|
p = px;
|
|
len = HAWK_OOECS_LEN(&rtx->inrec.line);
|
|
#endif
|
|
|
|
while (p != HAWK_NULL)
|
|
{
|
|
switch (how)
|
|
{
|
|
case 0:
|
|
/* 1 character FS */
|
|
p = hawk_rtx_strxntok(rtx, p, len, fs_ptr, fs_len, &tok);
|
|
break;
|
|
|
|
case 1:
|
|
/* 5 character FS beginning with ? */
|
|
p = hawk_rtx_strxnfld(rtx, p, len, fs_ptr[1], fs_ptr[2], fs_ptr[3], fs_ptr[4], &tok);
|
|
break;
|
|
|
|
default:
|
|
/* all other cases */
|
|
p = hawk_rtx_strxntokbyrex(
|
|
rtx,
|
|
HAWK_OOECS_PTR(&rtx->inrec.line),
|
|
HAWK_OOECS_LEN(&rtx->inrec.line),
|
|
p, len,
|
|
rtx->gbl.fs[rtx->gbl.ignorecase], &tok
|
|
);
|
|
if (p == HAWK_NULL && hawk_rtx_geterrnum(rtx) != HAWK_ENOERR)
|
|
{
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
return -1;
|
|
}
|
|
}
|
|
#if 1
|
|
if (rtx->inrec.nflds == 0 && p == HAWK_NULL && tok.len == 0)
|
|
{
|
|
/* there are no fields. it can just return here
|
|
* as hawk_rtx_clrrec has been called before this */
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
HAWK_ASSERT ((tok.ptr != HAWK_NULL && tok.len > 0) || tok.len == 0);
|
|
|
|
#if 1
|
|
if (rtx->inrec.nflds >= rtx->inrec.maxflds)
|
|
{
|
|
void* tmp;
|
|
|
|
if (rtx->inrec.nflds < 16) nflds = 32;
|
|
else nflds = rtx->inrec.nflds * 2;
|
|
|
|
tmp = hawk_rtx_allocmem(rtx, HAWK_SIZEOF(*rtx->inrec.flds) * nflds);
|
|
if (tmp == HAWK_NULL)
|
|
{
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
return -1;
|
|
}
|
|
|
|
if (rtx->inrec.flds != HAWK_NULL)
|
|
{
|
|
HAWK_MEMCPY (tmp, rtx->inrec.flds, HAWK_SIZEOF(*rtx->inrec.flds) * rtx->inrec.nflds);
|
|
hawk_rtx_freemem (rtx, rtx->inrec.flds);
|
|
}
|
|
|
|
rtx->inrec.flds = tmp;
|
|
rtx->inrec.maxflds = nflds;
|
|
}
|
|
#endif
|
|
|
|
rtx->inrec.flds[rtx->inrec.nflds].ptr = tok.ptr;
|
|
rtx->inrec.flds[rtx->inrec.nflds].len = tok.len;
|
|
rtx->inrec.flds[rtx->inrec.nflds].val = hawk_rtx_makenstrvalwithoocs (rtx, &tok);
|
|
|
|
if (rtx->inrec.flds[rtx->inrec.nflds].val == HAWK_NULL)
|
|
{
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
return -1;
|
|
}
|
|
|
|
hawk_rtx_refupval (rtx, rtx->inrec.flds[rtx->inrec.nflds].val);
|
|
rtx->inrec.nflds++;
|
|
|
|
len = HAWK_OOECS_LEN(&rtx->inrec.line) - (p - px);
|
|
}
|
|
|
|
if (fs_free) hawk_rtx_freemem (rtx, fs_free);
|
|
|
|
/* set the number of fields */
|
|
v = hawk_rtx_makeintval(rtx, (hawk_int_t)rtx->inrec.nflds);
|
|
if (v == HAWK_NULL) return -1;
|
|
|
|
hawk_rtx_refupval (rtx, v);
|
|
if (hawk_rtx_setgbl(rtx, HAWK_GBL_NF, v) == -1)
|
|
{
|
|
hawk_rtx_refdownval (rtx, v);
|
|
return -1;
|
|
}
|
|
hawk_rtx_refdownval (rtx, v);
|
|
return 0;
|
|
}
|
|
|
|
int hawk_rtx_clrrec (hawk_rtx_t* run, int skip_inrec_line)
|
|
{
|
|
hawk_oow_t i;
|
|
int n = 0;
|
|
|
|
if (run->inrec.d0 != hawk_val_nil)
|
|
{
|
|
hawk_rtx_refdownval (run, run->inrec.d0);
|
|
run->inrec.d0 = hawk_val_nil;
|
|
}
|
|
|
|
if (run->inrec.nflds > 0)
|
|
{
|
|
HAWK_ASSERT (run->inrec.flds != HAWK_NULL);
|
|
|
|
for (i = 0; i < run->inrec.nflds; i++)
|
|
{
|
|
HAWK_ASSERT (run->inrec.flds[i].val != HAWK_NULL);
|
|
hawk_rtx_refdownval (run, run->inrec.flds[i].val);
|
|
}
|
|
run->inrec.nflds = 0;
|
|
|
|
if (hawk_rtx_setgbl (
|
|
run, HAWK_GBL_NF, HAWK_VAL_ZERO) == -1)
|
|
{
|
|
/* first of all, this should never happen.
|
|
* if it happened, it would return an error
|
|
* after all the clearance tasks */
|
|
n = -1;
|
|
}
|
|
}
|
|
|
|
HAWK_ASSERT (run->inrec.nflds == 0);
|
|
if (!skip_inrec_line) hawk_ooecs_clear (&run->inrec.line);
|
|
|
|
return n;
|
|
}
|
|
|
|
static int recomp_record_fields (hawk_rtx_t* rtx, hawk_oow_t lv, const hawk_oocs_t* str)
|
|
{
|
|
hawk_val_t* v;
|
|
hawk_oow_t max, i, nflds;
|
|
|
|
/* recomposes the record and the fields when $N has been assigned
|
|
* a new value and recomputes NF accordingly */
|
|
|
|
HAWK_ASSERT (lv > 0);
|
|
max = (lv > rtx->inrec.nflds)? lv: rtx->inrec.nflds;
|
|
|
|
nflds = rtx->inrec.nflds;
|
|
if (max > rtx->inrec.maxflds)
|
|
{
|
|
void* tmp;
|
|
|
|
/* if the given field number is greater than the maximum
|
|
* number of fields that the current record can hold,
|
|
* the field spaces are resized */
|
|
|
|
tmp = hawk_rtx_reallocmem(rtx, rtx->inrec.flds, HAWK_SIZEOF(*rtx->inrec.flds) * max);
|
|
if (!tmp) return -1;
|
|
|
|
rtx->inrec.flds = tmp;
|
|
rtx->inrec.maxflds = max;
|
|
}
|
|
|
|
lv = lv - 1; /* adjust the value to 0-based index */
|
|
|
|
hawk_ooecs_clear (&rtx->inrec.line);
|
|
|
|
for (i = 0; i < max; i++)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
if (hawk_ooecs_ncat(&rtx->inrec.line, rtx->gbl.ofs.ptr, rtx->gbl.ofs.len) == (hawk_oow_t)-1) return -1;
|
|
}
|
|
|
|
if (i == lv)
|
|
{
|
|
hawk_val_t* tmp;
|
|
|
|
rtx->inrec.flds[i].ptr = HAWK_OOECS_PTR(&rtx->inrec.line) + HAWK_OOECS_LEN(&rtx->inrec.line);
|
|
rtx->inrec.flds[i].len = str->len;
|
|
|
|
if (hawk_ooecs_ncat(&rtx->inrec.line, str->ptr, str->len) == (hawk_oow_t)-1) return -1;
|
|
|
|
tmp = hawk_rtx_makestrvalwithoocs (rtx, str);
|
|
if (tmp == HAWK_NULL) return -1;
|
|
|
|
if (i < nflds)
|
|
hawk_rtx_refdownval (rtx, rtx->inrec.flds[i].val);
|
|
else rtx->inrec.nflds++;
|
|
|
|
rtx->inrec.flds[i].val = tmp;
|
|
hawk_rtx_refupval (rtx, tmp);
|
|
}
|
|
else if (i >= nflds)
|
|
{
|
|
rtx->inrec.flds[i].ptr = HAWK_OOECS_PTR(&rtx->inrec.line) + HAWK_OOECS_LEN(&rtx->inrec.line);
|
|
rtx->inrec.flds[i].len = 0;
|
|
|
|
if (hawk_ooecs_cat(&rtx->inrec.line, HAWK_T("")) == (hawk_oow_t)-1) return -1;
|
|
|
|
/* hawk_rtx_refdownval should not be called over
|
|
* rtx->inrec.flds[i].val as it is not initialized
|
|
* to any valid values */
|
|
/*hawk_rtx_refdownval (rtx, rtx->inrec.flds[i].val);*/
|
|
rtx->inrec.flds[i].val = hawk_val_zls;
|
|
hawk_rtx_refupval (rtx, hawk_val_zls);
|
|
rtx->inrec.nflds++;
|
|
}
|
|
else
|
|
{
|
|
hawk_val_str_t* tmp;
|
|
|
|
tmp = (hawk_val_str_t*)rtx->inrec.flds[i].val;
|
|
|
|
rtx->inrec.flds[i].ptr = HAWK_OOECS_PTR(&rtx->inrec.line) + HAWK_OOECS_LEN(&rtx->inrec.line);
|
|
rtx->inrec.flds[i].len = tmp->val.len;
|
|
|
|
if (hawk_ooecs_ncat(&rtx->inrec.line, tmp->val.ptr, tmp->val.len) == (hawk_oow_t)-1) return -1;
|
|
}
|
|
}
|
|
|
|
v = hawk_rtx_getgbl (rtx, HAWK_GBL_NF);
|
|
HAWK_ASSERT (HAWK_RTX_GETVALTYPE (rtx, v) == HAWK_VAL_INT);
|
|
|
|
if (HAWK_RTX_GETINTFROMVAL (rtx, v)!= max)
|
|
{
|
|
v = hawk_rtx_makeintval (rtx, (hawk_int_t)max);
|
|
if (v == HAWK_NULL) return -1;
|
|
|
|
hawk_rtx_refupval (rtx, v);
|
|
if (hawk_rtx_setgbl (rtx, HAWK_GBL_NF, v) == -1)
|
|
{
|
|
hawk_rtx_refdownval (rtx, v);
|
|
return -1;
|
|
}
|
|
hawk_rtx_refdownval (rtx, v);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|