CalcAssembler.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/calculator/CalcAssembler.h#3 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2004-2009 SQLstream, Inc.
// Copyright (C) 2009-2009 LucidEra, Inc.
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_CalcAssembler_Included
#define Fennel_CalcAssembler_Included

#include "fennel/calculator/CalcLexer.h"
#include "fennel/calculator/CalcAssemblerException.h"
#include "fennel/calculator/InstructionFactory.h"

#include <strstream>

FENNEL_BEGIN_NAMESPACE

using namespace std;

typedef size_t TRegisterIndex;

class Calculator;
class RegisterReference;
class TupleDescriptor;
class StoredTypeDescriptorFactory;

extern int CalcYYparse (void *);

class FENNEL_CALCULATOR_EXPORT CalcAssembler
{
public:
    explicit
    CalcAssembler(Calculator* calc) {
        assert(calc != NULL);
        mCalc = calc;
    }

    ~CalcAssembler();

    CalcLexer&  getLexer() {
        return mLexer;
    }

    int   assemble(const char* program);
    int   assemble();

    // Functions for creating objects for the calculator
    static TupleData*
    createTupleData(
        TupleDescriptor const& tupleDes,
        FixedBuffer** buf);

    static RegisterReference*
    createRegisterReference(
        RegisterReference::ERegisterSet setIndex,
        TRegisterIndex                  regIndex,
        StandardTypeDescriptorOrdinal   regType);

    static Instruction*
    createInstruction(
        string& name,
        vector<RegisterReference*> const &operands,
        CalcYYLocType& location)
    {
        Instruction* inst = NULL;
        try {
            inst = InstructionFactory::createInstruction(name, operands);
        } catch (FennelExcn& ex) {
            throw CalcAssemblerException(ex.getMessage(), location);
        } catch (std::exception& ex) {
            throw CalcAssemblerException(ex.what(), location);
        }
        if (inst == NULL) {
            string error;
            error = "Error instantiating instruction: " + name;
            if (operands.size() > 0) {
                error += " ";
                int i;
                for (i = 0; i < operands.size(); i++) {
                    error += operands[i]->toString();
                    if (i + 1 < operands.size()) {
                        error += ", ";
                    }
                }
            }
            throw CalcAssemblerException(error, location);
        }
        return inst;
    }

    static Instruction* createInstruction(
        string& name,
        RegisterReference* result,
        RegisterReference* operand1,
        RegisterReference* operand2,
        CalcYYLocType& location)
    {
        vector<RegisterReference*> operands;
        operands.push_back(result);
        operands.push_back(operand1);
        operands.push_back(operand2);
        return createInstruction(name, operands, location);
    }


    static Instruction* createInstruction(
        string& name,
        RegisterReference* result,
        RegisterReference* operand1,
        CalcYYLocType& location)
    {
        vector<RegisterReference*> operands;
        operands.push_back(result);
        operands.push_back(operand1);
        return createInstruction(name, operands, location);
    }

    static Instruction* createInstruction(
        string& name,
        RegisterReference* result,
        CalcYYLocType& location)
    {
        vector<RegisterReference*> operands;
        operands.push_back(result);
        return createInstruction(name, operands, location);
    }

    static Instruction* createInstruction(
        string& name,
        CalcYYLocType& location)
    {
        vector<RegisterReference*> operands;
        return createInstruction(name, operands, location);
    }

    static Instruction* createInstruction(
        string& name,
        TProgramCounter pc,
        CalcYYLocType& location)
    {
        return createInstruction(name, pc, NULL, location);
    }


    static Instruction* createInstruction(
        string& name,
        TProgramCounter pc,
        RegisterReference* operand,
        CalcYYLocType& location)
    {
        Instruction* inst = NULL;

        try {
            inst = InstructionFactory::createInstruction(name, pc, operand);
        } catch (FennelExcn& ex) {
            throw CalcAssemblerException(ex.getMessage(), location);
        } catch (std::exception& ex) {
            throw CalcAssemblerException(ex.what(), location);
        }

        if (inst == NULL) {
            stringstream errorStr("Error instantiating instruction: ");
            errorStr << name << " " << pc << ", ";
            if (operand) {
                errorStr << operand->toString();
            }
            throw CalcAssemblerException(errorStr.str(), location);
        }
        return inst;
    }

    Instruction* createInstruction(
        string& name,
        string& function,
        vector<RegisterReference*>& operands,
        CalcYYLocType& location)
    {
        Instruction* inst = NULL;

        try {
            inst = InstructionFactory::createInstruction(
                name, function, operands);
        } catch (FennelExcn& ex) {
            throw CalcAssemblerException(ex.getMessage(), location);
        } catch (std::exception& ex) {
            throw CalcAssemblerException(ex.what(), location);
        }

        if (inst == NULL) {
            InstructionSignature sig(function, operands);
            stringstream errorStr("Error instantiating instruction: ");
            errorStr << name << " ";
            errorStr << sig.compute();
            errorStr << " not registered ";
            throw CalcAssemblerException(errorStr.str(), location);
        }

        return inst;
    }

