Examples of net.percederberg.grammatica.parser.TokenPattern

Package net.percederberg.grammatica.parser

Examples of net.percederberg.grammatica.parser.TokenPattern

net.percederberg.grammatica.parser.TokenPattern
A token pattern. This class contains the definition of a token (i.e. it's pattern), and allows testing a string against this pattern. A token pattern is uniquely identified by an integer id, that must be provided upon creation. @author Per Cederberg, @version 1.5

     *
     * @throws ParseException if the node analysis discovered errors
     */
    protected Node exitIdentifier(Token node) throws ParseException {
        String             name = node.getImage();
        TokenPattern       token = grammar.getTokenPatternByName(name);
        ProductionPattern  prod = grammar.getProductionPatternByName(name);


        if (token != null) {
            node.addValue(token);
        } else if (prod != null) {

View Full Code Here

     *
     * @throws ParseException if the node analysis discovered errors
     */
    protected Node exitQuotedString(Token node) throws ParseException {
        String        str;
        TokenPattern  token;


        str = node.getImage();
        str = str.substring(1, str.length() - 1);
        token = grammar.getTokenPatternByImage(str);
        if (token != null) {

View Full Code Here

     * @throws ParseException if the node analysis discovered errors
     */
    protected Node exitTokenDeclaration(Production node)
        throws ParseException {


        TokenPattern  pattern;
        String        name;
        int           type;
        String        str;
        Token         token;
        Node          child;


        // Create token pattern
        name = getIdentifier((Token) getChildAt(node, 0));
        child = getChildAt(node, 2);
        type = getIntValue(child, 0);
        str = getStringValue(child, 1);
        pattern = new TokenPattern(nextTokenId++, name, type, str);


        // Process optional ignore or error
        if (node.getChildCount() == 4) {
            child = getChildAt(node, 3);
            token = (Token) getValue(child, 0);
            str = null;
            if (child.getValueCount() == 2) {
                str = getStringValue(child, 1);
            }
            switch (token.getId()) {
            case GrammarConstants.IGNORE:
                if (str == null) {
                    pattern.setIgnore();
                } else {
                    pattern.setIgnore(str);
                }
                break;
            case GrammarConstants.ERROR:
                if (str == null) {
                    pattern.setError();
                } else {
                    pattern.setError(str);
                }
                break;
            }
        }

View Full Code Here

     *
     * @throws ParserCreationException if the tokenizer couldn't be
     *             initialized correctly
     */
    private void createPatterns() throws ParserCreationException {
        TokenPattern  pattern;


        pattern = new TokenPattern(GrammarConstants.HEADER,
                                   "HEADER",
                                   TokenPattern.STRING_TYPE,
                                   "%header%");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.TOKENS,
                                   "TOKENS",
                                   TokenPattern.STRING_TYPE,
                                   "%tokens%");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.PRODUCTIONS,
                                   "PRODUCTIONS",
                                   TokenPattern.STRING_TYPE,
                                   "%productions%");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.IGNORE,
                                   "IGNORE",
                                   TokenPattern.REGEXP_TYPE,
                                   "%ignore([^%]*)%");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.ERROR,
                                   "ERROR",
                                   TokenPattern.REGEXP_TYPE,
                                   "%error([^%]*)%");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.UNTERMINATED_DIRECTIVE,
                                   "UNTERMINATED_DIRECTIVE",
                                   TokenPattern.REGEXP_TYPE,
                                   "%[^%\\n\\r]*");
        pattern.setError("unterminated directive");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.EQUALS,
                                   "EQUALS",
                                   TokenPattern.STRING_TYPE,
                                   "=");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.LEFT_PAREN,
                                   "LEFT_PAREN",
                                   TokenPattern.STRING_TYPE,
                                   "(");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.RIGHT_PAREN,
                                   "RIGHT_PAREN",
                                   TokenPattern.STRING_TYPE,
                                   ")");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.LEFT_BRACE,
                                   "LEFT_BRACE",
                                   TokenPattern.STRING_TYPE,
                                   "{");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.RIGHT_BRACE,
                                   "RIGHT_BRACE",
                                   TokenPattern.STRING_TYPE,
                                   "}");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.LEFT_BRACKET,
                                   "LEFT_BRACKET",
                                   TokenPattern.STRING_TYPE,
                                   "[");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.RIGHT_BRACKET,
                                   "RIGHT_BRACKET",
                                   TokenPattern.STRING_TYPE,
                                   "]");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.QUESTION_MARK,
                                   "QUESTION_MARK",
                                   TokenPattern.STRING_TYPE,
                                   "?");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.PLUS_SIGN,
                                   "PLUS_SIGN",
                                   TokenPattern.STRING_TYPE,
                                   "+");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.ASTERISK,
                                   "ASTERISK",
                                   TokenPattern.STRING_TYPE,
                                   "*");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.VERTICAL_BAR,
                                   "VERTICAL_BAR",
                                   TokenPattern.STRING_TYPE,
                                   "|");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.SEMICOLON,
                                   "SEMICOLON",
                                   TokenPattern.STRING_TYPE,
                                   ";");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.IDENTIFIER,
                                   "IDENTIFIER",
                                   TokenPattern.REGEXP_TYPE,
                                   "[A-Za-z][A-Za-z0-9_]*");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.QUOTED_STRING,
                                   "QUOTED_STRING",
                                   TokenPattern.REGEXP_TYPE,
                                   "\"[^\"]*\"|'[^']*'");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.REGEXP,
                                   "REGEXP",
                                   TokenPattern.REGEXP_TYPE,
                                   "<<([^\\\\>]|(\\\\.)|(>[^>]))*>>");
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.SINGLE_LINE_COMMENT,
                                   "SINGLE_LINE_COMMENT",
                                   TokenPattern.REGEXP_TYPE,
                                   "//.*");
        pattern.setIgnore();
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.MULTI_LINE_COMMENT,
                                   "MULTI_LINE_COMMENT",
                                   TokenPattern.REGEXP_TYPE,
                                   "/\\*([^*]|\\*+[^*/])*\\*+/");
        pattern.setIgnore();
        addPattern(pattern);


        pattern = new TokenPattern(GrammarConstants.WHITESPACE,
                                   "WHITESPACE",
                                   TokenPattern.REGEXP_TYPE,
                                   "[ \\t\\n\\r]+");
        pattern.setIgnore();
        addPattern(pattern);
    }

