class Utility

{

public delegate TargetType MapCallBk<Type, TargetType>(Type element);

public static TargetType[] map<Type, TargetType>(IEnumerable<Type> iterator, MapCallBk<Type, TargetType> callBk)

{

List<TargetType> res = new(16);

foreach (var item in iterator)

{

res.Add(callBk(item));

}

return res.ToArray();

}

public static T getJsonVal<T>(JObject jobj, string key, T defVal)

{

if (!jobj.ContainsKey(key)) return defVal;

return jobj[key].Value<T>();

}

public static T[] getJsonArray<T>(JObject jobj, string key, T[] defVal = null) where T : class

{

if (!jobj.ContainsKey(key)) return defVal;

return jobj[key].Values<T>().ToArray();

}

public static string toUnixPath(string path)

{

return path.Replace('\\', '/');

}

public static string toLocalPath(string path, string pathSep = null)

{

pathSep = pathSep ?? Path.DirectorySeparatorChar.ToString();

if (pathSep == "\\")

return path.Replace("/", pathSep);

else

return path.Replace("\\", pathSep);

}

public static string formatPath(string path_)

{

List<string> pList = new(256);

// delete '.'

{

string[] partList = toUnixPath(path_).Split('/');

foreach (var str in partList)

{

if (str != ".") pList.Add(str);

}

}

return string.Join(Path.DirectorySeparatorChar.ToString(), pList);

}

public static bool isAbsolutePath(string path)

{

return Path.IsPathRooted(path);

}

/// <summary>

/// 相对路径转换

/// </summary>

/// <param name="root_"></param>

/// <param name="targetPath_"></param>

/// <param name="useUnixPath"></param>

/// <returns>返回相对路径，比如：abc\def。如果失败则返回null</returns>

public static string toRelativePath(string root_, string targetPath_, bool useUnixPath = false)

{

string DIR_SEP = (useUnixPath ? '/' : Path.DirectorySeparatorChar).ToString();

// check null or empty

if (String.IsNullOrWhiteSpace(root_) ||

String.IsNullOrWhiteSpace(targetPath_)) return null;

string root = formatPath(root_);

string targetPath = formatPath(targetPath_);

// must be abs path

if (Path.IsPathRooted(root) == false ||

Path.IsPathRooted(targetPath) == false) return null;

// split path to list

string[] rootList = Utility.toUnixPath(root).Trim('/').Split('/');

string[] targetList = Utility.toUnixPath(targetPath).Trim('/').Split('/');

// find common prefix

int minLen = Math.Min(rootList.Length, targetList.Length);

int comLen = 0; // common prefix len

for (; comLen < minLen; comLen++)

{

if (rootList[comLen] != targetList[comLen])

break;

}

// no any common prefix, not have relative path

if (comLen == 0) return null;

// ---

List<string> rePath = new(256);

// push parent path '..'

for (int i = 0; i < rootList.Length - comLen; i++)

rePath.Add("..");

// push base path

for (int i = comLen; i < targetList.Length; i++)

rePath.Add(targetList[i]);

return String.Join(DIR_SEP, rePath);

}

// convert JObject to 'string' or 'IEnumerable<string>'

public static object getJObjectVal(JToken jobj)

{

object paramsValue;

switch (jobj.Type)

{

case JTokenType.String:

paramsValue = jobj.Value<string>();

break;

case JTokenType.Boolean:

paramsValue = jobj.Value<bool>() ? "true" : "false";

break;

case JTokenType.Integer:

case JTokenType.Float:

paramsValue = jobj.Value<object>().ToString();

break;

case JTokenType.Array:

paramsValue = jobj.Values<string>();

break;

default:

paramsValue = null;

break;

}

return paramsValue;

}

}

class OsInfo

{

private static OsInfo _instance = null;

public string OsType { get; }

public string CRLF { get; }

public int SysCmdLenLimit { get; }

private OsInfo()

{

if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))

{

OsType = "win32";

}

else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))

{

OsType = "linux";

}

else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))

{

OsType = "osx";

}

else

{

OsType = "freebsd";

}

CRLF = OsType == "win32" ? "\r\n" : "\n";

// 注意：SysCmdLenLimit 只是一个保守估计值，不需要太精确

// 一旦参数过长，我们应该优先考虑使用文件传输，而不是命令行

if (OsType == "win32")

SysCmdLenLimit = 16 * 1024;

else

SysCmdLenLimit = 32 * 1024;

}

public static OsInfo instance()

