Mine

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using DDW.Collections;
using System.Diagnostics;

namespace DDW
{
    class cmcfinal
    {
        List<Parser.Error> errors = new List<Parser.Error>();
        static List<string> usingyS = new List<string>();
        static List<UsingDirectiveNode> usingy = new List<UsingDirectiveNode>();
        public static EasySlovník<string, ClassNode> třídy = new EasySlovník<string, ClassNode>();
        //-Delegate, Interface, Enum, Structs
        public static EasySlovník<string, DelegateNode> delegáti = new EasySlovník<string, DelegateNode>();
        public static EasySlovník<string, InterfaceNode> rozhraní = new EasySlovník<string, InterfaceNode>();
        public static EasySlovník<string, EnumNode> výčty = new EasySlovník<string, EnumNode>();
        public static EasySlovník<string, StructNode> struktury = new EasySlovník<string, StructNode>();

        internal void UložAOtevřiZdrojovýSoubor()
        {
            StringBuilder sb = new StringBuilder();
            string soubor = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "temp.cs");

            foreach (UsingDirectiveNode item in usingy)
            {
                sb.Append(item.ToSource());
            }
            sb.AppendLine();
            sb.AppendLine();

            foreach (KeyValuePair<string, ClassNode> item in třídy)
            {
                sb.AppendLine(item.Value.ToSource());
            }
            foreach (KeyValuePair<string, DelegateNode> item in delegáti)
            {
                sb.AppendLine(item.Value.ToSource());
            }
            foreach (KeyValuePair<string, InterfaceNode> item in rozhraní)
            {
                sb.AppendLine(item.Value.ToSource());
            }
            foreach (KeyValuePair<string, EnumNode> item in výčty)
            {
                sb.AppendLine(item.Value.ToSource());
            }
            foreach (KeyValuePair<string, StructNode> item in struktury)
            {
                sb.AppendLine(item.Value.ToSource());
            }
            string uložit = sb.ToString();
            File.WriteAllText(soubor, sb.ToString());
            Process.Start(soubor);
        }

        private CompilationUnitNode ParseUnit(string fileName)
        {
            FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
            StreamReader sr = new StreamReader(fs, true);
            Lexer l = new Lexer(sr);
            TokenCollection toks = l.Lex();

            Parser p = null;
            CompilationUnitNode cu = null;

            p = new Parser(fileName);
            cu = p.Parse(toks, l.StringLiterals);

            if (p.Errors.Count != 0)
            {
                Console.WriteLine();
                errors.AddRange(p.Errors);
                return null;
            }
            return cu;
        }

