sassc 0.0.1

data/ext/libsass/parser.hpp

@@ -0,0 +1,264 @@
+#define SASS_PARSER
+
+#include <vector>
+#include <map>
+
+#ifndef SASS_PRELEXER
+#include "prelexer.hpp"
+#endif
+
+#ifndef SASS_TOKEN
+#include "token.hpp"
+#endif
+
+#ifndef SASS_CONTEXT
+#include "context.hpp"
+#endif
+
+#ifndef SASS_AST
+#include "ast.hpp"
+#endif
+
+#ifndef SASS_POSITION
+#include "position.hpp"
+#endif
+
+#include <iostream>
+
+struct Selector_Lookahead {
+  const char* found;
+  bool has_interpolants;
+};
+
+namespace Sass {
+  using std::string;
+  using std::vector;
+  using std::map;
+  using namespace Prelexer;
+
+  class Parser {
+  private:
+    void add_single_file (Import* imp, string import_path);
+  public:
+    class AST_Node;
+
+    enum Syntactic_Context { nothing, mixin_def, function_def };
+
+    Context& ctx;
+    vector<Syntactic_Context> stack;
+    const char* source;
+    const char* position;
+    const char* end;
+    string path;
+    size_t column;
+    Position source_position;
+
+
+    Token lexed;
+    bool dequote;
+
+    Parser(Context& ctx, string path, Position source_position)
+    : ctx(ctx), stack(vector<Syntactic_Context>()),
+      source(0), position(0), end(0), path(path), column(1), source_position(source_position)
+    { dequote = false; stack.push_back(nothing); }
+
+    static Parser from_string(string src, Context& ctx, string path = "", Position source_position = Position());
+    static Parser from_c_str(const char* src, Context& ctx, string path = "", Position source_position = Position());
+    static Parser from_token(Token t, Context& ctx, string path = "", Position source_position = Position());
+
+#ifdef __clang__
+
+    // lex and peak uses the template parameter to branch on the action, which
+    // triggers clangs tautological comparison on the single-comparison
+    // branches. This is not a bug, just a merging of behaviour into
+    // one function
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+#endif
+
+    template <prelexer mx>
+    const char* peek(const char* start = 0)
+    {
+      if (!start) start = position;
+      const char* after_whitespace;
+      if (mx == block_comment) {
+        after_whitespace = // start;
+          zero_plus< alternatives<spaces, line_comment> >(start);
+      }
+      else if (/*mx == ancestor_of ||*/ mx == no_spaces) {
+        after_whitespace = position;
+      }
+      else if (mx == spaces || mx == ancestor_of) {
+        after_whitespace = mx(start);
+        if (after_whitespace) {
+          return after_whitespace;
+        }
+        else {
+          return 0;
+        }
+      }
+      else if (mx == optional_spaces) {
+        after_whitespace = optional_spaces(start);
+      }
+      else if (mx == line_comment_prefix || mx == block_comment_prefix) {
+        after_whitespace = position;
+      }
+      else {
+        after_whitespace = spaces_and_comments(start);
+      }
+      const char* after_token = mx(after_whitespace);
+      if (after_token) {
+        return after_token;
+      }
+      else {
+        return 0;
+      }
+    }
+
+    template <prelexer mx>
+    const char* lex()
+    {
+      const char* after_whitespace;
+      if (mx == block_comment) {
+        after_whitespace = // position;
+          zero_plus< alternatives<spaces, line_comment> >(position);
+      }
+      else if (mx == url) {
+        after_whitespace = position;
+      }
+      else if (mx == ancestor_of || mx == no_spaces) {
+        after_whitespace = position;
+      }
+      else if (mx == spaces) {
+        after_whitespace = spaces(position);
+        if (after_whitespace) {
+          source_position.line += count_interval<'\n'>(position, after_whitespace);
+          lexed = Token(position, after_whitespace);
+          return position = after_whitespace;
+        }
+        else {
+          return 0;
+        }
+      }
+      else if (mx == optional_spaces) {
+        after_whitespace = optional_spaces(position);
+      }
+      else {
+        after_whitespace = spaces_and_comments(position);
+      }
+      const char* after_token = mx(after_whitespace);
+      if (after_token) {
+        size_t previous_line = source_position.line;
+        source_position.line += count_interval<'\n'>(position, after_token);
+
+        size_t whitespace = 0;
+        const char* ptr = after_whitespace - 1;
+        while (ptr >= position) {
+          if (*ptr == '\n')
+            break;
+          whitespace++;
+          ptr--;
+        }
+        if (previous_line != source_position.line) {
+          column = 1;
+        }
+
+        source_position.column = column + whitespace;
+        column += after_token - after_whitespace + whitespace;
+        lexed = Token(after_whitespace, after_token);
+
+        return position = after_token;
+      }
+      else {
+        return 0;
+      }
+    }
+
+#ifdef __clang__
+
+#pragma clang diagnostic pop
+
+#endif
+
+    void error(string msg, Position pos = Position());
+    void read_bom();
+
+    Block* parse();
+    Import* parse_import();
+    Definition* parse_definition();
+    Parameters* parse_parameters();
+    Parameter* parse_parameter();
+    Mixin_Call* parse_mixin_call();
+    Arguments* parse_arguments();
+    Argument* parse_argument();
+    Assignment* parse_assignment();
+    Propset* parse_propset();
+    Ruleset* parse_ruleset(Selector_Lookahead lookahead);
+    Selector_Schema* parse_selector_schema(const char* end_of_selector);
+    Selector_List* parse_selector_group();
+    Complex_Selector* parse_selector_combination();
+    Compound_Selector* parse_simple_selector_sequence();
+    Simple_Selector* parse_simple_selector();
+    Wrapped_Selector* parse_negated_selector();
+    Simple_Selector* parse_pseudo_selector();
+    Attribute_Selector* parse_attribute_selector();
+    Block* parse_block();
+    Declaration* parse_declaration();
+    Expression* parse_map_value();
+    Expression* parse_map();
+    Expression* parse_list();
+    Expression* parse_comma_list();
+    Expression* parse_space_list();
+    Expression* parse_disjunction();
+    Expression* parse_conjunction();
+    Expression* parse_relation();
+    Expression* parse_expression();
+    Expression* parse_term();
+    Expression* parse_factor();
+    Expression* parse_value();
+    Function_Call* parse_calc_function();
+    Function_Call* parse_function_call();
+    Function_Call_Schema* parse_function_call_schema();
+    String* parse_interpolated_chunk(Token);
+    String* parse_string();
+    String_Constant* parse_static_value();
+    String* parse_ie_property();
+    String* parse_ie_keyword_arg();
+    String_Schema* parse_value_schema();
+    String* parse_identifier_schema();
+    String_Schema* parse_url_schema();
+    If* parse_if_directive(bool else_if = false);
+    For* parse_for_directive();
+    Each* parse_each_directive();
+    While* parse_while_directive();
+    Media_Block* parse_media_block();
+    List* parse_media_queries();
+    Media_Query* parse_media_query();
+    Media_Query_Expression* parse_media_expression();
+    Feature_Block* parse_feature_block();
+    Feature_Query* parse_feature_queries();
+    Feature_Query_Condition* parse_feature_query();
+    Feature_Query_Condition* parse_feature_query_in_parens();
+    Feature_Query_Condition* parse_supports_negation();
+    Feature_Query_Condition* parse_supports_conjunction();
+    Feature_Query_Condition* parse_supports_disjunction();
+    Feature_Query_Condition* parse_supports_declaration();
+    At_Rule* parse_at_rule();
+    Warning* parse_warning();
+    Error* parse_error();
+    Debug* parse_debug();
+
+    Selector_Lookahead lookahead_for_selector(const char* start = 0);
+    Selector_Lookahead lookahead_for_extension_target(const char* start = 0);
+
+    Expression* fold_operands(Expression* base, vector<Expression*>& operands, Binary_Expression::Type op);
+    Expression* fold_operands(Expression* base, vector<Expression*>& operands, vector<Binary_Expression::Type>& ops);
+
+    void throw_syntax_error(string message, size_t ln = 0);
+    void throw_read_error(string message, size_t ln = 0);
+  };
+
+  size_t check_bom_chars(const char* src, const char *end, const unsigned char* bom, size_t len);
+}

