caddr_t arithm_dt_subtract (ccaddr_t box1, ccaddr_t box2, caddr_t *err_ret) { dtp_t dtp1 = DV_TYPE_OF (box1), dtp2 = DV_TYPE_OF (box2); if ((DV_DATETIME == dtp1) && (DV_DATETIME == dtp2)) { boxint s1 = DT_CAST_TO_TOTAL_SECONDS(box1); boxint s2 = DT_CAST_TO_TOTAL_SECONDS(box2); int frac1 = DT_FRACTION(box1); int frac2 = DT_FRACTION(box2); if (frac1 == frac2) return box_num (s1 - s2); else { numeric_t res = numeric_allocate (); numeric_from_int64 (res, ((s1 - s2) * 1000000000L) + (frac1 - frac2)); res->n_len -= 9; res->n_scale += 9; return (caddr_t)res; } } if ((DV_DATETIME == dtp1) && ((DV_LONG_INT == dtp2) || (DV_DOUBLE_FLOAT == dtp2) || (DV_NUMERIC == dtp2))) { caddr_t res = arithm_dt_add_num (box1, box2, 1, err_ret); if (NULL != err_ret) return res; if (NULL == res) goto generic_err; return res; } generic_err: err_ret[0] = srv_make_new_error ("22003", "SR087", "Wrong arguments for datetime arithmetic, can not subtract value of type %d (%s) from value type %d (%s).", dtp2, dv_type_title (dtp2), dtp1, dv_type_title (dtp1) ); return NULL; }
caddr_t arithm_dt_add (ccaddr_t box1, ccaddr_t box2, caddr_t *err_ret) { dtp_t dtp1 = DV_TYPE_OF (box1), dtp2 = DV_TYPE_OF (box2); if ((DV_DATETIME == dtp1) && ((DV_LONG_INT == dtp2) || (DV_DOUBLE_FLOAT == dtp2) || (DV_NUMERIC == dtp2))) { caddr_t res = arithm_dt_add_num (box1, box2, 0, err_ret); if (NULL != err_ret) return res; if (NULL == res) goto generic_err; return res; } if ((DV_DATETIME == dtp2) && ((DV_LONG_INT == dtp1) || (DV_DOUBLE_FLOAT == dtp1) || (DV_NUMERIC == dtp1))) { caddr_t res = arithm_dt_add_num (box2, box1, 0, err_ret); if (NULL != err_ret) return res; if (NULL == res) goto generic_err; return res; } generic_err: err_ret[0] = srv_make_new_error ("22003", "SR087", "Wrong arguments for datetime arithmetic, can not add values of type %d (%s) and type %d (%s).", dtp1, dv_type_title (dtp1), dtp2, dv_type_title (dtp2) ); return NULL; }
caddr_t numeric_bin_op (numeric_bop_t num_op, numeric_t x, numeric_t y, caddr_t * qst, state_slot_t * target) { int rc; caddr_t res_box = NULL; if (target) { res_box = QST_GET (qst, target); if (DV_NUMERIC == DV_TYPE_OF (res_box)) { rc = num_op ((numeric_t) res_box, x, y); } else { res_box = (caddr_t) numeric_allocate (); rc = num_op ((numeric_t) res_box, x, y); qst_set (qst, target, res_box); } } else { res_box = (caddr_t) numeric_allocate (); rc = num_op ((numeric_t) res_box, x, y); } if (rc != NUMERIC_STS_SUCCESS) { char state[10]; char msg[200]; numeric_error (rc, state, sizeof (state), msg, sizeof (msg)); sqlr_new_error (state, "SR083", "%s", msg); } return res_box; }
void qst_set_numeric_buf (caddr_t * qst, state_slot_t * sl, db_buf_t xx) { #ifdef QST_DEBUG if (sl->ssl_index < QI_FIRST_FREE) GPF_T1 ("Invalid SSL in qst_set"); else if (sl->ssl_type == SSL_CONSTANT) GPF_T1 ("Invalid constant SSL in qst_set"); else { #endif caddr_t old = NULL; old = QST_GET (qst, sl); if (DV_NUMERIC != DV_TYPE_OF (old)) old = NULL; if (!old) { old = (caddr_t) numeric_allocate (); numeric_from_buf ((numeric_t) old, xx); qst_set (qst, sl, old); } else { numeric_from_buf ((numeric_t) old, xx); } #ifdef QST_DEBUG } #endif }
int setp_comp_array (setp_node_t * setp, caddr_t * qst, caddr_t * left, state_slot_t ** right) { int inx; dk_set_t is_rev = setp->setp_key_is_desc; _DO_BOX (inx, right) { collation_t * coll = setp->setp_keys_box[inx]->ssl_sqt.sqt_collation; caddr_t right_v; int rc; right_v = qst_get (qst, right[inx]); rc = cmp_boxes (left[inx], right_v, coll, coll); if (rc == DVC_UNKNOWN) { /* GK: the NULLs sort high */ dtp_t dtp1 = DV_TYPE_OF (left[inx]); dtp_t dtp2 = DV_TYPE_OF (right_v); if (dtp1 == DV_DB_NULL) { if (dtp2 == DV_DB_NULL) rc = DVC_MATCH; else rc = DVC_LESS; } else rc = DVC_GREATER; } else if (DVC_NOORDER == rc) rc = DVC_UNKNOWN; /* { dtp_t dtp1 = DV_TYPE_OF (left[inx]); dtp_t dtp2 = DV_TYPE_OF (right_v); if (dtp1 < dtp2) rc = DVC_LESS; else if (dtp1 > dtp2) rc = DVC_GREATER; } */ if (is_rev && ORDER_DESC == (ptrlong) is_rev->data) DVC_INVERT_CMP (rc); if (rc != DVC_MATCH) return rc; is_rev = is_rev ? is_rev->next : NULL; }
caddr_t bif_im_DeepZoom4to1 (caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; caddr_t res; int fmt_is_set = 0; int image_ctr; im_init (&env, qst, args, "IM DeepZoom4to1"); im_set_background (&env, "#000000"); env.ime_target_magick_wand = NewMagickWand (); if (MagickFalse == MagickNewImage (env.ime_target_magick_wand, 256, 256, env.ime_background)) im_leave_with_error (&env, "22023", "IM001", "Can not make new image"); if (MagickFalse == MagickSetImageType (env.ime_target_magick_wand, TrueColorType)) im_leave_with_error (&env, "22023", "IM001", "Can not set image type"); if (MagickFalse == MagickSetImageDepth (env.ime_target_magick_wand, 16)) im_leave_with_error (&env, "22023", "IM001", "Can not set image depth"); if (MagickFalse == MagickSetImageExtent (env.ime_target_magick_wand, 256, 256)) im_leave_with_error (&env, "22023", "IM001", "Can not set image extent"); if (MagickFalse == MagickSetImageBackgroundColor (env.ime_target_magick_wand, env.ime_background)) im_leave_with_error (&env, "22023", "IM001", "Can not set image background"); image_ctr = BOX_ELEMENTS (args) / 2; if (image_ctr > 4) image_ctr = 4; while (0 < image_ctr--) { if (DV_DB_NULL == DV_TYPE_OF (bif_arg (qst, args, image_ctr*2, "IM DeepZoom4to1"))) continue; im_env_set_input_blob (&env, image_ctr * 2); /*im_env_set_blob_ext (&env, 2);*/ im_read (&env); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { unsigned long v_size, h_size; if (!fmt_is_set) { if (MagickFalse == MagickSetImageFormat (env.ime_target_magick_wand, MagickGetImageFormat (env.ime_magick_wand))) im_leave_with_error (&env, "22023", "IM001", "Can not set image format"); fmt_is_set = 1; } h_size = MagickGetImageWidth (env.ime_magick_wand); v_size = MagickGetImageHeight (env.ime_magick_wand); if ((256 < h_size) || (256 < v_size)) continue; MagickResizeImage (env.ime_magick_wand, h_size/2, v_size/2, BoxFilter, 1.0); if (MagickFalse == MagickCompositeImage (env.ime_target_magick_wand, env.ime_magick_wand, OverCompositeOp, (image_ctr & 1) * 128, (image_ctr & 2) * 64)) im_leave_with_error (&env, "22023", "IM001", "Can not composite image"); } im_reset_read (&env); } MagickProfileImage (env.ime_target_magick_wand, "*", NULL, 0); DestroyMagickWand (env.ime_magick_wand); env.ime_magick_wand = env.ime_target_magick_wand; env.ime_target_magick_wand = NULL; res = im_write (&env); im_leave (&env); return res; }
caddr_t bif_date_arg (caddr_t * qst, state_slot_t ** args, int nth, char *func) { caddr_t arg = bif_arg (qst, args, nth, func); dtp_t dtp = DV_TYPE_OF (arg); if (dtp != DV_DATETIME && dtp != DV_BIN) sqlr_new_error ("22007", "DT001", "Function %s needs a datetime, date or time as argument %d, not an arg of type %s (%d)", func, nth + 1, dv_type_title (dtp), dtp); return arg; }
caddr_t clr_deserialize (dk_session_t * ses, long mode, caddr_t asm_name, caddr_t type, void *udt) { MonoArray *v_args = NULL, *bin_data; MonoArray *mono_list; int len; caddr_t in_values, bin_data_ptr; MonoDomain *domain = virtuoso_domain; get_mono_thread (); in_values = (caddr_t) scan_session_boxing (ses); if (DV_TYPE_OF (in_values) != DV_BIN) return (caddr_t) box_num (0); len = box_length (in_values); bin_data = mono_array_new (domain, mono_get_byte_class(), len); bin_data_ptr = mono_array_addr (bin_data, char, 0); memcpy (bin_data_ptr, in_values, len); if (in_values) dk_free_tree (in_values); v_args = MAKE_PARAM_ARRAY (domain, 4); mono_array_set (v_args, gpointer, 0, bin_data); SET_INT_ARG (domain, v_args, 1, mode); SET_STRING_ARG (domain, v_args, 2, asm_name); SET_STRING_ARG (domain, v_args, 3, type); QR_RESET_CTX { mono_list = (MonoArray *) call_mono (VIRTCLR_NAME, "VInvoke:obj_deserialize", v_args, domain); } QR_RESET_CODE { caddr_t err; POP_QR_RESET; err = thr_get_error_code (THREAD_CURRENT_THREAD); if (ARRAYP (err)) log_error ("Mono Deserialization error : [%s] [%s]", ERR_STATE(err), ERR_MESSAGE (err)); else log_error ("Mono Deserialization error : unknown"); dk_free_tree (err); return 0; } END_QR_RESET; return sa_to_dk ((MonoArray *) mono_list, 0, 0, udt); }
caddr_t bif_im_AnnotateImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args) { char * szMe = "IM AnnotateImageBlob"; caddr_t res; caddr_t blob = (caddr_t)bif_arg (qst, args, 0, szMe); long blob_size = box_length (blob) - 1; long x_pos = bif_long_arg (qst, args, 1, szMe); long y_pos = bif_long_arg (qst, args, 2, szMe); caddr_t text = bif_string_arg (qst, args, 3, szMe); int n_args = BOX_ELEMENTS(args); long angle = n_args > 4 ? bif_long_arg (qst, args, 4, szMe) : 0; long f_size = n_args > 5 ? bif_long_arg (qst, args, 5, szMe) : 12; char *text_color = n_args > 6 ? bif_string_arg (qst, args, 6, szMe) : "black" ; dtp_t dtp = DV_TYPE_OF (blob); im_env_t env; im_init (&env, qst, args, "IM AnnotateImageBlob"); if (IS_STRING_DTP (dtp)) blob_size = box_length (blob) - 1; else if (dtp == DV_BIN) blob_size = box_length (blob); else im_leave_with_error (&env, "22023", "IM001", "AnnotateImageBlob needs string or binary as 1-st argument"); im_env_set_blob_ext (&env, 7, -1); env.ime_drawing_wand = NewDrawingWand (); im_read (&env); im_set_background (&env, text_color); DrawSetFillColor (env.ime_drawing_wand, env.ime_background); DrawSetFontSize (env.ime_drawing_wand, f_size); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { env.ime_status = MagickAnnotateImage (env.ime_magick_wand, env.ime_drawing_wand, x_pos, y_pos, angle, text); if (env.ime_status == MagickFalse) im_leave_with_error (&env, "22023", "IM001", "Cannot annotate image"); } res = im_write (&env); im_leave (&env); return res; }
static int param_to_mono_array (caddr_t *list_args, int n_args, MonoArray ** p_i_array, MonoArray **p_o_array) { caddr_t * line; MonoObject *arg = NULL; MonoDomain *domain = virtuoso_domain; MonoArray *i_array, *o_array; guint32 is_object; int inx; i_array = (MonoArray*)mono_array_new (domain, mono_get_object_class (), n_args); o_array = (MonoArray*)mono_array_new (domain, mono_get_intptr_class (), n_args); for (inx = 0; inx < n_args; ++inx) { line = (caddr_t *) list_args[inx]; is_object = 0; if (DV_TYPE_OF (line[1]) == DV_DB_NULL) { arg = NULL; goto put_it; } if (!strncmp (line[0], "System.String", sizeof ("System.String")) || !strncmp (line[0], "String", sizeof ("String"))) { if (!DV_STRINGP (line[1])) goto convert_error; arg = (MonoObject *) mono_string_new (domain, line[1]); } else if (!strncmp (line[0], "Int32", sizeof ("Int32")) || !strncmp (line[0], "System.Int32", sizeof ("System.Int32")) || !strncmp (line[0], "int", sizeof ("int"))) { gint32 ivalue; if (DV_TYPE_OF (line[1]) != DV_LONG_INT) goto convert_error; ivalue = unbox (line[1]); arg = mono_value_box (domain, mono_get_int32_class (), &ivalue); } else if (!strncmp (line[0], "System.Single", sizeof ("System.Single")) || !strncmp (line[0], "Single", sizeof ("Single"))) { float flt_value; if (DV_TYPE_OF (line[1]) != DV_SINGLE_FLOAT) goto convert_error; flt_value = unbox_float (line[1]); arg = mono_value_box (domain, mono_get_single_class (), &flt_value); } else if (!strncmp (line[0], "System.Data.SqlTypes.SqlDouble", sizeof ("System.Data.SqlTypes.SqlDouble")) || !strncmp (line[0], "System.Double", sizeof ("System.Double")) || !strncmp (line[0], "Double", sizeof ("Double"))) { double dbl_value; if (DV_TYPE_OF (line[1]) != DV_DOUBLE_FLOAT) goto convert_error; dbl_value = unbox_double (line[1]); arg = mono_value_box (domain, mono_get_double_class (), &dbl_value); } else /*if (!strncmp (line[0], "CLRObject", sizeof ("CLRObject"))) */ { gint32 ivalue; if (DV_TYPE_OF (line[1]) != DV_LONG_INT) goto convert_error; is_object = unbox (line[1]); arg = mono_value_box (domain, mono_get_int32_class (), &ivalue); } put_it: mono_array_set (i_array, gpointer, inx, arg); mono_array_set (o_array, gpointer, inx, (gpointer) is_object); } *p_i_array = i_array; *p_o_array = o_array; return 0; convert_error: sqlr_new_error ("22023", "XXXXX", "wrong or unknown type"); return 0; }
void im_env_set_input_blob (im_env_t *env, int in_arg_no) { env->ime_input_blob = bif_string_arg (env->ime_qst, env->ime_args, in_arg_no, env->ime_bifname); env->ime_input_blob_len = bif_long_arg (env->ime_qst, env->ime_args, in_arg_no+1, env->ime_bifname); im_dbg_printf (("IM %p: %s() set input to blob, %ld bytes declared, %ld bytes actual with dtp %u\n", env, env->ime_bifname, (long)(env->ime_input_blob_len), (long)(box_length (env->ime_input_blob)), (unsigned)(DV_TYPE_OF(env->ime_input_blob)))); }
shuric_t *shuric_load (shuric_vtable_t *vt, caddr_t uri, caddr_t ts, caddr_t uri_text_content, shuric_t *loaded_by, struct query_instance_s *qi, void *env, caddr_t *err_ret ) { caddr_t str = NULL; shuric_t ** cached_shuric_ptr; shuric_t *new_cached_shuric = NULL, *old_cached_shuric = NULL; shuric_t * new_shuric = NULL; shuric_t * res = NULL; /* = NULL to keep compiler happy */ dk_set_t obsoletes = NULL; dbg_printf (("shuric_load started (\"%s\", \"%s\", \"%s\" @ %p)\n", vt->shuric_type_title, uri, loaded_by ? loaded_by->shuric_uri : "", loaded_by )); if (NULL != err_ret[0]) return NULL; if (NULL != uri) { if (DV_STRING != DV_TYPE_OF (uri)) { err_ret[0] = srv_make_new_error ("39000", "FA041", "A URI of a shareable XSLT/XQuery resource has invalid data type."); goto cleanup; } if (box_length (uri) > MAX_SHURIC_URI_LENGTH) { err_ret[0] = srv_make_new_error ("39000", "FA042", "An abnormally long string is passed as URI of a shareable XSLT/XQuery resource."); goto cleanup; } } if (NULL != uri) { if (NULL != loaded_by) { shuric_t *old_inc = shuric_scan_relations (loaded_by, uri, SHURIC_SCAN_INCLUDED_BY | SHURIC_SCAN_IMPORTED_BY); if (old_inc != NULL) { char impuri[300]; if (NULL != loaded_by->shuric_uri) strcpy (impuri, "(temporary resource with no URI)"); else { strcpy_ck (impuri, loaded_by->shuric_uri); } shuric_release (old_inc); err_ret[0] = srv_make_new_error ("39000", "FA048", "Cyclic references: '%.300s' refers to his ancestor '%.300s' as to child resource", impuri, uri); } } mutex_enter (shuric_mtx); cached_shuric_ptr = (shuric_t **) id_hash_get (shuric_global_hashtable, (caddr_t) &uri); old_cached_shuric = ((NULL == cached_shuric_ptr) ? NULL : cached_shuric_ptr[0]); if (NULL != old_cached_shuric) old_cached_shuric->shuric_ref_count++; /* Temporary lock to keep the pointer valid. */ mutex_leave (shuric_mtx); if ((NULL != old_cached_shuric) && (old_cached_shuric->_ != vt)) { err_ret[0] = srv_make_new_error ("39000", "FA046", "Server uses the content of URI '%.200s' as '%.30s' and can not load it as '%.30s'", uri, old_cached_shuric->_->shuric_type_title, vt->shuric_type_title ); goto cleanup; } } if (NULL == uri_text_content) { QR_RESET_CTX { str = vt->shuric_uri_to_text (uri, qi, env, err_ret); } QR_RESET_CODE { du_thread_t *self = THREAD_CURRENT_THREAD; err_ret[0] = thr_get_error_code (self); thr_set_error_code (self, NULL); } END_QR_RESET; }
caddr_t bif_mediawiki_lexer_impl (caddr_t * qst, caddr_t * err, state_slot_t ** args, char *bifname, int run_lexer) { caddr_t rawtext = bif_string_arg (qst, args, 0, bifname); caddr_t CLUSTER_arg = bif_string_arg (qst, args, 1, bifname); caddr_t TOPIC = bif_string_arg (qst, args, 2, bifname); caddr_t WIKINAME = bif_string_arg (qst, args, 3, bifname); caddr_t *env = (caddr_t *)bif_arg (qst, args, 4, bifname); int envlen = 0, envctr; dk_session_t *pipe = NULL, *out = NULL; caddr_t macroexpanded = NULL, res = NULL; switch (DV_TYPE_OF ((caddr_t)env)) { case DV_ARRAY_OF_POINTER: envlen = BOX_ELEMENTS ((caddr_t)env); if (envlen % 2) sqlr_new_error ("22023", "WV001", "%s needs an array of even length or NULL argument 4", bifname); for (envctr = 0; envctr < envlen; envctr++) if (DV_STRING != DV_TYPE_OF (env[envctr])) sqlr_new_error ("22023", "WV001", "%s needs an array of even length of strings or NULL argument 4", bifname); break; case DV_DB_NULL: break; default: sqlr_new_error ("22023", "WV001", "%s needs an array or NULL as argument 4", bifname); } pipe = strses_allocate (); mutex_enter (mediawiki_lexer_mutex); mediawiki_env = dk_alloc_box ((8 + envlen) * sizeof (caddr_t), DV_ARRAY_OF_POINTER); mediawiki_env[0] = "CLUSTER"; mediawiki_env[1] = mediawiki_CLUSTER = CLUSTER_arg; mediawiki_env[2] = "TOPIC"; mediawiki_env[3] = mediawiki_TOPIC = TOPIC; mediawiki_env[4] = "WIKINAME"; mediawiki_env[5] = mediawiki_WIKINAME = WIKINAME; mediawiki_env[6] = "WIKIVERSION"; mediawiki_env[7] = mediawiki_WIKIVERSION; for (envctr = 0; envctr < envlen; envctr++) mediawiki_env[8+envctr] = env[envctr]; QR_RESET_CTX { mediamacyyrestart (NULL); mediamacyylex_prepare (rawtext, pipe); mediamacyylex (); macroexpanded = strses_string (pipe); if (run_lexer) { out = strses_allocate (); mediawikiyyrestart (NULL); mediawikiyylex_prepare (macroexpanded, out); mediawikiyylex (); } } QR_RESET_CODE { du_thread_t *self = THREAD_CURRENT_THREAD; caddr_t err = thr_get_error_code (self); dk_free_box (mediawiki_env); /* not dk_free_tree */ mutex_leave (mediawiki_lexer_mutex); strses_free (pipe); dk_free_box (macroexpanded); if (run_lexer) strses_free (out); POP_QR_RESET; sqlr_resignal (err); } END_QR_RESET; dk_free_box (mediawiki_env); /* not dk_free_tree */ mutex_leave (mediawiki_lexer_mutex); if (run_lexer) { res = strses_string (out); strses_free (out); strses_free (pipe); dk_free_box (macroexpanded); return res; } else { strses_free (pipe); return macroexpanded; } }
caddr_t arithm_dt_add_num (ccaddr_t box1, ccaddr_t box2, int subtraction, caddr_t *err_ret) { int dt_type = DT_DT_TYPE (box1); dtp_t dtp2 = DV_TYPE_OF (box2); boxint whole_seconds = 0; boxint nanoseconds = 0; TIMESTAMP_STRUCT ts; caddr_t res; switch (dtp2) { case DV_LONG_INT: whole_seconds = unbox (box2); break; case DV_DOUBLE_FLOAT: { double n = unbox_double (box2); double rest; whole_seconds = (n >= 0.0) ? floor(n + 0.5) : ceil(n - 0.5); rest = n - whole_seconds; if (abs(rest/n) > (3 * DBL_EPSILON)) nanoseconds = (n - whole_seconds) * 1000000000L; break; } case DV_NUMERIC: { numeric_t n = (numeric_t)box2; if (NUMERIC_STS_SUCCESS != numeric_to_int64 (n, &whole_seconds)) { err_ret[0] = srv_make_new_error ("22003", "SR087", "Wrong arguments for datetime arithmetic: decimal is out of range."); return NULL; } if (n->n_scale > 0) { char *nptr = n->n_value + n->n_len; int ctr; int mult = 1; for (ctr = 9; ctr > n->n_scale; ctr--) mult *= 10; while (ctr--) { nanoseconds += mult * nptr[ctr]; mult *= 10; } } break; } default: return NULL; } DT_AUDIT_FIELDS (dt); dt_to_GMTimestamp_struct (box1, &ts); ts_add (&ts, (subtraction ? -whole_seconds : whole_seconds), "second"); if (nanoseconds) ts_add (&ts, (subtraction ? -nanoseconds : nanoseconds), "nanosecond"); res = dk_alloc_box (DT_LENGTH, DV_DATETIME); GMTimestamp_struct_to_dt (&ts, res); DT_SET_TZ (res, DT_TZ (box1)); if ((DT_TYPE_DATE == dt_type) && (0 == (((whole_seconds * 1000000000L) + nanoseconds) % (SPERDAY * 1000000000L)))) DT_SET_DT_TYPE (res, dt_type); DT_AUDIT_FIELDS (dt); return res; }