Ntp.Analyzer.Config.Compiler.ConfigParser Class Reference

The config parser transforms configuration texts into a syntax tree. More...

Inheritance diagram for Ntp.Analyzer.Config.Compiler.ConfigParser:

Collaboration diagram for Ntp.Analyzer.Config.Compiler.ConfigParser:

Public Member Functions
	ConfigParser (string file, ISyntaxNode root)
	Initializes a new instance of the ConfigParser class. More...
void	Dispose ()
void	Execute ()
	Execute the parser stage. More...

Public Attributes
IEnumerable< string >	Errors => errors
	Gets the errors from parsing. More...

Properties
SymbolTable	SymbolTable [get, set]
	Gets or sets the symbol table. More...
Properties inherited from Ntp.Analyzer.Config.Compiler.ICompilerStage
IEnumerable< string >	Errors [get]
	Gets the errors from this stage. More...
SymbolTable	SymbolTable [get, set]
	Gets or sets the symbol table. More...

Private Member Functions
void	AddToSymbolTable (string name, ISyntaxNode node)
void	LogError (string error)
void	ParseAboutPageSection (ISyntaxNode parent)
void	ParseContentSection (ISyntaxNode parent)
void	ParseDatabaseSection (ISyntaxNode parent)
void	ParseDelimiter ()
void	ParseDirectoryDestinationSection (ISyntaxNode parent)
void	ParseFileDestinationSection (ISyntaxNode parent)
void	ParseGraphSetSection (ISyntaxNode parent)
void	ParseHeartbeatSection (ISyntaxNode parent)
void	ParseHostGraphPageSection (ISyntaxNode parent)
void	ParseHostGraphSection (ISyntaxNode parent)
	Parses a host graph configuration section. More...
void	ParseHostPageSection (ISyntaxNode parent)
	Parses a host page configuration section. More...
void	ParseHostSection (ISyntaxNode parent)
void	ParseIntOrString (ISyntaxNode parent)
void	ParseListenerSection (ISyntaxNode parent)
void	ParseLogSection (ISyntaxNode parent)
void	ParseMenuItem (ISyntaxNode parent)
void	ParseMenuItemType (ISyntaxNode node)
void	ParseMenuSection (ISyntaxNode parent)
void	ParseNotifySection (ISyntaxNode parent)
void	ParseOption< T > (ISyntaxNode node, List< Symbol > options)
	Parses the options of a setting. More...
void	ParsePeerGraphPageSection (ISyntaxNode parent)
void	ParsePeerGraphSection (ISyntaxNode parent)
	Parses a peer graph configuration section. More...
void	ParsePeerPageSection (ISyntaxNode parent)
void	ParsePeerSummaryPageSection (ISyntaxNode parent)
void	ParsePermissionSection (ISyntaxNode parent)
void	ParseReadingSection (ISyntaxNode parent)
void	ParseSectionEnd (string name)
	Parses the footer of a configuration section. More...
string	ParseSectionStart ()
	Get the header of a configuration section. More...
void	ParseStatSection (ISyntaxNode parent)
	Parses the stat configuration section. More...
void	ParseSummariesSection (ISyntaxNode parent)
void	ParseTrafficGraphSection (ISyntaxNode parent)
	Parses a traffic graph configuration section. More...
ISyntaxNode	ParseValue (ISyntaxNode parent)
	Parses the value of a setting. More...
void	ParseWebLinkSection (ISyntaxNode parent)

Private Attributes
readonly List< string >	errors
readonly ISyntaxNode	root
readonly Tokenizer	tokenizer

Detailed Description

The config parser transforms configuration texts into a syntax tree.

Definition at line 35 of file ConfigParser.cs.

Constructor & Destructor Documentation

Ntp.Analyzer.Config.Compiler.ConfigParser.ConfigParser ( string  file, ISyntaxNode  root  )

inline

Initializes a new instance of the ConfigParser class.

Parameters

file	Configuration file.
root	Syntax root node.

Definition at line 42 of file ConfigParser.cs.

        {
            this.root = root;
            tokenizer = new Tokenizer(file);
            errors = new List<string>();
        }

Member Function Documentation

void Ntp.Analyzer.Config.Compiler.ConfigParser.AddToSymbolTable ( string  name, ISyntaxNode  node  )

inlineprivate

