[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-2018  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
/* 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_ENCLOSURE =  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 GimmickType {\r
  GIMMICK_FAIL = 0,\r
  GIMMICK_KEEP = 1,\r
  GIMMICK_SAVE = 2,\r
  GIMMICK_UPDATE_VAR = 3,\r
#ifdef USE_CALLOUT\r
  GIMMICK_CALLOUT = 4,\r
#endif\r
};\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_ENCLOSURE  NODE_TYPE2BIT(NODE_ENCLOSURE)\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_IS_SIMPLE_TYPE(node) \\r
  ((NODE_TYPE2BIT(NODE_TYPE(node)) & \\r
    (NODE_BIT_STRING | NODE_BIT_CCLASS | NODE_BIT_CTYPE | NODE_BIT_BACKREF)) != 0)\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 ENCLOSURE_(node)   (&((node)->u.enclosure))\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 ANCHOR_ANYCHAR_INF_MASK  (ANCHOR_ANYCHAR_INF | ANCHOR_ANYCHAR_INF_ML)\r
#define ANCHOR_END_BUF_MASK      (ANCHOR_END_BUF | ANCHOR_SEMI_END_BUF)\r
\r
enum EnclosureType {\r
  ENCLOSURE_MEMORY = 0,\r
  ENCLOSURE_OPTION = 1,\r
  ENCLOSURE_STOP_BACKTRACK = 2,\r
  ENCLOSURE_IF_ELSE = 3,\r
};\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
#define NODE_STRING_RAW                (1<<0) /* by backslashed number */\r
#define NODE_STRING_AMBIG              (1<<1)\r
#define NODE_STRING_DONT_GET_OPT_INFO  (1<<2)\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_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_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
enum QuantBodyEmpty {\r
  QUANT_BODY_IS_NOT_EMPTY = 0,\r
  QUANT_BODY_IS_EMPTY     = 1,\r
  QUANT_BODY_IS_EMPTY_MEM = 2,\r
  QUANT_BODY_IS_EMPTY_REC = 3\r
};\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_STOP_BT_SIMPLE_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_STOP_BT_SIMPLE_REPEAT(node) \\r
    ((NODE_STATUS(node) & NODE_ST_STOP_BT_SIMPLE_REPEAT) != 0)\r
\r
#define NODE_BODY(node)           ((node)->u.base.body)\r
#define NODE_QUANT_BODY(node)      ((node)->body)\r
#define NODE_ENCLOSURE_BODY(node)   ((node)->body)\r
#define NODE_CALL_BODY(node)      ((node)->body)\r
#define NODE_ANCHOR_BODY(node)    ((node)->body)\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    capa;    /* (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 QuantBodyEmpty body_empty_info;\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 EnclosureType 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
} EnclosureNode;\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 EnclosureNode : ENCLOSURE_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
    EnclosureNode enclosure;\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
\r
#define NULL_NODE  ((Node* )0)\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_enclosure P_((int 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
b602265d	7	* Copyright (c) 2002-2018 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
	34	/* node type */\r
b602265d DG	35	typedef enum {\r
	36	NODE_STRING = 0,\r
	37	NODE_CCLASS = 1,\r
	38	NODE_CTYPE = 2,\r
	39	NODE_BACKREF = 3,\r
	40	NODE_QUANT = 4,\r
	41	NODE_ENCLOSURE = 5,\r
	42	NODE_ANCHOR = 6,\r
	43	NODE_LIST = 7,\r
	44	NODE_ALT = 8,\r
	45	NODE_CALL = 9,\r
	46	NODE_GIMMICK = 10\r
	47	} NodeType;\r
	48	\r
	49	enum GimmickType {\r
	50	GIMMICK_FAIL = 0,\r
	51	GIMMICK_KEEP = 1,\r
	52	GIMMICK_SAVE = 2,\r
	53	GIMMICK_UPDATE_VAR = 3,\r
	54	#ifdef USE_CALLOUT\r
	55	GIMMICK_CALLOUT = 4,\r
	56	#endif\r
	57	};\r
	58	\r
