[ICEs.git] / hppa-ICE-insn-constraints / regex.i.8

struct locale_data {
	unsigned int nstrings;
	union locale_data_value {
		char *string;
		unsigned int word;
	} values[];
};
extern __thread struct locale_data **_nl_current_LC_CTYPE
    __attribute__ ((tls_model("initial-exec")));
typedef unsigned long int reg_syntax_t;
extern reg_syntax_t re_syntax_options;
typedef enum {
	REG_ENOSYS
} reg_errcode_t;
typedef struct {
	unsigned char *buffer;
	reg_syntax_t syntax;
	char *fastmap;
	unsigned char *translate;
	unsigned int re_nsub;
} regex_t;
extern __thread void *__libc_tsd_CTYPE_TOLOWER;
inline int **__ctype_tolower_loc(void)
{
	union {
		void **ptr;
		int **tablep;
	} u;
	u.ptr = (&__libc_tsd_CTYPE_TOLOWER);
	if (*u.tablep == 0)
		*u.tablep =
		    ((int *)((*_nl_current_LC_CTYPE)->values[0].string) + 128);
	return u.tablep;
}
inline int tolower(int __c)
{
	return *__ctype_tolower_loc()[__c];
}
typedef struct {
} mbstate_t;
typedef unsigned long int *bitset_t;
typedef unsigned long int *re_bitset_ptr_t;
typedef struct {
	int nelem;
	int *elems;
} re_node_set;
typedef enum {
	NON_TYPE = 0, CHARACTER = 1, END_OF_RE = 2, SIMPLE_BRACKET =
	    3, OP_BACK_REF = 4, OP_PERIOD = 5, COMPLEX_BRACKET =
	    6, OP_UTF8_PERIOD = 7, OP_OPEN_SUBEXP = 8 | 0, OP_CLOSE_SUBEXP =
	    8 | 1, OP_ALT = 8 | 2, OP_DUP_ASTERISK = 8 | 3, ANCHOR =
	    8 | 4, CONCAT = 16, SUBEXP = 17, OP_DUP_PLUS =
	    18, 
} re_token_type_t;
typedef struct {
	long int *mbchars;
	int nmbchars;
} re_charset_t;
typedef struct {
	union {
		unsigned char c;
		re_bitset_ptr_t sbcset;
		re_charset_t *mbcset;
	} opr;
	re_token_type_t type:8;
} re_token_t;
typedef struct re_dfa_t re_dfa_t;
typedef struct bin_tree_t bin_tree_t;
struct re_dfastate_t {
	re_node_set nodes;
};
typedef struct re_dfastate_t re_dfastate_t;
struct re_dfa_t {
	re_token_t *nodes;
	unsigned int nodes_len;
	re_dfastate_t *init_state;
	bin_tree_t *str_tree;
	re_bitset_ptr_t sb_char;
	int nbackref;
	unsigned int has_mb_node:1;
	unsigned int is_utf8:1;
	unsigned int map_notascii:1;
	int mb_cur_max;
	int *subexp_map;
};
static reg_errcode_t re_compile_internal(regex_t * preg, const char *pattern,
					 unsigned int length,
					 reg_syntax_t syntax);
static void re_compile_fastmap_iter(regex_t * bufp,
				    const re_dfastate_t * init_state,
				    char *fastmap);
static reg_errcode_t analyze(regex_t * preg);
static reg_errcode_t optimize_subexps(void *extra, bin_tree_t * node);
const char *__re_compile_pattern(pattern, length, bufp)
const char *pattern;
{
	reg_errcode_t ret;
	ret = re_compile_internal(bufp, pattern, length, re_syntax_options);
}

