uintptr_t *MJC_allocArray(int32_t elements, int32_t element_size) {
// size request was # bytes - convert to words
int32_t size = WORDSIZE(elements * element_size);
if (size < 0) {
die_w_msg("Negative array size request");
}
#ifdef DEBUG_ALLOC
printf("MJC alloc array: num elements %d, size %d bytes (%d words)\n", elements,
element_size, (int)WORDSIZE(element_size));
#endif
// array header includes type and size
uintptr_t *a = heapalloc(size + OBJ_HEADER_SIZE) + OBJ_HEADER_SIZE;
// store the marker "ARRAY" to indicate an array object
a[-OBJ_HEADER_TYPE_OFFSET] = (uintptr_t)(ARRAY_HEADER_TYPE);
a[-OBJ_HEADER_SIZE_OFFSET] = size;
// initialize remaining alloc space to 0
memset(a, 0, size * sizeof(uintptr_t));
return a;
}
void set_first_derives(void)
{
register unsigned *rrow;
register unsigned *vrow;
register int j;
register unsigned mask;
register unsigned cword;
register Yshort *rp;
int rule;
int i;
int rulesetsize;
int varsetsize;
rulesetsize = WORDSIZE(nrules);
varsetsize = WORDSIZE(nvars);
first_derives = NEW2(nvars * rulesetsize, first_derives[0]);
first_derives -= ntokens * rulesetsize;
set_EFF();
rrow = first_derives + ntokens * rulesetsize;
for (i = start_symbol; i < nsyms; ++i)
{
vrow = EFF + ((i - ntokens) * varsetsize);
cword = *vrow++;
mask = 1;
for (j = start_symbol; j < nsyms; ++j)
{
if (cword & mask)
{
rp = derives[j];
while ((rule = *rp++) >= 0)
{
SETBIT(rrow, rule);
}
}
mask <<= 1;
if (mask == 0)
{
cword = *vrow++;
mask = 1;
}
}
vrow += varsetsize;
rrow += rulesetsize;
}
if (tflag > 1)
print_first_derives();
FREE(EFF);
}
void set_first_derives(void)
{
unsigned *rrow;
unsigned *vrow;
int j;
unsigned mask;
unsigned cword;
short *rp;
int rule;
int i;
int rulesetsize;
int varsetsize;
rulesetsize = WORDSIZE(nrules);
varsetsize = WORDSIZE(nvars);
first_derives = NEW2(nvars * rulesetsize, unsigned) - ntokens * rulesetsize;
set_EFF();
rrow = first_derives + ntokens * rulesetsize;
for (i = start_symbol; i < nsyms; i++)
{
vrow = EFF + ((i - ntokens) * varsetsize);
cword = *vrow++;
mask = 1;
for (j = start_symbol; j < nsyms; j++)
{
if (cword & mask)
{
rp = derives[j];
while ((rule = *rp++) >= 0)
{
SETBIT(rrow, rule);
}
}
mask <<= 1;
if (mask == 0)
{
cword = *vrow++;
mask = 1;
}
}
vrow += varsetsize;
rrow += rulesetsize;
}
#ifdef DEBUG
print_first_derives();
#endif
FREE(EFF);
}
void
set_first_derives(void)
{
unsigned *rrow;
unsigned *vrow;
int j;
unsigned k;
unsigned cword = 0;
Value_t *rp;
int rule;
int i;
int rulesetsize;
int varsetsize;
rulesetsize = WORDSIZE(nrules);
varsetsize = WORDSIZE(nvars);
first_base = NEW2(nvars * rulesetsize, unsigned);
first_derives = first_base - ntokens * rulesetsize;
set_EFF();
rrow = first_derives + ntokens * rulesetsize;
for (i = start_symbol; i < nsyms; i++)
{
vrow = EFF + ((i - ntokens) * varsetsize);
k = BITS_PER_WORD;
for (j = start_symbol; j < nsyms; k++, j++)
{
if (k >= BITS_PER_WORD)
{
cword = *vrow++;
k = 0;
}
if (cword & (unsigned)(1 << k))
{
rp = derives[j];
while ((rule = *rp++) >= 0)
{
SETBIT(rrow, rule);
}
}
}
rrow += rulesetsize;
}
#ifdef DEBUG
print_first_derives();
#endif
FREE(EFF);
}
static void print_EFF(void)
{
register int i, j;
register unsigned *rowp;
register unsigned word;
register unsigned mask;
BtYacc_logf("\n\nEpsilon Free Firsts\n");
for (i = start_symbol; i < nsyms; ++i)
{
BtYacc_logf("\n%-30s : ", symbol_name[i]);
rowp = EFF + ((i - start_symbol) * WORDSIZE(nvars));
word = *rowp++;
mask = 1;
for (j = 0; j < nvars; ++j)
{
if (word & mask)
BtYacc_logf(" %s", symbol_name[start_symbol + j]);
mask <<= 1;
if (mask == 0)
{
word = *rowp++;
mask = 1;
}
}
}
}
static void set_EFF(void)
{
register unsigned *row;
register Yshort symbol;
register Yshort *sp;
register int rowsize;
register int i;
register int rule;
rowsize = WORDSIZE(nvars);
EFF = NEW2(nvars * rowsize, EFF[0]);
row = EFF;
for (i = start_symbol; i < nsyms; ++i)
{
sp = derives[i];
for (rule = *sp; rule > 0; rule = *++sp)
{
symbol = ritem[rrhs[rule]];
if (ISVAR(symbol))
{
symbol -= start_symbol;
SETBIT(row, symbol);
}
}
row += rowsize;
}
reflexive_transitive_closure(EFF, nvars);
if (tflag > 1)
print_EFF();
}
void
reflexive_transitive_closure(unsigned *R, int n)
{
int rowsize;
unsigned i;
unsigned *rp;
unsigned *relend;
transitive_closure(R, n);
rowsize = WORDSIZE(n);
relend = R + n*rowsize;
i = 0;
rp = R;
while (rp < relend)
{
*rp |= (1 << i);
if (++i >= BITS_PER_WORD)
{
i = 0;
rp++;
}
rp += rowsize;
}
}
void
finalize_closure(void)
{
FREE(itemset);
FREE(ruleset);
FREE(first_derives + ntokens * WORDSIZE(nrules));
}
void print_EFF(void)
{
int i, j, k;
unsigned *rowp;
unsigned word;
unsigned mask;
printf("\n\nEpsilon Free Firsts\n");
for (i = start_symbol; i < nsyms; i++)
{
printf("\n%s", symbol_name[i]);
rowp = EFF + ((i - start_symbol) * WORDSIZE(nvars));
word = *rowp++;
mask = 1;
for (j = 0; j < nvars; j++)
{
if (word & mask) printf(" %s", symbol_name[start_symbol + j]);
mask <<= 1;
if (mask == 0)
{
word = *rowp++;
mask = 1;
}
}
}
}
void set_EFF(void)
{
unsigned *row;
int symbol;
short *sp;
int rowsize;
int i;
int rule;
rowsize = WORDSIZE(nvars);
EFF = NEW2(nvars * rowsize, unsigned);
row = EFF;
for (i = start_symbol; i < nsyms; i++)
{
sp = derives[i];
for (rule = *sp; rule > 0; rule = *++sp)
{
symbol = ritem[rrhs[rule]];
if (ISVAR(symbol))
{
symbol -= start_symbol;
SETBIT(row, symbol);
}
}
row += rowsize;
}
reflexive_transitive_closure(EFF, nvars);
#ifdef DEBUG
print_EFF();
#endif
}
static void
print_EFF(void)
{
int i, j;
unsigned *rowp;
unsigned word;
unsigned k;
printf("\n\nEpsilon Free Firsts\n");
for (i = start_symbol; i < nsyms; i++)
{
printf("\n%s", symbol_name[i]);
rowp = EFF + ((i - start_symbol) * WORDSIZE(nvars));
word = *rowp++;
k = BITS_PER_WORD;
for (j = 0; j < nvars; k++, j++)
{
if (k >= BITS_PER_WORD)
{
word = *rowp++;
k = 0;
}
if (word & (1 << k))
printf(" %s", symbol_name[start_symbol + j]);
}
}
}
void reflexive_transitive_closure(unsigned *R, int n)
{
int rowsize;
unsigned mask;
unsigned *rp;
unsigned *relend;
transitive_closure(R, n);
rowsize = WORDSIZE(n);
relend = R + n*rowsize;
mask = 1;
rp = R;
while (rp < relend)
{
*rp |= mask;
mask <<= 1;
if (mask == 0)
{
mask = 1;
rp++;
}
rp += rowsize;
}
}
static void
print_first_derives(void)
{
int i;
int j;
unsigned *rp;
unsigned cword;
unsigned k;
printf("\n\n\nFirst Derives\n");
for (i = start_symbol; i < nsyms; i++)
{
printf("\n%s derives\n", symbol_name[i]);
rp = first_derives + i * WORDSIZE(nrules);
k = BITS_PER_WORD;
for (j = 0; j <= nrules; k++, j++)
{
if (k >= BITS_PER_WORD)
{
cword = *rp++;
k = 0;
}
if (cword & (1 << k))
printf(" %d\n", j);
}
}
fflush(stdout);
}
void
finalize_closure(void)
{
free(itemset);
free(ruleset);
free(first_derives + ntokens * WORDSIZE(nrules));
}
void print_first_derives(void)
{
int i;
int j;
unsigned *rp;
unsigned cword;
unsigned mask;
printf("\n\n\nFirst Derives\n");
for (i = start_symbol; i < nsyms; i++)
{
printf("\n%s derives\n", symbol_name[i]);
rp = first_derives + i * WORDSIZE(nrules);
cword = *rp++;
mask = 1;
for (j = 0; j <= nrules; j++)
{
if (cword & mask) printf(" %d\n", j);
mask <<= 1;
if (mask == 0)
{
cword = *rp++;
mask = 1;
}
}
}
fflush(stdout);
}
uintptr_t *MJC_allocObject(size_t size) {
#ifdef DEBUG_ALLOC
printf("MJC alloc object size %zu bytes (%zu words)\n", size, WORDSIZE(size));
#endif
// size request was # bytes - convert to words
size = WORDSIZE(size);
uintptr_t *obj = heapalloc(size + OBJ_HEADER_SIZE) + OBJ_HEADER_SIZE;
// store a class type into the header for later use
obj[-OBJ_HEADER_TYPE_OFFSET] = (uintptr_t)(OBJECT_HEADER_TYPE);
obj[-OBJ_HEADER_SIZE_OFFSET] = size;
// initialize remaining alloc space to 0
memset(obj, 0, size * sizeof(uintptr_t));
return obj;
}
void transitive_closure(unsigned *R, int n)
{
int rowsize;
unsigned mask;
unsigned *rowj;
unsigned *rp;
unsigned *rend;
unsigned *ccol;
unsigned *relend;
unsigned *cword;
unsigned *rowi;
rowsize = WORDSIZE(n);
relend = R + n*rowsize;
cword = R;
mask = 1;
rowi = R;
while (rowi < relend)
{
ccol = cword;
rowj = R;
while (rowj < relend)
{
if (*ccol & mask)
{
rp = rowi;
rend = rowj + rowsize;
while (rowj < rend)
*rowj++ |= *rp++;
}
else
{
rowj += rowsize;
}
ccol += rowsize;
}
mask <<= 1;
if (mask == 0)
{
mask = 1;
cword++;
}
rowi += rowsize;
}
}
static void
transitive_closure(unsigned *R, int n)
{
int rowsize;
unsigned i;
unsigned *rowj;
unsigned *rp;
unsigned *rend;
unsigned *ccol;
unsigned *relend;
unsigned *cword;
unsigned *rowi;
rowsize = WORDSIZE(n);
relend = R + n*rowsize;
cword = R;
i = 0;
rowi = R;
while (rowi < relend)
{
ccol = cword;
rowj = R;
while (rowj < relend)
{
if (*ccol & (1 << i))
{
rp = rowi;
rend = rowj + rowsize;
while (rowj < rend)
*rowj++ |= *rp++;
}
else
{
rowj += rowsize;
}
ccol += rowsize;
}
if (++i >= BITS_PER_WORD)
{
i = 0;
cword++;
}
rowi += rowsize;
}
}
static void print_first_derives(void)
{
register int i;
register int j;
register unsigned *rp;
register unsigned cword;
register unsigned mask;
int kp;
BtYacc_logf("\n\n\nFirst Derives\n");
for (i = start_symbol; i < nsyms; ++i)
{
BtYacc_logf("\n%-30s derives\n", symbol_name[i]);
assert(i >= ntokens);
rp = first_derives + i * WORDSIZE(nrules);
cword = *rp++;
mask = 1;
kp = 0;
for (j = 0; j <= nrules; ++j)
{
if (cword & mask)
{
BtYacc_logf(" %5d", j);
kp++;
if (kp == 10)
{
BtYacc_logf("\n");
kp = 0;
}
}
mask <<= 1;
if (mask == 0)
{
cword = *rp++;
mask = 1;
}
}
if (kp)
{
BtYacc_logf("\n");
}
}
fflush(stdout);
}
void lalr() {
tokensetsize = WORDSIZE(ntokens);
set_state_table();
set_accessing_symbol();
set_shift_table();
set_reduction_table();
set_maxrhs();
initialize_LA();
set_goto_map();
initialize_F();
build_relations();
compute_FOLLOWS();
compute_lookaheads();
}
static void
transitive_closure(unsigned *R, int n)
{
register size_t rowsize;
register unsigned mask;
register unsigned *rowj;
register unsigned *rp;
register unsigned *rend;
register unsigned *ccol;
unsigned *relend;
unsigned *cword;
unsigned *rowi;
rowsize = WORDSIZE (n) * sizeof (unsigned);
relend = (unsigned *) ((char *) R + (n * rowsize));
cword = R;
mask = 1;
rowi = R;
while (rowi < relend) {
ccol = cword;
rowj = R;
while (rowj < relend) {
if (*ccol & mask) {
rp = rowi;
rend = (unsigned *) ((char *) rowj + rowsize);
while (rowj < rend)
*rowj++ |= *rp++;
} else {
rowj = (unsigned *) ((char *) rowj + rowsize);
}
ccol = (unsigned *) ((char *) ccol + rowsize);
}
mask <<= 1;
if (mask == 0) {
mask = 1;
cword++;
}
rowi = (unsigned *) ((char *) rowi + rowsize);
}
}
static void graph_LA(int ruleno) {
int i;
unsigned tokensetsize;
unsigned *rowp;
tokensetsize = (unsigned)WORDSIZE(ntokens);
if (ruleno == LAruleno[larno]) {
rowp = LA + larno * tokensetsize;
fprintf(graph_file, " { ");
for (i = ntokens - 1; i >= 0; i--)
if (BIT(rowp, i))
fprintf(graph_file, "%s ", symbol_pname[i]);
fprintf(graph_file, "}");
++larno;
}
}
action* add_reductions(int stateno, action* actions) {
register int i, j, m, n;
register int ruleno, tokensetsize;
register unsigned *rowp;
tokensetsize = WORDSIZE(ntokens);
m = lookaheads[stateno];
n = lookaheads[stateno + 1];
for (i = m; i < n; i++)
{
ruleno = LAruleno[i];
rowp = LA + i * tokensetsize;
for (j = ntokens - 1; j >= 0; j--)
{
if (BIT(rowp, j))
actions = add_reduce(actions, ruleno, j);
}
}
return (actions);
}
void
closure(Value_t *nucleus, int n)
{
unsigned ruleno;
unsigned word;
unsigned i;
Value_t *csp;
unsigned *dsp;
unsigned *rsp;
int rulesetsize;
Value_t *csend;
unsigned *rsend;
int symbol;
Value_t itemno;
rulesetsize = WORDSIZE(nrules);
rsend = ruleset + rulesetsize;
for (rsp = ruleset; rsp < rsend; rsp++)
*rsp = 0;
csend = nucleus + n;
for (csp = nucleus; csp < csend; ++csp)
{
symbol = ritem[*csp];
if (ISVAR(symbol))
{
dsp = first_derives + symbol * rulesetsize;
rsp = ruleset;
while (rsp < rsend)
*rsp++ |= *dsp++;
}
}
ruleno = 0;
itemsetend = itemset;
csp = nucleus;
for (rsp = ruleset; rsp < rsend; ++rsp)
{
word = *rsp;
if (word)
{
for (i = 0; i < BITS_PER_WORD; ++i)
{
if (word & (unsigned)(1 << i))
{
itemno = rrhs[ruleno + i];
while (csp < csend && *csp < itemno)
*itemsetend++ = *csp++;
*itemsetend++ = itemno;
while (csp < csend && *csp == itemno)
++csp;
}
}
}
ruleno += BITS_PER_WORD;
}
while (csp < csend)
*itemsetend++ = *csp++;
#ifdef DEBUG
print_closure(n);
#endif
}
void closure(short *nucleus,int n)
{
int ruleno;
unsigned word;
unsigned mask;
short *csp;
unsigned *dsp;
unsigned *rsp;
int rulesetsize;
short *csend;
unsigned *rsend;
int symbol;
int itemno;
rulesetsize = WORDSIZE(nrules);
rsp = ruleset;
rsend = ruleset + rulesetsize;
for (rsp = ruleset; rsp < rsend; rsp++)
*rsp = 0;
csend = nucleus + n;
for (csp = nucleus; csp < csend; ++csp)
{
symbol = ritem[*csp];
if (ISVAR(symbol))
{
dsp = first_derives + symbol * rulesetsize;
rsp = ruleset;
while (rsp < rsend)
*rsp++ |= *dsp++;
}
}
ruleno = 0;
itemsetend = itemset;
csp = nucleus;
for (rsp = ruleset; rsp < rsend; ++rsp)
{
word = *rsp;
if (word == 0) ruleno += BITS_PER_WORD;
else
{
mask = 1;
while (mask)
{
if (word & mask)
{
itemno = rrhs[ruleno];
while (csp < csend && *csp < itemno)
*itemsetend++ = *csp++;
*itemsetend++ = itemno;
while (csp < csend && *csp == itemno)
++csp;
}
mask <<= 1;
++ruleno;
}
}
}
while (csp < csend)
*itemsetend++ = *csp++;
#ifdef DEBUG
print_closure(n);
#endif
}
