Пример #1
0
 private void DoPassThree(List <LexTree> _tokenlist, int _count)
 {
     for (int i = 0; i < _tokenlist.Count; i++)
     {
         LexTree lexTree = _tokenlist[i];
         eLex    eLex    = eLex.None;
         if (i + 1 < _tokenlist.Count)
         {
             eLex = _tokenlist[i + 1].Token;
         }
         if (_count == 0 && lexTree.Node != null)
         {
             i = RemoveFunctions(_tokenlist, i, _count);
         }
         if (lexTree.Token == eLex.SemiColon && eLex == eLex.RCB)
         {
             _tokenlist.RemoveRange(i, 1);
             i--;
         }
         if (lexTree.Children != null)
         {
             DoPassThree(lexTree.Children, _count + 1);
         }
     }
 }
Пример #2
0
 private void DoPassOne(List <LexTree> _tokenlist)
 {
     for (int i = 0; i < _tokenlist.Count; i++)
     {
         bool    flag    = true;
         LexTree lexTree = _tokenlist[i];
         if (lexTree.Text == "function")
         {
             i    = ParseFunction(_tokenlist, i);
             flag = false;
         }
         else if (lexTree.Text == "prototype")
         {
             i    = ParseProtoTypeFunction(_tokenlist, i);
             flag = false;
         }
         else if (lexTree.Token == eLex.ID)
         {
             AddCount(_tokenlist, i);
         }
         else if (lexTree.Text == "true")
         {
             lexTree.Text = "!0";
         }
         else if (lexTree.Text == "false")
         {
             lexTree.Text = "!1";
         }
         if (flag && lexTree.Children != null)
         {
             DoPassOne(lexTree.Children);
         }
     }
 }
Пример #3
0
        public int RemoveFunctionReferences(List <LexTree> _tokenlist, int _i)
        {
            LexTree lexTree = _tokenlist[_i];

            if (lexTree.Children == null)
            {
                return(_i);
            }
            if (lexTree.Node.Count == 0 && !lexTree.Node.AlreadyRemoved)
            {
                lexTree.Node.AlreadyRemoved = true;
                {
                    foreach (KeyValuePair <string, VFNode> item in lexTree.Used)
                    {
                        item.Value.Count--;
                        if (item.Value.Count <= 0 && item.Value.pFunction != null)
                        {
                            m_FunctionRemoved = true;
                            if (Verbose)
                            {
                                foreach (LexTree item2 in item.Value.pFunction)
                                {
                                    Program.Out.WriteLine("*Function: " + item2.Name);
                                }
                            }
                        }
                    }
                    return(_i);
                }
            }
            return(_i);
        }
Пример #4
0
 private void DoObfuscation(List <LexTree> _list)
 {
     if (Obfuscate)
     {
         LexTree lexTree  = null;
         LexTree lexTree2 = null;
         foreach (LexTree item in _list)
         {
             if (item.Token == eLex.ID)
             {
                 string value;
                 if (!m_Encoder.TryGetValue(item.Text, out value))
                 {
                     value = NewName(true);
                     m_Encoder.Add(item.Text, value);
                 }
                 item.Text = value;
             }
             if (item.Children != null)
             {
                 DoObfuscation(item.Children);
             }
             lexTree  = lexTree2;
             lexTree2 = item;
         }
     }
 }
Пример #5
0
 private void DoPassTwo(List <LexTree> _tokenlist, int _count)
 {
     for (int i = 0; i < _tokenlist.Count; i++)
     {
         LexTree lexTree = _tokenlist[i];
         if (_count == 0 && lexTree.Text == "function")
         {
             i = RemoveFunctionReferences(_tokenlist, i);
         }
         if (lexTree.Children != null)
         {
             DoPassTwo(lexTree.Children, _count + 1);
         }
     }
 }
Пример #6
0
        public void AddCount(List <LexTree> _tokenlist, int _i)
        {
            LexTree lexTree = _tokenlist[_i];

            if (lexTree.Text != null)
            {
                VFNode value;
                if (!m_FunctionList.TryGetValue(lexTree.Text, out value))
                {
                    value = new VFNode(lexTree.Text);
                    m_FunctionList.Add(lexTree.Text, value);
                }
                value.Count++;
            }
        }
