public static IStatementFormatter GetFormatter(IIndentable indentable, StringBuilder outSql, IStatement statement) { Type formatterType; if (!_formatters.TryGetValue(statement.GetType(), out formatterType)) { throw new FormatterNotImplementedException( "Formatter not implemented for statement: " + statement.GetType().Name ); } var formatter = Activator.CreateInstance( formatterType, indentable, outSql, statement ) as IStatementFormatter; if (formatter == null) { throw new ArgumentNullException("Formatter not instantiated: " + formatterType.Name); } return(formatter); }
private static void ThrowUnknownStatement(IStatement state) { System.Text.StringBuilder build = new System.Text.StringBuilder(); build.Append("未知の Statement です。\r\n"); build.Append("----------------------------\r\n型\r\n"); build.Append(state.GetType()); build.Append("\r\n----------------------------\r\nインターフェイス\r\n"); foreach (System.Type t in state.GetType().GetInterfaces()) { build.Append(t); } throw new System.Exception(build.ToString()); }
public static void WriteStatement(Context context, IStatement statement) { if (statement is IExpression) { WriteExpression(context, (IExpression)statement); } else if (statement is ReturnStatement) { WriteReturnStatement(context, (ReturnStatement)statement); } else if (statement is IfStatement) { WriteIfStatement(context, (IfStatement)statement); } else if (statement is VariableDeclaration) { WriteVariableDeclaration(context, (VariableDeclaration)statement); } else { throw new NotImplementedException($"Unknown statement type: {statement.GetType().Name}"); } Write(context, ';'); }
public virtual StatementViewModel CreateStatementByInstance(IStatement statement, ILanguage language) { if (statement is Set.Statements.HasPartStatement) { return(new HasPartStatement(statement as Set.Statements.HasPartStatement, language)); } else if (statement is Set.Statements.GroupStatement) { return(new GroupStatement(statement as Set.Statements.GroupStatement, language)); } else if (statement is Set.Statements.HasSignStatement) { return(new HasSignStatement(statement as Set.Statements.HasSignStatement, language)); } else if (statement is Modules.Classification.Statements.IsStatement) { return(new IsStatement(statement as Modules.Classification.Statements.IsStatement, language)); } else if (statement is Set.Statements.SignValueStatement) { return(new SignValueStatement(statement as Set.Statements.SignValueStatement, language)); } else if (statement is Mathematics.Statements.ComparisonStatement) { return(new ComparisonStatement(statement as Mathematics.Statements.ComparisonStatement, language)); } else if (statement is Processes.Statements.ProcessesStatement) { return(new ProcessesStatement(statement as Processes.Statements.ProcessesStatement, language)); } else { throw new NotSupportedException(statement.GetType().FullName); } }
/// <summary> /// Can we combine? Yes, if and only if the same guy and same variables! /// </summary> /// <param name="statement"></param> /// <param name="optimize"></param> /// <returns></returns> public bool TryCombineStatement(IStatement statement, ICodeOptimizationService optimize) { if (statement.GetType() != typeof(StatementRecordPairValues)) { return(false); } var other = statement as StatementRecordPairValues; if (other._index.RawValue != _index.RawValue) { return(false); } var isTheSame = _savers.Zip(other._savers, (f, s) => f.indexValue.RawValue == s.indexValue.RawValue && f.mapRecord.Type == s.mapRecord.Type).All(b => b); if (!isTheSame) { return(false); } // Now we can do them all. foreach (var saver in _savers.Zip(other._savers, (f, s) => Tuple.Create(f, s))) { optimize.TryRenameVarialbeOneLevelUp(saver.Item2.mapRecord.RawValue, saver.Item1.mapRecord); } return(true); }
/// <summary> /// Gets the Request to send to a cassandra node based on the statement type /// </summary> internal IRequest GetRequest(IStatement statement) { var defaultConsistency = Configuration.QueryOptions.GetConsistencyLevel(); if (statement is RegularStatement) { var s = (RegularStatement)statement; var options = QueryProtocolOptions.CreateFromQuery(s, defaultConsistency); options.ValueNames = s.QueryValueNames; return(new QueryRequest(BinaryProtocolVersion, s.QueryString, s.IsTracing, options)); } if (statement is BoundStatement) { var s = (BoundStatement)statement; var options = QueryProtocolOptions.CreateFromQuery(s, defaultConsistency); return(new ExecuteRequest(BinaryProtocolVersion, s.PreparedStatement.Id, null, s.IsTracing, options)); } if (statement is BatchStatement) { var s = (BatchStatement)statement; var consistency = defaultConsistency; if (s.ConsistencyLevel != null) { consistency = s.ConsistencyLevel.Value; } return(new BatchRequest(BinaryProtocolVersion, s, consistency)); } throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported"); }
private static bool TestLetStatement(IStatement statement, string name) { if (statement.TokenLiteral() != "let") { Console.WriteLine("Expected 'len', but got {0}", statement.TokenLiteral()); return false; } var letStatement = statement.GetType(); if (letStatement != typeof(LetStatement)) { Console.WriteLine("Expected 'LetStatement', but got {0}", letStatement); return false; } if (statement.Name.StringValue != name) { Console.WriteLine("Expected {0}, but got {1}", statement.Name.StringValue, name); return false; } if (statement.Name.TokenLiteral() != name) { Console.WriteLine("Expected {0}, but got {1}", statement.Name, name); return false; } return true; }
protected virtual void VisitStatement(IStatement statement) { if (!StatementVisitors.ContainsKey(statement.GetType())) { throw new NotImplementedException("Statement " + statement.GetType().Name + " is not implemented"); } StatementVisitors[statement.GetType()](this, statement); if (statement is Token) { var token = (Token)statement; State.Parameters.AddRange(token.Parameters); State.ParameterValues.AddRange(token.ParameterValues); } }
private void WriteUnsupported(IStatement value) { _formatter.WriteLiteral("# Unsupported statement " + value.GetType().Name + ":"); _formatter.WriteLine(); _formatter.WriteLiteral("#" + value.ToString()); _formatter.WriteLine(); }
protected override IStatement DoConvertStatement(IStatement ist) { if ((ist is IForStatement) || (ist is IExpressionStatement) || (ist is IBlockStatement) || (ist is IConditionStatement)) { return(base.DoConvertStatement(ist)); } Error("Unsupported statement type: " + ist.GetType().Name); return(ist); }
public static IStatementFormatter GetFormatter( IIndentable indentable, StringBuilder outSql, IStatement statement ) { Type formatterType; if ( !_formatters.TryGetValue( statement.GetType(), out formatterType ) ) throw new FormatterNotImplementedException( "Formatter not implemented for statement: " + statement.GetType().Name ); var formatter = Activator.CreateInstance( formatterType, indentable, outSql, statement ) as IStatementFormatter; if ( formatter == null ) throw new ArgumentNullException( "Formatter not instantiated: " + formatterType.Name ); return formatter; }
private void TestLetStatement(IStatement s, string name) { Assert.AreEqual("let", s.TokenLiteral, $"s.TokenLiteral is not 'let'. got={s.TokenLiteral}"); var letStmnt = s as LetStatement; Assert.IsNotNull(letStmnt, $"s is not LetStatement. got={s.GetType().Name}"); Assert.AreEqual(name, letStmnt.Name.Value, $"letStmt.Name.Value not '{name}'. got={letStmnt.Name.Value}"); Assert.AreEqual(name, letStmnt.Name.TokenLiteral, $"s.Name not '{name}'. got={letStmnt.Name}"); }
/// <summary> /// Gets the Request to send to a cassandra node based on the statement type /// </summary> internal static IRequest GetRequest(IStatement statement, ISerializer serializer, IRequestOptions requestOptions) { ICqlRequest request = null; if (statement.IsIdempotent == null) { statement.SetIdempotence(requestOptions.DefaultIdempotence); } if (statement is RegularStatement s1) { s1.Serializer = serializer; var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s1, requestOptions, null); options.ValueNames = s1.QueryValueNames; request = new QueryRequest(serializer, s1.QueryString, options, s1.IsTracing, s1.OutgoingPayload); } if (statement is BoundStatement s2) { // set skip metadata only when result metadata id is supported because of CASSANDRA-10786 var skipMetadata = serializer.ProtocolVersion.SupportsResultMetadataId() && s2.PreparedStatement.ResultMetadata.ContainsColumnDefinitions(); var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s2, requestOptions, skipMetadata); request = new ExecuteRequest( serializer, s2.PreparedStatement.Id, null, s2.PreparedStatement.ResultMetadata, options, s2.IsTracing, s2.OutgoingPayload); } if (statement is BatchStatement s) { s.Serializer = serializer; var consistency = requestOptions.ConsistencyLevel; if (s.ConsistencyLevel.HasValue) { consistency = s.ConsistencyLevel.Value; } request = new BatchRequest(serializer, s.OutgoingPayload, s, consistency, requestOptions); } if (request == null) { throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported"); } return(request); }
private static StatementType GetExpressionType(IStatement statement) { System.Type t = statement.GetType(); StatementType ret; if (state_types.TryGetValue(statement.GetType(), out ret)) { return(ret); } System.Type[] interfaces = t.GetInterfaces(); for (int i = 0, iM = interfaces.Length; i < iM; i++) { if (state_types.TryGetValue(interfaces[i], out ret)) { state_types[t] = ret; // 覚えて置く return(ret); } } return(StatementType.Unknown); }
protected string StatementLabel(IStatement ist) { if (ist is IExpressionStatement) { IExpressionStatement ies = (IExpressionStatement)ist; string s; if (ies.Expression is IAssignExpression) { s = ExpressionToString(((IAssignExpression)ies.Expression).Target); } else { s = ExpressionToString(ies.Expression); } if (s.StartsWith("this.")) { s = s.Substring(5); } //if (s.EndsWith("[0]")) s = s.Substring(0, s.Length - 3); return(s); } if (ist is IForStatement) { return(StatementLabel(((IForStatement)ist).Body.Statements[0])); } if (ist is IConditionStatement) { return(String.Format("if ({0}) {1}", ((IConditionStatement)ist).Condition.ToString(), StatementLabel(((IConditionStatement)ist).Then))); } if (ist is IBlockStatement) { int blockSize = ((IBlockStatement)ist).Statements.Count; string s; if (blockSize > 0) { s = StatementLabel(((IBlockStatement)ist).Statements[0]); } else { s = "EmptyBlock"; } if (blockSize > 1) { s += " ..."; } return(s); } return(ist.GetType().Name); }
public override void TraverseChildren(IStatement statement) { log.WriteTrace("Traversing {0} statement.", statement.GetType().Name); var statementVisitor = new NewObjStatementVisitor(statement, log, registry); statementVisitor.Traverse(statement); var fieldReferenceVisitor = new FieldReferenceVisitor(statement, log, registry); fieldReferenceVisitor.Traverse(statement); var fieldAssignmentVisitor = new FieldAssignmentVisitor(statement, log, registry); fieldAssignmentVisitor.Traverse(statement); base.TraverseChildren(statement); }
public IPhpStatement[] TranslateStatement(IStatement x) { if (!(x is CSharpBase)) { throw new Exception("Błąd translacji " + x.GetType().FullName); } var op = new OptimizeOptions(); var s = new PhpStatementSimplifier(op); var a = new PhpStatementTranslatorVisitor(_state); var tmp = a.Visit(x as CSharpBase); var result = new List <IPhpStatement>(tmp.Length); result.AddRange(tmp.Select(i => s.Visit(i as PhpSourceBase))); return(result.ToArray()); }
public void TestTryCombine([PexAssumeUnderTest]StatementForLoop target, IStatement s) { /// We should never be able to combine any filter statements currently! var val = new Variables.ValSimple("true", typeof(bool)); var result = target.TryCombineStatement(s, null); if (s.GetType() != typeof(StatementForLoop)) { Assert.IsFalse(result, "Types not right"); } else { var other = s as StatementForLoop; Assert.AreEqual(other.ArrayLength == target.ArrayLength, result, "for loops not conssitent"); } }
public void TestTryCombine([PexAssumeUnderTest] StatementForLoop target, IStatement s) { /// We should never be able to combine any filter statements currently! var val = new Variables.ValSimple("true", typeof(bool)); var result = target.TryCombineStatement(s, null); if (s.GetType() != typeof(StatementForLoop)) { Assert.IsFalse(result, "Types not right"); } else { var other = s as StatementForLoop; Assert.AreEqual(other.ArrayLength == target.ArrayLength, result, "for loops not conssitent"); } }
public void GenerateStatement(IStatement statement, ILGenerator ilGenerator) { switch (statement) { case VariableAssignment variableAssignment: GenerateVarAssignment(variableAssignment, ilGenerator); break; case ArrayElementAssignment arrayElementAssignment: GenerateArrayElementAssignment(arrayElementAssignment, ilGenerator); break; case VariableDeclaration declaration: GenerateDeclaration(declaration, ilGenerator); break; case FunctionCall functionCall: GenerateFuncCall(functionCall, ilGenerator); break; case ReturnStatement returnStatement: GenerateReturnStatement(returnStatement, ilGenerator); break; case WhileStatement whileStatement: GenerateWhileStatement(whileStatement, ilGenerator); break; case IfStatement ifStatement: GenerateIfStatement(ifStatement, ilGenerator); break; case ForStatement forStatement: GenerateForStatement(forStatement, ilGenerator); break; case BlockStatement blockStatement: GenerateBlockStatement(blockStatement, ilGenerator); break; default: throw new NotImplementedException($"Cannot Generate statement: {statement.GetType()}"); } }
private static void Process(this IStatement statement) { switch (statement) { case VariableAssignment variableAssignment: variableAssignment.Process(); break; case ArrayElementAssignment arrayElementAssignment: arrayElementAssignment.Process(); break; case VariableDeclaration declaration: declaration.Process(); break; case FunctionCall functionCall: functionCall.Process(); break; case ReturnStatement returnStatement: returnStatement.Process(); break; case WhileStatement whileStatement: whileStatement.Process(); break; case IfStatement ifStatement: ifStatement.Process(); break; case ForStatement forStatement: forStatement.Process(); break; case BlockStatement blockStatement: blockStatement.Process(); break; default: throw new NotImplementedException($"Statements process: {statement.GetType()}"); } }
public IPlatformStatementTranspiler GetTranspilerForStatement(IStatement statement) { var sttType = statement.GetType(); if (_typeTranspilers.TryGetValue(sttType, out var value)) { return(value); } if (_fallbackType.TryGetValue(sttType, out sttType)) { if (_typeTranspilers.TryGetValue(sttType, out value)) { return(value); } } throw new InvalidOperationException(); }
private static IExpression GetContainerExpression(IStatement container) { if (container is IForStatement ifs) { return(Recognizer.LoopSizeExpression(ifs)); } else if (container is IConditionStatement ics) { return(ics.Condition); } else if (container is IRepeatStatement irs) { return(irs.Count); } else { throw new ArgumentException($"unrecognized container type: {container.GetType()}"); } }
public Task ExecuteStatement(IStatement stat, LuaState state, CancellationToken token = default) { if (state.FunctionState.DidReturn || token.IsCancellationRequested) { return(Task.CompletedTask); } switch (stat) { case Assignment assignment: return(_statementInterpreter.ExecuteAssignment(assignment, state, token)); case LocalAssignment localAssignment: return(_statementInterpreter.ExecuteLocalAssignment(localAssignment, state, token)); case FunctionCall call: return(_statementInterpreter.ExecuteFunctionCall(call, state, token)); case Block block: return(_statementInterpreter.ExecuteBlock(block, state, token)); case IfStat ifStat: return(_statementInterpreter.ExecuteIfStat(ifStat, state, token)); case ReturnStat returnStat: return(_statementInterpreter.ExecuteReturnStat(returnStat, state, token)); case WhileStat whileStat: return(_statementInterpreter.ExecuteWhileStat(whileStat, state, token)); case RepeatStat repeatStat: return(_statementInterpreter.ExecuteRepeatStat(repeatStat, state, token)); case GenericFor genericFor: return(_statementInterpreter.ExecuteGenericFor(genericFor, state, token)); case NumericFor numericFor: return(_statementInterpreter.ExecuteNumericFor(numericFor, state, token)); default: throw new NotImplementedException(stat.GetType().Name); } }
public IPyStatement[] TranslateStatement([NotNull] IStatement x) { if (x == null) { throw new ArgumentNullException(nameof(x)); } if (!(x is CSharpBase)) { throw new Exception($"Translation error: {x.GetType().FullName} is not CSharpBase instance"); } var op = new OptimizeOptions(); var s = new PyStatementSimplifier(op); var a = new PyStatementTranslatorVisitor(_state); var tmp = a.Visit(x as CSharpBase); var result = new List <IPyStatement>(tmp.Length); result.AddRange(tmp.Select(i => s.Visit(i as PySourceBase))); return(result.ToArray()); }
/// <summary> /// Gets the Request to send to a cassandra node based on the statement type /// </summary> internal static IRequest GetRequest(IStatement statement, Serializer serializer, Configuration config) { ICqlRequest request = null; if (statement.IsIdempotent == null) { statement.SetIdempotence(config.QueryOptions.GetDefaultIdempotence()); } if (statement is RegularStatement) { var s = (RegularStatement)statement; s.Serializer = serializer; var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s, config.QueryOptions, config.Policies); options.ValueNames = s.QueryValueNames; request = new QueryRequest(serializer.ProtocolVersion, s.QueryString, s.IsTracing, options); } if (statement is BoundStatement) { var s = (BoundStatement)statement; var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s, config.QueryOptions, config.Policies); request = new ExecuteRequest(serializer.ProtocolVersion, s.PreparedStatement.Id, null, s.IsTracing, options); } if (statement is BatchStatement) { var s = (BatchStatement)statement; s.Serializer = serializer; var consistency = config.QueryOptions.GetConsistencyLevel(); if (s.ConsistencyLevel != null) { consistency = s.ConsistencyLevel.Value; } request = new BatchRequest(serializer.ProtocolVersion, s, consistency); } if (request == null) { throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported"); } //Set the outgoing payload for the request request.Payload = statement.OutgoingPayload; return(request); }
public virtual string GetSql (IStatement statement) { if (statement == null) throw new ArgumentNullException ("statement"); Type type = statement.GetType (); if (type == typeof (SelectStatement)) return GetStatementSql (statement as SelectStatement); else if (type == typeof (InsertStatement)) return GetStatementSql (statement as InsertStatement); else if (type == typeof (UpdateStatement)) return GetStatementSql (statement as UpdateStatement); else if (type == typeof (DeleteStatement)) return GetStatementSql (statement as DeleteStatement); else if (type == typeof (DropStatement)) return GetStatementSql (statement as DropStatement); else if (type == typeof (TruncateStatement)) return GetStatementSql (statement as TruncateStatement); else throw new NotImplementedException (type.FullName); }
/// <summary> /// Gets the Request to send to a cassandra node based on the statement type /// </summary> internal static IRequest GetRequest(IStatement statement, ISerializer serializer, IRequestOptions requestOptions) { ICqlRequest request = null; if (statement.IsIdempotent == null) { statement.SetIdempotence(requestOptions.DefaultIdempotence); } if (statement is RegularStatement s1) { s1.Serializer = serializer; var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s1, requestOptions); options.ValueNames = s1.QueryValueNames; request = new QueryRequest(serializer.ProtocolVersion, s1.QueryString, s1.IsTracing, options); } if (statement is BoundStatement s2) { var options = QueryProtocolOptions.CreateFromQuery(serializer.ProtocolVersion, s2, requestOptions); request = new ExecuteRequest(serializer.ProtocolVersion, s2.PreparedStatement.Id, null, s2.PreparedStatement.ResultMetadataId, s2.IsTracing, options); } if (statement is BatchStatement s) { s.Serializer = serializer; var consistency = requestOptions.ConsistencyLevel; if (s.ConsistencyLevel.HasValue) { consistency = s.ConsistencyLevel.Value; } request = new BatchRequest(serializer.ProtocolVersion, s, consistency, requestOptions); } if (request == null) { throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported"); } //Set the outgoing payload for the request request.Payload = statement.OutgoingPayload; return(request); }
public virtual string GetSql(IStatement statement) { if (statement == null) { throw new ArgumentNullException("statement"); } Type type = statement.GetType(); if (type == typeof(SelectStatement)) { return(GetStatementSql(statement as SelectStatement)); } else if (type == typeof(InsertStatement)) { return(GetStatementSql(statement as InsertStatement)); } else if (type == typeof(UpdateStatement)) { return(GetStatementSql(statement as UpdateStatement)); } else if (type == typeof(DeleteStatement)) { return(GetStatementSql(statement as DeleteStatement)); } else if (type == typeof(DropStatement)) { return(GetStatementSql(statement as DropStatement)); } else if (type == typeof(TruncateStatement)) { return(GetStatementSql(statement as TruncateStatement)); } else { throw new NotImplementedException(type.FullName); } }
/// <inheritdoc /> public IAsyncResult BeginExecute(IStatement statement, object tag, AsyncCallback callback, object state) { if (statement == null) { throw new ArgumentNullException("statement"); } var options = Cluster.Configuration.QueryOptions; var consistency = statement.ConsistencyLevel ?? options.GetConsistencyLevel(); if (statement is RegularStatement) { return(BeginQuery((RegularStatement)statement, callback, state, tag)); } if (statement is BoundStatement) { return(BeginExecuteQuery((BoundStatement)statement, callback, state, tag)); } if (statement is BatchStatement) { return(BeginBatch((BatchStatement)statement, callback, state, tag)); } throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported"); }
void WriteStatement(IStatement stmt) { switch (stmt) { case IInsertStatement insertStmt: WriteInsertStatement(insertStmt); break; case IInsertSelectStatement insertSelectStmt: WriteInsertSelectStatement(insertSelectStmt); break; case ISelectStatement selectStmt: WriteSelectStatement(selectStmt); break; case IUpdateStatement updateStmt: WriteUpdateStatement(updateStmt); break; case IDeleteStatement deleteStmt: WriteDeleteStatement(deleteStmt); break; case IDeclareVariableStatement declareStmt: WriteDeclareSqlVariable(declareStmt); break; case ISetVariableStatement setStmt: WriteSetSqlVariable(setStmt); break; default: throw new Exception("Unsupported statement " + stmt.GetType().Name); } }
// Modifies affectingVariables. internal static bool ContainerAffectsVariables(IStatement container, Set <IVariableDeclaration> affectingVariables) { if (container is IForStatement) { IForStatement ifs2 = (IForStatement)container; if (affectingVariables.Contains(Recognizer.LoopVariable(ifs2))) { // all variables in the loop bounds become affecting variables. affectingVariables.AddRange( Recognizer.GetVariables(Recognizer.LoopStartExpression(ifs2)).Concat( Recognizer.GetVariables(ifs2.Condition) )); return(true); } return(false); } else if (container is IConditionStatement) { IConditionStatement ics = (IConditionStatement)container; // if the condition refers to an affecting variable, then it is a parent. bool isParent = Recognizer.GetVariables(ics.Condition).Any(affectingVariables.Contains); if (isParent) { // all variables in the condition become affecting variables, // since they change the outcome of the condition and therefore the bounds of ifs. affectingVariables.AddRange(Recognizer.GetVariables(ics.Condition)); return(true); } return(false); } else { throw new NotImplementedException($"Unrecognized container type: {StringUtil.TypeToString(container.GetType())}"); } }
public IPhpStatement[] TranslateStatement(IStatement x) { if (!(x is CSharpBase)) throw new Exception("Błąd translacji " + x.GetType().FullName); var op = new OptimizeOptions(); var s = new StatementSimplifier(op); var a = new StatementTranslatorVisitor(_state); var tmp = a.Visit(x as CSharpBase); var result = new List<IPhpStatement>(tmp.Length); result.AddRange(tmp.Select(i => s.Visit(i as PhpSourceBase))); return result.ToArray(); }
// // public InvalidStatementStructureCompilerException(string message) // : base(message) // { // } // // public InvalidStatementStructureCompilerException(string message, Exception innerException) : base(message, innerException) // { // } // // public InvalidStatementStructureCompilerException(Exception innerException) : base(innerException) // { // } public static string CreateMessage(IStatement statement, StatementInfo info) { return ($"Invalid statement of type '{statement?.GetType().Name}' was found {info}"); }
private void WriteStatement(IStatement value, IFormatter formatter, bool lastStatement) { if (value == null) { throw new ArgumentNullException("value"); } if (value is IBlockStatement) { this.WriteBlockStatement(value as IBlockStatement, formatter); return; } if (value is IExpressionStatement) { this.WriteExpressionStatement(value as IExpressionStatement, formatter); return; } if (value is IGotoStatement) { this.WriteGotoStatement(value as IGotoStatement, formatter); return; } if (value is ILabeledStatement) { this.WriteLabeledStatement(value as ILabeledStatement, formatter); return; } if (value is IConditionStatement) { this.WriteConditionStatement(value as IConditionStatement, formatter); return; } if (value is IMethodReturnStatement) { this.WriteMethodReturnStatement(value as IMethodReturnStatement, formatter, lastStatement); return; } if (value is IForStatement) { this.WriteForStatement(value as IForStatement, formatter); return; } if (value is IForEachStatement) { this.WriteForEachStatement(value as IForEachStatement, formatter); return; } if (value is IUsingStatement) { this.WriteUsingStatement(value as IUsingStatement, formatter); return; } if (value is IFixedStatement) { this.WriteFixedStatement(value as IFixedStatement, formatter); return; } if (value is IWhileStatement) { this.WriteWhileStatement(value as IWhileStatement, formatter); return; } if (value is IDoStatement) { this.WriteDoStatement(value as IDoStatement, formatter); return; } if (value is ITryCatchFinallyStatement) { this.WriteTryCatchFinallyStatement(value as ITryCatchFinallyStatement, formatter); return; } if (value is IThrowExceptionStatement) { this.WriteThrowExceptionStatement(value as IThrowExceptionStatement, formatter); return; } if (value is IAttachEventStatement) { this.WriteAttachEventStatement(value as IAttachEventStatement, formatter); return; } if (value is IRemoveEventStatement) { this.WriteRemoveEventStatement(value as IRemoveEventStatement, formatter); return; } if (value is ISwitchStatement) { this.WriteSwitchStatement(value as ISwitchStatement, formatter); return; } if (value is IBreakStatement) { this.WriteBreakStatement(value as IBreakStatement, formatter); return; } if (value is IContinueStatement) { this.WriteContinueStatement(value as IContinueStatement, formatter); return; } if (value is IMemoryCopyStatement) { this.WriteMemoryCopyStatement(value as IMemoryCopyStatement, formatter); return; } if (value is IMemoryInitializeStatement) { this.WriteMemoryInitializeStatement(value as IMemoryInitializeStatement, formatter); return; } if (value is IDebugBreakStatement) { this.WriteDebugBreakStatement(value as IDebugBreakStatement, formatter); return; } if (value is ILockStatement) { this.WriteLockStatement(value as ILockStatement, formatter); return; } if (value is ICommentStatement) { this.WriteCommentStatement(value as ICommentStatement, formatter); return; } throw new ArgumentException("Invalid statement type `" + value.GetType() + "`.", "value"); }
/// <summary> /// Gets the Request to send to a cassandra node based on the statement type /// </summary> internal IRequest GetRequest(IStatement statement) { var defaultConsistency = Configuration.QueryOptions.GetConsistencyLevel(); if (statement is RegularStatement) { var s = (RegularStatement)statement; var options = QueryProtocolOptions.CreateFromQuery(s, defaultConsistency); options.ValueNames = s.QueryValueNames; return new QueryRequest(BinaryProtocolVersion, s.QueryString, s.IsTracing, options); } if (statement is BoundStatement) { var s = (BoundStatement)statement; var options = QueryProtocolOptions.CreateFromQuery(s, defaultConsistency); return new ExecuteRequest(BinaryProtocolVersion, s.PreparedStatement.Id, null, s.IsTracing, options); } if (statement is BatchStatement) { var s = (BatchStatement)statement; var consistency = defaultConsistency; if (s.ConsistencyLevel != null) { consistency = s.ConsistencyLevel.Value; } return new BatchRequest(BinaryProtocolVersion, s, consistency); } throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported"); }
public virtual void VisitStatement(IStatement value) { if (value == null) { return; } // Performance: This method gets called often and needs to run fast. // 216988 ExpressionStatement // 123584 BlockStatement // 41587 ConditionStatement // 25567 MethodReturnStatement // 15264 LabeledStatement // 13260 GotoStatement if (value is IExpressionStatement) { this.VisitExpressionStatement(value as IExpressionStatement); return; } if (value is IBlockStatement) { this.VisitBlockStatement(value as IBlockStatement); return; } if (value is IConditionStatement) { this.VisitConditionStatement(value as IConditionStatement); return; } if (value is IMethodReturnStatement) { this.VisitMethodReturnStatement(value as IMethodReturnStatement); return; } if (value is ILabeledStatement) { this.VisitLabeledStatement(value as ILabeledStatement); return; } if (value is IGotoStatement) { this.VisitGotoStatement(value as IGotoStatement); return; } if (value is IForStatement) { this.VisitForStatement(value as IForStatement); return; } if (value is IForEachStatement) { this.VisitForEachStatement(value as IForEachStatement); return; } if (value is IWhileStatement) { this.VisitWhileStatement(value as IWhileStatement); return; } if (value is IDoStatement) { this.VisitDoStatement(value as IDoStatement); return; } if (value is ITryCatchFinallyStatement) { this.VisitTryCatchFinallyStatement(value as ITryCatchFinallyStatement); return; } if (value is IThrowExceptionStatement) { this.VisitThrowExceptionStatement(value as IThrowExceptionStatement); return; } if (value is IAttachEventStatement) { this.VisitAttachEventStatement(value as IAttachEventStatement); return; } if (value is IRemoveEventStatement) { this.VisitRemoveEventStatement(value as IRemoveEventStatement); return; } if (value is ISwitchStatement) { this.VisitSwitchStatement(value as ISwitchStatement); return; } if (value is IBreakStatement) { this.VisitBreakStatement(value as IBreakStatement); return; } if (value is IContinueStatement) { this.VisitContinueStatement(value as IContinueStatement); return; } if (value is ICommentStatement) { this.VisitCommentStatement(value as ICommentStatement); return; } if (value is IUsingStatement) { this.VisitUsingStatement(value as IUsingStatement); return; } if (value is IFixedStatement) { this.VisitFixedStatement(value as IFixedStatement); return; } if (value is ILockStatement) { this.VisitLockStatement(value as ILockStatement); return; } if (value is IMemoryCopyStatement) { this.VisitMemoryCopyStatement(value as IMemoryCopyStatement); return; } if (value is IMemoryInitializeStatement) { this.VisitMemoryInitializeStatement(value as IMemoryInitializeStatement); return; } if (value is IDebugBreakStatement) { this.VisitDebugBreakStatement(value as IDebugBreakStatement); return; } throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Invalid statement type '{0}'.", value.GetType().Name)); }
/// <summary> /// Gets the Request to send to a cassandra node based on the statement type /// </summary> internal IRequest GetRequest(IStatement statement) { ICqlRequest request = null; if (statement is RegularStatement) { var s = (RegularStatement)statement; s.ProtocolVersion = BinaryProtocolVersion; var options = QueryProtocolOptions.CreateFromQuery(s, Configuration.QueryOptions); options.ValueNames = s.QueryValueNames; request = new QueryRequest(BinaryProtocolVersion, s.QueryString, s.IsTracing, options); } if (statement is BoundStatement) { var s = (BoundStatement)statement; var options = QueryProtocolOptions.CreateFromQuery(s, Configuration.QueryOptions); request = new ExecuteRequest(BinaryProtocolVersion, s.PreparedStatement.Id, null, s.IsTracing, options); } if (statement is BatchStatement) { var s = (BatchStatement)statement; s.ProtocolVersion = BinaryProtocolVersion; var consistency = Configuration.QueryOptions.GetConsistencyLevel(); if (s.ConsistencyLevel != null) { consistency = s.ConsistencyLevel.Value; } request = new BatchRequest(BinaryProtocolVersion, s, consistency); } if (request == null) { throw new NotSupportedException("Statement of type " + statement.GetType().FullName + " not supported"); } //Set the outgoing payload for the request request.Payload = statement.OutgoingPayload; return request; }
public static string GetRefUrlFor(IStatement s, CodeLocation caret) { if (s is IExpressionContainingStatement) { var exprs = (s as IExpressionContainingStatement).SubExpressions; IExpression targetExpr = null; if (exprs != null) foreach (var ex in exprs) if (caret >= ex.Location && caret <= ex.EndLocation && (targetExpr = ExpressionHelper.SearchExpressionDeeply (ex, caret)) != ex) break; if (targetExpr != null) return GetRefUrlFor (targetExpr); } if (s is DeclarationStatement) { var ds = s as DeclarationStatement; foreach (var decl in ds.Declarations) { if (caret >= decl.Location && caret <= decl.EndLocation) { if (decl is DVariable) { var dv = decl as DVariable; if (dv.Initializer != null && caret >= dv.Location && caret <= dv.EndLocation) return GetRefUrlFor (dv.Initializer); } } } } if (s is StatementContainingStatement) { var stmts = (s as StatementContainingStatement).SubStatements; if (stmts != null) foreach (var stmt in stmts) { if (caret >= stmt.Location && caret <= stmt.EndLocation) { var r = GetRefUrlFor (stmt, caret); if (r != null) return r; } } } var url = "statement.html#"; if (s is ForeachStatement && (s as ForeachStatement).IsRangeStatement) url += "ForeachRangeStatement"; else if (s is StatementCondition) { var sc = (StatementCondition) s; if(sc.Condition is DebugCondition) url = "version.html#DebugCondition"; else if (sc.Condition is VersionCondition) url = "version.html#VersionCondition"; else if (sc.Condition is StaticIfCondition) url = "version.html#StaticIfCondition"; } else url += s.GetType ().Name; return url; }
public static string GetRefUrlFor(IStatement s, CodeLocation caret) { if (s is IExpressionContainingStatement) { var exprs = (s as IExpressionContainingStatement).SubExpressions; IExpression targetExpr = null; if (exprs != null) { foreach (var ex in exprs) { if (caret >= ex.Location && caret <= ex.EndLocation && (targetExpr = ExpressionHelper.SearchExpressionDeeply(ex, caret)) != ex) { break; } } } if (targetExpr != null) { return(GetRefUrlFor(targetExpr)); } } if (s is DeclarationStatement) { var ds = s as DeclarationStatement; foreach (var decl in ds.Declarations) { if (caret >= decl.Location && caret <= decl.EndLocation) { if (decl is DVariable) { var dv = decl as DVariable; if (dv.Initializer != null && caret >= dv.Location && caret <= dv.EndLocation) { return(GetRefUrlFor(dv.Initializer)); } } } } } if (s is StatementContainingStatement) { var stmts = (s as StatementContainingStatement).SubStatements; if (stmts != null) { foreach (var stmt in stmts) { if (caret >= stmt.Location && caret <= stmt.EndLocation) { var r = GetRefUrlFor(stmt, caret); if (r != null) { return(r); } } } } } var url = "statement.html#"; if (s is ForeachStatement && (s as ForeachStatement).IsRangeStatement) { url += "ForeachRangeStatement"; } else if (s is StatementCondition) { var sc = (StatementCondition)s; if (sc.Condition is DebugCondition) { url = "version.html#DebugCondition"; } else if (sc.Condition is VersionCondition) { url = "version.html#VersionCondition"; } else if (sc.Condition is StaticIfCondition) { url = "version.html#StaticIfCondition"; } } else { url += s.GetType().Name; } return(url); }
/// <summary> /// Can we combine? Yes, if and only if the same guy and same variables! /// </summary> /// <param name="statement"></param> /// <param name="optimize"></param> /// <returns></returns> public bool TryCombineStatement(IStatement statement, ICodeOptimizationService optimize) { if (statement.GetType() != typeof(StatementRecordPairValues)) return false; var other = statement as StatementRecordPairValues; if (other._index.RawValue != _index.RawValue) return false; var isTheSame = _savers.Zip(other._savers, (f, s) => f.indexValue.RawValue == s.indexValue.RawValue && f.mapRecord.Type == s.mapRecord.Type).All(b => b); if (!isTheSame) { return false; } // Now we can do them all. foreach (var saver in _savers.Zip(other._savers, (f, s) => Tuple.Create(f, s))) { optimize.TryRenameVarialbeOneLevelUp(saver.Item2.mapRecord.RawValue, saver.Item1.mapRecord); } return true; }