gecko/js/src/jsreops.tbl

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * vim: set ts=8 sw=4 et tw=0 ft=C:
 *
 * ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "license"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "as is" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Mozilla Communicator client code, released
 * March 31, 1998.
 *
 * The Initial Developer of the Original Code is
 * Netscape Communications Corporation.
 * Portions created by the Initial Developer are Copyright (C) 1998
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Alternatively, the contentsof this file are subject to the Mozilla Public License Version
 * 1.1 (the "license"); you may not use this file except in compliance with
 * the License. You may obtain a copy of thter (the "lgpl"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */


/* Note : contiguity of 'simple opcodes' is important for SimpleMatch() */

/* match rest of input against rest of r.e. */
REOP_DEF(REOP_EMPTY,         "empty")
/* beginning of input (or line if multiline) */
REOP_DEF(REOP_BOL,           "bol")
/* end of input (or line if multiline) */
REOP_DEF(REOP_EOL,           "eol")
/* match "" at word boundary */
REOP_DEF(REOP_WBDRY,         "wbdry")
/* match "" at word non-boundary */
REOP_DEF(REOP_WNONBDRY,      "wnonbdry")
/* stands for any character */
REOP_DEF(REOP_DOT,           "dot")
/* match a digit char: [0-9] */
REOP_DEF(REOP_DIGIT,         "digit")
/* match a non-digit char: [^0-9] */
REOP_DEF(REOP_NONDIGIT,      "nondigit")
/* match an alphanumeric char: [0-9a-z_A-Z] */
REOP_DEF(REOP_ALNUM,         "alnum")
/* match a non-alphanumeric char: [^0-9a-z_A-Z] */
REOP_DEF(REOP_NONALNUM,      "nonalnum")
/* match a whitespace char */
REOP_DEF(REOP_SPACE,         "space")
/* match a non-whitespace char */
REOP_DEF(REOP_NONSPACE,      "nonspace")
/* back-reference (e.g., \1) to a parenthetical */
REOP_DEF(REOP_BACKREF,       "backref")
/* match a flat string */
REOP_DEF(REOP_FLAT,          "flat")
/* match a single char */
REOP_DEF(REOP_FLAT1,         "flat1")
/* case-independent REOP_FLAT */
REOP_DEF(REOP_FLATi,         "flati")
/* case-independent REOP_FLAT1 */
REOP_DEF(REOP_FLAT1i,        "flat1i")
/* single Unicode char */
REOP_DEF(REOP_UCFLAT1,       "ucflat1")
/* case-independent REOP_UCFLAT1 */
REOP_DEF(REOP_UCFLAT1i,      "ucflat1i")
/* flat Unicode string; len immediate counts chars */
REOP_DEF(REOP_UCFLAT,        "ucflat")
/* case-independent REOP_UCFLAT */
REOP_DEF(REOP_UCFLATi,       "ucflati")
/* character class with index */
REOP_DEF(REOP_CLASS,         "class")
/* negated character class with index */
REOP_DEF(REOP_NCLASS,        "nclass")

/* NCLASS is considered to be the last "simple" op-code */
    

/* alternative subexpressions in kid and next */
REOP_DEF(REOP_ALT,           "alt")
/* quantified atom: atom{1,2} */
REOP_DEF(REOP_QUANT,         "quant")
/* zero or more occurrences of kid */
REOP_DEF(REOP_STAR,          "star")
/* one or more occurrences of kid */
REOP_DEF(REOP_PLUS,          "plus")
/* optional subexpression in kid */
REOP_DEF(REOP_OPT,           "opt")
/* left paren bytecode: kid is u.num'th sub-regexp */
REOP_DEF(REOP_LPAREN,        "lparen")
/* right paren bytecode */
REOP_DEF(REOP_RPAREN,        "rparen")
/* for deoptimized closure loops */
REOP_DEF(REOP_JUMP,          "jump")
/* optimize .* to use a single opcode */
REOP_DEF(REOP_DOTSTAR,       "dotstar")
/* non-capturing version of REOP_LPAREN */
REOP_DEF(REOP_LPARENNON,     "lparennon")
/* zero width positive lookahead assertion */
REOP_DEF(REOP_ASSERT,        "assert")
/* zero width negative lookahead assertion */
REOP_DEF(REOP_ASSERT_NOT,    "assert_not")
/* sentinel at end of assertion child */
REOP_DEF(REOP_ASSERTTEST,    "asserttest")
/* sentinel at end of !assertion child */
REOP_DEF(REOP_ASSERTNOTTEST, "assertnottest")
/* non-greedy version of * */
REOP_DEF(REOP_MINIMALSTAR,   "minimalstar")
/* non-greedy version of + */
REOP_DEF(REOP_MINIMALPLUS,   "minimalplus")
/* non-greedy version of ? */
REOP_DEF(REOP_MINIMALOPT,    "minimalopt")
/* non-greedy version of {} */
REOP_DEF(REOP_MINIMALQUANT,  "minimalquant")
/* sentinel at end of quantifier child */
REOP_DEF(REOP_ENDCHILD,      "endchild")
/* directs execution of greedy quantifier */
REOP_DEF(REOP_REPEAT,        "repeat")
/* directs execution of non-greedy quantifier */
REOP_DEF(REOP_MINIMALREPEAT, "minimalrepeat")
/* prerequisite for ALT, either of two chars */
REOP_DEF(REOP_ALTPREREQ,     "altprereq")
/* prerequisite for ALT, a char or a class */
REOP_DEF(REOP_ALTPREREQ2,    "altprereq2")
/* end of final alternate */
REOP_DEF(REOP_ENDALT,        "endalt")
/* concatenation of terms (parse time only) */
REOP_DEF(REOP_CONCAT,        "concat")
/* end of expression */
REOP_DEF(REOP_END,           "end")