protected void Init() { _measureOrMetricKeys = new List <T>(); _resolver = new NamespaceResolver <T>(_innerCube); _wherebuilder = new WhereBuilder <T>(_resolver); _axisBuilder = new AxisBuilder <T>(_innerCube.Config.Storage.MolapConfig.HashType, _innerCube.Schema); }
public override void OnElement(Element element) { //Getting namespace and prefix string prefix, ns; NamespaceResolver.GetPrefixAndNs(element, _currentDocument, () => ScopeContext.Peek(), out prefix, out ns); if (string.IsNullOrEmpty(element.NsPrefix)) { prefix = null; } //Starting Element if (!string.IsNullOrEmpty(element.Name)) { if (element.Delimiter != DelimiterEnum.CCC) { //not text node _xmlTextWriter.WriteStartElement(prefix, element.Name, ns); AddLocationMapRecord(_currentModuleMember.Module.FileName, (IMappedPair)element); //Write all namespace declarations in the root element if (!_rootElementAdded) { WritePendingNamespaceDeclarations(ns); _rootElementAdded = true; } } } else { if (element.Parent.Delimiter == DelimiterEnum.CCC && (element.Delimiter == DelimiterEnum.C || element.Delimiter == DelimiterEnum.CC)) { // This is item of explicit array (:::) WriteExplicitArrayItem(element); } } if (!ResolveValue(element) && !EnterChoiceContainer(element, element.Entities)) { base.OnElement(element); } //End Element if (!string.IsNullOrEmpty(element.Name)) { if (element.Delimiter != DelimiterEnum.CCC) //not text node and not explicit array { _xmlTextWriter.WriteEndElement(); } } else { if (element.Parent.Delimiter == DelimiterEnum.CCC && (element.Delimiter == DelimiterEnum.C || element.Delimiter == DelimiterEnum.CC)) { _xmlTextWriter.WriteEndElement(); } } }
public void ShouldAddUsingAtSortedPlace() { const string source = @" using System; using System.Threading; namespace ns.something { public class Test {/*here*/} }"; var document = GetTestDocument(source); int position = source.IndexOf("/*here*/"); var newDoc = new NamespaceResolver().AddNamespaceImportAsync("System.Collections", document, position, CancellationToken.None).Result; var newDocText = newDoc.GetTextAsync().Result.ToString(); var usingIndexes = new[] { "using System;", "using System.Collections;", "using System.Threading;" } .Select(u => newDocText.IndexOf(u)) .ToArray(); Assert.That(usingIndexes, Does.Not.Contain(-1), "Missing namespace!"); Assert.That(usingIndexes, Is.Ordered); }
public MolapQueryOrchestrator(Cube <T> cube) { _cube = cube; _resolver = new NamespaceResolver <T>(cube); _allKeysComparer = new AllKeysComparer <T>(); _pairsEqualityComparer = new KeysBaseEqualityComparer <T>(); }
public StreamingElementWriter(XmlWriter w) { this.writer = w; this.element = null; this.attributes = new List<XAttribute>(); this.resolver = new NamespaceResolver(); }
public WhereBuilder(NamespaceResolver <T> resolver) { _resolver = resolver; BuilderFactory = new PredicateBuilderFactory <T>(_resolver); _rootBlock = new BlockPredicateBuilder <T>(BuilderFactory); _currentBlock = _rootBlock; }
public void Init() { cube = CubeSourcesFixture.GetBasicCubeThreeDimensionsTwoMeasures2(); cube.Initialize(); cube.Process(); _resolver = new NamespaceResolver <int>(cube); }
/// <inheritdoc /> public override void Visit(Element element) { //Getting namespace and prefix NamespaceResolver.GetPrefixAndNs(element, CurrentDocument, CurrentModuleMember, ScopeContext.Peek(), out var prefix, out var ns); if (string.IsNullOrEmpty(element.NsPrefix)) { prefix = null; } //Starting Element if (!string.IsNullOrEmpty(element.Name)) { if (element.Assignment != AssignmentEnum.CCC) { //not text node XmlTextWriter.WriteStartElement(prefix, element.Name, ns); AddLocationMapRecord(CurrentModuleMember.Module.FileName, (IMappedPair)element); //Write all namespace declarations in the root element if (!DocumentElementAdded) { WritePendingNamespaceDeclarations(ns); DocumentElementAdded = true; } } } else { if (element.Parent.Assignment == AssignmentEnum.CCC && (element.Assignment == AssignmentEnum.C || element.Assignment == AssignmentEnum.CC || element.Assignment == AssignmentEnum.E || element.Assignment == AssignmentEnum.EE)) { // This is item of explicit array (:::) WriteExplicitArrayItem(element, prefix, ns); } } if (!ResolveValue(element) && !EnterChoiceContainer(element, element.Entities)) { base.Visit(element); } //End Element if (!string.IsNullOrEmpty(element.Name)) { if (element.Assignment != AssignmentEnum.CCC) //not text node and not explicit array { XmlTextWriter.WriteEndElement(); } } else { if (element.Parent.Assignment == AssignmentEnum.CCC && (element.Assignment == AssignmentEnum.C || element.Assignment == AssignmentEnum.CC || element.Assignment == AssignmentEnum.E || element.Assignment == AssignmentEnum.EE)) { XmlTextWriter.WriteEndElement(); } } }
private void WriteUsingList(string path, StringBuilder codeBuilder, IEnumerable <SyntaxTree> syntaxForrest) { codeBuilder.AppendLine("using Microsoft.Extensions.DependencyInjection;"); var usings = NamespaceResolver.FindNamespaces(syntaxForrest, SourceNamespace); foreach (var @using in usings) { codeBuilder.AppendLine($"using {@using};"); } }
protected void ResolveNamespace() { try { Namespace = NamespaceResolver.ResolveNamespace(Path); } catch { Namespace = null; } }
public ValueSerializerContext (PrefixLookup prefixLookup, XamlSchemaContext schemaContext) { if (prefixLookup == null) throw new ArgumentNullException ("prefixLookup"); if (schemaContext == null) throw new ArgumentNullException ("schemaContext"); prefix_lookup = prefixLookup; namespace_resolver = new NamespaceResolver (prefix_lookup.Namespaces); type_resolver = new XamlTypeResolver (namespace_resolver, schemaContext); sctx = schemaContext; }
private NameBindingVisitor( IReadOnlyDictionary <string, DeclaredSymbol> declarations, IDictionary <SyntaxBase, Symbol> bindings, NamespaceResolver namespaceResolver, ImmutableDictionary <SyntaxBase, LocalScope> allLocalScopes) { this.declarations = declarations; this.bindings = bindings; this.namespaceResolver = namespaceResolver; this.allLocalScopes = allLocalScopes; this.activeScopes = new Stack <LocalScope>(); }
public ValueSerializerContext (PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider) { if (prefixLookup == null) throw new ArgumentNullException ("prefixLookup"); if (schemaContext == null) throw new ArgumentNullException ("schemaContext"); prefix_lookup = prefixLookup; namespace_resolver = new NamespaceResolver (prefix_lookup.Namespaces); type_resolver = new XamlTypeResolver (namespace_resolver, schemaContext); sctx = schemaContext; ambient_provider = ambientProvider; this.provideValue = provideValue; this.rootProvider = rootProvider; }
public static ImmutableDictionary <SyntaxBase, Symbol> GetBindings( ProgramSyntax programSyntax, IReadOnlyDictionary <string, DeclaredSymbol> outermostDeclarations, NamespaceResolver namespaceResolver, ImmutableArray <LocalScope> childScopes) { // bind identifiers to declarations var bindings = new Dictionary <SyntaxBase, Symbol>(); var allLocalScopes = ScopeCollectorVisitor.Build(childScopes); var binder = new NameBindingVisitor(outermostDeclarations, bindings, namespaceResolver, allLocalScopes); binder.Visit(programSyntax); return(bindings.ToImmutableDictionary()); }
private void WriteExplicitArrayItem(Element element) { string prefix; string ns; NamespaceResolver.GetPrefixAndNs((INsNode)element.Parent, _currentDocument, () => ScopeContext.Peek(), out prefix, out ns); if (string.IsNullOrEmpty(element.NsPrefix)) { prefix = null; } _xmlTextWriter.WriteStartElement(prefix, element.Parent.Name, ns); AddLocationMapRecord(_currentModuleMember.Module.FileName, (IMappedPair)element); }
private void WritePendingNamespaceDeclarations(string uri) { NsInfo nsInfo = NamespaceResolver.GetNsInfo(_currentDocument); if (nsInfo == null) { return; } foreach (var ns in nsInfo.Namespaces) { if (ns.Value == uri) { continue; } _xmlTextWriter.WriteAttributeString("xmlns", ns.Name, null, ns.Value); } }
public void ShouldAddNamespaceRelativeToParentNamespace() { const string source = @" namespace A.B.C { using System; public class Test {/*here*/} }"; var document = GetTestDocument(source); int position = source.IndexOf("/*here*/"); var newDoc = new NamespaceResolver().AddNamespaceImportAsync("A.B.Csmth.D.E", document, position, CancellationToken.None).Result; var newDocText = newDoc.GetTextAsync().Result.ToString(); Assert.That(newDocText, Does.Not.Contain("using A.B.Csmth.D.E;")); Assert.That(newDocText, Does.Contain("using Csmth.D.E;")); }
public static void Build(string concern, string operation, GroupByType groupBy) { ClassAssembler .Configure(concern, operation, PatternDirectoryType.Queries, groupBy) .ImportNamespaces(new List <NamespaceModel> { new NamespaceModel("MediatR"), new NamespaceModel($"{NamespaceResolver.Resolve(concern,"Responses",groupBy)}", true), }) .CreateNamespace() .CreateClass() .WithInheritance(new List <string> { $"IRequest<{concern}{operation}{PatternFileType.Response}>" }) .Generate() ; }
public override void OnAttribute(DOM.Attribute attribute) { string prefix = string.Empty, ns = string.Empty; if (!string.IsNullOrEmpty(attribute.NsPrefix)) { NamespaceResolver.GetPrefixAndNs(attribute, _currentDocument, () => ScopeContext.Peek(), out prefix, out ns); } _xmlTextWriter.WriteStartAttribute(prefix, attribute.Name, ns); if (!ResolveValue(attribute)) { EnterChoiceContainer(attribute, new PairCollection <Entity>().AddRange(((DOM.Mapped.Attribute)attribute).InterpolationItems?.OfType <Entity>())); } _xmlTextWriter.WriteEndAttribute(); AddLocationMapRecord(_currentModuleMember.Module.FileName, (IMappedPair)attribute); }
public void ShouldAddUsingInsideNamespaceIfUsingsArePresent() { const string source = @" namespace ns.something { using System; public class Test {/*here*/} }"; var document = GetTestDocument(source); int position = source.IndexOf("/*here*/"); var newDoc = new NamespaceResolver().AddNamespaceImportAsync("System.Collections", document, position, CancellationToken.None).Result; var newDocText = newDoc.GetTextAsync().Result.ToString(); Assert.That(newDocText, Does.Contain("using System.Collections;")); Assert.That(newDocText.IndexOf("using System.Collections;"), Is.GreaterThan(newDocText.IndexOf("namespace ns.something"))); }
private static void DecompileAllFallout4Scripts() { var folder = GetSolutionDir() + @"\Source\Test Scripts\Fallout 4\"; var allScripts = Directory.GetFiles(folder, "*.pex", SearchOption.AllDirectories); var clrNamespaceResolver = new NamespaceResolver(); var csharpConverter = new Papyrus2CSharpConverter(clrNamespaceResolver, new TypeReferenceResolver(clrNamespaceResolver, new TypeNameResolver(new PascalCaseNameResolver(new AdvancedConsoleUserInterface(), new PascalCaseNameResolverSettings(null))))); var index = 1; foreach (var s in allScripts) { Console.SetCursorPosition(0, 0); var asm = PapyrusAssemblyDefinition.ReadAssembly(s); var output = csharpConverter.Convert(new PapyrusAssemblyInput(asm)) as MultiCSharpOutput; var targetOutputFolder = "c:\\PapyrusDotNet\\Output\\Decompiled"; if (!Directory.Exists(targetOutputFolder)) { Directory.CreateDirectory(targetOutputFolder); } output?.Save(targetOutputFolder); Console.WriteLine("Decompiled: " + index + "/" + allScripts.Length); index++; } //var pexAssemblies = new PapyrusAssemblyDefinition[] //{ // PapyrusAssemblyDefinition.ReadAssembly(pexFile1), // PapyrusAssemblyDefinition.ReadAssembly(pexFile2), // PapyrusAssemblyDefinition.ReadAssembly(pexFile3) //}; }
private object GetIndentifierValue(IScriptContext context, string identifier) { //object result = context.GetItem(identifier, false); //if (result != RuntimeHost.NoVariable) return result; if (IsGlobal) { _variable = null; IScriptScope scope = context.Scope.Parent; while (scope != null) { if (scope.HasVariable(identifier)) { return(scope.GetItem(identifier, true)); } scope = scope.Parent; } } else { if (_variable != null && _variable.Value != null) { return(_variable.Value); } object result; _variable = CreateRef(identifier, context, true, out result); if (result != RuntimeHost.NoVariable) { return(result); } } return(RuntimeHost.HasType(identifier) ? (object)RuntimeHost.GetType(identifier) : NamespaceResolver.Get(identifier)); }
public FileSymbol(string name, ProgramSyntax syntax, NamespaceResolver namespaceResolver, IEnumerable <LocalScope> outermostScopes, IEnumerable <DeclaredSymbol> declarations, Uri fileUri) : base(name) { this.Syntax = syntax; this.NamespaceResolver = namespaceResolver; FileUri = fileUri; this.LocalScopes = outermostScopes.ToImmutableArray(); // TODO: Avoid looping 6 times? this.ImportDeclarations = declarations.OfType <ImportedNamespaceSymbol>().ToImmutableArray(); this.ParameterDeclarations = declarations.OfType <ParameterSymbol>().ToImmutableArray(); this.VariableDeclarations = declarations.OfType <VariableSymbol>().ToImmutableArray(); this.ResourceDeclarations = declarations.OfType <ResourceSymbol>().ToImmutableArray(); this.ModuleDeclarations = declarations.OfType <ModuleSymbol>().ToImmutableArray(); this.OutputDeclarations = declarations.OfType <OutputSymbol>().ToImmutableArray(); this.declarationsByName = this.Declarations.ToLookup(decl => decl.Name, LanguageConstants.IdentifierComparer); }
public static void Build(string concern, string operation, OperationType ot, GroupByType groupBy) { var tInObjectName = ot switch { OperationType.COMMAND => $"{concern}{operation}Command", OperationType.QUERY => $"{concern}{operation}Query" }; var operationTypeNamespace = ot switch { OperationType.COMMAND => NamespaceResolver.Resolve(concern, "Commands", groupBy), OperationType.QUERY => NamespaceResolver.Resolve(concern, "Queries", groupBy) }; ClassAssembler .ConfigureHandler(concern, operation, PatternDirectoryType.Handlers, groupBy) .ImportNamespaces(new List <NamespaceModel> { new NamespaceModel("MediatR"), new NamespaceModel(operationTypeNamespace, true), new NamespaceModel($"{NamespaceResolver.Resolve(concern,"Responses",groupBy)}", true), new NamespaceModel("System.Collections.Generic"), new NamespaceModel("System.Threading"), new NamespaceModel("System.Threading.Tasks") }) .CreateNamespace() .CreateClass(new[] { SyntaxFactory.Token(SyntaxKind.PublicKeyword) }) .WithInheritance(new List <string> { $"IRequestHandler<{tInObjectName},{concern}{operation}Response>" }) .ImplementMediatorHandlerInheritance($"{concern}{operation}Response", tInObjectName) .GenerateHandler() ; } } }
public DimensionSlicerBuilder(NamespaceResolver <T> resolver) { _members = new List <T>(); _resolver = resolver; }
public PredicateBuilderFactory(NamespaceResolver <T> resolver) { _resolver = resolver; }
public ElementWriter(XmlWriterSettings settings) { this.lines = new LineWriter(); this.writer = XmlWriter.Create(lines, settings); this.resolver = default(NamespaceResolver); }
protected void Init() { _resolver = new NamespaceResolver <T>(_innerCube); _expressionBuilders = new Dictionary <string, MetricExpressionBuilder <T> >(); }
protected override ClrAssemblyOutput ConvertAssembly(PapyrusAssemblyInput input) { var exeAsm = Assembly.GetExecutingAssembly(); var assemblyName = NamespaceResolver.Resolve("Core"); assembly = Thread.GetDomain().DefineDynamicAssembly( new AssemblyName(assemblyName), AssemblyBuilderAccess.RunAndSave, outputDirectory); mainModule = assembly.DefineDynamicModule(assemblyName, assemblyName + ".dll"); var i = 1; var x = Console.CursorLeft; var y = Console.CursorTop; foreach (var inputAssembly in input.Assemblies) { Console.SetCursorPosition(x, y); Console.WriteLine("Adding assembly references... " + i++ + "/" + input.Assemblies.Length); PrepareTypes(inputAssembly); } foreach (var inputAssembly in input.Assemblies) { foreach (var ptype in inputAssembly.Types) { foreach (var type in DefinedTypes) { var targetBaseType = ReferenceTypes.FirstOrDefault(t => t.Name.ToLower() == ptype.BaseTypeName.Value.ToLower()); if (targetBaseType != null) { type.SetParent(targetBaseType); } } } } i = 1; Console.SetCursorPosition(0, y + 1); foreach (var papyrusAssembly in input.Assemblies) { foreach (var type in papyrusAssembly.Types) { Console.SetCursorPosition(0, y + 1); Console.WriteLine("Building Classes... " + i++ + "/" + input.Assemblies.Length); var definedType = DefinedTypes.FirstOrDefault(n => n.Name == type.Name.Value); if (definedType == null) { definedType = mainModule.DefineType(type.Name.Value, TypeAttributes.Public); } BuildType(definedType, type); } } foreach (var t in DefinedTypes) { t.CreateType(); } //exeAsm.FindTypes("attribute") // .ForEach(attr => ImportType(mainModule, attr)); Console.WriteLine("Process Completed."); return(new ClrAssemblyOutput(assembly)); }
public XamlXmlParser (XmlReader xmlReader, XamlSchemaContext schemaContext, XamlXmlReaderSettings settings) { if (xmlReader == null) throw new ArgumentNullException ("xmlReader"); if (schemaContext == null) throw new ArgumentNullException ("schemaContext"); sctx = schemaContext; this.settings = settings ?? new XamlXmlReaderSettings (); // filter out some nodes. var xrs = new XmlReaderSettings () { CloseInput = this.settings.CloseInput, IgnoreComments = true, IgnoreProcessingInstructions = true, IgnoreWhitespace = true }; r = XmlReader.Create (xmlReader, xrs); line_info = r as IXmlLineInfo; xaml_namespace_resolver = new NamespaceResolver (r as IXmlNamespaceResolver); }
private void AddTypeDefinition(TypeDefinition owningType, string name, PapyrusTypeDefinition type, bool isNested) { if (mainModule.Types.Any(t => t.Name.ToLower() == name.ToLower())) { // Type already exists? Don't do anything. return; } var newType = new TypeDefinition(NamespaceResolver.Resolve(name), name, isNested ? TypeAttributes.NestedPublic | TypeAttributes.SequentialLayout | TypeAttributes.BeforeFieldInit | TypeAttributes.Sealed : TypeAttributes.Public | TypeAttributes.Class); if (isNested) { newType.IsClass = false; newType.BaseType = mainModule.Import(typeof(ValueType)); if (owningType.NestedTypes.Any(t => t.Name.ToLower() == name.ToLower())) { // Structure already exists? Don't do anything. return; } owningType.NestedTypes.Add(newType); } else { mainModule.Types.Add(newType); } AddEmptyConstructor(newType); if (!isNested) { if (!string.IsNullOrEmpty(type.BaseTypeName?.Value)) { var baseType = ResolveTypeReference(null, type.BaseTypeName.Value); newType.BaseType = baseType ?? objectType; } else { newType.BaseType = objectType; } } foreach (var field in type.Fields) { var fieldType = field.DefaultValue; var typeName = fieldType.Name; var typeRef = ResolveTypeReference(null, typeName); var attributes = FieldAttributes.Public; if (field.Name.Value.ToLower().EndsWith("_var")) { if (type.Properties.Any( n => field.Name.Value.Contains('_') && n.Name.Value == field.Name.Value.Split('_')[0] || n.AutoName == field.Name.Value)) { attributes = FieldAttributes.Private; } } //if (field.IsConst) //{ // attributes |= FieldAttributes.InitOnly; //} var fieldDef = new FieldDefinition(field.Name.Value.Replace("::", ""), attributes, typeRef); newType.Fields.Add(fieldDef); } foreach (var prop in type.Properties) { FieldDefinition targetField = null; foreach (var field in newType.Fields) { if (!string.IsNullOrEmpty(prop.AutoName)) { if (prop.AutoName.Contains(field.Name)) { targetField = field; break; } } if (field.Name.ToLower().Contains(prop.Name.Value.ToLower() + "_var")) { targetField = field; break; } } var typeRef = ResolveTypeReference(null, prop.TypeName); newType.AddProperty(nameConventionResolver.Resolve(prop.Name.Value), typeRef, targetField); } foreach (var structure in type.NestedTypes) { AddTypeDefinition(newType, structure.Name, structure, true); } foreach (var state in type.States) { foreach (var method in state.Methods) { method.Name.Value = nameConventionResolver.Resolve(method.Name.Value); var typeRef = ResolveTypeReference(null, method.ReturnTypeName); var attributes = MethodAttributes.Public; if (method.IsGlobal /* || method.IsNative */) { attributes |= MethodAttributes.Static; } else if (method.IsEvent) { attributes |= MethodAttributes.Virtual; attributes |= MethodAttributes.NewSlot; } var methodDef = new MethodDefinition(method.Name.Value, attributes, typeRef); // methodDef.IsNative = method.IsNative; foreach (var param in method.Parameters) { var paramTypeRef = ResolveTypeReference(null, param.TypeName); var paramDef = new ParameterDefinition(param.Name.Value, ParameterAttributes.None, paramTypeRef); methodDef.Parameters.Add(paramDef); } var existingMethod = newType.Methods.Any(m => m.Name == methodDef.Name && methodDef.ReturnType == typeRef && methodDef.Parameters.Count == m.Parameters.Count ); if (!existingMethod) { CreateEmptyFunctionBody(ref methodDef); newType.Methods.Add(methodDef); } } } // return newType; }
public ElementWriter(XmlWriter writer) { this.writer = writer; this.resolver = new NamespaceResolver(); }
public ExpressionBuilder(NamespaceResolver <T> resolver) { _resolver = resolver; }
private static void ReadAndWritePex() { var drive = "d"; var dir = @":\Git\PapyrusDotNet\Examples\Fallout4Example\bin\Debug\"; var targetFolder = drive + dir; if (!Directory.Exists(targetFolder)) { targetFolder = "c" + dir; } // var provider = new Mono.Cecil.Pdb.PdbReaderProvider(); // provider.GetSymbolReader() // PdbFactory factory = new PdbFactory(); // ISymbolReader reader = //factory.CreateReader(assdef.MainModule, ass_file); var readerParameters = new ReaderParameters { ReadSymbols = true }; var converter = new Clr2PapyrusConverter(new NoopUserInterface(), new ClrInstructionProcessor( new LoadProcessor(), new StoreProcessor(new PapyrusValueTypeConverter()), new BranchProcessor(), new CallProcessor(new PapyrusValueTypeConverter()), new ConditionalProcessor(), new ReturnProcessor(new PapyrusValueTypeConverter()), new StringConcatProcessor() ), PapyrusCompilerOptions.Strict); var assemblyDefinition = AssemblyDefinition.ReadAssembly( targetFolder + "fallout4example.dll", readerParameters); try { assemblyDefinition.MainModule.ReadSymbols(); } catch { } var value = converter.Convert( new ClrAssemblyInput( assemblyDefinition, PapyrusVersionTargets.Fallout4)) as PapyrusAssemblyOutput; #if false var folder = @"d:\git\PapyrusDotNet\Source\Test Scripts\Fallout 4\"; var pexFile1 = folder + @"AssaultronHeadModStealthScript.pex"; var pexFile2 = folder + @"BobbleheadStandContainerScript.pex"; var pexFile3 = folder + @"DN035QuestScript.pex"; var pexAssemblies = new PapyrusAssemblyDefinition[] { PapyrusAssemblyDefinition.ReadAssembly(pexFile1), PapyrusAssemblyDefinition.ReadAssembly(pexFile2), PapyrusAssemblyDefinition.ReadAssembly(pexFile3) }; #else var pexAssemblies = new PapyrusAssemblyDefinition[0]; #endif var asm = value.Assemblies; var defs = new List <PapyrusAssemblyDefinition>(pexAssemblies); var targetOutputFolder = "c:\\PapyrusDotNet\\Output"; if (!Directory.Exists(targetOutputFolder)) { Directory.CreateDirectory(targetOutputFolder); } value.Save(targetOutputFolder); var scripts = Directory.GetFiles(targetOutputFolder, "*.pex").Select(PapyrusAssemblyDefinition.ReadAssembly); defs.AddRange(scripts); //defs.AddRange(asm); var clrNamespaceResolver = new NamespaceResolver(); var csharpConverter = new Papyrus2CSharpConverter(clrNamespaceResolver, new TypeReferenceResolver(clrNamespaceResolver, new TypeNameResolver(new PascalCaseNameResolver(new AdvancedConsoleUserInterface(), new PascalCaseNameResolverSettings(null))))); var output = csharpConverter.Convert(new PapyrusAssemblyInput(defs.ToArray())) as MultiCSharpOutput; output.Save(targetOutputFolder); //var sourceScript = "D:\\Spel\\Fallout 4 Scripts\\scripts\\Actor.pex"; //var destinationScript = "D:\\Spel\\Fallout 4 Scripts\\scripts\\Actor.pex_new"; //var src = PapyrusAssemblyDefinition.ReadAssembly(sourceScript); //Assert.IsNotNull(src); //Assert.IsNotNull(src.Header.SourceHeader.Source); //src.Write(destinationScript); //var dest = PapyrusAssemblyDefinition.ReadAssembly(destinationScript); //Assert.IsNotNull(src); //Assert.IsNotNull(dest.Header.SourceHeader.Source); //Assert.AreEqual(src.Header.SourceHeader.Source, dest.Header.SourceHeader.Source); // TestManySkyrimPapyrus(); //var startTime = DateTime.Now; //var fallout4ScriptFolder = @"D:\Spel\Fallout 4 Scripts\scripts\"; //var fallout4Script = "D:\\Spel\\Fallout 4 Scripts\\scripts\\Actor.pex"; //var skyrimScript = @"C:\CreationKit\Data\scripts\activemagiceffect.pex"; ////var assembly = PapyrusAssemblyDefinition.LoadAssembly(skyrimScript, true); //var allScriptFiles = Directory.GetFiles(fallout4ScriptFolder, "*.pex", SearchOption.AllDirectories); //var assemblies = allScriptFiles.Select(PapyrusAssemblyDefinition.LoadAssembly); //var namespaceResolver = new ClrNamespaceResolver(); //var converter = new PapyrusToClrConverter(namespaceResolver, // new ClrTypeReferenceResolver(namespaceResolver, new ClrTypeNameResolver())); //var output = converter.Convert(new PapyrusAssemblyInput(assemblies.ToArray())); //var clr = output as ClrAssemblyOutput; //clr.OutputAssembly.Write( // @"D:\Git\PapyrusDotNet\Source\PapyrusDotNet.ConsoleTests\bin\Debug\PapyrusDotNet.Core.dll"); //Console.WriteLine("Build Time: " + (DateTime.Now - startTime).TotalSeconds + " seconds."); }
protected override CecilAssemblyOutput ConvertAssembly(PapyrusAssemblyInput input) { var exeAsm = Assembly.GetExecutingAssembly(); var name = "Core"; clrAssembly = AssemblyDefinition.CreateAssembly( new AssemblyNameDefinition(NamespaceResolver.Resolve(name), new Version(2, 0)), NamespaceResolver.Resolve(name), ModuleKind.Dll); mainModule = clrAssembly.MainModule; objectType = mainModule.Import(typeof(object)); int i = 1, ij = 0; userInterface.DrawInterface("(2/3) Adding assembly references."); foreach (var inputAssembly in input.Assemblies) { var redrawProgress = ij >= 100 || i == input.Assemblies.Length || input.Assemblies.Length < 500; if (redrawProgress) { //Console.SetCursorPosition(x, y); //Console.WriteLine("Adding assembly references... " + i + "/" + input.Assemblies.Length); userInterface.DrawProgressBarWithInfo(i, input.Assemblies.Length); ij = 0; } ij++; i++; AddAssemblyReferences(inputAssembly); } i = 1; ij = 0; //Console.SetCursorPosition(0, y + 1); userInterface.DrawInterface("(3/3) Creating CLR types."); foreach (var papyrusAssembly in input.Assemblies) { foreach (var type in papyrusAssembly.Types) { var redrawProgress = ij >= 100 || i == input.Assemblies.Length || input.Assemblies.Length < 500; if (redrawProgress) { //Console.SetCursorPosition(0, y + 1); //Console.WriteLine("Building Classes... " + i + "/" + input.Assemblies.Length); userInterface.DrawProgressBarWithInfo(i, input.Assemblies.Length); ij = 0; } ij++; i++; AddTypeDefinition(null, type.Name, type, false); } } exeAsm.FindTypes("attribute") .ForEach(attr => ImportType(mainModule, attr)); userInterface.DrawResult("Building Core Library Completed."); return(new CecilAssemblyOutput(clrAssembly)); }
public UnimportedCSharpCompletionProvider(IOptionsProvider optionsProvider) { _optionsProvider = optionsProvider; _namespaceResolver = new NamespaceResolver(); }
public XamlTypeResolver (NamespaceResolver namespaceResolver, XamlSchemaContext schemaContext) { ns_resolver = namespaceResolver; schema_context = schemaContext; }