Definition at line 120 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Table.SymbolTable.Add(), and Ntp.Analyzer.Config.Table.SymbolTable.Lookup().

        {
            var current = SymbolTable.Lookup(name);

            if (current != null)
            {
                LogError($"section {name} is already defined. Choose another name.");
            }
            else
            {
                SymbolTable.Add(name, node);
            }
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.Dispose ( )

inline

Definition at line 115 of file ConfigParser.cs.

        {
            tokenizer.Dispose();
        }

void Ntp.Analyzer.Config.Compiler.ConfigParser.Execute ( )

inline

Execute the parser stage.

Implements Ntp.Analyzer.Config.Compiler.ICompilerStage.

Definition at line 68 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Table.Token.EndOfFile.

        {
            var node = root;
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordDatabase:
                        ParseDatabaseSection(node);
                        break;
                    case Symbol.KeywordPermission:
                        ParsePermissionSection(node);
                        break;
                    case Symbol.KeywordNotify:
                        ParseNotifySection(node);
                        break;
                    case Symbol.KeywordDaemon:
                    case Symbol.KeywordService:
                        ParseHeartbeatSection(node);
                        break;
                    case Symbol.KeywordReading:
                        ParseReadingSection(node);
                        break;
                    case Symbol.KeywordLog:
                        ParseLogSection(node);
                        break;
                    case Symbol.KeywordListener:
                        ParseListenerSection(node);
                        break;
                    case Symbol.KeywordServer:
                        ParseHostSection(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            if (errors.Count == 0 && tokenizer.PeekNext() != Token.EndOfFile)
            {
                LogError("Unknown section.");
            }
        }

void Ntp.Analyzer.Config.Compiler.ConfigParser.LogError ( string  error )

inlineprivate

Definition at line 134 of file ConfigParser.cs.

        {
            string entry = $"Error in line {tokenizer.LineNumber} column {tokenizer.ColumnNumber}: {error}";
            errors.Add(entry);
        }

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseAboutPageSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 140 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new AboutPageSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordTitle:
                    case Symbol.KeywordPageTitle:
                    case Symbol.KeywordServerId:
                    case Symbol.KeywordContentTitle:
                    case Symbol.KeywordLink:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordPageTemplate:
                        ParseOption<PageThemeNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordDefault,
                            Symbol.KeywordBootstrap
                        });
                        break;
                    case Symbol.KeywordContent:
                        ParseContentSection(node);
                        break;
                    case Symbol.KeywordDestinations:
                        ParseFileDestinationSection(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseContentSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 185 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add(), Ntp.Analyzer.Config.Table.Keyword.Content, and Ntp.Analyzer.Config.Table.Token.Text.

        {
            tokenizer.Consume();

            if (tokenizer.GetNext().Symbol != Symbol.OpeningBrace)
                LogError("Content section should begin with an opening brace.");

            tokenizer.Consume();

            Token token;
            var content = new StringBuilder();
            while ((token = tokenizer.GetNext()).Symbol != Symbol.ClosingBrace)
                content.Append(token.Text);

            var node = new StringSettingNode(Keyword.Content, content.ToString(), tokenizer.LineNumber);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseDatabaseSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 203 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new DatabaseSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordName:
                    case Symbol.KeywordHost:
                    case Symbol.KeywordIp:
                    case Symbol.KeywordAddress:
                    case Symbol.KeywordHostAddress:
                    case Symbol.KeywordPort:
                    case Symbol.KeywordUser:
                    case Symbol.KeywordPass:
                    case Symbol.KeywordCreate:
                    case Symbol.KeywordUpgrade:
                    case Symbol.KeywordImport:
                    case Symbol.KeywordDatabaseName:
                    case Symbol.KeywordDatabaseUser:
                    case Symbol.KeywordDatabasePass:
                    case Symbol.KeywordConString:
                    case Symbol.KeywordCertFile:
                    case Symbol.KeywordCertPass:
                    case Symbol.KeywordConnectionTimeout:
                    case Symbol.KeywordProtocol:
                    case Symbol.KeywordEnableSsl:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordDatabaseProvider:
                        ParseOption<DatabaseProviderNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordDatabaseProviderMySql,
                            Symbol.KeywordDatabaseProviderPostgre
                        });
                        break;
                    case Symbol.KeywordSslMode:
                        ParseOption<DatabaseProviderNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordRequired,
                            Symbol.KeywordPreferred
                        });
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseDelimiter ( )