{

if (_instance == null)

_instance = new OsInfo();

return _instance;

}

}

class RuntimeEncoding

{

public int CurrentCodePage { get; }

public Encoding Default { get; } // 用于本地打印输出的默认字符集（ANSI）

public Encoding UTF8 { get; }

public Encoding UTF16 { get; }

public Encoding UTF16BE { get; }

public Encoding UTF32BE { get; }

private static RuntimeEncoding _instance = null;

[DllImport("kernel32.dll", SetLastError = true)]

static extern int GetACP();

private RuntimeEncoding()

{

Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

UTF8 = new UTF8Encoding(false);

UTF16 = Encoding.Unicode;

UTF16BE = new UnicodeEncoding(true, false);

UTF32BE = new UTF32Encoding(true, false);

// init system default encoding

CurrentCodePage = OsInfo.instance().OsType == "win32" ? GetACP() : Encoding.Default.CodePage;

Encoding sysDefEncoding = Encoding.GetEncoding(CurrentCodePage);

if (CurrentCodePage == 65001) sysDefEncoding = UTF8; // no bom-header

Default = sysDefEncoding;

}

public static RuntimeEncoding instance()

{

if (_instance == null)

_instance = new RuntimeEncoding();

return _instance;

}

}

class CmdGenerator

{

public struct GeneratorOption

{

public string bindirEnvName;

public string bindirAbsPath;

public string outpath;

public string cwd;

public bool testMode;

public string compiler_prefix;

public Dictionary<string, string> srcParams;

};

public class CmdInfo

{

public string exePath; // [required] executable file full path

public string commandLine; // [required] 传递给 exePath 的命令行。取值根据编译器的命令行模式而有所不同

// 当编译器从命令行读取参数时，该值与sourceArgs相同，

// 当编译器从文件中读取参数时，该值为编译器要求的格式，比如：--Via <filepath> ...

public string sourcePath; // [required] 对于编译器来说，值为源文件的绝对路径; 对于链接器来说，该值无意义，暂时用作存放map文件的路径

public string sourceArgs; // [required] c/c++/asm 源文件的完整编译参数。

public string sourceType; // [required] 源文件类型，取值：'c', 'cpp', 'asm', or 'other'

public string outPath; // [required] 输出文件的完整路径（绝对路径）

public Encoding outputEncoding; // [required] 命令行的字符集编码：UTF8/GBK/...

public bool sourceArgsChanged; // [required] 指示自从上次编译后编译参数是否改变，用于确定是否需要重新编译

public string baseArgs; // [optional] 基础的编译参数，不含有 -o，-MMD 等带有输出文件路径的参数

public string compilerId; // [optional] 编译器id（小写），比如：'gcc', 'sdcc'

public string compilerModel; // [optional] 编译器的类型名字，比如：'c', 'cpp', 'c/cpp', 'asm', 'asm-clang', 'linker' ...

public string title; // [optional] a title for this command

public string shellCommand; // [optional] shell command which will be invoke compiler, used to gen 'compile_commands.json'

public string[] outputs = null; // [optional] if output more than one files, use this field

public string sdcc_bundleLibArgs; // [specific] just for SDCC compiler

};

public class LinkerExCmdInfo : CmdInfo

{

public string type;

};

class TypeErrorException : Exception

{

public TypeErrorException(string msg) : base(msg)

{

}

};

public delegate void CmdVisitor(string key, string cmdLine);

class CmdFormat

{

public string prefix = "";

public string body = null;

public string body_noval = null; // 适用于宏定义没有值的情况下，指定格式字符串

public string suffix = "";

public string sep = " ";

public bool noQuotes = false;

};

class InvokeFormat

{

public bool useFile = false;

public string body = "${value}";

};

public static readonly string optionKey = "options";

public static readonly string[] formatKeyList = {

"$includes", "$defines", "$libs"

};

private readonly Dictionary<string, Encoding> encodings = new(8);

private readonly Dictionary<string, string[]> baseOpts = new(512); // base compiler options

private readonly Dictionary<string, string[]> userOpts = new(512); // user compiler options

private readonly Dictionary<string, JObject> paramObj = new(8);

private readonly Dictionary<string, JObject> models = new(8);

private readonly Dictionary<string, Dictionary<string, CmdFormat>> formats = new(16);

private readonly Dictionary<string, InvokeFormat> invokeFormats = new(16);

private readonly string toolPrefix; // compiler prefix, like: arm-none-eabi-

private readonly string toolId; // compiler ID

private readonly bool useUnixPath; // whether use unix path in compiler options

private readonly string outDir; // output root folder

private readonly string binDir; // compiler root folder (with tail '/'), default: '%TOOL_DIR%/'

private readonly string cwd; // project root folder

private readonly string compilerAttr_commandPrefix; // the compiler options prefix

private readonly string compilerAttr_directorySeparator; // the path-sep for compiler options

private readonly JObject model; // compiler model obj

private readonly JObject parameters; // builder.params obj

public string compilerName { get; } // complier short name

public string compilerVersion { get; } // compiler version string, like: '5.06 update 6 (build 750)'

public string compilerFullName { get; } // compiler full name (contain version string)

private readonly Dictionary<string, int> objNameMap = new(512);

private readonly Dictionary<string, string> srcParams = new(512);

public string asmCompilerName; // asm compiler type we used

public CmdGenerator(JObject cModel, JObject cParams, GeneratorOption option)

{

model = cModel;

parameters = cParams;

outDir = option.outpath;

// 注意：为什么不将变量 %TOOL_DIR% 替换为实际的值？历史原因，某些情况下使用cmd执行命令，使用环境变量可以避免路径超出长度

binDir = option.bindirEnvName != null ? (option.bindirEnvName + Path.DirectorySeparatorChar) : "";

cwd = option.cwd;

compilerAttr_commandPrefix = option.compiler_prefix;

srcParams = option.srcParams;

toolId = cModel["id"].Value<string>();

useUnixPath = cModel.ContainsKey("useUnixPath") ? cModel["useUnixPath"].Value<bool>() : false;

compilerAttr_directorySeparator = useUnixPath ? "/" : Path.DirectorySeparatorChar.ToString();

// init compiler params

JObject compileOptions = (JObject)cParams[optionKey];

paramObj.Add("global", compileOptions.ContainsKey("global") ? (JObject)compileOptions["global"] : new JObject());

paramObj.Add("c", compileOptions.ContainsKey("c/cpp-compiler") ? (JObject)compileOptions["c/cpp-compiler"] : new JObject());

paramObj.Add("cpp", compileOptions.ContainsKey("c/cpp-compiler") ? (JObject)compileOptions["c/cpp-compiler"] : new JObject());

paramObj.Add("asm", compileOptions.ContainsKey("asm-compiler") ? (JObject)compileOptions["asm-compiler"] : new JObject());

paramObj.Add("linker", compileOptions.ContainsKey("linker") ? (JObject)compileOptions["linker"] : new JObject());

// init compiler models

string cCompilerName = ((JObject)cModel["groups"]).ContainsKey("c/cpp") ? "c/cpp" : "c";

string cppCompilerName = ((JObject)cModel["groups"]).ContainsKey("c/cpp") ? "c/cpp" : "cpp";

string linkerName = getUserSpecifiedModelName("linker");

if (!((JObject)cModel["groups"]).ContainsKey(cCompilerName))

throw new Exception("Not found c compiler model");

if (!((JObject)cModel["groups"]).ContainsKey(cppCompilerName))

throw new Exception("Not found cpp compiler model");

if (!((JObject)cModel["groups"]).ContainsKey(linkerName))

throw new Exception("Invalid '$use' option, please check compile option 'linker.$use'");

models.Add("c", (JObject)cModel["groups"][cCompilerName]);

models.Add("cpp", (JObject)cModel["groups"][cppCompilerName]);

models.Add("linker", (JObject)cModel["groups"][linkerName]);

// init asm compiler models and params

asmCompilerName = getUserSpecifiedModelName("asm");

if (asmCompilerName == "asm-auto")

{

models.Add("asm", (JObject)cModel["groups"]["asm"]);

foreach (var item in (JObject)cModel["groups"])

{

if (item.Key.StartsWith("asm-"))

{

models.Add(item.Key, (JObject)cModel["groups"][item.Key]);

paramObj.Add(item.Key, paramObj["asm"]);

}

}

}

else

{

if (!((JObject)cModel["groups"]).ContainsKey(asmCompilerName))

throw new Exception("Invalid '$use' option, please check compile option 'asm-compiler.$use'");

models.Add("asm", (JObject)cModel["groups"][asmCompilerName]);

}

// init command line from model

JObject globalParams = paramObj["global"];

// set tool path prefix

{

if (globalParams.ContainsKey("toolPrefix"))

{

toolPrefix = globalParams["toolPrefix"].Value<string>();

}

else if (cModel.ContainsKey("toolPrefix"))

{

toolPrefix = cModel["toolPrefix"].Value<string>();

}

else

{

toolPrefix = "";

}

}

// set executable suffix

{

JObject linkerParams = paramObj["linker"];

if (linkerParams.ContainsKey("elf-suffix"))

{

models["linker"]["$outputSuffix"] = linkerParams["elf-suffix"].Value<string>();

}

}

// replace tool prefix

foreach (var key in models.Keys)

{

string oldName = models[key]["$path"].Value<string>();

models[key]["$path"] = oldName.Replace("${toolPrefix}", toolPrefix);

}

// replace tool name

foreach (var key in models.Keys)

{

if (paramObj[key].ContainsKey("$toolName"))

{

string tName = paramObj[key]["$toolName"].Value<string>();

string oldName = models[key]["$path"].Value<string>();

models[key]["$path"] = oldName.Replace("${toolName}", tName);

}

else if (models[key].ContainsKey("$defToolName"))

{

string tName = models[key]["$defToolName"].Value<string>();

string oldName = models[key]["$path"].Value<string>();

models[key]["$path"] = oldName.Replace("${toolName}", tName);

}

}

// set object suffix

if (paramObj["linker"].ContainsKey("$objectSuffix"))

{

string objSuffix = paramObj["linker"]["$objectSuffix"].Value<string>().Trim();

if (!string.IsNullOrEmpty(objSuffix))

{

string[] baseList = { "c", "cpp", "asm" };

foreach (var key in baseList)

{

if (models[key].ContainsKey("$outputSuffix"))

models[key]["$outputSuffix"] = objSuffix;

}

foreach (var key in models.Keys)

{

if (key.StartsWith("asm-"))

{

if (models[key].ContainsKey("$outputSuffix"))

models[key]["$outputSuffix"] = objSuffix;

}

}

}

}

// try to get compiler fullname and version

{

// init default value

compilerName = getModelName();

compilerVersion = string.Empty;

compilerFullName = compilerName;

// parse from compiler

try

{

string exePath = option.bindirAbsPath + Path.DirectorySeparatorChar + getActivedRawToolPath("c");

JObject vMatcher = this.getToolchainVersionMatcher();

if (vMatcher != null)

{

var matcher = new Regex(vMatcher["matcher"].Value<string>(), RegexOptions.IgnoreCase);

int eCode = Program.runExe(exePath, vMatcher["args"].Value<string>(), out string output);

// ignore exit code for keil_c51 compiler

if (getCompilerId() == "KEIL_C51" ||

getCompilerId() == "COSMIC_STM8")

{

eCode = Program.CODE_DONE;

}

if (eCode == Program.CODE_DONE && !String.IsNullOrWhiteSpace(output))

{

string[] lines = Program.CRLFMatcher.Split(output);

foreach (var line in lines)

{

var res = matcher.Match(line);

if (res.Success && res.Groups.Count > 0)

{

if (res.Groups["name"] != null)

{

compilerName = res.Groups["name"].Value;

}

if (res.Groups["version"] != null)

{

compilerVersion = res.Groups["version"].Value;

}

// full name is the full matched txt

compilerFullName = line.Trim();

break; // found it, exit

}

}

}

}

}

catch (Exception)

{

// nothing todo

}

// if compiler name is empty, use default name

if (string.IsNullOrWhiteSpace(compilerName))

{

compilerName = getModelName();

}

}

// init params for other spec compiler

{

if (toolId == "SDCC")

{

//TODO

}

}

// set encodings

foreach (string modelName in models.Keys)

{

if (models[modelName].ContainsKey("$encoding"))

{

string codeName = models[modelName]["$encoding"].Value<string>();

switch (codeName)

{

case "UTF8":

encodings.Add(modelName, RuntimeEncoding.instance().UTF8);

break;

default:

encodings.Add(modelName, getEncoding(codeName));

break;

}

}

else

{

// force set encoding for gcc 1x.x

/*if (getModelID().Contains("GCC") &&

{

encodings.Add(modelName, RuntimeEncoding.instance().Default);

}

}

}

// set include, define commands format

foreach (string modelName in models.Keys)

{

JObject modelParams = models[modelName];

Dictionary<string, CmdFormat> properties = new(32);

foreach (string key in formatKeyList)

{

if (modelParams.ContainsKey(key))

{

properties.Add(key, modelParams[key].ToObject<CmdFormat>());

}

}

formats.Add(modelName, properties);

// invoker mode

InvokeFormat invokeFormat;

if (modelParams.ContainsKey("$invoke"))

invokeFormat = modelParams["$invoke"].ToObject<InvokeFormat>();

else

invokeFormat = new InvokeFormat();

if (option.testMode) invokeFormat.useFile = false;

invokeFormats.Add(modelName, invokeFormat);

}

// set outName to unique

getUniqueName(getOutName());

// set stable compiler options

foreach (var model in models)

{

string name = model.Key;

JObject cmpModel = model.Value;

JObject[] cmpParams = {

globalParams,

paramObj[name]

};

var baseOptLi = new List<string>(64);

var userOptLi = new List<string>(256);

// set default options

if (cmpModel.ContainsKey("$default"))

{

foreach (var ele in ((JArray)cmpModel["$default"]).Values<string>())

baseOptLi.Add(ele);

}

// set include path and defines for c/c++/asm compiler

if (name != "linker")

{

// include list

var incOpts = getIncludesCmdLine(name, ((JArray)cParams["incDirs"]).Values<string>());

if (!string.IsNullOrEmpty(incOpts)) userOptLi.Add(incOpts);

// macro list

var defOpts = getdefinesCmdLine(name, ((JArray)cParams["defines"]).Values<string>());

if (!string.IsNullOrEmpty(defOpts)) userOptLi.Add(defOpts);

}

// set lib search folders for linker

else

{

string command = getLibSearchFolders(name, ((JArray)cParams["libDirs"]).Values<string>());

if (!string.IsNullOrEmpty(command))

{

baseOptLi.Add(command);

}

}

// merge user compiler options

foreach (var ele in cmpModel)

{

// skip built-in args

if (ele.Key[0] == '$') continue;

try

{

object paramsValue = mergeParamsList(cmpParams, ele.Key, ele.Value["type"].Value<string>());

string cmd = getCommandValue((JObject)ele.Value, paramsValue).Trim();

if (!string.IsNullOrEmpty(cmd))

{

userOptLi.Add(cmd);

}

}

catch (TypeErrorException err)

{

throw new Exception($"Error field type for key: \"{ele.Key}\". " + err.Message);

}

catch (Exception err)

{

throw new Exception($"Init command failed: \"{name}\", Key: \"{ele.Key}\". " + err.Message);

}

}

if (cmpModel.ContainsKey("$default-tail"))

{

foreach (var ele in ((JArray)cmpModel["$default-tail"]).Values<string>())

userOptLi.Add(ele);

}

// format ${var} variables in string

formatVarInCompilerOptions(cmpModel, baseOptLi, cmpParams);

formatVarInCompilerOptions(cmpModel, userOptLi, cmpParams);

baseOpts.Add(name, baseOptLi.ToArray());

userOpts.Add(name, userOptLi.ToArray());

}

}

private void formatVarInCompilerOptions(JObject model, List<string> opts, JObject[] userParams)

{

var matcher = new Regex(@"\$\{([^\}]+)\}", RegexOptions.IgnoreCase | RegexOptions.Compiled);

for (int i = 0; i < opts.Count; i++)

{

Match mList = matcher.Match(opts[i]);

if (mList.Success && mList.Groups.Count > 1)

{

for (int mIndex = 1; mIndex < mList.Groups.Count; mIndex++)

{

string key = mList.Groups[mIndex].Value;

if (!model.ContainsKey(key)) continue;

try

{

JObject field = (JObject)model[key];

object paramsVal = mergeParamsList(userParams, key, field["type"].Value<string>());

string cmdStr = getCommandValue(field, paramsVal);

opts[i] = opts[i].Replace("${" + key + "}", cmdStr);

}

catch (Exception)

{

// ignore log

}

}

}

}

}

private bool isArmGnuAsmFile(string fpath)

{

try

{

int lineLimit = 200; // max line we will detect

foreach (var line_ in File.ReadLines(fpath))

{

string line = line_.Trim();

// skip empty line

if (String.IsNullOrWhiteSpace(line))

continue;

// it's a armasm comment syntax

if (line.StartsWith(";"))

return false;

// it's a arm gnu comment syntax

if (line.StartsWith("/*") || line.StartsWith("//"))

return true;

// it's gnu asm label

if (Regex.IsMatch(line, @"^\s*\.(?:syntax|arch|section|global)\s+"))

return true;

// line limit

if (--lineLimit <= 0)

break;

}

}

catch (Exception)

{

// nothing todo