private static void initSuperTable()
{
//////////////////////////////////////////////////////
Unit StringSlice(VM vm)
{
string input_string = vm.GetString(0);
Float start = vm.GetNumber(1);
Float end = vm.GetNumber(2);
if (end < input_string.Length)
{
string result = input_string.Substring((int)start, (int)(end - start));
return(new Unit(result));
}
return(new Unit(UnitType.Null));
}
methodTable.Set("slice", new IntrinsicUnit("string_slice", StringSlice, 3));
//////////////////////////////////////////////////////
Unit StringSplit(VM vm)
{
StringUnit val_input_string = vm.GetStringUnit(0);
string input_string = val_input_string.ToString();
Float start = vm.GetNumber(1);
if (start < input_string.Length)
{
Float end = input_string.Length;
string result = input_string.Substring((int)start, (int)(end - start));
val_input_string.content = input_string.Substring(0, (int)start);
return(new Unit(result));
}
return(new Unit(UnitType.Null));
}
methodTable.Set("split", new IntrinsicUnit("string_split", StringSplit, 2));
//////////////////////////////////////////////////////
Unit StringLength(VM vm)
{
StringUnit val_input_string = vm.GetStringUnit(0);
return(new Unit(val_input_string.content.Length));
}
methodTable.Set("length", new IntrinsicUnit("string_length", StringLength, 1));
//////////////////////////////////////////////////////
Unit StringCopy(VM vm)
{
Unit val_input_string = vm.GetUnit(0);
if (val_input_string.Type == UnitType.String)
{
return(new Unit(val_input_string.ToString()));
}
else
{
return(new Unit(UnitType.Null));
}
}
methodTable.Set("copy", new IntrinsicUnit("string_copy", StringCopy, 1));
//////////////////////////////////////////////////////
Unit ToList(VM vm)
{
string val_input_string = vm.GetString(0);
List <Unit> string_list = new List <Unit>();
foreach (char c in val_input_string.ToCharArray())
{
string_list.Add(new Unit(c));
}
return(new Unit(new ListUnit(string_list)));
}
methodTable.Set("to_list", new IntrinsicUnit("string_to_list", ToList, 1));
//////////////////////////////////////////////////////
Unit CharAt(VM vm)
{
string input_string = vm.GetString(0);
Integer index = vm.GetInteger(1);
if (index < input_string.Length)
{
char result = input_string[(int)index];
return(new Unit(result));
}
return(new Unit(UnitType.Null));
}
methodTable.Set("char_at", new IntrinsicUnit("string_char_at", CharAt, 2));
//////////////////////////////////////////////////////
Unit Contains(VM vm)
{
string input_string = vm.GetString(0);
string contained_string = vm.GetString(1);
return(new Unit(input_string.Contains(contained_string)));
}
methodTable.Set("contains", new IntrinsicUnit("string_contains", Contains, 2));
//////////////////////////////////////////////////////
Unit ContainsChar(VM vm)
{
string input_string = vm.GetString(0);
char contained_char = vm.GetChar(1);
return(new Unit(input_string.Contains(contained_char)));
}
methodTable.Set("contains_char", new IntrinsicUnit("string_contains_char", ContainsChar, 2));
//////////////////////////////////////////////////////
Unit Escape(VM vm)
{
string input_string = vm.GetString(0);
return(new Unit(System.Text.RegularExpressions.Regex.Escape(input_string)));
}
methodTable.Set("escape", new IntrinsicUnit("string_escape", Escape, 1));
//////////////////////////////////////////////////////
Unit Unescape(VM vm)
{
string input_string = vm.GetString(0);
return(new Unit(System.Text.RegularExpressions.Regex.Unescape(input_string)));
}
methodTable.Set("unescape", new IntrinsicUnit("string_unescape", Unescape, 1));
}
private static void initMethodTable()
{
{
Unit Clone(VM vm)
{
TableUnit this_table = vm.GetTable(0);
Dictionary <Unit, Unit> table_copy = new Dictionary <Unit, Unit>();
foreach (KeyValuePair <Unit, Unit> entry in this_table.Map)
{
table_copy.Add(entry.Key, entry.Value);
}
TableUnit copy = new TableUnit(table_copy);
copy.ExtensionTable = this_table.ExtensionTable;
return(new Unit(copy));
}
methodTable.Set("clone", new IntrinsicUnit("table_clone", Clone, 1));
//////////////////////////////////////////////////////
Unit Count(VM vm)
{
TableUnit this_table = vm.GetTable(0);
int count = this_table.Count;
return(new Unit(count));
}
methodTable.Set("count", new IntrinsicUnit("table_count", Count, 1));
//////////////////////////////////////////////////////
Unit Clear(VM vm)
{
TableUnit this_table = vm.GetTable(0);
this_table.Map.Clear();
return(new Unit(UnitType.Null));
}
methodTable.Set("clear", new IntrinsicUnit("table_clear", Clear, 1));
//////////////////////////////////////////////////////
Unit ToString(VM vm)
{
TableUnit this_table = vm.GetTable(0);
string value = "";
bool first = true;
foreach (KeyValuePair <Unit, Unit> entry in this_table.Map)
{
if (first)
{
value +=
System.Text.RegularExpressions.Regex.Unescape(entry.Key.ToString())
+ " : " + System.Text.RegularExpressions.Regex.Unescape(entry.Value.ToString());
first = false;
}
else
{
value +=
", "
+ System.Text.RegularExpressions.Regex.Unescape(entry.Key.ToString())
+ " : " + System.Text.RegularExpressions.Regex.Unescape(entry.Value.ToString());
}
}
return(new Unit(value));
}
methodTable.Set("to_string", new IntrinsicUnit("table_to_string", ToString, 1));
//////////////////////////////////////////////////////
Unit MakeIterator(VM vm)
{
TableUnit this_table = vm.GetTable(0);
System.Collections.IDictionaryEnumerator enumerator = this_table.Map.GetEnumerator();
TableUnit iterator = new TableUnit(null);
iterator.Set("key", new Unit(UnitType.Null));
iterator.Set("value", new Unit(UnitType.Null));
Unit next(VM vm)
{
if (enumerator.MoveNext())
{
iterator.Set("key", (Unit)(enumerator.Key));
iterator.Set("value", (Unit)(enumerator.Value));
return(new Unit(true));
}
return(new Unit(false));
};
iterator.Set("next", new IntrinsicUnit("table_iterator_next", next, 0));
return(new Unit(iterator));
}
methodTable.Set("iterator", new IntrinsicUnit("table_iterator", MakeIterator, 1));
//////////////////////////////////////////////////////
Unit MakeNumericIterator(VM vm)
{
TableUnit this_table = vm.GetTable(0);
System.Collections.IDictionaryEnumerator enumerator = this_table.Map.GetEnumerator();
TableUnit iterator = new TableUnit(null);
iterator.Set("key", new Unit(UnitType.Null));
iterator.Set("value", new Unit(UnitType.Null));
Unit next(VM vm)
{
while (true)
{
if (enumerator.MoveNext())
{
if (Unit.IsNumeric((Unit)enumerator.Key))
{
iterator.Set("key", (Unit)(enumerator.Key));
iterator.Set("value", (Unit)(enumerator.Value));
return(new Unit(true));
}
}
else
{
return(new Unit(false));
}
}
};
iterator.Set("next", new IntrinsicUnit("table_iterator_next", next, 0));
return(new Unit(iterator));
}
methodTable.Set("numeric_iterator", new IntrinsicUnit("table_numeric_iterator", MakeNumericIterator, 1));
//////////////////////////////////////////////////////
Unit Indexes(VM vm)
{
TableUnit this_table = vm.GetTable(0);
ListUnit indexes = new ListUnit(null);
foreach (Unit v in this_table.Map.Keys)
{
indexes.Elements.Add(v);
}
return(new Unit(indexes));
}
methodTable.Set("indexes", new IntrinsicUnit("table_indexes", Indexes, 1));
//////////////////////////////////////////////////////
Unit NumericIndexes(VM vm)
{
TableUnit this_table = vm.GetTable(0);
ListUnit indexes = new ListUnit(null);
foreach (Unit v in this_table.Map.Keys)
{
if (Unit.IsNumeric(v))
{
indexes.Elements.Add(v);
}
}
return(new Unit(indexes));
}
methodTable.Set("numeric_indexes", new IntrinsicUnit("table_numeric_indexes", NumericIndexes, 1));
//////////////////////////////////////////////////////
Unit SetExtensionTable(VM vm)
{
Unit this_unit = vm.GetUnit(0);
TableUnit extension_table = vm.GetTable(1);
if (extension_table.GetExtensionTable() != null)
{
throw new Exception("Extension Table has an Extention Table!");
}
if (this_unit.heapUnitValue.GetExtensionTable() != null)
{
throw new Exception("Table already has an Extention Table!");
}
this_unit.heapUnitValue.SetExtensionTable(extension_table);
return(new Unit(UnitType.Null));
}
methodTable.Set("set_extension_table", new IntrinsicUnit("table_set_extension_table", SetExtensionTable, 2));
//////////////////////////////////////////////////////
Unit UnsetExtensionTable(VM vm)
{
Unit this_unit = vm.GetUnit(0);
this_unit.heapUnitValue.UnsetExtensionTable();
return(new Unit(UnitType.Null));
}
methodTable.Set("unset_extension_table", new IntrinsicUnit("table_unset_extension_table", UnsetExtensionTable, 1));
//////////////////////////////////////////////////////
Unit GetExtensionTable(VM vm)
{
Unit this_unit = vm.GetUnit(0);
TableUnit extension_table = this_unit.heapUnitValue.GetExtensionTable();
if (extension_table == null)
{
return(new Unit(UnitType.Null));
}
return(new Unit(extension_table));
}
methodTable.Set("get_extension_table", new IntrinsicUnit("table_get_extension_table", GetExtensionTable, 1));
//////////////////////////////////////////////////////
Unit Merge(VM vm)
{
TableUnit this_table = vm.GetTable(0);
TableUnit merging_table = vm.GetTable(1);
foreach (KeyValuePair <Unit, Unit> u in merging_table.Map)
{
if (!this_table.Map.ContainsKey(u.Key))
{
this_table.Map.Add(u.Key, u.Value);
}
}
return(new Unit(UnitType.Null));
}
methodTable.Set("merge", new IntrinsicUnit("merge", Merge, 2));
}
}
private static void initMethodTable()
{
{
//////////////////////////////////////////////////////
Unit Clone(VM vm)
{
ListUnit this_list = vm.GetList(0);
List <Unit> new_list_elements = new List <Unit>();
foreach (Unit v in this_list.Elements)
{
new_list_elements.Add(v);
}
ListUnit new_list = new ListUnit(new_list_elements);
new_list.MethodTable = this_list.MethodTable;
return(new Unit(new_list));
}
methodTable.Set("clone", new IntrinsicUnit("list_clone", Clone, 1));
//////////////////////////////////////////////////////
Unit Count(VM vm)
{
ListUnit this_list = vm.GetList(0);
int count = this_list.Count;
return(new Unit(count));
}
methodTable.Set("count", new IntrinsicUnit("list_count", Count, 1));
//////////////////////////////////////////////////////
Unit Clear(VM vm)
{
ListUnit this_list = vm.GetList(0);
this_list.Elements.Clear();
return(new Unit(UnitType.Null));
}
methodTable.Set("clear", new IntrinsicUnit("list_clear", Clear, 1));
//////////////////////////////////////////////////////
Unit ToString(VM vm)
{
ListUnit this_list = vm.GetList(0);
bool first = true;
string value = "";
foreach (Unit v in this_list.Elements)
{
if (first)
{
value += System.Text.RegularExpressions.Regex.Unescape(v.ToString());
first = false;
}
else
{
value += ", " + System.Text.RegularExpressions.Regex.Unescape(v.ToString());
}
}
return(new Unit(value));
}
methodTable.Set("to_string", new IntrinsicUnit("list_to_string", ToString, 1));
//////////////////////////////////////////////////////
Unit MakeIndexesIterator(VM vm)
{
ListUnit this_list = vm.GetList(0);
int i = -1;
TableUnit iterator = new TableUnit(null);
Unit next(VM vm)
{
if (i < (this_list.Count - 1))
{
i++;
iterator.Set("key", i);
iterator.Set("value", this_list.Elements[i]);
return(new Unit(true));
}
return(new Unit(false));
};
iterator.Set("next", new IntrinsicUnit("list_index_iterator_next", next, 0));
return(new Unit(iterator));
}
methodTable.Set("index_iterator", new IntrinsicUnit("list_index_iterator", MakeIndexesIterator, 1));
//////////////////////////////////////////////////////
Unit MakeIterator(VM vm)
{
ListUnit this_list = vm.GetList(0);
int i = -1;
Unit value = new Unit(UnitType.Null);
TableUnit iterator = new TableUnit(null);
Unit next(VM vm)
{
if (i < (this_list.Count - 1))
{
i++;
iterator.Set("value", this_list.Elements[i]);
return(new Unit(true));
}
return(new Unit(false));
};
iterator.Set("next", new IntrinsicUnit("list_iterator_next", next, 0));
return(new Unit(iterator));
}
methodTable.Set("iterator", new IntrinsicUnit("list_iterator", MakeIterator, 1));
//////////////////////////////////////////////////////
Unit Init(VM vm)
{
ListUnit this_list = vm.GetList(0);
Integer new_end = vm.GetInteger(1);
int size = this_list.Count;
for (int i = size; i < new_end; i++)
{
this_list.Elements.Add(new Unit(UnitType.Null));
}
return(new Unit(UnitType.Null));
}
methodTable.Set("init", new IntrinsicUnit("list_init", Init, 2));
//////////////////////////////////////////////////////
Unit Push(VM vm)
{
ListUnit this_list = vm.GetList(0);
Unit value = vm.GetUnit(1);
this_list.Elements.Add(value);
return(new Unit(UnitType.Null));
}
methodTable.Set("push", new IntrinsicUnit("list_push", Push, 2));
//////////////////////////////////////////////////////
Unit Pop(VM vm)
{
ListUnit this_list = vm.GetList(0);
Float value = this_list.Elements[^ 1].floatValue;