bool SpanningTreeProtocolInterface::SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const parameterlist& params, User* source) { if (!source) source = ServerInstance->FakeClient; CmdBuilder encap(source, "ENCAP"); // Are there any wildcards in the target string? if (targetmask.find_first_of("*?") != std::string::npos) { // Yes, send the target string as-is; servers will decide whether or not it matches them encap.push(targetmask).push(cmd).insert(params).Broadcast(); } else { // No wildcards which means the target string has to be the name of a known server TreeServer* server = Utils->FindServer(targetmask); if (!server) return false; // Use the SID of the target in the message instead of the server name encap.push(server->GetID()).push(cmd).insert(params).Unicast(server->ServerUser); } return true; }
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); } }
obj subs0(obj v, obj * vars){ assert(!! v); switch(v->type){ case tSymbol: if(vars){ // macro obj vp = search_assoc(*vars, v); if(vp) return vp; // vp = searchFunc(v, specials); // if(vp) {release(vp); return retain(v);} obj (*func)(obj) = searchFunc(v, specials); if(func) return retain(v); vp = find_var(v); if(vp) {release(vp); return retain(v);} assert(0); // return ref2var(add_assoc(*vars, v, Null())); } else { // quasi-quote obj vp = find_var(v); if(vp) return vp; return retain(v); } case tAssign:{ obj vp = search_assoc(*vars, car(v)); //macro-locals if(vp) goto nex; /* vp = searchFunc(car(v), specials); // not needed because cant assign to global if(vp) {release(vp); vp = retain(v); return vp;} vp = find_var(v); if(vp) {release(vp); vp = retain(v); return vp;} */ vp = ref2var(nil); add_assoc(vars, car(v), vp); nex: return operate(tAssign, vp, subs0(cdr(v), vars)); } case tArray:{ obj r = aArray(uar(v).size); for(int i=0; i < uar(v).size; i++) uar(r).v[i] = subs0(uar(v).v[i], vars); return r; } case LIST: //list case POW: case MULT: case DIVIDE: case ARITH: case CONDITION: case tIf: case tExec: { list l = phi(); for(list s=ul(v); s; s=rest(s)) l = cons(subs0(first(s), vars), l); return render(type(v), reverse(l)); } case tReturn: if(!uref(v)) return retain(v); case tMinus: return encap(v->type, subs0(uref(v), vars)); case tClosure: case tArrow: return render(type(v), list3(subs0(em0(v),vars), subs0(em1(v), vars), nil)); case tDefine: case tSyntaxDef: assert(0); case tInd: case tWhile: { obj st = subs0(cdr(v), vars); if(type(st)==LIST) st->type = tExec; return operate(v->type, subs0(car(v), vars), st); } case tOp: return operate(v->type, subs0(car(v), vars), subs0(cdr(v), vars)); case INT: case tDouble: case TOKEN: case tNull: case tLAVec: case tDblArray: case tIntArr: case tDblAr2: case IMAGE: case STRING: case tBreak: return retain(v); default: break; } print(v); assert(0); return v; }