/alps/pcitool

To get this branch, use:
bzr branch http://suren.me/webbzr/alps/pcitool

« back to all changes in this revision

Viewing changes to pcilib/unit.c

  • Committer: Suren A. Chilingaryan
  • Date: 2015-10-18 01:47:47 UTC
  • Revision ID: csa@suren.me-20151018014747-9ji2ygdhz1l9wnt5
Support properties of arbitrary type

Show diffs side-by-side

added added

removed removed

Lines of Context:
pcilib/unit.c
35
35
 
36
36
        // ToDo: Check if exists...
37
37
    for (i = 0; i < n; i++) {
 
38
        pcilib_unit_t unit = pcilib_find_unit_by_name(ctx, desc[i].name);
 
39
        if (unit != PCILIB_UNIT_INVALID) {
 
40
            pcilib_clean_units(ctx, ctx->num_units);
 
41
            pcilib_error("Unit %s is already defined in the model", desc[i].name);
 
42
            return PCILIB_ERROR_EXIST;
 
43
        }
 
44
 
38
45
        pcilib_unit_context_t *unit_ctx = (pcilib_unit_context_t*)malloc(sizeof(pcilib_unit_context_t));
39
46
        if (!unit_ctx) {
40
 
            err = PCILIB_ERROR_MEMORY;
41
 
            break;
 
47
            pcilib_clean_units(ctx, ctx->num_units);
 
48
            return PCILIB_ERROR_MEMORY;
42
49
        }
 
50
 
43
51
        memset(unit_ctx, 0, sizeof(pcilib_unit_context_t));
44
52
        unit_ctx->unit = ctx->num_units + i;
45
53
        unit_ctx->name = desc[i].name;
48
56
        memcpy(ctx->units + ctx->num_units + i, &desc[i], sizeof(pcilib_unit_description_t));
49
57
    }
50
58
 
51
 
    memset(ctx->units + ctx->num_units + i, 0, sizeof(pcilib_unit_description_t));
52
 
    ctx->num_units += i;
 
59
    ctx->num_units += n;
 
60
    memset(ctx->units + ctx->num_units, 0, sizeof(pcilib_unit_description_t));
53
61
 
54
62
    return err;
55
63
}
56
64
 
57
 
void pcilib_clean_units(pcilib_t *ctx) {
 
65
void pcilib_clean_units(pcilib_t *ctx, pcilib_unit_t start) {
58
66
    pcilib_unit_context_t *s, *tmp;
59
67
 
60
68
    if (ctx->unit_hash) {
61
69
        HASH_ITER(hh, ctx->unit_hash, s, tmp) {
62
 
            HASH_DEL(ctx->unit_hash, s);
63
 
            free(s);
 
70
            if (s->unit >= start) {
 
71
                HASH_DEL(ctx->unit_hash, s);
 
72
                free(s);
 
73
            }
64
74
        }
65
75
    }
66
76
 
67
 
    memset(ctx->units, 0, sizeof(pcilib_unit_description_t));
68
 
    ctx->num_units = 0;
 
77
    memset(&ctx->units[start], 0, sizeof(pcilib_unit_description_t));
 
78
    ctx->num_units = start;
69
79
}
70
80
 
71
81
pcilib_unit_t pcilib_find_unit_by_name(pcilib_t *ctx, const char *name) {
105
115
    return NULL;
106
116
}
107
117
 
108
 
int pcilib_transform_unit(pcilib_t *ctx, pcilib_unit_transform_t *trans, pcilib_value_t *value) {
 
118
int pcilib_transform_unit(pcilib_t *ctx, const pcilib_unit_transform_t *trans, pcilib_value_t *value) {
109
119
    int err;
110
120
 
111
 
    err = pcilib_py_eval_string(ctx, trans->transform, value);
112
 
    if (err) return err;
113
 
 
114
 
    value->unit = trans->unit;
 
121
    if (trans->transform) {
 
122
        err = pcilib_py_eval_string(ctx, trans->transform, value);
 
123
        if (err) return err;
 
124
 
 
125
        value->unit = trans->unit;
 
126
    } else if (trans->unit) {
 
127
        value->unit = trans->unit;
 
128
    } 
 
129
 
115
130
    return 0;
116
131
}
117
132