package com.ucalc.lib;

/**
 * Auto-generated with uCalc Transform 3.0 on 10/21/16
 */
public class uCalc {




   public class BuiltInTypesEnum {
     public static final int Type_Unspecified = 0;
     public static final int Type_Auto = 1;
     public static final int Type_Boolean = 2;
     public static final int Type_Integer_8 = 3;
     public static final int Type_Integer_8u = 4;
     public static final int Type_Integer_16 = 5;
     public static final int Type_Integer_16u = 6;
     public static final int Type_Integer_32 = 7;
     public static final int Type_Integer_32u = 8;
     public static final int Type_Integer_64 = 9;
     public static final int Type_Integer_64u = 10;
     public static final int Type_Integer_128 = 11;
     public static final int Type_Integer_128u = 12;
     public static final int Type_Float_Single = 13;
     public static final int Type_Float_Double = 14;
     public static final int Type_Float_Extended = 15;
     public static final int Type_Size_t = 16;
     public static final int Type_Complex = 17;
     public static final int Type_Decimal = 18;
     public static final int Type_BigNum = 19;
     public static final int Type_Date = 20;
     public static final int Type_String = 21;
     public static final int Type_String_LPCSTR = 22;
     public static final int Type_String_Fixed = 23;
     public static final int Type_String_Wide = 24;
     public static final int Type_List_Stack = 25;
     public static final int Type_List_Table = 26;
     public static final int Type_List_Sorted = 27;
     public static final int Type_Null = 28;
     public static final int Type_Void = 29;
     public static final int Type_Any = 30;
     public static final int Type_Pointer = 31;
     public static final int Type_Omni = 32;
     public static final int Type_UserDefined = 33;
     public static final int Type_DataType = 34;
     public static final int Type_Namespace = 35;
     public static final int Type_IntPtr = 36;
     public static final int Type_ADDR = 37;
     public static final int Type_uCalcPtr = 38;
     public static final int Type_Item = 39;
     public static final int Type_ParsedExpr = 40;
     public static final int Type_uCalcCallback = 41;
     public static final int Type_Object = 42;
     public static final int Type_Intrinsic = 43;
   }

   public class DataTypeConstruction {
     public static final int TypeConstr_ByteSize = 0;
     public static final int TypeConstr_AllocArray = 1;
     public static final int TypeConstr_AllocScalar = 2;
     public static final int TypeConstr_AllocByPtr = 3;
     public static final int TypeConstr_ReleaseArray = 4;
     public static final int TypeConstr_ReleaseScalar = 5;
     public static final int TypeConstr_ResetScalar = 6;
     public static final int TypeConstr_ResetArray = 7;
     public static final int TypeConstr_SetArrayValue = 8;
     public static final int TypeConstr_SetScalarValue = 9;
     public static final int TypeConstr_SwapScalarValues = 10;
   }

   public class ErrorHandlerResponseEnum {
     public static final int ErrorAbort = 0;
     public static final int ErrorResume = 1;
     public static final int ErrorReRaise = 2;
   }

   public class ErrorNumberEnum {
     public static final int Err_None = 0;
     public static final int Err_Dynamically_Defined = 1;
     public static final int Err_Syntax_Error = 2;
     public static final int Err_Undefined_Identifier = 3;
     public static final int Err_FileNotFound = 4;
     public static final int Err_Unrecognized_Token = 5;
     public static final int Err_Unrecognized_Command = 6;
     public static final int Err_Datatype_Mismatch = 7;
     public static final int Err_Invalid_Argument_Count = 8;
     public static final int Err_Invalid_Definition = 9;
     public static final int Err_CodeBlock_Error = 10;
     public static final int Err_Undefined_Callback = 11;
     public static final int Err_ErrorMessageAlreadyDefined = 12;
     public static final int Err_ItemCannotBeModified = 13;
     public static final int Err_Unrecognized_Class_Member = 14;
     public static final int Err_Unrecognized_Namespace_Member = 15;
     public static final int Err_Unbalanced_Quote = 16;
     public static final int Err_ValueCannotBeAssigned = 17;
     public static final int Err_ReParseOverflow = 18;
     public static final int Err_Array_Bounds_Exceeded = 19;
     public static final int Err_Float_Division_By_Zero = 20;
     public static final int Err_Float_Inexact_Result = 21;
     public static final int Err_Float_Invalid_Operation = 22;
     public static final int Err_Float_Overflow = 23;
     public static final int Err_Float_Underflow = 24;
     public static final int Err_Customized1 = 100;
     public static final int Err_Customized2 = 101;
     public static final int Err_Customized3 = 102;
     public static final int Err_Customized4 = 103;
     public static final int Err_Customized5 = 104;
     public static final int Err_Customized6 = 105;
     public static final int Err_Customized7 = 106;
     public static final int Err_Customized8 = 107;
     public static final int Err_Customized9 = 108;
     public static final int Err_Customized10 = 109;
     public static final int Err_Customized11 = 110;
     public static final int Err_Customized12 = 111;
     public static final int Err_Customized13 = 112;
     public static final int Err_Customized14 = 113;
     public static final int Err_Customized15 = 114;
     public static final int Err_Customized16 = 115;
     public static final int Err_Customized17 = 116;
     public static final int Err_Customized18 = 117;
     public static final int Err_Customized19 = 118;
     public static final int Err_Customized20 = 119;
   }

   public class GroupingEnum {
     public static final int GroupLeftToRight = 0;
     public static final int GroupRightToLeft = 1;
   }

