コード例 #1
0
 public ClassDeclarationAst(QualifierListAst qualifierList, IdentifierToken className, IdentifierToken superClass, ReadOnlyCollection <IClassFeatureAst> classFeatures)
 {
     this.QualifierList = qualifierList ?? new QualifierListAst.Builder().Build();
     this.ClassName     = className ?? throw new ArgumentNullException(nameof(className));
     this.SuperClass    = superClass;
     this.ClassFeatures = classFeatures ?? new ReadOnlyCollection <IClassFeatureAst>(new List <IClassFeatureAst>());
 }
コード例 #2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        /// <remarks>
        ///
        /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf
        /// A.12 Parameter declaration
        ///
        ///     parameterDeclaration = [ qualifierList ] ( primitiveParamDeclaration /
        ///                            complexParamDeclaration /
        ///                            enumParamDeclaration /
        ///                            referenceParamDeclaration )
        ///
        ///     primitiveParamDeclaration = primitiveType parameterName [ array ]
        ///                                 [ "=" primitiveTypeValue ]
        ///     complexParamDeclaration   = structureOrClassName parameterName [ array ]
        ///                                 [ "=" ( complexTypeValue / aliasIdentifier ) ]
        ///     enumParamDeclaration      = enumName parameterName [ array ]
        ///                                 [ "=" enumValue ]
        ///     referenceParamDeclaration = classReference parameterName [ array ]
        ///                                 [ "=" referenceTypeValue ]
        ///
        ///     parameterName = IDENTIFIER
        ///
        /// </remarks>
        internal static ParameterDeclarationAst Parse(ParserStream stream)
        {
            var parameter  = new ParameterDeclarationAst();
            var qualifiers = default(QualifierListAst);

            if (stream.Peek <AttributeOpenToken>() != null)
            {
                qualifiers = QualifierListAst.Parse(stream);
            }
            parameter.Qualifiers = qualifiers;
            parameter.Type       = stream.Read <IdentifierToken>();
            if (stream.PeekIdentifier(Keywords.REF))
            {
                stream.ReadIdentifier(Keywords.REF);
                parameter.IsRef = true;
            }
            else
            {
                parameter.IsRef = false;
            }
            parameter.Name = stream.Read <IdentifierToken>();
            if (stream.Peek <AttributeOpenToken>() != null)
            {
                stream.Read <AttributeOpenToken>();
                stream.Read <AttributeCloseToken>();
                parameter.IsArray = true;
            }
            if (stream.Peek <EqualsOperatorToken>() != null)
            {
                stream.Read <EqualsOperatorToken>();
                parameter.DefaultValue = ClassFeatureAst.ReadDefaultValue(stream, parameter.Type);
            }
            return(parameter);
        }
コード例 #3
0
 public StructureDeclarationAst(QualifierListAst qualifierList, IdentifierToken structureName, IdentifierToken superStructure, ReadOnlyCollection <IStructureFeatureAst> structureFeatures)
 {
     this.QualifierList     = qualifierList ?? new QualifierListAst.Builder().Build();
     this.StructureName     = structureName ?? throw new ArgumentNullException(nameof(structureName));
     this.SuperStructure    = superStructure;
     this.StructureFeatures = structureFeatures ?? new ReadOnlyCollection <IStructureFeatureAst>(new List <IStructureFeatureAst>());
 }
コード例 #4
0
        /// <summary>
        /// </summary>
        /// <returns></returns>
        /// <remarks>
        ///
        /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf
        /// A.14 Complex type value
        ///
        ///     complexTypeValue  = complexValue / complexValueArray
        ///
        /// </remarks>
        internal static ComplexTypeValueAst Parse(ParserStream stream, QualifierListAst qualifiers)
        {
            var node = default(ComplexTypeValueAst);

            var peek = stream.Peek();

            if (peek is BlockOpenToken)
            {
                // complexValueArray
                node = ComplexValueArrayAst.Parse(stream);
            }
            else if (peek is IdentifierToken)
            {
                // complexValue
                node = ComplexValueAst.Parse(stream);
            }
            else
            {
                throw new UnexpectedTokenException(peek);
            }

            node.Qualifiers = qualifiers;

            return(node);
        }
