Ejemplo n.º 1
0
        public static List <LogInfo> IniAddSectionOp(EngineState s, CodeCommand cmd)
        {
            List <LogInfo> logs = new List <LogInfo>();

            Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_IniAddSectionOp));
            CodeInfo_IniAddSectionOp infoOp = cmd.Info as CodeInfo_IniAddSectionOp;

            string fileName = StringEscaper.Preprocess(s, infoOp.Infos[0].FileName);

            if (StringEscaper.PathSecurityCheck(fileName, out string errorMsg) == false)
            {
                logs.Add(new LogInfo(LogState.Error, errorMsg));
                return(logs);
            }

            string[] sections = new string[infoOp.Cmds.Count];
            for (int i = 0; i < sections.Length; i++)
            {
                CodeInfo_IniAddSection info = infoOp.Infos[i];

                string sectionName = StringEscaper.Preprocess(s, info.Section); // WB082 : 여기 값은 변수 Expand 안한다.
                if (sectionName.Equals(string.Empty, StringComparison.Ordinal))
                {
                    throw new InvalidCodeCommandException("Section name cannot be empty", cmd);
                }

                sections[i] = sectionName;
            }

            string dirPath = Path.GetDirectoryName(fileName);

            if (Directory.Exists(dirPath) == false)
            {
                Directory.CreateDirectory(dirPath);
            }

            bool result = Ini.AddSections(fileName, sections);

            if (result)
            {
                for (int i = 0; i < sections.Length; i++)
                {
                    logs.Add(new LogInfo(LogState.Success, $"Section [{sections[i]}] added", infoOp.Cmds[i]));
                }
                logs.Add(new LogInfo(LogState.Success, $"Added [{sections.Length}] sections to [{fileName}]", cmd));
            }
            else
            {
                for (int i = 0; i < sections.Length; i++)
                {
                    logs.Add(new LogInfo(LogState.Error, $"Could not add section [{sections[i]}]", infoOp.Cmds[i]));
                }
                logs.Add(new LogInfo(LogState.Error, $"Could not add [{sections.Length}] sections to [{fileName}]", cmd));
            }

            return(logs);
        }
Ejemplo n.º 2
0
        public static List <LogInfo> IniAddSection(EngineState s, CodeCommand cmd)
        {
            List <LogInfo> logs = new List <LogInfo>();

            CodeInfo_IniAddSection info = cmd.Info.Cast <CodeInfo_IniAddSection>();

            string fileName = StringEscaper.Preprocess(s, info.FileName);
            string section  = StringEscaper.Preprocess(s, info.Section);

            Debug.Assert(fileName != null, $"{nameof(fileName)} != null");
            Debug.Assert(section != null, $"{nameof(section)} != null");

            if (section.Length == 0)
            {
                return(LogInfo.LogErrorMessage(logs, "Section name cannot be empty"));
            }

            if (!StringEscaper.PathSecurityCheck(fileName, out string errorMsg))
            {
                return(LogInfo.LogErrorMessage(logs, errorMsg));
            }

            string dirPath = Path.GetDirectoryName(fileName);

            if (dirPath == null)
            {
                throw new InternalException("Internal Logic Error at IniAddSection");
            }
            if (!Directory.Exists(dirPath))
            {
                Directory.CreateDirectory(dirPath);
            }

            // If a dest file does not exist, create an empty file to force ANSI encoding as default in IniReadWriter.
            if (!File.Exists(fileName))
            {
                File.Create(fileName).Dispose();
            }

            bool result = IniReadWriter.AddSection(fileName, section);

            if (result)
            {
                logs.Add(new LogInfo(LogState.Success, $"Section [{section}] added to [{fileName}]", cmd));
            }
            else
            {
                logs.Add(new LogInfo(LogState.Error, $"Could not add section [{section}] to [{fileName}]", cmd));
            }

            return(logs);
        }
