/// <summary> /// Rewrites the expression with a field access expression. /// </summary> /// <param name="node">IdentifierNameSyntax</param> /// <returns>SyntaxNode</returns> private SyntaxNode RewriteExpression(IdentifierNameSyntax node) { SyntaxNode rewritten = node; if (!base.IsInStateScope(rewritten) || !(base.IsMachineField(rewritten) || base.IsMachineMethod(rewritten))) { return(rewritten); } if (!(rewritten.Parent is MemberAccessExpressionSyntax) && !(rewritten.Parent is ObjectCreationExpressionSyntax) && !(rewritten.Parent is TypeOfExpressionSyntax)) { var text = "this." + node.ToString(); rewritten = SyntaxFactory.ParseExpression(text); rewritten = rewritten.WithTriviaFrom(node); } if ((rewritten.Parent is MemberAccessExpressionSyntax) && (rewritten.Parent as MemberAccessExpressionSyntax).Expression is IdentifierNameSyntax && ((rewritten.Parent as MemberAccessExpressionSyntax).Expression as IdentifierNameSyntax). IsEquivalentTo(node)) { var text = "this." + node.ToString(); rewritten = SyntaxFactory.ParseExpression(text); rewritten = rewritten.WithTriviaFrom(node); } return(rewritten); }
/// <summary> /// Find OptionAttribute from a property. /// </summary> /// <param name="context"></param> private void AnalyzeProperty(SyntaxNodeAnalysisContext context) { var propertyNode = (PropertyDeclarationSyntax)context.Node; foreach (var attributeSyntax in propertyNode.AttributeLists.SelectMany(x => x.Attributes)) { string? attributeName = attributeSyntax.Name switch { IdentifierNameSyntax identifierName => identifierName.ToString(), QualifiedNameSyntax qualifiedName => qualifiedName.ChildNodes().OfType<IdentifierNameSyntax>().LastOrDefault()?.ToString(), _ => null, }; if (attributeName != null && _attributeNames.Contains(attributeName)) { var (name, location) = AnalyzeOptionAttributeArguments(attributeSyntax); if (name != null && location != null) { var diagnostic = Diagnostic.Create(Rule, location, name); context.ReportDiagnostic(diagnostic); } break; } } }
public static async Task <Document> RefactorAsync( Document document, IdentifierNameSyntax identifierName, CancellationToken cancellationToken = default(CancellationToken)) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var localSymbol = semanticModel.GetSymbol(identifierName, cancellationToken) as ILocalSymbol; if (localSymbol?.Type?.IsErrorType() == false && localSymbol.GetSyntax(cancellationToken) is VariableDeclaratorSyntax variableDeclarator) { SyntaxToken identifier = variableDeclarator.Identifier; var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent; ExpressionSyntax value = localSymbol.Type.GetDefaultValueSyntax(variableDeclaration.Type.WithoutTrivia()); EqualsValueClauseSyntax newEqualsValue = EqualsValueClause(value) .WithLeadingTrivia(TriviaList(Space)) .WithTrailingTrivia(identifier.TrailingTrivia); VariableDeclaratorSyntax newNode = variableDeclarator .WithInitializer(newEqualsValue) .WithIdentifier(identifier.WithoutTrailingTrivia()); return(await document.ReplaceNodeAsync(variableDeclarator, newNode, cancellationToken).ConfigureAwait(false)); } Debug.Fail(identifierName.ToString()); return(document); }
private void AnalyzeProperty(SyntaxNodeAnalysisContext context) { var propertyNode = (PropertyDeclarationSyntax)context.Node; var optionTypes = context.Compilation is null ? Array.Empty <INamedTypeSymbol>() : new[] { context.Compilation.GetTypeByMetadataName("dotnetCampus.Cli.OptionAttribute"), context.Compilation.GetTypeByMetadataName("dotnetCampus.Cli.ValueAttribute"), }; foreach (var attributeSyntax in propertyNode.AttributeLists.SelectMany(x => x.Attributes)) { string?attributeName = attributeSyntax.Name switch { IdentifierNameSyntax identifierName => identifierName.ToString(), QualifiedNameSyntax qualifiedName => qualifiedName.ChildNodes().OfType <IdentifierNameSyntax>().LastOrDefault()?.ToString(), _ => null, }; if (attributeName != null) { var attributeType = context.SemanticModel.GetTypeInfo(attributeSyntax).Type; var isTheAttributeType = optionTypes.Any(x => SymbolEqualityComparer.Default.Equals(x, attributeType)); if (isTheAttributeType) { var isValidPropertyUsage = AnalyzeOptionPropertyType(propertyNode); var diagnostic = CreateDiagnosticForTypeSyntax( isValidPropertyUsage ? ValidRule : InvalidRule, propertyNode); context.ReportDiagnostic(diagnostic); break; } } } }
private static Func<SyntaxNode, Scope, SyntaxNode> LinkDapper(IdentifierNameSyntax identifier) { return (node, scope) => { var method = node .Ancestors() .OfType<MethodDeclarationSyntax>() .FirstOrDefault(); if (method == null) { Debug.Assert(false); //td: error return node; } if (method .ParameterList .Parameters .Any(parameter => parameter .Identifier .ToString() == "__scope")) { var document = scope.GetDocument<SyntaxToken, SyntaxNode, SemanticModel>(); document.change(method.Body, AddConnectionVariable(ConnectionFromContext .Get<StatementSyntax>(identifier.ToString()))); } //assume __connection is available return node; }; }
public override TempComputeResult VisitIdentifierName(IdentifierNameSyntax node) { var identifierName = node.ToString(); var tuple = GetOrCreateVariableReference(node, identifierName); if (node.Parent is InvocationExpressionSyntax) { HandleInvocationExpressionSyntax(tuple, node.Parent as InvocationExpressionSyntax); } else { var top = tuple.Top; VariableInfo localVariable; if (LocalVariables.TryGetValue(top.Name, out localVariable)) { top.Type = VariableTypes.Normal; top.Address = localVariable.Address; top.ValueType = localVariable.ValueObjType; } else { top.Type = VariableTypes.FieldReference; } } return(ResolveVariable(tuple.Bottom)); }
public override void VisitIdentifierName(IdentifierNameSyntax node) { if (_graph.UsedVariableNodes.Contains(node.Identifier)) { var variableName = node.ToString(); VisitVariable(variableName, node.Identifier); } }
static string getName(NameSyntax name) { return(name switch { IdentifierNameSyntax identifierNameSyntax => identifierNameSyntax.ToString(), QualifiedNameSyntax qualifiedNameSyntax => $"{getName(qualifiedNameSyntax.Left)}.{getName(qualifiedNameSyntax.Right)}", _ => string.Empty });
/// <summary> /// Rewrites the expression with a field access expression. /// </summary> /// <param name="node">IdentifierNameSyntax</param> /// <returns>SyntaxNode</returns> private SyntaxNode RewriteExpression(IdentifierNameSyntax node) { SyntaxNode rewritten = node; if (!base.IsInStateScope(rewritten) || !(base.IsMachineField(rewritten) || base.IsMachineMethod(rewritten))) { return(rewritten); } if (rewritten.Parent is ArgumentSyntax && rewritten.Parent.Parent is ArgumentListSyntax && rewritten.Parent.Parent.Parent is InvocationExpressionSyntax) { var invocation = rewritten.Parent.Parent.Parent as InvocationExpressionSyntax; if (invocation.Expression is IdentifierNameSyntax && (invocation.Expression as IdentifierNameSyntax).Identifier.ValueText.Equals("nameof") && invocation.ArgumentList.Arguments.Count == 1) { return(rewritten); } } if (!(rewritten.Parent is MemberAccessExpressionSyntax) && !(rewritten.Parent is ObjectCreationExpressionSyntax) && !(rewritten.Parent is TypeOfExpressionSyntax)) { var text = "this." + node.ToString(); rewritten = SyntaxFactory.ParseExpression(text); rewritten = rewritten.WithTriviaFrom(node); } if ((rewritten.Parent is MemberAccessExpressionSyntax) && (rewritten.Parent as MemberAccessExpressionSyntax).Expression is IdentifierNameSyntax && ((rewritten.Parent as MemberAccessExpressionSyntax).Expression as IdentifierNameSyntax). IsEquivalentTo(node)) { var text = "this." + node.ToString(); rewritten = SyntaxFactory.ParseExpression(text); rewritten = rewritten.WithTriviaFrom(node); } return(rewritten); }
public static void Go(HaxeWriter writer, IdentifierNameSyntax identifier, bool byRef = false) { writer.Write(identifier.ToString()); if (!byRef) { var symbol = Program.GetModel(identifier).GetSymbolInfo(identifier).Symbol; if (Program.RefOutSymbols.ContainsKey(symbol)) { writer.Write(".Value"); } } }
private StatementSyntax LinkSignal(IdentifierNameSyntax name, InvocationExpressionSyntax success, InvocationExpressionSyntax failure) { var signalName = name.ToString(); var signal = _class.GetSignal(signalName); Debug.Assert(signal != null); return(Templates .SignalListener .Get <StatementSyntax>( Roslyn.Quoted(signalName), WrapInLambda(success))); }
public override Tristate VisitIdentifierName(IdentifierNameSyntax node) { Tristate state; if (_symbolStates.TryGetValue(node.ToString(), out state)) { return(state); } else { return(_undefinedSymbolValue); } }
private string GetIdentifierWithNamespace(IdentifierNameSyntax node) { var identifier = node.ToString(); var parent = node.Parent as MemberAccessExpressionSyntax; while (parent != null && parent.ToString().EndsWithOrdinalIgnoreCase(identifier)) { identifier = parent.ToString(); parent = parent.Parent as MemberAccessExpressionSyntax; } return(identifier); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { if (_ignore.Contains(node.ToString())) { return(node); } if (node.Parent != null) { return(node); } return(SyntaxFactory.AliasQualifiedName(SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.GlobalKeyword)), node)); }
public static void Go(HaxeWriter writer, IdentifierNameSyntax identifier, bool byRef = false) { writer.Write(identifier.ToString()); if (!byRef) { var symbol = Program.GetModel(identifier).GetSymbolInfo(identifier).Symbol; if (symbol == null) { throw new Exception("Symbol could not be resolved. Are you sure the C# is valid? " + Utility.Descriptor(identifier)); } if (Program.RefOutSymbols.ContainsKey(symbol)) { writer.Write(".Value"); } } }
public override void VisitIdentifierName(IdentifierNameSyntax node) { var refSymbol = RoslynUtils.GetReferenceSymbol(node, _semanticModel); if (refSymbol != null && RoslynUtils.IsVariableSymbol(refSymbol) && refSymbol.Locations[0].IsInSource) { var typeSymbol = RoslynUtils.GetVariableTypeSymbol(refSymbol); if (typeSymbol.ToString() == _targetType) { _inScopeSymbols.Add(_tokenToLocation(node.GetLocation(), node.ToString()), new ScopeData(SymbolToString(refSymbol), new HashSet <String>(_semanticModel.LookupSymbols(node.GetLocation().SourceSpan.End).Where(s => RoslynUtils.IsVariableSymbol(s)). Where(s => s.Locations[0].IsInSource). Where(s => RoslynUtils.GetVariableTypeSymbol(s).ToString() == _targetType).Select(s => SymbolToString(s))))); } } base.VisitIdentifierName(node); }
private static Document InsertAddHandlerCall(Document document, ReferenceLocation location, IdentifierNameSyntax busNodeName, IdentifierNameSyntax errorEventHandlerName) { var root = document.GetSyntaxRootAsync().Result; var generator = SyntaxGenerator.GetGenerator(document); var statement = root.FindNode(location.Location.SourceSpan).GetAncestorStatement(); root = root.InsertNodesAfter(statement, new[] { ExpressionStatement( (ExpressionSyntax)generator.InvocationExpression( generator.MemberAccessExpression( IdentifierName(busNodeName.ToString()), nameof(IBus.AddHandler)), generator.ObjectCreationExpression( IdentifierName(errorEventHandlerName.ToString()))) ) }); return(document.WithSyntaxRoot(root)); }
protected void HandleNameOfExpression(InvocationExpressionSyntax node) { SyntaxNode currentNode = node.ArgumentList.Arguments[0].Expression; string currentName = ""; while (currentNode != null) { switch (currentNode.Kind()) { case SyntaxKind.SimpleMemberAccessExpression: MemberAccessExpressionSyntax memberNode = (MemberAccessExpressionSyntax)currentNode; currentName = memberNode.Name.ToString(); currentNode = memberNode.Name; break; case SyntaxKind.IdentifierName: IdentifierNameSyntax identifierName = (IdentifierNameSyntax)currentNode; currentName = identifierName.ToString(); currentNode = null; break; default: currentNode = null; break; } if (currentNode != null) { UpdateSyntaxNode(currentNode); } } if (currentName == "") { throw new System.ArgumentException("Expression does not have a name"); } if (visitorContext.topCaptureScope != null) { visitorContext.topCaptureScope.SetToLocalSymbol(visitorContext.topTable.CreateConstSymbol(typeof(string), currentName)); } }
/// <summary> /// 識別子名構文のTypeScript変換 /// </summary> /// <param name="condition">ExpressionSyntaxインスタンス</param> /// <param name="localDeclarationStatements">ローカル変数リスト</param> /// <returns>TypeScriptに変換した文字列</returns> private string ConvertExpression(IdentifierNameSyntax condition, List <string> localDeclarationStatements) { var identifierName = condition.ToString(); // インスタンスメンバの場合はthisを付けて返す if (!IsLocalDeclarationStatement(condition, localDeclarationStatements)) { return("this." + identifierName); } // クラスメンバの場合はクラス名を付ける var className = ClassObject.GetInstance().ProcessClassName; if (ClassObject.GetInstance().StaticMembers.Where(item => item.Key == className).Any(item => item.Value.Contains(identifierName))) { identifierName = $"{ className}.{identifierName}"; } return(identifierName); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { if (MainDataType == DataType.Float) { return(base.VisitIdentifierName(node)); } if (node.ToString() != mainDataTypeName) { return(base.VisitIdentifierName(node)); } if (TargetDataType == DataType.Double) { var newNode = SyntaxFactory.PredefinedType(SyntaxFactory.ParseToken("double")); return(newNode.WithTriviaFrom(node)); } else { var newNode = node.WithIdentifier(SyntaxFactory.Identifier(targetDataTypeName)); return(newNode.WithTriviaFrom(node)); } }
public static IList <QvtKeyParserResult> Parse(string s) { IList <QvtKeyParserResult> result = new List <QvtKeyParserResult>(); List <StatementSyntax> parsed = CSharpParser.ParseInstructions(s); foreach (ExpressionStatementSyntax statementSyntax in parsed.OfType <ExpressionStatementSyntax>()) { QvtKeyParserResult qvtKeyParserResult = new QvtKeyParserResult(); result.Add(qvtKeyParserResult); InvocationExpressionSyntax invocationExpressionSyntax = statementSyntax.Expression as InvocationExpressionSyntax; if (invocationExpressionSyntax != null) { IdentifierNameSyntax caller = invocationExpressionSyntax.Expression as IdentifierNameSyntax; if (caller != null) { qvtKeyParserResult.ClassName = caller.ToString(); } foreach (ArgumentSyntax argument in invocationExpressionSyntax.ArgumentList.Arguments) { IList <string> path = new List <string>(); ExpressionSyntax argumentContent = argument.Expression; if (argumentContent is IdentifierNameSyntax) { path.Add(argumentContent.ToString()); } else if (argumentContent is MemberAccessExpressionSyntax) { IList <string> properties = ManageMemberAccess((MemberAccessExpressionSyntax)argumentContent); path.AddRange(properties); } qvtKeyParserResult.NavigatedProperties.Add(path); } } } return(result); }
public static bool TryGetAction( BlockSyntax block, List <StatementSyntax> selectedStatements, out Func <SyntaxNode, SyntaxNode> action) { action = null; var selectionStartIndex = block.Statements.IndexOf(selectedStatements[0]); var currentDeclarationInfo = GetDeclarationInfo(selectedStatements[0], false); if (currentDeclarationInfo == null) { return(false); } // // Check all selected statements but last for pattern: // var var0 = <smth> // var var1 = var0.<some method> or var0?.<some method> // for (int i = 1; i < selectedStatements.Count - 1; ++i) { var nextDeclarationInfo = GetDeclarationInfo(selectedStatements[i], true); if (nextDeclarationInfo == null) { return(false); } var currentIdentifier = currentDeclarationInfo.Item1; var nextInfocationTarget = nextDeclarationInfo.Item2; if (currentIdentifier.ToString() != nextInfocationTarget.ToString()) { return(false); } if (IsReferencedIn(currentIdentifier.ToString(), block, selectionStartIndex + i + 1)) { return(false); } currentDeclarationInfo = nextDeclarationInfo; } // // The last statement could differ from LocalDeclarationStatement, so we just search for // - invocation on MemberAccessExpressionSyntax where Expression is last variable in chain // or // - ConditionalAccessExpressionSyntax with invocation where Expression is last variable in chain // var lastVariableName = currentDeclarationInfo.Item1.ToString(); var lastExpression = selectedStatements.Last().DescendantNodes().FirstOrDefault(s => { IdentifierNameSyntax identifier = null; if (s.IsKind(SyntaxKind.InvocationExpression)) { var invocation = (InvocationExpressionSyntax)s; if (!invocation.Expression.IsKind(SyntaxKind.SimpleMemberAccessExpression)) { return(false); } var memberAccess = (MemberAccessExpressionSyntax)invocation.Expression; if (!memberAccess.Expression.IsKind(SyntaxKind.IdentifierName)) { return(false); } identifier = (IdentifierNameSyntax)memberAccess.Expression; } else if (s.IsKind(SyntaxKind.ConditionalAccessExpression)) { var conditionalAccess = (ConditionalAccessExpressionSyntax)s; if (!conditionalAccess.WhenNotNull.IsKind(SyntaxKind.InvocationExpression)) { return(false); } if (!conditionalAccess.Expression.IsKind(SyntaxKind.IdentifierName)) { return(false); } identifier = (IdentifierNameSyntax)conditionalAccess.Expression; } else { return(false); } return(identifier.ToString() == lastVariableName); }) as ExpressionSyntax; if (lastExpression == null) { return(false); } int lastVariableReferencesCount = GetReferencesCount( lastVariableName, block, selectionStartIndex + selectedStatements.Count - 1); if (lastVariableReferencesCount > 1) { return(false); } var declarations = selectedStatements.Take(selectedStatements.Count - 1).ToList(); action = syntaxRoot => { return(ChainMethodCalls(syntaxRoot, lastExpression, declarations)); }; return(true); }
private void CompileNode(SyntaxNode node) { //if (node is GlobalStatementSyntax) //{ //GlobalStatementSyntax globalStatement = node as GlobalStatementSyntax; if (node is GlobalStatementSyntax) { node = ((GlobalStatementSyntax)node).Statement; } if (node is BlockSyntax) { BlockSyntax block = node as BlockSyntax; foreach (StatementSyntax statement in block.Statements) { CompileNode(statement); } } else if (node is ParenthesizedExpressionSyntax) { ParenthesizedExpressionSyntax parenthesizedExpression = node as ParenthesizedExpressionSyntax; CompileNode(parenthesizedExpression.Expression); if (node.Parent.Kind() == SyntaxKind.LogicalNotExpression || // TODO - check this still works node.Parent.Kind() == SyntaxKind.BitwiseNotExpression || node.Parent.Kind() == SyntaxKind.UnaryMinusExpression) { OP_NEG opNeg = new OP_NEG(); OpCodes.Add(opNeg); } } else if (node is ExpressionStatementSyntax) { ExpressionStatementSyntax expressionStatement = node as ExpressionStatementSyntax; CompileNode(expressionStatement.Expression); } else if (node is LiteralExpressionSyntax) { LiteralExpressionSyntax literalExpression = node as LiteralExpressionSyntax; OP_PUSH opPush = new OP_PUSH(); opPush.DataIndex = Literals[literalExpression].Address; OpCodes.Add(opPush); if (Literals[literalExpression].IsNegative) { //push a negative on top OP_NEG opNeg = new OP_NEG(); OpCodes.Add(opNeg); } } //else if (node is null) //{ //} else if (node is PrefixUnaryExpressionSyntax) { PrefixUnaryExpressionSyntax prefixUnaryExpression = node as PrefixUnaryExpressionSyntax; //a not? negatives are handled later if (prefixUnaryExpression.Kind() == SyntaxKind.LogicalNotExpression) { CompileNode(prefixUnaryExpression.Operand); //add a not OP_NOT opNot = new OP_NOT(); OpCodes.Add(opNot); } else { CompileNode(prefixUnaryExpression.Operand); } } else if (node is IdentifierNameSyntax) { IdentifierNameSyntax identifierName = node as IdentifierNameSyntax; OP_PUSH opPush = new OP_PUSH(); if (identifierName != null) { opPush.DataIndex = Variables[identifierName.ToString()].Address; // TODO check this .PlainName } OpCodes.Add(opPush); if (node.Parent.Kind() == SyntaxKind.UnaryMinusExpression) // TODO - check this { //add a not OP_NEG opNeg = new OP_NEG(); OpCodes.Add(opNeg); } } else if (node is ArgumentSyntax) { ArgumentSyntax argument = node as ArgumentSyntax; if (argument.Expression is PrefixUnaryExpressionSyntax) { //for a negative parse the operand PrefixUnaryExpressionSyntax prefixUnaryExpression = argument.Expression as PrefixUnaryExpressionSyntax; CompileNode(prefixUnaryExpression.Operand); } //if (argument.Expression is LiteralExpressionSyntax // || argument.Expression is IdentifierNameSyntax) else { CompileNode(argument.Expression); } } //a function invocation else if (node is InvocationExpressionSyntax) { InvocationExpressionSyntax invocationExpressionSyntax = node as InvocationExpressionSyntax; //first we have an identifier expression IdentifierNameSyntax identifierNameSyntax = invocationExpressionSyntax.Expression as IdentifierNameSyntax; //then arguments foreach (ArgumentSyntax argumentSyntax in invocationExpressionSyntax.ArgumentList.Arguments) //TODO .Reverse()? { //Console.WriteLine(" [Literal]"); //Console.WriteLine(" " + (LiteralExpressionSyntax)(argumentSyntax.Expression)); CompileNode(argumentSyntax); } if (identifierNameSyntax.ToString() == "Print") { OP_PRINT opPrint = new OP_PRINT(); OpCodes.Add(opPrint); } else { //push the function code OP_PUSH opPush = new OP_PUSH(); if (!FunctionTable.Functions.ContainsKey(identifierNameSyntax.ToString())) { if (!this.AddFunctions && !this.justPatchFunctions) { hasMissingFunctions = true; //if (!this.DirectoryBased) if (true) { Console.WriteLine(string.Format("Missing function {0}", identifierNameSyntax.ToString())); } opPush.DataIndex = 0x0FF0; } else { Console.WriteLine(string.Format("Fetching function {0}", identifierNameSyntax.ToString())); short functionPointer = FunctionTable.FindFunction(this.ScriptFilename.Replace(".hfs", ".bin"), identifierNameSyntax.ToString(), opPush.Address + 1); opPush.DataIndex = functionPointer; } } else { opPush.DataIndex = FunctionTable.Functions[identifierNameSyntax.ToString()]; } OpCodes.Add(opPush); //add function call OP_FUNCTION opFunction = new OP_FUNCTION(); OpCodes.Add(opFunction); //do a discard if (node.Parent is BinaryExpressionSyntax || node.Parent is AssignmentExpressionSyntax) { } else { OP_DISCARD opDiscard = new OP_DISCARD(); OpCodes.Add(opDiscard); } } } else if (node is AssignmentExpressionSyntax) { AssignmentExpressionSyntax assignmentExpression = node as AssignmentExpressionSyntax; CompileNode(assignmentExpression.Right); IdentifierNameSyntax identifierName = assignmentExpression.Left as IdentifierNameSyntax; //gettop the left OP_GETTOP opGettop = new OP_GETTOP(); opGettop.DataIndex = Variables[identifierName.ToString()].Address; OpCodes.Add(opGettop); //for an if we need to keep the value //or for a double assign if (assignmentExpression.Parent.Kind() != SyntaxKind.IfStatement && assignmentExpression.Parent.Kind() != SyntaxKind.SimpleAssignmentExpression) { //do a discard OP_DISCARD opDiscard = new OP_DISCARD(); OpCodes.Add(opDiscard); } } else if (node is BinaryExpressionSyntax) { BinaryExpressionSyntax binaryExpression = node as BinaryExpressionSyntax; if (binaryExpression.OperatorToken.Kind() == SyntaxKind.EqualsToken) { CompileNode(binaryExpression.Right); IdentifierNameSyntax identifierName = binaryExpression.Left as IdentifierNameSyntax; //gettop the left OP_GETTOP opGettop = new OP_GETTOP(); opGettop.DataIndex = Variables[identifierName.ToString()].Address; OpCodes.Add(opGettop); //for an if we need to keep the value if (binaryExpression.Parent.Kind() != SyntaxKind.IfStatement) { //do a discard OP_DISCARD opDiscard = new OP_DISCARD(); OpCodes.Add(opDiscard); } } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.EqualsEqualsToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_EQUAL opEqual = new OP_EQUAL(); OpCodes.Add(opEqual); if (node.Parent.Kind() == SyntaxKind.ExpressionStatement) { //just discard the result OP_DISCARD opDiscard = new OP_DISCARD(); OpCodes.Add(opDiscard); } } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.ExclamationEqualsToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_NOT_EQUAL opNotEqual = new OP_NOT_EQUAL(); OpCodes.Add(opNotEqual); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.MinusToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_MINUS opEqual = new OP_MINUS(); OpCodes.Add(opEqual); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.PlusToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_CONCAT opEqual = new OP_CONCAT(); OpCodes.Add(opEqual); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.GreaterThanToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_MORE_THAN opEqual = new OP_MORE_THAN(); OpCodes.Add(opEqual); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.LessThanToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_LESS_THAN opEqual = new OP_LESS_THAN(); OpCodes.Add(opEqual); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.LessThanEqualsToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_LESS_THAN_OR_EQUAL opLessOrEqual = new OP_LESS_THAN_OR_EQUAL(); OpCodes.Add(opLessOrEqual); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.GreaterThanEqualsToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_MORE_THAN_OR_EQUAL opGreatOrEqual = new OP_MORE_THAN_OR_EQUAL(); OpCodes.Add(opGreatOrEqual); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.BarBarToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_OR opOr = new OP_OR(); OpCodes.Add(opOr); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.AmpersandAmpersandToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_AND opAnd = new OP_AND(); OpCodes.Add(opAnd); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.AsteriskToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_MULTIPLY opMultiply = new OP_MULTIPLY(); OpCodes.Add(opMultiply); } else if (binaryExpression.OperatorToken.Kind() == SyntaxKind.SlashToken) { CompileNode(binaryExpression.Left); CompileNode(binaryExpression.Right); OP_DIVIDE opDivide = new OP_DIVIDE(); OpCodes.Add(opDivide); } } else if (node is WhileStatementSyntax) { WhileStatementSyntax whileStatement = node as WhileStatementSyntax; short whileAddress = OpCode.NextAddress; CompileNode(whileStatement.Condition); //look at the condition here OP_JMPF opJmpF = new OP_JMPF(); OpCodes.Add(opJmpF); CompileNode(whileStatement.Statement); //jmp back to the condition OP_JMP opJmp = new OP_JMP(); opJmp.DataIndex = whileAddress; OpCodes.Add(opJmp); //jump over the jmp back opJmpF.DataIndex = (short)(opJmp.Address + 3); } else if (node is IfStatementSyntax) { IfStatementSyntax ifStatement = node as IfStatementSyntax; //look at the condition here CompileNode(ifStatement.Condition); short ifAddress = OpCode.NextAddress; //do a jump to end if condition is false OP_JMPF opJmpF = new OP_JMPF(); OpCodes.Add(opJmpF); CompileNode(ifStatement.Statement); //has an else option? if (ifStatement.Else != null) //TODO - check this works { OP_JMP opJmp = new OP_JMP(); OpCodes.Add(opJmp); //save this as the else jump so we can hook it up later this.ElseJmps.Push(opJmp); } //add in the jump target JUMPTARGET jumpTarget = new JUMPTARGET(); jumpTarget.DataIndex = ifAddress; OpCodes.Add(jumpTarget); //jump is to here opJmpF.DataIndex = jumpTarget.Address; CompileNode(ifStatement.Else); } else if (node is ElseClauseSyntax) { ElseClauseSyntax elseClause = node as ElseClauseSyntax; CompileNode(elseClause.Statement); //pop off last one OP_JMP opJmp = this.ElseJmps.Pop(); //add in the jump target JUMPTARGET jumpTarget = new JUMPTARGET(); jumpTarget.DataIndex = opJmp.Address; OpCodes.Add(jumpTarget); //jump is to here opJmp.DataIndex = jumpTarget.Address; } //} //else if (node is BlockSyntax) //{ // BlockSyntax block = node as BlockSyntax; // foreach (StatementSyntax statement in block.Statements) // { // CompileNode(statement); // } //} }
private EssentialOCL.IOclExpression ConstructOCLExpression(QVTRelations.IRelation relation, ExpressionSyntax parsedExpression, QVTBase.IPattern pattern, EMOF.IType type = null) { // Case single identifier => OCL VariableExp if (parsedExpression is IdentifierNameSyntax) { EssentialOCL.IVariable variable = ConstructVariable(relation, parsedExpression.ToString(), type); pattern?.BindsTo.Add(variable); return(new EssentialOCL.VariableExp() { ReferredVariable = variable }); } // Case method call => QVT RelationCallExp (if the relation exists) of function call (if the function exists) if (parsedExpression is InvocationExpressionSyntax) { InvocationExpressionSyntax invocationExpressionSyntax = (InvocationExpressionSyntax)parsedExpression; // We are only interested in direct calls if (invocationExpressionSyntax.Expression is IdentifierNameSyntax) { IdentifierNameSyntax methodIdentifier = (IdentifierNameSyntax)invocationExpressionSyntax.Expression; ArgumentListSyntax argumentList = invocationExpressionSyntax.ArgumentList; QVTRelations.IRelation calledRelation = FindRelation((QVTRelations.IRelationalTransformation)(relation.Transformation), methodIdentifier.ToString()); QVTBase.IFunction calledFunction = FindFunction((QVTRelations.IRelationalTransformation)(relation.Transformation), methodIdentifier.ToString()); if (calledRelation != null) { QVTRelations.RelationCallExp call = new QVTRelations.RelationCallExp { ReferredRelation = calledRelation }; if (argumentList.Arguments.Count != calledRelation.Domain.Count) { throw new InvalidQVTRelationsModelException("Relation " + relation.Name + ": wrong number of arguments in relation call " + calledRelation.Name); } foreach (ArgumentSyntax argumentSyntax in argumentList.Arguments) { QVTRelations.IRelationDomain correspondingDomain = (QVTRelations.IRelationDomain)calledRelation.Domain[argumentList.Arguments.IndexOf(argumentSyntax)]; ExpressionSyntax argumentExpression = argumentSyntax.Expression; EssentialOCL.IOclExpression argumentOCLExpression = ConstructOCLExpression(relation, argumentExpression, pattern, correspondingDomain.RootVariable.Type); call.Argument.Add(argumentOCLExpression); } return(call); } else if (calledFunction != null) { string methodname = methodIdentifier.ToString(); EssentialOCL.IOperationCallExp call = new EssentialOCL.OperationCallExp() { Type = calledFunction.Type, ReferredOperation = calledFunction, Name = calledFunction.Name, }; foreach (ArgumentSyntax argumentSyntax in argumentList.Arguments) { ExpressionSyntax argumentExpression = argumentSyntax.Expression; EssentialOCL.IOclExpression argumentOCLExpression = ConstructOCLExpression(relation, argumentExpression, pattern, calledFunction.Type); call.Argument.Add(argumentOCLExpression); } return(call); } } } // Case assignment => Custom Assignment //TODO replace by OCL '=='? Meaning having to provide basic parts of OCL standard lib if (parsedExpression is AssignmentExpressionSyntax) { AssignmentExpressionSyntax assignmentExpressionSyntax = (AssignmentExpressionSyntax)parsedExpression; IdentifierNameSyntax leftIdentifier = (IdentifierNameSyntax)assignmentExpressionSyntax.Left; ExpressionSyntax right = assignmentExpressionSyntax.Right; EssentialOCL.IVariable variable = ConstructVariable(relation, leftIdentifier.ToString()); pattern?.BindsTo.Add(variable); return(new EssentialOCL.Assignment() { AssignedVariable = variable, Value = ConstructOCLExpression(relation, right, pattern) }); } // Any other case => Custom CSharpOpaqueExpression // TODO replace by QVT "Function" with a black box implementation? EssentialOCL.CSharpOpaqueExpression cSharpOpaqueExpression = new EssentialOCL.CSharpOpaqueExpression() { Code = parsedExpression.ToString() }; SetBindings(relation, pattern, cSharpOpaqueExpression, parsedExpression); return(cSharpOpaqueExpression); }
public override void VisitIdentifierName(IdentifierNameSyntax node) { VisitSymbol(node.ToString()); }
/// <summary> /// 表达式解析 /// </summary> /// <param name="expressionSyntax"></param> /// <returns></returns> private string AnalyzerExpression(ExpressionSyntax expressionSyntax) { if (expressionSyntax is LiteralExpressionSyntax) { var str = expressionSyntax.ToString(); if (str == FALSE) { return(str); } return(expressionSyntax.ToString().Replace("f", "")); //屏蔽掉因为浮点数的字符串 } if (expressionSyntax is BinaryExpressionSyntax) { return(AnalyzerBinaryExpression(expressionSyntax as BinaryExpressionSyntax)); } if (expressionSyntax is AssignmentExpressionSyntax) { return(AnalyzerAssignmentExpression(expressionSyntax as AssignmentExpressionSyntax)); } if (expressionSyntax is MemberAccessExpressionSyntax) { var exp = GetMemberAccessExpression((MemberAccessExpressionSyntax)expressionSyntax); if (string.IsNullOrEmpty(exp)) { return(expressionSyntax.ToString()); } return(exp); } if (expressionSyntax is IdentifierNameSyntax) { bool isAddPointer = GetMethodPointer(expressionSyntax.ToString()); if (isAddPointer) { return($"{TH}." + expressionSyntax); } return(expressionSyntax.ToString()); } if (expressionSyntax is ElementAccessExpressionSyntax) { return(GetElementAccessExpression(expressionSyntax as ElementAccessExpressionSyntax)); } if (expressionSyntax is ArrayCreationExpressionSyntax) { var ex = (ArrayCreationExpressionSyntax)expressionSyntax; return(CharpTypeToGolangType(ex.Type) + ex.Initializer); } if (expressionSyntax is PostfixUnaryExpressionSyntax) { return(expressionSyntax.ToString()); } if (expressionSyntax is InvocationExpressionSyntax) { InvocationExpressionSyntax syntaxNode = (InvocationExpressionSyntax)expressionSyntax; if (syntaxNode.Expression is IdentifierNameSyntax) { return(AnalyzerExpression(syntaxNode.Expression) + syntaxNode.ArgumentList); } if (syntaxNode.Expression is MemberAccessExpressionSyntax) { var expStr = GetMemberAccessExpression(syntaxNode.Expression as MemberAccessExpressionSyntax); if (string.IsNullOrEmpty(expStr)) { IdentifierNameSyntax identifier = (IdentifierNameSyntax)((MemberAccessExpressionSyntax)syntaxNode.Expression).Expression; if (_classNameList.IndexOf(identifier.ToString()) != -1) { return(syntaxNode.ToString().Replace($"{identifier.ToString()}.", "")); } bool isAddPointer = GetMethodPointer(identifier.ToString()); if (isAddPointer) { return($"{TH}." + syntaxNode); } return(syntaxNode.ToString()); } return(expStr); } return(syntaxNode.ToString()); } if (expressionSyntax is ObjectCreationExpressionSyntax) { ObjectCreationExpressionSyntax syntaxNode = (ObjectCreationExpressionSyntax)expressionSyntax; if (syntaxNode.Type is GenericNameSyntax) { return(CharpTypeToGolangType(syntaxNode.Type) + syntaxNode.Initializer); } else { return($"{syntaxNode.NewKeyword.ToString()}({syntaxNode.Type.ToString()})"); } } return(String.Empty); }