   public class ItemIsEnum {
     public static final int AnyItem = 0;
     public static final int RightToLeft = 1;
     public static final int DataType = 2;
     public static final int Array = 3;
     public static final int Class = 4;
     public static final int NameSpace = 5;
     public static final int Variable = 6;
     public static final int LocalVariable = 7;
     public static final int Function = 8;
     public static final int Operator = 9;
     public static final int FunctionOrOperator = 10;
     public static final int Prefix = 11;
     public static final int Infix = 12;
     public static final int Postfix = 13;
     public static final int AddressOwner = 14;
     public static final int ByVal = 15;
     public static final int ByRef = 16;
     public static final int ByCopy = 17;
     public static final int ByExpr = 18;
     public static final int ByHandle = 19;
     public static final int Pointer = 20;
     public static final int Optional = 21;
     public static final int VariableNumberOfArgs = 22;
     public static final int LiteralItem = 23;
     public static final int Locked = 24;
     public static final int Enabled = 25;
     public static final int Exclude = 26;
     public static final int Transform = 27;
     public static final int Search = 28;
     public static final int ItemDef = 29;
     public static final int ErrorHandler = 30;
     public static final int StopNow = 31;
     public static final int ApiCall = 32;
     public static final int CaseSensitive = 33;
     public static final int QuotedText = 34;
     public static final int RewindOnChange = 35;
     public static final int ExpandArg = 36;
     public static final int Active = 37;
     public static final int IgnoreStatementSep = 38;
     public static final int IgnoreCodeBlock = 39;   
     public static final int SkipEvalExpand = 40;
     public static final int ExprUnit = 41;
     public static final int EagerArg = 42;
     public static final int SkipSyntax = 43;
     public static final int SkipOver = 44;
     public static final int Modified = 45;
     public static final int WhiteSpaceCounts = 46;
     public static final int IgnoreQuote = 47;
     public static final int UpToEndOrSeparator = 48;
     public static final int UpToUserStop = 49;
     public static final int UpToCompleted = 50;   
     public static final int ExpandMode = 51;
     public static final int StepsOn = 52;
     public static final int EvalStrOutput = 53;
     public static final int SkipOutput = 54;
     public static final int DefaultSettings = 55;
     public static final int NotFound = 56;  
     public static final int MiscItem = 57;
   }

   public class LicenseTypeEnum {
     public static final int License_Demo = 0;
     public static final int License_FMP_Free = 1;
     public static final int License_FMP_Standard_32 = 2;
     public static final int License_FMP_Standard_64 = 3;
     public static final int License_FMP_32_and_64 = 4;
     public static final int License_LanguageBuilder = 5;
     public static final int License_GeneralParser = 6;
     public static final int License_Interpreter = 7;
     public static final int License_ConsoleCalc = 8;
     public static final int License_WindowsCalc = 9;
     public static final int License_StringLib = 10;
     public static final int License_Transform = 11;
     public static final int License_TransformLib = 12;
     public static final int License_Search = 13;
     public static final int License_SearchLib = 14;
     public static final int License_Library1 = 15;
     public static final int License_Library2 = 16;
     public static final int License_Beta = 17;
     public static final int License_Debugger = 18;
     public static final int License_uCalc_All = 19;
     public static final int License_Developer = 20;
     public static final int License_EndUser = 21;
   }

   public class TokenEnum {
     public static final int None = 0;
     public static final int Generic = 1;
     public static final int Empty = 2;
     public static final int AlphaNumeric = 3;
     public static final int ArgSeparator = 4;
     public static final int CodeBlock = 5;
     public static final int CodeBlockMatch = 6;
     public static final int MemberAccess = 7;
     public static final int Literal = 8;
     public static final int StatementSep = 9;
     public static final int WhiteSpace = 10;
     public static final int Reducible = 11;
     public static final int Eof = 12;
     public static final int CurrentThread = 13; 
     public static final int LocalVar = 14;
     public static final int StaticVar = 15;
     public static final int DefineNow = 15;
     public static final int TempDef = 16;
     public static final int EvalInsert = 17;
     public static final int EvalDuringParse = 18;
     public static final int ExpandInsert = 19;
     public static final int FileInclude = 20;
     public static final int CurrentSpace = 21;
     public static final int DefSpace = 22;
     public static final int EvalSpace = 23;
   }

   public class TrueFalseEnum {
     public static final int False = 0;
     public static final int True = 1;
   }

   public class FPEnvExceptionEnum {
     public static final int DivisionByZero = 8;
     public static final int Inexact = 1;
     public static final int Invalid = 16;
     public static final int Overflow = 4;
     public static final int Underflow = 2;
     public static final int AllExceptions = 31; 
   }

   public class FPEnvRoundingEnum {
     public static final int Round_Down = 512;
     public static final int Round_ToNearest = 0;
     public static final int Round_TowardZero = 768;
     public static final int Round_Up = 256; 
   }

   public class RegExGrammarEnum {
     public static final int RegEx_Default = 0;
     public static final int RegEx_ECMAScript = 1;
     public static final int RegEx_basic = 2;
     public static final int RegEx_extended = 3;
     public static final int RegEx_awk = 4;
     public static final int RegEx_grep = 5;
     public static final int RegEx_egrep = 6;
   }

   public class TransformResetEnum {
     public static final int Reset_All = 0;
     public static final int Reset_Input = 1;
     public static final int Reset_Tokens = 2;
     public static final int Reset_Rules = 3;
     public static final int Reset_Results = 4;
     public static final int Reset_Passes = 5;
   }

   public class PassEnum {
     public static final int Pass_Independent = 0;
     public static final int Pass_InheritCopy = 1;
     public static final int Pass_InheritShare = 2;
   }

   public class StepsEnum {
     public static final int Steps_None = 0;
     public static final int Steps_All = 1;
     public static final int Steps_Passes = 2;
   }