Пример #7
0
        public int CheckHex(List <LexTree> _tokenlist, int _i)
        {
            LexTree lexTree = _tokenlist[_i];

            if (lexTree.Text.Length < 3)
            {
                return(_i);
            }
            string value;

            if (lexTree.Text[0] == '0' && (lexTree.Text[1] == 'x' || lexTree.Text[1] == 'X') && m_MaskConvert.TryGetValue(lexTree.Text, out value))
            {
                lexTree.Text = value;
            }
            return(_i);
        }
Пример #8
0
        public void DoObfuscate(IEnumerable <string> _files, string _outputfilename, IEnumerable <string> _obfuscateWhiteList)
        {
            List <string> list = new List <string>();

            if (EncodeStrings)
            {
                list.Add(m_DecodeFunction);
            }
            list.AddRange(_files);
            foreach (string _obfuscateWhite in _obfuscateWhiteList)
            {
                m_pLex.AddCommand(_obfuscateWhite, eLex.reserved);
            }
            using (StreamWriter streamWriter = new StreamWriter(_outputfilename))
            {
                foreach (string item2 in list)
                {
                    m_pLex.Text = item2;
                    eLex eLex;
                    do
                    {
                        eLex = m_pLex.yylex();
                        LexTree item = new LexTree(eLex, m_pLex.yyText);
                        m_TokenTree.Add(item);
                    }while (eLex != eLex.EOF);
                }
                ScanFile();
                DoObfuscation(m_TokenTree);
                if (Obfuscate)
                {
                    string value = "";
                    if (m_Encoder.TryGetValue(m_StringTableName, out value))
                    {
                        m_StringTableName = value;
                    }
                }
                DoEncodeStrings(m_TokenTree);
                if (EncodeStrings)
                {
                    WriteStringTable(streamWriter);
                }
                WriteNodeList(m_TokenTree, streamWriter);
                streamWriter.Close();
            }
        }
Пример #9
0
        public int RemoveFunctions(List <LexTree> _tokenlist, int _i, int _count)
        {
            LexTree lexTree = _tokenlist[_i];

            if (lexTree.Children == null)
            {
                return(_i);
            }
            if (lexTree.Node.Count == 0)
            {
                _tokenlist.RemoveRange(_i, 1);
                _i--;
                if (Verbose)
                {
                    Program.Out.WriteLine("Function: " + lexTree.Name);
                }
            }
            return(_i);
        }