コード例 #5
0
 public EnumerationDeclarationAst(QualifierListAst qualifierList, IdentifierToken enumName, IdentifierToken enumType, ReadOnlyCollection <EnumElementAst> enumElements)
 {
     this.QualifierList = qualifierList ?? new QualifierListAst.Builder().Build();
     this.EnumName      = enumName ?? throw new ArgumentNullException(nameof(enumName));
     this.EnumType      = enumType ?? throw new ArgumentNullException(nameof(enumType));
     this.EnumElements  = enumElements ?? new ReadOnlyCollection <EnumElementAst>(
         new List <EnumElementAst>()
         );
 }
コード例 #6
0
        /// <summary>
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        /// <remarks>
        /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0.pdf
        /// Section A.2 - MOF specification
        ///
        ///     mofProduction = compilerDirective /
        ///                     structureDeclaration /
        ///                     classDeclaration /
        ///                     associationDeclaration /
        ///                     enumerationDeclaration /
        ///                     instanceDeclaration /
        ///                     qualifierDeclaration
        ///
        /// </remarks>
        internal static MofProductionAst Parse(ParserStream stream)
        {
            var peek = stream.Peek();

            // compilerDirective
            var pragma = peek as PragmaToken;

            if (pragma != null)
            {
                return(CompilerDirectiveAst.Parse(stream));
            }

            // all other mofProduction structures can start with an optional qualifierList
            var qualifiers = default(QualifierListAst);

            if (peek is AttributeOpenToken)
            {
                qualifiers = QualifierListAst.Parse(stream);
            }

            var identifier = stream.Peek <IdentifierToken>();

            switch (identifier.GetNormalizedName())
            {
            case Keywords.STRUCTURE:
                // structureDeclaration
                throw new UnsupportedTokenException(identifier);

            case Keywords.CLASS:
                // classDeclaration
                var @class = ClassDeclarationAst.Parse(stream, qualifiers);
                return(@class);

            case Keywords.ASSOCIATION:
                // associationDeclaration
                throw new UnsupportedTokenException(identifier);

            case Keywords.ENUMERATION:
                // enumerationDeclaration
                throw new UnsupportedTokenException(identifier);

            case Keywords.INSTANCE:
            case Keywords.VALUE:
                // instanceDeclaration
                var instance = ComplexTypeValueAst.Parse(stream, qualifiers);
                return(instance);

            case Keywords.QUALIFIER:
                // qualifierDeclaration
                throw new UnsupportedTokenException(identifier);

            default:
                throw new UnexpectedTokenException(peek);
            }

            #endregion
        }
コード例 #7
0
        /// <summary>
        /// </summary>
        /// <returns></returns>
        /// <remarks>
        /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf
        /// A.5 Class declaration
        ///
        ///     classDeclaration = [ qualifierList ] CLASS className [ superClass ]
        ///                        "{" *classFeature "}" ";"
        ///
        ///     className        = elementName
        ///     superClass       = ":" className
        ///     classFeature     = structureFeature /
        ///                        methodDeclaration
        ///     CLASS            = "class" ; keyword: case insensitive
        ///
        /// </remarks>
        internal static ClassDeclarationAst ParseClassAst(ParserStream stream, QualifierListAst qualifiers)
        {
            var node = new ClassDeclarationAst();

            // [ qualifierList ]
            node.Qualifiers = qualifiers;

            // CLASS
            stream.ReadIdentifier(Keywords.CLASS);

            // className
            var className = stream.Read <IdentifierToken>();

            if (!StringValidator.IsClassName(className.Name))
            {
                throw new InvalidOperationException("Identifer is not a valid class name.");
            }
            node.ClassName = className;

            // [ superClass ]
            if (stream.Peek <ColonToken>() != null)
            {
                stream.Read <ColonToken>();
                var superclass = stream.Read <IdentifierToken>();
                if (!StringValidator.IsClassName(className.Name))
                {
                    throw new InvalidOperationException("Identifer is not a valid superclass name.");
                }
                node.Superclass = superclass;
            }

            // "{"
            stream.Read <BlockOpenToken>();

            // *classFeature
            while (!stream.Eof)
            {
                var peek = stream.Peek() as BlockCloseToken;
                if (peek != null)
                {
                    break;
                }
                var classFeature = ClassFeatureAst.Parse(stream);
                node.Features.Add(classFeature);
            }

            // "}" ";"
            stream.Read <BlockCloseToken>();
            stream.Read <StatementEndToken>();

            return(node);
        }