   public class TransformPropertiesEnum {
     public static final int NoTransformProperties = 0;
     public static final int Snapshot_EachChange = 1;
     public static final int Snapshot_EachPass = 2;
     public static final int Snapshot_LocalChange = 4;
     public static final int Archive_LocalOriginals = 5;
     public static final int CountChanges = 8;
   }







public int uCalcHandle;


public class ParsedExpr {


public int ExprHandle;




public double Evaluate() { return  uCalcImport.Evaluate(ExprHandle); } 


public double EvaluateNTE() { return  uCalcImport.EvaluateNTE(ExprHandle); } 


public int EvaluateInt32() { return  uCalcImport.EvaluateInt32(ExprHandle); } 


public String EvaluateStr() { return  uCalcImport.EvaluateStr(ExprHandle); } 


public int EvaluateVoid() { return  uCalcImport.EvaluateVoid(ExprHandle); } 


public void Execute() { uCalcImport.Execute(ExprHandle); } 


public void ReleaseExpr() { uCalcImport.ReleaseExpr(ExprHandle); } 


public int Handle() { return  uCalcImport.Handle1Overload1ParsedExpr(ExprHandle); } 


public void Release() { ReleaseExpr(); ExprHandle = 0; }


public ParsedExpr() { ExprHandle = 0; }
public ParsedExpr( int ExpressionHandle) { ExprHandle = ExpressionHandle; }
public ParsedExpr( ParsedExpr ParsedExprInstance) { ExprHandle = ParsedExprInstance.ExprHandle; }
   }



public class Item {


public int ItemHandle;


public int ElementCount() { return  uCalcImport.ElementCount(ItemHandle); } 


public DataType GetDataType() { return  new DataType(uCalcImport.GetDataType(ItemHandle )); } 


public int FunctionAddress() { return  uCalcImport.FunctionAddress(ItemHandle); } 


public int IsProperty(int ItemProperty) { return  uCalcImport.IsProperty(ItemHandle,  ItemProperty); } 


public String Name() { return  uCalcImport.Name1Overload1Item(ItemHandle); } 


public Item NextOverload() { return  new Item(uCalcImport.NextOverload(ItemHandle )); } 


public int Precedence() { return  uCalcImport.Precedence1Overload1Item(ItemHandle); } 


public void ReleaseItem() { uCalcImport.ReleaseItem(ItemHandle); } 


public void Rename(String NewName) { uCalcImport.Rename(ItemHandle,  NewName); } 


public void SetVariableValue(double Value) { uCalcImport.SetVariableValue(ItemHandle,  Value); } 


public void SetVariableValueAny(String Value) { uCalcImport.SetVariableValueAny(ItemHandle,  Value); } 


public void SetVariableValueByte(byte  Value) { uCalcImport.SetVariableValueByte(ItemHandle,   Value); } 


public void SetVariableValueInt16(short  Value) { uCalcImport.SetVariableValueInt16(ItemHandle,   Value); } 


public void SetVariableValueInt32(int Value) { uCalcImport.SetVariableValueInt32(ItemHandle,  Value); } 


public void SetVariableValueInt64(long  Value) { uCalcImport.SetVariableValueInt64(ItemHandle,   Value); } 


public void SetVariableValueSng(float Value) { uCalcImport.SetVariableValueSng(ItemHandle,  Value); } 


public void SetVariableValueDbl(double Value) { uCalcImport.SetVariableValueDbl(ItemHandle,  Value); } 


public void SetVariableValueStr(String Value) { uCalcImport.SetVariableValueStr(ItemHandle,  Value); } 


public void SetVariableValuePtr(int Value) { uCalcImport.SetVariableValuePtr(ItemHandle,  Value); } 


public void SetVariableValueByPtr(int Value) { uCalcImport.SetVariableValueByPtr(ItemHandle,  Value); } 


public String Text() { return  uCalcImport.Text(ItemHandle); } 


public uCalc GetuCalc() { return  new uCalc(uCalcImport.GetuCalc1Overload1Item(ItemHandle )); } 


public double Value() { return  uCalcImport.Value(ItemHandle); } 


public byte ValueByte() { return  uCalcImport.ValueByte(ItemHandle); } 


public short ValueInt16() { return  uCalcImport.ValueInt16(ItemHandle); } 


public int ValueInt32() { return  uCalcImport.ValueInt32(ItemHandle); } 


public long ValueInt64() { return  uCalcImport.ValueInt64(ItemHandle); } 


public float ValueSng() { return  uCalcImport.ValueSng(ItemHandle); } 


public double ValueDbl() { return  uCalcImport.ValueDbl(ItemHandle); } 


public String ValueStr() { return  uCalcImport.ValueStr(ItemHandle); } 


public int ValuePtr() { return  uCalcImport.ValuePtr(ItemHandle); } 


public int ValueAddr() { return  uCalcImport.ValueAddr(ItemHandle); } 


public int Handle() { return  uCalcImport.Handle1Overload1Item(ItemHandle); } 


public void Release() { ReleaseItem(); ItemHandle = 0; }


public Item() { ItemHandle = 0; }
public Item( int PassedItemHandle) { ItemHandle = PassedItemHandle; }
public Item( Item ItemHandleInstance) { ItemHandle = ItemHandleInstance.ItemHandle; }
   }





public class Callback {


public int ExprPartHandle;


public double Arg(int Index) { return  uCalcImport.Arg(ExprPartHandle,  Index); } 


public int ArgCount() { return  uCalcImport.ArgCount(ExprPartHandle); } 


public Item ArgObj(int Index) { return  new Item(uCalcImport.ArgObj(ExprPartHandle,  Index )); } 


public int ArgAddr(int Index) { return  uCalcImport.ArgAddr(ExprPartHandle,  Index); } 


public ParsedExpr ArgExpr(int Index) { return  new ParsedExpr(uCalcImport.ArgExpr(ExprPartHandle,  Index )); } 


public int ArgInt32(int Index) { return  uCalcImport.ArgInt32(ExprPartHandle,  Index); } 


public long ArgInt64(int Index) { return  uCalcImport.ArgInt64(ExprPartHandle,  Index); } 


public int ArgPtr(int Index) { return  uCalcImport.ArgPtr(ExprPartHandle,  Index); } 


public String ArgStr(int Index) { return  uCalcImport.ArgStr(ExprPartHandle,  Index); } 


public void Return(double Value) { uCalcImport.Return(ExprPartHandle,  Value); } 


public void ReturnInt32(int Value) { uCalcImport.ReturnInt32(ExprPartHandle,  Value); } 


public void ReturnInt64(long  Value) { uCalcImport.ReturnInt64(ExprPartHandle,   Value); } 


public void ReturnPtr(int Value) { uCalcImport.ReturnPtr(ExprPartHandle,  Value); } 


public void ReturnStr(String Value) { uCalcImport.ReturnStr(ExprPartHandle,  Value); } 


public int ErrorRaise(int ErrNumber) { return  uCalcImport.ErrorRaise(ExprPartHandle,  ErrNumber); } 


public int ErrorRaiseMessage(String ErrMessage) { return  uCalcImport.ErrorRaiseMessage(ExprPartHandle,  ErrMessage); } 


public uCalc GetuCalc() { return  new uCalc(uCalcImport.GetuCalc1Overload1Callback(ExprPartHandle )); } 


public int Handle() { return  uCalcImport.Handle1Overload1Callback(ExprPartHandle); } 


public Item OpItem() { return  new Item(uCalcImport.OpItem(ExprPartHandle )); } 


public Callback() { ExprPartHandle = 0; }
public Callback( int ExpressionHandle) { ExprPartHandle = ExpressionHandle; }
public Callback( Callback ExprInstance) { ExprPartHandle = ExprInstance.ExprPartHandle; }
   }



public class DataType {


public int DataTypeHandle;


public int AllocArray(int ArraySize) { return  uCalcImport.AllocArray(DataTypeHandle,  ArraySize); } 


public int AllocByPtr(int ValuePtr) { return  uCalcImport.AllocByPtr(DataTypeHandle,  ValuePtr); } 


public int AllocScalar() { return  uCalcImport.AllocScalar(DataTypeHandle, ""); }