View Full Code Here

        Grammar                   grammar = getGrammar();
        VisualBasicConstantsFile  constants;
        VisualBasicTokenizerFile  tokenizer;
        VisualBasicParserFile     parser;
        VisualBasicAnalyzerFile   analyzer;
        TokenPattern              token;
        ProductionPattern         production;
        int                       i;


        // Create output files
        constants = new VisualBasicConstantsFile(this);

View Full Code Here

        Grammar              grammar = getGrammar();
        CSharpConstantsFile  constants = new CSharpConstantsFile(this);
        CSharpTokenizerFile  tokenizer = new CSharpTokenizerFile(this);
        CSharpAnalyzerFile   analyzer = new CSharpAnalyzerFile(this);
        CSharpParserFile     parser = new CSharpParserFile(this, tokenizer, analyzer);
        TokenPattern         token;
        ProductionPattern    production;
        int                  i;


        // Create token declarations
        for (i = 0; i < grammar.getTokenPatternCount(); i++) {

View Full Code Here

        Grammar            grammar = getGrammar();
        JavaConstantsFile  constants = new JavaConstantsFile(this);
        JavaTokenizerFile  tokenizer = new JavaTokenizerFile(this);
        JavaAnalyzerFile   analyzer = new JavaAnalyzerFile(this);
        JavaParserFile     parser = new JavaParserFile(this, tokenizer, analyzer);
        TokenPattern       token;
        ProductionPattern  production;
        int                i;


        // Create token declarations
        for (i = 0; i < grammar.getTokenPatternCount(); i++) {

View Full Code Here

     *
     * @throws ParserCreationException if the tokenizer couldn't be
     *             initialized correctly
     */
    private void createPatterns() throws ParserCreationException {
        TokenPattern  pattern;


        pattern = new TokenPattern(ArithmeticConstants.ADD,
                                   "ADD",
                                   TokenPattern.STRING_TYPE,
                                   "+");
        addPattern(pattern);


        pattern = new TokenPattern(ArithmeticConstants.SUB,
                                   "SUB",
                                   TokenPattern.STRING_TYPE,
                                   "-");
        addPattern(pattern);


        pattern = new TokenPattern(ArithmeticConstants.MUL,
                                   "MUL",
                                   TokenPattern.STRING_TYPE,
                                   "*");
        addPattern(pattern);


        pattern = new TokenPattern(ArithmeticConstants.DIV,
                                   "DIV",
                                   TokenPattern.STRING_TYPE,
                                   "/");
        addPattern(pattern);


        pattern = new TokenPattern(ArithmeticConstants.LEFT_PAREN,
                                   "LEFT_PAREN",
                                   TokenPattern.STRING_TYPE,
                                   "(");
        addPattern(pattern);


        pattern = new TokenPattern(ArithmeticConstants.RIGHT_PAREN,
                                   "RIGHT_PAREN",
                                   TokenPattern.STRING_TYPE,
                                   ")");
        addPattern(pattern);


        pattern = new TokenPattern(ArithmeticConstants.NUMBER,
                                   "NUMBER",
                                   TokenPattern.REGEXP_TYPE,
                                   "[0-9]+");
        addPattern(pattern);


        pattern = new TokenPattern(ArithmeticConstants.IDENTIFIER,
                                   "IDENTIFIER",
                                   TokenPattern.REGEXP_TYPE,
                                   "[a-z]");
        addPattern(pattern);


        pattern = new TokenPattern(ArithmeticConstants.WHITESPACE,
                                   "WHITESPACE",
                                   TokenPattern.REGEXP_TYPE,
                                   "[ \\t\\n\\r]+");
        pattern.setIgnore();
        addPattern(pattern);
    }

View Full Code Here

     *
     * @throws ParserCreationException if the tokenizer couldn't be
     *             initialized correctly
     */
    private void createPatterns() throws ParserCreationException {
        TokenPattern  pattern;


        pattern = new TokenPattern(RegexpConstants.LEFT_PAREN,
                                   "LEFT_PAREN",
                                   TokenPattern.STRING_TYPE,
                                   "(");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.RIGHT_PAREN,
                                   "RIGHT_PAREN",
                                   TokenPattern.STRING_TYPE,
                                   ")");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.LEFT_BRACKET,
                                   "LEFT_BRACKET",
                                   TokenPattern.STRING_TYPE,
                                   "[");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.RIGHT_BRACKET,
                                   "RIGHT_BRACKET",
                                   TokenPattern.STRING_TYPE,
                                   "]");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.LEFT_BRACE,
                                   "LEFT_BRACE",
                                   TokenPattern.STRING_TYPE,
                                   "{");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.RIGHT_BRACE,
                                   "RIGHT_BRACE",
                                   TokenPattern.STRING_TYPE,
                                   "}");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.QUESTION,
                                   "QUESTION",
                                   TokenPattern.STRING_TYPE,
                                   "?");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.ASTERISK,
                                   "ASTERISK",
                                   TokenPattern.STRING_TYPE,
                                   "*");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.PLUS,
                                   "PLUS",
                                   TokenPattern.STRING_TYPE,
                                   "+");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.VERTICAL_BAR,
                                   "VERTICAL_BAR",
                                   TokenPattern.STRING_TYPE,
                                   "|");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.DOT,
                                   "DOT",
                                   TokenPattern.STRING_TYPE,
                                   ".");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.COMMA,
                                   "COMMA",
                                   TokenPattern.STRING_TYPE,
                                   ",");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.NUMBER,
                                   "NUMBER",
                                   TokenPattern.REGEXP_TYPE,
                                   "[0-9]+");
        addPattern(pattern);


        pattern = new TokenPattern(RegexpConstants.CHAR,
                                   "CHAR",
                                   TokenPattern.REGEXP_TYPE,
                                   "(\\\\.)|.");
        addPattern(pattern);
    }

