void gen_bu_action()
{
if ( reject || num_backing_up == 0 )
return;
set_indent( 3 );
indent_puts( "case 0: /* must back up */" );
indent_puts( "/* undo the effects of YY_DO_BEFORE_ACTION */" );
indent_puts( "*yy_cp = yy_hold_char;" );
if ( fullspd || fulltbl )
indent_puts( "yy_cp = yy_last_accepting_cpos + 1;" );
else
/* Backing-up info for compressed tables is taken \after/
* yy_cp has been incremented for the next state.
*/
indent_puts( "yy_cp = yy_last_accepting_cpos;" );
indent_puts( "yy_current_state = yy_last_accepting_state;" );
indent_puts( "goto yy_find_action;" );
outc( '\n' );
set_indent( 0 );
}
//特定のキーから離れたときに動作する
gboolean key_release(GtkWidget *widget, GdkEventKey *event)
{
if ((event->keyval == GDK_braceright || (event->keyval == GDK_bracketright && press_brace == 1)) && (state & auto_mask)) {
press_brace = 0;
set_indent();
} else if (event->keyval == GDK_Return && (state & auto_mask)) {
set_indent();
}
return FALSE;
}
//特定のキーが押された時に動作する
gboolean key_press(GtkWidget *widget, GdkEventKey *event)
{
if (event->keyval == GDK_Tab && (state & auto_mask)) {
if (gtk_text_buffer_get_has_selection(GTK_TEXT_BUFFER(buffer))) {
set_indent_all();
} else {
set_indent();
}
return TRUE;
} else if (event->keyval == GDK_BackSpace && (state & delete_mask) && !gtk_text_buffer_get_has_selection(GTK_TEXT_BUFFER(buffer))) {
if (delete_hungry_backward()) return TRUE;
} else if (event->keyval == GDK_Delete && (state & delete_mask) && !gtk_text_buffer_get_has_selection(GTK_TEXT_BUFFER(buffer))) {
if (delete_hungry_forward()) return TRUE;
}
if (event->keyval == GDK_braceright && (state & auto_mask)) press_brace = 1;
return FALSE;
}
/*
* Prints brief annotation for a row of data values
*/
static void
annotate_brief(
const ncvar_t *vp, /* variable */
const size_t *cor, /* corner coordinates */
size_t vdims[] /* variable dimension sizes */
)
{
int vrank = vp->ndims;
int id;
printf ("// ");
print_name(vp->name);
printf("(");
switch (formatting_specs.data_lang) {
case LANG_C:
/* print brief comment with C variable indices */
for (id = 0; id < vrank-1; id++)
printf("%lu,", (unsigned long)cor[id]);
if (vdims[vrank-1] == 1)
printf("0");
else
printf(" 0-%lu", (unsigned long)vdims[vrank-1]-1);
break;
case LANG_F:
/* print brief comment with Fortran variable indices */
if (vdims[vrank-1] == 1)
printf("1");
else
printf("1-%lu ", (unsigned long)vdims[vrank-1]);
for (id = vrank-2; id >=0 ; id--) {
printf(",%lu", (unsigned long)(1 + cor[id]));
}
break;
}
printf(")\n");
indent_out();
printf(" ");
set_indent(4 + indent_get());
}
static void out_linetoscr_mode (DEPTH_T bpp, HMODE_T hmode, int aga, CMODE_T cmode)
{
int old_indent = set_indent (8);
if (aga && cmode == CMODE_DUALPF) {
outln ( "int *lookup = bpldualpfpri ? dblpf_ind2_aga : dblpf_ind1_aga;");
outln ( "int *lookup_no = bpldualpfpri ? dblpf_2nd2 : dblpf_2nd1;");
} else if (cmode == CMODE_DUALPF)
outln ( "int *lookup = bpldualpfpri ? dblpf_ind2 : dblpf_ind1;");
/* TODO: add support for combining pixel writes in 8-bpp modes. */
if (bpp == DEPTH_16BPP && hmode != HMODE_DOUBLE) {
outln ( "int rem;");
outln ( "if (((long)&buf[dpix]) & 2) {");
outln ( " uae_u32 spix_val;");
outln ( " uae_u32 dpix_val;");
out_linetoscr_do_srcpix (bpp, hmode, aga, cmode);
out_linetoscr_do_dstpix (bpp, hmode, aga, cmode);
out_linetoscr_do_incspix (bpp, hmode, aga, cmode);
outln ( " buf[dpix++] = dpix_val;");
outln ( "}");
outln ( "if (dpix >= stoppos)");
outln ( " return spix;");
outln ( "rem = (((long)&buf[stoppos]) & 2);");
outln ( "if (rem)");
outln ( " stoppos--;");
}
outln ( "while (dpix < stoppos) {");
outln ( " uae_u32 spix_val;");
outln ( " uae_u32 dpix_val;");
outln ( " uae_u32 out_val;");
outln ( "");
out_linetoscr_do_srcpix (bpp, hmode, aga, cmode);
out_linetoscr_do_dstpix (bpp, hmode, aga, cmode);
out_linetoscr_do_incspix (bpp, hmode, aga, cmode);
outln ( " out_val = dpix_val;");
if (hmode != HMODE_DOUBLE && bpp == DEPTH_16BPP) {
out_linetoscr_do_srcpix (bpp, hmode, aga, cmode);
out_linetoscr_do_dstpix (bpp, hmode, aga, cmode);
out_linetoscr_do_incspix (bpp, hmode, aga, cmode);
if (do_bigendian)
outln ( " out_val = (out_val << 16) | (dpix_val & 0xFFFF);");
else
outln ( " out_val = (out_val & 0xFFFF) | (dpix_val << 16);");
}
if (hmode == HMODE_DOUBLE) {
if (bpp == DEPTH_8BPP) {
outln ( " *((uae_u16 *)&buf[dpix]) = (uae_u16) out_val;");
outln ( " dpix += 2;");
} else if (bpp == DEPTH_16BPP) {
outln ( " *((uae_u32 *)&buf[dpix]) = out_val;");
outln ( " dpix += 2;");
} else {
outln ( " buf[dpix++] = out_val;");
outln ( " buf[dpix++] = out_val;");
}
} else {
if (bpp == DEPTH_16BPP) {
outln ( " *((uae_u32 *)&buf[dpix]) = out_val;");
outln ( " dpix += 2;");
} else
outln ( " buf[dpix++] = out_val;");
}
outln ( "}");
if (bpp == DEPTH_16BPP && hmode != HMODE_DOUBLE) {
outln ( "if (rem) {");
outln ( " uae_u32 spix_val;");
outln ( " uae_u32 dpix_val;");
out_linetoscr_do_srcpix (bpp, hmode, aga, cmode);
out_linetoscr_do_dstpix (bpp, hmode, aga, cmode);
out_linetoscr_do_incspix (bpp, hmode, aga, cmode);
outln ( " buf[dpix++] = dpix_val;");
outln ( "}");
}
set_indent (old_indent);
return;
}
/* Output the data for a single variable, in NcML syntax.
* TODO: currently not called, need option for NcML with values ... */
int
vardatax(
const ncvar_t *vp, /* variable */
size_t vdims[], /* variable dimension sizes */
int ncid, /* netcdf id */
int varid /* variable id */
)
{
size_t *cor; /* corner coordinates */
size_t *edg; /* edges of hypercube */
size_t *add; /* "odometer" increment to next "row" */
void *vals;
int id;
int ir;
size_t nels;
size_t ncols;
size_t nrows;
int vrank = vp->ndims;
cor = (size_t *) emalloc((vrank + 1) * sizeof(size_t));
edg = (size_t *) emalloc((vrank + 1) * sizeof(size_t));
add = (size_t *) emalloc((vrank + 1) * sizeof(size_t));
nels = 1;
for (id = 0; id < vrank; id++) {
cor[id] = 0;
edg[id] = 1;
nels *= vdims[id]; /* total number of values for variable */
}
printf(" <values>\n ");
set_indent (7);
if (vrank < 1) {
ncols = 1;
} else {
ncols = vdims[vrank-1]; /* size of "row" along last dimension */
edg[vrank-1] = vdims[vrank-1];
for (id = 0; id < vrank; id++)
add[id] = 0;
if (vrank > 1)
add[vrank-2] = 1;
}
nrows = nels/ncols; /* number of "rows" */
vals = emalloc(ncols * vp->tinfo->size);
for (ir = 0; ir < nrows; ir++) {
size_t corsav;
bool_t lastrow;
if (vrank > 0) {
corsav = cor[vrank-1];
}
lastrow = (bool_t)(ir == nrows-1);
if (vrank > 0)
edg[vrank-1] = ncols;
NC_CHECK(nc_get_vara(ncid, varid, cor, edg, vals) );
/* Test if we should treat array of chars as a string */
if(vp->type == NC_CHAR &&
(vp->fmt == 0 || STREQ(vp->fmt,"%s") || STREQ(vp->fmt,""))) {
pr_tvalsx(vp, ncols, 0, lastrow, (char *) vals);
} else {
pr_any_valsx(vp, ncols, 0, lastrow, vals);
}
if (vrank > 0)
cor[vrank-1] += ncols;
if (vrank > 0)
cor[vrank-1] = corsav;
if (ir < nrows-1)
if (!upcorner(vdims,vp->ndims,cor,add))
error("vardata: odometer overflowed!");
set_indent(2);
}
printf(" </values>\n");
free(vals);
free(cor);
free(edg);
free(add);
return 0;
}
/* Output the data for a single variable, in CDL syntax. */
int
vardata(
const ncvar_t *vp, /* variable */
size_t vdims[], /* variable dimension sizes */
int ncid, /* netcdf id */
int varid /* variable id */
)
{
size_t *cor; /* corner coordinates */
size_t *edg; /* edges of hypercube */
size_t *add; /* "odometer" increment to next "row" */
void *vals;
int id;
int ir;
size_t nels;
size_t ncols;
size_t nrows;
int vrank = vp->ndims;
cor = (size_t *) emalloc((1 + vrank) * sizeof(size_t));
edg = (size_t *) emalloc((1 + vrank) * sizeof(size_t));
add = (size_t *) emalloc((1 + vrank) * sizeof(size_t));
nels = 1;
if(vrank == 0) { /*scalar*/
cor[0] = 0;
edg[0] = 1;
} else {
for (id = 0; id < vrank; id++) {
cor[id] = 0;
edg[id] = 1;
nels *= vdims[id]; /* total number of values for variable */
}
}
printf("\n");
indent_out();
printf(" ");
print_name(vp->name);
if (vrank <= 1) {
printf(" = ");
set_indent ((int)strlen(vp->name) + 4 + indent_get());
} else {
printf(" =\n ");
set_indent (2 + indent_get());
}
if (vrank == 0) {
ncols = 1;
} else {
ncols = vdims[vrank-1]; /* size of "row" along last dimension */
edg[vrank-1] = ncols;
for (id = 0; id < vrank; id++)
add[id] = 0;
if (vrank > 1)
add[vrank-2] = 1;
}
nrows = nels/ncols; /* number of "rows" */
vals = emalloc(ncols * vp->tinfo->size);
/* Test if we should treat array of chars as a string */
if(vp->type == NC_CHAR && (vp->fmt == 0 || STREQ(vp->fmt,"%s") || STREQ(vp->fmt,""))) {
for (ir = 0; ir < nrows; ir++) {
if (vrank > 0) {
if (formatting_specs.brief_data_cmnts != false && vrank > 1 && ncols > 0) {
annotate_brief(vp, cor, vdims);
}
}
NC_CHECK(nc_get_vara(ncid, varid, cor, edg, vals));
pr_tvals(vp, ncols, (ir == nrows-1), (char *) vals, cor);
if (ir < nrows-1)
if (!upcorner(vdims, vp->ndims, cor, add))
error("vardata: odometer overflowed!");
set_indent(2);
}
} else {
int level = 0;
int rank = vp->ndims;
int marks_pending = 0;
NC_CHECK(print_rows(level, ncid, varid, vp, ncols, rank, vdims, cor, edg,
vals, marks_pending));
}
free(vals);
free(cor);
free(edg);
free(add);
return 0;
}
/* Output the data for a single variable, in NcML syntax.
* TODO: currently not called, need option for NcML with values ... */
int
vardatax(
const ncvar_t *vp, /* variable */
size_t vdims[], /* variable dimension sizes */
int ncid, /* netcdf id */
int varid, /* variable id */
const fspec_t *fsp /* formatting specs */
)
{
size_t cor[NC_MAX_DIMS]; /* corner coordinates */
size_t edg[NC_MAX_DIMS]; /* edges of hypercube */
size_t add[NC_MAX_DIMS]; /* "odometer" increment to next "row" */
size_t gulp;
void *vals;
int id;
int ir;
size_t nels;
size_t ncols;
size_t nrows;
int vrank = vp->ndims;
nels = 1;
for (id = 0; id < vrank; id++) {
cor[id] = 0;
edg[id] = 1;
nels *= vdims[id]; /* total number of values for variable */
}
printf(" <values>\n ");
set_indent (7);
if (vrank < 1) {
ncols = 1;
} else {
ncols = vdims[vrank-1]; /* size of "row" along last dimension */
edg[vrank-1] = vdims[vrank-1];
for (id = 0; id < vrank; id++)
add[id] = 0;
if (vrank > 1)
add[vrank-2] = 1;
}
nrows = nels/ncols; /* number of "rows" */
gulp = ncols < VALBUFSIZ ? VALBUFSIZ : ncols;
vals = emalloc(gulp * vp->tinfo->size);
for (ir = 0; ir < nrows; ir++) {
/*
* rather than just printing a whole row at once (which might
* exceed the capacity of some platforms), we break each row
* into smaller chunks, if necessary.
*/
size_t corsav;
int left = (int)ncols;
boolean lastrow;
if (vrank > 0) {
corsav = cor[vrank-1];
}
lastrow = (boolean)(ir == nrows-1);
while (left > 0) {
size_t toget = left < gulp ? left : gulp;
if (vrank > 0)
edg[vrank-1] = toget;
NC_CHECK(nc_get_vara(ncid, varid, cor, edg, vals) );
/* Test if we should treat array of chars as a string */
if(vp->type == NC_CHAR &&
(vp->fmt == 0 || STREQ(vp->fmt,"%s") || STREQ(vp->fmt,""))) {
pr_tvalsx(vp, toget, left > toget, lastrow, (char *) vals);
} else {
pr_any_valsx(vp, toget, left > toget, lastrow, vals);
}
left -= toget;
if (vrank > 0)
cor[vrank-1] += toget;
}
if (vrank > 0)
cor[vrank-1] = corsav;
if (ir < nrows-1)
if (!upcorner(vdims,vp->ndims,cor,add))
error("vardata: odometer overflowed!");
set_indent(2);
}
printf(" </values>\n");
free(vals);
return 0;
}
/* Output the data for a single variable, in CDL syntax. */
int
vardata(
const ncvar_t *vp, /* variable */
size_t vdims[], /* variable dimension sizes */
int ncid, /* netcdf id */
int varid, /* variable id */
const fspec_t *fsp /* formatting specs */
)
{
size_t cor[NC_MAX_DIMS]; /* corner coordinates */
size_t edg[NC_MAX_DIMS]; /* edges of hypercube */
size_t add[NC_MAX_DIMS]; /* "odometer" increment to next "row" */
size_t gulp;
void *vals;
int id;
int ir;
size_t nels;
size_t ncols;
size_t nrows;
int vrank = vp->ndims;
nels = 1;
for (id = 0; id < vrank; id++) {
cor[id] = 0;
edg[id] = 1;
nels *= vdims[id]; /* total number of values for variable */
}
printf("\n");
indent_out();
/* printf(" %s = ", vp->name); */
/* or */
/* printf(" %s =\n ", vp->name); */
printf(" ");
print_name(vp->name);
if (vrank <= 1) {
printf(" = ");
set_indent ((int)strlen(vp->name) + 4 + indent_get());
} else {
printf(" =\n ");
set_indent (2 + indent_get());
}
if (vrank < 1) {
ncols = 1;
} else {
ncols = vdims[vrank-1]; /* size of "row" along last dimension */
edg[vrank-1] = vdims[vrank-1];
for (id = 0; id < vrank; id++)
add[id] = 0;
if (vrank > 1)
add[vrank-2] = 1;
}
nrows = nels/ncols; /* number of "rows" */
gulp = ncols < VALBUFSIZ ? ncols : VALBUFSIZ;
vals = emalloc(gulp * vp->tinfo->size);
for (ir = 0; ir < nrows; ir++) {
/*
* rather than just printing a whole row at once (which might
* exceed the capacity of some platforms), we break each row
* into smaller chunks, if necessary.
*/
size_t corsav = 0;
int left = (int)ncols;
boolean lastrow;
if (vrank > 0) {
corsav = cor[vrank-1];
if (fsp->brief_data_cmnts != false
&& vrank > 1
&& left > 0) { /* print brief comment with indices range */
/* printf("// %s(",vp->name); */
printf("// ");
printf(vp->name);
printf("(");
switch (fsp->data_lang) {
case LANG_C:
/* print brief comment with C variable indices */
for (id = 0; id < vrank-1; id++)
printf("%lu,", (unsigned long)cor[id]);
if (vdims[vrank-1] == 1)
printf("0");
else
printf(" 0-%lu", (unsigned long)vdims[vrank-1]-1);
break;
case LANG_F:
/* print brief comment with Fortran variable indices */
if (vdims[vrank-1] == 1)
printf("1");
else
printf("1-%lu ", (unsigned long)vdims[vrank-1]);
for (id = vrank-2; id >=0 ; id--) {
printf(",%lu", (unsigned long)(1 + cor[id]));
}
break;
}
printf(")\n");
indent_out();
printf(" ");
set_indent(4 + indent_get());
}
}
lastrow = (boolean)(ir == nrows-1);
while (left > 0) {
size_t toget = left < gulp ? left : gulp;
if (vrank > 0)
edg[vrank-1] = toget;
NC_CHECK(nc_get_vara(ncid, varid, cor, edg, vals) );
/* Test if we should treat array of chars as a string */
if(vp->type == NC_CHAR &&
(vp->fmt == 0 || STREQ(vp->fmt,"%s") || STREQ(vp->fmt,""))) {
pr_tvals(vp, toget, left > toget, lastrow, (char *) vals,
fsp, cor);
} else {
pr_any_vals(vp, toget, left > toget, lastrow, vals, fsp, cor);
}
left -= toget;
if (vrank > 0)
cor[vrank-1] += toget;
}
if (vrank > 0)
cor[vrank-1] = corsav;
if (ir < nrows-1)
if (!upcorner(vdims,vp->ndims,cor,add))
error("vardata: odometer overflowed!");
set_indent(2);
}
free(vals);
return 0;
}
/* Output the data for a single variable, in CDL syntax. */
int
vardata(
const ncvar_t *vp, /* variable */
size_t vdims[], /* variable dimension sizes */
int ncid, /* netcdf id */
int varid /* variable id */
)
{
size_t *cor; /* corner coordinates */
size_t *edg; /* edges of hypercube */
size_t *add; /* "odometer" increment to next "row" */
void *vals;
int id;
size_t nels;
size_t ncols;
size_t nrows;
int vrank = vp->ndims;
int level = 0;
int marks_pending = 0;
cor = (size_t *) emalloc((1 + vrank) * sizeof(size_t));
edg = (size_t *) emalloc((1 + vrank) * sizeof(size_t));
add = (size_t *) emalloc((1 + vrank) * sizeof(size_t));
nels = 1;
if(vrank == 0) { /*scalar*/
cor[0] = 0;
edg[0] = 1;
} else {
for (id = 0; id < vrank; id++) {
cor[id] = 0;
edg[id] = 1;
nels *= vdims[id]; /* total number of values for variable */
}
}
printf("\n");
indent_out();
printf(" ");
print_name(vp->name);
if (vrank <= 1) {
printf(" = ");
set_indent ((int)strlen(vp->name) + 4 + indent_get());
} else {
printf(" =\n ");
set_indent (2 + indent_get());
}
if (vrank == 0) {
ncols = 1;
} else {
ncols = vdims[vrank-1]; /* size of "row" along last dimension */
edg[vrank-1] = ncols;
for (id = 0; id < vrank; id++)
add[id] = 0;
if (vrank > 1)
add[vrank-2] = 1;
}
nrows = nels/ncols; /* number of "rows" */
vals = emalloc(ncols * vp->tinfo->size);
NC_CHECK(print_rows(level, ncid, varid, vp, vdims, cor, edg, vals, marks_pending));
free(vals);
free(cor);
free(edg);
free(add);
return 0;
}
/* Output the data for a single variable, in CDL syntax. */
int
vardata(
const struct ncvar *vp, /* variable */
long vdims[], /* variable dimension sizes */
int ncid, /* netcdf id */
int varid, /* variable id */
const struct fspec* fsp /* formatting specs */
)
{
long cor[NC_MAX_DIMS]; /* corner coordinates */
long edg[NC_MAX_DIMS]; /* edges of hypercube */
long add[NC_MAX_DIMS]; /* "odometer" increment to next "row" */
#define VALBUFSIZ 1000
double vals[VALBUFSIZ] ; /* aligned buffer */
int gulp = VALBUFSIZ;
int id;
int ir;
long nels;
long ncols;
long nrows;
int vrank = vp->ndims;
static int initeps = 0;
/* printf format used to print each value */
char *fmt = get_fmt(ncid, varid, vp->type);
if (!initeps) { /* make sure epsilons get initialized */
init_epsilons();
initeps = 1;
}
nels = 1;
for (id = 0; id < vrank; id++) {
cor[id] = 0;
edg[id] = 1;
nels *= vdims[id]; /* total number of values for variable */
}
if (vrank <= 1) {
Printf("\n %s = ", vp->name);
set_indent ((int)strlen(vp->name) + 4);
} else {
Printf("\n %s =\n ", vp->name);
set_indent (2);
}
if (vrank < 1) {
ncols = 1;
} else {
ncols = vdims[vrank-1]; /* size of "row" along last dimension */
edg[vrank-1] = vdims[vrank-1];
for (id = 0; id < vrank; id++)
add[id] = 0;
if (vrank > 1)
add[vrank-2] = 1;
}
nrows = nels/ncols; /* number of "rows" */
for (ir = 0; ir < nrows; ir++) {
/*
* rather than just printing a whole row at once (which might exceed
* the capacity of MSDOS platforms, for example), we break each row
* into smaller chunks, if necessary.
*/
long corsav;
int left = (int)ncols;
boolean lastrow;
if (vrank > 0) {
corsav = cor[vrank-1];
if (fsp->brief_data_cmnts != false
&& vrank > 1
&& left > 0) { /* print brief comment with indices range */
Printf("// %s(",vp->name);
switch (fsp->data_lang) {
case LANG_C:
/* print brief comment with C variable indices */
for (id = 0; id < vrank-1; id++)
Printf("%lu,", (unsigned long)cor[id]);
if (vdims[vrank-1] == 1)
Printf("0");
else
Printf(" 0-%lu", (unsigned long)vdims[vrank-1]-1);
break;
case LANG_F:
/* print brief comment with Fortran variable indices */
if (vdims[vrank-1] == 1)
Printf("1");
else
Printf("1-%lu ", (unsigned long)vdims[vrank-1]);
for (id = vrank-2; id >=0 ; id--) {
Printf(",%lu", (unsigned long)(1 + cor[id]));
}
break;
}
Printf(")\n ");
set_indent(4);
}
}
lastrow = (boolean)(ir == nrows-1);
while (left > 0) {
long toget = left < gulp ? left : gulp;
if (vrank > 0)
edg[vrank-1] = toget;
switch(vp->type) {
case NC_CHAR:
NC_CHECK(
ncvarget(ncid, varid, cor, edg, (char *)vals) );
pr_tvals(vp, toget, fmt, left > toget, lastrow,
(char *) vals, fsp, cor);
break;
case NC_BYTE:
NC_CHECK(
ncvarget(ncid, varid, cor, edg, (signed char *)vals) );
pr_bvals(vp, toget, fmt, left > toget, lastrow,
(signed char *) vals, fsp, cor);
break;
case NC_SHORT:
NC_CHECK(
ncvarget(ncid, varid, cor, edg, (short *)vals) );
pr_svals(vp, toget, fmt, left > toget, lastrow,
(short *) vals, fsp, cor);
break;
case NC_INT:
NC_CHECK(
ncvarget(ncid, varid, cor, edg, (int *)vals) );
pr_ivals(vp, toget, fmt, left > toget, lastrow,
(int *) vals, fsp, cor);
break;
case NC_FLOAT:
NC_CHECK(
ncvarget(ncid, varid, cor, edg, (float *)vals) );
pr_fvals(vp, toget, fmt, left > toget, lastrow,
(float *) vals, fsp, cor);
break;
case NC_DOUBLE:
NC_CHECK(
ncvarget(ncid, varid, cor, edg, (double *)vals) );
pr_dvals(vp, toget, fmt, left > toget, lastrow,
(double *) vals, fsp, cor);
break;
default:
error("vardata: bad type");
}
left -= toget;
if (vrank > 0)
cor[vrank-1] += toget;
}
if (vrank > 0)
cor[vrank-1] = corsav;
if (ir < nrows-1)
if (!upcorner(vdims,vp->ndims,cor,add))
error("vardata: odometer overflowed!");
set_indent(2);
}
return 0;
}
void make_tables(void)
{
int i;
int did_eof_rule = false;
skelout();
/* First, take care of YY_DO_BEFORE_ACTION depending on yymore
* being used.
*/
set_indent( 1 );
if ( yymore_used && ! yytext_is_array )
{
indent_puts( "yytext_ptr -= yy_more_len; \\" );
indent_puts( "yyleng = (int) (yy_cp - yytext_ptr); \\" );
}
else
indent_puts( "yyleng = (int) (yy_cp - yy_bp); \\" );
/* Now also deal with copying yytext_ptr to yytext if needed. */
skelout();
if ( yytext_is_array )
{
if ( yymore_used )
indent_puts(
"if ( yyleng + yy_more_offset >= YYLMAX ) \\" );
else
indent_puts( "if ( yyleng >= YYLMAX ) \\" );
indent_up();
indent_puts(
"YY_FATAL_ERROR( \"token too large, exceeds YYLMAX\" ); \\" );
indent_down();
if ( yymore_used )
{
indent_puts(
"yy_flex_strncpy( &yytext[yy_more_offset], yytext_ptr, yyleng + 1 ); \\" );
indent_puts( "yyleng += yy_more_offset; \\" );
indent_puts(
"yy_prev_more_offset = yy_more_offset; \\" );
indent_puts( "yy_more_offset = 0; \\" );
}
else
{
indent_puts(
"yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \\" );
}
}
set_indent( 0 );
skelout();
out_dec( "#define YY_NUM_RULES %d\n", num_rules );
out_dec( "#define YY_END_OF_BUFFER %d\n", num_rules + 1 );
if ( fullspd )
{
/* Need to define the transet type as a size large
* enough to hold the biggest offset.
*/
int total_table_size = tblend + numecs + 1;
char *trans_offset_type =
(total_table_size >= MAX_SHORT || long_align) ?
"long" : "short";
set_indent( 0 );
indent_puts( "struct yy_trans_info" );
indent_up();
indent_puts( "{" ); /* } for vi */
if ( long_align )
indent_puts( "long yy_verify;" );
else
indent_puts( "short yy_verify;" );
/* In cases where its sister yy_verify *is* a "yes, there is
* a transition", yy_nxt is the offset (in records) to the
* next state. In most cases where there is no transition,
* the value of yy_nxt is irrelevant. If yy_nxt is the -1th
* record of a state, though, then yy_nxt is the action number
* for that state.
*/
indent_put2s( "%s yy_nxt;", trans_offset_type );
indent_puts( "};" );
indent_down();
}
if ( fullspd )
genctbl();
else if ( fulltbl )
genftbl();
else
gentabs();
/* Definitions for backing up. We don't need them if REJECT
* is being used because then we use an alternative backin-up
* technique instead.
*/
if ( num_backing_up > 0 && ! reject )
{
if ( ! C_plus_plus )
{
indent_puts(
"static yy_state_type yy_last_accepting_state;" );
indent_puts(
"static char *yy_last_accepting_cpos;\n" );
}
}
if ( nultrans )
{
out_str_dec( C_state_decl, "yy_NUL_trans", lastdfa + 1 );
for ( i = 1; i <= lastdfa; ++i )
{
if ( fullspd )
out_dec( " &yy_transition[%d],\n", base[i] );
else
mkdata( nultrans[i] );
}
dataend();
}
if ( ddebug )
{ /* Spit out table mapping rules to line numbers. */
if ( ! C_plus_plus )
{
indent_puts( "extern int yy_flex_debug;" );
indent_puts( "int yy_flex_debug = 1;\n" );
}
out_str_dec( long_align ? C_long_decl : C_short_decl,
"yy_rule_linenum", num_rules );
for ( i = 1; i < num_rules; ++i )
mkdata( rule_linenum[i] );
dataend();
}
if ( reject )
{
/* Declare state buffer variables. */
if ( ! C_plus_plus )
{
outn(
"static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;" );
outn( "static char *yy_full_match;" );
outn( "static int yy_lp;" );
}
if ( variable_trailing_context_rules )
{
if ( ! C_plus_plus )
{
outn(
"static int yy_looking_for_trail_begin = 0;" );
outn( "static int yy_full_lp;" );
outn( "static int *yy_full_state;" );
}
out_hex( "#define YY_TRAILING_MASK 0x%x\n",
(unsigned int) YY_TRAILING_MASK );
out_hex( "#define YY_TRAILING_HEAD_MASK 0x%x\n",
(unsigned int) YY_TRAILING_HEAD_MASK );
}
outn( "#define REJECT \\" );
outn( "{ \\" ); /* } for vi */
outn(
"*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \\" );
outn(
"yy_cp = yy_full_match; /* restore poss. backed-over text */ \\" );
if ( variable_trailing_context_rules )
{
outn(
"yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \\" );
outn(
"yy_state_ptr = yy_full_state; /* restore orig. state */ \\" );
outn(
"yy_current_state = *yy_state_ptr; /* restore curr. state */ \\" );
}
outn( "++yy_lp; \\" );
outn( "goto find_rule; \\" );
/* { for vi */
outn( "}" );
}
else
{
outn(
"/* The intent behind this definition is that it'll catch" );
outn( " * any uses of REJECT which flex missed." );
outn( " */" );
outn( "#define REJECT reject_used_but_not_detected" );
}
if ( yymore_used )
{
if ( ! C_plus_plus )
{
if ( yytext_is_array )
{
indent_puts( "static int yy_more_offset = 0;" );
indent_puts(
"static int yy_prev_more_offset = 0;" );
}
else
{
indent_puts( "static int yy_more_flag = 0;" );
indent_puts( "static int yy_more_len = 0;" );
}
}
if ( yytext_is_array )
{
indent_puts(
"#define yymore() (yy_more_offset = yy_flex_strlen( yytext ))" );
indent_puts( "#define YY_NEED_STRLEN" );
indent_puts( "#define YY_MORE_ADJ 0" );
indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET \\" );
indent_up();
indent_puts( "{ \\" );
indent_puts( "yy_more_offset = yy_prev_more_offset; \\" );
indent_puts( "yyleng -= yy_more_offset; \\" );
indent_puts( "}" );
indent_down();
}
else
{
indent_puts( "#define yymore() (yy_more_flag = 1)" );
indent_puts( "#define YY_MORE_ADJ yy_more_len" );
indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" );
}
}
else
{
indent_puts( "#define yymore() yymore_used_but_not_detected" );
indent_puts( "#define YY_MORE_ADJ 0" );
indent_puts( "#define YY_RESTORE_YY_MORE_OFFSET" );
}
if ( ! C_plus_plus )
{
if ( yytext_is_array )
{
outn( "#ifndef YYLMAX" );
outn( "#define YYLMAX 8192" );
outn( "#endif\n" );
outn( "char yytext[YYLMAX];" );
outn( "char *yytext_ptr;" );
}
else
outn( "char *yytext;" );
}
out( &action_array[defs1_offset] );
line_directive_out( stdout, 0 );
skelout();
if ( ! C_plus_plus )
{
if ( use_read )
{
outn(
"\tif ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \\" );
outn(
"\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );" );
}
else
{
outn(
"\tif ( yy_current_buffer->yy_is_interactive ) \\" );
outn( "\t\t{ \\" );
outn( "\t\tint c = '*', n; \\" );
outn( "\t\tfor ( n = 0; n < max_size && \\" );
outn( "\t\t\t (c = getc( yyin )) != EOF && c != '\\n'; ++n ) \\" );
outn( "\t\t\tbuf[n] = (char) c; \\" );
outn( "\t\tif ( c == '\\n' ) \\" );
outn( "\t\t\tbuf[n++] = (char) c; \\" );
outn( "\t\tif ( c == EOF && ferror( yyin ) ) \\" );
outn(
"\t\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" ); \\" );
outn( "\t\tresult = n; \\" );
outn( "\t\t} \\" );
outn(
"\telse if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \\" );
outn( "\t\t && ferror( yyin ) ) \\" );
outn(
"\t\tYY_FATAL_ERROR( \"input in flex scanner failed\" );" );
}
}
skelout();
indent_puts( "#define YY_RULE_SETUP \\" );
indent_up();
if ( bol_needed )
{
indent_puts( "if ( yyleng > 0 ) \\" );
indent_up();
indent_puts( "yy_current_buffer->yy_at_bol = \\" );
indent_puts( "\t\t(yytext[yyleng - 1] == '\\n'); \\" );
indent_down();
}
indent_puts( "YY_USER_ACTION" );
indent_down();
skelout();
/* Copy prolog to output file. */
out( &action_array[prolog_offset] );
line_directive_out( stdout, 0 );
skelout();
set_indent( 2 );
if ( yymore_used && ! yytext_is_array )
{
indent_puts( "yy_more_len = 0;" );
indent_puts( "if ( yy_more_flag )" );
indent_up();
indent_puts( "{" );
indent_puts( "yy_more_len = yy_c_buf_p - yytext_ptr;" );
indent_puts( "yy_more_flag = 0;" );
indent_puts( "}" );
indent_down();
}
skelout();
gen_start_state();
/* Note, don't use any indentation. */
outn( "yy_match:" );
gen_next_match();
skelout();
set_indent( 2 );
gen_find_action();
skelout();
if ( do_yylineno )
{
indent_puts( "if ( yy_act != YY_END_OF_BUFFER )" );
indent_up();
indent_puts( "{" );
indent_puts( "int yyl;" );
indent_puts( "for ( yyl = 0; yyl < yyleng; ++yyl )" );
indent_up();
indent_puts( "if ( yytext[yyl] == '\\n' )" );
indent_up();
indent_puts( "++yylineno;" );
indent_down();
indent_down();
indent_puts( "}" );
indent_down();
}
skelout();
if ( ddebug )
{
indent_puts( "if ( yy_flex_debug )" );
indent_up();
indent_puts( "{" );
indent_puts( "if ( yy_act == 0 )" );
indent_up();
indent_puts( C_plus_plus ?
"cerr << \"--scanner backing up\\n\";" :
"fprintf( stderr, \"--scanner backing up\\n\" );" );
indent_down();
do_indent();
out_dec( "else if ( yy_act < %d )\n", num_rules );
indent_up();
if ( C_plus_plus )
{
indent_puts(
"cerr << \"--accepting rule at line \" << yy_rule_linenum[yy_act] <<" );
indent_puts(
" \"(\\\"\" << yytext << \"\\\")\\n\";" );
}
else
{
indent_puts(
"fprintf( stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\"," );
indent_puts(
" yy_rule_linenum[yy_act], yytext );" );
}
indent_down();
do_indent();
out_dec( "else if ( yy_act == %d )\n", num_rules );
indent_up();
if ( C_plus_plus )
{
indent_puts(
"cerr << \"--accepting default rule (\\\"\" << yytext << \"\\\")\\n\";" );
}
else
{
indent_puts(
"fprintf( stderr, \"--accepting default rule (\\\"%s\\\")\\n\"," );
indent_puts( " yytext );" );
}
indent_down();
do_indent();
out_dec( "else if ( yy_act == %d )\n", num_rules + 1 );
indent_up();
indent_puts( C_plus_plus ?
"cerr << \"--(end of buffer or a NUL)\\n\";" :
"fprintf( stderr, \"--(end of buffer or a NUL)\\n\" );" );
indent_down();
do_indent();
outn( "else" );
indent_up();
if ( C_plus_plus )
{
indent_puts(
"cerr << \"--EOF (start condition \" << YY_START << \")\\n\";" );
}
else
{
indent_puts(
"fprintf( stderr, \"--EOF (start condition %d)\\n\", YY_START );" );
}
indent_down();
indent_puts( "}" );
indent_down();
}
/* Copy actions to output file. */
skelout();
indent_up();
gen_bu_action();
out( &action_array[action_offset] );
line_directive_out( stdout, 0 );
/* generate cases for any missing EOF rules */
for ( i = 1; i <= lastsc; ++i )
if ( ! sceof[i] )
{
do_indent();
out_str( "case YY_STATE_EOF(%s):\n", scname[i] );
did_eof_rule = true;
}
if ( did_eof_rule )
{
indent_up();
indent_puts( "yyterminate();" );
indent_down();
}
/* Generate code for handling NUL's, if needed. */
/* First, deal with backing up and setting up yy_cp if the scanner
* finds that it should JAM on the NUL.
*/
skelout();
set_indent( 4 );
if ( fullspd || fulltbl )
indent_puts( "yy_cp = yy_c_buf_p;" );
else
{ /* compressed table */
if ( ! reject && ! interactive )
{
/* Do the guaranteed-needed backing up to figure
* out the match.
*/
indent_puts( "yy_cp = yy_last_accepting_cpos;" );
indent_puts(
"yy_current_state = yy_last_accepting_state;" );
}
else
/* Still need to initialize yy_cp, though
* yy_current_state was set up by
* yy_get_previous_state().
*/
indent_puts( "yy_cp = yy_c_buf_p;" );
}
/* Generate code for yy_get_previous_state(). */
set_indent( 1 );
skelout();
gen_start_state();
set_indent( 2 );
skelout();
gen_next_state( true );
set_indent( 1 );
skelout();
gen_NUL_trans();
skelout();
if ( do_yylineno )
{ /* update yylineno inside of unput() */
indent_puts( "if ( c == '\\n' )" );
indent_up();
indent_puts( "--yylineno;" );
indent_down();
}
skelout();
/* Update BOL and yylineno inside of input(). */
if ( bol_needed )
{
indent_puts( "yy_current_buffer->yy_at_bol = (c == '\\n');" );
if ( do_yylineno )
{
indent_puts( "if ( yy_current_buffer->yy_at_bol )" );
indent_up();
indent_puts( "++yylineno;" );
indent_down();
}
}
else if ( do_yylineno )
{
indent_puts( "if ( c == '\\n' )" );
indent_up();
indent_puts( "++yylineno;" );
indent_down();
}
skelout();
/* Copy remainder of input to output. */
line_directive_out( stdout, 1 );
if ( sectnum == 3 )
(void) flexscan(); /* copy remainder of input to output */
}
