internal void IncludeCompilationUnitUsingClauses() { CompilationUnitNode compilationUnit = (CompilationUnitNode)parent; if (compilationUnit.UsingClauses.Count != 0) { ParseNodeList mergedUsings = new ParseNodeList(); mergedUsings.Append(compilationUnit.UsingClauses); if (_usingClauses.Count != 0) { mergedUsings.Append(_usingClauses); } _usingClauses = GetParentedNodeList(mergedUsings); } }
internal override void MergePartialType(CustomTypeNode partialTypeNode) { base.MergePartialType(partialTypeNode); if (partialTypeNode._baseTypes.Count > 0) { _baseTypes.Append(GetParentedNodeList(partialTypeNode._baseTypes)); } }
public static ParseNodeList GetAttributeList(ParseNodeList attributeBlocks) { if ((attributeBlocks == null) || (attributeBlocks.Count == 0)) { return attributeBlocks; } ParseNodeList attributes = new ParseNodeList(); foreach (AttributeBlockNode attributeBlock in attributeBlocks) { ParseNodeList localAttributes = attributeBlock.Attributes; if (localAttributes.Count != 0) { attributes.Append(localAttributes); } } return attributes; }
private void BuildCodeModel() { _compilationUnitList = new ParseNodeList(); CodeModelBuilder codeModelBuilder = new CodeModelBuilder(_options, this); CodeModelValidator codeModelValidator = new CodeModelValidator(this); CodeModelProcessor validationProcessor = new CodeModelProcessor(codeModelValidator, _options); foreach (IStreamSource source in _options.Sources) { CompilationUnitNode compilationUnit = codeModelBuilder.BuildCodeModel(source); if (compilationUnit != null) { validationProcessor.Process(compilationUnit); _compilationUnitList.Append(compilationUnit); } } }
private ParseNodeList GetNamespaces(ParseNodeList members) { ParseNodeList namespaceList = new ParseNodeList(); foreach (ParseNode memberNode in members) { NamespaceNode namespaceNode = memberNode as NamespaceNode; if (namespaceNode == null) { // Top-level type nodes are turned into children of a namespace with // an empty name. Token nsToken = new Token(TokenType.Namespace, memberNode.Token.SourcePath, memberNode.Token.Position); namespaceNode = new NamespaceNode(nsToken, String.Empty, _usingClauses, new ParseNodeList(memberNode)); } namespaceList.Append(namespaceNode); } return namespaceList; }
public static ParseNodeList GetAttributeList(ParseNodeList attributeBlocks) { if ((attributeBlocks == null) || (attributeBlocks.Count == 0)) { return(attributeBlocks); } ParseNodeList attributes = new ParseNodeList(); foreach (AttributeBlockNode attributeBlock in attributeBlocks) { ParseNodeList localAttributes = attributeBlock.Attributes; if (localAttributes.Count != 0) { attributes.Append(localAttributes); } } return(attributes); }
private ParseNodeList GetNamespaces(ParseNodeList members) { ParseNodeList namespaceList = new ParseNodeList(); foreach (ParseNode memberNode in members) { NamespaceNode namespaceNode = memberNode as NamespaceNode; if (namespaceNode == null) { // Top-level type nodes are turned into children of a namespace with // an empty name. Token nsToken = new Token(TokenType.Namespace, memberNode.Token.SourcePath, memberNode.Token.Position); namespaceNode = new NamespaceNode(nsToken, String.Empty, _usingClauses, new ParseNodeList(memberNode)); } namespaceList.Append(namespaceNode); } return(namespaceList); }
internal virtual void MergePartialType(CustomTypeNode partialTypeNode) { Debug.Assert(Name == partialTypeNode.Name); if (partialTypeNode._attributes.Count > 0) { _attributes.Append(GetParentedNodeList(partialTypeNode._attributes)); } if ((partialTypeNode.Modifiers & Modifiers.PartialModifiers) != 0) { _modifiers |= (partialTypeNode.Modifiers & Modifiers.PartialModifiers); } if (partialTypeNode._typeParameters.Count > 0) { _typeParameters.Append(GetParentedNodeList(partialTypeNode._typeParameters)); } if (partialTypeNode._constraintClauses.Count > 0) { _constraintClauses.Append(GetParentedNodeList(partialTypeNode._constraintClauses)); } }
private ParseNodeList ParseClassOrStructMembers() { ParseNodeList list = new ParseNodeList(); TokenType type = PeekType(); while (type != TokenType.CloseCurly && type != TokenType.EOF) { int mark = Mark(); list.Append(ParseClassOrStructMember()); if (mark == Mark()) { // didn't consume any tokens! // ensure we make some progress NextToken(); } type = PeekType(); } return list; }
private ParseNode ParseAttributeBlock() { Token token = Eat(TokenType.OpenSquare); AttributeTargets location; if (PeekType() <= TokenType.Identifier && PeekType(1) == TokenType.Colon) { location = CheckAttributeTargets(NextToken()); Eat(TokenType.Colon); } else { location = 0; } ParseNodeList list = new ParseNodeList(); do { list.Append(ParseAttribute()); } while ((null != EatOpt(TokenType.Comma)) && (PeekType() != TokenType.CloseSquare)); Eat(TokenType.CloseSquare); return new AttributeBlockNode( token, location, list); }
private ParseNodeList ParseAttributes() { ParseNodeList list = new ParseNodeList(); while (PeekType() == TokenType.OpenSquare) { list.Append(ParseAttributeBlock()); } return list; }
private TryNode ParseTry() { Token token = Eat(TokenType.Try); ParseNode body = ParseBlock(); ParseNodeList catchClauses = new ParseNodeList(); while (PeekType() == TokenType.Catch) { Token catchToken = Eat(TokenType.Catch); ParseNode type; AtomicNameNode name; if (PeekType() == TokenType.OpenParen) { Eat(TokenType.OpenParen); type = ParseType(); if (PeekType() == TokenType.Identifier) { name = ParseIdentifier(); } else { name = null; } Eat(TokenType.CloseParen); } else { type = null; name = null; } catchClauses.Append(new CatchNode( catchToken, type, name, ParseBlock())); } ParseNode finallyClause; if (PeekType() == TokenType.Finally) { Eat(TokenType.Finally); finallyClause = ParseBlock(); } else { finallyClause = null; } return new TryNode( token, body, catchClauses, finallyClause); }
private ParseNodeList ParseFieldInitializers(bool isFixed) { ParseNodeList list = new ParseNodeList(); do { if (!isFixed) list.Append(new VariableInitializerNode(ParseIdentifier(), ParseVariableInitializer())); else list.Append(new VariableInitializerNode(ParseIdentifier(), ParseFixedArrayDimension())); } while (EatOpt(TokenType.Comma) != null); return list; }
private BlockStatementNode ParseBlock() { Token token = PeekToken(); ParseNodeList statements = new ParseNodeList(); Eat(TokenType.OpenCurly); TokenType type = PeekType(); while (type != TokenType.CloseCurly && type != TokenType.EOF) { int mark = Mark(); statements.Append(ParseStatement()); // ensure we make progress in an error case if (mark == Mark()) { NextToken(); } type = PeekType(); } Eat(TokenType.CloseCurly); return new BlockStatementNode(token, statements); }
// namespace-or-type-name private NameNode ParseNamespaceOrTypeName() { Token token = PeekToken(); NameNode name = ParseAliasQualifiedName(false); if ((PeekType() == TokenType.Dot || PeekType() == TokenType.ColonColon) && PeekType(1) == TokenType.Identifier) { ParseNodeList list = new ParseNodeList(name); do { EatDotOrColonColon(); list.Append(ParseSimpleName(false)); } while (PeekType() == TokenType.Dot && PeekType(1) == TokenType.Identifier); return new MultiPartNameNode(token, list); } else { return name; } }
private ParseNodeList ParseExternAliases() { ParseNodeList list = new ParseNodeList(); Token token; while (null != (token = EatOpt(TokenType.Extern))) { EatContextualKeyword(aliasName); list.Append( new ExternAliasNode( token, ParseIdentifier())); Eat(TokenType.Semicolon); } return list; }
private ParseNodeList ParseTypeArgumentList() { ParseNodeList returnValue = new ParseNodeList(); Eat(TokenType.OpenAngle); do { returnValue.Append(ParseType()); } while (null != EatOpt(TokenType.Comma)); Eat(TokenType.CloseAngle); return returnValue; }
// qualified-name private NameNode ParseMultiPartName() { Token token = PeekToken(); NameNode name = ParseIdentifier(); if (PeekType() == TokenType.Dot && PeekType(1) == TokenType.Identifier) { ParseNodeList list = new ParseNodeList(name); do { Eat(TokenType.Dot); list.Append(ParseIdentifier()); } while (PeekType() == TokenType.Dot && PeekType(1) == TokenType.Identifier); return new MultiPartNameNode(token, list); } else { return name; } }
private ExpressionListNode ParseParenArgumentList() { Token token = PeekToken(); Eat(TokenType.OpenParen); ParseNodeList list = new ParseNodeList(); while (PeekType() != TokenType.CloseParen) { list.Append(ParseArgument()); if (null == EatOpt(TokenType.Comma)) { break; } } Eat(TokenType.CloseParen); return new ExpressionListNode(token, list); }
private ArrayInitializerNode ParseArrayInitializer() { Token token = Eat(TokenType.OpenCurly); ParseNodeList list = new ParseNodeList(); while (PeekType() != TokenType.CloseCurly && PeekType() != TokenType.EOF) { if (PeekType() == TokenType.OpenCurly) { list.Append(ParseArrayInitializer()); } else { list.Append(ParseExpression()); } if (null == EatOpt(TokenType.Comma)) { break; } } Eat(TokenType.CloseCurly); return new ArrayInitializerNode(token, list); }
// using-directives private ParseNodeList ParseUsingClauses() { ParseNodeList list = new ParseNodeList(); while (PeekType() == TokenType.Using) { Token token = Eat(TokenType.Using); if (PeekType() == TokenType.Identifier && PeekType(1) == TokenType.Equal) { // using-alias-directive AtomicNameNode name = ParseIdentifier(); Eat(TokenType.Equal); list.Append( new UsingAliasNode( token, name, ParseNamespaceOrTypeName())); } else { // using-namespace-directive list.Append( new UsingNamespaceNode( token, ParseNamespaceOrTypeName())); } Eat(TokenType.Semicolon); } return list; }
// this // type-name.this // methodName ( // methodName<T> ( // typename.methodName ( // propertyName { // typename.propertyName { // typename.methodName<[Attr]T> ( // fieldName private ScanMemberNameKind ParseMemberName(out NameNode interfaceType) { if (PeekType() == TokenType.Operator) { interfaceType = null; return ScanMemberNameKind.Operator; } Token token = PeekToken(); ParseNodeList list = new ParseNodeList(); if (PeekType() == TokenType.Identifier && PeekType(1) == TokenType.ColonColon) { interfaceType = ParseAliasQualifiedName(false); list.Append(interfaceType); EatDotOrColonColon(); } else { interfaceType = null; } ScanMemberNameKind result = ScanMemberNameKind.Invalid; do { if (PeekType() == TokenType.This) result = ScanMemberNameKind.Indexer; else if (PeekType() != TokenType.Identifier) result = ScanMemberNameKind.Field; else { switch (PeekType(1)) { case TokenType.OpenCurly: result = ScanMemberNameKind.Property; break; case TokenType.OpenParen: result = ScanMemberNameKind.Method; break; case TokenType.OpenAngle: int mark = Mark(); NextToken(); // _id TypeArgumentListScan scan = ScanTypeArgumentListOpt(); if (scan == TypeArgumentListScan.MayBeTypeArgumentList) { switch (PeekType()) { case TokenType.Dot: case TokenType.ColonColon: scan = TypeArgumentListScan.MustBeTypeArgumentList; break; default: scan = TypeArgumentListScan.TypeParameterList; break; } } Rewind(mark); if (scan == TypeArgumentListScan.TypeParameterList || scan == TypeArgumentListScan.NotTypeArgumentList) { result = ScanMemberNameKind.Method; break; } list.Append(ParseSimpleName(false)); EatDotOrColonColon(); break; case TokenType.ColonColon: case TokenType.Dot: list.Append(ParseSimpleName(false)); EatDotOrColonColon(); break; default: result = ScanMemberNameKind.Field; break; } } } while (ScanMemberNameKind.Invalid == result); if (list.Count > 1) interfaceType = new MultiPartNameNode(token, list); return result; }
private ParseNodeList ParseTypeParametersOpt() { ParseNodeList returnValue = new ParseNodeList(); if (PeekType() == TokenType.OpenAngle) { Eat(TokenType.OpenAngle); do { returnValue.Append(ParseTypeParameter()); } while (null != EatOpt(TokenType.Comma)); Eat(TokenType.CloseAngle); } return returnValue; }
private SwitchNode ParseSwitch() { Token token = Eat(TokenType.Switch); ParseNode condition = ParseParenExpression(); ParseNodeList cases = new ParseNodeList(); Eat(TokenType.OpenCurly); TokenType type = PeekType(); while (type != TokenType.CloseCurly && type != TokenType.EOF) { Token sectionToken = PeekToken(); // parse case labels ParseNodeList labels = new ParseNodeList(); ParseNode label; while ((label = ParseSwitchLabel()) != null) { Eat(TokenType.Colon); labels.Append(label); } if (labels.Count == 0) { ReportError(ParseError.CaseOrDefaultExpected); } // parse statements ParseNodeList statements = new ParseNodeList(); type = PeekType(); while (type != TokenType.Case && type != TokenType.Default && type != TokenType.CloseCurly && type != TokenType.EOF) { int mark = Mark(); statements.Append(ParseStatement()); // ensure we make progress in an error case if (mark == Mark()) { NextToken(); } type = PeekType(); } if (statements.Count == 0) { ReportError(ParseError.StatementExpected); } cases.Append(new SwitchSectionNode( sectionToken, labels, statements)); } Eat(TokenType.CloseCurly); return new SwitchNode(token, condition, cases); }
private TypeParameterConstraintNode ParseConstraintClause() { EatWhere(); AtomicNameNode name = ParseIdentifier(); Eat(TokenType.Colon); bool hasConstructorConstraint = false; ParseNodeList typeConstraints = new ParseNodeList(); do { if (PeekType() == TokenType.New) { if (hasConstructorConstraint) ReportError(ParseError.DuplicateConstructorConstraint); hasConstructorConstraint = true; Eat(TokenType.New); Eat(TokenType.OpenParen); Eat(TokenType.CloseParen); } else { if (hasConstructorConstraint) ReportError(ParseError.ConstructorConstraintMustBeLast); typeConstraints.Append(ParseNamespaceOrTypeName()); } } while (null != EatOpt(TokenType.Comma)); return new TypeParameterConstraintNode(name, typeConstraints, hasConstructorConstraint); }
private ParseNodeList ParseFormalParameterList(TokenType endType, bool allowAttributes) { ParseNodeList list = new ParseNodeList(); if (PeekType() != endType) { ParameterNode lastParam; do { lastParam = ParseFormalParameter(allowAttributes); list.Append(lastParam); } while (null != EatOpt(TokenType.Comma) && lastParam.Flags != ParameterFlags.Params); } return list; }
private ParseNodeList ParseConstraintClauses() { ParseNodeList returnValue = new ParseNodeList(); while (PeekWhere()) { returnValue.Append(ParseConstraintClause()); } return returnValue; }
private ParseNodeList ParseEnumMembers() { ParseNodeList list = new ParseNodeList(); while (PeekType() == TokenType.Identifier || PeekType() == TokenType.OpenSquare) { list.Append(ParseEnumerationField()); if (null == EatOpt(TokenType.Comma)) { break; } } return list; }
private ParseNodeList ParseGlobalAttributes() { ParseNodeList list = new ParseNodeList(); while (PeekType() == TokenType.OpenSquare && PeekType(1) == TokenType.Identifier && PeekType(2) == TokenType.Colon && (((IdentifierToken)PeekToken(1)).Symbol == assemblyName || ((IdentifierToken)PeekToken(1)).Symbol == moduleName)) { list.Append(ParseAttributeBlock()); } return list; }
// namespace-member-declarations private ParseNodeList ParseNamespaceMembers() { ParseNodeList list = new ParseNodeList(); while (true) { TokenType type = PeekType(); switch (type) { case TokenType.Namespace: list.Append(ParseNamespace()); break; case TokenType.Class: case TokenType.Interface: case TokenType.Enum: case TokenType.Delegate: case TokenType.Struct: case TokenType.Abstract: case TokenType.Sealed: case TokenType.Public: case TokenType.Internal: case TokenType.Private: case TokenType.Protected: case TokenType.New: case TokenType.Virtual: case TokenType.Static: case TokenType.Readonly: case TokenType.Extern: case TokenType.Override: case TokenType.Unsafe: case TokenType.OpenSquare: list.Append(ParseTypeDeclaration()); break; case TokenType.Identifier: if (PeekPartial()) goto case TokenType.Class; goto default; default: return list; } } }
private ExpressionListNode ParseExpressionList(TokenType terminator) { Token token = PeekToken(); ParseNodeList list = new ParseNodeList(); if (PeekType() != terminator) { do { list.Append(ParseExpression()); } while (null != EatOpt(TokenType.Comma)); } return new ExpressionListNode(token, list); }