private ClassDeclarationSyntax _generatePszClass(Dictionary <string, Tuple <string, FieldDeclarationSyntax> > fields, XSharpTreeTransformationCore trans)
{
var clsmembers = _pool.Allocate <MemberDeclarationSyntax>();
foreach (var field in fields)
{
var fieldDecl = field.Value.Item2;
clsmembers.Add(fieldDecl);
}
var decl = _syntaxFactory.ClassDeclaration(
default(SyntaxList <AttributeListSyntax>),
trans.TokenList(SyntaxKind.StaticKeyword, SyntaxKind.InternalKeyword),
SyntaxFactory.MakeToken(SyntaxKind.ClassKeyword),
SyntaxFactory.MakeIdentifier(XSharpSpecialNames.PSZTable),
default(TypeParameterListSyntax),
default(BaseListSyntax),
default(SyntaxList <TypeParameterConstraintClauseSyntax>),
SyntaxFactory.MakeToken(SyntaxKind.OpenBraceToken),
clsmembers,
SyntaxFactory.MakeToken(SyntaxKind.CloseBraceToken),
null);
fields.Clear();
return(decl);
}
private MemberDeclarationSyntax createProperty(string fldName, TypeSyntax type, XSharpParserRuleContext context, XP.ClassvarModifiersContext modifiers)
{
var accessors = _pool.Allocate <AccessorDeclarationSyntax>();
BlockSyntax body = null;
if (_options.fox1)
{
var call = GenerateMethodCall(XSharpSpecialNames.GetProperty, MakeArgumentList(MakeArgument(GenerateLiteral(fldName))), true);
body = MakeBlock(GenerateReturn(call, true));
body.XGenerated = true;
}
var accessor = _syntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration,
EmptyList <AttributeListSyntax>(), EmptyList(),
SyntaxFactory.MakeToken(SyntaxKind.GetKeyword),
body,
null,
SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
accessor.XNode = context;
accessor.XGenerated = true;
accessors.Add(accessor);
if (_options.fox1)
{
var call = GenerateMethodCall(XSharpSpecialNames.SetProperty, MakeArgumentList(MakeArgument(GenerateLiteral(fldName)), MakeArgument(GenerateSimpleName("value"))), true);
body = MakeBlock(GenerateExpressionStatement(call, true));
body.XGenerated = true;
}
accessor = _syntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration,
EmptyList <AttributeListSyntax>(), EmptyList(),
SyntaxFactory.MakeToken(SyntaxKind.SetKeyword),
body,
null,
SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
accessor.XNode = context;
accessor.XGenerated = true;
accessors.Add(accessor);
var id = SyntaxFactory.MakeIdentifier(fldName);
var accessorList = _syntaxFactory.AccessorList(SyntaxFactory.MakeToken(SyntaxKind.OpenBraceToken),
accessors, SyntaxFactory.MakeToken(SyntaxKind.CloseBraceToken));
_pool.Free(accessors);
var mods = modifiers?.GetList <SyntaxToken>() ?? DefaultMethodModifiers(false, false, false);
var prop = _syntaxFactory.PropertyDeclaration(
attributeLists: EmptyList <AttributeListSyntax>(),
modifiers: mods,
type: type,
explicitInterfaceSpecifier: null,
identifier: id,
accessorList: accessorList,
expressionBody: null,
initializer: null,
semicolonToken: SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
return(prop);
}
public override void ExitXppmethod([NotNull] XP.XppmethodContext context)
{
// should do the same as the 'normal' methods in VO Class
// Retrieve visibility from the XppClassInfo, from the list of declared methods
// when not declared produce warning (error ?)
// When classname clause is missing then assume the last class in the file before this method
context.SetSequencePoint(context.M, context.end.Stop);
if (context.Info == null)
{
context.AddError(new ParseErrorData(context, ErrorCode.WRN_XPPMethodNotDeclared, context.ShortName));
// setup dummy declaration
context.Info = new XppDeclaredMethodInfo()
{
Name = context.ShortName, Declaration = context, Entity = context, Visibility = XP.HIDDEN
};
}
if (context.Data.IsInitAxit)
{
// method init becomes constructor, method initClass becomes Class constructor
implementConstructor(context);
return;
}
SyntaxList <SyntaxToken> modifiers;
if (context.Info.IsProperty)
{
// the backing method becomes private
modifiers = decodeXppMemberModifiers(XP.PRIVATE, false, context.Modifiers?._Tokens);
}
else
{
modifiers = decodeXppMemberModifiers(context.Info.Visibility, false, context.Modifiers?._Tokens);
}
TypeSyntax returnType = context.Type?.Get <TypeSyntax>();
if (returnType == null)
{
returnType = _getMissingType();
}
var attributes = context.Attributes?.GetList <AttributeListSyntax>() ?? EmptyList <AttributeListSyntax>();
var parameters = context.ParamList?.Get <ParameterListSyntax>() ?? EmptyParameterList();
var name = context.Id.Get <SyntaxToken>();
if (context.Info.IsProperty && !context.Info.HasVarName)
{
// rename method because the property has the same name as the method
name = SyntaxFactory.MakeIdentifier(context.Id.GetText() + XSharpSpecialNames.PropertySuffix);
}
var method = XppCreateMethod(context, name, attributes, modifiers, parameters, returnType);
context.Put(method);
}
private ConstructorDeclarationSyntax createConstructor(XP.FoxclassContext context, SyntaxListBuilder <MemberDeclarationSyntax> members,
List <String> fieldNames, ConstructorDeclarationSyntax existingctor)
{
var stmts = new List <StatementSyntax>();
bool hasinit = false;
var attributeLists = _pool.Allocate <AttributeListSyntax>();
ParameterListSyntax initparams = EmptyParameterList();
ConstructorDeclarationSyntax ctor = null;
foreach (var member in context._Members)
{
if (member is XP.FoxclsmethodContext fm)
{
// fetch parameters from procedure/function init
var method = fm.Member as XP.FoxmethodContext;
if (method.Id.GetText().ToLower() == "init")
{
var syntax = method.Get <MethodDeclarationSyntax>();
initparams = syntax.ParameterList;
attributeLists.AddRange(syntax.AttributeLists);
hasinit = true;
}
}
else if (member is XP.FoxclsvarinitContext cvi)
{
// Generate code to initialize properties
var fldinit = cvi.Member;
var assign = fldinit.F.Get <ExpressionSyntax>();
var stmt = GenerateExpressionStatement(assign);
stmt.XNode = fldinit.F;
stmts.Add(stmt);
}
else if (member is XP.FoxaddobjectContext fac)
{
// generate object creation and addobject call
// Property:= ClassName{}{.......}
var addobject = fac.Member;
var create = createAddObject(addobject);
var name = addobject.Id.GetText();
var prop = MakeSimpleMemberAccess(GenerateSelf(), GenerateSimpleName(name));
var assign = MakeSimpleAssignment(prop, create);
var stmt = GenerateExpressionStatement(assign);
stmt.XNode = addobject;
stmts.Add(stmt);
// AddObject(SELF:Property)
var arg1 = MakeArgument(GenerateLiteral(name));
var arg2 = MakeArgument(prop);
var mcall = GenerateMethodCall(XSharpSpecialNames.AddObject, MakeArgumentList(arg1, arg2));
stmt = GenerateExpressionStatement(mcall);
stmt.XNode = addobject;
stmts.Add(stmt);
}
}
if (_options.fox1)
{
if (stmts.Count > 0)
{
// Generate Virtual Protected _InitProperties
// SUPER:_InitProperties()
// All Statements
var mac = MakeSimpleMemberAccess(GenerateSuper(), GenerateSimpleName(XSharpSpecialNames.InitProperties));
var superCall = _syntaxFactory.InvocationExpression(mac, EmptyArgumentList());
var stmt = GenerateExpressionStatement(superCall, true);
stmts.Insert(0, stmt);
var body = MakeBlock(stmts);
body.XGenerated = true;
var mods = TokenList(SyntaxKind.ProtectedKeyword, SyntaxKind.OverrideKeyword);
var id = SyntaxFactory.MakeIdentifier(XSharpSpecialNames.InitProperties);
var mem = _syntaxFactory.MethodDeclaration(MakeCompilerGeneratedAttribute(), mods, _voidType, null, id,
null, EmptyParameterList(), null, body, null, SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
members.Add(mem);
stmts.Clear();
}
}
if (stmts.Count > 0 || hasinit || existingctor != null)
{
var argList = new List <ArgumentSyntax>();
for (int i = 0; i < initparams.Parameters.Count; i++)
{
var par = initparams.Parameters[i];
argList.Add(MakeArgument(GenerateSimpleName(par.Identifier.Text)));
}
ArgumentListSyntax args = MakeArgumentList(argList.ToArray());
if (existingctor != null)
{
stmts.AddRange(existingctor.Body.Statements.Nodes);
var body = MakeBlock(stmts);
ctor = existingctor.Update(existingctor.AttributeLists, existingctor.Modifiers, existingctor.Identifier,
existingctor.ParameterList, existingctor.Initializer, body, existingctor.ExpressionBody, existingctor.SemicolonToken);
}
else
{
var chain = _syntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer,
SyntaxFactory.MakeToken(SyntaxKind.ColonToken),
SyntaxFactory.MakeToken(SyntaxKind.BaseKeyword),
args
);
var mods = TokenList(SyntaxKind.PublicKeyword);
var id = context.Id.Get <SyntaxToken>();
GenerateAttributeList(attributeLists, SystemQualifiedNames.CompilerGenerated);
var body = MakeBlock(stmts);
ctor = _syntaxFactory.ConstructorDeclaration(attributeLists, mods, id, initparams, chain, body, null, null);
}
}
_pool.Free(attributeLists);
return(ctor);
}
public override void ExitFoxmethod([NotNull] XP.FoxmethodContext context)
{
context.SetSequencePoint(context.T.Start, context.end.Stop);
var idName = context.Id.Get <SyntaxToken>();
var mods = context.Modifiers?.GetList <SyntaxToken>() ?? DefaultMethodModifiers(false, false, context.TypeParameters != null);
var isExtern = mods.Any((int)SyntaxKind.ExternKeyword);
var isAbstract = mods.Any((int)SyntaxKind.AbstractKeyword);
var hasNoBody = isExtern || isAbstract;
var mName = idName.Text;
if (mName.EndsWith("_ACCESS", StringComparison.OrdinalIgnoreCase))
{
mName = mName.Substring(0, mName.Length - "_ACCESS".Length);
}
else if (mName.EndsWith("_ASSIGN", StringComparison.OrdinalIgnoreCase))
{
mName = mName.Substring(0, mName.Length - "_ASSIGN".Length);
}
idName = SyntaxFactory.MakeIdentifier(mName);
bool isAccessAssign = this.isAccessAssign(context.RealType);
var attributes = context.Attributes?.GetList <AttributeListSyntax>() ?? EmptyList <AttributeListSyntax>();
bool hasExtensionAttribute = false;
if (isAccessAssign)
{
var vomods = _pool.Allocate();
vomods.Add(SyntaxFactory.MakeToken(SyntaxKind.PrivateKeyword));
if (mods.Any((int)SyntaxKind.StaticKeyword))
{
vomods.Add(SyntaxFactory.MakeToken(SyntaxKind.StaticKeyword));
}
if (mods.Any((int)SyntaxKind.UnsafeKeyword))
{
vomods.Add(SyntaxFactory.MakeToken(SyntaxKind.UnsafeKeyword));
}
mods = vomods.ToList <SyntaxToken>();
_pool.Free(vomods);
}
if (!isExtern)
{
isExtern = hasDllImport(attributes);
hasNoBody = hasNoBody || isExtern;
}
if (isExtern && !mods.Any((int)SyntaxKind.ExternKeyword))
{
// Add Extern Keyword to modifiers
var m1 = _pool.Allocate();
m1.AddRange(mods);
if (!m1.Any((int)SyntaxKind.ExternKeyword))
{
m1.Add(SyntaxFactory.MakeToken(SyntaxKind.ExternKeyword));
}
mods = m1.ToList <SyntaxToken>();
_pool.Free(m1);
}
var parameters = context.ParamList?.Get <ParameterListSyntax>() ?? EmptyParameterList();
var body = hasNoBody ? null : context.StmtBlk.Get <BlockSyntax>();
var returntype = context.Type?.Get <TypeSyntax>();
if (returntype == null)
{
if (context.RealType == XP.ASSIGN)
{
returntype = VoidType();
}
else // method and access
{
returntype = _getMissingType();
returntype.XNode = context;
}
}
else
{
returntype.XVoDecl = true;
}
var oldbody = body;
ImplementClipperAndPSZ(context, ref attributes, ref parameters, ref body, ref returntype);
if (body != oldbody)
{
context.StmtBlk.Put(body);
}
if (context.RealType == XP.ASSIGN)
{
// Assign does not need a return.
// So do not add missing returns
returntype = VoidType();
}
else if (context.StmtBlk != null && !hasNoBody)
{
body = AddMissingReturnStatement(body, context.StmtBlk, returntype);
}
MemberDeclarationSyntax m = _syntaxFactory.MethodDeclaration(
attributeLists: attributes,
modifiers: mods,
returnType: returntype,
explicitInterfaceSpecifier: null,
identifier: idName,
typeParameterList: context.TypeParameters?.Get <TypeParameterListSyntax>(),
parameterList: parameters,
constraintClauses: MakeList <TypeParameterConstraintClauseSyntax>(context._ConstraintsClauses),
body: body,
expressionBody: null, // TODO: (grammar) expressionBody methods
semicolonToken: (!hasNoBody && context.StmtBlk != null) ? null : SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
if (hasExtensionAttribute)
{
m = m.WithAdditionalDiagnostics(new SyntaxDiagnosticInfo(ErrorCode.ERR_ExplicitExtension));
}
bool separateMethod = false;
context.Put(m);
if (isAccessAssign && !separateMethod)
{
if (context.Data.HasClipperCallingConvention && context.CallingConvention != null)
{
m = m.WithAdditionalDiagnostics(new SyntaxDiagnosticInfo(
ErrorCode.ERR_NoClipperCallingConventionForAccessAssign));
}
context.Put(m);
ClassEntities.Peek().AddVoPropertyAccessor(context, context.RealType, idName);
}
}
private PropertyDeclarationSyntax XppCreateProperty(XppDeclaredMethodInfo propDecl)
{
var propctxt = (XP.XpppropertyContext)propDecl.Declaration;
string propName = propDecl.Name;
string accName = propDecl.AccessMethod;
string assName = propDecl.AssignMethod;
if (accName != null && !propDecl.HasVarName)
{
accName = accName + XSharpSpecialNames.PropertySuffix;
}
if (assName != null && !propDecl.HasVarName)
{
assName = assName + XSharpSpecialNames.PropertySuffix;
}
var propType = propctxt.Type?.Get <TypeSyntax>();
if (propType == null)
{
propType = _getMissingType();
}
var method = propDecl.Entity as XP.XppmethodContext;
var accessors = _pool.Allocate <AccessorDeclarationSyntax>();
var modifiers = decodeXppMemberModifiers(propDecl.Visibility, false, method.Modifiers?._Tokens);
var attributes = EmptyList <AttributeListSyntax>();
if (method.Attributes != null && propctxt.Attributes == null)
{
attributes = method.Attributes.GetList <AttributeListSyntax>();
}
else if (method.Attributes == null && propctxt.Attributes != null)
{
attributes = propctxt.Attributes.GetList <AttributeListSyntax>();
}
#region Accessor
if (!String.IsNullOrEmpty(accName))
{
var methodCall = GenerateMethodCall(accName, true);
var block = MakeBlock(GenerateReturn(methodCall));
block.XGenerated = true;
var accessor = _syntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration,
EmptyList <AttributeListSyntax>(), EmptyList <SyntaxToken>(),
SyntaxFactory.MakeToken(SyntaxKind.GetKeyword),
block, null, SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
accessor.XNode = method;
accessors.Add(accessor);
}
#endregion
#region Assign
if (!String.IsNullOrEmpty(assName))
{
method = propDecl.SetEntity as XP.XppmethodContext;
var args = MakeArgumentList(MakeArgument(GenerateSimpleName("value")));
var methodCall = GenerateMethodCall(accName, args, true);
var stmt = GenerateExpressionStatement(methodCall);
var block = MakeBlock(stmt);
block.XGenerated = true;
var accessor = _syntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration,
EmptyList <AttributeListSyntax>(), EmptyList <SyntaxToken>(),
SyntaxFactory.MakeToken(SyntaxKind.SetKeyword),
block, null, SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
accessor.XNode = method;
accessors.Add(accessor);
}
#endregion
var accessorList = _syntaxFactory.AccessorList(SyntaxFactory.MakeToken(SyntaxKind.OpenBraceToken),
accessors, SyntaxFactory.MakeToken(SyntaxKind.CloseBraceToken));
var prop = _syntaxFactory.PropertyDeclaration(
attributes,
modifiers: modifiers,
type: propType,
explicitInterfaceSpecifier: null,
identifier: SyntaxFactory.MakeIdentifier(propName),
accessorList: accessorList,
expressionBody: null,
initializer: null,
semicolonToken: SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
_pool.Free(accessors);
return(prop);
}