private static void SortMetaData(LuaTableExpression metaData)
{
if (metaData != null)
{
metaData.Items.Sort((x, y) => string.Compare(MetaDataName(x), MetaDataName(y), StringComparison.Ordinal));
}
}
private static void SortMetaData(LuaTableExpression metaData)
{
if (metaData != null)
{
metaData.Items.Sort((x, y) => MetaDataName(x).CompareTo(MetaDataName(y)));
}
}
private void CheckCtorsFunction(LuaBlockSyntax body)
{
bool hasInit = initStatements_.Count > 0;
bool hasCtors = ctors_.Count > 0;
if (hasCtors)
{
if (hasInit)
{
if (ctors_.Count == 1)
{
ctors_.First().Body.Statements.InsertRange(0, initStatements_);
}
else
{
var initIdentifier = LuaIdentifierNameSyntax.Init;
AddInitFunction(body, initIdentifier, GetInitFunction(), false);
foreach (var ctor in ctors_)
{
if (!ctor.IsInvokeThisCtor)
{
LuaInvocationExpressionSyntax invocationInit = new LuaInvocationExpressionSyntax(initIdentifier, LuaIdentifierNameSyntax.This);
ctor.Body.Statements.Insert(0, new LuaExpressionStatementSyntax(invocationInit));
}
}
}
}
if (ctors_.Count == 1)
{
var ctor = ctors_.First();
if (ctor.Body.Statements.Count > 0)
{
AddInitFunction(body, LuaIdentifierNameSyntax.Ctor, ctor);
}
}
else
{
LuaTableExpression ctrosTable = new LuaTableExpression();
int index = 1;
foreach (var ctor in ctors_)
{
string name = SpecailWord(Tokens.Ctor + index);
LuaIdentifierNameSyntax nameIdentifier = name;
AddInitFunction(body, nameIdentifier, ctor, false);
ctrosTable.Add(nameIdentifier);
++index;
}
AddResultTable(LuaIdentifierNameSyntax.Ctor, ctrosTable);
}
}
else
{
if (hasInit)
{
AddInitFunction(body, LuaIdentifierNameSyntax.Ctor, GetInitFunction());
}
}
}
internal void AddClassMetaData(LuaTableExpression data)
{
if (metadata_ == null)
{
metadata_ = new LuaTableExpression();
}
metadata_.Add(LuaIdentifierNameSyntax.Class, data);
}
private void AddInterfaceDefaultMethod(LuaIdentifierNameSyntax name, LuaExpressionSyntax value)
{
if (interfaceDefaultMethods_ == null)
{
interfaceDefaultMethods_ = new LuaTableExpression();
AddResultTable(LuaIdentifierNameSyntax.InterfaceDefaultMethodVar, interfaceDefaultMethods_);
}
interfaceDefaultMethods_.Add(name, value);
}
internal void AddBaseTypes(IEnumerable <LuaExpressionSyntax> baseTypes, LuaSpeaicalGenericType genericArgument, List <LuaIdentifierNameSyntax> baseCopyFields)
{
bool hasLazyGenericArgument = false;
if (genericArgument != null)
{
if (genericArgument.IsLazy)
{
hasLazyGenericArgument = true;
}
else
{
AddResultTable(genericArgument.Name, genericArgument.Value);
}
}
bool hasBaseCopyField = baseCopyFields != null && baseCopyFields.Count > 0;
LuaFunctionExpressionSyntax functionExpression = new LuaFunctionExpressionSyntax();
functionExpression.AddParameter(LuaIdentifierNameSyntax.Global);
if (hasLazyGenericArgument || hasBaseCopyField)
{
functionExpression.AddParameter(LuaIdentifierNameSyntax.This);
}
if (hasLazyGenericArgument)
{
var assignment = new LuaAssignmentExpressionSyntax(new LuaMemberAccessExpressionSyntax(LuaIdentifierNameSyntax.This, genericArgument.Name), genericArgument.Value);
functionExpression.AddStatement(assignment);
}
LuaTableExpression table = new LuaTableExpression();
if (hasBaseCopyField)
{
var baseIdentifier = LuaIdentifierNameSyntax.Base;
functionExpression.AddStatement(new LuaLocalVariableDeclaratorSyntax(baseIdentifier, baseTypes.First()));
foreach (var field in baseCopyFields)
{
var left = new LuaMemberAccessExpressionSyntax(LuaIdentifierNameSyntax.This, field);
var right = new LuaMemberAccessExpressionSyntax(baseIdentifier, field);
functionExpression.AddStatement(new LuaAssignmentExpressionSyntax(left, right));
table.Items.Add(new LuaSingleTableItemSyntax(baseIdentifier));
table.Items.AddRange(baseTypes.Skip(1).Select(i => new LuaSingleTableItemSyntax(i)));
}
}
else
{
table.Items.AddRange(baseTypes.Select(i => new LuaSingleTableItemSyntax(i)));
}
functionExpression.AddStatement(new LuaReturnStatementSyntax(table));
AddResultTable(LuaIdentifierNameSyntax.Inherits, functionExpression);
}
internal void AddFieldAttributes(LuaIdentifierNameSyntax name, List <LuaExpressionSyntax> attributes)
{
if (attributes.Count > 0)
{
var table = new LuaTableExpression(attributes)
{
IsSingleLine = true
};
AddMetadata(ref attributes_, LuaIdentifierNameSyntax.Attributes, new LuaKeyValueTableItemSyntax(name, table));
}
}
private void AddMetadata(ref LuaTableExpression table, LuaIdentifierNameSyntax name, LuaTableItemSyntax item)
{
if (metadata_ == null)
{
metadata_ = new LuaTableExpression();
}
if (table == null)
{
table = new LuaTableExpression();
metadata_.Add(name, table);
}
table.Items.Add(item);
}
private void CheckMetatableMoreThanUpvalues(LuaTableExpression table, int nameIndex, ref int upvalueCount)
{
int kMaxUpvalueCount = kUpvaluesMaxCount - 2 - (IsClassUsed ? 1 : 0);
var expression = table.GetSingleExpression(nameIndex);
if (expression is LuaIdentifierNameSyntax name)
{
if (upvalueCount >= kMaxUpvalueCount)
{
CheckTooManyVariables(false);
var left = LuaIdentifierNameSyntax.MorenManyLocalVarTempTable.MemberAccess(name);
methodList_.Statements.Add(left.Assignment(name));
table.Items[nameIndex] = new LuaSingleTableItemSyntax(left);
}
else
{
++upvalueCount;
}
}
}
private static IEnumerable <LuaTableExpression> GetMetatables(LuaTableExpression metaMethods)
{
return(metaMethods.Items.OfType <LuaSingleTableItemSyntax>().Select(i => (LuaTableExpression)i.Expression));
}
private void CheckCtorsFunction(LuaBlockSyntax body)
{
bool hasInit = initStatements_.Count > 0;
bool hasCtors = ctors_.Count > 0;
if (hasCtors)
{
if (hasInit)
{
if (ctors_.Count == 1)
{
ctors_.First().Function.Body.Statements.InsertRange(0, initStatements_);
}
else
{
var init = LuaIdentifierNameSyntax.Init;
AddInitFunction(body, init, GetInitFunction(), false);
foreach (var ctor in ctors_)
{
if (!ctor.Function.IsInvokeThisCtor)
{
var invocationInit = new LuaInvocationExpressionSyntax(init, LuaIdentifierNameSyntax.This);
ctor.Function.Body.Statements.Insert(0, invocationInit);
}
}
}
}
if (ctors_.Count == 1)
{
var ctor = ctors_.First();
if (ctor.Function.Body.Statements.Count > 0)
{
if (ctor.Document != null)
{
body.AddStatement(ctor.Document);
}
AddInitFunction(body, LuaIdentifierNameSyntax.Ctor, ctor.Function);
}
}
else
{
LuaTableExpression ctrosTable = new LuaTableExpression();
int index = 1;
foreach (var ctor in ctors_)
{
if (ctor.Document != null)
{
body.AddStatement(ctor.Document);
}
LuaIdentifierNameSyntax nameIdentifier = GetCtorNameString(index);
AddInitFunction(body, nameIdentifier, ctor.Function, false);
ctrosTable.Add(nameIdentifier);
++index;
}
AddResultTable(LuaIdentifierNameSyntax.Ctor, ctrosTable);
}
}
else
{
if (hasInit)
{
AddInitFunction(body, LuaIdentifierNameSyntax.Ctor, GetInitFunction());
}
}
}
internal void AddMethodMetaData(LuaTableExpression data)
{
AddMetadata(ref metaMethods_, LuaIdentifierNameSyntax.Methods, new LuaSingleTableItemSyntax(data));
}
internal void AddPropertyMetaData(LuaTableExpression data)
{
AddMetadata(ref metaProperties_, LuaIdentifierNameSyntax.Properties, new LuaSingleTableItemSyntax(data));
}
