/* $OpenBSD: scanopt.c,v 1.5 2015/12/11 00:08:43 mmcc Exp $ */

/* flex - tool to generate fast lexical analyzers */

/*  Copyright (c) 1990 The Regents of the University of California. */

/*  All rights reserved. */

/*  This code is derived from software contributed to Berkeley by */

/*  Vern Paxson. */

/*  The United States Government has rights in this work pursuant */

/*  to contract no. DE-AC03-76SF00098 between the United States */

/*  Department of Energy and the University of California. */

/*  This file is part of flex. */

/*  Redistribution and use in source and binary forms, with or without */

/*  modification, are permitted provided that the following conditions */

/*  are met: */

/*  1. Redistributions of source code must retain the above copyright */

/*     notice, this list of conditions and the following disclaimer. */

/*  2. Redistributions in binary form must reproduce the above copyright */

/*     notice, this list of conditions and the following disclaimer in the */

/*     documentation and/or other materials provided with the distribution. */

/*  Neither the name of the University nor the names of its contributors */

/*  may be used to endorse or promote products derived from this software */

/*  without specific prior written permission. */

/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */

/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */

/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */

/*  PURPOSE. */

#include "flexdef.h"

#include "scanopt.h"

/* Internal structures */

#ifdef HAVE_STRCASECMP

#define STRCASECMP(a,b) strcasecmp(a,b)

#else

static int STRCASECMP PROTO ((const char *, const char *));

static int STRCASECMP (a, b)

     const char *a;

     const char *b;

{

}

#endif

#define ARG_NONE 0x01

#define ARG_REQ  0x02

#define ARG_OPT  0x04

#define IS_LONG  0x08

struct _aux {

	int     flags;		/* The above hex flags. */

	int     namelen;	/* Length of the actual option word, e.g., "--file[=foo]" is 4 */

	int     printlen;	/* Length of entire string, e.g., "--file[=foo]" is 12 */

};

struct _scanopt_t {

	const optspec_t *options;	/* List of options. */

	struct _aux *aux;	/* Auxiliary data about options. */

	int     optc;		/* Number of options. */

	int     argc;		/* Number of args. */

	char  **argv;		/* Array of strings. */

	int     index;		/* Used as: argv[index][subscript]. */

	int     subscript;

	char    no_err_msg;	/* If true, do not print errors. */

	char    has_long;

	char    has_short;

};

/* Accessor functions. These WOULD be one-liners, but portability calls. */

static const char *NAME PROTO ((struct _scanopt_t *, int));

static int PRINTLEN PROTO ((struct _scanopt_t *, int));

static int RVAL PROTO ((struct _scanopt_t *, int));

static int FLAGS PROTO ((struct _scanopt_t *, int));

static const char *DESC PROTO ((struct _scanopt_t *, int));

static int scanopt_err PROTO ((struct _scanopt_t *, int, int, int));

static int matchlongopt PROTO ((char *, char **, int *, char **, int *));

static int find_opt

PROTO ((struct _scanopt_t *, int, char *, int, int *, int *opt_offset));

static const char *NAME (s, i)

     struct _scanopt_t *s;

     int     i;

{

		((s->aux[i].flags & IS_LONG) ? 2 : 1);

}

static int PRINTLEN (s, i)

     struct _scanopt_t *s;

     int     i;

{

}

static int RVAL (s, i)

     struct _scanopt_t *s;

     int     i;

{

}

static int FLAGS (s, i)

     struct _scanopt_t *s;

     int     i;

{

}

static const char *DESC (s, i)

     struct _scanopt_t *s;

     int     i;

{

}

#ifndef NO_SCANOPT_USAGE

static int get_cols PROTO ((void));

static int get_cols ()

{

	char   *env;

#ifdef HAVE_NCURSES_H

	initscr ();

	endwin ();

	if (COLS > 0)

		return COLS;

#endif

}

#endif

/* Macro to check for NULL before assigning a value. */

#define SAFE_ASSIGN(ptr,val) \

    do{                      \

        if((ptr)!=NULL)      \

            *(ptr) = val;    \

    }while(0)

/* Macro to assure we reset subscript whenever we adjust s->index.*/

#define INC_INDEX(s,n)     \

    do{                    \

       (s)->index += (n);  \

       (s)->subscript= 0;  \

    }while(0)

