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;
}
