public virtual object VisitOperatorDeclaration(OperatorNode operatorDeclaration, object data) { stackMap.Push(operatorDeclaration); operatorDeclaration.Attributes.AcceptVisitor(this, data); if (operatorDeclaration.Param1 != null) { operatorDeclaration.Param1.AcceptVisitor(this, data); } if (operatorDeclaration.Param2 != null) { operatorDeclaration.Param2.AcceptVisitor(this, data); } operatorDeclaration.Type.AcceptVisitor(this, data); operatorDeclaration.Statements.AcceptVisitor(this, data); stackMap.Pop(); return(null); }
private void ParseOperatorDecl(IType type) { OperatorNode node; //we check the return type of the method. // -> it determines if the method is an iterator. if ( type != null //implicit/explicit operator && type is TypeNode && iteratorsClass.Contains(((TypeNode)type).GenericIndependentIdentifier)) { node = new OperatorNode(true, curtok); curIterator = node; } else { node = new OperatorNode(false, curtok); } curOperator = node; if (curAttributes.Count > 0) { node.Attributes = curAttributes; curAttributes = new NodeCollection<AttributeNode>(); } uint mask = ~(uint)Modifier.OperatorMods; if (((uint)curmods & mask) != (uint)Modifier.Empty) ReportError("operator declaration contains illegal modifiers"); node.Modifiers = curmods; curmods = Modifier.Empty; if ((node.Modifiers & Modifier.Unsafe) != Modifier.Empty) { //unsafe modifier -> unsafe type. isUnsafe++; node.IsUnsafeDeclared = true; } //the operator is declared in an unsafe type ? node.IsUnsafe = isUnsafe > 0; ClassNode cl = typeStack.Peek(); cl.Operators.Add(node); CheckStaticClass(cl, node.Modifiers, true); if (type == null && curtok.ID == TokenID.Explicit) { Advance(); node.IsExplicit = true; AssertAndAdvance(TokenID.Operator); type = ParseType(); } else if (type == null && curtok.ID == TokenID.Implicit) { Advance(); node.IsImplicit = true; AssertAndAdvance(TokenID.Operator); type = ParseType(); } else { AssertAndAdvance(TokenID.Operator); node.Operator = curtok.ID; Advance(); } node.Type = type; NodeCollection<ParamDeclNode> paramList = ParseParamList(); if (paramList.Count == 0 || paramList.Count > 2) { ReportError("Operator declarations must only have one or two parameters."); } node.Param1 = paramList[0]; if (paramList.Count == 2) { node.Param2 = paramList[1]; } ParseBlock(node.Statements); if (node.IsIterator) { if ((node.Param1.Modifiers & (Modifier.Ref | Modifier.Out)) != Modifier.Empty) { ReportError("Iterators can not have nor 'ref' nor 'out' parameter."); } if ((node.Param2.Modifiers & (Modifier.Ref | Modifier.Out)) != Modifier.Empty) { ReportError("Iterators can not have nor 'ref' nor 'out' parameter."); } } curIterator = null; curOperator = null; if ((node.Modifiers & Modifier.Unsafe) != Modifier.Empty) { //unsafe modifier -> unsafe type. isUnsafe--; } // Doubt this will be in use. if (node.IsImplicit) this.nameTable.AddIdentifier(new OperatorName(TokenID.Implicit, this.currentContext)); else if (node.IsExplicit) this.nameTable.AddIdentifier(new OperatorName(TokenID.Explicit, this.currentContext)); else this.nameTable.AddIdentifier(new OperatorName(node.Operator, this.currentContext)); }
public virtual object VisitOperatorDeclaration(OperatorNode operatorDeclaration, object data) { stackMap.Push(operatorDeclaration); operatorDeclaration.Attributes.AcceptVisitor(this, data); if (operatorDeclaration.Param1 != null) { operatorDeclaration.Param1.AcceptVisitor(this, data); } if (operatorDeclaration.Param2 != null) { operatorDeclaration.Param2.AcceptVisitor(this, data); } operatorDeclaration.Type.AcceptVisitor(this, data); operatorDeclaration.Statements.AcceptVisitor(this, data); stackMap.Pop(); return null; }