moved the xma mmgr to std.c with the new function hawk_init_xma_mmgr() and hawk_fini_xma_mmgr()
This commit is contained in:
parent
2a03c6f061
commit
715085c778
140
bin/hawk.c
140
bin/hawk.c
@ -30,8 +30,8 @@
|
||||
#include <hawk-utl.h>
|
||||
#include <hawk-fmt.h>
|
||||
#include <hawk-cli.h>
|
||||
#include <hawk-xma.h>
|
||||
#include <hawk-glob.h>
|
||||
#include <hawk-xma.h>
|
||||
|
||||
#if !defined(_GNU_SOURCE)
|
||||
# define _GNU_SOURCE
|
||||
@ -75,7 +75,6 @@
|
||||
#endif
|
||||
|
||||
static hawk_rtx_t* app_rtx = HAWK_NULL;
|
||||
static int app_debug = 0;
|
||||
|
||||
typedef struct gv_t gv_t;
|
||||
typedef struct gvm_t gvm_t;
|
||||
@ -123,11 +122,9 @@ struct arg_t
|
||||
unsigned int classic: 1;
|
||||
int opton;
|
||||
int optoff;
|
||||
int debug;
|
||||
|
||||
hawk_uintptr_t memlimit;
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
hawk_uintptr_t failmalloc;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
@ -547,9 +544,6 @@ static void print_usage (FILE* out, const hawk_bch_t* argv0, const hawk_bch_t* r
|
||||
fprintf (out, " -m/--memory-limit number limit the memory usage (bytes)\n");
|
||||
fprintf (out, " -w expand datafile wildcards\n");
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
fprintf (out, " -X number fail the number'th memory allocation\n");
|
||||
#endif
|
||||
#if defined(HAWK_OOCH_IS_UCH)
|
||||
fprintf (out, " --script-encoding string specify script file encoding name\n");
|
||||
fprintf (out, " --console-encoding string specify console encoding name\n");
|
||||
@ -674,7 +668,6 @@ static int process_argv (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_ar
|
||||
{ ":field-separator", 'F' },
|
||||
{ ":assign", 'v' },
|
||||
{ ":memory-limit", 'm' },
|
||||
{ ":mode", 'M' },
|
||||
|
||||
{ ":script-encoding", '\0' },
|
||||
{ ":console-encoding", '\0' },
|
||||
@ -690,11 +683,7 @@ static int process_argv (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_ar
|
||||
|
||||
static hawk_bcli_t opt =
|
||||
{
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
"hDc:f:d:t:F:v:m:I:wX:",
|
||||
#else
|
||||
"hDc:f:d:t:F:v:m:I:w",
|
||||
#endif
|
||||
lng
|
||||
};
|
||||
|
||||
@ -726,7 +715,7 @@ static int process_argv (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_ar
|
||||
goto oops;
|
||||
|
||||
case 'D':
|
||||
app_debug = 1;
|
||||
arg->debug = 1;
|
||||
break;
|
||||
|
||||
case 'c':
|
||||
@ -843,15 +832,6 @@ static int process_argv (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_ar
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
case 'X':
|
||||
{
|
||||
arg->failmalloc = strtoul(opt.arg, HAWK_NULL, 10);
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
|
||||
case '\0':
|
||||
{
|
||||
/* a long option with no corresponding short option */
|
||||
@ -1033,89 +1013,12 @@ static void print_hawk_rtx_error (hawk_rtx_t* rtx)
|
||||
);
|
||||
}
|
||||
|
||||
static void* xma_alloc (hawk_mmgr_t* mmgr, hawk_oow_t size)
|
||||
{
|
||||
return hawk_xma_alloc(mmgr->ctx, size);
|
||||
}
|
||||
|
||||
static void* xma_realloc (hawk_mmgr_t* mmgr, void* ptr, hawk_oow_t size)
|
||||
{
|
||||
return hawk_xma_realloc(mmgr->ctx, ptr, size);
|
||||
}
|
||||
|
||||
static void xma_free (hawk_mmgr_t* mmgr, void* ptr)
|
||||
{
|
||||
hawk_xma_free (mmgr->ctx, ptr);
|
||||
}
|
||||
|
||||
static hawk_mmgr_t xma_mmgr =
|
||||
{
|
||||
xma_alloc,
|
||||
xma_realloc,
|
||||
xma_free,
|
||||
HAWK_NULL
|
||||
};
|
||||
|
||||
static void xma_dumper_without_hawk (void* ctx, const hawk_bch_t* fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start (ap, fmt);
|
||||
vfprintf (stderr, fmt, ap);
|
||||
va_end (ap);
|
||||
}
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
static hawk_uintptr_t debug_mmgr_count = 0;
|
||||
static hawk_uintptr_t debug_mmgr_alloc_count = 0;
|
||||
static hawk_uintptr_t debug_mmgr_realloc_count = 0;
|
||||
static hawk_uintptr_t debug_mmgr_free_count = 0;
|
||||
|
||||
static void* debug_mmgr_alloc (hawk_mmgr_t* mmgr, hawk_oow_t size)
|
||||
{
|
||||
void* ptr;
|
||||
struct arg_t* arg = (struct arg_t*)mmgr->ctx;
|
||||
debug_mmgr_count++;
|
||||
if (debug_mmgr_count % arg->failmalloc == 0) return HAWK_NULL;
|
||||
ptr = malloc (size);
|
||||
if (ptr) debug_mmgr_alloc_count++;
|
||||
return ptr;
|
||||
}
|
||||
|
||||
static void* debug_mmgr_realloc (hawk_mmgr_t* mmgr, void* ptr, hawk_oow_t size)
|
||||
{
|
||||
void* rptr;
|
||||
struct arg_t* arg = (struct arg_t*)mmgr->ctx;
|
||||
debug_mmgr_count++;
|
||||
if (debug_mmgr_count % arg->failmalloc == 0) return HAWK_NULL;
|
||||
rptr = realloc (ptr, size);
|
||||
if (rptr)
|
||||
{
|
||||
if (ptr) debug_mmgr_realloc_count++;
|
||||
else debug_mmgr_alloc_count++;
|
||||
}
|
||||
return rptr;
|
||||
}
|
||||
|
||||
static void debug_mmgr_free (hawk_mmgr_t* mmgr, void* ptr)
|
||||
{
|
||||
debug_mmgr_free_count++;
|
||||
free (ptr);
|
||||
}
|
||||
|
||||
static hawk_mmgr_t debug_mmgr =
|
||||
{
|
||||
debug_mmgr_alloc,
|
||||
debug_mmgr_realloc,
|
||||
debug_mmgr_free,
|
||||
HAWK_NULL
|
||||
};
|
||||
#endif
|
||||
|
||||
static HAWK_INLINE int execute_hawk (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_argv0)
|
||||
{
|
||||
hawk_t* hawk = HAWK_NULL;
|
||||
hawk_rtx_t* rtx = HAWK_NULL;
|
||||
hawk_val_t* retv;
|
||||
hawk_mmgr_t xma_mmgr;
|
||||
int i;
|
||||
struct arg_t arg;
|
||||
int ret = -1;
|
||||
@ -1150,18 +1053,9 @@ static HAWK_INLINE int execute_hawk (int argc, hawk_bch_t* argv[], const hawk_bc
|
||||
psout.u.fileb.cmgr = arg.script_cmgr;
|
||||
}
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
if (arg.failmalloc > 0)
|
||||
{
|
||||
debug_mmgr.ctx = &arg;
|
||||
mmgr = &debug_mmgr;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (arg.memlimit > 0)
|
||||
{
|
||||
xma_mmgr.ctx = hawk_xma_open(hawk_get_sys_mmgr(), 0, HAWK_NULL, arg.memlimit);
|
||||
if (xma_mmgr.ctx == HAWK_NULL)
|
||||
if (hawk_init_xma_mmgr(&xma_mmgr, arg.memlimit) <= -1)
|
||||
{
|
||||
print_error ("cannot open memory heap\n");
|
||||
goto oops;
|
||||
@ -1180,7 +1074,7 @@ static HAWK_INLINE int execute_hawk (int argc, hawk_bch_t* argv[], const hawk_bc
|
||||
|
||||
if (arg.modern) i = HAWK_MODERN;
|
||||
else if (arg.classic) i = HAWK_CLASSIC;
|
||||
else hawk_getopt (hawk, HAWK_OPT_TRAIT, &i);
|
||||
else hawk_getopt(hawk, HAWK_OPT_TRAIT, &i);
|
||||
if (arg.opton) i |= arg.opton;
|
||||
if (arg.optoff) i &= ~arg.optoff;
|
||||
hawk_setopt (hawk, HAWK_OPT_TRAIT, &i);
|
||||
@ -1293,7 +1187,7 @@ static HAWK_INLINE int execute_hawk (int argc, hawk_bch_t* argv[], const hawk_bc
|
||||
hawk_int_t tmp;
|
||||
|
||||
hawk_rtx_refdownval (rtx, retv);
|
||||
if (app_debug) dprint_return (rtx, retv);
|
||||
if (arg.debug) dprint_return (rtx, retv);
|
||||
|
||||
ret = 0;
|
||||
if (hawk_rtx_valtoint(rtx, retv, &tmp) >= 0) ret = tmp;
|
||||
@ -1310,27 +1204,13 @@ oops:
|
||||
|
||||
unset_intr_pipe ();
|
||||
|
||||
if (xma_mmgr.ctx)
|
||||
if (arg.memlimit > 0)
|
||||
{
|
||||
if (app_debug) hawk_xma_dump (xma_mmgr.ctx, xma_dumper_without_hawk, HAWK_NULL);
|
||||
hawk_xma_close (xma_mmgr.ctx);
|
||||
if (arg.debug) hawk_xma_dump (xma_mmgr.ctx, main_xma_dumper_without_hawk, HAWK_NULL);
|
||||
hawk_fini_xma_mmgr (&xma_mmgr);
|
||||
}
|
||||
freearg (&arg);
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
/*
|
||||
if (arg.failmalloc > 0)
|
||||
{
|
||||
hawk_fprintf (HAWK_STDERR, HAWK_T("\n"));
|
||||
hawk_fprintf (HAWK_STDERR, HAWK_T("-[MALLOC COUNTS]---------------------------------------\n"));
|
||||
hawk_fprintf (HAWK_STDERR, HAWK_T("ALLOC: %lu FREE: %lu: REALLOC: %lu\n"),
|
||||
(unsigned long)debug_mmgr_alloc_count,
|
||||
(unsigned long)debug_mmgr_free_count,
|
||||
(unsigned long)debug_mmgr_realloc_count);
|
||||
hawk_fprintf (HAWK_STDERR, HAWK_T("-------------------------------------------------------\n"));
|
||||
}*/
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
11
bin/main.c
11
bin/main.c
@ -26,8 +26,19 @@
|
||||
|
||||
#include "main.h"
|
||||
#include <hawk.h>
|
||||
#include <hawk-xma.h>
|
||||
#include <stdio.h>
|
||||
|
||||
void main_xma_dumper_without_hawk (void* ctx, const hawk_bch_t* fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start (ap, fmt);
|
||||
vfprintf (stderr, fmt, ap);
|
||||
va_end (ap);
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------- */
|
||||
|
||||
static int main_version(int argc, hawk_bch_t* argv[], const hawk_bch_t* real_argv0)
|
||||
{
|
||||
printf ("%s %s\n", hawk_get_base_name_bcstr(real_argv0), HAWK_PACKAGE_VERSION);
|
||||
|
@ -36,6 +36,8 @@ extern "C" {
|
||||
int main_hawk(int argc, hawk_bch_t* argv[], const hawk_bch_t* real_argv0);
|
||||
int main_sed(int argc, hawk_bch_t* argv[], const hawk_bch_t* real_argv0);
|
||||
|
||||
void main_xma_dumper_without_hawk (void* ctx, const hawk_bch_t* fmt, ...);
|
||||
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
|
174
bin/sed.c
174
bin/sed.c
@ -23,13 +23,14 @@
|
||||
(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 "main.h"
|
||||
|
||||
#include <hawk-sed.h>
|
||||
#include <hawk-xma.h>
|
||||
#include <hawk-cli.h>
|
||||
#include <hawk-fmt.h>
|
||||
#include <hawk-utl.h>
|
||||
#include <hawk-std.h>
|
||||
#include <hawk-xma.h>
|
||||
|
||||
#if !defined(_GNU_SOURCE)
|
||||
# define _GNU_SOURCE
|
||||
@ -87,89 +88,14 @@ struct arg_t
|
||||
int inplace;
|
||||
int wildcard;
|
||||
|
||||
int debug;
|
||||
#if defined(HAWK_ENABLE_SEDTRACER)
|
||||
int trace;
|
||||
#endif
|
||||
|
||||
hawk_uintptr_t memlimit;
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
hawk_uintptr_t failmalloc;
|
||||
#endif
|
||||
};
|
||||
|
||||
/* ------------------------------------------------------------------- */
|
||||
static void* xma_alloc (hawk_mmgr_t* mmgr, hawk_oow_t size)
|
||||
{
|
||||
return hawk_xma_alloc (mmgr->ctx, size);
|
||||
}
|
||||
|
||||
static void* xma_realloc (hawk_mmgr_t* mmgr, void* ptr, hawk_oow_t size)
|
||||
{
|
||||
return hawk_xma_realloc (mmgr->ctx, ptr, size);
|
||||
}
|
||||
|
||||
static void xma_free (hawk_mmgr_t* mmgr, void* ptr)
|
||||
{
|
||||
hawk_xma_free (mmgr->ctx, ptr);
|
||||
}
|
||||
|
||||
static hawk_mmgr_t xma_mmgr =
|
||||
{
|
||||
xma_alloc,
|
||||
xma_realloc,
|
||||
xma_free,
|
||||
HAWK_NULL
|
||||
};
|
||||
|
||||
/* ------------------------------------------------------------------- */
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
static hawk_uintptr_t debug_mmgr_count = 0;
|
||||
static hawk_uintptr_t debug_mmgr_alloc_count = 0;
|
||||
static hawk_uintptr_t debug_mmgr_realloc_count = 0;
|
||||
static hawk_uintptr_t debug_mmgr_free_count = 0;
|
||||
|
||||
static void* debug_mmgr_alloc (hawk_mmgr_t* mmgr, hawk_oow_t size)
|
||||
{
|
||||
void* ptr;
|
||||
struct arg_t* arg = (struct arg_t*)mmgr->ctx;
|
||||
debug_mmgr_count++;
|
||||
if (debug_mmgr_count % arg->failmalloc == 0) return HAWK_NULL;
|
||||
ptr = malloc(size);
|
||||
if (ptr) debug_mmgr_alloc_count++;
|
||||
return ptr;
|
||||
}
|
||||
|
||||
static void* debug_mmgr_realloc (hawk_mmgr_t* mmgr, void* ptr, hawk_oow_t size)
|
||||
{
|
||||
void* rptr;
|
||||
struct arg_t* arg = (struct arg_t*)mmgr->ctx;
|
||||
debug_mmgr_count++;
|
||||
if (debug_mmgr_count % arg->failmalloc == 0) return HAWK_NULL;
|
||||
rptr = realloc(ptr, size);
|
||||
if (rptr)
|
||||
{
|
||||
if (ptr) debug_mmgr_realloc_count++;
|
||||
else debug_mmgr_alloc_count++;
|
||||
}
|
||||
return rptr;
|
||||
}
|
||||
|
||||
static void debug_mmgr_free (hawk_mmgr_t* mmgr, void* ptr)
|
||||
{
|
||||
debug_mmgr_free_count++;
|
||||
free (ptr);
|
||||
}
|
||||
|
||||
static hawk_mmgr_t debug_mmgr =
|
||||
{
|
||||
debug_mmgr_alloc,
|
||||
debug_mmgr_realloc,
|
||||
debug_mmgr_free,
|
||||
HAWK_NULL
|
||||
};
|
||||
#endif
|
||||
|
||||
/* ------------------------------------------------------------------- */
|
||||
|
||||
static void print_error (const hawk_bch_t* fmt, ...)
|
||||
@ -201,33 +127,31 @@ static void print_usage (FILE* out, const hawk_bch_t* argv0, const hawk_bch_t* r
|
||||
fprintf (out, " %s%s%s [options] -e script [file]\n", b1, b2, b3);
|
||||
|
||||
fprintf (out, "Options as follows:\n");
|
||||
fprintf (out, " -h/--help show this message\n");
|
||||
fprintf (out, " -n disable auto-print\n");
|
||||
fprintf (out, " -e script specify a script\n");
|
||||
fprintf (out, " -f file specify a script file\n");
|
||||
fprintf (out, " -o file specify an output file\n");
|
||||
fprintf (out, " -r use the extended regular expression\n");
|
||||
fprintf (out, " -R enable non-standard extensions to the regular\n");
|
||||
fprintf (out, " expression\n");
|
||||
fprintf (out, " -i perform in-place editing. imply -s\n");
|
||||
fprintf (out, " -s process input files separately\n");
|
||||
fprintf (out, " -a perform strict address and label check\n");
|
||||
fprintf (out, " -b allow extended address formats\n");
|
||||
fprintf (out, " <start~step>,<start,+line>,<start,~line>,<0,/regex/>\n");
|
||||
fprintf (out, " -x allow text on the same line as c, a, i\n");
|
||||
fprintf (out, " -y ensure a newline at text end\n");
|
||||
fprintf (out, " -m number specify the maximum amount of memory to use in bytes\n");
|
||||
fprintf (out, " -w expand file wildcards\n");
|
||||
fprintf (out, " -h/--help show this message\n");
|
||||
fprintf (out, " -D show extra information\n");
|
||||
fprintf (out, " -n disable auto-print\n");
|
||||
fprintf (out, " -e script specify a script\n");
|
||||
fprintf (out, " -f file specify a script file\n");
|
||||
fprintf (out, " -o file specify an output file\n");
|
||||
fprintf (out, " -r use the extended regular expression\n");
|
||||
fprintf (out, " -R enable non-standard extensions to the regular\n");
|
||||
fprintf (out, " expression\n");
|
||||
fprintf (out, " -i perform in-place editing. imply -s\n");
|
||||
fprintf (out, " -s process input files separately\n");
|
||||
fprintf (out, " -a perform strict address and label check\n");
|
||||
fprintf (out, " -b allow extended address formats\n");
|
||||
fprintf (out, " <start~step>,<start,+line>,<start,~line>,<0,/regex/>\n");
|
||||
fprintf (out, " -x allow text on the same line as c, a, i\n");
|
||||
fprintf (out, " -y ensure a newline at text end\n");
|
||||
fprintf (out, " -m/--memory-limit number specify the maximum amount of memory to use in bytes\n");
|
||||
fprintf (out, " -w expand file wildcards\n");
|
||||
#if defined(HAWK_ENABLE_SEDTRACER)
|
||||
fprintf (out, " -t print command traces\n");
|
||||
#endif
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
fprintf (out, " -X number fail the number'th memory allocation\n");
|
||||
fprintf (out, " -t print command traces\n");
|
||||
#endif
|
||||
#if defined(HAWK_OOCH_IS_UCH)
|
||||
fprintf (out, " --script-encoding string specify script file encoding name\n");
|
||||
fprintf (out, " --infile-encoding string specify input file encoding name\n");
|
||||
fprintf (out, " --outfile-encoding string specify output file encoding name\n");
|
||||
fprintf (out, " --script-encoding string specify script file encoding name\n");
|
||||
fprintf (out, " --infile-encoding string specify input file encoding name\n");
|
||||
fprintf (out, " --outfile-encoding string specify output file encoding name\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -288,17 +212,13 @@ static int handle_args (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_arg
|
||||
{ ":infile-encoding", '\0' },
|
||||
{ ":outfile-encoding", '\0' },
|
||||
#endif
|
||||
|
||||
{ ":memory-limit", 'm' },
|
||||
{ "help", 'h' },
|
||||
{ HAWK_NULL, '\0' }
|
||||
};
|
||||
static hawk_bcli_t opt =
|
||||
{
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
"hne:f:o:rRisabxytm:wX:",
|
||||
#else
|
||||
"hne:f:o:rRisabxytm:w",
|
||||
#endif
|
||||
"hDne:f:o:rRisabxytm:w",
|
||||
lng
|
||||
};
|
||||
hawk_bci_t c;
|
||||
@ -325,6 +245,10 @@ static int handle_args (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_arg
|
||||
print_usage (stdout, argv[0], real_argv0);
|
||||
goto done;
|
||||
|
||||
case 'D':
|
||||
arg->debug = 1;
|
||||
break;
|
||||
|
||||
case 'n':
|
||||
arg->option |= HAWK_SED_QUIET;
|
||||
break;
|
||||
@ -390,12 +314,6 @@ static int handle_args (int argc, hawk_bch_t* argv[], const hawk_bch_t* real_arg
|
||||
arg->wildcard = 1;
|
||||
break;
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
case 'X':
|
||||
arg->failmalloc = strtoul(opt.arg, HAWK_NULL, 10);
|
||||
break;
|
||||
#endif
|
||||
|
||||
case '\0':
|
||||
{
|
||||
if (hawk_comp_bcstr(opt.lngopt, "script-encoding", 0) == 0)
|
||||
@ -790,6 +708,7 @@ static HAWK_INLINE int execute_sed (int argc, hawk_bch_t* argv[], const hawk_bch
|
||||
int xarg_inited = 0;
|
||||
hawk_mmgr_t* mmgr = hawk_get_sys_mmgr();
|
||||
hawk_cmgr_t* cmgr = hawk_get_cmgr_by_id(HAWK_CMGR_UTF8);
|
||||
hawk_mmgr_t xma_mmgr;
|
||||
|
||||
memset (&arg, 0, HAWK_SIZEOF(arg));
|
||||
ret = handle_args(argc, argv, real_argv0, &arg);
|
||||
@ -798,18 +717,9 @@ static HAWK_INLINE int execute_sed (int argc, hawk_bch_t* argv[], const hawk_bch
|
||||
|
||||
ret = -1;
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
if (arg.failmalloc > 0)
|
||||
{
|
||||
debug_mmgr.ctx = &arg;
|
||||
mmgr = &debug_mmgr;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (arg.memlimit > 0)
|
||||
{
|
||||
xma_mmgr.ctx = hawk_xma_open(hawk_get_sys_mmgr(), 0, HAWK_NULL, arg.memlimit);
|
||||
if (xma_mmgr.ctx == HAWK_NULL)
|
||||
if (hawk_init_xma_mmgr(&xma_mmgr, arg.memlimit) <= -1)
|
||||
{
|
||||
print_error ("cannot open memory heap\n");
|
||||
goto oops;
|
||||
@ -1085,21 +995,13 @@ static HAWK_INLINE int execute_sed (int argc, hawk_bch_t* argv[], const hawk_bch
|
||||
oops:
|
||||
if (xarg_inited) purge_xarg (&xarg);
|
||||
if (sed) hawk_sed_close (sed);
|
||||
if (xma_mmgr.ctx) hawk_xma_close (xma_mmgr.ctx);
|
||||
if (arg.memlimit > 0)
|
||||
{
|
||||
if (arg.debug) hawk_xma_dump (xma_mmgr.ctx, main_xma_dumper_without_hawk, HAWK_NULL);
|
||||
hawk_fini_xma_mmgr (&xma_mmgr);
|
||||
}
|
||||
free_scripts ();
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
if (arg.failmalloc > 0)
|
||||
{
|
||||
fprintf (stderr, "\n");
|
||||
fprintf (stderr, "-[MALLOC COUNTS]---------------------------------------\n");
|
||||
fprintf (stderr, "ALLOC: %lu FREE: %lu: REALLOC: %lu\n",
|
||||
(unsigned long)debug_mmgr_alloc_count,
|
||||
(unsigned long)debug_mmgr_free_count,
|
||||
(unsigned long)debug_mmgr_realloc_count);
|
||||
fprintf (stderr, "-------------------------------------------------------\n");
|
||||
}
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -231,7 +231,7 @@ public:
|
||||
|
||||
///
|
||||
/// The getErrorNumber() function gets the number of the last
|
||||
/// error occurred. It returns HAWK_SED_ENOERR if the stream editor
|
||||
/// error occurred. It returns HAWK_ENOERR if the stream editor
|
||||
/// has not been initialized with the open() function.
|
||||
///
|
||||
hawk_errnum_t getErrorNumber () const;
|
||||
|
@ -55,6 +55,7 @@ pkginclude_HEADERS = \
|
||||
hawk-chr.h \
|
||||
hawk-cli.h \
|
||||
hawk-cmn.h \
|
||||
hawk-cut.h \
|
||||
hawk-dir.h \
|
||||
hawk-ecs.h \
|
||||
hawk-fio.h \
|
||||
@ -90,6 +91,8 @@ libhawk_la_SOURCES = \
|
||||
$(pkginclude_HEADERS) \
|
||||
arr.c \
|
||||
chr.c \
|
||||
cut-prv.h \
|
||||
cut.c \
|
||||
dir.c \
|
||||
ecs-imp.h \
|
||||
ecs.c \
|
||||
@ -169,6 +172,7 @@ libhawk_la_SOURCES += \
|
||||
syscall.h \
|
||||
tio.c \
|
||||
std.c \
|
||||
std-cut.c \
|
||||
std-json.c \
|
||||
std-sed.c
|
||||
|
||||
|
161
lib/Makefile.in
161
lib/Makefile.in
@ -247,30 +247,30 @@ libhawk_la_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
|
||||
$(am__DEPENDENCIES_6) $(am__DEPENDENCIES_7) \
|
||||
$(am__DEPENDENCIES_8) $(am__DEPENDENCIES_9)
|
||||
am__libhawk_la_SOURCES_DIST = hawk.h hawk-arr.h hawk-chr.h hawk-cli.h \
|
||||
hawk-cmn.h hawk-dir.h hawk-ecs.h hawk-fio.h hawk-fmt.h \
|
||||
hawk-gem.h hawk-glob.h hawk-htb.h hawk-json.h hawk-map.h \
|
||||
hawk-mtx.h hawk-rbt.h hawk-pac1.h hawk-pio.h hawk-skad.h \
|
||||
hawk-utl.h hawk-sed.h hawk-sio.h hawk-std.h hawk-str.h \
|
||||
hawk-tio.h hawk-tre.h hawk-upac.h hawk-xma.h Hawk.hpp \
|
||||
Hawk-Sed.hpp arr.c chr.c dir.c ecs-imp.h ecs.c err-prv.h err.c \
|
||||
err-sys.c fmt-imp.h fmt.c fnc-prv.h fnc.c gem.c gem-glob.c \
|
||||
gem-nwif.c gem-nwif2.c hawk-prv.h hawk.c htb.c idmap-imp.h \
|
||||
json.c json-prv.h mb8.c misc-imp.h misc-prv.h misc.c \
|
||||
parse-prv.h parse.c rbt.c rec.c rio-prv.h rio.c run-prv.h \
|
||||
run.c sed-prv.h sed.c skad-prv.h skad.c tre-prv.h tre-ast.c \
|
||||
tre-ast.h tre-compile.c tre-compile.h tre-match-bt.c \
|
||||
tre-match-pa.c tre-match-ut.h tre-mem.c tre-mem.h tre-parse.c \
|
||||
tre-parse.h tre-stack.h tre-stack.c tre.c tree-prv.h tree.c \
|
||||
uch-prop.h uch-case.h utf16.c utf8.c utl-ass.c utl-cmgr.c \
|
||||
utl-rnd.c utl-sort.c utl-str.c utl-sys.c utl-xstr.c utl.c \
|
||||
val-prv.h val.c xma.c cli-imp.h cli.c fio.c mtx.c pio.c sio.c \
|
||||
syscall.h tio.c std.c std-json.c std-sed.c Hawk.cpp Std.cpp \
|
||||
Sed.cpp Std-Sed.cpp mod-hawk.c mod-hawk.h mod-math.c \
|
||||
mod-math.h mod-str.c mod-str.h mod-sys.c mod-sys.h \
|
||||
../mod/mod-ffi.c ../mod/mod-ffi.h ../mod/mod-memc.c \
|
||||
../mod/mod-memc.h ../mod/mod-mysql.c ../mod/mod-mysql.h \
|
||||
../mod/mod-sed.c ../mod/mod-sed.h ../mod/mod-uci.c \
|
||||
../mod/mod-uci.h
|
||||
hawk-cmn.h hawk-cut.h hawk-dir.h hawk-ecs.h hawk-fio.h \
|
||||
hawk-fmt.h hawk-gem.h hawk-glob.h hawk-htb.h hawk-json.h \
|
||||
hawk-map.h hawk-mtx.h hawk-rbt.h hawk-pac1.h hawk-pio.h \
|
||||
hawk-skad.h hawk-utl.h hawk-sed.h hawk-sio.h hawk-std.h \
|
||||
hawk-str.h hawk-tio.h hawk-tre.h hawk-upac.h hawk-xma.h \
|
||||
Hawk.hpp Hawk-Sed.hpp arr.c chr.c cut-prv.h cut.c dir.c \
|
||||
ecs-imp.h ecs.c err-prv.h err.c err-sys.c fmt-imp.h fmt.c \
|
||||
fnc-prv.h fnc.c gem.c gem-glob.c gem-nwif.c gem-nwif2.c \
|
||||
hawk-prv.h hawk.c htb.c idmap-imp.h json.c json-prv.h mb8.c \
|
||||
misc-imp.h misc-prv.h misc.c parse-prv.h parse.c rbt.c rec.c \
|
||||
rio-prv.h rio.c run-prv.h run.c sed-prv.h sed.c skad-prv.h \
|
||||
skad.c tre-prv.h tre-ast.c tre-ast.h tre-compile.c \
|
||||
tre-compile.h tre-match-bt.c tre-match-pa.c tre-match-ut.h \
|
||||
tre-mem.c tre-mem.h tre-parse.c tre-parse.h tre-stack.h \
|
||||
tre-stack.c tre.c tree-prv.h tree.c uch-prop.h uch-case.h \
|
||||
utf16.c utf8.c utl-ass.c utl-cmgr.c utl-rnd.c utl-sort.c \
|
||||
utl-str.c utl-sys.c utl-xstr.c utl.c val-prv.h val.c xma.c \
|
||||
cli-imp.h cli.c fio.c mtx.c pio.c sio.c syscall.h tio.c std.c \
|
||||
std-cut.c std-json.c std-sed.c Hawk.cpp Std.cpp Sed.cpp \
|
||||
Std-Sed.cpp mod-hawk.c mod-hawk.h mod-math.c mod-math.h \
|
||||
mod-str.c mod-str.h mod-sys.c mod-sys.h ../mod/mod-ffi.c \
|
||||
../mod/mod-ffi.h ../mod/mod-memc.c ../mod/mod-memc.h \
|
||||
../mod/mod-mysql.c ../mod/mod-mysql.h ../mod/mod-sed.c \
|
||||
../mod/mod-sed.h ../mod/mod-uci.c ../mod/mod-uci.h
|
||||
am__objects_1 =
|
||||
am__objects_2 = $(am__objects_1)
|
||||
@ENABLE_CXX_TRUE@am__objects_3 = libhawk_la-Hawk.lo libhawk_la-Std.lo \
|
||||
@ -291,28 +291,30 @@ am__dirstamp = $(am__leading_dot)dirstamp
|
||||
@ENABLE_MOD_UCI_STATIC_TRUE@am__objects_9 = \
|
||||
@ENABLE_MOD_UCI_STATIC_TRUE@ ../mod/libhawk_la-mod-uci.lo
|
||||
am_libhawk_la_OBJECTS = $(am__objects_2) libhawk_la-arr.lo \
|
||||
libhawk_la-chr.lo libhawk_la-dir.lo libhawk_la-ecs.lo \
|
||||
libhawk_la-err.lo libhawk_la-err-sys.lo libhawk_la-fmt.lo \
|
||||
libhawk_la-fnc.lo libhawk_la-gem.lo libhawk_la-gem-glob.lo \
|
||||
libhawk_la-gem-nwif.lo libhawk_la-gem-nwif2.lo \
|
||||
libhawk_la-hawk.lo libhawk_la-htb.lo libhawk_la-json.lo \
|
||||
libhawk_la-mb8.lo libhawk_la-misc.lo libhawk_la-parse.lo \
|
||||
libhawk_la-rbt.lo libhawk_la-rec.lo libhawk_la-rio.lo \
|
||||
libhawk_la-run.lo libhawk_la-sed.lo libhawk_la-skad.lo \
|
||||
libhawk_la-tre-ast.lo libhawk_la-tre-compile.lo \
|
||||
libhawk_la-tre-match-bt.lo libhawk_la-tre-match-pa.lo \
|
||||
libhawk_la-tre-mem.lo libhawk_la-tre-parse.lo \
|
||||
libhawk_la-tre-stack.lo libhawk_la-tre.lo libhawk_la-tree.lo \
|
||||
libhawk_la-utf16.lo libhawk_la-utf8.lo libhawk_la-utl-ass.lo \
|
||||
libhawk_la-chr.lo libhawk_la-cut.lo libhawk_la-dir.lo \
|
||||
libhawk_la-ecs.lo libhawk_la-err.lo libhawk_la-err-sys.lo \
|
||||
libhawk_la-fmt.lo libhawk_la-fnc.lo libhawk_la-gem.lo \
|
||||
libhawk_la-gem-glob.lo libhawk_la-gem-nwif.lo \
|
||||
libhawk_la-gem-nwif2.lo libhawk_la-hawk.lo libhawk_la-htb.lo \
|
||||
libhawk_la-json.lo libhawk_la-mb8.lo libhawk_la-misc.lo \
|
||||
libhawk_la-parse.lo libhawk_la-rbt.lo libhawk_la-rec.lo \
|
||||
libhawk_la-rio.lo libhawk_la-run.lo libhawk_la-sed.lo \
|
||||
libhawk_la-skad.lo libhawk_la-tre-ast.lo \
|
||||
libhawk_la-tre-compile.lo libhawk_la-tre-match-bt.lo \
|
||||
libhawk_la-tre-match-pa.lo libhawk_la-tre-mem.lo \
|
||||
libhawk_la-tre-parse.lo libhawk_la-tre-stack.lo \
|
||||
libhawk_la-tre.lo libhawk_la-tree.lo libhawk_la-utf16.lo \
|
||||
libhawk_la-utf8.lo libhawk_la-utl-ass.lo \
|
||||
libhawk_la-utl-cmgr.lo libhawk_la-utl-rnd.lo \
|
||||
libhawk_la-utl-sort.lo libhawk_la-utl-str.lo \
|
||||
libhawk_la-utl-sys.lo libhawk_la-utl-xstr.lo libhawk_la-utl.lo \
|
||||
libhawk_la-val.lo libhawk_la-xma.lo libhawk_la-cli.lo \
|
||||
libhawk_la-fio.lo libhawk_la-mtx.lo libhawk_la-pio.lo \
|
||||
libhawk_la-sio.lo libhawk_la-tio.lo libhawk_la-std.lo \
|
||||
libhawk_la-std-json.lo libhawk_la-std-sed.lo $(am__objects_3) \
|
||||
$(am__objects_4) $(am__objects_5) $(am__objects_6) \
|
||||
$(am__objects_7) $(am__objects_8) $(am__objects_9)
|
||||
libhawk_la-std-cut.lo libhawk_la-std-json.lo \
|
||||
libhawk_la-std-sed.lo $(am__objects_3) $(am__objects_4) \
|
||||
$(am__objects_5) $(am__objects_6) $(am__objects_7) \
|
||||
$(am__objects_8) $(am__objects_9)
|
||||
libhawk_la_OBJECTS = $(am_libhawk_la_OBJECTS)
|
||||
AM_V_P = $(am__v_P_@AM_V@)
|
||||
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
|
||||
@ -339,7 +341,8 @@ am__depfiles_remade = ../mod/$(DEPDIR)/libhawk_la-mod-ffi.Plo \
|
||||
./$(DEPDIR)/libhawk_la-Std-Sed.Plo \
|
||||
./$(DEPDIR)/libhawk_la-Std.Plo ./$(DEPDIR)/libhawk_la-arr.Plo \
|
||||
./$(DEPDIR)/libhawk_la-chr.Plo ./$(DEPDIR)/libhawk_la-cli.Plo \
|
||||
./$(DEPDIR)/libhawk_la-dir.Plo ./$(DEPDIR)/libhawk_la-ecs.Plo \
|
||||
./$(DEPDIR)/libhawk_la-cut.Plo ./$(DEPDIR)/libhawk_la-dir.Plo \
|
||||
./$(DEPDIR)/libhawk_la-ecs.Plo \
|
||||
./$(DEPDIR)/libhawk_la-err-sys.Plo \
|
||||
./$(DEPDIR)/libhawk_la-err.Plo ./$(DEPDIR)/libhawk_la-fio.Plo \
|
||||
./$(DEPDIR)/libhawk_la-fmt.Plo ./$(DEPDIR)/libhawk_la-fnc.Plo \
|
||||
@ -359,6 +362,7 @@ am__depfiles_remade = ../mod/$(DEPDIR)/libhawk_la-mod-ffi.Plo \
|
||||
./$(DEPDIR)/libhawk_la-rec.Plo ./$(DEPDIR)/libhawk_la-rio.Plo \
|
||||
./$(DEPDIR)/libhawk_la-run.Plo ./$(DEPDIR)/libhawk_la-sed.Plo \
|
||||
./$(DEPDIR)/libhawk_la-sio.Plo ./$(DEPDIR)/libhawk_la-skad.Plo \
|
||||
./$(DEPDIR)/libhawk_la-std-cut.Plo \
|
||||
./$(DEPDIR)/libhawk_la-std-json.Plo \
|
||||
./$(DEPDIR)/libhawk_la-std-sed.Plo \
|
||||
./$(DEPDIR)/libhawk_la-std.Plo ./$(DEPDIR)/libhawk_la-tio.Plo \
|
||||
@ -435,12 +439,12 @@ am__can_run_installinfo = \
|
||||
*) (install-info --version) >/dev/null 2>&1;; \
|
||||
esac
|
||||
am__pkginclude_HEADERS_DIST = hawk.h hawk-arr.h hawk-chr.h hawk-cli.h \
|
||||
hawk-cmn.h hawk-dir.h hawk-ecs.h hawk-fio.h hawk-fmt.h \
|
||||
hawk-gem.h hawk-glob.h hawk-htb.h hawk-json.h hawk-map.h \
|
||||
hawk-mtx.h hawk-rbt.h hawk-pac1.h hawk-pio.h hawk-skad.h \
|
||||
hawk-utl.h hawk-sed.h hawk-sio.h hawk-std.h hawk-str.h \
|
||||
hawk-tio.h hawk-tre.h hawk-upac.h hawk-xma.h Hawk.hpp \
|
||||
Hawk-Sed.hpp
|
||||
hawk-cmn.h hawk-cut.h hawk-dir.h hawk-ecs.h hawk-fio.h \
|
||||
hawk-fmt.h hawk-gem.h hawk-glob.h hawk-htb.h hawk-json.h \
|
||||
hawk-map.h hawk-mtx.h hawk-rbt.h hawk-pac1.h hawk-pio.h \
|
||||
hawk-skad.h hawk-utl.h hawk-sed.h hawk-sio.h hawk-std.h \
|
||||
hawk-str.h hawk-tio.h hawk-tre.h hawk-upac.h hawk-xma.h \
|
||||
Hawk.hpp Hawk-Sed.hpp
|
||||
HEADERS = $(pkginclude_HEADERS)
|
||||
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) \
|
||||
hawk-cfg.h.in
|
||||
@ -666,28 +670,29 @@ BUILT_SOURCES = \
|
||||
utl-str.c
|
||||
|
||||
pkginclude_HEADERS = hawk.h hawk-arr.h hawk-chr.h hawk-cli.h \
|
||||
hawk-cmn.h hawk-dir.h hawk-ecs.h hawk-fio.h hawk-fmt.h \
|
||||
hawk-gem.h hawk-glob.h hawk-htb.h hawk-json.h hawk-map.h \
|
||||
hawk-mtx.h hawk-rbt.h hawk-pac1.h hawk-pio.h hawk-skad.h \
|
||||
hawk-utl.h hawk-sed.h hawk-sio.h hawk-std.h hawk-str.h \
|
||||
hawk-tio.h hawk-tre.h hawk-upac.h hawk-xma.h $(am__append_7)
|
||||
hawk-cmn.h hawk-cut.h hawk-dir.h hawk-ecs.h hawk-fio.h \
|
||||
hawk-fmt.h hawk-gem.h hawk-glob.h hawk-htb.h hawk-json.h \
|
||||
hawk-map.h hawk-mtx.h hawk-rbt.h hawk-pac1.h hawk-pio.h \
|
||||
hawk-skad.h hawk-utl.h hawk-sed.h hawk-sio.h hawk-std.h \
|
||||
hawk-str.h hawk-tio.h hawk-tre.h hawk-upac.h hawk-xma.h \
|
||||
$(am__append_7)
|
||||
pkglib_LTLIBRARIES = libhawk.la $(am__append_11)
|
||||
libhawk_la_SOURCES = $(pkginclude_HEADERS) arr.c chr.c dir.c ecs-imp.h \
|
||||
ecs.c err-prv.h err.c err-sys.c fmt-imp.h fmt.c fnc-prv.h \
|
||||
fnc.c gem.c gem-glob.c gem-nwif.c gem-nwif2.c hawk-prv.h \
|
||||
hawk.c htb.c idmap-imp.h json.c json-prv.h mb8.c misc-imp.h \
|
||||
misc-prv.h misc.c parse-prv.h parse.c rbt.c rec.c rio-prv.h \
|
||||
rio.c run-prv.h run.c sed-prv.h sed.c skad-prv.h skad.c \
|
||||
tre-prv.h tre-ast.c tre-ast.h tre-compile.c tre-compile.h \
|
||||
tre-match-bt.c tre-match-pa.c tre-match-ut.h tre-mem.c \
|
||||
tre-mem.h tre-parse.c tre-parse.h tre-stack.h tre-stack.c \
|
||||
tre.c tree-prv.h tree.c uch-prop.h uch-case.h utf16.c utf8.c \
|
||||
utl-ass.c utl-cmgr.c utl-rnd.c utl-sort.c utl-str.c utl-sys.c \
|
||||
utl-xstr.c utl.c val-prv.h val.c xma.c cli-imp.h cli.c fio.c \
|
||||
mtx.c pio.c sio.c syscall.h tio.c std.c std-json.c std-sed.c \
|
||||
$(am__append_8) $(am__append_9) $(am__append_12) \
|
||||
$(am__append_14) $(am__append_16) $(am__append_20) \
|
||||
$(am__append_21)
|
||||
libhawk_la_SOURCES = $(pkginclude_HEADERS) arr.c chr.c cut-prv.h cut.c \
|
||||
dir.c ecs-imp.h ecs.c err-prv.h err.c err-sys.c fmt-imp.h \
|
||||
fmt.c fnc-prv.h fnc.c gem.c gem-glob.c gem-nwif.c gem-nwif2.c \
|
||||
hawk-prv.h hawk.c htb.c idmap-imp.h json.c json-prv.h mb8.c \
|
||||
misc-imp.h misc-prv.h misc.c parse-prv.h parse.c rbt.c rec.c \
|
||||
rio-prv.h rio.c run-prv.h run.c sed-prv.h sed.c skad-prv.h \
|
||||
skad.c tre-prv.h tre-ast.c tre-ast.h tre-compile.c \
|
||||
tre-compile.h tre-match-bt.c tre-match-pa.c tre-match-ut.h \
|
||||
tre-mem.c tre-mem.h tre-parse.c tre-parse.h tre-stack.h \
|
||||
tre-stack.c tre.c tree-prv.h tree.c uch-prop.h uch-case.h \
|
||||
utf16.c utf8.c utl-ass.c utl-cmgr.c utl-rnd.c utl-sort.c \
|
||||
utl-str.c utl-sys.c utl-xstr.c utl.c val-prv.h val.c xma.c \
|
||||
cli-imp.h cli.c fio.c mtx.c pio.c sio.c syscall.h tio.c std.c \
|
||||
std-cut.c std-json.c std-sed.c $(am__append_8) $(am__append_9) \
|
||||
$(am__append_12) $(am__append_14) $(am__append_16) \
|
||||
$(am__append_20) $(am__append_21)
|
||||
libhawk_la_CPPFLAGS = $(CPPFLAGS_ALL_COMMON) $(CPPFLAGS_PFMOD) \
|
||||
$(am__append_3) $(am__append_17)
|
||||
libhawk_la_CFLAGS = $(CFLAGS_ALL_COMMON)
|
||||
@ -876,6 +881,7 @@ distclean-compile:
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-arr.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-chr.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-cli.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-cut.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-dir.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-ecs.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-err-sys.Plo@am__quote@ # am--include-marker
|
||||
@ -906,6 +912,7 @@ distclean-compile:
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-sed.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-sio.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-skad.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-std-cut.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-std-json.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-std-sed.Plo@am__quote@ # am--include-marker
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libhawk_la-std.Plo@am__quote@ # am--include-marker
|
||||
@ -1007,6 +1014,13 @@ libhawk_la-chr.lo: chr.c
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libhawk_la_CPPFLAGS) $(CPPFLAGS) $(libhawk_la_CFLAGS) $(CFLAGS) -c -o libhawk_la-chr.lo `test -f 'chr.c' || echo '$(srcdir)/'`chr.c
|
||||
|
||||
libhawk_la-cut.lo: cut.c
|
||||
@am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libhawk_la_CPPFLAGS) $(CPPFLAGS) $(libhawk_la_CFLAGS) $(CFLAGS) -MT libhawk_la-cut.lo -MD -MP -MF $(DEPDIR)/libhawk_la-cut.Tpo -c -o libhawk_la-cut.lo `test -f 'cut.c' || echo '$(srcdir)/'`cut.c
|
||||
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libhawk_la-cut.Tpo $(DEPDIR)/libhawk_la-cut.Plo
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='cut.c' object='libhawk_la-cut.lo' libtool=yes @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libhawk_la_CPPFLAGS) $(CPPFLAGS) $(libhawk_la_CFLAGS) $(CFLAGS) -c -o libhawk_la-cut.lo `test -f 'cut.c' || echo '$(srcdir)/'`cut.c
|
||||
|
||||
libhawk_la-dir.lo: dir.c
|
||||
@am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libhawk_la_CPPFLAGS) $(CPPFLAGS) $(libhawk_la_CFLAGS) $(CFLAGS) -MT libhawk_la-dir.lo -MD -MP -MF $(DEPDIR)/libhawk_la-dir.Tpo -c -o libhawk_la-dir.lo `test -f 'dir.c' || echo '$(srcdir)/'`dir.c
|
||||
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libhawk_la-dir.Tpo $(DEPDIR)/libhawk_la-dir.Plo
|
||||
@ -1357,6 +1371,13 @@ libhawk_la-std.lo: std.c
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libhawk_la_CPPFLAGS) $(CPPFLAGS) $(libhawk_la_CFLAGS) $(CFLAGS) -c -o libhawk_la-std.lo `test -f 'std.c' || echo '$(srcdir)/'`std.c
|
||||
|
||||
libhawk_la-std-cut.lo: std-cut.c
|
||||
@am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libhawk_la_CPPFLAGS) $(CPPFLAGS) $(libhawk_la_CFLAGS) $(CFLAGS) -MT libhawk_la-std-cut.lo -MD -MP -MF $(DEPDIR)/libhawk_la-std-cut.Tpo -c -o libhawk_la-std-cut.lo `test -f 'std-cut.c' || echo '$(srcdir)/'`std-cut.c
|
||||
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libhawk_la-std-cut.Tpo $(DEPDIR)/libhawk_la-std-cut.Plo
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='std-cut.c' object='libhawk_la-std-cut.lo' libtool=yes @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libhawk_la_CPPFLAGS) $(CPPFLAGS) $(libhawk_la_CFLAGS) $(CFLAGS) -c -o libhawk_la-std-cut.lo `test -f 'std-cut.c' || echo '$(srcdir)/'`std-cut.c
|
||||
|
||||
libhawk_la-std-json.lo: std-json.c
|
||||
@am__fastdepCC_TRUE@ $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libhawk_la_CPPFLAGS) $(CPPFLAGS) $(libhawk_la_CFLAGS) $(CFLAGS) -MT libhawk_la-std-json.lo -MD -MP -MF $(DEPDIR)/libhawk_la-std-json.Tpo -c -o libhawk_la-std-json.lo `test -f 'std-json.c' || echo '$(srcdir)/'`std-json.c
|
||||
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libhawk_la-std-json.Tpo $(DEPDIR)/libhawk_la-std-json.Plo
|
||||
@ -1660,6 +1681,7 @@ distclean: distclean-am
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-arr.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-chr.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-cli.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-cut.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-dir.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-ecs.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-err-sys.Plo
|
||||
@ -1690,6 +1712,7 @@ distclean: distclean-am
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-sed.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-sio.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-skad.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-std-cut.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-std-json.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-std-sed.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-std.Plo
|
||||
@ -1777,6 +1800,7 @@ maintainer-clean: maintainer-clean-am
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-arr.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-chr.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-cli.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-cut.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-dir.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-ecs.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-err-sys.Plo
|
||||
@ -1807,6 +1831,7 @@ maintainer-clean: maintainer-clean-am
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-sed.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-sio.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-skad.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-std-cut.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-std-json.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-std-sed.Plo
|
||||
-rm -f ./$(DEPDIR)/libhawk_la-std.Plo
|
||||
|
124
lib/cut-prv.h
Normal file
124
lib/cut-prv.h
Normal file
@ -0,0 +1,124 @@
|
||||
/*
|
||||
Copyright (c) 2006-2020 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.
|
||||
*/
|
||||
|
||||
#ifndef _HAWK_CUT_PRV_H_
|
||||
#define _HAWK_CUT_PRV_H_
|
||||
|
||||
#include <hawk-cut.h>
|
||||
#include <hawk-ecs.h>
|
||||
|
||||
typedef struct hawk_cut_sel_blk_t hawk_cut_sel_blk_t;
|
||||
|
||||
struct hawk_cut_sel_blk_t
|
||||
{
|
||||
hawk_oow_t len;
|
||||
struct
|
||||
{
|
||||
enum
|
||||
{
|
||||
HAWK_SED_SEL_CHAR = HAWK_T('c'),
|
||||
HAWK_SED_SEL_FIELD = HAWK_T('f')
|
||||
} id;
|
||||
hawk_oow_t start;
|
||||
hawk_oow_t end;
|
||||
} range[128];
|
||||
hawk_cut_sel_blk_t* next;
|
||||
};
|
||||
|
||||
struct hawk_cut_t
|
||||
{
|
||||
HAWK_CUT_HDR;
|
||||
|
||||
#if 0
|
||||
hawk_cut_errstr_t errstr; /**< error string getter */
|
||||
hawk_cut_errnum_t errnum; /**< stores an error number */
|
||||
hawk_ooch_t errmsg[128]; /**< error message holder */
|
||||
#endif
|
||||
|
||||
int option; /**< stores options */
|
||||
|
||||
struct
|
||||
{
|
||||
hawk_cut_sel_blk_t fb; /**< the first block is static */
|
||||
hawk_cut_sel_blk_t* lb; /**< points to the last block */
|
||||
|
||||
hawk_ooch_t din; /**< input field delimiter */
|
||||
hawk_ooch_t dout; /**< output field delimiter */
|
||||
|
||||
hawk_oow_t count;
|
||||
hawk_oow_t fcount;
|
||||
hawk_oow_t ccount;
|
||||
} sel;
|
||||
|
||||
struct
|
||||
{
|
||||
/** data needed for output streams */
|
||||
struct
|
||||
{
|
||||
hawk_cut_io_impl_t fun; /**< an output handler */
|
||||
hawk_cut_io_arg_t arg; /**< output handling data */
|
||||
|
||||
hawk_ooch_t buf[2048];
|
||||
hawk_oow_t len;
|
||||
int eof;
|
||||
} out;
|
||||
|
||||
/** data needed for input streams */
|
||||
struct
|
||||
{
|
||||
hawk_cut_io_impl_t fun; /**< an input handler */
|
||||
hawk_cut_io_arg_t arg; /**< input handling data */
|
||||
|
||||
hawk_ooch_t xbuf[1]; /**< a read-ahead buffer */
|
||||
int xbuf_len; /**< data length in the buffer */
|
||||
|
||||
hawk_ooch_t buf[2048]; /**< input buffer */
|
||||
hawk_oow_t len; /**< data length in the buffer */
|
||||
hawk_oow_t pos; /**< current position in the buffer */
|
||||
int eof; /**< EOF indicator */
|
||||
|
||||
hawk_ooecs_t line; /**< pattern space */
|
||||
hawk_oow_t num; /**< current line number */
|
||||
|
||||
hawk_oow_t nflds; /**< the number of fields */
|
||||
hawk_oow_t cflds; /**< capacity of flds field */
|
||||
hawk_oocs_t sflds[128]; /**< static field buffer */
|
||||
hawk_oocs_t* flds;
|
||||
int delimited;
|
||||
} in;
|
||||
} e;
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/* NOTHING */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
745
lib/cut.c
Normal file
745
lib/cut.c
Normal file
@ -0,0 +1,745 @@
|
||||
/*
|
||||
Copyright (c) 2006-2020 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 "cut-prv.h"
|
||||
#include "hawk-prv.h"
|
||||
#include <hawk-chr.h>
|
||||
|
||||
static int hawk_cut_init (hawk_cut_t* cut, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr);
|
||||
static void hawk_cut_fini (hawk_cut_t* cut);
|
||||
|
||||
#define SETERR0(cut,num) \
|
||||
do { hawk_cut_seterrnum (cut, HAWK_NULL, num); } while (0)
|
||||
|
||||
#define DFL_LINE_CAPA 256
|
||||
|
||||
static int add_selector_block (hawk_cut_t* cut)
|
||||
{
|
||||
hawk_cut_sel_blk_t* b;
|
||||
|
||||
b = (hawk_cut_sel_blk_t*)hawk_cut_allocmem(cut, HAWK_SIZEOF(*b));
|
||||
if (HAWK_UNLIKELY(!b)) return -1;
|
||||
|
||||
HAWK_MEMSET(b, 0, HAWK_SIZEOF(*b));
|
||||
b->next = HAWK_NULL;
|
||||
b->len = 0;
|
||||
|
||||
cut->sel.lb->next = b;
|
||||
cut->sel.lb = b;
|
||||
cut->sel.count = 0;
|
||||
cut->sel.fcount = 0;
|
||||
cut->sel.ccount = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void free_all_selector_blocks (hawk_cut_t* cut)
|
||||
{
|
||||
hawk_cut_sel_blk_t* b;
|
||||
|
||||
for (b = cut->sel.fb.next; b != HAWK_NULL; )
|
||||
{
|
||||
hawk_cut_sel_blk_t* nxt = b->next;
|
||||
hawk_cut_freemem(cut, b);
|
||||
b = nxt;
|
||||
}
|
||||
|
||||
cut->sel.lb = &cut->sel.fb;
|
||||
cut->sel.lb->len = 0;
|
||||
cut->sel.lb->next = HAWK_NULL;
|
||||
cut->sel.count = 0;
|
||||
cut->sel.fcount = 0;
|
||||
cut->sel.ccount = 0;
|
||||
}
|
||||
|
||||
hawk_cut_t* hawk_cut_open (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, hawk_cmgr_t* cmgr, hawk_errnum_t* errnum)
|
||||
{
|
||||
hawk_cut_t* cut;
|
||||
|
||||
cut = (hawk_cut_t*)HAWK_MMGR_ALLOC(mmgr, HAWK_SIZEOF(hawk_cut_t) + xtnsize);
|
||||
if (HAWK_LIKELY(cut))
|
||||
{
|
||||
if (hawk_cut_init(cut, mmgr, cmgr) <= -1)
|
||||
{
|
||||
if (errnum) *errnum = hawk_cut_geterrnum(cut);
|
||||
HAWK_MMGR_FREE (mmgr, cut);
|
||||
cut = HAWK_NULL;
|
||||
}
|
||||
else HAWK_MEMSET(cut + 1, 0, xtnsize);
|
||||
}
|
||||
else if (errnum) *errnum = HAWK_ENOMEM;
|
||||
|
||||
return cut;
|
||||
}
|
||||
|
||||
void hawk_cut_close (hawk_cut_t* cut)
|
||||
{
|
||||
hawk_cut_fini (cut);
|
||||
HAWK_MMGR_FREE (hawk_cut_getmmgr(cut), cut);
|
||||
}
|
||||
|
||||
static int hawk_cut_init (hawk_cut_t* cut, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr)
|
||||
{
|
||||
HAWK_MEMSET (cut, 0, HAWK_SIZEOF(*cut));
|
||||
|
||||
cut->_instsize = HAWK_SIZEOF(*cut);
|
||||
cut->_gem.mmgr = mmgr;
|
||||
cut->_gem.cmgr = cmgr;
|
||||
|
||||
/* initialize error handling fields */
|
||||
cut->_gem.errnum = HAWK_ENOERR;
|
||||
cut->_gem.errmsg[0] = '\0';
|
||||
cut->_gem.errloc.line = 0;
|
||||
cut->_gem.errloc.colm = 0;
|
||||
cut->_gem.errloc.file = HAWK_NULL;
|
||||
cut->_gem.errstr = hawk_dfl_errstr;
|
||||
|
||||
|
||||
/* on init, the last points to the first */
|
||||
cut->sel.lb = &cut->sel.fb;
|
||||
/* the block has no data yet */
|
||||
cut->sel.fb.len = 0;
|
||||
|
||||
cut->e.in.cflds = HAWK_COUNTOF(cut->e.in.sflds);
|
||||
cut->e.in.flds = cut->e.in.sflds;
|
||||
|
||||
if (hawk_ooecs_init(&cut->e.in.line, hawk_cut_getgem(cut), DFL_LINE_CAPA) <= -1) return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void hawk_cut_fini (hawk_cut_t* cut)
|
||||
{
|
||||
free_all_selector_blocks (cut);
|
||||
if (cut->e.in.flds != cut->e.in.sflds) hawk_cut_freemem(cut, cut->e.in.flds);
|
||||
hawk_ooecs_fini(&cut->e.in.line);
|
||||
}
|
||||
|
||||
void hawk_cut_setoption (hawk_cut_t* cut, int option)
|
||||
{
|
||||
cut->option = option;
|
||||
}
|
||||
|
||||
int hawk_cut_getoption (hawk_cut_t* cut)
|
||||
{
|
||||
return cut->option;
|
||||
}
|
||||
|
||||
void hawk_cut_clear (hawk_cut_t* cut)
|
||||
{
|
||||
free_all_selector_blocks (cut);
|
||||
if (cut->e.in.flds != cut->e.in.sflds) hawk_cut_freemem(cut, cut->e.in.flds);
|
||||
cut->e.in.cflds = HAWK_COUNTOF(cut->e.in.sflds);
|
||||
cut->e.in.flds = cut->e.in.sflds;
|
||||
|
||||
hawk_ooecs_clear(&cut->e.in.line);
|
||||
hawk_ooecs_setcapa(&cut->e.in.line, DFL_LINE_CAPA);
|
||||
}
|
||||
|
||||
int hawk_cut_comp (hawk_cut_t* cut, const hawk_ooch_t* str, hawk_oow_t len)
|
||||
{
|
||||
const hawk_ooch_t* p = str;
|
||||
const hawk_ooch_t* xnd = str + len;
|
||||
hawk_ooci_t c;
|
||||
int sel = HAWK_SED_SEL_CHAR;
|
||||
|
||||
#define CC(x,y) (((x) <= (y))? ((hawk_ooci_t)*(x)): HAWK_OOCI_EOF)
|
||||
#define NC(x,y) (((x) < (y))? ((hawk_ooci_t)*(++(x))): HAWK_OOCI_EOF)
|
||||
#define EOF(x) ((x) == HAWK_OOCI_EOF)
|
||||
#define MASK_START (1 << 1)
|
||||
#define MASK_END (1 << 2)
|
||||
#define MAX HAWK_TYPE_MAX(hawk_oow_t)
|
||||
|
||||
/* free selector blocks compiled previously */
|
||||
free_all_selector_blocks (cut);
|
||||
|
||||
/* set the default delimiters */
|
||||
cut->sel.din = HAWK_T(' ');
|
||||
cut->sel.dout = HAWK_T(' ');
|
||||
|
||||
/* if the selector string is empty, don't need to proceed */
|
||||
if (len <= 0) return 0;
|
||||
|
||||
/* compile the selector string */
|
||||
xnd--; c = CC (p, xnd);
|
||||
while (1)
|
||||
{
|
||||
hawk_oow_t start = 0, end = 0;
|
||||
int mask = 0;
|
||||
|
||||
while (hawk_is_ooch_space(c)) c = NC(p, xnd);
|
||||
if (EOF(c))
|
||||
{
|
||||
if (cut->sel.count > 0)
|
||||
{
|
||||
SETERR0 (cut, HAWK_CUT_ESELNV);
|
||||
return -1;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (c == HAWK_T('d'))
|
||||
{
|
||||
/* the next character is the input delimiter.
|
||||
* the output delimiter defaults to the input
|
||||
* delimiter. */
|
||||
c = NC(p, xnd);
|
||||
if (EOF(c))
|
||||
{
|
||||
SETERR0 (cut, HAWK_CUT_ESELNV);
|
||||
return -1;
|
||||
}
|
||||
cut->sel.din = c;
|
||||
cut->sel.dout = c;
|
||||
|
||||
c = NC(p, xnd);
|
||||
}
|
||||
else if (c == HAWK_T('D'))
|
||||
{
|
||||
/* the next two characters are the input and
|
||||
* the output delimiter each. */
|
||||
c = NC(p, xnd);
|
||||
if (EOF(c))
|
||||
{
|
||||
SETERR0 (cut, HAWK_CUT_ESELNV);
|
||||
return -1;
|
||||
}
|
||||
cut->sel.din = c;
|
||||
|
||||
c = NC(p, xnd);
|
||||
if (EOF(c))
|
||||
{
|
||||
SETERR0 (cut, HAWK_CUT_ESELNV);
|
||||
return -1;
|
||||
}
|
||||
cut->sel.dout = c;
|
||||
|
||||
c = NC(p, xnd);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (c == HAWK_T('c') || c == HAWK_T('f'))
|
||||
{
|
||||
sel = c;
|
||||
c = NC(p, xnd);
|
||||
while (hawk_is_ooch_space(c)) c = NC(p, xnd);
|
||||
}
|
||||
|
||||
if (hawk_is_ooch_digit(c))
|
||||
{
|
||||
do
|
||||
{
|
||||
start = start * 10 + (c - HAWK_T('0'));
|
||||
c = NC(p, xnd);
|
||||
}
|
||||
while (hawk_is_ooch_digit(c));
|
||||
|
||||
while (hawk_is_ooch_space(c)) c = NC(p, xnd);
|
||||
mask |= MASK_START;
|
||||
}
|
||||
else start++;
|
||||
|
||||
if (c == HAWK_T('-'))
|
||||
{
|
||||
c = NC(p, xnd);
|
||||
while (hawk_is_ooch_space(c)) c = NC(p, xnd);
|
||||
|
||||
if (hawk_is_ooch_digit(c))
|
||||
{
|
||||
do
|
||||
{
|
||||
end = end * 10 + (c - HAWK_T('0'));
|
||||
c = NC(p, xnd);
|
||||
}
|
||||
while (hawk_is_ooch_digit(c));
|
||||
mask |= MASK_END;
|
||||
}
|
||||
else end = MAX;
|
||||
|
||||
while (hawk_is_ooch_space(c)) c = NC(p, xnd);
|
||||
}
|
||||
else end = start;
|
||||
|
||||
if (!(mask & (MASK_START | MASK_END)))
|
||||
{
|
||||
SETERR0 (cut, HAWK_CUT_ESELNV);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (cut->sel.lb->len >= HAWK_COUNTOF(cut->sel.lb->range))
|
||||
{
|
||||
if (add_selector_block (cut) <= -1)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
cut->sel.lb->range[cut->sel.lb->len].id = sel;
|
||||
cut->sel.lb->range[cut->sel.lb->len].start = start;
|
||||
cut->sel.lb->range[cut->sel.lb->len].end = end;
|
||||
cut->sel.lb->len++;
|
||||
cut->sel.count++;
|
||||
if (sel == HAWK_SED_SEL_FIELD) cut->sel.fcount++;
|
||||
else cut->sel.ccount++;
|
||||
}
|
||||
|
||||
if (EOF(c)) break;
|
||||
if (c == HAWK_T(',')) c = NC(p, xnd);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int read_char (hawk_cut_t* cut, hawk_ooch_t* c)
|
||||
{
|
||||
hawk_ooi_t n;
|
||||
|
||||
if (cut->e.in.pos >= cut->e.in.len)
|
||||
{
|
||||
n = cut->e.in.fun(cut, HAWK_CUT_IO_READ, &cut->e.in.arg, cut->e.in.buf, HAWK_COUNTOF(cut->e.in.buf));
|
||||
if (n <= -1) return -1;
|
||||
if (n == 0) return 0; /* end of file */
|
||||
|
||||
cut->e.in.len = n;
|
||||
cut->e.in.pos = 0;
|
||||
}
|
||||
|
||||
*c = cut->e.in.buf[cut->e.in.pos++];
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int read_line (hawk_cut_t* cut)
|
||||
{
|
||||
hawk_oow_t len = 0;
|
||||
hawk_ooch_t c;
|
||||
int n;
|
||||
|
||||
hawk_ooecs_clear(&cut->e.in.line);
|
||||
if (cut->e.in.eof) return 0;
|
||||
|
||||
while (1)
|
||||
{
|
||||
n = read_char(cut, &c);
|
||||
if (n <= -1) return -1;
|
||||
if (n == 0)
|
||||
{
|
||||
cut->e.in.eof = 1;
|
||||
if (len == 0) return 0;
|
||||
break;
|
||||
}
|
||||
|
||||
if (c == HAWK_T('\n'))
|
||||
{
|
||||
/* don't include the line terminater to a line */
|
||||
/* TODO: support different line end convension */
|
||||
break;
|
||||
}
|
||||
|
||||
if (hawk_ooecs_ccat(&cut->e.in.line, c) == (hawk_oow_t)-1) return -1;
|
||||
len++;
|
||||
}
|
||||
|
||||
cut->e.in.num++;
|
||||
|
||||
if (cut->option & HAWK_CUT_TRIMSPACE) hawk_ooecs_trim(&cut->e.in.line, HAWK_TRIM_LEFT | HAWK_TRIM_RIGHT);
|
||||
if (cut->option & HAWK_CUT_NORMSPACE) hawk_ooecs_compact(&cut->e.in.line);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int flush (hawk_cut_t* cut)
|
||||
{
|
||||
hawk_oow_t pos = 0;
|
||||
hawk_ooi_t n;
|
||||
|
||||
while (cut->e.out.len > 0)
|
||||
{
|
||||
n = cut->e.out.fun(cut, HAWK_CUT_IO_WRITE, &cut->e.out.arg, &cut->e.out.buf[pos], cut->e.out.len);
|
||||
if (n <= -1) return -1;
|
||||
if (n == 0) return -1; /* reached the end of file - this is also an error */
|
||||
|
||||
pos += n;
|
||||
cut->e.out.len -= n;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int write_char (hawk_cut_t* cut, hawk_ooch_t c)
|
||||
{
|
||||
cut->e.out.buf[cut->e.out.len++] = c;
|
||||
if (c == HAWK_T('\n') || cut->e.out.len >= HAWK_COUNTOF(cut->e.out.buf)) return flush(cut);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int write_linebreak (hawk_cut_t* cut)
|
||||
{
|
||||
/* TODO: different line termination convention */
|
||||
return write_char(cut, HAWK_T('\n'));
|
||||
}
|
||||
|
||||
static int write_str (hawk_cut_t* cut, const hawk_ooch_t* str, hawk_oow_t len)
|
||||
{
|
||||
hawk_oow_t i;
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
{
|
||||
if (write_char(cut, str[i]) <= -1) return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cut_chars (hawk_cut_t* cut, hawk_oow_t start, hawk_oow_t end, int delim)
|
||||
{
|
||||
const hawk_ooch_t* ptr = HAWK_OOECS_PTR(&cut->e.in.line);
|
||||
hawk_oow_t len = HAWK_OOECS_LEN(&cut->e.in.line);
|
||||
|
||||
if (len <= 0) return 0;
|
||||
|
||||
if (start <= end)
|
||||
{
|
||||
if (start <= len && end > 0)
|
||||
{
|
||||
if (start >= 1) start--;
|
||||
if (end >= 1) end--;
|
||||
|
||||
if (end >= len) end = len - 1;
|
||||
|
||||
if (delim && write_char(cut, cut->sel.dout) <= -1) return -1;
|
||||
if (write_str(cut, &ptr[start], end-start+1) <= -1) return -1;
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (start > 0 && end <= len)
|
||||
{
|
||||
hawk_oow_t i;
|
||||
|
||||
if (start >= 1) start--;
|
||||
if (end >= 1) end--;
|
||||
|
||||
if (start >= len) start = len - 1;
|
||||
|
||||
if (delim && write_char (cut, cut->sel.dout) <= -1)
|
||||
return -1;
|
||||
|
||||
for (i = start; i >= end; i--)
|
||||
{
|
||||
if (write_char (cut, ptr[i]) <= -1)
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int isdelim (hawk_cut_t* cut, hawk_ooch_t c)
|
||||
{
|
||||
return ((cut->option & HAWK_CUT_WHITESPACE) && hawk_is_ooch_space(c)) ||
|
||||
(!(cut->option & HAWK_CUT_WHITESPACE) && c == cut->sel.din);
|
||||
}
|
||||
|
||||
static int split_line (hawk_cut_t* cut)
|
||||
{
|
||||
const hawk_ooch_t* ptr = HAWK_OOECS_PTR(&cut->e.in.line);
|
||||
hawk_oow_t len = HAWK_OOECS_LEN(&cut->e.in.line);
|
||||
hawk_oow_t i, x = 0, xl = 0;
|
||||
|
||||
cut->e.in.delimited = 0;
|
||||
cut->e.in.flds[x].ptr = ptr;
|
||||
for (i = 0; i < len; )
|
||||
{
|
||||
hawk_ooch_t c = ptr[i++];
|
||||
if (isdelim(cut,c))
|
||||
{
|
||||
if (cut->option & HAWK_CUT_FOLDDELIMS)
|
||||
{
|
||||
while (i < len && isdelim(cut,ptr[i])) i++;
|
||||
}
|
||||
|
||||
cut->e.in.flds[x++].len = xl;
|
||||
|
||||
if (x >= cut->e.in.cflds)
|
||||
{
|
||||
hawk_oocs_t* tmp;
|
||||
hawk_oow_t nsz;
|
||||
|
||||
nsz = cut->e.in.cflds;
|
||||
if (nsz > 100000) nsz += 100000;
|
||||
else nsz *= 2;
|
||||
|
||||
tmp = hawk_cut_allocmem(cut, HAWK_SIZEOF(*tmp) * nsz);
|
||||
if (HAWK_UNLIKELY(!tmp)) return -1;
|
||||
|
||||
HAWK_MEMCPY (tmp, cut->e.in.flds, HAWK_SIZEOF(*tmp) * cut->e.in.cflds);
|
||||
|
||||
if (cut->e.in.flds != cut->e.in.sflds) hawk_cut_freemem(cut, cut->e.in.flds);
|
||||
cut->e.in.flds = tmp;
|
||||
cut->e.in.cflds = nsz;
|
||||
}
|
||||
|
||||
xl = 0;
|
||||
cut->e.in.flds[x].ptr = &ptr[i];
|
||||
cut->e.in.delimited = 1;
|
||||
}
|
||||
else xl++;
|
||||
}
|
||||
cut->e.in.flds[x].len = xl;
|
||||
cut->e.in.nflds = ++x;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cut_fields (hawk_cut_t* cut, hawk_oow_t start, hawk_oow_t end, int delim)
|
||||
{
|
||||
hawk_oow_t len = cut->e.in.nflds;
|
||||
|
||||
if (!cut->e.in.delimited /*|| len <= 0*/) return 0;
|
||||
|
||||
HAWK_ASSERT (len > 0);
|
||||
if (start <= end)
|
||||
{
|
||||
if (start <= len && end > 0)
|
||||
{
|
||||
hawk_oow_t i;
|
||||
|
||||
if (start >= 1) start--;
|
||||
if (end >= 1) end--;
|
||||
|
||||
if (end >= len) end = len - 1;
|
||||
|
||||
if (delim && write_char(cut, cut->sel.dout) <= -1) return -1;
|
||||
|
||||
for (i = start; i <= end; i++)
|
||||
{
|
||||
if (write_str(cut, cut->e.in.flds[i].ptr, cut->e.in.flds[i].len) <= -1) return -1;
|
||||
if (i < end && write_char(cut, cut->sel.dout) <= -1) return -1;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (start > 0 && end <= len)
|
||||
{
|
||||
hawk_oow_t i;
|
||||
|
||||
if (start >= 1) start--;
|
||||
if (end >= 1) end--;
|
||||
|
||||
if (start >= len) start = len - 1;
|
||||
|
||||
if (delim && write_char (cut, cut->sel.dout) <= -1)
|
||||
return -1;
|
||||
|
||||
for (i = start; i >= end; i--)
|
||||
{
|
||||
if (write_str(cut, cut->e.in.flds[i].ptr, cut->e.in.flds[i].len) <= -1) return -1;
|
||||
if (i > end && write_char (cut, cut->sel.dout) <= -1) return -1;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int hawk_cut_exec (hawk_cut_t* cut, hawk_cut_io_impl_t inf, hawk_cut_io_impl_t outf)
|
||||
{
|
||||
int ret = 0;
|
||||
hawk_ooi_t n;
|
||||
|
||||
cut->e.out.fun = outf;
|
||||
cut->e.out.eof = 0;
|
||||
cut->e.out.len = 0;
|
||||
|
||||
cut->e.in.fun = inf;
|
||||
cut->e.in.eof = 0;
|
||||
cut->e.in.len = 0;
|
||||
cut->e.in.pos = 0;
|
||||
cut->e.in.num = 0;
|
||||
|
||||
n = cut->e.in.fun(cut, HAWK_CUT_IO_OPEN, &cut->e.in.arg, HAWK_NULL, 0);
|
||||
if (n <= -1)
|
||||
{
|
||||
ret = -1;
|
||||
goto done3;
|
||||
}
|
||||
if (n == 0)
|
||||
{
|
||||
/* EOF reached upon opening an input stream.
|
||||
* no data to process. this is success */
|
||||
goto done2;
|
||||
}
|
||||
|
||||
n = cut->e.out.fun (cut, HAWK_CUT_IO_OPEN, &cut->e.out.arg, HAWK_NULL, 0);
|
||||
if (n <= -1)
|
||||
{
|
||||
ret = -1;
|
||||
goto done2;
|
||||
}
|
||||
if (n == 0)
|
||||
{
|
||||
/* still don't know if we will write something.
|
||||
* just mark EOF on the output stream and continue */
|
||||
cut->e.out.eof = 1;
|
||||
}
|
||||
|
||||
while (1)
|
||||
{
|
||||
hawk_cut_sel_blk_t* b;
|
||||
int id = 0; /* mark 'no output' so far */
|
||||
int delimited = 0;
|
||||
int linebreak = 0;
|
||||
|
||||
n = read_line (cut);
|
||||
if (n <= -1) { ret = -1; goto done; }
|
||||
if (n == 0) goto done;
|
||||
|
||||
if (cut->sel.fcount > 0)
|
||||
{
|
||||
if (split_line (cut) <= -1) { ret = -1; goto done; }
|
||||
delimited = cut->e.in.delimited;
|
||||
}
|
||||
|
||||
for (b = &cut->sel.fb; b != HAWK_NULL; b = b->next)
|
||||
{
|
||||
hawk_oow_t i;
|
||||
|
||||
for (i = 0; i < b->len; i++)
|
||||
{
|
||||
if (b->range[i].id == HAWK_SED_SEL_CHAR)
|
||||
{
|
||||
n = cut_chars (
|
||||
cut,
|
||||
b->range[i].start,
|
||||
b->range[i].end,
|
||||
id == 2
|
||||
);
|
||||
if (n >= 1)
|
||||
{
|
||||
/* mark a char's been output */
|
||||
id = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
n = cut_fields (
|
||||
cut,
|
||||
b->range[i].start,
|
||||
b->range[i].end,
|
||||
id > 0
|
||||
);
|
||||
if (n >= 1)
|
||||
{
|
||||
/* mark a field's been output */
|
||||
id = 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (n <= -1) { ret = -1; goto done; }
|
||||
}
|
||||
}
|
||||
|
||||
if (cut->sel.ccount > 0)
|
||||
{
|
||||
/* so long as there is a character selector,
|
||||
* a newline must be printed */
|
||||
linebreak = 1;
|
||||
}
|
||||
else if (cut->sel.fcount > 0)
|
||||
{
|
||||
/* if only field selectors are specified */
|
||||
|
||||
if (delimited)
|
||||
{
|
||||
/* and if the input line is delimited,
|
||||
* write a line break */
|
||||
linebreak = 1;
|
||||
}
|
||||
else if (!(cut->option & HAWK_CUT_DELIMONLY))
|
||||
{
|
||||
/* if not delimited, write the
|
||||
* entire undelimited input line depending
|
||||
* on the option set. */
|
||||
if (write_str(cut, HAWK_OOECS_PTR(&cut->e.in.line), HAWK_OOECS_LEN(&cut->e.in.line)) <= -1)
|
||||
{
|
||||
ret = -1; goto done;
|
||||
}
|
||||
|
||||
/* a line break is needed in this case */
|
||||
linebreak = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (linebreak && write_linebreak(cut) <= -1)
|
||||
{
|
||||
ret = -1; goto done;
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
cut->e.out.fun (cut, HAWK_CUT_IO_CLOSE, &cut->e.out.arg, HAWK_NULL, 0);
|
||||
done2:
|
||||
cut->e.in.fun (cut, HAWK_CUT_IO_CLOSE, &cut->e.in.arg, HAWK_NULL, 0);
|
||||
done3:
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/* -------------------------------------- */
|
||||
|
||||
void* hawk_cut_allocmem (hawk_cut_t* cut, hawk_oow_t size)
|
||||
{
|
||||
void* ptr = HAWK_MMGR_ALLOC(hawk_cut_getmmgr(cut), size);
|
||||
if (HAWK_UNLIKELY(!ptr)) hawk_cut_seterrnum(cut, HAWK_NULL, HAWK_ENOMEM);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void* hawk_cut_callocmem (hawk_cut_t* cut, hawk_oow_t size)
|
||||
{
|
||||
void* ptr = HAWK_MMGR_ALLOC(hawk_cut_getmmgr(cut), size);
|
||||
if (HAWK_LIKELY(ptr)) HAWK_MEMSET(ptr, 0, size);
|
||||
else hawk_cut_seterrnum(cut, HAWK_NULL, HAWK_ENOMEM);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void* hawk_cut_reallocmem (hawk_cut_t* cut, void* ptr, hawk_oow_t size)
|
||||
{
|
||||
void* nptr = HAWK_MMGR_REALLOC(hawk_cut_getmmgr(cut), ptr, size);
|
||||
if (HAWK_UNLIKELY(!nptr)) hawk_cut_seterrnum(cut, HAWK_NULL, HAWK_ENOMEM);
|
||||
return nptr;
|
||||
}
|
||||
|
||||
void hawk_cut_freemem (hawk_cut_t* cut, void* ptr)
|
||||
{
|
||||
HAWK_MMGR_FREE(hawk_cut_getmmgr(cut), ptr);
|
||||
}
|
@ -447,3 +447,26 @@ hawk_oow_t FN(fmt) (str_t* str, const char_t* fmt, ...)
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
hawk_oow_t FN(compact) (str_t* str)
|
||||
{
|
||||
if (str->val.ptr)
|
||||
{
|
||||
str->val.len = compact_chars(str->val.ptr, str->val.len);
|
||||
str->val.ptr[str->val.len] = '\0';
|
||||
}
|
||||
return str->val.len;
|
||||
}
|
||||
|
||||
hawk_oow_t FN(trim) (str_t* str, int flags)
|
||||
{
|
||||
if (str->val.ptr)
|
||||
{
|
||||
const char_t* ptr;
|
||||
hawk_oow_t len = str->val.len;
|
||||
ptr = trim_chars(str->val.ptr, &len, flags);
|
||||
copy_chars(str->val.ptr, ptr, len);
|
||||
str->val.ptr[len] = '\0';
|
||||
}
|
||||
return str->val.len;
|
||||
}
|
||||
|
12
lib/ecs.c
12
lib/ecs.c
@ -34,12 +34,18 @@
|
||||
#undef char_t
|
||||
#undef cstr_t
|
||||
#undef count_chars
|
||||
#undef compact_chars
|
||||
#undef copy_chars
|
||||
#undef trim_chars
|
||||
#define FN(verb) _FN(becs,verb)
|
||||
#define T(x) HAWK_BT(x)
|
||||
#define str_t hawk_becs_t
|
||||
#define char_t hawk_bch_t
|
||||
#define cstr_t hawk_bcs_t
|
||||
#define count_chars(x) hawk_count_bcstr(x)
|
||||
#define compact_chars(x,l) hawk_compact_bchars(x,l)
|
||||
#define copy_chars(x,y,l) hawk_copy_bchars(x,y,l)
|
||||
#define trim_chars(x,l,f) hawk_trim_bchars(x,l,f)
|
||||
#define BUILD_BECS
|
||||
#include "ecs-imp.h"
|
||||
|
||||
@ -51,12 +57,18 @@
|
||||
#undef char_t
|
||||
#undef cstr_t
|
||||
#undef count_chars
|
||||
#undef compact_chars
|
||||
#undef copy_chars
|
||||
#undef trim_chars
|
||||
#define FN(verb) _FN(uecs,verb)
|
||||
#define T(x) HAWK_UT(x)
|
||||
#define str_t hawk_uecs_t
|
||||
#define char_t hawk_uch_t
|
||||
#define cstr_t hawk_ucs_t
|
||||
#define count_chars(x) hawk_count_ucstr(x)
|
||||
#define compact_chars(x,l) hawk_compact_uchars(x,l)
|
||||
#define copy_chars(x,y,l) hawk_copy_uchars(x,y,l)
|
||||
#define trim_chars(x,l,f) hawk_trim_uchars(x,l,f)
|
||||
#define BUILD_UECS
|
||||
#include "ecs-imp.h"
|
||||
|
||||
|
@ -209,6 +209,10 @@ const hawk_ooch_t* hawk_dfl_errstr (hawk_errnum_t errnum)
|
||||
HAWK_T("occurrence specifier too large"),
|
||||
HAWK_T("no previous regular expression"),
|
||||
HAWK_T("cut selector not valid"),
|
||||
HAWK_T("I/O error with file '${0}'"),
|
||||
|
||||
/* cut error messages */
|
||||
HAWK_T("selector not valid"),
|
||||
HAWK_T("I/O error with file '${0}'")
|
||||
};
|
||||
|
||||
|
@ -1079,6 +1079,10 @@ enum hawk_errnum_t
|
||||
HAWK_SED_ECSLNV, /**< cut selector not valid */
|
||||
HAWK_SED_EIOFIL, /**< io error with file '${0}' */
|
||||
|
||||
/* cut errors */
|
||||
HAWK_CUT_ESELNV, /**< selector not valid */
|
||||
HAWK_CUT_EIOFIL, /**< io error with file '${0}'*/
|
||||
|
||||
/* the number of error numbers, internal use only */
|
||||
HAWK_NUMERRNUMS
|
||||
};
|
||||
|
481
lib/hawk-cut.h
Normal file
481
lib/hawk-cut.h
Normal file
@ -0,0 +1,481 @@
|
||||
/*
|
||||
Copyright (c) 2006-2020 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.
|
||||
*/
|
||||
|
||||
#ifndef _HAWK_CUT_H_
|
||||
#define _HAWK_CUT_H_
|
||||
|
||||
#include <hawk-cmn.h>
|
||||
#include <hawk-gem.h>
|
||||
#include <hawk-sio.h>
|
||||
|
||||
/** @file
|
||||
* This file defines a text cutter utility.
|
||||
*
|
||||
* @todo HAWK_CUT_ORDEREDSEL - A selector 5,3,1 is ordered to 1,3,5
|
||||
*/
|
||||
|
||||
/**
|
||||
* @example cut.c
|
||||
* This example implements a simple cut utility.
|
||||
*/
|
||||
|
||||
/** @struct hawk_cut_t
|
||||
* The hawk_cut_t type defines a text cutter. The details are hidden as it is
|
||||
* a large complex structure vulnerable to unintended changes.
|
||||
*/
|
||||
typedef struct hawk_cut_t hawk_cut_t;
|
||||
|
||||
#define HAWK_CUT_HDR \
|
||||
hawk_oow_t _instsize; \
|
||||
hawk_gem_t _gem
|
||||
|
||||
typedef struct hawk_cut_alt_t hawk_cut_alt_t;
|
||||
struct hawk_cut_alt_t
|
||||
{
|
||||
/* ensure that hawk_cut_alt_t matches the beginning part of hawk_cut_t */
|
||||
HAWK_CUT_HDR;
|
||||
};
|
||||
|
||||
/**
|
||||
* The hawk_cut_option_t type defines various option codes for a text cutter.
|
||||
* Options can be OR'ed with each other and be passed to a text cutter with
|
||||
* the hawk_cut_setoption() function.
|
||||
*/
|
||||
enum hawk_cut_option_t
|
||||
{
|
||||
/** show delimited line only. if not set, undelimited lines are
|
||||
* shown in its entirety */
|
||||
HAWK_CUT_DELIMONLY = (1 << 0),
|
||||
|
||||
/** treat any whitespaces as an input delimiter */
|
||||
HAWK_CUT_WHITESPACE = (1 << 2),
|
||||
|
||||
/** fold adjacent delimiters */
|
||||
HAWK_CUT_FOLDDELIMS = (1 << 3),
|
||||
|
||||
/** trim leading and trailing whitespaces off the input line */
|
||||
HAWK_CUT_TRIMSPACE = (1 << 4),
|
||||
|
||||
/** normalize whitespaces in the input line */
|
||||
HAWK_CUT_NORMSPACE = (1 << 5)
|
||||
};
|
||||
typedef enum hawk_cut_option_t hawk_cut_option_t;
|
||||
|
||||
/**
|
||||
* The hawk_cut_io_cmd_t type defines I/O command codes. The code indicates
|
||||
* the action to take in an I/O handler.
|
||||
*/
|
||||
enum hawk_cut_io_cmd_t
|
||||
{
|
||||
HAWK_CUT_IO_OPEN = 0,
|
||||
HAWK_CUT_IO_CLOSE = 1,
|
||||
HAWK_CUT_IO_READ = 2,
|
||||
HAWK_CUT_IO_WRITE = 3
|
||||
};
|
||||
typedef enum hawk_cut_io_cmd_t hawk_cut_io_cmd_t;
|
||||
|
||||
/**
|
||||
* The hawk_cut_io_arg_t type defines a data structure required by
|
||||
* an I/O handler.
|
||||
*/
|
||||
struct hawk_cut_io_arg_t
|
||||
{
|
||||
void* handle; /**< I/O handle */
|
||||
const hawk_ooch_t* path; /**< file path. HAWK_NULL for a console */
|
||||
};
|
||||
typedef struct hawk_cut_io_arg_t hawk_cut_io_arg_t;
|
||||
|
||||
/**
|
||||
* The hawk_cut_io_impl_t type defines an I/O handler. hawk_cut_exec() calls
|
||||
* I/O handlers to read from and write to a text stream.
|
||||
*/
|
||||
typedef hawk_ooi_t (*hawk_cut_io_impl_t) (
|
||||
hawk_cut_t* cut,
|
||||
hawk_cut_io_cmd_t cmd,
|
||||
hawk_cut_io_arg_t* arg,
|
||||
hawk_ooch_t* data,
|
||||
hawk_oow_t count
|
||||
);
|
||||
|
||||
/* ------------------------------------------------------------------------ */
|
||||
|
||||
/**
|
||||
* The hawk_cut_iostd_type_t type defines types of standard
|
||||
* I/O resources.
|
||||
*/
|
||||
enum hawk_cut_iostd_type_t
|
||||
{
|
||||
HAWK_CUT_IOSTD_NULL, /**< null resource type */
|
||||
HAWK_CUT_IOSTD_FILE, /**< file */
|
||||
HAWK_CUT_IOSTD_FILEB, /**< file */
|
||||
HAWK_CUT_IOSTD_FILEU, /**< file */
|
||||
HAWK_CUT_IOSTD_OOCS, /**< string */
|
||||
HAWK_CUT_IOSTD_BCS,
|
||||
HAWK_CUT_IOSTD_UCS,
|
||||
HAWK_CUT_IOSTD_SIO /**< sio */
|
||||
};
|
||||
typedef enum hawk_cut_iostd_type_t hawk_cut_iostd_type_t;
|
||||
|
||||
/**
|
||||
* The hawk_cut_iostd_t type defines a standard I/O resource.
|
||||
*/
|
||||
struct hawk_cut_iostd_t
|
||||
{
|
||||
/** resource type */
|
||||
hawk_cut_iostd_type_t type;
|
||||
|
||||
/** union describing the resource of the specified type */
|
||||
union
|
||||
{
|
||||
/** file path with character encoding */
|
||||
struct
|
||||
{
|
||||
/** file path to open. #HAWK_NULL or '-' for stdin/stdout. */
|
||||
const hawk_ooch_t* path;
|
||||
/** a stream created with the file path is set with this
|
||||
* cmgr if it is not #HAWK_NULL. */
|
||||
hawk_cmgr_t* cmgr;
|
||||
} file;
|
||||
|
||||
struct
|
||||
{
|
||||
const hawk_bch_t* path;
|
||||
hawk_cmgr_t* cmgr;
|
||||
} fileb;
|
||||
|
||||
struct
|
||||
{
|
||||
const hawk_uch_t* path;
|
||||
hawk_cmgr_t* cmgr;
|
||||
} fileu;
|
||||
|
||||
/**
|
||||
* input string or dynamically allocated output string
|
||||
*
|
||||
* For input, the ptr and the len field of str indicates the
|
||||
* pointer and the length of a string to read. You must set
|
||||
* these two fields before calling hawk_cut_execstd().
|
||||
*
|
||||
* For output, the ptr and the len field of str indicates the
|
||||
* pointer and the length of produced output. The output
|
||||
* string is dynamically allocated. You don't need to set these
|
||||
* fields before calling hawk_cut_execstd() because they are
|
||||
* set by hawk_cut_execstd() and valid while the relevant cut
|
||||
* object is alive. You must free the memory chunk pointed to by
|
||||
* the ptr field with hawk_cut_freemem() once you're done with it
|
||||
* to avoid memory leaks.
|
||||
*/
|
||||
hawk_oocs_t oocs;
|
||||
hawk_bcs_t bcs;
|
||||
hawk_ucs_t ucs;
|
||||
|
||||
/** pre-opened sio stream */
|
||||
hawk_sio_t* sio;
|
||||
} u;
|
||||
};
|
||||
|
||||
typedef struct hawk_cut_iostd_t hawk_cut_iostd_t;
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* The hawk_cut_open() function creates a text cutter.
|
||||
* @return A pointer to a text cutter on success, #HAWK_NULL on failure
|
||||
*/
|
||||
|
||||
HAWK_EXPORT hawk_cut_t* hawk_cut_open (
|
||||
hawk_mmgr_t* mmgr, /**< memory manager */
|
||||
hawk_oow_t xtnsize, /**< extension size in bytes */
|
||||
hawk_cmgr_t* cmgr,
|
||||
hawk_errnum_t* errnum
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_close() function destroys a text cutter.
|
||||
*/
|
||||
HAWK_EXPORT void hawk_cut_close (
|
||||
hawk_cut_t* cut /**< text cutter */
|
||||
);
|
||||
|
||||
#if defined(HAWK_HAVE_INLINE)
|
||||
/**
|
||||
* The hawk_cut_getxtn() function returns the pointer to the extension area
|
||||
* placed behind the actual cut object.
|
||||
*/
|
||||
static HAWK_INLINE void* hawk_cut_getxtn (hawk_cut_t* cut) { return (void*)((hawk_uint8_t*)cut + ((hawk_cut_alt_t*)cut)->_instsize); }
|
||||
|
||||
/**
|
||||
* The hawk_cut_getgem() function gets the pointer to the gem structure of the
|
||||
* cut object.
|
||||
*/
|
||||
static HAWK_INLINE hawk_gem_t* hawk_cut_getgem (hawk_cut_t* cut) { return &((hawk_cut_alt_t*)cut)->_gem; }
|
||||
|
||||
/**
|
||||
* The hawk_cut_getmmgr() function gets the memory manager ucut in
|
||||
* hawk_cut_open().
|
||||
*/
|
||||
static HAWK_INLINE hawk_mmgr_t* hawk_cut_getmmgr (hawk_cut_t* cut) { return ((hawk_cut_alt_t*)cut)->_gem.mmgr; }
|
||||
static HAWK_INLINE hawk_cmgr_t* hawk_cut_getcmgr (hawk_cut_t* cut) { return ((hawk_cut_alt_t*)cut)->_gem.cmgr; }
|
||||
static HAWK_INLINE void hawk_cut_setcmgr (hawk_cut_t* cut, hawk_cmgr_t* cmgr) { ((hawk_cut_alt_t*)cut)->_gem.cmgr = cmgr; }
|
||||
#else
|
||||
#define hawk_cut_getxtn(cut) ((void*)((hawk_uint8_t*)cut + ((hawk_cut_alt_t*)cut)->_instsize))
|
||||
#define hawk_cut_getgem(cut) (&((hawk_cut_alt_t*)(cut))->_gem)
|
||||
#define hawk_cut_getmmgr(cut) (((hawk_cut_alt_t*)(cut))->_gem.mmgr)
|
||||
#define hawk_cut_getcmgr(cut) (((hawk_cut_alt_t*)(cut))->_gem.cmgr)
|
||||
#define hawk_cut_setcmgr(cut,_cmgr) (((hawk_cut_alt_t*)(cut))->_gem.cmgr = (_cmgr))
|
||||
#endif /* HAWK_HAVE_INLINE */
|
||||
|
||||
/**
|
||||
* The hawk_cut_getoption() function retrieves the current options set in
|
||||
* a text cutter.
|
||||
* @return 0 or a number OR'ed of #hawk_cut_option_t values
|
||||
*/
|
||||
HAWK_EXPORT int hawk_cut_getoption (
|
||||
hawk_cut_t* cut /**< text cutter */
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_setoption() function sets the option code.
|
||||
*/
|
||||
HAWK_EXPORT void hawk_cut_setoption (
|
||||
hawk_cut_t* cut, /**< text cutter */
|
||||
int opt /**< 0 or a number OR'ed of #hawk_cut_option_t values */
|
||||
);
|
||||
|
||||
HAWK_EXPORT hawk_errstr_t hawk_cut_geterrstr (
|
||||
hawk_cut_t* cut
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_geterrnum() function returns the number of the last error
|
||||
* occurred.
|
||||
* \return error number
|
||||
*/
|
||||
|
||||
/**
|
||||
* The hawk_cut_geterror() function gets an error number, an error location,
|
||||
* and an error message. The information is set to the memory area pointed
|
||||
* to by each parameter.
|
||||
*/
|
||||
#if defined(HAWK_HAVE_INLINE)
|
||||
static HAWK_INLINE hawk_errnum_t hawk_cut_geterrnum (hawk_cut_t* cut) { return hawk_gem_geterrnum(hawk_cut_getgem(cut)); }
|
||||
static HAWK_INLINE const hawk_loc_t* hawk_cut_geterrloc (hawk_cut_t* cut) { return hawk_gem_geterrloc(hawk_cut_getgem(cut)); }
|
||||
static HAWK_INLINE const hawk_bch_t* hawk_cut_geterrbmsg (hawk_cut_t* cut) { return hawk_gem_geterrbmsg(hawk_cut_getgem(cut)); }
|
||||
static HAWK_INLINE const hawk_uch_t* hawk_cut_geterrumsg (hawk_cut_t* cut) { return hawk_gem_geterrumsg(hawk_cut_getgem(cut)); }
|
||||
static HAWK_INLINE void hawk_cut_geterrbinf (hawk_cut_t* cut, hawk_errbinf_t* errinf) { return hawk_gem_geterrbinf(hawk_cut_getgem(cut), errinf); }
|
||||
static HAWK_INLINE void hawk_cut_geterruinf (hawk_cut_t* cut, hawk_erruinf_t* errinf) { return hawk_gem_geterruinf(hawk_cut_getgem(cut), errinf); }
|
||||
static HAWK_INLINE void hawk_cut_geterror (hawk_cut_t* cut, hawk_errnum_t* errnum, const hawk_ooch_t** errmsg, hawk_loc_t* errloc) { return hawk_gem_geterror(hawk_cut_getgem(cut), errnum, errmsg, errloc); }
|
||||
#else
|
||||
#define hawk_cut_geterrnum(cut) hawk_gem_geterrnum(hawk_cut_getgem(cut))
|
||||
#define hawk_cut_geterrloc(cut) hawk_gem_geterrloc(hawk_cut_getgem(cut))
|
||||
#define hawk_cut_geterrbmsg(cut) hawk_gem_geterrbmsg(hawk_cut_getgem(cut))
|
||||
#define hawk_cut_geterrumsg(cut) hawk_gem_geterrumsg(hawk_cut_getgem(cut))
|
||||
#define hawk_cut_geterrbinf(cut, errinf) (hawk_gem_geterrbinf(hawk_cut_getgem(cut), errinf))
|
||||
#define hawk_cut_geterruinf(cut, errinf) (hawk_gem_geterruinf(hawk_cut_getgem(cut), errinf))
|
||||
#define hawk_cut_geterror(cut, errnum, errmsg, errloc) (hawk_gem_geterror(hawk_cut_getgem(cut), errnum, errmsg, errloc))
|
||||
#endif
|
||||
|
||||
#if defined(HAWK_OOCH_IS_BCH)
|
||||
# define hawk_cut_geterrmsg hawk_cut_geterrbmsg
|
||||
# define hawk_cut_geterrinf hawk_cut_geterrbinf
|
||||
#else
|
||||
# define hawk_cut_geterrmsg hawk_cut_geterrumsg
|
||||
# define hawk_cut_geterrinf hawk_cut_geterruinf
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* The hawk_cut_seterrnum() function sets the error information omitting
|
||||
* error location. You must pass a non-NULL for \a errarg if the specified
|
||||
* error number \a errnum requires one or more arguments to format an
|
||||
* error message.
|
||||
*/
|
||||
#if defined(HAWK_HAVE_INLINE)
|
||||
static HAWK_INLINE void hawk_cut_seterrnum (hawk_cut_t* cut, const hawk_loc_t* errloc, hawk_errnum_t errnum) { hawk_gem_seterrnum (hawk_cut_getgem(cut), errloc, errnum); }
|
||||
static HAWK_INLINE void hawk_cut_seterrinf (hawk_cut_t* cut, const hawk_errinf_t* errinf) { hawk_gem_seterrinf (hawk_cut_getgem(cut), errinf); }
|
||||
static HAWK_INLINE void hawk_cut_seterror (hawk_cut_t* cut, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_oocs_t* errarg) { hawk_gem_seterror(hawk_cut_getgem(cut), errloc, errnum, errarg); }
|
||||
static HAWK_INLINE const hawk_ooch_t* hawk_cut_backuperrmsg (hawk_cut_t* cut) { return hawk_gem_backuperrmsg(hawk_cut_getgem(cut)); }
|
||||
#else
|
||||
#define hawk_cut_seterrnum(cut, errloc, errnum) hawk_gem_seterrnum(hawk_cut_getgem(cut), errloc, errnum)
|
||||
#define hawk_cut_seterrinf(cut, errinf) hawk_gem_seterrinf(hawk_cut_getgem(cut), errinf)
|
||||
#define hawk_cut_seterror(cut, errloc, errnum, errarg) hawk_gem_seterror(hawk_cut_getgem(cut), errloc, errnum, errarg)
|
||||
#define hawk_cut_backuperrmsg(cut) hawk_gem_backuperrmsg(hawk_cut_getgem(cut))
|
||||
#endif
|
||||
|
||||
|
||||
HAWK_EXPORT void hawk_cut_seterrbfmt (
|
||||
hawk_cut_t* cut,
|
||||
const hawk_loc_t* errloc,
|
||||
hawk_errnum_t errnum,
|
||||
const hawk_bch_t* fmt,
|
||||
...
|
||||
);
|
||||
|
||||
HAWK_EXPORT void hawk_cut_seterrufmt (
|
||||
hawk_cut_t* cut,
|
||||
const hawk_loc_t* errloc,
|
||||
hawk_errnum_t errnum,
|
||||
const hawk_uch_t* fmt,
|
||||
...
|
||||
);
|
||||
|
||||
|
||||
HAWK_EXPORT void hawk_cut_seterrbvfmt (
|
||||
hawk_cut_t* cut,
|
||||
const hawk_loc_t* errloc,
|
||||
hawk_errnum_t errnum,
|
||||
const hawk_bch_t* errfmt,
|
||||
va_list ap
|
||||
);
|
||||
|
||||
HAWK_EXPORT void hawk_cut_seterruvfmt (
|
||||
hawk_cut_t* cut,
|
||||
const hawk_loc_t* errloc,
|
||||
hawk_errnum_t errnum,
|
||||
const hawk_uch_t* errfmt,
|
||||
va_list ap
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_clear() function clears memory buffers internally allocated.
|
||||
*/
|
||||
HAWK_EXPORT void hawk_cut_clear (
|
||||
hawk_cut_t* cut /**< text cutter */
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_comp() function compiles a selector into an internal form.
|
||||
* @return 0 on success, -1 on error
|
||||
*/
|
||||
HAWK_EXPORT int hawk_cut_comp (
|
||||
hawk_cut_t* cut, /**< text cutter */
|
||||
const hawk_ooch_t* str, /**< selector pointer */
|
||||
hawk_oow_t len /**< selector length */
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_exec() function executes the compiled commands.
|
||||
* @return 0 on success, -1 on error
|
||||
*/
|
||||
HAWK_EXPORT int hawk_cut_exec (
|
||||
hawk_cut_t* cut, /**< text cutter */
|
||||
hawk_cut_io_impl_t inf, /**< input text stream */
|
||||
hawk_cut_io_impl_t outf /**< output text stream */
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_allocmem() function allocates a chunk of memory using
|
||||
* the memory manager of \a cut.
|
||||
*/
|
||||
HAWK_EXPORT void* hawk_cut_allocmem (
|
||||
hawk_cut_t* cut,
|
||||
hawk_oow_t size
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_callocmem() function allocates a chunk of memory using
|
||||
* the memory manager of \a cut and clears it to zeros.
|
||||
*/
|
||||
HAWK_EXPORT void* hawk_cut_callocmem (
|
||||
hawk_cut_t* cut,
|
||||
hawk_oow_t size
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_reallocmem() function reallocates a chunk of memory using
|
||||
* the memory manager of \a cut.
|
||||
*/
|
||||
HAWK_EXPORT void* hawk_cut_reallocmem (
|
||||
hawk_cut_t* cut,
|
||||
void* ptr,
|
||||
hawk_oow_t size
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_freemem() function frees a chunk of memory using
|
||||
* the memory manager of \a cut.
|
||||
*/
|
||||
HAWK_EXPORT void hawk_cut_freemem (
|
||||
hawk_cut_t* cut,
|
||||
void* ptr
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_openstd() function creates a text cutter with the default
|
||||
* memory manager and initialized it for other hawk_cut_xxxxstd functions.
|
||||
* @return pointer to a text cutter on success, QSE_NULL on failure.
|
||||
*/
|
||||
HAWK_EXPORT hawk_cut_t* hawk_cut_openstd (
|
||||
hawk_oow_t xtnsize, /**< extension size in bytes */
|
||||
hawk_errnum_t* errnum
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_openstdwithmmgr() function creates a text cutter with a
|
||||
* user-defined memory manager. It is equivalent to hawk_cut_openstd(),
|
||||
* except that you can specify your own memory manager.
|
||||
* @return pointer to a text cutter on success, QSE_NULL on failure.
|
||||
*/
|
||||
HAWK_EXPORT hawk_cut_t* hawk_cut_openstdwithmmgr (
|
||||
hawk_mmgr_t* mmgr, /**< memory manager */
|
||||
hawk_oow_t xtnsize, /**< extension size in bytes */
|
||||
hawk_cmgr_t* cmgr,
|
||||
hawk_errnum_t* errnum
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_compstd() function compiles a null-terminated selector.
|
||||
* Call hawk_cut_comp() for a length delimited selector.
|
||||
*/
|
||||
HAWK_EXPORT int hawk_cut_compstd (
|
||||
hawk_cut_t* cut,
|
||||
const hawk_ooch_t* str
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_cut_execstd() function executes the compiled script
|
||||
* over an input file @a infile and an output file @a outfile.
|
||||
* If @a infile is QSE_NULL, the standard console input is used.
|
||||
* If @a outfile is QSE_NULL, the standard console output is used..
|
||||
*/
|
||||
HAWK_EXPORT int hawk_cut_execstd (
|
||||
hawk_cut_t* cut,
|
||||
hawk_cut_iostd_t in[],
|
||||
hawk_cut_iostd_t* out
|
||||
);
|
||||
|
||||
HAWK_EXPORT int hawk_cut_execstdfile (
|
||||
hawk_cut_t* cut,
|
||||
const hawk_ooch_t* infile,
|
||||
const hawk_ooch_t* outfile,
|
||||
hawk_cmgr_t* cmgr
|
||||
);
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
@ -335,6 +335,15 @@ HAWK_EXPORT hawk_oow_t hawk_becs_fmt (
|
||||
...
|
||||
);
|
||||
|
||||
HAWK_EXPORT hawk_oow_t hawk_becs_compact (
|
||||
hawk_becs_t* str
|
||||
);
|
||||
|
||||
HAWK_EXPORT hawk_oow_t hawk_becs_trim (
|
||||
hawk_becs_t* str,
|
||||
int flags
|
||||
);
|
||||
|
||||
/* ------------------------------------------------------------------------ */
|
||||
|
||||
/**
|
||||
@ -550,6 +559,15 @@ HAWK_EXPORT hawk_oow_t hawk_uecs_fmt (
|
||||
...
|
||||
);
|
||||
|
||||
HAWK_EXPORT hawk_oow_t hawk_uecs_compact (
|
||||
hawk_uecs_t* str
|
||||
);
|
||||
|
||||
HAWK_EXPORT hawk_oow_t hawk_uecs_trim (
|
||||
hawk_uecs_t* str,
|
||||
int flags
|
||||
);
|
||||
|
||||
#if defined(HAWK_OOCH_IS_UCH)
|
||||
# define hawk_ooecs_open hawk_uecs_open
|
||||
# define hawk_ooecs_close hawk_uecs_close
|
||||
@ -579,6 +597,8 @@ HAWK_EXPORT hawk_oow_t hawk_uecs_fmt (
|
||||
# define hawk_ooecs_fcat hawk_uecs_fcat
|
||||
# define hawk_ooecs_vfmt hawk_uecs_vfmt
|
||||
# define hawk_ooecs_fmt hawk_uecs_fmt
|
||||
# define hawk_ooecs_compact hawk_uecs_compact
|
||||
# define hawk_ooecs_trim hawk_uecs_trim
|
||||
#else
|
||||
# define hawk_ooecs_open hawk_becs_open
|
||||
# define hawk_ooecs_close hawk_becs_close
|
||||
@ -608,6 +628,8 @@ HAWK_EXPORT hawk_oow_t hawk_uecs_fmt (
|
||||
# define hawk_ooecs_fcat hawk_becs_fcat
|
||||
# define hawk_ooecs_vfmt hawk_becs_vfmt
|
||||
# define hawk_ooecs_fmt hawk_becs_fmt
|
||||
# define hawk_ooecs_compact hawk_becs_compact
|
||||
# define hawk_ooecs_trim hawk_becs_trim
|
||||
#endif
|
||||
|
||||
HAWK_EXPORT hawk_oow_t hawk_becs_ncatuchars (
|
||||
|
@ -499,7 +499,7 @@ HAWK_EXPORT hawk_htb_pair_t* hawk_htb_update (
|
||||
* hawk_htb_t* htb, hawk_htb_pair_t* pair,
|
||||
* void* kptr, hawk_oow_t klen, void* ctx)
|
||||
* {
|
||||
* hawk_cstr_t* v = (hawk_cstr_t*)ctx;
|
||||
* hawk_oocs_t* v = (hawk_oocs_t*)ctx;
|
||||
* if (pair == HAWK_NULL)
|
||||
* {
|
||||
* // no existing key for the key
|
||||
@ -552,7 +552,7 @@ HAWK_EXPORT hawk_htb_pair_t* hawk_htb_update (
|
||||
*
|
||||
* for (i = 0; i < HAWK_COUNTOF(vals); i++)
|
||||
* {
|
||||
* hawk_cstr_t ctx;
|
||||
* hawk_oocs_t ctx;
|
||||
* ctx.ptr = vals[i]; ctx.len = hawk_count_oocstr(vals[i]);
|
||||
* hawk_htb_cbsert (s1,
|
||||
* keys[i%HAWK_COUNTOF(keys)], hawk_count_oocstr(keys[i%HAWK_COUNTOF(keys)]),
|
||||
|
@ -463,7 +463,7 @@ HAWK_EXPORT hawk_rbt_pair_t* hawk_rbt_update (
|
||||
* hawk_rbt_t* rbt, hawk_rbt_pair_t* pair,
|
||||
* void* kptr, hawk_oow_t klen, void* ctx)
|
||||
* {
|
||||
* hawk_cstr_t* v = (hawk_cstr_t*)ctx;
|
||||
* hawk_oocs_t* v = (hawk_oocs_t*)ctx;
|
||||
* if (pair == HAWK_NULL)
|
||||
* {
|
||||
* // no existing key for the key
|
||||
@ -515,7 +515,7 @@ HAWK_EXPORT hawk_rbt_pair_t* hawk_rbt_update (
|
||||
*
|
||||
* for (i = 0; i < HAWK_COUNTOF(vals); i++)
|
||||
* {
|
||||
* hawk_cstr_t ctx;
|
||||
* hawk_oocs_t ctx;
|
||||
* ctx.ptr = vals[i]; ctx.len = hawk_count_oocstr(vals[i]);
|
||||
* hawk_rbt_cbsert (s1,
|
||||
* keys[i%HAWK_COUNTOF(keys)], hawk_count_oocstr(keys[i%HAWK_COUNTOF(keys)]),
|
||||
|
@ -735,6 +735,15 @@ HAWK_EXPORT void hawk_sed_setlinenum (
|
||||
hawk_oow_t num /**< a line number */
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_sed_getspace() function gets the pointer and the length
|
||||
* to a buffer space specfied by \a space.
|
||||
*/
|
||||
HAWK_EXPORT void hawk_sed_getspace (
|
||||
hawk_sed_t* sed,
|
||||
hawk_sed_space_t space,
|
||||
hawk_oocs_t* str
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_sed_allocmem() function allocates a chunk of memory using
|
||||
@ -746,7 +755,7 @@ HAWK_EXPORT void* hawk_sed_allocmem (
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_sed_allocmem() function allocates a chunk of memory using
|
||||
* The hawk_sed_callocmem() function allocates a chunk of memory using
|
||||
* the memory manager of \a sed and clears it to zeros.
|
||||
*/
|
||||
HAWK_EXPORT void* hawk_sed_callocmem (
|
||||
@ -755,7 +764,7 @@ HAWK_EXPORT void* hawk_sed_callocmem (
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_sed_allocmem() function reallocates a chunk of memory using
|
||||
* The hawk_sed_reallocmem() function reallocates a chunk of memory using
|
||||
* the memory manager of \a sed.
|
||||
*/
|
||||
HAWK_EXPORT void* hawk_sed_reallocmem (
|
||||
@ -765,7 +774,7 @@ HAWK_EXPORT void* hawk_sed_reallocmem (
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_sed_allocmem() function frees a chunk of memory using
|
||||
* The hawk_sed_freemem() function frees a chunk of memory using
|
||||
* the memory manager of \a sed.
|
||||
*/
|
||||
HAWK_EXPORT void hawk_sed_freemem (
|
||||
@ -773,16 +782,6 @@ HAWK_EXPORT void hawk_sed_freemem (
|
||||
void* ptr
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_sed_getspace() function gets the pointer and the length
|
||||
* to a buffer space specfied by \a space.
|
||||
*/
|
||||
HAWK_EXPORT void hawk_sed_getspace (
|
||||
hawk_sed_t* sed,
|
||||
hawk_sed_space_t space,
|
||||
hawk_oocs_t* str
|
||||
);
|
||||
|
||||
/* ------------------------------------------------------------------------ */
|
||||
|
||||
/**
|
||||
|
@ -272,10 +272,39 @@ HAWK_EXPORT const hawk_ooch_t* hawk_stdgetfileindirs (
|
||||
|
||||
/* ------------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
* The hawk_get_sys_mmgr() function returns a pointer to a stock memory manager structure
|
||||
* that can be used where a custom memory manager is not required. The returned structure
|
||||
* is managed internally and should not be modified or finalized by the caller.
|
||||
*
|
||||
* \return Pointer to the system-wide default memory manager.
|
||||
*/
|
||||
HAWK_EXPORT hawk_mmgr_t* hawk_get_sys_mmgr (
|
||||
void
|
||||
);
|
||||
|
||||
/**
|
||||
* This hawk_init_xma_mmgr() function initializes the memory manager structure pointed
|
||||
* to by `mmgr` with the specified memory limit `memlimit`. The caller is responsible for
|
||||
* allocating the memory for `mmgr` prior to calling this function.
|
||||
*
|
||||
* \return 0 on success, or a negative value on failure
|
||||
*/
|
||||
HAWK_EXPORT int hawk_init_xma_mmgr (
|
||||
hawk_mmgr_t* mmgr,
|
||||
hawk_oow_t memlimit
|
||||
);
|
||||
|
||||
/**
|
||||
* The hawk_fini_xma_mmgr() function cleans up resources associated with the memory
|
||||
* manager structure previously initialized by `hawk_init_xma_mmgr()`. After this call,
|
||||
* the `mmgr` structure should not be used unless it is re-initialized.
|
||||
*
|
||||
*/
|
||||
HAWK_EXPORT void hawk_fini_xma_mmgr (
|
||||
hawk_mmgr_t* mmgr
|
||||
);
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
@ -72,9 +72,8 @@
|
||||
*/
|
||||
#include <hawk-cmn.h>
|
||||
|
||||
#if defined(HAWK_BUILD_DEBUG)
|
||||
# define HAWK_XMA_ENABLE_STAT
|
||||
#endif
|
||||
/*#define HAWK_XMA_ENABLE_STAT*/
|
||||
#define HAWK_XMA_ENABLE_STAT
|
||||
|
||||
/** @struct hawk_xma_t
|
||||
* The hawk_xma_t type defines a simple memory allocator over a memory zone.
|
||||
@ -109,10 +108,19 @@ struct hawk_xma_t
|
||||
struct
|
||||
{
|
||||
hawk_oow_t total;
|
||||
hawk_oow_t alloc;
|
||||
hawk_oow_t avail;
|
||||
hawk_oow_t nused;
|
||||
hawk_oow_t nfree;
|
||||
hawk_oow_t alloc; /* allocated size */
|
||||
hawk_oow_t avail; /* available size */
|
||||
hawk_oow_t nused; /* nubmer of used blocks */
|
||||
hawk_oow_t nfree; /* number of free blocks */
|
||||
hawk_oow_t alloc_hwmark; /* high watermark - highest total memory ever allocated */
|
||||
|
||||
hawk_oow_t nallocops; /* number of alloc operations */
|
||||
hawk_oow_t nallocgoodops; /* number of successful alloc operations */
|
||||
hawk_oow_t nallocbadops; /* number of failed alloc operations */
|
||||
hawk_oow_t nreallocops; /* number of realloc operations */
|
||||
hawk_oow_t nreallocgoodops; /* number of good realloc operations */
|
||||
hawk_oow_t nreallocbadops; /* number of failed realloc operations - could fall back to normal alloc*/
|
||||
hawk_oow_t nfreeops; /* number of free operations */
|
||||
} stat;
|
||||
#endif
|
||||
};
|
||||
|
48
lib/sed.c
48
lib/sed.c
@ -2050,10 +2050,7 @@ static int read_char (hawk_sed_t* sed, hawk_ooch_t* c)
|
||||
{
|
||||
if (sed->e.in.pos >= sed->e.in.len)
|
||||
{
|
||||
n = sed->e.in.fun (
|
||||
sed, HAWK_SED_IO_READ, &sed->e.in.arg,
|
||||
sed->e.in.buf, HAWK_COUNTOF(sed->e.in.buf)
|
||||
);
|
||||
n = sed->e.in.fun(sed, HAWK_SED_IO_READ, &sed->e.in.arg, sed->e.in.buf, HAWK_COUNTOF(sed->e.in.buf));
|
||||
if (n <= -1) return -1;
|
||||
if (n == 0) return 0; /* end of file */
|
||||
|
||||
@ -2127,10 +2124,7 @@ static int flush (hawk_sed_t* sed)
|
||||
|
||||
while (sed->e.out.len > 0)
|
||||
{
|
||||
n = sed->e.out.fun (
|
||||
sed, HAWK_SED_IO_WRITE, &sed->e.out.arg,
|
||||
&sed->e.out.buf[pos], sed->e.out.len);
|
||||
|
||||
n = sed->e.out.fun(sed, HAWK_SED_IO_WRITE, &sed->e.out.arg, &sed->e.out.buf[pos], sed->e.out.len);
|
||||
if (n <= -1) return -1;
|
||||
if (n == 0) return -1; /* reached the end of file - this is also an error */
|
||||
|
||||
@ -2144,12 +2138,7 @@ static int flush (hawk_sed_t* sed)
|
||||
static int write_char (hawk_sed_t* sed, hawk_ooch_t c)
|
||||
{
|
||||
sed->e.out.buf[sed->e.out.len++] = c;
|
||||
if (c == HAWK_T('\n') ||
|
||||
sed->e.out.len >= HAWK_COUNTOF(sed->e.out.buf))
|
||||
{
|
||||
return flush (sed);
|
||||
}
|
||||
|
||||
if (c == HAWK_T('\n') || sed->e.out.len >= HAWK_COUNTOF(sed->e.out.buf)) return flush (sed);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -3949,6 +3938,21 @@ void hawk_sed_pushecb (hawk_sed_t* sed, hawk_sed_ecb_t* ecb)
|
||||
sed->ecb = ecb;
|
||||
}
|
||||
|
||||
void hawk_sed_getspace (hawk_sed_t* sed, hawk_sed_space_t space, hawk_oocs_t* str)
|
||||
{
|
||||
switch (space)
|
||||
{
|
||||
case HAWK_SED_SPACE_HOLD:
|
||||
str->ptr = HAWK_OOECS_PTR(&sed->e.txt.hold);
|
||||
str->len = HAWK_OOECS_LEN(&sed->e.txt.hold);
|
||||
break;
|
||||
case HAWK_SED_SPACE_PATTERN:
|
||||
str->ptr = HAWK_OOECS_PTR(&sed->e.in.line);
|
||||
str->len = HAWK_OOECS_LEN(&sed->e.in.line);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void* hawk_sed_allocmem (hawk_sed_t* sed, hawk_oow_t size)
|
||||
{
|
||||
void* ptr = HAWK_MMGR_ALLOC(hawk_sed_getmmgr(sed), size);
|
||||
@ -3975,19 +3979,3 @@ void hawk_sed_freemem (hawk_sed_t* sed, void* ptr)
|
||||
{
|
||||
HAWK_MMGR_FREE (hawk_sed_getmmgr(sed), ptr);
|
||||
}
|
||||
|
||||
|
||||
void hawk_sed_getspace (hawk_sed_t* sed, hawk_sed_space_t space, hawk_oocs_t* str)
|
||||
{
|
||||
switch (space)
|
||||
{
|
||||
case HAWK_SED_SPACE_HOLD:
|
||||
str->ptr = HAWK_OOECS_PTR(&sed->e.txt.hold);
|
||||
str->len = HAWK_OOECS_LEN(&sed->e.txt.hold);
|
||||
break;
|
||||
case HAWK_SED_SPACE_PATTERN:
|
||||
str->ptr = HAWK_OOECS_PTR(&sed->e.in.line);
|
||||
str->len = HAWK_OOECS_LEN(&sed->e.in.line);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
1217
lib/std-cut.c
Normal file
1217
lib/std-cut.c
Normal file
File diff suppressed because it is too large
Load Diff
@ -120,13 +120,14 @@ hawk_sed_t* hawk_sed_openstdwithmmgr (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, haw
|
||||
if (!cmgr) cmgr = hawk_get_cmgr_by_id(HAWK_CMGR_UTF8);
|
||||
|
||||
sed = hawk_sed_open(mmgr, HAWK_SIZEOF(xtn_t) + xtnsize, cmgr, errnum);
|
||||
if (!sed) return HAWK_NULL;
|
||||
if (HAWK_UNLIKELY(!sed)) return HAWK_NULL;
|
||||
|
||||
sed->_instsize += HAWK_SIZEOF(xtn_t);
|
||||
|
||||
return sed;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------- */
|
||||
|
||||
static int verify_iostd_in (hawk_sed_t* sed, hawk_sed_iostd_t in[])
|
||||
{
|
||||
hawk_oow_t i;
|
||||
@ -135,7 +136,7 @@ static int verify_iostd_in (hawk_sed_t* sed, hawk_sed_iostd_t in[])
|
||||
{
|
||||
/* if 'in' is specified, it must contains at least one
|
||||
* valid entry */
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_EINVAL, "no input handler provided");
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_EINVAL, "no input handler provided");
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -149,7 +150,7 @@ static int verify_iostd_in (hawk_sed_t* sed, hawk_sed_iostd_t in[])
|
||||
in[i].type != HAWK_SED_IOSTD_UCS &&
|
||||
in[i].type != HAWK_SED_IOSTD_SIO)
|
||||
{
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_EINVAL, "unsupported input type provided - handler %d type %d", i, in[i].type);
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_EINVAL, "unsupported input type provided - handler %d type %d", i, in[i].type);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
@ -165,7 +166,7 @@ static hawk_sio_t* open_sio_file (hawk_sed_t* sed, const hawk_ooch_t* file, int
|
||||
if (sio == HAWK_NULL)
|
||||
{
|
||||
const hawk_ooch_t* bem = hawk_sed_backuperrmsg(sed);
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to open %js - %js", file, bem);
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to open %js - %js", file, bem);
|
||||
}
|
||||
return sio;
|
||||
}
|
||||
@ -188,7 +189,7 @@ static hawk_ooch_t* add_sio_name_with_uchars (hawk_sed_t* sed, const hawk_uch_t*
|
||||
link = (hawk_link_t*)hawk_sed_callocmem(sed, HAWK_SIZEOF(*link) + HAWK_SIZEOF(hawk_uch_t) * (len + 1));
|
||||
if (!link) return HAWK_NULL;
|
||||
|
||||
hawk_copy_uchars_to_ucstr_unlimited ((hawk_uch_t*)(link + 1), ptr, len);
|
||||
hawk_copy_uchars_to_ucstr_unlimited((hawk_uch_t*)(link + 1), ptr, len);
|
||||
#else
|
||||
hawk_oow_t bcslen, ucslen;
|
||||
|
||||
@ -200,7 +201,7 @@ static hawk_ooch_t* add_sio_name_with_uchars (hawk_sed_t* sed, const hawk_uch_t*
|
||||
|
||||
ucslen = len;
|
||||
bcslen = bcslen + 1;
|
||||
hawk_gem_convutobchars (hawk_sed_getgem(sed), ptr, &ucslen, (hawk_bch_t*)(link + 1), &bcslen);
|
||||
hawk_gem_convutobchars(hawk_sed_getgem(sed), ptr, &ucslen, (hawk_bch_t*)(link + 1), &bcslen);
|
||||
((hawk_bch_t*)(link + 1))[bcslen] = '\0';
|
||||
#endif
|
||||
|
||||
@ -228,14 +229,14 @@ static hawk_ooch_t* add_sio_name_with_bchars (hawk_sed_t* sed, const hawk_bch_t*
|
||||
|
||||
bcslen = len;
|
||||
ucslen = ucslen + 1;
|
||||
hawk_gem_convbtouchars (hawk_sed_getgem(sed), ptr, &bcslen, (hawk_uch_t*)(link + 1), &ucslen, 0);
|
||||
hawk_gem_convbtouchars(hawk_sed_getgem(sed), ptr, &bcslen, (hawk_uch_t*)(link + 1), &ucslen, 0);
|
||||
((hawk_uch_t*)(link + 1))[ucslen] = '\0';
|
||||
|
||||
#else
|
||||
link = (hawk_link_t*)hawk_sed_callocmem(sed, HAWK_SIZEOF(*link) + HAWK_SIZEOF(hawk_bch_t) * (len + 1));
|
||||
if (!link) return HAWK_NULL;
|
||||
|
||||
hawk_copy_bchars_to_bcstr_unlimited ((hawk_bch_t*)(link + 1), ptr, len);
|
||||
hawk_copy_bchars_to_bcstr_unlimited((hawk_bch_t*)(link + 1), ptr, len);
|
||||
#endif
|
||||
|
||||
link->link = xtn->sio_names;
|
||||
@ -265,7 +266,7 @@ static hawk_sio_t* open_sio_std (hawk_sed_t* sed, hawk_sio_std_t std, int flags)
|
||||
if (sio == HAWK_NULL)
|
||||
{
|
||||
const hawk_ooch_t* bem = hawk_sed_backuperrmsg(sed);
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to open %js - %js", &sio_std_names[std], bem);
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to open %js - %js", &sio_std_names[std], bem);
|
||||
}
|
||||
return sio;
|
||||
}
|
||||
@ -284,25 +285,25 @@ static void set_eiofil_for_iostd (hawk_sed_t* sed, hawk_sed_iostd_t* io)
|
||||
case HAWK_SED_IOSTD_FILE:
|
||||
#endif
|
||||
case HAWK_SED_IOSTD_FILEB:
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "I/O error with file '%hs' - %js", io->u.fileb.path, bem);
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_SED_EIOFIL, "I/O error with file '%hs' - %js", io->u.fileb.path, bem);
|
||||
break;
|
||||
|
||||
#if defined(HAWK_OOCH_IS_UCH)
|
||||
case HAWK_SED_IOSTD_FILE:
|
||||
#endif
|
||||
case HAWK_SED_IOSTD_FILEU:
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "I/O error with file '%ls' - %js", io->u.fileu.path, bem);
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_SED_EIOFIL, "I/O error with file '%ls' - %js", io->u.fileu.path, bem);
|
||||
break;
|
||||
|
||||
default:
|
||||
HAWK_ASSERT (!"should never happen - unknown file I/O type");
|
||||
hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINVAL);
|
||||
hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_EINVAL);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "I/O error with file '%js' - %js", &sio_std_names[HAWK_SIO_STDIN], bem);
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_SED_EIOFIL, "I/O error with file '%js' - %js", &sio_std_names[HAWK_SIO_STDIN], bem);
|
||||
}
|
||||
}
|
||||
|
||||
@ -314,7 +315,7 @@ static void close_main_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_sed
|
||||
case HAWK_SED_IOSTD_FILE:
|
||||
case HAWK_SED_IOSTD_FILEB:
|
||||
case HAWK_SED_IOSTD_FILEU:
|
||||
hawk_sio_close (arg->handle);
|
||||
hawk_sio_close(arg->handle);
|
||||
break;
|
||||
|
||||
case HAWK_SED_IOSTD_OOCS:
|
||||
@ -412,7 +413,7 @@ static int open_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_sed_
|
||||
|
||||
default:
|
||||
HAWK_ASSERT (!"should never happen - io-type must be one of SIO,FILE,FILEB,FILEU,STR");
|
||||
hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINTERN);
|
||||
hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_EINTERN);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -576,7 +577,7 @@ static int open_output_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_sed
|
||||
|
||||
default:
|
||||
HAWK_ASSERT (!"should never happen - io-type must be one of SIO,FILE,FILEB,FILEU,STR");
|
||||
hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINTERN);
|
||||
hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_EINTERN);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -624,7 +625,7 @@ static hawk_ooi_t read_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, ha
|
||||
wcslen = len;
|
||||
if ((m = hawk_conv_bchars_to_uchars_with_cmgr(&io->u.bcs.ptr[base->mempos], &mbslen, buf, &wcslen, hawk_sed_getcmgr(sed), 0)) <= -1 && m != -2)
|
||||
{
|
||||
hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EECERR);
|
||||
hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_EECERR);
|
||||
n = -1;
|
||||
}
|
||||
else
|
||||
@ -646,7 +647,7 @@ static hawk_ooi_t read_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, ha
|
||||
mbslen = len;
|
||||
if ((m = hawk_conv_uchars_to_bchars_with_cmgr(&io->u.ucs.ptr[base->mempos], &wcslen, buf, &mbslen, hawk_sed_getcmgr(sed))) <= -1 && m != -2)
|
||||
{
|
||||
hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EECERR);
|
||||
hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_EECERR);
|
||||
n = -1;
|
||||
}
|
||||
else
|
||||
@ -714,7 +715,7 @@ static hawk_ooi_t read_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, ha
|
||||
arg->handle = old;
|
||||
|
||||
/* close the previous stream */
|
||||
close_main_stream (sed, arg, io);
|
||||
close_main_stream(sed, arg, io);
|
||||
|
||||
arg->handle = new;
|
||||
|
||||
@ -739,7 +740,7 @@ static hawk_ooi_t s_in (hawk_sed_t* sed, hawk_sed_io_cmd_t cmd, hawk_sed_io_arg_
|
||||
|
||||
case HAWK_SED_IO_CLOSE:
|
||||
{
|
||||
close_main_stream (sed, arg, xtn->s.in.cur);
|
||||
close_main_stream(sed, arg, xtn->s.in.cur);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -751,7 +752,7 @@ static hawk_ooi_t s_in (hawk_sed_t* sed, hawk_sed_io_cmd_t cmd, hawk_sed_io_arg_
|
||||
default:
|
||||
{
|
||||
HAWK_ASSERT (!"should never happen - cmd must be one of OPEN,CLOSE,READ");
|
||||
hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINTERN);
|
||||
hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_EINTERN);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
@ -799,13 +800,13 @@ static hawk_ooi_t x_in (hawk_sed_t* sed, hawk_sed_io_cmd_t cmd, hawk_sed_io_arg_
|
||||
{
|
||||
/* main data stream */
|
||||
if (xtn->e.in.ptr == HAWK_NULL)
|
||||
hawk_sio_close (arg->handle);
|
||||
hawk_sio_close(arg->handle);
|
||||
else
|
||||
close_main_stream (sed, arg, xtn->e.in.cur);
|
||||
close_main_stream(sed, arg, xtn->e.in.cur);
|
||||
}
|
||||
else
|
||||
{
|
||||
hawk_sio_close (arg->handle);
|
||||
hawk_sio_close(arg->handle);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -823,7 +824,7 @@ static hawk_ooi_t x_in (hawk_sed_t* sed, hawk_sed_io_cmd_t cmd, hawk_sed_io_arg_
|
||||
if (n <= -1)
|
||||
{
|
||||
const hawk_ooch_t* bem = hawk_sed_backuperrmsg(sed);
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to read '%js' - %js", &sio_std_names[HAWK_SIO_STDIN], bem);
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to read '%js' - %js", &sio_std_names[HAWK_SIO_STDIN], bem);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
@ -839,7 +840,7 @@ static hawk_ooi_t x_in (hawk_sed_t* sed, hawk_sed_io_cmd_t cmd, hawk_sed_io_arg_
|
||||
if (n <= -1)
|
||||
{
|
||||
const hawk_ooch_t* bem = hawk_sed_backuperrmsg(sed);
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to read '%js' - %js", arg->path, bem);
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to read '%js' - %js", arg->path, bem);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
@ -847,7 +848,7 @@ static hawk_ooi_t x_in (hawk_sed_t* sed, hawk_sed_io_cmd_t cmd, hawk_sed_io_arg_
|
||||
|
||||
default:
|
||||
HAWK_ASSERT (!"should never happen - cmd must be one of OPEN,CLOSE,READ");
|
||||
hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINTERN);
|
||||
hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_EINTERN);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
@ -908,13 +909,13 @@ static hawk_ooi_t x_out (
|
||||
if (arg->path == HAWK_NULL)
|
||||
{
|
||||
if (xtn->e.out.ptr == HAWK_NULL)
|
||||
hawk_sio_close (arg->handle);
|
||||
hawk_sio_close(arg->handle);
|
||||
else
|
||||
close_main_stream (sed, arg, xtn->e.out.ptr);
|
||||
close_main_stream(sed, arg, xtn->e.out.ptr);
|
||||
}
|
||||
else
|
||||
{
|
||||
hawk_sio_close (arg->handle);
|
||||
hawk_sio_close(arg->handle);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -977,7 +978,7 @@ static hawk_ooi_t x_out (
|
||||
if (n <= -1)
|
||||
{
|
||||
const hawk_ooch_t* bem = hawk_sed_backuperrmsg(sed);
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to write '%js' - %js", arg->path, bem);
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to write '%js' - %js", arg->path, bem);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
@ -985,11 +986,13 @@ static hawk_ooi_t x_out (
|
||||
|
||||
default:
|
||||
HAWK_ASSERT (!"should never happen - cmd must be one of OPEN,CLOSE,WRITE");
|
||||
hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINTERN);
|
||||
hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_EINTERN);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------- */
|
||||
|
||||
int hawk_sed_compstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_oow_t* count)
|
||||
{
|
||||
xtn_t* xtn = GET_XTN(sed);
|
||||
@ -998,7 +1001,7 @@ int hawk_sed_compstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_oow_t* count)
|
||||
if (in == HAWK_NULL)
|
||||
{
|
||||
/* it requires a valid array unlike hawk_sed_execstd(). */
|
||||
hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_EINVAL, "no input handler provided");
|
||||
hawk_sed_seterrbfmt(sed, HAWK_NULL, HAWK_EINVAL, "no input handler provided");
|
||||
if (count) *count = 0;
|
||||
return -1;
|
||||
}
|
||||
@ -1008,7 +1011,7 @@ int hawk_sed_compstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_oow_t* count)
|
||||
return -1;
|
||||
}
|
||||
|
||||
HAWK_MEMSET (&xtn->s, 0, HAWK_SIZEOF(xtn->s));
|
||||
HAWK_MEMSET(&xtn->s, 0, HAWK_SIZEOF(xtn->s));
|
||||
xtn->s.in.ptr = in;
|
||||
xtn->s.in.cur = in;
|
||||
|
||||
@ -1016,7 +1019,7 @@ int hawk_sed_compstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_oow_t* count)
|
||||
|
||||
if (count) *count = xtn->s.in.cur - xtn->s.in.ptr;
|
||||
|
||||
clear_sio_names (sed);
|
||||
clear_sio_names(sed);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -1035,12 +1038,12 @@ int hawk_sed_execstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_sed_iostd_t*
|
||||
out->type != HAWK_SED_IOSTD_OOCS &&
|
||||
out->type != HAWK_SED_IOSTD_SIO)
|
||||
{
|
||||
hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINVAL);
|
||||
hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_EINVAL);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
HAWK_MEMSET (&xtn->e, 0, HAWK_SIZEOF(xtn->e));
|
||||
HAWK_MEMSET(&xtn->e, 0, HAWK_SIZEOF(xtn->e));
|
||||
xtn->e.in.ptr = in;
|
||||
xtn->e.in.cur = in;
|
||||
xtn->e.out.ptr = out;
|
||||
@ -1060,7 +1063,7 @@ int hawk_sed_execstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_sed_iostd_t*
|
||||
HAWK_ASSERT (xtn->e.out.memstr.be != HAWK_NULL);
|
||||
hawk_becs_yield (xtn->e.out.memstr.be, &out->u.bcs, 0);
|
||||
}
|
||||
if (xtn->e.out.memstr.be) hawk_becs_close (xtn->e.out.memstr.be);
|
||||
if (xtn->e.out.memstr.be) hawk_becs_close(xtn->e.out.memstr.be);
|
||||
break;
|
||||
|
||||
#if defined(HAWK_OOCH_IS_UCH)
|
||||
@ -1072,7 +1075,7 @@ int hawk_sed_execstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_sed_iostd_t*
|
||||
HAWK_ASSERT (xtn->e.out.memstr.ue != HAWK_NULL);
|
||||
hawk_uecs_yield (xtn->e.out.memstr.ue, &out->u.ucs, 0);
|
||||
}
|
||||
if (xtn->e.out.memstr.ue) hawk_uecs_close (xtn->e.out.memstr.ue);
|
||||
if (xtn->e.out.memstr.ue) hawk_uecs_close(xtn->e.out.memstr.ue);
|
||||
break;
|
||||
|
||||
default:
|
||||
@ -1082,7 +1085,7 @@ int hawk_sed_execstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_sed_iostd_t*
|
||||
|
||||
}
|
||||
|
||||
clear_sio_names (sed);
|
||||
clear_sio_names(sed);
|
||||
return n;
|
||||
}
|
||||
|
||||
|
45
lib/std.c
45
lib/std.c
@ -26,6 +26,7 @@
|
||||
#include <hawk-std.h>
|
||||
#include <hawk-pio.h>
|
||||
#include <hawk-sio.h>
|
||||
#include <hawk-xma.h>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
@ -233,6 +234,47 @@ hawk_mmgr_t* hawk_get_sys_mmgr (void)
|
||||
{
|
||||
return &sys_mmgr;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
|
||||
static void* xma_alloc (hawk_mmgr_t* mmgr, hawk_oow_t size)
|
||||
{
|
||||
return hawk_xma_alloc(mmgr->ctx, size);
|
||||
}
|
||||
|
||||
static void* xma_realloc (hawk_mmgr_t* mmgr, void* ptr, hawk_oow_t size)
|
||||
{
|
||||
return hawk_xma_realloc(mmgr->ctx, ptr, size);
|
||||
}
|
||||
|
||||
static void xma_free (hawk_mmgr_t* mmgr, void* ptr)
|
||||
{
|
||||
hawk_xma_free (mmgr->ctx, ptr);
|
||||
}
|
||||
|
||||
int hawk_init_xma_mmgr (hawk_mmgr_t* mmgr, hawk_oow_t memlimit)
|
||||
{
|
||||
hawk_xma_t* xma;
|
||||
|
||||
xma = hawk_xma_open(hawk_get_sys_mmgr(), 0, HAWK_NULL, memlimit);
|
||||
if (HAWK_UNLIKELY(!xma)) return -1;
|
||||
|
||||
HAWK_MEMSET(mmgr, 0, HAWK_SIZEOF(*mmgr));
|
||||
mmgr->alloc = xma_alloc;
|
||||
mmgr->realloc = xma_realloc;
|
||||
mmgr->free = xma_free;
|
||||
mmgr->ctx = xma;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void hawk_fini_xma_mmgr (hawk_mmgr_t* mmgr)
|
||||
{
|
||||
if (mmgr->ctx) hawk_xma_close(mmgr->ctx);
|
||||
mmgr->ctx = HAWK_NULL;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
|
||||
@ -2490,14 +2532,13 @@ static int open_rio_console (hawk_rtx_t* rtx, hawk_rio_arg_t* riod)
|
||||
|
||||
if (rxtn->c.out.count == 0)
|
||||
{
|
||||
sio = open_sio_std_rtx (
|
||||
sio = open_sio_std_rtx(
|
||||
rtx, HAWK_SIO_STDOUT,
|
||||
HAWK_SIO_WRITE | HAWK_SIO_IGNOREECERR | HAWK_SIO_LINEBREAK
|
||||
);
|
||||
if (sio == HAWK_NULL) return -1;
|
||||
|
||||
if (rxtn->c.cmgr) hawk_sio_setcmgr (sio, rxtn->c.cmgr);
|
||||
|
||||
riod->handle = sio;
|
||||
rxtn->c.out.count++;
|
||||
return 1;
|
||||
|
@ -720,7 +720,7 @@ hawk_flt_t hawk_uchars_to_flt (const hawk_uch_t* str, hawk_oow_t len, const hawk
|
||||
end = str + len;
|
||||
|
||||
/* Strip off leading blanks and check for a sign */
|
||||
/*while (AWK_IS_SPACE(*p)) p++;*/
|
||||
/*while (hawk_is_uch_space(*p)) p++;*/
|
||||
if (stripspc)
|
||||
{
|
||||
/* strip off leading spaces */
|
||||
@ -929,7 +929,7 @@ hawk_flt_t hawk_bchars_to_flt (const hawk_bch_t* str, hawk_oow_t len, const hawk
|
||||
end = str + len;
|
||||
|
||||
/* Strip off leading blanks and check for a sign */
|
||||
/*while (AWK_IS_SPACE(*p)) p++;*/
|
||||
/*while (hawk_is_bch_space(*p)) p++;*/
|
||||
if (stripspc)
|
||||
{
|
||||
/* strip off leading spaces */
|
||||
|
102
lib/xma.c
102
lib/xma.c
@ -197,18 +197,18 @@ hawk_xma_t* hawk_xma_open (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, void* zoneptr,
|
||||
|
||||
if (hawk_xma_init(xma, mmgr, zoneptr, zonesize) <= -1)
|
||||
{
|
||||
HAWK_MMGR_FREE (mmgr, xma);
|
||||
HAWK_MMGR_FREE(mmgr, xma);
|
||||
return HAWK_NULL;
|
||||
}
|
||||
|
||||
HAWK_MEMSET (xma + 1, 0, xtnsize);
|
||||
HAWK_MEMSET(xma + 1, 0, xtnsize);
|
||||
return xma;
|
||||
}
|
||||
|
||||
void hawk_xma_close (hawk_xma_t* xma)
|
||||
{
|
||||
hawk_xma_fini (xma);
|
||||
HAWK_MMGR_FREE (xma->_mmgr, xma);
|
||||
HAWK_MMGR_FREE(xma->_mmgr, xma);
|
||||
}
|
||||
|
||||
int hawk_xma_init (hawk_xma_t* xma, hawk_mmgr_t* mmgr, void* zoneptr, hawk_oow_t zonesize)
|
||||
@ -246,7 +246,7 @@ int hawk_xma_init (hawk_xma_t* xma, hawk_mmgr_t* mmgr, void* zoneptr, hawk_oow_t
|
||||
first->free_prev = HAWK_NULL;
|
||||
first->free_next = HAWK_NULL;
|
||||
|
||||
HAWK_MEMSET (xma, 0, HAWK_SIZEOF(*xma));
|
||||
HAWK_MEMSET(xma, 0, HAWK_SIZEOF(*xma));
|
||||
xma->_mmgr = mmgr;
|
||||
xma->bdec = szlog2(FIXED * ALIGN); /* precalculate the decrement value */
|
||||
|
||||
@ -268,6 +268,15 @@ int hawk_xma_init (hawk_xma_t* xma, hawk_mmgr_t* mmgr, void* zoneptr, hawk_oow_t
|
||||
xma->stat.avail = zonesize - MBLKHDRSIZE;
|
||||
xma->stat.nfree = 1;
|
||||
xma->stat.nused = 0;
|
||||
xma->stat.alloc_hwmark = 0;
|
||||
|
||||
xma->stat.nallocops = 0;
|
||||
xma->stat.nallocgoodops = 0;
|
||||
xma->stat.nallocbadops = 0;
|
||||
xma->stat.nreallocops = 0;
|
||||
xma->stat.nreallocgoodops = 0;
|
||||
xma->stat.nreallocbadops = 0;
|
||||
xma->stat.nfreeops = 0;
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
@ -277,7 +286,7 @@ void hawk_xma_fini (hawk_xma_t* xma)
|
||||
{
|
||||
/* the head must point to the free chunk allocated in init().
|
||||
* let's deallocate it */
|
||||
if (xma->internal) HAWK_MMGR_FREE (xma->_mmgr, xma->start);
|
||||
if (xma->internal) HAWK_MMGR_FREE(xma->_mmgr, xma->start);
|
||||
xma->start = HAWK_NULL;
|
||||
xma->end = HAWK_NULL;
|
||||
}
|
||||
@ -390,6 +399,7 @@ static hawk_xma_fblk_t* alloc_from_freelist (hawk_xma_t* xma, hawk_oow_t xfi, ha
|
||||
xma->stat.nused++;
|
||||
xma->stat.alloc += cand->size;
|
||||
xma->stat.avail -= cand->size;
|
||||
if (xma->stat.alloc > xma->stat.alloc_hwmark) xma->stat.alloc_hwmark = xma->stat.alloc;
|
||||
#endif
|
||||
return cand;
|
||||
}
|
||||
@ -406,6 +416,9 @@ void* hawk_xma_alloc (hawk_xma_t* xma, hawk_oow_t size)
|
||||
|
||||
DBG_VERIFY (xma, "alloc start");
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nallocops++;
|
||||
#endif
|
||||
/* round up 'size' to the multiples of ALIGN */
|
||||
if (size < MINALLOCSIZE) size = MINALLOCSIZE;
|
||||
size = HAWK_ALIGN_POW2(size, ALIGN);
|
||||
@ -425,18 +438,25 @@ void* hawk_xma_alloc (hawk_xma_t* xma, hawk_oow_t size)
|
||||
detach_from_freelist (xma, cand);
|
||||
cand->free = 0;
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nfree--;
|
||||
xma->stat.nused++;
|
||||
xma->stat.alloc += cand->size;
|
||||
xma->stat.avail -= cand->size;
|
||||
#endif
|
||||
if (xma->stat.alloc > xma->stat.alloc_hwmark) xma->stat.alloc_hwmark = xma->stat.alloc;
|
||||
#endif
|
||||
}
|
||||
else if (xfi == XFIMAX(xma))
|
||||
{
|
||||
/* huge block */
|
||||
cand = alloc_from_freelist(xma, XFIMAX(xma), size);
|
||||
if (!cand) return HAWK_NULL;
|
||||
if (HAWK_UNLIKELY(!cand))
|
||||
{
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nallocbadops++;
|
||||
#endif
|
||||
return HAWK_NULL;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -465,10 +485,19 @@ void* hawk_xma_alloc (hawk_xma_t* xma, hawk_oow_t size)
|
||||
cand = alloc_from_freelist(xma, xfi, size);
|
||||
if (cand) break;
|
||||
}
|
||||
if (!cand) return HAWK_NULL;
|
||||
if (!cand)
|
||||
{
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nallocbadops++;
|
||||
#endif
|
||||
return HAWK_NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nallocgoodops++;
|
||||
#endif
|
||||
DBG_VERIFY (xma, "alloc end");
|
||||
return SYS_TO_USR(cand);
|
||||
}
|
||||
@ -522,10 +551,11 @@ static void* _realloc_merge (hawk_xma_t* xma, void* b, hawk_oow_t size)
|
||||
z = next_mblk(y);
|
||||
if ((hawk_uint8_t*)z < xma->end) z->prev_size = y->size;
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.alloc += req;
|
||||
xma->stat.avail -= req; /* req + MBLKHDRSIZE(tmp) - MBLKHDRSIZE(n) */
|
||||
#endif
|
||||
if (xma->stat.alloc > xma->stat.alloc_hwmark) xma->stat.alloc_hwmark = xma->stat.alloc;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -538,11 +568,12 @@ static void* _realloc_merge (hawk_xma_t* xma, void* b, hawk_oow_t size)
|
||||
z = next_mblk(blk);
|
||||
if ((hawk_uint8_t*)z < xma->end) z->prev_size = blk->size;
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nfree--;
|
||||
xma->stat.alloc += MBLKHDRSIZE + n->size;
|
||||
xma->stat.avail -= n->size;
|
||||
#endif
|
||||
if (xma->stat.alloc > xma->stat.alloc_hwmark) xma->stat.alloc_hwmark = xma->stat.alloc;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else if (size < blk->size)
|
||||
@ -577,10 +608,10 @@ static void* _realloc_merge (hawk_xma_t* xma, void* b, hawk_oow_t size)
|
||||
z = next_mblk(y); /* get adjacent block to the merged block */
|
||||
if ((hawk_uint8_t*)z < xma->end) z->prev_size = y->size;
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.alloc -= rem;
|
||||
xma->stat.avail += rem; /* rem - MBLKHDRSIZE(y) + MBLKHDRSIZE(n) */
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -598,11 +629,11 @@ static void* _realloc_merge (hawk_xma_t* xma, void* b, hawk_oow_t size)
|
||||
/*n = next_mblk(y);
|
||||
if ((hawk_uint8_t*)n < xma->end)*/ n->prev_size = y->size;
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nfree++;
|
||||
xma->stat.alloc -= rem;
|
||||
xma->stat.avail += y->size;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -614,7 +645,7 @@ static void* _realloc_merge (hawk_xma_t* xma, void* b, hawk_oow_t size)
|
||||
void* hawk_xma_calloc (hawk_xma_t* xma, hawk_oow_t size)
|
||||
{
|
||||
void* ptr = hawk_xma_alloc(xma, size);
|
||||
if (ptr) HAWK_MEMSET (ptr, 0, size);
|
||||
if (HAWK_LIKELY(ptr)) HAWK_MEMSET(ptr, 0, size);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
@ -630,9 +661,15 @@ void* hawk_xma_realloc (hawk_xma_t* xma, void* b, hawk_oow_t size)
|
||||
else
|
||||
{
|
||||
/* try reallocation by merging the adjacent continuous blocks */
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nreallocops++;
|
||||
#endif
|
||||
n = _realloc_merge (xma, b, size);
|
||||
if (!n)
|
||||
{
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nreallocbadops++;
|
||||
#endif
|
||||
/* reallocation by merging failed. fall back to the slow
|
||||
* allocation-copy-free scheme */
|
||||
n = hawk_xma_alloc(xma, size);
|
||||
@ -642,6 +679,12 @@ void* hawk_xma_realloc (hawk_xma_t* xma, void* b, hawk_oow_t size)
|
||||
hawk_xma_free (xma, b);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
xma->stat.nreallocgoodops++;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
return n;
|
||||
@ -661,6 +704,7 @@ void hawk_xma_free (hawk_xma_t* xma, void* b)
|
||||
/* update statistical variables */
|
||||
xma->stat.nused--;
|
||||
xma->stat.alloc -= org_blk_size;
|
||||
xma->stat.nfreeops++;
|
||||
#endif
|
||||
|
||||
x = prev_mblk(blk);
|
||||
@ -800,9 +844,10 @@ void hawk_xma_dump (hawk_xma_t* xma, hawk_xma_dumper_t dumper, void* ctx)
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
dumper (ctx, "== statistics ==\n");
|
||||
dumper (ctx, "total = %zu\n", xma->stat.total);
|
||||
dumper (ctx, "alloc = %zu\n", xma->stat.alloc);
|
||||
dumper (ctx, "avail = %zu\n", xma->stat.avail);
|
||||
dumper (ctx, "Total = %zu\n", xma->stat.total);
|
||||
dumper (ctx, "Alloc = %zu\n", xma->stat.alloc);
|
||||
dumper (ctx, "Avail = %zu\n", xma->stat.avail);
|
||||
dumper (ctx, "Alloc High Watermark = %zu\n", xma->stat.alloc_hwmark);
|
||||
#endif
|
||||
|
||||
dumper (ctx, "== blocks ==\n");
|
||||
@ -819,13 +864,20 @@ void hawk_xma_dump (hawk_xma_t* xma, hawk_xma_dumper_t dumper, void* ctx)
|
||||
#endif
|
||||
|
||||
dumper (ctx, "---------------------------------------\n");
|
||||
dumper (ctx, "Allocated blocks: %18zu bytes\n", asum);
|
||||
dumper (ctx, "Available blocks: %18zu bytes\n", fsum);
|
||||
dumper (ctx, "Allocated blocks : %18zu bytes\n", asum);
|
||||
dumper (ctx, "Available blocks : %18zu bytes\n", fsum);
|
||||
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
dumper (ctx, "Internal use : %18zu bytes\n", isum);
|
||||
dumper (ctx, "Total : %18zu bytes\n", (asum + fsum + isum));
|
||||
dumper (ctx, "Internal use : %18zu bytes\n", isum);
|
||||
dumper (ctx, "Total : %18zu bytes\n", (asum + fsum + isum));
|
||||
dumper (ctx, "Alloc operations : %18zu\n", xma->stat.nallocops);
|
||||
dumper (ctx, "Good alloc operations : %18zu\n", xma->stat.nallocgoodops);
|
||||
dumper (ctx, "Bad alloc operations : %18zu\n", xma->stat.nallocbadops);
|
||||
dumper (ctx, "Realloc operations : %18zu\n", xma->stat.nreallocops);
|
||||
dumper (ctx, "Good realloc operations: %18zu\n", xma->stat.nreallocgoodops);
|
||||
dumper (ctx, "Bad realloc operations : %18zu\n", xma->stat.nreallocbadops);
|
||||
dumper (ctx, "Free operations : %18zu\n", xma->stat.nfreeops);
|
||||
#endif
|
||||
|
||||
#if defined(HAWK_XMA_ENABLE_STAT)
|
||||
|
@ -13,12 +13,15 @@ int main ()
|
||||
{
|
||||
hawk_json_t* json;
|
||||
hawk_json_prim_t prim;
|
||||
/* const hawk_ooch_t* TODO */
|
||||
|
||||
no_plan();
|
||||
prim.instcb = on_json_element;
|
||||
|
||||
json = hawk_json_openstd(0, &prim, HAWK_NULL);
|
||||
OK (json != HAWK_NULL, "instantiation must be successful");
|
||||
|
||||
/* hawk_json_feed(json, "{\"hello\": \"world\"}", & TODO */
|
||||
|
||||
hawk_json_close(json);
|
||||
return exit_status();
|
||||
|
Loading…
x
Reference in New Issue
Block a user