caddr_t
bif_im_CreateImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
char * szMe = "IM CreateImageBlob";
caddr_t res;
long x_size = bif_long_arg (qst, args, 0, szMe);
long y_size = bif_long_arg (qst, args, 1, szMe);
caddr_t bg_color = (caddr_t)bif_string_arg (qst, args, 2, szMe);
caddr_t fmt = (caddr_t)bif_string_arg (qst, args, 3, szMe);
im_init (&env, qst, args, "IM CreateImageBlob");
if (x_size <= 0 || y_size <= 0)
im_leave_with_error (&env, "22023", "IM001", "Negative image size");
if (x_size*y_size > 3333279) /* 10M / 3 color - 54byte */
im_leave_with_error (&env, "22023", "IM001", "Too large image image size requested");
im_set_background (&env, bg_color);
env.ime_status = MagickNewImage (env.ime_magick_wand, x_size, y_size, env.ime_background);
if (env.ime_status == MagickFalse)
im_leave_with_error (&env, "22023", "IM001", "Cannot create image");
env.ime_status = MagickSetImageFormat (env.ime_magick_wand, fmt);
if (env.ime_status == MagickFalse)
im_leave_with_error (&env, "22023", "IM001", "Cannot set image format");
res = im_write (&env);
im_leave (&env);
return res;
}
void
im_env_set_filenames (im_env_t *env, int in_arg_no, int out_arg_no)
{
env->ime_input_filename = bif_string_arg (env->ime_qst, env->ime_args, in_arg_no, env->ime_bifname);
im_dbg_printf (("IM %p: %s() set input file name to %s\n", env, env->ime_bifname, env->ime_input_filename));
if (0 <= out_arg_no)
{
if (out_arg_no < env->ime_argcount)
env->ime_output_filename = bif_string_arg (env->ime_qst, env->ime_args, out_arg_no, env->ime_bifname);
else
env->ime_output_filename = env->ime_input_filename;
im_dbg_printf (("IM %p: %s() set output file name to %s\n", env, env->ime_bifname, env->ime_output_filename));
}
}
void
im_env_set_blob_ext (im_env_t *env, int in_arg_no, int out_arg_no)
{
if ((0 <= in_arg_no) && (in_arg_no < env->ime_argcount))
{
env->ime_input_ext = bif_string_arg (env->ime_qst, env->ime_args, in_arg_no, env->ime_bifname);
im_dbg_printf (("IM %p: %s() set input extension for blob to %s\n", env, env->ime_bifname, env->ime_input_ext));
}
if ((0 <= out_arg_no) && (out_arg_no < env->ime_argcount))
{
env->ime_output_ext = bif_string_arg (env->ime_qst, env->ime_args, out_arg_no, env->ime_bifname);
im_dbg_printf (("IM %p: %s() set output extension for blob to %s\n", env, env->ime_bifname, env->ime_input_ext));
}
}
static caddr_t
bif_mts_enlist_transaction (caddr_t * qst, caddr_t * err_ret,
state_slot_t ** args)
{
/* get encoded transaction cookie */
caddr_t tr_cookie_str =
bif_string_arg (qst, args, 0, "mts_enlist_transaction");
caddr_t tr_cookie;
unsigned long len;
if (!stricmp(tr_cookie_str,"LOCAL"))
{
/* should be changed */
dbg_printf(("retire lt=%x\n",((query_instance_t*)QST_INSTANCE(qst))->qi_trx));
tp_retire((query_instance_t*)QST_INSTANCE(qst));
return box_num (0);
}
dbg_printf(("enlisting...\n"));
if (export_mts_bin_decode (tr_cookie_str, &tr_cookie, &len) == -1)
sqlr_error("MX001", "could not decode transaction cookie");
if (mts_trx_enlist (QI_TRX (QST_INSTANCE (qst)), tr_cookie, len))
{
dk_free (tr_cookie, -1);
sqlr_error("MX002", "could not enlist in transaction (%s)",tr_cookie_str);
};
dk_free (tr_cookie, -1);
return box_num (0);
}
caddr_t bif_im_ConvertImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
caddr_t res;
char out_name[64];
caddr_t format = bif_string_arg (qst, args, 2, "IM ConvertImageBlob");
im_init (&env, qst, args, "IM ConvertImageBlob");
im_env_set_input_blob (&env, 0);
im_env_set_blob_ext (&env, 3, -1);
im_read (&env);
if (env.ime_input_ext != NULL)
{
if (strlen(format) < 30)
{
strcpy(out_name, "image.");
strcat(out_name, format);
}
}
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
env.ime_status = MagickSetImageFormat (env.ime_magick_wand, format);
MagickSetFilename (env.ime_magick_wand, out_name);
if (env.ime_status == MagickFalse)
im_leave_with_error (&env, "22023", "IM001", "bif_im_ConvertImageBlob cannot convert image");
}
res = im_write (&env);
im_leave (&env);
return res;
}
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))));
}
static caddr_t
bif_extract (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t unit = bif_string_arg (qst, args, 0, "extract");
caddr_t dt = bif_date_arg (qst, args, 1, "extract");
TIMESTAMP_STRUCT ts;
dt_to_timestamp_struct (dt, &ts);
if (!stricmp (unit, "SECOND"))
return box_num (ts.second);
else if (!stricmp (unit, "MINUTE"))
return box_num (ts.minute);
else if (!stricmp (unit, "HOUR"))
return box_num (ts.hour);
else if (!stricmp (unit, "DAY"))
return box_num (ts.day);
else if (!stricmp (unit, "MONTH"))
return box_num (ts.month);
else if (!stricmp (unit, "YEAR"))
return box_num (ts.year);
else
{
*err_ret = srv_make_new_error ("22015", "DT005", "Bad interval in extract.");
return NULL;
}
}
caddr_t
bif_dateadd (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t res;
caddr_t part = bif_string_arg (qst, args, 0, "dateadd");
boxint n = bif_long_arg (qst, args, 1, "dateadd");
caddr_t dt = bif_date_arg (qst, args, 2, "dateadd");
TIMESTAMP_STRUCT ts;
int dt_type = DT_DT_TYPE (dt);
int year_or_month_tz_tweak = (((!strcmp ("year", part)) || (!strcmp ("month", part))) ? DT_TZ (dt) : 0);
DT_AUDIT_FIELDS (dt);
dt_to_GMTimestamp_struct (dt, &ts);
if (year_or_month_tz_tweak)
ts_add (&ts, year_or_month_tz_tweak, "minute");
ts_add (&ts, n, part);
if (year_or_month_tz_tweak)
ts_add (&ts, -year_or_month_tz_tweak, "minute");
res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
GMTimestamp_struct_to_dt (&ts, res);
DT_SET_TZ (res, DT_TZ (dt));
if (DT_TYPE_DATE == dt_type
&& (0 == stricmp (part, "year") || 0 == stricmp (part, "month") || 0 == stricmp (part, "day")))
DT_SET_DT_TYPE (res, dt_type);
DT_AUDIT_FIELDS (dt);
return res;
}
caddr_t bif_im_ConvertImageFile (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
bif_string_arg (qst, args, 1, "IM ConvertImageFile");
im_init (&env, qst, args, "IM ConvertImageFile");
im_env_set_filenames (&env, 0, 1);
im_read (&env);
im_write (&env);
im_leave (&env);
return(0);
}
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 caddr_t
bif_mts_status (caddr_t* qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t param_str =
bif_string_arg (qst, args, 0, "mts_status");
if (!stricmp("TRANSACTION",param_str))
{
return (caddr_t)mts_transaction_status(QI_TRX(QST_INSTANCE(qst)));
} else if (!stricmp("MTS",param_str))
{
return (caddr_t)mts_server_status();
}
sqlr_error("MX000", "unknown parameter %s", param_str);
return 0;
};
caddr_t
bif_date_diff (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t unit = bif_string_arg (qst, args, 0, "datediff");
caddr_t dt1 = bif_date_arg (qst, args, 1, "datediff");
caddr_t dt2 = bif_date_arg (qst, args, 2, "datediff");
boxint s1 = (boxint)DT_DAY (dt1) * 24 * 60 * 60 + (boxint)DT_HOUR (dt1) * 60 * 60 + (boxint)DT_MINUTE (dt1) * 60 + DT_SECOND (dt1);
boxint s2 = (boxint)DT_DAY (dt2) * 24 * 60 * 60 + (boxint)DT_HOUR (dt2) * 60 * 60 + (boxint)DT_MINUTE (dt2) * 60 + DT_SECOND (dt2);
int frac1, frac2;
int diffyear, diffmonth;
if (0 == stricmp (unit, "day"))
return box_num ((boxint)DT_DAY (dt2) - (boxint)DT_DAY (dt1));
if (0 == stricmp (unit, "hour"))
return box_num ((s2 - s1) / (60 * 60));
if (0 == stricmp (unit, "minute"))
return box_num ((s2 - s1) / 60);
if (0 == stricmp (unit, "second"))
return box_num (s2 - s1);
diffyear = !stricmp (unit, "year");
diffmonth = (diffyear ? 0 : !stricmp (unit, "month"));
if (diffyear || diffmonth)
{
TIMESTAMP_STRUCT ts1;
TIMESTAMP_STRUCT ts2;
int tz_tweak = DT_TZ (dt1);
dt_to_GMTimestamp_struct (dt2, &ts2);
dt_to_GMTimestamp_struct (dt1, &ts1);
ts_add (&ts1, tz_tweak, "minute");
ts_add (&ts2, tz_tweak, "minute");
if (diffyear)
return box_num ((boxint)ts2.year - (boxint)ts1.year);
if (diffmonth)
return box_num ((boxint)(ts2.year * 12 + ts2.month) - (boxint)(ts1.year * 12 + ts1.month));
}
frac1 = DT_FRACTION(dt1);
frac2 = DT_FRACTION(dt2);
if (0 == stricmp (unit, "millisecond"))
return box_num ((s2 - s1) * (boxint)1000 + (frac2 / 1000000 - frac1 / 1000000));
if (0 == stricmp (unit, "microsecond"))
return box_num ((s2 - s1) * (boxint)1000000 + (frac2 / 1000 - frac1 / 1000));
if (0 == stricmp (unit, "nanosecond"))
return box_num ((s2 - s1) * (boxint)1000000000 + (frac2 - frac1));
sqlr_new_error ("22023", "DT002", "Bad unit in datediff: %s.", unit);
return NULL;
}
caddr_t
bif_im_get_impl (caddr_t * qst, caddr_t * err, state_slot_t ** args, int is_file_in, int op, const char *bifname)
{
im_env_t env;
char *strg_value = NULL;
unsigned long ul_value = 0;
caddr_t res = NULL;
int is_string_res = (('A' == op) || ('F' == op) || ('I' == op));
int is_list_res = ('2' == op);
int is_key_needed = ('A' == op);
caddr_t key = is_key_needed ? bif_string_arg (qst, args, (is_file_in ? 1 : 2), bifname) : NULL;
im_init (&env, qst, args, bifname);
if (is_file_in)
im_env_set_filenames (&env, 0, -1);
else
{
im_env_set_input_blob (&env, 0);
im_env_set_blob_ext (&env, (is_key_needed ? 3 : 2), -1);
}
im_read (&env);
MagickResetIterator(env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
switch (op)
{
case 'A': strg_value = MagickGetImageAttribute (env.ime_magick_wand, key); break;
case 'F': strg_value = MagickGetImageFormat (env.ime_magick_wand); break;
case 'I': strg_value = MagickIdentifyImage (env.ime_magick_wand); break;
case 'W': ul_value = MagickGetImageWidth (env.ime_magick_wand); break;
case 'H': ul_value = MagickGetImageHeight (env.ime_magick_wand); break;
case 'D': ul_value = MagickGetImageDepth (env.ime_magick_wand); break;
case '2':
ul_value = MagickGetImageWidth (env.ime_magick_wand);
if (ul_value)
{
dk_free_tree (res);
res = dk_alloc_box (2 * sizeof (caddr_t), DV_ARRAY_OF_POINTER);
((caddr_t *)res)[0] = box_num (ul_value);
((caddr_t *)res)[1] = box_num (MagickGetImageHeight (env.ime_magick_wand));
}
break;
}
}
if (is_string_res)
{
if (strg_value)
{
res = box_dv_short_string (strg_value);
MagickRelinquishMemory (strg_value);
}
}
else if (!is_list_res)
{
if (ul_value)
res = box_num (ul_value);
}
if (NULL == res)
res = NEW_DB_NULL;
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;
}
}