inlineprivate

Definition at line 260 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Table.Token.NewLine.

        {
            if (tokenizer.PeekNext() == Token.NewLine)
                return;

            tokenizer.ConsumeWhiteSpaces();
            if (tokenizer.PeekNext() != Token.NewLine)
                LogError("Expected end of line.");
        }

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseDirectoryDestinationSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 270 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new DirDestinationSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordPrefix:
                    case Symbol.KeywordDirectory:
                        ParseValue(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseFileDestinationSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 295 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new FileDestinationSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                if (tokenizer.GetNext().Symbol == Symbol.KeywordFile)
                    ParseValue(node);
                else
                    pass = false;
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseGraphSetSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 314 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add(), and Ntp.Analyzer.Config.Syntax.ISyntaxNode.Symbol.

        {
            var name = ParseSectionStart();
            var node = new GraphSetSyntaxNode(name, parent.Symbol, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordTitle:
                    case Symbol.KeywordLinkIndex:
                    case Symbol.KeywordGraph:
                        ParseValue(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseHeartbeatSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 340 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new HeartbeatSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                if (tokenizer.GetNext().Symbol == Symbol.KeywordHeartbeat)
                    ParseValue(node);
                else
                    pass = false;
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseHostGraphPageSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 359 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new HostGraphPageSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordGraphPage:
                    case Symbol.KeywordLinkIndex:
                    case Symbol.KeywordLink:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordDestinations:
                        ParseDirectoryDestinationSection(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseHostGraphSection ( ISyntaxNode  parent )

inlineprivate

Parses a host graph configuration section.

Parameters

parent

Parent node.

Definition at line 396 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new HostGraphSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordTitle:
                    case Symbol.KeywordWidth:
                    case Symbol.KeywordHeight:
                    case Symbol.KeywordTimespan:
                    case Symbol.KeywordFilterFactor:
                    case Symbol.KeywordJitter:
                    case Symbol.KeywordOffset:
                    case Symbol.KeywordGraphFrequency:
                    case Symbol.KeywordGraphStability:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordDestinations:
                        ParseFileDestinationSection(node);
                        break;
                    case Symbol.KeywordWebLinks:
                        ParseWebLinkSection(node);
                        break;
                    case Symbol.KeywordGraphTime:
                    case Symbol.KeywordTimeStamp:
                        ParseOption<TimeStampNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordTimeStampLocal,
                            Symbol.KeywordTimeStampUtc
                        });
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseHostPageSection ( ISyntaxNode  parent )

inlineprivate

Parses a host page configuration section.

Parameters

parent

Parent node.

Definition at line 450 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new HostPageSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordPageTitle:
                    case Symbol.KeywordLink:
                    case Symbol.KeywordPoolMember:
                    case Symbol.KeywordQueryDirect:
                    case Symbol.KeywordPeerPage:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordPageTemplate:
                        ParseOption<PageThemeNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordDefault,
                            Symbol.KeywordBootstrap
                        });
                        break;
                    case Symbol.KeywordPageTime:
                    case Symbol.KeywordTimeStamp:
                        ParseOption<TimeStampNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordTimeStampLocal,
                            Symbol.KeywordTimeStampUtc
                        });
                        break;
                    case Symbol.KeywordGraphSet:
                        ParseGraphSetSection(node);
                        break;
                    case Symbol.KeywordSummaries:
                        ParseSummariesSection(node);
                        break;
                    case Symbol.KeywordDestinations:
                        ParseFileDestinationSection(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseHostSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 506 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new HostSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordHostId:
                    case Symbol.KeywordIp:
                    case Symbol.KeywordAddress:
                    case Symbol.KeywordHostAddress:
                    case Symbol.KeywordFilePath:
                    case Symbol.KeywordWebPath:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordHostType:
                        ParseOption<HostTypeNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordNtpdc,
                            Symbol.KeywordNtpq,
                            Symbol.KeywordNtpctl
                        });
                        break;
                    case Symbol.KeywordTimeStamp:
                        ParseOption<TimeStampNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordTimeStampLocal,
                            Symbol.KeywordTimeStampUtc
                        });
                        break;
                    case Symbol.KeywordAboutPage:
                        ParseAboutPageSection(node);
                        break;
                    case Symbol.KeywordHostPage:
                        ParseHostPageSection(node);
                        break;
                    case Symbol.KeywordPeerPage:
                        ParsePeerPageSection(node);
                        break;
                    case Symbol.KeywordHostGraph:
                        ParseHostGraphSection(node);
                        break;
                    case Symbol.KeywordPeerGraph:
                        ParsePeerGraphSection(node);
                        break;
                    case Symbol.KeywordTrafficGraph:
                        ParseTrafficGraphSection(node);
                        break;
                    case Symbol.KeywordPeerSummaryPage:
                        ParsePeerSummaryPageSection(node);
                        break;
                    case Symbol.KeywordHostGraphPage:
                        ParseHostGraphPageSection(node);
                        break;
                    case Symbol.KeywordPeerGraphPage:
                        ParsePeerGraphPageSection(node);
                        break;
                    case Symbol.KeywordMenu:
                        ParseMenuSection(node);
                        break;
                    case Symbol.KeywordHostStats:
                    case Symbol.KeywordHostIoStats:
                    case Symbol.KeywordPeerStats:
                    case Symbol.KeywordDriftStats:
                        ParseStatSection(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseIntOrString ( ISyntaxNode  parent )

inlineprivate

Definition at line 586 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add(), and Ntp.Analyzer.Config.Table.IntegerToken.Text.

        {
            var keyword = ((KeywordToken) tokenizer.Token).Keyword;
            tokenizer.ConsumeWhiteSpaces();
            var token = tokenizer.GetNext();

            switch (token.TokenType)
            {
                case TokenType.IntegerValue:
                    parent.Add(new IntegerSettingNode(keyword, ((IntegerToken) token).Value, tokenizer.LineNumber));
                    break;
                case TokenType.Literal:
                case TokenType.QuotedIdent:
                    parent.Add(new StringSettingNode(keyword, token.Text, tokenizer.LineNumber));
                    break;
                default:
                    LogError($"{keyword.Name} must be either an integer or a string.");
                    break;
            }
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseListenerSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 607 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new ListenerSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                var token = tokenizer.GetNext();

                switch (token.Symbol)
                {
                    case Symbol.KeywordIp:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordPort:
                        ParseValue(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseLogSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 636 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new LogSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordType:
                        ParseOption<LogTypeNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordFile,
                            Symbol.KeywordSyslog,
                            Symbol.KeywordConsole
                        });
                        break;
                    case Symbol.KeywordSeverity:
                        ParseOption<SeverityNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordError,
                            Symbol.KeywordWarn,
                            Symbol.KeywordNotice,
                            Symbol.KeywordInfo,
                            Symbol.KeywordDebug,
                            Symbol.KeywordTrace
                        });
                        break;
                    case Symbol.KeywordShowTimestamp:
                    case Symbol.KeywordShowSeverity:
                    case Symbol.KeywordTimeFormat:
                    case Symbol.KeywordFile:
                        ParseValue(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseMenuItem ( ISyntaxNode  parent )

inlineprivate

Definition at line 682 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new MenuItemSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordPage:
                    case Symbol.KeywordCaption:
                    case Symbol.KeywordLink:
                    case Symbol.KeywordDropdown:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordType:
                        ParseMenuItemType(node);
                        break;
                    case Symbol.KeywordContent:
                        ParseMenuSection(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseMenuItemType ( ISyntaxNode  node )

inlineprivate

Definition at line 715 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add(), and Ntp.Analyzer.Config.Syntax.SyntaxNode< T >.Symbol.

        {
            tokenizer.Consume();
            var token = tokenizer.GetNext();

            switch (token.Symbol)
            {
                case Symbol.KeywordLink:
                case Symbol.KeywordName:
                case Symbol.KeywordPage:
                case Symbol.KeywordSpacer:
                case Symbol.KeywordHeader:
                    node.Add(new MenuItemTypeNode {Value = token.Symbol});
                    break;
                case Symbol.KeywordDropdown:
                    ParseMenuItem(node);
                    break;
                default:
                    node.Add(new MenuItemTypeNode {Value = Symbol.Unknown});
                    break;
            }
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseMenuSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 738 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new MenuSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                if (tokenizer.GetNext().Symbol == Symbol.KeywordItem)
                    ParseMenuItem(node);
                else
                    pass = false;
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseNotifySection ( ISyntaxNode  parent )

inlineprivate

Definition at line 757 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new NotifySyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordUser:
                    case Symbol.KeywordPass:
                    case Symbol.KeywordIp:
                    case Symbol.KeywordHost:
                    case Symbol.KeywordAddress:
                    case Symbol.KeywordHostAddress:
                    case Symbol.KeywordPort:
                    case Symbol.KeywordEnableSsl:
                    case Symbol.KeywordSender:
                    case Symbol.KeywordMail:
                    case Symbol.KeywordRecipient:
                    case Symbol.KeywordSubject:
                    case Symbol.KeywordSmtpHost:
                    case Symbol.KeywordSmtpPort:
                    case Symbol.KeywordSmtpUser:
                    case Symbol.KeywordSmtpPass:
                        ParseValue(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseOption< T > ( ISyntaxNode  node, List< Symbol >  options  )

inlineprivate

Parses the options of a setting.

Parameters

node	Parent node.
options	Options.

Type Constraints

T	:	SymbolSettingNode
T	:	new()

Definition at line 804 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.SyntaxNode< T >.Add().

                    : SymbolSettingNode, new()
        {
            tokenizer.ConsumeWhiteSpaces();
            var token = tokenizer.GetNext();

            if (options.Contains(token.Symbol))
                node.Add(new T {Value = token.Symbol});
            else
            {
                var keyword = ((KeywordToken) tokenizer.Token).Keyword;
                LogError($"Invalid value for option {keyword}");
            }

            ParseDelimiter();
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParsePeerGraphPageSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 821 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new PeerGraphPageSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordGraphPage:
                    case Symbol.KeywordLinkIndex:
                    case Symbol.KeywordLink:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordDestinations:
                        ParseDirectoryDestinationSection(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParsePeerGraphSection ( ISyntaxNode  parent )

inlineprivate

Parses a peer graph configuration section.

Parameters

parent

Parent node.

Definition at line 858 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new PeerGraphSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordTitle:
                    case Symbol.KeywordWidth:
                    case Symbol.KeywordHeight:
                    case Symbol.KeywordTimespan:
                    case Symbol.KeywordFilterFactor:
                    case Symbol.KeywordJitter:
                    case Symbol.KeywordOffset:
                    case Symbol.KeywordGraphBalance:
                    case Symbol.KeywordGraphDelay:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordDestinations:
                        ParseDirectoryDestinationSection(node);
                        break;
                    case Symbol.KeywordWebLinks:
                        ParseWebLinkSection(node);
                        break;
                    case Symbol.KeywordGraphTime:
                    case Symbol.KeywordTimeStamp:
                        ParseOption<TimeStampNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordTimeStampLocal,
                            Symbol.KeywordTimeStampUtc
                        });
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParsePeerPageSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 908 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new PeerPageSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordTitle:
                    case Symbol.KeywordPageTitle:
                    case Symbol.KeywordLink:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordPageTemplate:
                        ParseOption<PageThemeNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordDefault,
                            Symbol.KeywordBootstrap
                        });
                        break;
                    case Symbol.KeywordTimeStamp:
                    case Symbol.KeywordPageTime:
                        ParseOption<TimeStampNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordTimeStampLocal,
                            Symbol.KeywordTimeStampUtc
                        });
                        break;
                    case Symbol.KeywordGraphSet:
                        ParseGraphSetSection(node);
                        break;
                    case Symbol.KeywordDestinations:
                        ParseDirectoryDestinationSection(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParsePeerSummaryPageSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 959 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new PeerSummaryPageSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordTitle:
                    case Symbol.KeywordPageTitle:
                    case Symbol.KeywordPeerPage:
                    case Symbol.KeywordLink:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordPageTemplate:
                        ParseOption<PageThemeNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordDefault,
                            Symbol.KeywordBootstrap
                        });
                        break;
                    case Symbol.KeywordGraphSet:
                        ParseGraphSetSection(node);
                        break;
                    case Symbol.KeywordDestinations:
                        ParseFileDestinationSection(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParsePermissionSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 1003 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new PermissionSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordUser:
                    case Symbol.KeywordExecUser:
                    case Symbol.KeywordGroup:
                        ParseIntOrString(node);
                        break;
                    case Symbol.KeywordMode:
                        ParseValue(node);
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseReadingSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 1032 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add(), and Ntp.Analyzer.Config.Syntax.Setting.StringSettingNode.Value.

        {
            var name = ParseSectionStart();
            var node = new ReadingSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordName:
                        StringSettingNode nameNode = ParseValue(node) as StringSettingNode;
                        if (nameNode != null)
                            name = nameNode.Value;
                        break;
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordTimeStamp:
                        ParseOption<TimeStampNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordTimeStampLocal,
                            Symbol.KeywordTimeStampUtc
                        });
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseSectionEnd ( string  name )

