[mirror_edk2.git] / MdeModulePkg / Universal / RegularExpressionDxe / Oniguruma / regparse.h

#ifndef REGPARSE_H\r
#define REGPARSE_H\r
/**********************************************************************\r
  regparse.h -  Oniguruma (regular expression library)\r
**********************************************************************/\r
/*-\r
 * Copyright (c) 2002-2019  K.Kosako  <sndgk393 AT ybb DOT ne DOT jp>\r
 * All rights reserved.\r
 *\r
 * Redistribution and use in source and binary forms, with or without\r
 * modification, are permitted provided that the following conditions\r
 * are met:\r
 * 1. Redistributions of source code must retain the above copyright\r
 *    notice, this list of conditions and the following disclaimer.\r
 * 2. Redistributions in binary form must reproduce the above copyright\r
 *    notice, this list of conditions and the following disclaimer in the\r
 *    documentation and/or other materials provided with the distribution.\r
 *\r
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\r
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\r
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
 * SUCH DAMAGE.\r
 */\r
\r
#include "regint.h"\r
\r
#define NODE_STRING_MARGIN         16\r
#define NODE_STRING_BUF_SIZE       24  /* sizeof(CClassNode) - sizeof(int)*4 */\r
#define NODE_BACKREFS_SIZE          6\r
\r
/* node type */\r
typedef enum {\r
  NODE_STRING    =  0,\r
  NODE_CCLASS    =  1,\r
  NODE_CTYPE     =  2,\r
  NODE_BACKREF   =  3,\r
  NODE_QUANT     =  4,\r
  NODE_BAG       =  5,\r
  NODE_ANCHOR    =  6,\r
  NODE_LIST      =  7,\r
  NODE_ALT       =  8,\r
  NODE_CALL      =  9,\r
  NODE_GIMMICK   = 10\r
} NodeType;\r
\r
enum BagType {\r
  BAG_MEMORY         = 0,\r
  BAG_OPTION         = 1,\r
  BAG_STOP_BACKTRACK = 2,\r
  BAG_IF_ELSE        = 3,\r
};\r
\r
enum GimmickType {\r
  GIMMICK_FAIL       = 0,\r
  GIMMICK_SAVE       = 1,\r
  GIMMICK_UPDATE_VAR = 2,\r
#ifdef USE_CALLOUT\r
  GIMMICK_CALLOUT    = 3,\r
#endif\r
};\r
\r
enum BodyEmptyType {\r
  BODY_IS_NOT_EMPTY             = 0,\r
  BODY_IS_EMPTY_POSSIBILITY     = 1,\r
  BODY_IS_EMPTY_POSSIBILITY_MEM = 2,\r
  BODY_IS_EMPTY_POSSIBILITY_REC = 3\r
};\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
\r
  UChar* s;\r
  UChar* end;\r
  unsigned int flag;\r
  int    capacity;    /* (allocated size - 1) or 0: use buf[] */\r
  UChar  buf[NODE_STRING_BUF_SIZE];\r
} StrNode;\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
\r
  unsigned int flags;\r
  BitSet bs;\r
  BBuf*  mbuf;   /* multi-byte info or NULL */\r
} CClassNode;\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
  struct _Node* body;\r
\r
  int lower;\r
  int upper;\r
  int greedy;\r
  enum BodyEmptyType emptiness;\r
  struct _Node* head_exact;\r
  struct _Node* next_head_exact;\r
  int is_refered;     /* include called node. don't eliminate even if {0} */\r
} QuantNode;\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
  struct _Node* body;\r
\r
  enum BagType type;\r
  union {\r
    struct {\r
      int regnum;\r
      AbsAddrType called_addr;\r
      int entry_count;\r
      int called_state;\r
    } m;\r
    struct {\r
      OnigOptionType options;\r
    } o;\r
    struct {\r
      /* body is condition */\r
      struct _Node* Then;\r
      struct _Node* Else;\r
    } te;\r
  };\r
  /* for multiple call reference */\r
  OnigLen min_len;   /* min length (byte) */\r
  OnigLen max_len;   /* max length (byte) */\r
  int char_len;      /* character length  */\r
  int opt_count;     /* referenced count in optimize_nodes() */\r
} BagNode;\r
\r
#ifdef USE_CALL\r
\r
typedef struct {\r
  int           offset;\r
  struct _Node* target;\r
} UnsetAddr;\r
\r
typedef struct {\r
  int        num;\r
  int        alloc;\r
  UnsetAddr* us;\r
} UnsetAddrList;\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
  struct _Node* body; /* to BagNode : BAG_MEMORY */\r
\r
  int     by_number;\r
  int     group_num;\r
  UChar*  name;\r
  UChar*  name_end;\r
  int     entry_count;\r
} CallNode;\r
\r
#endif\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
\r
  int  back_num;\r
  int  back_static[NODE_BACKREFS_SIZE];\r
  int* back_dynamic;\r
  int  nest_level;\r
} BackRefNode;\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
  struct _Node* body;\r