14b0e578 CS	59	\r
14b0e578 CS	60	/* node type bit */\r
b602265d DG	61	#define NODE_TYPE2BIT(type) (1<<(type))\r
	62	\r
	63	#define NODE_BIT_STRING NODE_TYPE2BIT(NODE_STRING)\r
	64	#define NODE_BIT_CCLASS NODE_TYPE2BIT(NODE_CCLASS)\r
	65	#define NODE_BIT_CTYPE NODE_TYPE2BIT(NODE_CTYPE)\r
	66	#define NODE_BIT_BACKREF NODE_TYPE2BIT(NODE_BACKREF)\r
	67	#define NODE_BIT_QUANT NODE_TYPE2BIT(NODE_QUANT)\r
	68	#define NODE_BIT_ENCLOSURE NODE_TYPE2BIT(NODE_ENCLOSURE)\r
	69	#define NODE_BIT_ANCHOR NODE_TYPE2BIT(NODE_ANCHOR)\r
	70	#define NODE_BIT_LIST NODE_TYPE2BIT(NODE_LIST)\r
	71	#define NODE_BIT_ALT NODE_TYPE2BIT(NODE_ALT)\r
	72	#define NODE_BIT_CALL NODE_TYPE2BIT(NODE_CALL)\r
	73	#define NODE_BIT_GIMMICK NODE_TYPE2BIT(NODE_GIMMICK)\r
	74	\r
	75	#define NODE_IS_SIMPLE_TYPE(node) \\r
	76	((NODE_TYPE2BIT(NODE_TYPE(node)) & \\r
	77	(NODE_BIT_STRING \| NODE_BIT_CCLASS \| NODE_BIT_CTYPE \| NODE_BIT_BACKREF)) != 0)\r
	78	\r
	79	#define NODE_TYPE(node) ((node)->u.base.node_type)\r
	80	#define NODE_SET_TYPE(node, ntype) (node)->u.base.node_type = (ntype)\r
	81	\r
	82	#define STR_(node) (&((node)->u.str))\r
	83	#define CCLASS_(node) (&((node)->u.cclass))\r
	84	#define CTYPE_(node) (&((node)->u.ctype))\r
	85	#define BACKREF_(node) (&((node)->u.backref))\r
	86	#define QUANT_(node) (&((node)->u.quant))\r
	87	#define ENCLOSURE_(node) (&((node)->u.enclosure))\r
	88	#define ANCHOR_(node) (&((node)->u.anchor))\r
	89	#define CONS_(node) (&((node)->u.cons))\r
	90	#define CALL_(node) (&((node)->u.call))\r
	91	#define GIMMICK_(node) (&((node)->u.gimmick))\r
	92	\r
	93	#define NODE_CAR(node) (CONS_(node)->car)\r
	94	#define NODE_CDR(node) (CONS_(node)->cdr)\r
	95	\r
	96	#define CTYPE_ANYCHAR -1\r
	97	#define NODE_IS_ANYCHAR(node) \\r
	98	(NODE_TYPE(node) == NODE_CTYPE && CTYPE_(node)->ctype == CTYPE_ANYCHAR)\r
	99	\r
	100	#define CTYPE_OPTION(node, reg) \\r
	101	(NODE_IS_FIXED_OPTION(node) ? CTYPE_(node)->options : reg->options)\r
	102	\r
	103	\r
	104	#define ANCHOR_ANYCHAR_INF_MASK (ANCHOR_ANYCHAR_INF \| ANCHOR_ANYCHAR_INF_ML)\r
