private static int runLines(Interpreter interp,
IEnumerable <string> lines)
{
var ls = new LocalScope("code-inner");
var obj = new UserObject();
interp.Extend(obj);
ls.AddLocalDef("self", obj);
interp.ExtendMinor(ls);
var memo = interp.Memorise();
bool unfinished;
GraceObject result;
foreach (var line in lines)
{
int r = REPL.RunLine(interp, obj, memo, line, out unfinished,
out result);
if (r != 0)
{
return(r);
}
if (unfinished)
{
return(1);
}
}
return(0);
}
public ClassDeclaration(INode parent, Scope parentScope, bool isPrintable = true, bool codeGeneration = true)
{
Parent = parent;
Scope = new LocalScope(parentScope);
IsPrintable = isPrintable;
CodeGeneration = codeGeneration;
}
//public override void SendUpdateToClient(UpdateMessage update)
//{
// Console.WriteLine("Send update...");
// WebSocketOODSSServer server = (WebSocketOODSSServer) LocalScope.Get(SessionObjects.WebSocketOODSSServer);
//}
/// <summary>
/// send update message to client
/// </summary>
/// <param name="update">update message</param>
/// <param name="receivingSessionId">sessionId of the client</param>
public override void SendUpdateToClient(UpdateMessage update, string receivingSessionId)
{
Console.WriteLine("Send Update Message Please");
WebSocketOODSSServer server = (WebSocketOODSSServer)LocalScope.Get(SessionObjects.WebSocketOODSSServer);
server.SendUpdateMessage(receivingSessionId, update);
}
/// <summary>Performs set-up behaviour shared by multiple
/// constructors</summary>
private void initialise()
{
var s = new LocalScope();
scope.scope = s;
majorScope = s;
s.AddMethod("print(_)",
new DelegateMethod1Ctx(Print));
s.AddLocalDef("true", GraceBoolean.True);
s.AddLocalDef("false", GraceBoolean.False);
s.AddMethod("_base_while_do(_,_)",
new DelegateMethodReq(BaseWhileDo));
s.AddMethod("_base_try_catch_finally(_,_)",
new DelegateMethodReq(BaseTryCatchFinally));
s.AddMethod("_base_try_catch_finally(_,_,_)",
new DelegateMethodReq(BaseTryCatchFinally));
s.AddMethod("_base_try_catch_finally(_,_,_,_)",
new DelegateMethodReq(BaseTryCatchFinally));
s.AddMethod("_base_try_catch_finally(_,_,_,_,_)",
new DelegateMethodReq(BaseTryCatchFinally));
s.AddMethod("_base_try_catch_finally(_,_,_,_,_,_)",
new DelegateMethodReq(BaseTryCatchFinally));
s.AddMethod("_base_try_catch_finally(_,_,_,_,_,_,_)",
new DelegateMethodReq(BaseTryCatchFinally));
s.AddMethod("Exception",
new ConstantMethod(
new GraceExceptionKind("Exception")));
}
private static int wsrepl(string filename)
{
var ws = new Grace.Execution.WebSocketServer();
var wss = ws.Start();
var ls = new LocalScope("repl-inner");
var obj = new UserObject();
var interp = REPL.CreateInterpreter(obj, ls,
new WSOutputSink(wss));
interp.LoadPrelude();
var dir = Path.GetFullPath(".");
interp.AddModuleRoot(dir);
ErrorReporting.SilenceError("P1001");
var memo = interp.Memorise();
string accum = String.Empty;
bool unfinished;
GraceObject result;
wss.JsonReceived += (o, e) => {
var je = (JsonWSEvent)e;
var root = je.Root;
var cn = root.XPathSelectElement("//code");
if (cn == null)
{
return;
}
var line = cn.Value;
//var line = ((TextWSEvent)e).Text;
Console.WriteLine("got text: " + line);
accum += line.Replace("\u0000", "") + "\n";
var r = REPL.RunLine(
interp, obj, memo, accum, out unfinished,
out result);
if (result != null)
{
ls["LAST"] = result;
}
if (unfinished)
{
// "Unexpected end of file" is expected here
// for unfinished statements.
unfinished = false;
}
else if (r != 0)
{
// All other errors are errors, and should
// clear the accumulated buffer and let the
// user start again.
accum = String.Empty;
}
else
{
accum = String.Empty;
}
};
wss.Run();
return(0);
}
/// <summary>
/// Create a REPL-ready interpreter using a given
/// module object and interior scope.
/// </summary>
/// <param name="obj">
/// Module object
/// </param>
/// <param name="localScope">
/// Interior scope which holds (at least) "self".
/// </param>
public static Interpreter CreateInterpreter(UserObject obj,
LocalScope localScope)
{
var interp = new Interpreter();
configureInterpreter(interp, obj, localScope);
return(interp);
}
/// <summary>
/// Creates a new isolated scope. After than any value added to this content object will be released once
/// <see cref="ReleaseScope" /> is called. The previous scope is linked such that its values are still available.
/// </summary>
public void EnterChildScope()
{
if (MaxRecursion > 0 && _recursion++ > MaxRecursion)
{
throw new InvalidOperationException("The maximum level of recursion has been reached. Your script must have a cyclic include statement.");
}
LocalScope = LocalScope.EnterChildScope();
}
private static void configureInterpreter(Interpreter interp,
UserObject obj, LocalScope localScope)
{
interp.LoadPrelude();
interp.Extend(obj);
localScope.AddLocalDef("self", obj);
localScope.AddLocalDef("LAST", GraceObject.Done);
interp.ExtendMinor(localScope);
}
/// <summary>
/// Constructs a new scope.
/// </summary>
/// <param name="localScope">The current local scope.</param>
/// <param name="metadataReader">The assocated metadata reader.</param>
internal MethodScope(
LocalScope localScope,
MetadataReader metadataReader)
{
MetadataReader = metadataReader;
StartOffset = localScope.StartOffset;
Length = localScope.Length;
localVariables = localScope.GetLocalVariables();
}
public LocalScopeEntry(PEFile module, MetadataReader metadata, bool isEmbedded, LocalScopeHandle handle)
{
this.offset = isEmbedded ? null : (int?)metadata.GetTableMetadataOffset(TableIndex.LocalScope)
+ metadata.GetTableRowSize(TableIndex.LocalScope) * (MetadataTokens.GetRowNumber(handle) - 1);
this.module = module;
this.metadata = metadata;
this.handle = handle;
this.localScope = metadata.GetLocalScope(handle);
}
public void ReleaseScope()
{
LocalScope = LocalScope.ReleaseScope();
if (LocalScope == null)
{
throw new InvalidOperationException();
}
}
/// <summary>
/// Ends a scope.
/// </summary>
/// <param name="isLocalScope">If set to <c>true</c> is local scope.</param>
public void EndScope(bool isLocalScope = false)
{
if (isLocalScope)
{
currentLocalScope = currentLocalScope.ParentScope;
}
CurrentScope = CurrentScope.ParentScope;
}
public Object Invoke(Object[] arguments)
{
var scope = new LocalScope(_parentScope);
var ctx = new ExecutionContext(_operations, scope);
ctx.Push(_pointer);
ctx.Push(arguments);
ctx.Execute();
return(ctx.Pop());
}
public LocalScope(CodeGenerator codegen, LocalScope parent, ScopeType type, int from, int to)
{
Contract.ThrowIfNull(codegen);
Debug.Assert(from < to);
_codegen = codegen;
_parent = parent;
_type = type;
_from = from;
_to = to;
}
/// <summary>
/// Frees the memory associated with the specified scope, and
/// generates code to decrement the stack pointer accordingly.
/// </summary>
/// <param name="scope">the scope to free</param>
/// <param name="unDeclareVars">whether to also un-define the local
/// variables to prevent further use</param>
private void FreeLocalVariables(LocalScope scope, bool unDeclareVars)
{
foreach (ScriptVariable variable in scope.Members)
{
// TODO: Generate code to free local variables
if (unDeclareVars)
{
// TODO: Undefine local variables
}
}
}
/// <summary>
/// Frees the memory associated with the specified scope, and
/// generates code to decrement the stack pointer accordingly.
/// </summary>
/// <param name="scope">the scope to free</param>
/// <param name="unDeclareVars">whether to also un-define the local
/// variables to prevent further use</param>
private void FreeLocalVariables(LocalScope scope, bool unDeclareVars)
{
foreach (ScriptVariable variable in scope.Members)
{
// TODO: Generate code to free local variables
if (unDeclareVars)
{
// TODO: Undefine local variables
}
}
}
public BlockStatement(INode parent, Scope parentScope, bool introduceScope = true)
{
Parent = parent;
if (introduceScope)
{
Scope = new LocalScope(parentScope);
}
else
{
Scope = parentScope;
}
}
private static bool GetLocalsInfoForMethod(string assemblyPath, int methodToken, out List <LocalVarInfo> locals)
{
locals = null;
OpenedReader openedReader = GetReader(assemblyPath, isFileLayout: true, peStream: null, pdbStream: null);
if (openedReader == null)
{
return(false);
}
using (openedReader)
{
try
{
Handle handle = MetadataTokens.Handle(methodToken);
if (handle.Kind != HandleKind.MethodDefinition)
{
return(false);
}
locals = new List <LocalVarInfo>();
MethodDebugInformationHandle methodDebugHandle =
((MethodDefinitionHandle)handle).ToDebugInformationHandle();
LocalScopeHandleCollection localScopes = openedReader.Reader.GetLocalScopes(methodDebugHandle);
foreach (LocalScopeHandle scopeHandle in localScopes)
{
LocalScope scope = openedReader.Reader.GetLocalScope(scopeHandle);
LocalVariableHandleCollection localVars = scope.GetLocalVariables();
foreach (LocalVariableHandle varHandle in localVars)
{
LocalVariable localVar = openedReader.Reader.GetLocalVariable(varHandle);
if (localVar.Attributes == LocalVariableAttributes.DebuggerHidden)
{
continue;
}
LocalVarInfo info = new LocalVarInfo();
info.startOffset = scope.StartOffset;
info.endOffset = scope.EndOffset;
info.name = openedReader.Reader.GetString(localVar.Name);
locals.Add(info);
}
}
}
catch
{
return(false);
}
}
return(true);
}
private LocalScope CreateLocalScope(Scope parent, Vector <Parameter> parameters)
{
var locals = new LocalScope(parent);
foreach (var parameter in parameters)
{
if (!locals.TryIncludeUniqueBinding(parameter))
{
LogError(CompilerError.DuplicateIdentifier(parameter.Position, parameter));
}
}
return(locals);
}
/// <summary>
/// Exits the current scope that has been created by <see cref="EnterChildScope" />
/// </summary>
public void ReleaseScope()
{
if (_recursion > 0)
{
_recursion--;
}
LocalScope = LocalScope.ReleaseScope();
if (LocalScope == null)
{
throw new InvalidOperationException();
}
}
protected static Scope Scope(params TypeMapping[] locals)
{
var globalScope = new GlobalScope();
var localScope = new LocalScope(globalScope);
foreach (var local in locals)
{
var item = local(null);
var name = local.Method.GetParameters()[0].Name;
localScope.Bind(name, item);
}
return(localScope);
}
internal static bool GetLocalVariableAndScopeByIndex(IntPtr symbolReaderHandle, int methodToken, int localIndex, out string localVarName, out int ilStartOffset, out int ilEndOffset)
{
Debug.Assert(symbolReaderHandle != IntPtr.Zero);
localVarName = null;
ilStartOffset = 0;
ilEndOffset = 0;
GCHandle gch = GCHandle.FromIntPtr(symbolReaderHandle);
MetadataReader reader = ((OpenedReader)gch.Target).Reader;
try
{
Handle handle = MetadataTokens.Handle(methodToken);
if (handle.Kind != HandleKind.MethodDefinition)
{
return(false);
}
MethodDebugInformationHandle methodDebugHandle = ((MethodDefinitionHandle)handle).ToDebugInformationHandle();
LocalScopeHandleCollection localScopes = reader.GetLocalScopes(methodDebugHandle);
foreach (LocalScopeHandle scopeHandle in localScopes)
{
LocalScope scope = reader.GetLocalScope(scopeHandle);
LocalVariableHandleCollection localVars = scope.GetLocalVariables();
foreach (LocalVariableHandle varHandle in localVars)
{
LocalVariable localVar = reader.GetLocalVariable(varHandle);
if (localVar.Index == localIndex)
{
if (localVar.Attributes == LocalVariableAttributes.DebuggerHidden)
{
return(false);
}
localVarName = reader.GetString(localVar.Name);
ilStartOffset = scope.StartOffset;
ilEndOffset = scope.EndOffset;
return(true);
}
}
}
}
catch
{
}
return(false);
}
/// <summary>
/// Helper method to return local variable name for given local index and IL offset.
/// </summary>
/// <param name="assemblyFileName">file name of the assembly</param>
/// <param name="methodToken">method token</param>
/// <param name="localIndex">local variable index</param>
/// <param name="localVarName">local variable name return</param>
/// <returns>true if name has been found</returns>
public static bool GetLocalVariableByIndex(string assemblyFileName, int methodToken, int localIndex, out string localVarName)
{
MetadataReader peReader, pdbReader;
localVarName = null;
try
{
if (!GetReaders(assemblyFileName, out peReader, out pdbReader))
{
return(false);
}
Handle handle = MetadataTokens.Handle(methodToken);
if (handle.Kind != HandleKind.MethodDefinition)
{
return(false);
}
MethodDebugInformationHandle methodDebugHandle = ((MethodDefinitionHandle)handle).ToDebugInformationHandle();
LocalScopeHandleCollection localScopes = pdbReader.GetLocalScopes(methodDebugHandle);
foreach (LocalScopeHandle scopeHandle in localScopes)
{
LocalScope scope = pdbReader.GetLocalScope(scopeHandle);
LocalVariableHandleCollection localVars = scope.GetLocalVariables();
foreach (LocalVariableHandle varHandle in localVars)
{
LocalVariable localVar = pdbReader.GetLocalVariable(varHandle);
if (localVar.Index == localIndex)
{
if (localVar.Attributes == LocalVariableAttributes.DebuggerHidden)
{
return(false);
}
localVarName = pdbReader.GetString(localVar.Name);
return(true);
}
}
}
return(false);
}
finally
{
peReader = null;
pdbReader = null;
}
}
private static bool conditionsMet(
string l,
Dictionary <string, string> data
)
{
var interpreter = new Interpreter();
interpreter.LoadPrelude();
var ls = new LocalScope();
foreach (var k in data.Keys)
{
switch (k)
{
case "method":
case "type":
case "class":
case "object":
case "def":
case "var":
case "dialect":
case "import":
case "return":
case "is":
case "where":
ls.AddLocalDef(k + "_", GraceString.Create(data[k]));
break;
default:
ls.AddLocalDef(k, GraceString.Create(data[k]));
break;
}
}
interpreter.Extend(ls);
while (l.StartsWith("|["))
{
int end = l.IndexOf("]|");
var condition = l.Substring(2, end - 2);
if (!conditionMet(condition, data, interpreter))
{
return(false);
}
l = l.Substring(end + 2);
}
return(true);
}
/// <summary>
/// Helper method to return local variable name for given local index and IL offset.
/// </summary>
/// <param name="openedReader">symbol reader returned by LoadSymbolsForModule</param>
/// <param name="methodToken">method token</param>
/// <param name="localIndex">local variable index</param>
/// <param name="localVarName">local variable name return</param>
/// <returns>true if name has been found</returns>
private bool GetLocalVariableByIndex(
OpenedReader openedReader,
int methodToken,
int localIndex,
out string localVarName)
{
localVarName = null;
MetadataReader reader = openedReader.Reader;
try
{
Handle handle = MetadataTokens.Handle(methodToken);
if (handle.Kind != HandleKind.MethodDefinition)
{
return(false);
}
MethodDebugInformationHandle methodDebugHandle = ((MethodDefinitionHandle)handle).ToDebugInformationHandle();
LocalScopeHandleCollection localScopes = reader.GetLocalScopes(methodDebugHandle);
foreach (LocalScopeHandle scopeHandle in localScopes)
{
LocalScope scope = reader.GetLocalScope(scopeHandle);
LocalVariableHandleCollection localVars = scope.GetLocalVariables();
foreach (LocalVariableHandle varHandle in localVars)
{
LocalVariable localVar = reader.GetLocalVariable(varHandle);
if (localVar.Index == localIndex)
{
if (localVar.Attributes == LocalVariableAttributes.DebuggerHidden)
{
return(false);
}
localVarName = reader.GetString(localVar.Name);
return(true);
}
}
}
}
catch (Exception ex)
{
Trace.TraceError($"GetLocalVariableByIndex: {ex.Message}");
}
return(false);
}
public void HasATypeInWhichOnlyGenericTypeVariablesAreFreshenedOnEachScopeLookup()
{
using (TypeVariable.TestFactory())
{
//Prevent type '1' from being freshened on type lookup by marking it as non-generic:
var typeVariable0 = TypeVariable.CreateGeneric();
var typeVariable1 = TypeVariable.CreateNonGeneric();
var expectedTypeAfterLookup = new NamedType("A", new TypeVariable(4), typeVariable1, new NamedType("B", new TypeVariable(4), typeVariable1));
var definedType = new NamedType("A", typeVariable0, typeVariable1, new NamedType("B", typeVariable0, typeVariable1));
var typeChecker = new TypeChecker();
var globalScope = new GlobalScope();
var localScope = new LocalScope(globalScope);
localScope.Bind("foo", definedType);
Type("foo", localScope, typeChecker).ShouldEqual(expectedTypeAfterLookup);
}
}
public void HasATypeInWhichOnlyGenericTypeVariablesAreFreshenedOnEachScopeLookup()
{
using (TypeVariable.TestFactory())
{
//Prevent type '1' from being freshened on type lookup by marking it as non-generic:
var typeVariable0 = TypeVariable.CreateGeneric();
var typeVariable1 = TypeVariable.CreateNonGeneric();
var expectedTypeAfterLookup = new NamedType("A", new TypeVariable(8), typeVariable1, new NamedType("B", new TypeVariable(8), typeVariable1));
var definedType = new NamedType("A", typeVariable0, typeVariable1, new NamedType("B", typeVariable0, typeVariable1));
var typeChecker = new TypeChecker();
var globalScope = new GlobalScope();
var localScope = new LocalScope(globalScope);
localScope.Bind("foo", definedType);
Type("foo", localScope, typeChecker).ShouldEqual(expectedTypeAfterLookup);
}
}
internal void GenerateScope(BoundBlock block, ScopeType type, int to)
{
Contract.ThrowIfNull(block);
// open scope
_scope = new LocalScope(this, _scope, type, block.Ordinal, to);
_scope.ContinueWith(block);
while ((block = _scope.Dequeue()) != null)
{
GenerateBlock(block);
}
// close scope
_scope = _scope.Parent;
//
_il.AssertStackEmpty();
}
/// <summary>
/// Begins a new scope.
/// </summary>
/// <param name="isLocalScope">If set to <c>true</c> is local scope.</param>
public void BeginScope(bool isLocalScope = false)
{
if (isLocalScope)
{
currentLocalScope = new LocalScope(currentLocalScope);
}
Scope newScope = new Scope(CurrentScope);
if (lastScope != null)
{
lastScope.NextScope = newScope;
}
else
{
globalScope.NextScope = newScope;
}
CurrentScope.AddScope(newScope);
CurrentScope = newScope;
lastScope = newScope;
}
internal void Dump()
{
Console.WriteLine("Code offset: {0:X8}", CodeReader.Offset);
Console.WriteLine("EvalStack: {0}", _evalStack.Count);
if (_evalStack.Count > 0)
{
var evalStackValues = new JSValue[_evalStack.Count];
_evalStack.CopyTo(evalStackValues, 0);
for (var i = evalStackValues.Length - 1; i >= 0; i--)
{
Console.WriteLine("[{0:D3}] - {1}", i, evalStackValues[i]);
}
}
Console.WriteLine("Local variables: {0}", Function.CompiledFunction.DeclaredVariables.Length);
foreach (var variableName in Function.CompiledFunction.DeclaredVariables)
{
Console.WriteLine("{0} = {1}", variableName, LocalScope.GetVariable(variableName));
}
Console.WriteLine();
}
/// <summary>
/// Initializes a new instance of the <see cref="PdbLocalScope"/> class.
/// </summary>
/// <param name="function">Function that contains this scope.</param>
/// <param name="handle">Our metadata reader handle.</param>
/// <param name="parent">Parent scope.</param>
internal PdbLocalScope(PdbFunction function, LocalScopeHandle handle, IPdbLocalScope parent = null)
{
Function = function;
localScopeCache = SimpleCache.CreateStruct(() => function.PdbFile.Reader.GetLocalScope(handle));
childrenCache = SimpleCache.CreateStruct(() =>
{
var enumerator = LocalScope.GetChildren();
List <IPdbLocalScope> children = new List <IPdbLocalScope>();
while (enumerator.MoveNext())
{
children.Add(new PdbLocalScope(function, enumerator.Current, this));
}
return(children);
});
constantsCache = SimpleCache.CreateStruct(() =>
{
var localConstants = LocalScope.GetLocalConstants();
IPdbLocalConstant[] constants = new IPdbLocalConstant[localConstants.Count];
int i = 0;
foreach (var c in localConstants)
{
constants[i++] = new PdbLocalConstant(this, c);
}
return(constants);
});
variablesCache = SimpleCache.CreateStruct(() =>
{
var localVariables = LocalScope.GetLocalVariables();
IPdbLocalVariable[] variables = new IPdbLocalVariable[localVariables.Count];
int i = 0;
foreach (var v in localVariables)
{
variables[i++] = new PdbLocalVariable(this, v);
}
return(variables);
});
}
/// <summary>
/// Binds the parameters to local variables in the function scope.
/// </summary>
/// <param name="name">
/// The name of the parameter to bind the value to.
/// </param>
/// <param name="value">
/// The value to bind to the parameter. It should be assumed by
/// derived classes that the proper type coercion has already taken
/// place and that any prerequisite metadata has been satisfied.
/// </param>
/// <param name="parameterMetadata"></param>
internal override void BindParameter(string name, object value, CompiledCommandParameter parameterMetadata)
{
if (value == AutomationNull.Value || value == UnboundParameter.Value)
{
value = null;
}
Diagnostics.Assert(name != null, "The caller should verify that name is not null");
var varPath = new VariablePath(name, VariablePathFlags.Variable);
// If the parameter was allocated in the LocalsTuple, we can avoid creating a PSVariable,
if (LocalScope != null &&
varPath.IsAnyLocal() &&
LocalScope.TrySetLocalParameterValue(varPath.UnqualifiedPath, CopyMutableValues(value)))
{
return;
}
// Otherwise we'll fall through and enter a new PSVariable in the current scope. This
// is what normally happens when dotting (though the above may succeed if a parameter name
// was an automatic variable like $PSBoundParameters.
// First we need to make a variable instance and apply
// any attributes from the script.
PSVariable variable = new PSVariable(varPath.UnqualifiedPath, value,
varPath.IsPrivate ? ScopedItemOptions.Private : ScopedItemOptions.None);
Context.EngineSessionState.SetVariable(varPath, variable, false, CommandOrigin.Internal);
RuntimeDefinedParameter runtimeDefinedParameter;
if (Script.RuntimeDefinedParameters.TryGetValue(name, out runtimeDefinedParameter))
{
// The attributes have already been checked and conversions run, so it is wrong
// to do so again.
variable.AddParameterAttributesNoChecks(runtimeDefinedParameter.Attributes);
}
}
public Expression TypeCheck(Block block, Scope scope)
{
var position = block.Position;
var variableDeclarations = block.VariableDeclarations;
var innerExpressions = block.InnerExpressions;
var localScope = new LocalScope(scope);
var typedVariableDeclarations = new List<VariableDeclaration>();
foreach (var variable in variableDeclarations)
{
var typedValue = TypeCheck(variable.Value, localScope);
var bindingType = variable.IsImplicitlyTyped
? typedValue.Type /*Replaces implicit type.*/
: TypeOf(variable.DeclaredTypeName);
var binding = new VariableDeclaration(variable.Position, variable.DeclaredTypeName, variable.Identifier, typedValue, bindingType);
if (!localScope.TryIncludeUniqueBinding(binding))
LogError(CompilerError.DuplicateIdentifier(binding.Position, binding));
Unify(typedValue.Position, bindingType, typedValue.Type);
typedVariableDeclarations.Add(binding);
}
var typedInnerExpressions = TypeCheck(innerExpressions, localScope);
var blockType = typedInnerExpressions.Last().Type;
return new Block(position, typedVariableDeclarations.ToVector(), typedInnerExpressions, blockType);
}
/// <summary>
/// Ends a scope.
/// </summary>
/// <param name="isLocalScope">If set to <c>true</c> is local scope.</param>
public void EndScope (bool isLocalScope = false)
{
if (isLocalScope) {
currentLocalScope = currentLocalScope.ParentScope;
}
CurrentScope = CurrentScope.ParentScope;
}
public LocalScope (LocalScope parentScope)
{
ParentScope = parentScope;
NextLocal = 0;
}
/// <summary>
/// Begins a new scope.
/// </summary>
/// <param name="isLocalScope">If set to <c>true</c> is local scope.</param>
public void BeginScope (bool isLocalScope = false)
{
if (isLocalScope) {
currentLocalScope = new LocalScope (currentLocalScope);
}
Scope newScope = new Scope (CurrentScope);
if (lastScope != null) {
lastScope.NextScope = newScope;
} else {
globalScope.NextScope = newScope;
}
CurrentScope.AddScope (newScope);
CurrentScope = newScope;
lastScope = newScope;
}
private LocalScope CreateLocalScope(Scope parent, Vector<Function> methods)
{
var locals = new LocalScope(parent);
foreach (var method in methods)
if (!locals.TryIncludeUniqueBinding(method))
LogError(CompilerError.DuplicateIdentifier(method.Position, method));
return locals;
}
private LocalScope CreateLocalScope(Scope parent, Vector<Parameter> parameters)
{
var locals = new LocalScope(parent);
foreach (var parameter in parameters)
if (!locals.TryIncludeUniqueBinding(parameter))
LogError(CompilerError.DuplicateIdentifier(parameter.Position, parameter));
return locals;
}
private void DefineScopeLocals(LocalScope currentScope, StandaloneSignatureHandle localSignatureHandleOpt)
{
foreach (ILocalDefinition scopeConstant in currentScope.Constants)
{
var signatureHandle = _metadataWriter.SerializeLocalConstantStandAloneSignature(scopeConstant);
if (!_metadataWriter.IsLocalNameTooLong(scopeConstant))
{
DefineLocalConstant(scopeConstant.Name, scopeConstant.CompileTimeValue.Value, _metadataWriter.GetConstantTypeCode(scopeConstant), signatureHandle);
}
}
foreach (ILocalDefinition scopeLocal in currentScope.Variables)
{
if (!_metadataWriter.IsLocalNameTooLong(scopeLocal))
{
Debug.Assert(scopeLocal.SlotIndex >= 0);
DefineLocalVariable((uint)scopeLocal.SlotIndex, scopeLocal.Name, scopeLocal.PdbAttributes, localSignatureHandleOpt);
}
}
}
