public Class_definitionContext class_definition()
{
Class_definitionContext _localctx = new Class_definitionContext(Context, State);
EnterRule(_localctx, 0, RULE_class_definition);
try {
EnterOuterAlt(_localctx, 1);
{
State = 20; Match(VISIBILITY);
State = 21; Match(CLASS);
State = 22; Match(ID);
State = 23; Match(LEFT_BRACE);
State = 24; method();
State = 25; Match(RIGHT_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public void Exit_ClassDefinition(Class_definitionContext context)
{
if (_classAlreadyImplementsInterface)
{
return;
}
_interfaceDefinitionBuilder.Append("}");
}
public void Enter_ClassDefinition(Class_definitionContext context)
{
var id = context.identifier();
_currentClassName = _tokenStream.GetText(id.Start, id.Stop);
var classRuleAttr = ValidationRuleProvider <ClassNameValidationAttribute>(nameof(Enter_ClassDefinition)) as ClassNameValidationAttribute;
if (classRuleAttr != null)
{
var nameRuleError = classRuleAttr.Validate(_currentNamespace, _currentClassName, string.Empty, string.Empty, string.Empty);
if (nameRuleError != null)
{
_nameRuleErrorsList.Add(nameRuleError);
}
}
//var match = Regex.Match(_currentClassName, RegexConstants.PascalCaseClassMethodRegex);
//if (match.Length < _currentClassName.Length)
//{
// _nameRuleErrorsList.Add(new NameRuleError(NameRuleViolations.ClassNameRuleViolation, _currentNamespace, _currentClassName, string.Empty, string.Empty));
//}
var tpcc = context.type_parameter_constraints_clauses();
var tpl = context.type_parameter_list();
if (tpl != null)
{
var gen = _tokenStream.GetText(tpl.Start, tpl.Stop);
}
if (context.children.Count >= 4)
{
//Class has Implemented Interfaces
Class_baseContext interfaceImpl = (Class_baseContext)context.children.FirstOrDefault((x) => x.GetType() == typeof(Class_baseContext));
if (interfaceImpl?.Start?.Text == ":")
{
//This implements one or multiple interfaces
_classAlreadyImplementsInterface = true;
}
}
if (_classAlreadyImplementsInterface)
{
return;
}
//var parent = context.Parent as Common_member_declarationContext;
//var accessMod = ts.GetText(parent.Start, parent.Start);
var interfaceName = string.Format("{0}{1}", "I", _currentClassName);
var compiledInterfaceName = string.Format("public interface {0}", interfaceName);
_interfaceDefinitionBuilder.AppendLine();
_interfaceDefinitionBuilder.Append(compiledInterfaceName);
_interfaceDefinitionBuilder.AppendLine();
_interfaceDefinitionBuilder.Append("{");
}
private void ParseTypeDeclaration(Type_declarationContext node)
{
Class_definitionContext classContext = node.class_definition();
Interface_definitionContext interfaceContext = node.interface_definition();
Delegate_definitionContext delegateContext = node.delegate_definition();
Enum_definitionContext enumContext = node.enum_definition();
bool isClass = classContext != null;
bool isInterface = interfaceContext != null;
bool isDelegate = delegateContext != null;
bool isEnum = enumContext != null;
string type = "";
string name = "";
if (isClass)
{
type = "Class";
name = this.GetNodeName(classContext.identifier());
}
else if (isInterface)
{
type = "Interface";
name = this.GetNodeName(interfaceContext.identifier());
}
else if (isDelegate)
{
type = "Delegate";
name = this.GetNodeName(delegateContext.identifier());
}
else if (isEnum)
{
type = "Enum";
name = this.GetNodeName(enumContext.identifier());
}
if (!string.IsNullOrEmpty(name))
{
this.WriteLine();
this.WriteKeyValue(type, name);
}
if (isClass)
{
this.WriteBeginBrace();
this.ParseClassDeclaration(classContext);
this.WriteEndBrace();
}
else if (isInterface)
{
this.WriteBeginBrace();
this.ParseInterfaceDeclaration(interfaceContext);
this.WriteEndBrace();
}
}
private void ParseClassDeclaration(Class_definitionContext node)
{
var members = node.class_body().class_member_declarations().class_member_declaration();
foreach (var member in members)
{
Common_member_declarationContext child = member.GetRuleContext <Common_member_declarationContext>(0);
if (child is Common_member_declarationContext)
{
Common_member_declarationContext commonMemberContext = child as Common_member_declarationContext;
Event_declarationContext eventContext = commonMemberContext.event_declaration();
Typed_member_declarationContext typeMemberContext = commonMemberContext.typed_member_declaration();
Method_declarationContext methodContext = commonMemberContext.method_declaration();
string type = "";
string name = "";
if (eventContext != null)
{
type = "Event";
name = eventContext.variable_declarators().GetText();
}
if (typeMemberContext != null)
{
Field_declarationContext field = typeMemberContext.field_declaration();
Property_declarationContext property = typeMemberContext.property_declaration();
if (field != null)
{
type = "Field";
name = field.variable_declarators().GetText();
}
else if (property != null)
{
type = "Property";
name = property.member_name().GetText();
}
}
else if (methodContext != null)
{
type = "Method";
name = methodContext.method_member_name().GetText();
}
if (!string.IsNullOrEmpty(name))
{
this.WriteKeyValue(type, name);
}
}
}
}
/// <summary>
/// Define class scope and symbol
/// </summary>
/// <param name="context"></param>
public override void EnterClass_definition([NotNull] Class_definitionContext context)
{
var classIdentityContext = context.identifier();
ClassSymbol classSymbol = new ClassSymbol(classIdentityContext.GetText());
classSymbol.SetEnclosingScope(currentScope);
classSymbol.DefNode = context;
classIdentityContext.Symbol = classSymbol;
classIdentityContext.Scope = classSymbol;
Define(classSymbol);
linker[currentFileAnalysis].Add(classSymbol);
currentScope = classSymbol;
}
public override void ExitClass_definition([NotNull] Class_definitionContext context)
{
currentScope = currentScope.GetEnclosingScope();
}