View Full Code Here

     *
     * @throws ParserCreationException if the tokenizer couldn't be
     *             initialized correctly
     */
    private void createPatterns() throws ParserCreationException {
        TokenPattern  pattern;


        pattern = new TokenPattern(Asn1Constants.DOT,
                                   "DOT",
                                   TokenPattern.STRING_TYPE,
                                   ".");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.DOUBLE_DOT,
                                   "DOUBLE_DOT",
                                   TokenPattern.STRING_TYPE,
                                   "..");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.TRIPLE_DOT,
                                   "TRIPLE_DOT",
                                   TokenPattern.STRING_TYPE,
                                   "...");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.COMMA,
                                   "COMMA",
                                   TokenPattern.STRING_TYPE,
                                   ",");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.SEMI_COLON,
                                   "SEMI_COLON",
                                   TokenPattern.STRING_TYPE,
                                   ";");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.LEFT_PAREN,
                                   "LEFT_PAREN",
                                   TokenPattern.STRING_TYPE,
                                   "(");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.RIGHT_PAREN,
                                   "RIGHT_PAREN",
                                   TokenPattern.STRING_TYPE,
                                   ")");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.LEFT_BRACE,
                                   "LEFT_BRACE",
                                   TokenPattern.STRING_TYPE,
                                   "{");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.RIGHT_BRACE,
                                   "RIGHT_BRACE",
                                   TokenPattern.STRING_TYPE,
                                   "}");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.LEFT_BRACKET,
                                   "LEFT_BRACKET",
                                   TokenPattern.STRING_TYPE,
                                   "[");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.RIGHT_BRACKET,
                                   "RIGHT_BRACKET",
                                   TokenPattern.STRING_TYPE,
                                   "]");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MINUS,
                                   "MINUS",
                                   TokenPattern.STRING_TYPE,
                                   "-");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.LESS_THAN,
                                   "LESS_THAN",
                                   TokenPattern.STRING_TYPE,
                                   "<");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.VERTICAL_BAR,
                                   "VERTICAL_BAR",
                                   TokenPattern.STRING_TYPE,
                                   "|");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.DEFINITION,
                                   "DEFINITION",
                                   TokenPattern.STRING_TYPE,
                                   "::=");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.DEFINITIONS,
                                   "DEFINITIONS",
                                   TokenPattern.STRING_TYPE,
                                   "DEFINITIONS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.EXPLICIT,
                                   "EXPLICIT",
                                   TokenPattern.STRING_TYPE,
                                   "EXPLICIT");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.IMPLICIT,
                                   "IMPLICIT",
                                   TokenPattern.STRING_TYPE,
                                   "IMPLICIT");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.TAGS,
                                   "TAGS",
                                   TokenPattern.STRING_TYPE,
                                   "TAGS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.BEGIN,
                                   "BEGIN",
                                   TokenPattern.STRING_TYPE,
                                   "BEGIN");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.END,
                                   "END",
                                   TokenPattern.STRING_TYPE,
                                   "END");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.EXPORTS,
                                   "EXPORTS",
                                   TokenPattern.STRING_TYPE,
                                   "EXPORTS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.IMPORTS,
                                   "IMPORTS",
                                   TokenPattern.STRING_TYPE,
                                   "IMPORTS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.FROM,
                                   "FROM",
                                   TokenPattern.STRING_TYPE,
                                   "FROM");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MACRO,
                                   "MACRO",
                                   TokenPattern.STRING_TYPE,
                                   "MACRO");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.INTEGER,
                                   "INTEGER",
                                   TokenPattern.STRING_TYPE,
                                   "INTEGER");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.REAL,
                                   "REAL",
                                   TokenPattern.STRING_TYPE,
                                   "REAL");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.BOOLEAN,
                                   "BOOLEAN",
                                   TokenPattern.STRING_TYPE,
                                   "BOOLEAN");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.NULL,
                                   "NULL",
                                   TokenPattern.STRING_TYPE,
                                   "NULL");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.BIT,
                                   "BIT",
                                   TokenPattern.STRING_TYPE,
                                   "BIT");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.OCTET,
                                   "OCTET",
                                   TokenPattern.STRING_TYPE,
                                   "OCTET");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.STRING,
                                   "STRING",
                                   TokenPattern.STRING_TYPE,
                                   "STRING");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.ENUMERATED,
                                   "ENUMERATED",
                                   TokenPattern.STRING_TYPE,
                                   "ENUMERATED");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.SEQUENCE,
                                   "SEQUENCE",
                                   TokenPattern.STRING_TYPE,
                                   "SEQUENCE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.SET,
                                   "SET",
                                   TokenPattern.STRING_TYPE,
                                   "SET");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.OF,
                                   "OF",
                                   TokenPattern.STRING_TYPE,
                                   "OF");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.CHOICE,
                                   "CHOICE",
                                   TokenPattern.STRING_TYPE,
                                   "CHOICE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.UNIVERSAL,
                                   "UNIVERSAL",
                                   TokenPattern.STRING_TYPE,
                                   "UNIVERSAL");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.APPLICATION,
                                   "APPLICATION",
                                   TokenPattern.STRING_TYPE,
                                   "APPLICATION");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.PRIVATE,
                                   "PRIVATE",
                                   TokenPattern.STRING_TYPE,
                                   "PRIVATE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.ANY,
                                   "ANY",
                                   TokenPattern.STRING_TYPE,
                                   "ANY");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.DEFINED,
                                   "DEFINED",
                                   TokenPattern.STRING_TYPE,
                                   "DEFINED");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.BY,
                                   "BY",
                                   TokenPattern.STRING_TYPE,
                                   "BY");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.OBJECT,
                                   "OBJECT",
                                   TokenPattern.STRING_TYPE,
                                   "OBJECT");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.IDENTIFIER,
                                   "IDENTIFIER",
                                   TokenPattern.STRING_TYPE,
                                   "IDENTIFIER");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.INCLUDES,
                                   "INCLUDES",
                                   TokenPattern.STRING_TYPE,
                                   "INCLUDES");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MIN,
                                   "MIN",
                                   TokenPattern.STRING_TYPE,
                                   "MIN");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MAX,
                                   "MAX",
                                   TokenPattern.STRING_TYPE,
                                   "MAX");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.SIZE,
                                   "SIZE",
                                   TokenPattern.STRING_TYPE,
                                   "SIZE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.WITH,
                                   "WITH",
                                   TokenPattern.STRING_TYPE,
                                   "WITH");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.COMPONENT,
                                   "COMPONENT",
                                   TokenPattern.STRING_TYPE,
                                   "COMPONENT");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.COMPONENTS,
                                   "COMPONENTS",
                                   TokenPattern.STRING_TYPE,
                                   "COMPONENTS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.PRESENT,
                                   "PRESENT",
                                   TokenPattern.STRING_TYPE,
                                   "PRESENT");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.ABSENT,
                                   "ABSENT",
                                   TokenPattern.STRING_TYPE,
                                   "ABSENT");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.OPTIONAL,
                                   "OPTIONAL",
                                   TokenPattern.STRING_TYPE,
                                   "OPTIONAL");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.DEFAULT,
                                   "DEFAULT",
                                   TokenPattern.STRING_TYPE,
                                   "DEFAULT");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.TRUE,
                                   "TRUE",
                                   TokenPattern.STRING_TYPE,
                                   "TRUE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.FALSE,
                                   "FALSE",
                                   TokenPattern.STRING_TYPE,
                                   "FALSE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.PLUS_INFINITY,
                                   "PLUS_INFINITY",
                                   TokenPattern.STRING_TYPE,
                                   "PLUS-INFINITY");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MINUS_INFINITY,
                                   "MINUS_INFINITY",
                                   TokenPattern.STRING_TYPE,
                                   "MINUS-INFINITY");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MODULE_IDENTITY,
                                   "MODULE_IDENTITY",
                                   TokenPattern.STRING_TYPE,
                                   "MODULE-IDENTITY");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.OBJECT_IDENTITY,
                                   "OBJECT_IDENTITY",
                                   TokenPattern.STRING_TYPE,
                                   "OBJECT-IDENTITY");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.OBJECT_TYPE,
                                   "OBJECT_TYPE",
                                   TokenPattern.STRING_TYPE,
                                   "OBJECT-TYPE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.NOTIFICATION_TYPE,
                                   "NOTIFICATION_TYPE",
                                   TokenPattern.STRING_TYPE,
                                   "NOTIFICATION-TYPE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.TRAP_TYPE,
                                   "TRAP_TYPE",
                                   TokenPattern.STRING_TYPE,
                                   "TRAP-TYPE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.TEXTUAL_CONVENTION,
                                   "TEXTUAL_CONVENTION",
                                   TokenPattern.STRING_TYPE,
                                   "TEXTUAL-CONVENTION");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.OBJECT_GROUP,
                                   "OBJECT_GROUP",
                                   TokenPattern.STRING_TYPE,
                                   "OBJECT-GROUP");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.NOTIFICATION_GROUP,
                                   "NOTIFICATION_GROUP",
                                   TokenPattern.STRING_TYPE,
                                   "NOTIFICATION-GROUP");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MODULE_COMPLIANCE,
                                   "MODULE_COMPLIANCE",
                                   TokenPattern.STRING_TYPE,
                                   "MODULE-COMPLIANCE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.AGENT_CAPABILITIES,
                                   "AGENT_CAPABILITIES",
                                   TokenPattern.STRING_TYPE,
                                   "AGENT-CAPABILITIES");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.LAST_UPDATED,
                                   "LAST_UPDATED",
                                   TokenPattern.STRING_TYPE,
                                   "LAST-UPDATED");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.ORGANIZATION,
                                   "ORGANIZATION",
                                   TokenPattern.STRING_TYPE,
                                   "ORGANIZATION");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.CONTACT_INFO,
                                   "CONTACT_INFO",
                                   TokenPattern.STRING_TYPE,
                                   "CONTACT-INFO");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.DESCRIPTION,
                                   "DESCRIPTION",
                                   TokenPattern.STRING_TYPE,
                                   "DESCRIPTION");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.REVISION,
                                   "REVISION",
                                   TokenPattern.STRING_TYPE,
                                   "REVISION");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.STATUS,
                                   "STATUS",
                                   TokenPattern.STRING_TYPE,
                                   "STATUS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.REFERENCE,
                                   "REFERENCE",
                                   TokenPattern.STRING_TYPE,
                                   "REFERENCE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.SYNTAX,
                                   "SYNTAX",
                                   TokenPattern.STRING_TYPE,
                                   "SYNTAX");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.BITS,
                                   "BITS",
                                   TokenPattern.STRING_TYPE,
                                   "BITS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.UNITS,
                                   "UNITS",
                                   TokenPattern.STRING_TYPE,
                                   "UNITS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.ACCESS,
                                   "ACCESS",
                                   TokenPattern.STRING_TYPE,
                                   "ACCESS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MAX_ACCESS,
                                   "MAX_ACCESS",
                                   TokenPattern.STRING_TYPE,
                                   "MAX-ACCESS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MIN_ACCESS,
                                   "MIN_ACCESS",
                                   TokenPattern.STRING_TYPE,
                                   "MIN-ACCESS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.INDEX,
                                   "INDEX",
                                   TokenPattern.STRING_TYPE,
                                   "INDEX");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.AUGMENTS,
                                   "AUGMENTS",
                                   TokenPattern.STRING_TYPE,
                                   "AUGMENTS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.IMPLIED,
                                   "IMPLIED",
                                   TokenPattern.STRING_TYPE,
                                   "IMPLIED");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.DEFVAL,
                                   "DEFVAL",
                                   TokenPattern.STRING_TYPE,
                                   "DEFVAL");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.OBJECTS,
                                   "OBJECTS",
                                   TokenPattern.STRING_TYPE,
                                   "OBJECTS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.ENTERPRISE,
                                   "ENTERPRISE",
                                   TokenPattern.STRING_TYPE,
                                   "ENTERPRISE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.VARIABLES,
                                   "VARIABLES",
                                   TokenPattern.STRING_TYPE,
                                   "VARIABLES");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.DISPLAY_HINT,
                                   "DISPLAY_HINT",
                                   TokenPattern.STRING_TYPE,
                                   "DISPLAY-HINT");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.NOTIFICATIONS,
                                   "NOTIFICATIONS",
                                   TokenPattern.STRING_TYPE,
                                   "NOTIFICATIONS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MODULE,
                                   "MODULE",
                                   TokenPattern.STRING_TYPE,
                                   "MODULE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.MANDATORY_GROUPS,
                                   "MANDATORY_GROUPS",
                                   TokenPattern.STRING_TYPE,
                                   "MANDATORY-GROUPS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.GROUP,
                                   "GROUP",
                                   TokenPattern.STRING_TYPE,
                                   "GROUP");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.WRITE_SYNTAX,
                                   "WRITE_SYNTAX",
                                   TokenPattern.STRING_TYPE,
                                   "WRITE-SYNTAX");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.PRODUCT_RELEASE,
                                   "PRODUCT_RELEASE",
                                   TokenPattern.STRING_TYPE,
                                   "PRODUCT-RELEASE");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.SUPPORTS,
                                   "SUPPORTS",
                                   TokenPattern.STRING_TYPE,
                                   "SUPPORTS");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.VARIATION,
                                   "VARIATION",
                                   TokenPattern.STRING_TYPE,
                                   "VARIATION");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.CREATION_REQUIRES,
                                   "CREATION_REQUIRES",
                                   TokenPattern.STRING_TYPE,
                                   "CREATION-REQUIRES");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.BINARY_STRING,
                                   "BINARY_STRING",
                                   TokenPattern.REGEXP_TYPE,
                                   "'[0-1]*'(B|b)");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.HEXADECIMAL_STRING,
                                   "HEXADECIMAL_STRING",
                                   TokenPattern.REGEXP_TYPE,
                                   "'[0-9A-Fa-f]*'(H|h)");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.QUOTED_STRING,
                                   "QUOTED_STRING",
                                   TokenPattern.REGEXP_TYPE,
                                   "\"([^\"]|\"\")*\"");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.IDENTIFIER_STRING,
                                   "IDENTIFIER_STRING",
                                   TokenPattern.REGEXP_TYPE,
                                   "[a-zA-Z][a-zA-Z0-9-_]*");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.NUMBER_STRING,
                                   "NUMBER_STRING",
                                   TokenPattern.REGEXP_TYPE,
                                   "[0-9]+");
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.WHITESPACE,
                                   "WHITESPACE",
                                   TokenPattern.REGEXP_TYPE,
                                   "[ \\t\\n\\r\\f\\x0b\\x17\\x18\\x19\\x1a]+");
        pattern.setIgnore();
        addPattern(pattern);


        pattern = new TokenPattern(Asn1Constants.COMMENT,
                                   "COMMENT",
                                   TokenPattern.REGEXP_TYPE,
                                   "--([^\\n\\r-]|-[^\\n\\r-])*(--|-?[\\n\\r])");
        pattern.setIgnore();
        addPattern(pattern);
    }

View Full Code Here

TOP

Related Classes of net.percederberg.grammatica.parser.TokenPattern

net.percederberg.grammatica.FirstPassAnalyzer

net.percederberg.grammatica.GrammarTokenizer

net.percederberg.grammatica.output.CSharpParserGenerator

net.percederberg.grammatica.output.JavaParserGenerator

net.percederberg.grammatica.output.VisualBasicParserGenerator

net.percederberg.grammatica.SecondPassAnalyzer

net.percederberg.grammatica.test.ArithmeticTokenizer

net.percederberg.grammatica.test.RegexpTokenizer

net.percederberg.mibble.asn1.Asn1Tokenizer

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.