inlineprivate

Parses the footer of a configuration section.

Parameters

name	Section name. Shown in error messages.

Definition at line 1075 of file ConfigParser.cs.

        {
            if (tokenizer.Token.Symbol == Symbol.ClosingBrace)
                return;

            tokenizer.ConsumeWhiteSpaces();
            if (tokenizer.GetNext().Symbol == Symbol.ClosingBrace)
                return;

            string errorName = string.IsNullOrWhiteSpace(name)
                ? string.Empty
                : name + " ";

            LogError($"Configuration section {errorName}has unexpected content.");
        }

string Ntp.Analyzer.Config.Compiler.ConfigParser.ParseSectionStart ( )

inlineprivate

Get the header of a configuration section.

Returns

Definition at line 1095 of file ConfigParser.cs.

        {
            tokenizer.Consume();
            var token = tokenizer.GetNext();

            string name = null;
            if (token.IsText)
            {
                name = token.Text;
                tokenizer.Consume();
                token = tokenizer.GetNext();
            }

            if (token.Symbol != Symbol.OpeningBrace)
                LogError("Configuration section should begin with an opening brace.");

            return name;
        }

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseStatSection ( ISyntaxNode  parent )

inlineprivate

Parses the stat configuration section.

Parameters

parent

Parent node.

