Changeset View
Changeset View
Standalone View
Standalone View
contrib/less/regexp.c
Show First 20 Lines • Show All 201 Lines • ▼ Show 20 Lines | |||||
* thing really will compile successfully, and we never have to move the | * thing really will compile successfully, and we never have to move the | ||||
* code and thus invalidate pointers into it. (Note that it has to be in | * code and thus invalidate pointers into it. (Note that it has to be in | ||||
* one piece because free() must be able to free it all.) | * one piece because free() must be able to free it all.) | ||||
* | * | ||||
* Beware that the optimization-preparation code in here knows about some | * Beware that the optimization-preparation code in here knows about some | ||||
* of the structure of the compiled regexp. | * of the structure of the compiled regexp. | ||||
*/ | */ | ||||
regexp * | regexp * | ||||
regcomp(exp) | regcomp(char *exp) | ||||
char *exp; | |||||
{ | { | ||||
register regexp *r; | regexp *r; | ||||
register char *scan; | char *scan; | ||||
register char *longest; | char *longest; | ||||
register int len; | int len; | ||||
int flags; | int flags; | ||||
if (exp == NULL) | if (exp == NULL) | ||||
FAIL("NULL argument"); | FAIL("NULL argument"); | ||||
/* First pass: determine size, legality. */ | /* First pass: determine size, legality. */ | ||||
regparse = exp; | regparse = exp; | ||||
regnpar = 1; | regnpar = 1; | ||||
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines | |||||
* | * | ||||
* Caller must absorb opening parenthesis. | * Caller must absorb opening parenthesis. | ||||
* | * | ||||
* Combining parenthesis handling with the base level of regular expression | * Combining parenthesis handling with the base level of regular expression | ||||
* is a trifle forced, but the need to tie the tails of the branches to what | * is a trifle forced, but the need to tie the tails of the branches to what | ||||
* follows makes it hard to avoid. | * follows makes it hard to avoid. | ||||
*/ | */ | ||||
static char * | static char * | ||||
reg(paren, flagp) | reg(int paren, int *flagp) | ||||
int paren; /* Parenthesized? */ | |||||
int *flagp; | |||||
{ | { | ||||
register char *ret; | char *ret; | ||||
register char *br; | char *br; | ||||
register char *ender; | char *ender; | ||||
register int parno = 0; | int parno = 0; | ||||
int flags; | int flags; | ||||
*flagp = HASWIDTH; /* Tentatively. */ | *flagp = HASWIDTH; /* Tentatively. */ | ||||
/* Make an OPEN node, if parenthesized. */ | /* Make an OPEN node, if parenthesized. */ | ||||
if (paren) { | if (paren) { | ||||
if (regnpar >= NSUBEXP) | if (regnpar >= NSUBEXP) | ||||
FAIL("too many ()"); | FAIL("too many ()"); | ||||
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines | |||||
} | } | ||||
/* | /* | ||||
- regbranch - one alternative of an | operator | - regbranch - one alternative of an | operator | ||||
* | * | ||||
* Implements the concatenation operator. | * Implements the concatenation operator. | ||||
*/ | */ | ||||
static char * | static char * | ||||
regbranch(flagp) | regbranch(int *flagp) | ||||
int *flagp; | |||||
{ | { | ||||
register char *ret; | char *ret; | ||||
register char *chain; | char *chain; | ||||
register char *latest; | char *latest; | ||||
int flags; | int flags; | ||||
*flagp = WORST; /* Tentatively. */ | *flagp = WORST; /* Tentatively. */ | ||||
ret = regnode(BRANCH); | ret = regnode(BRANCH); | ||||
chain = NULL; | chain = NULL; | ||||
while (*regparse != '\0' && *regparse != '|' && *regparse != ')') { | while (*regparse != '\0' && *regparse != '|' && *regparse != ')') { | ||||
latest = regpiece(&flags); | latest = regpiece(&flags); | ||||
Show All 17 Lines | |||||
* | * | ||||
* Note that the branching code sequences used for ? and the general cases | * Note that the branching code sequences used for ? and the general cases | ||||
* of * and + are somewhat optimized: they use the same NOTHING node as | * of * and + are somewhat optimized: they use the same NOTHING node as | ||||
* both the endmarker for their branch list and the body of the last branch. | * both the endmarker for their branch list and the body of the last branch. | ||||
* It might seem that this node could be dispensed with entirely, but the | * It might seem that this node could be dispensed with entirely, but the | ||||
* endmarker role is not redundant. | * endmarker role is not redundant. | ||||
*/ | */ | ||||
static char * | static char * | ||||
regpiece(flagp) | regpiece(int *flagp) | ||||
int *flagp; | |||||
{ | { | ||||
register char *ret; | char *ret; | ||||
register char op; | char op; | ||||
register char *next; | char *next; | ||||
int flags; | int flags; | ||||
ret = regatom(&flags); | ret = regatom(&flags); | ||||
if (ret == NULL) | if (ret == NULL) | ||||
return(NULL); | return(NULL); | ||||
op = *regparse; | op = *regparse; | ||||
if (!ISMULT(op)) { | if (!ISMULT(op)) { | ||||
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines | |||||
- regatom - the lowest level | - regatom - the lowest level | ||||
* | * | ||||
* Optimization: gobbles an entire sequence of ordinary characters so that | * Optimization: gobbles an entire sequence of ordinary characters so that | ||||
* it can turn them into a single node, which is smaller to store and | * it can turn them into a single node, which is smaller to store and | ||||
* faster to run. Backslashed characters are exceptions, each becoming a | * faster to run. Backslashed characters are exceptions, each becoming a | ||||
* separate node; the code is simpler that way and it's not worth fixing. | * separate node; the code is simpler that way and it's not worth fixing. | ||||
*/ | */ | ||||
static char * | static char * | ||||
regatom(flagp) | regatom(int *flagp) | ||||
int *flagp; | |||||
{ | { | ||||
register char *ret; | char *ret; | ||||
int flags; | int flags; | ||||
*flagp = WORST; /* Tentatively. */ | *flagp = WORST; /* Tentatively. */ | ||||
switch (*regparse++) { | switch (*regparse++) { | ||||
case '^': | case '^': | ||||
ret = regnode(BOL); | ret = regnode(BOL); | ||||
break; | break; | ||||
case '$': | case '$': | ||||
ret = regnode(EOL); | ret = regnode(EOL); | ||||
break; | break; | ||||
case '.': | case '.': | ||||
ret = regnode(ANY); | ret = regnode(ANY); | ||||
*flagp |= HASWIDTH|SIMPLE; | *flagp |= HASWIDTH|SIMPLE; | ||||
break; | break; | ||||
case '[': { | case '[': { | ||||
register int clss; | int clss; | ||||
register int classend; | int classend; | ||||
if (*regparse == '^') { /* Complement of range. */ | if (*regparse == '^') { /* Complement of range. */ | ||||
ret = regnode(ANYBUT); | ret = regnode(ANYBUT); | ||||
regparse++; | regparse++; | ||||
} else | } else | ||||
ret = regnode(ANYOF); | ret = regnode(ANYOF); | ||||
if (*regparse == ']' || *regparse == '-') | if (*regparse == ']' || *regparse == '-') | ||||
regc(*regparse++); | regc(*regparse++); | ||||
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines | case '\\': | ||||
if (*regparse == '\0') | if (*regparse == '\0') | ||||
FAIL("trailing \\"); | FAIL("trailing \\"); | ||||
ret = regnode(EXACTLY); | ret = regnode(EXACTLY); | ||||
regc(*regparse++); | regc(*regparse++); | ||||
regc('\0'); | regc('\0'); | ||||
*flagp |= HASWIDTH|SIMPLE; | *flagp |= HASWIDTH|SIMPLE; | ||||
break; | break; | ||||
default: { | default: { | ||||
register int len; | int len; | ||||
register char ender; | char ender; | ||||
regparse--; | regparse--; | ||||
len = (int) strcspn(regparse, META); | len = (int) strcspn(regparse, META); | ||||
if (len <= 0) | if (len <= 0) | ||||
FAIL("internal disaster"); | FAIL("internal disaster"); | ||||
ender = *(regparse+len); | ender = *(regparse+len); | ||||
if (len > 1 && ISMULT(ender)) | if (len > 1 && ISMULT(ender)) | ||||
len--; /* Back off clear of ?+* operand. */ | len--; /* Back off clear of ?+* operand. */ | ||||
Show All 12 Lines | regatom(int *flagp) | ||||
return(ret); | return(ret); | ||||
} | } | ||||
/* | /* | ||||
- regnode - emit a node | - regnode - emit a node | ||||
*/ | */ | ||||
static char * /* Location. */ | static char * /* Location. */ | ||||
regnode(op) | regnode(char op) | ||||
char op; | |||||
{ | { | ||||
register char *ret; | char *ret; | ||||
register char *ptr; | char *ptr; | ||||
ret = regcode; | ret = regcode; | ||||
if (ret == ®dummy) { | if (ret == ®dummy) { | ||||
regsize += 3; | regsize += 3; | ||||
return(ret); | return(ret); | ||||
} | } | ||||
ptr = ret; | ptr = ret; | ||||
*ptr++ = op; | *ptr++ = op; | ||||
*ptr++ = '\0'; /* Null "next" pointer. */ | *ptr++ = '\0'; /* Null "next" pointer. */ | ||||
*ptr++ = '\0'; | *ptr++ = '\0'; | ||||
regcode = ptr; | regcode = ptr; | ||||
return(ret); | return(ret); | ||||
} | } | ||||
/* | /* | ||||
- regc - emit (if appropriate) a byte of code | - regc - emit (if appropriate) a byte of code | ||||
*/ | */ | ||||
static void | static void | ||||
regc(b) | regc(char b) | ||||
char b; | |||||
{ | { | ||||
if (regcode != ®dummy) | if (regcode != ®dummy) | ||||
*regcode++ = b; | *regcode++ = b; | ||||
else | else | ||||
regsize++; | regsize++; | ||||
} | } | ||||
/* | /* | ||||
- reginsert - insert an operator in front of already-emitted operand | - reginsert - insert an operator in front of already-emitted operand | ||||
* | * | ||||
* Means relocating the operand. | * Means relocating the operand. | ||||
*/ | */ | ||||
static void | static void | ||||
reginsert(op, opnd) | reginsert(char op, char *opnd) | ||||
char op; | |||||
char *opnd; | |||||
{ | { | ||||
register char *src; | char *src; | ||||
register char *dst; | char *dst; | ||||
register char *place; | char *place; | ||||
if (regcode == ®dummy) { | if (regcode == ®dummy) { | ||||
regsize += 3; | regsize += 3; | ||||
return; | return; | ||||
} | } | ||||
src = regcode; | src = regcode; | ||||
regcode += 3; | regcode += 3; | ||||
dst = regcode; | dst = regcode; | ||||
while (src > opnd) | while (src > opnd) | ||||
*--dst = *--src; | *--dst = *--src; | ||||
place = opnd; /* Op node, where operand used to be. */ | place = opnd; /* Op node, where operand used to be. */ | ||||
*place++ = op; | *place++ = op; | ||||
*place++ = '\0'; | *place++ = '\0'; | ||||
*place++ = '\0'; | *place++ = '\0'; | ||||
} | } | ||||
/* | /* | ||||
- regtail - set the next-pointer at the end of a node chain | - regtail - set the next-pointer at the end of a node chain | ||||
*/ | */ | ||||
static void | static void | ||||
regtail(p, val) | regtail(char *p, char *val) | ||||
char *p; | |||||
char *val; | |||||
{ | { | ||||
register char *scan; | char *scan; | ||||
register char *temp; | char *temp; | ||||
register int offset; | int offset; | ||||
if (p == ®dummy) | if (p == ®dummy) | ||||
return; | return; | ||||
/* Find last node. */ | /* Find last node. */ | ||||
scan = p; | scan = p; | ||||
for (;;) { | for (;;) { | ||||
temp = regnext(scan); | temp = regnext(scan); | ||||
Show All 9 Lines | regtail(char *p, char *val) | ||||
*(scan+1) = (offset>>8)&0377; | *(scan+1) = (offset>>8)&0377; | ||||
*(scan+2) = offset&0377; | *(scan+2) = offset&0377; | ||||
} | } | ||||
/* | /* | ||||
- regoptail - regtail on operand of first argument; nop if operandless | - regoptail - regtail on operand of first argument; nop if operandless | ||||
*/ | */ | ||||
static void | static void | ||||
regoptail(p, val) | regoptail(char *p, char *val) | ||||
char *p; | |||||
char *val; | |||||
{ | { | ||||
/* "Operandless" and "op != BRANCH" are synonymous in practice. */ | /* "Operandless" and "op != BRANCH" are synonymous in practice. */ | ||||
if (p == NULL || p == ®dummy || OP(p) != BRANCH) | if (p == NULL || p == ®dummy || OP(p) != BRANCH) | ||||
return; | return; | ||||
regtail(OPERAND(p), val); | regtail(OPERAND(p), val); | ||||
} | } | ||||
/* | /* | ||||
Show All 20 Lines | |||||
void regdump(); | void regdump(); | ||||
STATIC char *regprop(); | STATIC char *regprop(); | ||||
#endif | #endif | ||||
/* | /* | ||||
- regexec - match a regexp against a string | - regexec - match a regexp against a string | ||||
*/ | */ | ||||
int | int | ||||
regexec2(prog, string, notbol) | regexec2(regexp *prog, char *string, int notbol) | ||||
register regexp *prog; | |||||
register char *string; | |||||
int notbol; | |||||
{ | { | ||||
register char *s; | char *s; | ||||
/* Be paranoid... */ | /* Be paranoid... */ | ||||
if (prog == NULL || string == NULL) { | if (prog == NULL || string == NULL) { | ||||
regerror("NULL parameter"); | regerror("NULL parameter"); | ||||
return(0); | return(0); | ||||
} | } | ||||
/* Check validity of program. */ | /* Check validity of program. */ | ||||
Show All 40 Lines | do { | ||||
return(1); | return(1); | ||||
} while (*s++ != '\0'); | } while (*s++ != '\0'); | ||||
/* Failure. */ | /* Failure. */ | ||||
return(0); | return(0); | ||||
} | } | ||||
int | int | ||||
regexec(prog, string) | regexec(regexp *prog, char *string) | ||||
register regexp *prog; | |||||
register char *string; | |||||
{ | { | ||||
return regexec2(prog, string, 0); | return regexec2(prog, string, 0); | ||||
} | } | ||||
/* | /* | ||||
- regtry - try match at specific point | - regtry - try match at specific point | ||||
*/ | */ | ||||
static int /* 0 failure, 1 success */ | static int /* 0 failure, 1 success */ | ||||
regtry(prog, string) | regtry(regexp *prog, char *string) | ||||
regexp *prog; | |||||
char *string; | |||||
{ | { | ||||
register int i; | int i; | ||||
register char **sp; | char **sp; | ||||
register char **ep; | char **ep; | ||||
reginput = string; | reginput = string; | ||||
regstartp = prog->startp; | regstartp = prog->startp; | ||||
regendp = prog->endp; | regendp = prog->endp; | ||||
sp = prog->startp; | sp = prog->startp; | ||||
ep = prog->endp; | ep = prog->endp; | ||||
for (i = NSUBEXP; i > 0; i--) { | for (i = NSUBEXP; i > 0; i--) { | ||||
Show All 14 Lines | |||||
* Conceptually the strategy is simple: check to see whether the current | * Conceptually the strategy is simple: check to see whether the current | ||||
* node matches, call self recursively to see whether the rest matches, | * node matches, call self recursively to see whether the rest matches, | ||||
* and then act accordingly. In practice we make some effort to avoid | * and then act accordingly. In practice we make some effort to avoid | ||||
* recursion, in particular by going through "ordinary" nodes (that don't | * recursion, in particular by going through "ordinary" nodes (that don't | ||||
* need to know whether the rest of the match failed) by a loop instead of | * need to know whether the rest of the match failed) by a loop instead of | ||||
* by recursion. | * by recursion. | ||||
*/ | */ | ||||
static int /* 0 failure, 1 success */ | static int /* 0 failure, 1 success */ | ||||
regmatch(prog) | regmatch(char *prog) | ||||
char *prog; | |||||
{ | { | ||||
register char *scan; /* Current node. */ | char *scan; /* Current node. */ | ||||
emaste: comment indentation? | |||||
char *next; /* Next node. */ | char *next; /* Next node. */ | ||||
scan = prog; | scan = prog; | ||||
#ifdef DEBUG | #ifdef DEBUG | ||||
if (scan != NULL && regnarrate) | if (scan != NULL && regnarrate) | ||||
fprintf(stderr, "%s(\n", regprop(scan)); | fprintf(stderr, "%s(\n", regprop(scan)); | ||||
#endif | #endif | ||||
while (scan != NULL) { | while (scan != NULL) { | ||||
Show All 13 Lines | case EOL: | ||||
return(0); | return(0); | ||||
break; | break; | ||||
case ANY: | case ANY: | ||||
if (*reginput == '\0') | if (*reginput == '\0') | ||||
return(0); | return(0); | ||||
reginput++; | reginput++; | ||||
break; | break; | ||||
case EXACTLY: { | case EXACTLY: { | ||||
register int len; | int len; | ||||
register char *opnd; | char *opnd; | ||||
opnd = OPERAND(scan); | opnd = OPERAND(scan); | ||||
/* Inline the first character, for speed. */ | /* Inline the first character, for speed. */ | ||||
if (*opnd != *reginput) | if (*opnd != *reginput) | ||||
return(0); | return(0); | ||||
len = (int) strlen(opnd); | len = (int) strlen(opnd); | ||||
if (len > 1 && strncmp(opnd, reginput, len) != 0) | if (len > 1 && strncmp(opnd, reginput, len) != 0) | ||||
return(0); | return(0); | ||||
Show All 18 Lines | #endif | ||||
case OPEN+2: | case OPEN+2: | ||||
case OPEN+3: | case OPEN+3: | ||||
case OPEN+4: | case OPEN+4: | ||||
case OPEN+5: | case OPEN+5: | ||||
case OPEN+6: | case OPEN+6: | ||||
case OPEN+7: | case OPEN+7: | ||||
case OPEN+8: | case OPEN+8: | ||||
case OPEN+9: { | case OPEN+9: { | ||||
register int no; | int no; | ||||
register char *save; | char *save; | ||||
no = OP(scan) - OPEN; | no = OP(scan) - OPEN; | ||||
save = reginput; | save = reginput; | ||||
if (regmatch(next)) { | if (regmatch(next)) { | ||||
/* | /* | ||||
* Don't set startp if some later | * Don't set startp if some later | ||||
* invocation of the same parentheses | * invocation of the same parentheses | ||||
Show All 11 Lines | #endif | ||||
case CLOSE+2: | case CLOSE+2: | ||||
case CLOSE+3: | case CLOSE+3: | ||||
case CLOSE+4: | case CLOSE+4: | ||||
case CLOSE+5: | case CLOSE+5: | ||||
case CLOSE+6: | case CLOSE+6: | ||||
case CLOSE+7: | case CLOSE+7: | ||||
case CLOSE+8: | case CLOSE+8: | ||||
case CLOSE+9: { | case CLOSE+9: { | ||||
register int no; | int no; | ||||
register char *save; | char *save; | ||||
no = OP(scan) - CLOSE; | no = OP(scan) - CLOSE; | ||||
save = reginput; | save = reginput; | ||||
if (regmatch(next)) { | if (regmatch(next)) { | ||||
/* | /* | ||||
* Don't set endp if some later | * Don't set endp if some later | ||||
* invocation of the same parentheses | * invocation of the same parentheses | ||||
* already has. | * already has. | ||||
*/ | */ | ||||
if (regendp[no] == NULL) | if (regendp[no] == NULL) | ||||
regendp[no] = save; | regendp[no] = save; | ||||
return(1); | return(1); | ||||
} else | } else | ||||
return(0); | return(0); | ||||
} | } | ||||
/* NOTREACHED */ | /* NOTREACHED */ | ||||
break; | break; | ||||
case BRANCH: { | case BRANCH: { | ||||
register char *save; | char *save; | ||||
if (OP(next) != BRANCH) /* No choice. */ | if (OP(next) != BRANCH) /* No choice. */ | ||||
next = OPERAND(scan); /* Avoid recursion. */ | next = OPERAND(scan); /* Avoid recursion. */ | ||||
else { | else { | ||||
do { | do { | ||||
save = reginput; | save = reginput; | ||||
if (regmatch(OPERAND(scan))) | if (regmatch(OPERAND(scan))) | ||||
return(1); | return(1); | ||||
reginput = save; | reginput = save; | ||||
scan = regnext(scan); | scan = regnext(scan); | ||||
} while (scan != NULL && OP(scan) == BRANCH); | } while (scan != NULL && OP(scan) == BRANCH); | ||||
return(0); | return(0); | ||||
/* NOTREACHED */ | /* NOTREACHED */ | ||||
} | } | ||||
} | } | ||||
/* NOTREACHED */ | /* NOTREACHED */ | ||||
break; | break; | ||||
case STAR: | case STAR: | ||||
case PLUS: { | case PLUS: { | ||||
register char nextch; | char nextch; | ||||
register int no; | int no; | ||||
register char *save; | char *save; | ||||
register int min; | int min; | ||||
/* | /* | ||||
* Lookahead to avoid useless match attempts | * Lookahead to avoid useless match attempts | ||||
* when we know what character comes next. | * when we know what character comes next. | ||||
*/ | */ | ||||
nextch = '\0'; | nextch = '\0'; | ||||
if (OP(next) == EXACTLY) | if (OP(next) == EXACTLY) | ||||
nextch = *OPERAND(next); | nextch = *OPERAND(next); | ||||
Show All 34 Lines | #endif | ||||
regerror("corrupted pointers"); | regerror("corrupted pointers"); | ||||
return(0); | return(0); | ||||
} | } | ||||
/* | /* | ||||
- regrepeat - repeatedly match something simple, report how many | - regrepeat - repeatedly match something simple, report how many | ||||
*/ | */ | ||||
static int | static int | ||||
regrepeat(p) | regrepeat(char *p) | ||||
char *p; | |||||
{ | { | ||||
register int count = 0; | int count = 0; | ||||
register char *scan; | char *scan; | ||||
register char *opnd; | char *opnd; | ||||
scan = reginput; | scan = reginput; | ||||
opnd = OPERAND(p); | opnd = OPERAND(p); | ||||
switch (OP(p)) { | switch (OP(p)) { | ||||
case ANY: | case ANY: | ||||
count = (int) strlen(scan); | count = (int) strlen(scan); | ||||
scan += count; | scan += count; | ||||
break; | break; | ||||
Show All 24 Lines | regrepeat(char *p) | ||||
return(count); | return(count); | ||||
} | } | ||||
/* | /* | ||||
- regnext - dig the "next" pointer out of a node | - regnext - dig the "next" pointer out of a node | ||||
*/ | */ | ||||
static char * | static char * | ||||
regnext(p) | regnext(char *p) | ||||
Not Done Inline Actionsregister emaste: register
| |||||
register char *p; | |||||
{ | { | ||||
register int offset; | int offset; | ||||
if (p == ®dummy) | if (p == ®dummy) | ||||
return(NULL); | return(NULL); | ||||
offset = NEXT(p); | offset = NEXT(p); | ||||
if (offset == 0) | if (offset == 0) | ||||
return(NULL); | return(NULL); | ||||
if (OP(p) == BACK) | if (OP(p) == BACK) | ||||
return(p-offset); | return(p-offset); | ||||
else | else | ||||
return(p+offset); | return(p+offset); | ||||
} | } | ||||
#ifdef DEBUG | #ifdef DEBUG | ||||
STATIC char *regprop(); | STATIC char *regprop(); | ||||
/* | /* | ||||
- regdump - dump a regexp onto stdout in vaguely comprehensible form | - regdump - dump a regexp onto stdout in vaguely comprehensible form | ||||
*/ | */ | ||||
void | void | ||||
regdump(r) | regdump(regexp *r) | ||||
regexp *r; | |||||
{ | { | ||||
register char *s; | char *s; | ||||
register char op = EXACTLY; /* Arbitrary non-END op. */ | char op = EXACTLY; /* Arbitrary non-END op. */ | ||||
register char *next; | char *next; | ||||
s = r->program + 1; | s = r->program + 1; | ||||
while (op != END) { /* While that wasn't END last time... */ | while (op != END) { /* While that wasn't END last time... */ | ||||
op = OP(s); | op = OP(s); | ||||
printf("%2d%s", s-r->program, regprop(s)); /* Where, what. */ | printf("%2d%s", s-r->program, regprop(s)); /* Where, what. */ | ||||
next = regnext(s); | next = regnext(s); | ||||
if (next == NULL) /* Next ptr. */ | if (next == NULL) /* Next ptr. */ | ||||
Show All 21 Lines | if (r->regmust != NULL) | ||||
printf("must have \"%s\"", r->regmust); | printf("must have \"%s\"", r->regmust); | ||||
printf("\n"); | printf("\n"); | ||||
} | } | ||||
/* | /* | ||||
- regprop - printable representation of opcode | - regprop - printable representation of opcode | ||||
*/ | */ | ||||
static char * | static char * | ||||
regprop(op) | regprop(char *op) | ||||
char *op; | |||||
{ | { | ||||
register char *p; | char *p; | ||||
static char buf[50]; | static char buf[50]; | ||||
(void) strcpy(buf, ":"); | (void) strcpy(buf, ":"); | ||||
switch (OP(op)) { | switch (OP(op)) { | ||||
case BOL: | case BOL: | ||||
p = "BOL"; | p = "BOL"; | ||||
break; | break; | ||||
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines | |||||
*/ | */ | ||||
#ifdef STRCSPN | #ifdef STRCSPN | ||||
/* | /* | ||||
* strcspn - find length of initial segment of s1 consisting entirely | * strcspn - find length of initial segment of s1 consisting entirely | ||||
* of characters not from s2 | * of characters not from s2 | ||||
*/ | */ | ||||
static int | static int | ||||
strcspn(s1, s2) | strcspn(char *s1, char *s2) | ||||
char *s1; | |||||
char *s2; | |||||
{ | { | ||||
register char *scan1; | char *scan1; | ||||
register char *scan2; | char *scan2; | ||||
register int count; | int count; | ||||
count = 0; | count = 0; | ||||
for (scan1 = s1; *scan1 != '\0'; scan1++) { | for (scan1 = s1; *scan1 != '\0'; scan1++) { | ||||
for (scan2 = s2; *scan2 != '\0';) /* ++ moved down. */ | for (scan2 = s2; *scan2 != '\0';) /* ++ moved down. */ | ||||
if (*scan1 == *scan2++) | if (*scan1 == *scan2++) | ||||
return(count); | return(count); | ||||
count++; | count++; | ||||
} | } | ||||
return(count); | return(count); | ||||
} | } | ||||
#endif | #endif |
comment indentation?