/// <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);
}