\r
  int type;\r
  int char_len;\r
  int ascii_mode;\r
} AnchorNode;\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
\r
  struct _Node* car;\r
  struct _Node* cdr;\r
} ConsAltNode;\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
\r
  int ctype;\r
  int not;\r
  OnigOptionType options;\r
  int ascii_mode;\r
} CtypeNode;\r
\r
typedef struct {\r
  NodeType node_type;\r
  int status;\r
\r
  enum GimmickType type;\r
  int  detail_type;\r
  int  num;\r
  int  id;\r
} GimmickNode;\r
\r
typedef struct _Node {\r
  union {\r
    struct {\r
      NodeType node_type;\r
      int status;\r
      struct _Node* body;\r
    } base;\r
\r
    StrNode       str;\r
    CClassNode    cclass;\r
    QuantNode     quant;\r
    BagNode       bag;\r
    BackRefNode   backref;\r
    AnchorNode    anchor;\r
    ConsAltNode   cons;\r
    CtypeNode     ctype;\r
#ifdef USE_CALL\r
    CallNode      call;\r
#endif\r
    GimmickNode   gimmick;\r
  } u;\r
} Node;\r
\r
#define NULL_NODE  ((Node* )0)\r
\r
\r
/* node type bit */\r
#define NODE_TYPE2BIT(type)      (1<<(type))\r
\r
#define NODE_BIT_STRING     NODE_TYPE2BIT(NODE_STRING)\r
#define NODE_BIT_CCLASS     NODE_TYPE2BIT(NODE_CCLASS)\r
#define NODE_BIT_CTYPE      NODE_TYPE2BIT(NODE_CTYPE)\r
#define NODE_BIT_BACKREF    NODE_TYPE2BIT(NODE_BACKREF)\r
#define NODE_BIT_QUANT      NODE_TYPE2BIT(NODE_QUANT)\r
#define NODE_BIT_BAG        NODE_TYPE2BIT(NODE_BAG)\r
#define NODE_BIT_ANCHOR     NODE_TYPE2BIT(NODE_ANCHOR)\r
#define NODE_BIT_LIST       NODE_TYPE2BIT(NODE_LIST)\r
#define NODE_BIT_ALT        NODE_TYPE2BIT(NODE_ALT)\r
#define NODE_BIT_CALL       NODE_TYPE2BIT(NODE_CALL)\r
#define NODE_BIT_GIMMICK    NODE_TYPE2BIT(NODE_GIMMICK)\r
\r
#define NODE_TYPE(node)             ((node)->u.base.node_type)\r
#define NODE_SET_TYPE(node, ntype)   (node)->u.base.node_type = (ntype)\r
\r
#define STR_(node)         (&((node)->u.str))\r
#define CCLASS_(node)      (&((node)->u.cclass))\r
#define CTYPE_(node)       (&((node)->u.ctype))\r
#define BACKREF_(node)     (&((node)->u.backref))\r
#define QUANT_(node)       (&((node)->u.quant))\r
#define BAG_(node)         (&((node)->u.bag))\r
#define ANCHOR_(node)      (&((node)->u.anchor))\r
#define CONS_(node)        (&((node)->u.cons))\r
#define CALL_(node)        (&((node)->u.call))\r
#define GIMMICK_(node)     (&((node)->u.gimmick))\r
\r
#define NODE_CAR(node)         (CONS_(node)->car)\r
#define NODE_CDR(node)         (CONS_(node)->cdr)\r
\r
#define CTYPE_ANYCHAR      -1\r
#define NODE_IS_ANYCHAR(node) \\r
  (NODE_TYPE(node) == NODE_CTYPE && CTYPE_(node)->ctype == CTYPE_ANYCHAR)\r
\r
#define CTYPE_OPTION(node, reg) \\r
  (NODE_IS_FIXED_OPTION(node) ? CTYPE_(node)->options : reg->options)\r
\r
\r
#define ANCR_ANYCHAR_INF_MASK  (ANCR_ANYCHAR_INF | ANCR_ANYCHAR_INF_ML)\r
#define ANCR_END_BUF_MASK      (ANCR_END_BUF | ANCR_SEMI_END_BUF)\r
\r
#define NODE_STRING_RAW                (1<<0) /* by backslashed number */\r
#define NODE_STRING_AMBIG              (1<<1)\r
#define NODE_STRING_GOOD_AMBIG         (1<<2)\r
#define NODE_STRING_DONT_GET_OPT_INFO  (1<<3)\r
\r
#define NODE_STRING_LEN(node)            (int )((node)->u.str.end - (node)->u.str.s)\r
#define NODE_STRING_SET_RAW(node)        (node)->u.str.flag |= NODE_STRING_RAW\r
#define NODE_STRING_CLEAR_RAW(node)      (node)->u.str.flag &= ~NODE_STRING_RAW\r
#define NODE_STRING_SET_AMBIG(node)      (node)->u.str.flag |= NODE_STRING_AMBIG\r
#define NODE_STRING_SET_GOOD_AMBIG(node) (node)->u.str.flag |= NODE_STRING_GOOD_AMBIG\r
#define NODE_STRING_SET_DONT_GET_OPT_INFO(node) \\r
  (node)->u.str.flag |= NODE_STRING_DONT_GET_OPT_INFO\r
#define NODE_STRING_IS_RAW(node) \\r
  (((node)->u.str.flag & NODE_STRING_RAW) != 0)\r
#define NODE_STRING_IS_AMBIG(node) \\r
  (((node)->u.str.flag & NODE_STRING_AMBIG) != 0)\r
#define NODE_STRING_IS_GOOD_AMBIG(node) \\r
  (((node)->u.str.flag & NODE_STRING_GOOD_AMBIG) != 0)\r
#define NODE_STRING_IS_DONT_GET_OPT_INFO(node) \\r
  (((node)->u.str.flag & NODE_STRING_DONT_GET_OPT_INFO) != 0)\r
\r
#define BACKREFS_P(br) \\r
  (IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static)\r
