register_global_value(int data_index, KurumiValue value)
{
if (data_index < data.Length)
{
data[data_index].reference = value;
}
}
add(KurumiValue value)
{
if (value != null)
{
args.Add(value);
}
}
stack_debug()
{
for (int i = 0; i < sp; i++)
{
KurumiValue v = value_stack[i];
Console.WriteLine("{0}", v.to_string());
}
}
div(KurumiValue other)
{
if (other.type == KurumiValueTypes.Number || other.type == KurumiValueTypes.Integer)
{
return(new KurumiNumber(number / ((KurumiNumber)other).number));
}
return(this);
}
debug()
{
for (int i = 0; i < args.Count; i++)
{
KurumiValue v = args[i];
Console.WriteLine("Position in list: {2, 3} Value: {0, 8} Type: {1, 5}", v.to_string(), v.type, i);
}
}
print(KurumiScript script, KurumiValueList args)
{
int size = args.size();
for (int i = 0; i < size; i++)
{
KurumiValue v = args.pop();
Console.WriteLine(v.to_string());
}
args.add(new KurumiNull());
}
add(KurumiValue other)
{
if (other.type == KurumiValueTypes.String)
{
return(other.add(this));
}
if (other.type == KurumiValueTypes.Number || other.type == KurumiValueTypes.Integer)
{
return(new KurumiNumber(number + ((KurumiNumber)other).number));
}
return(this);
}
pop()
{
int size = args.Count;
if (size <= 0)
{
return(null);
}
size -= 1;
KurumiValue v = args[size];
args.RemoveAt(size);
return(v);
}
interpret()
{
while (vp < expression.size() && !freeze)
{
KurumiValue value = expression[vp++];
switch (value.type)
{
case KurumiValueTypes.Command:
execute_command((KurumiCommand)value);
break;
case KurumiValueTypes.String:
case KurumiValueTypes.Number:
value_stack[sp++] = value;
break;
}
}
}
noteq(KurumiValue other)
{
return(other.equal_number(this).negation());
}
set_value(string name, KurumiValue value)
{
register_global_value(storage.get_index_from_name(name), value);
}
add(KurumiValue other)
{
return(new KurumiString(to_string() + other.to_string()));
}
noteq(KurumiValue other)
{
return(other.equal_string(this).negation());
}
equal(KurumiValue other)
{
return(other.equal_string(this));
}
noteq(KurumiValue other)
{
return(this);
}
div(KurumiValue other)
{
return(this);
}
equal(KurumiValue other)
{
return(other.equal_number(this));
}
execute_command(KurumiCommand command)
{
//Console.WriteLine("execute_command: {0}", command.command_type.ToString());
//stack_debug();
switch (command.command_type)
{
case KurumiCommandType.JMPIN: {
KurumiValue jmpp = expression[vp++];
KurumiValue expv = value_stack[--sp];
if (expv.to_bool() == false)
{
vp = (int)jmpp.to_number();
}
break;
}
case KurumiCommandType.JMP: {
KurumiValue jmpp = expression[vp++];
vp = (int)jmpp.to_number();
break;
}
case KurumiCommandType.ASSIGN: {
KurumiValue rexp = value_stack[--sp];
KurumiValue lexp = value_stack[--sp];
((KurumiReference)lexp).reference = rexp.clone();
break;
}
case KurumiCommandType.ADD: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp++] = rexp.add(lexp);
break;
}
case KurumiCommandType.SUB: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp] = lexp.sub(rexp);
sp++;
break;
}
case KurumiCommandType.MUL: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp++] = lexp.mul(rexp);
break;
}
case KurumiCommandType.DIV: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp++] = lexp.div(rexp);
break;
}
case KurumiCommandType.EQUAL: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp++] = lexp.equal(rexp);
break;
}
case KurumiCommandType.NOTEQ: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp++] = lexp.noteq(rexp);
break;
}
case KurumiCommandType.GTHAN: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp++] = lexp.gthan(rexp);
break;
}
case KurumiCommandType.LTHAN: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp++] = lexp.lthan(rexp);
break;
}
case KurumiCommandType.GOREQ: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp++] = lexp.goreq(rexp);
break;
}
case KurumiCommandType.LOREQ: {
KurumiValue rexp = value_stack[--sp].dereference();
KurumiValue lexp = value_stack[--sp].dereference();
value_stack[sp++] = lexp.loreq(rexp);
break;
}
case KurumiCommandType.CALL: {
KurumiValue func = value_stack[--sp];
KurumiValue retc = expression[vp++];
KurumiValue size = expression[vp++];
int sz = (int)size.to_number();
int rc = (int)retc.to_number();
KurumiValueList args = new KurumiValueList();
if (sz > 0)
{
for (int i = 0; i < sz; i++)
{
args.add(value_stack[--sp].dereference());
}
}
func.call(this, args);
if (rc > 0)
{
value_stack[sp++] = args.top();
}
break;
}
case KurumiCommandType.REF: {
KurumiValue refv = expression[vp++];
value_stack[sp++] = data[(int)refv.to_number()];
break;
}
}
//Console.WriteLine("after_execute_command");
//stack_debug();
}
equal(KurumiValue other)
{
return(this);
}
lthan(KurumiValue other)
{
return(other.lthan_number(this));
}
gthan(KurumiValue other)
{
return(this);
}
goreq(KurumiValue other)
{
return(other.lthan_number(this).negation());
}
