public object VisitUnaryOp(Token op, INode node, object options) // добавление ветрки для унарной операции { LegacyData legacyData = (LegacyData)options; BranchOrientation legacyOrientation = legacyData.LegacyOrientation; string legacyIndent = legacyData.LegacyIndent; if (legacyOrientation == BranchOrientation.Left) { sb.AppendLine(ReplaceLastChar(legacyIndent, L_TURN) + H_PIPE + " (" + op.ToString() + ")"); } else { sb.AppendLine(ReplaceLastChar(legacyIndent, R_TURN) + H_PIPE + " (" + op.ToString() + ")"); } if (legacyOrientation == BranchOrientation.Right) { node.Accept(this, new LegacyData { LegacyIndent = ReplaceLastChar(legacyIndent, SPACE) + TAB + R_TURN, LegacyOrientation = BranchOrientation.Right }); } else { node.Accept(this, new LegacyData { LegacyIndent = ReplaceLastChar(legacyIndent, V_PIPE) + TAB + R_TURN, LegacyOrientation = BranchOrientation.Right }); } return(this.sb.ToString()); }
public object VisitUnaryOp(Token op, INode node) { switch (op.Type) { case TokenType.Plus: return((decimal)node.Accept(this)); case TokenType.Minus: return(-(decimal)node.Accept(this)); default: throw new Exception(string.Format("Token of type {0} cannot be evaluated.", op.Type.ToString())); } }
public object VisitUnaryOp(Token op, INode node, object options) // вычисление результата выполнения унарных операций { switch (op.Type) { case TokenType.Plus: return((decimal)node.Accept(this, options)); case TokenType.Minus: return(-(decimal)node.Accept(this, options)); default: throw new Exception(string.Format("Операция типа {0} не может быть произведена.", op.Type.ToString())); } }
/// <summary> /// Connect returns a new connection to the database. Changes made to the database /// through this connection are applied via the Raft consensus system. The Store /// must have been opened first. Must be called on the leader or an error will /// we returned. /// /// Any connection returned by this call are READ_COMMITTED isolated from all /// other connections, including the connection built-in to the Store itself. /// </summary> /// <param name="opt"></param> /// <returns></returns> public async Task <StoreConnection> Connect(StoreConnection.ConnectionOptions opt) { // Randomly-selected connection ID must be part of command so // that all nodes use the same value as connection ID. Func <ulong> newRandomId = () => { var buf = new byte[8]; randSrc.NextBytes(buf); return(BitConverter.ToUInt64(buf, 0)); }; ulong connID = newRandomId(); connsMu.EnterWriteLock(); try { while (conns.ContainsKey(connID)) { connID = newRandomId(); } conns.Add(connID, null); } finally { connsMu.ExitWriteLock(); } var cmd = new Command { Typ = CommandType.connect, Sub = new connectionSub { ConnID = connID, IdleTimeout = opt?.IdleTimeout, TxTimeout = opt?.TxTimeout } }; var f = await raft.Accept(cmd).ThrowOnError(); connsMu.EnterReadLock(); try { stats.NumConnects.WriteMetric(1); return(conns[connID]); } finally { connsMu.ExitReadLock(); } }
public static string Visit(INode node, NodeBuilder nodeBuilder) { var visitor = new XmlVisitor(nodeBuilder); node.Accept(visitor); return(visitor._builder.ToString()); }
public void Compile(INode moduleAst) { moduleAst.Accept(this); // Bake it typeBuilder.CreateType(); assemblyBuilder.Save(moduleBuilder.ScopeName); }
public static string Visit(INode node) { var visitor = new GeneratorVisitor(); node.Accept(visitor); return(visitor._builder.ToString()); }
public async Task <IActionResult> Command() { try { using (var reader = new StreamReader(HttpContext.Request.Body)) { var json = await reader.ReadToEndAsync(); var command = JsonConvert.DeserializeObject <ICommand>(json, _jsonSerialiserSettings); _logger.LogDebug($"{_baseSchemeUrlAndPort}/command called, my state is {_node.State.GetType().FullName}"); var commandResponse = await _node.Accept(command); json = JsonConvert.SerializeObject(commandResponse, _jsonSerialiserSettings); return(StatusCode(200, json)); } } catch (Exception e) { _logger.LogError($"THERE WAS A PROBLEM ON NODE {_node.State.CurrentState.Id}", e); throw; } }
protected IEnumerable <String> ExtractIsoCodes(INode node) { var resolver = new TryExtractIsoCode_INodeResolver(this); node.Accept(resolver); return(resolver.Result); }
public IBasket TryExtractBasketOnceResolved(INode node) { var resolver = new ExtractBasketsIdsOnceResolved_INodeResolver(this); node.Accept(resolver); return(resolver.ResultOpt); }
public void Add(INode n) { AddItem(new CompletionItem { Label = n.Name, Deprecated = n is DNode dNode && dNode.ContainsAnyAttribute(DTokens.Deprecated), TextEdit = CalculateTextEdit(n.Name), Kind = n.Accept(new CompletionItemKindVisitor()) });
public object VisitBinOp(Token op, INode left, INode right, object options) // вычисление результата выполнения бинарных операций { switch (op.Type) { case TokenType.Plus: return((decimal)left.Accept(this, options) + (decimal)right.Accept(this, options)); // сложение case TokenType.Minus: return((decimal)left.Accept(this, options) - (decimal)right.Accept(this, options)); // вычитание case TokenType.Multiply: return((decimal)left.Accept(this, options) * (decimal)right.Accept(this, options)); // умножение case TokenType.Divide: return((decimal)left.Accept(this, options) / (decimal)right.Accept(this, options)); // деление default: throw new Exception(string.Format("Операция типа {0} не может быть произведена.", op.Type.ToString())); } }
public object VisitBinOp(Token op, INode left, INode right) { switch (op.Type) { case TokenType.Plus: return((decimal)left.Accept(this) + (decimal)right.Accept(this)); case TokenType.Minus: return((decimal)left.Accept(this) - (decimal)right.Accept(this)); case TokenType.Multiply: return((decimal)left.Accept(this) * (decimal)right.Accept(this)); case TokenType.Divide: return((decimal)left.Accept(this) / (decimal)right.Accept(this)); default: throw new Exception(string.Format("Token of type {0} cannot be evaluated.", op.Type.ToString())); } }
public async Task <Responses.Response> Set(FileConfiguration fileConfiguration) { var result = await _node.Accept(new UpdateFileConfiguration(fileConfiguration)); if (result.GetType() == typeof(ErrorResponse <UpdateFileConfiguration>)) { return(new Responses.ErrorResponse(new UnableToSaveAcceptCommand($"unable to save file configuration to state machine"))); } return(new Responses.OkResponse()); }
protected ICommandContext createCommandContext(String twoWaySql, String[] argNames, Type[] argTypes, Object[] args) { ICommandContext context; { InternalSqlParser parser = new InternalSqlParser(twoWaySql, true); INode node = parser.Parse(); InternalCommandContextCreator creator = new InternalCommandContextCreator(argNames, argTypes); context = creator.CreateCommandContext(args); node.Accept(context); } return(context); }
public static String ConvertTwoWaySql2DisplaySql(String twoWaySql, String[] argNames, Type[] argTypes, Object[] args) { ICommandContext context; { InternalSqlParser parser = new InternalSqlParser(twoWaySql, false); INode node = parser.Parse(); InternalCommandContextCreator creator = new InternalCommandContextCreator(argNames, argTypes); context = creator.CreateCommandContext(args); node.Accept(context); } String preparedSql = context.Sql; return(InternalBindVariableUtil.GetCompleteSql(preparedSql, context.BindVariables)); }
//rendre intelligent cette methode pour pre process les instruction qui lui sont passé public void Emit(Op op, int val) { switch (op) { case Op.CONST: Current = new Const(val); break; case Op.STO: Console.Write("store: "); Current.Accept(new PrintVisitor()); break; } }
/// <summary> /// Adds a node to the completion data /// </summary> /// <param name="Node"></param> public void Add(INode Node) { if (Node.NameHash == 0) { return; } var name = Node.Name; if (!nameMatches(name)) { return; } var sb = new StringBuilder(NodeToolTipContentGen.Instance.GenTooltipSignature(Node as DNode)); GenerateNodeTooltipBody(Node as DNode, sb); addExpansion(name, Node.Accept(NodeTypeNameVisitor.Instance), sb.ToString()); }
/// <summary> /// Writes the buffered formula in infix notation, minimizing the number of parentheses written /// </summary> /// <exception cref="MissingMemberException">No valid formula is currently buffered.</exception> private void PrintSimpleInfix(INode formula) { if (isMinInfixBuffered) { Console.WriteLine(bufferedMinInfix); return; } if (formula == null) { throw new MissingMemberException("No valid formula specified"); } string result = formula.Accept(_minInfixWriter); bufferedMinInfix = result; isMinInfixBuffered = true; Console.WriteLine(bufferedMinInfix); }
/// <summary> /// Evaluates the buffered formula as a floating point number and writes the result to <code>Console.Out</code> /// </summary> /// <exception cref="MissingMemberException">No valid formula is currently buffered.</exception> /// <exception cref="FormatException">Propagated exception from evaluation.</exception> private void EvalAsDouble(INode formula) { if (isDoubleBuffered) { Console.WriteLine(bufferedDoubleValue.ToString("f05")); return; } if (formula == null) { throw new MissingMemberException("Trying to evaluate formula, but none is specified."); } double result = formula.Accept(_doubleEvaler); bufferedDoubleValue = result; isDoubleBuffered = true; Console.WriteLine(bufferedDoubleValue.ToString("f05")); }
/// <summary> /// Evaluates the buffered formula in integer form and writes the result to <code>Console.Out</code> /// </summary> /// <exception cref="MissingMemberException">No valid formula is currently buffered.</exception> /// <exception cref="FormatException">Propagated exception from evaluation.</exception> /// <exception cref="DivideByZeroException">Propagated exception from evaluation.</exception> /// <exception cref="OverflowException">Propagated exception from evaluation.</exception> private void EvalAsInt(INode formula) { if (isIntBuffered) { Console.WriteLine(bufferedIntValue); return; } if (formula == null) { throw new MissingMemberException("Trying to evaluate formula, but none is specified."); } int result = formula.Accept(_intEvaler); bufferedIntValue = result; isIntBuffered = true; Console.WriteLine(bufferedIntValue); }
void SetTemplate(ElementTemplate dt, INode node) { #pragma warning disable 0612 ((IDataTemplate)dt).LoadTemplate = () => { #pragma warning restore 0612 var context = new HydratationContext { ParentContext = Context, RootElement = Context.RootElement }; node.Accept(new ExpandMarkupsVisitor(context), null); node.Accept(new NamescopingVisitor(context), null); node.Accept(new CreateValuesVisitor(context), null); node.Accept(new RegisterXNamesVisitor(context), null); node.Accept(new FillResourceDictionariesVisitor(context), null); node.Accept(new ApplyPropertiesVisitor(context, true), null); return(context.Values[node]); }; }
public void Visit(INode node) { node.Accept(this); }
public virtual TResult Visit(INode node) { return(node != null?node.Accept(this) : default(TResult)); }
protected TResult Visit(INode <AstNode> subject, bool throwOnError) { return(subject.Accept <TResult>(this, throwOnError)); }
public virtual void Visit(TContext context, INode node) { node.Accept(context, this); }
public bool GetTime(INode source, INode target, MovementType movementType, out float time) { source.Accept(this, target, movementType); time = resTime; return(canPass); }
/// <summary> /// The variable's or method's base type will be resolved (if auto type, the intializer's type will be taken). /// A class' base class will be searched. /// etc.. /// </summary> public static AbstractType HandleNodeMatch( INode m, ResolutionContext ctxt, AbstractType resultBase = null, ISyntaxRegion typeBase = null, NodeMatchHandleVisitor vis = null) { // See https://github.com/aBothe/Mono-D/issues/161 int stkC; if (stackCalls == null) { stackCalls = new Dictionary <INode, int>(); stackCalls[m] = 1; } else { stackCalls[m] = stackCalls.TryGetValue(m, out stkC) ? ++stkC : 1; } /* * Pushing a new scope is only required if current scope cannot be found in the handled node's hierarchy. * Edit: No, it is required nearly every time because of nested type declarations - then, we do need the * current block scope. */ bool popAfterwards; { var newScope = m is IBlockNode ? (IBlockNode)m : m.Parent as IBlockNode; popAfterwards = ctxt.ScopedBlock != newScope && newScope != null; if (popAfterwards) { var options = ctxt.CurrentContext.ContextDependentOptions; var applyOptions = ctxt.ScopedBlockIsInNodeHierarchy(m); ctxt.PushNewScope(newScope); if (applyOptions) { ctxt.CurrentContext.ContextDependentOptions = options; } } } // To support resolving type parameters to concrete types if the context allows this, introduce all deduced parameters to the current context if (resultBase is DSymbol) { ctxt.CurrentContext.IntroduceTemplateParameterTypes((DSymbol)resultBase); } var ret = m.Accept(vis ?? new NodeMatchHandleVisitor { ctxt = ctxt, resultBase = resultBase, typeBase = typeBase }); if (popAfterwards) { ctxt.Pop(); } else if (resultBase is DSymbol) { ctxt.CurrentContext.RemoveParamTypesFromPreferredLocals((DSymbol)resultBase); } stackCalls.TryGetValue(m, out stkC); if (stkC == 1) { stackCalls.Remove(m); } else { stackCalls[m] = stkC - 1; } return(ret); }
public void Accept(INodeVisitor visitor, INode target, MovementType movementType) { target.Accept(visitor, this, movementType); }
public static string Visit(INode node) { var visitor = new XmlVisitor(); node.Accept(visitor); return visitor._builder.ToString(); }
void SetTemplate(ElementTemplate dt, INode node) { #pragma warning disable 0612 ((IDataTemplate)dt).LoadTemplate = () => { #pragma warning restore 0612 var context = new HydratationContext { ParentContext = Context, RootElement = Context.RootElement }; node.Accept(new ExpandMarkupsVisitor(context), null); node.Accept(new NamescopingVisitor(context), null); node.Accept(new CreateValuesVisitor(context), null); node.Accept(new RegisterXNamesVisitor(context), null); node.Accept(new FillResourceDictionariesVisitor(context), null); node.Accept(new ApplyPropertiesVisitor(context, true), null); return context.Values[node]; }; }
public void Accept(NodeVisitor visitor) { _node.Accept(visitor); }