 public int AllocScalar(String Value) { return  uCalcImport.AllocScalar(DataTypeHandle,  Value); } 


public int ByteSize() { return  uCalcImport.ByteSize(DataTypeHandle); } 


public int Index() { return  uCalcImport.Index(DataTypeHandle); } 


public Item GetItem() { return  new Item(uCalcImport.GetItem(DataTypeHandle )); } 


public String Name() { return  uCalcImport.Name1Overload1DataType(DataTypeHandle); } 


public void ReleaseArray(int ValuePtr) { uCalcImport.ReleaseArray(DataTypeHandle,  ValuePtr); } 


public void ReleaseScalar(int ValuePtr) { uCalcImport.ReleaseScalar(DataTypeHandle,  ValuePtr); } 


public void ResetArray(int ValuePtr) { uCalcImport.ResetArray(DataTypeHandle,  ValuePtr); } 


public void ResetScalar(int ValuePtr) { uCalcImport.ResetScalar(DataTypeHandle,  ValuePtr); } 


public void SetArray(int Destination ,  int Source ,  int Index) { uCalcImport.SetArray(DataTypeHandle,  Destination ,   Source ,   Index); } 


public void SetScalar(int Destination ,  int Source) { uCalcImport.SetScalar(DataTypeHandle,  Destination ,   Source); } 


public void SwapScalarValues(int ValuePtrA ,  int ValuePtrB) { uCalcImport.SwapScalarValues(DataTypeHandle,  ValuePtrA ,   ValuePtrB); } 


public String ToString(int ValuePtr) { return  uCalcImport.ToString1Overload1DataType11ByPtr(DataTypeHandle,  ValuePtr); } 


public String ToString(String Value) { return  uCalcImport.ToString1Overload1DataType11ByStr(DataTypeHandle,  Value); } 


public int Handle() { return  uCalcImport.Handle1Overload1DataType(DataTypeHandle); } 

public DataType() { DataTypeHandle = 0; }
public DataType( int PassedDataTypeHandle) { DataTypeHandle = PassedDataTypeHandle; }
public DataType( DataType DataTypeHandleInstance) { DataTypeHandle = DataTypeHandleInstance.DataTypeHandle; }
   }






public class uCalcTransform {


public int TransformHandle;


public class RuleClass {


public int RuleHandle;


public RuleClass Active(int TrueFalse) { return  new RuleClass(uCalcImport.Active(RuleHandle,  TrueFalse )); } 


public RuleClass FindPart(String Pattern) { return  new RuleClass(uCalcImport.FindPart(RuleHandle,  Pattern )); } 


public RuleClass FromPart(String Pattern) { return  new RuleClass(uCalcImport.FromPart(RuleHandle,  Pattern )); } 


public RuleClass ToPart(String Pattern) { return  new RuleClass(uCalcImport.ToPart(RuleHandle,  Pattern )); } 


public RuleClass CaseSensitive(int TrueFalse) { return  new RuleClass(uCalcImport.CaseSensitive(RuleHandle,  TrueFalse )); } 


public RuleClass WhitespaceSensitive(int TrueFalse) { return  new RuleClass(uCalcImport.WhitespaceSensitive(RuleHandle,  TrueFalse )); } 


public RuleClass CodeBlockSensitive(int TrueFalse) { return  new RuleClass(uCalcImport.CodeBlockSensitive(RuleHandle,  TrueFalse )); } 


public RuleClass Comment(String CommentStr) { return  new RuleClass(uCalcImport.Comment1Overload1uCalcTransform1RuleClass(RuleHandle,  CommentStr )); } 


public uCalcTransform LocalTransform() { return  new uCalcTransform(uCalcImport.LocalTransform(RuleHandle )); } 


public RuleClass Maximum(int Value) { return  new RuleClass(uCalcImport.Maximum(RuleHandle,  Value )); } 


public RuleClass MaximumHard(int Value) { return  new RuleClass(uCalcImport.MaximumHard(RuleHandle,  Value )); } 


public RuleClass Minimum(int Value) { return  new RuleClass(uCalcImport.Minimum(RuleHandle,  Value )); } 


public RuleClass MinimumHard(int Value) { return  new RuleClass(uCalcImport.MinimumHard(RuleHandle,  Value )); } 


public RuleClass Precedence(int Value) { return  new RuleClass(uCalcImport.Precedence(RuleHandle,  Value )); } 


public RuleClass QuoteSensitive(int TrueFalse) { return  new RuleClass(uCalcImport.QuoteSensitive(RuleHandle,  TrueFalse )); } 


public String ReplacementText() { return  uCalcImport.ReplacementText(RuleHandle); } 


public RuleClass StartAfter(int Value) { return  new RuleClass(uCalcImport.StartAfter(RuleHandle,  Value )); } 


public RuleClass StopAfter(int Value) { return  new RuleClass(uCalcImport.StopAfter(RuleHandle,  Value )); } 


public RuleClass SkipOver(int TrueFalse) { return  new RuleClass(uCalcImport.SkipOver(RuleHandle,  TrueFalse )); } 


public RuleClass RewindOnChange(int TrueFalse) { return  new RuleClass(uCalcImport.RewindOnChange(RuleHandle,  TrueFalse )); } 


public RuleClass ParseAgainMax(int TrueFalse ,  int RaiseError) { return  new RuleClass(uCalcImport.ParseAgainMax(RuleHandle,  TrueFalse ,   RaiseError )); } 


public RuleClass RightToLeft(int TrueFalse) { return  new RuleClass(uCalcImport.RightToLeft(RuleHandle,  TrueFalse )); } 


public void ReleaseRule() { uCalcImport.ReleaseRule(RuleHandle); } 


public void Release() { ReleaseRule(); RuleHandle = 0; }


public RuleClass() { RuleHandle = 0; }
public RuleClass( int rHandle) { RuleHandle = rHandle; }
public RuleClass( RuleClass RuleInstance) { RuleHandle = RuleInstance.RuleHandle; }
   }



public class Tokens {


public int TokensHandle;


public Tokens Comment(String CommentStr) { return  new Tokens(uCalcImport.Comment1Overload1uCalcTransform1Tokens(TokensHandle,  CommentStr )); } 


public Tokens Import(int FromTokenList) { return  new Tokens(uCalcImport.Import1Overload1uCalcTransform1Tokens11Obj(TokensHandle,  FromTokenList )); } 


public Tokens Import(String TokenFile) { return  new Tokens(uCalcImport.Import1Overload1uCalcTransform1Tokens11File(TokensHandle,  TokenFile )); } 


public Item Define(String TokenDef) { return  new Item(uCalcImport.Define1Overload1uCalcTransform1Tokens(TokensHandle,  TokenDef , 0, "", 0, 0 )); }

