/*
* Scan all leading options
*/
int leadOptions(char **Xline, optScanner fct, void * arg)
{ int ec = E_None;
char *p, *q, *line;
assert(Xline && *Xline);
p = *Xline;
while(*(line = skipdm(p))) {
q = unquote(line, p = skipwd(line));
if(!q) {
error_out_of_memory();
return E_NoMem;
}
if(!isoption(q)
|| ((ec = scanOption(fct, arg, q)) != E_None
&& ec != E_Ignore)) {
free(q);
break;
}
free(q);
}
*Xline = line;
return ec;
}
static void
outline(Fmt_t* fp)
{
register char* cp = fp->outbuf;
int n = 0;
int c;
int d;
if (!fp->outp)
return;
while (fp->outp[-1] == ' ')
fp->outp--;
*fp->outp = 0;
while (*cp++ == ' ')
n++;
if (n >= TABSZ)
{
n /= TABSZ;
cp = &fp->outbuf[TABSZ*n];
while (n--)
*--cp = '\t';
}
else
cp = fp->outbuf;
fp->nwords = 0;
if (!isoption(fp, 'o'))
sfputr(fp->out, cp, '\n');
else if (*cp)
{
n = fp->indent;
if (*cp != '[')
{
if (*cp == ' ')
cp++;
n += INDENT;
}
while (n--)
sfputc(fp->out, ' ');
if (fp->quote)
{
if ((d = (fp->outp - cp)) <= 0)
c = 0;
else if ((c = fp->outp[-1]) == 'n' && d > 1 && fp->outp[-2] == '\\')
c = '}';
sfprintf(fp->out, "\"%s%s\"\n", cp, c == ']' || c == '{' || c == '}' ? "" : " ");
}
else
sfputr(fp->out, cp, '\n');
if (fp->nextdent)
{
fp->indent += fp->nextdent;
fp->endbuf -= fp->nextdent;
fp->nextdent = 0;
}
}
fp->outp = 0;
}
static int deal_options(char **options, int listsize, char **list)
{
int i;
i = 1;
while (i < listsize && tru_arg(list[i]) && isoption(list[i]))
ft_strjoinfree(options, list[i++] + 1);
check_options(*options);
if (i < listsize && ft_strcmp(list[i], "--") == 0)
i++;
return (i);
}
/*
* Scan an option and update its value within the option array
* Return: 0 on success
*/
int scanOption(optScanner fct, void * const ag, char *rest)
{
char *line, *arg, *optend;
int ch, bool;
assert(rest);
if(!isoption(line = rest)) return -1;
/* check for leading boolean character */
switch(*++line) {
case '\0': return E_None; /* empty option */
case '-': bool = -1; ++line; break;
case '+': bool = 1; ++line; break;
default: bool = 0; break;
}
if(!isprint(ch = toupper(*line)) || strchr("-+=:", ch)) {
error_illformed_option(rest);
return E_Useage;
}
if((optend = strpbrk(line, "=:")) != NULL) { /* option has argument */
arg = optend + 1;
} else {
arg = NULL;
optend = strchr(line, '\0');
}
/* check for trailing boolean character */
switch(optend[-1]) {
case '-': bool = -1;
--optend;
break;
case '+': bool = 1;
--optend;
break;
}
*optend = '\0';
if(!fct) {
error_invalid_lswitch(line);
return E_Useage;
}
return fct(line, line[1]? 0: ch, bool, arg, ag);
}
/*
* Find the next delimiter/non-delimiter within p
* Honor quotes and leading option characters
*/
static char *find(char *p, int delim)
{ int ch, quote;
int isopt;
assert(p);
#define isdelim(ch) (isopt? isoptdelim(ch): isargdelim(ch))
if((isopt = isoption(p)) != 0 && delim) {
/* Assume the following example:
p == "arg/opt"
first find("arg/opt", 1) == find next delimiter
returns pointer to "/opt"
Now the process would call skip delimiters to reach the
next argument --> find("/opt", 0) == find next non-delimiter
will return "/opt", because '/' is delimiter only when
searching for delimiters.
Now the process would call skip non-delimiters to reach the
end of the arg --> find("/opt", 1) == find next delimiter
This time the leading optch's are part of the argument.
===> This is performed in this branch.
If the string would be "/opt1/opt2", the call of
find("/opt1/opt2", 1) == find next delimiter must stop
at the second '/'.
*/
while((ch = *++p) != 0 && isoptch(ch));
}
quote = 0;
while((ch = *p++) != '\0' && (quote
|| (delim && !(isdelim(ch) || isoptch(ch)))
|| (!delim && isdelim(ch))))
if(quote == ch)
quote = 0;
else if(strchr(QUOTE_STR, ch))
quote = ch;
return p - 1;
#undef isdelim
}
/*
* Parse global options
*/
static int parseOptions(optScanner fct, void * const arg, char **argv, int *argc, int *optcnt)
{ int ec = E_None;
char **argp, *a;
assert(argv);
assert(argc);
assert(optcnt);
*optcnt = 0;
argp = argv;
while((*argp++ = a = *argv++) != NULL)
if(isoption(a))
if((ec = scanOption(fct, arg, a)) == E_None) {
free(*--argp); /* ignore (overwrite) it */
++*optcnt;
} else if(ec != E_Ignore) { /* the entry caused an error */
/* Copy the remaining entries */
while((*argp++ = *argv++) != NULL);
break;
}
*argc -= *optcnt;
return ec; /* everything done */
}
int main(int argc, char* argv[]) {
jq_state *jq = NULL;
int ret = 0;
int compiled = 0;
char *t = NULL;
if (argc) progname = argv[0];
if (argc > 1 && !strcmp(argv[1], "--run-tests")) {
return jq_testsuite(argc, argv);
}
jq = jq_init();
if (jq == NULL) {
perror("malloc");
ret = 2;
goto out;
}
const char* program = 0;
input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
ninput_files = 0;
int further_args_are_files = 0;
int jq_flags = 0;
size_t short_opts = 0;
jv program_arguments = jv_array();
jv lib_search_paths = jv_array();
for (int i=1; i<argc; i++, short_opts = 0) {
if (further_args_are_files) {
input_filenames[ninput_files++] = argv[i];
} else if (!strcmp(argv[i], "--")) {
if (!program) usage(2);
further_args_are_files = 1;
} else if (!isoptish(argv[i])) {
if (program) {
input_filenames[ninput_files++] = argv[i];
} else {
program = argv[i];
}
} else {
if (argv[i][1] == 'L') {
if (argv[i][2] != 0) { // -Lname (faster check than strlen)
lib_search_paths = jv_array_append(lib_search_paths, jv_string(argv[i]+2));
} else if (i >= argc - 1) {
fprintf(stderr, "-L takes a parameter: (e.g. -L /search/path or -L/search/path)\n");
die();
} else {
lib_search_paths = jv_array_append(lib_search_paths, jv_string(argv[i+1]));
i++;
}
continue;
}
if (isoption(argv[i], 's', "slurp", &short_opts)) {
options |= SLURP;
if (!short_opts) continue;
}
if (isoption(argv[i], 'r', "raw-output", &short_opts)) {
options |= RAW_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'c', "compact-output", &short_opts)) {
options |= COMPACT_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'C', "color-output", &short_opts)) {
options |= COLOUR_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'M', "monochrome-output", &short_opts)) {
options |= NO_COLOUR_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'a', "ascii-output", &short_opts)) {
options |= ASCII_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "unbuffered", &short_opts)) {
options |= UNBUFFERED_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'S', "sort-keys", &short_opts)) {
options |= SORTED_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'R', "raw-input", &short_opts)) {
options |= RAW_INPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'n', "null-input", &short_opts)) {
options |= PROVIDE_NULL;
if (!short_opts) continue;
}
if (isoption(argv[i], 'f', "from-file", &short_opts)) {
options |= FROM_FILE;
if (!short_opts) continue;
}
if (isoption(argv[i], 'j', "join-output", &short_opts)) {
options |= RAW_OUTPUT | RAW_NO_LF;
if (!short_opts) continue;
}
if (isoption(argv[i], 'i', "in-place", &short_opts)) {
options |= IN_PLACE;
if (!short_opts) continue;
}
if (isoption(argv[i], 'e', "exit-status", &short_opts)) {
options |= EXIT_STATUS;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "arg", &short_opts)) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --arg takes two parameters (e.g. -a varname value)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
arg = jv_object_set(arg, jv_string("value"), jv_string(argv[i+2]));
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "argfile", &short_opts)) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --argfile takes two parameters (e.g. -a varname filename)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
jv data = jv_load_file(argv[i+2], 0);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: Bad JSON in --argfile %s %s: %s\n", progname,
argv[i+1], argv[i+2], jv_string_value(data));
jv_free(data);
ret = 2;
goto out;
}
if (jv_get_kind(data) == JV_KIND_ARRAY && jv_array_length(jv_copy(data)) == 1)
data = jv_array_get(data, 0);
arg = jv_object_set(arg, jv_string("value"), data);
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "debug-dump-disasm", &short_opts)) {
options |= DUMP_DISASM;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "debug-trace", &short_opts)) {
jq_flags |= JQ_DEBUG_TRACE;
if (!short_opts) continue;
}
if (isoption(argv[i], 'h', "help", &short_opts)) {
usage(0);
if (!short_opts) continue;
}
if (isoption(argv[i], 'V', "version", &short_opts)) {
printf("jq-%s\n", JQ_VERSION);
ret = 0;
goto out;
}
// check for unknown options... if this argument was a short option
if (strlen(argv[i]) != short_opts + 1) {
fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
die();
}
}
}
char *penv = getenv("JQ_LIBRARY_PATH");
if (penv) {
#ifdef WIN32
#define PATH_ENV_SEPARATOR ";"
#else
#define PATH_ENV_SEPARATOR ":"
#endif
lib_search_paths = jv_array_concat(lib_search_paths,jv_string_split(jv_string(penv),jv_string(PATH_ENV_SEPARATOR)));
#undef PATH_ENV_SEPARATOR
}
jq_set_lib_dirs(jq,lib_search_paths);
char *origin = strdup(argv[0]);
if (origin == NULL) {
fprintf(stderr, "Error: out of memory\n");
exit(1);
}
jq_set_lib_origin(jq,jv_string(dirname(origin)));
free(origin);
#if (!defined(WIN32) && defined(HAVE_ISATTY)) || defined(HAVE__ISATTY)
#if defined(HAVE__ISATTY) && defined(isatty)
#undef isatty
#define isatty _isatty
#endif
if (!program && isatty(STDOUT_FILENO) && !isatty(STDIN_FILENO))
program = ".";
#endif
if (!program) usage(2);
if ((options & IN_PLACE)) {
if (ninput_files == 0) usage(2);
if (strcmp(input_filenames[0], "-") == 0) usage(2);
size_t tlen = strlen(input_filenames[0]) + 7;
t = jv_mem_alloc(tlen);
int n = snprintf(t, tlen,"%sXXXXXX", input_filenames[0]);
assert(n > 0 && (size_t)n < tlen);
if (mkstemp(t) == -1) {
fprintf(stderr, "Error: %s creating temporary file", strerror(errno));
exit(3);
}
if (freopen(t, "w", stdout) == NULL) {
fprintf(stderr, "Error: %s redirecting stdout to temporary file", strerror(errno));
exit(3);
}
}
if (ninput_files == 0) current_input = stdin;
if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", progname);
die();
}
if (options & FROM_FILE) {
jv data = jv_load_file(program, 1);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: %s\n", progname, jv_string_value(data));
jv_free(data);
ret = 2;
goto out;
}
compiled = jq_compile_args(jq, jv_string_value(data), program_arguments);
jv_free(data);
} else {
compiled = jq_compile_args(jq, program, program_arguments);
}
if (!compiled){
ret = 3;
goto out;
}
if (options & DUMP_DISASM) {
jq_dump_disassembly(jq, 0);
printf("\n");
}
if (options & PROVIDE_NULL) {
ret = process(jq, jv_null(), jq_flags);
} else {
jv slurped;
if (options & SLURP) {
if (options & RAW_INPUT) {
slurped = jv_string("");
} else {
slurped = jv_array();
}
}
struct jv_parser* parser = jv_parser_new(0);
char buf[4096];
while (read_more(buf, sizeof(buf))) {
if (options & RAW_INPUT) {
int len = strlen(buf);
if (len > 0) {
if (options & SLURP) {
slurped = jv_string_concat(slurped, jv_string(buf));
} else {
if (buf[len-1] == '\n') buf[len-1] = 0;
ret = process(jq, jv_string(buf), jq_flags);
}
}
} else {
jv_parser_set_buf(parser, buf, strlen(buf), !feof(stdin));
jv value;
while (jv_is_valid((value = jv_parser_next(parser)))) {
if (options & SLURP) {
slurped = jv_array_append(slurped, value);
} else {
ret = process(jq, value, jq_flags);
}
}
if (jv_invalid_has_msg(jv_copy(value))) {
jv msg = jv_invalid_get_msg(value);
fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
jv_free(msg);
ret = 4;
break;
} else {
jv_free(value);
}
}
}
jv_parser_free(parser);
if (ret != 0)
goto out;
if (options & SLURP) {
ret = process(jq, slurped, jq_flags);
}
}
if ((options & IN_PLACE)) {
#ifdef WIN32
(void) freopen("NUL", "w+", stdout);
#else
(void) freopen("/dev/null", "w+", stdout);
#endif
if (rename(t, input_filenames[0]) == -1) {
fprintf(stderr, "Error: %s renaming temporary file", strerror(errno));
exit(3);
}
jv_mem_free(t);
}
out:
jv_mem_free(input_filenames);
jq_teardown(&jq);
if (ret >= 10 && (options & EXIT_STATUS))
return ret - 10;
if (ret >= 10)
return 0;
return ret;
}
int cmd_copy(char *rest)
{ char **argv, *p;
int argc, opts, argi;
int freeDestFile = 0;
struct CopySource *h;
/* Initialize options */
optA = optB = optV = optY = 0;
/* read the parameters from env */
if ((argv = scanCmdline(getEnv("COPYCMD"), opt_copy, 0, &argc, &opts))
== 0)
return 1;
freep(argv); /* ignore any parameter from env var */
if((argv = scanCmdline(rest, opt_copy, 0, &argc, &opts)) == 0)
return 1;
/* scan the trailing '/a' and '/b' options */
while(argc > 0 && isoption(argv[argc - 1])) {
p = argv[--argc]; /* argv[] must not be changed */
if(leadOptions(&p, opt_copy1, 0) != E_None) {
freep(argv);
return 1;
}
}
initContext();
/* Now parse the remaining arguments into the copy file
structure */
for(argi = 0; argi < argc; ++argi)
if(isoption(p = argv[argi])) { /* infix /a or /b */
if(leadOptions(&p, opt_copy1, 0) != E_None) {
killContext();
freep(argv);
return 1;
}
/* Change the flags of the previous argument */
if(lastApp)
lastApp->flags = cpyFlags();
} else { /* real argument */
if(*p == '+') { /* to previous argument */
appendToFile = 1;
while(*++p == '+');
if(!*p)
continue;
}
if(!addSource(p)) {
killContext();
freep(argv);
return 1;
}
}
if(appendToFile) {
error_trailing_plus();
killContext();
freep(argv);
return 1;
}
if(!last) { /* Nothing to do */
error_nothing_to_do();
killContext();
freep(argv);
return 1;
}
assert(head);
/* Now test if a destination was specified */
if(head != last && !last->app) { /* Yeah */
destFile = dfnexpand(last->fnam, 0);
if(!destFile) {
error_out_of_memory();
goto errRet;
}
freeDestFile = 1;
h = head; /* remove it from argument list */
while(h->nxt != last) {
assert(h->nxt);
h = h->nxt;
}
free(last);
(last = h)->nxt = 0;
p = strchr(destFile, '\0') - 1;
if(*p == '\\' || *p == '/') /* must be a directory */
destIsDir = 1;
else destIsDir = dfnstat(destFile) & DFN_DIRECTORY;
} else { /* Nay */
destFile = ".";
destIsDir = 1;
}
/* Now copy the files */
h = head;
while(copyFiles(h) && (h = h->nxt) != 0);
if(freeDestFile)
free(destFile);
errRet:
killContext();
freep(argv);
return 0;
}
static int
dofmt(Fmt_t* fp)
{
register int c;
int b;
int x;
int splice;
char* cp;
char* dp;
char* ep;
char* lp;
char* tp;
char buf[8192];
cp = 0;
while (cp || (cp = sfgetr(fp->in, '\n', 0)) && !(splice = 0) && (lp = cp + sfvalue(fp->in) - 1) || (cp = sfgetr(fp->in, '\n', SF_LASTR)) && (splice = 1) && (lp = cp + sfvalue(fp->in)))
{
if (isoption(fp, 'o'))
{
if (!isoption(fp, 'i'))
{
setoption(fp, 'i');
b = 0;
while (cp < lp)
{
if (*cp == ' ')
b += 1;
else if (*cp == '\t')
b += INDENT;
else
break;
cp++;
}
fp->indent = roundof(b, INDENT);
}
else
while (cp < lp && (*cp == ' ' || *cp == '\t'))
cp++;
if (!isoption(fp, 'q') && cp < lp)
{
setoption(fp, 'q');
if (*cp == '"')
{
ep = lp;
while (--ep > cp)
if (*ep == '"')
{
fp->quote = 1;
break;
}
else if (*ep != ' ' && *ep != '\t')
break;
}
}
}
again:
dp = buf;
ep = 0;
for (b = 1;; b = 0)
{
if (cp >= lp)
{
cp = 0;
break;
}
c = *cp++;
if (isoption(fp, 'o'))
{
if (c == '\\')
{
x = 0;
c = ' ';
cp--;
while (cp < lp)
{
if (*cp == '\\')
{
cp++;
if ((lp - cp) < 1)
{
c = '\\';
break;
}
if (*cp == 'n')
{
cp++;
c = '\n';
if ((lp - cp) > 2)
{
if (*cp == ']' || *cp == '@' && *(cp + 1) == '(')
{
*dp++ = '\\';
*dp++ = 'n';
c = *cp++;
break;
}
if (*cp == '\\' && *(cp + 1) == 'n')
{
cp += 2;
*dp++ = '\n';
break;
}
}
}
else if (*cp == 't' || *cp == ' ')
{
cp++;
x = 1;
c = ' ';
}
else
{
if (x && dp != buf && *(dp - 1) != ' ')
*dp++ = ' ';
*dp++ = '\\';
c = *cp++;
break;
}
}
else if (*cp == ' ' || *cp == '\t')
{
cp++;
c = ' ';
x = 1;
}
else
{
if (x && c != '\n' && dp != buf && *(dp - 1) != ' ')
*dp++ = ' ';
break;
}
}
if (c == '\n')
{
c = 0;
goto flush;
}
if (c == ' ' && (dp == buf || *(dp - 1) == ' '))
continue;
}
else if (c == '"')
{
if (b || cp >= lp)
{
if (fp->quote)
continue;
fp->section = 0;
}
}
else if (c == '\a')
{
*dp++ = '\\';
c = 'a';
}
else if (c == '\b')
{
*dp++ = '\\';
c = 'b';
}
else if (c == '\f')
{
*dp++ = '\\';
c = 'f';
}
else if (c == '\v')
{
*dp++ = '\\';
c = 'v';
}
else if (c == ']' && (cp >= lp || *cp != ':' && *cp != '#' && *cp != '!'))
{
if (cp < lp && *cp == ']')
{
cp++;
*dp++ = c;
}
else
{
fp->section = 1;
fp->retain = 0;
flush:
*dp++ = c;
*dp = 0;
split(fp, buf, 0);
outline(fp);
goto again;
}
}
else if (fp->section)
{
if (c == '[')
{
if (b)
fp->retain = 1;
else
{
cp--;
c = 0;
goto flush;
}
fp->section = 0;
}
else if (c == '{')
{
x = 1;
for (tp = cp; tp < lp; tp++)
{
if (*tp == '[' || *tp == '\n')
break;
if (*tp == ' ' || *tp == '\t' || *tp == '"')
continue;
if (*tp == '\\' && (lp - tp) > 1)
{
if (*++tp == 'n')
break;
if (*tp == 't' || *tp == '\n')
continue;
}
x = 0;
break;
}
if (x)
{
if (fp->endbuf > (fp->outbuf + fp->indent + 2*INDENT))
fp->nextdent = 2*INDENT;
goto flush;
}
else
fp->section = 0;
}
else if (c == '}')
{
if (fp->indent && (b || *(cp - 2) != 'f'))
{
if (b)
{
fp->indent -= 2*INDENT;
fp->endbuf += 2*INDENT;
}
else
{
cp--;
c = 0;
}
goto flush;
}
else
fp->section = 0;
}
else if (c == ' ' || c == '\t')
continue;
else
fp->section = 0;
}
else if (c == '?' && (cp >= lp || *cp != '?'))
{
if (fp->retain)
{
cp--;
while (cp < lp && *cp != ' ' && *cp != '\t' && *cp != ']' && dp < &buf[sizeof(buf)-3])
*dp++ = *cp++;
if (cp < lp && (*cp == ' ' || *cp == '\t'))
*dp++ = *cp++;
*dp = 0;
split(fp, buf, 0);
dp = buf;
ep = 0;
fp->retain = 0;
if (fp->outp >= fp->endbuf)
outline(fp);
continue;
}
}
else if (c == ' ' || c == '\t')
for (c = ' '; *cp == ' ' || *cp == '\t'; cp++);
}
else if (c == '\b')
{
if (dp > buf)
{
dp--;
if (ep)
ep--;
}
continue;
}
else if (c == '\t')
{
/*
* expand tabs
*/
if (!ep)
ep = dp;
c = isoption(fp, 'o') ? 1 : TABSZ - (dp - buf) % TABSZ;
if (dp >= &buf[sizeof(buf) - c - 3])
{
cp--;
break;
}
while (c-- > 0)
*dp++ = ' ';
continue;
}
else if (!isprint(c))
continue;
if (dp >= &buf[sizeof(buf) - 3])
{
tp = dp;
while (--tp > buf)
if (isspace(*tp))
{
cp -= dp - tp;
dp = tp;
break;
}
ep = 0;
break;
}
if (c != ' ')
ep = 0;
else if (!ep)
ep = dp;
*dp++ = c;
}
if (ep)
*ep = 0;
else
*dp = 0;
split(fp, buf, splice);
}
return 0;
}
static int
parseCommandLineOptions(int argc0, char **argv, int *compile)
{ GET_LD
int argc = argc0;
for( ; argc > 0 && (argv[0][0] == '-' || argv[0][0] == '+'); argc--, argv++ )
{ char *s = &argv[0][1];
if ( streq(s, "-" ) ) /* swipl <plargs> -- <app-args> */
{ break;
}
if ( streq(s, "tty") ) /* +/-tty */
{ if ( s[-1] == '+' )
setPrologFlagMask(PLFLAG_TTY_CONTROL);
else
clearPrologFlagMask(PLFLAG_TTY_CONTROL);
continue;
} else if ( isoption(s, "nosignals") )
{ clearPrologFlagMask(PLFLAG_SIGNALS);
continue;
} else if ( isoption(s, "nodebug") )
{ clearPrologFlagMask(PLFLAG_DEBUGINFO);
continue;
} else if ( streq(s, "-quiet") )
{ GD->options.silent = TRUE;
continue;
}
if ( *s == '-' )
{ const char *optval;
s++;
if ( (optval=is_longopt(s, "pldoc")) )
{ GD->options.pldoc_server = store_string(optval);
} else if ( is_longopt(s, "home") )
{ /* already handled */
#ifdef __WINDOWS__
} else if ( (optval=is_longopt(s, "win_app")) )
{ GD->options.win_app = TRUE;
#endif
} else if ( (optval=is_longopt(s, "traditional")) )
{ setTraditional();
}
continue; /* don't handle --long=value */
}
while(*s)
{ switch(*s)
{ case 'd': if (argc > 1)
{ prolog_debug_from_string(argv[1], TRUE);
argc--, argv++;
} else
return -1;
break;
case 'p': optionList(&GD->options.search_paths);
break;
case 'O': GD->cmdline.optimise = TRUE; /* see initFeatures() */
break;
case 'x':
case 'o': optionString(GD->options.compileOut);
break;
case 'f': optionString(GD->options.initFile);
break;
case 'F': optionString(GD->options.systemInitFile);
break;
case 'l':
case 's': optionList(&GD->options.scriptFiles);
break;
case 'g': optionString(GD->options.goal);
break;
case 't': optionString(GD->options.topLevel);
break;
case 'c': *compile = TRUE;
break;
case 'b': GD->bootsession = TRUE;
break;
case 'q': GD->options.silent = TRUE;
break;
case 'L':
case 'G':
case 'T':
case 'A':
case 'H':
{ uintptr_t size = memarea_limit(&s[1]);
if ( size == MEMAREA_INVALID_SIZE )
return -1;
switch(*s)
{ case 'L': GD->options.localSize = size; goto next;
case 'G': GD->options.globalSize = size; goto next;
case 'T': GD->options.trailSize = size; goto next;
case 'H':
case 'A':
Sdprintf("% Warning: -%csize is no longer supported\n", *s);
goto next;
}
}
}
s++;
}
next:;
}
return argc0-argc;
}
int main(int argc, char* argv[]) {
if (argc) progname = argv[0];
const char* program = 0;
for (int i=1; i<argc; i++) {
if (!isoptish(argv[i])) {
if (program) usage();
program = argv[i];
} else if (isoption(argv[i], 's', "slurp")) {
options |= SLURP;
} else if (isoption(argv[i], 'r', "raw-output")) {
options |= RAW_OUTPUT;
} else if (isoption(argv[i], 'c', "compact-output")) {
options |= COMPACT_OUTPUT;
} else if (isoption(argv[i], 'a', "ascii-output")) {
options |= ASCII_OUTPUT;
} else if (isoption(argv[i], 'R', "raw-input")) {
options |= RAW_INPUT;
} else if (isoption(argv[i], 'n', "null-input")) {
options |= PROVIDE_NULL;
} else if (isoption(argv[i], 'h', "help")) {
usage();
} else {
fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
die();
}
}
if (!program) usage();
if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", program);
die();
}
bc = jq_compile(program);
if (!bc) return 1;
#if JQ_DEBUG
dump_disassembly(0, bc);
printf("\n");
#endif
if (options & PROVIDE_NULL) {
process(jv_null());
} else {
jv slurped;
if (options & SLURP) slurped = jv_invalid();
int first = 1;
struct jv_parser parser;
jv_parser_init(&parser);
while (!feof(stdin)) {
char buf[4096];
if (!fgets(buf, sizeof(buf), stdin)) buf[0] = 0;
if (options & RAW_INPUT) {
int len = strlen(buf);
if (len > 0) {
if (options & SLURP) {
if (first) slurped = jv_string(buf);
else slurped = jv_string_concat(slurped, jv_string(buf));
} else {
if (buf[len-1] == '\n') buf[len-1] = 0;
process(jv_string(buf));
}
}
} else {
jv_parser_set_buf(&parser, buf, strlen(buf), !feof(stdin));
jv value;
while (jv_is_valid((value = jv_parser_next(&parser)))) {
if (options & SLURP) {
if (first) slurped = jv_array();
slurped = jv_array_append(slurped, value);
} else {
process(value);
}
}
if (jv_invalid_has_msg(jv_copy(value))) {
jv msg = jv_invalid_get_msg(value);
fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
jv_free(msg);
break;
} else {
jv_free(value);
}
}
first = 0;
}
jv_parser_free(&parser);
if (options & SLURP) {
if (jv_is_valid(slurped)) {
process(slurped);
} else {
jv_free(slurped);
}
}
}
bytecode_free(bc);
return 0;
}
int initialize(void)
{
//int rc;
int comPath; /* path to COMMAND.COM (for COMSPEC/reload) */
char *newTTY; /* what to change TTY to */
int showinfo; /* show initial info only if no command line options */
int ec; /* error code */
unsigned offs; /* offset into environment segment */
int cmdlen; /* length of command line */
char *cmdline; /* command line duplicated into heap */
char *p, *h, *q;
#ifdef FEATURE_CALL_LOGGING
#ifndef INCLUDE_CMD_FDDEBUG
FILE *f;
#endif
#endif
/* Set up the host environment of COMMAND.COM */
/* Install the dummy handlers for Criter and ^Break */
initCBreak();
setvect(0x23, cbreak_handler);
setvect(0x24, dummy_criter_handler);
/* DOS shells patch the PPID to the own PID, how stupid this is, however,
because then DOS won't terminate them, e.g. when a Critical Error
occurs that is not detected by COMMAND.COM */
oldPSP = OwnerPSP;
atexit(exitfct);
OwnerPSP = _psp;
dbg_printmem();
#ifdef DEBUG
{ void* p;
if((p = malloc(5*1024)) == 0)
dprintf(("[MEM: Out of memory allocating test block during INIT]"));
else free(p);
}
#endif
#ifdef FEATURE_KERNEL_SWAP_SHELL
if(kswapInit()) { /* re-invoked */
if(kswapLoadStruc()) {
/* OK, on success we need not really keep the shell trick
(pretend we are our own parent), which might cause
problems with beta-software-bugs ;-)
In fact, KSSF will catch up our crashes and re-invoke
FreeCOM, probably with the loss of any internal
settings. */
OwnerPSP = oldPSP;
return E_None;
}
}
#endif
/* Some elder DOSs may not pass an initializied environment segment */
if (env_glbSeg && !isMCB(SEG2MCB(env_glbSeg)))
env_setGlbSeg(0); /* Disable the environment */
/* Now parse the command line parameters passed to COMMAND.COM */
/* Preparations */
newTTY = 0;
comPath = tracemode = 0;
showinfo = 1;
/* Because FreeCom should be executed in a DOS3+ compatible
environment most of the time, it is assumed that its path
can be determined from the environment.
This has the advantage that the string area is accessable
very early in the run.
The name of the current file is string #0. */
if((offs = env_string(0, 0)) != 0) /* OK, environment filled */
grabComFilename(0, (char far *)MK_FP(env_glbSeg, offs));
/* After that argv[0] is no longer used and maybe zapped.
This also will help, as most programs altering the environment
segment externally don't expect a string area. */
env_nullStrings(0);
/* Aquire the command line, there are three possible sources:
1) DOS command line @PSP:0x80 as pascal string,
2) extended DOS command line environment variable CMDLINE,
if peekb(PSP, 0x80) == 127,&
3) MKS command line @ENV:2, if peekb(ENV, 0) == '~'
&& peekb(ENV, 1) == '='
Currently implemented is version #1 only
*/
cmdlen = peekb(_psp, 0x80);
if(cmdlen < 0 || cmdlen > 126) {
error_corrupt_command_line();
cmdlen = 0;
}
/* duplicate the command line into the local address space */
if((cmdline = malloc(cmdlen + 1)) == 0) {
error_out_of_memory(); /* Cannot recover from this problem */
return E_NoMem;
}
_fmemcpy((char far*)cmdline, MK_FP(_psp, 0x81), cmdlen);
cmdline[cmdlen] = '\0';
#ifdef FEATURE_CALL_LOGGING
#ifndef INCLUDE_CMD_FDDEBUG
if((f = fopen(logFilename, "at")) == 0) {
fprintf(stderr, "Cannot open logfile: \"%s\"\n", logFilename);
} else {
putc('"', f);
if(ComPath) /* path to command.com already known */
fputs(ComPath, f);
putc('"', f);
putc(':', f);
fputs(cmdline, f);
putc('\n', f);
fclose(f);
}
#else
cmd_fddebug(logFilename);
dbg_outc('"');
dbg_outs(ComPath);
dbg_outc('"');
dbg_outc(':');
dbg_outsn(cmdline);
#endif
#endif
canexit = 1;
p = cmdline; /* start of the command line */
do {
ec = leadOptions(&p, opt_init, 0);
if(ec == E_NoOption) { /* /C or /K */
assert(p && *p);
if(!isoption(p)) {
error_quoted_c_k();
p = 0;
break;
}
assert(p[1] && strchr("kKcC", p[1]));
p += 2; /* p := start of command line to execute */
break;
} else if(ec != E_None) {
showhelp = 1;
p = 0;
break;
}
assert(p && !isoption(p) && !isspace(*p));
if(!*p) {
p = 0;
break; /* end of line reached */
}
q = unquote(p, h = skip_word(p));
p = h; /* Skip this word */
if(!q) {
error_out_of_memory();
p = 0;
break;
}
if(!comPath) { /* 1st argument */
grabComFilename(1, (char far*)q);
comPath = 1;
free(q);
} else if(!newTTY) { /* 2nd argument */
#ifdef INCLUDE_CMD_CTTY
newTTY = q;
#else
error_ctty_excluded();
free(q);
#endif
} else {
error_too_many_parameters(q);
showhelp = 1;
free(q);
break;
}
} while(1);
/*
* Now:
* + autoexec: AUTOEXEC.BAT file to be executed if /P switch
* is enabled; if NULL, use default
* + comPath: user-defined PATH to COMMAND.COM; if NULL, use
* the one from the environment
* + newTTY: the name of the device to be CTTY'ed; if NULL,
* no change
* + p: pointer to the command to be executed:
* *p == 'c' or 'C' --> spawn command, then terminate shell
* *p == 'k' or 'K' --> spawn command, then go interactive
* &p[1] --> command line, unless the first character is an
* argument character
*/
/* Now process the options */
#ifdef INCLUDE_CMD_CTTY
if (newTTY) { /* change TTY as early as possible so the caller gets
the messages into the correct channel */
cmd_ctty(newTTY);
free(newTTY);
}
#endif
if(!ComPath) {
/* FreeCom is unable to find itself --> print error message */
/* Emergency error */
#undef TEXT_MSG_FREECOM_NOT_FOUND
puts(TEXT_MSG_FREECOM_NOT_FOUND);
return E_Useage;
}
/* First of all, set up the environment */
/* If a new valid size is specified, use that */
env_resizeCtrl |= ENV_USEUMB | ENV_ALLOWMOVE;
if(newEnvSize > 16 && newEnvSize < 32767)
env_setsize(0, newEnvSize);
/* Otherwise the path is placed into the environment */
/* Set the COMSPEC variable. */
if(chgEnv("COMSPEC", ComPath)) { /* keep it silent */
/* Failed to add this variable, the most likely problem should be that
the environment is too small --> it is increased and the
operation is redone */
env_resize(0, strlen(ComPath) + 10);
if(chgEnv("COMSPEC", ComPath))
chgEnv("COMSPEC", NULL); /* Cannot set -> zap an old one */
}
inInit = 0;
/* Install INT 24 Critical error handler */
/* Needs the ComPath variable, eventually */
if(!kswapContext) {
/* Load the module/context into memory */
if((kswapContext = modContext()) == 0) {
error_loading_context();
return E_NoMem;
}
#ifdef FEATURE_KERNEL_SWAP_SHELL
if(swapOnExec != ERROR)
kswapRegister(kswapContext);
#endif
}
ctxtCreate();
/* re-use the already loaded Module */
setvect(0x24, (void interrupt(*)())
MK_FP(FP_SEG(kswapContext->cbreak_hdlr), kswapContext->ofs_criter));
if(internalBufLen)
error_l_notimplemented();
if(inputBufLen)
error_u_notimplemented();
if(tracemode)
showinfo = 0;
if (showhelp)
displayString(TEXT_CMDHELP_COMMAND);
if ((showhelp || exitflag) && canexit)
return E_None;
/* Now the /P option can be processed */
if(!canexit) {
char *autoexec;
autoexec = user_autoexec? user_autoexec: AUTO_EXEC;
showinfo = 0;
short_version();
if(skipAUTOEXEC) { /* /D option */
showinfo = 0;
displayString(TEXT_MSG_INIT_BYPASSING_AUTOEXEC, autoexec);
} else {
if(exist(autoexec)) {
#ifdef FEATURE_BOOT_KEYS
struct REGPACK r;
int key;
r.r_ax = 0x3000; /* Get DOS version & OEM ID */
intr(0x21, &r);
if(!tracemode /* /Y --> F8 on CONFIG.SYS */
|| ((r.r_bx & 0xff00) == 0xfd00 /* FreeDOS >= build 2025 */
&& !(r.r_cx > 0x101 || (r.r_bx & 0xff) > 24))) {
displayString(TEXT_MSG_INIT_BYPASS_AUTOEXEC, autoexec);
key = cgetchar_timed(3);
putchar('\n');
} else key = 0;
if(key == KEY_F8)
tracemode = 1;
if(key == KEY_F5)
displayString(TEXT_MSG_INIT_BYPASSING_AUTOEXEC, autoexec);
else
#endif
process_input(1, autoexec);
} else {
if(user_autoexec)
error_sfile_not_found(user_autoexec);
#ifdef INCLUDE_CMD_DATE
cmd_date(0);
#endif
#ifdef INCLUDE_CMD_TIME
cmd_time(0);
#endif
}
}
free(user_autoexec);
} else {
assert(user_autoexec == 0);
}
/* Now the /C or /K option can be processed */
if (p)
{
process_input(1, p);
return spawnAndExit;
}
/* Don't place something here that must be executed after a /K or /C */
if (showinfo)
{
short_version();
#ifndef DEBUG
putchar('\n');
showcmds(0);
putchar('\n');
#endif
}
return E_None;
}
int main(int argc, char* argv[]) {
int ret = 0;
if (argc) progname = argv[0];
if (argc > 1 && !strcmp(argv[1], "--run-tests")) {
return jq_testsuite(argc - 1, argv + 1);
}
const char* program = 0;
input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
ninput_files = 0;
int further_args_are_files = 0;
int jq_flags = 0;
jv program_arguments = jv_array();
for (int i=1; i<argc; i++) {
if (further_args_are_files) {
input_filenames[ninput_files++] = argv[i];
} else if (!strcmp(argv[i], "--")) {
if (!program) usage();
further_args_are_files = 1;
} else if (!isoptish(argv[i])) {
if (program) {
input_filenames[ninput_files++] = argv[i];
} else {
program = argv[i];
}
} else if (isoption(argv[i], 's', "slurp")) {
options |= SLURP;
} else if (isoption(argv[i], 'r', "raw-output")) {
options |= RAW_OUTPUT;
} else if (isoption(argv[i], 'c', "compact-output")) {
options |= COMPACT_OUTPUT;
} else if (isoption(argv[i], 'C', "color-output")) {
options |= COLOUR_OUTPUT;
} else if (isoption(argv[i], 'M', "monochrome-output")) {
options |= NO_COLOUR_OUTPUT;
} else if (isoption(argv[i], 'a', "ascii-output")) {
options |= ASCII_OUTPUT;
} else if (isoption(argv[i], 'R', "raw-input")) {
options |= RAW_INPUT;
} else if (isoption(argv[i], 'n', "null-input")) {
options |= PROVIDE_NULL;
} else if (isoption(argv[i], 'f', "from-file")) {
options |= FROM_FILE;
} else if (isoption(argv[i], 0, "arg")) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --arg takes two parameters (e.g. -a varname value)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
arg = jv_object_set(arg, jv_string("value"), jv_string(argv[i+2]));
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
} else if (isoption(argv[i], 0, "debug-dump-disasm")) {
options |= DUMP_DISASM;
} else if (isoption(argv[i], 0, "debug-trace")) {
jq_flags |= JQ_DEBUG_TRACE;
} else if (isoption(argv[i], 'h', "help")) {
usage();
} else if (isoption(argv[i], 'V', "version")) {
fprintf(stderr, "jq version %s\n", PACKAGE_VERSION);
return 0;
} else {
fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
die();
}
}
if (!program) usage();
if (ninput_files == 0) current_input = stdin;
if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", progname);
die();
}
if (options & FROM_FILE) {
jv data = slurp_file(program);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: %s\n", progname, jv_string_value(data));
jv_free(data);
return 1;
}
bc = jq_compile_args(jv_string_value(data), program_arguments);
jv_free(data);
} else {
bc = jq_compile_args(program, program_arguments);
}
if (!bc) return 1;
if (options & DUMP_DISASM) {
dump_disassembly(0, bc);
printf("\n");
}
if (options & PROVIDE_NULL) {
process(jv_null(), jq_flags);
} else {
jv slurped;
if (options & SLURP) {
if (options & RAW_INPUT) {
slurped = jv_string("");
} else {
slurped = jv_array();
}
}
struct jv_parser parser;
jv_parser_init(&parser);
char buf[4096];
while (read_more(buf, sizeof(buf))) {
if (options & RAW_INPUT) {
int len = strlen(buf);
if (len > 0) {
if (options & SLURP) {
slurped = jv_string_concat(slurped, jv_string(buf));
} else {
if (buf[len-1] == '\n') buf[len-1] = 0;
process(jv_string(buf), jq_flags);
}
}
} else {
jv_parser_set_buf(&parser, buf, strlen(buf), !feof(stdin));
jv value;
while (jv_is_valid((value = jv_parser_next(&parser)))) {
if (options & SLURP) {
slurped = jv_array_append(slurped, value);
} else {
process(value, jq_flags);
}
}
if (jv_invalid_has_msg(jv_copy(value))) {
jv msg = jv_invalid_get_msg(value);
fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
jv_free(msg);
ret = 1;
break;
} else {
jv_free(value);
}
}
}
jv_parser_free(&parser);
if (ret != 0)
goto out;
if (options & SLURP) {
process(slurped, jq_flags);
}
}
out:
jv_mem_free(input_filenames);
bytecode_free(bc);
return ret;
}
void main(int argc, char *argv[])
{
word16 instr_len;
word16 offset;
char infilename[80];
char c;
*infilename = 0;
while (--argc) {
argv++;
if (**argv=='?') {
hlp: fprintf(stderr,
"2ASM Version 1.01 (C) Copyright 1992, Robin Hilliard\n"
"Converts binary files to 80*86 assembly\n"
"Usage:\n"
"\t2asm <file> [-e] [-x] [-s] [-d]\n"
"Switches:\n"
"\t-e :\tDisassemble (unoverridden) emulated 80*87 instructions\n"
"\t-x :\tOutput numbers in pure hex (default is reassemblable)\n"
"\t-s :\tDon't specify operand size, even where necessary\n"
"\t-d :\tDon't specify distance short/near/far jmps and calls"
);
exit(1);
}
if (isoption(**argv)) {
while (isoption(**argv)) {
nextflag:
switch (c = *(++*argv)) {
case 'e':
do_emul87 = 1;
break;
case 'x':
do_hex = 1;
break;
case 's':
do_size = 0;
break;
case 'd':
do_distance = 0;
break;
case '?':
case 'H':
goto hlp;
case '#': /* hidden flag in the Loft's programs! */
fprintf(stderr,"Last compiled on " __TIME__ ", " __DATE__) ;
exit(1);
default:
fprintf(stderr, "Unknown option: `-%c'", c);
exit(1);
}
++*argv;
}
} else { /* assume that its a file name */
if (*infilename) {
fprintf(stderr,"Unknown file argument: \"%s\"", *argv);
exit(1);
}
strcpy(infilename,*argv);
}
}
if ((infile=fopen(infilename,"rb"))==NULL) {
printf("Unable to open %s",infilename);
exit(2);
}
offset = 0;
strlwr(infilename);
if (strstr(infilename, ".com")) /* not perfect, fix later */
instruction_offset = offset = 0x100;
if (!setjmp(reached_eof)) {
do {
instr_len = unassemble(offset);
offset += instr_len;
} while (instr_len); /* whoops, no files > 64k */
}
}
int main(int argc, char* argv[]) {
jq_state *jq = NULL;
int ret = 0;
int compiled = 0;
if (argc) progname = argv[0];
if (argc > 1 && !strcmp(argv[1], "--run-tests")) {
return jq_testsuite(argc, argv);
}
jq = jq_init();
if (jq == NULL) {
perror("malloc");
ret = 1;
goto out;
}
const char* program = 0;
input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
ninput_files = 0;
int further_args_are_files = 0;
int jq_flags = 0;
jv_parser_flags parser_flags = 0;
jv program_arguments = jv_array();
for (int i=1; i<argc; i++) {
if (further_args_are_files) {
input_filenames[ninput_files++] = argv[i];
} else if (!strcmp(argv[i], "--")) {
if (!program) usage();
further_args_are_files = 1;
} else if (!isoptish(argv[i])) {
if (program) {
input_filenames[ninput_files++] = argv[i];
} else {
program = argv[i];
}
} else if (isoption(argv[i], 's', "slurp")) {
options |= SLURP;
} else if (isoption(argv[i], 'r', "raw-output")) {
options |= RAW_OUTPUT;
} else if (isoption(argv[i], 'c', "compact-output")) {
options |= COMPACT_OUTPUT;
} else if (isoption(argv[i], 'C', "color-output")) {
options |= COLOUR_OUTPUT;
} else if (isoption(argv[i], 'M', "monochrome-output")) {
options |= NO_COLOUR_OUTPUT;
} else if (isoption(argv[i], 'a', "ascii-output")) {
options |= ASCII_OUTPUT;
} else if (isoption(argv[i], 0, "unbuffered")) {
options |= UNBUFFERED_OUTPUT;
} else if (isoption(argv[i], 'S', "sort-keys")) {
options |= SORTED_OUTPUT;
} else if (isoption(argv[i], 'R', "raw-input")) {
options |= RAW_INPUT;
} else if (isoption(argv[i], 'n', "null-input")) {
options |= PROVIDE_NULL;
} else if (isoption(argv[i], 'f', "from-file")) {
options |= FROM_FILE;
} else if (isoption(argv[i], 'e', "exit-status")) {
options |= EXIT_STATUS;
} else if (isoption(argv[i], 'I', "online-input")) {
parser_flags = JV_PARSE_EXPLODE_TOPLEVEL_ARRAY;
} else if (isoption(argv[i], 0, "arg")) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --arg takes two parameters (e.g. -a varname value)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
arg = jv_object_set(arg, jv_string("value"), jv_string(argv[i+2]));
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
} else if (isoption(argv[i], 0, "argfile")) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --argfile takes two parameters (e.g. -a varname filename)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
jv data = jv_load_file(argv[i+2], 0);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: Bad JSON in --argfile %s %s: %s\n", progname,
argv[i+1], argv[i+2], jv_string_value(data));
jv_free(data);
ret = 1;
goto out;
}
if (jv_get_kind(data) == JV_KIND_ARRAY && jv_array_length(jv_copy(data)) == 1)
data = jv_array_get(data, 0);
arg = jv_object_set(arg, jv_string("value"), data);
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
} else if (isoption(argv[i], 0, "debug-dump-disasm")) {
options |= DUMP_DISASM;
} else if (isoption(argv[i], 0, "debug-trace")) {
jq_flags |= JQ_DEBUG_TRACE;
} else if (isoption(argv[i], 'h', "help")) {
usage();
} else if (isoption(argv[i], 'V', "version")) {
printf("jq-%s\n", JQ_VERSION);
ret = 0;
goto out;
} else {
fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
die();
}
}
if (!program) usage();
if (ninput_files == 0) current_input = stdin;
if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", progname);
die();
}
if (options & FROM_FILE) {
jv data = jv_load_file(program, 1);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: %s\n", progname, jv_string_value(data));
jv_free(data);
ret = 1;
goto out;
}
compiled = jq_compile_args(jq, jv_string_value(data), program_arguments);
jv_free(data);
} else {
compiled = jq_compile_args(jq, program, program_arguments);
}
if (!compiled){
ret = 1;
goto out;
}
if (options & DUMP_DISASM) {
jq_dump_disassembly(jq, 0);
printf("\n");
}
if (options & PROVIDE_NULL) {
ret = process(jq, jv_null(), jq_flags);
} else {
jv slurped;
if (options & SLURP) {
if (options & RAW_INPUT) {
slurped = jv_string("");
} else {
slurped = jv_array();
}
}
struct jv_parser* parser = jv_parser_new(parser_flags);
char buf[4096];
while (read_more(buf, sizeof(buf))) {
if (options & RAW_INPUT) {
int len = strlen(buf);
if (len > 0) {
if (options & SLURP) {
slurped = jv_string_concat(slurped, jv_string(buf));
} else {
if (buf[len-1] == '\n') buf[len-1] = 0;
ret = process(jq, jv_string(buf), jq_flags);
}
}
} else {
jv_parser_set_buf(parser, buf, strlen(buf), !feof(stdin));
jv value;
while (jv_is_valid((value = jv_parser_next(parser)))) {
if (options & SLURP) {
slurped = jv_array_append(slurped, value);
} else {
ret = process(jq, value, jq_flags);
}
}
if (jv_invalid_has_msg(jv_copy(value))) {
jv msg = jv_invalid_get_msg(value);
fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
jv_free(msg);
ret = 1;
break;
} else {
jv_free(value);
}
}
}
jv_parser_free(parser);
if (ret != 0)
goto out;
if (options & SLURP) {
ret = process(jq, slurped, jq_flags);
}
}
out:
jv_mem_free(input_filenames);
jq_teardown(&jq);
if (ret >= 10 && ret <= 11 && !(options & EXIT_STATUS))
return 0;
return ret;
}
int
b_fmt(int argc, char** argv, void *context)
{
register int n;
char* cp;
Fmt_t fmt;
char outbuf[8 * 1024];
fmt.flags = 0;
fmt.out = sfstdout;
fmt.outbuf = outbuf;
fmt.outp = 0;
fmt.endbuf = &outbuf[72];
fmt.indent = 0;
fmt.nextdent = 0;
fmt.nwords = 0;
fmt.prefix = 0;
fmt.quote = 0;
fmt.retain = 0;
fmt.section = 1;
cmdinit(argc, argv, context, ERROR_CATALOG, 0);
for (;;)
{
switch (n = optget(argv, usage))
{
case 'c':
case 'o':
case 's':
case 'u':
setoption(&fmt, n);
continue;
case 'w':
if (opt_info.num < TABSZ || opt_info.num>= sizeof(outbuf))
error(2, "width out of range");
fmt.endbuf = &outbuf[opt_info.num];
continue;
case ':':
error(2, "%s", opt_info.arg);
break;
case '?':
error(ERROR_usage(2), "%s", opt_info.arg);
break;
}
break;
}
argv += opt_info.index;
if (error_info.errors)
error(ERROR_usage(2), "%s", optusage(NiL));
if (isoption(&fmt, 'o'))
setoption(&fmt, 'c');
if (isoption(&fmt, 's'))
clroption(&fmt, 'u');
if (cp = *argv)
argv++;
do {
if (!cp || streq(cp, "-"))
fmt.in = sfstdin;
else if (!(fmt.in = sfopen(NiL, cp, "r")))
{
error(ERROR_system(0), "%s: cannot open", cp);
error_info.errors = 1;
continue;
}
dofmt(&fmt);
if (fmt.in != sfstdin)
sfclose(fmt.in);
} while (cp = *argv++);
outline(&fmt);
if (sfsync(sfstdout))
error(ERROR_system(0), "write error");
return error_info.errors != 0;
}
int _CRTAPI1
main(
int argc,
char **argv
)
{
// Initialize program defaults
program = *argv++; argc--;
fin = stdin;
fout = stdout;
outbuf.eolflag = 0;
outbuf.maxlen = 79;
outbuf.count = 0;
// Parse command line options
while (argc) {
if (isoption(**argv)) {
char *poption = (*argv) + 1;
// -<n> : specify maximum output line length
if (isdigit(*poption)) {
outbuf.maxlen = atoi(poption);
if (outbuf.maxlen <= 0)
usage();
} else if (_stricmp(poption, "cr") == 0) {
// -cr : terminate output line with CR
outbuf.eolflag = CR;
} else if (_stricmp(poption, "lf") == 0) {
// -lf : terminate output line with LF
outbuf.eolflag = LF;
} else
usage();
} else if (fin == stdin) {
fin = fopen(*argv, "r");
if (fin == NULL)
error("couldn't open input file");
} else if (fout == stdout) {
fout = fopen(*argv, "w+");
if (fout == NULL)
error("couldn't open output file");
} else
usage();
argv++; argc--;
}
// Allocate memory
outbuf.buffer = (char *) malloc(outbuf.maxlen + 2);
if (outbuf.buffer == NULL)
error("out of memory");
// Compact input file and generate output
compact();
return 0;
}
int main(int argc, char* argv[]) {
jq_state *jq = NULL;
int ret = 0;
int compiled = 0;
int parser_flags = 0;
int nfiles = 0;
int badwrite;
jv program_arguments = jv_array();
#ifdef WIN32
SetConsoleOutputCP(CP_UTF8);
fflush(stdout);
fflush(stderr);
_setmode(fileno(stdout), _O_TEXT | _O_U8TEXT);
_setmode(fileno(stderr), _O_TEXT | _O_U8TEXT);
int wargc;
wchar_t **wargv = CommandLineToArgvW(GetCommandLineW(), &wargc);
assert(wargc == argc);
size_t arg_sz;
for (int i = 0; i < argc; i++) {
argv[i] = alloca((arg_sz = WideCharToMultiByte(CP_UTF8,
0,
wargv[i],
-1, 0, 0, 0, 0)));
WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1, argv[i], arg_sz, 0, 0);
}
#endif
if (argc) progname = argv[0];
jq = jq_init();
if (jq == NULL) {
perror("malloc");
ret = 2;
goto out;
}
int dumpopts = JV_PRINT_INDENT_FLAGS(2);
const char* program = 0;
jv_extra_opt extra_opt;
extra_opt.array_fold=0;
extra_opt.array_fold_indent=1;
jq_util_input_state *input_state = jq_util_input_init(NULL, NULL); // XXX add err_cb
int further_args_are_files = 0;
int jq_flags = 0;
size_t short_opts = 0;
jv lib_search_paths = jv_null();
for (int i=1; i<argc; i++, short_opts = 0) {
if (further_args_are_files) {
jq_util_input_add_input(input_state, argv[i]);
nfiles++;
} else if (!strcmp(argv[i], "--")) {
if (!program) usage(2);
further_args_are_files = 1;
} else if (!isoptish(argv[i])) {
if (program) {
jq_util_input_add_input(input_state, argv[i]);
nfiles++;
} else {
program = argv[i];
}
} else {
if (argv[i][1] == 'L') {
if (jv_get_kind(lib_search_paths) == JV_KIND_NULL)
lib_search_paths = jv_array();
if (argv[i][2] != 0) { // -Lname (faster check than strlen)
lib_search_paths = jv_array_append(lib_search_paths, jq_realpath(jv_string(argv[i]+2)));
} else if (i >= argc - 1) {
fprintf(stderr, "-L takes a parameter: (e.g. -L /search/path or -L/search/path)\n");
die();
} else {
lib_search_paths = jv_array_append(lib_search_paths, jq_realpath(jv_string(argv[i+1])));
i++;
}
continue;
}
if (isoption(argv[i], 0, "fold", &short_opts)) {
if (i >= argc - 1) {
fprintf(stderr, "%s: --fold takes one parameter\n", progname);
die();
}
extra_opt.array_fold = atoi(argv[i+1]);
if (extra_opt.array_fold < 1 || extra_opt.array_fold > 255) {
fprintf(stderr, "%s: --fold takes a number between 1 and 255\n", progname);
die();
}
i++;
if (!short_opts) continue;
}
if (isoption(argv[i], 's', "slurp", &short_opts)) {
options |= SLURP;
if (!short_opts) continue;
}
if (isoption(argv[i], 'r', "raw-output", &short_opts)) {
options |= RAW_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'c', "compact-output", &short_opts)) {
dumpopts &= ~(JV_PRINT_TAB | JV_PRINT_INDENT_FLAGS(7));
if (!short_opts) continue;
}
if (isoption(argv[i], 'C', "color-output", &short_opts)) {
options |= COLOR_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'M', "monochrome-output", &short_opts)) {
options |= NO_COLOR_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'a', "ascii-output", &short_opts)) {
options |= ASCII_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "unbuffered", &short_opts)) {
options |= UNBUFFERED_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'S', "sort-keys", &short_opts)) {
options |= SORTED_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'R', "raw-input", &short_opts)) {
options |= RAW_INPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'n', "null-input", &short_opts)) {
options |= PROVIDE_NULL;
if (!short_opts) continue;
}
if (isoption(argv[i], 'f', "from-file", &short_opts)) {
options |= FROM_FILE;
if (!short_opts) continue;
}
if (isoption(argv[i], 'j', "join-output", &short_opts)) {
options |= RAW_OUTPUT | RAW_NO_LF;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "tab", &short_opts)) {
dumpopts &= ~JV_PRINT_INDENT_FLAGS(7);
dumpopts |= JV_PRINT_TAB | JV_PRINT_PRETTY;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "indent", &short_opts)) {
if (i >= argc - 1) {
fprintf(stderr, "%s: --indent takes one parameter\n", progname);
die();
}
dumpopts &= ~(JV_PRINT_TAB | JV_PRINT_INDENT_FLAGS(7));
int indent = atoi(argv[i+1]);
if (indent < -1 || indent > 7) {
fprintf(stderr, "%s: --indent takes a number between -1 and 7\n", progname);
die();
}
dumpopts |= JV_PRINT_INDENT_FLAGS(indent);
i++;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "seq", &short_opts)) {
options |= SEQ;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "stream", &short_opts)) {
parser_flags |= JV_PARSE_STREAMING;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "stream-errors", &short_opts)) {
parser_flags |= JV_PARSE_STREAM_ERRORS;
if (!short_opts) continue;
}
if (isoption(argv[i], 'e', "exit-status", &short_opts)) {
options |= EXIT_STATUS;
if (!short_opts) continue;
}
// FIXME: For --arg* we should check that the varname is acceptable
if (isoption(argv[i], 0, "arg", &short_opts)) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --arg takes two parameters (e.g. --arg varname value)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
arg = jv_object_set(arg, jv_string("value"), jv_string(argv[i+2]));
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "argjson", &short_opts)) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --argjson takes two parameters (e.g. --argjson varname text)\n", progname);
die();
}
jv v = jv_parse(argv[i+2]);
if (!jv_is_valid(v)) {
fprintf(stderr, "%s: invalid JSON text passed to --argjson\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
arg = jv_object_set(arg, jv_string("value"), v);
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "argfile", &short_opts) ||
isoption(argv[i], 0, "slurpfile", &short_opts)) {
const char *which;
if (isoption(argv[i], 0, "argfile", &short_opts))
which = "argfile";
else
which = "slurpfile";
if (i >= argc - 2) {
fprintf(stderr, "%s: --%s takes two parameters (e.g. --%s varname filename)\n", progname, which, which);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
jv data = jv_load_file(argv[i+2], 0);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: Bad JSON in --%s %s %s: %s\n", progname, which,
argv[i+1], argv[i+2], jv_string_value(data));
jv_free(data);
jv_free(arg);
ret = 2;
goto out;
}
if (isoption(argv[i], 0, "argfile", &short_opts) &&
jv_get_kind(data) == JV_KIND_ARRAY && jv_array_length(jv_copy(data)) == 1)
data = jv_array_get(data, 0);
arg = jv_object_set(arg, jv_string("value"), data);
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "debug-dump-disasm", &short_opts)) {
options |= DUMP_DISASM;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "debug-trace", &short_opts)) {
jq_flags |= JQ_DEBUG_TRACE;
if (!short_opts) continue;
}
if (isoption(argv[i], 'h', "help", &short_opts)) {
usage(0);
if (!short_opts) continue;
}
if (isoption(argv[i], 'V', "version", &short_opts)) {
printf("jq-%s\n", JQ_VERSION);
ret = 0;
goto out;
}
if (isoption(argv[i], 0, "run-tests", &short_opts)) {
i++;
// XXX Pass program_arguments, even a whole jq_state *, through;
// could be useful for testing
ret = jq_testsuite(lib_search_paths,
(options & DUMP_DISASM) || (jq_flags & JQ_DEBUG_TRACE),
argc - i, argv + i);
goto out;
}
// check for unknown options... if this argument was a short option
if (strlen(argv[i]) != short_opts + 1) {
fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
die();
}
}
}
if (isatty(fileno(stdout))) {
dumpopts |= JV_PRINT_ISATTY;
#ifndef WIN32
/* Disable color by default on Windows builds as Windows
terminals tend not to display it correctly */
dumpopts |= JV_PRINT_COLOR;
#endif
}
if (options & SORTED_OUTPUT) dumpopts |= JV_PRINT_SORTED;
if (options & ASCII_OUTPUT) dumpopts |= JV_PRINT_ASCII;
if (options & COLOR_OUTPUT) dumpopts |= JV_PRINT_COLOR;
if (options & NO_COLOR_OUTPUT) dumpopts &= ~JV_PRINT_COLOR;
if (jv_get_kind(lib_search_paths) == JV_KIND_NULL) {
// Default search path list
lib_search_paths = JV_ARRAY(jv_string("~/.jq"),
jv_string("$ORIGIN/../lib/jq"),
jv_string("$ORIGIN/lib"));
}
jq_set_attr(jq, jv_string("JQ_LIBRARY_PATH"), lib_search_paths);
char *origin = strdup(argv[0]);
if (origin == NULL) {
fprintf(stderr, "Error: out of memory\n");
exit(1);
}
jq_set_attr(jq, jv_string("JQ_ORIGIN"), jv_string(dirname(origin)));
free(origin);
if (strchr(JQ_VERSION, '-') == NULL)
jq_set_attr(jq, jv_string("VERSION_DIR"), jv_string(JQ_VERSION));
else
jq_set_attr(jq, jv_string("VERSION_DIR"), jv_string_fmt("%.*s-master", (int)(strchr(JQ_VERSION, '-') - JQ_VERSION), JQ_VERSION));
#if (!defined(WIN32) && defined(HAVE_ISATTY)) || defined(HAVE__ISATTY)
#if defined(HAVE__ISATTY) && defined(isatty)
#undef isatty
#define isatty _isatty
#endif
if (!program && isatty(STDOUT_FILENO) && !isatty(STDIN_FILENO))
program = ".";
#endif
if (!program) usage(2);
if (options & FROM_FILE) {
char *program_origin = strdup(program);
if (program_origin == NULL) {
perror("malloc");
exit(2);
}
jv data = jv_load_file(program, 1);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: %s\n", progname, jv_string_value(data));
jv_free(data);
ret = 2;
goto out;
}
jq_set_attr(jq, jv_string("PROGRAM_ORIGIN"), jq_realpath(jv_string(dirname(program_origin))));
compiled = jq_compile_args(jq, jv_string_value(data), jv_copy(program_arguments));
free(program_origin);
jv_free(data);
} else {
jq_set_attr(jq, jv_string("PROGRAM_ORIGIN"), jq_realpath(jv_string("."))); // XXX is this good?
compiled = jq_compile_args(jq, program, jv_copy(program_arguments));
}
if (!compiled){
ret = 3;
goto out;
}
if (options & DUMP_DISASM) {
jq_dump_disassembly(jq, 0);
printf("\n");
}
if ((options & SEQ))
parser_flags |= JV_PARSE_SEQ;
if ((options & RAW_INPUT))
jq_util_input_set_parser(input_state, NULL, (options & SLURP) ? 1 : 0);
else
jq_util_input_set_parser(input_state, jv_parser_new(parser_flags), (options & SLURP) ? 1 : 0);
// Let jq program read from inputs
jq_set_input_cb(jq, jq_util_input_next_input_cb, input_state);
// Let jq program call `debug` builtin and have that go somewhere
jq_set_debug_cb(jq, debug_cb, &dumpopts);
if (nfiles == 0)
jq_util_input_add_input(input_state, "-");
if (options & PROVIDE_NULL) {
if (extra_opt.array_fold==0) {
ret = process(jq, jv_null(), jq_flags, dumpopts);
} else {
ret = process_extra_opt(jq, jv_null(), jq_flags, dumpopts, &extra_opt);
}
} else {
jv value;
while (jq_util_input_errors(input_state) == 0 &&
(jv_is_valid((value = jq_util_input_next_input(input_state))) || jv_invalid_has_msg(jv_copy(value)))) {
if (jv_is_valid(value)) {
if (extra_opt.array_fold==0) {
ret = process(jq, value, jq_flags, dumpopts);
} else {
ret = process_extra_opt(jq, value, jq_flags, dumpopts, &extra_opt);
}
continue;
}
// Parse error
jv msg = jv_invalid_get_msg(value);
if (!(options & SEQ)) {
// --seq -> errors are not fatal
ret = 4;
fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
jv_free(msg);
break;
}
fprintf(stderr, "ignoring parse error: %s\n", jv_string_value(msg));
jv_free(msg);
}
}
if (jq_util_input_errors(input_state) != 0)
ret = 2;
out:
badwrite = ferror(stdout);
if (fclose(stdout)!=0 || badwrite) {
fprintf(stderr,"Error: writing output failed: %s\n", strerror(errno));
ret = 2;
}
jv_free(program_arguments);
jq_util_input_free(&input_state);
jq_teardown(&jq);
if (ret >= 10 && (options & EXIT_STATUS))
return ret - 10;
if (ret >= 10)
return 0;
return ret;
}
int initialize(void)
{
int comPath; /* path to COMMAND.COM (for COMSPEC/reload) */
char *newTTY; /* what to change TTY to */
int showinfo; /* show initial info only if no command line options */
int key;
int ec; /* error code */
unsigned offs; /* offset into environment segment */
int cmdlen; /* length of command line */
char *cmdline; /* command line duplicated into heap */
char *p, *h, *q;
#ifdef FEATURE_CALL_LOGGING
FILE *f;
#endif
/* Set up the host environment of COMMAND.COM */
/* Install the ^Break handler (see chkCBreak() for more details) */
extern void initCBreakCatcher(void);
initCBreakCatcher();
/* Install INT 24 Critical error handler */
init_error_handler();
/* DOS shells patch the PPID to the own PID, how stupid this is, however,
because then DOS won't terminate them, e.g. when a Critical Error
occurs that is not detected by COMMAND.COM */
oldPSP = OwnerPSP;
atexit(exitfct);
OwnerPSP = _psp;
/* Some elder DOSs may not pass an initialzied environment segment */
if (env_glbSeg && !isMCB(SEG2MCB(env_glbSeg)))
env_setGlbSeg(0); /* Disable the environment */
/* Now parse the command line parameters passed to COMMAND.COM */
/* Preparations */
newTTY = NULL;
comPath = tracemode = 0;
showinfo = 1;
/* Because FreeCom should be executed in a DOS3+ compatible
environment most of the time, it is assumed that its path
can be determined from the environment.
This has the advantage that the string area is accessable
very early in the run.
The name of the current file is string #0. */
if((offs = env_string(0, 0)) != 0) /* OK, environment filled */
grabComFilename(0, (char far *)MK_FP(env_glbSeg, offs));
/* Aquire the command line, there are three possible sources:
1) DOS command line @PSP:0x80 as pascal string,
2) extended DOS command line environment variable CMDLINE,
if peekb(PSP, 0x80) == 127,&
3) MKS command line @ENV:2, if peekb(ENV, 0) == '~'
Currently implemented is version #1 only
*/
cmdlen = peekb(_psp, 0x80);
if(cmdlen < 0 || cmdlen > 126) {
error_corrupt_command_line();
cmdlen = 0;
}
/* duplicate the command line into the local address space */
if((cmdline = malloc(cmdlen + 1)) == NULL) {
error_out_of_memory(); /* Cannot recover from this problem */
return E_NoMem;
}
_fmemcpy((char far*)cmdline, MK_FP(_psp, 0x81), cmdlen);
cmdline[cmdlen] = '\0';
#ifdef FEATURE_CALL_LOGGING
if((f = fopen(logFilename, "at")) == NULL) {
fprintf(stderr, "Cannot open logfile: \"%s\"\n", logFilename);
exit(125);
}
putc('"', f);
if(ComPath) /* path to command.com already known */
fputs(ComPath, f);
putc('"', f);
putc(':', f);
fputs(cmdline, f);
putc('\n', f);
fclose(f);
#endif
p = cmdline; /* start of the command line */
do {
ec = leadOptions(&p, opt_init, NULL);
if(ec == E_NoOption) { /* /C or /K */
assert(p && *p);
if(!isoption(p)) {
error_quoted_c_k();
p = NULL;
break;
}
assert(p[1] && strchr("kKcC", p[1]));
p += 2; /* p := start of command line to execute */
break;
} else if(ec != E_None) {
showhelp = 1;
p = NULL;
break;
}
assert(p && !isoption(p) && !isspace(*p));
if(!*p) {
p = NULL;
break; /* end of line reached */
}
q = unquote(p, h = skip_word(p));
p = h; /* Skip this word */
if(!q) {
error_out_of_memory();
p = NULL;
break;
}
if(!comPath) { /* 1st argument */
grabComFilename(1, (char far*)q);
comPath = 1;
free(q);
} else if(!newTTY) { /* 2nd argument */
#ifdef INCLUDE_CMD_CTTY
newTTY = q;
#else
error_ctty_excluded();
free(q);
#endif
} else {
error_too_many_parameters(q);
showhelp = 1;
free(q);
break;
}
} while(1);
/*
* Now:
* + autoexec: AUTOEXEC.BAT file to be executed if /P switch
* is enabled; if NULL, use default
* + comPath: user-defined PATH to COMMAND.COM; if NULL, use
* the one from the environment
* + newTTY: the name of the device to be CTTY'ed; if NULL,
* no change
* + p: pointer to the command to be executed:
* *p == 'c' or 'C' --> spawn command, then terminate shell
* *p == 'k' or 'K' --> spawn command, then go interactive
* &p[1] --> command line, unless the first character is an
* argument character
*/
/* Now process the options */
#ifdef INCLUDE_CMD_CTTY
if (newTTY) { /* change TTY as early as possible so the caller gets
the messages into the correct channel */
cmd_ctty(newTTY);
free(newTTY);
}
#endif
if(!ComPath) {
/* FreeCom is unable to find itself --> print error message */
/* Emergency error */
puts("You must specify the complete path to " COM_NAME);
puts("as the first argument of COMMAND,");
puts("for instance: C:\\FDOS");
return E_Useage;
}
/* First of all, set up the environment */
env_resizeCtrl |= ENV_USEUMB | ENV_ALLOWMOVE;
if (envSize < 0)
envSize = 32767; /* Numeric overflow (number > 32767 specified) */
else if (envSize < 256)
envSize = 256; /* Minimum size of 256. */
if(envSize > env_resize(0, 0)) /* Test if to enlarge environment */
env_setsize(0, envSize);
/* Set the COMSPEC variable. */
#if 0
if (chgEnv("COMSPEC", ComPath)) error_env_var("COMSPEC");
#else
if (chgEnv("COMSPEC", ComPath)) {
/* Failed to add this variable, the most likely problem should be that
the environment is too small --> it is increased and the
operation is redone */
env_resize(0, strlen(ComPath) + 10);
if (chgEnv("COMSPEC", ComPath))
error_env_var("COMSPEC");
}
#endif
if(internalBufLen)
error_l_notimplemented();
if(inputBufLen)
error_u_notimplemented();
if(tracemode)
showinfo = 0;
if (showhelp)
displayString(TEXT_CMDHELP_COMMAND);
if ((showhelp || exitflag) && canexit)
return E_None;
/* Now the /P option can be processed */
if (!canexit)
{
char *autoexec;
autoexec = user_autoexec? user_autoexec: AUTO_EXEC;
showinfo = 0;
short_version();
/* JP: changed so that if autoexec does not exist, then don't ask
to trace or bypass.
*/
if (exist(autoexec))
{
printf("\nPress F8 for trace mode, or F5 to bypass %s... ", autoexec);
key = WaitForFkeys();
putchar('\n');
if (key == KEY_F8)
{
tracemode = 1;
}
if (key == KEY_F5)
{
printf("Bypassing %s\n", autoexec);
}
else
process_input(1, autoexec);
}
else
{
if(user_autoexec)
printf("%s not found.\n", autoexec);
#ifdef INCLUDE_CMD_DATE
cmd_date(NULL);
#endif
#ifdef INCLUDE_CMD_TIME
cmd_time(NULL);
#endif
}
free(user_autoexec);
}
else
{
assert(user_autoexec == NULL);
}
/* Now the /C or /K option can be processed */
if (p)
{
process_input(1, p);
return spawnAndExit;
}
/* Don't place something here that must be executed after a /K or /C */
if (showinfo)
{
short_version();
putchar('\n');
showcmds(NULL);
putchar('\n');
}
return E_None;
}
static void
split(Fmt_t* fp, char* buf, int splice)
{
register char* cp;
register char* ep;
register char* qp;
register int c = 1;
register int q = 0;
register int n;
int prefix;
for (ep = buf; *ep == ' '; ep++);
prefix = ep - buf;
/*
* preserve blank lines
*/
if ((*ep == 0 || *buf == '.') && !isoption(fp, 'o'))
{
if (*ep)
prefix = strlen(buf);
outline(fp);
strcpy(fp->outbuf, buf);
fp->outp = fp->outbuf+prefix;
outline(fp);
return;
}
if (fp->prefix < prefix && !isoption(fp, 'c'))
outline(fp);
if (!fp->outp || prefix < fp->prefix)
fp->prefix = prefix;
while (c)
{
cp = ep;
while (*ep == ' ')
ep++;
if (cp != ep && isoption(fp, 'u'))
cp = ep-1;
while (c = *ep)
{
if (c == ' ')
break;
ep++;
/*
* skip over \space
*/
if (c == '\\' && *ep)
ep++;
}
n = (ep-cp);
if (n && isoption(fp, 'o'))
{
for (qp = cp; qp < ep; qp++)
if (*qp == '\\')
qp++;
else if (*qp == '"')
q = !q;
if (*(ep-1) == '"')
goto skip;
}
if (fp->nwords > 0 && &fp->outp[n] >= fp->endbuf && !fp->retain && !q)
outline(fp);
skip:
if (fp->nwords == 0)
{
if (fp->prefix)
memset(fp->outbuf, ' ', fp->prefix);
fp->outp = &fp->outbuf[fp->prefix];
while (*cp == ' ')
cp++;
n = (ep-cp);
}
memcpy(fp->outp, cp, n);
fp->outp += n;
fp->nwords++;
}
if (isoption(fp, 's') || *buf == 0)
outline(fp);
else if (fp->outp)
{
/*
* two spaces at ends of sentences
*/
if (!isoption(fp, 'o') && strchr(".:!?", fp->outp[-1]))
*fp->outp++ = ' ';
if (!splice && !fp->retain && (!fp->quote || (fp->outp - fp->outbuf) < 2 || fp->outp[-2] != '\\' || fp->outp[-1] != 'n' && fp->outp[-1] != 't' && fp->outp[-1] != ' '))
*fp->outp++ = ' ';
}
}