Guest User

Untitled

a guest
May 22nd, 2018
78
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 23.15 KB | None | 0 0
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.IO;
  5.  
  6. namespace ReaDat
  7. {
  8.     class GothicDat
  9.     {
  10.         #region DatReader
  11.  
  12.         /// <summary>
  13.         /// Abgeleitet von BinaryReader mit ein paar modifizierten Funktionen
  14.         /// </summary>
  15.         internal class DatReader : BinaryReader
  16.         {
  17.             public DatReader(Stream s) : base(s) { }
  18.  
  19.             public override char ReadChar()
  20.             {
  21.                 return Convert.ToChar(ReadByte());
  22.             }
  23.  
  24.             public override string ReadString()
  25.             {
  26.                 char c = ReadChar();
  27.                 StringBuilder sb = new StringBuilder();
  28.                 while (c != '\n')
  29.                 {
  30.                     sb.Append(c);
  31.                     c = ReadChar();
  32.                 }
  33.                 return sb.ToString();
  34.             }
  35.         }
  36.  
  37.         #endregion
  38.  
  39.         /// <summary>
  40.         /// Sucht nach Symbol.name in der Symboltable
  41.         /// </summary>
  42.         /// <param name="name">Name des zu suchenden Symbols</param>
  43.         /// <returns>Das passende Symbol. Wird keine Übereinstimmung gefunden wird null zurückgegeben</returns>
  44.         public Symbol GetSymbol(string name)
  45.         {
  46.             foreach (Symbol s in Symbols)
  47.                 if (s.name == name)
  48.                     return s;
  49.             return null;
  50.         }
  51.  
  52.         /// <summary>
  53.         /// Version der .dat
  54.         /// </summary>
  55.         public byte Version;
  56.  
  57.         public Symbol[] Symbols;
  58.         public readonly byte[] Stack;
  59.  
  60.         private int GetStackInt(int offs)
  61.         {
  62.             return Stack[offs] + (Stack[offs + 1] << 8) + (Stack[offs + 2] << 16) + (Stack[offs + 3] << 24);
  63.         }
  64.  
  65.         private readonly byte[] content;
  66.  
  67.         public GothicDat(string Path)
  68.         {
  69.             content = File.ReadAllBytes(Path);
  70.             MemoryStream m = new MemoryStream(content);
  71.             DatReader br = new DatReader(m);
  72.  
  73.             // === Header ===
  74.             Version = br.ReadByte();
  75.  
  76.             // === Symboltable ===
  77.             int nr = br.ReadInt32();
  78.             // sortedTable
  79.             int[] sortedTable = new int[nr];     // Nur temporär.. Was soll ich damit?
  80.             for (int i = 0; i < nr; ++i)
  81.                 sortedTable[i] = br.ReadInt32();
  82.             // symbols
  83.             Symbols = new Symbol[nr];
  84.             for (int i = 0; i < nr; ++i)
  85.                 Symbols[i] = new Symbol(ref br, this, i);
  86.  
  87.             // === Stack ===
  88.             UInt32 size = br.ReadUInt32();
  89.             Stack = br.ReadBytes((int)size);
  90.  
  91.             br.Close();
  92.             m.Close();
  93.             content = null;
  94.         }
  95.  
  96.         public class Symbol
  97.         {
  98.             internal Symbol(ref DatReader br, GothicDat s, int ID)
  99.             {
  100.                 id = ID;
  101.                 Parent = s;
  102.                 b_hasName = br.ReadInt32();
  103.                 name = br.ReadString();
  104.                 offset = br.ReadInt32();
  105.                 bitfield = br.ReadInt32();
  106.                 filenr = br.ReadInt32();
  107.                 line = br.ReadInt32();
  108.                 line_anz = br.ReadInt32();
  109.                 pos_beg = br.ReadInt32();
  110.                 pos_anz = br.ReadInt32();
  111.                 if ((flags & zPAR_FLAG_CLASSVAR) == 0)
  112.                 {
  113.                     if (type == zPAR_TYPE_FUNC || type == zPAR_TYPE_CLASS || type == zPAR_TYPE_PROTOTYPE)
  114.                         content = new object[1];
  115.                     else
  116.                         content = new object[ele];
  117.  
  118.                     if (content.Length == 0 && type == zPAR_TYPE_INSTANCE)
  119.                         content = new object[1];
  120.  
  121.                     for (int i = 0; i < content.Length; ++i)
  122.                     {
  123.                         switch (type)
  124.                         {
  125.                             case zPAR_TYPE_STRING:
  126.                                 content[i] = br.ReadString();
  127.                                 break;
  128.                             case zPAR_TYPE_FLOAT:
  129.                                 content[i] = br.ReadSingle();
  130.                                 break;
  131.                             default:
  132.                                 content[i] = br.ReadInt32();
  133.                                 break;
  134.                         }
  135.                     }
  136.                 }
  137.                 parent = br.ReadInt32();
  138.             }
  139.  
  140.             private readonly GothicDat Parent;
  141.  
  142.             public int b_hasName;
  143.             public int id;
  144.             public string name;
  145.             public int offset;
  146.             public int bitfield;
  147.             public int filenr;
  148.             public int line;
  149.             public int line_anz;
  150.             public int pos_beg;
  151.             public int pos_anz;
  152.             public int parent;
  153.  
  154.             public object[] content;
  155.  
  156.             public int type { get { return bitfield & zCPar_Symbol_bitfield_type; } }
  157.             public int ele { get { return bitfield & zCPar_Symbol_bitfield_ele; } }
  158.             public int flags { get { return bitfield & zCPar_Symbol_bitfield_flags; } }
  159.  
  160.             public string TypeToString()
  161.             {
  162.                 StringBuilder sb = new StringBuilder();
  163.                 switch (type)
  164.                 {
  165.                     case zPAR_TYPE_VOID: return("void");
  166.                     case zPAR_TYPE_FLOAT: sb.Append("float");
  167.                         break;
  168.                     case zPAR_TYPE_INT: sb.Append("int");
  169.                         break;
  170.                     case zPAR_TYPE_STRING: sb.Append("string");
  171.                         break;
  172.                     case zPAR_TYPE_CLASS: return("class");
  173.                     case zPAR_TYPE_FUNC: return("func");
  174.                     case zPAR_TYPE_PROTOTYPE: return("prototype");
  175.                     case zPAR_TYPE_INSTANCE: return("instance");
  176.                     default:
  177.                         return string.Empty;
  178.                 }
  179.                 if(ele > 1)
  180.                 {
  181.                     sb.Append('[');
  182.                     sb.Append(ele);
  183.                     sb.Append(']');
  184.                 }
  185.                 return sb.ToString();
  186.             }
  187.  
  188.             public string GetReturnValue()
  189.             {
  190.                 switch(offset)
  191.                 {
  192.                     case 0:
  193.                         return "void";
  194.                     case 1:
  195.                         return "float";
  196.                     case 2:
  197.                         return "int";
  198.                     case 3:
  199.                         return "string";
  200.                     case 7:
  201.                         return "inst";
  202.                     default:
  203.                         return offset.ToString();
  204.                 }
  205.             }
  206.  
  207.             public string GetLocalName()
  208.             {
  209.                 return name.Split('.')[1];
  210.             }
  211.  
  212.             public string ParamsToString()
  213.             {
  214.                 if (ele == 0) return "()";
  215.                 StringBuilder s = new StringBuilder("(");
  216.                 s.Append(Parent.Symbols[id + 1].TypeToString());
  217.                 s.Append(' ');
  218.                 s.Append(Parent.Symbols[id + 1].GetLocalName());
  219.                 for (int i = 1; i < ele; ++i)
  220.                 {
  221.                     s.Append(", ");
  222.                     s.Append(Parent.Symbols[id + i + 1].TypeToString());
  223.                     s.Append(' ');
  224.                     s.Append(Parent.Symbols[id + i + 1].GetLocalName());
  225.                 }
  226.                 s.Append(")");
  227.                 return s.ToString();
  228.             }
  229.  
  230.             public string FlagsToString()
  231.             {
  232.                 StringBuilder s = new StringBuilder();
  233.                 if ((flags & zPAR_FLAG_CONST) > 0) s.Append("CONST, ");
  234.                 if ((flags & zPAR_FLAG_RETURN) > 0) s.Append("RETURN, ");
  235.                 if ((flags & zPAR_FLAG_CLASSVAR) > 0) s.Append("CLASSVAR, ");
  236.                 if ((flags & zPAR_FLAG_EXTERNAL) > 0) s.Append("EXTERNAL, ");
  237.                 if ((flags & zPAR_FLAG_MERGED) > 0) s.Append("MERGED, ");
  238.                 try
  239.                 {
  240.                     return s.Remove(s.Length - 2, 2).ToString();
  241.                 }
  242.                 catch
  243.                 {
  244.                     return String.Empty;
  245.                 }
  246.             }
  247.  
  248.             private string OnecontentToString(int o)
  249.             {
  250.                 switch(type)
  251.                 {
  252.                     case zPAR_TYPE_STRING:
  253.                         return "\"" + (string)content[o] + '"';
  254.                     case zPAR_TYPE_INT:
  255.                         return ((int) content[o]).ToString();
  256.                     case zPAR_TYPE_FLOAT:
  257.                         return ((float) content[o]).ToString();
  258.                 }
  259.                 return "";
  260.             }
  261.  
  262.             public string ContentToString()
  263.             {
  264.                 if ((type != zPAR_TYPE_STRING && type != zPAR_TYPE_INT && type != zPAR_TYPE_FLOAT) || (flags & zPAR_FLAG_CONST) == 0)
  265.                     return string.Empty;
  266.                 if (ele <= 1)
  267.                     return OnecontentToString(0);
  268.                 StringBuilder b = new StringBuilder();
  269.                 b.Append("{ ");
  270.                 b.Append(OnecontentToString(0));
  271.                 for(int i = 1; i < ele; ++i)
  272.                 {
  273.                     b.Append(", ");
  274.                     b.Append(OnecontentToString(i));
  275.                 }
  276.                 b.Append(" }");
  277.                 return b.ToString();
  278.             }
  279.  
  280.             public override string ToString()
  281.             {
  282.                 if (IsFunction() || IsInstance())
  283.                     return Parent.FuncToString(this);
  284.                 if (content == null || content.Length == 0 || !IsConst()) return base.ToString();
  285.                 return ContentToString();
  286.             }
  287.  
  288.             public bool IsFunction()
  289.             {
  290.                 return (((flags & zPAR_FLAG_CONST) > 0) && (type == zPAR_TYPE_FUNC));
  291.             }
  292.  
  293.             public bool IsInstance()
  294.             {
  295.                 return (type == zPAR_TYPE_INSTANCE);
  296.             }
  297.  
  298.             public bool IsPrototype()
  299.             {
  300.                 return (type == zPAR_TYPE_PROTOTYPE);
  301.             }
  302.  
  303.             public bool IsConst()
  304.             {
  305.                 return ((flags & zPAR_FLAG_CONST) > 0);
  306.             }
  307.  
  308.             public string ParentToString()
  309.             {
  310.                 return (parent == -1)? "" : Parent.Symbols[parent%Parent.Symbols.Length].name;
  311.             }
  312.         }
  313.  
  314.         public string TokToString(int tok)
  315.         {
  316.             switch (tok)
  317.             {
  318.                 case zPAR_OP_PLUS: return "add";
  319.                 case zPAR_OP_MINUS: return "sub";
  320.                 case zPAR_OP_MUL: return "mul";
  321.                 case zPAR_OP_DIV: return "div";
  322.                 case zPAR_OP_MOD: return "mod";
  323.                 case zPAR_OP_OR: return "or";
  324.                 case zPAR_OP_AND: return "and";
  325.                 case zPAR_OP_LOWER: return "lwr";
  326.                 case zPAR_OP_HIGHER: return "hgh";
  327.                 case zPAR_OP_IS: return "is";
  328.                 case zPAR_OP_LOG_OR: return "lor";
  329.                 case zPAR_OP_LOG_AND: return "land";
  330.                 case zPAR_OP_SHIFTL: return "shl";
  331.                 case zPAR_OP_SHIFTR: return "shr";
  332.                 case zPAR_OP_LOWER_EQ: return "leq";
  333.                 case zPAR_OP_EQUAL: return "eq";
  334.                 case zPAR_OP_NOTEQUAL: return "neq";
  335.                 case zPAR_OP_HIGHER_EQ: return "heq";
  336.                 case zPAR_OP_ISPLUS: return "iadd";
  337.                 case zPAR_OP_ISMINUS: return "isub";
  338.                 case zPAR_OP_ISMUL: return "imul";
  339.                 case zPAR_OP_ISDIV: return "idiv";
  340.                 case zPAR_OP_UN_PLUS: return "uplus";
  341.                 case zPAR_OP_UN_MINUS: return "uminus";
  342.                 case zPAR_OP_UN_NOT: return "not";
  343.                 case zPAR_OP_UN_NEG: return "neg";
  344.                 case zPAR_TOK_RET: return "retn";
  345.                 case zPAR_TOK_CALL: return "call   ";
  346.                 case zPAR_TOK_CALLEXTERN: return "callx  ";
  347.                 case zPAR_TOK_POPINT: return "popi";
  348.                 case zPAR_TOK_PUSHINT: return "pushi  ";
  349.                 case zPAR_TOK_PUSHVAR: return "pushv  ";
  350.                 case zPAR_TOK_PUSHSTR: return "pushs  ";
  351.                 case zPAR_TOK_PUSHINST: return "pushin ";
  352.                 case zPAR_TOK_PUSHINDEX: return "pushid ";
  353.                 case zPAR_TOK_POPVAR: return "popv";
  354.                 case zPAR_TOK_ASSIGNSTR: return "astr";
  355.                 case zPAR_TOK_ASSIGNSTRP: return "astrp";
  356.                 case zPAR_TOK_ASSIGNFUNC: return "afnc";
  357.                 case zPAR_TOK_ASSIGNFLOAT: return "aflt";
  358.                 case zPAR_TOK_ASSIGNINST: return "ains";
  359.                 case zPAR_TOK_JUMP: return "jmp    ";
  360.                 case zPAR_TOK_JUMPF: return "jmpf   ";
  361.                 case zPAR_TOK_SETINSTANCE: return "sinst  ";
  362.                 case zPAR_TOK_ARRAYACCESS: return "pusha  ";
  363.                 default:
  364.                     return string.Empty;
  365.             }
  366.         }
  367.  
  368.         public string FuncToString(Symbol fnc)
  369.         {
  370.             int c = (int)fnc.content[0] - 1;
  371.             StringBuilder s = new StringBuilder();
  372.             List<int> jmpStck = new List<int>();
  373.  
  374.             loopStart:
  375.             do
  376.             {
  377.                 c++;
  378.                 byte b = Stack[c];
  379.                 string h = c.ToString("X");
  380.                 int len = h.Length;
  381.                 while (++len < 8) s.Append('0');
  382.  
  383.                 s.Append(h);
  384.                 s.Append(' ');
  385.                 s.Append(' ');
  386.  
  387.                 h = TokToString(Stack[c]);
  388.                 s.Append(h);
  389.  
  390.                 if (((b >= zPAR_TOK_CALL) && (b <= zPAR_TOK_POPVAR))
  391.                     || ((b >= zPAR_TOK_JUMP) && (b <= zPAR_TOK_SETINSTANCE))
  392.                     || (b == zPAR_TOK_ARRAYACCESS))
  393.                 {
  394.                     int r = 0;
  395.                     for (int i = 0; i < 4; ++i)
  396.                         r += Stack[c + i + 1] << (i << 3);
  397.                     string res = string.Empty;
  398.                     switch (b)
  399.                     {
  400.                         case zPAR_TOK_CALL:
  401.                             foreach (Symbol sym in Symbols)
  402.                             {
  403.                                 if (!sym.IsFunction()&&!sym.IsPrototype()&&!sym.IsInstance()) continue;
  404.                                 if ((int)sym.content[0] != r) continue;
  405.                                 res = sym.name;
  406.                                 break;
  407.                             }
  408.                             if(res == string.Empty)
  409.                                 res = r.ToString();
  410.                             break;
  411.                         case zPAR_TOK_JUMPF:
  412.                         case zPAR_TOK_JUMP:
  413.                             jmpStck.Add(+r);
  414.                             res = "0x" + r.ToString("X").ToUpper();
  415.                             break;
  416.                         default:
  417.                             if (b != zPAR_TOK_PUSHINT)
  418.                             {
  419.                                 res = Symbols[r].name;
  420.                                 if (b == zPAR_TOK_ARRAYACCESS)
  421.                                 {
  422.                                     res += "[" + Stack[c + 5] + "]";
  423.                                     ++c;
  424.                                 }
  425.                                 if(Symbols[r].IsConst() && !Symbols[r].IsFunction() && !Symbols[r].IsInstance() && !Symbols[r].IsPrototype())
  426.                                 {
  427.                                     res += ", " + Symbols[r];
  428.                                 }
  429.                             }
  430.                             else
  431.                             {
  432.                                 res = r.ToString();
  433.                             }
  434.                             break;
  435.                     }
  436.  
  437.                     s.Append(res);
  438.                     c += 4;
  439.                 }
  440.                 s.Append('\n');
  441.             }
  442.             while (Stack[c] != zPAR_TOK_RET);
  443.             if (c + 1 != Stack.Length)
  444.             {
  445.                 bool found = false;
  446.                 foreach (Symbol S in Symbols)
  447.                 {
  448.                     if (!S.IsFunction()&&!S.IsInstance()&&!S.IsPrototype()) continue;
  449.                     if ((int)S.content[0] != (c + 1)) continue;
  450.                     found = true;
  451.                     break;
  452.                 }
  453.                 if(!found)
  454.                     goto loopStart;
  455.             }
  456.  
  457.             return s.ToString();
  458.         }
  459.  
  460.         #region Parsertokens
  461.  
  462.         //Gewöhnliche Operatoren
  463.         public const byte zPAR_OP_PLUS = 0;            //"+" 0x00
  464.         public const byte zPAR_OP_MINUS = 1;            //"-" 0x01
  465.         public const byte zPAR_OP_MUL = 2;            //"*" 0x02
  466.         public const byte zPAR_OP_DIV = 3;            //"/" 0x03
  467.         public const byte zPAR_OP_MOD = 4;            //"%" 0x04
  468.         public const byte zPAR_OP_OR = 5;            //"|" 0x05
  469.         public const byte zPAR_OP_AND = 6;            //"&" 0x06
  470.         public const byte zPAR_OP_LOWER = 7;            //"<" 0x07
  471.         public const byte zPAR_OP_HIGHER = 8;            //">" 0x08
  472.  
  473.         //Ausnahme:
  474.         public const byte zPAR_OP_IS = 9;            //"=" 0x09 //hole i1, i2 vom Datenstack und setze i1 = i2. i1 muss hier eine Referenz sein.
  475.  
  476.         //Operatoren aus zwei Zeichen                    
  477.         public const byte zPAR_OP_LOG_OR = 11;       //"||"0x0B
  478.         public const byte zPAR_OP_LOG_AND = 12;       //"&&"0x0C
  479.         public const byte zPAR_OP_SHIFTL = 13;       //"<<"0x0D
  480.         public const byte zPAR_OP_SHIFTR = 14;       //">>"0x0E
  481.         public const byte zPAR_OP_LOWER_EQ = 15;       //"<="0x0F
  482.         public const byte zPAR_OP_EQUAL = 16;       //"=="0x10
  483.         public const byte zPAR_OP_NOTEQUAL = 17;       //"!="0x11
  484.         public const byte zPAR_OP_HIGHER_EQ = 18;       //">="0x12
  485.         public const byte zPAR_OP_ISPLUS = 19;       //"+="0x13
  486.         public const byte zPAR_OP_ISMINUS = 20;       //"-="0x14
  487.         public const byte zPAR_OP_ISMUL = 21;       //"*="0x15
  488.         public const byte zPAR_OP_ISDIV = 22;       //"/="0x16
  489.  
  490.         /* Unäre Operatoren nehmen natürlich nur einen Wert vom Datenstack.
  491.             Sie schieben ebenfalls das Ergebnis auf den Datenstack. */
  492.         public const byte zPAR_OP_UNARY = 30;
  493.         public const byte zPAR_OP_UN_PLUS = 30;       //"+" 0x1E
  494.         public const byte zPAR_OP_UN_MINUS = 31;       //"-" 0x1F
  495.         public const byte zPAR_OP_UN_NOT = 32;       //"!" 0x20
  496.         public const byte zPAR_OP_UN_NEG = 33;       //"~" 0x21
  497.         public const byte zPAR_OP_MAX = 33;
  498.  
  499.         //Jetzt: Andere Tokens (zum Parsen)
  500.         public const byte zPAR_TOK_BRACKETON = 40;
  501.         public const byte zPAR_TOK_BRACKETOFF = 41;
  502.         public const byte zPAR_TOK_SEMIKOLON = 42;
  503.         public const byte zPAR_TOK_KOMMA = 43;
  504.         public const byte zPAR_TOK_SCHWEIF = 44;
  505.         public const byte zPAR_TOK_NONE = 45;
  506.  
  507.         public const byte zPAR_TOK_FLOAT = 51;
  508.         public const byte zPAR_TOK_VAR = 52;
  509.         public const byte zPAR_TOK_OPERATOR = 53;
  510.  
  511.         /* Weitere Befehle (Nicht vergessen: Operatoren sind auch Befehle!)
  512.             * Manchen Befehlen folgt immer ein Parameter nach.
  513.             * Anderen Befehle bestehen nur aus dem Befehlstoken */
  514.         public const byte zPAR_TOK_RET = 60; //0x3C    //return
  515.         public const byte zPAR_TOK_CALL = 61; //0x3D    //rufe Funktion auf. Es folgen 4 byte Callziel (Stackadresse)
  516.         public const byte zPAR_TOK_CALLEXTERN = 62; //0x3E    //rufe External auf. Es folgen 4 byte Symbol der External
  517.         public const byte zPAR_TOK_POPINT = 63; //0x3F    //ungenutzt
  518.         public const byte zPAR_TOK_PUSHINT = 64; //0x40    //schiebe integer Konstante auf den Datenstack. Es folgt die byteegerkonstante (4 byte)
  519.         public const byte zPAR_TOK_PUSHVAR = 65; //0x41    //schiebe Variable auf den Datenstack. Es folt der Symbolindex der Variable (4 byte)
  520.         public const byte zPAR_TOK_PUSHSTR = 66; //0x42    //ungenutzt
  521.         public const byte zPAR_TOK_PUSHINST = 67; //0x43    //schiebe Instanz auf den Datenstack. Es folgen die 4 byte Symbolindex der Instanz
  522.         public const byte zPAR_TOK_PUSHINDEX = 68; //0x44    //ungenutzt
  523.         public const byte zPAR_TOK_POPVAR = 69; //0x45    //ungenutzt
  524.         public const byte zPAR_TOK_ASSIGNSTR = 70; //0x46    //Zuweisung. Hole v1, v2 vom Stack und setze v1 = v2
  525.         public const byte zPAR_TOK_ASSIGNSTRP = 71; //0x47    //Zuweisung. Hole v1, v2 vom Stack und setze v1 = v2
  526.         public const byte zPAR_TOK_ASSIGNFUNC = 72; //0x48    //Zuweisung. Hole v1, v2 vom Stack und setze v1 = v2
  527.         public const byte zPAR_TOK_ASSIGNFLOAT = 73; //0x49    //Zuweisung. Hole v1, v2 vom Stack und setze v1 = v2
  528.         public const byte zPAR_TOK_ASSIGNINST = 74; //0x4A    //Zuweisung. Hole v1, v2 vom Stack und setze v1 = v2
  529.         public const byte zPAR_TOK_JUMP = 75; //0x4B    //Springe im Parserstack. Es folgen 4 byte Sprungziel
  530.         public const byte zPAR_TOK_JUMPF = 76; //0x4C    //Hole b vom Datenstack und springe, falls b == 0 ist. Es folgen 4 byte Sprungziel (lies: "jump if false". Für "if"-Bedingungen)
  531.  
  532.         public const byte zPAR_TOK_SETINSTANCE = 80; //0x50    //Es folgen 4 byte Symbolindex. Umständlich zu erklären. So grob: "Setze aktuelle Instanz."
  533.  
  534.         //Irgendwelche byteernas. Wahrscheinlich nur bedingt relevant.
  535.         public const byte zPAR_TOK_SKIP = 90;
  536.         public const byte zPAR_TOK_LABEL = 91;
  537.         public const byte zPAR_TOK_FUNC = 92;
  538.         public const byte zPAR_TOK_FUNCEND = 93;
  539.         public const byte zPAR_TOK_CLASS = 94;
  540.         public const byte zPAR_TOK_CLASSEND = 95;
  541.         public const byte zPAR_TOK_INSTANCE = 96;
  542.         public const byte zPAR_TOK_INSTANCEEND = 97;
  543.         public const byte zPAR_TOK_NEWSTRING = 98;
  544.  
  545.         //Kann verodert mit zPAR_TOK_PUSHVAR benutzt werden. In dem Fall wird noch ein weiteres Byte als Index erwartet. Für Pushen von Arraywerten.
  546.         public const byte zPAR_TOK_FLAGARRAY = zPAR_TOK_VAR + 128;
  547.         public const byte zPAR_TOK_ARRAYACCESS = 245;
  548.  
  549.         public const int zCPar_Symbol_bitfield_ele = ((1 << 12) - 1) << 0;
  550.         public const int zCPar_Symbol_bitfield_type = ((1 << 4) - 1) << 12;
  551.         public const int zCPar_Symbol_bitfield_flags = ((1 << 6) - 1) << 16;
  552.         public const int zCPar_Symbol_bitfield_space = ((1 << 1) - 1) << 22;
  553.  
  554.         public const int zPAR_TYPE_VOID = 0 << 12;
  555.         public const int zPAR_TYPE_FLOAT = 1 << 12;
  556.         public const int zPAR_TYPE_INT = 2 << 12;
  557.         public const int zPAR_TYPE_STRING = 3 << 12;
  558.         public const int zPAR_TYPE_CLASS = 4 << 12;
  559.         public const int zPAR_TYPE_FUNC = 5 << 12;
  560.         public const int zPAR_TYPE_PROTOTYPE = 6 << 12;
  561.         public const int zPAR_TYPE_INSTANCE = 7 << 12;
  562.  
  563.         public const int zPAR_FLAG_CONST = 1 << 16;
  564.         public const int zPAR_FLAG_RETURN = 2 << 16;
  565.         public const int zPAR_FLAG_CLASSVAR = 4 << 16;
  566.         public const int zPAR_FLAG_EXTERNAL = 8 << 16;
  567.         public const int zPAR_FLAG_MERGED = 16 << 16;
  568.  
  569.         #endregion
  570.     }
  571. }
Add Comment
Please, Sign In to add comment