public static SymbolResolver EnvironmentFromObject(object dataObject, SymbolResolver parent)
{
// If we have no data context, return an empty environment.
//
if (dataObject == null)
{
return parent ?? new SymbolResolver();
}
// Maybe it is already an environment.
//
SymbolResolver environment = dataObject as SymbolResolver;
if (environment != null)
{
return environment;
}
// Otherwise populate the new environment based on the data context.
//
environment = parent ?? new SymbolResolver();
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(dataObject))
{
if (property.IsReadOnly)
{
environment.Add(property.Name, property.GetValue(dataObject));
}
else
{
environment.Add(property.Name, new PropertyDescriptorLocationReference { Component = dataObject, Property = property });
}
}
return environment;
}
public static SymbolResolver EnvironmentFromNameTable(IXamlNameResolver table, SymbolResolver parent)
{
SymbolResolver environment = parent ?? new SymbolResolver();
if (table == null)
{
return(environment);
}
foreach (KeyValuePair <string, object> pair in table.GetAllNamesAndValuesInScope())
{
environment.Add(pair);
}
return(environment);
}
public static SymbolResolver EnvironmentFromNameTable(IXamlNameResolver table, SymbolResolver parent)
{
SymbolResolver environment = parent ?? new SymbolResolver();
if (table == null)
{
return environment;
}
foreach (KeyValuePair<string, object> pair in table.GetAllNamesAndValuesInScope())
{
environment.Add(pair);
}
return environment;
}
private void LinkRelatedTokens(List <CilCondition> conditions)
{
foreach (var condition in conditions)
{
foreach (var matcher in condition.Matchers)
{
foreach (CilSymbolRef symbol in matcher.AllOutcomes)
{
if (SymbolResolver.Contains(symbol))
{
SymbolResolver.Link(symbol);
}
}
}
}
}
public void TestResolver()
{
var snippets = Startup.Create <Snippets>("Workspace");
snippets.Compile(SNIPPETS.HelloQ);
var resolver = new SymbolResolver(snippets);
// Intrinsics:
var symbol = resolver.Resolve("X");
Assert.IsNotNull(symbol);
Assert.AreEqual("Microsoft.Quantum.Intrinsic.X", symbol.Name);
// FQN Intrinsics:
symbol = resolver.Resolve("Microsoft.Quantum.Intrinsic.X");
Assert.IsNotNull(symbol);
Assert.AreEqual("Microsoft.Quantum.Intrinsic.X", symbol.Name);
// From namespace:
symbol = resolver.Resolve("Tests.qss.CCNOTDriver");
Assert.IsNotNull(symbol);
Assert.AreEqual("Tests.qss.CCNOTDriver", symbol.Name);
symbol = resolver.Resolve("CCNOTDriver");
Assert.IsNotNull(symbol);
Assert.AreEqual("Tests.qss.CCNOTDriver", symbol.Name);
/// From Canon:
symbol = resolver.Resolve("ApplyToEach");
Assert.IsNotNull(symbol);
Assert.AreEqual("Microsoft.Quantum.Canon.ApplyToEach", symbol.Name);
// Snippets:
symbol = resolver.Resolve("HelloQ");
Assert.IsNotNull(symbol);
Assert.AreEqual("HelloQ", symbol.Name);
// resolver is case sensitive:
symbol = resolver.Resolve("helloq");
Assert.IsNull(symbol);
// Invalid name
symbol = resolver.Resolve("foo");
Assert.IsNull(symbol);
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
var baseNode = completionNode;
if (baseNode.Parent != null && (baseNode.Parent == parseTreeNode || baseNode.m_iChildIndex == 0 && baseNode.Parent.Parent == parseTreeNode))
{
SymbolDefinition target = null;
SyntaxTreeNode_Base targetNode = null;
var node = parseTreeNode
.Parent
.Parent
.Parent;
if (node.RuleName == "objectCreationExpression")
{
targetNode = node.Parent;
target = SymbolDefinition.ResolveNode(targetNode);
var targetAsType = target as TypeDefinitionBase;
if (targetAsType != null)
{
target = targetAsType.GetThisInstance();
}
}
else
{
targetNode = node.Parent.LeafAt(0);
target = SymbolDefinition.ResolveNode(node.Parent.LeafAt(0));
}
if (target != null)
{
HashSet <SymbolDefinition> completions = new HashSet <SymbolDefinition>();
SymbolResolver.GetCompletions(IdentifierCompletionsType.Member, targetNode, completions, completionAssetPath);
foreach (var symbol in completions)
{
data.Add(symbol.name, symbol);
}
}
}
else
{
base.GetCompletionData(data, fromInstance, assembly);
}
}
private Program(string[] args)
{
executableName = args[0];
using (var snap = new Toolhelp32Snapshot(Toolhelp32SnapshotFlags.Process)) {
var procEntry = snap.GetProcesses().FirstOrDefault(p => p.Executable == executableName);
if (procEntry is null)
{
throw new ProcessNotFoundException();
}
process = procEntry.Open(ProcessAccessRights.VMOperation | ProcessAccessRights.VMRead | ProcessAccessRights.Synchronize | ProcessAccessRights.QueryInformation);
}
ModuleEntry mainModule = process.GetModules().First(m => m.Name == executableName);
string pdbPath = mainModule.Path.Replace(".exe", ".pdb");
resolver = new SymbolResolver();
resolver.AddPdb(pdbPath, mainModule.BaseAddress);
memoryReader = new LiveProcessMemoryAccessor(process);
}
public static SymbolResolver EnvironmentFromObject(object dataObject, SymbolResolver parent)
{
// If we have no data context, return an empty environment.
//
if (dataObject == null)
{
return(parent ?? new SymbolResolver());
}
// Maybe it is already an environment.
//
SymbolResolver environment = dataObject as SymbolResolver;
if (environment != null)
{
return(environment);
}
// Otherwise populate the new environment based on the data context.
//
environment = parent ?? new SymbolResolver();
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(dataObject))
{
if (property.IsReadOnly)
{
environment.Add(property.Name, property.GetValue(dataObject));
}
else
{
environment.Add(property.Name, new PropertyDescriptorLocationReference {
Component = dataObject, Property = property
});
}
}
return(environment);
}
// user can specify a formatter without symbol solver
// so we need to clone the formatter with settings and provide our symbols solver
internal Formatter GetFormatterWithSymbolSolver(IReadOnlyDictionary <ulong, string> addressToNameMapping)
{
var symbolSolver = new SymbolResolver(addressToNameMapping);
switch (Formatter)
{
case MasmFormatter masmFormatter:
return(new MasmFormatter(masmFormatter.MasmOptions, symbolSolver));
case NasmFormatter nasmFormatter:
return(new NasmFormatter(nasmFormatter.NasmOptions, symbolSolver));
case GasFormatter gasFormatter:
return(new GasFormatter(gasFormatter.GasOptions, symbolSolver));
case IntelFormatter intelFormatter:
return(new IntelFormatter(intelFormatter.IntelOptions, symbolSolver));
default:
// we don't know how to translate it so we just return the original one
// it's better not to solve symbols rather than throw exception ;)
return(Formatter);
}
}
private static extern LLVMOrcErrorCode LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef @JITStack, out LLVMOrcModuleHandle retHandle, LLVMSharedModuleRef @Mod, SymbolResolver @SymbolResolver, IntPtr @SymbolResolverCtx);
private SymbolReference TypeOfImplicitParameter(SymbolDeclaration declaration)
{
int index = 0;
var node = declaration.parseTreeNode;
if (node.Parent.RuleName == "implicitAnonymousFunctionParameterList")
{
index = node.m_iChildIndex / 2;
node = node.Parent;
}
node = node.Parent; // anonymousFunctionSignature
node = node.Parent; // lambdaExpression
node = node.Parent; // nonAssignmentExpression
node = node.Parent; // elementInitializer or expression
if (node.RuleName == "elementInitializer")
{
node = node.Parent // elementInitializerList
.Parent // collectionInitializer
.Parent // objectOrCollectionInitializer
.Parent // objectCreationExpression
.Parent; // primaryExpression
if (node.RuleName != "primaryExpression")
{
return(null);
}
node = node.NodeAt(1);
if (node == null || node.RuleName != "nonArrayType")
{
return(null);
}
var collectionType = ResolveNode(node.ChildAt(0)).TypeOf() as TypeDefinitionBase;
if (collectionType != null && collectionType.kind != SymbolKind.Error)
{
var enumerableType = collectionType.ConvertTo(builtInTypes_IEnumerable_1) as SD_Type_Constructed;
var targetTypeReference = enumerableType == null || enumerableType.typeArguments == null ? null : enumerableType.typeArguments.FirstOrDefault();
var targetType = targetTypeReference == null ? null : targetTypeReference.Definition;
if (targetType != null && targetType.kind == SymbolKind.Delegate)
{
var delegateParameters = targetType.GetParameters();
if (delegateParameters != null && index < delegateParameters.Count)
{
var type = delegateParameters[index].TypeOf();
type = type.SubstituteTypeParameters(targetType);
return(new SymbolReference(type));
}
}
}
}
if (node.RuleName == "expression" && (node.Parent.RuleName == "localVariableInitializer" || node.Parent.RuleName == "variableInitializer"))
{
node = node.Parent.Parent;
if (node.RuleName == "variableInitializerList")
{
node = node.Parent.Parent.Parent.NodeAt(1);
if (node == null || node.RuleName != "nonArrayType")
{
return(null);
}
}
else if (node.RuleName != "localVariableDeclarator" && node.RuleName != "variableDeclarator")
{
return(null);
}
var targetSymbol = node.ChildAt(0).ResolvedSymbol ?? ResolveNode(node.ChildAt(0));
if (targetSymbol != null && targetSymbol.kind != SymbolKind.Error)
{
var targetType = targetSymbol.kind == SymbolKind.Delegate ? targetSymbol : targetSymbol.TypeOf();
if (targetType != null && targetType.kind == SymbolKind.Delegate)
{
var delegateParameters = targetType.GetParameters();
if (delegateParameters != null && index < delegateParameters.Count)
{
var type = delegateParameters[index].TypeOf();
type = type.SubstituteTypeParameters(targetType);
return(new SymbolReference(type));
}
}
}
}
else if (node.RuleName == "expression" && node.Parent.RuleName == "argumentValue")
{
node = node.Parent; // argumentValue
if (node.m_iChildIndex == 0)
{
node = node.Parent; // argument
var argumentIndex = node.m_iChildIndex / 2;
node = node.Parent; // argumentList
node = node.Parent; // arguments
node = node.Parent; // constructorInitializer or attribute or primaryExpressionPart or objectCreationExpression
if (node.RuleName == "primaryExpressionPart")
{
SyntaxTreeNode_Leaf methodId = null;
node = node.Parent.NodeAt(node.m_iChildIndex - 1); // primaryExpressionStart or primaryExpressionPart
if (node.RuleName == "primaryExpressionStart")
{
methodId = node.LeafAt(0);
}
else // node.RuleName == "primaryExpressionPart"
{
node = node.NodeAt(0);
if (node.RuleName == "accessIdentifier")
{
methodId = node.LeafAt(1);
}
}
if (methodId != null && methodId.token.tokenKind == LexerToken.Kind.Identifier)
{
if (methodId.ResolvedSymbol == null || methodId.ResolvedSymbol.kind == SymbolKind.MethodGroup)
{
SymbolResolver.ResolveNode(node);
}
var method = methodId.ResolvedSymbol as MethodDefinition;
var constructedSymbol = methodId.ResolvedSymbol as SD_ConstructedReference;
if (method != null)
{
if (method.IsExtensionMethod)
{
var nodeLeft = methodId.Parent;
if (nodeLeft != null && nodeLeft.RuleName == "accessIdentifier")
{
nodeLeft = nodeLeft.FindPreviousNode() as SyntaxTreeNode_Rule;
if (nodeLeft != null)
{
if (nodeLeft.RuleName == "primaryExpressionPart" || nodeLeft.RuleName == "primaryExpressionStart")
{
var symbolLeft = SymbolResolver.GetResolvedSymbol(nodeLeft);
if (symbolLeft != null && symbolLeft.kind != SymbolKind.Error && !(symbolLeft is TypeDefinitionBase))
{
++argumentIndex;
}
}
else
{
++argumentIndex;
}
}
}
}
if (argumentIndex < method.parameters.Count)
{
var parameter = method.parameters[argumentIndex];
var parameterType = parameter.TypeOf();
if (parameterType.kind == SymbolKind.Delegate)
{
parameterType = parameterType.SubstituteTypeParameters(method);
var delegateParameters = parameterType.GetParameters();
if (delegateParameters != null && index < delegateParameters.Count)
{
var type = delegateParameters[index].TypeOf();
type = type.SubstituteTypeParameters(parameterType);
//type = type.SubstituteTypeParameters(method);
return(new SymbolReference(type));
}
}
}
}
else if (constructedSymbol != null && constructedSymbol.kind == SymbolKind.Method)
{
var genericMethod = constructedSymbol.referencedSymbol;
var parameters = genericMethod.GetParameters();
if (parameters != null && argumentIndex < parameters.Count)
{
var parameter = parameters[argumentIndex];
var parameterType = parameter.TypeOf();
if (parameterType.kind == SymbolKind.Delegate)
{
parameterType = parameterType.SubstituteTypeParameters(constructedSymbol);
var delegateParameters = parameterType.GetParameters();
if (delegateParameters != null && index < delegateParameters.Count)
{
var type = delegateParameters[index].TypeOf();
type = type.SubstituteTypeParameters(parameterType);
//type = type.SubstituteTypeParameters(constructedSymbol);
return(new SymbolReference(type));
}
}
}
}
}
}
}
}
return(null);
}
public static bool Generate(String Ssdl, String exSsdl, string edmxPath, out String ddl, List<Exception> errors)
{
String DdlOut = null;
bool HasErrors = false;
Version version = EntityFrameworkVersions.Version3;
var inputs = new Dictionary<string, object>()
{
{"ExistingSsdlInput", exSsdl},
{"SsdlInput", Ssdl }
};
var resolver = new SymbolResolver();
var edmParameterBag = new EdmParameterBag(
null, // syncContext
null, // assemblyLoader
version, // targetVersion
"System.Data.SqlClient", // providerInvariantName
"2008", // providerManifestToken
"none", // providerConnectionString
"dbo", // databaseSchemaName
"Dummy", // databaseName
//TODO - get ddlTemplatePath from registry?
@"C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\IDE\Extensions\Microsoft\Entity Framework Tools\DBGen\SSDLToSQL10.tt", // ddlTemplatePath
edmxPath // edmxPath
);
resolver.Add(typeof(EdmParameterBag).Name, edmParameterBag);
SsdlToDdlActivity activity = new SsdlToDdlActivity();
var wfa = new WorkflowApplication(activity, inputs);
wfa.Extensions.Add(resolver);
AutoResetEvent syncEvent = new AutoResetEvent(false);
AutoResetEvent idleEvent = new AutoResetEvent(false);
wfa.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
syncEvent.Set();
DdlOut = (string)e.Outputs["DdlOutput"];
};
wfa.Aborted = e =>
{
syncEvent.Set();
errors.Add(e.Reason);
HasErrors = false;
};
wfa.OnUnhandledException = e =>
{
syncEvent.Set();
errors.Add(e.UnhandledException);
HasErrors = false;
return UnhandledExceptionAction.Cancel;
};
wfa.Run();
// Loop until the workflow completes.
WaitHandle[] handles = new WaitHandle[] { syncEvent, idleEvent };
while (WaitHandle.WaitAny(handles) != 0)
{
}
ddl = DdlOut;
return HasErrors;
}
public static bool Generate(EdmItemCollection csdl, out String ssdl, out String msl, List<Exception> errors)
{
String SsdlOut = null;
String MslOut = null;
bool HasErrors = false;
var version = EntityFrameworkVersions.Version3;
var inputs = new Dictionary<string, object>()
{
{"CsdlInput", csdl},
{"OutputGeneratorType", typeof(CsdlToSsdl).AssemblyQualifiedName },
{"MslOutputGeneratorType", typeof(CsdlToMsl).AssemblyQualifiedName }
};
var resolver = new SymbolResolver();
var edmParameterBag = new EdmParameterBag(
null, // syncContext
null, // assemblyLoader
version, // targetVersion
"System.Data.SqlClient", // providerInvariantName
"2008", // providerManifestToken
null, // providerConnectionString
"dbo", // databaseSchemaName
null, // databaseName
null, // ddlTemplatePath
null // edmxPath
);
resolver.Add(typeof(EdmParameterBag).Name, edmParameterBag);
var activity = new CsdlToSsdlAndMslActivity();
var wfa = new WorkflowApplication(activity, inputs);
wfa.Extensions.Add(resolver);
AutoResetEvent syncEvent = new AutoResetEvent(false);
AutoResetEvent idleEvent = new AutoResetEvent(false);
wfa.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
syncEvent.Set();
SsdlOut = (string)e.Outputs["SsdlOutput"];
MslOut = (string)e.Outputs["MslOutput"];
};
wfa.Aborted = e =>
{
syncEvent.Set();
errors.Add(e.Reason);
HasErrors = true;
};
wfa.OnUnhandledException = e =>
{
syncEvent.Set();
errors.Add(e.UnhandledException);
HasErrors = true;
return UnhandledExceptionAction.Cancel;
};
wfa.Run();
// Loop until the workflow completes.
WaitHandle[] handles = new WaitHandle[] { syncEvent, idleEvent };
while (WaitHandle.WaitAny(handles) != 0)
{
}
ssdl = SsdlOut;
msl = MslOut;
return HasErrors;
}
public static SymbolDefinition GetResolvedSymbol_Internal(ParseTree.BaseNode baseNode)
{
#endif
var leaf = baseNode as SyntaxTreeNode_Leaf;
if (leaf != null)
{
if (leaf.ResolvedSymbol == null && leaf.Parent != null)
{
ResolveNode(leaf.Parent);
}
return(leaf.ResolvedSymbol);
}
var node = baseNode as SyntaxTreeNode_Rule;
if (node == null || node.NumValidNodes == 0)
{
return(null);
}
switch (node.RuleName)
{
case "primaryExpressionStart":
if (node.NumValidNodes < 3)
{
return(GetResolvedSymbol(node.ChildAt(0)));
}
leaf = node.LeafAt(2);
return(leaf != null ? leaf.ResolvedSymbol : null);
case "primaryExpressionPart":
return(GetResolvedSymbol(node.NodeAt(0)));
case "arguments":
return(GetResolvedSymbol(node.FindPreviousNode() as SyntaxTreeNode_Rule));
case "objectCreationExpression":
var newType = GetResolvedSymbol(node.FindPreviousNode() as SyntaxTreeNode_Rule);
if (newType == null || newType.kind == SymbolKind.Error)
{
newType = SymbolDefinition.builtInTypes_object;
}
var typeOfNewType = (TypeDefinitionBase)newType.TypeOf();
return(typeOfNewType.GetThisInstance());
case "arrayCreationExpression":
var elementType = GetResolvedSymbol(node.FindPreviousNode() as SyntaxTreeNode_Rule);
var arrayInstance = SymbolDefinition.ResolveNode(node, null, elementType);
return(arrayInstance ?? SymbolDefinition.builtInTypes_Array.GetThisInstance());
case "nonArrayType":
var typeNameType = GetResolvedSymbol(node.NodeAt(0)) as TypeDefinitionBase;
if (typeNameType == null || typeNameType.kind == SymbolKind.Error)
{
typeNameType = SymbolDefinition.builtInTypes_object;
}
return(node.NumValidNodes == 1 ? typeNameType : typeNameType.MakeNullableType());
case "typeName":
return(GetResolvedSymbol(node.NodeAt(0)));
case "namespaceOrTypeName":
return(GetResolvedSymbol(node.NodeAt(node.NumValidNodes & ~1)));
case "accessIdentifier":
leaf = node.NumValidNodes < 2 ? null : node.LeafAt(1);
if (leaf != null && leaf.ResolvedSymbol == null)
{
SymbolResolver.ResolveNode(node);
}
return(leaf != null ? leaf.ResolvedSymbol : null);
case "predefinedType":
case "typeOrGeneric":
return(node.LeafAt(0).ResolvedSymbol);
case "typeofExpression":
return(((TypeDefinitionBase)ReflectedTypeReference.ForType(typeof(Type)).Definition).GetThisInstance());
case "sizeofExpression":
return(SymbolDefinition.builtInTypes_int.GetThisInstance());
case "localVariableType":
case "brackets":
case "expression":
case "unaryExpression":
case "parenExpression":
case "checkedExpression":
case "uncheckedExpression":
case "defaultValueExpression":
case "relationalExpression":
case "inclusiveOrExpression":
case "exclusiveOrExpression":
case "andExpression":
case "equalityExpression":
case "shiftExpression":
case "primaryExpression":
case "type":
return(SymbolDefinition.ResolveNode(node, null, null, 0));
default:
#if SI3_WARNINGS
Debug.LogWarning(node.RuleName);
#endif
return(SymbolDefinition.ResolveNode(node, null, null, 0));
}
}
private static extern LLVMOrcErrorCode LLVMOrcAddObjectFile(LLVMOrcJITStackRef @JITStack, out LLVMOrcModuleHandle retHandle, LLVMSharedObjectBufferRef @Obj, SymbolResolver @SymbolResolver, IntPtr @SymbolResolverCtx);
public StackWalker(NativeThread thread, ProcessMemoryAccessor memoryReader, SymbolResolver resolver)
{
walker = new DiaStackWalker();
helper = new StackWalkHelper(thread, memoryReader, resolver);
}
private string ConvertInstructionToString(InstructionStatementSyntax instruction, SymbolResolver resolver)
{
StringBuilder instructionBuilder = new StringBuilder();
instructionBuilder.Append(instruction.InstructionToken.Text);
if (instruction.Operands.Any())
{
int operandIndex = 0;
instructionBuilder.Append(" ");
foreach (var operand in instruction.Operands)
{
instructionBuilder.Append(resolver.ResolveSymbol(operand));
if (++operandIndex != instruction.Operands.Count())
{
instructionBuilder.Append(",");
}
}
}
return(instructionBuilder.ToString());
}
internal static WorkflowApplication CreateDatabaseScriptGenerationWorkflow(
SynchronizationContext syncContext,
Project project,
string artifactPath,
FileInfo workflowFileInfo,
string templatePath,
EdmItemCollection edmItemCollection,
string existingSsdl,
string existingMsl,
string databaseSchemaName,
string databaseName,
string providerInvariantName,
string providerConnectionString,
string providerManifestToken,
Version targetVersion,
Action<WorkflowApplicationCompletedEventArgs> workflowCompletedHandler,
Func<WorkflowApplicationUnhandledExceptionEventArgs, UnhandledExceptionAction> unhandledExceptionHandler)
{
// Inputs are specific to the workflow. No need to provide a strongly typed bag here
// because the workflow has to define these.
var inputs = new Dictionary<string, object>
{
{ EdmConstants.csdlInputName, edmItemCollection },
{ EdmConstants.existingSsdlInputName, existingSsdl },
{ EdmConstants.existingMslInputName, existingMsl }
};
// Initialize the AssemblyLoader. This will cache project/website references and proffer assembly
// references to the XamlSchemaContext as well as the OutputGeneratorActivities
var assemblyLoader = new DatabaseGenerationAssemblyLoader(project, VsUtils.GetVisualStudioInstallDir());
// Parameters can be used throughout the workflow. These are more ubiquitous than inputs and
// so they do not need to be defined ahead of time in the workflow.
var edmWorkflowSymbolResolver = new EdmParameterBag(
syncContext, assemblyLoader, targetVersion, providerInvariantName, providerManifestToken, providerConnectionString,
databaseSchemaName, databaseName, templatePath, artifactPath);
// Deserialize the XAML file into a Activity
Activity modelFirstWorkflowElement;
using (var stream = workflowFileInfo.OpenRead())
{
using (
var xamlXmlReader = new XamlXmlReader(XmlReader.Create(stream), new DatabaseGenerationXamlSchemaContext(assemblyLoader))
)
{
modelFirstWorkflowElement = ActivityXamlServices.Load(xamlXmlReader);
}
}
// Create a WorkflowInstance from the WorkflowElement and pass in the inputs
var workflowInstance = new WorkflowApplication(modelFirstWorkflowElement, inputs);
// Attach a SymbolResolver for external parameters; this is like the ParameterBag
var symbolResolver = new SymbolResolver();
symbolResolver.Add(typeof(EdmParameterBag).Name, edmWorkflowSymbolResolver);
workflowInstance.Extensions.Add(symbolResolver);
workflowInstance.Completed = workflowCompletedHandler;
workflowInstance.OnUnhandledException = unhandledExceptionHandler;
return workflowInstance;
}
public static void _Resolve(this SymbolResolver _this, ResolveParams rp)
{
}
public CilGrammar(CilGrammarSource source, ILogging logging)
{
Type definitionType = source.DefinitionType;
GlobalContextProvider = new CilContextProvider(definitionType);
this.IsValid = true;
var startMeta = MetadataParser.EnumerateAndBind(definitionType);
if (startMeta.Count() == 0)
{
throw new InvalidOperationException(
string.Format(
"No metadata found in language definition '{0}'",
definitionType.FullName));
}
this.SymbolResolver = new CilSymbolRefResolver();
this.Start = CilSymbolRef.Create(typeof(void));
var collector = new MetadataCollector(logging);
collector.AddSymbol(Start);
foreach (var meta in startMeta)
{
collector.AddMeta(meta);
}
if (collector.HasInvalidData)
{
this.IsValid = false;
}
this.metadata = collector.Metadata;
this.productions = collector.Productions;
foreach (var tid in collector.Symbols)
{
SymbolResolver.Link(tid);
}
var categories = new [] { SymbolCategory.Beacon, SymbolCategory.DoNotInsert, SymbolCategory.DoNotDelete, SymbolCategory.ExplicitlyUsed };
foreach (var category in categories)
{
foreach (var symbol in metadata.SelectMany(m => m.GetSymbolsInCategory(category)))
{
var def = SymbolResolver.Resolve(symbol);
def.Categories |= category;
}
}
if (productions.Count == 0)
{
throw new InvalidOperationException(
string.Format(
"Language definition '{0}' should have at least one parse production",
definitionType.FullName));
}
this.mergers
= metadata
.SelectMany(meta => meta.GetMergers(collector.Symbols))
.ToArray();
var terminals = collector.Symbols.Except(productions.Select(r => r.Outcome).Distinct()).ToArray();
var scanDataCollector = new ScanDataCollector(terminals, logging);
scanDataCollector.AddCondition(definitionType);
if (scanDataCollector.HasInvalidData)
{
this.IsValid = false;
}
conditions = scanDataCollector.Conditions;
LinkRelatedTokens(conditions);
var allTerms = (from t in scanDataCollector.Terminals
let def = SymbolResolver.Resolve(t)
where def != null
select def)
.Distinct();
var termsProducedByScanner =
(from cond in scanDataCollector.Conditions
from prod in cond.Matchers
from outcome in prod.AllOutcomes
let def = SymbolResolver.Resolve(outcome)
where def != null
select def)
.Distinct();
var undefinedTerminals = allTerms
.Where(symbol => !IsSpecialSymbol(symbol))
.Except(termsProducedByScanner);
CheckAllScanRulesDefined(undefinedTerminals, source.Origin, logging);
precedence = metadata.SelectMany(m => m.GetSymbolPrecedence()).ToList();
LocalContextProviders = metadata.SelectMany((m, index) => m.GetLocalContextProviders());
this.Reports = metadata.SelectMany(m => m.GetReports()).ToArray();
}
[ClassInitialize] public static async Task ClassInitialize(TestContext tc) => symbols = await SymbolResolver.ForMyTests(tc.CancellationTokenSource.Token).Caf();
/// <summary>
/// Compiles a TaffyScript project.
/// </summary>
/// <param name="projectDir">The directory of the TaffyScript project.</param>
/// <returns></returns>
public override CompilerResult CompileProject(string projectDir)
{
var config = GetBuildConfig(projectDir);
if (config == null)
{
return(new CompilerResult(_logger));
}
if (string.IsNullOrEmpty(config.Output))
{
_logger.Error("The config file must contain an output path.", null);
return(new CompilerResult(_logger));
}
var dir = Path.Combine(projectDir, Path.GetDirectoryName(config.Output));
Directory.CreateDirectory(dir);
config.Output = Path.GetFileName(config.Output);
var expectedOutput = Path.Combine(dir, config.Output);
VerifyReferencesExists(projectDir, dir, config);
if (_logger.Errors.Count != 0)
{
return(new CompilerResult(_logger));
}
var table = new SymbolTable();
var root = new RootNode();
var parser = new Parser(_logger, table, root);
ParseFilesInProjectDirectory(projectDir, parser, GetExcludeSet(projectDir, config));
if (_logger.Errors.Count != 0)
{
return(new CompilerResult(_logger));
}
var symbolResolver = new SymbolResolver(table, _logger);
var resolver = new Resolver(_logger, table, symbolResolver);
// You MUST create the generator before resolving so it can load in
// the included assemblies.
var generator = new MsilWeakCodeGen(table, symbolResolver, config, _logger);
resolver.Resolve(root);
if (_logger.Errors.Count != 0)
{
return(new CompilerResult(_logger));
}
var result = generator.CompileTree(root);
if (result.Errors.Count > 0)
{
return(result);
}
else
{
expectedOutput += Path.GetExtension(result.PathToAssembly);
CopyFileIfNewer(typeof(TsObject).Assembly.Location, Path.Combine(dir, typeof(TsObject).Assembly.GetName().Name + ".dll"));
if (result.PathToAssembly != expectedOutput)
{
if (File.Exists(expectedOutput))
{
File.Delete(expectedOutput);
}
MoveFile(result.PathToAssembly, expectedOutput);
return(new CompilerResult(result.CompiledAssebmly, expectedOutput, _logger));
}
}
return(result);
}
public Resolver(IErrorLogger logger, SymbolTable table, SymbolResolver resolver)
{
_logger = logger;
_table = table;
_resolver = resolver;
}
public SymbolInstructionInfo(int codeSize, string hexBytes, Code code, Action <FormatterOptions> enableOption, SymbolResolver symbolResolver)
{
CodeSize = codeSize;
HexBytes = hexBytes;
Code = code;
InitOptions = enableOption;
InitDecoder = initDecoderDefault;
SymbolResolver = symbolResolver;
}
public static void InvokeActivity(Activity activity, SymbolResolver symbolResolver)
{
InvokeActivity(activity, symbolResolver, s_DEFAULT_TIMEOUT);
}
public IBufferWriter <byte> Emit(IBufferWriter <byte> stream, InstructionStatementSyntax instruction, SymbolResolver resolver)
{
stream.Write(Assemble(instruction, resolver));
return(stream);
}
internal static WorkflowApplication CreateDatabaseScriptGenerationWorkflow(
SynchronizationContext syncContext,
Project project,
string artifactPath,
FileInfo workflowFileInfo,
string templatePath,
EdmItemCollection edmItemCollection,
string existingSsdl,
string existingMsl,
string databaseSchemaName,
string databaseName,
string providerInvariantName,
string providerConnectionString,
string providerManifestToken,
Version targetVersion,
Action <WorkflowApplicationCompletedEventArgs> workflowCompletedHandler,
Func <WorkflowApplicationUnhandledExceptionEventArgs, UnhandledExceptionAction> unhandledExceptionHandler)
{
// Inputs are specific to the workflow. No need to provide a strongly typed bag here
// because the workflow has to define these.
var inputs = new Dictionary <string, object>
{
{ EdmConstants.csdlInputName, edmItemCollection },
{ EdmConstants.existingSsdlInputName, existingSsdl },
{ EdmConstants.existingMslInputName, existingMsl }
};
// Initialize the AssemblyLoader. This will cache project/website references and proffer assembly
// references to the XamlSchemaContext as well as the OutputGeneratorActivities
var assemblyLoader = new DatabaseGenerationAssemblyLoader(project, VsUtils.GetVisualStudioInstallDir());
// Parameters can be used throughout the workflow. These are more ubiquitous than inputs and
// so they do not need to be defined ahead of time in the workflow.
var edmWorkflowSymbolResolver = new EdmParameterBag(
syncContext, assemblyLoader, targetVersion, providerInvariantName, providerManifestToken, providerConnectionString,
databaseSchemaName, databaseName, templatePath, artifactPath);
// Deserialize the XAML file into a Activity
Activity modelFirstWorkflowElement;
using (var stream = workflowFileInfo.OpenRead())
{
using (
var xamlXmlReader = new XamlXmlReader(XmlReader.Create(stream), new DatabaseGenerationXamlSchemaContext(assemblyLoader))
)
{
modelFirstWorkflowElement = ActivityXamlServices.Load(xamlXmlReader);
}
}
// Create a WorkflowInstance from the WorkflowElement and pass in the inputs
var workflowInstance = new WorkflowApplication(modelFirstWorkflowElement, inputs);
// Attach a SymbolResolver for external parameters; this is like the ParameterBag
var symbolResolver = new SymbolResolver();
symbolResolver.Add(typeof(EdmParameterBag).Name, edmWorkflowSymbolResolver);
workflowInstance.Extensions.Add(symbolResolver);
workflowInstance.Completed = workflowCompletedHandler;
workflowInstance.OnUnhandledException = unhandledExceptionHandler;
return(workflowInstance);
}
internal StackWalkHelper(NativeThread thread, ProcessMemoryAccessor memoryAccessor, SymbolResolver resolver)
{
Thread = thread;
MemoryAccessor = memoryAccessor;
Resolver = resolver;
}
