// 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++;
}
