/*******************************************************************************
* Entry point
******************************************************************************/
int main(int argc, char *argv[argc]) {
// We first parse command line switchs
opt_t opt = opt_defaults;
opt_parse(argc, argv, &opt);
// Next we prepare the model
rdr_t *rdr = rdr_new(opt.maxent);
rdr->min_count = opt.min_count;
mdl_t *mdl = mdl_new(rdr);
mdl->opt = &opt;
// And switch to requested mode
switch (opt.mode) {
case 0:
dotrain(mdl);
break;
case 1:
dolabel(mdl);
break;
case 2:
dodump(mdl);
break;
case 3:
doupdt(mdl);
break;
}
// And cleanup
mdl_free(mdl);
return EXIT_SUCCESS;
}
void dump_db_to_cdb()
{
char *z;
z = "0";
*z =+ flagchanged;
buffer_puts(buffer_2, z);
buffer_puts(buffer_2, " ");
z = "0";
*z =+ flagchildrunning;
buffer_puts(buffer_2, z);
buffer_putsflush(buffer_2, " checking if a dump is needed\n");
if(flagsighup)
{
flagsighup = 0;
buffer_putsflush(buffer_2, ARGV0 "SIGHUP recived, dumping withouth further asking\n");
}
if(flagchanged && !flagchildrunning)
{
flagchanged = 0;
flagchildrunning++;
buffer_putsflush(buffer_2, ARGV0 "yep, forking\n");
/* fork of a child to do this */
switch(fork())
{
case 0:
/* this is the child */
/* XXX close fifos? */
sig_ignore(sig_alarm);
sig_ignore(sig_hangup);
buffer_putsflush(buffer_2, ARGV0 "child started\n");
dodump();
buffer_putsflush(buffer_2, ARGV0 "child exiting\n");
_exit(0);
case -1:
strerr_warn2(ARGV0, "unable to fork: ", &strerr_sys);
break;
}
/* this is the parent */
flagdumpasap = 0;
buffer_putsflush(buffer_2, ARGV0 "parent\n");
}
}
Proto *luaY_parser(lua_State *L, ZIO *z, Mbuffer *buff, const char *name)
{
LexState X;
FuncState F;
X.buff=buff;
luaX_setinput(L,&X,z,luaS_new(L,name));
X.fs=&F;
X.fs->h=luaH_new(L,0,0);
sethvalue2s(L,L->top,X.fs->h);
incr_top(L);
if (dump)
{
printf("0\t<file>\t%s\n",name);
dodump(&X);
}
else dostrip(&X);
return luaF_newproto(L);
}
main(int argc, char **argv)
{
FILE *fp;
long start, count;
if (argc < 2)
{
puts("Usage: HEXDUMP file_name [start] [length]");
return (EXIT_FAILURE);
}
if (argc > 2)
{
start = strtol(*(argv + 2), NULL, 0);
}
else
{
start = 0L;
}
if (argc > 3)
{
count = strtol(*(argv + 3), NULL, 0);
}
else
{
count = -1L;
}
fp = fopen(*(argv + 1), "rb");
if (fp == NULL)
{
printf("unable to open file %s for input\n", *(argv + 1));
return (EXIT_FAILURE);
}
skipb(fp, start);
dodump(fp, start, count);
return (EXIT_SUCCESS);
}
/*
* expand_builtin - evaluate built-in macros.
*/
void
expand_builtin(const char *argv[], int argc, int td)
{
int c, n;
int ac;
static int sysval = 0;
#ifdef DEBUG
printf("argc = %d\n", argc);
for (n = 0; n < argc; n++)
printf("argv[%d] = %s\n", n, argv[n]);
fflush(stdout);
#endif
/*
* if argc == 3 and argv[2] is null, then we
* have macro-or-builtin() type call. We adjust
* argc to avoid further checking..
*/
/* we keep the initial value for those built-ins that differentiate
* between builtin() and builtin.
*/
ac = argc;
if (argc == 3 && !*(argv[2]) && !mimic_gnu)
argc--;
switch (td & TYPEMASK) {
case DEFITYPE:
if (argc > 2)
dodefine(argv[2], (argc > 3) ? argv[3] : null);
break;
case PUSDTYPE:
if (argc > 2)
dopushdef(argv[2], (argc > 3) ? argv[3] : null);
break;
case DUMPTYPE:
dodump(argv, argc);
break;
case TRACEONTYPE:
dotrace(argv, argc, 1);
break;
case TRACEOFFTYPE:
dotrace(argv, argc, 0);
break;
case EXPRTYPE:
/*
* doexpr - evaluate arithmetic
* expression
*/
{
int base = 10;
int maxdigits = 0;
const char *errstr;
if (argc > 3) {
base = strtonum(argv[3], 2, 36, &errstr);
if (errstr) {
m4errx(1, "expr: base %s invalid.", argv[3]);
}
}
if (argc > 4) {
maxdigits = strtonum(argv[4], 0, INT_MAX, &errstr);
if (errstr) {
m4errx(1, "expr: maxdigits %s invalid.", argv[4]);
}
}
if (argc > 2)
pbnumbase(expr(argv[2]), base, maxdigits);
break;
}
case IFELTYPE:
if (argc > 4)
doifelse(argv, argc);
break;
case IFDFTYPE:
/*
* doifdef - select one of two
* alternatives based on the existence of
* another definition
*/
if (argc > 3) {
if (lookup_macro_definition(argv[2]) != NULL)
pbstr(argv[3]);
else if (argc > 4)
pbstr(argv[4]);
}
break;
case LENGTYPE:
/*
* dolen - find the length of the
* argument
*/
pbnum((argc > 2) ? strlen(argv[2]) : 0);
break;
case INCRTYPE:
/*
* doincr - increment the value of the
* argument
*/
if (argc > 2)
pbnum(atoi(argv[2]) + 1);
break;
case DECRTYPE:
/*
* dodecr - decrement the value of the
* argument
*/
if (argc > 2)
pbnum(atoi(argv[2]) - 1);
break;
case SYSCTYPE:
/*
* dosys - execute system command
*/
if (argc > 2) {
fflush(stdout);
sysval = system(argv[2]);
}
break;
case SYSVTYPE:
/*
* dosysval - return value of the last
* system call.
*
*/
pbnum(sysval);
break;
case ESYSCMDTYPE:
if (argc > 2)
doesyscmd(argv[2]);
break;
case INCLTYPE:
if (argc > 2)
if (!doincl(argv[2])) {
if (mimic_gnu) {
warn("%s at line %lu: include(%s)",
CURRENT_NAME, CURRENT_LINE, argv[2]);
exit_code = 1;
} else
err(1, "%s at line %lu: include(%s)",
CURRENT_NAME, CURRENT_LINE, argv[2]);
}
break;
case SINCTYPE:
if (argc > 2)
(void) doincl(argv[2]);
break;
#ifdef EXTENDED
case PASTTYPE:
if (argc > 2)
if (!dopaste(argv[2]))
err(1, "%s at line %lu: paste(%s)",
CURRENT_NAME, CURRENT_LINE, argv[2]);
break;
case SPASTYPE:
if (argc > 2)
(void) dopaste(argv[2]);
break;
case FORMATTYPE:
doformat(argv, argc);
break;
#endif
case CHNQTYPE:
dochq(argv, ac);
break;
case CHNCTYPE:
dochc(argv, argc);
break;
case SUBSTYPE:
/*
* dosub - select substring
*
*/
if (argc > 3)
dosub(argv, argc);
break;
case SHIFTYPE:
/*
* doshift - push back all arguments
* except the first one (i.e. skip
* argv[2])
*/
if (argc > 3) {
for (n = argc - 1; n > 3; n--) {
pbstr(rquote);
pbstr(argv[n]);
pbstr(lquote);
pushback(COMMA);
}
pbstr(rquote);
pbstr(argv[3]);
pbstr(lquote);
}
break;
case DIVRTYPE:
if (argc > 2 && (n = atoi(argv[2])) != 0)
dodiv(n);
else {
active = stdout;
oindex = 0;
}
break;
case UNDVTYPE:
doundiv(argv, argc);
break;
case DIVNTYPE:
/*
* dodivnum - return the number of
* current output diversion
*/
pbnum(oindex);
break;
case UNDFTYPE:
/*
* doundefine - undefine a previously
* defined macro(s) or m4 keyword(s).
*/
if (argc > 2)
for (n = 2; n < argc; n++)
macro_undefine(argv[n]);
break;
case POPDTYPE:
/*
* dopopdef - remove the topmost
* definitions of macro(s) or m4
* keyword(s).
*/
if (argc > 2)
for (n = 2; n < argc; n++)
macro_popdef(argv[n]);
break;
case MKTMTYPE:
/*
* dotemp - create a temporary file
*/
if (argc > 2) {
int fd;
char *temp;
temp = xstrdup(argv[2]);
fd = mkstemp(temp);
if (fd == -1)
err(1,
"%s at line %lu: couldn't make temp file %s",
CURRENT_NAME, CURRENT_LINE, argv[2]);
close(fd);
pbstr(temp);
free(temp);
}
break;
case TRNLTYPE:
/*
* dotranslit - replace all characters in
* the source string that appears in the
* "from" string with the corresponding
* characters in the "to" string.
*/
if (argc > 3) {
char *temp;
temp = xalloc(strlen(argv[2])+1, NULL);
if (argc > 4)
map(temp, argv[2], argv[3], argv[4]);
else
map(temp, argv[2], argv[3], null);
pbstr(temp);
free(temp);
} else if (argc > 2)
pbstr(argv[2]);
break;
case INDXTYPE:
/*
* doindex - find the index of the second
* argument string in the first argument
* string. -1 if not present.
*/
pbnum((argc > 3) ? indx(argv[2], argv[3]) : -1);
break;
case ERRPTYPE:
/*
* doerrp - print the arguments to stderr
* file
*/
if (argc > 2) {
for (n = 2; n < argc; n++)
fprintf(stderr, "%s ", argv[n]);
fprintf(stderr, "\n");
}
break;
case DNLNTYPE:
/*
* dodnl - eat-up-to and including
* newline
*/
while ((c = gpbc()) != '\n' && c != EOF)
;
break;
case M4WRTYPE:
/*
* dom4wrap - set up for
* wrap-up/wind-down activity
*/
if (argc > 2)
dom4wrap(argv[2]);
break;
case EXITTYPE:
/*
* doexit - immediate exit from m4.
*/
killdiv();
exit((argc > 2) ? atoi(argv[2]) : 0);
break;
case DEFNTYPE:
if (argc > 2)
for (n = 2; n < argc; n++)
dodefn(argv[n]);
break;
case INDIRTYPE: /* Indirect call */
if (argc > 2)
doindir(argv, argc);
break;
case BUILTINTYPE: /* Builtins only */
if (argc > 2)
dobuiltin(argv, argc);
break;
case PATSTYPE:
if (argc > 2)
dopatsubst(argv, argc);
break;
case REGEXPTYPE:
if (argc > 2)
doregexp(argv, argc);
break;
case LINETYPE:
doprintlineno(infile+ilevel);
break;
case FILENAMETYPE:
doprintfilename(infile+ilevel);
break;
case SELFTYPE:
pbstr(rquote);
pbstr(argv[1]);
pbstr(lquote);
break;
default:
m4errx(1, "eval: major botch.");
break;
}
}
static int
dofile(const char* file)
{
struct stat st;
size_t size = 0;
uchar* data = 0;
int fd = -1;
uchar* pack_data = 0;
size_t pack_len = 0;
char* namebuf = 0;
int ret = -1;
do
{
if (stat(file, &st) == -1)
{
fprintf(stderr, "%s: stat: %s\n", file, strerror(errno));
break;
}
size = st.st_size;
if ((data = (uchar*)malloc(size)) == 0)
{
fprintf(stderr, "%s: malloc %u: %s\n", file, (uint)size, strerror(errno));
break;
}
if ((fd = open(file, O_RDONLY)) == -1)
{
fprintf(stderr, "%s: open: %s\n", file, strerror(errno));
break;
}
ssize_t size2;
if ((size2 = read(fd, data, (unsigned)size)) == -1)
{
fprintf(stderr, "%s: read: %s\n", file, strerror(errno));
break;
}
if ((size_t)size2 != size)
{
fprintf(stderr, "%s: short read: %u != %u\n", file, (uint)size2, (uint)size);
break;
}
int error;
if ((error = packfrm(data, size, &pack_data, &pack_len)) != 0)
{
fprintf(stderr, "%s: packfrm: error %d\n", file, error);
break;
}
namebuf = strdup(file);
if (namebuf == 0)
{
fprintf(stderr, "%s: strdup: %s\n", file, strerror(errno));
break;
}
char* name = namebuf;
if (strchr(name, '/') != 0)
name = strrchr(name, '/') + 1;
char* dot;
if ((dot = strchr(name, '.')) != 0)
*dot = 0;
printf("\n/*\n");
printf(" name: %s\n", name);
printf(" orig: %u\n", (uint)size);
printf(" pack: %u\n", (uint)pack_len);
printf("*/\n\n");
dodump(name, pack_data, (uint)pack_len);
ret = 0;
}
while (0);
if (namebuf != 0)
free(namebuf);
if (pack_data != 0)
my_free(pack_data); // Free data returned from packfrm with my_free
if (fd != -1)
(void)close(fd);
if (data != 0)
free(data);
return ret;
}
