示例#1
0
文件: xmlsup.c 项目: if13b063/ITP6
/** @brief Parse all events.
 *
 * @param cur Pointer to the \<events\> node. */
static void parser_events(xmlNodePtr cur)
{
    xmlChar *name;
    int repeats;
    tupleinfo *dest=NULL;
    int n;

    while(cur!=NULL) {
        if(!xmlStrcmp(cur->name, XMLCHAR "event")) {
            name=parser_getprop_str(cur, XMLCHAR "name");

            repeats=parser_getprop_int(cur, XMLCHAR "repeats");
            if (repeats<=0) INVPROP("repeats", cur);

            for(n=0; n<repeats; n++) {
                dest=tuple_new(CHAR name);
                if(dest==NULL) {
                    fatal(_("Can't allocate memory"));
                }

                parser_event(cur, dest);
            }

            parser_newprop_int(cur, XMLCHAR "tupleid",
                               dest->tupleid-repeats+1);

            xmlFree(name);
        }
        cur=cur->next;
    }
}
示例#2
0
extern Tuple *tuple_join(Tuple *l, Tuple *r, int lpos[], int rpos[], int len)
{
    Value res[len];
    for (int i = 0; i < len; ++i)
        res[i] = rpos[i] < 0 ? tuple_attr(l, lpos[i]) : tuple_attr(r, rpos[i]);

    return tuple_new(res, len);
}
示例#3
0
static int
blackhole_space_execute_replace(struct space *space, struct txn *txn,
				struct request *request, struct tuple **result)
{
	struct txn_stmt *stmt = txn_current_stmt(txn);
	stmt->new_tuple = tuple_new(space->format, request->tuple,
				    request->tuple_end);
	if (stmt->new_tuple == NULL)
		return -1;
	tuple_ref(stmt->new_tuple);
	*result = stmt->new_tuple;
	return 0;
}
示例#4
0
void zpl_add_parameter(const char* def)
{
   const char* warning =
      "--- Warning 175: Illegal syntax for command line define \"%s\" -- ignored\n";
   Set*    set;
   Symbol* sym;
   Numb*   numb;
   Tuple*  tuple;
   Entry*  entry;
   char*   name;
   char*   value;

   assert(def != NULL);
   
   name  = strdup(def);
   value = strchr(name, '=');
   
   if (value == NULL)
   {
      fprintf(stderr, warning, def);
      free(name);
      return;
   }
   *value = '\0';
   value++;

   if (strlen(name) == 0 || strlen(value) == 0 || !is_valid_identifier(name))
   {
      if (verbose > VERB_QUIET)
         fprintf(stderr, warning, def);
      free(name);
      return;
   }
   set   = set_pseudo_new();
   sym   = symbol_new(str_new(name), SYM_ERR, set, 1, ENTRY_NULL);
   tuple = tuple_new(0);   

   if (!numb_is_number(value))
      entry = entry_new_strg(tuple, str_new(value));
   else
   {
      numb  = numb_new_ascii(value);
      entry = entry_new_numb(tuple, numb);
      numb_free(numb);
   }
   symbol_add_entry(sym, entry);
   
   tuple_free(tuple);
   set_free(set); 
   free(name); 
}
示例#5
0
extern Value tuple_attr(Tuple *t, int pos)
{
    void *mem = t;
    Value res = {.size = t->v.size[pos], .data = mem + t->v.off[pos]};
    return res;
}

