ast.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.
 */
#ifndef CELLATOM_AST_H_INCLUDED
#define CELLATOM_AST_H_INCLUDED
#include <stdint.h>
#include "Pegmatite/pegmatite.hh"

namespace AST
{
    struct StatementList;
}

namespace Interpreter
{
    struct State;
    void runOneStep(int16_t *oldgrid,
                    int16_t *newgrid,
                    int16_t width,
                    int16_t height,
                    AST::StatementList *ast);
}

namespace Compiler
{
    struct State;
    typedef void(*automaton)(int16_t *oldgrid,
                             int16_t *newgrid,
                             int16_t width,
                             int16_t height);
    automaton compile(AST::StatementList *ast, int optimiseLevel);
}
namespace llvm
{
    class Value;
}

namespace AST
{
    struct Statement : public pegmatite::ASTContainer
    {
        virtual uint16_t interpret(Interpreter::State &) = 0;
        virtual llvm::Value *compile(Compiler::State &) = 0;
    };

    struct StatementList : Statement
    {
        pegmatite::ASTList<Statement> statements;
        uint16_t interpret(Interpreter::State&) override;
        virtual llvm::Value *compile(Compiler::State &) override;
    };

    struct Literal : public Statement
    {
        uint16_t value;
        virtual uint16_t interpret(Interpreter::State &) override;
        virtual void construct(const pegmatite::InputRange &r,
                               pegmatite::ASTStack &st) override;
        virtual llvm::Value *compile(Compiler::State &) override;
    };

    struct Register : public Statement
    {
        virtual uint16_t interpret(Interpreter::State &) = 0;
        virtual void assign(Interpreter::State &, uint16_t) = 0;
        virtual llvm::Value *compile(Compiler::State &) = 0;
        virtual void assign(Compiler::State &, llvm::Value*) = 0;
    };

    struct VRegister : public Register
    {
        virtual uint16_t interpret(Interpreter::State &) override;
        virtual void assign(Interpreter::State &, uint16_t) override;
        virtual llvm::Value *compile(Compiler::State &) override;
        virtual void assign(Compiler::State &, llvm::Value*) override;
    };

    struct LocalRegister : public Register
    {
        int registerNumber;
        virtual void construct(const pegmatite::InputRange &r,
                               pegmatite::ASTStack &st) override;
        virtual uint16_t interpret(Interpreter::State &) override;
        virtual void assign(Interpreter::State &, uint16_t) override;
        virtual llvm::Value *compile(Compiler::State &) override;
        virtual void assign(Compiler::State &, llvm::Value*) override;
    };

    struct GlobalRegister : public Register
    {
        int registerNumber;
        virtual void construct(const pegmatite::InputRange &r,
                               pegmatite::ASTStack &st) override;
        virtual uint16_t interpret(Interpreter::State &) override;
        virtual void assign(Interpreter::State &, uint16_t) override;
        virtual llvm::Value *compile(Compiler::State &) override;
        virtual void assign(Compiler::State &, llvm::Value*) override;
    };
    struct Op: pegmatite::ASTNode
    {
        enum OpKind
        {
            Add,
            Assign,
            Sub,
            Mul,
            Div,
            Min,
            Max
        } op;
        virtual void construct(const pegmatite::InputRange &r,
                               pegmatite::ASTStack &st) override;
    };
    struct Arithmetic : public Statement
    {
        pegmatite::ASTPtr<Op>         op;
        pegmatite::ASTPtr<Register>   target;
        pegmatite::ASTPtr<Statement>  value;
        virtual uint16_t interpret(Interpreter::State &) override;
        virtual llvm::Value *compile(Compiler::State &) override;
    };

    struct Range : public pegmatite::ASTContainer
    {
        pegmatite::ASTPtr<Literal, /* optional */true> start;
        pegmatite::ASTPtr<Literal> end;
        pegmatite::ASTPtr<Statement> value;
    };

    struct RangeExpr : public Statement
    {
        pegmatite::ASTPtr<Register> value;
        pegmatite::ASTList<Range>   ranges;
        virtual uint16_t interpret(Interpreter::State &) override;
        virtual llvm::Value *compile(Compiler::State &) override;
    };

    struct Neighbours : Statement
    {
        pegmatite::ASTPtr<StatementList> statements;
        virtual uint16_t interpret(Interpreter::State &) override;
        virtual llvm::Value *compile(Compiler::State &) override;
    };


}


#endif // CELLATOM_AST_H_INCLUDED