コード例 #8
0
 private ParameterDeclarationAst(
     QualifierListAst qualifierList,
     IdentifierToken parameterType,
     IdentifierToken parameterRef,
     IdentifierToken parameterName,
     bool parameterIsArray,
     PropertyValueAst defaultValue
     )
 {
     this.QualifierList    = qualifierList ?? new QualifierListAst.Builder().Build();
     this.ParameterType    = parameterType ?? throw new ArgumentNullException(nameof(parameterType));
     this.ParameterRef     = parameterRef;
     this.ParameterName    = parameterName ?? throw new ArgumentNullException(nameof(parameterName));
     this.ParameterIsArray = parameterIsArray;
     this.DefaultValue     = defaultValue;
 }
コード例 #9
0
 private PropertyDeclarationAst(
     QualifierListAst qualifierList,
     IdentifierToken returnType,
     IdentifierToken returnTypeRef,
     IdentifierToken propertyName,
     bool returnTypeIsArray,
     PropertyValueAst initializer
     )
 {
     this.QualifierList     = qualifierList ?? new QualifierListAst.Builder().Build();
     this.ReturnType        = returnType ?? throw new ArgumentNullException(nameof(returnType));
     this.ReturnTypeRef     = returnTypeRef;
     this.PropertyName      = propertyName ?? throw new ArgumentNullException(nameof(propertyName));
     this.ReturnTypeIsArray = returnTypeIsArray;
     this.Initializer       = initializer;
 }
コード例 #10
0
 private QualifierTypeDeclarationAst(
     QualifierListAst qualifierList,
     IdentifierToken qualifierKeyword,
     IdentifierToken qualifierName,
     IdentifierToken qualifierType,
     IdentifierToken qualifierScope,
     IdentifierToken qualifierPolicy,
     ReadOnlyCollection <string> flavors
     )
 {
     this.QualifierList    = qualifierList ?? new QualifierListAst.Builder().Build();
     this.QualifierKeyword = qualifierKeyword ?? throw new ArgumentNullException(nameof(qualifierKeyword));
     this.QualifierName    = qualifierName ?? throw new ArgumentNullException(nameof(qualifierName));
     this.QualifierType    = qualifierType ?? throw new ArgumentNullException(nameof(qualifierType));
     this.QualifierScope   = qualifierScope ?? throw new ArgumentNullException(nameof(qualifierScope));
     this.QualifierPolicy  = qualifierPolicy ?? throw new ArgumentNullException(nameof(qualifierPolicy));
     this.Flavors          = flavors ?? throw new ArgumentNullException(nameof(flavors));
 }
コード例 #11
0
 private MethodDeclarationAst(
     QualifierListAst qualifierList,
     IdentifierToken returnType,
     IdentifierToken returnTypeRef,
     bool returnTypeIsArray,
     IdentifierToken methodName,
     ReadOnlyCollection <ParameterDeclarationAst> parameters
     )
 {
     this.QualifierList     = qualifierList ?? new QualifierListAst.Builder().Build();
     this.ReturnType        = returnType ?? throw new ArgumentNullException(nameof(returnType));
     this.ReturnTypeRef     = returnTypeRef;
     this.ReturnTypeIsArray = returnTypeIsArray;
     this.Name       = methodName ?? throw new ArgumentNullException(nameof(methodName));
     this.Parameters = parameters ?? new ReadOnlyCollection <ParameterDeclarationAst>(
         new List <ParameterDeclarationAst>()
         );
 }