scanopt_t *scanopt_init (options, argc, argv, flags)

     const optspec_t *options;

     int     argc;

     char  **argv;

     int     flags;

	int     i;

	struct _scanopt_t *s;

	/* Determine option count. (Find entry with all zeros). */

	       || options[s->optc].r_val || options[s->optc].desc)

	/* Build auxiliary data */

		const u_char *p, *pname;

		const struct optspec_t *opt;

		struct _aux *aux;

		}

		else {

		}

			/* detect required arg */

			    || !(aux->flags & IS_LONG)) {

			}

			/* detect optional arg. This overrides required arg. */

			}

		}

	}

}

#ifndef NO_SCANOPT_USAGE

/* these structs are for scanopt_usage(). */

struct usg_elem {

	int     idx;

	struct usg_elem *next;

	struct usg_elem *alias;

};

typedef struct usg_elem usg_elem;

/* Prints a usage message based on contents of optlist.

 * Parameters:

 *   scanner  - The scanner, already initialized with scanopt_init().

 *   fp       - The file stream to write to.

 *   usage    - Text to be prepended to option list.

 * Return:  Always returns 0 (zero).

 * The output looks something like this:

[indent][option, alias1, alias2...][indent][description line1

                                            description line2...]

 */

int     scanopt_usage (scanner, fp, usage)

     scanopt_t *scanner;

     FILE   *fp;

     const char *usage;

{

	struct _scanopt_t *s;

	usg_elem *store;	/* array of preallocated elements. */

	usg_elem *ue;

	int     maxlen[2];

	}

	else {

		/* Find the basename of argv[0] */

		const char *p;

	}

	/* Sort by r_val and string. Yes, this is O(n*n), but n is small. */

		/* grab the next preallocate node. */

		/* insert into list. */

		else {

				    RVAL (s, ue->idx)) {

					/* push onto the alias list. */

				}

				    &&

				    STRCASECMP (NAME (s, (*ue_curr)->idx),

						NAME (s, ue->idx)) > 0) {

				}

			}

		}

	}

#if 0

	if (1) {

		printf ("ORIGINAL:\n");

		for (i = 0; i < s->optc; i++)

			printf ("%2d: %s\n", i, NAME (s, i));

		printf ("SORTED:\n");

		ue = byr_val;

		while (ue) {

			usg_elem *ue2;

			printf ("%2d: %s\n", ue->idx, NAME (s, ue->idx));

			for (ue2 = ue->alias; ue2; ue2 = ue2->next)

				printf ("  +---> %2d: %s\n", ue2->idx,

					NAME (s, ue2->idx));

			ue = ue->next;

		}

	}

#endif

	/* Now build each row of output. */

	/* first pass calculate how much room we need. */

		usg_elem *ap;

#define CALC_LEN(i) do {\

          if(FLAGS(s,i) & IS_LONG) \

              len +=  (nlong++||nshort) ? 2+PRINTLEN(s,i) : PRINTLEN(s,i);\

          else\

              len +=  (nshort++||nlong)? 2+PRINTLEN(s,i) : PRINTLEN(s,i);\

        }while(0)

		/* do short aliases first. */

		}

		/* repeat the above loop, this time for long aliases. */

		}

		/* It's much easier to calculate length for description column! */

	}

	/* Determine how much room we have, and how much we will allocate to each col.

	 * Do not address pathological cases. Output will just be ugly. */

		/* col 0 gets whatever it wants. we'll wrap the desc col. */

	}

#define PRINT_SPACES(fp,n)\

    do{\

        int _n;\

        _n=(n);\

        while(_n-- > 0)\

            fputc(' ',(fp));\

    }while(0)

	/* Second pass (same as above loop), this time we print. */

	/* Sloppy hack: We iterate twice. The first time we print short and long options.

	   The second time we print those lines that have ONLY long options. */

			usg_elem *ap;

/* TODO: get has_short schtick to work */

				}

			}

			    (print_run == 2 && has_short))

				continue;

/* Print, adding a ", " between aliases. */

