static void Main(string[] args)
{
LogManager.inst.Init();
PathExt.InitPath();
AssemblyParser.AssemblyParse(PathExt.codePath);
Console.ReadKey();
}
public static List <ILocalizationUnit> ParseAssembly()
{
var asm_parser = new AssemblyParser();
asm_parser.Add(typeof(Catalog).Assembly.Location);
asm_parser.Add(typeof(Strings).Assembly.Location);
return(new List <ILocalizationUnit> (asm_parser.Parse()));
}
public void GetMethodsInvalidDirectory()
{
string directoryPath = null;
AssemblyParser parser = new AssemblyParser();
var result = parser.GetMethods(directoryPath);
Assert.AreEqual(result.Count, 0);
}
static void Main(string[] args)
{
Environment.CurrentDirectory = Path.GetDirectoryName(Path.GetFullPath(args[0]));
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += CurrentDomain_ReflectionOnlyAssemblyResolve;
var assem = Assembly.LoadFrom(Path.GetFullPath(args[0]));
AssemblyParser p = new AssemblyParser();
p.Load(assem, args[1]);
}
public MappingsHelper(string[] code)
{
var copy = code;
code = AssemblyParser.ReplaceDefines(code);
code = AssemblyParser.RemoveLabels(code);
code = AssemblyParser.GetRidOfCommentsAndEmptyLines(code);
var copyOfCopy = copy;
copy = copy.Select((x) =>
{
if (!x.Contains(';'))
{
return(x.Trim());
}
return(x.Substring(0, x.IndexOf(';')).Trim());
}).ToArray();
var table = AssemblyParser.GenerateDefineReplacementTable(copy);
for (int i = 0; i < copy.Length; i++)
{
if (copy.Contains("define"))
{
continue;
}
foreach (var defineValue in table)
{
if (copy[i].Contains(defineValue.Key))
{
copy[i] = copy[i].Replace(defineValue.Key, defineValue.Value);
}
}
}
int internalCount = 0;
for (int i = 0; i < copy.Length; i++)
{
if (code.Contains(copy[i].Trim()))
{
LineIndexToDissassemblyIndex.Add(i, internalCount);
DissassemblyIndexToLineIndex.Add(internalCount, i);
LineIndexToLength.Add(i, copyOfCopy[i].Length);
internalCount++;
}
}
}
protected void Application_Start(object sender, EventArgs e)
{
var app = new AssemblyParser();
app.AddAssembly(typeof(Sharp.EndPoints.Sitemap).Assembly);
app.AddAssembly(typeof(Global).Assembly);
app.AddGlobalParsers(new RouteParser());
app.Parse();
}
private void LoadForgeModAPI(AssemblyInfo assemblyInfo)
{
var modAPIType = AssemblyParser.FindType <ModAPI>(assemblyInfo, "ModForge_1.7.10");
if (modAPIType == null)
{
throw new NetworkHandlerException($"ModAPI loading error: {assemblyInfo.FileName} was not found or corrupted.");
}
try { ModAPIs.Add((ModAPI)Activator.CreateInstance(modAPIType, ModAPISide.Client, this)); }
catch (MissingMemberException) { throw new NetworkHandlerException("Protocol not supported."); }
}
public void GetMethodsValidDirectory()
{
string directoryPath = @"..\..\..\TestLibrary\bin\Debug\netstandard2.0\";
AssemblyParser parser = new AssemblyParser();
var result = parser.GetMethods(directoryPath);
//TestClass1 и TestClass2
Assert.AreEqual(result.Count, 2);
//2 метода Void, 1 int, геттер и сеттер автосвойства и 4 метода, унаследованных от класса object
Assert.AreEqual(result["TestClass1"].Count, 8);
//1 метод Void, 1 int, и 4 метода, унаследованных от класса object
Assert.AreEqual(result["TestClass2"].Count, 6);
}
static void Main(string[] args)
{
//PrintReferences(typeof(TestClass));
var definition = AssemblyParser.Parse(typeof(TestClass).Assembly);
var testMethod = definition.Modules
.SelectMany(x => x.Types)
.Where(x => x.Name == nameof(TestClass))
.SelectMany(x => x.Methods)
.FirstOrDefault(x => x.Name == nameof(TestClass.TestAsync));
Console.ReadLine();
}
public void AssemblyParserParseDeTest(string assemblyFile, string targetNamespace, string culture)
{
// Arrange
var parser = new AssemblyParser(assemblyFile, targetNamespace, culture);
// Act
var result = parser.Parse();
// Assert
Assert.That(result.Count, Is.EqualTo(2), "Number of children not as expected.");
Assert.That((string)result.SelectToken("address.city.required.message"), Is.EqualTo("Ort ist obligatorisch."));
Assert.That((int)result.SelectToken("address.zipCode.size.min"), Is.EqualTo(4));
Assert.That((int)result.SelectToken("person.age.max.value"), Is.EqualTo(99));
Assert.That((string)result.SelectToken("person.url.url.message"), Is.EqualTo("Must be a valid URL."));
}
public void CliRunnerBuildCompleteJavaScriptTest()
{
// Arrange
var parser = new AssemblyParser("Nca.Valdr.Tests.dll", "Nca.Valdr.Tests.DTOs", "en");
var metadata = parser.Parse();
var runner = new CliRunner(new CliOptions(new[] { "-i:x", "-o:y" }));
// Act
var result = runner.BuildJavaScript("app", metadata.ToString());
// Assert
var appValdrJsFile = File.OpenText("../../app/app.valdr.js");
var fileContent = appValdrJsFile.ReadToEnd();
Assert.That(result, Is.EqualTo(fileContent));
}
public void CliRunnerBuildCompleteJavaScriptTest()
{
// Arrange
var parser = new AssemblyParser("Nca.Valdr.Tests.dll", "Nca.Valdr.Tests.DTOs", "en");
var metadata = parser.Parse();
var runner = new CliRunner(new CliOptions(new[] { "-i:x", "-o:y" }));
// Act
var result = runner.BuildJavaScript("app", metadata.ToString());
// Assert
var appValdrJsFile = File.OpenText("../../app/app.valdr.js");
var fileContent = appValdrJsFile.ReadToEnd();
Assert.That(result.Replace("\r", string.Empty), Is.EqualTo(fileContent.Replace("\r", string.Empty)));
}
private bool ParseInit()
{
if (client == null)
{
Log.WriteLine("tcp already disconnected!now to compile the protoBuff");
}
else
{
client.Exit();
}
if (!bIsAssembly)
{
return(true);
}
return(AssemblyParser.AssemblyParse(PathExt.codePath));
}
public void AssemblyParserParseEnTest(string assemblyFile, string targetNamespace, string culture)
{
// Arrange
var parser = new AssemblyParser(assemblyFile, targetNamespace, culture);
// Act
var result = parser.Parse();
// Assert
Assert.That(result.Count, Is.EqualTo(2), "Number of children not as expected.");
Assert.That((string)result.SelectToken("address.city.required.message"), Is.EqualTo("City is required."));
Assert.That((int)result.SelectToken("address.zipCode.size.min"), Is.EqualTo(4));
Assert.That((string)result.SelectToken("person.validTo.future.message"), Is.EqualTo("validTo must be in the future."));
Assert.That((string)result.SelectToken("person.birthday.past.message"), Is.EqualTo("Birthday must be in the past."));
Assert.That((int)result.SelectToken("person.age.max.value"), Is.EqualTo(99));
Assert.That((string)result.SelectToken("person.url.url.message"), Is.EqualTo("Must be a valid URL."));
}
private void MainForm_Load(object sender, EventArgs e)
{
LogManager.inst.Init(this);
PathExt.InitPath();
InitXml();
LoadXml();
if (bIsAssembly)
{
if (ParseInit())
{
msgApi = new AssemblyProtoMsg();
}
}
else
{
msgApi = new ProtoMsg();
}
if (msgApi == null)
{
Log.ErrorLine("msgApi is null");
return;
}
msgApi.BindMsgId();
msgApi.BindParser();
Connect();
AssemblyHandler handler;
AssemblyResult result;
AssemblyParser.GetAsseblyResult(out handler, out result);
if (result == null)
{
Log.ErrorLine("AssemblyResult is null");
}
foreach (var item in result.ClassList)
{
if (item.Value.Contains("Message") && item.Key.Contains("MSG_CG"))
{
AssemblyClassInfo classInfo = handler.GetClassInfo(ConstData.ClientMsgDll, item.Value);
list.Add(classInfo.ClassName, classInfo);
comboBox2.Items.Add(classInfo.ClassName);
}
}
}
private M CreateAssemblyParsers(bool includeReferences = false)
{
string solutionName = SolutionNodeName;
Solution solution = new Solution(solutionFilePath);
IReadOnlyList <Project> projects = solution.GetSolutionProjects();
foreach (Project project in projects)
{
string assemblyPath = project.GetOutputPath();
if (assemblyPath == null)
{
return(Error.From($"Failed to parse:\n {solutionFilePath}\n" +
$"Project\n{project}\nhas no Debug assembly."));
}
string parent = GetProjectParentName(solutionName, project);
var assemblyParser = new AssemblyParser(
assemblyPath, project.ProjectFilePath, parent, nodeCallback, linkCallback, isReadSymbols);
assemblyParsers.Add(assemblyParser);
}
if (includeReferences)
{
var internalModules = assemblyParsers.Select(p => p.ModuleName).ToList();
var referencePaths = assemblyParsers
.SelectMany(parser => parser.GetReferencePaths(internalModules))
.Distinct()
.Where(File.Exists)
.ToList();
foreach (string referencePath in referencePaths)
{
var assemblyParser = new AssemblyParser(
referencePath, null, null, nodeCallback, linkCallback, isReadSymbols);
assemblyParsers.Add(assemblyParser);
}
}
return(M.Ok);
}
public ModularProtocolHandler(MineLibClient client, AssemblyInfo assemblyInfo, string login = "", string password = "") : base(client, assemblyInfo)
{
var protocolType = AssemblyParser.FindType <Protocol>(AssemblyInfo, "ProtocolModern_1.7.10");
if (protocolType == null)
{
throw new NetworkHandlerException($"Protocol loading error: {AssemblyInfo.FileName} was not found or corrupted.");
}
try { Protocol = (Protocol)Activator.CreateInstance(protocolType, Client, ProtocolPurpose.Play); }
catch (MissingMemberException) { throw new NetworkHandlerException("Protocol not supported."); }
if (!string.IsNullOrEmpty(login) && !string.IsNullOrEmpty(password))
{
if (!Protocol.Login(login, password).Result)
{
throw new NetworkHandlerException("Login Failed");
}
}
}
public void Test()
{
var parser = new AssemblyParser(GetType().Assembly);
var implementations = parser.GetImplementations();
foreach (var implementation in implementations)
{
_output.WriteLine($"{implementation.Key}:");
foreach (var type in implementation.Value)
{
_output.WriteLine($" {type.FullName}");
var excluded = parser.GetExcludedMethods(type, implementation.Key);
_output.WriteLine($" - excludes:");
foreach (var method in excluded)
{
_output.WriteLine($" {method}");
}
}
}
}
static int Main(string[] args)
{
try
{
// If a path to an assembly is passed on the command line, use
// that as a test target. If the command line is empty, use
// the path to this program's EXE.
//
string fileName = (args.Length > 0 ? args[0] : Assembly.GetExecutingAssembly().Location);
using (AssemblyParser asmParser = new AssemblyParser(fileName))
{
if (asmParser.IsAssembly)
{
return(1);
}
}
}
catch
{
}
return(0);
}
public Protocol(MineLibClient client, ProtocolPurpose purpose) : base(client, purpose)
{
Stream = new ProtobufStream(TCPClientWrapper.Create());
RegisterSupportedSendings();
//ModAPIs
var modules = AssemblyParser.GetAssemblyInfos("Forge*.dll");
if (modules.Any())
{
foreach (var module in modules)
{
LoadForgeModAPI(module);
}
}
else
{
LoadForgeModAPI(new AssemblyInfo("NONE"));
}
}
private void DoReflection()
{
TreeView.Nodes.Clear();
// get the binding flags
var bindingFlags = ShowInheritiedMembersCheckBox.Checked ? AssemblyParser.BindingFlagsWithHierarchy : AssemblyParser.BindingFlagsDeclaredOnly;
// parse the assembly via reflection into XML
_assemblyParser = new AssemblyParser();
_xml = _assemblyParser.ParseAssembly(_assembly, _assemblyFileName, bindingFlags);
// load xml into xdoc
XDocument codeDoc = XDocument.Parse(_xml);
// build the assembly Facet from the xml doc root
AssemblyFacet assemblyFacet = new AssemblyFacet(codeDoc.Root);
// iterate over the assemblyFacet to populate the tree
DisplayAssemblyTree(assemblyFacet);
// enable export
ExportButton.Enabled = true;
}
public async Task <M <NodeDataSource> > TryGetSourceAsync(string nodeName)
{
M result = CreateAssemblyParsers(true);
if (result.IsFaulted)
{
return(result.Error);
}
string moduleName = GetModuleName(nodeName);
AssemblyParser assemblyParser = assemblyParsers
.FirstOrDefault(p => p.ModuleName == moduleName);
if (assemblyParser == null)
{
return(Error.From($"Failed to find assembly for {moduleName}"));
}
return(await Task.Run(() =>
{
M <NodeDataSource> source = assemblyParser.TryGetSource(nodeName);
if (source.IsFaulted || source.Value.Path != null)
{
return source;
}
var sourcePath = TryGetFilePath(nodeName, assemblyParser.ProjectPath);
if (sourcePath.IsOk)
{
return new NodeDataSource(source.Value.Text, source.Value.LineNumber, sourcePath.Value);
}
return source;
}));
}
public void Setup()
{
_cache = new OutputWriter(new NullResponseWriter());
_parser = new AssemblyParser(_cache);
}
public void TestFixtureSetUp()
{
_assemblyParser = new AssemblyParser(Assembly.GetExecutingAssembly().Location);
}
/// <summary>
/// Parse the files.
/// </summary>
private static void Parse()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var location = Directory.GetCurrentDirectory();
var versionPath = Path.Combine(location, VersionInfo);
Console.WriteLine($"Retrieving version info from {versionPath}...");
var versionDoc = JsonDocument.Parse(File.ReadAllText(versionPath));
string version = versionDoc.RootElement.GetProperty(nameof(version)).GetString();
Console.WriteLine($"Docs version is {version}");
var fileChecker = new FileHelper(location);
var xmlParser = new XmlDocParser(fileChecker);
var markdown = new DocsToMarkdownParser();
var writer = new FileWriter(
rootDir.StartsWith("..") ? Path.Combine(location, rootDir) : rootDir,
version);
Console.WriteLine("Parsing assemblies (pass 1)...");
var assemblies = new List <(DocAssembly doc, AssemblyParser parser)>();
foreach (var type in ExampleTypes)
{
var parser = new AssemblyParser(type.Assembly);
var doc = parser.Parse();
assemblies.Add((doc, parser));
}
WriteSuccess($"Parsed {ExampleTypes.Length} assemblies. Starting pass 2...");
int fileCount = 0;
long elapsed = 0;
bool deleted = false;
foreach (var(doc, parser) in assemblies)
{
parser.Parse(doc);
Console.WriteLine($"Checking {doc.Name}...");
var docName = $"{doc.Name}.xml";
Console.Write($"Documentation file: {docName} exists? ");
if (fileChecker.FileExists(docName))
{
WriteSuccess("YES");
}
else
{
WriteWarning("NO");
}
Console.WriteLine("Parsing XML documents...");
xmlParser.ParseComments(docName, doc);
Console.WriteLine("Transforming to markdown...");
var docFile = markdown.Parse(doc);
if (deleted == false)
{
Console.WriteLine("Purging existing docs....");
writer.Purge();
deleted = true;
}
Console.WriteLine("Writing documentation...");
writer.Write(docFile);
stopwatch.Stop();
elapsed += stopwatch.ElapsedMilliseconds;
fileCount += docFile.FileCount;
WriteSuccess("Success.");
}
WriteSuccess($"Processed {TypeCache.Cache.TypeCount} types and generated {fileCount} files in {elapsed}ms.");
}
private static int Main(string[] args)
{
BindingFlags bindingFlags = BindingFlags.Default;
// parse the command line
// https://github.com/gsscoder/commandline
var options = new CommandLineOptions();
if (CommandLine.Parser.Default.ParseArguments(args, options))
{
// validate command line options
if (options.BindingFlags == "declaredOnly")
{
bindingFlags = AssemblyParser.BindingFlagsDeclaredOnly;
}
else if (options.BindingFlags == "withHierarchy")
{
bindingFlags = AssemblyParser.BindingFlagsWithHierarchy;
}
else
{
Console.WriteLine("ERROR: Invalid binding flags.");
return(-1);
}
if (options.Verbose == "true")
{
Console.WriteLine("Assembly target : {0}", options.InputFile);
Console.WriteLine("Output folder : {0}", options.OutputPath);
}
}
else
{
Console.WriteLine("Error: Command line arguments failed to parse");
return(-1);
}
try {
// input file must exist
if (!File.Exists(options.InputFile))
{
Console.WriteLine($"ERROR: Reflector input file does not exist : {options.InputFile}");
return(-1);
}
// output path must exist
Directory.CreateDirectory(options.OutputPath);
if (!Directory.Exists(options.OutputPath))
{
Console.WriteLine($"ERROR: Reflector output path does not exist : {options.OutputPath}");
return(-1);
}
// load assembly
var inputFileName = options.InputFile;
Assembly assembly = Assembly.LoadFrom(inputFileName);
// parse the assembly via reflection into XML
AssemblyParser assemblyParser = new AssemblyParser();
var xml = assemblyParser.ParseAssembly(assembly, inputFileName, bindingFlags);
// <assembly name>.xml file name
string xmlFileName = Path.GetFileNameWithoutExtension(inputFileName) + ".xml";
string outputFileName = Path.Combine(options.OutputPath, xmlFileName);
// Write assembly xml output overwriting existing files
File.WriteAllText(outputFileName, xml);
// parsed type names are written to <assembly name>.types.xml file name
xml = assemblyParser.ParsedTypeNames();
xmlFileName = Path.GetFileNameWithoutExtension(inputFileName) + ".types.xml";
outputFileName = Path.Combine(options.OutputPath, xmlFileName);
File.WriteAllText(outputFileName, xml);
} catch (Exception e)
{
Console.WriteLine("ERROR: An Exception Occurred : {0}", e.ToString());
return(-1);
}
return(0);
}
private bool ParseInit()
{
return(AssemblyParser.AssemblyParse(PathExt.codePath));
}
