sExpression *apply(sExpression *procOrLambda, sExpression *argument, sEnvironment *env){ if(isPrimitiveProc(procOrLambda)) { sProc *cfunc = toProc(procOrLambda); return applyProc(cfunc, argument); } else if(isLambdaType(procOrLambda)) { sLambda *lambd = toLambda(procOrLambda); sList *body = lambd->body; sList *arguments; sList *parameters; if(isList(argument)){ //可変長引数のため parameters = checkParameters(lambd->parameters, toList(argument)); arguments = checkArguments(parameters, toList(argument), lambd->isVarArgument); }else{ parameters = lambd->parameters; arguments = toList(cons(argument, &sNull)); } sEnvironment *env = extendEnvironment(parameters, arguments, lambd->frame); if(isList(car(body))){ return evalSequence(body, env); }else{ return eval(newExp(body, LIST_TAG), env); } } return &sNull; }
Bool isSyntaxRules(sExpression *exp){ if(isList(exp) && isSymbol(car(toList(exp)))){ if(strcmp(toSymb(car(toList(exp)))->name, "syntax-rules") == 0){ return TRUE; } } return FALSE; }
Bool isDefinitionSyntax(sExpression *exp){ if(isList(exp) && isSymbol(car(toList(exp)))){ if(strcmp(toSymb(car(toList(exp)))->name, "define-syntax") == 0){ return TRUE; } } return FALSE; }
sList *checkParameters(sList *parameters, sList *arguments){ sExpression *temp = checkParametersIter(newExp(parameters, LIST_TAG), newExp(arguments, LIST_TAG)); if(isList(temp)){ return toList(temp); }else{ return toList(cons(&sNull, &sNull)); } }
Bool defineVariable(sSymbol *symbol, sExpression *value, sEnvironment *env){ if(strcmp(symbol->name, "_error") != 0){ sExpression *exp = newExp(symbol, SYMBOL_TAG); putVars(toList(cons(exp, &sNull)), toList(cons(value, &sNull)), env->varmap); return TRUE; } return FALSE; }
static sExpression *assignValue(sExpression *exp){ if(isList(exp)){ sExpression *temp = cdr(toList( cdr(toList(exp)))); if(isList(temp)){ return car(toList(temp)); }else{ return temp; } } return &sNull; }
/* --------- define value --------------------- */ static sSymbol *definitionSymbol(sExpression *exp){ if(isList(exp)){ sExpression *temp = cadr(toList(exp)); if(isSymbol(temp)){ return toSymb(temp); }else{ return toSymb(car(toList(temp))); } } return toSymb(newSymbol("_error")); }
static sExpression *checkParametersIter(sExpression *parameters, sExpression *arguments){ if(isList(arguments)){ if(isList(parameters) && isSymbol(car(toList(parameters)))){ return cons(car(toList(parameters)), checkParametersIter(cdr(toList(parameters)), cdr(toList(arguments)))); }else{ return &sNull; } } return &sNull; }
static sExpression *checkArgumentsIter(sExpression *parameters, sExpression *arguments, Bool isVarArgument){ if(isList(parameters) && isList(arguments)){ if(isNull(cdr(toList(parameters))) && isVarArgument && isList(cdr(toList(arguments)))){ return cons(arguments, &sNull); }else{ return cons(car(toList(arguments)), checkArgumentsIter(cdr(toList(parameters)), cdr(toList(arguments)), isVarArgument)); } }else{ return arguments; } }
void telldata::argumentID::userStructListCheck(const telldata::tell_type& vartype, bool cmdUpdate) { for (argumentQ::iterator CA = _child.begin(); CA != _child.end(); CA++) if ( TLUNKNOWN_TYPE( (**CA)() ) ) (*CA)->userStructCheck(vartype, cmdUpdate); toList(cmdUpdate); }
LVal cons(void* v,LVal l) { struct Cons* ret=alloc(sizeof(struct Cons)); ret->val=(LVal)v; ret->type=0; ret->next=l; return (LVal)toList(ret); }
sExpression *cadr(sList *list){ sExpression *right = cdr(list); if(isList(right)){ return car(toList(right)); } return &sNull; }
sExpression *callProcSyntaxRules(sExpression *argument){ if(isList(argument)){ sExpression *body = cdr(toList(argument)); sExpression *temp = car(toList(argument)); sExpression *syntaxes = cons(car(toList(temp)), &sNull); sExpression *rules = cons(cadr(toList(temp)), &sNull); while(isList(body)){ temp = car(toList(body)); rules = cons(cadr(toList(temp)), rules); syntaxes = cons(car(toList(temp)), syntaxes); body = cdr(toList(body)); } return newSyntax(toList(rules), toList(syntaxes)); } return &sError; }
Bool isAssignment(sExpression *exp){ if(isList(exp)){ if(firstSymbol(toList(exp), "set!")){ return TRUE; } } return FALSE; }
//\! Take a string read in and evaluate it. ObjectPtr process(const char* str, Environment& env) { std::cout << "> " << str << std::endl; std::stringstream ss; ss << str; std::list<Token> tokens = toList(tokenize(ss)); return evaluate(tokens, env); }
Bool isDefinition(sExpression *exp){ if(isList(exp)){ if(firstSymbol(toList(exp), "define")){ return TRUE; } } return FALSE; }
Bool isIf(sExpression *exp){ if(isList(exp)){ if(firstSymbol(toList(exp), "if")){ return TRUE; } } return FALSE; }
/* ------------- assingment value ---------------------*/ static sSymbol *assignSynbol(sExpression *exp){ if(isList(exp)){ sExpression *temp = cadr(toList(exp)); if(isSymbol(temp)){ return toSymb(temp); } } return toSymb(newSymbol("_error")); }
sExpression *evalDefineSyntax(sExpression *exp, sEnvironment *env){ if(isDefinitionSyntax(exp) && isSyntaxRules( cadr(toList( cdr(toList(exp)))))){ sSymbol *name = toSymb(cadr(toList(exp))); sExpression *rules = cdr(toList( cdr(toList( cadr(toList( cdr(toList( exp)))))))); defineVariable(name, callProcSyntaxRules(rules), env); return &sTrue; } return &sError; }
DosQVariantArray *dos_qvariant_toArray(const DosQVariant *vptr) { auto variant = static_cast<const QVariant *>(vptr); QVariantList data = variant->toList(); auto result = new DosQVariantArray(); result->size = data.size(); result->data = new DosQVariant*[result->size]; for (int i = 0; i < result->size; ++i) result->data[i] = new QVariant(data[i]); return result; }
sExpression *evalIf(sList *arguments, sEnvironment *env){ sExpression *temp = cdr(arguments); if(isList(temp)){ sList *args = toList(temp); sExpression *predicate; if(LAZY_EVAL){ predicate = actualValue(car(args), env); }else{ predicate = eval(car(args), env); } sExpression *trueExp = car(toList(cdr(args))); sExpression *falseExp = car(toList(cdr(toList(cdr(args))))); if(isTrue(predicate)){ return eval(trueExp, env); }else{ return eval(falseExp, env); } } return &sNull; }
sExpression *evalSyntaxRuleIter(sExpression *syntax, sExpression *parameters, sExpression *rule){ if(isList(syntax) && isList(parameters)){ if(isSymbol(cadr(toList(syntax))) && (strcmp(toSymb(cadr(toList(syntax)))->name, "...") == 0)){ applySyntaxToRule(syntax, parameters, rule); return &sTrue; } else{ sExpression *result = evalSyntaxRuleIter(car(toList(syntax)), car(toList(parameters)), rule); if(isNull(result)){ return &sNull; } else{ return evalSyntaxRuleIter(cdr(toList(syntax)), cdr(toList(parameters)), rule); } } } else if(isNull(syntax) && !isNull(parameters)){ return &sNull; } else if(isSymbol(syntax)){ if(strcmp(toSymb(syntax)->name, "_") == 0){ return &sTrue; } else{ applySyntaxToRule(syntax, parameters, rule); return &sTrue; } } else if(isNull(syntax) && isNull(parameters)){ return &sTrue; } return &sNull; }
static void putVars(sList *parameterNames, sList *arguments, TCMAP *mapdb){ sExpression *firstP = car(parameterNames); sExpression *firstA = car(arguments); char *pName; void *aPointer; void *pPointer; int aSize; int pSize; if(isNull(firstP)){ return; } if(isSymbol(firstP)){ pName = toSymb(firstP)->name; }else{ return; } pPointer = pName; pSize = strlen(pName) * sizeof(char); aPointer = firstA->value; aSize = firstA->valueSize; TCXSTR *str = getTypeTag(pName); tcmapput(mapdb, pPointer, pSize, aPointer, aSize); tcmapput(mapdb, (char *)tcxstrptr(str), tcxstrsize(str), &(firstA->type), sizeof(sType)); sExpression *remainP = cdr(parameterNames); sExpression *remainA = cdr(arguments); if(isList(remainP) && isList(remainA)){ return putVars(toList(remainP), toList(remainA), mapdb); }else if(isSymbol(remainP)){ sList *lastOneParameter = toList(cons(remainP, &sNull)); sList *lastOneArgument = toList(cons(remainA, &sNull)); return putVars(lastOneParameter, lastOneArgument, mapdb); } return; }
QValueList<QDBusData> QDBusData::toQValueList(bool* ok) const { bool internalOk = false; QDBusDataList list = toList(&internalOk); if (!internalOk) { if (ok != 0) *ok = false; return QValueList<QDBusData>(); } return list.toQValueList(); }
Bool setVariable(sSymbol *symbol, sExpression *value, sEnvironment *env){ if(strcmp(symbol->name, "_error") != 0){ int i = 0; void *result = tcmapget(env->varmap, symbol->name, (strlen(symbol->name) * sizeof(char)), &i); if(i == 0) { if(isNoParent(env)){ return FALSE; }else{ return setVariable(symbol, value, env->parent); } } else { sExpression *exp = newExp(symbol, SYMBOL_TAG); putVars(toList(cons(exp, &sNull)), toList(cons(value, &sNull)), env->varmap); return TRUE; } } return FALSE; }
Node * buiCdr (ListNode * args, Env * env) { Node * t = eval((args->car), env); if (len(t) != 1) { error("** ERROR:cdr :","Wrong number of arguments: 1 expected"); return NULL; } if (t->type != PAIR) { return eval(toPair(t)->cdr, env); } else if (t->type != LIST && t != (Node *) &nil) { return eval((Node *)toList(t)->cdr, env); } else { error("*** ERROR:cdr:","Type \"pair\" expected"); return NULL; } }
Node * buiCar (ListNode * args, Env * env) { Node * t = eval(args->car, env); // 比如(list 1) 其实我表示成了(list 1 '()) =_= 自己栽在自己手上了.. if (len(t) != 1) { error("** ERROR:car :","Wrong number of arguments: 1 expected"); return NULL; } if (t->type != PAIR) { return eval(toPair(t)->car, env); } else if (t->type != LIST && t != (Node *) &nil) { return eval(toList(t)->car, env); } else { error("*** ERROR:car", "Type \"pair\" expected"); return NULL; } }
Node * buiCons(ListNode * args, Env * env) { if (len((Node *)args) != 2) { error("*** ERROR:cons:","Wrong number of arguments: 2 expected"); return NULL; } Node * t = eval((Node *)(args->cdr->car), env); if ( t->type == LIST ) { ListNode * tt = NEW(ListNode); tt->type= LIST; tt->car = eval(args->car, env); tt->cdr = toList(t); return (Node *)tt; } return (Node *) cons(eval(args->car, env), eval(args->cdr->car, env)); }
void MainWindow::loadLog() { auto v = m_settings.value("lastFiles", QList<QVariant>()); auto var = v.toList(); QString temp; for(int i = 0; i < var.size(); i++) { temp = var[i].toString(); if(QFile::exists(temp)) { recentProjects.push_back(temp); } } }
sExpression *cloneList(sExpression *exp){ if(isList(exp)){ sList *temp = toList(exp); return cons(cloneList(car(temp)), cloneList(cdr(temp))); } if(isSymbol(exp)){ return newSymbol(toSymb(exp)->name); } if(isNumber(exp)){ return newNumber(toNum(exp)->value); } if(isString(exp)){ return newString(toString(exp)->value); } return exp; }