private LuaExpressionSyntax BuildGroupClause(LuaExpressionSyntax collection, GroupClauseSyntax node, IQueryRangeVariable rangeVariable)
{
var keyType = semanticModel_.GetTypeInfo(node.ByExpression).Type;
var keyTypeName = GetTypeName(keyType);
var byExpression = (LuaExpressionSyntax)node.ByExpression.Accept(this);
var keySelector = new LuaFunctionExpressionSyntax();
keySelector.AddParameter(rangeVariable.Name);
keySelector.AddStatement(new LuaReturnStatementSyntax(byExpression));
var groupExpression = (LuaExpressionSyntax)node.GroupExpression.Accept(this);
if (node.GroupExpression.IsKind(SyntaxKind.IdentifierName))
{
var groupIdentifierName = groupExpression as LuaIdentifierNameSyntax;
if (groupIdentifierName != null && groupIdentifierName.ValueText == rangeVariable.Name.ValueText)
{
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.LinqGroupBy, collection, keySelector, keyTypeName));
}
}
var elementType = semanticModel_.GetTypeInfo(node.GroupExpression).Type;
var elementTypeName = GetTypeName(elementType);
var elementSelector = new LuaFunctionExpressionSyntax();
elementSelector.AddParameter(rangeVariable.Name);
elementSelector.AddStatement(new LuaReturnStatementSyntax(groupExpression));
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.LinqGroupBy, collection, keySelector, elementSelector, keyTypeName, elementTypeName));
}
private LuaExpressionSyntax BuildQuerySelect(LuaExpressionSyntax collection, SelectClauseSyntax node, IQueryRangeVariable rangeVariable)
{
var selectFunction = new LuaFunctionExpressionSyntax();
PushFunction(selectFunction);
selectFunction.AddParameter(rangeVariable.Name);
var expression = (LuaExpressionSyntax)node.Expression.Accept(this);
if (node.Expression.IsKind(SyntaxKind.IdentifierName))
{
if (expression is LuaIdentifierNameSyntax identifierName && identifierName.ValueText == rangeVariable.Name.ValueText)
{
PopFunction();
return(collection);
}
}
selectFunction.AddStatement(new LuaReturnStatementSyntax(expression));
PopFunction();
var type = semanticModel_.GetTypeInfo(node.Expression).Type;
var typeExpression = GetTypeName(type);
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.LinqSelect, collection, selectFunction, typeExpression));
}
private void BuildOperatorMethodDeclaration(BaseMethodDeclarationSyntax node)
{
var symbol = semanticModel_.GetDeclaredSymbol(node);
methodInfos_.Push(new MethodInfo(symbol));
bool isStatic = symbol.IsStatic;
bool isPrivate = symbol.IsPrivate();
LuaIdentifierNameSyntax name = GetMemberName(symbol);
var parameterList = (LuaParameterListSyntax)node.ParameterList.Accept(this);
LuaFunctionExpressionSyntax function = new LuaFunctionExpressionSyntax();
function.ParameterList.Parameters.AddRange(parameterList.Parameters);
PushFunction(function);
var comments = BuildDocumentationComment(node);
LuaBlockSyntax block = (LuaBlockSyntax)node.Body.Accept(this);
function.AddStatements(block.Statements);
CurType.AddMethod(name, function, isPrivate, symbol.IsStaticLazy(), comments);
PopFunction();
methodInfos_.Pop();
}
internal void Render(LuaFunctionExpressionSyntax node)
{
Write(node.FunctionKeyword);
WriteSpace();
node.ParameterList.Render(this);
node.Body.Render(this);
}
private LuaExpressionSyntax AddStructDefaultMethod(INamedTypeSymbol symbol, LuaStructDeclarationSyntax declaration)
{
LuaFunctionExpressionSyntax functionExpression = new LuaFunctionExpressionSyntax();
LuaExpressionSyntax typeName = GetTypeName(symbol);
functionExpression.AddStatement(new LuaReturnStatementSyntax(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.setmetatable, LuaTableInitializerExpression.Empty, typeName)));
declaration.AddMethod(LuaIdentifierNameSyntax.Default, functionExpression, false);
return(typeName);
}
public override LuaSyntaxNode VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
bool isEmpty = functions_.Count == 0;
if (isEmpty)
{
LuaFunctionExpressionSyntax function = new LuaFunctionExpressionSyntax();
PushFunction(function);
blocks_.Push(function.Body);
}
var temp = GetTempIdentifier(node.Expression);
conditionalTemps_.Push(temp);
var expression = (LuaExpressionSyntax)node.Expression.Accept(this);
CurBlock.Statements.Add(new LuaLocalVariableDeclaratorSyntax(temp, expression));
LuaBinaryExpressionSyntax condition = new LuaBinaryExpressionSyntax(temp, LuaSyntaxNode.Tokens.NotEquals, LuaIdentifierNameSyntax.Nil);
LuaIfStatementSyntax ifStatement = new LuaIfStatementSyntax(condition);
CurBlock.Statements.Add(ifStatement);
blocks_.Push(ifStatement.Body);
var whenNotNull = (LuaExpressionSyntax)node.WhenNotNull.Accept(this);
blocks_.Pop();
conditionalTemps_.Pop();
if (node.Parent.IsKind(SyntaxKind.ExpressionStatement))
{
if (isEmpty)
{
throw new InvalidOperationException();
}
ifStatement.Body.Statements.Add(new LuaExpressionStatementSyntax(whenNotNull));
return(LuaExpressionSyntax.EmptyExpression);
}
else
{
LuaAssignmentExpressionSyntax assignment = new LuaAssignmentExpressionSyntax(temp, whenNotNull);
ifStatement.Body.Statements.Add(new LuaExpressionStatementSyntax(assignment));
if (isEmpty)
{
var function = CurFunction;
function.AddStatement(new LuaReturnStatementSyntax(temp));
blocks_.Pop();
PopFunction();
return(new LuaInvocationExpressionSyntax(new LuaParenthesizedExpressionSyntax(function)));
}
else
{
return(temp);
}
}
}
private LuaExpressionSyntax BuildQueryWhere(LuaExpressionSyntax collection, WhereClauseSyntax node, LuaIdentifierNameSyntax rangeVariable)
{
var condition = (LuaExpressionSyntax)node.Condition.Accept(this);
var whereFunction = new LuaFunctionExpressionSyntax();
whereFunction.AddParameter(rangeVariable);
whereFunction.AddStatement(new LuaReturnStatementSyntax(condition));
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.LinqWhere, collection, whereFunction));
}
private LuaExpressionSyntax BuildJoinClause(LuaExpressionSyntax collection, JoinClauseSyntax node, ref IQueryRangeVariable rangeVariable, out bool isOver)
{
isOver = false;
var rangeVariable2 = AddRangeIdentifier(node.Identifier);
var inner = (LuaExpressionSyntax)node.InExpression.Accept(this);
var outerKeySelector = new LuaFunctionExpressionSyntax();
PushFunction(outerKeySelector);
outerKeySelector.AddParameter(rangeVariable.Name);
var left = (LuaExpressionSyntax)node.LeftExpression.Accept(this);
outerKeySelector.AddStatement(new LuaReturnStatementSyntax(left));
PopFunction();
var keyTypeSymbol = semanticModel_.GetTypeInfo(node.LeftExpression).Type;
var keyType = GetTypeName(keyTypeSymbol);
var innerKeySelector = new LuaFunctionExpressionSyntax();
PushFunction(innerKeySelector);
innerKeySelector.AddParameter(rangeVariable2.Name);
var right = (LuaExpressionSyntax)node.RightExpression.Accept(this);
innerKeySelector.AddStatement(new LuaReturnStatementSyntax(right));
PopFunction();
LuaFunctionExpressionSyntax resultSelector = new LuaFunctionExpressionSyntax();
PushFunction(resultSelector);
LuaExpressionSyntax resultSelectorExpression;
LuaExpressionSyntax resultSelectorType;
LuaIdentifierNameSyntax methodName;
var parentNode = (QueryBodySyntax)node.Parent;
if (node.Into == null)
{
methodName = LuaIdentifierNameSyntax.LinqJoin;
resultSelector.AddParameter(rangeVariable.Name);
resultSelector.AddParameter(rangeVariable2.Name);
isOver = BuildQueryJoin(node, out resultSelectorExpression, out resultSelectorType, ref rangeVariable, rangeVariable2);
}
else
{
methodName = LuaIdentifierNameSyntax.LinqGroupJoin;
var rangeVariableOfInto = AddRangeIdentifier(node.Into.Identifier);
resultSelector.AddParameter(rangeVariable.Name);
resultSelector.AddParameter(rangeVariableOfInto.Name);
isOver = BuildQueryJoin(node, out resultSelectorExpression, out resultSelectorType, ref rangeVariable, rangeVariableOfInto);
}
resultSelector.AddStatement(new LuaReturnStatementSyntax(resultSelectorExpression));
PopFunction();
return(new LuaInvocationExpressionSyntax(methodName, collection, inner, outerKeySelector, innerKeySelector, resultSelector, LuaIdentifierLiteralExpressionSyntax.Nil, keyType, resultSelectorType));
}
public override LuaSyntaxNode VisitFinallyClause(FinallyClauseSyntax node)
{
LuaFunctionExpressionSyntax functionExpress = new LuaFunctionExpressionSyntax();
PushFunction(functionExpress);
var finallyBlock = (LuaBlockSyntax)node.Block.Accept(this);
PopFunction();
functionExpress.AddStatements(finallyBlock.Statements);
return(functionExpress);
}
private void ExportManifestFile(List <string> modules, string outFolder)
{
const string kDir = "dir";
const string kDirInitCode = "dir = (dir and #dir > 0) and (dir .. '.') or \"\"";
const string kRequire = "require";
const string kLoadCode = "local load = function(module) return require(dir .. module) end";
const string kLoad = "load";
const string kInit = "System.init";
const string kManifestFile = "manifest.lua";
if (modules.Count > 0)
{
modules.Sort();
var types = GetExportTypes();
if (types.Count > 0)
{
LuaFunctionExpressionSyntax functionExpression = new LuaFunctionExpressionSyntax();
functionExpression.AddParameter(new LuaIdentifierNameSyntax(kDir));
functionExpression.AddStatement(new LuaIdentifierNameSyntax(kDirInitCode));
LuaIdentifierNameSyntax requireIdentifier = new LuaIdentifierNameSyntax(kRequire);
functionExpression.AddStatement(new LuaLocalVariableDeclaratorSyntax(requireIdentifier, requireIdentifier));
functionExpression.AddStatement(new LuaIdentifierNameSyntax(kLoadCode));
functionExpression.AddStatement(LuaBlankLinesStatement.One);
LuaIdentifierNameSyntax loadIdentifier = new LuaIdentifierNameSyntax(kLoad);
foreach (string module in modules)
{
var argument = new LuaStringLiteralExpressionSyntax(new LuaIdentifierNameSyntax(module));
var invocation = new LuaInvocationExpressionSyntax(loadIdentifier, argument);
functionExpression.AddStatement(invocation);
}
functionExpression.AddStatement(LuaBlankLinesStatement.One);
LuaTableInitializerExpression typeTable = new LuaTableInitializerExpression();
foreach (var type in types)
{
LuaIdentifierNameSyntax typeName = XmlMetaProvider.GetTypeShortName(type);
typeTable.Items.Add(new LuaSingleTableItemSyntax(new LuaStringLiteralExpressionSyntax(typeName)));
}
LuaInvocationExpressionSyntax initInvocation = new LuaInvocationExpressionSyntax(new LuaIdentifierNameSyntax(kInit), typeTable);
FillManifestInitConf(initInvocation);
functionExpression.AddStatement(initInvocation);
LuaCompilationUnitSyntax luaCompilationUnit = new LuaCompilationUnitSyntax();
luaCompilationUnit.Statements.Add(new LuaReturnStatementSyntax(functionExpression));
string outFile = Path.Combine(outFolder, kManifestFile);
Write(luaCompilationUnit, outFile);
}
}
}
private LuaExpressionSyntax BuildOrdering(LuaIdentifierNameSyntax methodName, LuaExpressionSyntax collection, OrderingSyntax node, IQueryRangeVariable rangeVariable)
{
var type = semanticModel_.GetTypeInfo(node.Expression).Type;
var typeName = GetTypeName(type);
var expression = (LuaExpressionSyntax)node.Expression.Accept(this);
var keySelector = new LuaFunctionExpressionSyntax();
keySelector.AddParameter(rangeVariable.Name);
keySelector.AddStatement(new LuaReturnStatementSyntax(expression));
return(new LuaInvocationExpressionSyntax(methodName, collection, keySelector, LuaIdentifierNameSyntax.Nil, typeName));
}
private LuaExpressionSyntax BuildGroupClause(LuaExpressionSyntax collection, GroupClauseSyntax node, LuaIdentifierNameSyntax rangeVariable)
{
var type = semanticModel_.GetTypeInfo(node.ByExpression).Type;
var typeName = GetTypeName(type);
var byExpression = (LuaExpressionSyntax)node.ByExpression.Accept(this);
var keySelector = new LuaFunctionExpressionSyntax();
keySelector.AddParameter(rangeVariable);
keySelector.AddStatement(new LuaReturnStatementSyntax(byExpression));
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.LinqGroupBy, collection, keySelector, typeName));
}
private List <LuaIdentifierNameSyntax> AddStructCloneMethod(INamedTypeSymbol symbol, LuaStructDeclarationSyntax declaration, LuaExpressionSyntax typeName)
{
List <LuaIdentifierNameSyntax> filelds = new List <LuaIdentifierNameSyntax>();
LuaFunctionExpressionSyntax functionExpression = new LuaFunctionExpressionSyntax();
functionExpression.AddParameter(LuaIdentifierNameSyntax.This);
LuaTableInitializerExpression cloneTable = new LuaTableInitializerExpression();
foreach (var member in symbol.GetMembers())
{
if (!member.IsStatic && member.Kind != SymbolKind.Method)
{
switch (member.Kind)
{
case SymbolKind.Field: {
IFieldSymbol memberSymbol = (IFieldSymbol)member;
LuaIdentifierNameSyntax name = new LuaIdentifierNameSyntax(member.Name);
AddStructCloneMethodItem(cloneTable, name, memberSymbol.Type);
filelds.Add(name);
break;
}
case SymbolKind.Property: {
IPropertySymbol memberSymbol = (IPropertySymbol)member;
if (IsPropertyField(memberSymbol))
{
LuaIdentifierNameSyntax name = new LuaIdentifierNameSyntax(member.Name);
AddStructCloneMethodItem(cloneTable, name, memberSymbol.Type);
filelds.Add(name);
}
break;
}
case SymbolKind.Event: {
IEventSymbol memberSymbol = (IEventSymbol)member;
if (IsEventFiled(memberSymbol))
{
LuaIdentifierNameSyntax name = new LuaIdentifierNameSyntax(member.Name);
AddStructCloneMethodItem(cloneTable, name, null);
filelds.Add(name);
}
break;
}
}
}
}
functionExpression.AddStatement(new LuaReturnStatementSyntax(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.setmetatable, cloneTable, typeName)));
declaration.AddMethod(LuaIdentifierNameSyntax.Clone, functionExpression, false);
return(filelds);
}
private LuaExpressionSyntax BuildLetClause(LuaExpressionSyntax collection, LetClauseSyntax node, ref IQueryRangeVariable rangeVariable)
{
var letExpression = (LuaExpressionSyntax)node.Expression.Accept(this);
var letRangeVariable = AddRangeIdentifier(node.Identifier);
var anonymousType = CreateQueryAnonymousType(rangeVariable.Name, rangeVariable.Name, letRangeVariable.Name, letExpression);
var selectFunction = new LuaFunctionExpressionSyntax();
selectFunction.AddParameter(rangeVariable.Name);
selectFunction.AddStatement(new LuaReturnStatementSyntax(anonymousType));
rangeVariable = new QueryPackVariable(rangeVariable, letRangeVariable);
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.LinqSelect, collection, selectFunction, LuaIdentifierNameSyntax.AnonymousType));
}
private void TryAddStructDefaultMethod(INamedTypeSymbol symbol, LuaStructDeclarationSyntax declaration) {
if (declaration.IsInitStatementExists) {
LuaIdentifierNameSyntax className = new LuaIdentifierNameSyntax(symbol.Name);
var thisIdentifier = LuaIdentifierNameSyntax.This;
LuaFunctionExpressionSyntax functionExpression = new LuaFunctionExpressionSyntax();
functionExpression.AddParameter(className);
var invocation = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.setmetatable, LuaTableInitializerExpression.Empty, className);
LuaLocalVariableDeclaratorSyntax local = new LuaLocalVariableDeclaratorSyntax(thisIdentifier, invocation);
functionExpression.AddStatement(local);
functionExpression.AddStatement(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Init, thisIdentifier)));
functionExpression.AddStatement(new LuaReturnStatementSyntax(thisIdentifier));
declaration.AddMethod(LuaIdentifierNameSyntax.Default, functionExpression, false);
}
}
private LuaExpressionSyntax BuildQueryWhere(LuaExpressionSyntax collection, WhereClauseSyntax node, IQueryRangeVariable rangeVariable)
{
var whereFunction = new LuaFunctionExpressionSyntax();
PushFunction(whereFunction);
var condition = (LuaExpressionSyntax)node.Condition.Accept(this);
if (condition == LuaIdentifierLiteralExpressionSyntax.True)
{
PopFunction();
return(collection);
}
whereFunction.AddParameter(rangeVariable.Name);
whereFunction.AddStatement(new LuaReturnStatementSyntax(condition));
PopFunction();
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.LinqWhere, collection, whereFunction));
}
private LuaExpressionSyntax VisitLambdaExpression(IEnumerable <ParameterSyntax> parameters, CSharpSyntaxNode body)
{
IMethodSymbol symbol = (IMethodSymbol)semanticModel_.GetSymbolInfo(body.Parent).Symbol;
methodInfos_.Push(new MethodInfo(symbol));
LuaFunctionExpressionSyntax function = new LuaFunctionExpressionSyntax();
PushFunction(function);
foreach (var parameter in parameters)
{
var luaParameter = (LuaParameterSyntax)parameter.Accept(this);
function.ParameterList.Parameters.Add(luaParameter);
}
LuaExpressionSyntax resultExpression = function;
if (body.IsKind(SyntaxKind.Block))
{
var block = (LuaBlockSyntax)body.Accept(this);
function.AddStatements(block.Statements);
}
else
{
var type = (INamedTypeSymbol)semanticModel_.GetTypeInfo(body.Parent).ConvertedType;
var delegateInvokeMethod = type.DelegateInvokeMethod;
blocks_.Push(function.Body);
var expression = (LuaExpressionSyntax)body.Accept(this);
blocks_.Pop();
if (delegateInvokeMethod.ReturnsVoid)
{
function.AddStatement(expression);
}
else
{
function.AddStatement(new LuaReturnStatementSyntax(expression));
}
}
PopFunction();
methodInfos_.Pop();
return(resultExpression);
}
private LuaFunctionExpressionSyntax BuildObjectInitializerExpression(InitializerExpressionSyntax node)
{
LuaFunctionExpressionSyntax function = new LuaFunctionExpressionSyntax();
PushFunction(function);
var temp = GetTempIdentifier(node);
function.AddParameter(temp);
foreach (var expression in node.Expressions)
{
if (expression.IsKind(SyntaxKind.SimpleAssignmentExpression))
{
AssignmentExpressionSyntax assignment = (AssignmentExpressionSyntax)expression;
var left = assignment.Left.Accept(this);
var right = (LuaExpressionSyntax)assignment.Right.Accept(this);
CheckValueTypeAndConversion(assignment.Right, ref right);
if (assignment.Left.IsKind(SyntaxKind.ImplicitElementAccess))
{
var argumentList = (LuaArgumentListSyntax)left;
LuaIdentifierNameSyntax methodName = new LuaIdentifierNameSyntax(LuaSyntaxNode.Tokens.Set);
LuaMemberAccessExpressionSyntax memberAccess = new LuaMemberAccessExpressionSyntax(temp, methodName, true);
LuaInvocationExpressionSyntax invocation = new LuaInvocationExpressionSyntax(memberAccess);
invocation.ArgumentList.Arguments.AddRange(argumentList.Arguments);
invocation.AddArgument(right);
function.AddStatement(invocation);
}
else
{
var memberAccess = BuildFieldOrPropertyMemberAccessExpression(temp, (LuaExpressionSyntax)left, false);
var assignmentExpression = BuildLuaSimpleAssignmentExpression(memberAccess, right);
function.AddStatement(assignmentExpression);
}
}
else
{
LuaMemberAccessExpressionSyntax memberAccess = new LuaMemberAccessExpressionSyntax(temp, LuaIdentifierNameSyntax.Add, true);
var value = (LuaExpressionSyntax)expression.Accept(this);
function.AddStatement(new LuaInvocationExpressionSyntax(memberAccess, value));
}
}
PopFunction();
return(function);
}
private LuaExpressionSyntax BuildFromClause(LuaExpressionSyntax collection, FromClauseSyntax node, ref IQueryRangeVariable rangeVariable, out bool isOver)
{
var collectionSelector = new LuaFunctionExpressionSyntax();
PushFunction(collectionSelector);
collectionSelector.AddParameter(rangeVariable.Name);
var expression = (LuaExpressionSyntax)node.Expression.Accept(this);
collectionSelector.AddStatement(new LuaReturnStatementSyntax(expression));
PopFunction();
var rangeVariable2 = AddRangeIdentifier(node.Identifier);
var resultSelector = new LuaFunctionExpressionSyntax();
PushFunction(resultSelector);
resultSelector.AddParameter(rangeVariable.Name);
resultSelector.AddParameter(rangeVariable2.Name);
LuaExpressionSyntax resultSelectorExpression;
LuaExpressionSyntax resultSelectorType;
var parentNode = (QueryBodySyntax)node.Parent;
if (IsSpecialQueryNode(parentNode))
{
var selectClause = (SelectClauseSyntax)parentNode.SelectOrGroup;
resultSelectorExpression = (LuaExpressionSyntax)selectClause.Expression.Accept(this);
var type = semanticModel_.GetTypeInfo(selectClause.Expression).Type;
resultSelectorType = GetTypeName(type);
isOver = true;
}
else
{
resultSelectorExpression = CreateQueryAnonymousType(rangeVariable.Name, rangeVariable.Name, rangeVariable2.Name, rangeVariable2.Name);
resultSelectorType = LuaIdentifierNameSyntax.AnonymousType;
rangeVariable = new QueryPackVariable(rangeVariable, rangeVariable2);
isOver = false;
}
resultSelector.AddStatement(new LuaReturnStatementSyntax(resultSelectorExpression));
PopFunction();
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.LinqSelectMany, collection, collectionSelector, resultSelector, resultSelectorType));
}
private void AddStructEqualsObjMethod(INamedTypeSymbol symbol, LuaStructDeclarationSyntax declaration, LuaExpressionSyntax typeName, List <LuaIdentifierNameSyntax> fields)
{
var thisIdentifier = LuaIdentifierNameSyntax.This;
LuaIdentifierNameSyntax obj = LuaIdentifierNameSyntax.Obj;
LuaFunctionExpressionSyntax functionExpression = new LuaFunctionExpressionSyntax();
functionExpression.AddParameter(thisIdentifier);
functionExpression.AddParameter(obj);
var left = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.getmetatable, obj);
LuaIfStatementSyntax ifStatement = new LuaIfStatementSyntax(new LuaBinaryExpressionSyntax(left, LuaSyntaxNode.Tokens.NotEquals, typeName));
ifStatement.Body.Statements.Add(new LuaReturnStatementSyntax(LuaIdentifierNameSyntax.False));
functionExpression.AddStatement(ifStatement);
if (fields.Count > 0)
{
var equalsStatic = LuaIdentifierNameSyntax.EqualsStatic;
LuaLocalVariableDeclaratorSyntax variableDeclarator = new LuaLocalVariableDeclaratorSyntax(equalsStatic, LuaIdentifierNameSyntax.SystemObjectEqualsStatic);
functionExpression.AddStatement(variableDeclarator);
LuaExpressionSyntax expression = null;
foreach (LuaIdentifierNameSyntax field in fields)
{
LuaMemberAccessExpressionSyntax argument1 = new LuaMemberAccessExpressionSyntax(thisIdentifier, field);
LuaMemberAccessExpressionSyntax argument2 = new LuaMemberAccessExpressionSyntax(obj, field);
LuaInvocationExpressionSyntax invocation = new LuaInvocationExpressionSyntax(equalsStatic, argument1, argument2);
if (expression == null)
{
expression = invocation;
}
else
{
expression = new LuaBinaryExpressionSyntax(expression, LuaSyntaxNode.Tokens.And, invocation);
}
}
Contract.Assert(expression != null);
functionExpression.AddStatement(new LuaReturnStatementSyntax(expression));
}
declaration.AddMethod(LuaIdentifierNameSyntax.EqualsObj, functionExpression, false);
}
public LuaStatementSyntax Transpile(JassFunctionDeclarationSyntax functionDeclaration)
{
RegisterFunctionReturnType(functionDeclaration.FunctionDeclarator);
var functionExpression = new LuaFunctionExpressionSyntax();
functionExpression.AddParameters(Transpile(functionDeclaration.FunctionDeclarator.ParameterList));
functionExpression.Body.Statements.AddRange(Transpile(functionDeclaration.Body));
functionExpression.RenderAsFunctionDefinition = true;
_localTypes.Clear();
var luaFunctionDeclaration = new LuaVariableDeclaratorSyntax(Transpile(functionDeclaration.FunctionDeclarator.IdentifierName), functionExpression);
luaFunctionDeclaration.IsLocalDeclaration = false;
var declaration = new LuaVariableListDeclarationSyntax();
declaration.Variables.Add(luaFunctionDeclaration);
return(new LuaLocalDeclarationStatementSyntax(declaration));
}
private LuaVariableListDeclarationSyntax GetMainFunctionSyntax(float left, float right, float top, float bottom, Tileset tileset, SoundEnvironment sound, params string[] initFunctions)
{
var localLeft = new LuaBinaryExpressionSyntax(
new LuaFloatLiteralExpressionSyntax(left),
LuaSyntaxNode.Tokens.Plus,
new LuaInvocationExpressionSyntax("GetCameraMargin", "CAMERA_MARGIN_LEFT"));
var localRight = new LuaBinaryExpressionSyntax(
new LuaFloatLiteralExpressionSyntax(right),
LuaSyntaxNode.Tokens.Sub,
new LuaInvocationExpressionSyntax("GetCameraMargin", "CAMERA_MARGIN_RIGHT"));
var localTop = new LuaBinaryExpressionSyntax(
new LuaFloatLiteralExpressionSyntax(top),
LuaSyntaxNode.Tokens.Sub,
new LuaInvocationExpressionSyntax("GetCameraMargin", "CAMERA_MARGIN_TOP"));
var localBottom = new LuaBinaryExpressionSyntax(
new LuaFloatLiteralExpressionSyntax(bottom),
LuaSyntaxNode.Tokens.Plus,
new LuaInvocationExpressionSyntax("GetCameraMargin", "CAMERA_MARGIN_BOTTOM"));
var locals = new[]
{
localLeft,
localRight,
localTop,
localBottom,
};
var statements = new List <LuaStatementSyntax>
{
new LuaLocalDeclarationStatementSyntax(new LuaLocalVariablesStatementSyntax(
new[]
{
new LuaSymbolNameSyntax(new LuaIdentifierLiteralExpressionSyntax("left")),
new LuaSymbolNameSyntax(new LuaIdentifierLiteralExpressionSyntax("right")),
new LuaSymbolNameSyntax(new LuaIdentifierLiteralExpressionSyntax("top")),
new LuaSymbolNameSyntax(new LuaIdentifierLiteralExpressionSyntax("bottom")),
},
locals)),
new LuaExpressionStatementSyntax(
new LuaInvocationExpressionSyntax(
"SetCameraBounds",
"left",
"bottom",
"right",
"top",
"left",
"top",
"right",
"bottom")),
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"SetDayNightModels",
new LuaStringLiteralExpressionSyntax(LightEnvironmentProvider.GetTerrainLightEnvironmentModel(tileset)),
new LuaStringLiteralExpressionSyntax(LightEnvironmentProvider.GetUnitLightEnvironmentModel(tileset)))),
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("NewSoundEnvironment", new LuaStringLiteralExpressionSyntax(SoundEnvironmentProvider.GetSoundEnvironment(sound)))),
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("SetAmbientDaySound", new LuaStringLiteralExpressionSyntax(SoundEnvironmentProvider.GetAmbientDaySound(tileset)))),
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("SetAmbientNightSound", new LuaStringLiteralExpressionSyntax(SoundEnvironmentProvider.GetAmbientNightSound(tileset)))),
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"SetMapMusic",
new LuaStringLiteralExpressionSyntax("Music"),
LuaIdentifierLiteralExpressionSyntax.False,
LuaNumberLiteralExpressionSyntax.Zero)),
};
foreach (var initFunction in initFunctions)
{
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(initFunction)));
}
var functionSyntax = new LuaFunctionExpressionSyntax();
functionSyntax.AddStatements(statements);
var mainFunctionDeclarator = new LuaVariableDeclaratorSyntax("main", functionSyntax);
mainFunctionDeclarator.IsLocalDeclaration = false;
var globalFunctionSyntax = new LuaVariableListDeclarationSyntax();
globalFunctionSyntax.Variables.Add(mainFunctionDeclarator);
return(globalFunctionSyntax);
}
public override LuaSyntaxNode VisitAttribute(AttributeSyntax node)
{
var symbol = (IMethodSymbol)semanticModel_.GetSymbolInfo(node.Name).Symbol;
INamedTypeSymbol typeSymbol = symbol.ContainingType;
if (!generator_.IsExportAttribute(typeSymbol))
{
return(null);
}
INamedTypeSymbol typeDeclarationSymbol = GetTypeDeclarationSymbol(node);
generator_.AddTypeDeclarationAttribute(typeDeclarationSymbol, typeSymbol);
++baseNameNodeCounter_;
var expression = GetTypeName(typeSymbol);
--baseNameNodeCounter_;
LuaInvocationExpressionSyntax invocation = BuildObjectCreationInvocation(symbol, new LuaMemberAccessExpressionSyntax(LuaIdentifierNameSyntax.Global, expression));
if (node.ArgumentList != null)
{
List <LuaExpressionSyntax> arguments = new List <LuaExpressionSyntax>();
List <Tuple <LuaExpressionSyntax, LuaExpressionSyntax> > initializers = new List <Tuple <LuaExpressionSyntax, LuaExpressionSyntax> >();
List <Tuple <NameColonSyntax, ExpressionSyntax> > argumentNodeInfos = new List <Tuple <NameColonSyntax, ExpressionSyntax> >();
foreach (var argumentNode in node.ArgumentList.Arguments)
{
var argumentExpression = (LuaExpressionSyntax)argumentNode.Expression.Accept(this);
CheckValueTypeAndConversion(argumentNode.Expression, ref argumentExpression);
if (argumentNode.NameEquals == null)
{
if (argumentNode.NameColon != null)
{
string name = argumentNode.NameColon.Name.Identifier.ValueText;
int index = symbol.Parameters.IndexOf(i => i.Name == name);
Contract.Assert(index != -1);
arguments.AddAt(index, argumentExpression);
}
else
{
arguments.Add(argumentExpression);
}
}
else
{
var name = (LuaExpressionSyntax)argumentNode.NameEquals.Accept(this);
initializers.Add(Tuple.Create(name, argumentExpression));
}
}
CheckInvocationDeafultArguments(symbol, symbol.Parameters, arguments, argumentNodeInfos, node, false);
invocation.AddArguments(arguments);
if (initializers.Count == 0)
{
return(invocation);
}
else
{
LuaFunctionExpressionSyntax function = new LuaFunctionExpressionSyntax();
PushFunction(function);
var temp = GetTempIdentifier(node);
function.AddParameter(temp);
foreach (var initializer in initializers)
{
var memberAccess = BuildFieldOrPropertyMemberAccessExpression(temp, initializer.Item1, false);
var assignmentExpression = BuildLuaSimpleAssignmentExpression(memberAccess, initializer.Item2);
function.AddStatement(assignmentExpression);
}
PopFunction();
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Create, invocation, function));
}
}
else
{
return(invocation);
}
}
private LuaVariableListDeclarationSyntax GetConfigFunctionSyntax(string mapName, string mapDescription, string lobbyMusic, params PlayerSlot[] playerSlots)
{
var statements = new List <LuaStatementSyntax>
{
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("SetMapName", new LuaStringLiteralExpressionSyntax(mapName))),
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("SetMapDescription", new LuaStringLiteralExpressionSyntax(mapDescription))),
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("SetPlayers", playerSlots.Length)),
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("SetTeams", playerSlots.Length)),
new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("SetGamePlacement", "MAP_PLACEMENT_TEAMS_TOGETHER")),
};
if (lobbyMusic != null)
{
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax("PlayMusic", lobbyMusic)));
}
for (var i = 0; i < playerSlots.Length; i++)
{
var playerSlot = playerSlots[i];
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"DefineStartLocation",
i,
playerSlot.StartLocationX,
playerSlot.StartLocationY)));
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"SetPlayerStartLocation",
new LuaInvocationExpressionSyntax("Player", i),
i)));
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"ForcePlayerStartLocation",
new LuaInvocationExpressionSyntax("Player", i),
i)));
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"SetPlayerColor",
new LuaInvocationExpressionSyntax("Player", i),
new LuaInvocationExpressionSyntax("ConvertPlayerColor", i))));
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"SetPlayerRacePreference",
new LuaInvocationExpressionSyntax("Player", i),
new LuaIdentifierLiteralExpressionSyntax(playerSlot.RacePreference))));
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"SetPlayerRaceSelectable",
new LuaInvocationExpressionSyntax("Player", i),
LuaIdentifierLiteralExpressionSyntax.False)));
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"SetPlayerController",
new LuaInvocationExpressionSyntax("Player", i),
new LuaIdentifierLiteralExpressionSyntax(playerSlot.Controller))));
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"SetPlayerTeam",
new LuaInvocationExpressionSyntax("Player", i),
playerSlot.Team)));
statements.Add(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(
"SetStartLocPrioCount",
i,
0)));
}
var functionSyntax = new LuaFunctionExpressionSyntax();
functionSyntax.AddStatements(statements);
var configFunctionDeclarator = new LuaVariableDeclaratorSyntax("config", functionSyntax);
configFunctionDeclarator.IsLocalDeclaration = false;
var globalFunctionSyntax = new LuaVariableListDeclarationSyntax();
globalFunctionSyntax.Variables.Add(configFunctionDeclarator);
return(globalFunctionSyntax);
}