 public Item Define(String TokenDef, int TokenType) { return  new Item(uCalcImport.Define1Overload1uCalcTransform1Tokens(TokensHandle,  TokenDef ,  TokenType, "", 0, 0 )); }

 public Item Define(String TokenDef, int TokenType, String EndMatch) { return  new Item(uCalcImport.Define1Overload1uCalcTransform1Tokens(TokensHandle,  TokenDef ,  TokenType,   EndMatch, 0, 0 )); }

 public Item Define(String TokenDef, int TokenType, String EndMatch, int SubMatch) { return  new Item(uCalcImport.Define1Overload1uCalcTransform1Tokens(TokensHandle,  TokenDef ,  TokenType,   EndMatch,   SubMatch, 0 )); }

 public Item Define(String TokenDef, int TokenType, String EndMatch, int SubMatch, int RegExGrammar) { return  new Item(uCalcImport.Define1Overload1uCalcTransform1Tokens(TokensHandle,  TokenDef ,  TokenType,   EndMatch,   SubMatch,  RegExGrammar )); } 



public Tokens() { TokensHandle = 0; }
public Tokens( int tHandle) { TokensHandle = tHandle; }
public Tokens( Tokens TokensInstance) { TokensHandle = TokensInstance.TokensHandle; }
   }



public uCalcTransform Comment(String CommentStr) { return  new uCalcTransform(uCalcImport.Comment1Overload1uCalcTransform(TransformHandle,  CommentStr )); } 


public RuleClass DefineRule(String Comment ,  String FindStr ,  String ToStr ,  int Min ,  int Max ,  int MinHard ,  int MaxHard ,  int Precedence ,  int StartAfter ,  int StopAfter ,  int SkipOver ,  int RewindOnChange ,  int CaseSensitive ,  int CodeblockSensitive ,  int QuoteSensitive ,  int RightToLeft) { return  new RuleClass(uCalcImport.DefineRule(TransformHandle,  Comment ,   FindStr ,   ToStr ,   Min ,   Max ,   MinHard ,   MaxHard ,   Precedence ,   StartAfter ,   StopAfter ,   SkipOver ,   RewindOnChange ,   CaseSensitive ,   CodeblockSensitive ,   QuoteSensitive ,   RightToLeft )); } 


public Item DefineToken(String TokenDef) { return  new Item(uCalcImport.DefineToken(TransformHandle,  TokenDef , 0, "", 0, 0 )); }

 public Item DefineToken(String TokenDef, int TokenType) { return  new Item(uCalcImport.DefineToken(TransformHandle,  TokenDef ,  TokenType, "", 0, 0 )); }

 public Item DefineToken(String TokenDef, int TokenType, String EndMatch) { return  new Item(uCalcImport.DefineToken(TransformHandle,  TokenDef ,  TokenType,   EndMatch, 0, 0 )); }

 public Item DefineToken(String TokenDef, int TokenType, String EndMatch, int SubMatch) { return  new Item(uCalcImport.DefineToken(TransformHandle,  TokenDef ,  TokenType,   EndMatch,   SubMatch, 0 )); }

