Lines Matching refs:state
16 SRE(at)(SRE_STATE* state, const SRE_CHAR* ptr, SRE_CODE at)
26 return ((void*) ptr == state->beginning);
29 return ((void*) ptr == state->beginning ||
33 return (((SRE_CHAR *)state->end - ptr == 1 &&
35 ((void*) ptr == state->end));
38 return ((void*) ptr == state->end ||
42 return ((void*) ptr == state->end);
45 if (state->beginning == state->end)
47 thatp = ((void*) ptr > state->beginning) ?
49 thisp = ((void*) ptr < state->end) ?
54 if (state->beginning == state->end)
56 thatp = ((void*) ptr > state->beginning) ?
58 thisp = ((void*) ptr < state->end) ?
63 if (state->beginning == state->end)
65 thatp = ((void*) ptr > state->beginning) ?
67 thisp = ((void*) ptr < state->end) ?
72 if (state->beginning == state->end)
74 thatp = ((void*) ptr > state->beginning) ?
76 thisp = ((void*) ptr < state->end) ?
81 if (state->beginning == state->end)
83 thatp = ((void*) ptr > state->beginning) ?
85 thisp = ((void*) ptr < state->end) ?
90 if (state->beginning == state->end)
92 thatp = ((void*) ptr > state->beginning) ?
94 thisp = ((void*) ptr < state->end) ?
104 SRE(charset)(SRE_STATE* state, const SRE_CODE* set, SRE_CODE ch)
191 SRE(charset_loc_ignore)(SRE_STATE* state, const SRE_CODE* set, SRE_CODE ch)
195 if (SRE(charset)(state, set, lo))
199 return up != lo && SRE(charset)(state, set, up);
202 LOCAL(Py_ssize_t) SRE(match)(SRE_STATE* state, const SRE_CODE* pattern, int toplevel);
205 SRE(count)(SRE_STATE* state, const SRE_CODE* pattern, Py_ssize_t maxcount)
209 const SRE_CHAR* ptr = (const SRE_CHAR *)state->ptr;
210 const SRE_CHAR* end = (const SRE_CHAR *)state->end;
222 while (ptr < end && SRE(charset)(state, pattern + 2, *ptr))
319 while ((SRE_CHAR*) state->ptr < end) {
320 i = SRE(match)(state, pattern, 0);
327 (SRE_CHAR*) state->ptr - ptr));
328 return (SRE_CHAR*) state->ptr - ptr;
332 ptr - (SRE_CHAR*) state->ptr));
333 return ptr - (SRE_CHAR*) state->ptr;
366 ctx->lastmark = state->lastmark; \
367 ctx->lastindex = state->lastindex; \
371 state->lastmark = ctx->lastmark; \
372 state->lastindex = ctx->lastindex; \
386 #define DATA_STACK_ALLOC(state, type, ptr) \
388 alloc_pos = state->data_stack_base; \
391 if (sizeof(type) > state->data_stack_size - alloc_pos) { \
392 int j = data_stack_grow(state, sizeof(type)); \
395 DATA_STACK_LOOKUP_AT(state, SRE(match_context), ctx, ctx_pos); \
397 ptr = (type*)(state->data_stack+alloc_pos); \
398 state->data_stack_base += sizeof(type); \
401 #define DATA_STACK_LOOKUP_AT(state, type, ptr, pos) \
404 ptr = (type*)(state->data_stack+pos); \
407 #define DATA_STACK_PUSH(state, data, size) \
410 data, state->data_stack_base, size)); \
411 if (size > state->data_stack_size - state->data_stack_base) { \
412 int j = data_stack_grow(state, size); \
415 DATA_STACK_LOOKUP_AT(state, SRE(match_context), ctx, ctx_pos); \
417 memcpy(state->data_stack+state->data_stack_base, data, size); \
418 state->data_stack_base += size; \
424 #define DATA_STACK_POP(state, data, size, discard) \
427 data, state->data_stack_base-size, size)); \
428 memcpy((void*) data, state->data_stack+state->data_stack_base-size, size); \
430 state->data_stack_base -= size; \
433 #define DATA_STACK_POP_DISCARD(state, size) \
436 state->data_stack_base-size, size)); \
437 state->data_stack_base -= size; \
441 DATA_STACK_PUSH(state, (x), sizeof(*(x)))
443 DATA_STACK_POP(state, (x), sizeof(*(x)), 1)
445 DATA_STACK_POP_DISCARD(state, sizeof(*(x)))
447 DATA_STACK_ALLOC(state, t, p)
449 DATA_STACK_LOOKUP_AT(state,t,p,pos)
454 DATA_STACK_PUSH(state, state->mark, _marks_size); \
459 DATA_STACK_POP(state, state->mark, _marks_size, 1); \
464 DATA_STACK_POP(state, state->mark, _marks_size, 0); \
469 DATA_STACK_POP_DISCARD(state, _marks_size); \
560 SRE(match)(SRE_STATE* state, const SRE_CODE* pattern, int toplevel)
562 const SRE_CHAR* end = (const SRE_CHAR *)state->end;
571 TRACE(("|%p|%p|ENTER\n", pattern, state->ptr));
586 const SRE_CHAR *ptr = (SRE_CHAR *)state->ptr;
616 state->lastindex = i/2 + 1;
617 if (i > state->lastmark) {
618 /* state->lastmark is the highest valid index in the
619 state->mark array. If it is increased by more than 1,
622 int j = state->lastmark + 1;
624 state->mark[j++] = NULL;
625 state->lastmark = i;
627 state->mark[i] = ptr;
658 ((state->match_all && ptr != state->end) ||
659 (state->must_advance && ptr == state->start)))
663 state->ptr = ptr;
670 if (!SRE(at)(state, ptr, *pattern))
709 !SRE(charset)(state, pattern + 1, *ptr))
778 || !SRE(charset)(state, pattern+1,
788 || !SRE(charset)(state, pattern+1,
798 || !SRE(charset_loc_ignore)(state, pattern+1, *ptr))
818 if (state->repeat)
827 !SRE(charset)(state, pattern + 3,
830 state->ptr = ptr;
833 if (state->repeat)
838 if (state->repeat)
842 if (state->repeat)
862 state->ptr = ptr;
864 ret = SRE(count)(state, pattern+3, pattern[2]);
879 ptr == state->end &&
880 !(ctx->toplevel && state->must_advance && ptr == state->start))
883 state->ptr = ptr;
888 if (state->repeat)
903 state->ptr = ptr;
907 if (state->repeat)
912 if (state->repeat)
919 if (state->repeat)
924 state->ptr = ptr;
928 if (state->repeat)
933 if (state->repeat)
940 if (state->repeat)
961 state->ptr = ptr;
967 ret = SRE(count)(state, pattern+3, pattern[1]);
980 ((state->match_all && ptr != state->end) ||
981 (state->must_advance && ptr == state->start))))
984 state->ptr = ptr;
990 if (state->repeat)
995 state->ptr = ptr;
999 if (state->repeat)
1004 if (state->repeat)
1008 state->ptr = ptr;
1009 ret = SRE(count)(state, pattern+3, 1);
1018 if (state->repeat)
1042 state->ptr = ptr;
1044 ret = SRE(count)(state, pattern + 3, pattern[2]);
1066 ptr == state->end &&
1067 !(ctx->toplevel && state->must_advance && ptr == state->start))
1070 state->ptr = ptr;
1095 ctx->u.rep->prev = state->repeat;
1097 state->repeat = ctx->u.rep;
1099 state->ptr = ptr;
1101 state->repeat = ctx->u.rep->prev;
1117 ctx->u.rep = state->repeat;
1121 state->ptr = ptr;
1138 state->ptr = ptr;
1144 state->ptr != ctx->u.rep->last_ptr) {
1152 ctx->u.rep->last_ptr = state->ptr;
1164 state->ptr = ptr;
1169 state->repeat = ctx->u.rep->prev;
1171 state->repeat = ctx->u.rep; // restore repeat before return
1174 state->ptr = ptr;
1181 ctx->u.rep = state->repeat;
1185 state->ptr = ptr;
1202 state->ptr = ptr;
1207 state->repeat = ctx->u.rep->prev;
1210 if (state->repeat)
1214 SRE_REPEAT *repeat_of_tail = state->repeat;
1215 state->repeat = ctx->u.rep; // restore repeat before return
1227 state->ptr = ptr;
1231 state->ptr == ctx->u.rep->last_ptr)
1237 ctx->u.rep->last_ptr = state->ptr;
1246 state->ptr = ptr;
1258 state->ptr = ptr;
1273 state->ptr = ptr;
1279 doesn't match the global state so that the while loop can
1287 state->ptr != ptr) {
1288 /* Save the Capture Group Marker state into the current
1297 state. When the loop reaches the next iteration,
1299 position with the global state holding the Input
1301 the most recent match. Thus, if state's Input
1309 ptr = state->ptr;
1333 state. */
1346 ptr = state->ptr;
1356 state->ptr = ptr;
1370 state->ptr = ptr;
1378 ptr = state->ptr;
1387 if (groupref >= state->lastmark) {
1390 SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];
1391 SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];
1411 if (groupref >= state->lastmark) {
1414 SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];
1415 SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];
1436 if (groupref >= state->lastmark) {
1439 SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];
1440 SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];
1461 if (groupref >= state->lastmark) {
1464 SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];
1465 SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];
1486 if (groupref >= state->lastmark) {
1490 SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];
1491 SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];
1506 if (ptr - (SRE_CHAR *)state->beginning < (Py_ssize_t)pattern[1])
1508 state->ptr = ptr - pattern[1];
1519 if (ptr - (SRE_CHAR *)state->beginning >= (Py_ssize_t)pattern[1]) {
1520 state->ptr = ptr - pattern[1];
1522 if (state->repeat)
1527 if (state->repeat)
1532 if (state->repeat)
1628 do { state->lastmark = state->lastindex = -1; } while (0)
1631 SRE(search)(SRE_STATE* state, SRE_CODE* pattern)
1633 SRE_CHAR* ptr = (SRE_CHAR *)state->start;
1634 SRE_CHAR* end = (SRE_CHAR *)state->end;
1691 end = (SRE_CHAR *)state->end;
1692 state->must_advance = 0;
1699 state->start = ptr;
1700 state->ptr = ptr + prefix_skip;
1703 status = SRE(match)(state, pattern + 2*prefix_skip, 0);
1717 end = (SRE_CHAR *)state->end;
1735 state->must_advance = 0;
1745 state->start = ptr - (prefix_len - 1);
1746 state->ptr = ptr - (prefix_len - prefix_skip - 1);
1749 status = SRE(match)(state, pattern + 2*prefix_skip, 0);
1765 end = (SRE_CHAR *)state->end;
1766 state->must_advance = 0;
1768 while (ptr < end && !SRE(charset)(state, charset, *ptr))
1773 state->start = ptr;
1774 state->ptr = ptr;
1775 status = SRE(match)(state, pattern, 0);
1785 state->start = state->ptr = ptr;
1786 status = SRE(match)(state, pattern, 1);
1787 state->must_advance = 0;
1792 state->start = state->ptr = ptr = end;
1799 state->start = state->ptr = ptr;
1800 status = SRE(match)(state, pattern, 0);