static int
_report_error(int err,
dident arg1, /* any arity */
dident module, /* arity 0 */
type mod_tag)
{
int res;
pword *old_tg = TG;
pword *tg = TG;
pword mod, goal;
Make_Struct(&goal, TG);
Push_Struct_Frame(d_.syserror); ++tg;
Make_Integer(tg, -err); ++tg;
Make_Struct(tg, TG); ++tg;
tg->val.did = module;
tg++->tag.all = mod_tag.all;
tg->val.did = module;
tg++->tag.all = mod_tag.all;
Push_Struct_Frame(d_.quotient); ++tg;
Make_Atom(tg, add_dict(arg1,0)); ++tg;
Make_Integer(tg, DidArity(arg1));
mod.val.did = d_.kernel_sepia;
mod.tag.kernel = ModuleTag(d_.kernel_sepia);
res = query_emulc(goal.val, goal.tag, mod.val, mod.tag);
TG = old_tg;
return res;
}
static int
p_tool_body(value vi, type ti, value vb, type tb, value vmb, type tmb, value vm, type tm)
{
dident di;
pri *procb, *proci;
int flags, arity;
dident module;
dident pdid;
pword *ptr = Gbl_Tg;
vmcode *code;
int err;
Prepare_Requests;
Check_Module(tm, vm);
Get_Proc_Did(vi, ti, di);
if (!IsRef(tb)
&& (!IsStructure(tb)
|| vb.ptr->val.did != d_.quotient))
{
Bip_Error(TYPE_ERROR);
}
Check_Output_Atom_Or_Nil(vmb, tmb);
if (!(proci = visible_procedure(di, vm.did, tm, PRI_CREATE)))
{
Get_Bip_Error(err);
Bip_Error(err);
}
if (!_tool_body(proci, &pdid, &arity, &module))
{
Get_Bip_Error(err);
Bip_Error(err);
}
Gbl_Tg += 3;
Check_Gc;
ptr[0].tag.kernel = TDICT;
ptr[0].val.did = d_.quotient;
ptr[1].tag.kernel = TDICT;
ptr[1].val.did = add_dict(pdid, 0);
ptr[2].tag.kernel = TINT;
ptr[2].val.nint = arity;
Request_Unify_Atom(vmb, tmb, module);
Request_Unify_Structure(vb, tb, ptr);
Return_Unify;
}
/*
* visible_op(functor, module) return a pointer to the visible operator
* under functor (an infix operator if functor is arity 2, an unary operator
* if functor is of arity 1 (if a prefix and a postfix are visible,
* the prefix is returned).
* return 0 if no operator is visible from module under functor.
* NOTE : when there is a prefix/postfix conflict, a local declaration
* should be return when there is one (e.g. local postfix and global prefix).
*/
opi*
visible_op(dident functor, dident module, type mod_tag, int *res)
{
opi *operator_prop;
int arity;
dident atom = add_dict(functor, 0);
if ((arity = DidArity(functor)) == 1)
{
/* look for a unary operator: first try FX,FY then XF,YF */
operator_prop = visible_prefix_op(atom, module, mod_tag, res);
/* visible_prefix_op() also finds FXX and FXY: ignore them here */
if (!operator_prop || IsPrefix2(operator_prop))
{
/* no unary prefix, look for postfix */
operator_prop = visible_postfix_op(atom, module, mod_tag, res);
}
}
else if (arity == 2)
{
/* look for a binary operator, first try XFX,XFY,YFX then FXX,FXY */
operator_prop = visible_infix_op(atom, module, mod_tag, res);
if (!operator_prop)
{
/* no infix, look for binary prefix */
operator_prop = visible_prefix_op(atom, module, mod_tag, res);
if (operator_prop && !IsPrefix2(operator_prop))
operator_prop = (opi *) 0;
}
}
else /* arity != 1 && arity != 2 so it is not an operator */
{
*res = PERROR; /* means no operator */
return 0;
}
return operator_prop;
}
/*
_insert_op( scope, preced, assoc, oper, module, mod_tag)
An insertion is made in the operator property list if there are
no conflict of associativity (postfix and infix).
However a local postfix/infix hide a global one so that
the conflict is impossible between a local and a global.
A local operator can not be modified in a locked module if the
module tag is not signed.
The precedence 0 is used to hide a global operator.
*/
static int
_insert_op(int scope, word preced, word assoc, dident oper, dident module, type mod_tag)
{
opi *operator_prop;
int prop_type;
int arity;
int res;
switch (assoc)
{
case XF:
case YF:
prop_type = POSTFIX_PROP;
arity = 1;
break;
case FX:
case FY:
prop_type = PREFIX_PROP;
arity = 1;
break;
case FXX:
case FXY:
prop_type = PREFIX_PROP;
arity = 2;
break;
case XFX:
case XFY:
case YFX:
prop_type = INFIX_PROP;
arity = 2;
break;
}
/* Disallow infix/postfix, if required by the module syntax */
if (prop_type != PREFIX_PROP && ModuleSyntax(module)->options & ISO_RESTRICTIONS)
{
if (OperatorItem(oper, module, mod_tag, VISIBLE_PROP,
(prop_type==INFIX_PROP? POSTFIX_PROP : INFIX_PROP), &res))
{
Bip_Error(ILLEGAL_OP_DEF);
}
}
a_mutex_lock(&PropertyLock);
res = PERROR;
operator_prop = OperatorItem(oper, module, mod_tag, scope, prop_type, &res);
if (operator_prop) /* same scope operator exists already */
{
if (preced && (GetOpiAssoc(operator_prop) != assoc ||
GetOpiPreced(operator_prop) != preced)) {
res = REDEF_OPERATOR;
} else {
res = PSUCCEED;
}
}
else
{
if (res != PERROR)
{
a_mutex_unlock(&PropertyLock);
Bip_Error(res);
}
/* No proper scope operator exists yet */
/* For locals, check hiding */
if (scope == LOCAL_PROP &&
OperatorItem(oper, module, mod_tag, GLOBAL_PROP, prop_type, &res))
res = HIDING_OPERATOR;
else
res = PSUCCEED;
operator_prop = NewOperatorItem(oper, module, mod_tag,
scope, prop_type, &res);
if (!operator_prop)
{
a_mutex_unlock(&PropertyLock);
Bip_Error(res);
}
}
/* now update the descriptor */
operator_prop->tag.kernel = TDICT;
Set_Opi_Assoc(operator_prop, assoc);
Set_Opi_Preced(operator_prop, preced);
OpiDid(operator_prop) = add_dict(oper, arity);
DidIsOp(oper) |= PropToFix(prop_type);
a_mutex_unlock(&PropertyLock);
if (res < 0)
{Bip_Error(res)}
return res;
}
void init_dict( SPELLEROBJ * st )
{
st->entries=0;
add_dict(st,2,"Wörter ->","\3");
add_dict(st,1,"<_G.,!?","< \2.,!?");
add_dict(st,1,"enis","enis");
add_dict(st,1,"ratd","ratd");
add_dict(st,1,"hulc","hulc");
add_dict(st,1,"gmobp","gmobp");
add_dict(st,1,"vwfkz","vwfkz");
add_dict(st,1,"jyxqäöü","jyxqäöü");
add_dict(st,1,"012345678","0123456789");
//add_dict(st,2,"Text senden","\1");
add_dict(st,1,"F12345678","F12345678");
st->dict[(st->entries)-1].data[1]=10;
st->dict[(st->entries)-1].data[2]=11;
st->dict[(st->entries)-1].data[3]=12;
st->dict[(st->entries)-1].data[4]=13;
st->dict[(st->entries)-1].data[5]=14;
st->dict[(st->entries)-1].data[6]=15;
st->dict[(st->entries)-1].data[7]=16;
st->dict[(st->entries)-1].data[8]=17;
add_dict(st,2,"Wörterbücher","\4");
st->dict[START_WORDS].type=0;st->dict[START_WORDS].count=0;
st->wordcount=0;
}
bool add_dict(dict *d, char *key, int type, ...)
{
uint32_t key_index = 0;
int count = 0;
dictEntry *de = NULL;
va_list value_ptr;
char *string_value_ptr = NULL;
va_start(value_ptr, type);
if (key == NULL || strlen(key) == 0)
{
printf("Enpty key.\n");
return false;
}
if (exist_key(d, key) == true)
{
printf("Exist a same key.\n");
return false;
}
if (d->rehash_index == -1)
{
if(d->hash_table[0].size <= d->hash_table[0].used )
{
d->hash_table[1].table = (dictEntry **)calloc(growth_size(d->hash_table[0].used ), sizeof(dictEntry *));
for (count = 0; count < growth_size(d->hash_table[0].used); count ++)
{
d->hash_table[1].table[count] = NULL; //pointer
}
d->hash_table[1].size = growth_size(d->hash_table[0].used);
d->hash_table[1].size_mask = d->hash_table[1].size - 1;
d->hash_table[1].used = 0;
d->rehash_index = 0;
single_rehash_dict(d);
switch (type) {
case BOOL_FALSE:
{
add_dict(d, key, type);
}
break;
case BOOL_TRUE:
{
add_dict(d, key, type);
}
break;
case INTTYPE:
{
add_dict(d, key, type, va_arg(value_ptr, long));
}
break;
case DECIMALTYPE:
{
add_dict(d, key, type, va_arg(value_ptr, double));
}
break;
case STRINGTYPE:
{
add_dict(d, key, type, va_arg(value_ptr, char *));
}
break;
case OBJECTTYPE:
{
add_dict(d, key, type, va_arg(value_ptr, void *));
}
break;
default:
{
printf("value type is error.\n");
return false;
}
break;
}
}
else
{
key_index = murmurhash(key, (uint32_t )strlen(key), MMHASH_SEED);
key_index = key_index & d->hash_table[0].size_mask;
de = (dictEntry *)calloc(1, sizeof(dictEntry));
de->key = (char *)calloc(strlen(key) + 1, sizeof(char));
memcpy(de->key, key, strlen(key));
switch (type) {
case BOOL_FALSE:
{
de->value_type = BOOL_FALSE;
de->value.bool_value = false;
}
break;
case BOOL_TRUE:
{
de->value_type = BOOL_TRUE;
de->value.num_value = true;
}
break;
case INTTYPE:
{
de->value_type = INTTYPE;
de->value.num_value = va_arg(value_ptr, long);
}
break;
case DECIMALTYPE:
{
de->value_type = DECIMALTYPE;
de->value.decimal_value = va_arg(value_ptr, double);
}
break;
case STRINGTYPE:
{
de->value_type = STRINGTYPE;
string_value_ptr = va_arg(value_ptr, char *);
de->value.string_value = (char *)calloc (strlen(string_value_ptr) + 1, sizeof(char));
memcpy(de->value.string_value, string_value_ptr, strlen(string_value_ptr));
}
break;
case OBJECTTYPE:
{
de->value_type = OBJECTTYPE;
de->value.object_value = va_arg(value_ptr, void *);
}
break;
default:
{
printf("value type is error.\n");
return false;
}
break;
}
de->next = d->hash_table[0].table[key_index];
d->hash_table[0].table[key_index] = de;
d->hash_table[0].used++;
}
}
if (exist_key(d, key) == false)
{
if (d->rehash_index != -1)
{
key_index = murmurhash(key, (uint32_t )strlen(key), MMHASH_SEED);
key_index = key_index & d->hash_table[1].size_mask;
de = (dictEntry *)calloc(1, sizeof(dictEntry));
de->key = (char *)calloc(strlen(key) + 1, sizeof(char));
memcpy(de->key, key, strlen(key));
switch (type) {
case INTTYPE:
{
de->value_type = INTTYPE;
de->value.num_value = va_arg(value_ptr, long);
}
break;
case DECIMALTYPE:
{
de->value_type = DECIMALTYPE;
de->value.decimal_value = va_arg(value_ptr, double);
}
break;
case STRINGTYPE:
{
de->value_type = STRINGTYPE;
string_value_ptr = va_arg(value_ptr, char *);
de->value.string_value = (char *)calloc (strlen(string_value_ptr) + 1, sizeof(char));
memcpy(de->value.string_value, string_value_ptr, strlen(string_value_ptr));
}
break;
case OBJECTTYPE:
{
de->value_type = OBJECTTYPE;
de->value.object_value = va_arg(value_ptr, void *);
//can't delete value
}
break;
default:
{
printf("value type is error.\n");
return false;
}
break;
}
de->next = d->hash_table[1].table[key_index];
d->hash_table[1].table[key_index] = de;
d->hash_table[1].used++;
}
}