 public Item DefineToken(String TokenDef, int TokenType, String EndMatch, int SubMatch, int RegExGrammar) { return  new Item(uCalcImport.DefineToken(TransformHandle,  TokenDef ,  TokenType,   EndMatch,   SubMatch,  RegExGrammar )); } 


public Tokens GetTokens() { return  new Tokens(uCalcImport.GetTokens(TransformHandle )); } 


public RuleClass FromTo(String FromStr) { return  new RuleClass(uCalcImport.FromTo(TransformHandle,  FromStr , "" )); }

 public RuleClass FromTo(String FromStr, String ToStr) { return  new RuleClass(uCalcImport.FromTo(TransformHandle,  FromStr ,   ToStr )); } 


public uCalcTransform Import(String FileName) { return  new uCalcTransform(uCalcImport.Import1Overload1uCalcTransform(TransformHandle,  FileName )); } 


public uCalcTransform ListPrefix(String Prefix) { return  new uCalcTransform(uCalcImport.ListPrefix(TransformHandle,  Prefix )); } 


public uCalcTransform ListPostfix(String Postfix) { return  new uCalcTransform(uCalcImport.ListPostfix(TransformHandle,  Postfix )); } 


public uCalcTransform ListSeparator(String Separator) { return  new uCalcTransform(uCalcImport.ListSeparator(TransformHandle,  Separator )); } 


public uCalcTransform ListDelimiters(String Prefix ,  String Separator ,  String Postfix) { return  new uCalcTransform(uCalcImport.ListDelimiters(TransformHandle,  Prefix ,   Separator ,   Postfix )); } 


public uCalc MathParser() { return  new uCalc(uCalcImport.MathParser(TransformHandle, 0 )); }

 public uCalc MathParser(int FMP) { return  new uCalc(uCalcImport.MathParser(TransformHandle,  FMP )); } 


public uCalcTransform NewPass() { return  new uCalcTransform(uCalcImport.NewPass(TransformHandle, 0 )); }

 public uCalcTransform NewPass(int Share) { return  new uCalcTransform(uCalcImport.NewPass(TransformHandle,  Share )); } 


public uCalcTransform Pass(int Index) { return  new uCalcTransform(uCalcImport.Pass(TransformHandle,  Index , 0 )); }

 public uCalcTransform Pass(int Index, int Share) { return  new uCalcTransform(uCalcImport.Pass(TransformHandle,  Index ,   Share )); } 


public uCalcTransform Reset() { return  new uCalcTransform(uCalcImport.Reset(TransformHandle, 0 )); }

 public uCalcTransform Reset(int ResetOption) { return  new uCalcTransform(uCalcImport.Reset(TransformHandle,  ResetOption )); } 


public String ResultStr() { return  uCalcImport.ResultStr(TransformHandle); } 


public uCalcTransform Transform() { return  new uCalcTransform(uCalcImport.Transform(TransformHandle )); } 


public String Expand(String Expression) { return  uCalcImport.Expand(TransformHandle,  Expression); } 


public String ExpandWithSteps(String Expression) { return  uCalcImport.ExpandWithSteps(TransformHandle,  Expression , "", "", ""); }

 public String ExpandWithSteps(String Expression, String Separator) { return  uCalcImport.ExpandWithSteps(TransformHandle,  Expression ,   Separator, "", ""); }

 public String ExpandWithSteps(String Expression, String Separator, String Prefix) { return  uCalcImport.ExpandWithSteps(TransformHandle,  Expression ,   Separator,   Prefix, ""); }

 public String ExpandWithSteps(String Expression, String Separator, String Prefix, String Postfix) { return  uCalcImport.ExpandWithSteps(TransformHandle,  Expression ,   Separator,   Prefix,   Postfix); } 


public uCalcTransform SetInput(String InputStr) { return  new uCalcTransform(uCalcImport.SetInput(TransformHandle,  InputStr )); } 


public uCalcTransform SetInputByRef(int InputStr) { return  new uCalcTransform(uCalcImport.SetInputByRef(TransformHandle,  InputStr )); } 


public uCalcTransform SetParser(int FMP) { return  new uCalcTransform(uCalcImport.SetParser(TransformHandle,  FMP )); } 


public uCalcTransform SetProperties() { return  new uCalcTransform(uCalcImport.SetProperties(TransformHandle, 0 )); }

 public uCalcTransform SetProperties(int TransformProperties) { return  new uCalcTransform(uCalcImport.SetProperties(TransformHandle,  TransformProperties )); } 


public int WasModified() { return  uCalcImport.WasModified(TransformHandle); } 


public void ReleaseTransform() { uCalcImport.ReleaseTransform(TransformHandle); } 


public RuleClass GetRule() { return  new RuleClass(uCalcImport.GetRule(TransformHandle, 0 )); }

 public RuleClass GetRule(int Index) { return  new RuleClass(uCalcImport.GetRule(TransformHandle,  Index )); } 


public RuleClass RulesDefault() { return  new RuleClass(uCalcImport.RulesDefault(TransformHandle )); } 


public RuleClass RulesOverall() { return  new RuleClass(uCalcImport.RulesOverall(TransformHandle )); } 


public void Release() { ReleaseTransform(); TransformHandle = 0; }


public uCalcTransform() {  }
public uCalcTransform( int tHandle) { TransformHandle = tHandle; }
public uCalcTransform( uCalcTransform TransformInstance) { TransformHandle = TransformInstance.TransformHandle; }
   }
 // uCalcTransform





public Item AddErrorHandler(int ErrorHandlerAddress) { return  new Item(uCalcImport.AddErrorHandler(uCalcHandle,  ErrorHandlerAddress , 0 )); }

 public Item AddErrorHandler(int ErrorHandlerAddress, int Position) { return  new Item(uCalcImport.AddErrorHandler(uCalcHandle,  ErrorHandlerAddress ,   Position )); } 


public int CreateuCalc() { return  uCalcImport.CreateuCalc(uCalcHandle); } 


public DataType DataTypeOfIndex(int Index) { return  new DataType(uCalcImport.DataTypeOfIndex(uCalcHandle,  Index )); } 


public Item Define(String Expression) { return  new Item(uCalcImport.Define1Overload1uCalc(uCalcHandle,  Expression , 0, 0 )); }

