public override List <PlayHistoryVO> GetModels(PlayHistoryPara mp)
{
string where = GetConditionByPara(mp);
CodeCommand command = new CodeCommand();
string cmd = LOAD
.Replace("@WHERE", where)
.Replace("@ORDER", GetOrderByPara(mp));
command.CommandText = cmd;
var table = DbProxyFactory.Instance.Proxy.ExecuteTable(command);
List <PlayHistoryVO> list = new List <PlayHistoryVO>();
for (int i = 0; i < table.Rows.Count; i++)
{
list.Add(new PlayHistoryVO(table.Rows[i]));
}
return(list);
}
public static List <LogInfo> DirDelete(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_DirDelete));
CodeInfo_DirDelete info = cmd.Info as CodeInfo_DirDelete;
string dirPath = StringEscaper.Preprocess(s, info.DirPath);
// Path Security Check
if (StringEscaper.PathSecurityCheck(dirPath, out string errorMsg) == false)
{
logs.Add(new LogInfo(LogState.Error, errorMsg));
return(logs);
}
// Delete Directory
FileHelper.DirectoryDeleteEx(dirPath);
logs.Add(new LogInfo(LogState.Success, $"Deleted directory [{dirPath}]"));
return(logs);
}
public static List <LogInfo> FileCreateBlank(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
CodeInfo_FileCreateBlank info = cmd.Info.Cast <CodeInfo_FileCreateBlank>();
string filePath = StringEscaper.Preprocess(s, info.FilePath);
Encoding encoding = EncodingHelper.DefaultAnsi;
if (info.Encoding != null)
{
encoding = info.Encoding;
}
if (File.Exists(filePath))
{
if (info.Preserve)
{
logs.Add(new LogInfo(info.NoWarn ? LogState.Ignore : LogState.Overwrite, $"[{filePath}] will not be overwritten", cmd));
return(logs);
}
logs.Add(new LogInfo(info.NoWarn ? LogState.Ignore : LogState.Overwrite, $"[{filePath}] will be overwritten", cmd));
}
if (!StringEscaper.PathSecurityCheck(filePath, out string errorMsg))
{
return(LogInfo.LogErrorMessage(logs, errorMsg));
}
Directory.CreateDirectory(FileHelper.GetDirNameEx(filePath));
EncodingHelper.WriteTextBom(filePath, encoding);
logs.Add(new LogInfo(LogState.Success, $"Created blank text file [{filePath}]", cmd));
return(logs);
}
public override bool Edit(SysAreaCityVO m)
{
CodeCommand command = new CodeCommand();
command.CommandText = EDIT;
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Id", Value = ParameterHelper.ConvertValue(m.Id)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Name", Value = ParameterHelper.ConvertValue(m.Name)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@ParentId", Value = ParameterHelper.ConvertValue(m.ParentId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@ZipCode", Value = ParameterHelper.ConvertValue(m.ZipCode)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateTime", Value = ParameterHelper.ConvertValue(m.CreateTime)
});
int result = DbProxyFactory.Instance.Proxy.ExecuteNonQuery(command);
if (result >= 1)
{
return(true);
}
return(false);
}
public static List <LogInfo> DirSize(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
CodeInfo_DirSize info = cmd.Info.Cast <CodeInfo_DirSize>();
string dirPath = StringEscaper.Preprocess(s, info.DirPath);
if (!Directory.Exists(dirPath))
{
return(LogInfo.LogErrorMessage(logs, $"Directory [{dirPath}] does not exist"));
}
string[] files = FileHelper.GetFilesEx(dirPath, "*", SearchOption.AllDirectories);
long dirSize = files.Sum(f => new FileInfo(f).Length);
logs.Add(new LogInfo(LogState.Success, $"Directory [{dirPath}] is [{dirSize}B]", cmd));
List <LogInfo> varLogs = Variables.SetVariable(s, info.DestVar, dirSize.ToString());
logs.AddRange(varLogs);
return(logs);
}
public override bool Insert(UserCodeInfoVO m)
{
CodeCommand command = new CodeCommand();
command.CommandText = INSERT;
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Name", Value = ParameterHelper.ConvertValue(m.Name)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@UserId", Value = ParameterHelper.ConvertValue(m.UserId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@TypeId", Value = ParameterHelper.ConvertValue(m.TypeId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CodeContent", Value = ParameterHelper.ConvertValue(m.CodeContent)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateDate", Value = ParameterHelper.ConvertValue(m.CreateDate)
});
int result = DbProxyFactory.Instance.Proxy.ExecuteNonQuery(command);
if (result >= 1)
{
return(true);
}
return(false);
}
public static List <LogInfo> Wait(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
CodeInfo_Wait info = cmd.Info.Cast <CodeInfo_Wait>();
if (!NumberHelper.ParseInt32(info.Second, out int second))
{
logs.Add(new LogInfo(LogState.Error, $"Argument [{info.Second}] is not a valid integer"));
return(logs);
}
if (second < 0)
{
logs.Add(new LogInfo(LogState.Error, $"Argument [{info.Second}] should be larger than 0"));
return(logs);
}
Task.Delay(TimeSpan.FromSeconds(second)).Wait();
logs.Add(new LogInfo(LogState.Success, $"Slept [{info.Second}] seconds", cmd));
return(logs);
}
public override int InsertIdentityId(SysAreaProvincesVO m)
{
CodeCommand command = new CodeCommand();
command.CommandText = INSERT + "; select @@Identity";
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Id", Value = ParameterHelper.ConvertValue(m.Id)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Name", Value = ParameterHelper.ConvertValue(m.Name)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateTime", Value = ParameterHelper.ConvertValue(m.CreateTime)
});
var result = DbProxyFactory.Instance.Proxy.ExecuteScalar(command);
return(int.Parse(result.ToString()));
}
public override bool Insert(SysAreaDistrictsVO m)
{
CodeCommand command = new CodeCommand();
command.CommandText = INSERT;
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Id", Value = ParameterHelper.ConvertValue(m.Id)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Name", Value = ParameterHelper.ConvertValue(m.Name)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CityId", Value = ParameterHelper.ConvertValue(m.CityId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@ProvincesId", Value = ParameterHelper.ConvertValue(m.ProvincesId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateTime", Value = ParameterHelper.ConvertValue(m.CreateTime)
});
int result = DbProxyFactory.Instance.Proxy.ExecuteNonQuery(command);
if (result >= 1)
{
return(true);
}
return(false);
}
public override int InsertIdentityId(UserFinanceHistoryVO m)
{
CodeCommand command = new CodeCommand();
command.CommandText = INSERT + "; select @@Identity";
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@UserId", Value = ParameterHelper.ConvertValue(m.UserId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@RechargeType", Value = ParameterHelper.ConvertValue(m.RechargeType)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Money", Value = ParameterHelper.ConvertValue(m.Money)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@MoneyType", Value = ParameterHelper.ConvertValue(m.MoneyType)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateDate", Value = ParameterHelper.ConvertValue(m.CreateDate)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateUserId", Value = ParameterHelper.ConvertValue(m.CreateUserId)
});
var result = DbProxyFactory.Instance.Proxy.ExecuteScalar(command);
return(int.Parse(result.ToString()));
}
public static List <LogInfo> AddVariables(EngineState s, CodeCommand cmd)
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_AddVariables));
CodeInfo_AddVariables info = cmd.Info as CodeInfo_AddVariables;
string pluginFile = StringEscaper.Preprocess(s, info.PluginFile);
string sectionName = StringEscaper.Preprocess(s, info.SectionName);
Plugin p = Engine.GetPluginInstance(s, cmd, s.CurrentPlugin.FullPath, pluginFile, out bool inCurrentPlugin);
// Does section exists?
if (!p.Sections.ContainsKey(sectionName))
{
throw new ExecuteException($"Plugin [{pluginFile}] does not have section [{sectionName}]");
}
// Directly read from file
List <string> lines = Ini.ParseRawSection(p.FullPath, sectionName);
// Add Variables
Dictionary <string, string> varDict = Ini.ParseIniLinesVarStyle(lines);
List <LogInfo> varLogs = s.Variables.AddVariables(info.Global ? VarsType.Global : VarsType.Local, varDict);
// Add Macros
SectionAddress addr = new SectionAddress(p, p.Sections[sectionName]);
List <LogInfo> macroLogs = s.Macro.LoadLocalMacroDict(addr, lines, true);
varLogs.AddRange(macroLogs);
if (varLogs.Count == 0) // No variables
{
varLogs.Add(new LogInfo(LogState.Info, $"Plugin [{pluginFile}]'s section [{sectionName}] does not have any variables"));
}
return(varLogs);
}
public override bool Edit(DomainSynchroHistoryVO m)
{
CodeCommand command = new CodeCommand();
command.CommandText = EDIT;
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@ServerId", Value = ParameterHelper.ConvertValue(m.ServerId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Name", Value = ParameterHelper.ConvertValue(m.Name)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@MainDomain", Value = ParameterHelper.ConvertValue(m.MainDomain)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Domains", Value = ParameterHelper.ConvertValue(m.Domains)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@DomainPath", Value = ParameterHelper.ConvertValue(m.DomainPath)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@OperType", Value = ParameterHelper.ConvertValue(m.OperType)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@IsSynchro", Value = ParameterHelper.ConvertValue(m.IsSynchro)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@SynchroDate", Value = ParameterHelper.ConvertValue(m.SynchroDate)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@ClientIp", Value = ParameterHelper.ConvertValue(m.ClientIp)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateDate", Value = ParameterHelper.ConvertValue(m.CreateDate)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateUserId", Value = ParameterHelper.ConvertValue(m.CreateUserId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@UserId", Value = ParameterHelper.ConvertValue(m.UserId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@IsDelete", Value = ParameterHelper.ConvertValue(m.IsDelete)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Id", Value = ParameterHelper.ConvertValue(m.Id)
});
int result = DbProxyFactory.Instance.Proxy.ExecuteNonQuery(command);
if (result >= 1)
{
return(true);
}
return(false);
}
public static List <LogInfo> TXTAddLine(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_TXTAddLine));
CodeInfo_TXTAddLine info = cmd.Info as CodeInfo_TXTAddLine;
string fileName = StringEscaper.Preprocess(s, info.FileName);
string line = StringEscaper.Preprocess(s, info.Line);
string modeStr = StringEscaper.Preprocess(s, info.Mode);
TXTAddLineMode mode;
if (modeStr.Equals("Append", StringComparison.OrdinalIgnoreCase))
{
mode = TXTAddLineMode.Append;
}
else if (info.Mode.Equals("Prepend", StringComparison.OrdinalIgnoreCase))
{
mode = TXTAddLineMode.Prepend;
}
else
{
throw new ExecuteException($"Mode [{modeStr}] must be one of [Append, Prepend]");
}
if (StringEscaper.PathSecurityCheck(fileName, out string errorMsg) == false)
{
logs.Add(new LogInfo(LogState.Error, errorMsg));
return(logs);
}
// Detect encoding of text
// If text does not exists, create blank file
Encoding encoding = Encoding.Default;
if (File.Exists(fileName))
{
encoding = FileHelper.DetectTextEncoding(fileName);
}
if (mode == TXTAddLineMode.Prepend)
{
string tempPath = Path.GetTempFileName();
using (StreamReader reader = new StreamReader(fileName, encoding))
using (StreamWriter writer = new StreamWriter(tempPath, false, encoding))
{
writer.WriteLine(line);
string lineFromSrc;
while ((lineFromSrc = reader.ReadLine()) != null)
{
writer.WriteLine(lineFromSrc);
}
}
FileHelper.FileReplaceEx(tempPath, fileName);
logs.Add(new LogInfo(LogState.Success, $"Prepened [{line}] to [{fileName}]", cmd));
}
else if (mode == TXTAddLineMode.Append)
{
bool newLineExist = true;
if (File.Exists(fileName))
{
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
long bomLen = FileHelper.TextBOMLength(fs);
byte[] lastChar = new byte[2];
if (2 + bomLen <= fs.Length)
{
fs.Position = fs.Length - 2;
fs.Read(lastChar, 0, 2);
if (lastChar[0] != '\r' || lastChar[1] != '\n')
{
newLineExist = false;
}
}
}
}
if (newLineExist)
{
File.AppendAllText(fileName, line + "\r\n", encoding);
}
else
{
File.AppendAllText(fileName, "\r\n" + line + "\r\n", encoding);
}
logs.Add(new LogInfo(LogState.Success, $"Appended [{line}] to [{fileName}]", cmd));
}
return(logs);
}
private static List <CodeCommand> InternalOptimize(List <CodeCommand> codes)
{
List <CodeCommand> optimized = new List <CodeCommand>();
Dictionary <CodeType, List <CodeCommand> > opDict = new Dictionary <CodeType, List <CodeCommand> >();
foreach (CodeType type in toOptimize)
{
opDict[type] = new List <CodeCommand>();
}
CodeType state = CodeType.None;
for (int i = 0; i < codes.Count; i++)
{
CodeCommand cmd = codes[i];
switch (state)
{
#region Default
case CodeType.None:
switch (cmd.Type)
{
case CodeType.TXTAddLine:
state = CodeType.TXTAddLine;
opDict[CodeType.TXTAddLine].Add(cmd);
break;
case CodeType.TXTReplace:
state = CodeType.TXTReplace;
opDict[CodeType.TXTReplace].Add(cmd);
break;
case CodeType.TXTDelLine:
state = CodeType.TXTDelLine;
opDict[CodeType.TXTDelLine].Add(cmd);
break;
case CodeType.INIWrite:
state = CodeType.INIWrite;
opDict[CodeType.INIWrite].Add(cmd);
break;
case CodeType.INIRead:
state = CodeType.INIRead;
opDict[CodeType.INIRead].Add(cmd);
break;
case CodeType.INIReadSection:
state = CodeType.INIReadSection;
opDict[CodeType.INIReadSection].Add(cmd);
break;
case CodeType.INIAddSection:
state = CodeType.INIAddSection;
opDict[CodeType.INIAddSection].Add(cmd);
break;
case CodeType.INIDeleteSection:
state = CodeType.INIDeleteSection;
opDict[CodeType.INIDeleteSection].Add(cmd);
break;
case CodeType.INIWriteTextLine:
state = CodeType.INIWriteTextLine;
opDict[CodeType.INIWriteTextLine].Add(cmd);
break;
case CodeType.Visible:
state = CodeType.Visible;
opDict[CodeType.Visible].Add(cmd);
break;
default:
optimized.Add(cmd);
break;
}
break;
#endregion
#region TXTAddLine
case CodeType.TXTAddLine:
Debug.Assert(opDict[state][0].Info.GetType() == typeof(CodeInfo_TXTAddLine));
switch (cmd.Type)
{
case CodeType.TXTAddLine:
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_TXTAddLine));
CodeInfo_TXTAddLine firstInfo = (opDict[state][0].Info as CodeInfo_TXTAddLine);
if (cmd.Info is CodeInfo_TXTAddLine info &&
info.FileName.Equals(firstInfo.FileName, StringComparison.OrdinalIgnoreCase) &&
info.Mode.Equals(firstInfo.Mode, StringComparison.OrdinalIgnoreCase))
{
opDict[state].Add(cmd);
}
public override int InsertIdentityId(DomainSynchroHistoryVO m)
{
CodeCommand command = new CodeCommand();
command.CommandText = INSERT + "; select @@Identity";
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@ServerId", Value = ParameterHelper.ConvertValue(m.ServerId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Name", Value = ParameterHelper.ConvertValue(m.Name)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@MainDomain", Value = ParameterHelper.ConvertValue(m.MainDomain)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@Domains", Value = ParameterHelper.ConvertValue(m.Domains)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@DomainPath", Value = ParameterHelper.ConvertValue(m.DomainPath)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@OperType", Value = ParameterHelper.ConvertValue(m.OperType)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@IsSynchro", Value = ParameterHelper.ConvertValue(m.IsSynchro)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@SynchroDate", Value = ParameterHelper.ConvertValue(m.SynchroDate)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@ClientIp", Value = ParameterHelper.ConvertValue(m.ClientIp)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateDate", Value = ParameterHelper.ConvertValue(m.CreateDate)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@CreateUserId", Value = ParameterHelper.ConvertValue(m.CreateUserId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@UserId", Value = ParameterHelper.ConvertValue(m.UserId)
});
command.Parameters.Add(new SqlParameter()
{
ParameterName = "@IsDelete", Value = ParameterHelper.ConvertValue(m.IsDelete)
});
var result = DbProxyFactory.Instance.Proxy.ExecuteScalar(command);
return(int.Parse(result.ToString()));
}
public static List <LogInfo> Eval(EngineState s, ScriptSection section, string rawCode, CodeType type, ErrorCheck check, out CodeCommand cmd)
{
CodeParser parser = new CodeParser(section, Global.Setting, Project.Compat);
return(Eval(s, parser, rawCode, type, check, out cmd));
}
public static List <LogInfo> Eval(EngineState s, CodeParser parser, string rawCode, CodeType type, ErrorCheck check, CompatOption compat, out CodeCommand cmd)
{
// Create CodeCommand
cmd = parser.ParseStatement(rawCode);
if (cmd.Type == CodeType.Error)
{
CodeInfo_Error info = cmd.Info.Cast <CodeInfo_Error>();
Console.WriteLine(info.ErrorMessage);
Assert.AreEqual(ErrorCheck.ParserError, check);
return(new List <LogInfo>());
}
Assert.AreEqual(type, cmd.Type);
// Run CodeCommand
s.SetCompat(compat);
List <LogInfo> logs = Engine.ExecuteCommand(s, cmd);
s.SetCompat(Project.Compat); // Reset to default
// Assert
CheckErrorLogs(logs, check);
// Return logs
return(logs);
}
public static List <LogInfo> CopyOrExpand(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
CodeInfo_CopyOrExpand info = cmd.Info.Cast <CodeInfo_CopyOrExpand>();
#region Event Handlers
void ReportExpandProgress(object sender, ProgressEventArgs e)
{
s.MainViewModel.BuildCommandProgressValue = e.PercentDone;
s.MainViewModel.BuildCommandProgressText = $"Expanding... ({e.PercentDone}%)";
}
#endregion
string srcFile = StringEscaper.Preprocess(s, info.SrcFile);
string destPath = StringEscaper.Preprocess(s, info.DestPath);
Debug.Assert(srcFile != null, $"{nameof(srcFile)} != null");
Debug.Assert(destPath != null, $"{nameof(destPath)} != null");
// Path Security Check
if (!StringEscaper.PathSecurityCheck(destPath, out string errorMsg))
{
return(LogInfo.LogErrorMessage(logs, errorMsg));
}
string srcFileName = Path.GetFileName(srcFile);
string srcFileExt = Path.GetExtension(srcFile);
if (!Directory.Exists(destPath))
{
if (File.Exists(destPath))
{
if (info.Preserve)
{
logs.Add(new LogInfo(info.NoWarn ? LogState.Ignore : LogState.Overwrite, $"File [{destPath}] already exists and will not be overwritten"));
return(logs);
}
logs.Add(new LogInfo(info.NoWarn ? LogState.Ignore : LogState.Overwrite, $"File [{destPath}] already exists and will be overwritten"));
}
}
// Get destFullPath. It should be a file.
string destDir;
string destFullPath;
if (Directory.Exists(destPath))
{
destDir = destPath;
destFullPath = Path.Combine(destPath, srcFileName);
}
else // Move to new name
{
destDir = FileHelper.GetDirNameEx(destPath);
destFullPath = destPath;
}
Directory.CreateDirectory(destDir);
// Check wildcard
// WinBuilder082 behavior
// - Some files are matched with wildcard : Reports success, but no files are copied.
// - No files are matched with wildcard : Reports error.
string wildcard = Path.GetFileName(srcFile);
if (wildcard.IndexOfAny(new char[] { '*', '?' }) != -1)
{
logs.Add(new LogInfo(LogState.Warning, "CopyOrExpand does not support filename with wildcard"));
return(logs);
}
// Copy or Expand srcFile.
if (File.Exists(srcFile))
{ // SrcFile is uncompressed, just copy!
File.Copy(srcFile, destFullPath, !info.Preserve);
logs.Add(new LogInfo(LogState.Success, $"[{srcFile}] copied to [{destPath}]"));
}
else
{ // Extract Cabinet from _ (Ex) EXPLORER.EX_ -> EXPLORER.EXE
// Terminate if a file does not have equivalent cabinet file
if (srcFileExt.Length == ".".Length)
{
return(logs);
}
string srcCabExt = srcFileExt.Substring(0, srcFileExt.Length - 1) + "_";
string srcCab = srcFile.Substring(0, srcFile.Length - srcCabExt.Length) + srcCabExt;
if (File.Exists(srcCab))
{
// Turn on report progress only if file is larger than 1MB
FileInfo fi = new FileInfo(srcCab);
bool reportProgress = 1024 * 1024 <= fi.Length;
using (SevenZipExtractor extractor = new SevenZipExtractor(srcCab))
{
if (extractor.Format != InArchiveFormat.Cab)
{
return(LogInfo.LogErrorMessage(logs, $"[{srcCab}] is not a cabinet archive"));
}
string[] archiveFileNames = extractor.ArchiveFileNames.ToArray();
if (archiveFileNames.Length != 1)
{
return(LogInfo.LogErrorMessage(logs, $"Cabinet [{srcCab}] should contain only a single file"));
}
if (!archiveFileNames.Contains(srcFileName, StringComparer.OrdinalIgnoreCase))
{
return(LogInfo.LogErrorMessage(logs, $"Failed to extract [{srcFileName}] from [{srcCab}]"));
}
if (reportProgress)
{
extractor.Extracting += ReportExpandProgress; // Use "Expanding" instead of "CopyOrExpanding"
s.MainViewModel.SetBuildCommandProgress("CopyOrExpand Progress");
}
try
{
using (FileStream fs = new FileStream(destFullPath, FileMode.Create))
{
extractor.ExtractFile(srcFileName, fs);
}
logs.Add(new LogInfo(LogState.Success, $"[{srcCab}] extracted to [{destFullPath}]"));
}
finally
{
extractor.Extracting -= ReportExpandProgress; // Use "Expanding" instead of "CopyOrExpanding"
s.MainViewModel.ResetBuildCommandProgress();
}
}
}
else
{ // Error
logs.Add(new LogInfo(LogState.Error, $"The file [{srcFile}] or [{Path.GetFileName(srcCab)}] could not be found"));
}
}
return(logs);
}
public static List <LogInfo> Eval(EngineState s, string rawCode, CodeType type, ErrorCheck check, CompatOption compat, out CodeCommand cmd)
{
CodeParser parser = new CodeParser(DummySection(), Global.Setting, compat);
return(Eval(s, parser, rawCode, type, check, compat, out cmd));
}
public static List <LogInfo> TXTAddLineOp(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_TXTAddLineOp));
CodeInfo_TXTAddLineOp infoOp = cmd.Info as CodeInfo_TXTAddLineOp;
string fileName = StringEscaper.Preprocess(s, infoOp.InfoList[0].FileName);
string modeStr = StringEscaper.Preprocess(s, infoOp.InfoList[0].Mode);
TXTAddLineMode mode;
if (modeStr.Equals("Append", StringComparison.OrdinalIgnoreCase))
{
mode = TXTAddLineMode.Append;
}
else if (modeStr.Equals("Prepend", StringComparison.OrdinalIgnoreCase))
{
mode = TXTAddLineMode.Prepend;
}
else
{
throw new ExecuteException($"Mode [{modeStr}] must be one of [Append, Prepend]");
}
if (StringEscaper.PathSecurityCheck(fileName, out string errorMsg) == false)
{
logs.Add(new LogInfo(LogState.Error, errorMsg));
return(logs);
}
// Detect encoding of text
// If text does not exists, create blank file
Encoding encoding = Encoding.Default;
if (File.Exists(fileName))
{
encoding = FileHelper.DetectTextEncoding(fileName);
}
string linesToWrite;
if (mode == TXTAddLineMode.Prepend)
{
string tempPath = Path.GetTempFileName();
using (StreamReader reader = new StreamReader(fileName, encoding))
using (StreamWriter writer = new StreamWriter(tempPath, false, encoding))
{
StringBuilder b = new StringBuilder();
for (int i = infoOp.InfoList.Count - 1; 0 <= i; i--)
{
b.AppendLine(StringEscaper.Preprocess(s, infoOp.InfoList[i].Line));
}
linesToWrite = b.ToString();
writer.Write(linesToWrite);
writer.Write(reader.ReadToEnd());
}
FileHelper.FileReplaceEx(tempPath, fileName);
logs.Add(new LogInfo(LogState.Success, $"Lines prepened to [{fileName}] : \r\n{linesToWrite}", cmd));
}
else if (mode == TXTAddLineMode.Append)
{
StringBuilder b = new StringBuilder();
for (int i = 0; i < infoOp.InfoList.Count; i++)
{
b.AppendLine(StringEscaper.Preprocess(s, infoOp.InfoList[i].Line));
}
linesToWrite = b.ToString();
bool newLineExist = true;
if (File.Exists(fileName))
{
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
long bomLen = FileHelper.TextBOMLength(fs);
byte[] lastChar = new byte[2];
if (2 + bomLen <= fs.Length)
{
fs.Position = fs.Length - 2;
fs.Read(lastChar, 0, 2);
if (lastChar[0] != '\r' || lastChar[1] != '\n')
{
newLineExist = false;
}
}
}
}
if (newLineExist)
{
File.AppendAllText(fileName, linesToWrite, encoding);
}
else
{
File.AppendAllText(fileName, "\r\n" + linesToWrite, encoding);
}
logs.Add(new LogInfo(LogState.Success, $"Lines appended to [{fileName}] : \r\n{linesToWrite}", cmd));
}
return(logs);
}
static IMemberRef GetMemberRef(IMenuItemContext context) => CodeCommand.GetMemberRef(context, MenuConstants.GUIDOBJ_SEARCH_GUID);
public static void RunExec(EngineState s, CodeCommand cmd, bool preserveCurParams = false, bool forceLog = false)
{
RunExec(s, cmd, preserveCurParams, forceLog, false);
}
public static List <LogInfo> Set(EngineState s, CodeCommand cmd)
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_Set));
CodeInfo_Set info = cmd.Info as CodeInfo_Set;
Variables.VarKeyType varType = Variables.DetermineType(info.VarKey);
if (varType == Variables.VarKeyType.None)
{
// Check Macro
if (Regex.Match(info.VarKey, Macro.MacroNameRegex, RegexOptions.Compiled).Success) // Macro Name Validation
{
string macroCommand = StringEscaper.Preprocess(s, info.VarValue);
if (macroCommand.Equals("NIL", StringComparison.OrdinalIgnoreCase))
{
macroCommand = null;
}
LogInfo log = s.Macro.SetMacro(info.VarKey, macroCommand, cmd.Addr, info.Permanent);
return(new List <LogInfo>(1)
{
log
});
}
}
// [WB082 Behavior]
// If PERMANENT was used but the key exists in interface command, the value will not be written to script.project but in interface.
// Need to investigate where the logs are saved in this case.
switch (info.Permanent)
{
case true:
{ // Check if interface contains VarKey
List <LogInfo> logs = new List <LogInfo>();
if (Variables.DetermineType(info.VarKey) != Variables.VarKeyType.Variable)
{
goto case false;
}
string varKey = Variables.TrimPercentMark(info.VarKey);
string finalValue = StringEscaper.Preprocess(s, info.VarValue);
#region Set UI
Plugin p = cmd.Addr.Plugin;
PluginSection iface = p.GetInterface(out string sectionName);
if (iface == null)
{
goto case false;
}
List <UICommand> uiCmds = iface.GetUICodes(true);
UICommand uiCmd = uiCmds.Find(x => x.Key.Equals(varKey));
if (uiCmd == null)
{
goto case false;
}
bool match = false;
switch (uiCmd.Type)
{
case UIType.TextBox:
{
Debug.Assert(uiCmd.Info.GetType() == typeof(UIInfo_TextBox));
UIInfo_TextBox uiInfo = uiCmd.Info as UIInfo_TextBox;
uiInfo.Value = finalValue;
logs.Add(new LogInfo(LogState.Success, $"Interface [{varKey}] set to [{finalValue}]"));
match = true;
}
break;
case UIType.NumberBox:
{
Debug.Assert(uiCmd.Info.GetType() == typeof(UIInfo_NumberBox));
UIInfo_NumberBox uiInfo = uiCmd.Info as UIInfo_NumberBox;
// WB082 just write string value in case of error, but PEBakery will throw warning
if (!NumberHelper.ParseInt32(finalValue, out int intVal))
{
logs.Add(new LogInfo(LogState.Warning, $"[{finalValue}] is not valid integer"));
return(logs);
}
uiInfo.Value = intVal;
logs.Add(new LogInfo(LogState.Success, $"Interface [{varKey}] set to [{finalValue}]"));
match = true;
}
break;
case UIType.CheckBox:
{
Debug.Assert(uiCmd.Info.GetType() == typeof(UIInfo_CheckBox));
UIInfo_CheckBox uiInfo = uiCmd.Info as UIInfo_CheckBox;
if (finalValue.Equals("True", StringComparison.OrdinalIgnoreCase))
{
uiInfo.Value = true;
logs.Add(new LogInfo(LogState.Success, $"Interface [{varKey}] set to [True]"));
match = true;
}
else if (finalValue.Equals("False", StringComparison.OrdinalIgnoreCase))
{
uiInfo.Value = false;
logs.Add(new LogInfo(LogState.Success, $"Interface [{varKey}] set to [False]"));
match = true;
}
else
{ // WB082 just write string value in case of error, but PEBakery will throw warning
logs.Add(new LogInfo(LogState.Warning, $"[{finalValue}] is not valid boolean"));
return(logs);
}
}
break;
case UIType.ComboBox:
{
Debug.Assert(uiCmd.Info.GetType() == typeof(UIInfo_ComboBox));
UIInfo_ComboBox uiInfo = uiCmd.Info as UIInfo_ComboBox;
int idx = uiInfo.Items.FindIndex(x => x.Equals(finalValue, StringComparison.OrdinalIgnoreCase));
if (idx == -1)
{ // Invalid Index
logs.Add(new LogInfo(LogState.Warning, $"[{finalValue}] not found in item list"));
return(logs);
}
uiInfo.Index = idx;
uiCmd.Text = uiInfo.Items[idx];
logs.Add(new LogInfo(LogState.Success, $"Interface [{varKey}] set to [{uiCmd.Text}]"));
match = true;
}
break;
case UIType.RadioButton:
{
Debug.Assert(uiCmd.Info.GetType() == typeof(UIInfo_RadioButton));
UIInfo_RadioButton uiInfo = uiCmd.Info as UIInfo_RadioButton;
if (finalValue.Equals("True", StringComparison.OrdinalIgnoreCase))
{
uiInfo.Selected = true;
logs.Add(new LogInfo(LogState.Success, $"Interface [{varKey}] set to true]"));
match = true;
}
else if (finalValue.Equals("False", StringComparison.OrdinalIgnoreCase))
{
uiInfo.Selected = false;
logs.Add(new LogInfo(LogState.Success, $"Interface [{varKey}] set to [False]"));
match = true;
}
else
{ // WB082 just write string value, but PEBakery will ignore and throw and warning
logs.Add(new LogInfo(LogState.Warning, $"[{finalValue}] is not valid boolean"));
return(logs);
}
}
break;
case UIType.FileBox:
{
Debug.Assert(uiCmd.Info.GetType() == typeof(UIInfo_FileBox));
UIInfo_FileBox uiInfo = uiCmd.Info as UIInfo_FileBox;
uiCmd.Text = finalValue;
logs.Add(new LogInfo(LogState.Success, $"Interface [{varKey}] set to [{finalValue}]"));
match = true;
}
break;
case UIType.RadioGroup:
{
Debug.Assert(uiCmd.Info.GetType() == typeof(UIInfo_RadioGroup));
UIInfo_RadioGroup uiInfo = uiCmd.Info as UIInfo_RadioGroup;
int idx = uiInfo.Items.FindIndex(x => x.Equals(finalValue, StringComparison.OrdinalIgnoreCase));
if (idx == -1)
{ // Invalid Index
logs.Add(new LogInfo(LogState.Warning, $"[{finalValue}] not found in item list"));
return(logs);
}
uiInfo.Selected = idx;
logs.Add(new LogInfo(LogState.Success, $"Interface [{varKey}] set to [{finalValue}]"));
match = true;
}
break;
}
if (match)
{
uiCmd.Update();
logs.AddRange(Variables.SetVariable(s, info.VarKey, info.VarValue, false, false));
return(logs);
}
else
{
goto case false;
}
#endregion
}
case false:
default:
return(Variables.SetVariable(s, info.VarKey, info.VarValue, info.Global, info.Permanent));
}
}
public static List <LogInfo> TXTDelLineOp(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_TXTDelLineOp));
CodeInfo_TXTDelLineOp infoOp = cmd.Info as CodeInfo_TXTDelLineOp;
string fileName = StringEscaper.Preprocess(s, infoOp.InfoList[0].FileName);
if (StringEscaper.PathSecurityCheck(fileName, out string errorMsg) == false)
{
logs.Add(new LogInfo(LogState.Error, errorMsg));
return(logs);
}
if (File.Exists(fileName) == false)
{
logs.Add(new LogInfo(LogState.Error, $"File [{fileName}] not exists"));
return(logs);
}
List <string> prepDeleteLine = new List <string>();
foreach (CodeInfo_TXTDelLine info in infoOp.InfoList)
{
string deleteLine = StringEscaper.Preprocess(s, info.DeleteLine);
prepDeleteLine.Add(deleteLine);
}
Encoding encoding = FileHelper.DetectTextEncoding(fileName);
int count = 0;
string tempPath = Path.GetTempFileName();
using (StreamReader reader = new StreamReader(fileName, encoding))
using (StreamWriter writer = new StreamWriter(tempPath, false, encoding))
{
string srcLine;
while ((srcLine = reader.ReadLine()) != null)
{
bool writeLine = true;
foreach (string deleteLine in prepDeleteLine)
{
// Strange enough, WB082 treat [deleteLine] as case sensitive string.
if (srcLine.StartsWith(deleteLine, StringComparison.Ordinal))
{
writeLine = false;
count++;
break;
}
}
if (writeLine)
{
writer.WriteLine(srcLine);
}
}
}
FileHelper.FileReplaceEx(tempPath, fileName);
logs.Add(new LogInfo(LogState.Success, $"Deleted [{count}] lines from [{fileName}]"));
return(logs);
}
public static void Loop(EngineState s, CodeCommand cmd)
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_Loop));
CodeInfo_Loop info = cmd.Info as CodeInfo_Loop;
if (info.Break)
{
if (s.LoopState == LoopState.Off)
{
s.Logger.Build_Write(s, new LogInfo(LogState.Error, "Loop is not running", cmd, s.CurDepth));
}
else
{
s.LoopState = LoopState.Off;
s.Logger.Build_Write(s, new LogInfo(LogState.Info, "Breaking loop", cmd, s.CurDepth));
// Reset LoopCounter, to be sure
s.LoopLetter = ' ';
s.LoopCounter = 0;
}
}
else if (s.LoopState != LoopState.Off)
{ // If loop is already turned on, throw error
s.Logger.Build_Write(s, new LogInfo(LogState.Error, "Nested loop is not supported", cmd, s.CurDepth));
}
else
{
string startStr = StringEscaper.Preprocess(s, info.StartIdx);
string endStr = StringEscaper.Preprocess(s, info.EndIdx);
// Prepare Loop
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>();
for (int i = 0; i < paramList.Count; i++)
{
paramDict[i + 1] = paramList[i];
}
long loopCount = 0;
long startIdx = 0, endIdx = 0;
char startLetter = ' ', endLetter = ' ';
switch (cmd.Type)
{
case CodeType.Loop:
{ // Integer Index
if (!NumberHelper.ParseInt64(startStr, out startIdx))
{
throw new ExecuteException($"Argument [{startStr}] is not a valid integer");
}
if (!NumberHelper.ParseInt64(endStr, out endIdx))
{
throw new ExecuteException($"Argument [{endStr}] is not a valid integer");
}
loopCount = endIdx - startIdx + 1;
}
break;
case CodeType.LoopLetter:
{ // Drive Letter
if (!(startStr.Length == 1 && StringHelper.IsAlphabet(startStr[0])))
{
throw new ExecuteException($"Argument [{startStr}] is not a valid drive letter");
}
if (!(endStr.Length == 1 && StringHelper.IsAlphabet(endStr[0])))
{
throw new ExecuteException($"Argument [{endStr}] is not a valid drive letter");
}
startLetter = char.ToUpper(startStr[0]);
endLetter = char.ToUpper(endStr[0]);
if (endLetter < startLetter)
{
throw new ExecuteException($"StartLetter must be smaller than EndLetter in lexicographic order");
}
loopCount = endLetter - startLetter + 1;
}
break;
default:
throw new InternalException("Internal Logic Error at CommandBranch.Loop");
}
// Log Messages
string logMessage;
if (inCurrentScript)
{
logMessage = $"Loop Section [{sectionName}] [{loopCount}] times";
}
else
{
logMessage = $"Loop [{p.Title}]'s Section [{sectionName}] [{loopCount}] times";
}
s.Logger.Build_Write(s, new LogInfo(LogState.Info, logMessage, cmd, s.CurDepth));
// Loop it
SectionAddress nextAddr = new SectionAddress(p, p.Sections[sectionName]);
int loopIdx = 1;
switch (cmd.Type)
{
case CodeType.Loop:
for (s.LoopCounter = startIdx; s.LoopCounter <= endIdx; s.LoopCounter++)
{ // Counter Variable is [#c]
s.Logger.Build_Write(s, new LogInfo(LogState.Info, $"Entering Loop with [{s.LoopCounter}] ({loopIdx}/{loopCount})", cmd, s.CurDepth));
s.Logger.LogSectionParameter(s, s.CurDepth, paramDict, cmd);
int depthBackup = s.CurDepth;
s.LoopState = LoopState.OnIndex;
Engine.RunSection(s, nextAddr, paramDict, s.CurDepth + 1, true);
if (s.LoopState == LoopState.Off) // Loop,Break
{
break;
}
s.LoopState = LoopState.Off;
s.CurDepth = depthBackup;
s.Logger.Build_Write(s, new LogInfo(LogState.Info, $"End of Loop with [{s.LoopCounter}] ({loopIdx}/{loopCount})", cmd, s.CurDepth));
loopIdx += 1;
}
break;
case CodeType.LoopLetter:
for (s.LoopLetter = startLetter; s.LoopLetter <= endLetter; s.LoopLetter++)
{ // Counter Variable is [#c]
s.Logger.Build_Write(s, new LogInfo(LogState.Info, $"Entering Loop with [{s.LoopLetter}] ({loopIdx}/{loopCount})", cmd, s.CurDepth));
s.Logger.LogSectionParameter(s, s.CurDepth, paramDict, cmd);
int depthBackup = s.CurDepth;
s.LoopState = LoopState.OnDriveLetter;
Engine.RunSection(s, nextAddr, paramDict, s.CurDepth + 1, true);
if (s.LoopState == LoopState.Off) // Loop,Break
{
break;
}
s.LoopState = LoopState.Off;
s.CurDepth = depthBackup;
s.Logger.Build_Write(s, new LogInfo(LogState.Info, $"End of Loop with [{s.LoopLetter}] ({loopIdx}/{loopCount})", cmd, s.CurDepth));
loopIdx += 1;
}
break;
default:
throw new InternalException("Internal Logic Error at CommandBranch.Loop");
}
// Reset LoopCounter, to be sure
s.LoopLetter = ' ';
s.LoopCounter = 0;
}
}
public static List <LogInfo> Math(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
CodeInfo_Math info = cmd.Info.Cast <CodeInfo_Math>();
MathType type = info.Type;
switch (type)
{
case MathType.Add:
case MathType.Sub:
case MathType.Mul:
case MathType.Div:
{
MathInfo_Arithmetic subInfo = info.SubInfo.Cast <MathInfo_Arithmetic>();
string srcStr1 = StringEscaper.Preprocess(s, subInfo.Src1);
string srcStr2 = StringEscaper.Preprocess(s, subInfo.Src2);
if (!NumberHelper.ParseDecimal(srcStr1, out decimal src1))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr1}] is not a valid integer"));
}
if (!NumberHelper.ParseDecimal(srcStr2, out decimal src2))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr2}] is not a valid integer"));
}
decimal destInt;
switch (type)
{
case MathType.Add:
destInt = src1 + src2;
break;
case MathType.Sub:
destInt = src1 - src2;
break;
case MathType.Mul:
destInt = src1 * src2;
break;
case MathType.Div:
destInt = src1 / src2;
break;
default:
throw new InternalException("Internal Logic Error at Math,Arithmetic");
}
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, destInt.ToString(CultureInfo.InvariantCulture)));
}
break;
case MathType.IntDiv:
{
MathInfo_IntDiv subInfo = info.SubInfo.Cast <MathInfo_IntDiv>();
string srcStr1 = StringEscaper.Preprocess(s, subInfo.Src1);
string srcStr2 = StringEscaper.Preprocess(s, subInfo.Src2);
if (srcStr1.StartsWith("-", StringComparison.Ordinal) ||
srcStr2.StartsWith("-", StringComparison.Ordinal))
{ // Signed
if (!NumberHelper.ParseInt64(srcStr1, out long src1))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr1}] is not a valid integer"));
}
if (!NumberHelper.ParseInt64(srcStr2, out long src2))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr2}] is not a valid integer"));
}
long q = src1 / src2;
long r = src1 % src2;
logs.AddRange(Variables.SetVariable(s, subInfo.QuotientVar, q.ToString()));
logs.AddRange(Variables.SetVariable(s, subInfo.RemainderVar, r.ToString()));
}
else
{ // Unsigned
if (!NumberHelper.ParseUInt64(srcStr1, out ulong src1))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr1}] is not a valid integer"));
}
if (!NumberHelper.ParseUInt64(srcStr2, out ulong src2))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr2}] is not a valid integer"));
}
ulong q = src1 / src2;
ulong r = src1 % src2;
logs.AddRange(Variables.SetVariable(s, subInfo.QuotientVar, q.ToString()));
logs.AddRange(Variables.SetVariable(s, subInfo.RemainderVar, r.ToString()));
}
}
break;
case MathType.Neg:
{
MathInfo_Neg subInfo = info.SubInfo.Cast <MathInfo_Neg>();
string srcStr = StringEscaper.Preprocess(s, subInfo.Src);
if (!NumberHelper.ParseDecimal(srcStr, out decimal src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
decimal destInt = src * -1;
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, destInt.ToString(CultureInfo.InvariantCulture)));
}
break;
case MathType.ToSign:
case MathType.ToUnsign:
{
// Math,IntSign,<DestVar>,<Src>,<BitSize>
// Math,IntUnsign,<DestVar>,<Src>,<BitSize>
MathInfo_IntegerSignedness subInfo = info.SubInfo.Cast <MathInfo_IntegerSignedness>();
string srcStr = StringEscaper.Preprocess(s, subInfo.Src);
string bitSizeStr = StringEscaper.Preprocess(s, subInfo.BitSize);
string errorMsg = ParseAndCheckBitSize(bitSizeStr, out int bitSize);
if (errorMsg != null)
{
return(LogInfo.LogErrorMessage(logs, errorMsg));
}
string destStr;
if (info.Type == MathType.ToSign)
{ // Unsigned int to signed int
switch (bitSize)
{
case 8:
{
if (!NumberHelper.ParseUInt8(srcStr, out byte src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((sbyte)src).ToString();
}
break;
case 16:
{
if (!NumberHelper.ParseUInt16(srcStr, out ushort src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((short)src).ToString();
}
break;
case 32:
{
if (!NumberHelper.ParseUInt32(srcStr, out uint src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((int)src).ToString();
}
break;
case 64:
{
if (!NumberHelper.ParseUInt64(srcStr, out ulong src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((long)src).ToString();
}
break;
default:
throw new InternalException("Internal Logic Error at Math,ToSign");
}
}
else
{ // Signed int to unsigned int
switch (bitSize)
{
case 8:
{
if (!NumberHelper.ParseInt8(srcStr, out sbyte src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((byte)src).ToString();
}
break;
case 16:
{
if (!NumberHelper.ParseInt16(srcStr, out short src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((ushort)src).ToString();
}
break;
case 32:
{
if (!NumberHelper.ParseInt32(srcStr, out int src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((uint)src).ToString();
}
break;
case 64:
{
if (!NumberHelper.ParseInt64(srcStr, out long src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((ulong)src).ToString();
}
break;
default:
throw new InternalException("Internal Logic Error at Math,ToUnsign");
}
}
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, destStr));
}
break;
case MathType.BoolAnd:
case MathType.BoolOr:
case MathType.BoolXor:
{
MathInfo_BoolLogicOperation subInfo = info.SubInfo.Cast <MathInfo_BoolLogicOperation>();
string srcStr1 = StringEscaper.Preprocess(s, subInfo.Src1);
string srcStr2 = StringEscaper.Preprocess(s, subInfo.Src2);
bool src1;
if (NumberHelper.ParseInt64(srcStr1, out long srcInt1)) // C-Style Boolean
{
src1 = srcInt1 != 0;
}
else if (srcStr1.Equals("True", StringComparison.OrdinalIgnoreCase))
{
src1 = true;
}
else if (srcStr1.Equals("False", StringComparison.OrdinalIgnoreCase))
{
src1 = false;
}
else
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr1}] is not valid boolean value"));
}
bool src2;
if (NumberHelper.ParseInt64(srcStr2, out long srcInt2)) // C-Style Boolean
{
src2 = srcInt2 != 0;
}
else if (srcStr2.Equals("True", StringComparison.OrdinalIgnoreCase))
{
src2 = true;
}
else if (srcStr2.Equals("False", StringComparison.OrdinalIgnoreCase))
{
src2 = false;
}
else
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr2}] is not valid boolean value"));
}
bool dest;
switch (type)
{
case MathType.BoolAnd:
dest = src1 && src2;
break;
case MathType.BoolOr:
dest = src1 || src2;
break;
case MathType.BoolXor:
dest = src1 ^ src2;
break;
default:
throw new InternalException("Internal Logic Error at Math,BoolLogicOper");
}
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, dest.ToString()));
}
break;
case MathType.BoolNot:
{
MathInfo_BoolNot subInfo = info.SubInfo.Cast <MathInfo_BoolNot>();
bool src;
string srcStr = StringEscaper.Preprocess(s, subInfo.Src);
if (NumberHelper.ParseInt64(srcStr, out long srcInt)) // C-Style Boolean
{
src = srcInt != 0;
}
else if (srcStr.Equals("True", StringComparison.OrdinalIgnoreCase))
{
src = true;
}
else if (srcStr.Equals("False", StringComparison.OrdinalIgnoreCase))
{
src = false;
}
else
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not valid boolean value"));
}
bool dest = !src;
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, dest.ToString()));
}
break;
case MathType.BitAnd:
case MathType.BitOr:
case MathType.BitXor:
{
MathInfo_BitLogicOperation subInfo = info.SubInfo.Cast <MathInfo_BitLogicOperation>();
string srcStr1 = StringEscaper.Preprocess(s, subInfo.Src1);
string srcStr2 = StringEscaper.Preprocess(s, subInfo.Src2);
if (!NumberHelper.ParseUInt64(srcStr1, out ulong src1))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr1}] is not a valid integer"));
}
if (!NumberHelper.ParseUInt64(srcStr2, out ulong src2))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr2}] is not a valid integer"));
}
ulong dest;
switch (type)
{
case MathType.BitAnd:
dest = src1 & src2;
break;
case MathType.BitOr:
dest = src1 | src2;
break;
case MathType.BitXor:
dest = src1 ^ src2;
break;
default:
throw new InternalException("Internal Logic Error at Math,BitLogicOper");
}
string destStr = dest.ToString();
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, destStr));
}
break;
case MathType.BitNot:
{
MathInfo_BitNot subInfo = info.SubInfo.Cast <MathInfo_BitNot>();
string srcStr = StringEscaper.Preprocess(s, subInfo.Src);
string bitSizeStr = StringEscaper.Preprocess(s, subInfo.BitSize);
string errorMsg = ParseAndCheckBitSize(bitSizeStr, out int bitSize);
if (errorMsg != null)
{
return(LogInfo.LogErrorMessage(logs, errorMsg));
}
string destStr;
switch (bitSize)
{
case 8:
{
if (!NumberHelper.ParseUInt8(srcStr, out byte src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((byte)~src).ToString();
}
break;
case 16:
{
if (!NumberHelper.ParseUInt16(srcStr, out ushort src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = ((ushort)~src).ToString();
}
break;
case 32:
{
if (!NumberHelper.ParseUInt32(srcStr, out uint src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = (~src).ToString();
}
break;
case 64:
{
if (!NumberHelper.ParseUInt64(srcStr, out ulong src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
destStr = (~src).ToString();
}
break;
default:
throw new InternalException("Internal Logic Error at Math,BitNot");
}
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, destStr));
}
break;
case MathType.BitShift:
{
MathInfo_BitShift subInfo = info.SubInfo.Cast <MathInfo_BitShift>();
string srcStr = StringEscaper.Preprocess(s, subInfo.Src);
string shiftStr = StringEscaper.Preprocess(s, subInfo.Shift);
if (!NumberHelper.ParseInt32(shiftStr, out int shift))
{
return(LogInfo.LogErrorMessage(logs, $"[{shiftStr}] is not a valid integer"));
}
string directionStr = StringEscaper.Preprocess(s, subInfo.Direction);
bool isLeft = false;
if (directionStr.Equals("Left", StringComparison.OrdinalIgnoreCase))
{
isLeft = true;
}
else if (!directionStr.Equals("Right", StringComparison.OrdinalIgnoreCase))
{
return(LogInfo.LogErrorMessage(logs, $"[{directionStr}] must be one of [Left, Right]"));
}
string bitSizeStr = StringEscaper.Preprocess(s, subInfo.BitSize);
string errorMsg = ParseAndCheckBitSize(bitSizeStr, out int bitSize);
if (errorMsg != null)
{
return(LogInfo.LogErrorMessage(logs, errorMsg));
}
string destStr;
switch (bitSize)
{
case 8:
{
if (!NumberHelper.ParseUInt8(srcStr, out byte src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
byte dest;
if (isLeft)
{
dest = (byte)(src << shift);
}
else
{
dest = (byte)(src >> shift);
}
destStr = dest.ToString();
}
break;
case 16:
{
if (!NumberHelper.ParseUInt16(srcStr, out ushort src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
ushort dest;
if (isLeft)
{
dest = (ushort)(src << shift);
}
else
{
dest = (ushort)(src >> shift);
}
destStr = dest.ToString();
}
break;
case 32:
{
if (!NumberHelper.ParseUInt32(srcStr, out uint src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
uint dest;
if (isLeft)
{
dest = src << shift;
}
else
{
dest = src >> shift;
}
destStr = dest.ToString();
}
break;
case 64:
{
if (!NumberHelper.ParseUInt64(srcStr, out ulong src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
ulong dest;
if (isLeft)
{
dest = src << shift;
}
else
{
dest = src >> shift;
}
destStr = dest.ToString();
}
break;
default:
throw new InternalException("Internal Logic Error at Math,BitShift");
}
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, destStr));
}
break;
case MathType.Ceil:
case MathType.Floor:
case MathType.Round:
{
MathInfo_CeilFloorRound subInfo = info.SubInfo.Cast <MathInfo_CeilFloorRound>();
string srcStr = StringEscaper.Preprocess(s, subInfo.Src);
if (!NumberHelper.ParseInt64(srcStr, out long srcInt))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
string unitStr = StringEscaper.Preprocess(s, subInfo.Unit);
// Is roundToStr number?
if (!NumberHelper.ParseInt64(unitStr, out long unit))
{
return(LogInfo.LogErrorMessage(logs, $"[{unitStr}] is not a valid integer"));
}
if (unit < 0)
{
return(LogInfo.LogErrorMessage(logs, $"[{unit}] must be positive integer"));
}
long destInt;
long remainder = srcInt % unit;
switch (type)
{
case MathType.Ceil:
destInt = srcInt - remainder + unit;
break;
case MathType.Floor:
destInt = srcInt - remainder;
break;
case MathType.Round:
if ((unit - 1) / 2 < remainder)
{
destInt = srcInt - remainder + unit;
}
else
{
destInt = srcInt - remainder;
}
break;
default:
throw new InternalException($"Internal Logic Error at Math,{info.Type}");
}
List <LogInfo> varLogs = Variables.SetVariable(s, subInfo.DestVar, destInt.ToString());
logs.AddRange(varLogs);
}
break;
case MathType.Abs:
{
MathInfo_Abs subInfo = info.SubInfo.Cast <MathInfo_Abs>();
string srcStr = StringEscaper.Preprocess(s, subInfo.Src);
if (!NumberHelper.ParseDecimal(srcStr, out decimal src))
{
return(LogInfo.LogErrorMessage(logs, $"[{srcStr}] is not a valid integer"));
}
decimal dest = System.Math.Abs(src);
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, dest.ToString(CultureInfo.InvariantCulture)));
}
break;
case MathType.Pow:
{
MathInfo_Pow subInfo = info.SubInfo.Cast <MathInfo_Pow>();
string baseStr = StringEscaper.Preprocess(s, subInfo.Base);
if (!NumberHelper.ParseDecimal(baseStr, out decimal _base))
{
return(LogInfo.LogErrorMessage(logs, $"[{baseStr}] is not a valid integer"));
}
string powerStr = StringEscaper.Preprocess(s, subInfo.Power);
if (!NumberHelper.ParseUInt32(powerStr, out uint power))
{
return(LogInfo.LogErrorMessage(logs, $"[{baseStr}] is not a postivie integer"));
}
decimal dest = NumberHelper.DecimalPower(_base, power);
logs.AddRange(Variables.SetVariable(s, subInfo.DestVar, dest.ToString(CultureInfo.InvariantCulture)));
}
break;
case MathType.Hex:
case MathType.Dec:
{
MathInfo_HexDec subInfo = info.SubInfo.Cast <MathInfo_HexDec>();
string intStr = StringEscaper.Preprocess(s, subInfo.Src);
string bitSizeStr = StringEscaper.Preprocess(s, subInfo.BitSize);
string errorMsg = ParseAndCheckBitSize(bitSizeStr, out int bitSize);
if (errorMsg != null)
{
return(LogInfo.LogErrorMessage(logs, errorMsg));
}
string dest;
switch (bitSize)
{
case 8:
if (!NumberHelper.ParseSignedAsUInt8(intStr, out byte u8))
{
return(LogInfo.LogErrorMessage(logs, $"[{intStr}] is not a valid 8bit integer"));
}
dest = info.Type == MathType.Hex ? $"0x{u8:X2}" : u8.ToString();
break;
case 16:
if (!NumberHelper.ParseSignedAsUInt16(intStr, out ushort u16))
{
return(LogInfo.LogErrorMessage(logs, $"[{intStr}] is not a valid 16bit integer"));
}
dest = info.Type == MathType.Hex ? $"0x{u16:X4}" : u16.ToString();
break;
case 32:
if (!NumberHelper.ParseSignedAsUInt32(intStr, out uint u32))
{
return(LogInfo.LogErrorMessage(logs, $"[{intStr}] is not a valid 32bit integer"));
}
dest = info.Type == MathType.Hex ? $"0x{u32:X8}" : u32.ToString();
break;
case 64:
if (!NumberHelper.ParseSignedAsUInt64(intStr, out ulong u64))
{
return(LogInfo.LogErrorMessage(logs, $"[{intStr}] is not a valid 64bit integer"));
}
dest = info.Type == MathType.Hex ? $"0x{u64:X16}" : u64.ToString();
break;
default:
throw new InternalException($"Internal Logic Error at Math,{info.Type}");
}
List <LogInfo> varLogs = Variables.SetVariable(s, subInfo.DestVar, dest);
logs.AddRange(varLogs);
}
break;
case MathType.Rand:
{
MathInfo_Rand subInfo = info.SubInfo.Cast <MathInfo_Rand>();
int min = 0;
if (subInfo.Min != null)
{
string minStr = StringEscaper.Preprocess(s, subInfo.Min);
if (!NumberHelper.ParseInt32(minStr, out min))
{
return(LogInfo.LogErrorMessage(logs, $"[{minStr}] is not a valid integer"));
}
if (min < 0)
{
return(LogInfo.LogErrorMessage(logs, $"[{min}] must be positive integer"));
}
}
int max = 65536;
if (subInfo.Max != null)
{
string maxStr = StringEscaper.Preprocess(s, subInfo.Max);
if (!NumberHelper.ParseInt32(maxStr, out max))
{
return(LogInfo.LogErrorMessage(logs, $"[{maxStr}] is not a valid integer"));
}
if (max < 0)
{
return(LogInfo.LogErrorMessage(logs, $"[{max}] must be positive integer"));
}
if (max <= min)
{
return(LogInfo.LogErrorMessage(logs, "Maximum bounds must be larger than minimum value"));
}
}
int destInt = s.Random.Next() % (max - min) + min;
List <LogInfo> varLogs = Variables.SetVariable(s, subInfo.DestVar, destInt.ToString());
logs.AddRange(varLogs);
}
break;
default: // Error
throw new InternalException("Internal Logic Error at CommandMath.Math");
}
return(logs);
}
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);
}
public static List <LogInfo> Expand(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
CodeInfo_Expand info = cmd.Info.Cast <CodeInfo_Expand>();
List <string> extractedFiles = new List <string>();
#region Event Handlers
void ReportExpandProgress(object sender, ProgressEventArgs e)
{
s.MainViewModel.BuildCommandProgressValue = e.PercentDone;
s.MainViewModel.BuildCommandProgressText = $"Expanding... ({e.PercentDone}%)";
}
object trackLock = new object();
void TrackExtractedFile(object sender, FileInfoEventArgs e)
{
lock (trackLock)
extractedFiles.Add(e.FileInfo.FileName);
}
#endregion
string srcCab = StringEscaper.Preprocess(s, info.SrcCab);
string destDir = StringEscaper.Preprocess(s, info.DestDir);
string singleFile = null;
if (info.SingleFile != null)
{
singleFile = StringEscaper.Preprocess(s, info.SingleFile);
}
// Path Security Check
if (!StringEscaper.PathSecurityCheck(destDir, out string errorMsg))
{
return(LogInfo.LogErrorMessage(logs, errorMsg));
}
if (!Directory.Exists(destDir))
{
if (File.Exists(destDir))
{
return(LogInfo.LogErrorMessage(logs, $"Path [{destDir}] is a file, not a directory"));
}
Directory.CreateDirectory(destDir);
}
// Does srcCab exist?
if (!File.Exists(srcCab))
{
return(LogInfo.LogErrorMessage(logs, $"Cannot find [{srcCab}]"));
}
// Turn on report progress only if file is larger than 1MB
FileInfo fi = new FileInfo(srcCab);
bool reportProgress = 1024 * 1024 <= fi.Length;
if (singleFile == null)
{ // No singleFile operand, extract all
using (SevenZipExtractor extractor = new SevenZipExtractor(srcCab))
{
if (extractor.Format != InArchiveFormat.Cab)
{
return(LogInfo.LogErrorMessage(logs, "Expand command must be used with cabinet archive"));
}
if (reportProgress)
{
extractor.FileExtractionFinished += TrackExtractedFile;
extractor.Extracting += ReportExpandProgress;
s.MainViewModel.SetBuildCommandProgress("Expand Progress");
}
try
{
extractor.ExtractArchive(destDir);
foreach (string file in extractedFiles)
{
logs.Add(new LogInfo(LogState.Success, $"[{file}] extracted"));
}
logs.Add(new LogInfo(LogState.Success, $"[{extractedFiles.Count}] files from [{srcCab}] extracted to [{destDir}]"));
}
finally
{
if (reportProgress)
{
extractor.FileExtractionFinished -= TrackExtractedFile;
extractor.Extracting -= ReportExpandProgress;
s.MainViewModel.ResetBuildCommandProgress();
}
}
}
}
else
{ // singleFile specified, extract only that file
string destPath = Path.Combine(destDir, singleFile);
if (File.Exists(destPath))
{ // Check PRESERVE, NOWARN
if (info.Preserve)
{ // Do nothing
logs.Add(new LogInfo(info.NoWarn ? LogState.Ignore : LogState.Overwrite, $"[{destPath}] already exists, skipping extract from [{srcCab}]"));
return(logs);
}
logs.Add(new LogInfo(info.NoWarn ? LogState.Ignore : LogState.Overwrite, $"[{destPath}] will be overwritten"));
}
using (SevenZipExtractor extractor = new SevenZipExtractor(srcCab))
{
if (extractor.Format != InArchiveFormat.Cab)
{
return(LogInfo.LogErrorMessage(logs, "Expand command must be used with cabinet archive"));
}
if (reportProgress)
{
extractor.Extracting += ReportExpandProgress;
s.MainViewModel.SetBuildCommandProgress("Expand Progress");
}
string[] archiveFileNames = extractor.ArchiveFileNames.ToArray();
if (archiveFileNames.Contains(singleFile, StringComparer.OrdinalIgnoreCase))
{
try
{
string destFile = Path.Combine(destDir, singleFile);
using (FileStream fs = new FileStream(destFile, FileMode.Create))
{
extractor.ExtractFile(singleFile, fs);
}
logs.Add(new LogInfo(LogState.Success, $"[{singleFile}] from [{srcCab}] extracted to [{destPath}]"));
}
finally
{
if (reportProgress)
{
extractor.Extracting -= ReportExpandProgress;
s.MainViewModel.ResetBuildCommandProgress();
}
}
}
else
{ // Unable to find specified file
logs.Add(new LogInfo(LogState.Error, $"Failed to extract [{singleFile}] from [{srcCab}]"));
}
}
}
return(logs);
}
static IEnumerable <IMemberRef> GetMemberRefs(IMenuItemContext context) => CodeCommand.GetMemberRefs(context, MenuConstants.GUIDOBJ_SEARCH_GUID);
public static List <LogInfo> Compress(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
CodeInfo_Compress info = cmd.Info.Cast <CodeInfo_Compress>();
#region Event Handlers
void ReportCompressProgress(object sender, ProgressEventArgs e)
{
s.MainViewModel.BuildCommandProgressValue = e.PercentDone;
s.MainViewModel.BuildCommandProgressText = $"Compressing... ({e.PercentDone}%)";
}
#endregion
// Parse arguments / parameters
string srcPath = StringEscaper.Preprocess(s, info.SrcPath);
string destArchive = StringEscaper.Preprocess(s, info.DestArchive);
SevenZip.OutArchiveFormat outFormat = ArchiveFile.ToSevenZipOutFormat(info.Format);
SevenZip.CompressionLevel compLevel = SevenZip.CompressionLevel.Normal;
if (info.CompressLevel is ArchiveFile.CompressLevel level)
{
try
{
compLevel = ArchiveFile.ToSevenZipLevel(level);
}
catch (ArgumentException)
{ // Should have been filtered by CodeParser
logs.Add(new LogInfo(LogState.CriticalError, $"Invalid ArchiveHelper.CompressLevel [{info.CompressLevel}]"));
return(logs);
}
}
// Path Security Check
if (!StringEscaper.PathSecurityCheck(destArchive, out string errorMsg))
{
return(LogInfo.LogErrorMessage(logs, errorMsg));
}
// Check if a file or directory exist under name of destArchive
bool appendMode = false;
if (Directory.Exists(destArchive))
{
return(LogInfo.LogErrorMessage(logs, $"[{destArchive}] should be a file, not a directory"));
}
if (File.Exists(destArchive))
{
logs.Add(new LogInfo(LogState.Overwrite, $"Archive [{destArchive}] will be appended"));
appendMode = true;
}
// If parent directory of destArchive does not exist, create it
Directory.CreateDirectory(FileHelper.GetDirNameEx(destArchive));
// Prepare SevenZipSharp compressor
SevenZipCompressor compressor = new SevenZipCompressor
{
ArchiveFormat = outFormat,
CompressionMode = appendMode ? CompressionMode.Append : CompressionMode.Create,
CompressionLevel = compLevel,
};
// Set filename encoding to UTF-8
// 7z files always use Unicode filename, so no action is required.
switch (outFormat)
{
case OutArchiveFormat.Zip:
compressor.CustomParameters["cu"] = "on"; // Force UTF-8 for filename
break;
}
string wildcard = Path.GetFileName(srcPath);
if (!StringHelper.IsWildcard(wildcard))
{ // No wildcard
if (File.Exists(srcPath))
{
// Compressor Options
compressor.DirectoryStructure = false;
// Compressor Callbacks
compressor.Compressing += ReportCompressProgress;
s.MainViewModel.SetBuildCommandProgress("Compress Progress");
try
{
compressor.CompressFiles(destArchive, srcPath);
}
finally
{
compressor.Compressing -= ReportCompressProgress;
s.MainViewModel.ResetBuildCommandProgress();
}
}
else if (Directory.Exists(srcPath))
{
// Compressor Options
compressor.DirectoryStructure = true;
compressor.PreserveDirectoryRoot = true;
compressor.IncludeEmptyDirectories = true;
// Compressor Callbacks
compressor.Compressing += ReportCompressProgress;
s.MainViewModel.SetBuildCommandProgress("Compress Progress");
try
{
compressor.CompressDirectory(srcPath, destArchive);
}
finally
{
compressor.Compressing -= ReportCompressProgress;
s.MainViewModel.ResetBuildCommandProgress();
}
}
else
{
return(LogInfo.LogErrorMessage(logs, $"Cannot find [{srcPath}]"));
}
if (File.Exists(destArchive))
{
logs.Add(new LogInfo(LogState.Success, $"[{srcPath}] compressed to [{destArchive}]"));
}
else
{
logs.Add(new LogInfo(LogState.Error, $"Compressing to [{srcPath}] failed"));
}
}
else
{ // With wildcard
string srcDirToFind = Path.GetDirectoryName(srcPath);
string[] files = FileHelper.GetFilesEx(srcDirToFind, wildcard, SearchOption.AllDirectories);
// Compressor Options
compressor.DirectoryStructure = true;
compressor.PreserveDirectoryRoot = true;
compressor.IncludeEmptyDirectories = true;
// Compressor Callbacks
compressor.Compressing += ReportCompressProgress;
s.MainViewModel.SetBuildCommandProgress("Compress Progress");
try
{
compressor.CompressFiles(destArchive, files);
foreach (string f in files)
{
logs.Add(new LogInfo(LogState.Success, $"Compressed [{f}]"));
}
}
finally
{
compressor.Compressing -= ReportCompressProgress;
s.MainViewModel.ResetBuildCommandProgress();
}
if (File.Exists(destArchive))
{
logs.Add(new LogInfo(LogState.Success, $"[{files.Length}] files compressed to [{destArchive}]"));
}
else
{
logs.Add(new LogInfo(LogState.Error, $"Compressing to [{srcPath}] failed"));
}
}
return(logs);
}
