static int32_t qb_validate_operands_transform(qb_compiler_context *cxt, qb_op_factory *f, qb_primitive_type expr_type, uint32_t flags, qb_operand *operands, uint32_t operand_count, qb_result_destination *result_destination) { qb_operand *matrix1 = &operands[0], *matrix2 = &operands[1]; if(matrix1->address->dimension_count < 2) { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 0, "matrix"); return FALSE; } if(matrix2->address->dimension_count < 1) { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 1, "vector"); return FALSE; } if(HAS_CONSTANT_DIMENSION(matrix1->address, -2) && HAS_CONSTANT_DIMENSION(matrix1->address, -1) && HAS_CONSTANT_DIMENSION(matrix2->address, -1)) { qb_matrix_order order = qb_get_matrix_order(cxt, f); qb_address *m1_col_address = qb_obtain_matrix_column_address(cxt, matrix1->address, order); qb_address *m1_row_address = qb_obtain_matrix_row_address(cxt, matrix1->address, order); qb_address *m2_row_address = DIMENSION_ADDRESS(matrix2->address, -1); uint32_t m1_col_count = VALUE(U32, m1_col_address); uint32_t m1_row_count = VALUE(U32, m1_row_address); uint32_t m2_row_count = VALUE(U32, m2_row_address); if(!(m2_row_count >= 2 && m2_row_count <= 4 && m1_col_count == m2_row_count + 1 && m1_row_count == m2_row_count)) { qb_report_invalid_transform_exception(cxt->line_id, m1_col_count, m1_row_count, m2_row_count); return FALSE; } } else { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 0, "matrix with fixed dimensions"); } return TRUE; }
static int32_t qb_validate_operands_array_pad(qb_compiler_context *cxt, qb_op_factory *f, qb_primitive_type expr_type, uint32_t flags, qb_operand *operands, uint32_t operand_count, qb_result_destination *result_destination) { qb_operand *input = &operands[0], *size = &operands[1], *value = &operands[2]; if(IS_SCALAR(input->address)) { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 0, "array"); return FALSE; } if(!IS_SCALAR(size->address)) { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 0, "scalar"); return FALSE; } if(input->address->dimension_count > 1) { qb_address *element_size_address = input->address->array_size_addresses[1]; qb_address *value_size_address = value->address->array_size_address; if(IS_IMMUTABLE(element_size_address) && IS_IMMUTABLE(value_size_address)) { uint32_t element_size = VALUE(U32, element_size_address); uint32_t value_size = VALUE(U32, value_size_address); if(element_size != value_size) { qb_report_unmet_intrinsic_condition_exception(cxt->line_id, cxt->intrinsic_function, "the third parameter to have the same size as the elements in the input array"); return FALSE; } } else { qb_operand guard_operands[2] = { { QB_OPERAND_ADDRESS, { value_size_address } }, { QB_OPERAND_ADDRESS, { element_size_address } } }; qb_operand guard_result = { QB_OPERAND_EMPTY, { NULL } }; qb_produce_op(cxt, &factory_guard_array_size_exact, guard_operands, 2, &guard_result, NULL, 0, NULL); } } else { if(!IS_SCALAR(value->address)) { qb_report_unmet_intrinsic_condition_exception(cxt->line_id, cxt->intrinsic_function, "the third parameter to be a scalar when the input array is not multidimensional"); return FALSE; } } return TRUE; }
int SimpleHinter::crossCount( const RecoResult & R, int x, int y, int W, int H ) { int value = VALUE( x, y ); // go top & bottom int vCount = 1; int step = y - 1; while ( step >= 0 && VALUE( x, step ) == value ) { vCount++; step--; } step = y + 1; while ( step < H && VALUE( x, step ) == value ) { vCount++; step++; } // go right & left int hCount = 1; step = x + 1; while ( step < W && VALUE( step, y ) == value ) { hCount++; step++; } step = x - 1; while ( step >= 0 && VALUE( step, y ) == value ) { hCount++; step--; } // return the longest line return qMax( vCount, hCount ); }
DefMarking(struct net_object *netobj, struct net_object *unf_netobj) { struct place_object *place; list curr = NULL; markPTR m; multisetPTR p_MS; int i; char *tag; while ( (curr = list_iterator(gListMarking, curr)) != NULL ){ m = DATA(curr); if(m->type==0){ evalMarking(m, &p_MS); for(i=0; i<CARD(p_MS) ; i++) if( VALUE(SET(p_MS)[i])>0 ){ tag = NewStringCat(m->place->tag, STR_INDEX(SET(p_MS)[i])); for(place = unf_netobj->places; place!=NULL && (strcmp(place->tag, tag)!=0) ; place = place->next); if(place == NULL) Error(UNKN_PLACE_ERR, "DefMarking", tag); else place->m0 = VALUE(SET(p_MS)[i]); } } else{ tag = NewStringCat(m->place->tag, "_"); for(place = unf_netobj->places; place!=NULL && (strcmp(place->tag, tag)!=0) ; place = place->next); if(place == NULL) Error(UNKN_PLACE_ERR, "DefMarking", tag); else place->mpar = m->mrk; } } }
// TODO : Fix it. Transaction abort clears transaction log buffer resulting in resetting transaction ID. TEST_F(NLDBTest, transaction_abort) { ASSERT_TRUE( nldb_tx_begin(tx) == 0 ); ASSERT_TRUE( nldb_table_put( tx, vol_table, KEY(rec1), VALUE(rec1) ) == 0 ); ASSERT_TRUE( nldb_tx_commit(tx) == 0 ); ASSERT_TRUE( nldb_tx_begin(tx) == 0 ); // Put the value with rec2 temporarily. ASSERT_TRUE( nldb_table_put( tx, vol_table, KEY(rec1), VALUE(rec2) ) == 0 ); // Check before abort { nldb_value_t v; ASSERT_TRUE( nldb_table_get( tx, vol_table, KEY(rec1), & v, NULL /*nldb_order_t*/) == 0 ); // The value should be rec2 ASSERT_TRUE( IS_VALUE_EQUAL(rec2, v)); } ASSERT_TRUE( nldb_tx_abort(tx) == 0 ); // Check value after abort { nldb_value_t v; ASSERT_TRUE( nldb_table_get( tx, vol_table, KEY(rec1), & v, NULL /*nldb_order_t*/ ) == 0 ); // The value should be rec1 after aborting the transaction. ASSERT_TRUE( IS_VALUE_EQUAL(rec1, v)); } }
void s3b_hash_remove(struct s3b_hash *hash, s3b_block_t key) { u_int i; u_int j; u_int k; /* Find entry */ for (i = FIRST(hash, key); 1; i = NEXT(hash, i)) { void *const value = VALUE(hash, i); if (EMPTY(value)) /* no such entry */ return; if (KEY(value) == key) /* entry found */ break; } /* Repair subsequent entries as necessary */ for (j = NEXT(hash, i); 1; j = NEXT(hash, j)) { void *const value = VALUE(hash, j); if (value == NULL) break; k = FIRST(hash, KEY(value)); if (j > i ? (k <= i || k > j) : (k <= i && k > j)) { VALUE(hash, i) = value; i = j; } } /* Remove entry */ assert(VALUE(hash, i) != NULL); VALUE(hash, i) = NULL; hash->numkeys--; }
static int32_t qb_validate_operands_vm_mult(qb_compiler_context *cxt, qb_op_factory *f, qb_primitive_type expr_type, uint32_t flags, qb_operand *operands, uint32_t operand_count, qb_result_destination *result_destination) { qb_operand *matrix1 = &operands[0], *matrix2 = &operands[1]; qb_matrix_order order = qb_get_matrix_order(cxt, f); qb_address *m1_col_address = DIMENSION_ADDRESS(matrix1->address, -1); qb_address *m2_row_address = qb_obtain_matrix_row_address(cxt, matrix2->address, order); if(matrix1->address->dimension_count < 1) { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 0, "vector"); return FALSE; } if(matrix2->address->dimension_count < 2) { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 1, "matrix"); return FALSE; } if(m1_col_address != m2_row_address) { if(IS_IMMUTABLE(m1_col_address) && IS_IMMUTABLE(m2_row_address)) { uint32_t m1_col_count = VALUE(U32, m1_col_address); uint32_t m2_row_count = VALUE(U32, m2_row_address); if(!cxt->matrix_padding) { if(m1_col_count != m2_row_count) { qb_report_invalid_matrix_multiplication_exception(cxt->line_id, m1_col_count, m2_row_count, 2); return FALSE; } } } else { qb_operand operands[2] = { { QB_OPERAND_ADDRESS, { m1_col_address } }, { QB_OPERAND_ADDRESS, { m2_row_address } } }; qb_produce_op(cxt, &factory_validate_vm_mult, operands, 2, NULL, NULL, 0, NULL); } } return TRUE; }
static void value_finalize (GObject *gobject) { g_free(VALUE (gobject)->dictkeyword); g_free(VALUE (gobject)->value); //G_OBJECT_CLASS (gobject)->finalize (gobject); }
static void ct_swap_data(node_t *node1, node_t *node2) { PyObject *tmp; tmp = KEY(node1); KEY(node1) = KEY(node2); KEY(node2) = tmp; tmp = VALUE(node1); VALUE(node1) = VALUE(node2); VALUE(node2) = tmp; }
P op_errormessage(void) { LBIG e, pid, port; P nb, tnb; B *m, *s; if (o_6 < FLOORopds) goto baderror; if (CLASS(o_6) != NUM) goto baderror; if (! VALUE(o_6, &pid)) goto baderror; if (TAG(o_5) != (ARRAY | BYTETYPE)) goto baderror; if (CLASS(o_4) != NUM) goto baderror; if (! VALUE(o_4, &port)) goto baderror; if (TAG(o_3) != (ARRAY | BYTETYPE)) goto baderror; if (CLASS(o_2) != NUM) goto baderror; if (!VALUE(o_2, &e)) goto baderror; if (TAG(o_1) != (ARRAY | BYTETYPE)) goto baderror; s = (B *)VALUE_BASE(o_1); tnb = ARRAY_SIZE(o_1); nb = dm_snprintf((char*) s, tnb, "On %*s port %llu, pid %llu: ", (int) ARRAY_SIZE(o_5), (char*) VALUE_BASE(o_5), (unsigned long long) port, (unsigned long long) pid); s += nb; tnb -= nb; if ((P)e < 0) /*Clib error */ nb = dm_snprintf((char*) s, tnb, "errno: %s", (char*) strerror(-(int)e)); else { /* one of our error codes: decode */ m = geterror((P) e); nb = strlen((char*) m); if (nb > tnb) nb = tnb; moveB(m, s, nb); } s += nb; tnb -= nb; nb = dm_snprintf((char*)s, tnb, " in %*s\n", (int) ARRAY_SIZE(o_3), (char*) VALUE_BASE(o_3)); ARRAY_SIZE(o_1) = (P)(s + nb) - VALUE_BASE(o_1); moveframe(o_1,o_6); FREEopds = o_5; return OK; baderror: printf("**Error with corrupted error info on operand stack!\n"); return op_halt(); }
void* _omFindInSortedList(void* list, int next, int long_field, unsigned long what) { while (list != NULL) { if (VALUE(list, long_field) >= what) { if (VALUE(list, long_field) == what) return list; return NULL; } ITER(list); } return NULL; }
/* Return the product of two expressions */ static exp_t * prod(exp_t *a1, exp_t *a2) { exp_t *res; CHKNUM(a1, *); CHKNUM(a2, *); if (isfloat(a1) || isfloat(a2)) res = nfloat(VALUE(a1) * VALUE(a2)); else res = nrat(NUMER(a1) * NUMER(a2), DENOM(a1) * DENOM(a2)); return res; }
void dl_print(List list) { assert_argument_not_null(list); dl_assert_element_size(list); ListNode *node = list->first; printf("["); if (node != NULL) { printf("%g", VALUE(node)); node = node->next; } for (; node != NULL; node = node->next) { printf(", %g", VALUE(node)); } printf("]"); }
void _stdcall AddDebugAlloc(void* pPointer, int nSize) { VALUE(vProgInfo); LPDBGALLOCINFO pDbg; char *pProgInfo = 0; if (pPointer && gbTrackAlloc) { pDbg = malloc(sizeof(DBGALLOCINFO)); if (!pDbg) return; EVALUATE(vProgInfo,"ALLTRIM(STR(LINENO())) + ':' + PROGRAM() + CHR(0)"); if (IS_STRING(vProgInfo)) { pProgInfo = strdup(HANDTOPTR(vProgInfo)); FREEHAND(vProgInfo); } pDbg->pPointer = pPointer; pDbg->pProgInfo = pProgInfo; pDbg->nSize = nSize; pDbg->next = gpDbgInfo; gpDbgInfo = pDbg; } }
static void print_dist (gsl_monte_vegas_state * state, unsigned long dim) { unsigned long i, j; int p = state->verbose; if (p < 1) return; for (j = 0; j < dim; ++j) { fprintf (state->ostream, "\n axis %lu \n", j); fprintf (state->ostream, " x g\n"); for (i = 0; i < state->bins; i++) { fprintf (state->ostream, "weight [%11.2e , %11.2e] = ", COORD (state, i, j), COORD(state,i+1,j)); fprintf (state->ostream, " %11.2e\n", VALUE (state, i, j)); } fprintf (state->ostream, "\n"); } fprintf (state->ostream, "\n"); fflush (state->ostream); }
List* Prepend( VALUE v ) final { auto c = Cons::Create(v, VALUE(this)); //std::cout << "\nBefore:" << LIST(TList,this).Print(); //std::cout << "\nPrepended:" << v.Print(); //std::cout << "\nAfter:" << LIST(TList,c).Print() << "\n"; return c; }
/* Return the division of two expressions */ static exp_t * divs(exp_t *a1, exp_t *a2) { exp_t *res; CHKNUM(a1, /); CHKNUM(a2, /); if (VALUE(a2) == 0) everr("/: argument is divided by zero", a1); if (isfloat(a1) || isfloat(a2)) res = nfloat(VALUE(a1) / VALUE(a2)); else res = nrat(NUMER(a1) * DENOM(a2), NUMER(a2) * DENOM(a1)); return res; }
static GCC_INLINE void fc_pro_get_board(long gamenumber, Position * pos) { int i, j; /* generic counters */ int wLeft = 52; /* cards left to be chosen in shuffle */ CARD deck[52]; /* deck of 52 unique cards */ int col; CARD card, suit; memset(pos, '\0', sizeof(*pos)); /* shuffle cards */ for (i = 0; i < 52; i++) /* put unique card in each deck loc. */ { deck[i] = i; } for (i = 0; i < 52; i++) { j = microsoft_rand_rand(&gamenumber) % wLeft; col = (i%8); card = deck[j]; suit = SUIT(card); pos->tableau[col].cards[pos->tableau[col].count++] = (Card)((VALUE(card)+1) + (((suit == 3) ? suit : ((suit+1)%3))<<4)) ; deck[j] = deck[--wLeft]; } }
static void ct_delete_node(node_t *node) { Py_XDECREF(KEY(node)); Py_XDECREF(VALUE(node)); PyMem_Free(node); }
void _stdcall ReplaceDebugAlloc(void* pOrig, void* pNew, int nSize) { LPDBGALLOCINFO pDbg = gpDbgInfo; VALUE(vProgInfo); char* pProgInfo = 0; if (!pNew || !gbTrackAlloc) return; while (pDbg && pDbg->pPointer != pOrig) pDbg = pDbg->next; if (pDbg) { EVALUATE(vProgInfo,"ALLTRIM(STR(LINENO())) + ':' + PROGRAM() + CHR(0)"); if (IS_STRING(vProgInfo)) { pProgInfo = strdup(HANDTOPTR(vProgInfo)); FREEHAND(vProgInfo); } if (pDbg->pProgInfo) free(pDbg->pProgInfo); pDbg->pPointer = pNew; pDbg->pProgInfo = pProgInfo; pDbg->nSize = nSize; } }
// Override of the List interface List* Append( VALUE elem ) { #ifdef USE_CONS_OPTIMIZATIONS List* tail = this; while (!tail->Rest().IsEmpty() ) { tail = tail->Rest().GetList(); } if (tail->RefCount < 2 && tail->Rest().IsEmpty()) { // We can optimize things as we can reuse this materalization. // Nobody is referencing it. if (tail->AttemptDirtyAdd(elem)) { return this; }; } #endif int originalCount = Count(); int last = Count()-1; List* c = VALUE(QParenthesis,elem).GetList(); while (last >= 0) { c = c->Prepend( GetAt(last) ); last--; } int newCount = c->Count(); assert( newCount == originalCount + 1 ); // std::cout << "\nBefore:" << LIST(this).Print(); // std::cout << "\nAdded:" << elem.Print(); // std::cout << "\nAfter:" << LIST(c).Print() << "\n"; return c; }
static int32_t qb_validate_operands_array_push(qb_compiler_context *cxt, qb_op_factory *f, qb_primitive_type expr_type, uint32_t flags, qb_operand *operands, uint32_t operand_count, qb_result_destination *result_destination) { qb_operand *container = &operands[0]; qb_address *container_element_size_address; uint32_t i; if(IS_TEMPORARY(container->address)) { qb_report_unexpected_value_as_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 0); return FALSE; } if(IS_SCALAR(container->address)) { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 0, "array"); return FALSE; } if(IS_FIXED_LENGTH(container->address)) { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, 0, "variable-length array"); return FALSE; } if(container->address->dimension_count > 1) { container_element_size_address = container->address->array_size_addresses[1]; } else { container_element_size_address = cxt->one_address; } // make sure the elements being pushed in match the size of the elements in the container for(i = 1; i < operand_count; i++) { qb_address *address = operands[i].address; qb_address *element_size_address = address->array_size_address; if(container_element_size_address != element_size_address) { if(IS_IMMUTABLE(container_element_size_address) && IS_IMMUTABLE(element_size_address)) { uint32_t container_element_size = VALUE(U32, container_element_size_address); uint32_t element_size = VALUE(U32, element_size_address); if(container_element_size != element_size) { qb_report_unmet_intrinsic_condition_exception(cxt->line_id, cxt->intrinsic_function, "values of the same size as the elements in the container"); return FALSE; } } else { qb_operand guard_operands[2] = { { QB_OPERAND_ADDRESS, { element_size_address } }, { QB_OPERAND_ADDRESS, { container_element_size_address } } }; qb_operand guard_result = { QB_OPERAND_EMPTY, { NULL } }; qb_produce_op(cxt, &factory_guard_array_size_exact, guard_operands, 2, &guard_result, NULL, 0, NULL); } } } return TRUE; }
static void check_blocks(void) { for (uint32_t n=0; n<nblocks; n++) { for (uint32_t i=0; i<sizeof(blocks[nblocks]->v)/sizeof(uint32_t); i++) { assert(blocks[n]->v[i] == VALUE(i)); } } }
void set_vars(int step) { int n, i; int v = VALUE(subrank, step); n = ldim1; for (i=0; i<n; i++) a1[i] = v; }
/* * Optimization of s3b_hash_put() for when it is known that no matching entry exists. */ void s3b_hash_put_new(struct s3b_hash *hash, void *value) { const s3b_block_t key = KEY(value); u_int i; for (i = FIRST(hash, key); 1; i = NEXT(hash, i)) { void *const value2 = VALUE(hash, i); if (EMPTY(value2)) break; assert(KEY(value2) != key); } assert(hash->numkeys < hash->maxkeys); VALUE(hash, i) = value; hash->numkeys++; }
/* Return the difference of two expressions */ static exp_t * sub(exp_t *a1, exp_t *a2) { long n1, n2, d1, d2; exp_t *res; CHKNUM(a1, -); CHKNUM(a2, -); if (isfloat(a1) || isfloat(a2)) res = nfloat(VALUE(a1) - VALUE(a2)); else { n1 = NUMER(a1), n2 = NUMER(a2); d1 = DENOM(a1), d2 = DENOM(a2); res = nrat(n1*d2 - n2*d1, d1 * d2); } return res; }
static void value_get_property (GObject *gobject, guint prop_id, GValue *value, GParamSpec *pspec) { switch (prop_id) { case PROP_DICTIONARY_KEYWORD: g_value_set_string (value, VALUE (gobject)->dictkeyword); break; case PROP_VALUE: g_value_set_string (value, VALUE (gobject)->value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); } }
double dl_next(ListIterator *iter) { if (*iter == NULL) { printf("%s: iterator does not have a next value\n", __func__); exit(EXIT_FAILURE); } double value = VALUE(*iter); *iter = (*iter)->next; return value; }
/* take a _node_t, value, and depth (zero means root) */ _node_t *_find(_node_t *o, uint32_t v, size_t d) { if (_is_leaf(o)) { return VALUE(o) == v ? o : NULL; } if (!_has_children(o)) { return NULL; } return _find(_children(o) + _idx8(v, d), v, d + 1); }
static int32_t qb_validate_operands_cross_product(qb_compiler_context *cxt, qb_op_factory *f, qb_primitive_type expr_type, uint32_t flags, qb_operand *operands, uint32_t operand_count, qb_result_destination *result_destination) { uint32_t i; for(i = 0; i < operand_count; i++) { qb_operand *operand = &operands[0]; if(IS_SCALAR(operand->address)) { qb_report_unexpected_intrinsic_argument_exception(cxt->line_id, cxt->intrinsic_function, i, "array"); return FALSE; } } if(operand_count == 3) { qb_operand *operand1 = &operands[0], *operand2 = &operands[1], *operand3 = &operands[2]; qb_address *v1_width_address = DIMENSION_ADDRESS(operand1->address, -1); qb_address *v2_width_address = DIMENSION_ADDRESS(operand2->address, -1); qb_address *v3_width_address = DIMENSION_ADDRESS(operand3->address, -1); if(IS_IMMUTABLE(v1_width_address) && IS_IMMUTABLE(v2_width_address) && IS_IMMUTABLE(v3_width_address)) { uint32_t v1_width = VALUE(U32, v1_width_address); uint32_t v2_width = VALUE(U32, v2_width_address); uint32_t v3_width = VALUE(U32, v3_width_address); if(!(v1_width == v2_width && v2_width == v3_width && v1_width == 4)) { qb_report_invalid_4d_cross_product_exception(cxt->line_id, v1_width, v2_width, v3_width); return FALSE; } } else { qb_operand operands[3] = { { QB_OPERAND_ADDRESS, { v1_width_address } }, { QB_OPERAND_ADDRESS, { v2_width_address } }, { QB_OPERAND_ADDRESS, { v3_width_address } } }; qb_produce_op(cxt, &factory_validate_cross_product_4d, operands, 3, NULL, NULL, 0, NULL); } } else { qb_operand *operand1 = &operands[0], *operand2 = &operands[1]; qb_address *v1_width_address = DIMENSION_ADDRESS(operand1->address, -1); qb_address *v2_width_address = DIMENSION_ADDRESS(operand2->address, -1); if(IS_IMMUTABLE(v1_width_address) && IS_IMMUTABLE(v2_width_address)) { uint32_t v1_width = VALUE(U32, v1_width_address); uint32_t v2_width = VALUE(U32, v2_width_address); if(!(v1_width == v2_width && 2 <= v1_width && v2_width <= 3)) { qb_report_invalid_cross_product_exception(cxt->line_id, v1_width, v2_width); return FALSE; } } else { qb_operand operands[2] = { { QB_OPERAND_ADDRESS, { v1_width_address } }, { QB_OPERAND_ADDRESS, { v2_width_address } } }; uint32_t width = 3; if(IS_IMMUTABLE(v1_width_address)) { width = VALUE(U32, v1_width_address); } if(IS_IMMUTABLE(v2_width_address)) { width = VALUE(U32, v2_width_address); } if(width == 2) { qb_produce_op(cxt, &factory_validate_cross_product_2d, operands, 2, NULL, NULL, 0, NULL); } else { qb_produce_op(cxt, &factory_validate_cross_product_3d, operands, 2, NULL, NULL, 0, NULL); } } } return TRUE; }