int __re_compile_fastmap(regex_t * bufp)
{
	re_dfa_t *dfa = (re_dfa_t *) bufp->buffer;
	char *fastmap = bufp->fastmap;
	re_compile_fastmap_iter(bufp, dfa->init_state, fastmap);
}
static inline void re_set_fastmap(char *fastmap, int icase, int ch)
{
	if (icase) {
		int __res;
		if (sizeof(ch) > 1) {
			if (ch) {
			} else
				__res = tolower(ch);
		}
		fastmap[__res] = 1;
	}
}
static void re_compile_fastmap_iter(regex_t * bufp,
				    const re_dfastate_t * init_state,
				    char *fastmap)
{
	re_dfa_t *dfa = (re_dfa_t *) bufp->buffer;
	int node_cnt;
	int icase = (dfa->mb_cur_max == 1 && (bufp->syntax & 0x40000));
	for (node_cnt = 0; node_cnt < init_state->nodes.nelem; ++node_cnt) {
		int node = init_state->nodes.elems[node_cnt];
		re_token_type_t type = dfa->nodes[node].type;
		if (type == CHARACTER) {
			if ((bufp->syntax & 0x40000) && dfa->mb_cur_max > 1) {
				void *buf = alloca(dfa->mb_cur_max);
			}
			int i;
			int ch;
			for (; i < (256 / (sizeof(unsigned long int) * 8));) {
				int j;
				unsigned long int w =
				    dfa->nodes[node].opr.sbcset[i];
				for (; j < 8;)
					if (w & 1)
						re_set_fastmap(fastmap, icase,
							       ch);
			}
		} else if (type == COMPLEX_BRACKET) {
			int i;
			re_charset_t *cset = dfa->nodes[node].opr.mbcset;
			for (; i < cset->nmbchars;) {
				char buf[256];
				mbstate_t state;
				if (__wcrtomb(buf, cset->mbchars[i], &state) !=
				    -1)
					re_set_fastmap(fastmap, icase, *buf);
				if ((bufp->syntax & 0x4000)
				    && dfa->mb_cur_max > 1) {
				}
			}
		}
	}
}
static bitset_t utf8_sb_map;
static reg_errcode_t re_compile_internal(regex_t * preg, const char *pattern,
					 unsigned int length,
					 reg_syntax_t syntax)
{
	reg_errcode_t err;
	re_dfa_t *dfa;
	err = analyze(preg);
	if (dfa->is_utf8 && !(syntax & 0x400000) && preg->translate == 0)
		optimize_utf8(dfa);
	if (dfa->mb_cur_max == 6 && __extension__( {
						  unsigned int __s1_len =
						  strlen(((*_nl_current_LC_CTYPE)->values[0].string)); 
unsigned int __s2_len = strlen("UTF-8");
 (((!((int)((((*_nl_current_LC_CTYPE)->values[0].string)) + 1) - (int)(((*_nl_current_LC_CTYPE)->values[0].string)) == 1) || __s1_len >= 4) && (!((int)(("UTF-8") + 1) - (int)("UTF-8") == 1) || __s2_len >= 4)) ? strcmp(((*_nl_current_LC_CTYPE)->values[0].string), "UTF-8") : (((int)((((*_nl_current_LC_CTYPE)->values[0].string)) + 1) - (int)(((*_nl_current_LC_CTYPE)->values[0].string)) == 1) && (__s1_len = strlen(((*_nl_current_LC_CTYPE)->values[0].string)), __s1_len < 4) ? (((int)(("UTF-8") + 1) - (int)("UTF-8") == 1) ? strcmp(((*_nl_current_LC_CTYPE)->values[0].string), "UTF-8") : (
((*_nl_current_LC_CTYPE)->values[0].string[0] - 'U')

)):
(((int)(("UTF-8") + 1) - (int)("UTF-8") == 1) && (
__s2_len < 4) ? (((int)((((*_nl_current_LC_CTYPE)->values[0].string)) + 1) - (int)(((*_nl_current_LC_CTYPE)->values[0].string)) == 1) ? strcmp(((*_nl_current_LC_CTYPE)->values[0].string), "UTF-8") : (
((*_nl_current_LC_CTYPE)->values[0].string[0] - 'U')
)):																																																																																																																													 strcmp(((*_nl_current_LC_CTYPE)->values[0].string), "UTF-8"))));}
	    ) == 0)
		dfa->is_utf8 = 1;
	dfa->map_notascii = (*_nl_current_LC_CTYPE)->values[0].word != 0;
	if (dfa->mb_cur_max > 1) {
		if (dfa->is_utf8)
			dfa->sb_char = (re_bitset_ptr_t) utf8_sb_map;
		else {
			int i;
			int j;
			int ch;
			for (;
			     i < (256 / (sizeof(unsigned long int) * 8));
			     ++j, ++ch) {
				unsigned int wch = __btowc(ch);
				if (wch != (0xffffffffu))
					dfa->sb_char[i] |= 1 << j;
			}
		}
	}
	int node;
	int i;
	int mb_chars;
	int has_period;
	for (; node < dfa->nodes_len;)
		switch (dfa->nodes[node].type) {
		case CHARACTER:
			if (dfa->nodes[node].opr.c >= 0x80)
				mb_chars = 1;
			for (; i < (256 / (sizeof(unsigned long int) * 8));)
				if (dfa->nodes[node].opr.sbcset[i])
					return;
		}
	dfa->has_mb_node = dfa->nbackref > 0 || has_period;
}
static reg_errcode_t analyze(regex_t * preg)
{
	re_dfa_t *dfa = (re_dfa_t *) preg->buffer;
	if (dfa->subexp_map != 0) {
		int i;
		for (; i < preg->re_nsub;)
			dfa->subexp_map[i] = i;
		preorder(dfa->str_tree, optimize_subexps, dfa);
		for (; i < preg->re_nsub; i++)
			if (dfa->subexp_map[i] != i)
				break;
	}
}
Commit	Line	Data
45516216	1	struct locale_data {
	2	unsigned int nstrings;
	3	union locale_data_value {
	4	char *string;
	5	unsigned int word;
	6	} values[];
	7	};
	8	extern __thread struct locale_data **_nl_current_LC_CTYPE
	9	__attribute__ ((tls_model("initial-exec")));
	10	typedef unsigned long int reg_syntax_t;
	11	extern reg_syntax_t re_syntax_options;
	12	typedef enum {
	13	REG_ENOSYS
	14	} reg_errcode_t;
	15	typedef struct {
	16	unsigned char *buffer;
	17	reg_syntax_t syntax;
	18	char *fastmap;
	19	unsigned char *translate;
	20	unsigned int re_nsub;
	21	} regex_t;
	22	extern __thread void *__libc_tsd_CTYPE_TOLOWER;
	23	inline int **__ctype_tolower_loc(void)
	24	{
	25	union {
	26	void **ptr;
	27	int **tablep;
	28	} u;
	29	u.ptr = (&__libc_tsd_CTYPE_TOLOWER);
	30	if (*u.tablep == 0)
	31	*u.tablep =
	32	((int )((_nl_current_LC_CTYPE)->values[0].string) + 128);
	33	return u.tablep;
	34	}
	35	inline int tolower(int __c)
	36	{
	37	return *__ctype_tolower_loc()[__c];
	38	}
	39	typedef struct {
	40	} mbstate_t;
	41	typedef unsigned long int *bitset_t;
	42	typedef unsigned long int *re_bitset_ptr_t;
	43	typedef struct {
	44	int nelem;
	45	int *elems;
	46	} re_node_set;
	47	typedef enum {
	48	NON_TYPE = 0, CHARACTER = 1, END_OF_RE = 2, SIMPLE_BRACKET =
	49	3, OP_BACK_REF = 4, OP_PERIOD = 5, COMPLEX_BRACKET =
	50	6, OP_UTF8_PERIOD = 7, OP_OPEN_SUBEXP = 8 \| 0, OP_CLOSE_SUBEXP =
	51	8 \| 1, OP_ALT = 8 \| 2, OP_DUP_ASTERISK = 8 \| 3, ANCHOR =
	52	8 \| 4, CONCAT = 16, SUBEXP = 17, OP_DUP_PLUS =
	53	18,
	54	} re_token_type_t;
	55	typedef struct {
	56	long int *mbchars;
	57	int nmbchars;
	58	} re_charset_t;
	59	typedef struct {
	60	union {
	61	unsigned char c;
	62	re_bitset_ptr_t sbcset;
	63	re_charset_t *mbcset;
	64	} opr;
65	re_token_type_t type:8;
66	} re_token_t;
67	typedef struct re_dfa_t re_dfa_t;
68	typedef struct bin_tree_t bin_tree_t;
69	struct re_dfastate_t {
70	re_node_set nodes;
71	};
72	typedef struct re_dfastate_t re_dfastate_t;
73	struct re_dfa_t {
74	re_token_t *nodes;
75	unsigned int nodes_len;
76	re_dfastate_t *init_state;
77	bin_tree_t *str_tree;
78	re_bitset_ptr_t sb_char;
79	int nbackref;
80	unsigned int has_mb_node:1;
81	unsigned int is_utf8:1;
82	unsigned int map_notascii:1;
83	int mb_cur_max;
84	int *subexp_map;
85	};
86	static reg_errcode_t re_compile_internal(regex_t * preg, const char *pattern,
87	unsigned int length,
88	reg_syntax_t syntax);
89	static void re_compile_fastmap_iter(regex_t * bufp,
90	const re_dfastate_t * init_state,
91	char *fastmap);
92	static reg_errcode_t analyze(regex_t * preg);
93	static reg_errcode_t optimize_subexps(void extra, bin_tree_t node);
94	const char *__re_compile_pattern(pattern, length, bufp)
95	const char *pattern;
96	{
97	reg_errcode_t ret;
98	ret = re_compile_internal(bufp, pattern, length, re_syntax_options);
99	}
100
101	int __re_compile_fastmap(regex_t * bufp)
102	{
103	re_dfa_t dfa = (re_dfa_t ) bufp->buffer;
104	char *fastmap = bufp->fastmap;
105	re_compile_fastmap_iter(bufp, dfa->init_state, fastmap);
106	}
107	static inline void re_set_fastmap(char *fastmap, int icase, int ch)
108	{
109	if (icase) {
110	int __res;
111	if (sizeof(ch) > 1) {
112	if (ch) {
113	} else
114	__res = tolower(ch);
115	}
116	fastmap[__res] = 1;
117	}
118	}
119	static void re_compile_fastmap_iter(regex_t * bufp,
120	const re_dfastate_t * init_state,
121	char *fastmap)
122	{
123	re_dfa_t dfa = (re_dfa_t ) bufp->buffer;
124	int node_cnt;
125	int icase = (dfa->mb_cur_max == 1 && (bufp->syntax & 0x40000));
126	for (node_cnt = 0; node_cnt < init_state->nodes.nelem; ++node_cnt) {
127	int node = init_state->nodes.elems[node_cnt];
128	re_token_type_t type = dfa->nodes[node].type;
129	if (type == CHARACTER) {
130	if ((bufp->syntax & 0x40000) && dfa->mb_cur_max > 1) {
131	void *buf = alloca(dfa->mb_cur_max);
132	}
133	int i;
134	int ch;
135	for (; i < (256 / (sizeof(unsigned long int) * 8));) {
136	int j;
137	unsigned long int w =
138	dfa->nodes[node].opr.sbcset[i];
139	for (; j < 8;)
140	if (w & 1)
141	re_set_fastmap(fastmap, icase,
142	ch);
143	}
144	} else if (type == COMPLEX_BRACKET) {
145	int i;
146	re_charset_t *cset = dfa->nodes[node].opr.mbcset;
147	for (; i < cset->nmbchars;) {
148	char buf[256];
149	mbstate_t state;
150	if (__wcrtomb(buf, cset->mbchars[i], &state) !=
151	-1)
152	re_set_fastmap(fastmap, icase, *buf);
153	if ((bufp->syntax & 0x4000)
154	&& dfa->mb_cur_max > 1) {
155	}
156	}
157	}
158	}
159	}
160	static bitset_t utf8_sb_map;
161	static reg_errcode_t re_compile_internal(regex_t * preg, const char *pattern,
162	unsigned int length,
163	reg_syntax_t syntax)
164	{
165	reg_errcode_t err;
166	re_dfa_t *dfa;
167	err = analyze(preg);
168	if (dfa->is_utf8 && !(syntax & 0x400000) && preg->translate == 0)
169	optimize_utf8(dfa);
170	if (dfa->mb_cur_max == 6 && __extension__( {
171	unsigned int __s1_len =
172	strlen(((*_nl_current_LC_CTYPE)->values[0].string));
173	unsigned int __s2_len = strlen("UTF-8");
174	(((!((int)((((_nl_current_LC_CTYPE)->values[0].string)) + 1) - (int)(((_nl_current_LC_CTYPE)->values[0].string)) == 1) \|\| __s1_len >= 4) && (!((int)(("UTF-8") + 1) - (int)("UTF-8") == 1) \|\| __s2_len >= 4)) ? strcmp(((_nl_current_LC_CTYPE)->values[0].string), "UTF-8") : (((int)((((_nl_current_LC_CTYPE)->values[0].string)) + 1) - (int)(((_nl_current_LC_CTYPE)->values[0].string)) == 1) && (__s1_len = strlen(((_nl_current_LC_CTYPE)->values[0].string)), __s1_len < 4) ? (((int)(("UTF-8") + 1) - (int)("UTF-8") == 1) ? strcmp(((*_nl_current_LC_CTYPE)->values[0].string), "UTF-8") : (
175	((*_nl_current_LC_CTYPE)->values[0].string[0] - 'U')
176
177	)):
178	(((int)(("UTF-8") + 1) - (int)("UTF-8") == 1) && (
179	__s2_len < 4) ? (((int)((((_nl_current_LC_CTYPE)->values[0].string)) + 1) - (int)(((_nl_current_LC_CTYPE)->values[0].string)) == 1) ? strcmp(((*_nl_current_LC_CTYPE)->values[0].string), "UTF-8") : (
180	((*_nl_current_LC_CTYPE)->values[0].string[0] - 'U')
181	)): strcmp(((*_nl_current_LC_CTYPE)->values[0].string), "UTF-8"))));}
182	) == 0)
183	dfa->is_utf8 = 1;
184	dfa->map_notascii = (*_nl_current_LC_CTYPE)->values[0].word != 0;
185	if (dfa->mb_cur_max > 1) {
186	if (dfa->is_utf8)
187	dfa->sb_char = (re_bitset_ptr_t) utf8_sb_map;
188	else {
189	int i;
190	int j;
191	int ch;
192	for (;
193	i < (256 / (sizeof(unsigned long int) * 8));
194	++j, ++ch) {
195	unsigned int wch = __btowc(ch);
196	if (wch != (0xffffffffu))
197	dfa->sb_char[i] \|= 1 << j;
198	}
199	}
200	}
201	int node;
202	int i;
203	int mb_chars;
204	int has_period;
205	for (; node < dfa->nodes_len;)
206	switch (dfa->nodes[node].type) {
207	case CHARACTER:
208	if (dfa->nodes[node].opr.c >= 0x80)
209	mb_chars = 1;
210	for (; i < (256 / (sizeof(unsigned long int) * 8));)
211	if (dfa->nodes[node].opr.sbcset[i])
212	return;
213	}
214	dfa->has_mb_node = dfa->nbackref > 0 \|\| has_period;
215	}
216	static reg_errcode_t analyze(regex_t * preg)
217	{
218	re_dfa_t dfa = (re_dfa_t ) preg->buffer;
219	if (dfa->subexp_map != 0) {
220	int i;
221	for (; i < preg->re_nsub;)
222	dfa->subexp_map[i] = i;
223	preorder(dfa->str_tree, optimize_subexps, dfa);
224	for (; i < preg->re_nsub; i++)
225	if (dfa->subexp_map[i] != i)
226	break;
227	}
228	}