data/ext/libsass/paths.hpp

@@ -0,0 +1,69 @@
+#include <vector>
+#include <iostream>
+#include <string>
+#include <sstream>
+
+using namespace std;
+
+template<typename T>
+string vector_to_string(vector<T> v)
+{
+  stringstream buffer;
+  buffer << "[";
+
+  if (!v.empty())
+  {  buffer << v[0]; }
+  else
+  { buffer << "]"; }
+
+  if (v.size() == 1)
+  { buffer << "]"; }
+  else
+  {
+    for (size_t i = 1, S = v.size(); i < S; ++i) buffer << ", " << v[i];
+    buffer << "]";
+  }
+
+  return buffer.str();
+}
+
+namespace Sass {
+
+  using namespace std;
+
+  template<typename T>
+  vector<vector<T> > paths(vector<vector<T> > strata, size_t from_end = 0)
+  {
+    if (strata.empty()) {
+      return vector<vector<T> >();
+    }
+
+    size_t end = strata.size() - from_end;
+    if (end <= 1) {
+      vector<vector<T> > starting_points;
+      starting_points.reserve(strata[0].size());
+      for (size_t i = 0, S = strata[0].size(); i < S; ++i) {
+        vector<T> starting_point;
+        starting_point.push_back(strata[0][i]);
+        starting_points.push_back(starting_point);
+      }
+      return starting_points;
+    }
+
+    vector<vector<T> > up_to_here = paths(strata, from_end + 1);
+    vector<T>          here       = strata[end-1];
+
+    vector<vector<T> > branches;
+    branches.reserve(up_to_here.size() * here.size());
+    for (size_t i = 0, S1 = up_to_here.size(); i < S1; ++i) {
+      for (size_t j = 0, S2 = here.size(); j < S2; ++j) {
+        vector<T> branch = up_to_here[i];
+        branch.push_back(here[j]);
+        branches.push_back(branch);
+      }
+    }
+
+    return branches;
+  }
+
+}

