static void* vars (int argc, char **argv, void *data) { ItemT *titem = items; cli_outfunf ("all variables:"); while (titem) { #ifdef HIDE_NULL_HELP if(titem->usage) #endif if (is_variable (titem)) { if (titem->string) { cli_outfunf ("%15s [%s]\t- %s", titem->name, titem->string, titem->usage); } else if (titem->integer) { cli_outfunf ("%15s [%i]\t- %s", titem->name, *titem->integer, titem->usage); } else { cli_outfunf ("%s\tis a broken variable", titem->name); } } titem = titem->next; } cli_outfunf ("----------------"); cli_outfunf ("to change a variable: \"variablename newvalue\""); return data; }
int parse_line (char *line, int line_length) { int i, ret, buffer_index; char buffer[32]; memset(buffer, 0, 32); buffer_index = ret = 0; printf("%s", line); for (i = 0; i < line_length; i++) { if (isspace(line[i]) && !buffer_index) continue; else if (line[i] == '#') { ret = DIRECTIVE_FOUND; break; } else if (isspace(line[i])) { if (is_string(buffer)) return parse_string(line, i, line_length, 1); else if (is_variable(buffer[0]) && find_assign(line, i, line_length)) return parse_string(line, i-1, line_length, 0); else { memset(buffer, 0, 32); buffer_index = 0; } } else { buffer[buffer_index++] = line[i]; if (check_overflow(buffer_index, 32)) return OVERFLOW_DETECTED; } } fwrite(line, strlen(line), sizeof(char), tmp); return ret; }
/***********************************************************************//** * @brief Set number of column elements for specific row * * @param[in] row Row index. * @param[in] elements Number of elements in @p row. * * @exception GException::out_of_range * Invalid row index specified. * @exception GException::invalid_argument * Invalid number of elements specified. * * Sets the number of elements in column for a specific @p row. ***************************************************************************/ void GFitsTableCol::elements(const int& row, const int& elements) { // Check row value if (row < 0 || row >= length()) { throw GException::out_of_range(G_ELEMENTS1, "Row index", row, length()); } // Check that elements is non-negative if (elements < 0) { std::string msg = "Number of elements " + gammalib::str(elements) + " can not be negative.\nPlease specify a" " non-negative number of elements."; throw GException::invalid_argument(G_ELEMENTS1, msg); } // First handle the case of a variable-length column if (is_variable()) { // Determine number of elements to add or to remove int difference = elements - (m_rowstart[row+1] - m_rowstart[row]); // If difference is positive, then add elements at the end of // the vector. This is done using resize_data() which will insert // "difference" elements at the index specified as first argument if (difference > 0) { resize_data(m_rowstart[row+1], difference); } // ... else if difference is negative then remove elements from // the end of the array. This is done using resize_data() which // will remove "difference" element from the index on specified as // first argument else if (difference < 0) { resize_data(m_rowstart[row+1]+difference, difference); } // Update row start indices for (int i = row + 1; i <= length(); ++i) { m_rowstart[i] += difference; } // Update maximum column length m_varlen = 0; for (int i = 0; i < length(); ++i) { int len = m_rowstart[row+1] - m_rowstart[row]; if (len > m_varlen) { m_varlen = len; } } } // endif: we had a variable-length column // Return return; }
struct node *build_expression_tree(int operands, int num_tokens, char **tokens) { int i, top; char *str; struct node *tmp; struct node *stack[operands]; top = 0; for (i = 1; i < num_tokens; ++i) { str = *(tokens + i); if (is_number(str)) { stack[top] = create_node(str, NUMBER); ++top; } else if (is_variable(str)) { stack[top] = create_node(str, VARIABLE); ++top; } else if (is_bin_operator(str)) { if (top >= 2) { tmp = create_node(str, BIN_OPERATOR); tmp->left = stack[top - 2]; tmp->right = stack[top - 1]; stack[top - 2] = tmp; --top; } else { fprintf(stderr, "Not enough elements on stack" " to apply binary operator: %s. Token" " number: %d.\n", str, i); return NULL; } } else if (is_un_operator(str)) { if (top >= 1) { tmp = create_node(str, UN_OPERATOR); tmp->right = stack[top - 1]; stack[top - 1] = tmp; } else { fprintf(stderr, "Not enough elements on stack" " to apply unary operator: %s. Token" " number: %d.\n", str, i); return NULL; } } else { fprintf(stderr, "Unrecognized token: %s", str); return NULL; } } if (top == 1) { return stack[top - 1]; } else { fprintf(stderr, "More or less than one elements left on" " stack after all applying all operations.\n"); return NULL; } }
int op_let_un_math(target_x86_t *target_x86, char *str_dst, char *str_src, char *op) { char line[STR_LINE_SIZE]; var_t *var; if( is_variable(str_src) ) { var_t *var; var = target_x86_get_var(target_x86, str_src); str_src = var->addr; } var = target_x86_get_var(target_x86, str_dst); str_dst = var->addr; sprintf(line, "mov eax, %s", str_src); add_line(target_x86, TARGET_TEXT, line); if( strcmp(op, "-") == 0 ) { add_line(target_x86, TARGET_TEXT, "neg eax"); } if( strcmp(op, "not") == 0 ) { add_line(target_x86, TARGET_TEXT, "neg eax"); } if( strcmp(op, "neg") == 0 ) { add_line(target_x86, TARGET_TEXT, "mov ecx, 0"); add_line(target_x86, TARGET_TEXT, "cmp eax, 0"); sprintf(line, "jne .label_%d", target_x86->label_count); add_line(target_x86, TARGET_TEXT, line); add_line(target_x86, TARGET_TEXT, "mov ecx, 1"); sprintf(line, ".label_%d:", target_x86->label_count); add_line(target_x86, TARGET_TEXT, line); add_line(target_x86, TARGET_TEXT, "mov eax, ecx"); target_x86->label_count++; } sprintf(line, "mov %s, eax", str_dst); add_line(target_x86, TARGET_TEXT, line); return 0; }
/***********************************************************************//** * @brief Load table column from FITS file * * Loads table column from FITS file by calling the load_column_variable() * method for variable-length columns and load_column_fixed() for fixed- * length columns. ***************************************************************************/ void GFitsTableCol::load_column(void) { // Load variable-length or fixed-length column from FITS file if (is_variable()) { load_column_variable(); } else { load_column_fixed(); } // Return return; }
/***********************************************************************//** * @brief Save table column into FITS file * * Save table column into FITS file by calling the save_column_variable() * method for variable-length columns and save_column_fixed() for fixed- * length columns. ***************************************************************************/ void GFitsTableCol::save_column(void) { // Save variable-length or fixed-length column into FITS file if (is_variable()) { save_column_variable(); } else { save_column_fixed(); } // Return return; }
int num_operands(int num_tokens, char **tokens) { int i, operands; const char *tok; operands = 0; for (i = 1; i < num_tokens; ++i) { tok = *(tokens + i); if (is_number(tok) || is_variable(tok)) { ++operands; } } return operands; }
char *cli_getstring(char *variable){ ItemT *titem = items; while (titem) { if (is_variable (titem)) { if (!strcmp (variable, titem->name)) { if(titem->string) return(titem->string); if(titem->integer) return NULL; /* FIXME: use a static buffer perhaps */ } } titem = titem->next; } return ""; }
int map_expr(double dataf[], int datai[], int elem_id, double coord[]) { int i,len,temp; struct Elem out; int *results; double *constf; results = &datai[elem_id+6]; constf = &dataf[datai[elem_id+2]]; len = datai[elem_id+5]; init_elem_stack(); for(i=0;i<len;i++) { if(is_operator(dataf,datai,results[i])||(decode(dataf,datai,results[i])==op_constf)) { if(decode(dataf,datai,results[i])==op_constf) { op_CONSTF(constf); continue; } call_ops(decode(dataf,datai,results[i])); } else { if(is_variable(results[i])) { temp = decode(dataf,datai,results[i]); if(temp%2==0) op_NUMi(datai[temp/2]); else op_NUMf(dataf[(temp-1)/2]); continue; } op_NUMi(decode(dataf,datai,results[i])); } } out = elem_pop(); if(out.type==INT) { update_gen(dataf,datai,elem_id,out.data.i,0); printf("%d\n",datai[(decode(dataf,datai,datai[elem_id+4]))/2]); } if(out.type==FLOAT) { update_gen(dataf,datai,elem_id,0,out.data.f); printf("%f\n",dataf[(decode(dataf,datai,datai[elem_id+4])-1)/2]); } return 1; }
/***********************************************************************//** * @brief Compute offset of column element in memory * * @param[in] row Row of column. * @param[in] inx Vector index in column row. * * @exception GException::out_of_range * Table row or vector index are out of valid range. * * Computes the offset of a column element in the storage array from the * @p row number and the vector index. The method also supports both * variable-length and fixed-length columns. ***************************************************************************/ int GFitsTableCol::offset(const int& row, const int& inx) const { // Check row value #if defined(G_RANGE_CHECK) if (row < 0 || row >= m_length) { throw GException::out_of_range(G_OFFSET, row, 0, m_length-1); } #endif // Check inx value #if defined(G_RANGE_CHECK) if (inx < 0 || inx >= elements(row)) { throw GException::out_of_range(G_OFFSET, inx, 0, elements(row)); } #endif // Calculate pixel offset int offset = (is_variable()) ? m_rowstart[row] + inx : row * m_number + inx; // Return offset return offset; }
data_t *eval(const data_t *exp, data_t *env) { if(eval_plz_die) { eval_plz_die = 0; ExitThread(0); } if(is_self_evaluating(exp)) return (data_t*)exp; if(is_variable(exp)) return lookup_variable_value(exp, env); if(is_quoted_expression(exp)) return get_text_of_quotation(exp); if(is_assignment(exp)) return eval_assignment(exp, env); if(is_definition(exp)) return eval_definition(exp, env); if(is_if(exp)) return eval_if(exp, env); if(is_lambda(exp)) return make_procedure(get_lambda_parameters(exp), get_lambda_body(exp), env); if(is_begin(exp)) return eval_sequence(get_begin_actions(exp), env); if(is_cond(exp)) return eval(cond_to_if(exp), env); if(is_letrec(exp)) return eval(letrec_to_let(exp), env); if(is_let_star(exp)) return eval(let_star_to_nested_lets(exp), env); if(is_let(exp)) return eval(let_to_combination(exp), env); if(is_application(exp)) return apply( eval(get_operator(exp), env), get_list_of_values(get_operands(exp), env)); printf("Unknown expression type -- EVAL '"); return make_symbol("error"); }
int op_let_assign(target_x86_t *target_x86, char *str_dst, char *str_src) { char line[STR_LINE_SIZE]; var_t *var; if( is_variable(str_src) ) { var_t *var; var = target_x86_get_var(target_x86, str_src); str_src = var->addr; } var = target_x86_get_var(target_x86, str_dst); str_dst = var->addr; sprintf(line, "mov eax, %s", str_src); add_line(target_x86, TARGET_TEXT, line); sprintf(line, "mov %s, eax", str_dst); add_line(target_x86, TARGET_TEXT, line); return 0; }
bool is_bound(object *expression, object *env) { return is_variable(expression) ? !is_error(lookup_variable_value(expression, env)) : false; }
object *eval(object *exp, object *env) { object *procedure; object *arguments; object *result; bool tailcall = false; do { if (is_self_evaluating(exp)) return exp; if (is_variable(exp)) return lookup_variable_value(exp, env); if (is_quoted(exp)) return text_of_quotation(exp); if (is_assignment(exp)) return eval_assignment(exp, env); if (is_definition(exp)) return eval_definition(exp, env); if (is_if(exp)) { exp = is_true(eval(if_predicate(exp), env)) ? if_consequent(exp) : if_alternative(exp); tailcall = true; continue; } if (is_lambda(exp)) return make_compound_proc(lambda_parameters(exp), lambda_body(exp), env); if (is_begin(exp)) { exp = begin_actions(exp); while (!is_last_exp(exp)) { eval(first_exp(exp), env); exp = rest_exps(exp); } exp = first_exp(exp); tailcall = true; continue; } if (is_cond(exp)) { exp = cond_to_if(exp); tailcall = true; continue; } if (is_let(exp)) { exp = let_to_application(exp); tailcall = true; continue; } if (is_and(exp)) { exp = and_tests(exp); if (is_empty(exp)) return make_boolean(true); while (!is_last_exp(exp)) { result = eval(first_exp(exp), env); if (is_false(result)) return result; exp = rest_exps(exp); } exp = first_exp(exp); tailcall = true; continue; } if (is_or(exp)) { exp = or_tests(exp); if (is_empty(exp)) { return make_boolean(false); } while (!is_last_exp(exp)) { result = eval(first_exp(exp), env); if (is_true(result)) return result; exp = rest_exps(exp); } exp = first_exp(exp); tailcall = true; continue; } if (is_application(exp)) { procedure = eval(operator(exp), env); arguments = list_of_values(operands(exp), env); if (is_primitive_proc(procedure) && procedure->data.primitive_proc.fn == eval_proc) { exp = eval_expression(arguments); env = eval_environment(arguments); tailcall = true; continue; } if (is_primitive_proc(procedure) && procedure->data.primitive_proc.fn == apply_proc) { procedure = apply_operator(arguments); arguments = apply_operands(arguments); } if (is_primitive_proc(procedure)) return (procedure->data.primitive_proc.fn)(arguments); if (is_compound_proc(procedure)) { env = extend_environment(procedure->data.compound_proc.parameters, arguments, procedure->data.compound_proc.env); exp = make_begin(procedure->data.compound_proc.body); tailcall = true; continue; } return make_error(342, "unknown procedure type"); } // is_application() } while (tailcall); fprintf(stderr, "cannot eval unknown expression type\n"); exit(EXIT_FAILURE); }
uint8_t *data () { return is_variable (header)? variable : bytes; }
static OBJ analyze_r(const struct analyze_t *arg) { OBJ op; OBJ ret; struct analyze_t new_arg; new_arg = *arg; ret = OBJ_NULL; if (is_self_evaluating(new_arg.sexp)) ret = new_arg.sexp; else if (is_variable(new_arg.sexp)) ret = analyze_variable_cell(new_arg.sexp,new_arg.env,new_arg.macro,new_arg.params,new_arg.macro_expand_env); else if(obj_pairp(new_arg.sexp)) { if(obj_pairp(car(new_arg.sexp))) { new_arg.sexp = car(new_arg.sexp); op = fake_eval(&new_arg); new_arg = *arg; } else op = analyze_variable_value(car(new_arg.sexp),new_arg.env,new_arg.macro,new_arg.params,new_arg.macro_expand_env); if(op == OBJ_NULL) /* error handle---fixme!! */ return OBJ_NULL; if(obj_corep(op)) { switch(obj_core_type(op)) { case DEFINE: case DEFINE_SYNTAX: new_arg.sexp = cdr(new_arg.sexp); ret = analyze_define(&new_arg); break; case SET: new_arg.sexp = cdr(new_arg.sexp); ret = analyze_set(&new_arg); break; case IF: ret = analyze_if(cdr(new_arg.sexp),new_arg.env,new_arg.tail); break; case QUOTE: ret = obj_make_quote(cadr(new_arg.sexp)); break; case BEGIN: new_arg.sexp = cdr(new_arg.sexp); ret = analyze_begin(&new_arg); break; case LAMBDA: new_arg.sexp = cdr(new_arg.sexp); ret = analyze_lambda(&new_arg); break; case SYNTAX_RULES: ret = analyze_syntax_rules(cdr(new_arg.sexp),new_arg.env); break; default: fprintf(stderr,"unknown core tag\n"); } } else if(obj_syntaxp(op)) { OBJ params; OBJ data; OBJ patten; OBJ template; int match; match = 0; data = obj_syntax_data(op); while(obj_pairp(data)) { patten = caar(data);
bool expression_calc::is_operand( const std::string& s ) { return is_numeric( s ) || is_variable( s ); }
object *bs_eval(object *exp, object *env) { tailcall: if (is_empty_list(exp)) { error("unable to evaluate empty list"); } else if (is_self_evaluating(exp)) { return exp; } else if (is_variable(exp)) { return lookup_variable_value(exp, env); } else if (is_quoted(exp)) { return quoted_expression(exp); } else if (is_assignment(exp)) { return eval_assignment(exp, env); } else if (is_definition(exp)) { return eval_definition(exp, env); } else if (is_if(exp)) { if (is_true(bs_eval(if_predicate(exp), env))) { exp = if_consequent(exp); } else { exp = if_alternate(exp); } goto tailcall; } else if (is_lambda(exp)) { return make_compound_proc(lambda_parameters(exp), lambda_body(exp), env); } else if (is_begin(exp)) { exp = begin_actions(exp); if (is_empty_list(exp)) { error("empty begin block"); } while (!is_empty_list(cdr(exp))) { bs_eval(car(exp), env); exp = cdr(exp); } exp = car(exp); goto tailcall; } else if (is_cond(exp)) { exp = cond_to_if(exp); goto tailcall; } else if (is_let(exp)) { exp = let_to_application(exp); goto tailcall; } else if (is_and(exp)) { exp = and_tests(exp); if (is_empty_list(exp)) { return get_boolean(1); } object *result; while (!is_empty_list(cdr(exp))) { result = bs_eval(car(exp), env); if (is_false(result)) { return result; } exp = cdr(exp); } exp = car(exp); goto tailcall; } else if (is_or(exp)) { exp = or_tests(exp); if (is_empty_list(exp)) { return get_boolean(0); } object *result; while (!is_empty_list(cdr(exp))) { result = bs_eval(car(exp), env); if (is_true(result)) { return result; } exp = cdr(exp); } exp = car(exp); goto tailcall; } else if (is_application(exp)) { object *procedure = bs_eval(application_operator(exp), env); object *parameters = eval_parameters(application_operands(exp), env); // handle eval specially for tailcall requirement. if (is_primitive_proc(procedure) && procedure->value.primitive_proc == eval_proc) { exp = eval_expression(parameters); env = eval_environment(parameters); goto tailcall; } // handle apply specially for tailcall requirement. if (is_primitive_proc(procedure) && procedure->value.primitive_proc == apply_proc) { procedure = apply_operator(parameters); parameters = apply_operands(parameters); } if (is_primitive_proc(procedure)) { return (procedure->value.primitive_proc)(parameters); } else if (is_compound_proc(procedure)) { env = extend_environment( procedure->value.compound_proc.parameters, parameters, procedure->value.compound_proc.env); exp = make_begin(procedure->value.compound_proc.body); goto tailcall; } else { error("unable to apply unknown procedure type"); } } else { error("unable to evaluate expression"); } }
uint64_t InsnSemanticsExpr::LeafNode::get_name() const { assert(is_variable() || is_memory()); return name; }
Number shunting_yard(std::vector<std::string> & tokens, std::vector<std::string> & out_ops, bool boolean_exp = false) { prepare(); std::string previous_token; Operator * op; Operator * previous_op = new Sum(); std::string last_token = ""; std::string token; for(auto s = tokens.begin(); s != tokens.end(); ++s) { token = *s; //std::cout<<token<<std::endl; if(is_number(token)) { if(is_number(previous_token)) { throw std::string("Too many operands"); } if(previous_op && previous_op->sign() == ")") { throw std::string("Missing operation between paretheses"); } Number i = parse_number(token); if(i >= Number("10", "99") || i <= Number("-10", "99")) { //std::cout<<i<<'\n'; throw std::string("Number out of valid range"); } if(is_variable(token)) { std::stringstream g; g << i; out_ops.push_back(token + "= " + g.str()); } output_stack.push(i); previous_op = nullptr; } else if((op = get_function_op(token)) != nullptr) { operator_stack.push(op); } else if (token == ",") { while(!operator_stack.empty() && operator_stack.top()->sign() != "(") { evaluate(operator_stack.top(), out_ops); operator_stack.pop(); } // error if(operator_stack.empty()) { throw std::string("mismatched parens"); } // dirty fix, the problem is that in get_operator we only return a // negative if there was an operator before, so root(3, -27) was being // treated as a substraction previous_op = new Sum(); } else if((op = get_operator(token, previous_op, boolean_exp)) != nullptr) { if(op->sign() == "(") { if(!previous_op || (previous_op && previous_op->sign() == ")" )) { throw std::string("Missing operation between paretheses"); } operator_stack.push(op); } else if(op->sign() == ")") { while(!operator_stack.empty() && operator_stack.top()->sign() != "(") { evaluate(operator_stack.top(), out_ops); operator_stack.pop(); } // error if(operator_stack.empty()) { throw std::string("mismatched parens"); } operator_stack.pop(); if(!operator_stack.empty() && operator_stack.top()->sign() == "r") { evaluate_function(operator_stack.top(), out_ops); operator_stack.pop(); } } else { while(!operator_stack.empty() && ( (op->associativity() == assoc::LEFT && op->precedence() <= operator_stack.top()->precedence()) || (op->associativity() == assoc::RIGHT && op->precedence() < operator_stack.top()->precedence()))) { evaluate(operator_stack.top(), out_ops); operator_stack.pop(); } operator_stack.push(op); } previous_op = op; } else if(token == "=" && !boolean_exp) { if(s+1 != tokens.end()) last_token = *(s+1); break; } // unknown token else { throw std::string("Unexpected Token '" + token + "'"); } previous_token = token; } while(!operator_stack.empty()) { op = operator_stack.top(); if(op->sign() == "(") { throw std::string("mismatched parens"); } operator_stack.pop(); evaluate(op, out_ops); } if(token != "=" && !boolean_exp) { throw std::string("Missing ="); } if(!last_token.empty() && !boolean_exp) { if(var_map.find(last_token) != var_map.end()) { var_map[last_token] = output_stack.top(); if(tokens[tokens.size()-1] != last_token) { throw std::string("Warning, no more expressions after variable assignment"); } // out ops A= std::stringstream ss; ss << output_stack.top(); out_ops.push_back(last_token + "= " + ss.str()); //std::cout << var_map[last_token] << '\n'; } else { throw std::string("Warning, no more expressions after ="); } } if(output_stack.empty()) return Number ("0","0"); Number ans = output_stack.top(); output_stack.pop(); if(!output_stack.empty()) throw std::string("too many arguments to function"); return ans; }
int parse_string (char *line, int offset, int line_length, int type) { int state, i, ret; char var_name[32]; int var_index; char assignment[256]; int assign_index; char buffer[256]; int size; memset(var_name, 0, 32); var_index = 0; memset(assignment, 0, 256); assign_index = 0; state = ret = 0; for (i = offset; i < line_length && state != 3; i++) { switch(state) { case 0: if (isspace(line[i])) continue; if (is_variable(line[i])) { var_name[var_index++] = line[i]; ret = check_overflow(var_index, 32); } else { if (line[i] == ';') state = 3; else if (line[i] == '=') state = 1; } break; case 1: if (!isspace(line[i])) { if (line[i] == '\"') state = 2; } else continue; break; case 2: if (!isspace(line[i])) { if (line[i] == '\"') state = 3; else { assignment[assign_index++] = line[i]; ret = check_overflow(assign_index, 256); } } else continue; break; default: break; } } if (type == 1) { if (root != NULL) insert_symbol(root, var_name); size = snprintf(buffer, 256, "\tchar %s = calloc(%d, sizeof(char));\n\0", var_name, assign_index+1); fwrite(buffer, size, sizeof(char), tmp); if (assign_index) { size = snprintf(buffer, 256, "\tstrcpy(%s, \"%s\");\n\0", var_name, assignment); fwrite(buffer, size, sizeof(char), tmp); } } else { size = snprintf(buffer, 256, "\t%s = realloc(%s, %d);\n\0", var_name, var_name, assign_index+1); fwrite(buffer, size, sizeof(char), tmp); size = snprintf(buffer, 256, "\tstrcpy(%s, \"%s\");\n\0", var_name, (assign_index)? assignment : "0"); fwrite(buffer, size, sizeof(char), tmp); } printf("Var_name: %s - Assign: %s Assign_size: %d\n", var_name, assignment, assign_index); return ret; }
static pSlipObject slip_eval(pSlip gd, pSlipObject exp, pSlipEnvironment env) { pSlipObject proc; pSlipObject args; tailcall: if (is_self_evaluating(exp) == S_TRUE) { return exp; } else if (is_variable(exp) == S_TRUE) { return lookup_variable_value(gd, exp, env); } else if (is_quoted(gd, exp) == S_TRUE) { return text_of_quotation(exp); } else if (is_assignment(gd, exp) == S_TRUE) { return eval_assignment(gd, exp, env); } else if (is_definition(gd, exp) == S_TRUE) { return eval_definition(gd, exp, env); } else if (is_if(gd, exp) == S_TRUE) { exp = is_true(gd, slip_eval(gd, if_predicate(exp), env)) == S_TRUE ? if_consequent(exp) : if_alternative(gd, exp); goto tailcall; } else if (is_lambda(gd, exp) == S_TRUE) { return s_NewCompoundProc(gd, lambda_parameters(exp), lambda_body(exp), env); } else if (is_begin(gd, exp) == S_TRUE) { exp = begin_actions(exp); while (!is_last_exp(gd, exp)) { slip_eval(gd, first_exp(exp), env); exp = rest_exps(exp); } exp = first_exp(exp); goto tailcall; } else if (is_cond(gd, exp) == S_TRUE) { exp = cond_to_if(gd, exp); goto tailcall; } else if (is_let(gd, exp) == S_TRUE) { exp = let_to_application(gd, exp); goto tailcall; } else if (is_application(exp) == S_TRUE) { proc = slip_eval(gd, slip_operator(exp), env); if (proc == NULL) return gd->singleton_False; if (proc->type == eType_PRIMITIVE_PROC || proc->type == eType_COMPOUND_PROC) { args = list_of_values(gd, operands(exp), env); if (args == NULL) return gd->singleton_False; if (sIsObject_PrimitiveProc(proc) == S_TRUE) { return proc->data.prim_proc.func(gd, args); } else if (sIsObject_CompoundProc(proc) == S_TRUE) { env = setup_environment(gd, proc->data.comp_proc.env, proc->data.comp_proc.params, args); exp = make_begin(gd, proc->data.comp_proc.code); goto tailcall; } else { throw_error(gd, "unknown procedure type\n"); return gd->singleton_False; } } else return proc; } else { throw_error(gd, "cannot eval unknown expression type\n"); return NULL; } throw_error(gd, "what??\n"); return NULL; }
static int target_x86_prepare_function(target_x86_t *target_x86, int n) { int i; for(i = n; i < target_x86->array_line->count; i++) { char *line = (char *) array_get(target_x86->array_line, i); if( strncmp(line, "begin_function", 14) == 0 ) { char cmd[STR_SIZE]; char param[STR_SIZE]; sscanf(line, "%s %s", cmd, param); target_x86->name = strdup(param); } if( strncmp(line, "param", 5) == 0 ) { char cmd[STR_SIZE]; char param[STR_SIZE]; sscanf(line, "%s %s", cmd, param); target_x86_add_param_var(target_x86, param); } if( strncmp(line, "let", 3) == 0 ) { char cmd[STR_SIZE]; char param1[STR_SIZE]; char param2[STR_SIZE]; char param3[STR_SIZE]; char op[STR_SIZE]; int res; res = analye_op_let(line, param1, param2, param3, op); if( res == LET_BIN ) { if( is_variable(param1) ) { target_x86_add_local_var(target_x86, param1); } if( is_variable(param2) ) { target_x86_add_local_var(target_x86, param2); } if( is_variable(param3) ) { target_x86_add_local_var(target_x86, param3); } } if( res == LET_UN || res == LET_AS ) { if( is_variable(param1) ) { target_x86_add_local_var(target_x86, param1); } if( is_variable(param2) ) { target_x86_add_local_var(target_x86, param2); } } } if( strncmp(line, "end_function", 12) == 0 ) { break; } } }
/***********************************************************************//** * @brief Print column information * * @param[in] chatter Chattiness (defaults to NORMAL). * @return String containing column information. * * @todo Format and cfitsio information is mainly for debugging. This could * vanish in a more stable version of the code, or it could be compiled-in * conditionally using a debug option. Alternatively, a higher chatter level * may be required to see this information. ***************************************************************************/ std::string GFitsTableCol::print(const GChatter& chatter) const { // Initialise result string std::string result; // Continue only if chatter is not silent if (chatter != SILENT) { // Append formatted column name. Optionally add units if (unit().length() > 0) { result.append(gammalib::parformat(name()+" ("+unit()+")")); } else { result.append(gammalib::parformat(name())); } // Append column number. This will be "-" if the column does not exist // in the FITS file. if (m_colnum > 0) { result.append(gammalib::right(gammalib::str(m_colnum),4)+" "); } else { result.append(gammalib::right("[-]",4)+" "); } // Append loading information if (is_loaded()) { result.append("[loaded] "); } else { result.append("[not loaded] "); } // Append format information result.append("["+tform_binary()+","+ascii_format()+"]"); // Append dimensions (if available) if (!dim().empty()) { // Build TDIM string std::string value = "("+gammalib::str(dim()[0]); for (int k = 1; k < dim().size(); ++k) { value += ","+gammalib::str(dim()[k]); } value += ")"; // Append result.append(" "+value); } // Append cfitsio information if (is_variable()) { result.append(" repeat=" + gammalib::str(repeat())); result.append(" width=" + gammalib::str(width())); result.append(" number=" + gammalib::str(number())); result.append(" length=" + gammalib::str(length())); result.append(" size=" + gammalib::str(m_size)); result.append(" varlen="); if (m_varlen > 0) { result.append(gammalib::str(m_varlen)); } else { result.append("undetermined"); } } else { result.append(" repeat=" + gammalib::str(repeat())); result.append(" width=" + gammalib::str(width())); result.append(" number=" + gammalib::str(number())); result.append(" length=" + gammalib::str(length())); result.append(" size=" + gammalib::str(m_size)); } } // endif: chatter was not silent // Compile option: print content #if defined(G_PRINT_CONTENT) if (chatter != SILENT) { // Fetch data if necessary if (!is_loaded()) fetch_data(); // Loop over all rows for (int row = 0; row < length(); ++row) { result.append("\n"); if (is_variable()) { result.append("start="); result.append(gammalib::str(m_rowstart[row])); result.append(":"); } for (int inx = 0; inx < elements(row); ++inx) { result.append(" "+string(row, inx)); } } if (is_variable()) { result.append("\nend="); result.append(gammalib::str(m_rowstart[length()])); } } #endif // Return result return result; }
void *cli_docmd (char *commandline, void *data) { int largc=0; char **largv; ItemT *titem = items; void *ret=data; cli_calllevel++; if (cli_precmd) cli_precmd (commandline); if (!inited) { init_cli (); titem = items; inited = 1; } largv=argv_tokenize(commandline); if(largv)largc=argc_of_argv(largv); if((!largc) || largv[0][0]=='\0' ){ free(largv); return ret; } while (titem) { if (!strcmp (largv[0], titem->name)) { if (is_command (titem)) { ret=titem->func (largc,largv, data); if (cli_postcmd) cli_postcmd (commandline); cli_calllevel--; free(largv); return ret; } else if (is_variable (titem)) { if (largc==1) { if (titem->string) { cli_outfunf ("%s\t[%s]\t- %s\n", titem->name, titem->string, titem->usage); } else if (titem->integer) { cli_outfunf ("%s\t[%i]\t- %s\n", titem->name, *titem->integer, titem->usage); } else { cli_outfunf ("%s\tis a broken variable\n", titem->name); } } else { if (titem->integer) *titem->integer = atoi (largv[1]); if (titem->string) strcpy (titem->string, largv[1]); if (titem->func) ret=titem->func (largc,largv, data); } if (cli_postcmd) cli_postcmd (commandline); cli_calllevel--; free(largv); return ret; } } titem = titem->next; } if(cli_unknown) cli_unknown(1,&commandline,data); if (cli_postcmd) cli_postcmd (commandline); cli_calllevel--; free(largv); return ret; }
bool Grammar::is_actor(const std::string& str) { return is_connection(str) || is_context(str) || is_type(str) || is_variable(str); }
int op_let_bin_math(target_x86_t *target_x86, char *str_dst, char *str_src_a, char *str_src_b, char *op) { char line[STR_LINE_SIZE]; var_t *var; if( is_variable(str_src_a) ) { var_t *var; var = target_x86_get_var(target_x86, str_src_a); str_src_a = var->addr; } if( is_variable(str_src_b) ) { var_t *var; var = target_x86_get_var(target_x86, str_src_b); str_src_b = var->addr; } var = target_x86_get_var(target_x86, str_dst); str_dst = var->addr; sprintf(line, "mov eax, %s", str_src_a); add_line(target_x86, TARGET_TEXT, line); sprintf(line, "mov ebx, %s", str_src_b); add_line(target_x86, TARGET_TEXT, line); if( strcmp(op, "+") == 0 ) { add_line(target_x86, TARGET_TEXT, "add eax, ebx"); } if( strcmp(op, "-") == 0 ) { add_line(target_x86, TARGET_TEXT, "sub eax, ebx"); } if( strcmp(op, "*") == 0 ) { add_line(target_x86, TARGET_TEXT, "imul ebx"); } if( strcmp(op, "/") == 0 ) { add_line(target_x86, TARGET_TEXT, "mov edx, 0"); add_line(target_x86, TARGET_TEXT, "div ebx"); } if( strcmp(op, "%") == 0 ) { add_line(target_x86, TARGET_TEXT, "mov edx, 0"); add_line(target_x86, TARGET_TEXT, "div ebx"); add_line(target_x86, TARGET_TEXT, "mov eax, edx"); } if( strcmp(op, "and") == 0 ) { add_line(target_x86, TARGET_TEXT, "mov ecx, 0"); add_line(target_x86, TARGET_TEXT, "cmp eax, 1"); sprintf(line, "jne .label_%d", target_x86->label_count); add_line(target_x86, TARGET_TEXT, line); add_line(target_x86, TARGET_TEXT, "cmp ebx, 1"); sprintf(line, "jne .label_%d", target_x86->label_count); add_line(target_x86, TARGET_TEXT, line); add_line(target_x86, TARGET_TEXT, "mov ecx, 1"); sprintf(line, ".label_%d:", target_x86->label_count); add_line(target_x86, TARGET_TEXT, line); add_line(target_x86, TARGET_TEXT, "mov eax, ecx"); target_x86->label_count++; } if( strcmp(op, "or") == 0 ) { add_line(target_x86, TARGET_TEXT, "mov ecx, 0"); add_line(target_x86, TARGET_TEXT, "cmp eax, 1"); sprintf(line, "je .label_%d", target_x86->label_count); add_line(target_x86, TARGET_TEXT, line); add_line(target_x86, TARGET_TEXT, "cmp ebx, 1"); sprintf(line, "je .label_%d", target_x86->label_count); add_line(target_x86, TARGET_TEXT, line); sprintf(line, "jmp .label_%d", target_x86->label_count+1); add_line(target_x86, TARGET_TEXT, line); sprintf(line, ".label_%d:", target_x86->label_count); add_line(target_x86, TARGET_TEXT, line); add_line(target_x86, TARGET_TEXT, "mov ecx, 1"); sprintf(line, ".label_%d:", target_x86->label_count+1); add_line(target_x86, TARGET_TEXT, line); add_line(target_x86, TARGET_TEXT, "mov eax, ecx"); target_x86->label_count += 2; } if( strcmp(op, "==") == 0 ) op_let_bin_cmp(target_x86, "je"); if( strcmp(op, "!=") == 0 ) op_let_bin_cmp(target_x86, "jne"); if( strcmp(op, ">") == 0 ) op_let_bin_cmp(target_x86, "ja"); if( strcmp(op, ">=") == 0 ) op_let_bin_cmp(target_x86, "jae"); if( strcmp(op, "<") == 0 ) op_let_bin_cmp(target_x86, "jb"); if( strcmp(op, "<=") == 0 ) op_let_bin_cmp(target_x86, "jbe"); sprintf(line, "mov %s, eax", str_dst); add_line(target_x86, TARGET_TEXT, line); return 0; }
bool Grammar::is_keyword_message_argument(const std::string& str) { return is_object_value(str) || is_namespace(str) || is_variable(str); }
/***********************************************************************//** * @brief Returns TFORM code for binary table column * * Constructs the TFORM code for a binary table column, supporting * fixed-length and variable-length column types. ***************************************************************************/ std::string GFitsTableCol::tform_binary(void) const { // Set type code string std::string typecode = ""; switch (std::abs(type())) { case __TBIT: typecode = "X"; break; case __TBYTE: typecode = "B"; break; case __TLOGICAL: typecode = "L"; break; case __TSTRING: // If there are substrings then add width of substring typecode = "A"; if (repeat() > width()) { typecode.append(gammalib::str(width())); } break; case __TUSHORT: typecode = "U"; break; case __TSHORT: typecode = "I"; break; case __TULONG: typecode = "V"; break; case __TLONG: typecode = "J"; break; case __TFLOAT: typecode = "E"; break; case __TLONGLONG: typecode = "K"; break; case __TDOUBLE: typecode = "D"; break; case __TCOMPLEX: typecode = "C"; break; case __TDBLCOMPLEX: typecode = "M"; break; default: break; } // Build TFORM code std::string tform; if (std::abs(type()) == __TSTRING) { tform.append(gammalib::str(repeat())); } else { tform.append(gammalib::str(number())); } if (is_variable()) { tform.append("P"); } tform.append(typecode); if (is_variable() && m_varlen > 0) { tform.append("("+gammalib::str(m_varlen)+")"); } // Return TFORM code return tform; }