Definition at line 1118 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var symbol = tokenizer.Token.Symbol;
            var name = ParseSectionStart();
            var node = new StatSyntaxNode(symbol, name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordFile:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordFrequency:
                        ParseIntOrString(node);
                        break;
                    case Symbol.KeywordTimeStamp:
                        ParseOption<TimeStampNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordTimeStampLocal,
                            Symbol.KeywordTimeStampUtc
                        });
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseSummariesSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 1155 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new SummariesSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                if (tokenizer.GetNext().Symbol == Symbol.KeywordPeerSummaryPage)
                    ParseValue(node);
                else
                    pass = false;
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseTrafficGraphSection ( ISyntaxNode  parent )

inlineprivate

Parses a traffic graph configuration section.

Parameters

parent

Parent node.

Definition at line 1178 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new TrafficGraphSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                switch (tokenizer.GetNext().Symbol)
                {
                    case Symbol.KeywordFrequency:
                    case Symbol.KeywordInitialRun:
                    case Symbol.KeywordFixedRun:
                    case Symbol.KeywordTitle:
                    case Symbol.KeywordWidth:
                    case Symbol.KeywordHeight:
                    case Symbol.KeywordTimespan:
                    case Symbol.KeywordGraphReceived:
                    case Symbol.KeywordGraphIgnored:
                    case Symbol.KeywordGraphDropped:
                    case Symbol.KeywordGraphSent:
                    case Symbol.KeywordGraphNotSent:
                    case Symbol.KeywordGraphAvgReceived:
                    case Symbol.KeywordGraphAvgIgnored:
                    case Symbol.KeywordGraphAvgDropped:
                    case Symbol.KeywordGraphAvgSent:
                    case Symbol.KeywordGraphAvgNotSent:
                    case Symbol.KeywordGraphPlotInterval:
                    case Symbol.KeywordGraphPacketRate:
                        ParseValue(node);
                        break;
                    case Symbol.KeywordDestinations:
                        ParseFileDestinationSection(node);
                        break;
                    case Symbol.KeywordWebLinks:
                        ParseWebLinkSection(node);
                        break;
                    case Symbol.KeywordGraphTime:
                    case Symbol.KeywordTimeStamp:
                        ParseOption<TimeStampNode>(node, new List<Symbol>
                        {
                            Symbol.KeywordTimeStampLocal,
                            Symbol.KeywordTimeStampUtc
                        });
                        break;
                    default:
                        pass = false;
                        break;
                }
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
            AddToSymbolTable(name, node);
        }

