enscript.c

Go to the documentation of this file.

 
class Class
{
 proto native external bool IsInherited(typename type);
 
 proto native owned external string ClassName();
 
 string GetDebugName() { return ClassName(); }
 
 proto native external typename Type();
 
 proto external static typename StaticType();
 
 static typename StaticGetType(typename t)
 {
 return t;
 }
 
 proto external string ToString();
 
 proto static Class Cast(Class from);
 
 proto static bool CastTo(out Class to, Class from);
 
 private proto static bool SafeCastType(Class type, out Class to, Class from);
};
 
class Managed
{
};
 
class NonSerialized
{
};
 
typedef int[] TypeID;
 
class ScriptModule
{
 private void ~ScriptModule();
 
 proto volatile int Call(Class inst, string function, void parm);
 
 proto volatile int CallFunction(Class inst, string function, out void returnVal, void parm);
 proto volatile int CallFunctionParams(Class inst, string function, out void returnVal, Class parms);
 proto native void Release();
 
 static proto native ScriptModule LoadScript(ScriptModule parentModule, string scriptFile, bool listing);
};
 
//main script module (contains script.c and this file)
//ScriptModule g_Script;
 
class EnScript
{
 private void EnScript() {}
 private void ~EnScript() {}
 
 static proto int GetClassVar(Class inst, string varname,int index, out void result);
 
 static proto int SetClassVar(Class inst, string varname, int index, void input);
 
 static proto int SetVar(out void var, string value);
 
 static proto void Watch(void var, int flags);
};
 
 
 
proto void Sort(void param_array[], int num);
proto void reversearray(void param_array);
proto void copyarray(void destArray, void srcArray);
 
proto int ParseStringEx(inout string input, string token);
 
proto int ParseString(string input, out string tokens[]);
 
proto native int KillThread(Class owner, string name);
 
proto volatile void Idle();
 
proto owned string ThreadFunction(Class owner, string name, int backtrace, out int linenumber);
 
string String(string s)
{
 return s;
}
 
void PrintString(string s)
{
 Print(s);
}
 
class array<Class T>
{
 proto native int Count();
 proto native void Clear();
 proto void Set(int n, T value);
 proto int Find(T value);
 proto T Get(int n);
 proto int Insert(T value);
 proto int InsertAt(T value, int index);
 void InsertAll(notnull array<T> from)
 {
 for ( int i = 0; i < from.Count(); i++ )
 {
 Insert( from.Get(i) );
 }
 }
 proto native void Remove(int index);
 proto native void RemoveOrdered(int index);
 proto native void Resize(int newSize);
 
 proto native void Reserve(int newSize);
 
 proto native void Swap(notnull array<T> other);
 
 proto native void Sort(bool reverse = false);
 proto int Copy(notnull array<T> from);
 proto int Init(T init[]);
 
 void RemoveItem(T value)
 {
 int remove_index = Find(value);
 
 if ( remove_index >= 0 )
 {
 RemoveOrdered(remove_index);
 }
 }
 
 void RemoveItemUnOrdered(T value)
 {
 int remove_index = Find(value);
 
 if ( remove_index >= 0 )
 {
 Remove(remove_index);
 }
 }
 
 bool IsValidIndex( int index )
 {
 return ( index > -1 && index < Count() );
 }
 
 /*
 T GetChecked( int index )
 {
 if( IsValidIndex( index ) )
 return Get( index );
 else
 return null;
 }
 */
 
 void Debug()
 {
 Print(string.Format("Array count: %1", Count()));
 for (int i = 0; i < Count(); i++)
 {
 T item = Get(i);
 Print(string.Format("[%1] => %2", i, item));
 }
 }
 
 int GetRandomIndex()
 {
 if ( Count() > 0 )
 {
 return Math.RandomInt(0, Count());
 }
 
 return -1; 
 }
 
 T GetRandomElement()
 {
 return Get(GetRandomIndex());
 }
 
 void SwapItems(int item1_index, int item2_index)
 {
 T item1 = Get(item1_index);
 Set(item1_index, Get(item2_index));
 Set(item2_index, item1);
 }
 
