public void evalExpression(Expression exp)
{
if (exp == null)
{
return;
}
if (exp is InstructionExpression)
{
evalInstruction((InstructionExpression)exp);
return;
}
else if (exp is SequenceExpression)
{
SequenceExpression seqExp = (SequenceExpression)exp, seqTmp;
Expression expTmp;
int index = insertIndex;
seqTmp = new SequenceExpression(new List<Expression>(seqExp.exps));
seqs.Add(seqExp);
runningSeqs.Add(seqTmp);
index = runningSeqs.Count - 1;
while (seqTmp.exps.Count > 0)
{
expTmp = seqTmp.exps.ElementAt(0);
evalExpression(expTmp);
seqTmp.exps.RemoveAt(0);
if (!shouldEvalSeq)
{
if (seqTmp.exps.Count == 0)
{
runningSeqs.RemoveAt(index);
}
return;
}
}
runningSeqs.RemoveAt(runningSeqs.Count - 1);
removeDeclaredVariables(seqs.ElementAt(seqs.Count - 1).declaredVariables());
seqs.RemoveAt(seqs.Count - 1);
return;
}
else if (exp is IfExpression)
{
ifExp = (IfExpression)exp;
o1 = evalSimpleExpression(ifExp.condition);
if ((bool)o1.value)
{
evalExpression(ifExp.body);
return;
}
if (ifExp.elseIfList != null)
{
foreach (ElseIfExpression elseIfExp in ifExp.elseIfList)
{
o1 = evalSimpleExpression(elseIfExp.condition);
if ((bool)o1.value)
{
evalExpression(elseIfExp.corps);
return;
}
}
}
if (ifExp.elseBlock != null)
{
evalExpression(ifExp.elseBlock.body);
return;
}
return;
}
else if (exp is SwitchExpression)
{
switchExp = (SwitchExpression)exp;
o1 = evalSimpleExpression(switchExp.exp);
foreach (SwitchCaseExpression sce in switchExp.cases)
{
if (sce is CaseExpression)
{
if (o1.type == ObjectType.stringType
&& isCatched((string)o1.value, sce, false))
{
return;
}
else if (o1.type == ObjectType.intType
&& isCatched((int)o1.value, sce, false))
{
return;
}
}
else if (sce is DefaultExpression)
{
evalExpression(((DefaultExpression)sce).body);
return;
}
}
return;
}
else if (exp is WhileExpression)
{
whileExp = (WhileExpression)exp;
while (true)
{
o1 = evalSimpleExpression(whileExp.condition);
if (!(bool)o1.value)
{
return;
}
evalExpression(whileExp.body);
}
}
else if (exp is DoWhileExpression)
{
doWhileExp = (DoWhileExpression)exp;
do
{
evalExpression(doWhileExp.body);
o1 = evalSimpleExpression(doWhileExp.condition);
if (!(bool)o1.value)
{
return;
}
} while (true);
}
else if (exp is ForExpression)
{
forExp = (ForExpression)exp;
evalExpression(forExp.init);
while (true)
{
o1 = evalSimpleExpression(forExp.condition);
if (!(bool)o1.value)
{
return;
}
evalExpression(forExp.body);
evalExpression(forExp.maj);
}
}
}
public ObjectExpression evalSimpleExpression(SimpleExpression exp)
{
if (exp is LiteralExpression)
{
lit = (LiteralExpression)exp;
switch (lit.value.type)
{
case ParserUtils.Token.TokenValue.STRING:
return new ObjectExpression(ObjectType.stringType, lit.value.stringValue);
case ParserUtils.Token.TokenValue.INT:
return new ObjectExpression(ObjectType.intType, lit.value.intValue);
case ParserUtils.Token.TokenValue.CHAR:
return new ObjectExpression(ObjectType.charType, lit.value.charValue);
case ParserUtils.Token.TokenValue.BOOLEAN:
return new ObjectExpression(ObjectType.booleanType, lit.value.booleanValue);
default:
break;
}
}
else if (exp is SubSimpleExpression)
{
return evalSimpleExpression(((SubSimpleExpression)exp).exp);
}
else if (exp is NullExpression)
{
return null;
}
else if (exp is BinaryOperatorExpression)
{
BinaryOperatorExpression binExp = (BinaryOperatorExpression)exp;
ObjectExpression oLeft = evalSimpleExpression(binExp.e1), oRight;
switch (binExp.op)
{
case ParserUtils.Token.TokenValue.AND:
if ((bool)oLeft.value)
{
oRight = evalSimpleExpression(binExp.e2);
return new ObjectExpression(ObjectType.booleanType, (bool)oRight.value);
}
return new ObjectExpression(ObjectType.booleanType, false);
case ParserUtils.Token.TokenValue.OR:
if ((bool)oLeft.value)
{
return new ObjectExpression(ObjectType.booleanType, true);
}
oRight = evalSimpleExpression(binExp.e2);
return new ObjectExpression(ObjectType.booleanType, (bool)oRight.value);
case ParserUtils.Token.TokenValue.PLUS:
oRight = evalSimpleExpression(binExp.e2);
if (oLeft.type == ObjectType.stringType || oRight.type == ObjectType.stringType)
{
return new ObjectExpression(ObjectType.stringType, oLeft.value.ToString() + oRight.value.ToString());
}
if (oLeft.type == ObjectType.intType && oRight.type == ObjectType.intType)
{
return new ObjectExpression(ObjectType.intType, (int)oLeft.value + (int)oRight.value);
}
break;
case ParserUtils.Token.TokenValue.MINUS:
oRight = evalSimpleExpression(binExp.e2);
return new ObjectExpression(ObjectType.intType, (int)oLeft.value - (int)oRight.value);
case ParserUtils.Token.TokenValue.TIMES:
oRight = evalSimpleExpression(binExp.e2);
return new ObjectExpression(ObjectType.intType, (int)oLeft.value * (int)oRight.value);
case ParserUtils.Token.TokenValue.DIV:
oRight = evalSimpleExpression(binExp.e2);
return new ObjectExpression(ObjectType.intType, (int)oLeft.value / (int)oRight.value);
case ParserUtils.Token.TokenValue.LT:
oRight = evalSimpleExpression(binExp.e2);
return new ObjectExpression(ObjectType.booleanType, (int)oLeft.value < (int)oRight.value);
case ParserUtils.Token.TokenValue.GT:
oRight = evalSimpleExpression(binExp.e2);
return new ObjectExpression(ObjectType.booleanType, (int)oLeft.value > (int)oRight.value);
case ParserUtils.Token.TokenValue.LEQ:
oRight = evalSimpleExpression(binExp.e2);
return new ObjectExpression(ObjectType.booleanType, (int)oLeft.value <= (int)oRight.value);
case ParserUtils.Token.TokenValue.GEQ:
oRight = evalSimpleExpression(binExp.e2);
return new ObjectExpression(ObjectType.booleanType, (int)oLeft.value >= (int)oRight.value);
case ParserUtils.Token.TokenValue.EQBOOL:
oRight = evalSimpleExpression(binExp.e2);
if (oLeft.type == ObjectType.intType)
{
return new ObjectExpression(ObjectType.booleanType, (int)oLeft.value == (int)oRight.value);
}
if (oLeft.type == ObjectType.stringType)
{
return new ObjectExpression(ObjectType.booleanType, ((string)oLeft.value).Equals((string)oRight.value));
}
if (oLeft.type == ObjectType.booleanType)
{
return new ObjectExpression(ObjectType.booleanType, (bool)oLeft.value == (bool)oRight.value);
}
if (oLeft.type == ObjectType.charType)
{
return new ObjectExpression(ObjectType.booleanType, (char)oLeft.value == (char)oRight.value);
}
break;
default:
break;
}
}
else if (exp is UnaryOperatorExpression)
{
unExp = (UnaryOperatorExpression)exp;
switch (unExp.op)
{
case ParserUtils.Token.TokenValue.NEG:
o1 = evalSimpleExpression(((UnaryOperatorExpression)exp).exp);
return new ObjectExpression(ObjectType.booleanType, !((bool)o1.value));
}
}
else if (exp is VariableExpression)
{
return variables[((VariableExpression)exp).name];
}
else if (exp is CharacterVariableExpression)
{
return new ObjectExpression(ObjectType.intType, IrisData.getPlayerVariable(((CharacterVariableExpression)exp).name));
}
return null;
}
public void evalInstruction(InstructionExpression instr)
{
if (instr is ValueExpression)
{
valueExp = (ValueExpression)instr;
if (valueExp.type == ObjectType.intType)
{
variables.Add(valueExp.name, new ObjectExpression(valueExp.type, 0));
}
else if (valueExp.type == ObjectType.booleanType)
{
variables.Add(valueExp.name, new ObjectExpression(valueExp.type, false));
}
else if (valueExp.type == ObjectType.stringType)
{
variables.Add(valueExp.name, new ObjectExpression(valueExp.type, ""));
}
if (valueExp.value != null)
{
variables[valueExp.name] = new ObjectExpression(valueExp.type, evalSimpleExpression(valueExp.value).value);
}
return;
}
else if (instr is AssignExpression)
{
assignExp = (AssignExpression)instr;
variables[assignExp.name] = evalSimpleExpression(assignExp.value);
return;
}
else if (instr is OpenMsgDialogInstruction)
{
gScreen.msgBox.openBox();
return;
}
else if (instr is MsgDisplayInstruction)
{
msgExp = (MsgDisplayInstruction)instr;
o1 = evalSimpleExpression(msgExp.msg);
if (o1.type != ObjectType.stringType)
{
return;
}
gScreen.msgBox.setText((string)o1.value);
return;
}
else if (instr is NextMsgDialogInstruction)
{
shouldEvalSeq = false;
gScreen.msgBox.showNextButton();
return;
}
else if (instr is CloseMsgDialogInstruction)
{
shouldEvalSeq = false;
gScreen.msgBox.showCloseButton();
return;
}
else if (instr is SwitchCharacterInstruction)
{
try
{
gScreen.msgBox.switchCharacter(IrisData.characters[((SwitchCharacterInstruction)instr).character.name]);
}
catch (Exception e)
{
return;
}
return;
}
else if (instr is RemoveCharacter)
{
gScreen.msgBox.removeCharacter();
return;
}
else if (instr is SetVariableInstruction)
{
setExp = (SetVariableInstruction)instr;
/*if (!playerVariables.ContainsKey(setExp.variable.name))
{
playerVariables.Add(setExp.variable.name, -1);
}
playerVariables[setExp.variable.name] = (int)(evalSimpleExpression(setExp.value).value);*/
IrisData.setPlayerVariable(setExp.variable.name, (int)(evalSimpleExpression(setExp.value).value));
return;
}
else if (instr is InputInstruction)
{
inputExp = (InputInstruction)instr;
o1 = variables[inputExp.name];
shouldEvalSeq = false;
if (o1.type == ObjectType.intType)
{
gScreen.iBox.openBox(InputBox.InputType.INT_INPUT);
lastInstr = inputExp;
}
else if (o1.type == ObjectType.stringType)
{
gScreen.iBox.openBox(InputBox.InputType.STRING_INPUT);
lastInstr = inputExp;
}
return;
}
else if (instr is MenuInstruction)
{
menuExp = (MenuInstruction)instr;
shouldEvalSeq = false;
gScreen.menBox.setChoices(((MenuInstruction)instr).choices);
gScreen.menBox.openMenu();
lastInstr = menuExp;
return;
}
else if (instr is PlayMediaInstruction)
{
playExp = (PlayMediaInstruction)instr;
/*if (!IrisData.sounds.ContainsKey(playExp.name))
{
return;
}*/
//else if(IrisData.
try
{
gScreen.playMedia(IrisData.sounds[playExp.name]);
}
catch (Exception e)
{
return;
}
return;
}
else if (instr is StopMediaInstruction)
{
gScreen.stopMedia();
return;
}
else if (instr is ShowImageInstruction)
{
showExp = (ShowImageInstruction)instr;
if (showExp.image is VariableExpression)
{
img = IrisData.images[((VariableExpression)showExp.image).name];
}
else
{
memberExp = (MemberAccessExpression)showExp.image;
charac = IrisData.characters[memberExp.name];
img = charac.getImage(memberExp.field);
}
gScreen.showImage(img, showExp.position);
return;
}
else if (instr is SetBackgroundInstruction)
{
bgdInstr = (SetBackgroundInstruction)instr;
try
{
gScreen.setBackground(IrisData.backgrounds[bgdInstr.image.name]);
}
catch (Exception e)
{
return;
}
return;
}
else if (instr is CleanBackgroundInstruction)
{
gScreen.clearBackground();
return;
}
else if (instr is CleanForegroundInstruction)
{
gScreen.clearForeGround();
return;
}
else if (instr is GotoInstruction)
{
gotoExp = (GotoInstruction)instr;
npcExp = gotoExp.npc;
evalExpression(IrisData.npcs[npcExp.npc].labels[npcExp.label]);
return;
}
}