Пример #10
0
        public void WriteNodeList(List <LexTree> _nodelist, StreamWriter oFile)
        {
            int     i       = 0;
            LexTree lexTree = new LexTree(eLex.None, " ");

            for (; i < _nodelist.Count; i++)
            {
                LexTree lexTree2             = _nodelist[i];
                GMAssetCompiler.eLex eLexVar = lexTree2.Token;
                if (PrettyPrint)
                {
                    if (eLexVar != eLex.NewLine && eLexVar != eLex.Comment)
                    {
                        if (m_WriteSpace && eLexVar != eLex.LeftBracket && eLexVar != eLex.SemiColon)
                        {
                            oFile.Write(" ");
                        }
                        m_WriteSpace = false;
                        if (eLexVar == eLex.reserved3)
                        {
                            oFile.Write(" ");
                            eLexVar = eLex.reserved2;
                        }
                        if (eLexVar == eLex.reserved2 && lexTree2.Text == "function" && lexTree.Text != "return")
                        {
                            oFile.WriteLine();
                        }
                        if (eLexVar == eLex.LCB)
                        {
                            oFile.WriteLine();
                            for (int j = 0; j < m_tabcount; j++)
                            {
                                oFile.Write('\t');
                            }
                        }
                        if (eLexVar == eLex.RCB)
                        {
                            m_tabcount--;
                            m_WriteTabs = m_tabcount;
                        }
                        if (m_WriteTabs > 0)
                        {
                            for (int k = 0; k < m_WriteTabs; k++)
                            {
                                oFile.Write('\t');
                            }
                            m_WriteTabs = 0;
                        }
                        oFile.Write(lexTree2.Text);
                        if (lexTree2.Text == "for" || lexTree2.Text == "while")
                        {
                            bool flag = false;
                            int  num  = 0;
                            while (!flag && i < _nodelist.Count)
                            {
                                i++;
                                LexTree lexTree3 = _nodelist[i];
                                eLex    token    = lexTree3.Token;
                                if (token == eLex.LeftBracket)
                                {
                                    num++;
                                }
                                if (token == eLex.RightBracket)
                                {
                                    num--;
                                    if (num == 0)
                                    {
                                        flag = true;
                                    }
                                }
                                if (token == eLex.reserved3)
                                {
                                    oFile.Write(" ");
                                }
                                oFile.Write(lexTree3.Text);
                                if (token == eLex.reserved3 || token == eLex.reserved2)
                                {
                                    oFile.Write(" ");
                                }
                            }
                        }
                        if (eLexVar == eLex.SemiColon || eLexVar == eLex.LCB || eLexVar == eLex.RCB)
                        {
                            if (eLexVar == eLex.LCB)
                            {
                                m_tabcount++;
                            }
                            oFile.WriteLine();
                            m_WriteTabs = m_tabcount;
                        }
                    }
                    if (eLexVar == eLex.reserved2)
                    {
                        m_WriteSpace = true;
                    }
                }
                else
                {
                    if (m_WriteSpace && eLexVar != eLex.LeftBracket && eLexVar != eLex.SemiColon)
                    {
                        oFile.Write(" ");
                    }
                    m_WriteSpace = false;
                    if (eLexVar == eLex.reserved3)
                    {
                        oFile.Write(" ");
                        eLexVar = eLex.reserved2;
                    }
                    if (eLexVar != eLex.NewLine && eLexVar != eLex.Comment && lexTree2.Text != null)
                    {
                        oFile.Write(lexTree2.Text);
                        m_LineWidth += lexTree2.Text.Length;
                    }
                    if (eLexVar == eLex.reserved2)
                    {
                        m_WriteSpace = true;
                    }
                    if (m_LineWidth >= UglyWidth)
                    {
                        bool flag2 = true;
                        if (eLexVar != eLex.SemiColon && eLexVar != eLex.Comma && eLexVar != eLex.RCB && eLexVar != eLex.LCB)
                        {
                            flag2 = false;
                        }
                        if (flag2)
                        {
                            m_LineWidth = 0;
                            oFile.WriteLine();
                            m_WriteSpace = false;
                        }
                    }
                }
                lexTree = _nodelist[i];
                if (lexTree2.Node != null && lexTree2.Children != null)
                {
                    WriteNodeList(lexTree2.Children, oFile);
                }
            }
        }