14b0e578 CS	105	#define ANCHOR_END_BUF_MASK (ANCHOR_END_BUF \| ANCHOR_SEMI_END_BUF)\r
14b0e578 CS	106	\r
b602265d DG	107	enum EnclosureType {\r
	108	ENCLOSURE_MEMORY = 0,\r
	109	ENCLOSURE_OPTION = 1,\r
	110	ENCLOSURE_STOP_BACKTRACK = 2,\r
	111	ENCLOSURE_IF_ELSE = 3,\r
	112	};\r
14b0e578	113	\r
b602265d DG	114	#define NODE_STRING_MARGIN 16\r
b602265d DG	115	#define NODE_STRING_BUF_SIZE 24 /* sizeof(CClassNode) - sizeof(int)4 /\r
14b0e578 CS	116	#define NODE_BACKREFS_SIZE 6\r
14b0e578 CS	117	\r
b602265d DG	118	#define NODE_STRING_RAW (1<<0) /* by backslashed number */\r
	119	#define NODE_STRING_AMBIG (1<<1)\r
	120	#define NODE_STRING_DONT_GET_OPT_INFO (1<<2)\r
	121	\r
	122	#define NODE_STRING_LEN(node) (int )((node)->u.str.end - (node)->u.str.s)\r
	123	#define NODE_STRING_SET_RAW(node) (node)->u.str.flag \|= NODE_STRING_RAW\r
	124	#define NODE_STRING_CLEAR_RAW(node) (node)->u.str.flag &= ~NODE_STRING_RAW\r
	125	#define NODE_STRING_SET_AMBIG(node) (node)->u.str.flag \|= NODE_STRING_AMBIG\r
	126	#define NODE_STRING_SET_DONT_GET_OPT_INFO(node) \\r
	127	(node)->u.str.flag \|= NODE_STRING_DONT_GET_OPT_INFO\r
	128	#define NODE_STRING_IS_RAW(node) \\r
	129	(((node)->u.str.flag & NODE_STRING_RAW) != 0)\r
	130	#define NODE_STRING_IS_AMBIG(node) \\r
	131	(((node)->u.str.flag & NODE_STRING_AMBIG) != 0)\r
	132	#define NODE_STRING_IS_DONT_GET_OPT_INFO(node) \\r
	133	(((node)->u.str.flag & NODE_STRING_DONT_GET_OPT_INFO) != 0)\r