        public void ParseFile(string fileName)
        {
            CompilationUnitNode cu = ParseUnit(fileName);
            if (cu != null)
            {
                //-TODO: Doplnit zachycení chyb
                PřidejNS(cu.DefaultNamespace);
                foreach (NamespaceNode item in cu.Namespaces)
                {
                    PřidejNS(item);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="item"></param>
        private void PřidejNS(NamespaceNode item)
        {
            foreach (ClassNode item2 in item.Classes)
            {
                PřidejTřídu(item2);
                
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="item2"></param>
        private void PřidejTřídu(ClassNode třída)
        {
            ClassNode cn = třídy[třída.Name.Identifier];
            if (cn == null)
            {
                třídy.Add(třída.Name.Identifier, třída);
                return;
            }
            cn = PřidejDoA1CoVNěmNejsou(cn, třída);

            třídy[třída.Name.Identifier] = cn;
        }

        private ClassNode PřidejDoA1CoVNěmNejsou(ClassNode cn, ClassNode třída)
        {
            PřidejAtributyDoA1(cn, třída);
            PřidejBaseTřídyDoA1(cn, třída);
            PřidejTřídyDoA1(cn, třída);
            PřidejKonstantyDoA1(cn, třída);
            PřidejKonstruktoryDoA1(cn, třída);
            PřidejDelegátiDoA1(cn, třída);
            PřidejDestruktoryDoA1(cn, třída);
            PřidejDocKomentářDoA1(cn, třída);
            PřidejVýčtyDoA1(cn, třída);
            PřidejUdálostiDoA1(cn, třída);
            PřidejPoložkyDoA1(cn, třída);
            PřidejFixovanéBufferyDoA1(cn, třída);
            PřidejIndexeryDoA1(cn, třída);
            PřidejRozhraníDoA1(cn, třída);
            PřidejMetodyDoA1(cn, třída);
            PřidejOperátoryDoA1(cn, třída);
            PřidejVlastnostiDoA1(cn, třída);
            PřidejStrukturyDoA1(cn, třída);
            //třídy[cn.Name.Identifier]= cn;
            Debug.Print(cn.Structs.Count.ToString());
            return cn;
        }

        /// <summary>
        /// Přidá struktury do A1 z A2.
        /// A1 je struktura z cache.
        /// </summary>
        /// <param name="cn"></param>
        /// <param name="třída"></param>
        private void PřidejStrukturyDoA1(ClassNode cn, ClassNode třída)
        {
            List<StructNode> kPřidání = new List<StructNode>();
            List<StructNode> kOdstranění = new List<StructNode>();
            List<string> názvyStruktur = new List<string>();
            foreach (StructNode strukturaZA1 in cn.Structs)
            {
                názvyStruktur.Add(strukturaZA1.GenericIdentifier);
                StructNode naOdstranění = null;
                StructNode naPřidání = null;
                if (ObsahujeStrukturuVětšíNežA1(strukturaZA1, třída, out naPřidání))
                {
                    kOdstranění.Add(strukturaZA1);
                    kPřidání.Add(naPřidání);
                }
                else if (ObsahujeA1StrukturyVA2PodleNázvu(strukturaZA1, třída, out naPřidání))
                {
                    kOdstranění.Add(strukturaZA1);
                    kPřidání.Add(naPřidání);
                }
                else if (ObsahujeStrukturuMenšíNežA1(strukturaZA1, třída, out naPřidání))
                {
                    kOdstranění.Add(strukturaZA1);
                    kPřidání.Add(naPřidání);
                }
            }
            foreach (StructNode item in třída.Structs)
            {
                if (!názvyStruktur.Contains(item.GenericIdentifier))
                {
                    cn.Structs.Add(item);
                }
            }
            foreach (StructNode item in kOdstranění)
            {
                cn.Structs.Remove(item);
            }
            foreach (StructNode item in kPřidání)
            {
                cn.Structs.Add(item);
            }
        }

        /// <summary>
        /// Do A3 uloží strukturu z 
        /// </summary>
        /// <param name="třída"></param>
        /// <param name="item"></param>
        /// <param name="naPřidání"></param>
        /// <returns></returns>
        private bool ObsahujeA1StrukturyVA2PodleNázvu(StructNode item, ClassNode třída, out StructNode naPřidání, out StructNode naOdstranění)
        {
            foreach (StructNode item2 in třída.Structs)
            {
                VypišInfoStruktury(item, "item");
                VypišInfoStruktury(item2, "item2");
                if (item.GenericIdentifier == item2.GenericIdentifier)
                {
                    if (item2.ToSource().Length > item.ToSource().Length)
                    {
                        naOdstranění = item;
                        naPřidání = item2;
                        return true;
                    }
                }       
            }
            naPřidání = naOdstranění = null;
            return false;
        }

        

        private bool ObsahujeStrukturuVětšíNežA1(StructNode item, ClassNode třída, out StructNode naPřidání, out StructNode naOdstranění)
        {
            foreach (StructNode item2 in třída.Structs)
            {
                if (item.GenericIdentifier == item2.GenericIdentifier)
                {
                    VypišInfoStruktury(item, "item");
                    VypišInfoStruktury(item2, "item2");
                    if (item2.ToSource().Length > item.ToSource().Length)
                    {
                        naOdstranění = item;
                        naPřidání = item2;
                        return true;
                    }
                }
            }
            naPřidání = naOdstranění = null;
            return false;
        }

        private bool ObsahujeStrukturuMenšíNežA1(StructNode item, ClassNode třída, out StructNode naPřidání, out StructNode naOdstranění)
        {
            foreach (StructNode item2 in třída.Structs)
            {
                if (item.GenericIdentifier == item2.GenericIdentifier)
                {
                    VypišInfoStruktury(item, "item");
                    VypišInfoStruktury(item2, "item2");
                    if (item2.ToSource().Length < item.ToSource().Length)
                    {
                        naOdstranění = item2;
                        naPřidání = item;
                        return true;
                    }
                }
            }
            naPřidání = naOdstranění = null;
            return false;
        }

        private void VypišInfoStruktury(StructNode item, string popis)
        {
            Debug.Print("***");
            Debug.Print(popis);
            Debug.Print(item.ToSource());
            Debug.Print(item.ToSource().Length.ToString());
            Debug.Print(item.GenericIdentifier);
            Debug.Print("***");
        }

        private void PřidejVlastnostiDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejOperátoryDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejMetodyDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejRozhraníDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejIndexeryDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejFixovanéBufferyDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejPoložkyDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejUdálostiDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejVýčtyDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejDocKomentářDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejDestruktoryDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejDelegátiDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejKonstruktoryDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejKonstantyDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejTřídyDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejBaseTřídyDoA1(ClassNode cn, ClassNode třída)
        {
            
        }

        private void PřidejAtributyDoA1(ClassNode cn, ClassNode třída)
        {
            
        }
    }

    class Pr
    {
        
    }
}