    static void setTupleDatum(
        StandardTypeDescriptorOrdinal type,
        TupleDatum& tupleDatum,
        TupleAttributeDescriptor& desc,
        double value);
    static void setTupleDatum(
        StandardTypeDescriptorOrdinal type,
        TupleDatum& tupleDatum,
        TupleAttributeDescriptor& desc,
        uint64_t value);
    static void setTupleDatum(
        StandardTypeDescriptorOrdinal type,
        TupleDatum& tupleDatum,
        TupleAttributeDescriptor& desc,
        int64_t value);
    static void setTupleDatum(
        StandardTypeDescriptorOrdinal type,
        TupleDatum& tupleDatum,
        TupleAttributeDescriptor& desc,
        string value);
    static void setTupleDatum(
        StandardTypeDescriptorOrdinal type,
        TupleDatum& tupleDatum,
        TupleAttributeDescriptor& desc,
        PConstBuffer buffer);

protected:
    friend int CalcYYparse (void *);

    // Protected functions that are used by CalcYYparse

    void  init();

    void allocateTuples();

    void bindRegisters();

    template <typename T>
    void bindRegisterValue(
        RegisterReference::ERegisterSet setIndex,
        TRegisterIndex regIndex,
        T value)
    {
        try {
            StandardTypeDescriptorOrdinal regType = getRegisterType(
                setIndex, regIndex);
            TupleData* tupleData = getTupleData(setIndex);
            assert(tupleData != NULL);
            TupleDatum& tupleDatum = (*tupleData)[regIndex];
            TupleDescriptor& tupleDesc = getTupleDescriptor(setIndex);
            setTupleDatum(regType, tupleDatum, tupleDesc[regIndex], value);
        } catch (CalcAssemblerException& ex) {
            // Just pass this exception up
            throw ex;
        } catch (FennelExcn& ex) {
            // Other exception - let's make the error clearer
            ostringstream errorStr("");
            errorStr << "Error binding register "
                     << RegisterReference::toString(setIndex, regIndex)
                     << ": " << ex.getMessage();
            throw CalcAssemblerException(
                errorStr.str(), getLexer().getLocation());
        } catch (exception& ex) {
            // Other exception - let's make the error clearer
            ostringstream errorStr("");
            errorStr << "Error binding register: "
                     << RegisterReference::toString(setIndex, regIndex)
                     << ": " << ex.what();
            throw CalcAssemblerException(
                errorStr.str(), getLexer().getLocation());
        }
    }

    template <typename T>
    void bindNextLiteral(T value)
    {
        bindRegisterValue<T>(RegisterReference::ELiteral, mLiteralIndex, value);
        mLiteralIndex++;
    }

    void bindLiteralDone();

    // CalcYYparse uses the two functions below to add a register

    void selectRegisterSet(RegisterReference::ERegisterSet setIndex);

    void addRegister(
        StandardTypeDescriptorOrdinal regType,
        uint cbStorage = 0);

    void addRegister(
        RegisterReference::ERegisterSet setIndex,
        StandardTypeDescriptorOrdinal regType,
        uint cbStorage = 0);


    // CalcYYparse uses this function to add a instruction

    void addInstruction(Instruction* inst);

    // Functions used by CalcYYparse to access registers and tuples

    TRegisterIndex getRegisterSize(RegisterReference::ERegisterSet setIndex);

    RegisterReference* getRegister(
        RegisterReference::ERegisterSet setIndex,
        TRegisterIndex regIndex);

    StandardTypeDescriptorOrdinal  getRegisterType(
        RegisterReference::ERegisterSet setIndex,
        TRegisterIndex regIndex);

    TupleData* getTupleData(RegisterReference::ERegisterSet setIndex);

    TupleDescriptor& getTupleDescriptor(
        RegisterReference::ERegisterSet setIndex);

    void checkPC(TProgramCounter pc, CalcYYLocType& loc) {
        assert(mCalc->mCode.size() > 0);
        if (pc >= static_cast<TProgramCounter>(mCalc->mCode.size())) {
            ostringstream errorStr("");
            errorStr << "Invalid PC " << pc << ": PC should be between 0 and "
                     << (mCalc->mCode.size() - 1);
            throw CalcAssemblerException(errorStr.str(), loc);
        }
    }

    void saveMaxPC(TProgramCounter pc)
    {
        assert(pc > 0);
        if (pc > mMaxPC) {
            mMaxPC = pc;
            mMaxPCLoc = getLexer().getLocation();
        }
    }

protected:
    CalcLexer   mLexer; 
    Calculator* mCalc;  

    TupleDescriptor mRegisterSetDescriptor[RegisterReference::ELastSet];

    TupleData* mRegisterTupleData[RegisterReference::ELastSet];
    FixedBuffer* mBuffers[RegisterReference::ELastSet];

    StandardTypeDescriptorFactory   mTypeFactory;

    RegisterReference::ERegisterSet mCurrentRegSet;

    TRegisterIndex                  mLiteralIndex;

    TProgramCounter mMaxPC;
    CalcYYLocType   mMaxPCLoc;
};

FENNEL_END_NAMESPACE

#endif

// End CalcAssembler.h

---