caddr_t
bif_merge_nasa_tjd_to_datetime (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
boxint num = bif_long_arg (qst, args, 0, "merge_nasa_tjd_to_datetime");
caddr_t res = dk_alloc_box_zero (DT_LENGTH, DV_DATETIME);
DT_SET_DAY (res, num + NASA_TJD_OFFSET);
if (1 < BOX_ELEMENTS (args))
{
double frac = bif_double_arg (qst, args, 1, "merge_nasa_tjd_to_datetime");
boxint frac_microsec = frac * (60*60*24*1000000.0);
if ((0 > frac_microsec) || (60*60*24*(boxint)(1000000) <= frac_microsec))
sqlr_new_error ("22023", "SR644", "Fraction of julian day should be nonnegative and less than 1");
DT_SET_FRACTION (res, (frac_microsec % 1000000) * 1000);
frac_microsec = frac_microsec / 1000000;
DT_SET_SECOND (res, (frac_microsec % 60));
frac_microsec = frac_microsec / 60;
DT_SET_MINUTE (res, (frac_microsec % 60));
frac_microsec = frac_microsec / 60;
DT_SET_HOUR (res, frac_microsec);
DT_SET_DT_TYPE (res, DT_TYPE_DATETIME);
}
else
DT_SET_DT_TYPE (res, DT_TYPE_DATE);
return res;
}
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_curdatetime (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
long fract = 0;
caddr_t res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
dt_now (res);
if (args && BOX_ELEMENTS (args) > 0)
fract = (long) bif_long_arg (qst, args, 0, "curdatetime");
DT_SET_FRACTION (res, fract);
return res;
}
void
im_init (im_env_t *env, caddr_t * qst, state_slot_t ** args, const char *bifname)
{
memset (env, 0, sizeof (im_env_t));
env->ime_qst = qst;
env->ime_args = args;
env->ime_argcount = BOX_ELEMENTS (args);
env->ime_bifname = bifname;
im_dbg_printf (("IM %p: init %s(), %d args...", env, bifname, env->ime_argcount));
im_enter (env);
im_dbg_printf (("...IM %p: entered\n", env));
}
char * media_mlex_macro_resolver (char *call)
{
int envlen = BOX_ELEMENTS ((caddr_t)mediawiki_env);
int envidx;
int call_len;
static caddr_t last_macro_found = NULL;
char name_buf[140];
dk_free_box (last_macro_found);
last_macro_found = NULL;
call_len = strlen (call);
mlex_dbg_printf (("{'%s' => ", call));
if ((call_len >= 66) || (call_len < 3))
goto failed; /* see below */
memcpy (name_buf, call + 1, call_len - 2);
name_buf[call_len - 2] = '\0';
for (envidx = 0; envidx < envlen; envidx += 2)
{
if (strcmp (mediawiki_env[envidx], name_buf))
continue;
last_macro_found = box_copy (mediawiki_env[envidx+1]);
mlex_dbg_printf (("'%s' via env}", last_macro_found));
return last_macro_found;
}
sprintf (name_buf, "WikiV (U=%.64s) %s", mediawiki_WIKINAME, call);
IN_TXN;
last_macro_found = registry_get (name_buf);
if (NULL != last_macro_found)
{
mlex_dbg_printf (("'%s' via registry U=%s}", last_macro_found, mediawiki_WIKINAME));
LEAVE_TXN;
return last_macro_found;
}
sprintf (name_buf, "WikiV (C=%.64s) %s", mediawiki_CLUSTER, call);
last_macro_found = registry_get (name_buf);
if (NULL != last_macro_found)
{
mlex_dbg_printf (("'%s' via registry C=%s}", last_macro_found, mediawiki_CLUSTER));
LEAVE_TXN;
return last_macro_found;
}
sprintf (name_buf, "WikiV %s", call);
last_macro_found = registry_get (name_buf);
if (NULL != last_macro_found)
{
mlex_dbg_printf (("'%s' via registry}", last_macro_found));
LEAVE_TXN;
return last_macro_found;
}
failed:
mlex_dbg_printf (("failure }"));
LEAVE_TXN;
return NULL;
}
caddr_t *
set_pos_param_row (cli_stmt_t * stmt, int nth)
{
int btype = stmt->stmt_bind_type;
int n_cols = BOX_ELEMENTS (stmt->stmt_compilation->sc_columns);
int iparam = 0;
caddr_t *row = (caddr_t *) dk_alloc_box_zero (n_cols * sizeof (caddr_t),
DV_ARRAY_OF_POINTER);
col_binding_t *cb = stmt->stmt_cols;
for (iparam = 0; iparam < n_cols; iparam++)
{
if (cb && cb->cb_place)
{
int c_type = cb->cb_c_type;
char *place = cb->cb_place;
SQLLEN *length = cb->cb_length;
int rebind_offset = stmt->stmt_imp_row_descriptor ?
(stmt->stmt_imp_row_descriptor->d_bind_offset_ptr ? *(stmt->stmt_imp_row_descriptor->d_bind_offset_ptr) : 0) : 0;
place += btype == 0 ? nth * sqlc_sizeof (c_type, cb->cb_max_length) : nth * btype;
place += rebind_offset;
if (length)
{
*((char **) &length) += btype == 0 ? nth * sizeof (SDWORD) : btype * nth;
*((char **) &length) += rebind_offset;
}
if (length && SQL_IGNORE == *length)
row[iparam] = (dk_alloc_box (0, DV_IGNORE));
else
{
caddr_t v = buffer_to_dv (place, length, c_type, c_type, BHID (nth, iparam + 1), NULL, CON_IS_INPROCESS (stmt->stmt_connection));
row[iparam] = v;
if (IS_BOX_POINTER (v) && DV_DAE == box_tag (v))
dk_set_push (&stmt->stmt_dae, &row[iparam]);
}
/* never a BLOB handle, since c_type never == SQL_ONGxx */
}
else
row[iparam] = dk_alloc_box (0, DV_IGNORE);
if (cb)
cb = cb->cb_next;
}
return row;
}
long
stmt_row_bookmark (cli_stmt_t * stmt, caddr_t * row)
{
long *bmidp;
long bmid;
cli_connection_t *con = stmt->stmt_connection;
caddr_t bm;
int len;
if (!stmt->stmt_opts->so_use_bookmarks)
return 0;
IN_CON (con);
if (!con->con_bookmarks)
con->con_bookmarks = hash_table_allocate (101);
if (!stmt->stmt_bookmarks)
{
stmt->stmt_bookmarks = hash_table_allocate (101);
stmt->stmt_bookmarks_rev = id_tree_hash_create (101);
}
con->con_last_bookmark++;
len = BOX_ELEMENTS (row);
bm = row[len - 2];
bmidp = (long *) id_hash_get (stmt->stmt_bookmarks_rev, (caddr_t) & bm);
if (bmidp)
{
LEAVE_CON (con);
return (*bmidp);
}
bmid = con->con_last_bookmark;
bm = box_copy_tree (bm);
sethash ((void *) (ptrlong) bmid, stmt->stmt_bookmarks, (void *) bm);
id_hash_set (stmt->stmt_bookmarks_rev, (caddr_t) & bm, (caddr_t) & bmid);
sethash ((void *) (ptrlong) bmid, con->con_bookmarks, (void *) bm);
LEAVE_CON (con);
return bmid;
}
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;
}
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;
}
}
