/* Parse a plot style. Used by 'set style {data|function}' and by
* (s)plot. */
enum PLOT_STYLE
get_style()
{
/* defined in plot.h */
enum PLOT_STYLE ps;
c_token++;
ps = lookup_table(&plotstyle_tbl[0], c_token);
c_token++;
if (ps == -1) {
int_error(c_token, "\
expecting 'lines', 'points', 'linespoints', 'dots', 'impulses',\n\
\t'yerrorbars', 'xerrorbars', 'xyerrorbars', 'steps', 'fsteps',\n\
\t'histeps', 'filledcurves', 'boxes', 'boxerrorbars', 'boxxyerrorbars',\n\
\t'vectors', 'financebars', 'candlesticks', 'errorlines', 'xerrorlines',\n\
\t'yerrorlines', 'xyerrorlines', 'pm3d', 'labels', 'histograms'"
",\n\t 'image', 'rgbimage'"
);
ps = LINES;
}
return ps;
}
void *_table_keys(void)
{
int i;
lookup_table(i, Ttop());
Tset(list_to_consnil((ATerm)ATtableKeys(ST_tables[i])));
return NULL;
}
static void
build_table (struct mi_cmd *commands)
{
int nr_rehash = 0;
int nr_entries = 0;
struct mi_cmd *command;
mi_table = XCNEWVEC (struct mi_cmd *, MI_TABLE_SIZE);
for (command = commands; command->name != 0; command++)
{
struct mi_cmd **entry = lookup_table (command->name);
if (*entry)
internal_error (__FILE__, __LINE__,
_("command `%s' appears to be duplicated"),
command->name);
*entry = command;
/* FIXME lose these prints */
if (0)
{
fprintf_unfiltered (gdb_stdlog, "%-30s %2d\n",
command->name, stats.rehash - nr_rehash);
}
nr_entries++;
nr_rehash = stats.rehash;
}
if (0)
{
fprintf_filtered (gdb_stdlog, "Average %3.1f\n",
(double) nr_rehash / (double) nr_entries);
}
}
static void
build_table (struct mi_cmd *commands)
{
int nr_rehash = 0;
int nr_entries = 0;
struct mi_cmd *command;
int sizeof_table = sizeof (struct mi_cmd **) * MI_TABLE_SIZE;
mi_table = xmalloc (sizeof_table);
memset (mi_table, 0, sizeof_table);
for (command = commands; command->name != 0; command++)
{
struct mi_cmd **entry = lookup_table (command->name);
if (*entry)
internal_error (__FILE__, __LINE__,
_("command `%s' appears to be duplicated"),
command->name);
*entry = command;
if (0)
{
fprintf_unfiltered (gdb_stdlog, "%-30s %2d\n",
command->name, stats.rehash - nr_rehash);
}
nr_entries++;
nr_rehash = stats.rehash;
}
if (0)
{
fprintf_filtered (gdb_stdlog, "Average %3.1f\n",
(double) nr_rehash / (double) nr_entries);
}
}
ATbool _table_keys(void)
{
int i;
lookup_table(i, Ttop);
Tset(list_to_consnil((ATerm)ATtableKeys(ST_tables[i])));
return ATtrue;
}
void *_destroy_table(void)
{
int i;
lookup_table(i, Ttop());
ATtableDestroy(ST_tables[i]);
ATtableRemove(ST_table_table, Ttop());
return NULL;
}
ATbool _destroy_table(void)
{
int i;
lookup_table(i, Ttop);
ATtableDestroy(ST_tables[i]);
ATtableRemove(ST_table_table, Ttop);
return ATtrue;
}
/* Find the value of a variable. */
double find_var(char* s){
int position;
if(!isalpha(*s)){
serror(4); /* not a variable */
return 0;
}
position=lookup_table();
// return variables[toupper(*bas_token)-'A'];
return variables[position];
}
void checkstmt( Statement *stmt, SymbolTable * table, HashTable *Htable)//changed
{
if(stmt->type == Assignment){
AssignmentStatement assign = stmt->stmt.assign;
printf("assignment : %s \n",assign.id);//changed
checkexpression(assign.expr, table,Htable);
stmt->stmt.assign.type = lookup_table(table, assign.id,Htable);
if (assign.expr->type == Float && stmt->stmt.assign.type == Int) {
printf("error : can't convert float to integer\n");
} else {
convertType(assign.expr, stmt->stmt.assign.type);
}
}
else if (stmt->type == Print){
printf("print : %s \n",stmt->stmt.variable);//changed
lookup_table(table, stmt->stmt.variable, Htable);
}
else printf("error : statement error\n");//error
}
static const char *lookup_table_fallback(int num, struct str_table *table)
{
static char buf[32];
const char *ret = lookup_table(num, table);
if (ret)
return ret;
snprintf(buf, sizeof(buf), "%d", num);
buf[sizeof(buf)-1] = 0;
return buf;
}
/* Parse options for style filledcurves and fill fco accordingly.
* If no option given, then set fco->opt_given to 0.
*/
void
get_filledcurves_style_options(filledcurves_opts *fco)
{
int p;
p = lookup_table(&filledcurves_opts_tbl[0], c_token);
if (p == FILLEDCURVES_ABOVE) {
fco->oneside = 1;
p = lookup_table(&filledcurves_opts_tbl[0], ++c_token);
} else if (p == FILLEDCURVES_BELOW) {
fco->oneside = -1;
p = lookup_table(&filledcurves_opts_tbl[0], ++c_token);
} else
fco->oneside = 0;
if (p == -1) {
fco->opt_given = 0;
return; /* no option given */
} else
fco->opt_given = 1;
c_token++;
fco->closeto = p;
fco->at = 0;
if (!equals(c_token, "="))
return;
/* parameter required for filledcurves x1=... and friends */
if (p < FILLEDCURVES_ATXY)
fco->closeto += 4;
c_token++;
fco->at = real_expression();
if (p != FILLEDCURVES_ATXY)
return;
/* two values required for FILLEDCURVES_ATXY */
if (!equals(c_token, ","))
int_error(c_token, "syntax is xy=<x>,<y>");
c_token++;
fco->aty = real_expression();
return;
}
void *_table_remove(void)
{
ATerm table, key;
int i;
if(MatchPair(Ttop(), &table, &key))
{
lookup_table(i, table);
ATtableRemove(ST_tables[i], key);
return NULL;
}
return fail_address;
}
ATbool _table_remove(void)
{
ATerm table, key;
int i;
if(MatchPair(Ttop, &table, &key))
{
lookup_table(i, table);
ATtableRemove(ST_tables[i], key);
return ATtrue;
}
return ATfalse;
}
static void die_signal_handler(int signum, siginfo_t *siginfo, void *context)
{
void *stack_syms[32];
int frames;
const char *cp;
fprintf(stderr, "Signal (%d) %s ", signum,
lookup_table_fallback(signum, sig_table));
if (siginfo->si_code == SI_USER)
fprintf(stderr, "(sent from pid %u) ", siginfo->si_pid);
cp = lookup_table(siginfo->si_code, generic_code_table);
if (cp)
fprintf(stderr, "si_code=%s ", cp);
else if (signum == SIGILL)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigill_code_table));
else if (signum == SIGFPE)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigfpe_code_table));
else if (signum == SIGSEGV)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigsegv_code_table));
else if (signum == SIGBUS)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigbus_code_table));
else if (signum == SIGCHLD)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigcld_code_table));
else
fprintf(stderr, "si code=%d ", siginfo->si_code);
if ((siginfo->si_code != SI_USER) &&
(signum == SIGILL || signum == SIGFPE ||
signum == SIGSEGV || signum == SIGBUS))
fprintf(stderr, "fault addr=%p", siginfo->si_addr);
fprintf(stderr, "\n");
#ifdef HAVE_BACKTRACE
#ifdef __GLIBC__
frames = backtrace(stack_syms, 32);
backtrace_symbols_fd(stack_syms, frames, 2);
#else
#warning "HAVE_BACKTRACE should be disabled on android OS!"
/* Hopefully, you're on an Android device and debuggerd will do this. */
#endif /* __GLIBC__ */
#endif /* HAVE_BACKTRACE */
exit(FSCK_ERROR);
}
void *_table_put(void)
{
ATerm table, key, value;
int i;
/* ATfprintf(stderr, "<table-put>%t\n", Ttop()); */
if(MatchTriple(Ttop(), &table, &key, &value))
{
/* ATfprintf(stderr, "<table-put>(%t,%t,%t)\n", table, key, value); */
lookup_table(i, table);
ATtablePut(ST_tables[i], key, value);
return NULL;
}
return fail_address;
}
ATbool _table_put(void)
{
ATerm table, key, value;
int i;
/* ATfprintf(stderr, "<table-put>%t\n", Ttop); */
if(MatchTriple(Ttop, &table, &key, &value))
{
/* ATfprintf(stderr, "<table-put>(%t,%t,%t)\n", table, key, value); */
lookup_table(i, table);
ATtablePut(ST_tables[i], key, value);
return ATtrue;
}
return ATfalse;
}
static void die_signal_handler(int signum, siginfo_t *siginfo, void *context)
{
void *stack_syms[32];
int frames;
const char *cp;
fprintf(stderr, "Signal (%d) %s ", signum,
lookup_table_fallback(signum, sig_table));
if (siginfo->si_code == SI_USER)
fprintf(stderr, "(sent from pid %u) ", siginfo->si_pid);
cp = lookup_table(siginfo->si_code, generic_code_table);
if (cp)
fprintf(stderr, "si_code=%s ", cp);
else if (signum == SIGILL)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigill_code_table));
else if (signum == SIGFPE)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigfpe_code_table));
else if (signum == SIGSEGV)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigsegv_code_table));
else if (signum == SIGBUS)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigbus_code_table));
else if (signum == SIGCHLD)
fprintf(stderr, "si_code=%s ",
lookup_table_fallback(siginfo->si_code,
sigcld_code_table));
else
fprintf(stderr, "si code=%d ", siginfo->si_code);
if ((siginfo->si_code != SI_USER) &&
(signum == SIGILL || signum == SIGFPE ||
signum == SIGSEGV || signum == SIGBUS))
fprintf(stderr, "fault addr=%p", siginfo->si_addr);
fprintf(stderr, "\n");
#ifdef HAVE_BACKTRACE
frames = backtrace(stack_syms, 32);
backtrace_symbols_fd(stack_syms, frames, 2);
#endif
exit(FSCK_ERROR);
}
ATbool _table_get(void)
{
ATerm table, key, value;
int i;
if(MatchPair(Ttop, &table, &key))
{
/* ATfprintf(stderr, "<table-get>(%t,%t)\n", table, key); */
lookup_table(i, table);
value = ATtableGet(ST_tables[i], key);
if(value == NULL)
return ATfalse;
else
Tset(value);
return ATtrue;
}
return ATfalse;
}
/* Parse a plot style. Used by 'set style {data|function}' and by (s)plot. */
enum PLOT_STYLE
get_style()
{
/* defined in plot.h */
enum PLOT_STYLE ps;
c_token++;
ps = lookup_table(&plotstyle_tbl[0], c_token);
c_token++;
if (ps == -1)
int_error(c_token, "unrecognized plot type");
return ps;
}
void *_table_get(void)
{
ATerm table, key, value;
int i;
if(MatchPair(Ttop(), &table, &key))
{
/* ATfprintf(stderr, "<table-get>(%t,%t)\n", table, key); */
lookup_table(i, table);
value = ATtableGet(ST_tables[i], key);
if(value == NULL)
return fail_address;
else
Tset(value);
return NULL;
}
return fail_address;
}
static int parse_iflag(char *str, int *set_iflag, int *clr_iflag)
{
int iflag;
char *s;
for (s = strtok(str, ","); s != NULL; s = strtok(NULL, ",")) {
if (*s == '-')
s++;
if ((iflag = lookup_table(ld_iflags, s)) < 0)
iflag = strtos32_or_err(s, _("invalid iflag"));
if (s > str && *(s - 1) == '-')
*clr_iflag |= iflag;
else
*set_iflag |= iflag;
}
dbg("iflag (set/clear): %d/%d", *set_iflag, *clr_iflag);
return 0;
}
/* Execute a simple form of the BASIC INPUT command */
void input()
{
int var;
double i;
get_token(); /* see if prompt string is present */
if(bas_token_type==QUOTE) {
printf("%s\n",bas_token); /* if so, print it and check for comma */
get_token();
if(*bas_token!=',') serror(1);
get_token();
}
else printf("? "); /* otherwise, prompt with / */
var = lookup_table();//toupper(*bas_token)-'A'; /* get the input var */
//HA - UNUSED INPUT!!
int shit=scanf("%lf", &i); /* read input */
printf( " %d :/\n", shit );
variables[var] = i; /* store it */
}//-----input
// transform from R to G
static inline void transform_to_G(const int n, float* const R){
#pragma omp parallel for schedule(static)
for(int j=0;j<n;j++){
// RESP to W
int sign;
if(R[j] < 0)
sign = -1;
else
sign = 1;
R[j] = sign * lookup_table(LOOKUP_W_TO_R, R_table, W_table, fabsf(R[j]));
// W to G
if(R[j] < 0)
sign = -1;
else
sign = 1;
R[j] = log10f(fabsf(R[j]) + 1.0f) * sign;
}
}
// transform gradient (Gx,Gy) to R
static inline void transform_to_R(const int n, float* const G)
{
#pragma omp parallel for schedule(static)
for(int j=0;j<n;j++)
{
// G to W
const float absG = fabsf(G[j]);
int sign;
if(G[j] < 0)
sign = -1;
else
sign = 1;
G[j] = (powf(10,absG) - 1.0f) * sign;
// W to RESP
if(G[j] < 0)
sign = -1;
else
sign = 1;
G[j] = sign * lookup_table(LOOKUP_W_TO_R, W_table, R_table, fabsf(G[j]));
}
}
void checkexpression( Expression * expr, SymbolTable * table )
{
char name[256];
if(expr->leftOperand == NULL && expr->rightOperand == NULL){
switch(expr->v.type){
case Identifier:
strcpy(name, expr->v.val.id);
expr->v.val.regId = variableToRegister(table, name);
printf("identifier : %s(%c)\n", name, expr->v.val.regId);
expr->type = lookup_table(table, name);
break;
case IntConst:
printf("constant : int\n");
expr->type = Int;
break;
case FloatConst:
printf("constant : float\n");
expr->type = Float;
break;
//case PlusNode: case MinusNode: case MulNode: case DivNode:
default:
break;
}
}
else{
Expression *left = expr->leftOperand;
Expression *right = expr->rightOperand;
checkexpression(left, table);
checkexpression(right, table);
DataType type = generalize(left, right);
convertType(left, type);//left->type = type;//converto
convertType(right, type);//right->type = type;//converto
expr->type = type;
}
}
void checkexpression( Expression * expr, SymbolTable * table ,HashTable *Htable)//changed
{
IdName c;
if(expr->leftOperand == NULL && expr->rightOperand == NULL){
switch(expr->v.type){
case Identifier:
//c = expr->v.val.id;
strcpy(c, expr->v.val.id);
printf("identifier : %s\n",c);
expr->type = lookup_table(table, c,Htable);
break;
case IntConst:
printf("constant : int\n");
expr->type = Int;
break;
case FloatConst:
printf("constant : float\n");
expr->type = Float;
break;
//case PlusNode: case MinusNode: case MulNode: case DivNode:
default:
break;
}
}
else{
Expression *left = expr->leftOperand;
Expression *right = expr->rightOperand;
checkexpression(left, table,Htable);
checkexpression(right, table,Htable);
DataType type = generalize(left, right);
convertType(left, type);//left->type = type;//converto
convertType(right, type);//right->type = type;//converto
expr->type = type;
}
}
/* Execute a FOR loop. */
void exec_for()
{
struct for_stack i;
double value;
get_token(); /* read the control variable */
if(!isalpha(*bas_token)) {
serror(4);
return;
}
i.var=lookup_table();//toupper(*bas_token)-'A'; /* save its index */
get_token(); /* read the equals sign */
if(*bas_token!='=') {
serror(3);
return;
}
get_exp(&value); /* get initial value */
variables[i.var]=value;
get_token();
if(bas_tok!=TO) serror(9); /* read and discard the TO */
get_exp(&i.target); /* get target value */
/* if loop can execute at least once, push info on stack */
if(value>=variables[i.var]) {
i.loc = prog;
fpush( &i);// 20100422 - i
}
else /* otherwise, skip loop code altogether */
while(bas_tok!=NEXT) get_token();
}
/* Assign a variable a value. */
int assignment(){
int var; double value;
/* get the variable name */
get_token();
// printf("new assignement <%s>\n", bas_token );
if(!isalpha(*bas_token)) {
serror(4);
return 0;
}
/*
* howto make a table of variables?
*/
var = lookup_table();// toupper(*bas_token)-'A';
// printf("assign <%s> retvar=%d ", bas_token, var );
/* get the equals sign */
get_token();
// printf(" <%s> ", bas_token );
if(*bas_token!='=') {
// printf("assignment%s\n","");
serror(3);
return 0;
}
/* get the value to assign to var */
// printf(" going to get_exp with bas_token <%s> \n ", bas_token );
get_exp(&value);
// printf(" = <%lf> (outcome)\n ", value );
/* assign the value */
variables[var] = value;
// printf("#<%d> val=<%lf>\n", var, value );
return 0; // ?????
}//--------------------------assignment
/******** The 'unset' command ********/
void
unset_command()
{
int found_token;
int save_token;
int i;
c_token++;
set_iterator = check_for_iteration();
found_token = lookup_table(&set_tbl[0],c_token);
/* HBB 20000506: rationalize occurences of c_token++ ... */
if (found_token != S_INVALID)
c_token++;
save_token = c_token;
ITERATE:
switch(found_token) {
case S_ANGLES:
unset_angles();
break;
case S_ARROW:
unset_arrow();
break;
case S_AUTOSCALE:
unset_autoscale();
break;
case S_BARS:
unset_bars();
break;
case S_BORDER:
unset_border();
break;
case S_BOXWIDTH:
unset_boxwidth();
break;
case S_CLIP:
unset_clip();
break;
case S_CNTRPARAM:
unset_cntrparam();
break;
case S_CNTRLABEL:
unset_cntrlabel();
break;
case S_CLABEL: /* deprecated command */
clabel_onecolor = TRUE;
break;
case S_CONTOUR:
unset_contour();
break;
case S_DASHTYPE:
unset_dashtype();
break;
case S_DGRID3D:
unset_dgrid3d();
break;
case S_DUMMY:
unset_dummy();
break;
case S_ENCODING:
unset_encoding();
break;
case S_DECIMALSIGN:
unset_decimalsign();
break;
case S_FIT:
unset_fit();
break;
case S_FORMAT:
c_token--;
set_format();
break;
case S_GRID:
unset_grid();
break;
case S_HIDDEN3D:
unset_hidden3d();
break;
case S_HISTORY:
break; /* FIXME: reset to default values? */
case S_HISTORYSIZE: /* Deprecated */
unset_historysize();
break;
case S_ISOSAMPLES:
unset_isosamples();
break;
case S_KEY:
unset_key();
break;
case S_LABEL:
unset_label();
break;
case S_LINETYPE:
unset_linetype();
break;
case S_LINK:
c_token--;
link_command();
break;
case S_LOADPATH:
unset_loadpath();
break;
case S_LOCALE:
unset_locale();
break;
case S_LOGSCALE:
unset_logscale();
break;
case S_MACROS:
/* Aug 2013 - macros are always enabled */
break;
case S_MAPPING:
unset_mapping();
break;
case S_BMARGIN:
unset_margin(&bmargin);
break;
case S_LMARGIN:
unset_margin(&lmargin);
break;
case S_RMARGIN:
unset_margin(&rmargin);
break;
case S_TMARGIN:
unset_margin(&tmargin);
break;
case S_DATAFILE:
if (almost_equals(c_token,"fort$ran")) {
df_fortran_constants = FALSE;
c_token++;
break;
} else if (almost_equals(c_token,"miss$ing")) {
unset_missing();
c_token++;
break;
} else if (almost_equals(c_token,"sep$arators")) {
free(df_separators);
df_separators = NULL;
c_token++;
break;
} else if (almost_equals(c_token,"com$mentschars")) {
free(df_commentschars);
df_commentschars = gp_strdup(DEFAULT_COMMENTS_CHARS);
c_token++;
break;
} else if (almost_equals(c_token,"bin$ary")) {
df_unset_datafile_binary();
c_token++;
break;
} else if (almost_equals(c_token,"nofpe_trap")) {
df_nofpe_trap = FALSE;
c_token++;
break;
}
df_fortran_constants = FALSE;
unset_missing();
free(df_separators);
df_separators = NULL;
free(df_commentschars);
df_commentschars = gp_strdup(DEFAULT_COMMENTS_CHARS);
df_unset_datafile_binary();
break;
#ifdef USE_MOUSE
case S_MOUSE:
unset_mouse();
break;
#endif
case S_MULTIPLOT:
term_end_multiplot();
break;
case S_OFFSETS:
unset_offsets();
break;
case S_ORIGIN:
unset_origin();
break;
case SET_OUTPUT:
unset_output();
break;
case S_PARAMETRIC:
unset_parametric();
break;
case S_PM3D:
unset_pm3d();
break;
case S_PALETTE:
unset_palette();
break;
case S_COLORBOX:
unset_colorbox();
break;
case S_POINTINTERVALBOX:
unset_pointintervalbox();
break;
case S_POINTSIZE:
unset_pointsize();
break;
case S_POLAR:
unset_polar();
break;
case S_PRINT:
unset_print();
break;
case S_PSDIR:
unset_psdir();
break;
#ifdef EAM_OBJECTS
case S_OBJECT:
unset_object();
break;
#endif
case S_RTICS:
unset_tics(POLAR_AXIS);
break;
case S_PAXIS:
i = int_expression();
if (i <= 0 || i > MAX_PARALLEL_AXES)
int_error(c_token, "expecting parallel axis number");
if (almost_equals(c_token, "tic$s")) {
unset_tics(PARALLEL_AXES+i-1);
c_token++;
}
break;
case S_SAMPLES:
unset_samples();
break;
case S_SIZE:
unset_size();
break;
case S_STYLE:
unset_style();
break;
case S_SURFACE:
unset_surface();
break;
case S_TABLE:
unset_table();
break;
case S_TERMINAL:
unset_terminal();
break;
case S_TICS:
unset_tics(ALL_AXES);
break;
case S_TICSCALE:
int_warn(c_token, "Deprecated syntax - use 'set tics scale default'");
break;
case S_TICSLEVEL:
case S_XYPLANE:
unset_ticslevel();
break;
case S_TIMEFMT:
unset_timefmt();
break;
case S_TIMESTAMP:
unset_timestamp();
break;
case S_TITLE:
unset_axislabel_or_title(&title);
break;
case S_VIEW:
unset_view();
break;
case S_ZERO:
unset_zero();
break;
/* FIXME - are the tics correct? */
case S_MXTICS:
unset_minitics(FIRST_X_AXIS);
break;
case S_XTICS:
unset_tics(FIRST_X_AXIS);
break;
case S_XDTICS:
case S_XMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MYTICS:
unset_minitics(FIRST_Y_AXIS);
break;
case S_YTICS:
unset_tics(FIRST_Y_AXIS);
break;
case S_YDTICS:
case S_YMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MX2TICS:
unset_minitics(SECOND_X_AXIS);
break;
case S_X2TICS:
unset_tics(SECOND_X_AXIS);
break;
case S_X2DTICS:
case S_X2MTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MY2TICS:
unset_minitics(SECOND_Y_AXIS);
break;
case S_Y2TICS:
unset_tics(SECOND_Y_AXIS);
break;
case S_Y2DTICS:
case S_Y2MTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MZTICS:
unset_minitics(FIRST_Z_AXIS);
break;
case S_ZTICS:
unset_tics(FIRST_Z_AXIS);
break;
case S_ZDTICS:
case S_ZMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MCBTICS:
unset_minitics(COLOR_AXIS);
break;
case S_CBTICS:
unset_tics(COLOR_AXIS);
break;
case S_CBDTICS:
case S_CBMTICS:
unset_month_day_tics(FIRST_X_AXIS);
break;
case S_MRTICS:
unset_minitics(POLAR_AXIS);
break;
case S_XDATA:
unset_timedata(FIRST_X_AXIS);
break;
case S_YDATA:
unset_timedata(FIRST_Y_AXIS);
break;
case S_ZDATA:
unset_timedata(FIRST_Z_AXIS);
break;
case S_CBDATA:
unset_timedata(COLOR_AXIS);
break;
case S_X2DATA:
unset_timedata(SECOND_X_AXIS);
break;
case S_Y2DATA:
unset_timedata(SECOND_Y_AXIS);
break;
case S_XLABEL:
unset_axislabel(FIRST_X_AXIS);
break;
case S_YLABEL:
unset_axislabel(FIRST_Y_AXIS);
break;
case S_ZLABEL:
unset_axislabel(FIRST_Z_AXIS);
break;
case S_CBLABEL:
unset_axislabel(COLOR_AXIS);
break;
case S_X2LABEL:
unset_axislabel(SECOND_X_AXIS);
break;
case S_Y2LABEL:
unset_axislabel(SECOND_Y_AXIS);
break;
case S_XRANGE:
unset_range(FIRST_X_AXIS);
break;
case S_X2RANGE:
unset_range(SECOND_X_AXIS);
break;
case S_YRANGE:
unset_range(FIRST_Y_AXIS);
break;
case S_Y2RANGE:
unset_range(SECOND_Y_AXIS);
break;
case S_ZRANGE:
unset_range(FIRST_Z_AXIS);
break;
case S_CBRANGE:
unset_range(COLOR_AXIS);
break;
case S_RRANGE:
unset_range(POLAR_AXIS);
break;
case S_TRANGE:
unset_range(T_AXIS);
break;
case S_URANGE:
unset_range(U_AXIS);
break;
case S_VRANGE:
unset_range(V_AXIS);
break;
case S_RAXIS:
raxis = FALSE;
c_token++;
break;
case S_XZEROAXIS:
unset_zeroaxis(FIRST_X_AXIS);
break;
case S_YZEROAXIS:
unset_zeroaxis(FIRST_Y_AXIS);
break;
case S_ZZEROAXIS:
unset_zeroaxis(FIRST_Z_AXIS);
break;
case S_X2ZEROAXIS:
unset_zeroaxis(SECOND_X_AXIS);
break;
case S_Y2ZEROAXIS:
unset_zeroaxis(SECOND_Y_AXIS);
break;
case S_ZEROAXIS:
unset_all_zeroaxes();
break;
case S_INVALID:
default:
int_error(c_token, "Unrecognized option. See 'help unset'.");
break;
}
if (next_iteration(set_iterator)) {
c_token = save_token;
goto ITERATE;
}
update_gpval_variables(0);
set_iterator = cleanup_iteration(set_iterator);
}
/* Exported function used to obtain info from the table */
struct mi_cmd *
mi_lookup (const char *command)
{
return *lookup_table (command);
}
