Esempio n. 1
0
        public static ParseResult CreateAggregationKindsFromTokenList(IEnumerable <Token> tokenList, Field.Kind fieldKind, out List <Aggregation.Kinds> aggregationTypes)
        {
            aggregationTypes = new List <Aggregation.Kinds>();

            foreach (var token in tokenList)
            {
                Aggregation.Kinds aggrType = Aggregation.Kinds.Undefined;

                // check whether the aggregation type name exists
                if (!SemanticsAnalyzer.CreateAggregationTypeFromName(token.Text, ref aggrType))
                {
                    return(new ParseResult(ParseCode.SemanticsInvalidAggregationType, "Invalid aggregation type", token.ColumnPos));
                }

                // check whether the aggregation type is supported by the field type
                if (!Field.IsAggregationAvailable(fieldKind, aggrType))
                {
                    return(new ParseResult(ParseCode.SemanticsInvalidAggregationType, "Invalid aggregation type for the requested field type", token.ColumnPos));
                }

                aggregationTypes.Add(aggrType);
            }

            return(new ParseResult(ParseCode.Success));
        }
Esempio n. 2
0
        public ParseResult CheckManifestFieldKindAndDefinition(string taskName, string eventName, string fieldName, Field.Kind expectedFieldKind, int columnPos)
        {
            // by-passing check in case semantic validadation against manifest files is disabled
            if (!this.manifestSemanticsCheckEnabled)
            {
                return(new ParseResult(ParseCode.Success));
            }

            FieldDefinition fieldDef;

            if (!this.manifestLookup.TryGetField(taskName, eventName, fieldName, out fieldDef))
            {
                return(new ParseResult(
                           ParseCode.SemanticsUndefinedEventInManifest,
                           string.Format("The specified field ({0}) is not available for the event defined by the pair (TaskName: {1}, EventName: {2})", fieldName, taskName, eventName),
                           columnPos));
            }

            // check whether field matches the expected type
            Field.Kind fieldKind = SemanticsAnalyzer.GetAggregationFieldKind(fieldDef);
            if (fieldKind != expectedFieldKind)
            {
                return(new ParseResult(
                           ParseCode.SemanticsInvalidFieldKind,
                           string.Format("The specified field ({0}) is of type ({1}) but was defined as a ({2}) type", fieldName, fieldKind.ToString(), expectedFieldKind.ToString()),
                           columnPos));
            }

            return(new ParseResult(ParseCode.Success));
        }
Esempio n. 3
0
        // this method implements the D production for the grammar
        // D -> E F G
        private ParseResult D(Field.Kind fieldKind, ref TraceAggregationConfig telConfigEntry)
        {
            // try parsing E , i.e get the param names
            List <Token> fieldTokenList = new List <Token>();
            ParseResult  parseRes       = this.E(fieldKind, telConfigEntry, ref fieldTokenList);

            if (parseRes.ParseCode != ParseCode.Success)
            {
                return(parseRes);
            }

            // get the field names
            List <Field> fieldParamList;

            parseRes = SemanticsAnalyzer.CreateFieldsFromTokenList(fieldTokenList, fieldKind, out fieldParamList);

            if (parseRes.ParseCode != ParseCode.Success)
            {
                return(parseRes);
            }

            // try parsing F , i.e get the aggregation kinds
            List <Token> aggregationParamList = new List <Token>();

            parseRes = this.F(ref aggregationParamList);

            if (parseRes.ParseCode != ParseCode.Success)
            {
                return(parseRes);
            }

            // check if the aggregation kinds are valid
            List <Aggregation.Kinds> aggregationKindsList;

            parseRes = SemanticsAnalyzer.CreateAggregationKindsFromTokenList(aggregationParamList, fieldKind, out aggregationKindsList);

            if (parseRes.ParseCode != ParseCode.Success)
            {
                return(parseRes);
            }

            // sucessfully parsed the aggregation entry E F
            // setting the current aggregation entry
            telConfigEntry.AddAggregationEntries(fieldParamList, aggregationKindsList);

            // try to find a new aggregation G
            parseRes = this.G(ref telConfigEntry);

            if (parseRes.ParseCode != ParseCode.Success)
            {
                return(parseRes);
            }

            return(new ParseResult(ParseCode.Success));
        }
Esempio n. 4
0
 // private constructor
 // the only public exposed method is the static method Parse
 private SyntaxAnalyzer(StreamReader fileStream, IEnumerable <string> manifestFilesPaths, LogErrorDelegate logErrorDelegate, bool verbose)
 {
     this.fileStream        = fileStream;
     this.lexAnalyzer       = null;
     this.semanticsAnalyzer = new SemanticsAnalyzer(manifestFilesPaths, manifestFilesPaths.Any(), logErrorDelegate, verbose);
 }