 void InsertArray(array<T> other)
 {
 for (int i = 0; i < other.Count(); i++)
 {
 T item = other.Get(i);
 Insert(item);
 }
 }
 
 void Invert()
 {
 int left = 0;
 int right = Count() - 1;
 if (right > 0)
 {
 while (left < right)
 {
 T temp = Get(left);
 Set(left++, Get(right));
 Set(right--, temp);
 }
 }
 }
 
 int MoveIndex(int curr_index, int move_number)
 {
 int count = Count();
 int new_index = curr_index;
 
 if ( move_number > 0 )
 {
 new_index = curr_index + move_number;
 }
 
 if ( move_number < 0 )
 {
 new_index = curr_index - move_number;
 
 if ( new_index < 0 )
 {
 if ( new_index <= -count )
 {
 new_index = (new_index % count);
 }
 
 new_index = new_index + count;
 }
 }
 
 if ( new_index >= count )
 {
 new_index = (new_index % count);
 }
 
 // move_number is 0
 return new_index;
 }
 
 void ShuffleArray()
 {
 for (int i = 0; i < Count(); i++)
 {
 SwapItems(i,GetRandomIndex());
 }
 }
 
 int DifferentAtPosition(array<T> pOtherArray)
 {
 if (Count() != pOtherArray.Count())
 {
 ErrorEx("arrays are not the same size");
 return -1;
 }
 
 for (int i = 0; i < pOtherArray.Count(); ++i)
 {
 if (Get(i) != pOtherArray.Get(i))
 {
 return i;
 }
 }
 
 return -1;
 }
};
 
//force these to compile so we can link C++ methods to them
typedef array<string> TStringArray;
typedef array<float> TFloatArray;
typedef array<int> TIntArray;
typedef array<bool> TBoolArray;
typedef array<Class> TClassArray;
typedef array<Managed> TManagedArray;
typedef array<ref Managed> TManagedRefArray;
typedef array<vector> TVectorArray;
typedef array<typename> TTypenameArray;
 
class set<Class T>
{
 proto native int Count();
 proto native void Clear();
 proto int Find(T value);
 proto T Get(int n);
 proto int Insert(T value);
 proto int InsertAt(T value, int index);
 proto native void Remove(int index);
 proto int Copy(set<T> from);
 proto native void Swap(set<T> other);
 proto int Init(T init[]);
 
 void InsertSet(set<T> other)
 {
 int count = other.Count();
 for (int i = 0; i < count; i++)
 {
 T item = other[i];
 Insert(item);
 }
 }
 
 void RemoveItem(T value)
 {
 int remove_index = Find(value);
 if (remove_index >= 0)
 {
 Remove(remove_index);
 }
 }
 
 void RemoveItems(set<T> other)
 {
 int count = other.Count();
 for (int i = 0; i < count; i++)
 {
 T item = other[i];
 RemoveItem(item);
 }
 }
 
 void Debug()
 {
 Print(string.Format("Set count: %1", Count()));
 for (int i = 0; i < Count(); i++)
 {
 T item = Get(i);
 Print(string.Format("[%1] => %2", i, item));
 }
 }
};
 
//force these to compile so we can link C++ methods to them
typedef set<string> TStringSet;
typedef set<float> TFloatSet;
typedef set<int> TIntSet;
typedef set<Class> TClassSet;
typedef set<Managed> TManagedSet;
typedef set<ref Managed> TManagedRefSet;
typedef set<typename> TTypenameSet;
 
typedef int MapIterator;
class map<Class TKey,Class TValue>
{
 proto native int Count();
 
 proto native void Clear();
 proto TValue Get(TKey key);
 proto bool Find(TKey key, out TValue val);
 proto TValue GetElement(int index);
 proto TKey GetKey(int i);
 proto void Set(TKey key, TValue value);
 proto void Remove(TKey key);
 proto void RemoveElement(int i);
 proto bool Contains(TKey key);
 proto bool Insert(TKey key, TValue value);
 proto int Copy(map<TKey,TValue> from);
 
