// Validate a result string bool validate_vmgahp_result_string(const char *result_string) { StringList result_list(result_string, " "); if( result_list.isEmpty() ) { return false; } // Format: <req_id> 0 <result1> .. // Format: <req_id> 1 <result1> .. if(result_list.number() < 3 ) { return false; } char *arg = NULL; result_list.rewind(); // first arg must be digit arg = result_list.next(); if( !arg || !verify_digit_arg(arg)) { vmprintf(D_ALWAYS, "First arg in result must be digit: %s\n", result_string); return false; } // second arg must be either 0 or 1 arg = result_list.next(); if( !arg || ( strcmp(arg, "0") && strcmp(arg, "1") ) ) { vmprintf(D_ALWAYS, "Second arg in result must be either 0 or 1: %s\n", result_string); return false; } return true; }
void cls_op::do_process(const tuple_ptr tup, int) { pre_process_hook(tup); std::vector<double> coordinates = std::vector<double>(m_value_d); for (int i = 0; i < m_value_d; i++) coordinates[i] = to_double((*tup)[i]); long timestamp = to_long(tup->op_arrival_time()); std::vector<cls_snapshot_microcluster*> *smc = m_clustream->process(coordinates, timestamp); if (smc != NULL) { cls_lbgu *lbgu = new cls_lbgu(smc, m_value_k); lbgu->start(); std::vector<cls_cluster*> result = lbgu->get_clusters(); std::vector<std::pair<int, cls_cluster*> > result_list(0); for (int i = 0; i < m_value_k; i++) result_list.push_back(std::pair<int, cls_cluster*>(i, result[i])); m_id++; if (m_first_output_done) { m_new_list = sort_clusters(m_old_list, result_list); m_difference = calculate_difference(m_old_list, m_new_list); } else { m_new_list = result_list; m_difference = result_list; m_first_output_done = true; } std::vector<std::pair<int, cls_cluster*> > output_list; if (m_output_version == 0) output_list = m_new_list; else if (m_output_version == 1) output_list = m_difference; else output_list = m_new_list; for (int i = 0; i < (int) output_list.size(); i++) { std::vector<boost::any> data(2 + m_value_d); data[0] = m_id; data[1] = output_list[i].first; for (int j = 0; j < m_value_d; j++) data[j+2] = output_list[i].second->get_coordinate(j); tuple_ptr n_tuple(new tuple(data)); publish_new(n_tuple); } m_old_list = m_new_list; } }
//========================================================================= scx::ScriptRef* SQLiteQuery::script_op(const scx::ScriptAuth& auth, const scx::ScriptRef& ref, const scx::ScriptOp& op, const scx::ScriptRef* right) { if (op.type() == scx::ScriptOp::Lookup) { const std::string name = right->object()->get_string(); if (name == "exec" || name == "next_result") { return new scx::ScriptMethodRef(ref,name); } if (name == "error") return scx::ScriptString::new_ref(m_error_string); if (name == "result") return result(); if (name == "result_list") return result_list(); if (name == "insert_id") return scx::ScriptInt::new_ref(insert_id()); } return scx::ScriptObject::script_op(auth,ref,op,right); }
// extract the n-th field string from string result. // field_num starts from 1. // For example, if result_string is "10 0 internal_error", // field_num = 1 will return "10"; // field_num = 2 will return "0"; // field_num = 3 will return "internal_error" MyString parse_result_string( const char *result_string, int field_num) { StringList result_list(result_string, " "); if( result_list.isEmpty() ) { return ""; } if( field_num > result_list.number() ) { return ""; } char *arg = NULL; int field = 0; result_list.rewind(); while( (arg = result_list.next()) != NULL ) { field++; if( field == field_num ) { return arg; } } return ""; }
static PyObject * archpy_disassemble (PyObject *self, PyObject *args, PyObject *kw) { static char *keywords[] = { "start_pc", "end_pc", "count", NULL }; CORE_ADDR start, end = 0; CORE_ADDR pc; gdb_py_ulongest start_temp; long count = 0, i; PyObject *end_obj = NULL, *count_obj = NULL; struct gdbarch *gdbarch = NULL; ARCHPY_REQUIRE_VALID (self, gdbarch); if (!PyArg_ParseTupleAndKeywords (args, kw, GDB_PY_LLU_ARG "|OO", keywords, &start_temp, &end_obj, &count_obj)) return NULL; start = start_temp; if (end_obj) { /* Make a long logic check first. In Python 3.x, internally, all integers are represented as longs. In Python 2.x, there is still a differentiation internally between a PyInt and a PyLong. Explicitly do this long check conversion first. In GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has to be done first to ensure we do not lose information in the conversion process. */ if (PyLong_Check (end_obj)) end = PyLong_AsUnsignedLongLong (end_obj); #if PY_MAJOR_VERSION == 2 else if (PyInt_Check (end_obj)) /* If the end_pc value is specified without a trailing 'L', end_obj will be an integer and not a long integer. */ end = PyInt_AsLong (end_obj); #endif else { PyErr_SetString (PyExc_TypeError, _("Argument 'end_pc' should be a (long) integer.")); return NULL; } if (end < start) { PyErr_SetString (PyExc_ValueError, _("Argument 'end_pc' should be greater than or " "equal to the argument 'start_pc'.")); return NULL; } } if (count_obj) { count = PyInt_AsLong (count_obj); if (PyErr_Occurred () || count < 0) { PyErr_SetString (PyExc_TypeError, _("Argument 'count' should be an non-negative " "integer.")); return NULL; } } gdbpy_ref<> result_list (PyList_New (0)); if (result_list == NULL) return NULL; for (pc = start, i = 0; /* All args are specified. */ (end_obj && count_obj && pc <= end && i < count) /* end_pc is specified, but no count. */ || (end_obj && count_obj == NULL && pc <= end) /* end_pc is not specified, but a count is. */ || (end_obj == NULL && count_obj && i < count) /* Both end_pc and count are not specified. */ || (end_obj == NULL && count_obj == NULL && pc == start);) { int insn_len = 0; gdbpy_ref<> insn_dict (PyDict_New ()); if (insn_dict == NULL) return NULL; if (PyList_Append (result_list.get (), insn_dict.get ())) return NULL; /* PyList_Append Sets the exception. */ string_file stb; TRY { insn_len = gdb_print_insn (gdbarch, pc, &stb, NULL); } CATCH (except, RETURN_MASK_ALL) { gdbpy_convert_exception (except); return NULL; } END_CATCH if (PyDict_SetItemString (insn_dict.get (), "addr", gdb_py_long_from_ulongest (pc)) || PyDict_SetItemString (insn_dict.get (), "asm", PyString_FromString (!stb.empty () ? stb.c_str () : "<unknown>")) || PyDict_SetItemString (insn_dict.get (), "length", PyInt_FromLong (insn_len))) return NULL; pc += insn_len; i++; }