14b0e578 CS	134	\r
14b0e578 CS	135	#define BACKREFS_P(br) \\r
b602265d DG	136	(IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static)\r
	137	\r
	138	enum QuantBodyEmpty {\r
	139	QUANT_BODY_IS_NOT_EMPTY = 0,\r
	140	QUANT_BODY_IS_EMPTY = 1,\r
	141	QUANT_BODY_IS_EMPTY_MEM = 2,\r
	142	QUANT_BODY_IS_EMPTY_REC = 3\r
	143	};\r
	144	\r
	145	/* node status bits */\r
	146	#define NODE_ST_MIN_FIXED (1<<0)\r
	147	#define NODE_ST_MAX_FIXED (1<<1)\r
	148	#define NODE_ST_CLEN_FIXED (1<<2)\r
	149	#define NODE_ST_MARK1 (1<<3)\r
	150	#define NODE_ST_MARK2 (1<<4)\r
	151	#define NODE_ST_STOP_BT_SIMPLE_REPEAT (1<<5)\r
	152	#define NODE_ST_RECURSION (1<<6)\r
	153	#define NODE_ST_CALLED (1<<7)\r
	154	#define NODE_ST_ADDR_FIXED (1<<8)\r
	155	#define NODE_ST_NAMED_GROUP (1<<9)\r
	156	#define NODE_ST_IN_REAL_REPEAT (1<<10) /* STK_REPEAT is nested in stack. */\r
	157	#define NODE_ST_IN_ZERO_REPEAT (1<<11) /* (....){0} */\r
	158	#define NODE_ST_IN_MULTI_ENTRY (1<<12)\r
	159	#define NODE_ST_NEST_LEVEL (1<<13)\r
	160	#define NODE_ST_BY_NUMBER (1<<14) /* {n,m} */\r
	161	#define NODE_ST_BY_NAME (1<<15) /* backref by name */\r
	162	#define NODE_ST_BACKREF (1<<16)\r
	163	#define NODE_ST_CHECKER (1<<17)\r
	164	#define NODE_ST_FIXED_OPTION (1<<18)\r
	165	#define NODE_ST_PROHIBIT_RECURSION (1<<19)\r
	166	#define NODE_ST_SUPER (1<<20)\r
	167	\r
	168	\r
	169	#define NODE_STATUS(node) (((Node* )node)->u.base.status)\r
	170	#define NODE_STATUS_ADD(node,f) (NODE_STATUS(node) \|= (NODE_ST_ ## f))\r
	171	#define NODE_STATUS_REMOVE(node,f) (NODE_STATUS(node) &= ~(NODE_ST_ ## f))\r
	172	\r
	173	#define NODE_IS_BY_NUMBER(node) ((NODE_STATUS(node) & NODE_ST_BY_NUMBER) != 0)\r
	174	#define NODE_IS_IN_REAL_REPEAT(node) ((NODE_STATUS(node) & NODE_ST_IN_REAL_REPEAT) != 0)\r
	175	#define NODE_IS_CALLED(node) ((NODE_STATUS(node) & NODE_ST_CALLED) != 0)\r
	176	#define NODE_IS_IN_MULTI_ENTRY(node) ((NODE_STATUS(node) & NODE_ST_IN_MULTI_ENTRY) != 0)\r
	177	#define NODE_IS_RECURSION(node) ((NODE_STATUS(node) & NODE_ST_RECURSION) != 0)\r
	178	#define NODE_IS_IN_ZERO_REPEAT(node) ((NODE_STATUS(node) & NODE_ST_IN_ZERO_REPEAT) != 0)\r
	179	#define NODE_IS_NAMED_GROUP(node) ((NODE_STATUS(node) & NODE_ST_NAMED_GROUP) != 0)\r
	180	#define NODE_IS_ADDR_FIXED(node) ((NODE_STATUS(node) & NODE_ST_ADDR_FIXED) != 0)\r
	181	#define NODE_IS_CLEN_FIXED(node) ((NODE_STATUS(node) & NODE_ST_CLEN_FIXED) != 0)\r
	182	#define NODE_IS_MIN_FIXED(node) ((NODE_STATUS(node) & NODE_ST_MIN_FIXED) != 0)\r
	183	#define NODE_IS_MAX_FIXED(node) ((NODE_STATUS(node) & NODE_ST_MAX_FIXED) != 0)\r
	184	#define NODE_IS_MARK1(node) ((NODE_STATUS(node) & NODE_ST_MARK1) != 0)\r
	185	#define NODE_IS_MARK2(node) ((NODE_STATUS(node) & NODE_ST_MARK2) != 0)\r
	186	#define NODE_IS_NEST_LEVEL(node) ((NODE_STATUS(node) & NODE_ST_NEST_LEVEL) != 0)\r
	187	#define NODE_IS_BY_NAME(node) ((NODE_STATUS(node) & NODE_ST_BY_NAME) != 0)\r
	188	#define NODE_IS_BACKREF(node) ((NODE_STATUS(node) & NODE_ST_BACKREF) != 0)\r
	189	#define NODE_IS_CHECKER(node) ((NODE_STATUS(node) & NODE_ST_CHECKER) != 0)\r
	190	#define NODE_IS_FIXED_OPTION(node) ((NODE_STATUS(node) & NODE_ST_FIXED_OPTION) != 0)\r
	191	#define NODE_IS_SUPER(node) ((NODE_STATUS(node) & NODE_ST_SUPER) != 0)\r
	192	#define NODE_IS_PROHIBIT_RECURSION(node) \\r
	193	((NODE_STATUS(node) & NODE_ST_PROHIBIT_RECURSION) != 0)\r
	194	#define NODE_IS_STOP_BT_SIMPLE_REPEAT(node) \\r
	195	((NODE_STATUS(node) & NODE_ST_STOP_BT_SIMPLE_REPEAT) != 0)\r
	196	\r
	197	#define NODE_BODY(node) ((node)->u.base.body)\r
	198	#define NODE_QUANT_BODY(node) ((node)->body)\r
	199	#define NODE_ENCLOSURE_BODY(node) ((node)->body)\r