コード例 #12
0
        internal static QualifierListAst Parse(ParserStream stream)
        {
            var ast = new QualifierListAst();

            stream.Read <AttributeOpenToken>();

            while (!stream.Eof)
            {
                ast.Qualifiers.Add(QualifierDeclarationAst.Parse(stream));
                if (stream.Peek <CommaToken>() == null)
                {
                    break;
                }
                stream.Read <CommaToken>();
            }

            stream.Read <AttributeCloseToken>();

            return(ast);
        }
コード例 #13
0
        /// <summary>
        /// </summary>
        /// <returns></returns>
        /// <remarks>
        /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf
        /// A.5 Class declaration
        ///
        ///     classFeature     = structureFeature / methodDeclaration
        ///
        ///     structureFeature = structureDeclaration / ; local structure
        ///                        enumDeclaration /      ; local enumeration
        ///                        propertyDeclaration
        ///
        ///     structureDeclaration = [ qualifierList ] STRUCTURE structureName
        ///                            [ superstructure ]
        ///                            "{" *structureFeature "}" ";"
        ///
        ///     enumDeclaration = enumTypeHeader
        ///                       enumName ":" enumTypeDeclaration ";"
        ///     enumTypeHeader  = [ qualifierList ] ENUMERATION
        ///
        ///     propertyDeclaration = [ qualifierList ] ( primitivePropertyDeclaration /
        ///                                               complexPropertyDeclaration /
        ///                                               enumPropertyDeclaration
        ///                                               referencePropertyDeclaration ) ";"
        ///
        ///     methodDeclaration = [ qualifierList ] ( ( returnDataType [ array ] ) /
        ///                                             VOID ) methodName
        ///                                             "(" [ parameterList ] ")" ";"
        ///
        /// </remarks>
        internal static ClassFeatureAst Parse(ParserStream stream)
        {
            // all classFeatures start with an optional "[ qualifierList ]"
            var qualifierList = default(QualifierListAst);
            var peek          = stream.Peek() as AttributeOpenToken;

            if ((peek as AttributeOpenToken) != null)
            {
                qualifierList = QualifierListAst.Parse(stream);
            }

            // we now need to work out if it's a structureDeclaration, enumDeclaration,
            // propertyDeclaration or methodDeclaration
            var identifier     = stream.Peek <IdentifierToken>();
            var identifierName = identifier.GetNormalizedName();

            if (identifier == null)
            {
                throw new UnexpectedTokenException(peek);
            }
            else if (identifierName == Keywords.STRUCTURE)
            {
                // structureDeclaration
                throw new UnsupportedTokenException(identifier);
            }
            else if (identifierName == Keywords.ENUMERATION)
            {
                // enumDeclaration
                throw new UnsupportedTokenException(identifier);
            }
            else
            {
                // propertyDeclaration or methodDeclaration
                return(ClassFeatureAst.ParseMemberDeclaration(stream, qualifierList));
            }
        }
コード例 #14
0
 internal static ClassDeclarationAst Parse(ParserStream stream, QualifierListAst qualifiers)
 {
     return(ClassDeclarationAst.ParseClassAst(stream, qualifiers));
 }
コード例 #15
0
 public EnumElementAst(QualifierListAst qualifierList, IdentifierToken enumElementName, IEnumElementValueAst enumElementValue)
 {
     this.QualifierList    = qualifierList ?? new QualifierListAst.Builder().Build();
     this.EnumElementName  = enumElementName;
     this.EnumElementValue = enumElementValue;
 }