\r
/* node status bits */\r
#define NODE_ST_MIN_FIXED             (1<<0)\r
#define NODE_ST_MAX_FIXED             (1<<1)\r
#define NODE_ST_CLEN_FIXED            (1<<2)\r
#define NODE_ST_MARK1                 (1<<3)\r
#define NODE_ST_MARK2                 (1<<4)\r
#define NODE_ST_STRICT_REAL_REPEAT    (1<<5)\r
#define NODE_ST_RECURSION             (1<<6)\r
#define NODE_ST_CALLED                (1<<7)\r
#define NODE_ST_ADDR_FIXED            (1<<8)\r
#define NODE_ST_NAMED_GROUP           (1<<9)\r
#define NODE_ST_IN_REAL_REPEAT        (1<<10) /* STK_REPEAT is nested in stack. */\r
#define NODE_ST_IN_ZERO_REPEAT        (1<<11) /* (....){0} */\r
#define NODE_ST_IN_MULTI_ENTRY        (1<<12)\r
#define NODE_ST_NEST_LEVEL            (1<<13)\r
#define NODE_ST_BY_NUMBER             (1<<14) /* {n,m} */\r
#define NODE_ST_BY_NAME               (1<<15) /* backref by name */\r
#define NODE_ST_BACKREF               (1<<16)\r
#define NODE_ST_CHECKER               (1<<17)\r
#define NODE_ST_FIXED_OPTION          (1<<18)\r
#define NODE_ST_PROHIBIT_RECURSION    (1<<19)\r
#define NODE_ST_SUPER                 (1<<20)\r
\r
\r
#define NODE_STATUS(node)           (((Node* )node)->u.base.status)\r
#define NODE_STATUS_ADD(node,f)     (NODE_STATUS(node) |= (NODE_ST_ ## f))\r
#define NODE_STATUS_REMOVE(node,f)  (NODE_STATUS(node) &= ~(NODE_ST_ ## f))\r
\r
#define NODE_IS_BY_NUMBER(node)       ((NODE_STATUS(node) & NODE_ST_BY_NUMBER)      != 0)\r
#define NODE_IS_IN_REAL_REPEAT(node)  ((NODE_STATUS(node) & NODE_ST_IN_REAL_REPEAT) != 0)\r
#define NODE_IS_CALLED(node)          ((NODE_STATUS(node) & NODE_ST_CALLED)         != 0)\r
#define NODE_IS_IN_MULTI_ENTRY(node)  ((NODE_STATUS(node) & NODE_ST_IN_MULTI_ENTRY) != 0)\r
#define NODE_IS_RECURSION(node)       ((NODE_STATUS(node) & NODE_ST_RECURSION)      != 0)\r
#define NODE_IS_IN_ZERO_REPEAT(node)  ((NODE_STATUS(node) & NODE_ST_IN_ZERO_REPEAT) != 0)\r
#define NODE_IS_NAMED_GROUP(node)     ((NODE_STATUS(node) & NODE_ST_NAMED_GROUP)  != 0)\r
#define NODE_IS_ADDR_FIXED(node)      ((NODE_STATUS(node) & NODE_ST_ADDR_FIXED)   != 0)\r
#define NODE_IS_CLEN_FIXED(node)      ((NODE_STATUS(node) & NODE_ST_CLEN_FIXED)   != 0)\r
#define NODE_IS_MIN_FIXED(node)       ((NODE_STATUS(node) & NODE_ST_MIN_FIXED)    != 0)\r
#define NODE_IS_MAX_FIXED(node)       ((NODE_STATUS(node) & NODE_ST_MAX_FIXED)    != 0)\r
#define NODE_IS_MARK1(node)           ((NODE_STATUS(node) & NODE_ST_MARK1)        != 0)\r
#define NODE_IS_MARK2(node)           ((NODE_STATUS(node) & NODE_ST_MARK2)        != 0)\r
#define NODE_IS_NEST_LEVEL(node)      ((NODE_STATUS(node) & NODE_ST_NEST_LEVEL)   != 0)\r
#define NODE_IS_BY_NAME(node)         ((NODE_STATUS(node) & NODE_ST_BY_NAME)      != 0)\r
#define NODE_IS_BACKREF(node)         ((NODE_STATUS(node) & NODE_ST_BACKREF)      != 0)\r
#define NODE_IS_CHECKER(node)         ((NODE_STATUS(node) & NODE_ST_CHECKER)      != 0)\r
#define NODE_IS_FIXED_OPTION(node)    ((NODE_STATUS(node) & NODE_ST_FIXED_OPTION) != 0)\r
#define NODE_IS_SUPER(node)           ((NODE_STATUS(node) & NODE_ST_SUPER)        != 0)\r
#define NODE_IS_PROHIBIT_RECURSION(node) \\r
    ((NODE_STATUS(node) & NODE_ST_PROHIBIT_RECURSION) != 0)\r
#define NODE_IS_STRICT_REAL_REPEAT(node) \\r
    ((NODE_STATUS(node) & NODE_ST_STRICT_REAL_REPEAT) != 0)\r
\r
#define NODE_BODY(node)           ((node)->u.base.body)\r
#define NODE_QUANT_BODY(node)     ((node)->body)\r
#define NODE_BAG_BODY(node)       ((node)->body)\r
#define NODE_CALL_BODY(node)      ((node)->body)\r
#define NODE_ANCHOR_BODY(node)    ((node)->body)\r
\r
#define SCANENV_MEMENV_SIZE               8\r
#define SCANENV_MEMENV(senv) \\r
 (IS_NOT_NULL((senv)->mem_env_dynamic) ? \\r
    (senv)->mem_env_dynamic : (senv)->mem_env_static)\r
