void test_array()
{
printf("test array\n");
Array* array = new_array(10);
Blob* data0 = new_blob(1,2,3,4);
Blob* data1 = new_blob(2,3,4,5);
Blob* data2 = new_blob(3,4,5,6);
Blob* data3 = new_blob(1,2,3,4);
Blob* data4 = new_blob(2,3,4,5);
Blob* data5 = new_blob(3,4,5,6);
Blob* data6 = new_blob(1,2,3,4);
Blob* data7 = new_blob(2,3,4,5);
Blob* data8 = new_blob(3,4,5,6);
Blob* data9 = new_blob(1,2,3,4);
Blob* data10 = new_blob(2,3,4,5);
Blob* data11 = new_blob(3,4,5,6);
array_push(array, data0 , del_blob);
array_push(array, data1 , del_blob);
array_push(array, data2 , del_blob);
array_push(array, data3 , del_blob);
array_push(array, data4 , del_blob);
array_push(array, data5 , del_blob);
array_push(array, data6 , del_blob);
array_push(array, data7 , del_blob);
array_push(array, data8 , del_blob);
array_push(array, data9 , del_blob);
array_push(array, data10, del_blob);
array_push(array, data11, del_blob);
array_print(array);
int32_t length = array->length, i;
Element* element = array->elements;
for (i = 0; i < length; ++i)
{
blob_print(element->data, false);
element ++;
printf("--------------------\n");
}
array_clear(array);
array_print(array);
del_array(array);
}
void array_load(
ARRAY A,
size_t cnt)
{
CELL *cells ; /* storage for A[1..cnt] */
size_t i ; /* index into cells[] */
if (A->type != AY_SPLIT || A->limit < (unsigned) cnt) {
array_clear(A) ;
A->limit = (unsigned) ( (cnt & (size_t) ~3) + 4 ) ;
A->ptr = zmalloc(A->limit*sizeof(CELL)) ;
A->type = AY_SPLIT ;
}
else
{
for(i=0; (unsigned) i < A->size; i++)
cell_destroy((CELL*)A->ptr + i) ;
}
cells = (CELL*) A->ptr ;
A->size = cnt ;
if (cnt > MAX_SPLIT) {
SPLIT_OV *p = split_ov_list ;
SPLIT_OV *q ;
split_ov_list = (SPLIT_OV*) 0 ;
i = MAX_SPLIT ;
while( p ) {
cells[i].type = C_MBSTRN ;
cells[i].ptr = (PTR) p->sval ;
q = p ;
p = q->link ;
ZFREE(q) ;
i++ ;
}
cnt = MAX_SPLIT ;
}
for(i=0; i < cnt; i++) {
cells[i].type = C_MBSTRN ;
cells[i].ptr = split_buff[i] ;
}
}
void dgemm_sparse_upper(hbmat_t* A, hbmat_t* B, hbmat_t* C){
/*
* Check if the input matrix has properly set
*/
if ( A->vptr == NULL )
hyper_sym_csr_task2(A);
// if ( B->vptr == NULL )
// hyper_sym_csr_task1(B);
if ( C->vptr == NULL )
hyper_sym_csr_task2(C);
int m = B->m; int n = B->n;
int* vptr = B->vptr; int* vpos = B->vpos; double* vval = B->vval;
int* vptr_c = C->vptr; int* vpos_c = C->vpos; double* vval_c = C->vval;
int col_pos, row_pos;
double* peelb = malloc(m*sizeof(double));
double* peelc = malloc(m*sizeof(double));
char* trans = "N";
int i;
for ( i = 0; i < m; i++ ) {
array_clear(peelb, m);
array_s2d(A, peelb, i);
mkl_cspblas_dcsrgemv(trans, &m, vval, vptr, vpos, peelb, peelc);
int k;
for ( k = vptr_c[i]; k < vptr_c[i+1]; k++ ) {
col_pos = vpos_c[k];
vval_c[k] -= peelc[col_pos];
}
}
free(peelb); free(peelc);
}
static int imapc_mailbox_commit_delayed_expunges(struct imapc_mailbox *mbox)
{
struct mail_index_view *view = imapc_mailbox_get_sync_view(mbox);
struct mail_index_transaction *trans;
struct seq_range_iter iter;
unsigned int n;
uint32_t lseq, uid;
int ret;
trans = mail_index_transaction_begin(view,
MAIL_INDEX_TRANSACTION_FLAG_EXTERNAL);
seq_range_array_iter_init(&iter, &mbox->delayed_expunged_uids); n = 0;
while (seq_range_array_iter_nth(&iter, n++, &uid)) {
if (mail_index_lookup_seq(view, uid, &lseq))
mail_index_expunge(trans, lseq);
}
array_clear(&mbox->delayed_expunged_uids);
ret = mail_index_transaction_commit(&trans);
if (ret < 0)
mailbox_set_index_error(&mbox->box);
return ret;
}
static void * Array_dtor (void * _self) {
struct Array * self = _self;
array_clear(self);
free(self -> _objects);
return self;
}
uint64_t mtl_lexer_get_token(mtl_parser_t *p) {
mtl_token_type_t prev_type = p->token.type;
p->token.type = MTL_UNKNOWN;
// Skip comment lines
while(p->fstring[p->c_index] == '#') {
p->c_index += strcspn(&p->fstring[p->c_index], "\n");
while(isspace(p->fstring[p->c_index])) p->c_index++;
}
// Skip all white spaces
while(isspace(p->fstring[p->c_index])) p->c_index++;
// Check if end of file has been reached
if(p->c_index >= p->fsize) {
p->token.type = MTL_ENDOFFILE;
return 1;
}
array_clear(p->token.lexeme);
// Read characters until the next whitespace or separator
while(!isspace(p->fstring[p->c_index])) {
char c = p->fstring[p->c_index++];
array_append(p->token.lexeme, &c);
}
size_t tok_len = array_size(p->token.lexeme);
char c = 0;
array_append(p->token.lexeme, &c);
// Get the actual data from the array
char *lexeme = (char*)array_data(p->token.lexeme);
// Check if this token is an identifier depending on the the previous token type
if(prev_type >= MTL_MAPKATAG && prev_type <= MTL_NEWMTLTAG) {
p->token.type = MTL_IDENTIFIER;
return 0;
}
// Check if the token is a tag
if(isalpha(lexeme[0])) {
// Which kind of tag
if(strcmp(lexeme, "Ns") == 0) p->token.type = MTL_NSTAG;
else if(strcmp(lexeme, "Ka") == 0) p->token.type = MTL_KATAG;
else if(strcmp(lexeme, "Kd") == 0) p->token.type = MTL_KDTAG;
else if(strcmp(lexeme, "Ks") == 0) p->token.type = MTL_KSTAG;
else if(strcmp(lexeme, "d") == 0) p->token.type = MTL_DTAG;
else if(strcmp(lexeme, "map_Ka") == 0) p->token.type = MTL_MAPKATAG;
else if(strcmp(lexeme, "map_Kd") == 0) p->token.type = MTL_MAPKDTAG;
else if(strcmp(lexeme, "map_Ks") == 0) p->token.type = MTL_MAPKSTAG;
else if(strcmp(lexeme, "map_Bump") == 0) p->token.type = MTL_MAPBUMPTAG;
else if(strcmp(lexeme, "map_d") == 0) p->token.type = MTL_MAPDTAG;
else if(strcmp(lexeme, "newmtl") == 0) p->token.type = MTL_NEWMTLTAG;
else p->token.type = MTL_ERROR;
return (p->token.type == MTL_ERROR) ? 1 : 0;
}
// Check if it is a floating point number: -?[0-9]+\.[0-9]+
if(strchr(lexeme, '.') != NULL && (lexeme[0] == '-' || isdigit(lexeme[0]))) {
p->token.type = MTL_ERROR;
// Confirm that this is a correctly formatted float
size_t index = 0;
if(lexeme[index] == '-') index++;
while(isdigit(lexeme[index++]));
// Must be a period
if(lexeme[(index-1)] != '.') return 1;
// Continue confirming digits in the decimal portion
while(isdigit(lexeme[index++]));
// If index is the number as tok_len then we have successfully confirmed a floating point number
if(--index != tok_len) return 1;
p->token.type = MTL_FLOAT;
return 0;
}
// Check if it is a uint: [0-9]+
if(isdigit(lexeme[0])) {
p->token.type = MTL_ERROR;
// Confirm that this is a correctly formatted uint
size_t index = 0;
while(isdigit(lexeme[index++]));
// If index is the same number as tok_len then we have successfully confirmed a uint
if(--index != tok_len) return 1;
p->token.type = MTL_UINT;
return 0;
}
return 0;
}
void
execute(INST * cdp, /* code ptr, start execution here */
CELL *sp, /* eval_stack pointer */
CELL *fp) /* frame ptr into eval_stack for
user defined functions */
{
/* some useful temporaries */
CELL *cp;
int t;
unsigned tu;
/* save state for array loops via a stack */
ALOOP_STATE *aloop_state = (ALOOP_STATE *) 0;
/* for moving the eval stack on deep recursion */
CELL *old_stack_base = 0;
CELL *old_sp = 0;
#ifdef DEBUG
CELL *entry_sp = sp;
#endif
int force_exit = (end_start == 0);
if (fp) {
/* we are a function call, check for deep recursion */
if (sp > stack_danger) { /* change stacks */
old_stack_base = stack_base;
old_sp = sp;
stack_base = (CELL *) zmalloc(sizeof(CELL) * EVAL_STACK_SIZE);
stack_danger = stack_base + DANGER;
sp = stack_base;
/* waste 1 slot for ANSI, actually large model msdos breaks in
RET if we don't */
#ifdef DEBUG
entry_sp = sp;
#endif
} else
old_stack_base = (CELL *) 0;
}
while (1) {
TRACE(("execute %s sp(%ld:%s)\n",
da_op_name(cdp),
(long) (sp - stack_base),
da_type_name(sp)));
switch ((cdp++)->op) {
/* HALT only used by the disassemble now ; this remains
so compilers don't offset the jump table */
case _HALT:
case _STOP: /* only for range patterns */
#ifdef DEBUG
if (sp != entry_sp + 1)
bozo("stop0");
#endif
return;
case _PUSHC:
inc_sp();
cellcpy(sp, (cdp++)->ptr);
break;
case _PUSHD:
inc_sp();
sp->type = C_DOUBLE;
sp->dval = *(double *) (cdp++)->ptr;
break;
case _PUSHS:
inc_sp();
sp->type = C_STRING;
sp->ptr = (cdp++)->ptr;
string(sp)->ref_cnt++;
break;
case F_PUSHA:
cp = (CELL *) cdp->ptr;
if (cp != field) {
if (nf < 0)
split_field0();
if (!(cp >= NF && cp <= LAST_PFIELD)) {
/* it is a real field $1, $2 ...
If it is greater than $NF, we have to
make sure it is set to "" so that
(++|--) and g?sub() work right
*/
t = field_addr_to_index(cp);
if (t > nf) {
cp->type = C_STRING;
cp->ptr = (PTR) & null_str;
null_str.ref_cnt++;
}
}
}
/* fall thru */
case _PUSHA:
case A_PUSHA:
inc_sp();
sp->ptr = (cdp++)->ptr;
break;
case _PUSHI:
/* put contents of next address on stack */
inc_sp();
cellcpy(sp, (cdp++)->ptr);
break;
case L_PUSHI:
/* put the contents of a local var on stack,
cdp->op holds the offset from the frame pointer */
inc_sp();
cellcpy(sp, fp + (cdp++)->op);
break;
case L_PUSHA:
/* put a local address on eval stack */
inc_sp();
sp->ptr = (PTR) (fp + (cdp++)->op);
break;
case F_PUSHI:
/* push contents of $i
cdp[0] holds & $i , cdp[1] holds i */
inc_sp();
if (nf < 0)
split_field0();
cp = (CELL *) cdp->ptr;
t = (cdp + 1)->op;
cdp += 2;
if (t <= nf)
cellcpy(sp, cp);
else { /* an unset field */
sp->type = C_STRING;
sp->ptr = (PTR) & null_str;
null_str.ref_cnt++;
}
break;
case NF_PUSHI:
inc_sp();
if (nf < 0)
split_field0();
cellcpy(sp, NF);
break;
case FE_PUSHA:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
tu = d_to_index(sp->dval);
if (tu && nf < 0)
split_field0();
sp->ptr = (PTR) field_ptr((int) tu);
if ((int) tu > nf) {
/* make sure it is set to "" */
cp = (CELL *) sp->ptr;
cell_destroy(cp);
cp->type = C_STRING;
cp->ptr = (PTR) & null_str;
null_str.ref_cnt++;
}
break;
case FE_PUSHI:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
tu = d_to_index(sp->dval);
if (nf < 0)
split_field0();
if ((int) tu <= nf) {
cellcpy(sp, field_ptr((int) tu));
} else {
sp->type = C_STRING;
sp->ptr = (PTR) & null_str;
null_str.ref_cnt++;
}
break;
case AE_PUSHA:
/* top of stack has an expr, cdp->ptr points at an
array, replace the expr with the cell address inside
the array */
cp = array_find((ARRAY) (cdp++)->ptr, sp, CREATE);
cell_destroy(sp);
sp->ptr = (PTR) cp;
break;
case AE_PUSHI:
/* top of stack has an expr, cdp->ptr points at an
array, replace the expr with the contents of the
cell inside the array */
cp = array_find((ARRAY) (cdp++)->ptr, sp, CREATE);
cell_destroy(sp);
cellcpy(sp, cp);
break;
case LAE_PUSHI:
/* sp[0] is an expression
cdp->op is offset from frame pointer of a CELL which
has an ARRAY in the ptr field, replace expr
with array[expr]
*/
if (fp != 0) {
cp = array_find((ARRAY) fp[(cdp++)->op].ptr, sp, CREATE);
cell_destroy(sp);
cellcpy(sp, cp);
}
break;
case LAE_PUSHA:
/* sp[0] is an expression
cdp->op is offset from frame pointer of a CELL which
has an ARRAY in the ptr field, replace expr
with & array[expr]
*/
if (fp != 0) {
cp = array_find((ARRAY) fp[(cdp++)->op].ptr, sp, CREATE);
cell_destroy(sp);
sp->ptr = (PTR) cp;
}
break;
case LA_PUSHA:
/* cdp->op is offset from frame pointer of a CELL which
has an ARRAY in the ptr field. Push this ARRAY
on the eval stack
*/
if (fp != 0) {
inc_sp();
sp->ptr = fp[(cdp++)->op].ptr;
}
break;
case SET_ALOOP:
{
ALOOP_STATE *ap = ZMALLOC(ALOOP_STATE);
size_t vector_size;
ap->var = (CELL *) sp[-1].ptr;
ap->base = ap->ptr = array_loop_vector((ARRAY) sp->ptr, &vector_size);
ap->limit = ap->base + vector_size;
sp -= 2;
/* push onto aloop stack */
ap->link = aloop_state;
aloop_state = ap;
cdp += cdp->op;
}
break;
case ALOOP:
{
ALOOP_STATE *ap = aloop_state;
if (ap != 0 && (ap->ptr < ap->limit)) {
cell_destroy(ap->var);
ap->var->type = C_STRING;
ap->var->ptr = (PTR) * ap->ptr++;
cdp += cdp->op;
} else {
cdp++;
}
}
break;
case POP_AL:
{
/* finish up an array loop */
ALOOP_STATE *ap = aloop_state;
if (ap != 0) {
aloop_state = ap->link;
while (ap->ptr < ap->limit) {
free_STRING(*ap->ptr);
ap->ptr++;
}
if (ap->base < ap->limit) {
zfree(ap->base,
((unsigned) (ap->limit - ap->base)
* sizeof(STRING *)));
}
ZFREE(ap);
}
}
break;
case _POP:
cell_destroy(sp);
sp--;
break;
case _ASSIGN:
/* top of stack has an expr, next down is an
address, put the expression in *address and
replace the address with the expression */
/* don't propagate type C_MBSTRN */
if (sp->type == C_MBSTRN)
check_strnum(sp);
sp--;
cell_destroy(((CELL *) sp->ptr));
cellcpy(sp, cellcpy(sp->ptr, sp + 1));
cell_destroy(sp + 1);
break;
case F_ASSIGN:
/* assign to a field */
if (sp->type == C_MBSTRN)
check_strnum(sp);
sp--;
field_assign((CELL *) sp->ptr, sp + 1);
cell_destroy(sp + 1);
cellcpy(sp, (CELL *) sp->ptr);
break;
case _ADD_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
#ifdef SW_FP_CHECK /* specific to V7 and XNX23A */
clrerr();
#endif
cp->dval += (sp--)->dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
sp->type = C_DOUBLE;
sp->dval = cp->dval;
break;
case _SUB_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
#ifdef SW_FP_CHECK
clrerr();
#endif
cp->dval -= (sp--)->dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
sp->type = C_DOUBLE;
sp->dval = cp->dval;
break;
case _MUL_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
#ifdef SW_FP_CHECK
clrerr();
#endif
cp->dval *= (sp--)->dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
sp->type = C_DOUBLE;
sp->dval = cp->dval;
break;
case _DIV_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
#ifdef NOINFO_SIGFPE
CHECK_DIVZERO(sp->dval);
#endif
#ifdef SW_FP_CHECK
clrerr();
#endif
cp->dval /= (sp--)->dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
sp->type = C_DOUBLE;
sp->dval = cp->dval;
break;
case _MOD_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
#ifdef NOINFO_SIGFPE
CHECK_DIVZERO(sp->dval);
#endif
cp->dval = fmod(cp->dval, (sp--)->dval);
sp->type = C_DOUBLE;
sp->dval = cp->dval;
break;
case _POW_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
cp->dval = pow(cp->dval, (sp--)->dval);
sp->type = C_DOUBLE;
sp->dval = cp->dval;
break;
/* will anyone ever use these ? */
case F_ADD_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
cast1_to_d(cellcpy(&tc, cp));
#ifdef SW_FP_CHECK
clrerr();
#endif
tc.dval += (sp--)->dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
sp->type = C_DOUBLE;
sp->dval = tc.dval;
field_assign(cp, &tc);
break;
case F_SUB_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
cast1_to_d(cellcpy(&tc, cp));
#ifdef SW_FP_CHECK
clrerr();
#endif
tc.dval -= (sp--)->dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
sp->type = C_DOUBLE;
sp->dval = tc.dval;
field_assign(cp, &tc);
break;
case F_MUL_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
cast1_to_d(cellcpy(&tc, cp));
#ifdef SW_FP_CHECK
clrerr();
#endif
tc.dval *= (sp--)->dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
sp->type = C_DOUBLE;
sp->dval = tc.dval;
field_assign(cp, &tc);
break;
case F_DIV_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
cast1_to_d(cellcpy(&tc, cp));
#ifdef NOINFO_SIGFPE
CHECK_DIVZERO(sp->dval);
#endif
#ifdef SW_FP_CHECK
clrerr();
#endif
tc.dval /= (sp--)->dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
sp->type = C_DOUBLE;
sp->dval = tc.dval;
field_assign(cp, &tc);
break;
case F_MOD_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
cast1_to_d(cellcpy(&tc, cp));
#ifdef NOINFO_SIGFPE
CHECK_DIVZERO(sp->dval);
#endif
tc.dval = fmod(tc.dval, (sp--)->dval);
sp->type = C_DOUBLE;
sp->dval = tc.dval;
field_assign(cp, &tc);
break;
case F_POW_ASG:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
cp = (CELL *) (sp - 1)->ptr;
cast1_to_d(cellcpy(&tc, cp));
tc.dval = pow(tc.dval, (sp--)->dval);
sp->type = C_DOUBLE;
sp->dval = tc.dval;
field_assign(cp, &tc);
break;
case _ADD:
sp--;
if (TEST2(sp) != TWO_DOUBLES)
cast2_to_d(sp);
#ifdef SW_FP_CHECK
clrerr();
#endif
sp[0].dval += sp[1].dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
break;
case _SUB:
sp--;
if (TEST2(sp) != TWO_DOUBLES)
cast2_to_d(sp);
#ifdef SW_FP_CHECK
clrerr();
#endif
sp[0].dval -= sp[1].dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
break;
case _MUL:
sp--;
if (TEST2(sp) != TWO_DOUBLES)
cast2_to_d(sp);
#ifdef SW_FP_CHECK
clrerr();
#endif
sp[0].dval *= sp[1].dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
break;
case _DIV:
sp--;
if (TEST2(sp) != TWO_DOUBLES)
cast2_to_d(sp);
#ifdef NOINFO_SIGFPE
CHECK_DIVZERO(sp[1].dval);
#endif
#ifdef SW_FP_CHECK
clrerr();
#endif
sp[0].dval /= sp[1].dval;
#ifdef SW_FP_CHECK
fpcheck();
#endif
break;
case _MOD:
sp--;
if (TEST2(sp) != TWO_DOUBLES)
cast2_to_d(sp);
#ifdef NOINFO_SIGFPE
CHECK_DIVZERO(sp[1].dval);
#endif
sp[0].dval = fmod(sp[0].dval, sp[1].dval);
break;
case _POW:
sp--;
if (TEST2(sp) != TWO_DOUBLES)
cast2_to_d(sp);
sp[0].dval = pow(sp[0].dval, sp[1].dval);
break;
case _NOT:
/* evaluates to 0.0 or 1.0 */
reswitch_1:
switch (sp->type) {
case C_NOINIT:
sp->dval = 1.0;
break;
case C_DOUBLE:
sp->dval = sp->dval != 0.0 ? 0.0 : 1.0;
break;
case C_FIELDWIDTHS:
case C_STRING:
sp->dval = string(sp)->len ? 0.0 : 1.0;
free_STRING(string(sp));
break;
case C_STRNUM: /* test as a number */
sp->dval = sp->dval != 0.0 ? 0.0 : 1.0;
free_STRING(string(sp));
break;
case C_MBSTRN:
check_strnum(sp);
goto reswitch_1;
default:
bozo("bad type on eval stack");
}
sp->type = C_DOUBLE;
break;
case _TEST:
/* evaluates to 0.0 or 1.0 */
reswitch_2:
switch (sp->type) {
case C_NOINIT:
sp->dval = 0.0;
break;
case C_DOUBLE:
sp->dval = sp->dval != 0.0 ? 1.0 : 0.0;
break;
case C_FIELDWIDTHS:
case C_STRING:
sp->dval = string(sp)->len ? 1.0 : 0.0;
free_STRING(string(sp));
break;
case C_STRNUM: /* test as a number */
sp->dval = sp->dval != 0.0 ? 1.0 : 0.0;
free_STRING(string(sp));
break;
case C_MBSTRN:
check_strnum(sp);
goto reswitch_2;
default:
bozo("bad type on eval stack");
}
sp->type = C_DOUBLE;
break;
case _UMINUS:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
sp->dval = -sp->dval;
break;
case _UPLUS:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
break;
case _CAT:
{
size_t len1, len2;
char *str1, *str2;
STRING *b;
sp--;
if (TEST2(sp) != TWO_STRINGS)
cast2_to_s(sp);
str1 = string(sp)->str;
len1 = string(sp)->len;
str2 = string(sp + 1)->str;
len2 = string(sp + 1)->len;
b = new_STRING0(len1 + len2);
memcpy(b->str, str1, len1);
memcpy(b->str + len1, str2, len2);
free_STRING(string(sp));
free_STRING(string(sp + 1));
sp->ptr = (PTR) b;
break;
}
case _PUSHINT:
inc_sp();
sp->type = (short) (cdp++)->op;
break;
case _BUILTIN:
case _PRINT:
sp = (*(PF_CP) (cdp++)->ptr) (sp);
break;
case _POST_INC:
cp = (CELL *) sp->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
sp->type = C_DOUBLE;
sp->dval = cp->dval;
cp->dval += 1.0;
break;
case _POST_DEC:
cp = (CELL *) sp->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
sp->type = C_DOUBLE;
sp->dval = cp->dval;
cp->dval -= 1.0;
break;
case _PRE_INC:
cp = (CELL *) sp->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
sp->dval = cp->dval += 1.0;
sp->type = C_DOUBLE;
break;
case _PRE_DEC:
cp = (CELL *) sp->ptr;
if (cp->type != C_DOUBLE)
cast1_to_d(cp);
sp->dval = cp->dval -= 1.0;
sp->type = C_DOUBLE;
break;
case F_POST_INC:
cp = (CELL *) sp->ptr;
cellcpy(&tc, cp);
cast1_to_d(&tc);
sp->type = C_DOUBLE;
sp->dval = tc.dval;
tc.dval += 1.0;
field_assign(cp, &tc);
break;
case F_POST_DEC:
cp = (CELL *) sp->ptr;
cellcpy(&tc, cp);
cast1_to_d(&tc);
sp->type = C_DOUBLE;
sp->dval = tc.dval;
tc.dval -= 1.0;
field_assign(cp, &tc);
break;
case F_PRE_INC:
cp = (CELL *) sp->ptr;
cast1_to_d(cellcpy(sp, cp));
sp->dval += 1.0;
field_assign(cp, sp);
break;
case F_PRE_DEC:
cp = (CELL *) sp->ptr;
cast1_to_d(cellcpy(sp, cp));
sp->dval -= 1.0;
field_assign(cp, sp);
break;
case _JMP:
cdp += cdp->op;
break;
case _JNZ:
/* jmp if top of stack is non-zero and pop stack */
if (test(sp))
cdp += cdp->op;
else
cdp++;
cell_destroy(sp);
sp--;
break;
case _JZ:
/* jmp if top of stack is zero and pop stack */
if (!test(sp))
cdp += cdp->op;
else
cdp++;
cell_destroy(sp);
sp--;
break;
case _LJZ:
/* special jump for logical and */
/* this is always preceded by _TEST */
if (sp->dval == 0.0) {
/* take jump, but don't pop stack */
cdp += cdp->op;
} else {
/* pop and don't jump */
sp--;
cdp++;
}
break;
case _LJNZ:
/* special jump for logical or */
/* this is always preceded by _TEST */
if (sp->dval != 0.0) {
/* take jump, but don't pop stack */
cdp += cdp->op;
} else {
/* pop and don't jump */
sp--;
cdp++;
}
break;
/* the relation operations */
/* compare() makes sure string ref counts are OK */
case _EQ:
t = compare(--sp);
sp->type = C_DOUBLE;
sp->dval = t == 0 ? 1.0 : 0.0;
break;
case _NEQ:
t = compare(--sp);
sp->type = C_DOUBLE;
sp->dval = t ? 1.0 : 0.0;
break;
case _LT:
t = compare(--sp);
sp->type = C_DOUBLE;
sp->dval = t < 0 ? 1.0 : 0.0;
break;
case _LTE:
t = compare(--sp);
sp->type = C_DOUBLE;
sp->dval = t <= 0 ? 1.0 : 0.0;
break;
case _GT:
t = compare(--sp);
sp->type = C_DOUBLE;
sp->dval = t > 0 ? 1.0 : 0.0;
break;
case _GTE:
t = compare(--sp);
sp->type = C_DOUBLE;
sp->dval = t >= 0 ? 1.0 : 0.0;
break;
case _MATCH0:
/* does $0 match, the RE at cdp? */
inc_sp();
if (field->type >= C_STRING) {
sp->type = C_DOUBLE;
sp->dval = (REtest(string(field)->str,
string(field)->len,
cast_to_re((cdp++)->ptr))
? 1.0
: 0.0);
break /* the case */ ;
} else {
cellcpy(sp, field);
/* and FALL THRU */
}
case _MATCH1:
/* does expr at sp[0] match RE at cdp */
if (sp->type < C_STRING)
cast1_to_s(sp);
t = REtest(string(sp)->str,
string(sp)->len,
cast_to_re((cdp++)->ptr));
free_STRING(string(sp));
sp->type = C_DOUBLE;
sp->dval = t ? 1.0 : 0.0;
break;
case _MATCH2:
/* does sp[-1] match sp[0] as re */
cast_to_RE(sp);
if ((--sp)->type < C_STRING)
cast1_to_s(sp);
t = REtest(string(sp)->str,
string(sp)->len,
cast_to_re((sp + 1)->ptr));
free_STRING(string(sp));
no_leaks_re_ptr((sp + 1)->ptr);
sp->type = C_DOUBLE;
sp->dval = t ? 1.0 : 0.0;
break;
case A_LENGTH:
sp--;
sp->type = C_DOUBLE;
sp->dval = (double) (((ARRAY) ((sp + 0)->ptr))->size);
break;
case A_TEST:
/* entry : sp[0].ptr-> an array
sp[-1] is an expression
we compute (expression in array) */
sp--;
cp = array_find((sp + 1)->ptr, sp, NO_CREATE);
cell_destroy(sp);
sp->type = C_DOUBLE;
sp->dval = (cp != (CELL *) 0) ? 1.0 : 0.0;
break;
case A_DEL:
/* sp[0].ptr -> array
sp[-1] is an expr
delete array[expr] */
array_delete(sp->ptr, sp - 1);
cell_destroy(sp - 1);
sp -= 2;
break;
case DEL_A:
/* free all the array at once */
array_clear(sp->ptr);
sp--;
break;
/* form a multiple array index */
case A_CAT:
sp = array_cat(sp, (cdp++)->op);
break;
case _EXIT:
if (sp->type != C_DOUBLE)
cast1_to_d(sp);
exit_code = d_to_i(sp->dval);
sp--;
/* fall thru */
case _EXIT0:
if (force_exit)
mawk_exit(exit_code);
cdp = end_start;
force_exit = 1; /* makes sure next exit exits */
if (begin_start) {
free_codes("BEGIN", begin_start, begin_size);
begin_start = 0;
begin_size = 0;
}
if (main_start) {
free_codes("MAIN", main_start, main_size);
main_start = 0;
main_size = 0;
}
sp = eval_stack - 1; /* might be in user function */
CLEAR_ALOOP_STACK(); /* ditto */
break;
case _JMAIN: /* go from BEGIN code to MAIN code */
free_codes("BEGIN", begin_start, begin_size);
begin_start = 0;
begin_size = 0;
cdp = main_start;
break;
case _OMAIN:
if (!main_fin)
open_main();
restart_label = cdp;
cdp = next_label;
break;
case _NEXT:
/* next might be inside an aloop -- clear stack */
CLEAR_ALOOP_STACK();
cdp = next_label;
break;
case _NEXTFILE:
/* nextfile might be inside an aloop -- clear stack */
CLEAR_ALOOP_STACK();
FINsemi_close(main_fin);
cdp = next_label;
break;
case OL_GL:
{
char *p;
size_t len;
if (!(p = FINgets(main_fin, &len))) {
if (force_exit)
mawk_exit(0);
cdp = end_start;
zfree(main_start, main_size);
main_start = (INST *) 0;
force_exit = 1;
} else {
set_field0(p, len);
cdp = restart_label;
rt_nr++;
rt_fnr++;
}
}
break;
/* two kinds of OL_GL is a historical stupidity from working on
a machine with very slow floating point emulation */
case OL_GL_NR:
{
char *p;
size_t len;
if (!(p = FINgets(main_fin, &len))) {
if (force_exit)
mawk_exit(0);
cdp = end_start;
zfree(main_start, main_size);
main_start = (INST *) 0;
force_exit = 1;
} else {
set_field0(p, len);
cdp = restart_label;
if (TEST2(NR) != TWO_DOUBLES)
cast2_to_d(NR);
NR->dval += 1.0;
rt_nr++;
FNR->dval += 1.0;
rt_fnr++;
}
}
break;
case _RANGE:
/* test a range pattern: pat1, pat2 { action }
entry :
cdp[0].op -- a flag, test pat1 if on else pat2
cdp[1].op -- offset of pat2 code from cdp
cdp[2].op -- offset of action code from cdp
cdp[3].op -- offset of code after the action from cdp
cdp[4] -- start of pat1 code
*/
#define FLAG cdp[0].op
#define PAT2 cdp[1].op
#define ACTION cdp[2].op
#define FOLLOW cdp[3].op
#define PAT1 4
if (FLAG) /* test against pat1 */
{
execute(cdp + PAT1, sp, fp);
t = test(sp + 1);
cell_destroy(sp + 1);
if (t)
FLAG = 0;
else {
cdp += FOLLOW;
break; /* break the switch */
}
}
/* test against pat2 and then perform the action */
execute(cdp + PAT2, sp, fp);
FLAG = test(sp + 1);
cell_destroy(sp + 1);
cdp += ACTION;
break;
/* function calls */
case _RET0:
inc_sp();
sp->type = C_NOINIT;
/* fall thru */
case _RET:
#ifdef DEBUG
if (sp != entry_sp + 1)
bozo("ret");
#endif
if (old_stack_base) /* reset stack */
{
/* move the return value */
cellcpy(old_sp + 1, sp);
cell_destroy(sp);
zfree(stack_base, sizeof(CELL) * EVAL_STACK_SIZE);
stack_base = old_stack_base;
stack_danger = old_stack_base + DANGER;
}
/* return might be inside an aloop -- clear stack */
CLEAR_ALOOP_STACK();
return;
case _CALL:
/* cdp[0] holds ptr to "function block"
cdp[1] holds number of input arguments
*/
{
FBLOCK *fbp = (FBLOCK *) (cdp++)->ptr;
int a_args = (cdp++)->op; /* actual number of args */
CELL *nfp = sp - a_args + 1; /* new fp for callee */
CELL *local_p = sp + 1; /* first local argument on stack */
char *type_p = 0; /* pts to type of an argument */
if (fbp->nargs)
type_p = fbp->typev + a_args - 1;
/* create space for locals */
t = fbp->nargs - a_args; /* t is number of locals */
while (t > 0) {
t--;
sp++;
type_p++;
sp->type = C_NOINIT;
if ((type_p) != 0 && (*type_p == ST_LOCAL_ARRAY))
sp->ptr = (PTR) new_ARRAY();
}
execute(fbp->code, sp, nfp);
/* cleanup the callee's arguments */
/* putting return value at top of eval stack */
if ((type_p != 0) && (sp >= nfp)) {
cp = sp + 1; /* cp -> the function return */
do {
if (*type_p == ST_LOCAL_ARRAY) {
if (sp >= local_p) {
array_clear(sp->ptr);
ZFREE((ARRAY) sp->ptr);
}
} else {
cell_destroy(sp);
}
type_p--;
sp--;
}
while (sp >= nfp);
cellcpy(++sp, cp);
cell_destroy(cp);
} else
sp++; /* no arguments passed */
}
break;
default:
bozo("bad opcode");
}
}
}
void index_sync_changes_reset(struct index_sync_changes_context *ctx)
{
array_clear(&ctx->syncs);
memset(&ctx->sync_rec, 0, sizeof(ctx->sync_rec));
}
void font_deinit()
{
array_clear(s_fontCtx.fonts);
}
static void maildir_keywords_clear(struct maildir_keywords *mk)
{
array_clear(&mk->list);
hash_table_clear(mk->hash, TRUE);
p_clear(mk->pool);
}
int mail_index_map_parse_keywords(struct mail_index_map *map)
{
struct mail_index *index = map->index;
const struct mail_index_ext *ext;
const struct mail_index_keyword_header *kw_hdr;
const struct mail_index_keyword_header_rec *kw_rec;
const char *name;
unsigned int i, name_area_end_offset, old_count;
uint32_t idx;
if (!mail_index_map_lookup_ext(map, MAIL_INDEX_EXT_KEYWORDS, &idx)) {
if (array_is_created(&map->keyword_idx_map))
array_clear(&map->keyword_idx_map);
return 0;
}
ext = array_idx(&map->extensions, idx);
/* Extension header contains:
- struct mail_index_keyword_header
- struct mail_index_keyword_header_rec * keywords_count
- const char names[] * keywords_count
*/
i_assert(ext->hdr_offset < map->hdr.header_size);
kw_hdr = CONST_PTR_OFFSET(map->hdr_base, ext->hdr_offset);
kw_rec = (const void *)(kw_hdr + 1);
name = (const char *)(kw_rec + kw_hdr->keywords_count);
old_count = !array_is_created(&map->keyword_idx_map) ? 0 :
array_count(&map->keyword_idx_map);
/* Keywords can only be added into same mapping. Removing requires a
new mapping (recreating the index file) */
if (kw_hdr->keywords_count == old_count) {
/* nothing changed */
return 0;
}
/* make sure the header is valid */
if (kw_hdr->keywords_count < old_count) {
mail_index_set_error(index, "Corrupted index file %s: "
"Keywords removed unexpectedly",
index->filepath);
return -1;
}
if ((size_t)(name - (const char *)kw_hdr) > ext->hdr_size) {
mail_index_set_error(index, "Corrupted index file %s: "
"keywords_count larger than header size",
index->filepath);
return -1;
}
name_area_end_offset = (const char *)kw_hdr + ext->hdr_size - name;
for (i = 0; i < kw_hdr->keywords_count; i++) {
if (kw_rec[i].name_offset > name_area_end_offset) {
mail_index_set_error(index, "Corrupted index file %s: "
"name_offset points outside allocated header",
index->filepath);
return -1;
}
}
if (name[name_area_end_offset-1] != '\0') {
mail_index_set_error(index, "Corrupted index file %s: "
"Keyword header doesn't end with NUL",
index->filepath);
return -1;
}
/* create file -> index mapping */
if (!array_is_created(&map->keyword_idx_map))
i_array_init(&map->keyword_idx_map, kw_hdr->keywords_count);
#ifdef DEBUG
/* Check that existing headers are still the same. It's behind DEBUG
since it's pretty useless waste of CPU normally. */
for (i = 0; i < array_count(&map->keyword_idx_map); i++) {
const char *keyword = name + kw_rec[i].name_offset;
const unsigned int *old_idx;
unsigned int kw_idx;
old_idx = array_idx(&map->keyword_idx_map, i);
if (!mail_index_keyword_lookup(index, keyword, &kw_idx) ||
kw_idx != *old_idx) {
mail_index_set_error(index, "Corrupted index file %s: "
"Keywords changed unexpectedly",
index->filepath);
return -1;
}
}
#endif
/* Register the newly seen keywords */
i = array_count(&map->keyword_idx_map);
for (; i < kw_hdr->keywords_count; i++) {
const char *keyword = name + kw_rec[i].name_offset;
unsigned int kw_idx;
if (*keyword == '\0') {
mail_index_set_error(index, "Corrupted index file %s: "
"Empty keyword name in header",
index->filepath);
return -1;
}
mail_index_keyword_lookup_or_create(index, keyword, &kw_idx);
array_append(&map->keyword_idx_map, &kw_idx, 1);
}
return 0;
}
bool mesh_load(mesh_t *mesh, const char *objfile) {
// Initialize the parser struct
obj_parser_t p;
if(obj_parser_init(&p, objfile) != 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not load mesh: %s\n", objfile);
return false;
}
// Initialize the arrays.
mesh->vattributes = array_create(256, 3*sizeof(GLfloat));
mesh->indices = array_create(256, sizeof(GLuint));
mesh->mtl_grps = array_create(2, sizeof(material_group_t));
// Grab the vertex attribute data and place them in separate arrays
array_t *uv = array_create(256, 3*sizeof(GLfloat));
array_t *normals = array_create(256, 3*sizeof(GLfloat));
array_t *mtllib = array_create(16, sizeof(char));
for(; p.token.type != OBJ_ENDOFFILE; obj_lexer_get_token(&p)) {
switch(p.token.type) {
case OBJ_VNTAG:
// Parse the vertex normals
obj_parser_vntag(&p, normals);
break;
case OBJ_VTTAG:
// Parse the vertex texture coordinates
obj_parser_vttag(&p, uv);
break;
case OBJ_VTAG:
// Parse the vertex position coordinates
obj_parser_vtag(&p, mesh->vattributes);
// Now append zero vectors for the normal and texture coordinate attributes
// The z value is initially set to -10.0f to indicate that the attribute is currently empty
GLfloat u[3] = {0.0f, 0.0f, -10.0f};
array_append(mesh->vattributes, &u);
array_append(mesh->vattributes, &u);
break;
case OBJ_MTLLIBTAG:
// Parse the name of the mtllib file
obj_parser_mtllibtag(&p, mtllib);
// Get the mtllib filename
array_prepend_str(mtllib, "resources/");
break;
default:
break;
}
}
// If a mtllib file was specified, parse it
array_t *mtl_list = array_create(2, sizeof(material_def_t));
if(array_size(mtllib) > 0) _mesh_load_material(mesh, array_data(mtllib), mtl_list);
array_t *i_positions = array_create(4, sizeof(GLuint));
array_t *i_texcoords = array_create(4, sizeof(GLuint));
array_t *i_normals = array_create(4, sizeof(GLuint));
// Parse the indices as they are read in and place the vertex attributes in the correct index in the vertex attribute array
for(p.c_index = 0, p.token.type = OBJ_UNKNOWN; p.token.type != OBJ_ENDOFFILE; obj_lexer_get_token(&p)) {
switch(p.token.type) {
case OBJ_FTAG:
{
// Parse the face indices
array_clear(i_positions);
array_clear(i_texcoords);
array_clear(i_normals);
obj_parser_ftag(&p, i_positions, i_texcoords, i_normals);
mesh->num_faces++;
// Create a material group if none exist
// We might have obj files with only one group of faces and no materials
if(array_size(mesh->mtl_grps) == 0) _mesh_create_material_group(mesh);
// Add the indices to the last material group in the list
material_group_t *grp = (material_group_t*)array_back(mesh->mtl_grps);
// For each vertex attribute specified, add them to the material group's indices list duplicating the attribute if necessary
for(uint64_t i = 0; i < 3; ++i) {
// Indices start from 1 in the Wavefront OBJ format
// Get all the indices for the each vertex attributes
GLuint index = *((GLuint*)array_at(i_positions, i))-1;
GLuint v_index = (array_size(i_texcoords) > 0) ? *((GLuint*)array_at(i_texcoords, i)) : 0;
GLuint n_index = (array_size(i_normals) > 0) ? *((GLuint*)array_at(i_normals, i)) : 0;
GLfloat v[3] = {0.0f, 0.0f, 0.0f};
GLfloat n[3] = {0.0f, 0.0f, 0.0f};
bool duplicate = false;
// Make sure the texture coordinate was specified
if(v_index != 0) {
v_index--;
memcpy(v, array_at(uv, v_index), 3*sizeof(GLfloat));
// Check if the vertex needs to be duplicated, if the texture coordinates are different for the same vertex
GLfloat *u = array_at(mesh->vattributes, index*3+1);
if((u[2] != -10.0f)&& (u[0] != v[0] || u[1] != v[1])) duplicate = true;
}
// Make sure a normal was specified
if(n_index != 0) {
n_index--;
memcpy(n, array_at(normals, n_index), 3*sizeof(GLfloat));
// Check if the vertex needs to be duplicated, if the normals are different for the same vertex
GLfloat *u = array_at(mesh->vattributes, index*3+2);
if((u[2] != -10.0f) && (u[0] != n[0] || u[1] != n[1] || u[2] != n[2])) duplicate = true;
}
// Duplicate the vertex attribute if needed
if(duplicate) {
GLfloat l[3] = {0.0f, 0.0f, 0.0f};
memcpy(l, array_at(mesh->vattributes, index*3), 3*sizeof(GLfloat));
array_append(mesh->vattributes, l);
index = ((GLuint)array_size(mesh->vattributes)-1)/3;
array_append(mesh->vattributes, v);
array_append(mesh->vattributes, n);
} else {
// Set the texture coordinate and normal in the vertex attribute array
array_set(mesh->vattributes, index*3+1, v);
array_set(mesh->vattributes, index*3+2, n);
}
// Append the index into the index array
array_append(mesh->indices, &index);
}
// Increment the count of indices for the material group
grp->count += 3;
break;
}
case OBJ_USEMTLTAG:
{
array_t *mtl_name = array_create(8, sizeof(char));
obj_parser_usemtltag(&p, mtl_name);
// Start a new material group using this material
_mesh_create_material_group(mesh);
// Load the material data for the material group
// Have to find the material with the specified material name in the material definition list
bool found_mtl = false;
for(uint64_t i = 0; i < array_size(mtl_list); i++) {
material_def_t *mtl_def = array_at(mtl_list, i);
if(strcmp((char*)array_data(mtl_def->mtl_name), (char*)array_data(mtl_name)) == 0) {
material_group_t *grp = (material_group_t*)array_back(mesh->mtl_grps);
// Copy the material data
memcpy(&grp->mtl, &mtl_def->mtl, sizeof(material_t));
found_mtl = true;
break;
}
}
if(!found_mtl) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not find material: \'%s\'\n", (char*)array_data(mtl_name));
}
array_delete(mtl_name);
break;
}
default:
break;
}
}
// Cleanup temp arrays
array_delete(uv);
array_delete(normals);
array_delete(mtllib);
array_delete(i_positions);
array_delete(i_texcoords);
array_delete(i_normals);
// Cleanup up the material definition list
for(uint64_t i = 0; i < array_size(mtl_list); i++) {
material_def_t *mtl_def = (material_def_t*)array_at(mtl_list, i);
array_delete(mtl_def->mtl_name);
}
array_delete(mtl_list);
// Delete the parser struct
obj_parser_free(&p);
// Generate and fill the OpenGL buffers
_mesh_gen_buffers(mesh);
// Print some stats
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Mesh loaded with %lu vertex attributes and %lu faces\n", array_size(mesh->vattributes)/3, mesh->num_faces);
return true;
}
void array_delete(
ARRAY A,
CELL *cp)
{
ANODE *ap ;
int redid ;
if (A->size == 0) return ;
switch(cp->type) {
case C_DOUBLE :
{
double d = cp->dval ;
Int ival = d_to_I(d) ;
if ((double)ival == d) {
if (A->type == AY_SPLIT)
{
if (ival >=1 && ival <= (int) A->size)
convert_split_array_to_table(A) ;
else return ; /* ival not in range */
}
ap = find_by_ival(A, ival, NO_CREATE, &redid) ;
if (ap) { /* remove from the front of the ilist */
DUAL_LINK *table = (DUAL_LINK*) A->ptr ;
table[(unsigned) ap->ival & A->hmask].ilink = ap->ilink ;
if (ap->sval) {
ANODE *p, *q = 0 ;
unsigned indx = (unsigned) ap->hval & A->hmask ;
p = table[indx].slink ;
while(p != ap) {
q = p ;
p = q->slink ;
}
if (q) q->slink = p->slink ;
else table[indx].slink = p->slink ;
free_STRING(ap->sval) ;
}
cell_destroy(&ap->cell) ;
ZFREE(ap) ;
if (--A->size == 0) array_clear(A) ;
}
return ;
}
else { /* get the string value */
char buff[260] ;
STRING *sval ;
sprintf(buff, string(CONVFMT)->str, d) ;
sval = new_STRING(buff) ;
ap = find_by_sval(A, sval, NO_CREATE, &redid) ;
free_STRING(sval) ;
}
}
break ;
case C_NOINIT :
ap = find_by_sval(A, &null_str, NO_CREATE, &redid) ;
break ;
default :
ap = find_by_sval(A, string(cp), NO_CREATE, &redid) ;
break ;
}
if (ap) { /* remove from the front of the slist */
DUAL_LINK *table = (DUAL_LINK*) A->ptr ;
table[ap->hval & A->hmask].slink = ap->slink ;
if (ap->ival != NOT_AN_IVALUE) {
ANODE *p, *q = 0 ;
unsigned indx = (unsigned) ap->ival & A->hmask ;
p = table[indx].ilink ;
while(p != ap) {
q = p ;
p = q->ilink ;
}
if (q) q->ilink = p->ilink ;
else table[indx].ilink = p->ilink ;
}
free_STRING(ap->sval) ;
cell_destroy(&ap->cell) ;
ZFREE(ap) ;
if (--A->size == 0) array_clear(A) ;
}
}
// The generic `main` function.
//
// Define all variables at the beginning to make the C99 compiler
// happy.
int main(int argc, char **argv) {
mpz_array s, p, out;
size_t count, i;
int c, vflg = 0, sflg = 0, rflg = 0, errflg = 0, r = 0;
char *filename = "primes.lst";
// #### argument parsing
// Boring `getopt` argument parsing.
while ((c = getopt(argc, argv, ":svr")) != -1) {
switch(c) {
case 's':
sflg++;
break;
case 'v':
vflg++;
break;
case 'r':
rflg++;
break;
case ':':
fprintf(stderr, "Option -%c requires an operand\n", optopt);
errflg++;
break;
case '?':
fprintf(stderr, "Unrecognized option: '-%c'\n", optopt);
errflg++;
}
}
if (optind < argc) {
filename = argv[optind];
if (optind + 1 < argc) errflg++;
}
if (rflg && vflg) {
fprintf(stderr, "\n\t-r and -v can't be used simultaneously!\n\n");
errflg++;
}
// Print the usage and exit if an error occurred during argument parsing.
if (errflg) {
fprintf(stderr, "usage: [-vsr] [file]\n"\
"\n\t-v be more verbose"\
"\n\t-r output the found coprimes in raw gmp format"\
"\n\t-s only check if there are coprimes"\
"\n\n");
exit(2);
}
// Print the banner.
if (vflg > 0) {
PRINT_BANNER;
}
// Load the keys.
array_init(&s, 10);
count = array_of_file(&s, filename);
if (count == 0) {
fprintf(stderr, "Can't load %s\n", filename);
return 1;
}
if (s.used != count) {
fprintf(stderr, "Array size and load count do not match\n");
return 2;
}
if (s.used == 0) {
fprintf(stderr, "No primes loaded (empty file)\n");
return 3;
}
// Print the key count.
if (vflg > 0) {
printf("%zu public keys loaded\nStarting factorization...\n", s.used);
}
// Computing a coprime base for a finite set [Algorithm 18.1](copri.html#computing-a-coprime-base-for-a-finite-set).
array_init(&p, 10);
array_cb(&p, &s);
// Check if we have found more coprime bases.
if (p.used == s.used) {
if (vflg > 0)
printf("No coprime pairs found :-(\n");
r = 1;
} else {
if (vflg > 0 || sflg > 0)
printf("Found ~%zu coprime pairs!!!\nSearching factors...\n", (p.used - s.used));
if (sflg == 0) {
array_init(&out, 9);
// Use [Algorithm 21.2](copri.html#factoring-a-set-over-a-coprime-base) to find the coprimes in the coprime base.
array_find_factors(&out, &s, &p);
// Output the factors.
if (out.used > 0) {
if ((out.used % 3) != 0) {
fprintf(stderr, "Find factors returned an invalid array\n");
} else {
if (rflg) {
for(i = 0; i < out.used; i++)
mpz_out_raw(stdout, out.array[i]);
} else {
for(i = 0; i < out.used; i+=3)
gmp_printf("\n### Found factors of\n%Zu\n=\n%Zu\nx\n%Zu\n", out.array[i], out.array[i+1], out.array[i+2]);
}
}
}
array_clear(&out);
}
}
array_clear(&p);
array_clear(&s);
return r;
}
void Service_create()
{
array_clear(s_serviceData);
}
void Service_destroy()
{
array_clear(s_serviceData);
}
int main(int argc, char **argv)
{
int forks = 1;
array_t(char*) addr_set;
array_init(addr_set);
char *keyfile = NULL;
const char *config = NULL;
char *keyfile_buf = NULL;
/* Long options. */
int c = 0, li = 0, ret = 0;
struct option opts[] = {
{"addr", required_argument, 0, 'a'},
{"config", required_argument, 0, 'c'},
{"keyfile",required_argument, 0, 'k'},
{"forks",required_argument, 0, 'f'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
while ((c = getopt_long(argc, argv, "a:c:f:k:vVh", opts, &li)) != -1) {
switch (c)
{
case 'a':
array_push(addr_set, optarg);
break;
case 'c':
config = optarg;
break;
case 'f':
g_interactive = 0;
forks = atoi(optarg);
if (forks == 0) {
kr_log_error("[system] error '-f' requires number, not '%s'\n", optarg);
return EXIT_FAILURE;
}
#if (!defined(UV_VERSION_HEX)) || (!defined(SO_REUSEPORT))
if (forks > 1) {
kr_log_error("[system] libuv 1.7+ is required for SO_REUSEPORT support, multiple forks not supported\n");
return EXIT_FAILURE;
}
#endif
break;
case 'k':
keyfile_buf = malloc(PATH_MAX);
assert(keyfile_buf);
/* Check if the path is absolute */
if (optarg[0] == '/') {
keyfile = strdup(optarg);
} else {
/* Construct absolute path, the file may not exist */
keyfile = realpath(".", keyfile_buf);
if (keyfile) {
int len = strlen(keyfile);
int namelen = strlen(optarg);
if (len + namelen < PATH_MAX - 1) {
keyfile[len] = '/';
memcpy(keyfile + len + 1, optarg, namelen + 1);
keyfile = strdup(keyfile); /* Duplicate */
} else {
keyfile = NULL; /* Invalidate */
}
}
}
free(keyfile_buf);
if (!keyfile) {
kr_log_error("[system] keyfile '%s': not writeable\n", optarg);
return EXIT_FAILURE;
}
break;
case 'v':
kr_debug_set(true);
break;
case 'V':
kr_log_info("%s, version %s\n", "Knot DNS Resolver", PACKAGE_VERSION);
return EXIT_SUCCESS;
case 'h':
case '?':
help(argc, argv);
return EXIT_SUCCESS;
default:
help(argc, argv);
return EXIT_FAILURE;
}
}
/* Switch to rundir. */
if (optind < argc) {
const char *rundir = argv[optind];
if (access(rundir, W_OK) != 0) {
kr_log_error("[system] rundir '%s': %s\n", rundir, strerror(errno));
return EXIT_FAILURE;
}
ret = chdir(rundir);
if (ret != 0) {
kr_log_error("[system] rundir '%s': %s\n", rundir, strerror(errno));
return EXIT_FAILURE;
}
if(config && access(config, R_OK) != 0) {
kr_log_error("[system] rundir '%s'\n", rundir);
kr_log_error("[system] config '%s': %s\n", config, strerror(errno));
return EXIT_FAILURE;
}
}
kr_crypto_init();
/* Fork subprocesses if requested */
int fork_count = forks;
while (--forks > 0) {
int pid = fork();
if (pid < 0) {
perror("[system] fork");
return EXIT_FAILURE;
}
/* Forked process */
if (pid == 0) {
kr_crypto_reinit();
break;
}
}
/* Block signals. */
uv_loop_t *loop = uv_default_loop();
uv_signal_t sigint, sigterm;
uv_signal_init(loop, &sigint);
uv_signal_init(loop, &sigterm);
uv_signal_start(&sigint, signal_handler, SIGINT);
uv_signal_start(&sigterm, signal_handler, SIGTERM);
/* Create a server engine. */
knot_mm_t pool = {
.ctx = mp_new (4096),
.alloc = (knot_mm_alloc_t) mp_alloc
};
struct engine engine;
ret = engine_init(&engine, &pool);
if (ret != 0) {
kr_log_error("[system] failed to initialize engine: %s\n", kr_strerror(ret));
return EXIT_FAILURE;
}
/* Create worker */
struct worker_ctx *worker = init_worker(loop, &engine, &pool, forks, fork_count);
if (!worker) {
kr_log_error("[system] not enough memory\n");
return EXIT_FAILURE;
}
/* Bind to sockets and run */
for (size_t i = 0; i < addr_set.len; ++i) {
int port = 53;
const char *addr = set_addr(addr_set.at[i], &port);
ret = network_listen(&engine.net, addr, (uint16_t)port, NET_UDP|NET_TCP);
if (ret != 0) {
kr_log_error("[system] bind to '%s#%d' %s\n", addr, port, knot_strerror(ret));
ret = EXIT_FAILURE;
}
}
/* Start the scripting engine */
if (ret == 0) {
ret = engine_start(&engine, config ? config : "config");
if (ret == 0) {
if (keyfile) {
auto_free char *cmd = afmt("trust_anchors.file = '%s'", keyfile);
if (!cmd) {
kr_log_error("[system] not enough memory\n");
return EXIT_FAILURE;
}
engine_cmd(&engine, cmd);
lua_settop(engine.L, 0);
}
/* Run the event loop */
ret = run_worker(loop, &engine);
}
}
/* Cleanup. */
array_clear(addr_set);
engine_deinit(&engine);
worker_reclaim(worker);
mp_delete(pool.ctx);
if (ret != 0) {
ret = EXIT_FAILURE;
}
kr_crypto_cleanup();
return ret;
}
uint8_t graph_threshold_chira(
graph_t *gin,
graph_t *gout,
uint32_t edgelimit,
uint32_t flags,
void *opt,
uint8_t (*init)(graph_t *g),
uint8_t (*remove)(
graph_t *g,
double *space,
array_t *edges,
graph_edge_t *edge),
uint8_t (*recalc)(
graph_t *g,
graph_edge_t *edge)
) {
uint32_t nnodes;
uint64_t i;
graph_t lgin;
array_t edges;
graph_edge_t edge;
graph_t gmod;
double *space;
double mod;
double maxmod;
uint32_t ncmps;
uint32_t *components;
maxmod = -1.0;
space = NULL;
edges.data = NULL;
gmod.neighbours = NULL;
components = NULL;
nnodes = graph_num_nodes(gin);
if (graph_copy(gin, &lgin)) goto fail;
if (stats_cache_init(&lgin)) goto fail;
if (array_create(&edges, sizeof(graph_edge_t), 10)) goto fail;
components = calloc(nnodes,sizeof(uint32_t));
if (components == NULL) goto fail;
space = calloc(nnodes,sizeof(double));
if (space == NULL) goto fail;
init(&lgin);
for (i = 0; i < edgelimit; i++) {
array_clear(&edges);
if (remove(&lgin, space, &edges, &edge)) goto fail;
/*
* modularity is calculated on the original graph, with
* the discovered components as the community structure
*/
ncmps = stats_num_components(&lgin, 0, NULL, components);
mod = stats_chira(gin, ncmps, components);
if (mod >= maxmod) {
maxmod = mod;
if (gmod.neighbours != NULL)
graph_free(&gmod);
gmod.neighbours = NULL;
if (graph_copy(&lgin, &gmod)) goto fail;
}
if (recalc(&lgin, &edge)) goto fail;
}
if (graph_copy(&gmod, gout)) goto fail;
free(space);
array_free(&edges);
return 0;
fail:
if (space != NULL) free(space);
if (edges.data != NULL) array_free(&edges);
if (gmod.neighbours != NULL) graph_free(&gmod);
if (components != NULL) free(components);
return 1;
}
static int
blast_client_handshake(blast_client_t* client) {
int isock, ssize;
socket_t** socks;
if (blast_time_elapsed_ms(client->last_send) > 10)
blast_client_send_handshake(client, client->readers[client->current]);
if (client->sock) {
socks = &client->sock;
ssize = 1;
}
else {
socks = client->socks;
ssize = array_size(client->socks);
}
for (isock = 0; isock < ssize; ++isock) {
const network_address_t* address = 0;
char packetbuffer[PACKET_DATABUF_SIZE];
size_t size = udp_socket_recvfrom(socks[isock], packetbuffer, sizeof(packetbuffer), &address);
if (size > 0) {
packet_t* packet = (packet_t*)packetbuffer;
if (packet->type == PACKET_HANDSHAKE) {
char buffer[NETWORK_ADDRESS_NUMERIC_MAX_LENGTH];
string_t addr = network_address_to_string(buffer, sizeof(buffer), address, true);
packet_handshake_t* handshake = (packet_handshake_t*)packet;
log_infof(HASH_BLAST,
STRING_CONST("Got handshake packet from %.*s (seq %d, timestamp %lld, latency %lld ms)"),
STRING_FORMAT(addr), (int)packet->seq, (tick_t)packet->timestamp,
blast_timestamp_elapsed_ms(client->begin_send, packet->timestamp));
if (!client->sock) {
client->target = address;
client->sock = client->socks[isock];
client->socks[isock] = 0;
}
if (client->state == BLAST_STATE_HANDSHAKE) {
log_infof(HASH_BLAST, STRING_CONST("Begin transfer of '%.*s' %lld bytes with token %d to %.*s"),
STRING_FORMAT(client->readers[client->current]->name), client->readers[client->current]->size,
handshake->token, STRING_FORMAT(addr));
client->token = (unsigned int)handshake->token;
client->begin_send = time_current();
client->last_send = 0;
client->seq = 0;
array_clear(client->pending);
client->state = BLAST_STATE_TRANSFER;
return 1;
}
}
else {
log_warnf(HASH_BLAST, WARNING_SUSPICIOUS,
STRING_CONST("Unknown datagram on socket in handshake state"));
}
}
}
if (client->state != BLAST_STATE_HANDSHAKE) {
for (isock = 0, ssize = array_size(client->socks); isock < ssize; ++isock) {
socket_t* sock = client->socks[isock];
socket_deallocate(sock);
}
array_deallocate(client->socks);
client->socks = 0;
}
return 1;
}
void sieve_jumplist_reset
(struct sieve_jumplist *jlist)
{
array_clear(&jlist->jumps);
}
int main(int argc, const char* argv[]) {
array_t(int) a = NULL;
test(array_size(a) == 0);
test(array_capacity(a) == 0);
array_alloc(a, 0, destructed_element_count_destructor);
test(array_size(a) == 0);
test(array_capacity(a) == 0);
array_append(a, 1);
test(array_size(a) == 1);
test(array_capacity(a) >= 1);
test(a[0] == 1);
array_append(a, 2);
test(array_size(a) == 2);
test(array_capacity(a) >= 2);
test(a[0] == 1);
test(a[1] == 2);
array_append(a, 3);
test(array_size(a) == 3);
test(array_capacity(a) >= 3);
test(a[0] == 1);
test(a[1] == 2);
test(a[2] == 3);
array_insert(a, 0, 0);
test(array_size(a) == 4);
test(array_capacity(a) >= 4);
test(a[0] == 0);
test(a[1] == 1);
test(a[2] == 2);
test(a[3] == 3);
array_reserve(a, 16);
test(array_size(a) == 4);
test(array_capacity(a) == 16);
test(a[0] == 0);
test(a[1] == 1);
test(a[2] == 2);
test(a[3] == 3);
array_shrink(a);
test(array_size(a) == 4);
test(array_capacity(a) == 4);
test(a[0] == 0);
test(a[1] == 1);
test(a[2] == 2);
test(a[3] == 3);
array_remove(a, 0);
test(array_size(a) == 3);
test(array_capacity(a) == 4);
test(a[0] == 1);
test(a[1] == 2);
test(a[2] == 3);
test(destructed_element_count == 1);
destructed_element_count = 0;
array_remove_unordered(a,0);
test(array_size(a) == 2);
test(array_capacity(a) == 4);
test(a[0] == 3);
test(a[1] == 2);
test(destructed_element_count == 1);
destructed_element_count = 0;
array_clear(a);
test(array_size(a) == 0);
test(array_capacity(a) >= 0);
test(destructed_element_count == 2);
destructed_element_count = 0;
array_append(a, 0);
array_append(a, 1);
array_append(a, 2);
test(array_size(a) == 3);
test(array_capacity(a) >= 3);
test(destructed_element_count == 0);
array_free(a);
test(a == NULL);
test(array_size(a) == 0);
test(array_capacity(a) == 0);
test(destructed_element_count == 3);
destructed_element_count = 0;
enum { TEST_LENGTH = 1024 };
array_alloc(a, 0, destructed_element_count_destructor);
for (int i = 0; i < TEST_LENGTH; ++i) {
array_append(a, i);
test(a[i] == i);
}
test(array_size(a) == TEST_LENGTH);
test(array_capacity(a) >= TEST_LENGTH);
for (int i = 0; i < TEST_LENGTH; ++i) {
test(a[i] == i);
}
{
int i = 0;
const int* const end = array_end(a);
for (int* itr = array_begin(a); itr < end; ++itr) {
test(*itr == i++);
}
}
{
int i = 0;
while (array_size(a)) {
test(a[0] == i++);
array_remove(a,0);
}
test(array_size(a) == 0);
test(array_capacity(a) >= TEST_LENGTH);
test(destructed_element_count == TEST_LENGTH);
destructed_element_count = 0;
}
array_free(a);
test(a == NULL);
test(array_size(a) == 0);
test(array_capacity(a) == 0);
array_alloc(a, 0, destructed_element_count_destructor);
for (int i = 0; i < TEST_LENGTH; ++i) {
array_insert(a, 0, i);
}
test(array_size(a) == TEST_LENGTH);
test(array_capacity(a) >= TEST_LENGTH);
for (int i = 0; i < TEST_LENGTH; ++i) {
test(a[i] == (TEST_LENGTH - 1) - i);
}
array_free(a);
test(a == NULL);
test(array_size(a) == 0);
test(array_capacity(a) == 0);
puts("array tests passed");
}
void imapc_msgmap_reset(struct imapc_msgmap *msgmap)
{
array_clear(&msgmap->uids);
msgmap->uid_next = 1;
}
void new_input_sections( void )
{
array_clear( &scn_array );
}
uint64_t obj_lexer_get_token(obj_parser_t *p) {
obj_token_type_t prev_type = p->token.type;
p->token.type = OBJ_UNKNOWN;
// Skip comment lines
while(p->fstring[p->c_index] == '#') {
p->c_index += strcspn(&p->fstring[p->c_index], "\n");
while(isspace(p->fstring[p->c_index])) p->c_index++;
}
// Skip all the white spaces and newlines
while(isspace(p->fstring[p->c_index])) p->c_index++;
// Check if end of file has been reached
if(p->c_index >= p->fsize) {
p->token.type = OBJ_ENDOFFILE;
return 1;
}
array_clear(p->token.lexeme);
// Read characters until the next whitespace or separator
while(!isspace(p->fstring[p->c_index]) && p->fstring[p->c_index] != '/') {
char c = p->fstring[p->c_index++];
array_append(p->token.lexeme, &c);
}
size_t tok_len = array_size(p->token.lexeme);
// If token length is zero, it must be the separator...right?
if(tok_len == 0) {
array_append(p->token.lexeme, &p->fstring[p->c_index++]);
tok_len++;
}
char c = 0;
array_append(p->token.lexeme, &c);
// Get the actual data from the array
char *lexeme = (char*)array_data(p->token.lexeme);
// Check if it is a separator
if(lexeme[0] == '/') {
p->token.type = OBJ_ERROR;
if(tok_len != 1) return 1;
p->token.type = OBJ_SEPARATOR;
return 0;
}
// Check if this token is an identifier depending on the previous type
if(prev_type == OBJ_MTLLIBTAG || prev_type == OBJ_USEMTLTAG) {
p->token.type = OBJ_IDENTIFIER;
return 0;
}
// Check if the token is a tag: r'vn|vt|v|f'
if(isalpha(lexeme[0])) {
// Which kind of tag?
if(strcmp(lexeme, "vn") == 0) p->token.type = OBJ_VNTAG;
else if(strcmp(lexeme, "vt") == 0) p->token.type = OBJ_VTTAG;
else if(strcmp(lexeme, "v") == 0) p->token.type = OBJ_VTAG;
else if(strcmp(lexeme, "f") == 0) p->token.type = OBJ_FTAG;
else if(strcmp(lexeme, "mtllib") == 0) p->token.type = OBJ_MTLLIBTAG;
else if(strcmp(lexeme, "usemtl") == 0) p->token.type = OBJ_USEMTLTAG;
else p->token.type = OBJ_ERROR;
return (p->token.type == OBJ_ERROR) ? 1 : 0;
}
// Check if it is a floating point number: -?[0-9]+\.[0-9]+
if(strchr(lexeme, '.') != NULL && (lexeme[0] == '-' || isdigit(lexeme[0]))) {
p->token.type = OBJ_ERROR;
// Confirm that this is a correctly formatted float
size_t index = 0;
if(lexeme[index] == '-') index++;
while(isdigit(lexeme[index++]));
// Must be a period
if(lexeme[(index-1)] != '.') return 1;
// Continue confirming digits in the decimal portion
while(isdigit(lexeme[index++]));
// If index is the number as tok_len then we have successfully confirmed a floating point number
if(--index != tok_len) return 1;
p->token.type = OBJ_FLOAT;
return 0;
}
// Check if it is a uint: [0-9]+
if(isdigit(lexeme[0])) {
p->token.type = OBJ_ERROR;
// Confirm that this is a correctly formatted uint
size_t index = 0;
while(isdigit(lexeme[index++]));
// If index is the same number as tok_len then we have successfully confirmed a uint
if(--index != tok_len) return 1;
p->token.type = OBJ_UINT;
return 0;
}
return 0;
}
void new_file_list( void )
{
array_clear( &link_array );
}
void index_mail_parse_header_init(struct index_mail *mail,
struct mailbox_header_lookup_ctx *headers)
{
struct index_mail_data *data = &mail->data;
const uint8_t *match;
unsigned int i, field_idx, match_count;
mail->header_seq = data->seq;
if (mail->header_data == NULL) {
mail->header_data = buffer_create_dynamic(default_pool, 4096);
i_array_init(&mail->header_lines, 32);
i_array_init(&mail->header_match, 32);
i_array_init(&mail->header_match_lines, 32);
mail->header_match_value = HEADER_MATCH_SKIP_COUNT;
} else {
buffer_set_used_size(mail->header_data, 0);
array_clear(&mail->header_lines);
array_clear(&mail->header_match_lines);
mail->header_match_value += HEADER_MATCH_SKIP_COUNT;
i_assert((mail->header_match_value &
(HEADER_MATCH_SKIP_COUNT-1)) == 0);
if (mail->header_match_value == 0) {
/* wrapped, we'll have to clear the buffer */
array_clear(&mail->header_match);
mail->header_match_value = HEADER_MATCH_SKIP_COUNT;
}
}
if (headers != NULL) {
for (i = 0; i < headers->count; i++) {
array_idx_set(&mail->header_match, headers->idx[i],
&mail->header_match_value);
}
}
if (data->wanted_headers != NULL && data->wanted_headers != headers) {
headers = data->wanted_headers;
for (i = 0; i < headers->count; i++) {
array_idx_set(&mail->header_match, headers->idx[i],
&mail->header_match_value);
}
}
/* register also all the other headers that exist in cache file */
T_BEGIN {
index_mail_parse_header_register_all_wanted(mail);
} T_END;
/* if we want sent date, it doesn't mean that we also want to cache
Date: header. if we have Date field's index set at this point we
know that we want it. otherwise add it and remember that we don't
want it cached. */
field_idx = get_header_field_idx(mail->mail.mail.box, "Date",
MAIL_CACHE_DECISION_NO);
match = array_get(&mail->header_match, &match_count);
if (field_idx < match_count &&
match[field_idx] == mail->header_match_value) {
/* cache Date: header */
} else if ((data->cache_fetch_fields & MAIL_FETCH_DATE) != 0 ||
data->save_sent_date) {
/* parse Date: header, but don't cache it. */
data->dont_cache_field_idx = field_idx;
array_idx_set(&mail->header_match, field_idx,
&mail->header_match_value);
}
}
void test_array(void)
{
int i;
double* d;
void* A = array_create(0);
fprintf(stdout, "call function : %s\n", __func__);
array_object_show(A);
fprintf(stdout, "\ntest function - array_push_back ===>\n");
{
srand((unsigned int)time(0));
for (i = 0; i < 5; ++i)
{
NEW0(d);
*d = (i + 1) * (i + 1) * rand() % 5555 * 0.123;
fprintf(stdout, "\tappend into array {object=>0x%p, value=>%.3f}\n", d, *d);
array_push_back(A, d);
}
array_object_show(A);
array_for_each(A, array_element_display, NULL);
array_for_each(A, array_element_destroy, NULL);
array_object_show(A);
array_clear(A);
}
array_object_show(A);
fprintf(stdout, "\ntest function - array_pop_back ===>\n");
{
srand((unsigned int)time(0));
for (i = 0; i < 5; ++i)
{
NEW0(d);
*d = (i + 1) * (i + 1) * rand() % 5555 * 0.123;
fprintf(stdout, "\tappend into array {object=>0x%p, value=>%.3f}\n", d, *d);
array_push_back(A, d);
}
array_object_show(A);
array_for_each(A, array_element_display, NULL);
d = (double*)array_pop_back(A);
fprintf(stdout, " the pop element {object=>0x%p,value=>%.3f}\n", d, *d);
FREE(d);
array_object_show(A);
array_for_each(A, array_element_display, NULL);
array_for_each(A, array_element_destroy, NULL);
array_object_show(A);
array_clear(A);
}
array_object_show(A);
fprintf(stdout, "\ntest function - array_erase ===>\n");
{
srand((unsigned int)time(0));
for (i = 0; i < 5; ++i)
{
NEW0(d);
*d = (i + 1) * (i + 1) * rand() % 5555 * 0.123;
fprintf(stdout, "\tappend into array {object=>0x%p, value=>%.3f}\n", d, *d);
array_push_back(A, d);
}
array_object_show(A);
array_for_each(A, array_element_display, NULL);
d = (double*)array_erase(A, array_begin(A));
fprintf(stdout, " the erased begin element {object=>0x%p,value=>%.3f}\n", d, *d);
FREE(d);
array_object_show(A);
array_for_each(A, array_element_display, NULL);
d = (double*)array_erase(A, array_end(A));
fprintf(stdout, " the erased end element {object=>0x%p,value=>%.3f}\n", d, *d);
FREE(d);
array_object_show(A);
array_for_each(A, array_element_display, NULL);
array_for_each(A, array_element_destroy, NULL);
array_object_show(A);
array_clear(A);
}
array_object_show(A);
fprintf(stdout, "\ntest function - array_remove ===>\n");
{
srand((unsigned int)time(0));
for (i = 0; i < 5; ++i)
{
NEW0(d);
*d = (i + 1) * (i + 1) * rand() % 5555 * 0.123;
fprintf(stdout, "\tappend into array {object=>0x%p, value=>%.3f}\n", d, *d);
array_push_back(A, d);
}
array_object_show(A);
array_for_each(A, array_element_display, NULL);
d = (double*)array_remove(A, 3);
fprintf(stdout, " the removed [3] -> {object=>0x%p,value=>%.3f}\n", d, *d);
FREE(d);
array_object_show(A);
array_for_each(A, array_element_display, NULL);
array_for_each(A, array_element_destroy, NULL);
array_object_show(A);
array_clear(A);
}
array_object_show(A);
fprintf(stdout, "\ntest function - array_copy ===>\n");
{
void* copy_A;
srand((unsigned int)time(0));
for (i = 0; i < 5; ++i)
{
NEW0(d);
*d = (i + 1) * (i + 1) * rand() % 5555 * 0.123;
fprintf(stdout, "\tappend into array {object=>0x%p, value=>%.3f}\n", d, *d);
array_push_back(A, d);
}
array_object_show(A);
array_for_each(A, array_element_display, NULL);
copy_A = array_copy(A, 10);
array_object_show(copy_A);
array_for_each(copy_A, array_element_display, NULL);
array_release(©_A);
array_for_each(A, array_element_destroy, NULL);
array_clear(A);
}
array_object_show(A);
fprintf(stdout, "\ntest function - array_resize ===>\n");
{
srand((unsigned int)time(0));
for (i = 0; i < 5; ++i)
{
NEW0(d);
*d = (i + 1) * (i + 1) * rand() % 5555 * 0.123;
fprintf(stdout, "\tappend into array {object=>0x%p, value=>%.3f}\n", d, *d);
array_push_back(A, d);
}
array_object_show(A);
array_for_each(A, array_element_display, NULL);
array_resize(A, 20);
array_object_show(A);
array_for_each(A, array_element_display, NULL);
array_for_each(A, array_element_destroy, NULL);
array_clear(A);
}
array_object_show(A);
fprintf(stdout, "\ntest function - array_release ===>\n");
array_release(&A);
array_object_show(A);
}