public ILispValue execute(LispArray array)
{
int max_it = array.getSize();
List <ILispValue> tmp = new List <ILispValue> ();
ILispValue ret = new LispBoolean(true);
if (array.getSize() >= 2)
{
for (int idx = 1; idx < max_it; idx++)
{
tmp.Add(array [idx].eval());
}
for (int idx = 0; idx < max_it - 2; idx++)
{
if (tmp [idx].getType() != tmp [idx + 1].getType() || tmp [idx].getString() == tmp [idx + 1].getString())
{
ret = new LispBoolean(false);
break;
}
}
return(ret);
}
else
{
return(new LispString("ERROR : === require at least 2 operands"));
}
}
public ILispValue execute(LispArray array)
{
if (array.getSize() == 2)
{
if (array [1].getType() == ELispType.LispValue)
{
if (((LispArray)array [1]).getSize() > 1)
{
var tmp = new List <ILispValue> ();
var src = ((LispArray)array [1]).getInner();
for (int idx = 1; idx < src.Count; idx++)
{
tmp.Add(src [idx]);
}
return(new LispArray(tmp));
}
else
{
return(new LispBoolean(false));
}
}
else
{
return(new LispBoolean(false));
}
}
else
{
return(new LispString("tail require exactly one operand"));
}
}
public ILispValue execute(LispArray array)
{
int max_it = array.getSize();
List <ILispValue> tmp = new List <ILispValue> ();
ILispValue ret;
if (array.getSize() > 1)
{
for (int idx = 1; idx < max_it; idx++)
{
tmp.Add(array [idx].eval());
}
if (tmp [0].getType() == ELispType.Floating)
{
if (tmp.Count == 1)
{
return(new LispFloating(-tmp [0].getFloating()));
}
double a = tmp [0].getFloating();
for (int idx = 1; idx < tmp.Count; idx++)
{
a -= tmp [idx].getFloating();
}
ret = new LispFloating(a);
}
else
{
if (tmp.Count == 1)
{
return(new LispInteger(-tmp [0].getInteger()));
}
BigInteger a = tmp [0].getInteger();
for (int idx = 1; idx < tmp.Count; idx++)
{
a -= tmp [idx].getInteger();
}
ret = new LispInteger(a);
}
return(ret);
}
else
{
return(new LispString("ERROR : - require at least one operand"));
}
}
public ILispValue execute(LispArray array)
{
if (array.getSize() == 4 || array.getSize() == 3)
{
if (array [1].eval().getBoolean())
{
return(array [2].eval());
}
else
{
return(array [3].eval());
}
}
else
{
return(new LispString("ERROR : (if cond then) or (if cond then else) enforced"));
}
}
public ILispValue execute(LispArray array)
{
if (array [1].getType() == ELispType.String && array.getSize() == 2)
{
return(ctx.bank [array [1].eval().getString()]);
}
else
{
return(new LispBoolean(false));
}
}
public ILispValue execute(LispArray array)
{
if (array.getSize() == 2)
{
value = array [1];
return(value);
}
else
{
return(value);
}
}
public ILispValue execute(LispArray array)
{
int max_it = array.getSize();
for (int idx = 1; idx < max_it; idx++)
{
if (array [idx].eval().getBoolean())
{
return(new LispBoolean(true));
}
}
return(new LispBoolean(false));
}
public ILispValue execute(LispArray array)
{
int max_it = array.getSize();
List <ILispValue> tmp = new List <ILispValue> ();
List <ILispValue> rng = new List <ILispValue> ();
if (array.getSize() == 3)
{
for (int idx = 1; idx < max_it; idx++)
{
tmp.Add(array [idx].eval());
}
if (tmp [0].getInteger() < tmp [1].getInteger())
{
for (BigInteger n = tmp [0].getInteger(); !n.Equals(tmp [1].getInteger()); n++)
{
rng.Add(new LispInteger(n));
}
rng.Add(new LispInteger(tmp [1].getInteger()));
}
else if (tmp [0].getInteger() > tmp [1].getInteger())
{
for (BigInteger n = tmp [0].getInteger(); !n.Equals(tmp [1].getInteger()); n--)
{
rng.Add(new LispInteger(n));
}
rng.Add(new LispInteger(tmp [1].getInteger()));
}
return(new LispArray(rng));
}
else
{
return(new LispString("ERROR : range require exactly 2 operands"));
}
}
public ILispValue execute(LispArray array)
{
int max_it = array.getSize();
List <ILispValue> tmp = new List <ILispValue> ();
ILispValue ret = new LispBoolean(false);
if (array.getSize() == 3)
{
for (int idx = 1; idx < max_it; idx++)
{
tmp.Add(array [idx].eval());
}
if (tmp [0].getString() != tmp[1].getString())
{
ret = new LispBoolean(true);
}
return(ret);
}
else
{
return(new LispString("ERROR : != require exactly 2 operands"));
}
}
public ILispValue execute(LispArray array)
{
if (array.getSize() == 3)
{
while (array [1].eval().getBoolean())
{
array [2].eval();
}
return(new LispBoolean(true));
}
else
{
return(new LispString("ERROR : (while cond block) enforced"));
}
}
public ILispValue execute(LispArray array)
{
int max_it = array.getSize();
List <ILispValue> tmp = new List <ILispValue> ();;
ILispValue ret;
if (array.getSize() > 1)
{
for (int idx = 1; idx < max_it; idx++)
{
tmp.Add(array [idx].eval());
}
if (tmp [0].getType() == ELispType.Floating)
{
double a = 1;
for (int idx = 0; idx < tmp.Count; idx++)
{
a *= tmp [idx].getFloating();
}
ret = new LispFloating(a);
}
else if (tmp [0].getType() == ELispType.LispValue && tmp.Count == 1)
{
List <ILispValue> tmp2 = new List <ILispValue> ();
for (int idx = 0; idx < ((LispArray)tmp[0]).getSize(); idx++)
{
tmp2.Add(((LispArray)tmp[0])[idx].eval());
}
if (tmp2 [0].getType() == ELispType.Floating)
{
double a = 1;
for (int idx = 0; idx < tmp2.Count; idx++)
{
a *= tmp2 [idx].getFloating();
}
ret = new LispFloating(a);
}
else
{
BigInteger a = 1;
for (int idx = 0; idx < tmp2.Count; idx++)
{
a *= tmp2 [idx].getInteger();
}
ret = new LispInteger(a);
}
}
else
{
BigInteger a = 1;
for (int idx = 0; idx < tmp.Count; idx++)
{
a *= tmp [idx].getInteger();
}
ret = new LispInteger(a);
}
return(ret);
}
else
{
return(new LispString("ERROR : * require at least one operand"));
}
}