 array<TKey> GetKeyArray()
 {
 array<TKey> keys = new array<TKey>;
 for (int i = 0; i < Count(); i++)
 {
 keys.Insert( GetKey( i ) );
 }
 return keys;
 }
 
 array<TValue> GetValueArray()
 {
 array<TValue> elements = new array<TValue>;
 for (int i = 0; i < Count(); i++)
 {
 elements.Insert( GetElement( i ) );
 }
 return elements;
 }
 
 bool ReplaceKey(TKey old_key, TKey new_key)
 {
 if (Contains(old_key))
 {
 Set(new_key, Get(old_key));
 Remove(old_key);
 return true;
 } 
 return false;
 }
 
 TKey GetKeyByValue(TValue value)
 {
 TKey ret;
 for (int i = 0; i < Count(); i++)
 {
 if (GetElement(i) == value) 
 {
 ret = GetKey(i);
 break;
 }
 }
 
 return ret;
 }
 
 bool GetKeyByValueChecked(TValue value, out TKey key)
 {
 for (int i = 0; i < Count(); i++)
 {
 if (GetElement(i) == value) 
 {
 key = GetKey(i);
 return true;
 }
 }
 return false;
 }
 
 proto native MapIterator Begin();
 proto native MapIterator End();
 proto native MapIterator Next(MapIterator it);
 proto TKey GetIteratorKey(MapIterator it);
 proto TValue GetIteratorElement(MapIterator it);
};
 
typedef map<int, float> TIntFloatMap;
typedef map<int, int> TIntIntMap;
typedef map<int, string> TIntStringMap;
typedef map<int, Class> TIntClassMap;
typedef map<int, Managed> TIntManagedMap;
typedef map<int, ref Managed> TIntManagedRefMap;
typedef map<int, typename> TIntTypenameMap;
typedef map<int, vector> TIntVectorMap;
 
typedef map<string, float> TStringFloatMap;
typedef map<string, int> TStringIntMap;
typedef map<string, string> TStringStringMap;
typedef map<string, Class> TStringClassMap;
typedef map<string, Managed> TStringManagedMap;
typedef map<string, ref Managed> TStringManagedRefMap;
typedef map<string, typename> TStringTypenameMap;
typedef map<string, vector> TStringVectorMap;
 
typedef map<Class, float> TClassFloatMap;
typedef map<Class, int> TClassIntMap;
typedef map<Class, string> TClassStringMap;
typedef map<Class, Class> TClassClassMap;
typedef map<Class, Managed> TClassManagedMap;
typedef map<Class, ref Managed> TClassManagedRefMap; 
typedef map<Class, typename> TClassTypenameMap;
typedef map<Class, vector> TClassVectorMap;
 
typedef map<typename, float> TTypeNameFloatMap;
typedef map<typename, int> TTypeNameIntMap;
typedef map<typename, string> TTypeNameStringMap;
typedef map<typename, Class> TTypeNameClassMap;
typedef map<typename, Managed> TTypeNameManagedMap;
typedef map<typename, ref Managed> TTypeNameManagedRefMap;
typedef map<typename, typename> TTypeNameTypenameMap;
typedef map<typename, vector> TTypeNameVectorMap;
 
typedef map<Managed, float> TManagedFloatMap;
typedef map<Managed, int> TManagedIntMap;
typedef map<Managed, string> TManagedStringMap;
typedef map<Managed, Class> TManagedClassMap;
typedef map<Managed, Managed> TManagedManagedMap;
typedef map<Managed, ref Managed> TManagedManagedRefMap;
typedef map<Managed, typename> TManagedTypenameMap;
typedef map<Managed, vector> TManagedVectorMap;
 
typedef map<ref Managed, float> TManagedRefFloatMap;
typedef map<ref Managed, int> TManagedRefIntMap;
typedef map<ref Managed, string> TManagedRefStringMap;
typedef map<ref Managed, Class> TManagedRefClassMap;
typedef map<ref Managed, Managed> TManagedRefManagedMap;
typedef map<ref Managed, ref Managed> TManagedRefManagedRefMap;
typedef map<ref Managed, typename> TManagedRefTypenameMap;
typedef map<ref Managed, vector> TManagedRefVectorMap;