コード例 #16
0
        /// <summary>
        /// </summary>
        /// <returns></returns>
        /// <remarks>
        /// See http://www.dmtf.org/sites/default/files/standards/documents/DSP0221_3.0.0a.pdf
        /// A.10 Property declaration
        /// Whitespace as defined in 5.2 is allowed between the elements of the rules in this ABNF section.
        ///
        ///     propertyDeclaration = [ qualifierList ] ( primitivePropertyDeclaration /
        ///                                               complexPropertyDeclaration /
        ///                                               enumPropertyDeclaration /
        ///                                               referencePropertyDeclaration) ";"
        ///
        ///     primitivePropertyDeclaration = primitiveType propertyName [ array ]
        ///                                    [ "=" primitiveTypeValue]
        ///     complexPropertyDeclaration   = structureOrClassName propertyName [ array ]
        ///                                    [ "=" ( complexTypeValue / aliasIdentifier ) ]
        ///     enumPropertyDeclaration      = enumName propertyName [ array ]
        ///                                    [ "=" enumTypeValue]
        ///     referencePropertyDeclaration = classReference propertyName [ array ]
        ///                                    [ "=" referenceTypeValue ]
        ///
        ///     array                        = "[" "]"
        ///     propertyName                 = IDENTIFIER
        ///     structureOrClassName         = IDENTIFIER
        ///     classReference               = DT_REFERENCE
        ///     DT_REFERENCE                 = className REF
        ///     REF                          = "ref" ; keyword: case insensitive
        ///
        /// A.11 Method declaration
        /// Whitespace as defined in 5.2 is allowed between the elements of the rules in this ABNF section.
        ///
        ///     methodDeclaration = [ qualifierList ] ( ( returnDataType [ array ] ) /
        ///                         VOID ) methodName
        ///                         "(" [ parameterList ] ")" ";"
        ///
        ///     returnDataType    = primitiveType /
        ///                         structureOrClassName /
        ///                         enumName /
        ///                         classReference
        ///     array             = "[" "]"
        ///     methodName        = IDENTIFIER
        ///     classReference    = DT_REFERENCE
        ///     DT_REFERENCE      = className REF
        ///     REF               = "ref" ; keyword: case insensitive
        ///     VOID              = "void" ; keyword: case insensitive
        ///     parameterList     = parameterDeclaration *( "," parameterDeclaration )
        ///
        private static ClassFeatureAst ParseMemberDeclaration(ParserStream stream, QualifierListAst qualifiers)
        {
            // primitiveType / structureOrClassName / enumName / classReference
            var returnType = stream.Read <IdentifierToken>();

            var @ref = default(IdentifierToken);

            if (stream.PeekIdentifier(Keywords.REF))
            {
                @ref = stream.ReadIdentifier(Keywords.REF);
            }

            // [ array ]
            var returnTypeIsArray = false;

            if (stream.Peek <AttributeOpenToken>() != null)
            {
                stream.Read <AttributeOpenToken>();
                stream.Read <AttributeCloseToken>();
                returnTypeIsArray = true;
            }

            // propertyName / methodName
            var memberName = stream.Read <IdentifierToken>();

            if ((stream.Peek <ParenthesesOpenToken>() != null) && (@ref == null))
            {
                // read the remainder of a methodDeclaration
                var ast = new MethodDeclarationAst
                {
                    Qualifiers        = qualifiers,
                    Name              = memberName,
                    ReturnType        = returnType,
                    ReturnTypeIsArray = returnTypeIsArray
                };
                // "("
                stream.Read <ParenthesesOpenToken>();
                //  [ parameterList ]
                if (stream.Peek <ParenthesesCloseToken>() == null)
                {
                    while (!stream.Eof)
                    {
                        if (ast.Parameters.Count > 0)
                        {
                            stream.Read <CommaToken>();
                        }
                        var parameter = ParameterDeclarationAst.Parse(stream);
                        ast.Parameters.Add(parameter);
                        if (stream.Peek <ParenthesesCloseToken>() != null)
                        {
                            break;
                        }
                    }
                }
                // ")" ";"
                stream.Read <ParenthesesCloseToken>();
                stream.Read <StatementEndToken>();
                return(ast);
            }
            else
            {
                // read the remainder of a propertyDeclaration
                var ast = new PropertyDeclarationAst
                {
                    Qualifiers = qualifiers,
                    Name       = memberName,
                    Type       = returnType,
                    IsRef      = (@ref != null)
                };
                if (stream.Peek <AttributeOpenToken>() != null)
                {
                    stream.Read <AttributeOpenToken>();
                    stream.Read <AttributeCloseToken>();
                    ast.IsArray = true;
                }
                if (stream.Peek <EqualsOperatorToken>() != null)
                {
                    stream.Read <EqualsOperatorToken>();
                    ast.Initializer = ClassFeatureAst.ReadDefaultValue(stream, returnType);
                }
                stream.Read <StatementEndToken>();
                return(ast);
            }
        }