\r
typedef struct {\r
  Node* node;\r
#if 0\r
  int in;\r
  int recursion;\r
#endif\r
} MemEnv;\r
\r
typedef struct {\r
  enum SaveType type;\r
} SaveItem;\r
\r
typedef struct {\r
  OnigOptionType   options;\r
  OnigCaseFoldType case_fold_flag;\r
  OnigEncoding     enc;\r
  OnigSyntaxType*  syntax;\r
  MemStatusType    capture_history;\r
  MemStatusType    bt_mem_start;\r
  MemStatusType    bt_mem_end;\r
  MemStatusType    backrefed_mem;\r
  UChar*           pattern;\r
  UChar*           pattern_end;\r
  UChar*           error;\r
  UChar*           error_end;\r
  regex_t*         reg;       /* for reg->names only */\r
  int              num_call;\r
#ifdef USE_CALL\r
  UnsetAddrList*   unset_addr_list;\r
  int              has_call_zero;\r
#endif\r
  int              num_mem;\r
  int              num_named;\r
  int              mem_alloc;\r
  MemEnv           mem_env_static[SCANENV_MEMENV_SIZE];\r
  MemEnv*          mem_env_dynamic;\r
  unsigned int     parse_depth;\r
\r
  int keep_num;\r
  int save_num;\r
  int save_alloc_num;\r
  SaveItem* saves;\r
} ScanEnv;\r
\r
\r
#define IS_SYNTAX_OP(syn, opm)    (((syn)->op  & (opm)) != 0)\r
#define IS_SYNTAX_OP2(syn, opm)   (((syn)->op2 & (opm)) != 0)\r
#define IS_SYNTAX_BV(syn, bvm)    (((syn)->behavior & (bvm)) != 0)\r
\r
typedef struct {\r
  int new_val;\r
} GroupNumRemap;\r
\r
extern int    onig_renumber_name_table P_((regex_t* reg, GroupNumRemap* map));\r
\r
extern int    onig_strncmp P_((const UChar* s1, const UChar* s2, int n));\r
extern void   onig_strcpy P_((UChar* dest, const UChar* src, const UChar* end));\r
extern void   onig_scan_env_set_error_string P_((ScanEnv* env, int ecode, UChar* arg, UChar* arg_end));\r
extern int    onig_scan_unsigned_number P_((UChar** src, const UChar* end, OnigEncoding enc));\r
extern void   onig_reduce_nested_quantifier P_((Node* pnode, Node* cnode));\r
extern void   onig_node_conv_to_str_node P_((Node* node, int raw));\r
extern int    onig_node_str_cat P_((Node* node, const UChar* s, const UChar* end));\r
extern int    onig_node_str_set P_((Node* node, const UChar* s, const UChar* end));\r
extern void   onig_node_free P_((Node* node));\r
extern Node*  onig_node_new_bag P_((enum BagType type));\r
extern Node*  onig_node_new_anchor P_((int type, int ascii_mode));\r
extern Node*  onig_node_new_str P_((const UChar* s, const UChar* end));\r
extern Node*  onig_node_new_list P_((Node* left, Node* right));\r
extern Node*  onig_node_list_add P_((Node* list, Node* x));\r
extern Node*  onig_node_new_alt P_((Node* left, Node* right));\r
extern void   onig_node_str_clear P_((Node* node));\r
extern int    onig_names_free P_((regex_t* reg));\r
extern int    onig_parse_tree P_((Node** root, const UChar* pattern, const UChar* end, regex_t* reg, ScanEnv* env));\r
extern int    onig_free_shared_cclass_table P_((void));\r
extern int    onig_is_code_in_cc P_((OnigEncoding enc, OnigCodePoint code, CClassNode* cc));\r
extern OnigLen onig_get_tiny_min_len(Node* node, unsigned int inhibit_node_types, int* invalid_node);\r
\r
#ifdef USE_CALLOUT\r
extern int onig_global_callout_names_free(void);\r
#endif\r
\r
#ifdef ONIG_DEBUG\r
extern int onig_print_names(FILE*, regex_t*);\r
#endif\r
\r
#endif /* REGPARSE_H */\r
Commit	Line	Data
14b0e578 CS	1	#ifndef REGPARSE_H\r
	2	#define REGPARSE_H\r
	3	/**********************************************************************\r
	4	regparse.h - Oniguruma (regular expression library)\r
	5	**********************************************************************/\r
	6	/*-\r
b26691c4	7	* Copyright (c) 2002-2019 K.Kosako <sndgk393 AT ybb DOT ne DOT jp>\r
14b0e578	8	* All rights reserved.\r
14b0e578 CS	9	*\r
	10	* Redistribution and use in source and binary forms, with or without\r
	11	* modification, are permitted provided that the following conditions\r
	12	* are met:\r
	13	* 1. Redistributions of source code must retain the above copyright\r
	14	* notice, this list of conditions and the following disclaimer.\r
	15	* 2. Redistributions in binary form must reproduce the above copyright\r
	16	* notice, this list of conditions and the following disclaimer in the\r
	17	* documentation and/or other materials provided with the distribution.\r
	18	*\r
	19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\r
	20	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
	21	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
	22	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\r
	23	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
	24	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
	25	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
	26	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
	27	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
	28	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
	29	* SUCH DAMAGE.\r
	30	*/\r
	31	\r
	32	#include "regint.h"\r
	33	\r
b26691c4 LG	34	#define NODE_STRING_MARGIN 16\r
	35	#define NODE_STRING_BUF_SIZE 24 /* sizeof(CClassNode) - sizeof(int)4 /\r
	36	#define NODE_BACKREFS_SIZE 6\r
	37	\r
14b0e578	38	/* node type */\r
b602265d DG	39	typedef enum {\r
	40	NODE_STRING = 0,\r
	41	NODE_CCLASS = 1,\r
	42	NODE_CTYPE = 2,\r
	43	NODE_BACKREF = 3,\r
	44	NODE_QUANT = 4,\r
b26691c4	45	NODE_BAG = 5,\r
b602265d DG	46	NODE_ANCHOR = 6,\r
	47	NODE_LIST = 7,\r
	48	NODE_ALT = 8,\r
	49	NODE_CALL = 9,\r
	50	NODE_GIMMICK = 10\r
	51	} NodeType;\r
	52	\r