Ejemplo n.º 3
0
        public static List <LogInfo> IniAddSection(EngineState s, CodeCommand cmd)
        {
            List <LogInfo> logs = new List <LogInfo>();

            Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_IniAddSection));
            CodeInfo_IniAddSection info = cmd.Info as CodeInfo_IniAddSection;

            string fileName    = StringEscaper.Preprocess(s, info.FileName);
            string sectionName = StringEscaper.Preprocess(s, info.Section); // WB082 : 여기 값은 변수 Expand 안한다.

            if (sectionName.Equals(string.Empty, StringComparison.Ordinal))
            {
                throw new InvalidCodeCommandException("Section name cannot be empty", cmd);
            }

            if (StringEscaper.PathSecurityCheck(fileName, out string errorMsg) == false)
            {
                logs.Add(new LogInfo(LogState.Error, errorMsg));
                return(logs);
            }

            string dirPath = Path.GetDirectoryName(fileName);

            if (Directory.Exists(dirPath) == false)
            {
                Directory.CreateDirectory(dirPath);
            }

            bool result = Ini.AddSection(fileName, sectionName);

            if (result)
            {
                logs.Add(new LogInfo(LogState.Success, $"Section [{sectionName}] added to [{fileName}]", cmd));
            }
            else
            {
                logs.Add(new LogInfo(LogState.Error, $"Could not add section [{sectionName}] to [{fileName}]", cmd));
            }
            return(logs);
        }