200	#define NODE_CALL_BODY(node) ((node)->body)\r
201	#define NODE_ANCHOR_BODY(node) ((node)->body)\r
202	\r
14b0e578 CS	203	\r
14b0e578 CS	204	typedef struct {\r
b602265d DG	205	NodeType node_type;\r
	206	int status;\r
	207	\r
14b0e578 CS	208	UChar* s;\r
	209	UChar* end;\r
	210	unsigned int flag;\r
	211	int capa; /* (allocated size - 1) or 0: use buf[] */\r
b602265d	212	UChar buf[NODE_STRING_BUF_SIZE];\r
14b0e578 CS	213	} StrNode;\r
	214	\r
	215	typedef struct {\r
b602265d DG	216	NodeType node_type;\r
	217	int status;\r
	218	\r
	219	unsigned int flags;\r
	220	BitSet bs;\r
	221	BBuf* mbuf; /* multi-byte info or NULL */\r
	222	} CClassNode;\r
	223	\r
	224	typedef struct {\r
	225	NodeType node_type;\r
	226	int status;\r
	227	struct _Node* body;\r
	228	\r
14b0e578 CS	229	int lower;\r
	230	int upper;\r
	231	int greedy;\r
b602265d	232	enum QuantBodyEmpty body_empty_info;\r
14b0e578 CS	233	struct _Node* head_exact;\r
	234	struct _Node* next_head_exact;\r
	235	int is_refered; /* include called node. don't eliminate even if {0} */\r
b602265d	236	} QuantNode;\r
14b0e578 CS	237	\r
14b0e578 CS	238	typedef struct {\r
b602265d DG	239	NodeType node_type;\r
	240	int status;\r
	241	struct _Node* body;\r
	242	\r
	243	enum EnclosureType type;\r
	244	union {\r
	245	struct {\r
	246	int regnum;\r
	247	AbsAddrType called_addr;\r
	248	int entry_count;\r
	249	int called_state;\r
	250	} m;\r
	251	struct {\r
	252	OnigOptionType options;\r
	253	} o;\r
	254	struct {\r
	255	/* body is condition */\r
	256	struct _Node* Then;\r
	257	struct _Node* Else;\r
	258	} te;\r
	259	};\r
14b0e578	260	/* for multiple call reference */\r
b602265d DG	261	OnigLen min_len; /* min length (byte) */\r
	262	OnigLen max_len; /* max length (byte) */\r
	263	int char_len; /* character length */\r
	264	int opt_count; /* referenced count in optimize_nodes() */\r
	265	} EnclosureNode;\r