b26691c4 LG	53	enum BagType {\r
	54	BAG_MEMORY = 0,\r
	55	BAG_OPTION = 1,\r
	56	BAG_STOP_BACKTRACK = 2,\r
	57	BAG_IF_ELSE = 3,\r
	58	};\r
	59	\r
b602265d	60	enum GimmickType {\r
b26691c4 LG	61	GIMMICK_FAIL = 0,\r
	62	GIMMICK_SAVE = 1,\r
	63	GIMMICK_UPDATE_VAR = 2,\r
b602265d	64	#ifdef USE_CALLOUT\r
b26691c4	65	GIMMICK_CALLOUT = 3,\r
b602265d DG	66	#endif\r
	67	};\r
	68	\r
b26691c4 LG	69	enum BodyEmptyType {\r
	70	BODY_IS_NOT_EMPTY = 0,\r
	71	BODY_IS_EMPTY_POSSIBILITY = 1,\r
	72	BODY_IS_EMPTY_POSSIBILITY_MEM = 2,\r
	73	BODY_IS_EMPTY_POSSIBILITY_REC = 3\r
b602265d	74	};\r
14b0e578	75	\r
14b0e578	76	typedef struct {\r
b602265d DG	77	NodeType node_type;\r
	78	int status;\r
	79	\r
14b0e578 CS	80	UChar* s;\r
	81	UChar* end;\r
	82	unsigned int flag;\r
b26691c4	83	int capacity; /* (allocated size - 1) or 0: use buf[] */\r
b602265d	84	UChar buf[NODE_STRING_BUF_SIZE];\r
14b0e578 CS	85	} StrNode;\r
	86	\r
	87	typedef struct {\r
b602265d DG	88	NodeType node_type;\r
	89	int status;\r
	90	\r
	91	unsigned int flags;\r
	92	BitSet bs;\r
	93	BBuf* mbuf; /* multi-byte info or NULL */\r
	94	} CClassNode;\r
	95	\r
	96	typedef struct {\r
	97	NodeType node_type;\r
	98	int status;\r
	99	struct _Node* body;\r
	100	\r
14b0e578 CS	101	int lower;\r
	102	int upper;\r
	103	int greedy;\r
b26691c4	104	enum BodyEmptyType emptiness;\r
14b0e578 CS	105	struct _Node* head_exact;\r
	106	struct _Node* next_head_exact;\r
	107	int is_refered; /* include called node. don't eliminate even if {0} */\r
b602265d	108	} QuantNode;\r
14b0e578 CS	109	\r
14b0e578 CS	110	typedef struct {\r
b602265d DG	111	NodeType node_type;\r
	112	int status;\r
	113	struct _Node* body;\r
	114	\r
b26691c4	115	enum BagType type;\r
b602265d DG	116	union {\r
	117	struct {\r
	118	int regnum;\r
	119	AbsAddrType called_addr;\r
	120	int entry_count;\r
	121	int called_state;\r
	122	} m;\r
	123	struct {\r
	124	OnigOptionType options;\r
	125	} o;\r
	126	struct {\r
	127	/* body is condition */\r
	128	struct _Node* Then;\r
	129	struct _Node* Else;\r
	130	} te;\r
	131	};\r
14b0e578	132	/* for multiple call reference */\r
b602265d DG	133	OnigLen min_len; /* min length (byte) */\r
	134	OnigLen max_len; /* max length (byte) */\r
	135	int char_len; /* character length */\r
	136	int opt_count; /* referenced count in optimize_nodes() */\r
b26691c4	137	} BagNode;\r
14b0e578	138	\r
b602265d	139	#ifdef USE_CALL\r
14b0e578 CS	140	\r
	141	typedef struct {\r
	142	int offset;\r
	143	struct _Node* target;\r
	144	} UnsetAddr;\r
	145	\r
	146	typedef struct {\r
	147	int num;\r
	148	int alloc;\r
	149	UnsetAddr* us;\r
	150	} UnsetAddrList;\r
	151	\r
	152	typedef struct {\r
b602265d DG	153	NodeType node_type;\r
b602265d DG	154	int status;\r
b26691c4	155	struct _Node* body; /* to BagNode : BAG_MEMORY */\r
b602265d DG	156	\r
b602265d DG	157	int by_number;\r
14b0e578 CS	158	int group_num;\r
	159	UChar* name;\r
	160	UChar* name_end;\r
b602265d	161	int entry_count;\r
14b0e578 CS	162	} CallNode;\r
	163	\r
	164	#endif\r
	165	\r
	166	typedef struct {\r
b602265d DG	167	NodeType node_type;\r
	168	int status;\r
	169	\r
14b0e578 CS	170	int back_num;\r
	171	int back_static[NODE_BACKREFS_SIZE];\r
	172	int* back_dynamic;\r
	173	int nest_level;\r
b602265d	174	} BackRefNode;\r
14b0e578 CS	175	\r
14b0e578 CS	176	typedef struct {\r
b602265d DG	177	NodeType node_type;\r
	178	int status;\r
	179	struct _Node* body;\r
	180	\r
14b0e578	181	int type;\r
14b0e578	182	int char_len;\r
b602265d	183	int ascii_mode;\r
14b0e578 CS	184	} AnchorNode;\r
	185	\r
	186	typedef struct {\r
b602265d DG	187	NodeType node_type;\r
	188	int status;\r
	189	\r
14b0e578 CS	190	struct _Node* car;\r
	191	struct _Node* cdr;\r
	192	} ConsAltNode;\r
	193	\r
	194	typedef struct {\r
b602265d DG	195	NodeType node_type;\r
	196	int status;\r
	197	\r
14b0e578 CS	198	int ctype;\r
14b0e578 CS	199	int not;\r
b602265d DG	200	OnigOptionType options;\r
b602265d DG	201	int ascii_mode;\r
14b0e578 CS	202	} CtypeNode;\r
14b0e578 CS	203	\r
b602265d DG	204	typedef struct {\r
	205	NodeType node_type;\r
	206	int status;\r
	207	\r
	208	enum GimmickType type;\r
	209	int detail_type;\r
	210	int num;\r
	211	int id;\r
	212	} GimmickNode;\r
	213	\r
