int regexpr(void) { int c; static char *buf = 0; static int bufsz = 500; char *bp; if (buf == 0 && (buf = (char *) malloc(bufsz)) == NULL) FATAL("out of space for rex expr"); bp = buf; for ( ; (c = input()) != '/' && c != 0; ) { if (!adjbuf(&buf, &bufsz, bp-buf+3, 500, &bp, 0)) FATAL("out of space for reg expr %.10s...", buf); if (c == '\n') { SYNTAX( "newline in regular expression %.10s...", buf ); unput('\n'); break; } else if (c == '\\') { *bp++ = '\\'; *bp++ = input(); } else { *bp++ = c; } } *bp = 0; if (c == 0) SYNTAX("non-terminated regular expression %.10s...", buf); yylval.s = tostring(buf); unput('/'); RET(REGEXPR); }
IntegerSyntax::IntegerSyntax() { SYNTAX("int"); sign_ = DEFINE("Sign", RANGE("+-")); binNumber_ = DEFINE("BinNumber", GLUE( STRING("0b"), REPEAT(1, 256, RANGE('0', '1')) ) ); octNumber_ = DEFINE("OctNumber", GLUE( CHAR('0'), REPEAT(1, 24, RANGE('0', '9')) ) ); hexNumber_ = DEFINE("HexNumber", GLUE( STRING("0x"), REPEAT(1, 20, CHOICE( RANGE('0', '9'), RANGE('a', 'f'), RANGE('A', 'F') ) ) ) ); decNumber_ = DEFINE("DecNumber", REPEAT(1, 20, RANGE('0', '9') ) ); literal_ = DEFINE("Literal", GLUE( REPEAT(0, 1, REF("Sign")), CHOICE( REF("BinNumber"), REF("OctNumber"), REF("HexNumber"), REF("DecNumber") ), NOT(RANGE(".eE")) ) ); ENTRY("Literal"); LINK(); }
int main(int argc,char** argv) { long index=256; ZZ seed; clear(seed); PARSE_MAIN_ARGS { MATCH_MAIN_ARGID("--index",index); MATCH_MAIN_ARGID("--seed",seed); SYNTAX(); } ZZX phi=find_cyclotomic(index); long n=deg(phi); ZZ det=find_determinant(index,10*n,seed); ZZ alpha=find_unity_root(index,det,phi); mat_ZZ B; B.SetDims(n,n); clear(B); B(1,1) = det; for (long i=2; i<=n; i++) { B(i,1)=det-PowerMod(alpha,i-1,det); B(i,i)=1; } cout << B << endl; cout << n << " " << index << " " << seed<< endl; cout << phi << endl; }
char *qstring(const char *is, int delim) /* collect string up to next delim */ { const char *os = is; int c, n; const uschar *s = (const uschar *) is; uschar *buf, *bp; if ((buf = malloc(strlen(is)+3)) == NULL) FATAL( "out of space in qstring(%s)", s); for (bp = buf; (c = *s) != delim; s++) { if (c == '\n') SYNTAX( "newline in string %.20s...", os ); else if (c != '\\') *bp++ = c; else { /* \something */ c = *++s; if (c == 0) { /* \ at end */ *bp++ = '\\'; break; /* for loop */ } switch (c) { case '\\': *bp++ = '\\'; break; case 'n': *bp++ = '\n'; break; case 't': *bp++ = '\t'; break; case 'b': *bp++ = '\b'; break; case 'f': *bp++ = '\f'; break; case 'r': *bp++ = '\r'; break; default: if (!isdigit(c)) { *bp++ = c; break; } n = c - '0'; if (isdigit(s[1])) { n = 8 * n + *++s - '0'; if (isdigit(s[1])) n = 8 * n + *++s - '0'; } *bp++ = n; break; } } } *bp++ = 0; return (char *) buf; }
Node *pa2stat(Node *a, Node *b, Node *c) /* pat, pat {...} */ { Node *x; x = node4(PASTAT2, a, b, c, itonp(paircnt)); if (paircnt++ >= PA2NUM) SYNTAX( "limited to %d pat,pat statements", PA2NUM ); x->ntype = NSTAT; return(x); }
int word(char *w) { Keyword *kp; int c, n; n = binsearch(w, keywords, sizeof(keywords)/sizeof(keywords[0])); /* BUG: this ought to be inside the if; in theory could fault (daniel barrett) */ kp = keywords + n; if (n != -1) { /* found in table */ yylval.i = kp->sub; switch (kp->type) { /* special handling */ case BLTIN: if (kp->sub == FSYSTEM && safe) SYNTAX( "system is unsafe" ); RET(kp->type); case FUNC: if (infunc) SYNTAX( "illegal nested function" ); RET(kp->type); case RETURN: if (!infunc) SYNTAX( "return not in function" ); RET(kp->type); case VARNF: yylval.cp = setsymtab("NF", "", 0.0, NUM, symtab); RET(VARNF); default: RET(kp->type); } } c = peek(); /* look for '(' */ if (c != '(' && infunc && (n=isarg(w)) >= 0) { yylval.i = n; RET(ARG); } else { yylval.cp = setsymtab(w, "", 0.0, STR|NUM|DONTFREE, symtab); if (c == '(') { RET(CALL); } else { RET(VAR); } } }
void defn(Cell *v, Node *vl, Node *st) /* turn on FCN bit in definition, */ { /* body of function, arglist */ Node *p; int n; if (isarr(v)) { SYNTAX( "`%s' is an array name and a function name", v->nval ); return; } if (isarg(v->nval) != -1) { SYNTAX( "`%s' is both function name and argument name", v->nval ); return; } v->tval = FCN; v->sval = (char *) st; n = 0; /* count arguments */ for (p = vl; p; p = p->nnext) n++; v->fval = n; dprintf( ("defining func %s (%d args)\n", v->nval, n) ); }
Node *makearr(Node *p) { Cell *cp; if (isvalue(p)) { cp = (Cell *) (p->narg[0]); if (isfcn(cp)) SYNTAX( "%s is a function, not an array", cp->nval ); else if (!isarr(cp)) { xfree(cp->sval); cp->sval = (char *) makesymtab(NSYMTAB); cp->tval = ARR; } } return p; }
int main(int argc,char** argv) { long n = 80; long bit = 10; ZZ seed; seed = 0; PARSE_MAIN_ARGS { MATCH_MAIN_ARGID("--dim",n); MATCH_MAIN_ARGID("--seed",seed); // MATCH_MAIN_ARGID("--bit",bit); SYNTAX(); } vec_ZZ v; generate_random_HNF(v,n,bit,seed); mat_ZZ B; B.SetDims(n,n); clear(B); B(1,1) = v(1); for (int i=2; i<=n; i++) { B(i,1)=v(i); B(i,i)=1; } cout << B << endl; }
int string(void) { int c, n; char *s, *bp; static char *buf = 0; static int bufsz = 500; if (buf == 0 && (buf = (char *) malloc(bufsz)) == NULL) FATAL("out of space for strings"); for (bp = buf; (c = input()) != '"'; ) { if (!adjbuf(&buf, &bufsz, bp-buf+2, 500, &bp, 0)) FATAL("out of space for string %.10s...", buf); switch (c) { case '\n': case '\r': case 0: SYNTAX( "non-terminated string %.10s...", buf ); lineno++; if (c == 0) /* hopeless */ FATAL( "giving up" ); break; case '\\': c = input(); switch (c) { case '"': *bp++ = '"'; break; case 'n': *bp++ = '\n'; break; case 't': *bp++ = '\t'; break; case 'f': *bp++ = '\f'; break; case 'r': *bp++ = '\r'; break; case 'b': *bp++ = '\b'; break; case 'v': *bp++ = '\v'; break; case 'a': *bp++ = '\007'; break; case '\\': *bp++ = '\\'; break; case '0': case '1': case '2': /* octal: \d \dd \ddd */ case '3': case '4': case '5': case '6': case '7': n = c - '0'; if ((c = peek()) >= '0' && c < '8') { n = 8 * n + input() - '0'; if ((c = peek()) >= '0' && c < '8') n = 8 * n + input() - '0'; } *bp++ = n; break; case 'x': /* hex \x0-9a-fA-F + */ { char xbuf[100], *px; for (px = xbuf; (c = input()) != 0 && px-xbuf < 100-2; ) { if (isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) *px++ = c; else break; } *px = 0; unput(c); sscanf(xbuf, "%x", &n); *bp++ = n; break; } default: *bp++ = c; break; } break; default: *bp++ = c; break; } } *bp = 0; s = tostring(buf); *bp++ = ' '; *bp++ = 0; yylval.cp = setsymtab(buf, s, 0.0, CON|STR|DONTFREE, symtab); RET(STRING); }
int yylex(void) { int c; static char *buf = 0; static int bufsize = 500; if (buf == 0 && (buf = (char *) malloc(bufsize)) == NULL) FATAL( "out of space in yylex" ); if (sc) { sc = 0; RET('}'); } if (reg) { reg = 0; return regexpr(); } /* printf("top\n"); */ for (;;) { c = gettok(&buf, &bufsize); /* printf("gettok [%s]\n", buf); */ if (c == 0) return 0; if (isalpha(c) || c == '_') return word(buf); if (isdigit(c)) { yylval.cp = setsymtab(buf, tostring(buf), atof(buf), CON|NUM, symtab); /* should this also have STR set? */ RET(NUMBER); } yylval.i = c; switch (c) { case '\n': /* {EOL} */ RET(NL); case '\r': /* assume \n is coming */ case ' ': /* {WS}+ */ case '\t': break; case '#': /* #.* strip comments */ while ((c = input()) != '\n' && c != 0) ; unput(c); break; case ';': RET(';'); case '\\': if (peek() == '\n') { input(); } else if (peek() == '\r') { input(); input(); /* \n */ lineno++; } else { RET(c); } break; case '&': if (peek() == '&') { input(); RET(AND); } else RET('&'); case '|': if (peek() == '|') { input(); RET(BOR); } else RET('|'); case '!': if (peek() == '=') { input(); yylval.i = NE; RET(NE); } else if (peek() == '~') { input(); yylval.i = NOTMATCH; RET(MATCHOP); } else RET(NOT); case '~': yylval.i = MATCH; RET(MATCHOP); case '<': if (peek() == '=') { input(); yylval.i = LE; RET(LE); } else { yylval.i = LT; RET(LT); } case '=': if (peek() == '=') { input(); yylval.i = EQ; RET(EQ); } else { yylval.i = ASSIGN; RET(ASGNOP); } case '>': if (peek() == '=') { input(); yylval.i = GE; RET(GE); } else if (peek() == '>') { input(); yylval.i = APPEND; RET(APPEND); } else { yylval.i = GT; RET(GT); } case '+': if (peek() == '+') { input(); yylval.i = INCR; RET(INCR); } else if (peek() == '=') { input(); yylval.i = ADDEQ; RET(ASGNOP); } else RET('+'); case '-': if (peek() == '-') { input(); yylval.i = DECR; RET(DECR); } else if (peek() == '=') { input(); yylval.i = SUBEQ; RET(ASGNOP); } else RET('-'); case '*': if (peek() == '=') { /* *= */ input(); yylval.i = MULTEQ; RET(ASGNOP); } else if (peek() == '*') { /* ** or **= */ input(); /* eat 2nd * */ if (peek() == '=') { input(); yylval.i = POWEQ; RET(ASGNOP); } else { RET(POWER); } } else RET('*'); case '/': RET('/'); case '%': if (peek() == '=') { input(); yylval.i = MODEQ; RET(ASGNOP); } else RET('%'); case '^': if (peek() == '=') { input(); yylval.i = POWEQ; RET(ASGNOP); } else RET(POWER); case '$': /* BUG: awkward, if not wrong */ c = gettok(&buf, &bufsize); if (isalpha(c)) { if (strcmp(buf, "NF") == 0) { /* very special */ unputstr("(NF)"); RET(INDIRECT); } c = peek(); if (c == '(' || c == '[' || (infunc && isarg(buf) >= 0)) { unputstr(buf); RET(INDIRECT); } yylval.cp = setsymtab(buf, "", 0.0, STR|NUM, symtab); RET(IVAR); } else if (c == 0) { /* */ SYNTAX( "unexpected end of input after $" ); RET(';'); } else { unputstr(buf); RET(INDIRECT); } case '}': if (--bracecnt < 0) SYNTAX( "extra }" ); sc = 1; RET(';'); case ']': if (--brackcnt < 0) SYNTAX( "extra ]" ); RET(']'); case ')': if (--parencnt < 0) SYNTAX( "extra )" ); RET(')'); case '{': bracecnt++; RET('{'); case '[': brackcnt++; RET('['); case '(': parencnt++; RET('('); case '"': return string(); /* BUG: should be like tran.c ? */ default: RET(c); } } }
static void re_compile_fastmap_aux(unsigned char *code, int pos, unsigned char *visited, unsigned char *can_be_null, unsigned char *fastmap) { int a; int b; int syntaxcode; if (visited[pos]) return; /* we have already been here */ visited[pos] = 1; for (;;) switch (code[pos++]) { case Cend: { *can_be_null = 1; return; } case Cbol: case Cbegbuf: case Cendbuf: case Cwordbeg: case Cwordend: case Cwordbound: case Cnotwordbound: { for (a = 0; a < 256; a++) fastmap[a] = 1; break; } case Csyntaxspec: { syntaxcode = code[pos++]; for (a = 0; a < 256; a++) if (SYNTAX(a) & syntaxcode) fastmap[a] = 1; return; } case Cnotsyntaxspec: { syntaxcode = code[pos++]; for (a = 0; a < 256; a++) if (!(SYNTAX(a) & syntaxcode) ) fastmap[a] = 1; return; } case Ceol: { fastmap['\n'] = 1; if (*can_be_null == 0) *can_be_null = 2; /* can match null, but only at end of buffer*/ return; } case Cset: { for (a = 0; a < 256/8; a++) if (code[pos + a] != 0) for (b = 0; b < 8; b++) if (code[pos + a] & (1 << b)) fastmap[(a << 3) + b] = 1; pos += 256/8; return; } case Cexact: { fastmap[(unsigned char)code[pos]] = 1; return; } case Canychar: { for (a = 0; a < 256; a++) if (a != '\n') fastmap[a] = 1; return; } case Cstart_memory: case Cend_memory: { pos++; break; } case Cmatch_memory: { for (a = 0; a < 256; a++) fastmap[a] = 1; *can_be_null = 1; return; } case Cjump: case Cdummy_failure_jump: case Cupdate_failure_jump: case Cstar_jump: { a = (unsigned char)code[pos++]; a |= (unsigned char)code[pos++] << 8; pos += (int)SHORT(a); if (visited[pos]) { /* argh... the regexp contains empty loops. This is not good, as this may cause a failure stack overflow when matching. Oh well. */ /* this path leads nowhere; pursue other paths. */ return; } visited[pos] = 1; break; } case Cfailure_jump: { a = (unsigned char)code[pos++]; a |= (unsigned char)code[pos++] << 8; a = pos + (int)SHORT(a); re_compile_fastmap_aux(code, a, visited, can_be_null, fastmap); break; } case Crepeat1: { pos += 2; break; } default: { PyErr_SetString(PyExc_SystemError, "Unknown regex opcode: memory corrupted?"); return; /*NOTREACHED*/ } } }
static Lisp_Object casify_object (enum case_action flag, Lisp_Object obj) { register int c, c1; register int inword = flag == CASE_DOWN; /* If the case table is flagged as modified, rescan it. */ if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1])) Fset_case_table (BVAR (current_buffer, downcase_table)); if (INTEGERP (obj)) { int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META); int flags = XINT (obj) & flagbits; int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters)); /* If the character has higher bits set above the flags, return it unchanged. It is not a real character. */ if ((unsigned) XFASTINT (obj) > (unsigned) flagbits) return obj; c1 = XFASTINT (obj) & ~flagbits; /* FIXME: Even if enable-multibyte-characters is nil, we may manipulate multibyte chars. This means we have a bug for latin-1 chars since when we receive an int 128-255 we can't tell whether it's an eight-bit byte or a latin-1 char. */ if (c1 >= 256) multibyte = 1; if (! multibyte) MAKE_CHAR_MULTIBYTE (c1); c = downcase (c1); if (inword) XSETFASTINT (obj, c | flags); else if (c == (XFASTINT (obj) & ~flagbits)) { if (! inword) c = upcase1 (c1); if (! multibyte) MAKE_CHAR_UNIBYTE (c); XSETFASTINT (obj, c | flags); } return obj; } if (!STRINGP (obj)) wrong_type_argument (Qchar_or_string_p, obj); else if (!STRING_MULTIBYTE (obj)) { EMACS_INT i; EMACS_INT size = SCHARS (obj); obj = Fcopy_sequence (obj); for (i = 0; i < size; i++) { c = SREF (obj, i); MAKE_CHAR_MULTIBYTE (c); c1 = c; if (inword && flag != CASE_CAPITALIZE_UP) c = downcase (c); else if (!uppercasep (c) && (!inword || flag != CASE_CAPITALIZE_UP)) c = upcase1 (c1); if ((int) flag >= (int) CASE_CAPITALIZE) inword = (SYNTAX (c) == Sword); if (c != c1) { MAKE_CHAR_UNIBYTE (c); /* If the char can't be converted to a valid byte, just don't change it. */ if (c >= 0 && c < 256) SSET (obj, i, c); } } return obj; } else { EMACS_INT i, i_byte, size = SCHARS (obj); int len; USE_SAFE_ALLOCA; unsigned char *dst, *o; /* Over-allocate by 12%: this is a minor overhead, but should be sufficient in 99.999% of the cases to avoid a reallocation. */ EMACS_INT o_size = SBYTES (obj) + SBYTES (obj) / 8 + MAX_MULTIBYTE_LENGTH; SAFE_ALLOCA (dst, void *, o_size); o = dst; for (i = i_byte = 0; i < size; i++, i_byte += len) { if ((o - dst) + MAX_MULTIBYTE_LENGTH > o_size) { /* Not enough space for the next char: grow the destination. */ unsigned char *old_dst = dst; o_size += o_size; /* Probably overkill, but extremely rare. */ SAFE_ALLOCA (dst, void *, o_size); memcpy (dst, old_dst, o - old_dst); o = dst + (o - old_dst); } c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, len); if (inword && flag != CASE_CAPITALIZE_UP) c = downcase (c); else if (!uppercasep (c) && (!inword || flag != CASE_CAPITALIZE_UP)) c = upcase1 (c); if ((int) flag >= (int) CASE_CAPITALIZE) inword = (SYNTAX (c) == Sword); o += CHAR_STRING (c, o); } eassert (o - dst <= o_size); obj = make_multibyte_string ((char *) dst, size, o - dst); SAFE_FREE (); return obj; } }
void yyerror(const char *s) { SYNTAX("%s", s); }
WireSyntax::WireSyntax() { SYNTAX("Wire"); DEFINE_VOID("Comment", CHOICE( GLUE( STRING("//"), CHOICE( FIND(AHEAD(CHAR('\n'))), FIND(EOI()) ) ), GLUE( STRING("/*"), REPEAT( CHOICE( INLINE("Comment"), GLUE( NOT(STRING("*/")), ANY() ) ) ), STRING("*/") ) ) ); DEFINE_VOID("Whitespace", REPEAT( CHOICE( RANGE(" \t\n"), INLINE("Comment") ) ) ); DEFINE("Name", REPEAT(1, EXCEPT(" \t\n:;")) ); DEFINE("Value", CHOICE( REF("Atom"), REF("Properties"), REF("Items") ) ); DEFINE("Object", GLUE( REPEAT(0, 1, GLUE( REF("Name"), INLINE("Whitespace"), CHAR(':'), INLINE("Whitespace") ) ), INLINE("Value") ) ); DEFINE("Atom", REPEAT( GLUE( NOT( CHOICE( GLUE( REPEAT(RANGE(" \t")), INLINE("Name"), REPEAT(RANGE(" \t")), CHAR(':') ), GLUE( REPEAT(RANGE(" \t")), RANGE("};,") ), STRING("\n\n") ) ), ANY() ) ) ); DEFINE("Properties", GLUE( CHAR('{'), INLINE("Whitespace"), REPEAT( GLUE( REF("Object"), INLINE("Whitespace"), RANGE(";,"), INLINE("Whitespace") ) ), CHAR('}') ) ); DEFINE("Items", GLUE( CHAR('['), INLINE("Whitespace"), REPEAT( GLUE( REF("Value"), INLINE("Whitespace"), RANGE(";,"), INLINE("Whitespace") ) ), CHAR(']') ) ); ENTRY("Object"); }
/* pattern is a list of strings: compiled_code, fastmap, syntax_fastmap, category_fastmap */ void set_pattern (Lisp_Object pattern, struct re_pattern_buffer *bufp, char *translate) { Lisp_Object temp; if (bufp->allocated != 0) { /* Coming here means that this buffer was used to hold an old-style pattern. Because new-style pattern is not self-destructive, we only have to set pointer. Instead, to avoid it being freed later, bufp->allocated should be set to 0. */ free (bufp->buffer); bufp->allocated = 0; } temp = XVECTOR (pattern)->contents[0]; bufp->buffer = (char *)XSTRING (temp)->data; bufp->used = XSTRING (temp)->size; bufp->translate = translate; /* 93.7.13 by K.Handa -- set fastmap */ bufp->mc_flag = !NILP (current_buffer->mc_flag); { Lisp_Object fmap, syntax_fmap, category_fmap; char *fastmap = bufp->fastmap; int i; unsigned char ch; bufp->fastmap_accurate = 1; fmap = XVECTOR (pattern)->contents[1]; if (NILP (fmap) && NILP (syntax_fmap) && NILP (category_fmap)) { bufp->can_be_null = 1; } else { bufp->can_be_null = 0; bzero (fastmap, 256); if (XTYPE (fmap) == Lisp_String) /* 93.7.19 by K.Handa */ bcopy (XSTRING (fmap)->data, fastmap, XSTRING (fmap)->size); syntax_fmap = XVECTOR (pattern)->contents[2]; if (XTYPE (syntax_fmap) == Lisp_String) { for (ch = 0; ch < 0x80; ch++) if (!fastmap[ch] && XSTRING (syntax_fmap)->data[syntax_code_spec[(char) SYNTAX (ch)]]) fastmap[ch] = 1; bufp->syntax_version = syntax_table_version; } else bufp->syntax_version = 0; category_fmap = XVECTOR (pattern)->contents[3]; if (XTYPE (category_fmap) == Lisp_String) { char str[96], *p; int not_category_spec = 0; for (i = 32; i < 128; i++) if (XSTRING (category_fmap)->data[i] == 2) { not_category_spec = 1; break; } for (ch = 0; ch < 0x80; ch++) { if (!fastmap[ch]) { pack_mnemonic_string (char_category (ch, current_buffer->category_table), str); if (not_category_spec) { for (p = str; *p; p++) if (XSTRING (category_fmap)->data[*p] != 2) { fastmap[ch] = 1; break; } } else { for (p = str; *p; p++) if (XSTRING (category_fmap)->data[*p] == 1) { fastmap[ch] = 1; break; } } } } bufp->category_version = category_table_version; } else bufp->category_version = 0; if (bufp->mc_flag && (XTYPE (syntax_fmap) == Lisp_String || XTYPE (category_fmap) == Lisp_String)) { for (ch = 0x80; ch < 0xA0; ch++) fastmap[ch] = 1; } } } /* 92.7.10 by T.Enami Force 're-compile-pattern' when compile_pattern is called next time. */ last_regexp = Qnil; }
void yyerror(const char *s) { SYNTAX(s); }
int re_match(regexp_t bufp, unsigned char *string, int size, int pos, regexp_registers_t old_regs) { unsigned char *code; unsigned char *translate; unsigned char *text; unsigned char *textstart; unsigned char *textend; int a; int b; int ch; int reg; int match_end; unsigned char *regstart; unsigned char *regend; int regsize; match_state state; assert(pos >= 0 && size >= 0); assert(pos <= size); text = string + pos; textstart = string; textend = string + size; code = bufp->buffer; translate = bufp->translate; NEW_STATE(state, bufp->num_registers); continue_matching: switch (*code++) { case Cend: { match_end = text - textstart; if (old_regs) { old_regs->start[0] = pos; old_regs->end[0] = match_end; if (!bufp->uses_registers) { for (a = 1; a < RE_NREGS; a++) { old_regs->start[a] = -1; old_regs->end[a] = -1; } } else { for (a = 1; a < bufp->num_registers; a++) { if ((GET_REG_START(state, a) == NULL) || (GET_REG_END(state, a) == NULL)) { old_regs->start[a] = -1; old_regs->end[a] = -1; continue; } old_regs->start[a] = GET_REG_START(state, a) - textstart; old_regs->end[a] = GET_REG_END(state, a) - textstart; } for (; a < RE_NREGS; a++) { old_regs->start[a] = -1; old_regs->end[a] = -1; } } } FREE_STATE(state); return match_end - pos; } case Cbol: { if (text == textstart || text[-1] == '\n') goto continue_matching; goto fail; } case Ceol: { if (text == textend || *text == '\n') goto continue_matching; goto fail; } case Cset: { NEXTCHAR(ch); if (code[ch/8] & (1<<(ch & 7))) { code += 256/8; goto continue_matching; } goto fail; } case Cexact: { NEXTCHAR(ch); if (ch != (unsigned char)*code++) goto fail; goto continue_matching; } case Canychar: { NEXTCHAR(ch); if (ch == '\n') goto fail; goto continue_matching; } case Cstart_memory: { reg = *code++; SET_REG_START(state, reg, text, goto error); goto continue_matching; } case Cend_memory: { reg = *code++; SET_REG_END(state, reg, text, goto error); goto continue_matching; } case Cmatch_memory: { reg = *code++; regstart = GET_REG_START(state, reg); regend = GET_REG_END(state, reg); if ((regstart == NULL) || (regend == NULL)) goto fail; /* or should we just match nothing? */ regsize = regend - regstart; if (regsize > (textend - text)) goto fail; if(translate) { for (; regstart < regend; regstart++, text++) if (translate[*regstart] != translate[*text]) goto fail; } else for (; regstart < regend; regstart++, text++) if (*regstart != *text) goto fail; goto continue_matching; } case Cupdate_failure_jump: { UPDATE_FAILURE(state, text, goto error); /* fall to next case */ } /* treat Cstar_jump just like Cjump if it hasn't been optimized */ case Cstar_jump: case Cjump: { a = (unsigned char)*code++; a |= (unsigned char)*code++ << 8; code += (int)SHORT(a); if (code<bufp->buffer || bufp->buffer+bufp->used<code) { PyErr_SetString(PyExc_SystemError, "Regex VM jump out of bounds (Cjump)"); FREE_STATE(state); return -2; } goto continue_matching; } case Cdummy_failure_jump: { unsigned char *failuredest; a = (unsigned char)*code++; a |= (unsigned char)*code++ << 8; a = (int)SHORT(a); assert(*code == Cfailure_jump); b = (unsigned char)code[1]; b |= (unsigned char)code[2] << 8; failuredest = code + (int)SHORT(b) + 3; if (failuredest<bufp->buffer || bufp->buffer+bufp->used < failuredest) { PyErr_SetString(PyExc_SystemError, "Regex VM jump out of bounds (Cdummy_failure_jump failuredest)"); FREE_STATE(state); return -2; } PUSH_FAILURE(state, failuredest, NULL, goto error); code += a; if (code<bufp->buffer || bufp->buffer+bufp->used < code) { PyErr_SetString(PyExc_SystemError, "Regex VM jump out of bounds (Cdummy_failure_jump code)"); FREE_STATE(state); return -2; } goto continue_matching; } case Cfailure_jump: { a = (unsigned char)*code++; a |= (unsigned char)*code++ << 8; a = (int)SHORT(a); if (code+a<bufp->buffer || bufp->buffer+bufp->used < code+a) { PyErr_SetString(PyExc_SystemError, "Regex VM jump out of bounds (Cfailure_jump)"); FREE_STATE(state); return -2; } PUSH_FAILURE(state, code + a, text, goto error); goto continue_matching; } case Crepeat1: { unsigned char *pinst; a = (unsigned char)*code++; a |= (unsigned char)*code++ << 8; a = (int)SHORT(a); pinst = code + a; if (pinst<bufp->buffer || bufp->buffer+bufp->used<pinst) { PyErr_SetString(PyExc_SystemError, "Regex VM jump out of bounds (Crepeat1)"); FREE_STATE(state); return -2; } /* pinst is sole instruction in loop, and it matches a * single character. Since Crepeat1 was originally a * Cupdate_failure_jump, we also know that backtracking * is useless: so long as the single-character * expression matches, it must be used. Also, in the * case of +, we've already matched one character, so + * can't fail: nothing here can cause a failure. */ switch (*pinst++) { case Cset: { if (translate) { while (text < textend) { ch = translate[(unsigned char)*text]; if (pinst[ch/8] & (1<<(ch & 7))) text++; else break; } } else { while (text < textend) { ch = (unsigned char)*text; if (pinst[ch/8] & (1<<(ch & 7))) text++; else break; } } break; } case Cexact: { ch = (unsigned char)*pinst; if (translate) { while (text < textend && translate[(unsigned char)*text] == ch) text++; } else { while (text < textend && (unsigned char)*text == ch) text++; } break; } case Canychar: { while (text < textend && (unsigned char)*text != '\n') text++; break; } case Csyntaxspec: { a = (unsigned char)*pinst; if (translate) { while (text < textend && (SYNTAX(translate[*text]) & a) ) text++; } else { while (text < textend && (SYNTAX(*text) & a) ) text++; } break; } case Cnotsyntaxspec: { a = (unsigned char)*pinst; if (translate) { while (text < textend && !(SYNTAX(translate[*text]) & a) ) text++; } else { while (text < textend && !(SYNTAX(*text) & a) ) text++; } break; } default: { FREE_STATE(state); PyErr_SetString(PyExc_SystemError, "Unknown regex opcode: memory corrupted?"); return -2; /*NOTREACHED*/ } } /* due to the funky way + and * are compiled, the top * failure- stack entry at this point is actually a * success entry -- update it & pop it */ UPDATE_FAILURE(state, text, goto error); goto fail; /* i.e., succeed <wink/sigh> */ } case Cbegbuf: { if (text == textstart) goto continue_matching; goto fail; } case Cendbuf: { if (text == textend) goto continue_matching; goto fail; } case Cwordbeg: { if (text == textend) goto fail; if (!(SYNTAX(*text) & Sword)) goto fail; if (text == textstart) goto continue_matching; if (!(SYNTAX(text[-1]) & Sword)) goto continue_matching; goto fail; } case Cwordend: { if (text == textstart) goto fail; if (!(SYNTAX(text[-1]) & Sword)) goto fail; if (text == textend) goto continue_matching; if (!(SYNTAX(*text) & Sword)) goto continue_matching; goto fail; } case Cwordbound: { /* Note: as in gnu regexp, this also matches at the * beginning and end of buffer. */ if (text == textstart || text == textend) goto continue_matching; if ((SYNTAX(text[-1]) & Sword) ^ (SYNTAX(*text) & Sword)) goto continue_matching; goto fail; } case Cnotwordbound: { /* Note: as in gnu regexp, this never matches at the * beginning and end of buffer. */ if (text == textstart || text == textend) goto fail; if (!((SYNTAX(text[-1]) & Sword) ^ (SYNTAX(*text) & Sword))) goto continue_matching; goto fail; } case Csyntaxspec: { NEXTCHAR(ch); if (!(SYNTAX(ch) & (unsigned char)*code++)) goto fail; goto continue_matching; } case Cnotsyntaxspec: { NEXTCHAR(ch); if (SYNTAX(ch) & (unsigned char)*code++) goto fail; goto continue_matching; } default: { FREE_STATE(state); PyErr_SetString(PyExc_SystemError, "Unknown regex opcode: memory corrupted?"); return -2; /*NOTREACHED*/ } } #if 0 /* This line is never reached --Guido */ abort(); #endif /* *NOTREACHED */ /* Using "break;" in the above switch statement is equivalent to "goto fail;" */ fail: POP_FAILURE(state, code, text, goto done_matching, goto error); goto continue_matching; done_matching: /* if(translated != NULL) */ /* free(translated); */ FREE_STATE(state); return -1; error: /* if (translated != NULL) */ /* free(translated); */ FREE_STATE(state); return -2; }