Here is the call graph for this function:

ISyntaxNode Ntp.Analyzer.Config.Compiler.ConfigParser.ParseValue ( ISyntaxNode  parent )

inlineprivate

Parses the value of a setting.

Parameters

parent

Parent node.

Definition at line 1239 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add(), Ntp.Analyzer.Config.Table.Token.NewLine, Ntp.Analyzer.Config.Table.IntegerToken.Symbol, Ntp.Analyzer.Config.Table.IntegerToken.TokenType, and Ntp.Analyzer.Config.Table.NumericToken.TokenType.

        {
            var keyword = ((KeywordToken) tokenizer.Token).Keyword;
            tokenizer.ConsumeWhiteSpaces();
            var token = tokenizer.GetNext();
            ISyntaxNode node;

            if (keyword.ValueType == typeof(string) && token.IsText)
                node = new StringSettingNode(keyword, token.Text, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(string) && token == Token.NewLine)
                node = new StringSettingNode(keyword, string.Empty, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(int) && token.TokenType == TokenType.IntegerValue)
                node = new IntegerSettingNode(keyword, ((IntegerToken) token).Value, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(int) && token.Symbol == Symbol.Zero)
                node = new IntegerSettingNode(keyword, 0, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(int) && token.Symbol == Symbol.One)
                node = new IntegerSettingNode(keyword, 1, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(double) && token.TokenType == TokenType.NumericValue)
                node = new NumericSettingNode(keyword, ((NumericToken) token).Value, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(double) && token.TokenType == TokenType.IntegerValue)
                node = new NumericSettingNode(keyword, ((IntegerToken) token).Value, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(double) && token.Symbol == Symbol.Zero)
                node = new NumericSettingNode(keyword, 0.0, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(double) && token.Symbol == Symbol.One)
                node = new NumericSettingNode(keyword, 1.0, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(bool) &&
                     (token.Symbol == Symbol.BooleanTrue || token.Symbol == Symbol.One))
                node = new BooleanSettingNode(keyword, true, tokenizer.LineNumber);
            else if (keyword.ValueType == typeof(bool) &&
                     (token.Symbol == Symbol.BooleanFalse || token.Symbol == Symbol.Zero))
                node = new BooleanSettingNode(keyword, false, tokenizer.LineNumber);
            else
            {
                LogError($"Invalid value for setting {keyword.Name}");
                ParseDelimiter();
                return null;
            }

            parent.Add(node);
            ParseDelimiter();
            return node;
        }