14b0e578 CS	214	typedef struct _Node {\r
14b0e578 CS	215	union {\r
b602265d DG	216	struct {\r
	217	NodeType node_type;\r
	218	int status;\r
	219	struct _Node* body;\r
	220	} base;\r
	221	\r
	222	StrNode str;\r
	223	CClassNode cclass;\r
	224	QuantNode quant;\r
b26691c4	225	BagNode bag;\r
b602265d DG	226	BackRefNode backref;\r
	227	AnchorNode anchor;\r
	228	ConsAltNode cons;\r
	229	CtypeNode ctype;\r
	230	#ifdef USE_CALL\r
	231	CallNode call;\r
14b0e578	232	#endif\r
b602265d	233	GimmickNode gimmick;\r
14b0e578 CS	234	} u;\r
	235	} Node;\r
	236	\r
14b0e578 CS	237	#define NULL_NODE ((Node* )0)\r
14b0e578 CS	238	\r
b26691c4 LG	239	\r
	240	/* node type bit */\r
	241	#define NODE_TYPE2BIT(type) (1<<(type))\r
	242	\r
	243	#define NODE_BIT_STRING NODE_TYPE2BIT(NODE_STRING)\r
	244	#define NODE_BIT_CCLASS NODE_TYPE2BIT(NODE_CCLASS)\r
	245	#define NODE_BIT_CTYPE NODE_TYPE2BIT(NODE_CTYPE)\r
	246	#define NODE_BIT_BACKREF NODE_TYPE2BIT(NODE_BACKREF)\r
	247	#define NODE_BIT_QUANT NODE_TYPE2BIT(NODE_QUANT)\r
	248	#define NODE_BIT_BAG NODE_TYPE2BIT(NODE_BAG)\r
	249	#define NODE_BIT_ANCHOR NODE_TYPE2BIT(NODE_ANCHOR)\r
	250	#define NODE_BIT_LIST NODE_TYPE2BIT(NODE_LIST)\r
	251	#define NODE_BIT_ALT NODE_TYPE2BIT(NODE_ALT)\r
	252	#define NODE_BIT_CALL NODE_TYPE2BIT(NODE_CALL)\r
	253	#define NODE_BIT_GIMMICK NODE_TYPE2BIT(NODE_GIMMICK)\r
	254	\r
	255	#define NODE_TYPE(node) ((node)->u.base.node_type)\r
	256	#define NODE_SET_TYPE(node, ntype) (node)->u.base.node_type = (ntype)\r
	257	\r
	258	#define STR_(node) (&((node)->u.str))\r
	259	#define CCLASS_(node) (&((node)->u.cclass))\r
	260	#define CTYPE_(node) (&((node)->u.ctype))\r
	261	#define BACKREF_(node) (&((node)->u.backref))\r
	262	#define QUANT_(node) (&((node)->u.quant))\r
	263	#define BAG_(node) (&((node)->u.bag))\r
	264	#define ANCHOR_(node) (&((node)->u.anchor))\r
	265	#define CONS_(node) (&((node)->u.cons))\r
	266	#define CALL_(node) (&((node)->u.call))\r
	267	#define GIMMICK_(node) (&((node)->u.gimmick))\r
	268	\r
	269	#define NODE_CAR(node) (CONS_(node)->car)\r
	270	#define NODE_CDR(node) (CONS_(node)->cdr)\r
	271	\r
	272	#define CTYPE_ANYCHAR -1\r
	273	#define NODE_IS_ANYCHAR(node) \\r
	274	(NODE_TYPE(node) == NODE_CTYPE && CTYPE_(node)->ctype == CTYPE_ANYCHAR)\r
	275	\r
	276	#define CTYPE_OPTION(node, reg) \\r
	277	(NODE_IS_FIXED_OPTION(node) ? CTYPE_(node)->options : reg->options)\r
	278	\r
	279	\r
	280	#define ANCR_ANYCHAR_INF_MASK (ANCR_ANYCHAR_INF \| ANCR_ANYCHAR_INF_ML)\r
	281	#define ANCR_END_BUF_MASK (ANCR_END_BUF \| ANCR_SEMI_END_BUF)\r
	282	\r
	283	#define NODE_STRING_RAW (1<<0) /* by backslashed number */\r
	284	#define NODE_STRING_AMBIG (1<<1)\r
	285	#define NODE_STRING_GOOD_AMBIG (1<<2)\r
	286	#define NODE_STRING_DONT_GET_OPT_INFO (1<<3)\r
	287	\r
	288	#define NODE_STRING_LEN(node) (int )((node)->u.str.end - (node)->u.str.s)\r
	289	#define NODE_STRING_SET_RAW(node) (node)->u.str.flag \|= NODE_STRING_RAW\r
	290	#define NODE_STRING_CLEAR_RAW(node) (node)->u.str.flag &= ~NODE_STRING_RAW\r
	291	#define NODE_STRING_SET_AMBIG(node) (node)->u.str.flag \|= NODE_STRING_AMBIG\r
	292	#define NODE_STRING_SET_GOOD_AMBIG(node) (node)->u.str.flag \|= NODE_STRING_GOOD_AMBIG\r
	293	#define NODE_STRING_SET_DONT_GET_OPT_INFO(node) \\r
	294	(node)->u.str.flag \|= NODE_STRING_DONT_GET_OPT_INFO\r
	295	#define NODE_STRING_IS_RAW(node) \\r
	296	(((node)->u.str.flag & NODE_STRING_RAW) != 0)\r
	297	#define NODE_STRING_IS_AMBIG(node) \\r
	298	(((node)->u.str.flag & NODE_STRING_AMBIG) != 0)\r
	299	#define NODE_STRING_IS_GOOD_AMBIG(node) \\r
	300	(((node)->u.str.flag & NODE_STRING_GOOD_AMBIG) != 0)\r
	301	#define NODE_STRING_IS_DONT_GET_OPT_INFO(node) \\r
	302	(((node)->u.str.flag & NODE_STRING_DONT_GET_OPT_INFO) != 0)\r
