public static string Format_Literal_Expression(LiteralExpression literal) { switch (literal.LiteralType) { case LiteralType.True: return "true"; case LiteralType.False: return "false"; case LiteralType.Null: return "null"; /* case LiteralType.DecimalInteger: break; case LiteralType.HexadecimalInteger: break; case LiteralType.OctalInteger: break; case LiteralType.Real: break; case LiteralType.Character: break; case LiteralType.String: break; case LiteralType.VerbatimString: break; */ } return literal.LiteralValue; }
protected void Verify(string source, object value) { if (!(value is Expression)) value = new LiteralExpression(value); base.Verify(source, (Expression)value); }
/// <summary> /// Initializes a new instance of the LabelStatement class. /// </summary> /// <param name="tokens"> /// The list of tokens that form the statement. /// </param> /// <param name="identifier"> /// The label identifier. /// </param> internal LabelStatement(CsTokenList tokens, LiteralExpression identifier) : base(StatementType.Label, tokens) { Param.AssertNotNull(tokens, "tokens"); Param.AssertNotNull(identifier, "identifier"); this.identifier = identifier; this.AddExpression(identifier); }
/// <summary> /// Initializes a new instance of the EventDeclaratorExpression class. /// </summary> /// <param name="tokens"> /// The list of tokens that form the statement. /// </param> /// <param name="identifier"> /// The identifier name of the event. /// </param> /// <param name="initializer"> /// The initialization expression for the event. /// </param> internal EventDeclaratorExpression(CsTokenList tokens, LiteralExpression identifier, Expression initializer) : base(ExpressionType.EventDeclarator, tokens) { Param.AssertNotNull(tokens, "tokens"); Param.AssertNotNull(identifier, "identifier"); Param.Ignore(initializer); this.identifier = identifier; this.initializer = initializer; this.AddExpression(identifier); if (initializer != null) { this.AddExpression(initializer); } }
private static Expression CoerceLiteralExpression(LiteralExpression literal) { // Force 0 and 1 literals to boolean. if (literal.Value is int) { switch ((int)literal.Value) { case 0: return new LiteralExpression(false, LiteralType.Boolean); case 1: return new LiteralExpression(true, LiteralType.Boolean); } } throw new ODataException(ErrorMessages.Parser_ExpectedBooleanExpression); }
/// <summary> /// Initializes a new instance of the AttributeExpression class. /// </summary> /// <param name="tokens"> /// The list of tokens that form the expression. /// </param> /// <param name="target"> /// The attribute target, if any. /// </param> /// <param name="initialization"> /// The attribute initialization call. /// </param> internal AttributeExpression(CsTokenList tokens, LiteralExpression target, Expression initialization) : base(ExpressionType.Attribute, tokens) { Param.AssertNotNull(tokens, "tokens"); Param.Ignore(target); Param.AssertNotNull(initialization, "initialization"); // Add the target expression. this.target = target; if (target != null) { this.AddExpression(target); } // Add the initialization expression. this.initialization = initialization; this.AddExpression(initialization); }
void LiteralExpression(ref ExpressionTreeBase expr) { if (la.kind == 35) { Get(); expr = new RangeExpression(t.val); } else if (la.kind == 3) { Get(); expr = new LiteralExpression(t.val); } else if (la.kind == 4) { Get(); expr = new LiteralExpression(t.val.Substring(1, t.val.Length - 2), true); } else if (la.kind == 5) { Get(); expr = new ValueExpression(Int32.Parse(t.val.Substring(1))); } else if (la.kind == 1) { Get(); expr = new LiteralExpression(t.val); } else SynErr(53); }
public sealed override void Initialize(AnalysisContext context) { context.RegisterCompilationStartAction( (compilationContext) => { Dictionary <IFieldSymbol, HashSet <INamedTypeSymbol> > fieldsSourceTypes = new Dictionary <IFieldSymbol, HashSet <INamedTypeSymbol> >(); compilationContext.RegisterOperationBlockStartAction( (operationBlockContext) => { if (operationBlockContext.OwningSymbol is IMethodSymbol containingMethod) { Dictionary <ILocalSymbol, HashSet <INamedTypeSymbol> > localsSourceTypes = new Dictionary <ILocalSymbol, HashSet <INamedTypeSymbol> >(); // Track explicit assignments. operationBlockContext.RegisterOperationAction( (operationContext) => { if (operationContext.Operation is IAssignmentExpression assignment) { AssignTo(assignment.Target, localsSourceTypes, fieldsSourceTypes, assignment.Value); } else if (operationContext.Operation is IIncrementOrDecrementExpression increment) { SyntaxNode syntax = increment.Syntax; ITypeSymbol type = increment.Type; Optional <object> constantValue = new Optional <object>(1); bool isImplicit = increment.IsImplicit; var value = new LiteralExpression(operationContext.Compilation.GetSemanticModel(syntax.SyntaxTree), syntax, type, constantValue, isImplicit); AssignTo(increment.Target, localsSourceTypes, fieldsSourceTypes, value); } else { throw TestExceptionUtilities.UnexpectedValue(operationContext.Operation); } }, OperationKind.SimpleAssignmentExpression, OperationKind.CompoundAssignmentExpression, OperationKind.IncrementExpression); // Track arguments that match out or ref parameters. operationBlockContext.RegisterOperationAction( (operationContext) => { IInvocationExpression invocation = (IInvocationExpression)operationContext.Operation; foreach (IArgument argument in invocation.ArgumentsInEvaluationOrder) { if (argument.Parameter.RefKind == RefKind.Out || argument.Parameter.RefKind == RefKind.Ref) { AssignTo(argument.Value, localsSourceTypes, fieldsSourceTypes, argument.Parameter.Type); } } }, OperationKind.InvocationExpression); // Track local variable initializations. operationBlockContext.RegisterOperationAction( (operationContext) => { IVariableDeclarationStatement declaration = (IVariableDeclarationStatement)operationContext.Operation; foreach (IVariableDeclaration variable in declaration.Declarations) { foreach (ILocalSymbol local in variable.Variables) { if (variable.Initializer != null) { AssignTo(local, local.Type, localsSourceTypes, variable.Initializer); } } } }, OperationKind.VariableDeclarationStatement); // Report locals that could have more specific types. operationBlockContext.RegisterOperationBlockEndAction( (operationBlockEndContext) => { foreach (ILocalSymbol local in localsSourceTypes.Keys) { if (HasMoreSpecificSourceType(local, local.Type, localsSourceTypes, out var mostSpecificSourceType)) { Report(operationBlockEndContext, local, mostSpecificSourceType, LocalCouldHaveMoreSpecificTypeDescriptor); } } }); } }); // Track field initializations. compilationContext.RegisterOperationAction( (operationContext) => { IFieldInitializer initializer = (IFieldInitializer)operationContext.Operation; foreach (IFieldSymbol initializedField in initializer.InitializedFields) { AssignTo(initializedField, initializedField.Type, fieldsSourceTypes, initializer.Value); } }, OperationKind.FieldInitializer); // Report fields that could have more specific types. compilationContext.RegisterCompilationEndAction( (compilationEndContext) => { foreach (IFieldSymbol field in fieldsSourceTypes.Keys) { if (HasMoreSpecificSourceType(field, field.Type, fieldsSourceTypes, out var mostSpecificSourceType)) { Report(compilationEndContext, field, mostSpecificSourceType, FieldCouldHaveMoreSpecificTypeDescriptor); } } }); }); }
/// <summary> /// Initializes a new instance of the <see cref="LayoutKeyValue"/> class. /// </summary> /// <param name="name">The name.</param> /// <param name="value">The value.</param> public LayoutKeyValue(Identifier name, LiteralExpression value) { Name = name; Value = value; }
private static MethodDeclaration GenerateMethod(ClassDeclaration clientClass, Method method, TypeReference requestType) { var m = clientClass.AddMember(new MethodDeclaration(method.MethodGroup.Name + '_' + GetMethodName(method))); m.SetData("Method", method); var buildUrlMethod = GenerateBuildUrlMethod(clientClass, method, requestType); GenerateMethodSignature(method, m, requestType, out var requestArgument, out var requestOptionsArgument, out var cancellationTokenArgument); m.Modifiers = Modifiers.Private; if (method.MethodType != MethodType.GetPaged) { m.Modifiers |= Modifiers.Async; } // Method body m.Statements = new StatementCollection(); // 1. Create url from parameters var buildUrlExpression = new MethodInvokeExpression(new MemberReferenceExpression(new TypeReference(clientClass), buildUrlMethod)); if (buildUrlMethod.Arguments.Count > 0) { buildUrlExpression.Arguments.Add(requestArgument); } var urlVariable = new VariableDeclarationStatement(typeof(string), "url", buildUrlExpression); m.Statements.Add(urlVariable); if (method.MethodType == MethodType.GetPaged) { // return new Meziantou.GitLab.PagedResponse<MergeRequest>(this, url, requestOptions); m.Statements.Add(new ReturnStatement(new NewObjectExpression(m.ReturnType !.Clone(), new ThisExpression(), urlVariable, requestOptionsArgument))); } else { // 2. Create HttpRequestMessage object var requestVariable = new VariableDeclarationStatement(typeof(HttpRequestMessage), "requestMessage", new NewObjectExpression(typeof(HttpRequestMessage))); var usingStatement = new UsingStatement() { Statement = requestVariable, Body = new StatementCollection() }; m.Statements.Add(usingStatement); var statements = usingStatement.Body; statements.Add(new AssignStatement(new MemberReferenceExpression(requestVariable, nameof(HttpRequestMessage.Method)), GetHttpMethod(method.MethodType))); statements.Add(new AssignStatement(new MemberReferenceExpression(requestVariable, nameof(HttpRequestMessage.RequestUri)), new NewObjectExpression(typeof(Uri), urlVariable, new MemberReferenceExpression(typeof(UriKind), nameof(UriKind.RelativeOrAbsolute))))); CreateBodyArgument(method, statements, requestArgument, requestVariable); // 3. Send request // var response = await SendAsync(request, options, cancellationToken).ConfigureAwait(false); var responseVariable = new VariableDeclarationStatement(WellKnownTypes.HttpResponseTypeReference.MakeNullable(), "response", LiteralExpression.Null()); statements.Add(responseVariable); var responseTry = new TryCatchFinallyStatement() { Try = new StatementCollection() }; statements.Add(responseTry); responseTry.Try.Add(new AssignStatement(responseVariable, new AwaitExpression(new MethodInvokeExpression(new MemberReferenceExpression(new ThisExpression(), "SendAsync"), requestVariable, requestOptionsArgument, cancellationTokenArgument)).ConfigureAwait(false))); // Dispose reponse in catch if Stream or in finally if not stream var disposeReponseStatements = new ConditionStatement() { Condition = new BinaryExpression(BinaryOperator.NotEquals, responseVariable, LiteralExpression.Null()), TrueStatements = responseVariable.CreateInvokeMethodExpression("Dispose"), }; if (method.ReturnType == ModelRef.File) { responseTry.Catch = new CatchClauseCollection { new CatchClause() { Body = disposeReponseStatements, }, }; responseTry.Catch[0].Body.Add(new ThrowStatement()); } else { responseTry.Finally = disposeReponseStatements; } // 4. Convert and return response object // if (response.StatusCode == HttpStatusCode.NotFound) return default; if (method.MethodType == MethodType.Get) { responseTry.Try.Add(new ConditionStatement() { Condition = new BinaryExpression(BinaryOperator.Equals, responseVariable.CreateMemberReferenceExpression("StatusCode"), new MemberReferenceExpression(typeof(HttpStatusCode), "NotFound")), TrueStatements = new ReturnStatement(new DefaultValueExpression()), }); } // await response.EnsureStatusCodeAsync(cancellationToken).ConfigureAwait(false); responseTry.Try.Add(new AwaitExpression(new MethodInvokeExpression(new MemberReferenceExpression(responseVariable, "EnsureStatusCodeAsync"), cancellationTokenArgument)).ConfigureAwait(false)); if (method.ReturnType != null) { // var result = await response.ToObjectAsync<T>(cancellationToken).ConfigureAwait(false); var resultVariable = new VariableDeclarationStatement(m.ReturnType.Parameters[0].MakeNullable(), "result"); responseTry.Try.Add(resultVariable); if (method.MethodType == MethodType.Get && method.ReturnType == ModelRef.File) { resultVariable.InitExpression = new AwaitExpression(responseVariable.CreateInvokeMethodExpression("ToStreamAsync", cancellationTokenArgument)).ConfigureAwait(false); } else if (method.MethodType == MethodType.GetCollection) { resultVariable.InitExpression = new AwaitExpression(responseVariable.CreateInvokeMethodExpression("ToCollectionAsync", new TypeReference[] { method.ReturnType.ToPropertyTypeReference() }, cancellationTokenArgument)).ConfigureAwait(false); } else { resultVariable.InitExpression = new AwaitExpression(responseVariable.CreateInvokeMethodExpression("ToObjectAsync", new TypeReference[] { method.ReturnType.ToPropertyTypeReference() }, cancellationTokenArgument)).ConfigureAwait(false); } // if (result is null) // throw new GitLabException(response.RequestMethod, response.RequestUri, response.StatusCode, $"The response cannot be converted to '{typeof(T)}' because the body is null or empty"); if (method.MethodType != MethodType.Get) { responseTry.Try.Add(new ConditionStatement() { Condition = new BinaryExpression(BinaryOperator.Equals, resultVariable, LiteralExpression.Null()), TrueStatements = new ThrowStatement(new NewObjectExpression(WellKnownTypes.GitLabExceptionTypeReference, responseVariable.CreateMemberReferenceExpression("RequestMethod"), responseVariable.CreateMemberReferenceExpression("RequestUri"), responseVariable.CreateMemberReferenceExpression("StatusCode"), new LiteralExpression($"The response cannot be converted to '{method.ReturnType.ToPropertyTypeReference().ClrFullTypeName}' because the body is null or empty"))), }); } responseTry.Try.Add(new ReturnStatement(resultVariable)); } } return(m);
public void VisitLiteralExpression(LiteralExpression literal) { throw new NotImplementedException(); }
protected abstract T CompileLiteralExpression(LiteralExpression expression);
public Window1() { BindKey(ApplicationCommands.Find, Key.F, ModifierKeys.Control); BindKey(EditingCommands.Backspace, Key.N, ModifierKeys.Alt); BindKey(EditingCommands.Delete, Key.M, ModifierKeys.Alt); BindKey(EditingCommands.DeleteNextWord, Key.M, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.DeletePreviousWord, Key.N, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveDownByLine, Key.K, ModifierKeys.Alt); BindKey(EditingCommands.MoveDownByPage, Key.K, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveLeftByCharacter, Key.J, ModifierKeys.Alt); BindKey(EditingCommands.MoveRightByCharacter, Key.Oem3, ModifierKeys.Alt); BindKey(EditingCommands.MoveUpByLine, Key.L, ModifierKeys.Alt); BindKey(EditingCommands.MoveLeftByWord, Key.J, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveRightByWord, Key.M, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveToDocumentEnd, Key.Oem1, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveToDocumentStart, Key.U, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveToLineEnd, Key.Oem1, ModifierKeys.Alt); BindKey(EditingCommands.MoveToLineStart, Key.U, ModifierKeys.Alt); BindKey(EditingCommands.MoveUpByPage, Key.L, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.SelectDownByLine, Key.K, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectDownByPage, Key.K, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectLeftByCharacter, Key.J, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectLeftByWord, Key.J, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectRightByCharacter, Key.Oem3, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectRightByWord, Key.Oem1, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectToDocumentEnd, Key.Oem1, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectToDocumentStart, Key.U, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectToLineEnd, Key.Oem1, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectToLineStart, Key.U, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectUpByLine, Key.L, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectUpByPage, Key.L, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); InitializeComponent(); textBox.FontSize = 16; intellisense.MaxHeight = 100; intellisense.Width = 200; intellisense.SetValue(ScrollViewer.HorizontalScrollBarVisibilityProperty, ScrollBarVisibility.Hidden); textBox.FontFamily = new FontFamily("Courier New"); textBox.AcceptsTab = true; intellisense.MouseDoubleClick += delegate { Complete(); }; textBox.PreviewKeyDown += delegate(object sender, KeyEventArgs e) { if (Intellisense) { e.Handled = true; if (e.KeyboardDevice.Modifiers == ModifierKeys.Alt) { if (e.Key == Key.L) { IntellisenseUp(); } else if (e.Key == Key.K) { IntellisenseDown(); } else { e.Handled = false; } } else if (e.KeyboardDevice.Modifiers == ModifierKeys.Control) { if (e.Key == Key.L) { EditingCommands.MoveToLineStart.Execute(null, textBox); EditingCommands.SelectToLineEnd.Execute(null, textBox); EditingCommands.Delete.Execute(null, textBox); } else if (e.Key == Key.Space) { } else { e.Handled = false; } } else if (e.Key == Key.Return) { Complete(); } else if (e.Key == Key.Tab) { Complete(); } else if (e.Key == Key.Up) { IntellisenseUp(); } else if (e.Key == Key.Down) { IntellisenseDown(); } else { e.Handled = false; } } };; textBox.KeyDown += delegate(object obj, KeyEventArgs e) { if (e.Key == Key.Return) { string line = textBox.GetLineText(textBox.GetLineIndexFromCharacterIndex(textBox.SelectionStart)); textBox.SelectedText = "\n".PadRight(1 + line.Length - line.TrimStart('\t').Length, '\t'); textBox.SelectionStart = textBox.SelectionStart + textBox.SelectionLength; textBox.SelectionLength = 0; textBox.Focus(); } else if (e.Key == Key.Escape) { if (Intellisense) { intellisense.Visibility = Visibility.Hidden; } } else if (e.Key == Key.OemPeriod) { string text = textBox.Text.Substring(0, textBox.SelectionStart); searchStart = textBox.SelectionStart; Interpreter.profiling = false; foreach (Parser.CachedRule rule in Parser.CachedRule.cachedRules) { rule.cached.Clear(); } Parser parser = new Parser(text, fileName); Map map = null; bool matched = Parser.File.Match(parser, ref map); LiteralExpression gac = new LiteralExpression(Gac.gac, null); LiteralExpression lib = new LiteralExpression(Gac.gac["library"], gac); lib.Statement = new LiteralStatement(gac); KeyStatement.intellisense = true; map[CodeKeys.Function].GetExpression(lib).Statement = new LiteralStatement(lib); map[CodeKeys.Function].Compile(lib); Source key = new Source( parser.State.Line, parser.State.Column, parser.FileName); intellisense.Items.Clear(); if (Meta.Expression.sources.ContainsKey(key)) { List <Meta.Expression> list = Meta.Expression.sources[key]; for (int i = 0; i < list.Count; i++) { if (list[i] is Search || list[i] is Select) { PositionIntellisense(); intellisense.Items.Clear(); Structure s = list[i].EvaluateStructure(); List <string> keys = new List <string>(); if (s != null) { foreach (Map m in ((LiteralStructure)s).Literal.Keys) { keys.Add(m.ToString()); } } keys.Sort(delegate(string a, string b) { return(a.CompareTo(b)); }); if (keys.Count != 0) { intellisense.Visibility = Visibility.Visible; } foreach (string k in keys) { intellisense.Items.Add(k); } if (intellisense.Items.Count != 0) { intellisense.SelectedIndex = 0; } } } } else { MessageBox.Show("no intellisense" + Meta.Expression.sources.Count); } Meta.Expression.sources.Clear(); } }; DockPanel dockPanel = new DockPanel(); Menu menu = new Menu(); DockPanel.SetDock(menu, Dock.Top); MenuItem file = new MenuItem(); MenuItem save = new MenuItem(); MenuItem run = new MenuItem(); MenuItem open = new MenuItem(); file.Header = "File"; open.Header = "Open"; save.Header = "Save"; run.Header = "Run"; open.Click += delegate { OpenFileDialog dialog = new OpenFileDialog(); if (dialog.ShowDialog() == true) { Open(dialog.FileName); } }; run.Click += delegate { Save(); Process.Start(System.IO.Path.Combine(@"D:\Meta\", @"bin\Debug\Meta.exe"), fileName); }; save.Click += delegate { Save(); }; DockPanel.SetDock(status, Dock.Bottom); dockPanel.Children.Add(status); file.Items.Add(open); file.Items.Add(save); file.Items.Add(run); menu.Items.Add(file); dockPanel.Children.Add(menu); DockPanel.SetDock(textBox, Dock.Bottom); textBox.TextChanged += delegate { if (Intellisense) { if (textBox.SelectionStart <= searchStart) { intellisense.Visibility = Visibility.Hidden; } else { int index = textBox.Text.Substring(0, textBox.SelectionStart).LastIndexOf('.'); if (index != -1) { string text = textBox.Text.Substring(index + 1, textBox.SelectionStart - index - 1); foreach (string item in intellisense.Items) { if (item.StartsWith(text, StringComparison.OrdinalIgnoreCase)) { intellisense.SelectedItem = item; intellisense.ScrollIntoView(intellisense.SelectedItem); break; } } } } } }; textBox.SelectionChanged += delegate { status.Content = "Ln " + (textBox.GetLineIndexFromCharacterIndex(textBox.SelectionStart) + 1); }; Canvas canvas = new Canvas(); canvas.Children.Add(textBox); canvas.Background = Brushes.Yellow; DockPanel.SetDock(canvas, Dock.Top); scrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Visible; scrollViewer.VerticalScrollBarVisibility = ScrollBarVisibility.Visible; scrollViewer.Content = canvas; dockPanel.Children.Add(scrollViewer); const int width = 0; const int height = 0; Canvas.SetLeft(textBox, width / 2); Canvas.SetTop(textBox, height / 2); textBox.SizeChanged += delegate { canvas.Width = textBox.ActualWidth + width; canvas.Height = textBox.ActualHeight + height; }; intellisense.SelectionChanged += delegate(object sender, SelectionChangedEventArgs e) { if (intellisense.SelectedItem != null) { intellisense.ScrollIntoView(intellisense.SelectedItem); } }; intellisense.Visibility = Visibility.Hidden; Canvas.SetZIndex(intellisense, 100); canvas.Children.Add(intellisense); this.Content = dockPanel; this.Loaded += delegate { Open(@"D:\meta\game.meta"); textBox.Focus(); textBox.SelectionStart = 0; }; }
public object Visit(LiteralExpression literalExpression) { PrintMiddle(literalExpression.Value.Value, ConsoleColor.Magenta); return(null !); }
public override void Visit(LiteralExpression expression) { _result = expression.Value; }
public CaseExpression(LiteralExpression literalValue, Expression bodyExp) { this.literal = literalValue; }
private static void FormatLiteralExpression(int prefixLength, StringBuilder builder, LiteralExpression literalExpression) { builder.AppendLine(literalExpression.LiteralValue.Value == null ? AddPrefix(prefixLength, "value: null") : AddPrefix(prefixLength, $"value: {literalExpression.LiteralValue.Value}({literalExpression.ValueType.Name})")); builder.AppendLine(AddPrefix(prefixLength, $"raw: {literalExpression.LiteralValue.Literal}")); }
public Window1() { BindKey(ApplicationCommands.Find, Key.F, ModifierKeys.Control); BindKey(EditingCommands.Backspace, Key.N, ModifierKeys.Alt); BindKey(EditingCommands.Delete, Key.M, ModifierKeys.Alt); BindKey(EditingCommands.DeleteNextWord, Key.M, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.DeletePreviousWord, Key.N, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveDownByLine, Key.K, ModifierKeys.Alt); BindKey(EditingCommands.MoveDownByPage, Key.K, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveLeftByCharacter, Key.J, ModifierKeys.Alt); BindKey(EditingCommands.MoveRightByCharacter, Key.Oem3, ModifierKeys.Alt); BindKey(EditingCommands.MoveUpByLine, Key.L, ModifierKeys.Alt); BindKey(EditingCommands.MoveLeftByWord, Key.J, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveRightByWord, Key.M, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveToDocumentEnd, Key.Oem1, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveToDocumentStart, Key.U, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.MoveToLineEnd, Key.Oem1, ModifierKeys.Alt); BindKey(EditingCommands.MoveToLineStart, Key.U, ModifierKeys.Alt); BindKey(EditingCommands.MoveUpByPage, Key.L, ModifierKeys.Alt | ModifierKeys.Control); BindKey(EditingCommands.SelectDownByLine, Key.K, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectDownByPage, Key.K, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectLeftByCharacter, Key.J, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectLeftByWord, Key.J, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectRightByCharacter, Key.Oem3, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectRightByWord, Key.Oem1, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectToDocumentEnd, Key.Oem1, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectToDocumentStart, Key.U, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); BindKey(EditingCommands.SelectToLineEnd, Key.Oem1, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectToLineStart, Key.U, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectUpByLine, Key.L, ModifierKeys.Alt | ModifierKeys.Shift); BindKey(EditingCommands.SelectUpByPage, Key.L, ModifierKeys.Alt | ModifierKeys.Control | ModifierKeys.Shift); InitializeComponent(); textBox.FontSize = 16; intellisense.MaxHeight = 100; intellisense.Width = 200; intellisense.SetValue(ScrollViewer.HorizontalScrollBarVisibilityProperty, ScrollBarVisibility.Hidden); textBox.FontFamily = new FontFamily("Courier New"); textBox.AcceptsTab = true; intellisense.MouseDoubleClick += delegate { Complete(); }; textBox.PreviewKeyDown += delegate(object sender, KeyEventArgs e) { if (Intellisense) { e.Handled = true; if (e.KeyboardDevice.Modifiers == ModifierKeys.Alt) { if (e.Key == Key.L) { IntellisenseUp(); } else if (e.Key == Key.K) { IntellisenseDown(); } else { e.Handled = false; } } else if (e.KeyboardDevice.Modifiers == ModifierKeys.Control) { if (e.Key == Key.L) { EditingCommands.MoveToLineStart.Execute(null, textBox); EditingCommands.SelectToLineEnd.Execute(null, textBox); EditingCommands.Delete.Execute(null, textBox); } else if (e.Key == Key.Space) { } else { e.Handled = false; } } else if (e.Key == Key.Return) { Complete(); } else if (e.Key == Key.Tab) { Complete(); } else if (e.Key == Key.Up) { IntellisenseUp(); } else if (e.Key == Key.Down) { IntellisenseDown(); } else { e.Handled = false; } } };; textBox.KeyDown += delegate(object obj, KeyEventArgs e) { if (e.Key == Key.Return) { string line = textBox.GetLineText(textBox.GetLineIndexFromCharacterIndex(textBox.SelectionStart)); textBox.SelectedText = "\n".PadRight(1 + line.Length - line.TrimStart('\t').Length, '\t'); textBox.SelectionStart = textBox.SelectionStart + textBox.SelectionLength; textBox.SelectionLength = 0; textBox.Focus(); } else if (e.Key == Key.Escape) { if (Intellisense) { intellisense.Visibility = Visibility.Hidden; } } else if (e.Key == Key.OemPeriod) { string text = textBox.Text.Substring(0, textBox.SelectionStart); searchStart = textBox.SelectionStart; Interpreter.profiling = false; foreach (Parser.CachedRule rule in Parser.CachedRule.cachedRules) { rule.cached.Clear(); } Parser parser = new Parser(text, fileName); Map map = null; bool matched = Parser.File.Match(parser, ref map); LiteralExpression gac = new LiteralExpression(Gac.gac, null); LiteralExpression lib = new LiteralExpression(Gac.gac["library"], gac); lib.Statement = new LiteralStatement(gac); KeyStatement.intellisense = true; map[CodeKeys.Function].GetExpression(lib).Statement = new LiteralStatement(lib); map[CodeKeys.Function].Compile(lib); Source key = new Source( parser.State.Line, parser.State.Column, parser.FileName); intellisense.Items.Clear(); if (Meta.Expression.sources.ContainsKey(key)) { List<Meta.Expression> list = Meta.Expression.sources[key]; for (int i = 0; i < list.Count; i++) { if (list[i] is Search || list[i] is Select) { PositionIntellisense(); intellisense.Items.Clear(); Structure s = list[i].EvaluateStructure(); List<string> keys = new List<string>(); if (s != null) { foreach (Map m in ((LiteralStructure)s).Literal.Keys) { keys.Add(m.ToString()); } } keys.Sort(delegate(string a, string b) { return a.CompareTo(b); }); if (keys.Count != 0) { intellisense.Visibility = Visibility.Visible; } foreach (string k in keys) { intellisense.Items.Add(k); } if (intellisense.Items.Count != 0) { intellisense.SelectedIndex = 0; } } } } else { MessageBox.Show("no intellisense" + Meta.Expression.sources.Count); } Meta.Expression.sources.Clear(); } }; DockPanel dockPanel = new DockPanel(); Menu menu = new Menu(); DockPanel.SetDock(menu, Dock.Top); MenuItem file = new MenuItem(); MenuItem save = new MenuItem(); MenuItem run = new MenuItem(); MenuItem open = new MenuItem(); file.Header = "File"; open.Header = "Open"; save.Header = "Save"; run.Header = "Run"; open.Click += delegate { OpenFileDialog dialog = new OpenFileDialog(); if (dialog.ShowDialog() == true) { Open(dialog.FileName); } }; run.Click += delegate { Save(); Process.Start(System.IO.Path.Combine(@"D:\Meta\", @"bin\Debug\Meta.exe"), fileName); }; save.Click += delegate { Save(); }; DockPanel.SetDock(status, Dock.Bottom); dockPanel.Children.Add(status); file.Items.Add(open); file.Items.Add(save); file.Items.Add(run); menu.Items.Add(file); dockPanel.Children.Add(menu); DockPanel.SetDock(textBox,Dock.Bottom); textBox.TextChanged += delegate { if (Intellisense) { if (textBox.SelectionStart <= searchStart) { intellisense.Visibility = Visibility.Hidden; } else { int index = textBox.Text.Substring(0, textBox.SelectionStart).LastIndexOf('.'); if (index != -1) { string text = textBox.Text.Substring(index + 1, textBox.SelectionStart - index - 1); foreach (string item in intellisense.Items) { if (item.StartsWith(text, StringComparison.OrdinalIgnoreCase)) { intellisense.SelectedItem = item; intellisense.ScrollIntoView(intellisense.SelectedItem); break; } } } } } }; textBox.SelectionChanged += delegate { status.Content = "Ln " + (textBox.GetLineIndexFromCharacterIndex(textBox.SelectionStart) + 1); }; Canvas canvas = new Canvas(); canvas.Children.Add(textBox); canvas.Background = Brushes.Yellow; DockPanel.SetDock(canvas, Dock.Top); scrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Visible; scrollViewer.VerticalScrollBarVisibility = ScrollBarVisibility.Visible; scrollViewer.Content = canvas; dockPanel.Children.Add(scrollViewer); const int width = 0; const int height = 0; Canvas.SetLeft(textBox, width/2); Canvas.SetTop(textBox, height/2); textBox.SizeChanged += delegate { canvas.Width = textBox.ActualWidth + width; canvas.Height = textBox.ActualHeight + height; }; intellisense.SelectionChanged += delegate(object sender, SelectionChangedEventArgs e) { if (intellisense.SelectedItem != null) { intellisense.ScrollIntoView(intellisense.SelectedItem); } }; intellisense.Visibility = Visibility.Hidden; Canvas.SetZIndex(intellisense, 100); canvas.Children.Add(intellisense); this.Content = dockPanel; this.Loaded += delegate { Open(@"D:\meta\game.meta"); textBox.Focus(); textBox.SelectionStart = 0; }; }
/// <summary> /// 式中のメンバアクセス、定数等を解析する。 /// </summary> /// <param name="syntax"></param> /// <param name="semanticModel"></param> /// <returns></returns> Expression ParseExpression(ExpressionSyntax syntax, SemanticModel semanticModel) { if (syntax == null) { return(null); } var mae = syntax as MemberAccessExpressionSyntax; var gns = syntax as GenericNameSyntax; var le = syntax as LiteralExpressionSyntax; var ie = syntax as InvocationExpressionSyntax; var oce = syntax as ObjectCreationExpressionSyntax; var ce = syntax as CastExpressionSyntax; var thise = syntax as ThisExpressionSyntax; var ae = syntax as AssignmentExpressionSyntax; var pe = syntax as ParenthesizedExpressionSyntax; var ine = syntax as IdentifierNameSyntax; var eae = syntax as ElementAccessExpressionSyntax; var be = syntax as BinaryExpressionSyntax; var preue = syntax as PrefixUnaryExpressionSyntax; var poue = syntax as PostfixUnaryExpressionSyntax; var basee = syntax as BaseExpressionSyntax; var ace = syntax as ArrayCreationExpressionSyntax; var sace = syntax as StackAllocArrayCreationExpressionSyntax; var iee = syntax as InitializerExpressionSyntax; /* * var coe = syntax as ConditionalExpressionSyntax; * var sle = syntax as SimpleLambdaExpressionSyntax; * var ple = syntax as ParenthesizedLambdaExpressionSyntax; * var oase = syntax as OmittedArraySizeExpressionSyntax; * var iace = syntax as ImplicitArrayCreationExpressionSyntax; * * var qua = syntax as QualifiedNameSyntax; * var predf = syntax as PredefinedTypeSyntax; */ // 自己の型を解析 TypeInfo?selfTypeInfo = null; selfTypeInfo = semanticModel.GetTypeInfo(syntax); var selfType = ParseType(syntax, selfTypeInfo, semanticModel); if (mae != null) { MemberAccessExpression exp = new MemberAccessExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Name = mae.Name.ToString(); if (mae.Name is GenericNameSyntax) { var gns_ = mae.Name as GenericNameSyntax; exp.Types = gns_.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray(); } TypeInfo?parentType = null; if (mae.Expression != null) { parentType = semanticModel.GetTypeInfo(mae.Expression); } // 種類を取得 var symbol = semanticModel.GetSymbolInfo(mae); var methodSymbol = symbol.Symbol as IMethodSymbol; var propertySymbol = symbol.Symbol as IPropertySymbol; // 親の種類を探索 List <ClassDef> classDefPs = new List <ClassDef>(); EnumDef enumDefP = null; InterfaceDef interfaceDefP = null; StructDef structDefP = null; // プロパティである if (propertySymbol != null) { exp.IsProperty = true; } if (parentType.HasValue && parentType.Value.Type != null) { if (parentType.Value.Type.TypeKind == TypeKind.Interface) { var memName = mae.Name.ToString(); var sym = semanticModel.GetSymbolInfo(mae); var name_ = parentType.Value.Type.Name; var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace); interfaceDefP = definitions.Interfaces.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault(); } else if (parentType.Value.Type.TypeKind == TypeKind.Class) { var memName = mae.Name.ToString(); var sym = semanticModel.GetSymbolInfo(mae); var name_ = parentType.Value.Type.Name; var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace); classDefPs = definitions.FindTypeWithBases(namespace_, name_).OfType <ClassDef>().ToList(); } else if (parentType.Value.Type.TypeKind == TypeKind.Enum) { var enumName = selfTypeInfo.Value.Type.Name; var namespace_ = Utils.ToStr(selfTypeInfo.Value.Type.ContainingNamespace); enumDefP = definitions.Enums.Where(_ => _.Namespace == namespace_ && _.Name == enumName).FirstOrDefault(); } else if (parentType.Value.Type.TypeKind == TypeKind.Struct) { var memName = mae.Name.ToString(); var sym = semanticModel.GetSymbolInfo(mae); var name_ = parentType.Value.Type.Name; var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace); structDefP = definitions.Structs.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault(); } } // 親から子を探索 if (interfaceDefP != null) { if (methodSymbol != null) { var method = interfaceDefP.Methods.Where(_ => { if (_.Name != methodSymbol.Name) { return(false); } if (_.Parameters.Count() != methodSymbol.Parameters.Count()) { return(false); } for (int i = 0; i < _.Parameters.Count(); i++) { if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name) { return(false); } // TODO 正しい変換 //if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type) } return(true); }).FirstOrDefault(); if (method != null) { exp.Name = null; exp.Method = method; } } else if (propertySymbol != null) { var prop = interfaceDefP.Properties.Where(_ => { if (_.Name != propertySymbol.Name) { return(false); } return(true); }).FirstOrDefault(); if (prop != null) { exp.Name = null; exp.Property = prop; } } } else if (classDefPs.Count > 0) { if (methodSymbol != null) { foreach (var classDefP in classDefPs) { var method = classDefP.Methods.Where(_ => { if (_.Name != methodSymbol.Name) { return(false); } if (_.Parameters.Count() != methodSymbol.Parameters.Count()) { return(false); } for (int i = 0; i < _.Parameters.Count(); i++) { if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name) { return(false); } // TODO 正しい変換 //if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type) } return(true); }).FirstOrDefault(); if (method != null) { exp.Name = null; exp.Class = classDefP; exp.Method = method; // staticの場合走査停止 if (method.IsStatic) { return(exp); } break; } } } else if (propertySymbol != null) { foreach (var classDefP in classDefPs) { var prop = classDefP.Properties.Where(_ => { if (_.Name != propertySymbol.Name) { return(false); } return(true); }).FirstOrDefault(); if (prop != null) { exp.Name = null; exp.Class = classDefP; exp.Property = prop; break; } } } } else if (structDefP != null) { if (propertySymbol != null) { var prop = structDefP.Properties.Where(_ => { if (_.Name != propertySymbol.Name) { return(false); } return(true); }).FirstOrDefault(); if (prop != null) { exp.Name = null; exp.Struct = structDefP; exp.Property = prop; } } } else if (enumDefP != null) { var name = mae.Name.ToString(); exp.EnumMember = enumDefP.Members.Where(_ => _.Name == name).FirstOrDefault(); if (exp.EnumMember != null) { exp.Enum = enumDefP; exp.Name = null; } } else { // 代替処理 if (propertySymbol != null) { exp.Property = new PropertyDef(); exp.Property.Name = exp.Name; } } if (exp.EnumMember != null) { // enumのメンバーだった場合、親は必ずenumなのでこれ以上走査しない } else if (mae.Expression != null) { exp.Expression = ParseExpression(mae.Expression, semanticModel); } return(exp); } else if (gns != null) { var symbol = semanticModel.GetSymbolInfo(gns); var methodSymbol = symbol.Symbol as IMethodSymbol; var fieldSymbol = symbol.Symbol as IFieldSymbol; var propertySymbol = symbol.Symbol as IPropertySymbol; var exp = new GenericNameExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Name = gns.Identifier.ValueText; if (methodSymbol != null) { exp.IsMethod = true; } if (propertySymbol != null) { exp.IsProperty = true; } exp.Types = gns.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray(); return(exp); } else if (le != null) { var text = le.GetText().ToString(); var exp = new LiteralExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Text = text; return(exp); } else if (ie != null) { var exp = new InvocationExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Method = ParseExpression(ie.Expression, semanticModel); exp.Args = ie.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray(); return(exp); } else if (oce != null) { var exp = new ObjectCreationExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Type = ParseType(oce.Type, semanticModel); if (oce.ArgumentList != null) { exp.Args = oce.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray(); } else { exp.Args = new Expression[0]; } return(exp); } else if (ce != null) { var exp = new CastExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Type = ParseType(ce.Type, semanticModel); exp.Expression = ParseExpression(ce.Expression, semanticModel); return(exp); } else if (thise != null) { var exp = new ThisExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } else if (ae != null) { var exp = new AssignmentExpression(); exp.SelfType = selfType; exp.Internal = syntax; if (ae.Kind() == SyntaxKind.AddAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Add; } if (ae.Kind() == SyntaxKind.SubtractAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Substract; } if (ae.Kind() == SyntaxKind.SimpleAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Simple; } if (ae.Kind() == SyntaxKind.DivideAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Divide; } if (ae.Kind() == SyntaxKind.ModuloAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Modulo; } exp.Temp = ae.Kind(); exp.Target = ParseExpression(ae.Left, semanticModel); exp.Expression = ParseExpression(ae.Right, semanticModel); return(exp); } else if (pe != null) { // ()の構文 return(ParseExpression(pe.Expression, semanticModel)); } else if (ine != null) { var symbol = semanticModel.GetSymbolInfo(ine); var methodSymbol = symbol.Symbol as IMethodSymbol; var fieldSymbol = symbol.Symbol as IFieldSymbol; var propertySymbol = symbol.Symbol as IPropertySymbol; var exp = new IdentifierNameExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Name = ine.Identifier.Text; if (selfTypeInfo?.Type != null) { exp.Type = ParseType(selfTypeInfo.Value.Type); } if (methodSymbol != null) { exp.IsMethod = true; } if (propertySymbol != null) { exp.IsProperty = true; } return(exp); } else if (eae != null) { if (eae.ArgumentList.Arguments.Count() != 1) { throw new ParseException("多次元配列は使用禁止です。"); } var value_ = eae.Expression; var arg = eae.ArgumentList.Arguments[0].Expression; var exp = new ElementAccessExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Value = ParseExpression(value_, semanticModel); exp.Arg = ParseExpression(arg, semanticModel); return(exp); } else if (be != null) { var exp = new BinaryExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Left = ParseExpression(be.Left, semanticModel); exp.Right = ParseExpression(be.Right, semanticModel); if (be.Kind() == SyntaxKind.AddExpression) { exp.Operator = BinaryExpression.OperatorType.Add; } if (be.Kind() == SyntaxKind.SubtractExpression) { exp.Operator = BinaryExpression.OperatorType.Subtract; } if (be.Kind() == SyntaxKind.IsExpression) { exp.Operator = BinaryExpression.OperatorType.Is; } if (be.Kind() == SyntaxKind.AsExpression) { exp.Operator = BinaryExpression.OperatorType.As; } if (be.Kind() == SyntaxKind.EqualsExpression) { exp.Operator = BinaryExpression.OperatorType.Equals; } if (be.Kind() == SyntaxKind.NotEqualsExpression) { exp.Operator = BinaryExpression.OperatorType.NotEquals; } if (be.Kind() == SyntaxKind.LogicalAndExpression) { exp.Operator = BinaryExpression.OperatorType.LogicalAnd; } if (be.Kind() == SyntaxKind.LogicalOrExpression) { exp.Operator = BinaryExpression.OperatorType.LogicalOr; } if (be.Kind() == SyntaxKind.GreaterThanExpression) { exp.Operator = BinaryExpression.OperatorType.GreaterThan; } if (be.Kind() == SyntaxKind.GreaterThanOrEqualExpression) { exp.Operator = BinaryExpression.OperatorType.GreaterThanOrEqual; } if (be.Kind() == SyntaxKind.LessThanExpression) { exp.Operator = BinaryExpression.OperatorType.LessThan; } if (be.Kind() == SyntaxKind.LessThanOrEqualExpression) { exp.Operator = BinaryExpression.OperatorType.LessThanOrEqual; } if (be.Kind() == SyntaxKind.MultiplyExpression) { exp.Operator = BinaryExpression.OperatorType.Multiply; } if (be.Kind() == SyntaxKind.DivideExpression) { exp.Operator = BinaryExpression.OperatorType.Divide; } if (be.Kind() == SyntaxKind.ModuloExpression) { exp.Operator = BinaryExpression.OperatorType.Modulo; } if (exp.Operator == BinaryExpression.OperatorType.None) { var span_ = syntax.SyntaxTree.GetLineSpan(syntax.Span); Console.WriteLine(string.Format("{0} : {1} には未対応です。", span_, be.Kind())); } return(exp); } else if (preue != null) { var exp = new PrefixUnaryExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Expression = ParseExpression(preue.Operand, semanticModel); switch (preue.Kind()) { case SyntaxKind.LogicalNotExpression: exp.Type = PrefixUnaryExpression.OperatorType.LogicalNot; break; case SyntaxKind.UnaryPlusExpression: exp.Type = PrefixUnaryExpression.OperatorType.UnaryPlus; break; case SyntaxKind.UnaryMinusExpression: exp.Type = PrefixUnaryExpression.OperatorType.UnaryMinus; break; case SyntaxKind.PreIncrementExpression: exp.Type = PrefixUnaryExpression.OperatorType.PreIncrement; break; default: throw new Exception(); break; } return(exp); } else if (poue != null) { var exp = new PostfixUnaryExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Operand = ParseExpression(poue.Operand, semanticModel); if (poue.Kind() == SyntaxKind.PostIncrementExpression) { exp.Type = PostfixUnaryExpression.OperatorType.PostIncrement; } if (poue.Kind() == SyntaxKind.PostDecrementExpression) { exp.Type = PostfixUnaryExpression.OperatorType.PostDecrement; } return(exp); } else if (basee != null) { var exp = new BaseExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } else if (iee != null) { var exp = new InitializerExpression(); exp.SelfType = selfType; exp.Internal = syntax; var expressions = iee.Expressions.Select(_ => _).ToArray(); exp.Expressions = expressions.Select(_ => ParseExpression(_, semanticModel)).ToArray(); return(exp); } else if (ace != null || sace != null) { // stackallocも含め、配列の確保として扱う。 ArrayTypeSyntax ats = null; if (ace != null) { ats = ace.Type; } if (sace != null) { ats = sace.Type as ArrayTypeSyntax; } var exp = new ObjectArrayCreationExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Type = ParseType(ats.ElementType, semanticModel); exp.Args = ats.RankSpecifiers.Select(_ => ParseExpression(_.Sizes.FirstOrDefault(), semanticModel)).ToArray(); return(exp); } else if (syntax is PredefinedTypeSyntax) { var s = syntax as PredefinedTypeSyntax; var exp = new TypeExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } else if (syntax is QualifiedNameSyntax) { var s = syntax as QualifiedNameSyntax; var exp = new TypeExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } var span = syntax.SyntaxTree.GetLineSpan(syntax.Span); Console.WriteLine(string.Format("{0} : {1} には未対応です。", span, syntax.GetType())); return(null); }
public static string CoerceString(LiteralExpression literal) { if (literal.LiteralType == LiteralType.String) return (string)literal.Value; else return literal.Value.ToString(); }
public virtual void VisitLiteralExpression(LiteralExpression node) { }
private Expression GetNextExpression( ExpressionPrecedence previousPrecedence, bool unsafeCode, bool allowVariableDeclaration, bool typeExpression) { Param.Ignore(previousPrecedence); Param.Ignore(unsafeCode); Param.Ignore(allowVariableDeclaration); Param.Ignore(typeExpression); // Saves the next expression. Expression expression = null; // Get the next symbol. Symbol symbol = this.GetNextSymbol(); if (symbol != null) { switch (symbol.SymbolType) { case SymbolType.Other: if (this.IsLambdaExpression()) { expression = this.GetLambdaExpression(unsafeCode); } else if (this.IsQueryExpression(unsafeCode)) { expression = this.GetQueryExpression(unsafeCode); } // If the expression is still null now, this is just a regular 'other' expression. if (expression == null) { expression = this.GetOtherExpression(allowVariableDeclaration, unsafeCode); } break; case SymbolType.Checked: expression = this.GetCheckedExpression(unsafeCode); break; case SymbolType.Unchecked: expression = this.GetUncheckedExpression(unsafeCode); break; case SymbolType.New: expression = this.GetNewAllocationExpression(unsafeCode); break; case SymbolType.Stackalloc: expression = this.GetStackallocExpression(unsafeCode); break; case SymbolType.Sizeof: expression = this.GetSizeofExpression(unsafeCode); break; case SymbolType.Typeof: expression = this.GetTypeofExpression(unsafeCode); break; case SymbolType.Default: expression = this.GetDefaultValueExpression(unsafeCode); break; case SymbolType.Delegate: expression = this.GetAnonymousMethodExpression(unsafeCode); break; case SymbolType.Increment: if (this.IsUnaryExpression()) { expression = this.GetUnaryIncrementExpression(unsafeCode); } break; case SymbolType.Decrement: if (this.IsUnaryExpression()) { expression = this.GetUnaryDecrementExpression(unsafeCode); } break; case SymbolType.Plus: case SymbolType.Minus: if (this.IsUnaryExpression()) { expression = this.GetUnaryExpression(unsafeCode); } break; case SymbolType.Not: case SymbolType.Tilde: expression = this.GetUnaryExpression(unsafeCode); break; case SymbolType.OpenParenthesis: if (this.IsLambdaExpression()) { expression = this.GetLambdaExpression(unsafeCode); } else { expression = this.GetOpenParenthesisExpression(unsafeCode); } break; case SymbolType.Number: Node<CsToken> tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Number, SymbolType.Number)); expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode); break; case SymbolType.String: tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.String, SymbolType.String)); expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode); break; case SymbolType.True: tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.True, SymbolType.True)); expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode); break; case SymbolType.False: tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.False, SymbolType.False)); expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode); break; case SymbolType.Null: tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Null, SymbolType.Null)); expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode); break; case SymbolType.This: tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.This, SymbolType.This)); expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode); break; case SymbolType.Base: tokenNode = this.tokens.InsertLast(this.GetToken(CsTokenType.Base, SymbolType.Base)); expression = new LiteralExpression(new CsTokenList(this.tokens, tokenNode, tokenNode), tokenNode); break; case SymbolType.Multiplication: if (!unsafeCode) { goto default; } expression = this.GetUnsafeAccessExpression(unsafeCode); break; case SymbolType.LogicalAnd: if (!unsafeCode) { goto default; } expression = this.GetUnsafeAccessExpression(unsafeCode); break; default: throw new SyntaxException(this.document.SourceCode, symbol.LineNumber); } } // Gather up all extensions to this expression. while (expression != null) { // Check if there is an extension to this expression. Expression extension = this.GetExpressionExtension(expression, previousPrecedence, unsafeCode, typeExpression); if (extension != null) { // The larger expression is what we want to return here. expression = extension; } else { // There are no more extensions. break; } } // Return the expression. return expression; }
public Expression visit(LiteralExpression e) { return(e); }
protected virtual void VisitLiteral(LiteralExpression literal) { }
private PatternExpression ParseExpression(bool readBinOp = false) { PatternExpression ret; PatternToken token = ReadToken(); switch (token.Type) { case TokenType.Literal: ret = new LiteralExpression(token.Value); break; case TokenType.LParens: { ret = ParseExpression(true); PatternToken parens = ReadToken(); if (parens.Type != TokenType.RParens) { throw MismatchParens(token.Position.Value); } } break; case TokenType.Identifier: if (IsOperator(token)) { // unary operator PatternOperator op = ops[token.Value](); if (!op.IsUnary) { throw UnexpectedToken(token); } op.OperandA = ParseExpression(); ret = op; } else if (IsFunction(token)) { // function PatternFunction fn = fns[token.Value](); PatternToken parens = ReadToken(); if (parens.Type != TokenType.LParens) { throw UnexpectedToken(parens, '('); } fn.Arguments = new List <PatternExpression>(fn.ArgumentCount); for (int i = 0; i < fn.ArgumentCount; i++) { if (PeekToken() == null) { throw UnexpectedEnd(); } if (PeekToken().Value.Type == TokenType.RParens) { throw BadArgCount(token, fn.ArgumentCount); } if (i != 0) { PatternToken comma = ReadToken(); if (comma.Type != TokenType.Comma) { throw UnexpectedToken(comma, ','); } } fn.Arguments.Add(ParseExpression()); } parens = ReadToken(); if (parens.Type == TokenType.Comma) { throw BadArgCount(token, fn.ArgumentCount); } if (parens.Type != TokenType.RParens) { throw MismatchParens(parens.Position.Value); } ret = fn; } else { bool boolValue; if (bool.TryParse(token.Value, out boolValue)) { ret = new LiteralExpression(boolValue); } else { throw UnknownToken(token); } } break; default: throw UnexpectedToken(token); } if (!readBinOp) { return(ret); } // binary operator PatternToken?peek = PeekToken(); while (peek != null) { if (peek.Value.Type != TokenType.Identifier) { break; } if (!IsOperator(peek.Value)) { break; } PatternToken binOpToken = ReadToken(); PatternOperator binOp = ops[binOpToken.Value](); if (binOp.IsUnary) { throw UnexpectedToken(binOpToken); } binOp.OperandA = ret; binOp.OperandB = ParseExpression(); ret = binOp; peek = PeekToken(); } return(ret); }
public void VisitLiteralExpression(LiteralExpression literal) { //no op }
public override void Visit(LiteralExpression node) { base.Visit(node); _result = Expression.Constant(node.Value, typeof(object)); }
/// <summary> /// Initializes a new instance of the <see cref="LayoutKeyValue"/> class. /// </summary> /// <param name="name">The name.</param> /// <param name="value">The value.</param> public LayoutKeyValue(Identifier name, object value) { Name = name; Value = new LiteralExpression(value); }
public virtual void VisitLiteralExpression(LiteralExpression literalExpression) { VisitChildren (literalExpression); }
private static LiteralExpression Clone(LiteralExpression expression) { return(expression); }
/// <summary> /// Initializes a new instance of the MemberAccessExpression class. /// </summary> /// <param name="proxy">Proxy object for the expression.</param> /// <param name="leftHandSide">The left side of the operation.</param> /// <param name="rightHandSide">The member being accessed.</param> internal MemberAccessExpression(CodeUnitProxy proxy, Expression leftHandSide, LiteralExpression rightHandSide) : base(proxy, ExpressionType.MemberAccess, leftHandSide, rightHandSide) { Param.Ignore(proxy, leftHandSide, rightHandSide); }
private static Expression ParseExpression(Match match) { string expressionText = match.Value.Trim(); Expression expression; lock (_expressions) { if (_expressions.TryGetValue(expressionText, out expression)) { return(expression); } // temporarily add a dummy expression to prevent other threads from parsing the same expression again Log.Debug("Cacheing expression: {0}", expressionText); _expressions.Add(expressionText, new LiteralExpression(expressionText)); } if (match.Groups["string"].Success) { expression = new LiteralExpression(match.Groups["string"].Value); } else if (match.Groups["int"].Success) { expression = new LiteralExpression(int.Parse(match.Groups["int"].Value)); } else if (match.Groups["float"].Success) { expression = new LiteralExpression(float.Parse(match.Groups["float"].Value, CultureInfo.InvariantCulture)); } else if (match.Groups["property"].Success) { expression = new PropertyExpression(match.Groups["property"].Value); } else if (match.Groups["function"].Success) { string functionName = match.Groups["function"].Value; FunctionDefinition function; if (!_registeredFunctions.TryGetValue(functionName, out function)) { Log.Error("Undefined function '{0}' in expression '{1}'", functionName, match.Value); expression = new LiteralExpression(match.Value); } else { int paramCount = match.Groups["param"].Captures.Count; Expression[] parameters = new Expression[paramCount]; for (int i = 0; i < paramCount; i++) { string paramText = match.Groups["param"].Captures[i].Value; Match paramMatch = _expressionRegEx.Match(paramText); parameters[i] = ParseExpression(paramMatch); } expression = new FunctionExpression(_registeredFunctions[functionName], parameters); } } lock (_expressions) { // now replace with the real expression _expressions[expressionText] = expression; } return(expression); }
private void FixBooleanLiteral(LiteralExpression literal) { literal.Value = Convert.ToBoolean(literal.Value); }
/// <summary> /// Initializes a new instance of the PointerAccessExpression class. /// </summary> /// <param name="proxy">Proxy object for the expression.</param> /// <param name="leftHandSide">The left side of the operation.</param> /// <param name="rightHandSide">The member being accessed.</param> internal PointerAccessExpression(CodeUnitProxy proxy, Expression leftHandSide, LiteralExpression rightHandSide) : base(proxy, ExpressionType.PointerAccess, leftHandSide, rightHandSide) { Param.Ignore(proxy, leftHandSide, rightHandSide); }
private void FixCharLiteral(LiteralExpression literal) { literal.Value = Convert.ToChar(literal.Value); }
private static Expression ParseExpression(Match match) { string expressionText = match.Value.Trim(); Expression expression; lock (_expressions) { if (_expressions.TryGetValue(expressionText, out expression)) { return expression; } // temporarily add a dummy expression to prevent other threads from parsing the same expression again Log.Debug("Cacheing expression: {0}", expressionText); _expressions.Add(expressionText, new LiteralExpression(expressionText)); } if (match.Groups["string"].Success) { expression = new LiteralExpression(match.Groups["string"].Value); } else if (match.Groups["int"].Success) { expression = new LiteralExpression(int.Parse(match.Groups["int"].Value)); } else if (match.Groups["float"].Success) { expression = new LiteralExpression(float.Parse(match.Groups["float"].Value, CultureInfo.InvariantCulture)); } else if (match.Groups["property"].Success) { expression = new PropertyExpression(match.Groups["property"].Value); } else if (match.Groups["function"].Success) { string functionName = match.Groups["function"].Value; FunctionDefinition function; if (!_registeredFunctions.TryGetValue(functionName, out function)) { Log.Error("Undefined function '{0}' in expression '{1}'", functionName, match.Value); expression = new LiteralExpression(match.Value); } else { int paramCount = match.Groups["param"].Captures.Count; Expression[] parameters = new Expression[paramCount]; for (int i = 0; i < paramCount; i++) { string paramText = match.Groups["param"].Captures[i].Value; Match paramMatch = _expressionRegEx.Match(paramText); parameters[i] = ParseExpression(paramMatch); } expression = new FunctionExpression(_registeredFunctions[functionName], parameters); } } lock (_expressions) { // now replace with the real expression _expressions[expressionText] = expression; } return expression; }
public Unit VisitLiteralExpression(LiteralExpression expression) { return(Unit.Value); }
protected override void VisitLiteral(LiteralExpression literal) { base.VisitLiteral(literal); AppendCodeBlock(String.Format(@"{0}.push({1});", CodeBufferVariableName, _serializer.Serialize(literal.Literal))); }
public virtual T visitLiteral(LiteralExpression literal, A arg) => visit(literal, arg);
public static bool TryCoerceInt(LiteralExpression expression, out int result) { switch (expression.LiteralType) { case LiteralType.Int: result = (int)expression.Value; return true; case LiteralType.Long: result = (int)(long)expression.Value; return true; default: result = 0; return false; } }
/// <summary> /// Creates a call to the REGEX function /// </summary> public static BooleanExpression Regex(this ExpressionBuilder eb, LiteralExpression text, VariableExpression pattern, string flags) { return(Regex(text.Expression, pattern.Expression, flags.ToConstantTerm())); }
/// <summary> /// Creates a call to the LANGMATCHES function /// </summary> public static BooleanExpression LangMatches(this ExpressionBuilder eb, LiteralExpression languageTag, string languageRange) { return(LangMatches(languageTag.Expression, languageRange.ToConstantTerm())); }
public string GetExpression(LiteralExpression expression, ref List<OleDbParameter> parameters) { string name = "p" + parameters.Count.ToString(); OleDbParameter parameter = new OleDbParameter(name, expression.Value); parameters.Add(parameter); return " ? "; }
/// <summary> /// Creates a call to the LANGMATCHES function /// </summary> public static BooleanExpression LangMatches(this ExpressionBuilder eb, LiteralExpression languageTag, VariableExpression languageRange) { return(LangMatches(languageTag.Expression, languageRange.Expression)); }
/// <summary> /// Initializes a new instance of the CatchStatement class. /// </summary> /// <param name="tokens"> /// The list of tokens that form the statement. /// </param> /// <param name="tryStatement"> /// The try-statement that this catch-statement is attached to. /// </param> /// <param name="classExpression"> /// The inner expression. /// </param> /// <param name="embeddedStatement"> /// The statement embedded within the catch-statement. /// </param> internal CatchStatement(CsTokenList tokens, TryStatement tryStatement, Expression classExpression, BlockStatement embeddedStatement) : base(StatementType.Catch, tokens) { Param.AssertNotNull(tokens, "tokens"); Param.AssertNotNull(tryStatement, "tryStatement"); Param.Ignore(classExpression); Param.AssertNotNull(embeddedStatement, "embeddedStatement"); this.tryStatement = tryStatement; this.catchExpression = classExpression; this.embeddedStatement = embeddedStatement; if (classExpression != null) { this.AddExpression(classExpression); if (classExpression != null) { if (classExpression.ExpressionType == ExpressionType.Literal) { this.classType = ((LiteralExpression)classExpression).Token as TypeToken; } else if (classExpression.ExpressionType == ExpressionType.VariableDeclaration) { VariableDeclarationExpression variableDeclaration = (VariableDeclarationExpression)classExpression; this.classType = variableDeclaration.Type; foreach (VariableDeclaratorExpression declarator in variableDeclaration.Declarators) { this.identifier = declarator.Identifier; break; } } } } this.AddStatement(embeddedStatement); }
/// <summary> /// Creates a call to the REGEX function /// </summary> public static BooleanExpression Regex(this ExpressionBuilder eb, LiteralExpression text, string pattern) { return(Regex(text.Expression, pattern.ToSimpleLiteral(), null)); }
/// <summary> /// Initializes a new instance of the QualifiedAliasExpression class. /// </summary> /// <param name="proxy">Proxy object for the expression.</param> /// <param name="leftHandSide">The left side of the operation.</param> /// <param name="rightHandSide">The member being accessed.</param> internal QualifiedAliasExpression(CodeUnitProxy proxy, Expression leftHandSide, LiteralExpression rightHandSide) : base(proxy, ExpressionType.QualifiedAlias, leftHandSide, rightHandSide) { Param.Ignore(proxy, leftHandSide, rightHandSide); }
/// <summary> /// Creates a call to the REGEX function /// </summary> public static BooleanExpression Regex(this ExpressionBuilder eb, LiteralExpression text, VariableExpression pattern) { return(Regex(text.Expression, pattern.Expression, null)); }
public virtual ICodeNode VisitLiteralExpression(LiteralExpression node) { return(node); }
/// <summary> /// Creates a call to the REGEX function /// </summary> public static BooleanExpression Regex(this ExpressionBuilder eb, LiteralExpression text, string pattern, string flags) { return(Regex(text.Expression, pattern.ToSimpleLiteral(), flags.ToConstantTerm())); }
private static MethodDeclaration GenerateBuildUrlMethod(ClassDeclaration clientClass, Method method, TypeReference requestType) { var m = clientClass.AddMember(new MethodDeclaration(method.MethodGroup.Name + '_' + GetMethodName(method) + "_BuildUrl")); m.Modifiers = Modifiers.Private | Modifiers.Static; m.ReturnType = typeof(string); // Method body m.Statements = new StatementCollection(); var urlVariable = new VariableDeclarationStatement(typeof(string), "url"); m.Statements.Add(urlVariable); // 1. Create url from parameters var parameters = method.Parameters.Where(p => GetParameterLocation(method, p) == ParameterLocation.Url).ToList(); if (parameters.Any()) { var requestArgument = m.AddArgument("request", requestType); // [System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope", Justification = "<Pending>")] m.CustomAttributes.Add(new CustomAttribute(typeof(SuppressMessageAttribute)) { Arguments = { new CustomAttributeArgument(new LiteralExpression("Reliability")), new CustomAttributeArgument(new LiteralExpression("CA2000:Dispose objects before losing scope")), new CustomAttributeArgument("Justification", new LiteralExpression("The rule doesn't understand ref struct")), }, }); var segments = GetSegments(method.UrlTemplate); var urlBuilder = new VariableDeclarationStatement( WellKnownTypes.UrlBuilderTypeReference, "urlBuilder", new NewObjectExpression(WellKnownTypes.UrlBuilderTypeReference)); var urlUsingStatement = new UsingStatement() { Statement = urlBuilder, Body = new StatementCollection(), }; var usingStatements = urlUsingStatement.Body; m.Statements.Add(urlUsingStatement); foreach (var segment in segments) { if (segment[0] == ':') { var param = parameters.SingleOrDefault(p => p.Name == segment[1..]); if (param == null) { throw new InvalidOperationException($"Parameter '{segment}' is not mapped for method '{method.UrlTemplate}'"); } AddParameter(param, separator: null, encoded: true); parameters.Remove(param); } else if (segment[0] == '*') { var param = parameters.SingleOrDefault(p => p.Name == segment[1..]); if (param == null) { throw new InvalidOperationException($"Parameter '{segment}' is not mapped for method '{method.UrlTemplate}'"); } AddParameter(param, separator: null, encoded: false); parameters.Remove(param); } else if (segment.StartsWith("[.", StringComparison.Ordinal)) { var param = parameters.SingleOrDefault(p => p.Name == segment[2..^ 1]); if (param == null) { throw new InvalidOperationException($"Parameter '{segment}' is not mapped for method '{method.UrlTemplate}'"); } AddParameter(param, separator: null, encoded: false, prefix: "."); parameters.Remove(param); } else { usingStatements.Add(urlBuilder.CreateInvokeMethodExpression("Append", new LiteralExpression(segment))); } } if (parameters.Any()) { var separator = new VariableDeclarationStatement(typeof(char), "separator", new LiteralExpression('?')); usingStatements.Add(separator); foreach (var param in parameters) { AddParameter(param, separator, encoded: true); } } usingStatements.Add(new AssignStatement(urlVariable, urlBuilder.CreateInvokeMethodExpression("ToString"))); void AddParameter(MethodParameter param, VariableDeclarationStatement separator, bool encoded, string prefix = null) { var appendParameterMethodName = encoded ? "AppendParameter" : "AppendRawParameter"; void AddSeparator(StatementCollection statements) { if (separator != null) { statements.Add(urlBuilder.CreateInvokeMethodExpression("Append", separator)); statements.Add(new AssignStatement(separator, new LiteralExpression('&'))); statements.Add(urlBuilder.CreateInvokeMethodExpression("Append", new LiteralExpression(param.Name + '='))); } } void AppendPrefix(StatementCollection statements) { if (!string.IsNullOrEmpty(prefix)) { statements.Add(urlBuilder.CreateInvokeMethodExpression("Append", prefix)); } } if (param.Type.IsParameterEntity) { var propertyName = param.Type.ParameterEntity.FinalType == ModelRef.Object ? "ValueAsString" : "Value"; var hasValueCondition = new ConditionStatement { Condition = CreatePropertyReference().CreateMemberReferenceExpression(nameof(Nullable <int> .HasValue)), TrueStatements = new StatementCollection(), }; AddSeparator(hasValueCondition.TrueStatements); AppendPrefix(hasValueCondition.TrueStatements); hasValueCondition.TrueStatements.Add(urlBuilder .CreateInvokeMethodExpression( appendParameterMethodName, FormatValue(param.Type, CreatePropertyReference().CreateInvokeMethodExpression("GetValueOrDefault").CreateMemberReferenceExpression(propertyName)))); urlUsingStatement.Body.Add(hasValueCondition); } else { var isValueType = param.Type.IsValueType && !param.Type.IsCollection; var hasValueCondition = new ConditionStatement { Condition = isValueType ? CreatePropertyReference().CreateMemberReferenceExpression("HasValue") : new UnaryExpression(UnaryOperator.Not, new MethodInvokeExpression( new MemberReferenceExpression(new TypeReference(typeof(object)), "ReferenceEquals"), CreatePropertyReference(), LiteralExpression.Null())), TrueStatements = new StatementCollection(), }; AddSeparator(hasValueCondition.TrueStatements); AppendPrefix(hasValueCondition.TrueStatements); Expression value = isValueType ? CreatePropertyReference().CreateInvokeMethodExpression("GetValueOrDefault") : CreatePropertyReference(); var appendMethod = new MethodInvokeExpression( new MemberReferenceExpression(urlBuilder, appendParameterMethodName), FormatValue(param.Type, value)); hasValueCondition.TrueStatements.Add(appendMethod); urlUsingStatement.Body.Add(hasValueCondition); } MemberReferenceExpression CreatePropertyReference() { return(requestArgument.CreateMemberReferenceExpression(ToPropertyName(param.Name))); } } } else { m.Statements.Add(new AssignStatement(urlVariable, new LiteralExpression(method.UrlTemplate))); } m.Statements.Add(new ReturnStatement(urlVariable)); return(m); }