Lines Matching defs:inf
139 re_inf inf;
144 inf.alt = irec_comp(pattern,
151 inf.cod = NULL;
152 inf.len = inf.spc = 0;
153 inf.bas = 0;
154 inf.par = 0;
155 inf.ref = 0;
156 inf.apat = NULL;
157 inf.flags = flags;
158 inf.ecode = 0;
160 inf.sp[i] = 0;
163 if (rec_byte(&inf, flags & (RE_NEWLINE | RE_NOSUB)) == 0 &&
164 rec_byte(&inf, 0xff) == 0 &&
165 rec_build_alt(&inf, inf.alt) == 0 &&
166 rec_rep_spc(&inf, 0) == 0 &&
167 rec_code(&inf, Re_Done) == 0) {
171 if (inf.ref)
172 inf.cod[1] = inf.ref - 1;
173 preg->cod = inf.cod;
175 preg->re_nsub = inf.ref;
178 irec_free_alt(inf.alt);
179 if (inf.ecode)
180 free(inf.cod);
186 return (inf.ecode);
1743 rec_check(re_inf *inf, int count)
1745 if (inf->len + count >= inf->spc) {
1751 spc += count + inf->spc;
1752 if ((cod = realloc(inf->cod, spc)) == NULL)
1753 return (inf->ecode = RE_ESPACE);
1754 inf->cod = cod;
1755 inf->spc = spc;
1758 return (inf->ecode);
1762 rec_code(re_inf *inf, ReCode code)
1764 if (rec_check(inf, 1) == 0)
1765 inf->cod[inf->len++] = code;
1767 return (inf->ecode);
1771 rec_byte(re_inf *inf, int value)
1773 if (rec_check(inf, 1) == 0)
1774 inf->cod[inf->len++] = value;
1776 return (inf->ecode);
1780 rec_code_byte(re_inf *inf, ReCode code, int value)
1782 if (rec_check(inf, 2) == 0) {
1783 inf->cod[inf->len++] = code;
1784 inf->cod[inf->len++] = value;
1787 return (inf->ecode);
1791 rec_length(re_inf *inf, int length)
1796 return (inf->ecode = RE_ESPACE);
1807 if (rec_check(inf, two) == 0) {
1808 inf->cod[inf->len++] = lo;
1810 inf->cod[inf->len++] = hi >> 8;
1813 return (inf->ecode);
1817 rec_byte_byte(re_inf *inf, int value0, int value1)
1819 if (rec_check(inf, 2) == 0) {
1820 inf->cod[inf->len++] = value0;
1821 inf->cod[inf->len++] = value1;
1824 return (inf->ecode);
1828 rec_code_byte_byte(re_inf *inf, ReCode code, int value0, int value1)
1830 if (rec_check(inf, 3) == 0) {
1831 inf->cod[inf->len++] = code;
1832 inf->cod[inf->len++] = value0;
1833 inf->cod[inf->len++] = value1;
1836 return (inf->ecode);
1840 rec_build_alt(re_inf *inf, rec_alt *alt)
1842 int offset, value, bas = inf->bas + 1;
1846 if (rec_inc_spc(inf))
1847 return (inf->ecode);
1850 rec_code(inf, Re_Alt);
1852 offset = inf->len; /* Remember current offset */
1853 rec_byte_byte(inf, 0, 0); /* Reserve two bytes for retry address */
1854 while (alt && inf->ecode == 0) {
1855 if (rec_build_pat(inf, alt->pat))
1858 if (alt && inf->ecode == 0) {
1860 if (inf->bas != bas) {
1862 rec_build_pat(inf, inf->apat);
1864 rec_alt_spc(inf, bas - 1);
1868 if ((value = inf->len - offset) >= 16384) {
1869 inf->ecode = RE_ESPACE;
1872 inf->cod[offset] = value & 0xff;
1873 inf->cod[offset + 1] = (value & 0xff00) >> 8;
1875 rec_code(inf, Re_AltNext);
1876 offset = inf->len;
1877 rec_byte_byte(inf, 0, 0);
1880 if (inf->ecode == 0) {
1882 if (inf->bas != bas) {
1884 rec_build_pat(inf, inf->apat);
1886 rec_alt_spc(inf, bas - 1);
1890 if ((value = inf->len - offset) >= 16384)
1891 return (inf->ecode = RE_ESPACE);
1892 inf->cod[offset] = value & 0xff;
1893 inf->cod[offset + 1] = (value & 0xff00) >> 8;
1895 rec_code(inf, Re_AltDone);
1897 rec_dec_spc(inf);
1901 rec_build_pat(inf, alt->pat);
1904 return (inf->ecode);
1908 rec_build_pat(re_inf *inf, rec_pat *pat)
1913 while (pat && inf->ecode == 0) {
1915 bas = inf->bas;
1916 if (pat->type == Rep_Group && !inf->par && rec_code(inf, Re_Open))
1917 return (inf->ecode);
1918 if (rec_inc_spc(inf))
1919 return (inf->ecode);
1920 offset = inf->len;
1921 if (rec_build_rep(inf, pat->rep))
1924 jump = inf->len;
1925 rec_byte_byte(inf, 0, 0);
1931 if (rec_add_spc(inf, pat->type == Rep_AnyMaybe))
1932 return (inf->ecode);
1933 if (rec_code(inf, (ReCode)pat->type) == 0 &&
1934 rec_byte(inf, inf->bas - 1) == 0 &&
1935 rec_byte(inf, inf->ref - 1) == 0)
1936 rec_off_spc(inf);
1941 rec_code_byte(inf, (ReCode)pat->type, pat->data.chr);
1946 rec_code_byte_byte(inf, (ReCode)pat->type,
1951 if (rec_code(inf, (ReCode)pat->type) == 0)
1952 rec_build_rng(inf, pat->data.rng);
1958 rec_code(inf, (ReCode)pat->type);
1960 if (rec_length(inf, length) == 0 && rec_check(inf, length) == 0) {
1961 memcpy(inf->cod + inf->len, pat->data.str, length);
1962 inf->len += length;
1989 rec_code(inf, (ReCode)pat->type);
1992 rec_code_byte(inf, Re_Backref, pat->data.chr);
1995 if (pat->rep == NULL && !inf->par && rec_code(inf, Re_Open))
1997 apat = inf->apat;
1998 inf->apat = pat->next;
1999 rec_build_grp(inf, pat->data.grp);
2000 inf->apat = apat;
2003 rec_build_stl(inf, pat->data.stl);
2008 if (rec_dec_spc(inf))
2009 return (inf->ecode);
2011 if (rec_rep_spc(inf, bas))
2012 return (inf->ecode);
2014 distance = inf->len - offset;
2016 if (rec_code(inf, Re_RepLongJump) ||
2017 rec_byte(inf, inf->bas) ||
2018 rec_byte(inf, distance & 0xff) ||
2019 rec_byte(inf, (distance & 0xff00) >> 8))
2022 else if (rec_code(inf, Re_RepJump) ||
2023 rec_byte(inf, inf->bas) ||
2024 rec_byte(inf, distance))
2026 distance = inf->len - offset;
2027 inf->cod[jump] = distance & 0xff;
2028 inf->cod[jump + 1] = (distance & 0xff00) >> 8;
2033 return (inf->ecode);
2037 rec_build_rng(re_inf *inf, rec_rng *rng)
2039 if (rec_check(inf, sizeof(rng->range)) == 0) {
2040 memcpy(inf->cod + inf->len, rng->range, sizeof(rng->range));
2041 inf->len += sizeof(rng->range);
2044 return (inf->ecode);
2048 rec_build_grp(re_inf *inf, rec_grp *grp)
2050 int par = inf->par;
2052 if (!(inf->flags & RE_NOSUB)) {
2053 ++inf->par;
2055 ++inf->ref;
2056 if (rec_build_alt(inf, grp->alt) == 0) {
2059 rec_code_byte(inf, Re_Update, inf->ref - 1);
2061 rec_code(inf, Re_Close);
2064 --inf->par;
2067 rec_build_alt(inf, grp->alt);
2069 return (inf->ecode);
2073 rec_build_stl(re_inf *inf, rec_stl *stl)
2091 return (inf->ecode = RE_ESPACE);
2092 if (rec_check(inf, rlen) ||
2093 rec_code(inf, code))
2094 return (inf->ecode);
2098 inf->cod[inf->len++] = stl->nstrs;
2100 inf->cod[inf->len++] = rlen & 0xff;
2101 inf->cod[inf->len++] = (rlen & 0xff00) >> 8;
2105 inf->cod[inf->len++] = stl->lens[i];
2109 memcpy(inf->cod + inf->len, stl->strs[i], len);
2110 inf->len += len;
2114 inf->cod[inf->len++] = (long)stl->strs[i];
2116 inf->cod[inf->len++] = (long)stl->strs[i] & 0xff;
2117 inf->cod[inf->len++] = ((long)stl->strs[i] & 0xff00) >> 8;
2127 memset(inf->cod + inf->len, 0xff, 512);
2131 inf->cod[inf->len + (chl << 1)] = len & 0xff;
2132 inf->cod[inf->len + (chl << 1) + 1] = (len & 0xff00) >> 8;
2136 inf->cod[inf->len + (chu << 1)] = len & 0xff;
2137 inf->cod[inf->len + (chu << 1) + 1] = (len & 0xff00) >> 8;
2143 inf->len += 512;
2147 inf->cod[inf->len++] = len;
2149 memcpy(inf->cod + inf->len, stl->strs[i], len);
2150 inf->len += len;
2154 inf->cod[inf->len++] = (long)stl->strs[i];
2156 inf->cod[inf->len++] = (long)stl->strs[i] & 0xff;
2157 inf->cod[inf->len++] = ((long)stl->strs[i] & 0xff00) >> 8;
2163 return (inf->ecode);
2167 rec_build_rep(re_inf *inf, rec_rep *rep)
2174 rec_code(inf, (ReCode)rep->type);
2177 if (rec_code(inf, Re_Exact) == 0)
2178 rec_byte(inf, rep->mine);
2181 if (rec_code(inf, Re_Min) == 0)
2182 rec_byte(inf, rep->mine);
2185 if (rec_code(inf, Re_Max) == 0)
2186 rec_byte(inf, rep->maxc);
2189 if (rec_code(inf, Re_MinMax) == 0 &&
2190 rec_byte(inf, rep->mine) == 0)
2191 rec_byte(inf, rep->maxc);
2195 rec_byte(inf, inf->bas - 1);
2198 return (inf->ecode);
2202 rec_inc_spc(re_inf *inf)
2204 if (++inf->bas >= MAX_DEPTH)
2205 return (inf->ecode = RE_ESPACE);
2207 return (inf->ecode);
2211 rec_dec_spc(re_inf *inf)
2213 if (--inf->bas < 0)
2214 return (inf->ecode = RE_ASSERT);
2216 return (inf->ecode);
2220 rec_add_spc(re_inf *inf, int maybe)
2222 if (++inf->bas >= MAX_DEPTH)
2223 return (inf->ecode = RE_ESPACE);
2224 inf->sp[inf->bas] = maybe + 1;
2226 return (inf->ecode);
2231 rec_alt_spc(re_inf *inf, int top)
2233 int distance, i, bas = inf->bas;
2235 while ((inf->bas > top) && inf->sp[inf->bas]) {
2237 distance = inf->len - inf->sr[inf->bas];
2240 inf->sj[inf->bas] = inf->len;
2243 if (rec_code(inf, Re_RepLongJump) ||
2244 rec_byte(inf, inf->bas - 1) ||
2245 rec_byte(inf, distance & 0xff) ||
2246 rec_byte(inf, (distance & 0xff00) >> 8))
2249 else if (rec_code(inf, Re_RepJump) ||
2250 rec_byte(inf, inf->bas - 1) ||
2251 rec_byte(inf, distance))
2255 --inf->bas;
2258 i = inf->bas + 1;
2260 if (inf->ecode == 0 && i <= bas && inf->sp[i]) {
2263 distance = inf->len - inf->sr[i];
2264 inf->cod[inf->sr[i] + 3] = distance & 0xff;
2265 inf->cod[inf->sr[i] + 4] = (distance & 0xff00) >> 8;
2268 if (rec_code(inf, inf->sp[i] == 1 ? Re_DoneIf : Re_MaybeDone))
2269 return (inf->ecode);
2273 if (inf->sp[i]) {
2274 distance = inf->sj[i] - inf->sr[i];
2275 inf->cod[inf->sr[i] + 3] = distance & 0xff;
2276 inf->cod[inf->sr[i] + 4] = (distance & 0xff00) >> 8;
2281 return (inf->ecode);
2285 rec_rep_spc(re_inf *inf, int top)
2287 int distance, i, bas = inf->bas;
2289 while (inf->bas > top) {
2290 if (inf->sp[inf->bas]) {
2292 distance = inf->len - inf->sr[inf->bas];
2295 inf->sj[inf->bas] = inf->len;
2298 if (rec_code(inf, Re_RepLongJump) ||
2299 rec_byte(inf, inf->bas - 1) ||
2300 rec_byte(inf, distance & 0xff) ||
2301 rec_byte(inf, (distance & 0xff00) >> 8))
2304 else if (rec_code(inf, Re_RepJump) ||
2305 rec_byte(inf, inf->bas - 1) ||
2306 rec_byte(inf, distance))
2311 --inf->bas;
2316 if (inf->sp[i])
2319 if (inf->ecode == 0 && i <= bas && inf->sp[i]) {
2322 distance = inf->len - inf->sr[i];
2323 inf->cod[inf->sr[i] + 3] = distance & 0xff;
2324 inf->cod[inf->sr[i] + 4] = (distance & 0xff00) >> 8;
2328 if (inf->sp[i]) {
2329 distance = inf->sj[i] - inf->sr[i];
2330 inf->cod[inf->sr[i] + 3] = distance & 0xff;
2331 inf->cod[inf->sr[i] + 4] = (distance & 0xff00) >> 8;
2336 return (inf->ecode);
2340 rec_off_spc(re_inf *inf)
2343 inf->sr[inf->bas] = inf->len - 3;
2346 return (rec_byte_byte(inf, 0, 0));