/* -*- 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")