void saffire_do_assign(char *var_name, char *val) { //printf("assign(%s => %s)\n", var_name, val); char type = VT_STRING; char *endptr; long num = strtol(val, &endptr, 10); if (endptr == val+strlen(val)) { type = VT_LONG; } t_var *var = var_find(var_name); if (var == NULL) { printf("Initial assign\n"); var = var_alloc(type, var_name, type == VT_STRING ? (void *)val : (void *)num); } else { if (var->type != type) { printf("We cannot switch types!"); exit(1); } if (type == VT_STRING) { var->val.str = strdup(val); } else if (type = VT_LONG) { var->val.num = num; } } //print_var(var); }
/* * Like var_assign_integer, only this routine copies the * supplied "string" into the var named "name". If the var * named "name" cannot be found then it is first allocated * before the copy. Space for the string in the var comes * from interprocess shared memory. If the var "name" * cannot be found or allocated, or the memory for the * var_string copy of "string" cannot be allocated, the * routine returns -1, otherwise it returns 0. */ int var_assign_string(char *name, char *string) { var_t *var; name += 1; if ((var = var_find(name)) == NULL) var = var_alloc(name); if (var == NULL) { filebench_log(LOG_ERROR, "Cannot assign variable %s", name); return (-1); } if ((var->var_string = ipc_stralloc(string)) == NULL) { filebench_log(LOG_ERROR, "Cannot assign variable %s", name); return (-1); } filebench_log(LOG_DEBUG_SCRIPT, "Assign string %s=%s", name, string); return (0); }
/* * Searches for the var named "name", and if not found * allocates it. The then extracts the var_string from * the var named "string" and copies it into the var_string * of the var "name", after first allocating a piece of * interprocess shared string memory. If the var "name" * cannot be found or allocated, or the var "string" cannot * be found, the routine returns -1, otherwise it returns 0. */ int var_assign_var(char *name, char *string) { var_t *var; var_string_t str; name += 1; if ((var = var_find(name)) == NULL) var = var_alloc(name); if (var == NULL) { filebench_log(LOG_ERROR, "Cannot assign variable %s", name); return (-1); } if ((str = var_ref_string(string)) == NULL) return (-1); if ((var->var_string = ipc_stralloc(*str)) == NULL) { filebench_log(LOG_ERROR, "Cannot assign variable %s", name); return (-1); } filebench_log(LOG_VERBOSE, "Assign string %s=%s", name, string); return (0); }
struct bwb_line * bwb_edit( struct bwb_line *l ) { char tbuf[ MAXSTRINGSIZE + 1 ]; char edname[ MAXSTRINGSIZE + 1 ]; struct bwb_variable *ed; FILE *loadfile; ed = var_find( DEFVNAME_EDITOR ); str_btoc( edname, var_getsval( ed )); sprintf( tbuf, "%s %s", edname, CURTASK progfile ); #if INTENSIVE_DEBUG sprintf( bwb_ebuf, "in bwb_edit(): command line <%s>", tbuf ); bwb_debug( bwb_ebuf ); #else nl(); endwin(); /* Added by JBV 10/11/97 */ system( tbuf ); /*-----------------------*/ /* Added by JBV 10/11/97 */ /*-----------------------*/ fprintf( stderr, "Press RETURN when ready..." ); fgets( tbuf, MAXREADLINESIZE, stdin ); refresh(); nonl(); #endif /* open edited file for read */ if ( ( loadfile = fopen( CURTASK progfile, "r" )) == NULL ) { sprintf( bwb_ebuf, err_openfile, CURTASK progfile ); bwb_error( bwb_ebuf ); ncu_setpos(); return bwb_zline( l ); } /* clear current contents */ bwb_new( l ); /* Relocated by JBV (bug found by DD) */ /* and (re)load the file into memory */ bwb_fload( loadfile ); ncu_setpos(); return bwb_zline( l ); }
/* * Searches for the named var, and if found returns the value, * of var_integer. If the var is not found, or the var_integer's * value is 0, logs an error and returns 0. */ vinteger_t var_to_integer(char *name) { var_t *var; name += 1; if ((var = var_find(name)) == NULL) var = var_find_dynamic(name); if ((var != NULL) && (var->var_integer)) return (var->var_integer); filebench_log(LOG_ERROR, "Variable %s referenced before set", name); return (0); }
void saffire_do_print(char *str) { //printf("print(%s)\n", str); if (str[0] == '$') { t_var *var = var_find(str); if (var == NULL) { printf("Cannot find variable %s", str); exit(1); } if (var->type == VT_STRING) { printf("%s", var->val.str); } else if (var->type = VT_LONG) { printf("%ld", var->val.num); } } else { str[strlen(str)-1] = '\0'; printf("%s", str+1); } }
struct bwb_line * bwb_edit( struct bwb_line *l ) { char tbuf[ MAXSTRINGSIZE + 1 ]; char edname[ MAXSTRINGSIZE + 1 ]; struct bwb_variable *ed; FILE *loadfile; ed = var_find( DEFVNAME_EDITOR ); str_btoc( edname, var_getsval( ed )); sprintf( tbuf, "%s %s", edname, CURTASK progfile ); #if INTENSIVE_DEBUG sprintf( bwb_ebuf, "in bwb_edit(): command line <%s>", tbuf ); bwb_debug( bwb_ebuf ); #else system( tbuf ); #endif /* open edited file for read */ if ( ( loadfile = fopen( CURTASK progfile, "r" )) == NULL ) { sprintf( bwb_ebuf, err_openfile, CURTASK progfile ); bwb_error( bwb_ebuf ); iqc_setpos(); return bwb_zline( l ); } /* clear current contents */ bwb_new( l ); /* Relocated by JBV (bug found by DD) */ /* and (re)load the file into memory */ bwb_fload( loadfile ); iqc_setpos(); return bwb_zline( l ); }
void _do_incdec(char *var_name, int inc) { t_var *var = var_find(var_name); if (var == NULL) { printf("Warning: var is not initialized."); var = var_alloc(VT_LONG, var_name, 0); } if (var->type != VT_LONG) { printf("Warning: var is not a number"); return; } if (inc) { var->val.num++; } else { var->val.num--; } //print_var(var); }
/* * Searches for the named var, and if found copies the var_string, * if it exists, or a decimal number string representation of * var_integer, into a malloc'd bit of memory using fb_stralloc(). * Returns a pointer to the created string, or NULL on failure. */ char * var_to_string(char *name) { var_t *var; char tmp[128]; name += 1; if ((var = var_find(name)) == NULL) var = var_find_dynamic(name); if (var == NULL) return (NULL); if (var->var_string) return (fb_stralloc(var->var_string)); (void) snprintf(tmp, sizeof (tmp), "%lld", var->var_integer); return (fb_stralloc(tmp)); }
/* * Searches for the named var, and if found returns a pointer * to the var's var_integer. If not found, attempts to allocate * a var named "name" and returns a pointer to it's (zeroed) * var_integer. If the var cannot be found or allocated, an * error is logged and the run is terminated. */ vinteger_t * var_ref_integer(char *name) { var_t *var; name += 1; if ((var = var_find(name)) == NULL) var = var_find_dynamic(name); if (var == NULL) var = var_alloc(name); if (var == NULL) { filebench_log(LOG_ERROR, "Invalid variable $%s", name); filebench_shutdown(1); } return (&var->var_integer); }
/* * Searches for the named var, and, if found, sets its * var_integer's value to that of the supplied integer. * If not found, the routine allocates a new var and sets * its var_integers's value to that of the supplied * integer. If the named var cannot be found or allocated * the routine returns -1, otherwise it returns 0. */ int var_assign_integer(char *name, vinteger_t integer) { var_t *var; name += 1; if ((var = var_find(name)) == NULL) var = var_alloc(name); if (var == NULL) { filebench_log(LOG_ERROR, "Cannot assign variable %s", name); return (-1); } var->var_integer = integer; filebench_log(LOG_DEBUG_SCRIPT, "Assign integer %s=%lld", name, integer); return (0); }
static struct bwb_line * dio_lrset(struct bwb_line * l, int rset) { char varname[BasicNameLengthMax + 1]; bstring *d, *s; int *pp; int n_params; int p; register int n, i; int startpos; struct exp_ese *e; struct bwb_variable *v; int pos; bwx_DEBUG(__FUNCTION__); /* find the variable name */ bwb_getvarname(l->buffer, varname, &(l->position)); v = var_find(varname); if (v == NULL) { sprintf(bwb_ebuf, "in dio_lrset(): failed to find variable"); bwb_error(bwb_ebuf); } if (v->type != STRING) { sprintf(bwb_ebuf, "in dio_lrset(): assignment must be to string variable"); bwb_error(bwb_ebuf); } /* read subscripts */ pos = 0; if ((v->dimensions == 1) && (v->array_sizes[0] == 1)) { n_params = 1; pp = &p; pp[0] = dim_base; } else { dim_getparams(l->buffer, &(l->position), &n_params, &pp); } CURTASK exps[CURTASK expsc].pos_adv = pos; for (n = 0; n < v->dimensions; ++n) { v->array_pos[n] = pp[n]; } /* get bstring pointer */ d = var_findsval(v, pp); /* find equals sign */ adv_ws(l->buffer, &(l->position)); if (l->buffer[l->position] != '=') { sprintf(bwb_ebuf, "in dio_lrset(): failed to find equal sign"); bwb_error(bwb_ebuf); } ++(l->position); adv_ws(l->buffer, &(l->position)); /* read remainder of line to get value */ e = bwb_exp(l->buffer, FALSE, &(l->position)); if (ERROR_PENDING) { return bwb_zline(l); } s = exp_getsval(e); /* set starting position */ startpos = 0; if (rset == TRUE) { if (s->length < d->length) { startpos = d->length - s->length; } } /* write characters to new position */ i = 0; for (n = startpos; (i < (int) s->length) && (n < (int) d->length); ++n) { d->sbuffer[n] = s->sbuffer[i]; ++i; } /* return */ return bwb_zline(l); }
struct bwb_line * bwb_FIELD(struct bwb_line * l) { int dev_number; struct exp_ese *e; int current_pos; char atbuf[BasicStringLengthMax + 1]; int pos; bwx_DEBUG(__FUNCTION__); current_pos = 0; /* first read device number */ adv_ws(l->buffer, &(l->position)); if (l->buffer[l->position] == BasicFileNumberPrefix) { ++(l->position); adv_ws(l->buffer, &(l->position)); } adv_element(l->buffer, &(l->position), atbuf); pos = 0; e = bwb_exp(atbuf, FALSE, &pos); if (ERROR_PENDING) { return bwb_zline(l); } if (e->type != NUMBER) { bwb_error("in bwb_field(): Number was expected for device number"); return bwb_zline(l); } dev_number = exp_getival(e); if (dev_number < 1 || dev_number > BasicFileNumberMax) { bwb_error("in bwb_field(): Requested device number is not VALID."); return bwb_zline(l); } /* be sure that the requested device is open */ if (dev_table[dev_number].mode != DEVMODE_RANDOM) { bwb_error("in bwb_field(): Requested device number is not RANDOM."); return bwb_zline(l); } /* loop to read variables */ do { int length; struct bwb_variable *v; bstring *b; /* read the comma and advance beyond it */ adv_ws(l->buffer, &(l->position)); if (l->buffer[l->position] == ',') { ++(l->position); } /* first find the size of the field */ adv_element(l->buffer, &(l->position), atbuf); /* get element */ pos = 0; e = bwb_exp(atbuf, FALSE, &pos); if (ERROR_PENDING) { return bwb_zline(l); } if (e->type != NUMBER) { bwb_error("in bwb_field(): number value for field size not found"); return bwb_zline(l); } length = exp_getival(e); /* read the AS */ adv_element(l->buffer, &(l->position), atbuf); /* get element */ if (strcasecmp(atbuf, "AS") != 0) { bwb_error("in bwb_field(): AS statement not found"); return bwb_zline(l); } /* read the string variable name */ #if 0 adv_element(l->buffer, &(l->position), atbuf); /* get element */ #endif bwb_getvarname(l->buffer, atbuf, &(l->position)); v = var_find(atbuf); if (v->type != STRING) { bwb_error("in bwb_field(): string variable name not found"); return bwb_zline(l); } /* check for overflow of record length */ if ((current_pos + length) > dev_table[dev_number].width) { bwb_error("in bwb_field(): record length exceeded"); return bwb_zline(l); } /* set buffer */ b = var_findsval(v, v->array_pos); b->sbuffer = dev_table[dev_number].buffer + current_pos; b->length = (unsigned int) length; /* Was unsigned char * (JBV 9/4/97) */ b->rab = TRUE; current_pos += length; /* eat up any remaining whitespace */ adv_ws(l->buffer, &(l->position)); } while (l->buffer[l->position] == ','); /* return */ return bwb_zline(l); }
void GLEPolish::internalPolish(GLEPcode& pcode, int *rtype) throw(ParserError) { GLESub* sub; string uc_token; int idx, ret, np, *plist, term_bracket = false; int curpri = 0; int nstk = 0, stk[50], stkp[50]; /* stack for operators */ int unary = 1; /* binary or unary operation expected */ bool isa_string = false; bool not_string = false; if (*rtype==1) not_string = true; if (*rtype>0) term_bracket = true; pcode.addInt(PCODE_EXPR); /* Expression follows */ int savelen = pcode.size(); /* Used to set acutal length at end */ pcode.addInt(0); /* Length of expression */ while (true) { string token = m_tokens.try_next_token(); int token_col = m_tokens.token_pos_col(); int token_len = token.length(); char first_char = token_len > 0 ? token[0] : ' '; // cout << "Token: '" << token << "'" << endl; // end of stream, or found ',' or ')' if (token_len == 0 || (token_len == 1 && (first_char == ',' || (first_char == ')' && curpri == 0) || (first_char == ']' && curpri == 0)))) { if (token_len != 0) { m_tokens.pushback_token(); } *rtype = 0; dbg gprint("Found END OF EXPRESSION \n"); if (curpri != 0) { throw error("unexpected end of expression, missing closing ')' or ']'"); } /* Pop everything off the stack */ for (int i = nstk; i > 0; i--) { dbg gprint("Adding left over operators I = %d op=%d \n",i,stk[i]); pcode.addInt(stk[i]); } if (unary == 1) { throw error("constant, function, or unary operator expected"); } pcode.setInt(savelen, pcode.size() - savelen - 1); #ifdef DEBUG_POLISH pcode.show(savelen); #endif return; } dbg gprint("First word token via (1=unary %d) cts {%s}\n ", unary, token.c_str()); switch (unary) { case 1: /* a unary operator, or function, or number or variable */ if (is_float(token)) { dbg gprint("Found number {%s}\n",token.c_str()); double value = atof(token.c_str()); pcode.addDouble(value); unary = 2; break; } str_to_uppercase(token, uc_token); /* NOT a number, is it a built in function? */ find_un((char*)uc_token.c_str(), &idx, &ret, &np, &plist); /* 1,2 = +,- */ if (idx > 3 && m_tokens.is_next_token("(")) { // // it is a built in function // dbg gprint("Found built in function \n"); get_params(pcode, np, plist, uc_token); pcode.addFunction(idx + FN_BUILTIN_MAGIC); unary = 2; break; } else if (idx > 0 && idx <= 3) { stack_fn(idx); unary = 1; break; } /* Is it a user-defined function, identical code too above. */ sub = sub_find((char*)uc_token.c_str()); if (sub != NULL && m_tokens.is_next_token("(")) { // // it is a user defined function // // printf("User cts=%s idx=%d ret=%d np=%d plist=%d\n",cts,idx,ret,np,plist); dbg gprint("Found user function \n"); get_params(pcode, sub->getNbParam(), sub->getParamTypes(), uc_token); pcode.addFunction(sub->getIndex()+LOCAL_START_INDEX); unary = 2; break; } /* Is it a 'known' variable */ int v; var_find((char*)uc_token.c_str(), &v, &ret); if (v >= 0) { // cout << "found var: '" << uc_token << "' -> " << v << endl; if (ret == 2) pcode.addStrVar(v); else pcode.addVar(v); unary = 2; if (m_vars != NULL && m_vars->try_get(uc_token) == -1) { /* Add it to list of vars */ m_vars->add_item(uc_token, v); } break; } /* Is it a string */ if (first_char == '"' || first_char == '\'') { dbg gprint("Found string \n"); string str_no_quote = token; str_remove_quote(str_no_quote); pcode.addString(str_no_quote); unary = 2; break; } if ((first_char == 'd' || first_char == 'D') && token_len == 1 && m_tokens.is_next_token("[")) { get_array_index(pcode); pcode.addFunction(FN_DI + FN_BUILTIN_MAGIC); unary = 2; break; } if (first_char == '(' && token_len == 1) { curpri = curpri + 100; break; } if ((first_char == ')' || first_char == ')') && token_len == 1) { throw error("constant, function, or unary operator expected"); } if (m_tokens.is_next_token("(")) { throw error(token_col, string("call to undefined function '"+token+"'")); } /* must be unquoted string, unless a binary operator was found, in which case it is an undelcared variable */ if (not_string || str_var(token)) { /* name that includes '$' is also assumed to be a variable */ dbg gprint("Found un-initialized variable {%s} /n",token.c_str()); if (!var_valid_name(uc_token)) { throw error(token_col, "illegal variable name '"+uc_token+"'"); } var_findadd((char*)uc_token.c_str(), &v, &ret); if (ret == 2) pcode.addStrVar(v); else pcode.addVar(v); not_string = true; unary = 2; if (m_vars != NULL && m_vars->try_get(uc_token) == -1) { /* Add it to list of vars */ m_vars->add_item(uc_token, v); } break; } // std::cout << "Unquoted string '" << token << "'" << std::endl; pcode.addString(token); if (!valid_unquoted_string(token)) { throw error(token_col, "invalid unquoted string '"+token+"'"); } isa_string = true; unary = 2; break; case 2: /* a binary operator, or space, or end of line */ /* MIGHT (gives error with a$ = b$+c$) */ if (first_char != '.') { if (isa_string) { throw error("left hand side contains unquoted string"); } not_string = true; } else { not_string = false; } /* Binary operators, +,-,*,/,^,<,>,<=,>=,.and.,.or. */ int priority = 0; if (token_len == 1) { switch (first_char) { case '+' : v = BIN_OP_PLUS; priority = 2; break; case '-' : v = BIN_OP_MINUS; priority = 2; break; case '*' : v = BIN_OP_MULTIPLY; priority = 3; break; case '/' : v = BIN_OP_DIVIDE; priority = 3; break; case '%' : v = BIN_OP_MOD; priority = 3; break; case '^' : v = BIN_OP_POW; priority = 4; break; case '=' : v = BIN_OP_EQUALS; priority = 1; break; case '&' : v = BIN_OP_AND; priority = 1; break; case '|' : v = BIN_OP_OR; priority = 1; break; case '<' : v = BIN_OP_LT; priority = 1; break; case '>' : v = BIN_OP_GT; priority = 1; break; case '.' : v = BIN_OP_DOT; priority = 2; break; default : v = 0; } } else { str_to_uppercase(token, uc_token); if (token == "<=") { v = BIN_OP_LE; priority = 1; } else if (token == "<>") { v = BIN_OP_NOT_EQUALS; priority = 1; } else if (token == ">=") { v = BIN_OP_GE; priority = 1; } else if (token == "**") { v = BIN_OP_POW; priority = 4; } else if (uc_token == "AND") { v = BIN_OP_AND; priority = 1; } else if (uc_token == "OR") { v = BIN_OP_OR; priority = 1; } else { v = 0; } } if (v > 0) { stack_bin(v, priority); dbg gprint("Found binary operator \n"); unary = 1; } else if (first_char == ')' && token_len == 1) { if (curpri > 0) { curpri = curpri - 100; unary = 2; break; } if (!term_bracket) { throw error("too many closing ')', expecting binary operator"); } } else { throw error(string("unknown binary operator '")+token+"'"); } } // end switch } // end for }