/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1988 AT&T */
/* All Rights Reserved */
#pragma ident "%Z%%M% %I% %E% SMI"
#include "ldefs.h"
static void add(int **array, int n);
static void follow(int v);
static void first(int v);
static void nextstate(int s, int c);
static void packtrans(int st, CHR *tch, int *tst, int cnt, int tryit);
static void acompute(int s);
static void rprint(int *a, char *s, int n);
static void shiftr(int *a, int n);
static void upone(int *a, int n);
static void bprint(char *a, char *s, int n);
static int notin(int n);
static int member(int d, CHR *t);
#ifdef PP
static void padd(int **array, int n);
#endif
void
cfoll(int v)
{
int i, j, k;
CHR *p;
i = name[v];
if (!ISOPERATOR(i))
i = 1;
switch (i) {
case 1: case RSTR: case RCCL: case RNCCL: case RNULLS:
for (j = 0; j < tptr; j++)
tmpstat[j] = FALSE;
count = 0;
follow(v);
#ifdef PP
padd(foll, v); /* packing version */
#else
add(foll, v); /* no packing version */
#endif
if (i == RSTR)
cfoll(left[v]);
else if (i == RCCL || i == RNCCL) {
for (j = 1; j < ncg; j++)
symbol[j] = (i == RNCCL);
p = (CHR *) left[v];
while (*p)
symbol[*p++] = (i == RCCL);
p = pcptr;
for (j = 1; j < ncg; j++)
if (symbol[j]) {
for (k = 0; p + k < pcptr; k++)
if (cindex[j] ==
*(p + k))
break;
if (p + k >= pcptr)
*pcptr++ = cindex[j];
}
*pcptr++ = 0;
if (pcptr > pchar + pchlen)
error(
"Too many packed character classes");
left[v] = (int)p;
name[v] = RCCL; /* RNCCL eliminated */
#ifdef DEBUG
if (debug && *p) {
(void) printf("ccl %d: %d", v, *p++);
while (*p)
(void) printf(", %d", *p++);
(void) putchar('\n');
}
#endif
}
break;
case CARAT:
cfoll(left[v]);
break;
/* XCU4: add RXSCON */
case RXSCON:
case STAR: case PLUS: case QUEST: case RSCON:
cfoll(left[v]);
break;
case BAR: case RCAT: case DIV: case RNEWE:
cfoll(left[v]);
cfoll(right[v]);
break;
#ifdef DEBUG
case FINAL:
case S1FINAL:
case S2FINAL:
break;
default:
warning("bad switch cfoll %d", v);
#endif
}
}
#ifdef DEBUG
void
pfoll(void)
{
int i, k, *p;
int j;
/* print sets of chars which may follow positions */
(void) printf("pos\tchars\n");
for (i = 0; i < tptr; i++)
if (p = foll[i]) {
j = *p++;
if (j >= 1) {
(void) printf("%d:\t%d", i, *p++);
for (k = 2; k <= j; k++)
(void) printf(", %d", *p++);
(void) putchar('\n');
}
}
}
#endif
static void
add(int **array, int n)
{
int i, *temp;
CHR *ctemp;
temp = nxtpos;
ctemp = tmpstat;
array[n] = nxtpos; /* note no packing is done in positions */
*temp++ = count;
for (i = 0; i < tptr; i++)
if (ctemp[i] == TRUE)
*temp++ = i;
nxtpos = temp;
if (nxtpos >= positions+maxpos)
error(
"Too many positions %s",
(maxpos == MAXPOS ? "\nTry using %p num" : ""));
}
static void
follow(int v)
{
int p;
if (v >= tptr-1)
return;
p = parent[v];
if (p == 0)
return;
switch (name[p]) {
/* will not be CHAR RNULLS FINAL S1FINAL S2FINAL RCCL RNCCL */
case RSTR:
if (tmpstat[p] == FALSE) {
count++;
tmpstat[p] = TRUE;
}
break;
case STAR: case PLUS:
first(v);
follow(p);
break;
case BAR: case QUEST: case RNEWE:
follow(p);
break;
case RCAT: case DIV:
if (v == left[p]) {
if (nullstr[right[p]])
follow(p);
first(right[p]);
}
else
follow(p);
break;
/* XCU4: add RXSCON */
case RXSCON:
case RSCON: case CARAT:
follow(p);
break;
#ifdef DEBUG
default:
warning("bad switch follow %d", p);
#endif
}
}
/*
* Check if I have a RXSCON in my upper node
*/
static int
check_me(int v)
{
int tmp = parent[v];
while (name[tmp] != RNEWE) {
if (name[tmp] == RXSCON)
return (1);
tmp = parent[tmp];
}
return (0);
}
/* calculate set of positions with v as root which can be active initially */
static void
first(int v)
{
int i;
CHR *p;
i = name[v];
if (!ISOPERATOR(i))
i = 1;
switch (i) {
case 1: case RCCL: case RNCCL:
case RNULLS: case FINAL:
case S1FINAL: case S2FINAL:
/*
* XCU4: if we are working on an exclusive start state and
* the parent of this position is not RXSCON or RSTR this
* is not an active position.
*
* (There is a possibility that RSXCON appreas as the
* (parent)* node. Check it by check_me().)
*/
if ((exclusive[stnum/2]) &&
ISOPERATOR(name[parent[v]]) &&
(name[parent[v]] != RXSCON) &&
(name[parent[v]] != RSTR) &&
(check_me(v) == 0)) {
break;
}
if (tmpstat[v] == FALSE) {
count++;
tmpstat[v] = TRUE;
}
break;
case BAR: case RNEWE:
first(left[v]);
first(right[v]);
break;
case CARAT:
if (stnum % 2 == 1)
first(left[v]);
break;
/* XCU4: add RXSCON */
case RXSCON:
case RSCON:
i = stnum/2 +1;
p = (CHR *) right[v];
while (*p)
if (*p++ == i) {
first(left[v]);
break;
}
break;
case STAR: case QUEST:
case PLUS: case RSTR:
/*
* XCU4: if we are working on an exclusive start state and
* the parent of this position is not RXSCON or RSTR this
* is not an active position.
*
* (There is a possibility that RSXCON appreas as the
* (parent)* node. Check it by check_me().)
*/
if ((exclusive[stnum/2]) &&
ISOPERATOR(name[parent[v]]) &&
(name[parent[v]] != RXSCON) &&
(name[parent[v]] != RSTR) &&
(check_me(v) == 0)) {
break;
}
first(left[v]);
break;
case RCAT: case DIV:
first(left[v]);
if (nullstr[left[v]])
first(right[v]);
break;
#ifdef DEBUG
default:
warning("bad switch first %d", v);
#endif
}
}
void
cgoto(void)
{
int i, j;
static int s;
int npos, curpos, n;
int tryit;
CHR tch[MAXNCG];
int tst[MAXNCG];
CHR *q;
/* generate initial state, for each start condition */
if (ratfor) {
(void) fprintf(fout, "blockdata\n");
(void) fprintf(fout, "common /Lvstop/ vstop\n");
(void) fprintf(fout, "define Svstop %d\n", nstates+1);
(void) fprintf(fout, "integer vstop(Svstop)\n");
} else
(void) fprintf(fout, "int yyvstop[] = {\n0,\n");
while (stnum < 2 || stnum/2 < sptr) {
for (i = 0; i < tptr; i++)
tmpstat[i] = 0;
count = 0;
if (tptr > 0)
first(tptr-1);
add(state, stnum);
#ifdef DEBUG
if (debug) {
if (stnum > 1)
(void) printf("%ws:\n", sname[stnum/2]);
pstate(stnum);
}
#endif
stnum++;
}
stnum--;
/* even stnum = might not be at line begin */
/* odd stnum = must be at line begin */
/* even states can occur anywhere, odd states only at line begin */
for (s = 0; s <= stnum; s++) {
tryit = FALSE;
cpackflg[s] = FALSE;
sfall[s] = -1;
acompute(s);
for (i = 0; i < ncg; i++)
symbol[i] = 0;
npos = *state[s];
for (i = 1; i <= npos; i++) {
curpos = *(state[s]+i);
if (!ISOPERATOR(name[curpos]))
symbol[name[curpos]] = TRUE;
else {
switch (name[curpos]) {
case RCCL:
tryit = TRUE;
q = (CHR *)left[curpos];
while (*q) {
for (j = 1; j < ncg; j++)
if (cindex[j] == *q)
symbol[j] =
TRUE;
q++;
}
break;
case RSTR:
symbol[right[curpos]] = TRUE;
break;
#ifdef DEBUG
case RNULLS:
case FINAL:
case S1FINAL:
case S2FINAL:
break;
default:
warning(
"bad switch cgoto %d state %d",
curpos, s);
break;
#endif
}
}
}
#ifdef DEBUG
if (debug) {
printf("State %d transitions on char-group {", s);
charc = 0;
for (i = 1; i < ncg; i++) {
if (symbol[i]) {
printf("%d,", i);
}
if (i == ncg-1)
printf("}\n");
if (charc > LINESIZE/4) {
charc = 0;
printf("\n\t");
}
}
}
#endif
/* for each char, calculate next state */
n = 0;
for (i = 1; i < ncg; i++) {
if (symbol[i]) {
/* executed for each state, transition pair */
nextstate(s, i);
xstate = notin(stnum);
if (xstate == -2)
warning("bad state %d %o", s, i);
else if (xstate == -1) {
if (stnum+1 >= nstates) {
stnum++;
error("Too many states %s",
(nstates == NSTATES ?
"\nTry using %n num":""));
}
add(state, ++stnum);
#ifdef DEBUG
if (debug)
pstate(stnum);
#endif
tch[n] = i;
tst[n++] = stnum;
} else { /* xstate >= 0 ==> state exists */
tch[n] = i;
tst[n++] = xstate;
}
}
}
tch[n] = 0;
tst[n] = -1;
/* pack transitions into permanent array */
if (n > 0)
packtrans(s, tch, tst, n, tryit);
else
gotof[s] = -1;
}
(void) (ratfor ? fprintf(fout, "end\n") : fprintf(fout, "0};\n"));
}
/*
* Beware -- 70% of total CPU time is spent in this subroutine -
* if you don't believe me - try it yourself !
*/
static void
nextstate(int s, int c)
{
int j, *newpos;
CHR *temp, *tz;
int *pos, i, *f, num, curpos, number;
/* state to goto from state s on char c */
num = *state[s];
temp = tmpstat;
pos = state[s] + 1;
for (i = 0; i < num; i++) {
curpos = *pos++;
j = name[curpos];
if ((!ISOPERATOR(j)) && j == c ||
j == RSTR && c == right[curpos] ||
j == RCCL && member(c, (CHR *) left[curpos])) {
f = foll[curpos];
number = *f;
newpos = f+1;
for (j = 0; j < number; j++)
temp[*newpos++] = 2;
}
}
j = 0;
tz = temp + tptr;
while (temp < tz) {
if (*temp == 2) {
j++;
*temp++ = 1;
}
else
*temp++ = 0;
}
count = j;
}
static int
notin(int n)
{ /* see if tmpstat occurs previously */
int *j, k;
CHR *temp;
int i;
if (count == 0)
return (-2);
temp = tmpstat;
for (i = n; i >= 0; i--) { /* for each state */
j = state[i];
if (count == *j++) {
for (k = 0; k < count; k++)
if (!temp[*j++])
break;
if (k >= count)
return (i);
}
}
return (-1);
}
static void
packtrans(int st, CHR *tch, int *tst, int cnt, int tryit)
{
/*
* pack transitions into nchar, nexts
* nchar is terminated by '\0', nexts uses cnt, followed by elements
* gotof[st] = index into nchr, nexts for state st
* sfall[st] = t implies t is fall back state for st
* == -1 implies no fall back
*/
int cmin, cval, tcnt, diff, p, *ast;
int i, j, k;
CHR *ach;
int go[MAXNCG], temp[MAXNCG], index, c;
int swork[MAXNCG];
CHR cwork[MAXNCG];
int upper;
rcount += (long)cnt;
cmin = -1;
cval = ncg;
ast = tst;
ach = tch;
/* try to pack transitions using ccl's */
if (!optim)
goto nopack; /* skip all compaction */
if (tryit) { /* ccl's used */
for (i = 1; i < ncg; i++) {
go[i] = temp[i] = -1;
symbol[i] = 1;
}
for (i = 0; i < cnt; i++) {
index = (unsigned char) tch[i];
if ((index >= 0) && (index < NCH)) {
go[index] = tst[i];
symbol[index] = 0;
} else {
(void) fprintf(stderr,
"lex`sub2`packtran: tch[%d] out of bounds (%d)\n",
i, (int)tch[i]);
}
}
for (i = 0; i < cnt; i++) {
c = match[tch[i]];
if (go[c] != tst[i] || c == tch[i])
temp[tch[i]] = tst[i];
}
/* fill in error entries */
for (i = 1; i < ncg; i++)
if (symbol[i])
temp[i] = -2; /* error trans */
/* count them */
k = 0;
for (i = 1; i < ncg; i++)
if (temp[i] != -1)
k++;
if (k < cnt) { /* compress by char */
#ifdef DEBUG
if (debug)
(void) printf(
"use compression %d, %d vs %d\n", st, k, cnt);
#endif
k = 0;
for (i = 1; i < ncg; i++)
if (temp[i] != -1) {
cwork[k] = i;
swork[k++] =
(temp[i] == -2 ? -1 : temp[i]);
}
cwork[k] = 0;
#ifdef PC
ach = cwork;
ast = swork;
cnt = k;
cpackflg[st] = TRUE;
#endif
}
}
/*
* get most similar state
* reject state with more transitions,
* state already represented by a third state,
* and state which is compressed by char if ours is not to be
*/
for (i = 0; i < st; i++) {
if (sfall[i] != -1)
continue;
if (cpackflg[st] == 1)
if (!(cpackflg[i] == 1))
continue;
p = gotof[i];
if (p == -1) /* no transitions */
continue;
tcnt = nexts[p];
if (tcnt > cnt)
continue;
diff = 0;
k = 0;
j = 0;
upper = p + tcnt;
while (ach[j] && p < upper) {
while (ach[j] < nchar[p] && ach[j]) {
diff++;
j++;
}
if (ach[j] == 0)
break;
if (ach[j] > nchar[p]) {
diff = ncg;
break;
}
/* ach[j] == nchar[p] */
if (ast[j] != nexts[++p] ||
ast[j] == -1 ||
(cpackflg[st] && ach[j] != match[ach[j]]))
diff++;
j++;
}
while (ach[j]) {
diff++;
j++;
}
if (p < upper)
diff = ncg;
if (diff < cval && diff < tcnt) {
cval = diff;
cmin = i;
if (cval == 0)
break;
}
}
/* cmin = state "most like" state st */
#ifdef DEBUG
if (debug)
(void) printf("select st %d for st %d diff %d\n",
cmin, st, cval);
#endif
#ifdef PS
if (cmin != -1) { /* if we can use st cmin */
gotof[st] = nptr;
k = 0;
sfall[st] = cmin;
p = gotof[cmin] + 1;
j = 0;
while (ach[j]) {
/* if cmin has a transition on c, then so will st */
/* st may be "larger" than cmin, however */
while (ach[j] < nchar[p-1] && ach[j]) {
k++;
nchar[nptr] = ach[j];
nexts[++nptr] = ast[j];
j++;
}
if (nchar[p-1] == 0)
break;
if (ach[j] > nchar[p-1]) {
warning("bad transition %d %d", st, cmin);
goto nopack;
}
/* ach[j] == nchar[p-1] */
if (ast[j] != nexts[p] ||
ast[j] == -1 ||
(cpackflg[st] && ach[j] != match[ach[j]])) {
k++;
nchar[nptr] = ach[j];
nexts[++nptr] = ast[j];
}
p++;
j++;
}
while (ach[j]) {
nchar[nptr] = ach[j];
nexts[++nptr] = ast[j++];
k++;
}
nexts[gotof[st]] = cnt = k;
nchar[nptr++] = 0;
} else {
#endif
nopack:
/* stick it in */
gotof[st] = nptr;
nexts[nptr] = cnt;
for (i = 0; i < cnt; i++) {
nchar[nptr] = ach[i];
nexts[++nptr] = ast[i];
}
nchar[nptr++] = 0;
#ifdef PS
}
#endif
if (cnt < 1) {
gotof[st] = -1;
nptr--;
} else
if (nptr > ntrans)
error(
"Too many transitions %s",
(ntrans == NTRANS ? "\nTry using %a num" : ""));
}
#ifdef DEBUG
void
pstate(int s)
{
int *p, i, j;
(void) printf("State %d:\n", s);
p = state[s];
i = *p++;
if (i == 0)
return;
(void) printf("%4d", *p++);
for (j = 1; j < i; j++) {
(void) printf(", %4d", *p++);
if (j%30 == 0)
(void) putchar('\n');
}
(void) putchar('\n');
}
#endif
static int
member(int d, CHR *t)
{
int c;
CHR *s;
c = d;
s = t;
c = cindex[c];
while (*s)
if (*s++ == c)
return (1);
return (0);
}
#ifdef DEBUG
void
stprt(int i)
{
int p, t;
(void) printf("State %d:", i);
/* print actions, if any */
t = atable[i];
if (t != -1)
(void) printf(" final");
(void) putchar('\n');
if (cpackflg[i] == TRUE)
(void) printf("backup char in use\n");
if (sfall[i] != -1)
(void) printf("fall back state %d\n", sfall[i]);
p = gotof[i];
if (p == -1)
return;
(void) printf("(%d transitions)\n", nexts[p]);
while (nchar[p]) {
charc = 0;
if (nexts[p+1] >= 0)
(void) printf("%d\t", nexts[p+1]);
else
(void) printf("err\t");
allprint(nchar[p++]);
while (nexts[p] == nexts[p+1] && nchar[p]) {
if (charc > LINESIZE) {
charc = 0;
(void) printf("\n\t");
}
allprint(nchar[p++]);
}
(void) putchar('\n');
}
(void) putchar('\n');
}
#endif
/* compute action list = set of poss. actions */
static void
acompute(int s)
{
int *p, i, j;
int q, r;
int cnt, m;
int temp[MAXPOSSTATE], k, neg[MAXPOSSTATE], n;
k = 0;
n = 0;
p = state[s];
cnt = *p++;
if (cnt > MAXPOSSTATE)
error("Too many positions for one state - acompute");
for (i = 0; i < cnt; i++) {
q = *p;
if (name[q] == FINAL)
temp[k++] = left[q];
else if (name[q] == S1FINAL) {
temp[k++] = left[q];
if ((r = left[q]) >= NACTIONS)
error(
"INTERNAL ERROR:left[%d]==%d>=NACTIONS", q, r);
extra[r] = 1;
} else if (name[q] == S2FINAL)
neg[n++] = left[q];
p++;
}
atable[s] = -1;
if (k < 1 && n < 1)
return;
#ifdef DEBUG
if (debug)
(void) printf("final %d actions:", s);
#endif
/* sort action list */
for (i = 0; i < k; i++)
for (j = i+1; j < k; j++)
if (temp[j] < temp[i]) {
m = temp[j];
temp[j] = temp[i];
temp[i] = m;
}
/* remove dups */
for (i = 0; i < k-1; i++)
if (temp[i] == temp[i+1])
temp[i] = 0;
/* copy to permanent quarters */
atable[s] = aptr;
#ifdef DEBUG
if (!ratfor)
(void) fprintf(fout, "/* actions for state %d */", s);
#endif
(void) putc('\n', fout);
for (i = 0; i < k; i++)
if (temp[i] != 0) {
(void) (ratfor ?
fprintf(fout, "data vstop(%d)/%d/\n",
aptr, temp[i]) :
fprintf(fout, "%d,\n", temp[i]));
#ifdef DEBUG
if (debug)
(void) printf("%d ", temp[i]);
#endif
aptr++;
}
for (i = 0; i < n; i++) { /* copy fall back actions - all neg */
ratfor ?
(void) fprintf(fout, "data vstop(%d)/%d/\n", aptr, neg[i]) :
(void) fprintf(fout, "%d,\n", neg[i]);
aptr++;
#ifdef DEBUG
if (debug)
(void) printf("%d ", neg[i]);
#endif
}
#ifdef DEBUG
if (debug)
(void) putchar('\n');
#endif
(void) (ratfor ? fprintf(fout, "data vstop (%d)/0/\n", aptr) :
fprintf(fout, "0, \n"));
aptr++;
}
#ifdef DEBUG
void
pccl(void)
{
/* print character class sets */
int i, j;
(void) printf("char class intersection\n");
for (i = 0; i < ccount; i++) {
charc = 0;
(void) printf("class %d:\n\t", i);
for (j = 1; j < ncg; j++)
if (cindex[j] == i) {
allprint(j);
if (charc > LINESIZE) {
(void) printf("\n\t");
charc = 0;
}
}
(void) putchar('\n');
}
charc = 0;
(void) printf("match:\n");
for (i = 0; i < ncg; i++) {
allprint(match[i]);
if (charc > LINESIZE) {
(void) putchar('\n');
charc = 0;
}
}
(void) putchar('\n');
}
#endif
void
mkmatch(void)
{
int i;
CHR tab[MAXNCG];
for (i = 0; i < ccount; i++)
tab[i] = 0;
for (i = 1; i < ncg; i++)
if (tab[cindex[i]] == 0)
tab[cindex[i]] = i;
/* tab[i] = principal char for new ccl i */
for (i = 1; i < ncg; i++)
match[i] = tab[cindex[i]];
}
void
layout(void)
{
/* format and output final program's tables */
int i, j, k;
int top, bot, startup, omin;
startup = 0;
for (i = 0; i < outsize; i++)
verify[i] = advance[i] = 0;
omin = 0;
yytop = 0;
for (i = 0; i <= stnum; i++) { /* for each state */
j = gotof[i];
if (j == -1) {
stoff[i] = 0;
continue;
}
bot = j;
while (nchar[j])
j++;
top = j - 1;
#if DEBUG
if (debug) {
(void) printf("State %d: (layout)\n", i);
for (j = bot; j <= top; j++) {
(void) printf(" %o", nchar[j]);
if (j % 10 == 0)
(void) putchar('\n');
}
(void) putchar('\n');
}
#endif
while (verify[omin+ZCH])
omin++;
startup = omin;
#if DEBUG
if (debug)
(void) printf(
"bot,top %d, %d startup begins %d\n",
bot, top, startup);
#endif
if (chset) {
do {
startup += 1;
if (startup > outsize - ZCH)
error("output table overflow");
for (j = bot; j <= top; j++) {
k = startup+ctable[nchar[j]];
if (verify[k])
break;
}
} while (j <= top);
#if DEBUG
if (debug)
(void) printf(" startup will be %d\n",
startup);
#endif
/* have found place */
for (j = bot; j <= top; j++) {
k = startup + ctable[nchar[j]];
if (ctable[nchar[j]] <= 0)
(void) printf(
"j %d nchar %d ctable.nch %d\n",
j, (int)nchar[j], ctable[nchar[k]]);
verify[k] = i + 1; /* state number + 1 */
advance[k] = nexts[j+1]+1;
if (yytop < k)
yytop = k;
}
} else {
do {
startup += 1;
if (startup > outsize - ZCH)
error("output table overflow");
for (j = bot; j <= top; j++) {
k = startup + nchar[j];
if (verify[k])
break;
}
} while (j <= top);
/* have found place */
#if DEBUG
if (debug)
(void) printf(" startup going to be %d\n", startup);
#endif
for (j = bot; j <= top; j++) {
k = startup + nchar[j];
verify[k] = i+1; /* state number + 1 */
advance[k] = nexts[j+1] + 1;
if (yytop < k)
yytop = k;
}
}
stoff[i] = startup;
}
/* stoff[i] = offset into verify, advance for trans for state i */
/* put out yywork */
if (ratfor) {
(void) fprintf(fout, "define YYTOPVAL %d\n", yytop);
rprint(verify, "verif", yytop+1);
rprint(advance, "advan", yytop+1);
shiftr(stoff, stnum);
rprint(stoff, "stoff", stnum+1);
shiftr(sfall, stnum);
upone(sfall, stnum+1);
rprint(sfall, "fall", stnum+1);
bprint(extra, "extra", casecount+1);
bprint((char *)match, "match", ncg);
shiftr(atable, stnum);
rprint(atable, "atable", stnum+1);
}
(void) fprintf(fout,
"# define YYTYPE %s\n", stnum+1 >= NCH ? "int" : "unsigned char");
(void) fprintf(fout,
"struct yywork { YYTYPE verify, advance; } yycrank[] = {\n");
for (i = 0; i <= yytop; i += 4) {
for (j = 0; j < 4; j++) {
k = i+j;
if (verify[k])
(void) fprintf(fout,
"%d,%d,\t", verify[k], advance[k]);
else
(void) fprintf(fout, "0,0,\t");
}
(void) putc('\n', fout);
}
(void) fprintf(fout, "0,0};\n");
/* put out yysvec */
(void) fprintf(fout, "struct yysvf yysvec[] = {\n");
(void) fprintf(fout, "0,\t0,\t0,\n");
for (i = 0; i <= stnum; i++) { /* for each state */
if (cpackflg[i])
stoff[i] = -stoff[i];
(void) fprintf(fout, "yycrank+%d,\t", stoff[i]);
if (sfall[i] != -1)
(void) fprintf(fout,
"yysvec+%d,\t", sfall[i]+1); /* state + 1 */
else
(void) fprintf(fout, "0,\t\t");
if (atable[i] != -1)
(void) fprintf(fout, "yyvstop+%d,", atable[i]);
else
(void) fprintf(fout, "0,\t");
#ifdef DEBUG
(void) fprintf(fout, "\t\t/* state %d */", i);
#endif
(void) putc('\n', fout);
}
(void) fprintf(fout, "0,\t0,\t0};\n");
/* put out yymatch */
(void) fprintf(fout, "struct yywork *yytop = yycrank+%d;\n", yytop);
(void) fprintf(fout, "struct yysvf *yybgin = yysvec+1;\n");
if (optim) {
if (handleeuc) {
(void) fprintf(fout, "int yymatch[] = {\n");
} else {
(void) fprintf(fout, "char yymatch[] = {\n");
}
if (chset == 0) { /* no chset, put out in normal order */
for (i = 0; i < ncg; i += 8) {
for (j = 0; j < 8; j++) {
int fbch;
fbch = match[i+j];
(void) fprintf(fout, "%3d, ", fbch);
}
(void) putc('\n', fout);
}
} else {
int *fbarr;
/*LINTED: E_BAD_PTR_CAST_ALIGN*/
fbarr = (int *)myalloc(2*MAXNCG, sizeof (*fbarr));
if (fbarr == 0)
error("No space for char table reverse", 0);
for (i = 0; i < MAXNCG; i++)
fbarr[i] = 0;
for (i = 0; i < ncg; i++)
fbarr[ctable[i]] = ctable[match[i]];
for (i = 0; i < ncg; i += 8) {
for (j = 0; j < 8; j++)
(void) fprintf(fout, "0%-3o,",
fbarr[i+j]);
(void) putc('\n', fout);
}
free(fbarr);
}
(void) fprintf(fout, "0};\n");
}
/* put out yyextra */
(void) fprintf(fout, "char yyextra[] = {\n");
for (i = 0; i < casecount; i += 8) {
for (j = 0; j < 8; j++)
(void) fprintf(fout, "%d,", i+j < NACTIONS ?
extra[i+j] : 0);
(void) putc('\n', fout);
}
(void) fprintf(fout, "0};\n");
if (handleeuc) {
/* Put out yycgidtbl */
(void) fprintf(fout, "#define YYNCGIDTBL %d\n", ncgidtbl);
(void) fprintf(fout, "\tunsigned long yycgidtbl[]={");
/*
* Use "unsigned long" instead of "lchar" to minimize
* the name-space polution for the application program.
*/
for (i = 0; i < ncgidtbl; ++i) {
if (i%8 == 0)
(void) fprintf(fout, "\n\t\t");
(void) fprintf(fout, "0x%08x, ", (int)yycgidtbl[i]);
}
(void) fprintf(fout, "\n\t0};\n");
}
}
static void
rprint(int *a, char *s, int n)
{
int i;
(void) fprintf(fout, "block data\n");
(void) fprintf(fout, "common /L%s/ %s\n", s, s);
(void) fprintf(fout, "define S%s %d\n", s, n);
(void) fprintf(fout, "integer %s (S%s)\n", s, s);
for (i = 1; i <= n; i++) {
if (i%8 == 1)
(void) fprintf(fout, "data ");
(void) fprintf(fout, "%s (%d)/%d/", s, i, a[i]);
(void) fprintf(fout, (i%8 && i < n) ? ", " : "\n");
}
(void) fprintf(fout, "end\n");
}
static void
shiftr(int *a, int n)
{
int i;
for (i = n; i >= 0; i--)
a[i+1] = a[i];
}
static void
upone(int *a, int n)
{
int i;
for (i = 0; i <= n; i++)
a[i]++;
}
static void
bprint(char *a, char *s, int n)
{
int i, j, k;
(void) fprintf(fout, "block data\n");
(void) fprintf(fout, "common /L%s/ %s\n", s, s);
(void) fprintf(fout, "define S%s %d\n", s, n);
(void) fprintf(fout, "integer %s (S%s)\n", s, s);
for (i = 1; i < n; i += 8) {
(void) fprintf(fout, "data %s (%d)/%d/", s, i, a[i]);
for (j = 1; j < 8; j++) {
k = i+j;
if (k < n)
(void) fprintf(fout,
", %s (%d)/%d/", s, k, a[k]);
}
(void) putc('\n', fout);
}
(void) fprintf(fout, "end\n");
}
#ifdef PP
static void
padd(int **array, int n)
{
int i, *j, k;
array[n] = nxtpos;
if (count == 0) {
*nxtpos++ = 0;
return;
}
for (i = tptr-1; i >= 0; i--) {
j = array[i];
if (j && *j++ == count) {
for (k = 0; k < count; k++)
if (!tmpstat[*j++])
break;
if (k >= count) {
array[n] = array[i];
return;
}
}
}
add(array, n);
}
#endif