Here is the call graph for this function:

void Ntp.Analyzer.Config.Compiler.ConfigParser.ParseWebLinkSection ( ISyntaxNode  parent )

inlineprivate

Definition at line 1282 of file ConfigParser.cs.

References Ntp.Analyzer.Config.Syntax.ISyntaxNode.Add().

        {
            var name = ParseSectionStart();
            var node = new WebLinkSyntaxNode(name, tokenizer.LineNumber);
            var pass = true;

            do
            {
                tokenizer.Consume();
                if (tokenizer.GetNext().Symbol == Symbol.KeywordLink)
                    ParseValue(node);
                else
                    pass = false;
            } while (pass);

            ParseSectionEnd(name);
            parent.Add(node);
        }

Here is the call graph for this function:

Member Data Documentation

readonly List<string> Ntp.Analyzer.Config.Compiler.ConfigParser.errors

private

Definition at line 49 of file ConfigParser.cs.

IEnumerable<string> Ntp.Analyzer.Config.Compiler.ConfigParser.Errors => errors

Gets the errors from parsing.

The parser errors.

Definition at line 63 of file ConfigParser.cs.

readonly ISyntaxNode Ntp.Analyzer.Config.Compiler.ConfigParser.root

private

Definition at line 50 of file ConfigParser.cs.

readonly Tokenizer Ntp.Analyzer.Config.Compiler.ConfigParser.tokenizer

private

Definition at line 51 of file ConfigParser.cs.

Property Documentation

SymbolTable Ntp.Analyzer.Config.Compiler.ConfigParser.SymbolTable

getset

Gets or sets the symbol table.

The symbol table.

Definition at line 57 of file ConfigParser.cs.

---

The documentation for this class was generated from the following file:

• Ntp.Analyzer/Config/Compiler/ConfigParser.cs