/// <summary>
/// Add values to the integer (changes the value of the object)
/// </summary>
/// <param name="Arguments">A list of values to add to the integer</param>
/// <returns>The sum of all the arguments and the internal integer</returns>
public ktValue Add(ktList Arguments)
{
ktValue Value = ktValue.Null;
// Check so we actually got some arguments
if (Arguments.IsEmpty())
{
throw new ktError("Can't add nothing (null) to an integer!", ktERR.NOTDEF);
}
// Go through the list of arguments
foreach (ktList L in Arguments)
{
// If there's nothing in this argument
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
// Try to convert the argument to an int and add it to the internal integer
m_value += GetAsInt((ktValue)L.Node.Value);
}
// Wrap this object in a ktValue ...
Value = new ktValue("return", "ktInt", this, m_HardType, true);
// ... and return it
return Value;
}
public bool SetVariable(ktString Name, ktValue Value, bool Add, bool Copy, bool IgnoreConstant)
{
// Nothing to use??
if (Name.IsEmpty() || (Value == null) || (m_Block == null))
{
return false;
}
return m_Block.SetVariable(Name, Value, Add, Copy, IgnoreConstant);
}
public ktValue(ktValue Value)
: base("ktValue", 0)
{
//ktDebug.Log( "Value::CONSTR( " + Value.Export() + " )" );
SetName(Value.Name);
SetType(Value.Type);
SetHardType(Value.HardType);
SetConstant(Value.Constant);
m_Object = Value.Value;
}
public override int Compare(ktString op, ktValue val)
{
int ret = 0;
bool bVal = val.ToBool();
switch (op)
{
case "<>":
case "!=":
case "op<>":
case "op!=":
case "operator<>":
case "operator!=":
case "ne":
case "isnotequal":
case "notequal":
{
ret = (m_value != bVal) ? 1 : 0;
break;
}
case "==":
case "op==":
case "operator==":
case "isequal":
case "equal":
case "eq":
{
ret = (m_value == bVal) ? 1 : 0;
break;
}
default:
{
throw new ktError("Couldn't find the method '" +
op + "' in class '" + m_Name + "'.", ktERR._404);
}
}
return ret;
}
/// <summary>
/// Calculate the modulus of the integer and the arguments (doesn't change the value of the object)
/// </summary>
/// <param name="Arguments">A list of values to multiply with the integer</param>
/// <returns>The product of all the arguments and the internal integer</returns>
public ktValue _Modulus(ktList Arguments)
{
ktValue Value = ktValue.Null;
ktValue Arg = ktValue.Null;
int res = m_value;
int a = 1;
// Check so we actually got some arguments
if (Arguments.IsEmpty())
{
throw new ktError("Can't divide an integer with nothing (null)!", ktERR.NOTDEF);
}
// Go through the list of arguments
foreach (ktList L in Arguments)
{
// If there's nothing in this argument
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
// Get the argument as an integer
a = GetAsInt((ktValue)L.Node.Value);
// Do modulus with the current argument
res %= a;
}
// Create a new ktInt and wrap it in a ktValue
Value = new ktValue("return", "ktInt", new ktInt(res), true, true);
return Value;
}
public virtual ktClass CreateObject(ktValue Value)
{
return CreateObject(Value.ToString());
}
/// <summary>
/// Calculate the value of the integer XOR with the power of the arguments (doesn't change the value of the object)
/// </summary>
/// <param name="Arguments">A list of values to XOR the integer with</param>
public ktValue _ExclusiveOr(ktList Arguments)
{
ktValue Value = ktValue.Null;
int res = m_value;
int a = 1;
// Check so we actually got some arguments
if (Arguments.IsEmpty())
{
throw new ktError("Can't divide an integer with nothing (null)!", ktERR.NOTDEF);
}
// Go through the list of arguments
foreach (ktList L in Arguments)
{
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
// Get the argument as an integer
a = GetAsInt((ktValue)L.Node.Value);
// Perform an XOR-operation
res ^= a;
}
// Create a new ktInt and wrap it in a ktValue
Value = new ktValue("return", "ktInt", new ktInt(res), false, true);
return Value;
}
public override ktValue SetProperty(ktString Name, ktValue Value)
{
if ((Name == "this") || (Name == "_this") ||
(Name == "object") || (Name == "_object") ||
(Name == "_") || (Name.IsEmpty()))
{
/*try {
m_Value = Convert.ToInt32( Value.ToString() );
} catch (Exception E) {
if (E.GetType() == typeof( System.FormatException )) {
throw new ktError( "kactalkClass::CreateObject: Cant make '" + Value + "' into an integer", ktERR.WRONGTYPE );
}
}*/
} /*else if (Name == "MathMode") {
// m_Value.MathMode = (((ktClass)Value.Value).ToString().ToLower() == "true");
m_Value.MathMode = Value.ToBool();
} */else
{
throw new ktError("Couldn't find the property '" +
Name + "' in class '" + m_Name + "'.", ktERR._404);
}
return GetProperty("_");
}
public bool SetVariable(ktString Name, ktValue Value, bool Add, bool Copy)
{
return SetVariable(Name, Value, Add, Copy, false);
}
public ktRunStatementClass(ktValue Value)
: this()
{
m_IsClass = false;
SetProperty("_", Value);
}
public override ktClass CreateObject(ktValue Value)
{
/*
int I = 0;
try {
I = Convert.ToInt32( Value.ToString() );
} catch (Exception E) {
if (E.GetType() == typeof( System.FormatException )) {
throw new ktError( "kactalkClass::CreateObject: Cant make '" + Value + "' into an integer", ktERR.WRONGTYPE );
}
}*/
return new ktRunStatementClass(new ktRunStatement());
}
/// <summary>
/// Get the argument/ktValue as an integer (takes in account strict typing etc)
/// </summary>
/// <param name="Arg">The argument</param>
/// <returns></returns>
protected int GetAsInt(ktValue Arg)
{
// Was we given a ktInt??
if (Arg.Type == "ktInt")
{
// Get the value directly from the ktInt object
return ((ktInt)Arg.Value).m_value;
}
// We got something else
else
{
// Is this declared as a hard/strict type
if (m_HardType)
{
throw new ktError("ktInt::Assign: Cant make '" + Arg.Type + "' into a (hard) ktInt!", ktERR.WRONGTYPE);
}
// Not hard?
else
{
// Try to convert it to an integer (Use the ToInt of the argument value)
return Arg.ToInt();
}
}
}
public override ktClass CreateObject(ktValue Value)
{
return new ktInt( GetAsInt( Value ) );
}
/// <summary>
/// Main constructor for kactalkClass,
/// it takes the kacTalk object/interpreter it should wrap/represent (as a ktValue)
/// </summary>
public kactalkClass(ktValue Value)
: this()
{
m_IsClass = false;
SetProperty("_", Value);
}
/// <summary>
/// Compare the integer with the given value
/// </summary>
/// <param name="op">The operator to use for the comparison</param>
/// <param name="val">The value to compare with</param>
/// <returns>A value representing the comparison</returns>
public override int Compare(ktString op, ktValue val)
{
int ret = 0;
// Get the value as an integer
int iVal = GetAsInt(val);
// Check which operator we should use
switch ( op.AsLower() )
{
case ">":
case "op>":
case "operator>":
case "mt":
case "gt":
case "greater":
case "greaterthan":
case "more":
case "morethan":
case "isgreater":
case "isgreaterthan":
case "ismore":
case "ismorethan":
{
ret = (m_value > iVal) ? 1 : 0;
break;
}
case ">=":
case "op>=":
case "operator>=":
case "mte":
case "gte":
case "greaterorequal":
case "greaterthanorequal":
case "moreorequal":
case "morethanorequal":
case "isgreaterorequal":
case "isgreaterthanorequal":
case "ismoreorequal":
case "ismorethanorequal":
{
ret = (m_value >= iVal) ? 1 : 0;
break;
}
case "<":
case "op<":
case "operator<":
case "lt":
case "less":
case "lessthan":
case "isless":
case "islessthan":
{
ret = (m_value < iVal) ? 1 : 0;
break;
}
case "<=":
case "op<=":
case "operator<=":
case "lte":
case "lessorequal":
case "lessthanorequal":
case "islessorequal":
case "islessthanorequal":
{
ret = (m_value <= iVal) ? 1 : 0;
break;
}
case "<>":
case "!=":
case "op<>":
case "op!=":
case "operator<>":
case "operator!=":
case "ne":
case "isnotequal":
case "notequal":
{
ret = (m_value != iVal) ? 1 : 0;
break;
}
case "==":
case "op==":
case "operator==":
case "isequal":
case "equal":
case "eq":
{
ret = (m_value == iVal) ? 1 : 0;
break;
}
case "compare":
{
ret = m_value.CompareTo(iVal);
break;
}
default:
{
throw new ktError("Couldn't find the method '" +
op + "' in class '" + m_Name + "'.", ktERR._404);
}
}
return ret;
}
public virtual ktValue _GetProperty(ktString Name, bool Copy)
{
ktValue Value = ktValue.Null;
if (Name.IsEmpty())
{
return Value;
}
if (m_Properties == null)
{
throw new ktError("Couldn't find the property '" +
Name + "' in class '" + m_Name + "'.", ktERR._404);
}
ktNode Node = m_Properties.GetNode(Name);
if ((Node == null) || (Node.Value == null))
{
throw new ktError("Couldn't find the property '" +
Name + "' in class '" + m_Name + "'.", ktERR._404);
//return Value;
}
if (Copy)
{
Value = new ktValue((ktValue)Node.Value);
}
else
{
Value = (ktValue)Node.Value;
}
return Value;
}
public virtual ktValue SetProperty(ktString Name, ktValue Value)
{
if (Name.IsEmpty())
{
throw new ktError("Didn't get the name of the property to change in class '" +
m_Name + "'.", ktERR.NOTSET);
}
if (m_Properties == null)
{
m_Properties = new ktList();
}
ktNode Node = m_Properties.GetNode(Name);
if ((Node == null) || (Node.Value == null))
{
if (m_AddIfNotSet)
{
return AddProperty(Name, Value);
}
else
{
throw new ktError("Couldn't find the property '" +
Name + "' in class '" + m_Name + "'.", ktERR._404);
}
}
else
{
ktValue Prop = (ktValue)Node.Value;
if (Prop.Constant)
{
throw new ktError("The property '" + Name + "' in class '" +
m_Name + "' is a constant and can't be changed.", ktERR.CONST);
}
else if (Value == null)
{
// HUM???
Prop.Value = null;
}
else
{
Prop.SetValue(Value);
}
return Prop;
}
}
public virtual ktValue GetMember(ktString Name)
{
ktValue Value = ktValue.Null;
try
{
Value = GetProperty(Name);
//ktDebug.Log( "GM::P V:" + Value.ToString() + ";" );
if (!Value.IsNull())
{
return Value;
}
}
catch (Exception)
{
//ktDebug.Log( "Err:" + E.ToString() + ";" );
}
try
{
ktFunction Func = GetMethod(Name);
Value = new ktValue(Name, "ktFunction", Func, true, true);
if (!Value.IsNull())
{
return Value;
}
}
catch (Exception)
{
if (Name == "Export")
{
ktDelegateFunction Func = new ktDelegateFunction("Export", ExportValue);
Value = new ktValue(Name, "ktFunction", Func, true, true);
if (!Value.IsNull())
{
return Value;
}
}
else if (Name.AsLower() == "tostring")
{
ktDelegateFunction Func = new ktDelegateFunction("ToString", ToStringValue);
Value = new ktValue(Name, "ktFunction", Func, true, true);
if (!Value.IsNull())
{
return Value;
}
}
}
throw new ktError("Can't find the member '" + Name + "' in class '" + m_Name + "'!", ktERR._404);
}
/// <summary>
/// Multiply values with the integer (doesn't change the value of the object)
/// </summary>
/// <param name="Arguments">A list of values to multiply with the integer</param>
/// <returns>The product of all the arguments and the internal integer</returns>
public ktValue _Multiply(ktList Arguments)
{
ktValue Value = ktValue.Null;
int res = m_value;
// Check so we actually got some arguments
if (Arguments.IsEmpty())
{
throw new ktError("Can't multiply nothing (null) to an integer!", ktERR.NOTDEF);
}
// Go through the list of arguments
foreach (ktList L in Arguments)
{
// If there's nothing in this argument
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
// Multiply with the current argument
res *= GetAsInt((ktValue)L.Node.Value);
}
// Create a new ktInt and wrap it in a ktValue
Value = new ktValue("return", "ktInt", new ktInt(res), true, true);
return Value;
}
/// <summary>
/// Calculate the value of the integer XOR with the power of the arguments (changes the value of the object)
/// </summary>
/// <param name="Arguments">A list of values to XOR the integer with</param>
/// <returns>The result</returns>
public ktValue ExclusiveOr(ktList Arguments)
{
ktValue Value = ktValue.Null;
int a = 1;
// Check so we actually got some arguments
if (Arguments.IsEmpty())
{
throw new ktError("Can't XOR an integer with nothing (null)!", ktERR.NOTDEF);
}
// Go through the list of arguments
foreach (ktList L in Arguments)
{
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
// Get the argument as an integer
a = GetAsInt((ktValue)L.Node.Value);
// Perform an XOR-operation
m_value ^= a;
}
// Wrap this object in a ktValue ...
Value = new ktValue("return", "ktInt", this, false, true);
// ... and return it
return Value;
}
/// <summary>
/// Calculate the value of the integer raised to the power of the arguments (doesn't change the value of the object)
/// </summary>
/// <param name="Arguments">A list of values to raise the integer with</param>
/// <returns>The value of the internal integer to the power of the arguments</returns>
public ktValue _Power(ktList Arguments)
{
ktValue Value = ktValue.Null;
int res = m_value;
int a = 1;
// Check so we actually got some arguments
if (Arguments.IsEmpty())
{
throw new ktError("Can't raise an integer with nothing (null)!", ktERR.NOTDEF);
}
// Go through the list of arguments
foreach (ktList L in Arguments)
{
// If there's nothing in this argument
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
// Get the argument as an integer
a = GetAsInt((ktValue)L.Node.Value);
// Raise it to the power of the argument
res = (int)Math.Pow((double)res,(double)a);
}
// Create a new ktInt and wrap it in a ktValue
Value = new ktValue("return", "ktInt", new ktInt(res), true, true);
return Value;
}
/// <summary>
/// Multiply values with the integer (changes the value of the object)
/// </summary>
/// <param name="Arguments">A list of values to multiply with the integer</param>
/// <returns>The product of all the arguments and the internal integer</returns>
public ktValue Multiply(ktList Arguments)
{
ktValue Value = ktValue.Null;
// Check so we actually got some arguments
if (Arguments.IsEmpty())
{
throw new ktError("Can't multiply nothing (null) with an integer!", ktERR.NOTDEF);
}
// Go through the list of arguments
foreach (ktList L in Arguments)
{
// If there's nothing in this argument
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
// Multiply with the current argument
m_value *= GetAsInt((ktValue)L.Node.Value);
}
// Wrap this object in a ktValue ...
Value = new ktValue("return", "ktInt", this, m_HardType, true);
// ... and return it
return Value;
}
public override ktValue AddProperty(ktValue Value)
{
return Value;
}
public virtual ktValue AddProperty(ktValue Value)
{
if (Value == null)
{
throw new ktError("Need a value-object when adding a property " +
" to class '" + m_Name + "'.", ktERR.NOTSET);
}
if (m_Properties == null)
{
m_Properties = new ktList();
}
m_Properties.Add(Value.Name, Value);
return Value;
}
public override ktList GetProperties()
{
ktValue This = new ktValue(m_Name, "int", this, true, false);
ktList List = new ktList();
List.Add("_", This);
List.Add("this", This);
List.Add("_this", This);
List.Add("object", This);
List.Add("_object", This);
List.Add("MathMode", This);
return List;
}
/// <summary>
/// Add values to the integer (doesn't change the value of the object)
/// </summary>
/// <param name="Arguments">A list of values to add to the integer</param>
/// <returns>The sum of all the arguments and the internal integer</returns>
public ktValue _Add(ktList Arguments)
{
ktValue Value = ktValue.Null;
int res = 0;
// Check so we actually got some arguments
if (Arguments.IsEmpty())
{
throw new ktError("Can't add nothing (null) to an integer!", ktERR.NOTDEF);
}
// Go through the list of arguments
foreach (ktList L in Arguments)
{
// If there's nothing in this argument
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
// Try to convert the argument to an int and add it to the sum
res += GetAsInt((ktValue)L.Node.Value);
}
// Add the current sum to the internal integer, create a new ktInt and wrap it in a ktValue
Value = new ktValue("return", "ktInt", new ktInt(m_value + res), true, true);
// Return the result
return Value;
}
public virtual ktValue AddProperty(ktString Name, ktValue Value)
{
if (Value == null)
{
throw new ktError("Need a value-object when adding property '" +
Name + "' to class '" + m_Name + "'.", ktERR.NOTSET);
}
Value.SetName(Name);
return AddProperty(Value);
}
/// <summary>
/// Divide values with the integer (doesn't change the value of the object)
/// </summary>
/// <param name="Arguments">A list of values to divide the integer with</param>
/// <returns>The quotient of all the arguments and the internal integer</returns>
public ktValue _Divide(ktList Arguments)
{
ktValue Value = ktValue.Null;
int res = m_value;
int a = 1;
// Check so we actually got some arguments
if (Arguments.IsEmpty())
{
throw new ktError("Can't divide an integer with nothing (null)!", ktERR.NOTDEF);
}
// Go through the list of arguments
foreach (ktList L in Arguments)
{
// If there's nothing in this argument
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
// Get the argument as an integer
a = GetAsInt((ktValue)L.Node.Value);
// Check so it isn't zero
if (a == 0)
{
// Oops, can't do that!!!
throw new ktError("You can't divide by zero!", ktERR.DIV_BY_ZERO);
}
// Divide with the current argument
res /= a;
}
// Create a new ktInt and wrap it in a ktValue
Value = new ktValue("return", "ktInt", new ktInt(res), true, true);
return Value;
}
public bool SetVariable(ktString Name, ktValue Value)
{
return SetVariable(Name, Value, true);
}
public virtual int Compare(ktString op, ktValue val)
{
throw new ktError("Compare not implemented in '" + this.m_Name + "'!");
}