Ejemplo n.º 4
0
        private static List <CodeCommand> InternalOptimize(List <CodeCommand> cmds)
        {
            List <CodeCommand> optimized = new List <CodeCommand>(cmds.Count);

            Dictionary <CodeType, List <CodeCommand> > opDict = OptimizedCodeTypes.ToDictionary(x => x, x => new List <CodeCommand>(cmds.Count / 2));

            CodeType s = CodeType.None;

            foreach (CodeCommand cmd in cmds)
            {
                bool loopAgain;
                do
                {
                    loopAgain = false;
                    switch (s)
                    {
                        #region Default
                    case CodeType.None:
                        switch (cmd.Type)
                        {
                        case CodeType.TXTAddLine:
                        case CodeType.TXTReplace:
                        case CodeType.TXTDelLine:
                        case CodeType.IniRead:
                        case CodeType.IniWrite:
                        case CodeType.IniDelete:
                        case CodeType.IniReadSection:
                        case CodeType.IniAddSection:
                        case CodeType.IniDeleteSection:
                        case CodeType.IniWriteTextLine:
                        case CodeType.Visible:
                        case CodeType.ReadInterface:
                        case CodeType.WriteInterface:
                        case CodeType.WimExtract:
                            s = cmd.Type;
                            opDict[cmd.Type].Add(cmd);
                            break;

                        case CodeType.WimPathAdd:
                        case CodeType.WimPathDelete:
                        case CodeType.WimPathRename:
                            s = CodeType.WimPathAdd;         // Use WimPathAdd as representative
                            opDict[CodeType.WimPathAdd].Add(cmd);
                            break;

                        default:
                            optimized.Add(cmd);
                            break;
                        }
                        break;

                        #endregion
                        #region TXTAddLine
                    case CodeType.TXTAddLine:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_TXTAddLine), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.TXTAddLine:
                        {
                            CodeInfo_TXTAddLine firstInfo = opDict[s][0].Info.Cast <CodeInfo_TXTAddLine>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region TXTReplace
                    case CodeType.TXTReplace:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_TXTReplace));
                        switch (cmd.Type)
                        {
                        case CodeType.TXTReplace:
                        {
                            CodeInfo_TXTReplace firstInfo = opDict[s][0].Info.Cast <CodeInfo_TXTReplace>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region TXTDelLine
                    case CodeType.TXTDelLine:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_TXTDelLine), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.TXTDelLine:
                        {
                            CodeInfo_TXTDelLine firstInfo = opDict[s][0].Info.Cast <CodeInfo_TXTDelLine>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region IniRead
                    case CodeType.IniRead:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_IniRead), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.IniRead:
                        {
                            CodeInfo_IniRead firstInfo = opDict[s][0].Info.Cast <CodeInfo_IniRead>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region IniWrite
                    case CodeType.IniWrite:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_IniWrite), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.IniWrite:
                        {
                            CodeInfo_IniWrite firstInfo = opDict[s][0].Info.Cast <CodeInfo_IniWrite>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region IinDelete
                    case CodeType.IniDelete:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_IniDelete), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.IniDelete:
                        {
                            CodeInfo_IniDelete firstInfo = opDict[s][0].Info.Cast <CodeInfo_IniDelete>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region IniReadSection
                    case CodeType.IniReadSection:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_IniReadSection));
                        switch (cmd.Type)
                        {
                        case CodeType.IniReadSection:
                        {
                            CodeInfo_IniReadSection firstInfo = opDict[s][0].Info.Cast <CodeInfo_IniReadSection>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region IniAddSection
                    case CodeType.IniAddSection:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_IniAddSection), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.IniAddSection:
                        {
                            CodeInfo_IniAddSection firstInfo = opDict[s][0].Info.Cast <CodeInfo_IniAddSection>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region IniDeleteSection
                    case CodeType.IniDeleteSection:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_IniDeleteSection), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.IniDeleteSection:
                        {
                            CodeInfo_IniDeleteSection firstInfo = opDict[s][0].Info.Cast <CodeInfo_IniDeleteSection>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region IniWriteTextLine
                    case CodeType.IniWriteTextLine:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_IniWriteTextLine), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.IniWriteTextLine:
                        {
                            CodeInfo_IniWriteTextLine firstInfo = opDict[s][0].Info.Cast <CodeInfo_IniWriteTextLine>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region Visible
                    case CodeType.Visible:
                        switch (cmd.Type)
                        {
                        case CodeType.Visible:
                            opDict[s].Add(cmd);
                            break;

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region ReadInterface
                    case CodeType.ReadInterface:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_ReadInterface), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.ReadInterface:
                        {
                            CodeInfo_ReadInterface firstInfo = opDict[s][0].Info.Cast <CodeInfo_ReadInterface>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region WriteInterface
                    case CodeType.WriteInterface:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_WriteInterface), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.WriteInterface:
                        {
                            CodeInfo_WriteInterface firstInfo = opDict[s][0].Info.Cast <CodeInfo_WriteInterface>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region WimExtract
                    case CodeType.WimExtract:
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_WimExtract), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.WimExtract:
                        {
                            CodeInfo_WimExtract firstInfo = opDict[s][0].Info.Cast <CodeInfo_WimExtract>();
                            if (firstInfo.OptimizeCompare(cmd.Info))
                            {
                                opDict[s].Add(cmd);
                            }
                            else
                            {
                                goto default;
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region WimPath Series
                    case CodeType.WimPathAdd:     // Use WimPathAdd as a representative of WimPath{Add, Delete, Rename}
                        Debug.Assert(opDict[s][0].Info.GetType() == typeof(CodeInfo_WimPathAdd) ||
                                     opDict[s][0].Info.GetType() == typeof(CodeInfo_WimPathDelete) ||
                                     opDict[s][0].Info.GetType() == typeof(CodeInfo_WimPathRename), "Invalid CodeInfo");
                        switch (cmd.Type)
                        {
                        case CodeType.WimPathAdd:
                        case CodeType.WimPathDelete:
                        case CodeType.WimPathRename:
                        {
                            CodeCommand firstCmd = opDict[s][0];
                            if (firstCmd.Type == CodeType.WimPathAdd)
                            {
                                CodeInfo_WimPathAdd firstInfo = opDict[s][0].Info.Cast <CodeInfo_WimPathAdd>();
                                if (firstInfo.OptimizeCompare(cmd.Info))
                                {
                                    opDict[s].Add(cmd);
                                }
                                else
                                {
                                    goto default;
                                }
                            }
                            else if (firstCmd.Type == CodeType.WimPathDelete)
                            {
                                CodeInfo_WimPathDelete firstInfo = opDict[s][0].Info.Cast <CodeInfo_WimPathDelete>();
                                if (firstInfo.OptimizeCompare(cmd.Info))
                                {
                                    opDict[s].Add(cmd);
                                }
                                else
                                {
                                    goto default;
                                }
                            }
                            else if (firstCmd.Type == CodeType.WimPathRename)
                            {
                                CodeInfo_WimPathRename firstInfo = opDict[s][0].Info.Cast <CodeInfo_WimPathRename>();
                                if (firstInfo.OptimizeCompare(cmd.Info))
                                {
                                    opDict[s].Add(cmd);
                                }
                                else
                                {
                                    goto default;
                                }
                            }
                            break;
                        }

                        case CodeType.Comment:         // Remove comments
                            break;

                        default:         // Optimize them
                            FinalizeSequence(s, opDict[s]);
                            s         = CodeType.None;
                            loopAgain = true;
                            break;
                        }
                        break;

                        #endregion
                        #region Error
                    default:
                        throw new InternalException("Internal Logic Error at CodeOptimizer.InternalOptimize()");
                        #endregion
                    }
                }while (loopAgain);
            }

            #region Finish
            foreach (var kv in opDict)
            {
                FinalizeSequence(kv.Key, kv.Value);
            }
            #endregion

            #region FinalizeSequence
            void FinalizeSequence(CodeType state, List <CodeCommand> cmdSeq)
            {
                CodeCommand opCmd;

                if (cmdSeq.Count == 1)
                {
                    opCmd = cmdSeq[0];
                }
                else if (1 < cmdSeq.Count)
                {
                    opCmd = PackCommand(state, new List <CodeCommand>(cmdSeq));
                }
                else // if (cmds.Count <= 0)
                {
                    return;
                }

                Debug.Assert(opCmd != null, "Internal Logic Error in CodeOptimizer.Optimize");
                optimized.Add(opCmd);

                cmdSeq.Clear();
            }

            #endregion

            return(optimized);
        }
Ejemplo n.º 5
0
        public static List <LogInfo> IniAddSectionOp(EngineState s, CodeCommand cmd)
        {
            List <LogInfo> logs = new List <LogInfo>();

            CodeInfo_IniAddSectionOp infoOp = cmd.Info.Cast <CodeInfo_IniAddSectionOp>();

            string fileName = StringEscaper.Preprocess(s, infoOp.Infos[0].FileName);

            Debug.Assert(fileName != null, $"{nameof(fileName)} != null");

            if (!StringEscaper.PathSecurityCheck(fileName, out string errorMsg))
            {
                return(LogInfo.LogErrorMessage(logs, errorMsg));
            }

            string[] sections = new string[infoOp.Cmds.Count];
            for (int i = 0; i < sections.Length; i++)
            {
                CodeInfo_IniAddSection info = infoOp.Infos[i];

                string sectionName = StringEscaper.Preprocess(s, info.Section);
                if (sectionName.Length == 0)
                {
                    return(LogInfo.LogErrorMessage(logs, "Section name cannot be empty"));
                }

                sections[i] = sectionName;
            }

            string dirPath = Path.GetDirectoryName(fileName);

            if (dirPath == null)
            {
                throw new InternalException("Internal Logic Error at IniAddSectionOp");
            }
            if (!Directory.Exists(dirPath))
            {
                Directory.CreateDirectory(dirPath);
            }

            bool result = IniReadWriter.AddSections(fileName, sections);

            if (result)
            {
                for (int i = 0; i < sections.Length; i++)
                {
                    logs.Add(new LogInfo(LogState.Success, $"Section [{sections[i]}] added", infoOp.Cmds[i]));
                }
                logs.Add(new LogInfo(LogState.Success, $"Added [{sections.Length}] sections to [{fileName}]", cmd));
            }
            else
            {
                for (int i = 0; i < sections.Length; i++)
                {
                    logs.Add(new LogInfo(LogState.Error, $"Could not add section [{sections[i]}]", infoOp.Cmds[i]));
                }
                logs.Add(new LogInfo(LogState.Error, $"Could not add [{sections.Length}] sections to [{fileName}]", cmd));
            }

            return(logs);
        }