14b0e578	266	\r
b602265d	267	#ifdef USE_CALL\r
14b0e578 CS	268	\r
	269	typedef struct {\r
	270	int offset;\r
	271	struct _Node* target;\r
	272	} UnsetAddr;\r
	273	\r
	274	typedef struct {\r
	275	int num;\r
	276	int alloc;\r
	277	UnsetAddr* us;\r
	278	} UnsetAddrList;\r
	279	\r
	280	typedef struct {\r
b602265d DG	281	NodeType node_type;\r
	282	int status;\r
	283	struct _Node* body; /* to EnclosureNode : ENCLOSURE_MEMORY */\r
	284	\r
	285	int by_number;\r
14b0e578 CS	286	int group_num;\r
	287	UChar* name;\r
	288	UChar* name_end;\r
b602265d	289	int entry_count;\r
14b0e578 CS	290	} CallNode;\r
	291	\r
	292	#endif\r
	293	\r
	294	typedef struct {\r
b602265d DG	295	NodeType node_type;\r
	296	int status;\r
	297	\r
14b0e578 CS	298	int back_num;\r
	299	int back_static[NODE_BACKREFS_SIZE];\r
	300	int* back_dynamic;\r
	301	int nest_level;\r
b602265d	302	} BackRefNode;\r
14b0e578 CS	303	\r
14b0e578 CS	304	typedef struct {\r
b602265d DG	305	NodeType node_type;\r
	306	int status;\r
	307	struct _Node* body;\r
	308	\r
14b0e578	309	int type;\r
14b0e578	310	int char_len;\r
b602265d	311	int ascii_mode;\r
14b0e578 CS	312	} AnchorNode;\r
	313	\r
	314	typedef struct {\r
b602265d DG	315	NodeType node_type;\r
	316	int status;\r
	317	\r
14b0e578 CS	318	struct _Node* car;\r
	319	struct _Node* cdr;\r
	320	} ConsAltNode;\r
	321	\r
	322	typedef struct {\r
b602265d DG	323	NodeType node_type;\r
	324	int status;\r
	325	\r
14b0e578 CS	326	int ctype;\r
14b0e578 CS	327	int not;\r
b602265d DG	328	OnigOptionType options;\r
b602265d DG	329	int ascii_mode;\r
14b0e578 CS	330	} CtypeNode;\r
14b0e578 CS	331	\r
b602265d DG	332	typedef struct {\r
	333	NodeType node_type;\r
	334	int status;\r
	335	\r
	336	enum GimmickType type;\r
	337	int detail_type;\r
	338	int num;\r
	339	int id;\r
	340	} GimmickNode;\r
	341	\r
14b0e578 CS	342	typedef struct _Node {\r
14b0e578 CS	343	union {\r
b602265d DG	344	struct {\r
	345	NodeType node_type;\r
	346	int status;\r
	347	struct _Node* body;\r
	348	} base;\r
	349	\r
	350	StrNode str;\r
	351	CClassNode cclass;\r
	352	QuantNode quant;\r
	353	EnclosureNode enclosure;\r
	354	BackRefNode backref;\r
	355	AnchorNode anchor;\r
	356	ConsAltNode cons;\r
	357	CtypeNode ctype;\r
	358	#ifdef USE_CALL\r
	359	CallNode call;\r
14b0e578	360	#endif\r
b602265d	361	GimmickNode gimmick;\r
14b0e578 CS	362	} u;\r
	363	} Node;\r
	364	\r
	365	\r
	366	#define NULL_NODE ((Node* )0)\r
	367	\r
b602265d DG	368	#define SCANENV_MEMENV_SIZE 8\r
	369	#define SCANENV_MEMENV(senv) \\r
	370	(IS_NOT_NULL((senv)->mem_env_dynamic) ? \\r
	371	(senv)->mem_env_dynamic : (senv)->mem_env_static)\r
	372	\r
	373	typedef struct {\r
	374	Node* node;\r
	375	#if 0\r
	376	int in;\r
	377	int recursion;\r
	378	#endif\r
	379	} MemEnv;\r
	380	\r
	381	typedef struct {\r
	382	enum SaveType type;\r
	383	} SaveItem;\r