data/ext/libsass/position.hpp

@@ -0,0 +1,22 @@
+#define SASS_POSITION
+
+#include <cstdlib>
+
+namespace Sass {
+
+  struct Position {
+    size_t file;
+    size_t line;
+    size_t column;
+
+    Position()
+    : file(0), line(0), column(0) { }
+
+    Position(const size_t file, const size_t line, const size_t column)
+    : file(file), line(line), column(column) { }
+
+    Position(const size_t line, const size_t column)
+    : file(0), line(line), column(column) { }
+  };
+
+}

data/ext/libsass/posix/getopt.c

@@ -0,0 +1,562 @@
+/*	$OpenBSD: getopt_long.c,v 1.23 2007/10/31 12:34:57 chl Exp $	*/
+/*	$NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $	*/
+
+/*
+ * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F39502-99-1-0512.
+ */
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <windows.h>
+
+#define	REPLACE_GETOPT		/* use this getopt as the system getopt(3) */
+
+#ifdef REPLACE_GETOPT
+int	opterr = 1;		/* if error message should be printed */
+int	optind = 1;		/* index into parent argv vector */
+int	optopt = '?';		/* character checked for validity */
+#undef	optreset		/* see getopt.h */
+#define	optreset		__mingw_optreset
+int	optreset;		/* reset getopt */
+char    *optarg;		/* argument associated with option */
+#endif
+
+#define PRINT_ERROR	((opterr) && (*options != ':'))
+
+#define FLAG_PERMUTE	0x01	/* permute non-options to the end of argv */
+#define FLAG_ALLARGS	0x02	/* treat non-options as args to option "-1" */
+#define FLAG_LONGONLY	0x04	/* operate as getopt_long_only */
+
+/* return values */
+#define	BADCH		(int)'?'
+#define	BADARG		((*options == ':') ? (int)':' : (int)'?')
+#define	INORDER 	(int)1
+
+#ifndef __CYGWIN__
+#define __progname __argv[0]
+#else
+extern char __declspec(dllimport) *__progname;
+#endif
+
+#ifdef __CYGWIN__
+static char EMSG[] = "";
+#else
+#define	EMSG		""
+#endif
+
+static int getopt_internal(int, char * const *, const char *,
+			   const struct option *, int *, int);
+static int parse_long_options(char * const *, const char *,
+			      const struct option *, int *, int);
+static int gcd(int, int);
+static void permute_args(int, int, int, char * const *);
+
+static char *place = EMSG; /* option letter processing */
+
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1;   /* first option after non options (for permute) */
+
+/* Error messages */
+static const char recargchar[] = "option requires an argument -- %c";
+static const char recargstring[] = "option requires an argument -- %s";
+static const char ambig[] = "ambiguous option -- %.*s";
+static const char noarg[] = "option doesn't take an argument -- %.*s";
+static const char illoptchar[] = "unknown option -- %c";
+static const char illoptstring[] = "unknown option -- %s";
+
+static void
+_vwarnx(const char *fmt,va_list ap)
+{
+  (void)fprintf(stderr,"%s: ",__progname);
+  if (fmt != NULL)
+    (void)vfprintf(stderr,fmt,ap);
+  (void)fprintf(stderr,"\n");
+}
+
+static void
+warnx(const char *fmt,...)
+{
+  va_list ap;
+  va_start(ap,fmt);
+  _vwarnx(fmt,ap);
+  va_end(ap);
+}
+
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int
+gcd(int a, int b)
+{
+	int c;
+
+	c = a % b;
+	while (c != 0) {
+		a = b;
+		b = c;
+		c = a % b;
+	}
+
+	return (b);
+}
+
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(int panonopt_start, int panonopt_end, int opt_end,
+	char * const *nargv)
+{
+	int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+	char *swap;
+
+	/*
+	 * compute lengths of blocks and number and size of cycles
+	 */
+	nnonopts = panonopt_end - panonopt_start;
+	nopts = opt_end - panonopt_end;
+	ncycle = gcd(nnonopts, nopts);
+	cyclelen = (opt_end - panonopt_start) / ncycle;
+
+	for (i = 0; i < ncycle; i++) {
+		cstart = panonopt_end+i;
+		pos = cstart;
+		for (j = 0; j < cyclelen; j++) {
+			if (pos >= panonopt_end)
+				pos -= nnonopts;
+			else
+				pos += nopts;
+			swap = nargv[pos];
+			/* LINTED const cast */
+			((char **) nargv)[pos] = nargv[cstart];
+			/* LINTED const cast */
+			((char **)nargv)[cstart] = swap;
+		}
+	}
+}
+
+/*
+ * parse_long_options --
+ *	Parse long options in argc/argv argument vector.
+ * Returns -1 if short_too is set and the option does not match long_options.
+ */
+static int
+parse_long_options(char * const *nargv, const char *options,
+	const struct option *long_options, int *idx, int short_too)
+{
+	char *current_argv, *has_equal;
+	size_t current_argv_len;
+	int i, ambiguous, match;
+
+#define IDENTICAL_INTERPRETATION(_x, _y)                                \
+	(long_options[(_x)].has_arg == long_options[(_y)].has_arg &&    \
+	 long_options[(_x)].flag == long_options[(_y)].flag &&          \
+	 long_options[(_x)].val == long_options[(_y)].val)
+
+	current_argv = place;
+	match = -1;
+	ambiguous = 0;
+
+	optind++;
+
+	if ((has_equal = strchr(current_argv, '=')) != NULL) {
+		/* argument found (--option=arg) */
+		current_argv_len = has_equal - current_argv;
+		has_equal++;
+	} else
+		current_argv_len = strlen(current_argv);
+
+	for (i = 0; long_options[i].name; i++) {
+		/* find matching long option */
+		if (strncmp(current_argv, long_options[i].name,
+		    current_argv_len))
+			continue;
+
+		if (strlen(long_options[i].name) == current_argv_len) {
+			/* exact match */
+			match = i;
+			ambiguous = 0;
+			break;
+		}
+		/*
+		 * If this is a known short option, don't allow
+		 * a partial match of a single character.
+		 */
+		if (short_too && current_argv_len == 1)
+			continue;
+
+		if (match == -1)	/* partial match */
+			match = i;
+		else if (!IDENTICAL_INTERPRETATION(i, match))
+			ambiguous = 1;
+	}
+	if (ambiguous) {
+		/* ambiguous abbreviation */
+		if (PRINT_ERROR)
+			warnx(ambig, (int)current_argv_len,
+			     current_argv);
+		optopt = 0;
+		return (BADCH);
+	}
+	if (match != -1) {		/* option found */
+		if (long_options[match].has_arg == no_argument
+		    && has_equal) {
+			if (PRINT_ERROR)
+				warnx(noarg, (int)current_argv_len,
+				     current_argv);
+			/*
+			 * XXX: GNU sets optopt to val regardless of flag
+			 */
+			if (long_options[match].flag == NULL)
+				optopt = long_options[match].val;
+			else
+				optopt = 0;
+			return (BADARG);
+		}
+		if (long_options[match].has_arg == required_argument ||
+		    long_options[match].has_arg == optional_argument) {
+			if (has_equal)
+				optarg = has_equal;
+			else if (long_options[match].has_arg ==
+			    required_argument) {
+				/*
+				 * optional argument doesn't use next nargv
+				 */
+				optarg = nargv[optind++];
+			}
+		}
+		if ((long_options[match].has_arg == required_argument)
+		    && (optarg == NULL)) {
+			/*
+			 * Missing argument; leading ':' indicates no error
+			 * should be generated.
+			 */
+			if (PRINT_ERROR)
+				warnx(recargstring,
+				    current_argv);
+			/*
+			 * XXX: GNU sets optopt to val regardless of flag
+			 */
+			if (long_options[match].flag == NULL)
+				optopt = long_options[match].val;
+			else
+				optopt = 0;
+			--optind;
+			return (BADARG);
+		}
+	} else {			/* unknown option */
+		if (short_too) {
+			--optind;
+			return (-1);
+		}
+		if (PRINT_ERROR)
+			warnx(illoptstring, current_argv);
+		optopt = 0;
+		return (BADCH);
+	}
+	if (idx)
+		*idx = match;
+	if (long_options[match].flag) {
+		*long_options[match].flag = long_options[match].val;
+		return (0);
+	} else
+		return (long_options[match].val);
+#undef IDENTICAL_INTERPRETATION
+}
+
+/*
+ * getopt_internal --
+ *	Parse argc/argv argument vector.  Called by user level routines.
+ */
+static int
+getopt_internal(int nargc, char * const *nargv, const char *options,
+	const struct option *long_options, int *idx, int flags)
+{
+	char *oli;				/* option letter list index */
+	int optchar, short_too;
+	static int posixly_correct = -1;
+
+	if (options == NULL)
+		return (-1);
+
+	/*
+	 * XXX Some GNU programs (like cvs) set optind to 0 instead of
+	 * XXX using optreset.  Work around this braindamage.
+	 */
+	if (optind == 0)
+		optind = optreset = 1;
+
+	/*
+	 * Disable GNU extensions if POSIXLY_CORRECT is set or options
+	 * string begins with a '+'.
+	 *
+	 * CV, 2009-12-14: Check POSIXLY_CORRECT anew if optind == 0 or
+	 *                 optreset != 0 for GNU compatibility.
+	 */
+	if (posixly_correct == -1 || optreset != 0)
+		posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
+	if (*options == '-')
+		flags |= FLAG_ALLARGS;
+	else if (posixly_correct || *options == '+')
+		flags &= ~FLAG_PERMUTE;
+	if (*options == '+' || *options == '-')
+		options++;
+
+	optarg = NULL;
+	if (optreset)
+		nonopt_start = nonopt_end = -1;
+start:
+	if (optreset || !*place) {		/* update scanning pointer */
+		optreset = 0;
+		if (optind >= nargc) {          /* end of argument vector */
+			place = EMSG;
+			if (nonopt_end != -1) {
+				/* do permutation, if we have to */
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				optind -= nonopt_end - nonopt_start;
+			}
+			else if (nonopt_start != -1) {
+				/*
+				 * If we skipped non-options, set optind
+				 * to the first of them.
+				 */
+				optind = nonopt_start;
+			}
+			nonopt_start = nonopt_end = -1;
+			return (-1);
+		}
+		if (*(place = nargv[optind]) != '-' ||
+		    (place[1] == '\0' && strchr(options, '-') == NULL)) {
+			place = EMSG;		/* found non-option */
+			if (flags & FLAG_ALLARGS) {
+				/*
+				 * GNU extension:
+				 * return non-option as argument to option 1
+				 */
+				optarg = nargv[optind++];
+				return (INORDER);
+			}
+			if (!(flags & FLAG_PERMUTE)) {
+				/*
+				 * If no permutation wanted, stop parsing
+				 * at first non-option.
+				 */
+				return (-1);
+			}
+			/* do permutation */
+			if (nonopt_start == -1)
+				nonopt_start = optind;
+			else if (nonopt_end != -1) {
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				nonopt_start = optind -
+				    (nonopt_end - nonopt_start);
+				nonopt_end = -1;
+			}
+			optind++;
+			/* process next argument */
+			goto start;
+		}
+		if (nonopt_start != -1 && nonopt_end == -1)
+			nonopt_end = optind;
+
+		/*
+		 * If we have "-" do nothing, if "--" we are done.
+		 */
+		if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
+			optind++;
+			place = EMSG;
+			/*
+			 * We found an option (--), so if we skipped
+			 * non-options, we have to permute.
+			 */
+			if (nonopt_end != -1) {
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				optind -= nonopt_end - nonopt_start;
+			}
+			nonopt_start = nonopt_end = -1;
+			return (-1);
+		}
+	}
+
+	/*
+	 * Check long options if:
+	 *  1) we were passed some
+	 *  2) the arg is not just "-"
+	 *  3) either the arg starts with -- we are getopt_long_only()
+	 */
+	if (long_options != NULL && place != nargv[optind] &&
+	    (*place == '-' || (flags & FLAG_LONGONLY))) {
+		short_too = 0;
+		if (*place == '-')
+			place++;		/* --foo long option */
+		else if (*place != ':' && strchr(options, *place) != NULL)
+			short_too = 1;		/* could be short option too */
+
+		optchar = parse_long_options(nargv, options, long_options,
+		    idx, short_too);
+		if (optchar != -1) {
+			place = EMSG;
+			return (optchar);
+		}
+	}
+
+	if ((optchar = (int)*place++) == (int)':' ||
+	    (optchar == (int)'-' && *place != '\0') ||
+	    (oli = strchr(options, optchar)) == NULL) {
+		/*
+		 * If the user specified "-" and  '-' isn't listed in
+		 * options, return -1 (non-option) as per POSIX.
+		 * Otherwise, it is an unknown option character (or ':').
+		 */
+		if (optchar == (int)'-' && *place == '\0')
+			return (-1);
+		if (!*place)
+			++optind;
+		if (PRINT_ERROR)
+			warnx(illoptchar, optchar);
+		optopt = optchar;
+		return (BADCH);
+	}
+	if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
+		/* -W long-option */
+		if (*place)			/* no space */
+			/* NOTHING */;
+		else if (++optind >= nargc) {	/* no arg */
+			place = EMSG;
+			if (PRINT_ERROR)
+				warnx(recargchar, optchar);
+			optopt = optchar;
+			return (BADARG);
+		} else				/* white space */
+			place = nargv[optind];
+		optchar = parse_long_options(nargv, options, long_options,
+		    idx, 0);
+		place = EMSG;
+		return (optchar);
+	}
+	if (*++oli != ':') {			/* doesn't take argument */
+		if (!*place)
+			++optind;
+	} else {				/* takes (optional) argument */
+		optarg = NULL;
+		if (*place)			/* no white space */
+			optarg = place;
+		else if (oli[1] != ':') {	/* arg not optional */
+			if (++optind >= nargc) {	/* no arg */
+				place = EMSG;
+				if (PRINT_ERROR)
+					warnx(recargchar, optchar);
+				optopt = optchar;
+				return (BADARG);
+			} else
+				optarg = nargv[optind];
+		}
+		place = EMSG;
+		++optind;
+	}
+	/* dump back option letter */
+	return (optchar);
+}
+
+#ifdef REPLACE_GETOPT
+/*
+ * getopt --
+ *	Parse argc/argv argument vector.
+ *
+ * [eventually this will replace the BSD getopt]
+ */
+int
+getopt(int nargc, char * const *nargv, const char *options)
+{
+
+	/*
+	 * We don't pass FLAG_PERMUTE to getopt_internal() since
+	 * the BSD getopt(3) (unlike GNU) has never done this.
+	 *
+	 * Furthermore, since many privileged programs call getopt()
+	 * before dropping privileges it makes sense to keep things
+	 * as simple (and bug-free) as possible.
+	 */
+	return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
+}
+#endif /* REPLACE_GETOPT */
+
+/*
+ * getopt_long --
+ *	Parse argc/argv argument vector.
+ */
+int
+getopt_long(int nargc, char * const *nargv, const char *options,
+    const struct option *long_options, int *idx)
+{
+
+	return (getopt_internal(nargc, nargv, options, long_options, idx,
+	    FLAG_PERMUTE));
+}
+
+/*
+ * getopt_long_only --
+ *	Parse argc/argv argument vector.
+ */
+int
+getopt_long_only(int nargc, char * const *nargv, const char *options,
+    const struct option *long_options, int *idx)
+{
+
+	return (getopt_internal(nargc, nargv, options, long_options, idx,
+	    FLAG_PERMUTE|FLAG_LONGONLY));
+}