Пример #11
0
        private int ParseProtoTypeFunction(List <LexTree> _tokenlist, int _i)
        {
            bool flag  = false;
            bool flag2 = true;

            _i -= 2;
            LexTree lexTree = _tokenlist[_i];

            if (_tokenlist[_i + 1].Token != eLex.Dot || _tokenlist[_i + 2].Text != "prototype" || _tokenlist[_i + 3].Token != eLex.Dot)
            {
                return(_i + 3);
            }
            int     num      = _i;
            LexTree lexTree2 = _tokenlist[_i + 4];

            if (_tokenlist[_i + 5].Token != eLex.Equals || _tokenlist[_i + 6].Text != "function" || _tokenlist[_i + 7].Token != eLex.LeftBracket)
            {
                return(_i + 3);
            }
            lexTree.Name = lexTree2.Text;
            flag         = true;
            flag2        = false;
            lexTree.Used = new Dictionary <string, VFNode>(50);
            VFNode value;

            if (!m_FunctionList.TryGetValue(lexTree2.Text, out value))
            {
                value = new VFNode(lexTree2.Text);
                m_FunctionList.Add(lexTree2.Text, value);
            }
            value.pFunction.Add(lexTree);
            lexTree.Node = value;
            _i          += 8;
            int num2 = 0;

            while (true)
            {
                LexTree lexTree3 = _tokenlist[_i];
                if (lexTree3.Text == "{")
                {
                    num2++;
                }
                if (lexTree3.Text == "}")
                {
                    num2--;
                    if (num2 == 0)
                    {
                        break;
                    }
                }
                if (!flag2 && lexTree3.Token == eLex.ID)
                {
                    VFNode value2;
                    if (!lexTree.Used.TryGetValue(lexTree3.Text, out value2))
                    {
                        if (!m_FunctionList.TryGetValue(lexTree3.Text, out value2))
                        {
                            value2 = new VFNode(lexTree3.Text);
                            m_FunctionList.Add(lexTree3.Text, value2);
                        }
                        lexTree.Used.Add(lexTree3.Text, value2);
                    }
                    value2.Count++;
                }
                else if (lexTree3.Text == "true")
                {
                    lexTree3.Text = "!0";
                }
                else if (lexTree3.Text == "false")
                {
                    lexTree3.Text = "!1";
                }
                _i++;
                if (_i >= _tokenlist.Count)
                {
                    return(_i);
                }
            }
            num2 = _i + 1 - num;
            if (flag)
            {
                List <LexTree> range = _tokenlist.GetRange(num + 1, num2);
                _tokenlist.RemoveRange(num + 1, num2);
                lexTree.Children = new List <LexTree>(num2);
                lexTree.Children.AddRange(range);
                _i = num;
            }
            return(_i);
        }
Пример #12
0
        private int ParseFunction(List <LexTree> _tokenlist, int _i)
        {
            bool    flag     = false;
            bool    flag2    = true;
            LexTree lexTree  = _tokenlist[_i];
            int     num      = _i;
            LexTree lexTree2 = _tokenlist[_i + 1];

            if (lexTree2.Text != "(" && lexTree2.Token == eLex.ID)
            {
                lexTree.Name = lexTree2.Text;
                flag         = true;
                flag2        = false;
                lexTree.Used = new Dictionary <string, VFNode>(50);
                _i          += 2;
                VFNode value;
                if (!m_FunctionList.TryGetValue(lexTree2.Text, out value))
                {
                    value = new VFNode(lexTree2.Text);
                    m_FunctionList.Add(lexTree2.Text, value);
                }
                value.pFunction.Add(lexTree);
                lexTree.Node = value;
            }
            int  num2  = 0;
            bool flag3 = false;

            while (true)
            {
                LexTree lexTree3 = _tokenlist[_i];
                if (lexTree3.Token == eLex.RightBracket)
                {
                    flag3 = true;
                }
                if (flag3)
                {
                    if (lexTree3.Text == "{")
                    {
                        num2++;
                    }
                    if (lexTree3.Text == "}")
                    {
                        num2--;
                        if (num2 == 0)
                        {
                            break;
                        }
                    }
                }
                if (lexTree3.Text == "function")
                {
                    lexTree3.anon = true;
                }
                if (!flag2 && lexTree3.Token == eLex.ID)
                {
                    VFNode value2;
                    if (!lexTree.Used.TryGetValue(lexTree3.Text, out value2))
                    {
                        if (!m_FunctionList.TryGetValue(lexTree3.Text, out value2))
                        {
                            value2 = new VFNode(lexTree3.Text);
                            m_FunctionList.Add(lexTree3.Text, value2);
                        }
                        lexTree.Used.Add(lexTree3.Text, value2);
                    }
                    value2.Count++;
                }
                else if (lexTree3.Text == "true")
                {
                    lexTree3.Text = "!0";
                }
                else if (lexTree3.Text == "false")
                {
                    lexTree3.Text = "!1";
                }
                _i++;
                if (_i >= _tokenlist.Count)
                {
                    return(_i);
                }
            }
            num2 = _i + 1 - num - 1;
            if (flag)
            {
                List <LexTree> range = _tokenlist.GetRange(num + 1, num2);
                _tokenlist.RemoveRange(num + 1, num2);
                lexTree.Children = new List <LexTree>(num2);
                lexTree.Children.AddRange(range);
                _i = num;
            }
            return(_i);
        }