caddr_t
bif_string_time (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t str = bif_string_or_wide_or_null_arg (qst, args, 0, "stringtime");
caddr_t res;
char temp[100];
char *txt;
caddr_t err_msg = NULL;
if (!str)
sqlr_new_error ("22002", "DT009", "Nulls not allowed as parameters to stringtime");
if (DV_WIDESTRINGP (str))
{
box_wide_string_as_narrow (str, temp, sizeof (temp), QST_CHARSET (qst));
txt = temp;
}
else
txt = str;
res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
odbc_string_to_time_dt (txt, res, &err_msg);
if (NULL != err_msg)
{
caddr_t err = srv_make_new_error ("22007", "DT010", "Can't convert '%s' to time : %s", str, err_msg);
dk_free_box (err_msg);
dk_free_box (res);
sqlr_resignal (err);
}
return res;
}
void
row_print_wide (caddr_t thing, dk_session_t * ses, dbe_column_t * col,
caddr_t * err_ret, dtp_t dtp, wcharset_t * wcharset)
{
switch (dtp)
{
case DV_STRING:
if (0 > print_narrow_string_as_wide (ses, (unsigned char *) thing, wcharset))
{
caddr_t err = NULL;
err = srv_make_new_error ("22005", "IN009",
"Bad value for wide string column %s, dtp = %d.",
col->col_name, dtp);
if (err_ret)
*err_ret = err;
else
sqlr_resignal (err);
return;
}
break;
case DV_WIDE:
wide_serialize (thing, ses);
break;
default:
{
caddr_t err = NULL;
err = srv_make_new_error ("22005", "IN011",
"Bad value for wide string column %s, type=%s.", col->col_name, dv_type_title (dtp));
if (err_ret)
*err_ret = err;
else
sqlr_resignal (err);
}
break;
}
}
void
im_leave_with_error (im_env_t *env, const char *code, const char *virt_code, const char *string, ...)
{
static char temp[2000];
va_list lst;
caddr_t err;
va_start (lst, string);
vsnprintf (temp, sizeof (temp), string, lst);
va_end (lst);
temp[sizeof(temp)-1] = '\0';
err = srv_make_new_error (code, virt_code, "Function \"%s\"(): %.2000s", env->ime_bifname, temp);
im_dbg_printf (("IM %p: an error will be signalled: Function \"%s\"(): %.2000s\n", env, env->ime_bifname, temp));
im_leave (env);
sqlr_resignal (err);
}
caddr_t
string_to_time_dt_box (char * str)
{
caddr_t res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
caddr_t err_msg = NULL;
odbc_string_to_time_dt (str, res, &err_msg);
if (NULL != err_msg)
{
caddr_t err = srv_make_new_error ("22007", "DT011", "Cannot convert %s to time : %s", str, err_msg);
dk_free_box (err_msg);
dk_free_box (res);
sqlr_resignal (err);
}
return res;
}
void
virt_mono_throw_unhandled_exception (MonoObject *exc)
{
caddr_t err;
char *message = (char *) "";
const char *name = (const char *) "";
MonoString *str;
MonoMethod *method;
MonoClass *klass;
gboolean free_message = FALSE;
gint i;
if (mono_object_isinst (exc, mono_get_exception_class ()))
{
klass = mono_object_get_class (exc);
method = NULL;
while (klass && method == NULL)
{
gpointer m_iter = NULL;
for (method = mono_class_get_methods (klass, &m_iter); method != NULL;
method = mono_class_get_methods (klass, &m_iter))
{
MonoMethodSignature *sig = mono_method_signature (method);
guint32 flags = 0;
const char *name = mono_method_get_name (method);
mono_method_get_flags (method, &flags);
if (!strcmp ("ToString", name) &&
sig->param_count == 0
#ifdef OLD_KIT_1_1_5
&& (flags & METHOD_ATTRIBUTE_VIRTUAL)
&& (flags & METHOD_ATTRIBUTE_PUBLIC)
#endif
)
{
break;
}
method = NULL;
}
if (method == NULL)
klass = mono_class_get_parent (klass);
}
g_assert (method);
str = (MonoString *) mono_runtime_invoke (method, exc, NULL, NULL);
if (str) {
message = mono_string_to_utf8 (str);
free_message = TRUE;
name = mono_class_get_name (klass);
}
}
/*
* g_printerr ("\nUnhandled Exception: %s.%s: %s\n", exc->vtable->klass->name_space,
* exc->vtable->klass->name, message);
*/
g_printerr ("\nUnhandled Exception: %s\n", message);
err = srv_make_new_error ("42000", "MN001", "Unhandled Mono Exception [%.200s]: %.200s",
name, message);
if (free_message)
g_free (message);
sqlr_resignal (err);
}
static caddr_t
sa_to_dk (MonoArray *mono_list, int ofs, int mode, void *udt)
{
guint32 ret_type;
int clr_object = 0;
MonoObject *type, *value;
caddr_t ret = NULL;
MonoClass *cls;
int len = mono_array_length (mono_list), inx;
dk_set_t ret_set = NULL;
type = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + 0);
ret_type = *(guint32 *)((char *)type + sizeof (MonoObject));
if (!ret_type)
{
char *error_text;
caddr_t err = NULL;
value = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + 1);
error_text = mono_string_to_utf8 ((MonoString *)value);
if (error_text)
err = srv_make_new_error ("42000", "MN002", "Mono error : %.200s",
mono_class_get_name (mono_object_get_class (value)), error_text);
else
err = srv_make_new_error ("42000", "MN003", "Unknown mono error");
g_free (error_text);
sqlr_resignal (err);
}
/* get type of object */
clr_object = 0;
if (ret_type == 5 || ret_type == 6)
clr_object = 1;
for (inx = 1; inx < len; inx++)
{
value = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + inx);
if (value)
{
cls = mono_object_get_class (value);
if (cls == mono_get_int32_class ())
{
gint32 v = *(gint32 *)((char *)value + sizeof (MonoObject));
if (clr_object)
{
void * what_udt;
if (mode)
{
/*add_id (v);*/
ret = box_num (v);
}
else
{
what_udt = udt_find_class_for_clr_instance (v, udt);
if (what_udt)
{
/*add_id (v);*/
ret = cpp_udt_clr_instance_allocate (v, what_udt);
}
else
{
sqlr_new_error ("22023", "MN005", "Can't map Mono result to PL type");
}
}
}
else
ret = box_num (v);
}
else if (cls == mono_get_uint32_class())
ret = box_num (*(guint32 *)((char *)value + sizeof (MonoObject)));
else if (cls == mono_get_single_class ())
ret = box_float (*(float *)((char *)value + sizeof (MonoObject)));
else if (cls == mono_get_double_class ())
ret = box_double (*(double *)((char *)value + sizeof (MonoObject)));
else if (cls == mono_get_boolean_class ())
ret = box_num (*(guint8 *)((guint8 *)value + sizeof (MonoObject)));
else if (cls == mono_get_string_class ())
{
char *utf8 = mono_string_to_utf8 ((MonoString *)value);
ret = box_utf8_as_wide_char (utf8, NULL, strlen (utf8), 0, DV_WIDE);
g_free (utf8);
}
else
{
const char *name = mono_class_get_name (cls);
sqlr_new_error ("22023", "MN006", "Can't map CLR result of type (%s) to PL type",
name ? name : "<unknown>");
}
}
else
ret = NULL;
if (ret_type != 3 && ret_type != 4 && ret_type != 5)
return ret;
else
dk_set_push (&ret_set, ret);
}
return list_to_array (dk_set_nreverse (ret_set));
}
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;
}
}