#define PRINT_IT(i) do{\

                  if(nwords++)\

                      nchars+=fprintf(fp,", ");\

                  nchars+=fprintf(fp,"%s",s->options[i].opt_fmt);\

            }while(0)

			/* print short aliases first. */

			}

			/* repeat the above loop, this time for long aliases. */

			}

			/* pad to desccol */

			/* Print description, wrapped to maxlen[1] columns. */

			if (1) {

				const char *pstart;

				while (1) {

					       && *p != '\n') {

								p;

					}

							 pstart);

					}

							 pstart);

					}

					else {	/* we hit the edge of the screen. wrap at space if possible. */

								 "%.*s\n",

								 (int)(lastws - pstart),

								 pstart);

								lastws + 1;

						}

						else {

								 "%.*s\n",

								 n,

								 pstart);

						}

						continue;

					}

				}

			}

		}

	}			/* end while */

}

#endif /* no scanopt_usage */

static int scanopt_err (s, opt_offset, is_short, err)

     struct _scanopt_t *s;

     int     opt_offset;

     int     is_short;

     int     err;

{

	char    optchar[2];

					s->argv[s->index][s->subscript];

			}

			else {

			}

		}

		case SCANOPT_ERR_ARG_NOT_ALLOWED:

				 _

				 ("option `%s' doesn't allow an argument\n"),

				 optname);

		case SCANOPT_ERR_ARG_NOT_FOUND:

				 _("option `%s' requires an argument\n"),

				 optname);

		case SCANOPT_ERR_OPT_AMBIGUOUS:

				 optname);

		case SCANOPT_ERR_OPT_UNRECOGNIZED:

				 optname);

		default:

			break;

		}

	}

}

/* Internal. Match str against the regex  ^--([^=]+)(=(.*))?

 * return 1 if *looks* like a long option.

 * 'str' is the only input argument, the rest of the arguments are output only.

 * optname will point to str + 2

 *

 */

static int matchlongopt (str, optname, optlen, arg, arglen)

     char   *str;

     char  **optname;

     int    *optlen;

     char  **arg;

     int    *arglen;

	char   *p;

	/* Match regex /--./   */

	/* find the end of optname */

		/* an option with no '=...' part. */

	/* We saw an '=' char. The rest of p is the arg. */

}

/* Internal. Look up long or short option by name.

 * Long options must match a non-ambiguous prefix, or exact match.

 * Short options must be exact.

 * Return boolean true if found and no error.

 * Error stored in err_code or zero if no error. */

static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)

     struct _scanopt_t *s;

     int     lookup_long;

     char   *optstart;

     int     len;

     int    *err_code;

     int    *opt_offset;

		char   *optname;

			(char *) (s->options[i].opt_fmt +

				  (lookup_long ? 2 : 1));

				/* exact match overrides all. */

				}

				/* ambiguity is ok between aliases. */

				    && lastr_val ==

			}

		}

			}

		}

	}

	}

	}

}

int     scanopt (svoid, arg, optindex)

     scanopt_t *svoid;

     char  **arg;

     int    *optindex;

	const optspec_t *optp;

	struct _scanopt_t *s;

	struct _aux *auxp;

	int     is_short;

	/* Normalize return-parameters. */

	/* pstart always points to the start of our current scan. */

		/* test for exact match of "--" */

		}

		/* Match an opt. */

		    (pstart, &optname, &namelen, &optarg, &arglen)) {

			/* it LOOKS like an opt, but is it one?! */

			    (s, 1, optname, namelen, &errcode,

			     &opt_offset)) {

			}

			/* We handle this below. */

			/* Check for short opt.  */

		}

			/* Pass through to below. */

		}

		else {

			/* It's not an option. We're done. */

		}

	}

	/* We have to re-check the subscript status because it

	 * may have changed above. */

		/* we are somewhere in a run of short opts,

		 * e.g., at the 'z' in `tar -xzf` */

		    (s, 0, pstart, namelen, &errcode, &opt_offset)) {

		}

		}

		else

	}

	/* At this point, we have a long or short option matched at opt_offset into

	 * the s->options array (and corresponding aux array).

	 * A trailing argument is in {optarg,arglen}, if any.

	 */

	/* Look ahead in argv[] to see if there is something

	 * that we can use as an argument (if needed). */

		&& strcmp ("--", s->argv[s->index + 1]) != 0;

	/* case: no args allowed */

				     SCANOPT_ERR_ARG_NOT_ALLOWED);

		}

		else

	}

	/* case: required */

					    SCANOPT_ERR_ARG_NOT_FOUND);

			/* Let the next argv element become the argument. */

		}

		else {

		}

	}

	/* case: optional */

	}

	/* Should not reach here. */

}

int     scanopt_destroy (svoid)

     scanopt_t *svoid;

	struct _scanopt_t *s;

	}

}