parser.hh

/*
 * Copyright (c) 2014 David Chisnall
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include "ast.hh"

namespace Parser
{
    using pegmatite::Rule;
    using pegmatite::operator""_E;
    using pegmatite::ExprPtr;
    using pegmatite::BindAST;
    using pegmatite::any;
    using pegmatite::nl;

    struct CellAtomGrammar
    {
        Rule whitespace  = ' '_E | '\t' | nl('\n');
        Rule comment     = '"' >>
                           (*(!ExprPtr('"'_E) >> (nl('\n') | any()))) >>
                           '"';
        Rule ignored     = *(comment | whitespace);
        Rule digit       = '0'_E - '9';
        Rule literal     = +digit;
        Rule v_reg       = 'v'_E;
        Rule local_reg   = 'a' >> digit;
        Rule global_reg  = 'g' >> digit;
        Rule reg         = v_reg | local_reg | global_reg;
        Rule op          = '+'_E | '=' |'-' | '*' | '/' | "min" | "max";
        Rule arithmetic  = op >> reg >> expression;
        Rule neighbours  = "neighbours"_E >> '(' >> statements >> ')';
        Rule range       = literal | ('('_E >> literal >> ',' >> literal >> ')');
        Rule range_expr  = range >> "=>" >> expression;
        Rule range_map   = '['_E >> reg >> '|' >>
                            +range_expr >> *(','_E >> range_expr) >>']';
        Rule expression  = literal | reg | range_map;
        Rule statement   = neighbours | arithmetic;
        Rule statements  = *statement;
        static const CellAtomGrammar& get()
        {
            static CellAtomGrammar g;
            return g;
        }
        private:
        CellAtomGrammar() {};
    };

    class CellAtomParser : public pegmatite::ASTParserDelegate
    {
#define CONNECT(cls, r) BindAST<AST::cls> r = CellAtomGrammar::get().r
        CONNECT(StatementList, statements);
        CONNECT(Literal, literal);
        CONNECT(Op, op);
        CONNECT(VRegister, v_reg);
        CONNECT(LocalRegister, local_reg);
        CONNECT(GlobalRegister, global_reg);
        CONNECT(Arithmetic, arithmetic);
        CONNECT(Range, range_expr);
        CONNECT(RangeExpr, range_map);
        CONNECT(Neighbours, neighbours);
#undef CONNECT
        public:
        const CellAtomGrammar &g = CellAtomGrammar::get();
    };
}