Lines Matching defs:env
249 _matchpush(Env_t* env, Rex_t* rex)
261 env->error = REG_ESPACE;
265 f->match = m = env->match + rex->re.group.number;
281 pospush(Env_t* env, Rex_t* rex, unsigned char* p, int be)
285 if (!(pos = vector(Pos_t, env->pos, env->pos->cur)))
287 env->error = REG_ESPACE;
293 env->pos->cur++;
306 better(Env_t* env, Pos_t* os, Pos_t* ns, Pos_t* oend, Pos_t* nend, int level)
313 if (env->error)
317 DEBUG_CODE(0x0080,{sfprintf(sfstdout, " %-*.*sold ", (level + 3) * 4, (level + 3) * 4, "");for (oe = os; oe < oend; oe++)sfprintf(sfstdout, "<%d,%d,%d>", oe->p - env->beg, oe->serial, oe->be);sfprintf(sfstdout, "\n %-*.*snew ", (level + 3) * 4, (level + 3) * 4, "");for (oe = ns; oe < nend; oe++)sfprintf(sfstdout, "<%d,%d,%d>", oe->p - env->beg, oe->serial, oe->be);sfprintf(sfstdout, "\n");},{0;});
327 env->error = REG_PANIC;
358 if (k = better(env, os + 1, ns + 1, oe, ne, level + 1))
384 _better(Env_t* env, Pos_t* os, Pos_t* ns, Pos_t* oend, Pos_t* nend, int level)
388 DEBUG_CODE(0x0040,{sfprintf(sfstdout, "AHA better old ");for (i = 0; i <= env->nsub; i++)showmatch(&env->best[i]);sfprintf(sfstdout, "\n new ");for (i = 0; i <= env->nsub; i++)showmatch(&env->match[i]);sfprintf(sfstdout, "\n");},{0;});
389 i = better(env, os, ns, oend, nend, 0);
403 parserep(Env_t* env, Rex_t* rex, Rex_t* cont, unsigned char* s, int n)
409 DEBUG_TEST(0x0010,(sfprintf(sfstdout, "AHA#%04d 0x%04x parserep %s %d %d %d %d `%-.*s'\n", __LINE__, debug_flag, rexname(rex->re.group.expr.rex), rex->re.group.number, rex->lo, n, rex->hi, env->end - s, s)),(0));
412 if (env->stack && pospush(env, rex, s, END_ANY))
414 i = follow(env, rex, cont, s);
415 if (env->stack)
416 pospop(env);
439 if (env->stack)
441 if (matchpush(env, rex))
443 if (pospush(env, rex, s, BEG_ONE))
445 DEBUG_TEST(0x0004,(sfprintf(sfstdout,"AHA#%04d 0x%04x PUSH %d (%d,%d)(%d,%d)(%d,%d) (%d,%d)(%d,%d)(%d,%d)\n", __LINE__, debug_flag, rex->re.group.number, env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->best[2].rm_so, env->best[2].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo, env->match[2].rm_so, env->match[2].rm_eo)),(0));
447 r = parse(env, rex->re.group.expr.rex, &catcher, s);
448 DEBUG_TEST(0x0010,(sfprintf(sfstdout, "AHA#%04d 0x%04x parserep parse %d %d `%-.*s'\n", __LINE__, debug_flag, rex->re.group.number, r, env->end - s, s)),(0));
449 if (env->stack)
451 pospop(env);
452 matchpop(env, rex);
453 DEBUG_TEST(0x0004,(sfprintf(sfstdout,"AHA#%04d 0x%04x POP %d %d (%d,%d)(%d,%d)(%d,%d) (%d,%d)(%d,%d)(%d,%d)\n", __LINE__, debug_flag, rex->re.group.number, r, env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->best[2].rm_so, env->best[2].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo, env->match[2].rm_so, env->match[2].rm_eo)),(0));
475 if (env->stack && pospush(env, rex, s, END_ANY))
477 i = follow(env, rex, cont, s);
478 if (env->stack)
479 pospop(env);
500 parsetrie(Env_t* env, Trie_node_t* x, Rex_t* rex, Rex_t* cont, unsigned char* s)
509 if (s >= env->end)
524 if (s >= env->end)
537 switch (follow(env, rex, cont, s))
548 switch (parsetrie(env, x->son, rex, cont, s))
568 switch (follow(env, rex, cont, s))
798 parse(Env_t* env, Rex_t* rex, Rex_t* cont, unsigned char* s)
820 DEBUG_TEST(0x0008,(sfprintf(sfstdout, "AHA#%04d 0x%04x parse %s `%-.*s'\n", __LINE__, debug_flag, rexname(rex), env->end - s, s)),(0));
824 if (env->stack)
826 if (matchpush(env, rex))
828 if (pospush(env, rex, s, BEG_ALT))
834 r = parse(env, rex->re.group.expr.binary.left, &catcher, s);
837 matchcopy(env, rex);
838 ((Pos_t*)env->pos->vec + env->pos->cur - 1)->serial = catcher.serial = rex->re.group.expr.binary.serial;
839 n = parse(env, rex->re.group.expr.binary.right, &catcher, s);
843 pospop(env);
844 matchpop(env, rex);
848 if ((r = parse(env, rex->re.group.expr.binary.left, cont, s)) == NONE)
849 r = parse(env, rex->re.group.expr.binary.right, cont, s);
855 if (pospush(env, rex, s, END_ANY))
857 r = follow(env, rex, rex->re.alt_catch.cont, s);
858 pospop(env);
861 o = &env->match[rex->lo];
866 if (e > env->end)
868 t = env->beg + o->rm_so;
893 if ((!(rex->flags & REG_NEWLINE) || s <= env->beg || *(s - 1) != '\n') && ((env->flags & REG_NOTBOL) || s != env->beg))
897 if (LEADING(env, rex, s))
900 if (n > env->end - s)
901 n = env->end - s;
915 switch (follow(env, rex, cont, s))
936 switch (follow(env, rex, cont, s))
953 if (LEADING(env, rex, s))
956 if (n > env->end - s)
957 n = env->end - s;
962 e = env->end;
967 env->error = REG_ESPACE;
976 switch (follow(env, rex, cont, s))
1000 switch (follow(env, rex, cont, s))
1024 return parse(env, rex->re.group.expr.binary.left, &catcher, s);
1037 if (!env->stack)
1039 n = s - env->beg;
1040 r = env->nsub;
1041 DEBUG_TEST(0x0100,(sfprintf(sfstdout,"AHA#%04d 0x%04x %s (%d,%d)(%d,%d)(%d,%d)(%d,%d) (%d,%d)(%d,%d)\n", __LINE__, debug_flag, rexname(rex), env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->best[2].rm_so, env->best[2].rm_eo, env->best[3].rm_so, env->best[3].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo)),(0));
1042 if ((i = env->best[0].rm_eo) >= 0)
1054 if (n == i && better(env,
1055 (Pos_t*)env->bestpos->vec,
1056 (Pos_t*)env->pos->vec,
1057 (Pos_t*)env->bestpos->vec+env->bestpos->cur,
1058 (Pos_t*)env->pos->vec+env->pos->cur,
1062 env->best[0].rm_eo = n;
1063 memcpy(&env->best[1], &env->match[1], r * sizeof(regmatch_t));
1064 n = env->pos->cur;
1065 if (!vector(Pos_t, env->bestpos, n))
1067 env->error = REG_ESPACE;
1070 env->bestpos->cur = n;
1071 memcpy(env->bestpos->vec, env->pos->vec, n * sizeof(Pos_t));
1072 DEBUG_TEST(0x0100,(sfprintf(sfstdout,"AHA#%04d 0x%04x %s (%d,%d)(%d,%d)(%d,%d)(%d,%d) (%d,%d)(%d,%d)\n", __LINE__, debug_flag, rexname(rex), env->best[0].rm_so, env->best[0].rm_eo, env->best[1].rm_so, env->best[1].rm_eo, env->best[2].rm_so, env->best[2].rm_eo, env->best[3].rm_so, env->best[3].rm_eo, env->match[0].rm_so, env->match[0].rm_eo, env->match[1].rm_so, env->match[1].rm_eo)),(0));
1075 if (LEADING(env, rex, s))
1078 if (n > env->end - s)
1079 n = env->end - s;
1096 switch (follow(env, rex, cont, s))
1113 env->error = REG_ESPACE;
1116 e = env->end;
1120 switch (follow(env, rex, cont, s))
1144 switch (follow(env, rex, cont, s))
1157 e = env->end;
1162 switch (follow(env, rex, cont, s))
1176 if ((!(rex->flags & REG_NEWLINE) || *s != '\n') && ((env->flags & REG_NOTEOL) || s < env->end))
1180 DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s `%-.*s'\n", __LINE__, debug_flag, rexname(rex), env->end - s, s)),(0));
1181 if (env->stack)
1184 env->match[rex->re.group.number].rm_so = s - env->beg;
1185 if (pospush(env, rex, s, BEG_SUB))
1187 catcher.re.group_catch.eo = rex->re.group.number ? &env->match[rex->re.group.number].rm_eo : (regoff_t*)0;
1193 r = parse(env, rex->re.group.expr.rex, &catcher, s);
1194 if (env->stack)
1196 pospop(env);
1198 env->match[rex->re.group.number].rm_so = -1;
1202 DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s=>%s `%-.*s'\n", __LINE__, debug_flag, rexname(rex), rexname(rex->re.group_catch.cont), env->end - s, s)),(0));
1203 if (env->stack)
1206 *rex->re.group_catch.eo = s - env->beg;
1207 if (pospush(env, rex, s, END_ANY))
1210 r = follow(env, rex, rex->re.group_catch.cont, s);
1211 if (env->stack)
1213 pospop(env);
1225 return parse(env, rex->re.group.expr.rex, &catcher, s);
1227 return follow(env, rex, rex->re.rep_catch.cont, rex->re.rep_catch.beg);
1229 r = parse(env, rex->re.group.expr.rex, NiL, s);
1231 r = follow(env, rex, cont, s);
1236 if ((s - env->beg) < rex->re.group.size)
1242 catcher.re.behind_catch.end = e = env->end;
1245 for (t = s - rex->re.group.size; t >= env->beg; t--)
1247 env->end = s;
1248 r = parse(env, rex->re.group.expr.rex, &catcher, t);
1249 env->end = e;
1257 env->end = rex->re.behind_catch.end;
1258 return follow(env, rex, rex->re.behind_catch.cont, rex->re.behind_catch.beg);
1260 if ((s - env->beg) < rex->re.group.size)
1267 e = env->end;
1268 env->end = s;
1269 for (t = s - rex->re.group.size; t >= env->beg; t--)
1271 r = parse(env, rex->re.group.expr.rex, &catcher, t);
1275 env->end = e;
1278 r = follow(env, rex, cont, s);
1301 r = parse(env, q, &catcher, s);
1305 else if (!rex->re.group.size || rex->re.group.size > 0 && env->match[rex->re.group.size].rm_so >= 0)
1316 return parse(env, q, &catcher, s);
1318 return follow(env, rex, cont, s);
1326 return parse(env, rex->re.cond_catch.next[1], &catcher, rex->re.cond_catch.beg);
1328 return follow(env, rex, rex->re.group_catch.cont, s);
1335 return parse(env, rex->re.group.expr.rex, &catcher, s);
1337 switch (r = follow(env, rex, rex->re.group_catch.cont, s))
1352 e = env->end;
1366 if (env->stack)
1367 env->best[0].rm_so = t - s - n;
1368 switch (follow(env, rex, cont, t))
1397 if (env->stack)
1398 env->best[0].rm_so = t - s - n;
1399 switch (follow(env, rex, cont, t))
1417 if (LEADING(env, rex, s))
1419 i = env->end - s;
1427 if (parse(env, rex->re.group.expr.rex, &catcher, s) == BAD)
1435 switch (follow(env, rex, cont, s + i))
1461 if (s >= env->end)
1467 if (s >= env->end || !(s = nestmatch(s, env->end, rex->re.nest.type, c)))
1475 if (!(s = nestmatch(s, env->end, rex->re.nest.type, c)))
1477 } while (s < env->end && !(rex->re.nest.type[*(s-1)] & (REX_NEST_delimiter|REX_NEST_separator|REX_NEST_terminator)));
1483 if (n > env->end - s)
1484 n = env->end - s;
1507 switch (follow(env, rex, cont, s))
1524 env->error = REG_ESPACE;
1527 e = env->end;
1549 switch (follow(env, rex, cont, s))
1580 switch (follow(env, rex, cont, s))
1602 switch (follow(env, rex, cont, s))
1629 switch (follow(env, rex, cont, s))
1653 switch (follow(env, rex, cont, s))
1671 if (env->stack && pospush(env, rex, s, BEG_REP))
1673 r = parserep(env, rex, cont, s, 0);
1674 if (env->stack)
1675 pospop(env);
1678 DEBUG_TEST(0x0020,(sfprintf(sfstdout, "AHA#%04d 0x%04x %s n %d len %d s `%-.*s'\n", __LINE__, debug_flag, rexname(rex), rex->re.rep_catch.n, s - rex->re.rep_catch.beg, env->end - s, s)),(0));
1679 if (env->stack && pospush(env, rex, s, END_ANY))
1688 if (!env->stack || s != rex->re.rep_catch.ref->re.rep_catch.beg && !rex->re.rep_catch.ref->re.group.expr.rex->re.group.back)
1690 else if (pospush(env, rex, s, END_ANY))
1694 r = follow(env, rex, rex->re.rep_catch.cont, s);
1695 pospop(env);
1699 r = parserep(env, rex->re.rep_catch.ref, rex->re.rep_catch.cont, s, rex->re.rep_catch.n);
1700 if (env->stack)
1701 pospop(env);
1704 DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s \"%-.*s\" `%-.*s'\n", __LINE__, debug_flag, rexname(rex), rex->re.string.size, rex->re.string.base, env->end - s, s)),(0));
1705 if (rex->re.string.size > (env->end - s))
1733 if (((s + rex->re.trie.min) > env->end) || !(x = rex->re.trie.root[rex->map ? rex->map[*s] : *s]))
1735 return parsetrie(env, x, rex, cont, s);
1738 r = (*env->disc->re_execf)(env->regex, rex->re.exec.data, rex->re.exec.text, rex->re.exec.size, (const char*)s, env->end - s, &u, env->disc);
1740 if (e >= s && e <= env->end)
1749 env->error = r;
1754 if (!isword(*s) || s > env->beg && isword(*(s - 1)))
1758 if (isword(*s) || s > env->beg && !isword(*(s - 1)))
1762 if (s > env->beg && isword(*(s - 1)) == isword(*s))
1766 if (s == env->beg || isword(*(s - 1)) != isword(*s))
1770 if (s != env->beg)
1774 for (t = s; t < env->end && *t == '\n'; t++);
1775 if (t < env->end)
1779 if (s < env->end)
1830 list(Env_t* env, Rex_t* rex)
1832 sfprintf(sfstderr, "AHA regex hard=%d stack=%p\n", env->hard, env->stack);
1854 Env_t* env;
1859 if (!p || !(env = p->env))
1862 return fatal(env->disc, REG_BADPAT, NiL);
1863 if (len < env->min)
1865 DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REG_NOMATCH %d %d\n", __LINE__, len, env->min)),(0));
1868 env->regex = p;
1869 env->beg = (unsigned char*)s;
1870 env->end = env->beg + len;
1871 stknew(stkstd, &env->stk);
1872 env->flags &= ~REG_EXEC;
1873 env->flags |= (flags & REG_EXEC);
1875 if (env->stack = env->hard || !(env->flags & REG_NOSUB) && nmatch)
1877 n = env->nsub;
1878 if (!(env->match = (regmatch_t*)stkpush(stkstd, 2 * (n + 1) * sizeof(regmatch_t))) ||
1879 !env->pos && !(env->pos = vecopen(16, sizeof(Pos_t))) ||
1880 !env->bestpos && !(env->bestpos = vecopen(16, sizeof(Pos_t))))
1885 env->pos->cur = env->bestpos->cur = 0;
1886 env->best = &env->match[n + 1];
1887 env->best[0].rm_so = 0;
1888 env->best[0].rm_eo = -1;
1890 env->match[i] = state.nomatch;
1894 DEBUG_TEST(0x1000,(list(env,env->rex)),(0));
1896 if ((e = env->rex)->type == REX_BM)
1936 if (env->stack)
1937 env->best[0].rm_so += i;
1947 if ((i = parse(env, e->next, &env->done, buf + index)) != NONE)
1949 if (env->stack)
1950 env->best[0].rm_so = index;
1951 n = env->nsub;
1965 n = env->nsub;
1968 j = env->once || (flags & REG_LEFT);
1970 while ((i = parse(env, e, &env->done, (unsigned char*)s)) == NONE || advance && !env->best[0].rm_eo && !(advance = 0))
1976 if ((unsigned char*)s > env->end - env->min)
1978 if (env->stack)
1979 env->best[0].rm_so += i;
1981 if ((flags & REG_LEFT) && env->stack && env->best[0].rm_so)
1984 if (k = env->error)
1988 k = env->error = REG_NOMATCH;
1991 if (!(env->flags & REG_NOSUB))
1993 k = (env->flags & (REG_SHELL|REG_AUGMENTED)) == (REG_SHELL|REG_AUGMENTED);
2000 match[m = j] = env->best[i];
2012 stkold(stkstd, &env->stk);
2013 env->stk.base = 0;
2015 fatal(p->env->disc, k, NiL);
2022 Env_t* env;
2024 if (p && (env = p->env))
2027 if (env->sub)
2033 p->env = 0;
2034 if (--env->refs <= 0 && !(env->disc->re_flags & REG_NOFREE))
2036 drop(env->disc, env->rex);
2037 if (env->pos)
2038 vecclose(env->pos);
2039 if (env->bestpos)
2040 vecclose(env->bestpos);
2041 if (env->stk.base)
2042 stkold(stkstd, &env->stk);
2043 alloc(env->disc, env, 0);