14b0e578 CS	384	\r
14b0e578 CS	385	typedef struct {\r
b602265d	386	OnigOptionType options;\r
14b0e578 CS	387	OnigCaseFoldType case_fold_flag;\r
	388	OnigEncoding enc;\r
	389	OnigSyntaxType* syntax;\r
b602265d DG	390	MemStatusType capture_history;\r
	391	MemStatusType bt_mem_start;\r
	392	MemStatusType bt_mem_end;\r
	393	MemStatusType backrefed_mem;\r
14b0e578 CS	394	UChar* pattern;\r
	395	UChar* pattern_end;\r
	396	UChar* error;\r
	397	UChar* error_end;\r
	398	regex_t* reg; /* for reg->names only */\r
	399	int num_call;\r
b602265d	400	#ifdef USE_CALL\r
14b0e578	401	UnsetAddrList* unset_addr_list;\r
b602265d	402	int has_call_zero;\r
14b0e578 CS	403	#endif\r
14b0e578 CS	404	int num_mem;\r
14b0e578	405	int num_named;\r
14b0e578	406	int mem_alloc;\r
b602265d DG	407	MemEnv mem_env_static[SCANENV_MEMENV_SIZE];\r
	408	MemEnv* mem_env_dynamic;\r
	409	unsigned int parse_depth;\r
	410	\r
	411	int keep_num;\r
	412	int save_num;\r
	413	int save_alloc_num;\r
	414	SaveItem* saves;\r
14b0e578 CS	415	} ScanEnv;\r
	416	\r
	417	\r
	418	#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0)\r
	419	#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0)\r
	420	#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0)\r
	421	\r
14b0e578 CS	422	typedef struct {\r
	423	int new_val;\r
	424	} GroupNumRemap;\r
	425	\r
	426	extern int onig_renumber_name_table P_((regex_t* reg, GroupNumRemap* map));\r
14b0e578 CS	427	\r
	428	extern int onig_strncmp P_((const UChar* s1, const UChar* s2, int n));\r
	429	extern void onig_strcpy P_((UChar* dest, const UChar* src, const UChar* end));\r
	430	extern void onig_scan_env_set_error_string P_((ScanEnv* env, int ecode, UChar* arg, UChar* arg_end));\r
	431	extern int onig_scan_unsigned_number P_((UChar** src, const UChar* end, OnigEncoding enc));\r
	432	extern void onig_reduce_nested_quantifier P_((Node* pnode, Node* cnode));\r
	433	extern void onig_node_conv_to_str_node P_((Node* node, int raw));\r
	434	extern int onig_node_str_cat P_((Node* node, const UChar* s, const UChar* end));\r
	435	extern int onig_node_str_set P_((Node* node, const UChar* s, const UChar* end));\r
	436	extern void onig_node_free P_((Node* node));\r
b602265d DG	437	extern Node* onig_node_new_enclosure P_((int type));\r
b602265d DG	438	extern Node* onig_node_new_anchor P_((int type, int ascii_mode));\r
14b0e578 CS	439	extern Node* onig_node_new_str P_((const UChar* s, const UChar* end));\r
	440	extern Node* onig_node_new_list P_((Node* left, Node* right));\r
	441	extern Node* onig_node_list_add P_((Node* list, Node* x));\r
	442	extern Node* onig_node_new_alt P_((Node* left, Node* right));\r
	443	extern void onig_node_str_clear P_((Node* node));\r
14b0e578	444	extern int onig_names_free P_((regex_t* reg));\r
b602265d	445	extern int onig_parse_tree P_((Node** root, const UChar* pattern, const UChar* end, regex_t* reg, ScanEnv* env));\r
14b0e578	446	extern int onig_free_shared_cclass_table P_((void));\r
b602265d DG	447	extern int onig_is_code_in_cc P_((OnigEncoding enc, OnigCodePoint code, CClassNode* cc));\r
	448	extern OnigLen onig_get_tiny_min_len(Node* node, unsigned int inhibit_node_types, int* invalid_node);\r
	449	\r
	450	#ifdef USE_CALLOUT\r
	451	extern int onig_global_callout_names_free(void);\r
	452	#endif\r
14b0e578 CS	453	\r
14b0e578 CS	454	#ifdef ONIG_DEBUG\r
14b0e578 CS	455	extern int onig_print_names(FILE, regex_t);\r
14b0e578 CS	456	#endif\r
14b0e578 CS	457	\r
14b0e578 CS	458	#endif /* REGPARSE_H */\r