private static void CheckAndRunCallback(EngineState s, ref CodeCommand cbCmd, string eventParam, string eventName, bool changeCurrentPlugin = false)
{
if (cbCmd == null)
{
return;
}
s.Logger.Build_Write(s, $"Processing callback of event [{eventName}]");
if (changeCurrentPlugin)
{
s.CurrentPlugin = cbCmd.Addr.Plugin;
}
s.CurDepth = 0;
if (cbCmd.Type == CodeType.Run || cbCmd.Type == CodeType.Exec)
{
Debug.Assert(cbCmd.Info.GetType() == typeof(CodeInfo_RunExec));
CodeInfo_RunExec info = cbCmd.Info as CodeInfo_RunExec;
if (1 <= info.Parameters.Count)
{
info.Parameters[0] = eventParam;
}
else
{
info.Parameters.Add(eventParam);
}
CommandBranch.RunExec(s, cbCmd, false, false, true);
}
else
{
ExecuteCommand(s, cbCmd);
}
s.Logger.Build_Write(s, new LogInfo(LogState.Info, $"End of callback [{eventName}]", s.CurDepth));
s.Logger.Build_Write(s, Logger.LogSeperator);
cbCmd = null;
}
private void InternalValidateCodes(List <CodeCommand> codes, List <LogInfo> logs)
{
foreach (CodeCommand cmd in codes)
{
switch (cmd.Type)
{
case CodeType.If:
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_If));
CodeInfo_If info = cmd.Info as CodeInfo_If;
if (info.Condition.Type == BranchConditionType.ExistSection)
{
// Exception Handling for 1-files.script
// If,ExistSection,%ScriptFile%,Cache_Delete_B,Run,%ScriptFile%,Cache_Delete_B
if (info.Condition.Arg1.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase))
{
if (info.Embed.Type == CodeType.Run || info.Embed.Type == CodeType.Exec)
{
Debug.Assert(info.Embed.Info.GetType() == typeof(CodeInfo_RunExec));
CodeInfo_RunExec subInfo = info.Embed.Info as CodeInfo_RunExec;
if (subInfo.ScriptFile.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase))
{
if (info.Condition.Arg2.Equals(subInfo.SectionName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
}
}
}
InternalValidateCodes(info.Link, logs);
}
break;
case CodeType.Else:
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_Else));
CodeInfo_Else info = cmd.Info as CodeInfo_Else;
InternalValidateCodes(info.Link, logs);
}
break;
case CodeType.Run:
case CodeType.Exec:
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_RunExec));
CodeInfo_RunExec info = cmd.Info as CodeInfo_RunExec;
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase))
{
if (p.Sections.ContainsKey(info.SectionName))
{
logs.AddRange(ValidateCodeSection(p.Sections[info.SectionName]));
}
else if (CodeParser.StringContainsVariable(info.SectionName) == false)
{
logs.Add(new LogInfo(LogState.Error, $"Section [{info.SectionName}] does not exist", cmd));
}
}
}
break;
case CodeType.Loop:
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_Loop));
CodeInfo_Loop info = cmd.Info as CodeInfo_Loop;
if (info.Break)
{
continue;
}
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase))
{
if (p.Sections.ContainsKey(info.SectionName))
{
logs.AddRange(ValidateCodeSection(p.Sections[info.SectionName]));
}
else if (CodeParser.StringContainsVariable(info.SectionName) == false)
{
logs.Add(new LogInfo(LogState.Error, $"Section [{info.SectionName}] does not exist", cmd));
}
}
}
break;
default:
break;
}
}
}
public static void RunExec(EngineState s, CodeCommand cmd, bool preserveCurParams, bool forceLog, bool callback)
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_RunExec));
CodeInfo_RunExec info = cmd.Info as CodeInfo_RunExec;
string scriptFile = StringEscaper.Preprocess(s, info.ScriptFile);
string sectionName = StringEscaper.Preprocess(s, info.SectionName);
List <string> paramList = StringEscaper.Preprocess(s, info.Parameters);
Script p = Engine.GetScriptInstance(s, cmd, s.CurrentScript.FullPath, scriptFile, out bool inCurrentScript);
// Does section exists?
if (!p.Sections.ContainsKey(sectionName))
{
throw new ExecuteException($"[{scriptFile}] does not have section [{sectionName}]");
}
// Section Parameter
Dictionary <int, string> paramDict = new Dictionary <int, string>();
if (preserveCurParams)
{
paramDict = s.CurSectionParams;
}
else
{
for (int i = 0; i < paramList.Count; i++)
{
paramDict[i + 1] = paramList[i];
}
}
// Branch to new section
SectionAddress nextAddr = new SectionAddress(p, p.Sections[sectionName]);
s.Logger.LogStartOfSection(s, nextAddr, s.CurDepth, inCurrentScript, paramDict, cmd, forceLog);
Dictionary <string, string> localVars = null;
Dictionary <string, string> fixedVars = null;
Dictionary <string, CodeCommand> localMacros = null;
if (cmd.Type == CodeType.Exec)
{
// Backup Varaibles and Macros
localVars = s.Variables.GetVarDict(VarsType.Local);
fixedVars = s.Variables.GetVarDict(VarsType.Fixed);
localMacros = s.Macro.LocalDict;
// Load Per-Script Variables
s.Variables.ResetVariables(VarsType.Local);
List <LogInfo> varLogs = s.Variables.LoadDefaultScriptVariables(p);
s.Logger.Build_Write(s, LogInfo.AddDepth(varLogs, s.CurDepth + 1));
// Load Per-Script Macro
s.Macro.ResetLocalMacros();
List <LogInfo> macroLogs = s.Macro.LoadLocalMacroDict(p, false);
s.Logger.Build_Write(s, LogInfo.AddDepth(macroLogs, s.CurDepth + 1));
}
// Run Section
int depthBackup = s.CurDepth;
int errorOffStartLineIdxBackup = s.ErrorOffStartLineIdx;
int erroroffCountBackup = s.ErrorOffLineCount;
Engine.RunSection(s, nextAddr, paramDict, s.CurDepth + 1, callback);
if (cmd.Type == CodeType.Exec)
{
// Restore Variables
s.Variables.SetVarDict(VarsType.Local, localVars);
s.Variables.SetVarDict(VarsType.Fixed, fixedVars);
// Restore Local Macros
s.Macro.SetLocalMacros(localMacros);
}
s.CurDepth = depthBackup;
s.ErrorOffStartLineIdx = errorOffStartLineIdxBackup;
s.ErrorOffLineCount = erroroffCountBackup;
s.Logger.LogEndOfSection(s, nextAddr, s.CurDepth, inCurrentScript, cmd, forceLog);
}
private void RecursiveFindCodeSection(IReadOnlyList <CodeCommand> codes, List <LogInfo> logs)
{
string targetCodeSection = null;
string targetInterfaceSection = null;
foreach (CodeCommand cmd in codes)
{
switch (cmd.Type)
{
#region Check CodeSections
case CodeType.If:
{
CodeInfo_If info = cmd.Info.Cast <CodeInfo_If>();
if (info.Condition.Type == BranchConditionType.ExistSection)
{
// For recursive section call
// Ex) If,ExistSection,%ScriptFile%,DoWork,Run,%ScriptFile%,DoWork
if (info.Condition.Arg1.Equals(Script.Const.ScriptFile, StringComparison.OrdinalIgnoreCase) &&
info.Embed.Type == CodeType.Run || info.Embed.Type == CodeType.RunEx || info.Embed.Type == CodeType.Exec)
{
CodeInfo_RunExec subInfo = info.Embed.Info.Cast <CodeInfo_RunExec>();
if (subInfo.ScriptFile.Equals(Script.Const.ScriptFile, StringComparison.OrdinalIgnoreCase))
{
if (info.Condition.Arg2.Equals(subInfo.SectionName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
}
}
RecursiveFindCodeSection(info.Link, logs);
}
break;
case CodeType.Else:
{
CodeInfo_Else info = cmd.Info.Cast <CodeInfo_Else>();
RecursiveFindCodeSection(info.Link, logs);
}
break;
case CodeType.Run:
case CodeType.Exec:
case CodeType.RunEx:
{
CodeInfo_RunExec info = cmd.Info.Cast <CodeInfo_RunExec>();
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals(Script.Const.ScriptFile, StringComparison.OrdinalIgnoreCase) &&
!CodeParser.StringContainsVariable(info.SectionName))
{
targetCodeSection = info.SectionName;
}
}
break;
case CodeType.Loop:
case CodeType.LoopLetter:
case CodeType.LoopEx:
case CodeType.LoopLetterEx:
{
CodeInfo_Loop info = cmd.Info.Cast <CodeInfo_Loop>();
if (info.Break)
{
continue;
}
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals(Script.Const.ScriptFile, StringComparison.OrdinalIgnoreCase) &&
!CodeParser.StringContainsVariable(info.SectionName))
{
targetCodeSection = info.SectionName;
}
}
break;
case CodeType.UserInput:
{
CodeInfo_UserInput info = cmd.Info.Cast <CodeInfo_UserInput>();
UserInputType type = info.Type;
switch (type)
{
case UserInputType.DirPath:
case UserInputType.FilePath:
{
UserInputInfo_DirFile subInfo = info.SubInfo.Cast <UserInputInfo_DirFile>();
if (info.Type == UserInputType.FilePath)
{ // Select File
if (subInfo.Filter != null)
{
string filter = StringEscaper.Unescape(subInfo.Filter);
if (StringEscaper.IsFileFilterValid(filter) == false)
{
logs.Add(new LogInfo(LogState.Error, $"File filter pattern [{filter}] is invalid", cmd));
}
}
}
else
{ // Select Folder
if (subInfo.Filter != null)
{
logs.Add(new LogInfo(LogState.Warning, $"File filters cannot be used for folder selection", cmd));
}
}
}
break;
}
}
break;
#endregion
#region Check InterfaceSections
case CodeType.AddInterface:
{
CodeInfo_AddInterface info = cmd.Info.Cast <CodeInfo_AddInterface>();
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals(Script.Const.ScriptFile, StringComparison.OrdinalIgnoreCase) &&
!CodeParser.StringContainsVariable(info.Section))
{
targetInterfaceSection = info.Section;
}
}
break;
case CodeType.ReadInterface:
{
CodeInfo_ReadInterface info = cmd.Info.Cast <CodeInfo_ReadInterface>();
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals(Script.Const.ScriptFile, StringComparison.OrdinalIgnoreCase) &&
!CodeParser.StringContainsVariable(info.Section))
{
targetInterfaceSection = info.Section;
}
}
break;
case CodeType.WriteInterface:
{
CodeInfo_WriteInterface info = cmd.Info.Cast <CodeInfo_WriteInterface>();
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals(Script.Const.ScriptFile, StringComparison.OrdinalIgnoreCase) &&
!CodeParser.StringContainsVariable(info.Section))
{
targetInterfaceSection = info.Section;
}
}
break;
case CodeType.IniWrite:
{
// To detect multi-interface without `InterfaceList=`,
// Inspect pattern `IniWrite,%ScriptFile%,Main,Interface,<NewInterfaceSection>`
CodeInfo_IniWrite info = cmd.Info.Cast <CodeInfo_IniWrite>();
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.FileName.Equals(Script.Const.ScriptFile, StringComparison.OrdinalIgnoreCase) &&
info.Section.Equals(ScriptSection.Names.Main, StringComparison.OrdinalIgnoreCase) &&
info.Key.Equals(ScriptSection.Names.Interface, StringComparison.OrdinalIgnoreCase) &&
!CodeParser.StringContainsVariable(info.Value))
{
targetInterfaceSection = info.Value;
}
}
break;
#endregion
}
if (targetCodeSection != null)
{
if (_sc.Sections.ContainsKey(targetCodeSection))
{
logs.AddRange(CheckCodeSection(_sc.Sections[targetCodeSection], cmd.RawCode, cmd.LineIdx));
}
else
{
logs.Add(new LogInfo(LogState.Error, $"Section [{targetCodeSection}] does not exist", cmd));
}
}
if (targetInterfaceSection != null)
{
if (_sc.Sections.ContainsKey(targetInterfaceSection))
{
logs.AddRange(CheckInterfaceSection(_sc.Sections[targetInterfaceSection], cmd.RawCode, cmd.LineIdx));
}
else
{
logs.Add(new LogInfo(LogState.Error, $"Section [{targetInterfaceSection}] does not exist", cmd));
}
}
}
}
private void InternalValidateCodes(CodeCommand[] codes, List <LogInfo> logs)
{
string targetCodeSection = null;
string targetInterfaceSection = null;
foreach (CodeCommand cmd in codes)
{
switch (cmd.Type)
{
#region Check CodeSections
case CodeType.If:
{
CodeInfo_If info = cmd.Info.Cast <CodeInfo_If>();
if (info.Condition.Type == BranchConditionType.ExistSection)
{
// For recursive section call
// Ex) If,ExistSection,%ScriptFile%,DoWork,Run,%ScriptFile%,DoWork
if (info.Condition.Arg1.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase) &&
info.Embed.Type == CodeType.Run || info.Embed.Type == CodeType.Exec)
{
CodeInfo_RunExec subInfo = info.Embed.Info.Cast <CodeInfo_RunExec>();
if (subInfo.ScriptFile.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase))
{
if (info.Condition.Arg2.Equals(subInfo.SectionName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
}
}
InternalValidateCodes(info.Link.ToArray(), logs);
}
break;
case CodeType.Else:
{
CodeInfo_Else info = cmd.Info.Cast <CodeInfo_Else>();
InternalValidateCodes(info.Link.ToArray(), logs);
}
break;
case CodeType.Run:
case CodeType.Exec:
case CodeType.RunEx:
{
CodeInfo_RunExec info = cmd.Info.Cast <CodeInfo_RunExec>();
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase) &&
!CodeParser.StringContainsVariable(info.SectionName))
{
targetCodeSection = info.SectionName;
}
}
break;
case CodeType.Loop:
case CodeType.LoopLetter:
case CodeType.LoopEx:
case CodeType.LoopLetterEx:
{
CodeInfo_Loop info = cmd.Info.Cast <CodeInfo_Loop>();
if (info.Break)
{
continue;
}
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase) &&
!CodeParser.StringContainsVariable(info.SectionName))
{
targetCodeSection = info.SectionName;
}
}
break;
#endregion
#region Check InterfaceSections
case CodeType.AddInterface:
{
CodeInfo_AddInterface info = cmd.Info.Cast <CodeInfo_AddInterface>();
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase) &&
CodeParser.StringContainsVariable(info.Section))
{
targetInterfaceSection = info.Section;
}
}
break;
case CodeType.ReadInterface:
{
CodeInfo_ReadInterface info = cmd.Info.Cast <CodeInfo_ReadInterface>();
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase) &&
CodeParser.StringContainsVariable(info.Section))
{
targetInterfaceSection = info.Section;
}
}
break;
case CodeType.WriteInterface:
{
CodeInfo_WriteInterface info = cmd.Info.Cast <CodeInfo_WriteInterface>();
// CodeValidator does not have Variable information, so just check with predefined literal
if (info.ScriptFile.Equals("%ScriptFile%", StringComparison.OrdinalIgnoreCase) &&
CodeParser.StringContainsVariable(info.Section))
{
targetInterfaceSection = info.Section;
}
}
break;
#endregion
}
if (targetCodeSection != null && !_visitedSections.Contains(targetCodeSection))
{
_visitedSections.Add(targetCodeSection);
if (_sc.Sections.ContainsKey(targetCodeSection))
{
logs.AddRange(ValidateCodeSection(_sc.Sections[targetCodeSection], cmd.RawCode, cmd.LineIdx));
}
else
{
logs.Add(new LogInfo(LogState.Error, $"Section [{targetCodeSection}] does not exist", cmd));
}
}
if (targetInterfaceSection != null && !_visitedSections.Contains(targetInterfaceSection))
{
_visitedSections.Add(targetInterfaceSection);
if (_sc.Sections.ContainsKey(targetInterfaceSection))
{
logs.AddRange(ValidateInterfaceSection(_sc.Sections[targetInterfaceSection], cmd.RawCode, cmd.LineIdx));
}
else
{
logs.Add(new LogInfo(LogState.Error, $"Section [{targetInterfaceSection}] does not exist", cmd));
}
}
}
}