IntegralPointerInstructionRegister Class Reference

#include <IntegralPointerInstruction.h>

Inheritance diagram for IntegralPointerInstructionRegister:

List of all members.

Static Public Member Functions
static void	registerInstructions ()
Static Private Member Functions
template<template< typename > class INSTCLASS2>
static void	registerTypes (vector< StandardTypeDescriptorOrdinal > const &t)
template<typename TYPE1, template< typename > class INSTCLASS>
static void	registerInstance (StandardTypeDescriptorOrdinal type)
template<typename IGNOREDDATATYPE, class INSTCLASS>
static void	registerInstance (StandardTypeDescriptorOrdinal type)
template<typename TYPE1, typename TYPE2, template< typename, typename > class INSTCLASS>
static void	registerInstance2 (StandardTypeDescriptorOrdinal type1, StandardTypeDescriptorOrdinal type2)

---

Detailed Description

Definition at line 204 of file IntegralPointerInstruction.h.

---

Member Function Documentation

template<template< typename > class INSTCLASS2>

static void IntegralPointerInstructionRegister::registerTypes

(

vector< StandardTypeDescriptorOrdinal > const &

t

)

[inline, static, private]

Definition at line 210 of file IntegralPointerInstruction.h.

                                                                  {

        for (uint i = 0; i < t.size(); i++) {
            StandardTypeDescriptorOrdinal type = t[i];
            // Type <char> below is a placeholder and is ignored.
            InstructionSignature sig = INSTCLASS2<char>::signature(type);
            switch (type) {
                // Array_Text, below, does not allow assembly programs
                // of to have say, pointer to int16s, but the language
                // does not have pointers defined other than
                // c,vc,b,vb, so this is OK for now.
#define Fennel_InstructionRegisterSwitch_Array 1
#include "fennel/calculator/InstructionRegisterSwitch.h"
            default:
                throw std::logic_error("Default InstructionRegister");
            }
        }
    }

static void IntegralPointerInstructionRegister::registerInstructions

(

)

[inline, static]

Definition at line 231 of file IntegralPointerInstruction.h.

References StandardTypeDescriptor::isArray(), and InstructionSignature::typeVector().

Referenced by InstructionFactory::registerInstructions().

                           {
        vector<StandardTypeDescriptorOrdinal> t;
        // isArray, below, does not allow assembly programs of to
        // have say, pointer to int16s, but the language does not have
        // pointers defined other than c,vc,b,vb, so this is OK for now.
        t = InstructionSignature::typeVector(StandardTypeDescriptor::isArray);

        // Have to do full fennel:: qualification of template
        // arguments below to prevent template argument 'TMPLT', of
        // this encapsulating class, from perverting NativeAdd into
        // NativeAdd<TMPLT> or something like
        // that. Anyway. Fennel::NativeAdd works just fine.
        registerTypes<fennel::PointerGetSize>(t);
        registerTypes<fennel::PointerGetMaxSize>(t);
    }

template<typename TYPE1, template< typename > class INSTCLASS>

static void InstructionRegister::registerInstance

(

StandardTypeDescriptorOrdinal

type

)

[inline, static, protected, inherited]

Definition at line 139 of file Instruction.h.

References InstructionFactory::getInstructionTable().

Referenced by ReturnInstructionRegister::registerInstructions().

    {
        StringToCreateFn* instMap = InstructionFactory::getInstructionTable();
        (*instMap)[INSTCLASS<TYPE1>::signature(type).compute()] =
            &INSTCLASS<TYPE1>::create;
    }

template<typename IGNOREDDATATYPE, class INSTCLASS>

static void InstructionRegister::registerInstance

(

StandardTypeDescriptorOrdinal

type

)

[inline, static, protected, inherited]

Definition at line 161 of file Instruction.h.

References InstructionFactory::getInstructionTable().

    {
        StringToCreateFn* instMap = InstructionFactory::getInstructionTable();
        (*instMap)[INSTCLASS::signature(type).compute()] =
            &INSTCLASS::create;
    }

template<typename TYPE1, typename TYPE2, template< typename, typename > class INSTCLASS>

static void InstructionRegister::registerInstance2	(	StandardTypeDescriptorOrdinal	type1,
		StandardTypeDescriptorOrdinal	type2
	)			[inline, static, protected, inherited]

Definition at line 150 of file Instruction.h.

References InstructionFactory::getInstructionTable().

    {
        StringToCreateFn* instMap = InstructionFactory::getInstructionTable();
        (*instMap)[INSTCLASS<TYPE1,TYPE2>::signature(type1, type2).compute()] =
            &INSTCLASS<TYPE1,TYPE2>::create;
    }

---

The documentation for this class was generated from the following file:

• /home/pub/open/dev/fennel/calculator/IntegralPointerInstruction.h

---