Exemple #1
0
void hlt_classifier_add(hlt_classifier* c, hlt_classifier_field** fields, int64_t priority, const hlt_type_info* vtype, void* value, hlt_exception** excpt, hlt_execution_context* ctx)
{
    if ( c->compiled ) {
        hlt_set_exception(excpt, &hlt_exception_value_error, 0, ctx);
        return;
    }

    hlt_classifier_rule* r = hlt_malloc(sizeof(hlt_classifier_rule));
    r->priority = priority;
    r->fields = fields;
    r->value = _to_voidp(vtype, value);
    GC_CCTOR_GENERIC(r->value, vtype, ctx);

    if ( c->num_rules >= c->max_rules ) {
        // Grow rule array.
        int64_t old_max_rules = c->max_rules;
        c->max_rules = (old_max_rules ? (int)(old_max_rules * 1.5) : 5);
        c->rules = (hlt_classifier_rule**) hlt_realloc(c->rules, c->max_rules * sizeof(hlt_classifier_rule), old_max_rules * sizeof(hlt_classifier_rule));
    }

    c->rules[c->num_rules++] = r;

    if ( priority > c->max_prio )
        c->max_prio = priority;

#ifdef DEBUG
    DBG_LOG("hilti-classifier", "%s: new rule %p with priority %d for classifier %p", "classifier_add", r, priority, c);
    dbg_print_fields(c, "classifier_add", fields);
#endif
}
Exemple #2
0
void __hlt_memory_nullbuffer_add(__hlt_memory_nullbuffer* nbuf, const hlt_type_info* ti, void* obj,
                                 hlt_execution_context* ctx)
{
    int64_t nbpos = _nullbuffer_index(nbuf, obj);

    if ( nbuf->flush_pos >= 0 ) {
        // We're flushing.

        if ( nbpos == nbuf->flush_pos )
            // Deleting this right now.
            return;

        if ( nbpos > nbuf->flush_pos )
            // In the buffer, and still getting there.
            return;

// Either not yet in the buffer, or we passed it already. Delete
// directly, we must not further modify the nullbuffer while flushing.

#ifdef DEBUG
        __hlt_gchdr* hdr = (__hlt_gchdr*)obj;
        assert(hdr->ref_cnt <= 0);
        _UNUSED(hdr);
#endif

        if ( ti->obj_dtor )
            (*(ti->obj_dtor))(ti, obj, ctx);

        if ( nbpos >= 0 )
            // Just to be safe.
            nbuf->objs[nbpos].obj = 0;

        __hlt_free(obj, ti->tag, "nullbuffer_add (during flush)");
        return;
    }

    if ( nbpos >= 0 )
        // Already in the buffer.
        return;

#ifdef DEBUG
    __hlt_gchdr* hdr = (__hlt_gchdr*)obj;
    _dbg_mem_gc("nullbuffer_add", ti, hdr, "", 0, ctx);
#endif

    if ( nbuf->used >= nbuf->allocated ) {
        size_t nsize = (nbuf->allocated * 2);
        nbuf->objs =
            (struct __obj_with_rtti*)hlt_realloc(nbuf->objs, sizeof(struct __obj_with_rtti) * nsize,
                                                 sizeof(struct __obj_with_rtti) * nbuf->allocated);
        nbuf->allocated = nsize;
    }

    struct __obj_with_rtti x;
    x.ti = ti;
    x.obj = obj;
    nbuf->objs[nbuf->used++] = x;

#ifdef DEBUG
    ++__hlt_globals()->num_nullbuffer;

    if ( nbuf->used > __hlt_globals()->max_nullbuffer )
        // Not thread-safe, but doesn't matter.
        __hlt_globals()->max_nullbuffer = nbuf->used;
#endif
}