/* --------------- init global variable ----------- */
void initPrimitiveVariable(){
eval(newList(3, newSymbol("define"), newSymbol("nil"), newExp(&sNull, NULL_TAG)),
sGlobalEnvironment);
eval(newList(3, newSymbol("define"), newSymbol("#t"), newExp(&sTrue, TRUE_TAG)),
sGlobalEnvironment);
eval(newList(3, newSymbol("define"), newSymbol("#f"), newExp(&sFalse, FALSE_TAG)),
sGlobalEnvironment);
eval(newList(3, newSymbol("define"), newSymbol("#e"), newExp(&sError, ERROR_TAG)),
sGlobalEnvironment);
}
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));
}
}
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;
}
sExpression *cons(sExpression *left, sExpression *right){
sList *list = (sList *)malloc(sizeof(sList));
list->car = left;
list->cdr = right;
sExpression *listexp = newExp(list, LIST_TAG);
return listexp;
}
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;
}
sExpression *evalSyntaxRule(sSyntax *syntax, sExpression *parameters){
sExpression *clonedRule = cloneList(newExp(syntax->rules, LIST_TAG));
sExpression *temp = &sNull;
sExpression *syntax_tmp = car(syntax->syntaxes);
sExpression *rule = car(toList(clonedRule));
sExpression *syntaxcdr = cdr(syntax->syntaxes);
sExpression *rulecdr = cdr(toList(clonedRule));
temp = evalSyntaxRuleIter(syntax_tmp, parameters, rule);
while(isList(syntaxcdr) && isNull(temp)){
syntax_tmp = car(toList(syntaxcdr));
rule = car(toList(rulecdr));
syntaxcdr = cdr(toList(syntaxcdr));
rulecdr = cdr(toList(rulecdr));
temp = evalSyntaxRuleIter(syntax_tmp, parameters, rule);
}
return rule;
}
sExpression *lookupVariable(sSymbol *symbol, sEnvironment *env){
int i = 0;
int keySize = strlen(symbol->name) * sizeof(char);
TCXSTR *str = getTypeTag(symbol->name);
void *result = tcmapget(env->varmap, symbol->name, keySize, &i);
if(i == 0){
//fail find
if(isNoParent(env)){
return &sNull;
}else{
return lookupVariable(symbol, env->parent);
}
}else{
//success find
sType *type = (sType *)tcmapget(env->varmap, tcxstrptr(str), tcxstrsize(str), &i);
sExpression *resultExp = newExp(result, *type);
return resultExp;
}
}
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;
}
sExpression *newSyntax(sList *rules, sList *syntaxes){
sSyntax *syntax = (sSyntax *)malloc(sizeof(sSyntax));
syntax->rules = rules;
syntax->syntaxes = syntaxes;
return newExp(syntax, SYNTAX_TAG);
}
void Session::attachSignals()
{
// zoneManager -> group Manager
connect(m_zoneMgr, SIGNAL(playerProfile(const charProfileStruct*)),
m_groupMgr, SLOT(player(const charProfileStruct*)));
// spawnShell -> group Manager
connect(m_spawnShell, SIGNAL(addItem(const Item*)),
m_groupMgr, SLOT(addItem(const Item*)));
connect(m_spawnShell, SIGNAL(delItem(const Item*)),
m_groupMgr, SLOT(delItem(const Item*)));
connect(m_spawnShell, SIGNAL(killSpawn(const Item*, const Item*, uint16_t)),
m_groupMgr, SLOT(killSpawn(const Item*)));
// zone Manager -> filter Manager
connect(m_zoneMgr, SIGNAL(zoneBegin(const QString&)),
m_filterMgr, SLOT(loadZone(const QString&)));
connect(m_zoneMgr, SIGNAL(zoneEnd(const QString&)),
m_filterMgr, SLOT(loadZone(const QString&)));
connect(m_zoneMgr, SIGNAL(zoneChanged(const QString&)),
m_filterMgr, SLOT(loadZone(const QString&)));
connect(m_zoneMgr, SIGNAL(zoneBegin(const ClientZoneEntryStruct*, size_t, uint8_t)),
m_messageShell, SLOT(zoneEntryClient(const ClientZoneEntryStruct*)));
connect(m_zoneMgr, SIGNAL(zoneChanged(const zoneChangeStruct*, size_t, uint8_t)),
m_messageShell, SLOT(zoneChanged(const zoneChangeStruct*, size_t, uint8_t)));
connect(m_zoneMgr, SIGNAL(zoneBegin(const QString&)),
m_messageShell, SLOT(zoneBegin(const QString&)));
connect(m_zoneMgr, SIGNAL(zoneEnd(const QString&, const QString&)),
m_messageShell, SLOT(zoneEnd(const QString&, const QString&)));
connect(m_zoneMgr, SIGNAL(zoneChanged(const QString&)),
m_messageShell, SLOT(zoneChanged(const QString&)));
connect(m_zoneMgr, SIGNAL(playerProfile(const charProfileStruct*)),
m_messageShell, SLOT(player(const charProfileStruct*)));
connect(m_player, SIGNAL(setExp(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)),
m_messageShell, SLOT(setExp(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)));
connect(m_player, SIGNAL(newExp(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)),
m_messageShell, SLOT(newExp(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)));
connect(m_player, SIGNAL(setAltExp(uint32_t, uint32_t, uint32_t, uint32_t)),
m_messageShell, SLOT(setAltExp(uint32_t, uint32_t, uint32_t, uint32_t)));
connect(m_player, SIGNAL(newAltExp(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)),
m_messageShell, SLOT(newAltExp(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)));
connect(m_spawnShell, SIGNAL(addItem(const Item*)),
m_messageShell, SLOT(addItem(const Item*)));
connect(m_spawnShell, SIGNAL(delItem(const Item*)),
m_messageShell, SLOT(delItem(const Item*)));
connect(m_spawnShell, SIGNAL(killSpawn(const Item*, const Item*, uint16_t)),
m_messageShell, SLOT(killSpawn(const Item*)));
// connect the SpellShell slots to ZoneMgr signals
connect(m_zoneMgr, SIGNAL(zoneChanged(const QString&)),
m_spellShell, SLOT(zoneChanged()));
// connect the SpellShell slots to SpawnShell signals
connect(m_spawnShell, SIGNAL(killSpawn(const Item*, const Item*, uint16_t)),
m_spellShell, SLOT(killSpawn(const Item*)));
// connect the SpellShell slots to Player signals
connect(m_player, SIGNAL(newPlayer()),
m_spellShell, SLOT(clear()));
connect(m_player, SIGNAL(buffLoad(const spellBuff *)),
m_spellShell, SLOT(buffLoad(const spellBuff *)));
connect(m_zoneMgr, SIGNAL(playerProfile(const charProfileStruct*)), m_player, SLOT(player(const charProfileStruct*)));
}
sList *checkArguments(sList *parameters, sList *arguments, Bool isVarArgument){
return toList(checkArgumentsIter(newExp(parameters, LIST_TAG),
newExp(arguments, LIST_TAG),
isVarArgument));
}
sExpression *newSymbol(char *name){
sSymbol *symb = (sSymbol *)malloc(sizeof(sSymbol));
symb->name = name;
sExpression *exp = newExp(symb, SYMBOL_TAG);
return exp;
}
