InstructionFactory.cpp

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/calculator/InstructionFactory.cpp#2 $
// 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
*/
#include "fennel/common/CommonPreamble.h"
#include "fennel/calculator/InstructionFactory.h"
#include "fennel/calculator/InstructionCommon.h"

FENNEL_BEGIN_CPPFILE("$Id: //open/dev/fennel/calculator/InstructionFactory.cpp#2 $");

StringToCreateFn InstructionFactory::instructionTable;
ExtendedInstructionTable InstructionFactory::extendedTable;

// Create a typical instruction
Instruction*
InstructionFactory::createInstruction(
    string const & name,
    vector<RegisterReference*> const &operands)
{
    InstructionSignature signature(name, operands);
    return createInstructionHelper(signature);
}

// Create a Jump instruction
Instruction*
InstructionFactory::createInstruction(
    string const & name,
    TProgramCounter pc,
    RegisterReference* operand)
{
    vector<RegisterReference*> v;
    if (operand) {
        v.push_back(operand);
    }

    InstructionSignature signature(name, pc, v);
    return createInstructionHelper(signature);
}

Instruction*
InstructionFactory::createInstructionHelper(InstructionSignature const &sig)
{
    InstructionCreateFunction createFn = instructionTable[sig.compute()];

    if (createFn) {
        return createFn(sig);
    } else {
        throw FennelExcn(sig.compute() + " is not a registered instruction");
    }
}

// Create an Extended instruction
Instruction*
InstructionFactory::createInstruction(
    string const & name,
    string const & function,
    vector<RegisterReference*> const &operands)
{
    InstructionSignature signature(function, operands);
    ExtendedInstructionDef* instDef = extendedTable[signature.compute()];
    if (instDef == NULL) {
        return NULL;
    }
    return instDef->createInstruction(operands);
}

string
InstructionFactory::signatures()
{
    ostringstream s("");

    StringToCreateFnIter i = instructionTable.begin();
    StringToCreateFnIter end = instructionTable.end();

    while (i != end) {
        s << (*i).first << endl;
        i++;
    }
    return s.str();
}

string
InstructionFactory::extendedSignatures()
{
    return extendedTable.signatures();
}

void
InstructionFactory::registerInstructions()
{
    BoolInstructionRegister::registerInstructions();
    BoolNativeInstructionRegister::registerInstructions();
    BoolPointerInstructionRegister::registerInstructions();
    CastInstructionRegister::registerInstructions();
    IntegralNativeInstructionRegister::registerInstructions();
    IntegralPointerInstructionRegister::registerInstructions();
    JumpInstructionRegister::registerInstructions();
    NativeNativeInstructionRegister::registerInstructions();
    PointerIntegralInstructionRegister::registerInstructions();
    PointerPointerInstructionRegister::registerInstructions();
    ReturnInstructionRegister::registerInstructions();
}

FENNEL_END_CPPFILE("$Id: //open/dev/fennel/calculator/InstructionFactory.cpp#2 $");

// End InstructionFactory.cpp

---