 public Item Define(String Expression, int Address) { return  new Item(uCalcImport.Define1Overload1uCalc(uCalcHandle,  Expression ,   Address, 0 )); }

 public Item Define(String Expression, int Address, int ExistingItem) { return  new Item(uCalcImport.Define1Overload1uCalc(uCalcHandle,  Expression ,   Address,   ExistingItem )); } 


public Item DefineConstant(String Definition) { return  new Item(uCalcImport.DefineConstant(uCalcHandle,  Definition , 0 )); }

 public Item DefineConstant(String Definition, int VariableAddress) { return  new Item(uCalcImport.DefineConstant(uCalcHandle,  Definition ,   VariableAddress )); } 


public Item DefineDataType(int TypeSize ,  int AllocArrayValue ,  int AllocScalar ,  int AllocScalarByPtr ,  int DeleteArray ,  int DeleteScalar ,  int ResetScalar ,  int ResetArray ,  int SetValueArray ,  int SetValueScalar ,  int SwapValues ,  int ToString) { return  new Item(uCalcImport.DefineDataType(uCalcHandle,  TypeSize ,   AllocArrayValue ,   AllocScalar ,   AllocScalarByPtr ,   DeleteArray ,   DeleteScalar ,   ResetScalar ,   ResetArray ,   SetValueArray ,   SetValueScalar ,   SwapValues ,   ToString )); } 


public Item DefineFunction(String Definition) { return  new Item(uCalcImport.DefineFunction(uCalcHandle,  Definition , 0 )); }

 public Item DefineFunction(String Definition, int FunctionAddress) { return  new Item(uCalcImport.DefineFunction(uCalcHandle,  Definition ,   FunctionAddress )); } 


public Item DefineOperator(String Definition ,  int iPrecedence) { return  new Item(uCalcImport.DefineOperator(uCalcHandle,  Definition ,   iPrecedence , 0, 0 )); }

 public Item DefineOperator(String Definition ,  int iPrecedence, int Grouping) { return  new Item(uCalcImport.DefineOperator(uCalcHandle,  Definition ,   iPrecedence ,  Grouping, 0 )); }

 public Item DefineOperator(String Definition ,  int iPrecedence, int Grouping, int FunctionAddress) { return  new Item(uCalcImport.DefineOperator(uCalcHandle,  Definition ,   iPrecedence ,  Grouping,   FunctionAddress )); } 


public Item DefineVariable(String Definition) { return  new Item(uCalcImport.DefineVariable(uCalcHandle,  Definition , 0 )); }

 public Item DefineVariable(String Definition, int VariableAddress) { return  new Item(uCalcImport.DefineVariable(uCalcHandle,  Definition ,   VariableAddress )); } 


public String ErrorExpression() { return  uCalcImport.ErrorExpression(uCalcHandle); } 


public int ErrorLocation() { return  uCalcImport.ErrorLocation(uCalcHandle); } 


public String ErrorMessage() { return  uCalcImport.ErrorMessage(uCalcHandle, 0); }

 public String ErrorMessage(int Index) { return  uCalcImport.ErrorMessage(uCalcHandle,  Index); } 


public int ErrorNumber() { return  uCalcImport.ErrorNumber(uCalcHandle); } 


public void ErrorResponse(int Response) { uCalcImport.ErrorResponse(uCalcHandle,  Response); } 


public String ErrorSymbol() { return  uCalcImport.ErrorSymbol(uCalcHandle); } 


public void ErrorSetExpression(String Expression) { uCalcImport.ErrorSetExpression(uCalcHandle,  Expression); } 


public double Eval(String Expression) { return  uCalcImport.Eval(uCalcHandle,  Expression); } 


public String EvalStr(String Expression) { return  uCalcImport.EvalStr(uCalcHandle,  Expression); } 


public int FPEnvClearException() { return  uCalcImport.FPEnvClearException(uCalcHandle, 0); }

 public int FPEnvClearException(int Exceptions) { return  uCalcImport.FPEnvClearException(uCalcHandle,  Exceptions); } 


public int FPEnvGetExceptionMask() { return  uCalcImport.FPEnvGetExceptionMask(uCalcHandle); } 


public int FPEnvRaiseException() { return  uCalcImport.FPEnvRaiseException(uCalcHandle, 0); }

 public int FPEnvRaiseException(int Exception) { return  uCalcImport.FPEnvRaiseException(uCalcHandle,  Exception); } 


public int FPEnvGetRounding() { return  uCalcImport.FPEnvGetRounding(uCalcHandle); } 


public void FPEnvSetExceptionMask(int Exceptions) { uCalcImport.FPEnvSetExceptionMask(uCalcHandle,  Exceptions); } 


public void FPEnvSetExceptionUnMask(int Exceptions) { uCalcImport.FPEnvSetExceptionUnMask(uCalcHandle,  Exceptions); } 


public int FPEnvSetRounding(int Direction) { return  uCalcImport.FPEnvSetRounding(uCalcHandle,  Direction); } 


public void FPEnvToggleExceptionMask(int Exception) { uCalcImport.FPEnvToggleExceptionMask(uCalcHandle,  Exception); } 


public int HandleOf(String ItemName) { return  uCalcImport.HandleOf(uCalcHandle,  ItemName , 0, 0); }

 public int HandleOf(String ItemName, long Properties) { return  uCalcImport.HandleOf(uCalcHandle,  ItemName ,    Properties, 0); }

 public int HandleOf(String ItemName, long Properties, int SkipTransform) { return  uCalcImport.HandleOf(uCalcHandle,  ItemName ,    Properties,   SkipTransform); } 


public Item GetItemOf(String ItemName) { return  new Item(uCalcImport.GetItemOf(uCalcHandle,  ItemName , 0, 0 )); }

