public override void LeaveCallableDefinition(CallableDefinition node) { MakeStaticIfNeeded(node); CantBeMarkedAbstract(node); CantBeMarkedTransient(node); CantBeMarkedPartial(node); }
override public void OnCallableDefinition(CallableDefinition node) { CompleteOmittedReturnType(node); CompleteOmittedParameterTypes(node); ClassDefinition cd = My<CallableTypeBuilder>.Instance.ForCallableDefinition(node); ReplaceCurrentNode(cd); }
public ClassDefinition ForCallableDefinition(CallableDefinition node) { ClassDefinition cd = CreateEmptyCallableDefinition(node.Name); cd.LexicalInfo = node.LexicalInfo; cd.GenericParameters = node.GenericParameters; cd.Members.Add(CreateInvokeMethod(node)); cd.Members.Add(CreateBeginInvokeMethod(node)); cd.Members.Add(CreateEndInvokeMethod(node)); return cd; }
private void CompleteOmittedParameterTypes(CallableDefinition node) { ParameterDeclarationCollection parameters = node.Parameters; if (parameters.Count == 0) return; foreach (ParameterDeclaration parameter in parameters) { if (parameter.Type != null) continue; parameter.Type = CodeBuilder.CreateTypeReference( parameter.IsParamArray ? TypeSystemServices.ObjectArrayType : TypeSystemServices.ObjectType); } }
public object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) { B.CallableDefinition cd = new B.CallableDefinition(GetLexicalInfo(delegateDeclaration)); cd.Name = delegateDeclaration.Name; ConvertAttributes(delegateDeclaration.Attributes, cd.Attributes); cd.Modifiers = ConvertModifier(delegateDeclaration, B.TypeMemberModifiers.Private); ConvertParameters(delegateDeclaration.Parameters, cd.Parameters); cd.ReturnType = ConvertTypeReference(delegateDeclaration.ReturnType); if (currentType != null) { currentType.Members.Add(cd); } else { module.Members.Add(cd); } return(cd); }
public override void OnCallableDefinition(CallableDefinition node) { if (null == node.ReturnType) { node.ReturnType = CodeBuilder.CreateTypeReference(TypeSystemServices.VoidType); } CompleteOmittedParameterType(node); ClassDefinition cd = TypeSystemServices.CreateCallableDefinition(node.Name); cd.LexicalInfo = node.LexicalInfo; cd.GenericParameters = node.GenericParameters; cd.Members.Add(CreateInvokeMethod(node)); cd.Members.Add(CreateBeginInvokeMethod(node)); cd.Members.Add(CreateEndInvokeMethod(node)); ReplaceCurrentNode(cd); }
override public object Clone() { CallableDefinition clone = (CallableDefinition)FormatterServices.GetUninitializedObject(typeof(CallableDefinition)); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._isSynthetic = _isSynthetic; clone._entity = _entity; if (_annotations != null) { clone._annotations = (Hashtable)_annotations.Clone(); } clone._modifiers = _modifiers; clone._name = _name; if (null != _attributes) { clone._attributes = _attributes.Clone() as AttributeCollection; clone._attributes.InitializeParent(clone); } if (null != _parameters) { clone._parameters = _parameters.Clone() as ParameterDeclarationCollection; clone._parameters.InitializeParent(clone); } if (null != _genericParameters) { clone._genericParameters = _genericParameters.Clone() as GenericParameterDeclarationCollection; clone._genericParameters.InitializeParent(clone); } if (null != _returnType) { clone._returnType = _returnType.Clone() as TypeReference; clone._returnType.InitializeParent(clone); } if (null != _returnTypeAttributes) { clone._returnTypeAttributes = _returnTypeAttributes.Clone() as AttributeCollection; clone._returnTypeAttributes.InitializeParent(clone); } return(clone); }
private void CompleteOmittedParameterType(CallableDefinition node) { ParameterDeclarationCollection parameters = node.Parameters; if (0 == parameters.Count) return; ParameterDeclaration last = parameters[-1]; foreach (ParameterDeclaration parameter in parameters) { if (null == parameter.Type) { if (parameters.VariableNumber && last == parameter) { parameter.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.ObjectArrayType); } else { parameter.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.ObjectType); } } } }
public override void OnCallableDefinition(AST.CallableDefinition node) { LoggingService.Debug("OnCallableDefinition: " + node.FullName); DomRegion region = GetRegion(node); DefaultClass c = new DefaultClass(_cu, ClassType.Delegate, GetModifier(node), region, OuterClass); ConvertAttributes(node, c); c.BaseTypes.Add(c.ProjectContent.SystemTypes.Delegate); c.FullyQualifiedName = node.FullName; if (_currentClass.Count > 0) { OuterClass.InnerClasses.Add(c); } else { _cu.Classes.Add(c); } _currentClass.Push(c); // necessary for CreateReturnType ConvertTemplates(node, c); IReturnType returnType = CreateReturnType(node.ReturnType); DefaultMethod invokeMethod = new DefaultMethod("Invoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); ConvertParameters(node.Parameters, invokeMethod); c.Methods.Add(invokeMethod); invokeMethod = new DefaultMethod("BeginInvoke", c.ProjectContent.SystemTypes.IAsyncResult, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); ConvertParameters(node.Parameters, invokeMethod); if (invokeMethod.Parameters == DefaultParameter.EmptyParameterList) { invokeMethod.Parameters = new List <IParameter>(); } invokeMethod.Parameters.Add(new DefaultParameter("callback", c.ProjectContent.SystemTypes.AsyncCallback, DomRegion.Empty)); invokeMethod.Parameters.Add(new DefaultParameter("object", c.ProjectContent.SystemTypes.Object, DomRegion.Empty)); c.Methods.Add(invokeMethod); invokeMethod = new DefaultMethod("EndInvoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); invokeMethod.Parameters.Add(new DefaultParameter("result", c.ProjectContent.SystemTypes.IAsyncResult, DomRegion.Empty)); c.Methods.Add(invokeMethod); _currentClass.Pop(); }
public override void OnCallableDefinition(CallableDefinition node) { NotImplemented(node, "Unexpected callable definition!"); }
public object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) { B.CallableDefinition cd = new B.CallableDefinition(GetLexicalInfo(delegateDeclaration)); cd.Name = delegateDeclaration.Name; ConvertAttributes(delegateDeclaration.Attributes, cd.Attributes); cd.Modifiers = ConvertModifier(delegateDeclaration, B.TypeMemberModifiers.Private); ConvertParameters(delegateDeclaration.Parameters, cd.Parameters); cd.ReturnType = ConvertTypeReference(delegateDeclaration.ReturnType); if (currentType != null) currentType.Members.Add(cd); else module.Members.Add(cd); return cd; }
Method CreateBeginInvokeMethod(CallableDefinition node) { Method method = CreateRuntimeMethod("BeginInvoke", CodeBuilder.CreateTypeReference(node.LexicalInfo, typeof(IAsyncResult))); method.Parameters.ExtendWithClones(node.Parameters); method.Parameters.Add( new ParameterDeclaration("callback", CodeBuilder.CreateTypeReference(node.LexicalInfo, typeof(AsyncCallback)))); method.Parameters.Add( new ParameterDeclaration("asyncState", CodeBuilder.CreateTypeReference(node.LexicalInfo, TypeSystemServices.ObjectType))); return method; }
Method CreateInvokeMethod(CallableDefinition node) { Method method = CreateRuntimeMethod("Invoke", node.ReturnType); method.Parameters = node.Parameters; return method; }
Method CreateEndInvokeMethod(CallableDefinition node) { Method method = CreateRuntimeMethod("EndInvoke", node.ReturnType); foreach (ParameterDeclaration p in node.Parameters) if (p.IsByRef) method.Parameters.Add(p.CloneNode()); method.Parameters.Add( new ParameterDeclaration("asyncResult", CodeBuilder.CreateTypeReference(node.LexicalInfo, typeof(IAsyncResult)))); return method; }
public override void OnCallableDefinition(CallableDefinition node) { WriteCallableDefinitionHeader("callable ", node); }
protected void callable_definition( TypeMemberCollection container ) //throws RecognitionException, TokenStreamException { IToken id = null; CallableDefinition cd = null; TypeReference returnType = null; GenericParameterDeclarationCollection genericParameters = null; try { // for error handling match(CALLABLE); id = LT(1); match(ID); if (0==inputState.guessing) { cd = new CallableDefinition(ToLexicalInfo(id)); cd.Name = id.getText(); cd.Modifiers = _modifiers; AddAttributes(cd.Attributes); container.Add(cd); genericParameters = cd.GenericParameters; } { switch ( LA(1) ) { case LBRACK: { match(LBRACK); { switch ( LA(1) ) { case OF: { match(OF); break; } case ID: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } generic_parameter_declaration_list(genericParameters); match(RBRACK); break; } case LPAREN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } match(LPAREN); parameter_declaration_list(cd.Parameters); match(RPAREN); { switch ( LA(1) ) { case AS: { match(AS); returnType=type_reference(); if (0==inputState.guessing) { cd.ReturnType=returnType; } break; } case EOL: case EOS: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } eos(); docstring(cd); } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "callable_definition"); recover(ex,tokenSet_22_); } else { throw ex; } } }
private void CompleteOmittedReturnType(CallableDefinition node) { if (node.ReturnType == null) node.ReturnType = CodeBuilder.CreateTypeReference(TypeSystemServices.VoidType); }
public override void OnCallableDefinition(CallableDefinition node) { }
override public object Clone() { CallableDefinition clone = new CallableDefinition(); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._isSynthetic = _isSynthetic; clone._entity = _entity; if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone(); clone._modifiers = _modifiers; clone._name = _name; if (null != _attributes) { clone._attributes = _attributes.Clone() as AttributeCollection; clone._attributes.InitializeParent(clone); } if (null != _parameters) { clone._parameters = _parameters.Clone() as ParameterDeclarationCollection; clone._parameters.InitializeParent(clone); } if (null != _genericParameters) { clone._genericParameters = _genericParameters.Clone() as GenericParameterDeclarationCollection; clone._genericParameters.InitializeParent(clone); } if (null != _returnType) { clone._returnType = _returnType.Clone() as TypeReference; clone._returnType.InitializeParent(clone); } if (null != _returnTypeAttributes) { clone._returnTypeAttributes = _returnTypeAttributes.Clone() as AttributeCollection; clone._returnTypeAttributes.InitializeParent(clone); } return clone; }
void WriteCallableDefinitionHeader(string keyword, CallableDefinition node) { WriteAttributes(node.Attributes, true); WriteOptionalModifiers(node); WriteKeyword(keyword); IExplicitMember em = node as IExplicitMember; if (null != em) { Visit(em.ExplicitInfo); } Write(node.Name); if (node.GenericParameters.Count > 0) { WriteGenericParameterList(node.GenericParameters); } WriteParameterList(node.Parameters); if (node.ReturnTypeAttributes.Count > 0) { Write(" "); WriteAttributes(node.ReturnTypeAttributes, false); } WriteTypeReference(node.ReturnType); }