extern Tuple *tuple_reord(Tuple *t, int pos[], int len)
{
    Value res[len];
    for (int i = 0; i < len; ++i)
        res[i] = tuple_attr(t, pos[i]);

    return tuple_new(res, len);
}
示例#6
0
void blokenv_call(STATE, cpu c, OBJECT self, int num_args) {
  OBJECT t1, t2, t3;
  int j;

  c->blockargs = num_args;

  t3 = tuple_new(state, num_args);
  for(j = 0; j < num_args; j++) {
    t1 = stack_pop();
    tuple_put(state, t3, j, t1);
  }
  stack_push(t3);

  cpu_flush_sp(c);
  t2 = cpu_create_block_context(state, c, self, c->sp);
  cpu_activate_context(state, c, t2, blokenv_get_home(self), 1);

}
示例#7
0
static void test_attr()
{
    Head *h = gen_head();

    int i = 1; char *s = "string_1";
    Value vals[2];
    vals[0] = val_new_int(&i);
    vals[1] = val_new_str(s);
    Tuple *t = tuple_new(vals, 2);

    int pos;
    Type type;
    head_attr(h, "c", &pos, &type);
    Expr *e = expr_eq(expr_str("string_1"), expr_attr(pos, type));

    if (expr_bool_val(e, t, NULL) == 0)
        fail();

    expr_free(e);
    tuple_free(t);
    mem_free(h);
}
示例#8
0
static PyObject *
tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    PyObject *tmp, *newobj, *item;
    Py_ssize_t i, n;

    assert(PyType_IsSubtype(type, &PyTuple_Type));
    tmp = tuple_new(&PyTuple_Type, args, kwds);
    if (tmp == NULL)
        return NULL;
    assert(PyTuple_Check(tmp));
    newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));
    if (newobj == NULL)
        return NULL;
    for (i = 0; i < n; i++) {
        item = PyTuple_GET_ITEM(tmp, i);
        Py_INCREF(item);
        PyTuple_SET_ITEM(newobj, i, item);
    }
    Py_DECREF(tmp);
    return newobj;
}
示例#9
0
static void test_compound()
{
    char *names[] = {"a", "b", "c"};
    Type types[] = {Int, Real, String};

    int a, b, c;
    Type ta, tb, tc;
    Head *h = head_new(names, types, 3);
    head_attr(h, "a", &a, &ta);
    head_attr(h, "b", &b, &tb);
    head_attr(h, "c", &c, &tc);

    int v_int = 3;
    double v_real = 1.01;
    char *v_str = "bbb";

    Value vals[3];
    vals[0] = val_new_int(&v_int);
    vals[1] = val_new_real(&v_real);
    vals[2] = val_new_str(v_str);
    Tuple *t = tuple_new(vals, 3);

    Expr *expr = expr_or(expr_gt(expr_attr(b, Real),
                                 expr_real(4.00)),
                         expr_lt(expr_attr(a, Int),
                                 expr_int(2)));
    expr = expr_or(expr,
                   expr_lt(expr_attr(c, String),
                           expr_str("aab")));

    if (expr_bool_val(expr, t, NULL))
        fail();

    expr_free(expr);
    tuple_free(t);
    mem_free(h);
}
示例#10
0
static void xspf_add_file (xmlNode * track, const gchar * filename, const gchar
 * base, Index * filenames, Index * tuples)
{
    xmlNode *nptr;
    gchar *location = NULL;
    Tuple * tuple = NULL;

    for (nptr = track->children; nptr != NULL; nptr = nptr->next) {
        if (nptr->type == XML_ELEMENT_NODE) {
            if (!xmlStrcmp(nptr->name, (xmlChar *)"location")) {
                /* Location is a special case */
                gchar *str = (gchar *)xmlNodeGetContent(nptr);

                if (strstr (str, "://") != NULL)
                    location = str_get (str);
                else if (str[0] == '/' && base != NULL)
                {
                    const gchar * colon = strstr (base, "://");

                    if (colon != NULL)
                        location = str_printf ("%.*s%s", (gint) (colon + 3 -
                         base), base, str);
                }
                else if (base != NULL)
                {
                    const gchar * slash = strrchr (base, '/');

                    if (slash != NULL)
                        location = str_printf ("%.*s%s", (gint) (slash + 1 -
                         base), base, str);
                }

                xmlFree(str);
            } else {
                /* Rest of the nodes are handled here */
                gint i;
                gboolean isMeta;
                xmlChar *findName;

                if (!xmlStrcmp(nptr->name, (xmlChar *)"meta")) {
                    isMeta = TRUE;
                    findName = xmlGetProp(nptr, (xmlChar *)"rel");
                } else {
                    isMeta = FALSE;
                    findName = xmlStrdup(nptr->name);
                }

                for (i = 0; i < xspf_nentries; i++)
                if ((xspf_entries[i].isMeta == isMeta) &&
                    !xmlStrcmp(findName, (xmlChar *)xspf_entries[i].xspfName)) {
                    xmlChar *str = xmlNodeGetContent(nptr);
                    switch (xspf_entries[i].type) {
                        case TUPLE_STRING:
                            if (! tuple)
                                tuple = tuple_new ();
                            tuple_set_str(tuple, xspf_entries[i].tupleField, NULL, (gchar *)str);
                            break;

                        case TUPLE_INT:
                            if (! tuple)
                                tuple = tuple_new ();
                            tuple_set_int(tuple, xspf_entries[i].tupleField, NULL, atol((char *)str));
                            break;

                        default:
                            break;
                    }
                    xmlFree(str);
                    break;
                }

                xmlFree(findName);
            }
        }
    }

    if (location != NULL)
    {
        if (tuple)
            tuple_set_filename (tuple, location);

        index_append(filenames, location);
        index_append(tuples, tuple);
    }
    else if (tuple)
        tuple_unref (tuple);
}
示例#11
0
/**
 * Tuple transforming function.
 *
 * Remove the fields designated by 'offset' and 'len' from an tuple,
 * and replace them with the elements of supplied data fields,
 * if any.
 *
 * Function returns newly allocated tuple.
 * It does not change any parent tuple data.
 */