 public Item GetItemOf(String ItemName, long Properties) { return  new Item(uCalcImport.GetItemOf(uCalcHandle,  ItemName ,    Properties, 0 )); }

 public Item GetItemOf(String ItemName, long Properties, int SkipExpansion) { return  new Item(uCalcImport.GetItemOf(uCalcHandle,  ItemName ,    Properties,   SkipExpansion )); } 


public Item GetItemOfProperty(int Property_ ,  int nth) { return  new Item(uCalcImport.GetItemOfProperty(uCalcHandle,  Property_ ,   nth , "" )); }

 public Item GetItemOfProperty(int Property_ ,  int nth, String DataTypeName) { return  new Item(uCalcImport.GetItemOfProperty(uCalcHandle,  Property_ ,   nth ,   DataTypeName )); } 




public int License(int LicenseType) { return  uCalcImport.License(uCalcHandle,  LicenseType, 0, 0, 0, 0, 0); }

 public int License(int LicenseType, int L1) { return  uCalcImport.License(uCalcHandle,  LicenseType,    L1, 0, 0, 0, 0); }

 public int License(int LicenseType, int L1, int L2) { return  uCalcImport.License(uCalcHandle,  LicenseType,    L1,    L2, 0, 0, 0); }

 public int License(int LicenseType, int L1, int L2, int L3) { return  uCalcImport.License(uCalcHandle,  LicenseType,    L1,    L2,    L3, 0, 0); }

 public int License(int LicenseType, int L1, int L2, int L3, int L4) { return  uCalcImport.License(uCalcHandle,  LicenseType,    L1,    L2,    L3,    L4, 0); }

 public int License(int LicenseType, int L1, int L2, int L3, int L4, int L5) { return  uCalcImport.License(uCalcHandle,  LicenseType,    L1,    L2,    L3,    L4,    L5); } 


public Item NamespaceChild() { return  new Item(uCalcImport.NamespaceChild(uCalcHandle, 0 )); }

 public Item NamespaceChild(int nth) { return  new Item(uCalcImport.NamespaceChild(uCalcHandle,  nth )); } 


public int NamespaceChildCount() { return  uCalcImport.NamespaceChildCount(uCalcHandle); } 


public Item NamespaceParent() { return  new Item(uCalcImport.NamespaceParent(uCalcHandle, 0 )); }

 public Item NamespaceParent(int Level) { return  new Item(uCalcImport.NamespaceParent(uCalcHandle,  Level )); } 


public Item NamespaceSymbol(int nth) { return  new Item(uCalcImport.NamespaceSymbol(uCalcHandle,  nth )); } 


public int NamespaceSymbolCount() { return  uCalcImport.NamespaceSymbolCount(uCalcHandle); } 


public uCalcTransform NewTransform() { return  new uCalcTransform(uCalcImport.NewTransform(uCalcHandle )); } 


public uCalcTransform ParserTransform() { return  new uCalcTransform(uCalcImport.ParserTransform(uCalcHandle )); } 


public ParsedExpr Parse(String Expression) { return  new ParsedExpr(uCalcImport.Parse(uCalcHandle,  Expression , "" )); }

 public ParsedExpr Parse(String Expression, String DataType) { return  new ParsedExpr(uCalcImport.Parse(uCalcHandle,  Expression ,   DataType )); } 


public int Precedence(String Operator1) { return  uCalcImport.Precedence1Overload1uCalc(uCalcHandle,  Operator1 , ""); }

 public int Precedence(String Operator1, String Operator2) { return  uCalcImport.Precedence1Overload1uCalc(uCalcHandle,  Operator1 ,   Operator2); } 


public long Properties(int p1) { return  uCalcImport.Properties(uCalcHandle,  p1, 0, 0, 0); }

 public long Properties(int p1, int p2) { return  uCalcImport.Properties(uCalcHandle,  p1,   p2, 0, 0); }

 public long Properties(int p1, int p2, int p3) { return  uCalcImport.Properties(uCalcHandle,  p1,   p2,   p3, 0); }

 public long Properties(int p1, int p2, int p3, int p4) { return  uCalcImport.Properties(uCalcHandle,  p1,   p2,   p3,   p4); } 


public void ReleaseuCalc() { uCalcImport.ReleaseuCalc(uCalcHandle); } 


public void ResetOutput() { uCalcImport.ResetOutput(uCalcHandle); } 


public Item Default() { return  new Item(uCalcImport.Default(uCalcHandle )); } 


public Item SetOutput(int FunctionAddress ,  String Properties) { return  new Item(uCalcImport.SetOutput1Overload1uCalc11Callback(uCalcHandle,  FunctionAddress ,   Properties )); } 


public Item SetOutput(String Definition) { return  new Item(uCalcImport.SetOutput1Overload1uCalc11NoCallback(uCalcHandle,  Definition )); } 


public Item CreateTransform() { return  new Item(uCalcImport.CreateTransform(uCalcHandle )); } 


public String ValueAt(int ValuePtr ,  String DataType) { return  uCalcImport.ValueAt(uCalcHandle,  ValuePtr ,   DataType); } 


public int Handle() { return  uCalcImport.Handle1Overload1uCalc(uCalcHandle); } 


public void Release() { ReleaseuCalc(); uCalcHandle = 0; }


public void Reset() { ReleaseuCalc(); uCalcHandle = CreateuCalc(); }
public uCalc() { uCalcHandle = 0; uCalcHandle = CreateuCalc(); }
public uCalc(uCalc uCalcInstance) { uCalcHandle = uCalcInstance.uCalcHandle; }
public uCalc(int InstHandle) { uCalcHandle = InstHandle; }
public uCalc(int LicenseType,   int L1 ,   int L2 ,   int L3 ,   int L4 ,   int L5 ) { License(LicenseType, L1, L2, L3, L4, L5); uCalcHandle = CreateuCalc(); }
   }
 // uCalc