303	\r
304	#define BACKREFS_P(br) \\r
305	(IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static)\r
306	\r
307	/* node status bits */\r
308	#define NODE_ST_MIN_FIXED (1<<0)\r
309	#define NODE_ST_MAX_FIXED (1<<1)\r
310	#define NODE_ST_CLEN_FIXED (1<<2)\r
311	#define NODE_ST_MARK1 (1<<3)\r
312	#define NODE_ST_MARK2 (1<<4)\r
313	#define NODE_ST_STRICT_REAL_REPEAT (1<<5)\r
314	#define NODE_ST_RECURSION (1<<6)\r
315	#define NODE_ST_CALLED (1<<7)\r
316	#define NODE_ST_ADDR_FIXED (1<<8)\r
317	#define NODE_ST_NAMED_GROUP (1<<9)\r
318	#define NODE_ST_IN_REAL_REPEAT (1<<10) /* STK_REPEAT is nested in stack. */\r
319	#define NODE_ST_IN_ZERO_REPEAT (1<<11) /* (....){0} */\r
320	#define NODE_ST_IN_MULTI_ENTRY (1<<12)\r
321	#define NODE_ST_NEST_LEVEL (1<<13)\r
322	#define NODE_ST_BY_NUMBER (1<<14) /* {n,m} */\r
323	#define NODE_ST_BY_NAME (1<<15) /* backref by name */\r
324	#define NODE_ST_BACKREF (1<<16)\r
325	#define NODE_ST_CHECKER (1<<17)\r
326	#define NODE_ST_FIXED_OPTION (1<<18)\r
327	#define NODE_ST_PROHIBIT_RECURSION (1<<19)\r
328	#define NODE_ST_SUPER (1<<20)\r
329	\r
330	\r
331	#define NODE_STATUS(node) (((Node* )node)->u.base.status)\r
332	#define NODE_STATUS_ADD(node,f) (NODE_STATUS(node) \|= (NODE_ST_ ## f))\r
333	#define NODE_STATUS_REMOVE(node,f) (NODE_STATUS(node) &= ~(NODE_ST_ ## f))\r
334	\r
335	#define NODE_IS_BY_NUMBER(node) ((NODE_STATUS(node) & NODE_ST_BY_NUMBER) != 0)\r
336	#define NODE_IS_IN_REAL_REPEAT(node) ((NODE_STATUS(node) & NODE_ST_IN_REAL_REPEAT) != 0)\r
337	#define NODE_IS_CALLED(node) ((NODE_STATUS(node) & NODE_ST_CALLED) != 0)\r
338	#define NODE_IS_IN_MULTI_ENTRY(node) ((NODE_STATUS(node) & NODE_ST_IN_MULTI_ENTRY) != 0)\r
339	#define NODE_IS_RECURSION(node) ((NODE_STATUS(node) & NODE_ST_RECURSION) != 0)\r
340	#define NODE_IS_IN_ZERO_REPEAT(node) ((NODE_STATUS(node) & NODE_ST_IN_ZERO_REPEAT) != 0)\r
341	#define NODE_IS_NAMED_GROUP(node) ((NODE_STATUS(node) & NODE_ST_NAMED_GROUP) != 0)\r
342	#define NODE_IS_ADDR_FIXED(node) ((NODE_STATUS(node) & NODE_ST_ADDR_FIXED) != 0)\r
343	#define NODE_IS_CLEN_FIXED(node) ((NODE_STATUS(node) & NODE_ST_CLEN_FIXED) != 0)\r
344	#define NODE_IS_MIN_FIXED(node) ((NODE_STATUS(node) & NODE_ST_MIN_FIXED) != 0)\r
345	#define NODE_IS_MAX_FIXED(node) ((NODE_STATUS(node) & NODE_ST_MAX_FIXED) != 0)\r
346	#define NODE_IS_MARK1(node) ((NODE_STATUS(node) & NODE_ST_MARK1) != 0)\r
347	#define NODE_IS_MARK2(node) ((NODE_STATUS(node) & NODE_ST_MARK2) != 0)\r
348	#define NODE_IS_NEST_LEVEL(node) ((NODE_STATUS(node) & NODE_ST_NEST_LEVEL) != 0)\r
349	#define NODE_IS_BY_NAME(node) ((NODE_STATUS(node) & NODE_ST_BY_NAME) != 0)\r
350	#define NODE_IS_BACKREF(node) ((NODE_STATUS(node) & NODE_ST_BACKREF) != 0)\r
351	#define NODE_IS_CHECKER(node) ((NODE_STATUS(node) & NODE_ST_CHECKER) != 0)\r
352	#define NODE_IS_FIXED_OPTION(node) ((NODE_STATUS(node) & NODE_ST_FIXED_OPTION) != 0)\r
353	#define NODE_IS_SUPER(node) ((NODE_STATUS(node) & NODE_ST_SUPER) != 0)\r
354	#define NODE_IS_PROHIBIT_RECURSION(node) \\r
355	((NODE_STATUS(node) & NODE_ST_PROHIBIT_RECURSION) != 0)\r
356	#define NODE_IS_STRICT_REAL_REPEAT(node) \\r
357	((NODE_STATUS(node) & NODE_ST_STRICT_REAL_REPEAT) != 0)\r
358	\r
359	#define NODE_BODY(node) ((node)->u.base.body)\r
360	#define NODE_QUANT_BODY(node) ((node)->body)\r
361	#define NODE_BAG_BODY(node) ((node)->body)\r
362	#define NODE_CALL_BODY(node) ((node)->body)\r
363	#define NODE_ANCHOR_BODY(node) ((node)->body)\r
364	\r
b602265d DG	365	#define SCANENV_MEMENV_SIZE 8\r
	366	#define SCANENV_MEMENV(senv) \\r
	367	(IS_NOT_NULL((senv)->mem_env_dynamic) ? \\r
	368	(senv)->mem_env_dynamic : (senv)->mem_env_static)\r
	369	\r
	370	typedef struct {\r
	371	Node* node;\r
	372	#if 0\r
	373	int in;\r
	374	int recursion;\r
	375	#endif\r
	376	} MemEnv;\r
	377	\r
	378	typedef struct {\r
	379	enum SaveType type;\r
	380	} SaveItem;\r