static int
lbox_tuple_transform(struct lua_State *L)
{
	struct tuple *tuple = lua_checktuple(L, 1);
	int argc = lua_gettop(L);
	if (argc < 3)
		luaL_error(L, "tuple.transform(): bad arguments");
	lua_Integer offset = lua_tointeger(L, 2);  /* Can be negative and can be > INT_MAX */
	lua_Integer len = lua_tointeger(L, 3);

	lua_Integer field_count = box_tuple_field_count(tuple);
	/* validate offset and len */
	if (offset == 0) {
		luaL_error(L, "tuple.transform(): offset is out of bound");
	} else if (offset < 0) {
		if (-offset > field_count)
			luaL_error(L, "tuple.transform(): offset is out of bound");
		offset += field_count + 1;
	} else if (offset > field_count) {
		offset = field_count + 1;
	}
	if (len < 0)
		luaL_error(L, "tuple.transform(): len is negative");
	if (len > field_count + 1 - offset)
		len = field_count + 1 - offset;

	assert(offset + len <= field_count + 1);

	/*
	 * Calculate the number of operations and length of UPDATE expression
	 */
	uint32_t op_cnt = 0;
	if (offset < field_count + 1 && len > 0)
		op_cnt++;
	if (argc > 3)
		op_cnt += argc - 3;

	if (op_cnt == 0) {
		/* tuple_update() does not accept an empty operation list. */
		luaT_pushtuple(L, tuple);
		return 1;
	}

	struct ibuf *buf = tarantool_lua_ibuf;
	ibuf_reset(buf);
	struct mpstream stream;
	mpstream_init(&stream, buf, ibuf_reserve_cb, ibuf_alloc_cb,
		      luamp_error, L);

	/*
	 * Prepare UPDATE expression
	 */
	mpstream_encode_array(&stream, op_cnt);
	if (len > 0) {
		mpstream_encode_array(&stream, 3);
		mpstream_encode_str(&stream, "#");
		mpstream_encode_uint(&stream, offset);
		mpstream_encode_uint(&stream, len);
	}

	for (int i = argc ; i > 3; i--) {
		mpstream_encode_array(&stream, 3);
		mpstream_encode_str(&stream, "!");
		mpstream_encode_uint(&stream, offset);
		luamp_encode(L, luaL_msgpack_default, &stream, i);
	}
	mpstream_flush(&stream);

	uint32_t new_size = 0, bsize;
	const char *old_data = tuple_data_range(tuple, &bsize);
	struct region *region = &fiber()->gc;
	size_t used = region_used(region);
	struct tuple *new_tuple = NULL;
	/*
	 * Can't use box_tuple_update() since transform must reset
	 * the tuple format to default. The new tuple most likely
	 * won't coerce into the original space format, so we have
	 * to use the default one with no restrictions on field
	 * count or types.
	 */
	const char *new_data = tuple_update_execute(region_aligned_alloc_cb,
						    region, buf->buf,
						    buf->buf + ibuf_used(buf),
						    old_data, old_data + bsize,
						    &new_size, 1, NULL);
	if (new_data != NULL)
		new_tuple = tuple_new(box_tuple_format_default(),
				      new_data, new_data + new_size);
	region_truncate(region, used);

	if (new_tuple == NULL)
		luaT_error(L);

	luaT_pushtuple(L, new_tuple);
	ibuf_reset(buf);
	return 1;
}
示例#12
0
int main()
{
    res.defi = -1;
    res.defd = -0.999;
    res.defl = -123;
    res.add_int = 0;
    res.add_real = 0.0;
    res.add_long = 0;

    int ints[MAX];
    double reals[MAX];
    long long longs[MAX];
    Value val_ints[MAX];
    Value val_reals[MAX];
    Value val_longs[MAX];

    Tuple *tuples[MAX];

    for (int i = 0; i < MAX; ++i) {
        ints[i] = i + 1;
        reals[i] = i + 0.5;
        longs[i] = 0x7000ffffffffffff;

        val_ints[i] = val_new_int(&ints[i]);
        val_reals[i] = val_new_real(&reals[i]);
        val_longs[i] = val_new_long(&longs[i]);

        if (i == 0 || ints[i] > res.max_int)
            res.max_int = ints[i];
        if (i == 0 || reals[i] > res.max_real)
            res.max_real = reals[i];
        if (i == 0 || longs[i] > res.max_long)
            res.max_long = longs[i];

        if (i == 0 || ints[i] < res.min_int)
            res.min_int = ints[i];
        if (i == 0 || reals[1] < res.min_real)
            res.min_real = reals[i];
        if (i == 0 || longs[i] < res.min_long)
            res.min_long = longs[i];

        res.add_int += ints[i];
        res.add_real += reals[i];
        res.add_long += longs[i];
    }

    res.avg_int = (double) res.add_int / MAX;
    res.avg_real = res.add_real / MAX;
    res.avg_long = (double) res.add_long / MAX;

    Value vals[3];
    for (int i = 0; i < MAX; ++i) {
        vals[0] = val_ints[i];
        vals[1] = val_reals[i];
        vals[2] = val_longs[i];

        tuples[i] = tuple_new(vals, 3);
    }

    test_cnt(tuples);
    test_min(tuples);
    test_max(tuples);
    test_avg(tuples);
    test_add(tuples);

    for (int i = 0; i < MAX; ++i)
        tuple_free(tuples[i]);

    return 0;
}