static bool pbind_vars(obj* vars, obj lt){
obj utype;
switch(lt->type){
default:
break;
case tSymbol:
if(vars) add_assoc(vars, lt, nil);
return true;
case tRef:
assert(0);
let(&(uref(lt)), nil);
return true;
case INT:
assert(0);
// return equal(lt,rt);
case tOp:
utype = search_assoc(curr_interp->types, ult(lt));
if(utype){
return pbind_vars(vars, urt(lt));
}
pbind_vars(vars, ult(lt));
return pbind_vars(vars, urt(lt));
case LIST:
list x=ul(lt);
for(; (x); x=rest(x)){
pbind_vars(vars, first(x));
}
return true;
}
print(lt);
assert(0);
return nil;
}
unsigned short limit_test ( void )
{
unsigned short ra;
short sa;
for(ra=0;;ra++) if(ult(ra,7)==0) break;
hexstring(ra);
if(ra!=7) return(1);
for(ra=0xF000;;ra++) if(ult(ra,0xF007)==0) break;
hexstring(ra);
if(ra!=0xF007) return(1);
for(sa=-7;;sa++) if(slt(sa,7)==0) break;
hexstring(sa);
if(sa!=7) return(1);
for(sa=-17;;sa++) if(slt(sa,-7)==0) break;
hexstring(sa);
if(sa!=-7) return(1);
for(ra=0;;ra++) if(ulte(ra,7)==0) break;
hexstring(ra);
if(ra!=8) return(1);
for(ra=0xF000;;ra++) if(ulte(ra,0xF007)==0) break;
hexstring(ra);
if(ra!=0xF008) return(1);
for(ra=0xF000;;ra++) if(ulte(ra,7)==0) break;
hexstring(ra);
if(ra!=0xF000) return(1);
for(sa=-7;;sa++) if(slte(sa,7)==0) break;
hexstring(sa);
if(sa!=8) return(1);
for(sa=-17;;sa++) if(slte(sa,-7)==0) break;
hexstring(sa);
if(sa!=-6) return(1);
for(ra=0;;ra++) if(ugt(ra,7)) break;
hexstring(ra);
if(ra!=8) return(1);
for(ra=0xF000;;ra++) if(ugt(ra,0xF007)) break;
hexstring(ra);
if(ra!=0xF008) return(1);
for(ra=0;;ra++) if(ugte(ra,7)) break;
hexstring(ra);
if(ra!=7) return(1);
for(ra=0xF000;;ra++) if(ugte(ra,0xF007)) break;
hexstring(ra);
if(ra!=0xF007) return(1);
return(0);
}
obj pop(obj* v){
obj lt = retain(ult(*v));
obj rt = retain(urt(*v));
release(*v);
*v = rt;
return lt;
}
static bool bind_vars(obj* vars, obj lt, obj rt){
obj utype;
switch(lt->type){
default:
break;
case tSymbol:
if(macromode){
if(obj rr = search_assoc(car(macro_env), lt)){
//macromode = false;
if(vars) add_assoc(vars, rr, rt);
//macromode = true;
return true;
}
}
if(vars) add_assoc(vars, lt, rt);
return true;
case tRef:
let(&(uref(lt)), rt);
return true;
case INT:
return equal(lt, rt);
case tOp:
utype = search_assoc(curr_interp->types, ult(lt));
if(utype){
if(vrInt(utype) != rt->type) return false;
return bind_vars(vars, urt(lt), uref(rt));
}
if(rt->type!=tOp) return false;
if(! bind_vars(vars, ult(lt), ult(rt))) return false;
return bind_vars(vars, urt(lt), urt(rt));
case LIST:
if(rt->type!=LIST) return false;
list x=ul(lt), a=ul(rt);
for(; (x && a); x=rest(x),a=rest(a)){
if(!bind_vars(vars, first(x), first(a))) return false;
}
if(x||a) return false;
return true;
}
print(lt);
assert(0);
return nil;
}
SHELL void sign_up()
{
clrvar(user.mptr);
clrvar(user.var);
user.number=user.member+1;
ult(user.number)->mpost =0;
ult(user.number)->post =0;
ult(user.number)->mlogin=0;
ult(user.number)->login =0;
setvar("mpost","0",user.var);
setvar("post","0",user.var);
setvar("mlogin","0",user.var);
setvar("login","0",user.var);
for(;;)
{
setvar("pass","",user.var);
msgout(IC_act "今からサインアップを行います。");
user_chk(1);
user_rep(user.member+1);
user_disp();
msgout(IC_act "以上でよろしいでしょうか？");
if (ynq())
break;
msgout(IC_act "中止しますか？");
if (ynq())
{
user_guest("");
return;
}
}
user_add();
user_write();
sys_log("| User登録");
where_seta();
}
static obj do_assign(obj lt, obj rt){
switch(type(lt)) {
case tRef:
return retain(*let(&(uref(lt)), rt));
case tSymbol:
return retain(*let(lfind_var(lt),rt));
default:
break;
case tInd:{
obj *var;
var = lfind_var(ult(lt));
if(!*var) error("the vector does not exist.");
if((*var)->refcount > 1){
obj nv = copy(*var);
release(*var);
*var = nv;
myPrintf("performance alert: copy");
}
obj inds = eval(urt(lt));
doLInd(var, ul(inds), rt);
release(inds);
return retain(rt);
}
case LIST:
return applyCC(do_assign, lt, rt);
if(type(rt)!=LIST) error("list<-nonlist");
list s = ul(rt);
for(list l = ul(lt); l; l=rest(l), s=rest(s)){
if(! s) error("number is not enough for rhs.");
do_assign(first(l),first(s));
}
if(s) error("too much for rhs.");
return nil;
}
print(lt);
assert(0);
return nil;
}
void ulist_rep(uint i,var_t *v)
{
char *p;
struct tm tm;
p=getvar("memo",v);
if (p==NULL)
p="メモなし。";
lstrcpy(ult(i)->memo ,nps(p,LN_memo));
lstrcpy(ult(i)->hoby ,nps(getvar("hoby",v),LN_memo));
lstrcpy(ult(i)->id ,nps(getvar("id",v),0));
lstrcpy(ult(i)->pass ,nps(getvar("pass",v),0));
lstrcpy(ult(i)->handle,nps(getvar("handle",v),LN_handle));
ult(i)->mpost =atoi(getvar("mpost",v));
ult(i)->post =atoi(getvar("post",v));
ult(i)->mlogin=atoi(getvar("mlogin",v));
ult(i)->login =atoi(getvar("login",v));
dtotm(getvar("birth",v),&tm);
ult(i)->birthm=tm.tm_mon;
ult(i)->birthd=tm.tm_mday;
ult(i)->wp =atoi(getvar("wp",v));
}
obj eval(obj exp){
ev: assert(!! exp);
obj rr,lt, rt;
switch (exp->type) {
case tInd:
return doInd(eval(ult(exp)), ul(eval(urt(exp))));
case LIST:
return List2v(evalList(ul(exp)));
case tArray:
return map_obj(eval, exp);
case tAnd:
return prod_eval(ul(exp), mult);
case MULT:
return prod_eval(ul(exp), mult);
case ARITH:
return prod_eval(ul(exp), add);
case POW:
return prod_eval(ul(exp), power);
case DIVIDE:
return prod_eval(ul(exp), divide);
case tRef:
return retain(uref(exp));
case tSymbol:
if( macromode) {
if(obj rr = search_assoc(car(macro_env), exp)){
macromode = false;
// macro lexical scope should be pushed to the stack here
rr = exec(rr);
macromode = true;
return rr;
}
}
return eval_symbol(exp);
case tMinus:
lt = eval(uref(exp));
rr = uMinus(lt); // releasing
if(rr) {release(lt); return rr;}
static obj symumn = Symbol("-");
rr = udef_op0(symumn, lt);
if(rr) {release(lt); return rr;}
error("uMinus: not defined to that type");
case tReturn:
if(! uref(exp)) return encap(tSigRet, nil);
return encap(tSigRet, eval(uref(exp)));
case tBreak:
return retain(exp);
case CONDITION:
return evalCond(exp);
case tOp:
if(type(ult(exp)) ==tSymbol) {
lt = search_assoc(curr_interp->types, ult(exp));
if(lt) return encap((ValueType)vrInt(lt), eval(urt(exp)));}
lt = eval(ult(exp));
push(lt);
switch(lt->type){
case tCont:
assert(0);
case tSpecial:
rr = ufn(lt)(urt(exp));
break;
case tSyntaxLam:
rr = macro_exec(lt, urt(exp));
break;
case tInternalFn:
case tClosure:
rt = eval(urt(exp));
rr = eval_function(lt, rt);
break;
default:
rt = eval(urt(exp));
rr = call_fn(mult, lt, rt);
release(rt);
}
release(pop(&is));
return rr;
case tClosure:
assert(0);
case tCurry:
return eval_curry(exp, em0(exp));
/* obj vars = Assoc();
bind_vars(&vars, em0(exp), em2(exp));
rr = eval_curry(exp, vars);
release(vars);
return rr;
*/ case tArrow:
// return enclose(exp);
/* if(macromode){
if(obj rr = search_assoc(car(macro_env), exp)){
}
}
*/ return render(tClosure, list3(retain(em0(exp)), retain(em1(exp)), retain(env)));
case tDefine:
return func_def(em0(exp), em1(exp), em2(exp));
case tSyntaxDef:
let(lfind_var(em0(exp)), render(tSyntaxLam, list3(retain(em1(exp)), retain(em2(exp)), nil)));
return nil;
case tExec:
return exec(exp);
case tAssign:
lt = car(exp);
if(type(lt)==tOp){
return func_def(ult(lt), urt(lt), cdr(exp));
} else if(type(lt)==tMinus){
static obj symumn = Symbol("-");
return func_def(symumn, uref(lt), cdr(exp));
} else return do_assign(lt, eval(cdr(exp)));
case tIf:
rr = eval(em0(exp));
if (type(rr) != INT) error("if: Boolean Expected");
if (vrInt(rr)) {
rr = em1(exp);
} else {
rr = em2(exp);
}
return eval(rr);
case tWhile:
for(;;) {
rr = eval(car(exp));
if (type(rr) != INT) error("while: Boolean expected");
if(!vrInt(rr)) break;
rr = exec(cdr(exp));
if(rr && type(rr)==tSigRet) return rr;
if(rr && type(rr)==tBreak) {release(rr); break;}
if(rr) release(rr);
}
return nil;
default:
return retain(exp);
}
}
bool operator()(const small_bv& v1, const small_bv& v2)
{
bv_ult <small_bv, bool> ult;
return (v1.msb() && !v2.msb()) || ((v1.msb() == v2.msb()) && ult(v1, v2));
}