14b0e578 CS	381	\r
14b0e578 CS	382	typedef struct {\r
b602265d	383	OnigOptionType options;\r
14b0e578 CS	384	OnigCaseFoldType case_fold_flag;\r
	385	OnigEncoding enc;\r
	386	OnigSyntaxType* syntax;\r
b602265d DG	387	MemStatusType capture_history;\r
	388	MemStatusType bt_mem_start;\r
	389	MemStatusType bt_mem_end;\r
	390	MemStatusType backrefed_mem;\r
14b0e578 CS	391	UChar* pattern;\r
	392	UChar* pattern_end;\r
	393	UChar* error;\r
	394	UChar* error_end;\r
	395	regex_t* reg; /* for reg->names only */\r
	396	int num_call;\r
b602265d	397	#ifdef USE_CALL\r
14b0e578	398	UnsetAddrList* unset_addr_list;\r
b602265d	399	int has_call_zero;\r
14b0e578 CS	400	#endif\r
14b0e578 CS	401	int num_mem;\r
14b0e578	402	int num_named;\r
14b0e578	403	int mem_alloc;\r
b602265d DG	404	MemEnv mem_env_static[SCANENV_MEMENV_SIZE];\r
	405	MemEnv* mem_env_dynamic;\r
	406	unsigned int parse_depth;\r
	407	\r
	408	int keep_num;\r
	409	int save_num;\r
	410	int save_alloc_num;\r
	411	SaveItem* saves;\r
14b0e578 CS	412	} ScanEnv;\r
	413	\r
	414	\r
	415	#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0)\r
	416	#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0)\r
	417	#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0)\r
	418	\r
14b0e578 CS	419	typedef struct {\r
	420	int new_val;\r
	421	} GroupNumRemap;\r
	422	\r
	423	extern int onig_renumber_name_table P_((regex_t* reg, GroupNumRemap* map));\r
14b0e578 CS	424	\r
	425	extern int onig_strncmp P_((const UChar* s1, const UChar* s2, int n));\r
	426	extern void onig_strcpy P_((UChar* dest, const UChar* src, const UChar* end));\r
	427	extern void onig_scan_env_set_error_string P_((ScanEnv* env, int ecode, UChar* arg, UChar* arg_end));\r
	428	extern int onig_scan_unsigned_number P_((UChar** src, const UChar* end, OnigEncoding enc));\r
	429	extern void onig_reduce_nested_quantifier P_((Node* pnode, Node* cnode));\r
	430	extern void onig_node_conv_to_str_node P_((Node* node, int raw));\r
	431	extern int onig_node_str_cat P_((Node* node, const UChar* s, const UChar* end));\r
	432	extern int onig_node_str_set P_((Node* node, const UChar* s, const UChar* end));\r
	433	extern void onig_node_free P_((Node* node));\r
b26691c4	434	extern Node* onig_node_new_bag P_((enum BagType type));\r
b602265d	435	extern Node* onig_node_new_anchor P_((int type, int ascii_mode));\r
14b0e578 CS	436	extern Node* onig_node_new_str P_((const UChar* s, const UChar* end));\r
	437	extern Node* onig_node_new_list P_((Node* left, Node* right));\r
	438	extern Node* onig_node_list_add P_((Node* list, Node* x));\r
	439	extern Node* onig_node_new_alt P_((Node* left, Node* right));\r
	440	extern void onig_node_str_clear P_((Node* node));\r
14b0e578	441	extern int onig_names_free P_((regex_t* reg));\r
b602265d	442	extern int onig_parse_tree P_((Node** root, const UChar* pattern, const UChar* end, regex_t* reg, ScanEnv* env));\r
14b0e578	443	extern int onig_free_shared_cclass_table P_((void));\r
b602265d DG	444	extern int onig_is_code_in_cc P_((OnigEncoding enc, OnigCodePoint code, CClassNode* cc));\r
	445	extern OnigLen onig_get_tiny_min_len(Node* node, unsigned int inhibit_node_types, int* invalid_node);\r
	446	\r
	447	#ifdef USE_CALLOUT\r
	448	extern int onig_global_callout_names_free(void);\r
	449	#endif\r
14b0e578 CS	450	\r
14b0e578 CS	451	#ifdef ONIG_DEBUG\r
14b0e578 CS	452	extern int onig_print_names(FILE, regex_t);\r
14b0e578 CS	453	#endif\r
14b0e578 CS	454	\r
14b0e578 CS	455	#endif /* REGPARSE_H */\r