--- /dev/null
+/* -*-c-*-
+ *
+ * Options parsing, similar to GNU @getopt_long@
+ *
+ * (c) 1996 Straylight/Edgeware
+ */
+
+/*----- Licensing notice --------------------------------------------------*
+ *
+ * This file is part of many programs.
+ *
+ * `mdwopt' is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * `mdwopt' is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with `mdwopt'; if not, write to the Free
+ * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+/*----- External dependencies ---------------------------------------------*/
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "mdwopt.h"
+
+/*----- Configuration things ----------------------------------------------*/
+
+#if defined(__riscos)
+# define PATHSEP '.'
+#elif defined(__OS2__) || defined(__MSDOS__) || defined(__WINNT__)
+# define PATHSEP '\\'
+#else /* Assume a sane filing system */
+# define PATHSEP '/'
+#endif
+
+/*----- Global variables --------------------------------------------------*/
+
+mdwopt_data mdwopt_global = {0, 0, 0, 1, 0, 0, 0, 0, 0};
+
+enum {
+ ORD_PERMUTE = 0, /* Permute the options (default) */
+ ORD_RETURN = 1, /* Return non-option things */
+ ORD_POSIX = 2, /* Do POSIX-type hacking */
+ ORD_NEGATE = 4 /* Magic negate-next-thing flag */
+};
+
+/*----- Word splitting ----------------------------------------------------*/
+
+#ifdef BUILDING_MLIB
+# include "str.h"
+# define qword str_qword
+#else
+
+/* --- @qword@ --- *
+ *
+ * Arguments: @char **pp@ = address of pointer into string
+ * @unsigned f@ = various flags
+ *
+ * Returns: Pointer to the next space-separated possibly-quoted word from
+ * the string, or null.
+ *
+ * Use: Fetches the next word from a string. If the flag
+ * @STRF_QUOTE@ is set, the `\' character acts as an escape, and
+ * single and double quotes protect whitespace.
+ */
+
+#define STRF_QUOTE 1u
+
+static char *qword(char **pp, unsigned f)
+{
+ char *p = *pp, *q, *qq;
+ int st = 0, pst = 0;
+
+ /* --- Preliminaries --- */
+
+ if (!p)
+ return (0);
+ while (isspace((unsigned char)*p))
+ p++;
+ if (!*p) {
+ *pp = 0;
+ return (0);
+ }
+
+ /* --- Main work --- */
+
+ for (q = qq = p; *q; q++) {
+ switch (st) {
+ case '\\':
+ *qq++ = *q;
+ st = pst;
+ break;
+ case '\'':
+ case '\"':
+ if (*q == st)
+ st = pst = 0;
+ else if (*q == '\\')
+ st = '\\';
+ else
+ *qq++ = *q;
+ break;
+ default:
+ if (isspace((unsigned char)*q)) {
+ do q++; while (*q && isspace((unsigned char)*q));
+ goto done;
+ } else if (!(f & STRF_QUOTE))
+ goto stdchar;
+ switch (*q) {
+ case '\\':
+ st = '\\';
+ break;
+ case '\'':
+ case '\"':
+ st = pst = *q;
+ break;
+ default:
+ stdchar:
+ *qq++ = *q;
+ break;
+ }
+ }
+ }
+
+ /* --- Finished --- */
+
+done:
+ *pp = *q ? q : 0;
+ *qq++ = 0;
+ return (p);
+}
+
+#endif
+
+/*----- Main code ---------------------------------------------------------*/
+
+/* --- @nextword@ --- *
+ *
+ * Arguments: @int argc@ = number of command line options
+ * @char *argv[]@ = pointer to command line options
+ * @mdwopt_data *data@ = pointer to persistent state
+ *
+ * Returns: Pointer to the next word to handle, or 0
+ *
+ * Use: Extracts the next word from the command line or environment
+ * variable.
+ */
+
+static char *nextword(int argc, char *const *argv, mdwopt_data *data)
+{
+ if (data->ind == -1) {
+ char *p;
+ if ((p = qword(&data->env, STRF_QUOTE)) != 0)
+ return (p);
+ data->ind = 1;
+ }
+
+ if (data->next == argc)
+ return (0);
+ return (argv[data->next++]);
+}
+
+/* --- @permute@ --- *
+ *
+ * Arguments: @char *argv[]@ = pointer to command line arguments
+ * @mdwopt_data *data@ = pointer to persistent data
+ *
+ * Returns: --
+ *
+ * Use: Moves a command line option into the right place.
+ */
+
+static void permute(char *const *argv, mdwopt_data *data)
+{
+ char **v = (char **)argv;
+ if (data->ind != -1) {
+ int i = data->next - 1;
+ char *p = v[i];
+ while (i > data->ind) {
+ v[i] = v[i - 1];
+ i--;
+ }
+ v[i] = p;
+ data->ind++;
+ }
+}
+
+/* --- @findOpt@ --- *
+ *
+ * Arguments: @int o@ = which option to search for
+ * @const char *shortopt@ = short options string to search
+ * @mdwopt_data *data@ = pointer to persistant state
+ *
+ * Returns: Pointer to rest of short options string (including magic
+ * characters)
+ *
+ * Use: Looks up a short option in the given string.
+ */
+
+static const char *findOpt(int o, const char *shortopt,
+ mdwopt_data *data)
+{
+ const char *p = shortopt;
+ for (;;) {
+ if (!*p)
+ return (0);
+
+ if (o != *p || (p[1] != '+' && data->order & ORD_NEGATE)) {
+ p++;
+ while (*p == '+')
+ p++;
+ while (*p == ':')
+ p++;
+ }
+ else
+ return (p + 1);
+ }
+}
+
+/* --- @mdwopt@ --- *
+ *
+ * Arguments: @int argc@ = number of command line arguments
+ * @char * const *argv@ = pointer to command line arguments
+ * @const char *shortopt@ = pointer to short options information
+ * @const struct option *longopts@ = pointer to long opts info
+ * @int *longind@ = where to store matched longopt
+ * @mdwopt_data *data@ = persistent state for the parser
+ * @int flags@ = various useful flags
+ *
+ * Returns: Value of option found next, or an error character, or
+ * @EOF@ for the last thing.
+ *
+ * Use: Reads options. The routine should be more-or-less compatible
+ * with standard getopts, although it provides many more
+ * features even than the standard GNU implementation.
+ *
+ * The precise manner of options parsing is determined by
+ * various flag settings, which are described below. By setting
+ * flag values appropriately, you can achieve behaviour very
+ * similar to most other getopt routines.
+ *
+ *
+ * How options parsing appears to users
+ *
+ * A command line consists of a number of `words' (which may
+ * contain spaces, according to various shell quoting
+ * conventions). A word may be an option, an argument to an
+ * option, or a non-option. An option begins with a special
+ * character, usually `%|-|%', although `%|+|%' is also used
+ * sometimes. As special exceptions, the word containing only a
+ * `%|-|%' is considered to be a non-option, since it usually
+ * represents standard input or output as a filename, and the
+ * word containing a double-dash `%|--|%' is used to mark all
+ * following words as being non-options regardless of their
+ * initial character.
+ *
+ * Traditionally, all words after the first non-option have been
+ * considered to be non-options automatically, so that options
+ * must be specified before filenames. However, this
+ * implementation can extract all the options from the command
+ * line regardless of their position. This can usually be
+ * disabled by setting one of the environment variables
+ * `%|POSIXLY_CORRECT|%' or `%|_POSIX_OPTION_ORDER|%'.
+ *
+ * There are two different styles of options: `short' and
+ * `long'.
+ *
+ * Short options are the sort which Unix has known for ages: an
+ * option is a single letter, preceded by a `%|-|%'. Short
+ * options can be joined together to save space (and possibly to
+ * make silly words): e.g., instead of giving options
+ * `%|-x -y|%', a user could write `%|-xy|%'. Some short
+ * options can have arguments, which appear after the option
+ * letter, either immediately following, or in the next `word'
+ * (so an option with an argument could be written as
+ * `%|-o foo|%' or as `%|-ofoo|%'). Note that options with
+ * optional arguments must be written in the second style.
+ *
+ * When a short option controls a flag setting, it is sometimes
+ * possible to explicitly turn the flag off, as well as turning
+ * it on, (usually to override default options). This is
+ * usually done by using a `%|+|%' instead of a `%|-|%' to
+ * introduce the option.
+ *
+ * Long options, as popularized by the GNU utilities, are given
+ * long-ish memorable names, preceded by a double-dash `%|--|%'.
+ * Since their names are more than a single character, long
+ * options can't be combined in the same way as short options.
+ * Arguments to long options may be given either in the same
+ * `word', separated from the option name by an equals sign, or
+ * in the following `word'.
+ *
+ * Long option names can be abbreviated if necessary, as long
+ * as the abbreviation is unique. This means that options can
+ * have sensible and memorable names but still not require much
+ * typing from an experienced user.
+ *
+ * Like short options, long options can control flag settings.
+ * The options to manipulate these settings come in pairs: an
+ * option of the form `%|--set-flag|%' might set the flag, while
+ * an option of the form `%|--no-set-flag|%' might clear it.
+ *
+ * It is usual for applications to provide both short and long
+ * options with identical behaviour. Some applications with
+ * lots of options may only provide long options (although they
+ * will often be only two or three characters long). In this
+ * case, long options can be preceded with a single `%|-|%'
+ * character, and negated by a `%|+|%' character.
+ *
+ * Finally, some (older) programs accept arguments of the form
+ * `%%@.{"-"<number>}%%', to set some numerical parameter,
+ * typically a line count of some kind.
+ *
+ *
+ * How programs parse options
+ *
+ * An application parses its options by calling mdwopt
+ * repeatedly. Each time it is called, mdwopt returns a value
+ * describing the option just read, and stores information about
+ * the option in a data block. The value %$-1$% is returned
+ * when there are no more options to be read. The `%|?|%'
+ * character is returned when an error is encountered.
+ *
+ * Before starting to parse options, the value @data->ind@ must
+ * be set to 0 or 1. The value of @data->err@ can also be set,
+ * to choose whether errors are reported by mdwopt.
+ *
+ * The program's `@argc@' and `@argv@' arguments are passed to
+ * the options parser, so that it can read the command line. A
+ * flags word is also passed, allowing the program fine control
+ * over parsing. The flags are described above.
+ *
+ * Short options are described by a string, which once upon a
+ * time just contained the permitted option characters. Now the
+ * options string begins with a collection of flag characters,
+ * and various flag characters can be put after options
+ * characters to change their properties.
+ *
+ * If the first character of the short options string is
+ * `%|+|%', `%|-|%' or `%|!|%', the order in which options are
+ * read is modified, as follows:
+ *
+ * `%|+|%' forces the POSIX order to be used. As soon as a non-
+ * option is found, mdwopt returns %$-1$%.
+ *
+ * `%|-|%' makes mdwopt treat non-options as being `special'
+ * sorts of option. When a non-option word is found, the
+ * value 0 is returned, and the actual text of the word
+ * is stored as being the option's argument.
+ *
+ * `%|!|%' forces the default order to be used. The entire
+ * command line is scanned for options, which are
+ * returned in order. However, during this process,
+ * the options are moved in the @argv@ array, so that
+ * they appear before the non- options.
+ *
+ * A `%|:|%' character may be placed after the ordering flag (or
+ * at the very beginning if no ordering flag is given) which
+ * indicates that the character `%|:|%', rather than `%|?|%',
+ * should be returned if a missing argument error is detected.
+ *
+ * Each option in the string can be followed by a `%|+|%' sign,
+ * indicating that it can be negated, a `%|:|%' sign indicating
+ * that it requires an argument, or a `%|::|%' string,
+ * indicating an optional argument. Both `%|+|%' and `%|:|%' or
+ * `%|::|%' may be given, although the `%|+|%' must come first.
+ *
+ * If an option is found, the option character is returned to
+ * the caller. A pointer to an argument is stored in
+ * @data->arg@, or @NULL@ is stored if there was no argument.
+ * If a negated option was found, the option character is
+ * returned ORred with @OPTF_NEGATED@ (bit 8 set).
+ *
+ * Long options are described in a table. Each entry in the
+ * table is of type @struct option@, and the table is terminated
+ * by an entry whose @name@ field is null. Each option has
+ * a flags word which, due to historical reasons, is called
+ * @has_arg@. This describes various properties of the option,
+ * such as what sort of argument it takes, and whether it can
+ * be negated.
+ *
+ * When mdwopt finds a long option, it looks the name up in the
+ * table. The index of the matching entry is stored in the
+ * @longind@ variable, passed to mdwopt (unless @longind@ is 0):
+ * a value of %$-1$% indicates that no long option was
+ * found. The behaviour is then dependent on the values in the
+ * table entry. If @flag@ is nonzero, it points to an integer
+ * to be modified by mdwopt. Usually the value in the @val@
+ * field is simply stored in the @flag@ variable. If the flag
+ * @OPTF_SWITCH@ is set, however, the value is combined with
+ * the existing value of the flags using a bitwise OR. If
+ * @OPTF_NEGATE@ is set, then the flag bit will be cleared if a
+ * matching negated long option is found. The value 0 is
+ * returned.
+ *
+ * If @flag@ is zero, the value in @val@ is returned by mdwopt,
+ * possibly with bit 8 set if the option was negated.
+ *
+ * Arguments for long options are stored in @data->arg@, as
+ * before.
+ *
+ * Numeric options, if enabled, cause the value `%|#|%' to be
+ * returned, and the numeric value to be stored in @data->opt@.
+ *
+ * If the flag @OPTF_ENVVAR@ is set on entry, options will be
+ * extracted from an environment variable whose name is built by
+ * capitalizing all the letters of the program's name. (This
+ * allows a user to have different default settings for a
+ * program, by calling it through different symbolic links.)
+ */
+
+int mdwopt(int argc, char *const *argv,
+ const char *shortopt,
+ const struct option *longopts, int *longind,
+ mdwopt_data *data, int flags)
+{
+ /* --- Local variables --- */
+
+ char *p, *q, *r;
+ char *prefix;
+ int i;
+ char noarg = '?';
+
+ /* --- Sort out our data --- */
+
+ if (!data)
+ data = &mdwopt_global;
+
+ /* --- See if this is the first time --- */
+
+ if (data->ind == 0 || (data->ind == 1 && ~flags & OPTF_NOPROGNAME)) {
+
+ /* --- Sort out default returning order --- */
+
+ if (getenv("_POSIX_OPTION_ORDER") ||
+ getenv("POSIXLY_CORRECT"))
+ data->order = ORD_POSIX;
+ else
+ data->order = ORD_PERMUTE;
+
+ /* --- Now see what the caller actually wants --- */
+
+ switch (shortopt[0]) {
+ case '-':
+ data->order = ORD_RETURN;
+ break;
+ case '+':
+ data->order = ORD_POSIX;
+ break;
+ case '!':
+ data->order = ORD_PERMUTE;
+ break;
+ }
+
+ /* --- Now decide on the program's name --- */
+
+ if (~flags & OPTF_NOPROGNAME) {
+ p = q = (char *)argv[0];
+ while (*p) {
+ if (*p++ == PATHSEP)
+ q = p;
+ }
+ data->prog = q;
+
+ data->ind = data->next = 1;
+ data->list = 0;
+
+ /* --- See about environment variables --- *
+ *
+ * Be careful. The program may be setuid, and an attacker might have
+ * given us a long name in @argv[0]@. If the name is very long, don't
+ * support this option.
+ */
+
+ if (flags & OPTF_ENVVAR && strlen(data->prog) < 48) {
+
+ char buf[64];
+
+ /* --- For RISC OS, support a different format --- *
+ *
+ * Acorn's RISC OS tends to put settings in variables named
+ * `App$Options' rather than `APP'. Under RISC OS, I'll support
+ * both methods, just to avoid confuddlement.
+ */
+
+#ifdef __riscos
+ sprintf(buf, "%s$Options", data->prog);
+ p = getenv(buf);
+ if (!p) {
+#endif
+
+ p = buf;
+ q = data->prog;
+ while (*q)
+ *p++ = toupper(*q++);
+ *p++ = 0;
+ p = getenv(buf);
+
+#ifdef __riscos
+ }
+#endif
+
+ /* --- Copy the options string into a buffer --- */
+
+ if (p) {
+ q = malloc(strlen(p) + 1);
+ if (!q) {
+ fprintf(stderr,
+ "%s: Not enough memory to read settings in "
+ "environment variable\n",
+ data->prog);
+ } else {
+ strcpy(q, p);
+ data->ind = -1;
+ data->env = data->estart = q;
+ }
+ }
+
+ }
+ }
+ else
+ data->ind = data->next = 0;
+ }
+
+ /* --- Do some initial bodgery --- *
+ *
+ * The @shortopt@ string can have some interesting characters at the
+ * beginning. We'll skip past them.
+ */
+
+ switch (shortopt[0]) {
+ case '+':
+ case '-':
+ case '!':
+ shortopt++;
+ break;
+ }
+
+ if (shortopt[0] == ':') {
+ noarg = shortopt[0];
+ shortopt++;
+ }
+
+ if (longind)
+ *longind = -1;
+ data->opt = -1;
+ data->arg = 0;
+
+ /* --- Now go off and search for an option --- */
+
+ if (!data->list || !*data->list) {
+ data->order &= 3; /* Clear negation flag */
+
+ /* --- Now we need to find the next option --- *
+ *
+ * Exactly how we do this depends on the settings of the order variable.
+ * We identify options as being things starting with `%|-|%', and which
+ * aren't equal to `%|-|%' or `%|--|%'. We'll look for options until:
+ *
+ * * We find something which isn't an option AND @order == ORD_POSIX@
+ * * We find a `%|--|%'
+ * * We reach the end of the list
+ *
+ * There are some added little wrinkles, which we'll meet as we go.
+ */
+
+ for (;;) {
+ p = nextword(argc, argv, data);
+ if (!p)
+ return (EOF);
+
+ /* --- See if we've found an option --- */
+
+ if ((p[0] == '-' || (p[0] == '+' && flags & OPTF_NEGATION)) &&
+ p[1] != 0) {
+ if (strcmp(p, "--") == 0) {
+ permute(argv, data);
+ return (EOF);
+ }
+ break;
+ }
+
+ /* --- Figure out how to proceed --- */
+
+ switch (data->order & 3) {
+ case ORD_POSIX:
+ return (EOF);
+ break;
+ case ORD_PERMUTE:
+ break;
+ case ORD_RETURN:
+ permute(argv, data);
+ data->arg = p;
+ return (0);
+ }
+ }
+
+ /* --- We found an option --- */
+
+ permute(argv, data);
+
+ /* --- Check for a numeric option --- *
+ *
+ * We only check the first character (or the second if the first is a
+ * sign). This ought to be enough.
+ */
+
+ if (flags & OPTF_NUMBERS && (p[0] == '-' || flags & OPTF_NEGNUMBER)) {
+ if (((p[1] == '+' || p[1] == '-') && isdigit((unsigned char)p[2])) ||
+ isdigit((unsigned char)p[1])) {
+ data->opt = strtol(p + 1, &data->arg, 10);
+ while (isspace((unsigned char)data->arg[0]))
+ data->arg++;
+ if (!data->arg[0])
+ data->arg = 0;
+ return (p[0] == '-' ? '#' : '#' | OPTF_NEGATED);
+ }
+ }
+
+ /* --- Check for a long option --- */
+
+ if (p[0] == '+')
+ data->order |= ORD_NEGATE;
+
+ if (((p[0] == '-' && p[1] == '-') ||
+ (flags & OPTF_NOSHORTS && !findOpt(p[1], shortopt, data))) &&
+ (~flags & OPTF_NOLONGS))
+ {
+ int match = -1;
+
+ if (p[0] == '+') {
+ data->order |= ORD_NEGATE;
+ p++;
+ prefix = "+";
+ } else if (p[1] == '-') {
+ if ((flags & OPTF_NEGATION) && strncmp(p + 2, "no-", 3) == 0) {
+ p += 5;
+ prefix = "--no-";
+ data->order |= ORD_NEGATE;
+ } else {
+ p += 2;
+ prefix = "--";
+ }
+ } else {
+ if ((flags & OPTF_NEGATION) && strncmp(p + 1, "no-", 3) == 0) {
+ p += 4;
+ prefix = "-no-";
+ data->order |= ORD_NEGATE;
+ } else {
+ p++;
+ prefix = "-";
+ }
+ }
+
+ for (i = 0; longopts[i].name; i++) {
+ if ((data->order & ORD_NEGATE) &&
+ (~longopts[i].has_arg & OPTF_NEGATE))
+ continue;
+
+ r = (char *) longopts[i].name;
+ q = p;
+ for (;;) {
+ if (*q == 0 || *q == '=') {
+ if (*r == 0) {
+ match = i;
+ goto botched;
+ }
+ if (match == -1) {
+ match = i;
+ break;
+ } else {
+ match = -1;
+ goto botched;
+ }
+ }
+ else if (*q != *r)
+ break;
+ q++, r++;
+ }
+ }
+
+ botched:
+ if (match == -1) {
+ if (data->err) {
+ fprintf(stderr, "%s: unrecognized option `%s%s'\n",
+ data->prog,
+ prefix, p);
+ }
+ return ('?');
+ }
+
+ if (longind)
+ *longind = match;
+
+ /* --- Handle argument behaviour --- */
+
+ while (*p != 0 && *p != '=')
+ p++;
+ p = (*p ? p + 1 : 0);
+ q = (char *) longopts[match].name;
+
+ switch (longopts[match].has_arg & OPTF_ARG) {
+ case OPTF_NOARG:
+ if (p) {
+ if (data->err) {
+ fprintf(stderr,
+ "%s: option `%s%s' does not accept arguments\n",
+ data->prog,
+ prefix, q);
+ }
+ return ('?');
+ }
+ break;
+
+ case OPTF_ARGREQ:
+ if (!p) {
+ p = nextword(argc, argv, data);
+
+ if (!p) {
+ if (data->err) {
+ fprintf(stderr, "%s: option `%s%s' requires an argument\n",
+ data->prog,
+ prefix, q);
+ }
+ return (noarg);
+ }
+
+ permute(argv, data);
+ }
+ break;
+
+ case OPTF_ARGOPT:
+ /* Who cares? */
+ break;
+ }
+ data->arg = p;
+
+ /* --- Do correct things now we have a match --- */
+
+ if (longopts[match].flag) {
+ if (longopts[match].has_arg & OPTF_SWITCH) {
+ if (data->order & ORD_NEGATE)
+ *longopts[match].flag &= ~longopts[match].val;
+ else
+ *longopts[match].flag |= longopts[match].val;
+ } else {
+ if (data->order & ORD_NEGATE)
+ *longopts[match].flag = 0;
+ else
+ *longopts[match].flag = longopts[match].val;
+ }
+ return (0);
+ } else {
+ if (data->order & ORD_NEGATE)
+ return (longopts[match].val | OPTF_NEGATED);
+ else
+ return (longopts[match].val);
+ }
+ }
+
+ /* --- Do short options things --- */
+
+ else {
+ if (p[0] == '+')
+ data->order |= ORD_NEGATE;
+ data->list = p + 1;
+ }
+ }
+
+ /* --- Now process the short options --- */
+
+ i = *data->list++;
+ data->opt = i;
+
+ p = (char *) findOpt(i, shortopt, data);
+ if (!p) {
+ if (data->err) {
+ fprintf(stderr, "%s: unknown option `%c%c'\n",
+ data->prog,
+ data->order & ORD_NEGATE ? '+' : '-',
+ i);
+ }
+ return ('?');
+ }
+
+ data->opt = i;
+
+ /* --- Sort out an argument, if we expect one --- */
+
+ if (p[0] == ':') {
+ q = (data->list[0] ? data->list : 0);
+ data->list = 0;
+ if (p[1] != ':' && !q) {
+
+ /* --- Same code as before --- */
+
+ q = nextword(argc, argv, data);
+ if (!q) {
+ if (data->err) {
+ fprintf(stderr, "%s: option `%c%c' requires an argument\n",
+ data->prog,
+ data->order & ORD_NEGATE ? '+' : '-',
+ i);
+ }
+ return (noarg);
+ }
+ permute(argv, data);
+ }
+
+ data->arg = q;
+ }
+ return ((data->order & ORD_NEGATE) ? i | OPTF_NEGATED : i);
+}
+
+/*----- That's all, folks -------------------------------------------------*/
~mdw / runlisp / blobdiff