pbc/array.c at master · konfan/pbc · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include "pbc.h"
#include "array.h"
#include "alloc.h"

#include <stdlib.h>
#include <string.h>

struct array {
	int number;
	union _pbc_var * a;
};

#define INNER_FIELD ((PBC_ARRAY_CAP - sizeof(struct array)) / sizeof(pbc_var))

void
_pbcA_open(pbc_array _array) {
	struct array * a = (struct array *)_array;
	a->number = 0;
	a->a = (union _pbc_var *)(a+1);
}

void
_pbcA_close(pbc_array _array) {
	struct array * a = (struct array *)_array;
	if (a->a != NULL && (union _pbc_var *)(a+1) != a->a) {
		free(a->a);
		a->a = NULL;
	}
}

void
_pbcA_push(pbc_array _array, pbc_var var) {
	struct array * a = (struct array *)_array;
	if (a->number >= INNER_FIELD) {
		if (a->number == INNER_FIELD) {
			int cap = 1;
			while (cap <= a->number + 1)
				cap *= 2;
			union _pbc_var * outer = malloc(cap * sizeof(union _pbc_var));
			memcpy(outer , a->a , INNER_FIELD * sizeof(pbc_var));
			a->a = outer;
		} else {
			int size=a->number;
			if (((size + 1) ^ size) > size) {
			   a->a=realloc(a->a,sizeof(union _pbc_var) * (size+1) * 2);
			}
		}
	}
	a->a[a->number] = *var;
	++ a->number;
}

void
_pbcA_index(pbc_array _array, int idx, pbc_var var)
{
	struct array * a = (struct array *)_array;
	var[0] = a->a[idx];
}

void *
_pbcA_index_p(pbc_array _array, int idx)
{
	struct array * a = (struct array *)_array;
	return &(a->a[idx]);
}

int
pbc_array_size(pbc_array _array) {
	struct array * a = (struct array *)_array;
	return a->number;
}

uint32_t
pbc_array_integer(pbc_array array, int index, uint32_t *hi) {
	pbc_var var;
	_pbcA_index(array , index , var);
	if (hi) {
		*hi = var->integer.hi;
	}
	return var->integer.low;
}

double
pbc_array_real(pbc_array array, int index) {
	pbc_var var;
	_pbcA_index(array , index , var);
	return var->real;
}

struct pbc_slice *
pbc_array_slice(pbc_array _array, int index) {
	struct array * a = (struct array *)_array;
	if (index <0 || index > a->number) {
		return NULL;
	}
	return (struct pbc_slice *) &(a->a[index]);
}

void
pbc_array_push_integer(pbc_array array, uint32_t low, uint32_t hi) {
	pbc_var var;
	var->integer.low = low;
	var->integer.hi = hi;
	_pbcA_push(array,var);
}

void
pbc_array_push_slice(pbc_array array, struct pbc_slice *s) {
	pbc_var var;
	var->m = *s;
	_pbcA_push(array,var);
}

void
pbc_array_push_real(pbc_array array, double v) {
	pbc_var var;
	var->real = v;
	_pbcA_push(array,var);
}