/// <summary> /// Gets the code snippet represented by a source ref /// </summary> /// <param name="sourceCodeRef">The source code reference.</param> /// <returns></returns> public string GetCodeSnippet(SourceRef sourceCodeRef) { if (sourceCodeRef.FromLine == sourceCodeRef.ToLine) { int from = AdjustStrIndex(Lines[sourceCodeRef.FromLine], sourceCodeRef.FromChar); int to = AdjustStrIndex(Lines[sourceCodeRef.FromLine], sourceCodeRef.ToChar); return Lines[sourceCodeRef.FromLine].Substring(from, to - from); } StringBuilder sb = new StringBuilder(); for (int i = sourceCodeRef.FromLine; i <= sourceCodeRef.ToLine; i++) { if (i == sourceCodeRef.FromLine) { int from = AdjustStrIndex(Lines[i], sourceCodeRef.FromChar); sb.Append(Lines[i].Substring(from)); } else if (i == sourceCodeRef.ToLine) { int to = AdjustStrIndex(Lines[i], sourceCodeRef.ToChar); sb.Append(Lines[i].Substring(0, to + 1)); } else { sb.Append(Lines[i]); } } return sb.ToString(); }
public ReturnStatement(ScriptLoadingContext lcontext, Expression e, SourceRef sref) : base(lcontext) { m_Expression = e; m_Ref = sref; lcontext.Source.Refs.Add(sref); }
public ForLoopStatement(ScriptLoadingContext lcontext, Token nameToken, Token forToken) : base(lcontext) { // for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end | // lexer already at the '=' ! [due to dispatching vs for-each] CheckTokenType(lcontext, TokenType.Op_Assignment); m_Start = Expression.Expr(lcontext); CheckTokenType(lcontext, TokenType.Comma); m_End = Expression.Expr(lcontext); if (lcontext.Lexer.Current.Type == TokenType.Comma) { lcontext.Lexer.Next(); m_Step = Expression.Expr(lcontext); } else { m_Step = new LiteralExpression(lcontext, DynValue.NewNumber(1)); } lcontext.Scope.PushBlock(); m_VarName = lcontext.Scope.DefineLocal(nameToken.Text); m_RefFor = forToken.GetSourceRef(CheckTokenType(lcontext, TokenType.Do)); m_InnerBlock = new CompositeStatement(lcontext); m_RefEnd = CheckTokenType(lcontext, TokenType.End).GetSourceRef(); m_StackFrame = lcontext.Scope.PopBlock(); lcontext.Source.Refs.Add(m_RefFor); lcontext.Source.Refs.Add(m_RefEnd); }
internal ScriptExecutionContext(Processor p, CallbackFunction callBackFunction, SourceRef sourceRef, bool isDynamic = false) { IsDynamicExecution = isDynamic; m_Processor = p; m_Callback = callBackFunction; CallingLocation = sourceRef; }
DebuggerAction IDebugger.GetAction(int ip, SourceRef sourceref) { PauseRequested = false; lock (m_Lock) if (Client != null) { Client.SendStopEvent(); } while (true) { lock (m_Lock) { if (Client == null) { return new DebuggerAction() { Action = DebuggerAction.ActionType.Run }; } if (m_PendingAction != null) { var action = m_PendingAction; m_PendingAction = null; return action; } } Sleep(10); } }
public SourceRef(SourceRef src, bool isStepStop) { SourceIdx = src.SourceIdx; FromChar = src.FromChar; ToChar = src.ToChar; FromLine = src.FromLine; ToLine = src.ToLine; IsStepStop = isStepStop; }
internal void DecorateMessage(Script script, SourceRef sref, int ip = -1) { if (sref != null) { DecoratedMessage = string.Format("{0}: {1}", sref.FormatLocation(script), Message); } else { DecoratedMessage = string.Format("bytecode:{0}: {1}", ip, Message); } }
public FunctionCallExpression(ScriptLoadingContext lcontext, Expression function, Token thisCallName) : base(lcontext) { Token callToken = thisCallName ?? lcontext.Lexer.Current; m_Name = thisCallName != null ? thisCallName.Text : null; m_DebugErr = function.GetFriendlyDebugName(); m_Function = function; switch (lcontext.Lexer.Current.Type) { case TokenType.Brk_Open_Round: Token openBrk = lcontext.Lexer.Current; lcontext.Lexer.Next(); Token t = lcontext.Lexer.Current; if (t.Type == TokenType.Brk_Close_Round) { m_Arguments = new List<Expression>(); SourceRef = callToken.GetSourceRef(t); lcontext.Lexer.Next(); } else { m_Arguments = ExprList(lcontext); SourceRef = callToken.GetSourceRef(CheckMatch(lcontext, openBrk, TokenType.Brk_Close_Round, ")")); } break; case TokenType.String: case TokenType.String_Long: { m_Arguments = new List<Expression>(); Expression le = new LiteralExpression(lcontext, lcontext.Lexer.Current); m_Arguments.Add(le); SourceRef = callToken.GetSourceRef(lcontext.Lexer.Current); } break; case TokenType.Brk_Open_Curly: case TokenType.Brk_Open_Curly_Shared: { m_Arguments = new List<Expression>(); m_Arguments.Add(new TableConstructor(lcontext, lcontext.Lexer.Current.Type == TokenType.Brk_Open_Curly_Shared)); SourceRef = callToken.GetSourceRefUpTo(lcontext.Lexer.Current); } break; default: throw new SyntaxErrorException(lcontext.Lexer.Current, "function arguments expected") { IsPrematureStreamTermination = (lcontext.Lexer.Current.Type == TokenType.Eof) }; } }
public ScopeBlockStatement(ScriptLoadingContext lcontext) : base(lcontext) { lcontext.Scope.PushBlock(); m_Do = CheckTokenType(lcontext, TokenType.Do).GetSourceRef(); m_Block = new CompositeStatement(lcontext); m_End = CheckTokenType(lcontext, TokenType.End).GetSourceRef(); m_StackFrame = lcontext.Scope.PopBlock(); lcontext.Source.Refs.Add(m_Do); lcontext.Source.Refs.Add(m_End); }
public DebuggerAction GetAction(int ip, SourceRef sourceref) { m_InstructionCounter += 1; if ((m_InstructionCounter % 1000) == 0) Console.Write("."); if (m_InstructionCounter > 50000) throw new MyException(); return new DebuggerAction() { Action = DebuggerAction.ActionType.StepIn, }; }
public IfStatement(ScriptLoadingContext lcontext) : base(lcontext) { while (lcontext.Lexer.Current.Type != TokenType.Else && lcontext.Lexer.Current.Type != TokenType.End) { m_Ifs.Add(CreateIfBlock(lcontext)); } if (lcontext.Lexer.Current.Type == TokenType.Else) { m_Else = CreateElseBlock(lcontext); } m_End = CheckTokenType(lcontext, TokenType.End).GetSourceRef(); lcontext.Source.Refs.Add(m_End); }
public RepeatStatement(ScriptLoadingContext lcontext) : base(lcontext) { m_Repeat = CheckTokenType(lcontext, TokenType.Repeat).GetSourceRef(); lcontext.Scope.PushBlock(); m_Block = new CompositeStatement(lcontext); var until = CheckTokenType(lcontext, TokenType.Until); m_Condition = Expression.Expr(lcontext); m_Until = until.GetSourceRefUpTo(lcontext.Lexer.Current); m_StackFrame = lcontext.Scope.PopBlock(); lcontext.Source.Refs.Add(m_Repeat); lcontext.Source.Refs.Add(m_Until); }
public AssignmentStatement(ScriptLoadingContext lcontext, Expression firstExpression, Token first) : base(lcontext) { m_LValues.Add(CheckVar(lcontext, firstExpression)); while (lcontext.Lexer.Current.Type == TokenType.Comma) { lcontext.Lexer.Next(); var e = Expression.PrimaryExp(lcontext); m_LValues.Add(CheckVar(lcontext, e)); } CheckTokenType(lcontext, TokenType.Op_Assignment); m_RValues = Expression.ExprList(lcontext); var last = lcontext.Lexer.Current; m_Ref = first.GetSourceRefUpTo(last); lcontext.Source.Refs.Add(m_Ref); }
public ForEachLoopStatement(ScriptLoadingContext lcontext, Token firstNameToken, Token forToken) : base(lcontext) { // for namelist in explist do block end | List<string> names = new List<string>(); names.Add(firstNameToken.Text); while (lcontext.Lexer.Current.Type == TokenType.Comma) { lcontext.Lexer.Next(); Token name = CheckTokenType(lcontext, TokenType.Name); names.Add(name.Text); } CheckTokenType(lcontext, TokenType.In); m_RValues = new ExprListExpression(Expression.ExprList(lcontext), lcontext); lcontext.Scope.PushBlock(); m_Names = names .Select(n => lcontext.Scope.TryDefineLocal(n)) .ToArray(); m_NameExps = m_Names .Select(s => new SymbolRefExpression(lcontext, s)) .Cast<IVariable>() .ToArray(); m_RefFor = forToken.GetSourceRef(CheckTokenType(lcontext, TokenType.Do)); m_Block = new CompositeStatement(lcontext); m_RefEnd = CheckTokenType(lcontext, TokenType.End).GetSourceRef(); m_StackFrame = lcontext.Scope.PopBlock(); lcontext.Source.Refs.Add(m_RefFor); lcontext.Source.Refs.Add(m_RefEnd); }
public ReturnStatement(ScriptLoadingContext lcontext) : base(lcontext) { Token ret = lcontext.Lexer.Current; lcontext.Lexer.Next(); Token cur = lcontext.Lexer.Current; if (cur.IsEndOfBlock() || cur.Type == TokenType.SemiColon) { m_Expression = null; m_Ref = ret.GetSourceRef(); } else { m_Expression = new ExprListExpression(Expression.ExprList(lcontext), lcontext); m_Ref = ret.GetSourceRefUpTo(lcontext.Lexer.Current); } lcontext.Source.Refs.Add(m_Ref); }
public WhileStatement(ScriptLoadingContext lcontext) : base(lcontext) { Token whileTk = CheckTokenType(lcontext, TokenType.While); m_Condition = Expression.Expr(lcontext); m_Start = whileTk.GetSourceRefUpTo(lcontext.Lexer.Current); //m_Start = BuildSourceRef(context.Start, exp.Stop); //m_End = BuildSourceRef(context.Stop, context.END()); lcontext.Scope.PushBlock(); CheckTokenType(lcontext, TokenType.Do); m_Block = new CompositeStatement(lcontext); m_End = CheckTokenType(lcontext, TokenType.End).GetSourceRef(); m_StackFrame = lcontext.Scope.PopBlock(); lcontext.Source.Refs.Add(m_Start); lcontext.Source.Refs.Add(m_End); }
public AssignmentStatement(ScriptLoadingContext lcontext, Token startToken) : base(lcontext) { List<string> names = new List<string>(); Token first = startToken; while (true) { Token name = CheckTokenType(lcontext, TokenType.Name); names.Add(name.Text); if (lcontext.Lexer.Current.Type != TokenType.Comma) break; lcontext.Lexer.Next(); } if (lcontext.Lexer.Current.Type == TokenType.Op_Assignment) { CheckTokenType(lcontext, TokenType.Op_Assignment); m_RValues = Expression.ExprList(lcontext); } else { m_RValues = new List<Expression>(); } foreach (string name in names) { var localVar = lcontext.Scope.TryDefineLocal(name); var symbol = new SymbolRefExpression(lcontext, localVar); m_LValues.Add(symbol); } Token last = lcontext.Lexer.Current; m_Ref = first.GetSourceRefUpTo(last); lcontext.Source.Refs.Add(m_Ref); }
private FunctionDefinitionExpression(ScriptLoadingContext lcontext, bool pushSelfParam, Table globalContext, bool isLambda) : base(lcontext) { if (globalContext != null) CheckTokenType(lcontext, TokenType.Function); // here lexer should be at the '(' or at the '|' var openRound = CheckTokenType(lcontext, isLambda ? TokenType.Lambda : TokenType.Brk_Open_Round); var paramnames = BuildParamList(lcontext, pushSelfParam, openRound, isLambda); // here lexer is at first token of body m_Begin = openRound.GetSourceRefUpTo(lcontext.Lexer.Current); // create scope lcontext.Scope.PushFunction(this, m_HasVarArgs); if (globalContext != null) { m_GlobalEnv = globalContext; m_Env = lcontext.Scope.TryDefineLocal(WellKnownSymbols.ENV); } else { lcontext.Scope.ForceEnvUpValue(); } m_ParamNames = DefineArguments(paramnames, lcontext); if (isLambda) m_Statement = CreateLambdaBody(lcontext); else m_Statement = CreateBody(lcontext); m_StackFrame = lcontext.Scope.PopFunction(); lcontext.Source.Refs.Add(m_Begin); lcontext.Source.Refs.Add(m_End); }
public IDisposable EnterSource(SourceRef sref) { return new SourceCodeStackGuard(sref, this); }
internal int Undump(Stream stream, int sourceID, Table envTable, out bool hasUpvalues) { int baseAddress = m_RootChunk.Code.Count; SourceRef sourceRef = new SourceRef(sourceID, 0, 0, 0, 0, false); using (BinaryReader br = new BinDumpBinaryReader(stream, Encoding.UTF8)) { ulong headerMark = br.ReadUInt64(); if (headerMark != DUMP_CHUNK_MAGIC) throw new ArgumentException("Not a MoonSharp chunk"); int version = br.ReadInt32(); if (version != DUMP_CHUNK_VERSION) throw new ArgumentException("Invalid version"); hasUpvalues = br.ReadBoolean(); int len = br.ReadInt32(); int numSymbs = br.ReadInt32(); SymbolRef[] allSymbs = new SymbolRef[numSymbs]; for (int i = 0; i < numSymbs; i++) allSymbs[i] = SymbolRef.ReadBinary(br); for (int i = 0; i < numSymbs; i++) allSymbs[i].ReadBinaryEnv(br, allSymbs); for (int i = 0; i <= len; i++) { Instruction I = Instruction.ReadBinary(sourceRef, br, baseAddress, envTable, allSymbs); m_RootChunk.Code.Add(I); } return baseAddress; } }
internal List<WatchItem> Debugger_GetCallStack(SourceRef startingRef) { List<WatchItem> wis = new List<WatchItem>(); for (int i = 0; i < m_ExecutionStack.Count; i++) { var c = m_ExecutionStack.Peek(i); var I = m_RootChunk.Code[c.Debug_EntryPoint]; string callname = I.OpCode == OpCode.Meta ? I.Name : null; if (c.ClrFunction != null) { wis.Add(new WatchItem() { Address = -1, BasePtr = -1, RetAddress = c.ReturnAddress, Location = startingRef, Name = c.ClrFunction.Name }); } else { wis.Add(new WatchItem() { Address = c.Debug_EntryPoint, BasePtr = c.BasePointer, RetAddress = c.ReturnAddress, Name = callname, Location = startingRef, }); } startingRef = c.CallingSourceRef; if (c.Continuation != null) { wis.Add(new WatchItem() { Name = c.Continuation.Name, Location = SourceRef.GetClrLocation() }); } } return wis; }
internal Instruction(SourceRef sourceref) { SourceCodeRef = sourceref; }
private Statement CreateBody(ScriptLoadingContext lcontext) { Statement s = new CompositeStatement(lcontext); if (lcontext.Lexer.Current.Type != TokenType.End) throw new SyntaxErrorException(lcontext.Lexer.Current, "'end' expected near '{0}'", lcontext.Lexer.Current.Text) { IsPrematureStreamTermination = (lcontext.Lexer.Current.Type == TokenType.Eof) }; m_End = lcontext.Lexer.Current.GetSourceRef(); lcontext.Lexer.Next(); return s; }
internal SyntaxErrorException(Script script, SourceRef sref, string message) : base(message) { DecorateMessage(script, sref); }
internal SyntaxErrorException(Script script, SourceRef sref, string format, params object[] args) : base(format, args) { DecorateMessage(script, sref); }
public SourceCodeStackGuard(SourceRef sref, ByteCode bc) { m_Bc = bc; m_Bc.PushSourceRef(sref); }
public void PushSourceRef(SourceRef sref) { m_SourceRefStack.Add(sref); m_CurrentSourceRef = sref; }
public void PopSourceRef() { m_SourceRefStack.RemoveAt(m_SourceRefStack.Count - 1); m_CurrentSourceRef = (m_SourceRefStack.Count > 0) ? m_SourceRefStack[m_SourceRefStack.Count - 1] : null; }
internal static Instruction ReadBinary(SourceRef chunkRef, BinaryReader rd, int baseAddress, Table envTable, SymbolRef[] deserializedSymbols) { Instruction that = new Instruction(chunkRef); that.OpCode = (OpCode)rd.ReadByte(); int usage = (int)that.OpCode.GetFieldUsage(); if ((usage & ((int)InstructionFieldUsage.NumValAsCodeAddress)) == (int)InstructionFieldUsage.NumValAsCodeAddress) that.NumVal = rd.ReadInt32() + baseAddress; else if ((usage & ((int)InstructionFieldUsage.NumVal)) != 0) that.NumVal = rd.ReadInt32(); if ((usage & ((int)InstructionFieldUsage.NumVal2)) != 0) that.NumVal2 = rd.ReadInt32(); if ((usage & ((int)InstructionFieldUsage.Name)) != 0) that.Name = rd.ReadString(); if ((usage & ((int)InstructionFieldUsage.Value)) != 0) that.Value = ReadValue(rd, envTable); if ((usage & ((int)InstructionFieldUsage.Symbol)) != 0) that.Symbol = ReadSymbol(rd, deserializedSymbols); if ((usage & ((int)InstructionFieldUsage.SymbolList)) != 0) { int len = rd.ReadInt32(); that.SymbolList = new SymbolRef[len]; for (int i = 0; i < that.SymbolList.Length; i++) that.SymbolList[i] = ReadSymbol(rd, deserializedSymbols); } return that; }
internal string PerformMessageDecorationBeforeUnwind(DynValue messageHandler, string decoratedMessage, SourceRef sourceRef) { try { DynValue[] args = new DynValue[] { DynValue.NewString(decoratedMessage) }; DynValue ret = DynValue.Nil; if (messageHandler.Type == DataType.Function) { ret = this.Call(messageHandler, args); } else if (messageHandler.Type == DataType.ClrFunction) { ScriptExecutionContext ctx = new ScriptExecutionContext(this, messageHandler.Callback, sourceRef); ret = messageHandler.Callback.Invoke(ctx, args); } else { throw new ScriptRuntimeException("error handler not set to a function"); } string newmsg = ret.ToPrintString(); if (newmsg != null) return newmsg; } catch (ScriptRuntimeException innerEx) { return innerEx.Message + "\n" + decoratedMessage; } return decoratedMessage; }
public bool Equals(SourceRef other) { return(Id == other.Id); }