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