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;
}
