int igraph_i_eigen_matrix_lapack_cmp_sm(void *extra, const void *a,
const void *b) {
igraph_i_eml_cmp_t *myextra=(igraph_i_eml_cmp_t *) extra;
int *aa=(int*) a, *bb=(int*) b;
igraph_real_t a_m=VECTOR(*myextra->mag)[*aa];
igraph_real_t b_m=VECTOR(*myextra->mag)[*bb];
if (MORE(a_m, b_m)) {
return 1;
} else if (LESS(a_m, b_m)) {
return -1;
} else {
igraph_real_t a_r=VECTOR(*myextra->real)[*aa];
igraph_real_t a_i=VECTOR(*myextra->imag)[*aa];
igraph_real_t b_r=VECTOR(*myextra->real)[*bb];
igraph_real_t b_i=VECTOR(*myextra->imag)[*bb];
if (NONZERO(a_i) && ZERO(b_i)) { return -1; }
if (ZERO(a_i) && NONZERO(b_i)) { return 1; }
if (LESS(a_r, b_r)) { return -1; }
if (MORE(a_r, b_r)) { return 1; }
if (LESS(a_i, b_i)) { return -1; }
if (MORE(a_i, b_i)) { return 1; }
}
return 0;
}
/*
- p_b_coll_elem - parse a collating-element name and look it up
== static char p_b_coll_elem(struct parse *p, int endc);
*/
static char /* value of collating element */
p_b_coll_elem(
struct parse *p,
int endc) /* name ended by endc,']' */
{
const char *sp;
const struct cname *cp;
size_t len;
_DIAGASSERT(p != NULL);
sp = p->next;
while (MORE() && !SEETWO(endc, ']'))
NEXT();
if (!MORE()) {
SETERROR(REG_EBRACK);
return(0);
}
len = p->next - sp;
for (cp = cnames; cp->name != NULL; cp++)
if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
return(cp->code); /* known name */
if (len == 1)
return(*sp); /* single character */
SETERROR(REG_ECOLLATE); /* neither */
return(0);
}
VALUE rb_big_barrett_reduce(VALUE x, VALUE m, VALUE mu, int inplace)
{
if (!NEGATIVE_P(x) && MORE(m, x))
{
return x;
}
unsigned long len = RBIGNUM_LEN(m); /* >= 1 */
if (FIXNUM_P(x))
{
return FIX2LONG(x) >= 0 ? x : rb_big_plus(m, x);
}
VALUE q = bigmul_high_digits(x, mu, len - 1, len - 1);
/* q is not normed */
q = rshift_digits_inplace(q, len + 1);
/* [x/m] - 3 <= q <= [x/m] */
q = bigmul_low_digits(q, m, len + 1);
/* q is normed */
VALUE a = inplace ? x : rb_big_clone(x);
if (RBIGNUM_LEN(a) > (long)len + 1)
{
RBIGNUM_SET_LEN(a, len + 1);
}
a = rb_big_minus(a, q);
if (NEGATIVE_P(a))
a = ADD(a, power_of_two((len + 1) * BITSPERDIG));
/* a = (x - q * m) mod (base ** (len + 1)) */
while (!MORE(m, a)) /* that is, m <= a */
a = SUB(a, m);
return rb_big_norm(a);
}
/*
- p_str - string (no metacharacters) "parser"
*/
static void
p_str(struct parse *p)
{
REQUIRE(MORE(), REG_EMPTY);
while (MORE())
ordinary(p, GETNEXT());
}
/*
- p_b_term - parse one term of a bracketed character list
*/
static void
p_b_term(struct parse *p, cset *cs)
{
char c;
char start, finish;
int i;
/* classify what we've got */
switch ((MORE()) ? PEEK() : '\0') {
case '[':
c = (MORE2()) ? PEEK2() : '\0';
break;
case '-':
SETERROR(REG_ERANGE);
return; /* NOTE RETURN */
break;
default:
c = '\0';
break;
}
switch (c) {
case ':': /* character class */
NEXT2();
REQUIRE(MORE(), REG_EBRACK);
c = PEEK();
REQUIRE(c != '-' && c != ']', REG_ECTYPE);
p_b_cclass(p, cs);
REQUIRE(MORE(), REG_EBRACK);
REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
break;
case '=': /* equivalence class */
NEXT2();
REQUIRE(MORE(), REG_EBRACK);
c = PEEK();
REQUIRE(c != '-' && c != ']', REG_ECOLLATE);
p_b_eclass(p, cs);
REQUIRE(MORE(), REG_EBRACK);
REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
break;
default: /* symbol, ordinary character, or range */
/* xxx revision needed for multichar stuff */
start = p_b_symbol(p);
if (SEE('-') && MORE2() && PEEK2() != ']') {
/* range */
NEXT();
if (EAT('-'))
finish = '-';
else
finish = p_b_symbol(p);
} else
finish = start;
/* xxx what about signed chars here... */
REQUIRE(start <= finish, REG_ERANGE);
for (i = start; i <= finish; i++)
CHadd(cs, i);
break;
}
}
/*
- p_str - string (no metacharacters) "parser"
== static void p_str(struct parse *p);
*/
static void
p_str(
struct parse *p)
{
_DIAGASSERT(p != NULL);
REQUIRE(MORE(), REG_EMPTY);
while (MORE())
ordinary(p, GETNEXT());
}
/*
- p_ere - ERE parser top level, concatenation and alternation
== static void p_ere(struct parse *p, int stop, size_t reclimit);
*/
static void
p_ere(
struct parse *p,
int stop, /* character this ERE should end at */
size_t reclimit)
{
char c;
sopno prevback = 0; /* pacify gcc */
sopno prevfwd = 0; /* pacify gcc */
sopno conc;
int first = 1; /* is this the first alternative? */
_DIAGASSERT(p != NULL);
if (reclimit++ > RECLIMIT || p->error == REG_ESPACE) {
p->error = REG_ESPACE;
return;
}
for (;;) {
/* do a bunch of concatenated expressions */
conc = HERE();
while (MORE() && (c = PEEK()) != '|' && c != stop)
p_ere_exp(p, reclimit);
REQUIRE(HERE() != conc, REG_EMPTY); /* require nonempty */
if (!EAT('|'))
break; /* NOTE BREAK OUT */
if (first) {
INSERT(OCH_, conc); /* offset is wrong */
prevfwd = conc;
prevback = conc;
first = 0;
}
ASTERN(OOR1, prevback);
prevback = THERE();
AHEAD(prevfwd); /* fix previous offset */
prevfwd = HERE();
EMIT(OOR2, 0); /* offset is very wrong */
}
if (!first) { /* tail-end fixups */
AHEAD(prevfwd);
ASTERN(O_CH, prevback);
}
assert(!MORE() || SEE(stop));
}
/*
- p_bre - BRE parser top level, anchoring and concatenation
* Giving end1 as OUT essentially eliminates the end1/end2 check.
*
* This implementation is a bit of a kludge, in that a trailing $ is first
* taken as an ordinary character and then revised to be an anchor. The
* only undesirable side effect is that '$' gets included as a character
* category in such cases. This is fairly harmless; not worth fixing.
* The amount of lookahead needed to avoid this kludge is excessive.
*/
static void
p_bre(struct parse *p,
int end1, /* first terminating character */
int end2) /* second terminating character */
{
sopno start = HERE();
int first = 1; /* first subexpression? */
int wasdollar = 0;
if (EAT('^')) {
EMIT(OBOL, 0);
p->g->iflags |= USEBOL;
p->g->nbol++;
}
while (MORE() && !SEETWO(end1, end2)) {
wasdollar = p_simp_re(p, first);
first = 0;
}
if (wasdollar) { /* oops, that was a trailing anchor */
DROP(1);
EMIT(OEOL, 0);
p->g->iflags |= USEEOL;
p->g->neol++;
}
REQUIRE(HERE() != start, REG_EMPTY); /* require nonempty */
}
/*
- p_b_cclass - parse a character-class name and deal with it
*/
static void
p_b_cclass(struct parse *p, cset *cs)
{
char *sp = p->next;
struct cclass *cp;
size_t len;
const char *u;
char c;
while (MORE() && isalpha(PEEK()))
NEXT();
len = p->next - sp;
for (cp = cclasses; cp->name != NULL; cp++)
if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
break;
if (cp->name == NULL) {
/* oops, didn't find it */
SETERROR(REG_ECTYPE);
return;
}
u = cp->chars;
while ((c = *u++) != '\0')
CHadd(cs, c);
for (u = cp->multis; *u != '\0'; u += strlen(u) + 1)
MCadd(p, cs, u);
}
static
void
swim(PQ q, int k)
{
while(k > 1 && MORE(k/2, k)) {
exchange(q, k, k/2);
k /= 2;
}
}
static
void
sink(PQ q, int k)
{
int j;
while(2*k <= q->count) {
j = 2 * k;
if(j < q->count && MORE(j, j+1))
j++;
if(!MORE(k, j))
break;
exchange(q, k, j);
k = j;
}
}
/*
- p_ere - ERE parser top level, concatenation and alternation
*/
static void
p_ere(struct parse *p, int stop) /* character this ERE should end at */
{
char c;
sopno prevback;
sopno prevfwd;
sopno conc;
int first = 1; /* is this the first alternative? */
for (;;) {
/* do a bunch of concatenated expressions */
conc = HERE();
while (MORE() && (c = PEEK()) != '|' && c != stop)
p_ere_exp(p);
REQUIRE(HERE() != conc, REG_EMPTY); /* require nonempty */
if (!EAT('|'))
break; /* NOTE BREAK OUT */
if (first) {
INSERT(OCH_, conc); /* offset is wrong */
prevfwd = conc;
prevback = conc;
first = 0;
}
ASTERN(OOR1, prevback);
prevback = THERE();
AHEAD(prevfwd); /* fix previous offset */
prevfwd = HERE();
EMIT(OOR2, 0); /* offset is very wrong */
}
if (!first) { /* tail-end fixups */
AHEAD(prevfwd);
ASTERN(O_CH, prevback);
}
assert(!MORE() || SEE(stop));
}
/*
- p_b_symbol - parse a character or [..]ed multicharacter collating symbol
*/
static char /* value of symbol */
p_b_symbol(struct parse *p)
{
char value;
REQUIRE(MORE(), REG_EBRACK);
if (!EATTWO('[', '.'))
return(GETNEXT());
/* collating symbol */
value = p_b_coll_elem(p, '.');
REQUIRE(EATTWO('.', ']'), REG_ECOLLATE);
return(value);
}
/*
- p_count - parse a repetition count
*/
static int /* the value */
p_count(struct parse *p)
{
int count = 0;
int ndigits = 0;
while (MORE() && isdigit((uch)PEEK()) && count <= DUPMAX) {
count = count*10 + (GETNEXT() - '0');
ndigits++;
}
REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
return(count);
}
echoObject *
echoListSplit3(echoScene *scene, echoObject *list, int depth) {
echoObject *ret, *tmp0, *tmp1;
if (!( echoTypeList == list->type ||
echoTypeAABBox == list->type ))
return NULL;
if (!depth)
return list;
ret = echoListSplit(scene, list, 0);
#define DOIT(obj, ax) ((obj) = echoListSplit(scene, (obj), (ax)))
#define MORE(obj) echoTypeSplit == (obj)->type
if (MORE(ret)) {
tmp0 = DOIT(SPLIT(ret)->obj0, 1);
if (MORE(tmp0)) {
tmp1 = DOIT(SPLIT(tmp0)->obj0, 2);
if (MORE(tmp1)) {
SPLIT(tmp1)->obj0 = echoListSplit3(scene, SPLIT(tmp1)->obj0, depth-1);
SPLIT(tmp1)->obj1 = echoListSplit3(scene, SPLIT(tmp1)->obj1, depth-1);
}
tmp1 = DOIT(SPLIT(tmp0)->obj1, 2);
if (MORE(tmp1)) {
SPLIT(tmp1)->obj0 = echoListSplit3(scene, SPLIT(tmp1)->obj0, depth-1);
SPLIT(tmp1)->obj1 = echoListSplit3(scene, SPLIT(tmp1)->obj1, depth-1);
}
}
tmp0 = DOIT(SPLIT(ret)->obj1, 1);
if (MORE(tmp0)) {
tmp1 = DOIT(SPLIT(tmp0)->obj0, 2);
if (MORE(tmp1)) {
SPLIT(tmp1)->obj0 = echoListSplit3(scene, SPLIT(tmp1)->obj0, depth-1);
SPLIT(tmp1)->obj1 = echoListSplit3(scene, SPLIT(tmp1)->obj1, depth-1);
}
tmp1 = DOIT(SPLIT(tmp0)->obj1, 2);
if (MORE(tmp1)) {
SPLIT(tmp1)->obj0 = echoListSplit3(scene, SPLIT(tmp1)->obj0, depth-1);
SPLIT(tmp1)->obj1 = echoListSplit3(scene, SPLIT(tmp1)->obj1, depth-1);
}
}
}
return ret;
}
/*
- p_bre - BRE parser top level, anchoring and concatenation
== static void p_bre(struct parse *p, int end1, \
== int end2, size_t reclimit);
* Giving end1 as OUT essentially eliminates the end1/end2 check.
*
* This implementation is a bit of a kludge, in that a trailing $ is first
* taken as an ordinary character and then revised to be an anchor. The
* only undesirable side effect is that '$' gets included as a character
* category in such cases. This is fairly harmless; not worth fixing.
* The amount of lookahead needed to avoid this kludge is excessive.
*/
static void
p_bre(
struct parse *p,
int end1, /* first terminating character */
int end2, /* second terminating character */
size_t reclimit)
{
sopno start;
int first = 1; /* first subexpression? */
int wasdollar = 0;
_DIAGASSERT(p != NULL);
if (reclimit++ > RECLIMIT || p->error == REG_ESPACE) {
p->error = REG_ESPACE;
return;
}
start = HERE();
if (EAT('^')) {
EMIT(OBOL, 0);
p->g->iflags |= USEBOL;
p->g->nbol++;
}
while (MORE() && !SEETWO(end1, end2)) {
wasdollar = p_simp_re(p, first, reclimit);
first = 0;
}
if (wasdollar) { /* oops, that was a trailing anchor */
DROP(1);
EMIT(OEOL, 0);
p->g->iflags |= USEEOL;
p->g->neol++;
}
REQUIRE(HERE() != start, REG_EMPTY); /* require nonempty */
}
uint8_t AVDMFastVideoGauss::doLine(uint8_t *pred,
uint8_t *cur,
uint8_t *next,
uint8_t *out,
uint32_t w)
{
uint8_t a1,a2,a3;
uint8_t b1,b2,b3;
uint8_t c1,c2,c3;
int32_t o;
//#define MASKED__
#define threshold 80
int v,r;
a2=*pred++;a3=*pred++;
b2=*cur++;b3=*cur++;
c2=*next++;c3=*next++;
*out++=b2;
w--;
while(w>1)
{
a1=a2;
a2=a3;
a3=*pred++;
b1=b2;
b2=b3;
b3=*cur++;
c1=c2;
c2=c3;
c3=*next++;
//
#ifdef MASKED__
v=b2;
r=16;
o=b2*16;
#define MORE(x,coef) if(abs(x-v)<=threshold) {o+=x*coef;r+=coef;}
MORE(a1,6);
MORE(a2,10);
MORE(a3,6);
MORE(b1,10);
MORE(b3,10);
MORE(c1,6);
MORE(c2,10);
MORE(c3,6);
o=(o+r-1)/r;
#else
o=6*a1+10*a2+6*a3+10*b1+16*b2+10*b3+6*c1+10*c2+6*c3;
o/=80;
#endif
*out++=o;
w--;
}
*out++=b3;
return 1;
}
/*
- p_bracket - parse a bracketed character list
*
* Note a significant property of this code: if the allocset() did SETERROR,
* no set operations are done.
*/
static void
p_bracket(struct parse *p)
{
cset *cs;
int invert = 0;
/* Dept of Truly Sickening Special-Case Kludges */
if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0) {
EMIT(OBOW, 0);
NEXTn(6);
return;
}
if (p->next + 5 < p->end && strncmp(p->next, "[:>:]]", 6) == 0) {
EMIT(OEOW, 0);
NEXTn(6);
return;
}
if ((cs = allocset(p)) == NULL) {
/* allocset did set error status in p */
return;
}
if (EAT('^'))
invert++; /* make note to invert set at end */
if (EAT(']'))
CHadd(cs, ']');
else if (EAT('-'))
CHadd(cs, '-');
while (MORE() && PEEK() != ']' && !SEETWO('-', ']'))
p_b_term(p, cs);
if (EAT('-'))
CHadd(cs, '-');
MUSTEAT(']', REG_EBRACK);
if (p->error != 0) { /* don't mess things up further */
freeset(p, cs);
return;
}
if (p->g->cflags®_ICASE) {
int i;
int ci;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i) && isalpha(i)) {
ci = othercase(i);
if (ci != i)
CHadd(cs, ci);
}
if (cs->multis != NULL)
mccase(p, cs);
}
if (invert) {
int i;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i))
CHsub(cs, i);
else
CHadd(cs, i);
if (p->g->cflags®_NEWLINE)
CHsub(cs, '\n');
if (cs->multis != NULL)
mcinvert(p, cs);
}
assert(cs->multis == NULL); /* xxx */
if (nch(p, cs) == 1) { /* optimize singleton sets */
ordinary(p, firstch(p, cs));
freeset(p, cs);
} else
EMIT(OANYOF, freezeset(p, cs));
}
/*
- p_simp_re - parse a simple RE, an atom possibly followed by a repetition
*/
static int /* was the simple RE an unbackslashed $? */
p_simp_re(struct parse *p,
int starordinary) /* is a leading * an ordinary character? */
{
int c;
int count;
int count2;
sopno pos;
int i;
sopno subno;
# define BACKSL (1<<CHAR_BIT)
pos = HERE(); /* repetion op, if any, covers from here */
assert(MORE()); /* caller should have ensured this */
c = GETNEXT();
if (c == '\\') {
REQUIRE(MORE(), REG_EESCAPE);
c = BACKSL | GETNEXT();
}
switch (c) {
case '.':
if (p->g->cflags®_NEWLINE)
nonnewline(p);
else
EMIT(OANY, 0);
break;
case '[':
p_bracket(p);
break;
case BACKSL|'{':
SETERROR(REG_BADRPT);
break;
case BACKSL|'(':
p->g->nsub++;
subno = p->g->nsub;
if (subno < NPAREN)
p->pbegin[subno] = HERE();
EMIT(OLPAREN, subno);
/* the MORE here is an error heuristic */
if (MORE() && !SEETWO('\\', ')'))
p_bre(p, '\\', ')');
if (subno < NPAREN) {
p->pend[subno] = HERE();
assert(p->pend[subno] != 0);
}
EMIT(ORPAREN, subno);
REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
break;
case BACKSL|')': /* should not get here -- must be user */
case BACKSL|'}':
SETERROR(REG_EPAREN);
break;
case BACKSL|'1':
case BACKSL|'2':
case BACKSL|'3':
case BACKSL|'4':
case BACKSL|'5':
case BACKSL|'6':
case BACKSL|'7':
case BACKSL|'8':
case BACKSL|'9':
i = (c&~BACKSL) - '0';
assert(i < NPAREN);
if (p->pend[i] != 0) {
assert(i <= p->g->nsub);
EMIT(OBACK_, i);
assert(p->pbegin[i] != 0);
assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
assert(OP(p->strip[p->pend[i]]) == ORPAREN);
(void) dupl(p, p->pbegin[i]+1, p->pend[i]);
EMIT(O_BACK, i);
} else
SETERROR(REG_ESUBREG);
p->g->backrefs = 1;
break;
case '*':
REQUIRE(starordinary, REG_BADRPT);
/* FALLTHROUGH */
default:
ordinary(p, (char)c);
break;
}
if (EAT('*')) { /* implemented as +? */
/* this case does not require the (y|) trick, noKLUDGE */
INSERT(OPLUS_, pos);
ASTERN(O_PLUS, pos);
INSERT(OQUEST_, pos);
ASTERN(O_QUEST, pos);
} else if (EATTWO('\\', '{')) {
count = p_count(p);
if (EAT(',')) {
if (MORE() && isdigit((uch)PEEK())) {
count2 = p_count(p);
REQUIRE(count <= count2, REG_BADBR);
} else /* single number with comma */
count2 = INFINITY;
} else /* just a single number */
count2 = count;
repeat(p, pos, count, count2);
if (!EATTWO('\\', '}')) { /* error heuristics */
while (MORE() && !SEETWO('\\', '}'))
NEXT();
REQUIRE(MORE(), REG_EBRACE);
SETERROR(REG_BADBR);
}
} else if (c == '$') /* $ (but not \$) ends it */
return(1);
return(0);
}
/*
- p_ere_exp - parse one subERE, an atom possibly followed by a repetition op
*/
static void
p_ere_exp(struct parse *p)
{
char c;
sopno pos;
int count;
int count2;
sopno subno;
int wascaret = 0;
assert(MORE()); /* caller should have ensured this */
c = GETNEXT();
pos = HERE();
switch (c) {
case '(':
REQUIRE(MORE(), REG_EPAREN);
p->g->nsub++;
subno = p->g->nsub;
if (subno < NPAREN)
p->pbegin[subno] = HERE();
EMIT(OLPAREN, subno);
if (!SEE(')'))
p_ere(p, ')');
if (subno < NPAREN) {
p->pend[subno] = HERE();
assert(p->pend[subno] != 0);
}
EMIT(ORPAREN, subno);
MUSTEAT(')', REG_EPAREN);
break;
#ifndef POSIX_MISTAKE
case ')': /* happens only if no current unmatched ( */
/*
* You may ask, why the ifndef? Because I didn't notice
* this until slightly too late for 1003.2, and none of the
* other 1003.2 regular-expression reviewers noticed it at
* all. So an unmatched ) is legal POSIX, at least until
* we can get it fixed.
*/
SETERROR(REG_EPAREN);
break;
#endif
case '^':
EMIT(OBOL, 0);
p->g->iflags |= USEBOL;
p->g->nbol++;
wascaret = 1;
break;
case '$':
EMIT(OEOL, 0);
p->g->iflags |= USEEOL;
p->g->neol++;
break;
case '|':
SETERROR(REG_EMPTY);
break;
case '*':
case '+':
case '?':
SETERROR(REG_BADRPT);
break;
case '.':
if (p->g->cflags®_NEWLINE)
nonnewline(p);
else
EMIT(OANY, 0);
break;
case '[':
p_bracket(p);
break;
case '\\':
REQUIRE(MORE(), REG_EESCAPE);
c = GETNEXT();
ordinary(p, c);
break;
case '{': /* okay as ordinary except if digit follows */
REQUIRE(!MORE() || !isdigit((uch)PEEK()), REG_BADRPT);
/* FALLTHROUGH */
default:
ordinary(p, c);
break;
}
if (!MORE())
return;
c = PEEK();
/* we call { a repetition if followed by a digit */
if (!( c == '*' || c == '+' || c == '?' ||
(c == '{' && MORE2() && isdigit((uch)PEEK2())) ))
return; /* no repetition, we're done */
NEXT();
REQUIRE(!wascaret, REG_BADRPT);
switch (c) {
case '*': /* implemented as +? */
/* this case does not require the (y|) trick, noKLUDGE */
INSERT(OPLUS_, pos);
ASTERN(O_PLUS, pos);
INSERT(OQUEST_, pos);
ASTERN(O_QUEST, pos);
break;
case '+':
INSERT(OPLUS_, pos);
ASTERN(O_PLUS, pos);
break;
case '?':
/* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
INSERT(OCH_, pos); /* offset slightly wrong */
ASTERN(OOR1, pos); /* this one's right */
AHEAD(pos); /* fix the OCH_ */
EMIT(OOR2, 0); /* offset very wrong... */
AHEAD(THERE()); /* ...so fix it */
ASTERN(O_CH, THERETHERE());
break;
case '{':
count = p_count(p);
if (EAT(',')) {
if (isdigit((uch)PEEK())) {
count2 = p_count(p);
REQUIRE(count <= count2, REG_BADBR);
} else /* single number with comma */
count2 = INFINITY;
} else /* just a single number */
count2 = count;
repeat(p, pos, count, count2);
if (!EAT('}')) { /* error heuristics */
while (MORE() && PEEK() != '}')
NEXT();
REQUIRE(MORE(), REG_EBRACE);
SETERROR(REG_BADBR);
}
break;
}
if (!MORE())
return;
c = PEEK();
if (!( c == '*' || c == '+' || c == '?' ||
(c == '{' && MORE2() && isdigit((uch)PEEK2())) ) )
return;
SETERROR(REG_BADRPT);
}
