Python: module TCE.base.program

TCE.base.program

index
/opt/tce/lib/python2.5/site-packages/TCE/base/program.so

Classes



Boost.Python.instance(__builtin__.object)

Address

NullAddress

CodeSnippet

Procedure

NullProcedure

Immediate

NullImmediate

Instruction

NullInstruction

InstructionReference
InstructionReferenceManager

NullInstructionReferenceManager

Label

CodeLabel
DataLabel

Move

NullMove

MoveGuard

NullMoveGuard

Program

NullProgram

ProgramWriter
Scope

GlobalScope

NullGlobalScope

Terminal

NullTerminal
TerminalFUPort
TerminalImmediate

TerminalAddress
TerminalInstructionAddress

TerminalRegister

class Address(Boost.Python.instance)


Method resolution order:

Address

Boost.Python.instance

__builtin__.object

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class CodeLabel(Label)


Method resolution order:

CodeLabel

Label

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, TTAProgram::InstructionReference ins, std::string name) -> void* C++ signature:     __init__(_object*, TTAProgram::Procedure proc) -> void*

address(...)
C++ signature:     address(TTAProgram::CodeLabel {lvalue}) -> TTAProgram::Address C++ signature:     address(CodeLabel_wrapper {lvalue}) -> TTAProgram::Address

instructionReference(...)
C++ signature: instructionReference(TTAProgram::CodeLabel {lvalue}) -> TTAProgram::InstructionReference

procedure(...)
C++ signature: procedure(TTAProgram::CodeLabel {lvalue}) -> TTAProgram::Procedure

setName(...)
C++ signature: setName(CodeLabel_wrapper {lvalue}, std::string name) -> void*

setScope(...)
C++ signature: setScope(CodeLabel_wrapper {lvalue}, TTAProgram::Scope scope) -> void*

Data and other attributes defined here:

__instance_size__ = 40

Methods inherited from Label:

name(...)
C++ signature: name(TTAProgram::Label {lvalue}) -> std::string

scope(...)
C++ signature: scope(TTAProgram::Label {lvalue}) -> TTAProgram::Scope

setAddress(...)
C++ signature: setAddress(TTAProgram::Label {lvalue}, TTAProgram::Address address) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class CodeSnippet(Boost.Python.instance)


Method resolution order:

CodeSnippet

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*, TTAProgram::Address start) -> void*

add(...)
C++ signature:     add(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction* ins) -> void* C++ signature:     add(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction* ins) -> void*

addFront(...)
C++ signature:     addFront(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction* ins) -> void* C++ signature:     addFront(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction* ins) -> void*

address(...)
C++ signature:     address(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Address C++ signature:     address(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Address

append(...)
C++ signature:     append(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     append(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     append(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet* cs) -> void* C++ signature:     append(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet* cs) -> void*

clear(...)
C++ signature:     clear(TTAProgram::CodeSnippet {lvalue}) -> void* C++ signature:     clear(CodeSnippet_wrapper {lvalue}) -> void*

copy(...)
C++ signature:     copy(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::CodeSnippet* C++ signature:     copy(CodeSnippet_wrapper {lvalue}) -> TTAProgram::CodeSnippet*

deleteInstructionAt(...)
C++ signature:     deleteInstructionAt(TTAProgram::CodeSnippet {lvalue}, unsigned int address) -> void* C++ signature:     deleteInstructionAt(CodeSnippet_wrapper {lvalue}, unsigned int address) -> void*

endAddress(...)
C++ signature:     endAddress(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Address C++ signature:     endAddress(CodeSnippet_wrapper {lvalue}) -> TTAProgram::Address

firstInstruction(...)
C++ signature: firstInstruction(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Instruction

hasNextInstruction(...)
C++ signature:     hasNextInstruction(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction ins) -> bool C++ signature:     hasNextInstruction(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction ins) -> bool

insertAfter(...)
C++ signature:     insertAfter(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void* C++ signature:     insertAfter(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void* C++ signature:     insertAfter(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction pos, TTAProgram::CodeSnippet cs) -> void* C++ signature:     insertAfter(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::CodeSnippet cs) -> void* C++ signature:     insertAfter(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction pos, TTAProgram::CodeSnippet* cs) -> void* C++ signature:     insertAfter(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::CodeSnippet* cs) -> void*

insertBefore(...)
C++ signature:     insertBefore(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void* C++ signature:     insertBefore(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void* C++ signature:     insertBefore(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction pos, TTAProgram::CodeSnippet cs) -> void* C++ signature:     insertBefore(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::CodeSnippet cs) -> void* C++ signature:     insertBefore(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction pos, TTAProgram::CodeSnippet* cs) -> void* C++ signature:     insertBefore(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::CodeSnippet* cs) -> void*

instructionAt(...)
C++ signature: instructionAt(TTAProgram::CodeSnippet {lvalue}, unsigned int address) -> TTAProgram::Instruction

instructionAtIndex(...)
C++ signature: instructionAtIndex(TTAProgram::CodeSnippet {lvalue}, int index) -> TTAProgram::Instruction

instructionCount(...)
C++ signature:     instructionCount(TTAProgram::CodeSnippet {lvalue}) -> int C++ signature:     instructionCount(CodeSnippet_wrapper {lvalue}) -> int

isInProgram(...)
C++ signature:     isInProgram(TTAProgram::CodeSnippet {lvalue}) -> bool C++ signature:     isInProgram(CodeSnippet_wrapper {lvalue}) -> bool

lastInstruction(...)
C++ signature: lastInstruction(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Instruction

nextInstruction(...)
C++ signature: nextInstruction(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Instruction

parent(...)
C++ signature: parent(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Program

prepend(...)
C++ signature:     prepend(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     prepend(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     prepend(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet* cs) -> void* C++ signature:     prepend(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet* cs) -> void*

previousInstruction(...)
C++ signature: previousInstruction(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Instruction

remove(...)
C++ signature:     remove(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void* C++ signature:     remove(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

removeLastInstruction(...)
C++ signature:     removeLastInstruction(TTAProgram::CodeSnippet {lvalue}) -> void* C++ signature:     removeLastInstruction(CodeSnippet_wrapper {lvalue}) -> void*

setParent(...)
C++ signature:     setParent(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Program {lvalue} prog) -> void* C++ signature:     setParent(CodeSnippet_wrapper {lvalue}, TTAProgram::Program {lvalue} prog) -> void*

setStartAddress(...)
C++ signature:     setStartAddress(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Address start) -> void* C++ signature:     setStartAddress(CodeSnippet_wrapper {lvalue}, TTAProgram::Address start) -> void*

startAddress(...)
C++ signature:     startAddress(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Address C++ signature:     startAddress(CodeSnippet_wrapper {lvalue}) -> TTAProgram::Address

Data and other attributes defined here:

__instance_size__ = 40

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class DataLabel(Label)


Method resolution order:

DataLabel

Label

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, std::string name, TTAProgram::Address address, TTAProgram::Scope scope) -> void*

setName(...)
C++ signature: setName(DataLabel_wrapper {lvalue}, std::string name) -> void*

setScope(...)
C++ signature: setScope(DataLabel_wrapper {lvalue}, TTAProgram::Scope scope) -> void*

Data and other attributes defined here:

__instance_size__ = 32

Methods inherited from Label:

address(...)
C++ signature:     address(TTAProgram::Label {lvalue}) -> TTAProgram::Address C++ signature:     address(Label_wrapper {lvalue}) -> TTAProgram::Address

name(...)
C++ signature: name(TTAProgram::Label {lvalue}) -> std::string

scope(...)
C++ signature: scope(TTAProgram::Label {lvalue}) -> TTAProgram::Scope

setAddress(...)
C++ signature: setAddress(TTAProgram::Label {lvalue}, TTAProgram::Address address) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class GlobalScope(Scope)


Method resolution order:

GlobalScope

Scope

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*) -> void*

addChild(...)
C++ signature: addChild(GlobalScope_wrapper {lvalue}, TTAProgram::Scope scope) -> void*

addGlobalCodeLabel(...)
C++ signature: addGlobalCodeLabel(GlobalScope_wrapper {lvalue}, TTAProgram::CodeLabel codeLabel, TTAProgram::Scope owner) -> void*

addGlobalDataLabel(...)
C++ signature: addGlobalDataLabel(GlobalScope_wrapper {lvalue}, TTAProgram::DataLabel codeLabel, TTAProgram::Scope owner) -> void*

child(...)
C++ signature: child(GlobalScope_wrapper {lvalue}, int index) -> TTAProgram::Scope

childCount(...)
C++ signature: childCount(GlobalScope_wrapper {lvalue}) -> int

copy(...)
C++ signature:     copy(TTAProgram::GlobalScope {lvalue}) -> TTAProgram::Scope* C++ signature:     copy(GlobalScope_wrapper {lvalue}) -> TTAProgram::Scope*

copyAndRelocate(...)
C++ signature:     copyAndRelocate(TTAProgram::GlobalScope {lvalue}, TTAProgram::Program program) -> TTAProgram::Scope* C++ signature:     copyAndRelocate(GlobalScope_wrapper {lvalue}, TTAProgram::Program program) -> TTAProgram::Scope*

globalCodeLabel(...)
C++ signature:     globalCodeLabel(TTAProgram::GlobalScope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::CodeLabel C++ signature:     globalCodeLabel(TTAProgram::GlobalScope {lvalue}, int index) -> TTAProgram::CodeLabel

globalCodeLabelCount(...)
C++ signature:     globalCodeLabelCount(TTAProgram::GlobalScope {lvalue}, TTAProgram::Address address) -> int C++ signature:     globalCodeLabelCount(TTAProgram::GlobalScope {lvalue}) -> int

globalDataLabel(...)
C++ signature:     globalDataLabel(TTAProgram::GlobalScope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::DataLabel C++ signature:     globalDataLabel(TTAProgram::GlobalScope {lvalue}, int index) -> TTAProgram::DataLabel

globalDataLabelCount(...)
C++ signature:     globalDataLabelCount(TTAProgram::GlobalScope {lvalue}, TTAProgram::Address address) -> int C++ signature:     globalDataLabelCount(TTAProgram::GlobalScope {lvalue}) -> int

isGlobal(...)
C++ signature:     isGlobal(TTAProgram::GlobalScope {lvalue}) -> bool C++ signature:     isGlobal(GlobalScope_wrapper {lvalue}) -> bool

parent(...)
C++ signature: parent(GlobalScope_wrapper {lvalue}) -> TTAProgram::Scope

removeCodeLabels(...)
C++ signature:     removeCodeLabels(TTAProgram::GlobalScope {lvalue}, unsigned int address) -> void* C++ signature:     removeCodeLabels(GlobalScope_wrapper {lvalue}, unsigned int address) -> void*

setDataLabelAddressSpace(...)
C++ signature:     setDataLabelAddressSpace(TTAProgram::GlobalScope {lvalue}, TTAMachine::AddressSpace space) -> void* C++ signature:     setDataLabelAddressSpace(GlobalScope_wrapper {lvalue}, TTAMachine::AddressSpace space) -> void*

setParent(...)
C++ signature: setParent(GlobalScope_wrapper {lvalue}, TTAProgram::Scope {lvalue} scope) -> void*

Data and other attributes defined here:

__instance_size__ = 80

Methods inherited from Scope:

addCodeLabel(...)
C++ signature:     addCodeLabel(TTAProgram::Scope {lvalue}, TTAProgram::CodeLabel const* codeLabel) -> void* C++ signature:     addCodeLabel(Scope_wrapper {lvalue}, TTAProgram::CodeLabel const* codeLabel) -> void*

addDataLabel(...)
C++ signature:     addDataLabel(TTAProgram::Scope {lvalue}, TTAProgram::DataLabel const* dataLabel) -> void* C++ signature:     addDataLabel(Scope_wrapper {lvalue}, TTAProgram::DataLabel const* dataLabel) -> void*

codeLabel(...)
C++ signature:     codeLabel(TTAProgram::Scope {lvalue}, std::string name) -> TTAProgram::CodeLabel C++ signature:     codeLabel(TTAProgram::Scope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::CodeLabel

codeLabelCount(...)
C++ signature: codeLabelCount(TTAProgram::Scope {lvalue}, TTAProgram::Address address) -> int

containsCodeLabel(...)
C++ signature: containsCodeLabel(TTAProgram::Scope {lvalue}, std::string name) -> bool

containsDataLabel(...)
C++ signature: containsDataLabel(TTAProgram::Scope {lvalue}, std::string name) -> bool

dataLabel(...)
C++ signature:     dataLabel(TTAProgram::Scope {lvalue}, std::string name) -> TTAProgram::DataLabel C++ signature:     dataLabel(TTAProgram::Scope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::DataLabel

dataLabelCount(...)
C++ signature: dataLabelCount(TTAProgram::Scope {lvalue}, TTAProgram::Address address) -> int

isLocal(...)
C++ signature:     isLocal(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isLocal(Scope_wrapper {lvalue}) -> bool

isProcedure(...)
C++ signature:     isProcedure(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isProcedure(Scope_wrapper {lvalue}) -> bool

isUnit(...)
C++ signature:     isUnit(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isUnit(Scope_wrapper {lvalue}) -> bool

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Immediate(Boost.Python.instance)


Method resolution order:

Immediate

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, TTAProgram::TerminalImmediate* value, TTAProgram::Terminal* dst) -> void*

copy(...)
C++ signature: copy(TTAProgram::Immediate {lvalue}) -> TTAProgram::Immediate*

destination(...)
C++ signature: destination(TTAProgram::Immediate {lvalue}) -> TTAProgram::Terminal

setValue(...)
C++ signature: setValue(TTAProgram::Immediate {lvalue}, TTAProgram::TerminalImmediate* value) -> void*

value(...)
C++ signature: value(TTAProgram::Immediate {lvalue}) -> TTAProgram::TerminalImmediate

Data and other attributes defined here:

__instance_size__ = 20

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Instruction(Boost.Python.instance)


Method resolution order:

Instruction

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, TTAMachine::InstructionTemplate instructionTemplate) -> void* C++ signature:     __init__(_object*, int size, TTAMachine::InstructionTemplate instructionTemplate) -> void*

addImmediate(...)
C++ signature: addImmediate(TTAProgram::Instruction {lvalue}, TTAProgram::Immediate* imm) -> void*

addMove(...)
C++ signature: addMove(TTAProgram::Instruction {lvalue}, TTAProgram::Move* move) -> void*

address(...)
C++ signature: address(TTAProgram::Instruction {lvalue}) -> TTAProgram::Address

copy(...)
C++ signature: copy(TTAProgram::Instruction {lvalue}) -> TTAProgram::Instruction*

hasCall(...)
C++ signature: hasCall(TTAProgram::Instruction {lvalue}) -> bool

hasConditionalRegisterAccesses(...)
C++ signature: hasConditionalRegisterAccesses(TTAProgram::Instruction {lvalue}) -> bool

hasControlFlowMove(...)
C++ signature: hasControlFlowMove(TTAProgram::Instruction {lvalue}) -> bool

hasJump(...)
C++ signature: hasJump(TTAProgram::Instruction {lvalue}) -> bool

hasRegisterAccesses(...)
C++ signature: hasRegisterAccesses(TTAProgram::Instruction {lvalue}) -> bool

immediate(...)
C++ signature: immediate(TTAProgram::Instruction {lvalue}, int i) -> TTAProgram::Immediate

immediateCount(...)
C++ signature: immediateCount(TTAProgram::Instruction {lvalue}) -> int

instructionTemplate(...)
C++ signature: instructionTemplate(TTAProgram::Instruction {lvalue}) -> TTAMachine::InstructionTemplate

isInProcedure(...)
C++ signature: isInProcedure(TTAProgram::Instruction {lvalue}) -> bool

move(...)
C++ signature: move(TTAProgram::Instruction {lvalue}, int i) -> TTAProgram::Move

moveCount(...)
C++ signature: moveCount(TTAProgram::Instruction {lvalue}) -> int

parent(...)
C++ signature: parent(TTAProgram::Instruction {lvalue}) -> TTAProgram::CodeSnippet

removeImmediate(...)
C++ signature: removeImmediate(TTAProgram::Instruction {lvalue}, TTAProgram::Immediate {lvalue} imm) -> void*

removeMove(...)
C++ signature: removeMove(TTAProgram::Instruction {lvalue}, TTAProgram::Move {lvalue} move) -> void*

setInstructionTemplate(...)
C++ signature: setInstructionTemplate(TTAProgram::Instruction {lvalue}, TTAMachine::InstructionTemplate insTemp) -> void*

setParent(...)
C++ signature: setParent(TTAProgram::Instruction {lvalue}, TTAProgram::CodeSnippet {lvalue} proc) -> void*

size(...)
C++ signature: size(TTAProgram::Instruction {lvalue}) -> int

Data and other attributes defined here:

__instance_size__ = 52

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class InstructionReference(Boost.Python.instance)


Method resolution order:

InstructionReference

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, TTAProgram::Instruction {lvalue} ins) -> void*

instruction(...)
C++ signature: instruction(TTAProgram::InstructionReference {lvalue}) -> TTAProgram::Instruction

setInstruction(...)
C++ signature: setInstruction(TTAProgram::InstructionReference {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

Data and other attributes defined here:

__instance_size__ = 16

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class InstructionReferenceManager(Boost.Python.instance)


Method resolution order:

InstructionReferenceManager

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*) -> void*

clearReferences(...)
C++ signature: clearReferences(TTAProgram::InstructionReferenceManager {lvalue}) -> void*

copy(...)
C++ signature: copy(TTAProgram::InstructionReferenceManager {lvalue}) -> TTAProgram::InstructionReferenceManager*

createReference(...)
C++ signature: createReference(TTAProgram::InstructionReferenceManager {lvalue}, TTAProgram::Instruction {lvalue} ins) -> TTAProgram::InstructionReference

hasReference(...)
C++ signature: hasReference(TTAProgram::InstructionReferenceManager {lvalue}, TTAProgram::Instruction {lvalue} ins) -> bool

reference(...)
C++ signature: reference(TTAProgram::InstructionReferenceManager {lvalue}, int index) -> TTAProgram::InstructionReference

referenceCount(...)
C++ signature: referenceCount(TTAProgram::InstructionReferenceManager {lvalue}) -> int

removeReference(...)
C++ signature: removeReference(TTAProgram::InstructionReferenceManager {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

replace(...)
C++ signature: replace(TTAProgram::InstructionReferenceManager {lvalue}, TTAProgram::Instruction {lvalue} insA, TTAProgram::Instruction {lvalue} insB) -> TTAProgram::InstructionReference

Data and other attributes defined here:

__instance_size__ = 24

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Label(Boost.Python.instance)


Method resolution order:

Label

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*, std::string name, TTAProgram::Address address, TTAProgram::Scope scope) -> void*

address(...)
C++ signature:     address(TTAProgram::Label {lvalue}) -> TTAProgram::Address C++ signature:     address(Label_wrapper {lvalue}) -> TTAProgram::Address

name(...)
C++ signature: name(TTAProgram::Label {lvalue}) -> std::string

scope(...)
C++ signature: scope(TTAProgram::Label {lvalue}) -> TTAProgram::Scope

setAddress(...)
C++ signature: setAddress(TTAProgram::Label {lvalue}, TTAProgram::Address address) -> void*

setName(...)
C++ signature: setName(Label_wrapper {lvalue}, std::string name) -> void*

setScope(...)
C++ signature: setScope(Label_wrapper {lvalue}, TTAProgram::Scope scope) -> void*

Data and other attributes defined here:

__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Move(Boost.Python.instance)


Method resolution order:

Move

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(boost::python::api::object, std::auto_ptr<TTAProgram::Terminal>, std::auto_ptr<TTAProgram::Terminal>, TTAMachine::Bus {lvalue}, std::auto_ptr<TTAProgram::MoveGuard>) -> void* C++ signature:     __init__(boost::python::api::object, std::auto_ptr<TTAProgram::Terminal>, std::auto_ptr<TTAProgram::Terminal>, TTAMachine::Bus {lvalue}) -> void*

bus(...)
C++ signature: bus(TTAProgram::Move {lvalue}) -> TTAMachine::Bus

copy(...)
C++ signature: copy(TTAProgram::Move {lvalue}) -> TTAProgram::Move*

destination(...)
C++ signature: destination(TTAProgram::Move {lvalue}) -> TTAProgram::Terminal

destinationSocket(...)
C++ signature: destinationSocket(TTAProgram::Move {lvalue}) -> TTAMachine::Socket

guard(...)
C++ signature: guard(TTAProgram::Move {lvalue}) -> TTAProgram::MoveGuard

isCall(...)
C++ signature: isCall(TTAProgram::Move {lvalue}) -> bool

isControlFlowMove(...)
C++ signature: isControlFlowMove(TTAProgram::Move {lvalue}) -> bool

isInInstruction(...)
C++ signature: isInInstruction(TTAProgram::Move {lvalue}) -> bool

isJump(...)
C++ signature: isJump(TTAProgram::Move {lvalue}) -> bool

isReturn(...)
C++ signature: isReturn(TTAProgram::Move {lvalue}) -> bool

isTriggering(...)
C++ signature: isTriggering(TTAProgram::Move {lvalue}) -> bool

isUnconditional(...)
C++ signature: isUnconditional(TTAProgram::Move {lvalue}) -> bool

parent(...)
C++ signature: parent(TTAProgram::Move {lvalue}) -> TTAProgram::Instruction

setBus(...)
C++ signature: setBus(TTAProgram::Move {lvalue}, TTAMachine::Bus {lvalue} bus) -> void*

setDestination(...)
C++ signature: setDestination(TTAProgram::Move {lvalue} inst, std::auto_ptr<TTAProgram::Terminal> dst) -> void*

setGuard(...)
C++ signature: setGuard(TTAProgram::Move {lvalue} inst, std::auto_ptr<TTAProgram::MoveGuard> guard) -> void*

setParent(...)
C++ signature: setParent(TTAProgram::Move {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

setSource(...)
C++ signature: setSource(TTAProgram::Move {lvalue} inst, std::auto_ptr<TTAProgram::Terminal> src) -> void*

source(...)
C++ signature: source(TTAProgram::Move {lvalue}) -> TTAProgram::Terminal

sourceSocket(...)
C++ signature: sourceSocket(TTAProgram::Move {lvalue}) -> TTAMachine::Socket

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class MoveGuard(Boost.Python.instance)


Method resolution order:

MoveGuard

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, TTAMachine::Guard {lvalue} guard) -> void*

copy(...)
C++ signature: copy(TTAProgram::MoveGuard {lvalue}) -> TTAProgram::MoveGuard*

guard(...)
C++ signature: guard(TTAProgram::MoveGuard {lvalue}) -> TTAMachine::Guard

isInverted(...)
C++ signature: isInverted(TTAProgram::MoveGuard {lvalue}) -> bool

isUnconditional(...)
C++ signature: isUnconditional(TTAProgram::MoveGuard {lvalue}) -> bool

Data and other attributes defined here:

__instance_size__ = 12

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullAddress(Address)


Method resolution order:

NullAddress

Address

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

location(...)
C++ signature: location(TTAProgram::NullAddress {lvalue}) -> unsigned int

space(...)
C++ signature: space(TTAProgram::NullAddress {lvalue}) -> TTAMachine::AddressSpace

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullAddress

Data and other attributes defined here:

__instance_size__ = 24

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullGlobalScope(GlobalScope)


Method resolution order:

NullGlobalScope

GlobalScope

Scope

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

addChild(...)
C++ signature: addChild(NullGlobalScope_wrapper {lvalue}, TTAProgram::Scope scope) -> void*

addGlobalCodeLabel(...)
C++ signature: addGlobalCodeLabel(NullGlobalScope_wrapper {lvalue}, TTAProgram::CodeLabel codeLabel, TTAProgram::Scope owner) -> void*

addGlobalDataLabel(...)
C++ signature: addGlobalDataLabel(NullGlobalScope_wrapper {lvalue}, TTAProgram::DataLabel codeLabel, TTAProgram::Scope owner) -> void*

child(...)
C++ signature: child(NullGlobalScope_wrapper {lvalue}, int index) -> TTAProgram::Scope

childCount(...)
C++ signature: childCount(NullGlobalScope_wrapper {lvalue}) -> int

parent(...)
C++ signature: parent(NullGlobalScope_wrapper {lvalue}) -> TTAProgram::Scope

setParent(...)
C++ signature: setParent(NullGlobalScope_wrapper {lvalue}, TTAProgram::Scope {lvalue} scope) -> void*

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullGlobalScope

Data and other attributes defined here:

__instance_size__ = 80

Methods inherited from GlobalScope:

copy(...)
C++ signature:     copy(TTAProgram::GlobalScope {lvalue}) -> TTAProgram::Scope* C++ signature:     copy(GlobalScope_wrapper {lvalue}) -> TTAProgram::Scope*

copyAndRelocate(...)
C++ signature:     copyAndRelocate(TTAProgram::GlobalScope {lvalue}, TTAProgram::Program program) -> TTAProgram::Scope* C++ signature:     copyAndRelocate(GlobalScope_wrapper {lvalue}, TTAProgram::Program program) -> TTAProgram::Scope*

globalCodeLabel(...)
C++ signature:     globalCodeLabel(TTAProgram::GlobalScope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::CodeLabel C++ signature:     globalCodeLabel(TTAProgram::GlobalScope {lvalue}, int index) -> TTAProgram::CodeLabel

globalCodeLabelCount(...)
C++ signature:     globalCodeLabelCount(TTAProgram::GlobalScope {lvalue}, TTAProgram::Address address) -> int C++ signature:     globalCodeLabelCount(TTAProgram::GlobalScope {lvalue}) -> int

globalDataLabel(...)
C++ signature:     globalDataLabel(TTAProgram::GlobalScope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::DataLabel C++ signature:     globalDataLabel(TTAProgram::GlobalScope {lvalue}, int index) -> TTAProgram::DataLabel

globalDataLabelCount(...)
C++ signature:     globalDataLabelCount(TTAProgram::GlobalScope {lvalue}, TTAProgram::Address address) -> int C++ signature:     globalDataLabelCount(TTAProgram::GlobalScope {lvalue}) -> int

isGlobal(...)
C++ signature:     isGlobal(TTAProgram::GlobalScope {lvalue}) -> bool C++ signature:     isGlobal(GlobalScope_wrapper {lvalue}) -> bool

removeCodeLabels(...)
C++ signature:     removeCodeLabels(TTAProgram::GlobalScope {lvalue}, unsigned int address) -> void* C++ signature:     removeCodeLabels(GlobalScope_wrapper {lvalue}, unsigned int address) -> void*

setDataLabelAddressSpace(...)
C++ signature:     setDataLabelAddressSpace(TTAProgram::GlobalScope {lvalue}, TTAMachine::AddressSpace space) -> void* C++ signature:     setDataLabelAddressSpace(GlobalScope_wrapper {lvalue}, TTAMachine::AddressSpace space) -> void*

Methods inherited from Scope:

addCodeLabel(...)
C++ signature:     addCodeLabel(TTAProgram::Scope {lvalue}, TTAProgram::CodeLabel const* codeLabel) -> void* C++ signature:     addCodeLabel(Scope_wrapper {lvalue}, TTAProgram::CodeLabel const* codeLabel) -> void*

addDataLabel(...)
C++ signature:     addDataLabel(TTAProgram::Scope {lvalue}, TTAProgram::DataLabel const* dataLabel) -> void* C++ signature:     addDataLabel(Scope_wrapper {lvalue}, TTAProgram::DataLabel const* dataLabel) -> void*

codeLabel(...)
C++ signature:     codeLabel(TTAProgram::Scope {lvalue}, std::string name) -> TTAProgram::CodeLabel C++ signature:     codeLabel(TTAProgram::Scope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::CodeLabel

codeLabelCount(...)
C++ signature: codeLabelCount(TTAProgram::Scope {lvalue}, TTAProgram::Address address) -> int

containsCodeLabel(...)
C++ signature: containsCodeLabel(TTAProgram::Scope {lvalue}, std::string name) -> bool

containsDataLabel(...)
C++ signature: containsDataLabel(TTAProgram::Scope {lvalue}, std::string name) -> bool

dataLabel(...)
C++ signature:     dataLabel(TTAProgram::Scope {lvalue}, std::string name) -> TTAProgram::DataLabel C++ signature:     dataLabel(TTAProgram::Scope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::DataLabel

dataLabelCount(...)
C++ signature: dataLabelCount(TTAProgram::Scope {lvalue}, TTAProgram::Address address) -> int

isLocal(...)
C++ signature:     isLocal(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isLocal(Scope_wrapper {lvalue}) -> bool

isProcedure(...)
C++ signature:     isProcedure(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isProcedure(Scope_wrapper {lvalue}) -> bool

isUnit(...)
C++ signature:     isUnit(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isUnit(Scope_wrapper {lvalue}) -> bool

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullImmediate(Immediate)


Method resolution order:

NullImmediate

Immediate

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

destination(...)
C++ signature: destination(TTAProgram::NullImmediate {lvalue}) -> TTAProgram::Terminal

value(...)
C++ signature: value(TTAProgram::NullImmediate {lvalue}) -> TTAProgram::TerminalImmediate

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullImmediate

Data and other attributes defined here:

__instance_size__ = 24

Methods inherited from Immediate:

copy(...)
C++ signature: copy(TTAProgram::Immediate {lvalue}) -> TTAProgram::Immediate*

setValue(...)
C++ signature: setValue(TTAProgram::Immediate {lvalue}, TTAProgram::TerminalImmediate* value) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullInstruction(Instruction)


Method resolution order:

NullInstruction

Instruction

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

addImmediate(...)
C++ signature: addImmediate(TTAProgram::NullInstruction {lvalue}, TTAProgram::Immediate {lvalue} imm) -> void*

addMove(...)
C++ signature: addMove(TTAProgram::NullInstruction {lvalue}, TTAProgram::Move {lvalue} move) -> void*

address(...)
C++ signature: address(TTAProgram::NullInstruction {lvalue}) -> TTAProgram::Address

immediate(...)
C++ signature: immediate(TTAProgram::NullInstruction {lvalue}, int i) -> TTAProgram::Immediate

immediateCount(...)
C++ signature: immediateCount(TTAProgram::NullInstruction {lvalue}) -> int

isInProcedure(...)
C++ signature: isInProcedure(TTAProgram::NullInstruction {lvalue}) -> bool

move(...)
C++ signature: move(TTAProgram::NullInstruction {lvalue}, int i) -> TTAProgram::Move

moveCount(...)
C++ signature: moveCount(TTAProgram::NullInstruction {lvalue}) -> int

parent(...)
C++ signature: parent(TTAProgram::NullInstruction {lvalue}) -> TTAProgram::Procedure

setParent(...)
C++ signature: setParent(TTAProgram::NullInstruction {lvalue}, TTAProgram::Procedure proc) -> void*

size(...)
C++ signature: size(TTAProgram::NullInstruction {lvalue}) -> int

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullInstruction

Data and other attributes defined here:

__instance_size__ = 56

Methods inherited from Instruction:

copy(...)
C++ signature: copy(TTAProgram::Instruction {lvalue}) -> TTAProgram::Instruction*

hasCall(...)
C++ signature: hasCall(TTAProgram::Instruction {lvalue}) -> bool

hasConditionalRegisterAccesses(...)
C++ signature: hasConditionalRegisterAccesses(TTAProgram::Instruction {lvalue}) -> bool

hasControlFlowMove(...)
C++ signature: hasControlFlowMove(TTAProgram::Instruction {lvalue}) -> bool

hasJump(...)
C++ signature: hasJump(TTAProgram::Instruction {lvalue}) -> bool

hasRegisterAccesses(...)
C++ signature: hasRegisterAccesses(TTAProgram::Instruction {lvalue}) -> bool

instructionTemplate(...)
C++ signature: instructionTemplate(TTAProgram::Instruction {lvalue}) -> TTAMachine::InstructionTemplate

removeImmediate(...)
C++ signature: removeImmediate(TTAProgram::Instruction {lvalue}, TTAProgram::Immediate {lvalue} imm) -> void*

removeMove(...)
C++ signature: removeMove(TTAProgram::Instruction {lvalue}, TTAProgram::Move {lvalue} move) -> void*

setInstructionTemplate(...)
C++ signature: setInstructionTemplate(TTAProgram::Instruction {lvalue}, TTAMachine::InstructionTemplate insTemp) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullInstructionReferenceManager(InstructionReferenceManager)


Method resolution order:

NullInstructionReferenceManager

InstructionReferenceManager

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullInstructionReferenceManager

Data and other attributes defined here:

__instance_size__ = 28

Methods inherited from InstructionReferenceManager:

clearReferences(...)
C++ signature: clearReferences(TTAProgram::InstructionReferenceManager {lvalue}) -> void*

copy(...)
C++ signature: copy(TTAProgram::InstructionReferenceManager {lvalue}) -> TTAProgram::InstructionReferenceManager*

createReference(...)
C++ signature: createReference(TTAProgram::InstructionReferenceManager {lvalue}, TTAProgram::Instruction {lvalue} ins) -> TTAProgram::InstructionReference

hasReference(...)
C++ signature: hasReference(TTAProgram::InstructionReferenceManager {lvalue}, TTAProgram::Instruction {lvalue} ins) -> bool

reference(...)
C++ signature: reference(TTAProgram::InstructionReferenceManager {lvalue}, int index) -> TTAProgram::InstructionReference

referenceCount(...)
C++ signature: referenceCount(TTAProgram::InstructionReferenceManager {lvalue}) -> int

removeReference(...)
C++ signature: removeReference(TTAProgram::InstructionReferenceManager {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

replace(...)
C++ signature: replace(TTAProgram::InstructionReferenceManager {lvalue}, TTAProgram::Instruction {lvalue} insA, TTAProgram::Instruction {lvalue} insB) -> TTAProgram::InstructionReference

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullMove(Move)


Method resolution order:

NullMove

Move

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

bus(...)
C++ signature: bus(TTAProgram::NullMove {lvalue}) -> TTAMachine::Bus

destination(...)
C++ signature: destination(TTAProgram::NullMove {lvalue}) -> TTAProgram::Terminal

destinationSocket(...)
C++ signature: destinationSocket(TTAProgram::NullMove {lvalue}) -> TTAMachine::Socket

guard(...)
C++ signature: guard(TTAProgram::NullMove {lvalue}) -> TTAProgram::MoveGuard

isInInstruction(...)
C++ signature: isInInstruction(TTAProgram::NullMove {lvalue}) -> bool

isUnconditional(...)
C++ signature: isUnconditional(TTAProgram::NullMove {lvalue}) -> bool

parent(...)
C++ signature: parent(TTAProgram::NullMove {lvalue}) -> TTAProgram::Instruction

setBus(...)
C++ signature: setBus(TTAProgram::NullMove {lvalue}, TTAMachine::Bus {lvalue} bus) -> void*

setDestination(...)
C++ signature: setDestination(TTAProgram::NullMove {lvalue}, TTAProgram::Terminal* dst) -> void*

setGuard(...)
C++ signature: setGuard(TTAProgram::NullMove {lvalue}, TTAProgram::MoveGuard* guard) -> void*

setParent(...)
C++ signature: setParent(TTAProgram::NullMove {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

setSource(...)
C++ signature: setSource(TTAProgram::NullMove {lvalue}, TTAProgram::Terminal* src) -> void*

source(...)
C++ signature: source(TTAProgram::NullMove {lvalue}) -> TTAProgram::Terminal

sourceSocket(...)
C++ signature: sourceSocket(TTAProgram::NullMove {lvalue}) -> TTAMachine::Socket

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullMove

Data and other attributes defined here:

__instance_size__ = 60

Methods inherited from Move:

copy(...)
C++ signature: copy(TTAProgram::Move {lvalue}) -> TTAProgram::Move*

isCall(...)
C++ signature: isCall(TTAProgram::Move {lvalue}) -> bool

isControlFlowMove(...)
C++ signature: isControlFlowMove(TTAProgram::Move {lvalue}) -> bool

isJump(...)
C++ signature: isJump(TTAProgram::Move {lvalue}) -> bool

isReturn(...)
C++ signature: isReturn(TTAProgram::Move {lvalue}) -> bool

isTriggering(...)
C++ signature: isTriggering(TTAProgram::Move {lvalue}) -> bool

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullMoveGuard(MoveGuard)


Method resolution order:

NullMoveGuard

MoveGuard

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

guard(...)
C++ signature: guard(TTAProgram::NullMoveGuard {lvalue}) -> TTAMachine::Guard

isInverted(...)
C++ signature: isInverted(TTAProgram::NullMoveGuard {lvalue}) -> bool

isUnconditional(...)
C++ signature: isUnconditional(TTAProgram::NullMoveGuard {lvalue}) -> bool

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullMoveGuard

Data and other attributes defined here:

__instance_size__ = 20

Methods inherited from MoveGuard:

copy(...)
C++ signature: copy(TTAProgram::MoveGuard {lvalue}) -> TTAProgram::MoveGuard*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullProcedure(Procedure)


Method resolution order:

NullProcedure

Procedure

CodeSnippet

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

addInstruction(...)
C++ signature: addInstruction(TTAProgram::NullProcedure {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

address(...)
C++ signature:     address(TTAProgram::NullProcedure {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Address C++ signature:     address(NullProcedure_wrapper {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Address

alignment(...)
C++ signature: alignment(TTAProgram::NullProcedure {lvalue}) -> int

endAddress(...)
C++ signature:     endAddress(TTAProgram::NullProcedure {lvalue}) -> TTAProgram::Address C++ signature:     endAddress(NullProcedure_wrapper {lvalue}) -> TTAProgram::Address

firstInstruction(...)
C++ signature: firstInstruction(TTAProgram::NullProcedure {lvalue}) -> TTAProgram::Instruction

hasNextInstruction(...)
C++ signature:     hasNextInstruction(TTAProgram::NullProcedure {lvalue}, TTAProgram::Instruction ins) -> bool C++ signature:     hasNextInstruction(NullProcedure_wrapper {lvalue}, TTAProgram::Instruction ins) -> bool

insertInstructionAfter(...)
C++ signature: insertInstructionAfter(TTAProgram::NullProcedure {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void*

instructionAt(...)
C++ signature: instructionAt(TTAProgram::NullProcedure {lvalue}, unsigned int address) -> TTAProgram::Instruction

instructionCount(...)
C++ signature:     instructionCount(TTAProgram::NullProcedure {lvalue}) -> int C++ signature:     instructionCount(NullProcedure_wrapper {lvalue}) -> int

isInProgram(...)
C++ signature:     isInProgram(TTAProgram::NullProcedure {lvalue}) -> bool C++ signature:     isInProgram(NullProcedure_wrapper {lvalue}) -> bool

lastInstruction(...)
C++ signature: lastInstruction(TTAProgram::NullProcedure {lvalue}) -> TTAProgram::Instruction

name(...)
C++ signature: name(TTAProgram::NullProcedure {lvalue}) -> std::string

nextInstruction(...)
C++ signature: nextInstruction(TTAProgram::NullProcedure {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Instruction

parent(...)
C++ signature: parent(TTAProgram::NullProcedure {lvalue}) -> TTAProgram::Program

previousInstruction(...)
C++ signature: previousInstruction(TTAProgram::NullProcedure {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Instruction

setParent(...)
C++ signature: setParent(TTAProgram::NullProcedure {lvalue}, TTAProgram::Program prog) -> void*

setStartAddress(...)
C++ signature:     setStartAddress(TTAProgram::NullProcedure {lvalue}, TTAProgram::Address start) -> void* C++ signature:     setStartAddress(NullProcedure_wrapper {lvalue}, TTAProgram::Address start) -> void*

startAddress(...)
C++ signature:     startAddress(TTAProgram::NullProcedure {lvalue}) -> TTAProgram::Address C++ signature:     startAddress(NullProcedure_wrapper {lvalue}) -> TTAProgram::Address

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullProcedure

Data and other attributes defined here:

__instance_size__ = 48

Methods inherited from Procedure:

add(...)
C++ signature:     add(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction* ins) -> void* C++ signature:     add(Procedure_wrapper {lvalue}, TTAProgram::Instruction* ins) -> void*

addFront(...)
C++ signature:     addFront(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction* arg0) -> void* C++ signature:     addFront(Procedure_wrapper {lvalue}, TTAProgram::Instruction* arg0) -> void*

copy(...)
C++ signature:     copy(TTAProgram::Procedure {lvalue}) -> TTAProgram::CodeSnippet* C++ signature:     copy(Procedure_wrapper {lvalue}) -> TTAProgram::CodeSnippet*

insertAfter(...)
C++ signature:     insertAfter(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void* C++ signature:     insertAfter(Procedure_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void*

insertBefore(...)
C++ signature:     insertBefore(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void* C++ signature:     insertBefore(Procedure_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void*

remove(...)
C++ signature:     remove(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void* C++ signature:     remove(Procedure_wrapper {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

Methods inherited from CodeSnippet:

append(...)
C++ signature:     append(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     append(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     append(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet* cs) -> void* C++ signature:     append(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet* cs) -> void*

clear(...)
C++ signature:     clear(TTAProgram::CodeSnippet {lvalue}) -> void* C++ signature:     clear(CodeSnippet_wrapper {lvalue}) -> void*

deleteInstructionAt(...)
C++ signature:     deleteInstructionAt(TTAProgram::CodeSnippet {lvalue}, unsigned int address) -> void* C++ signature:     deleteInstructionAt(CodeSnippet_wrapper {lvalue}, unsigned int address) -> void*

instructionAtIndex(...)
C++ signature: instructionAtIndex(TTAProgram::CodeSnippet {lvalue}, int index) -> TTAProgram::Instruction

prepend(...)
C++ signature:     prepend(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     prepend(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     prepend(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet* cs) -> void* C++ signature:     prepend(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet* cs) -> void*

removeLastInstruction(...)
C++ signature:     removeLastInstruction(TTAProgram::CodeSnippet {lvalue}) -> void* C++ signature:     removeLastInstruction(CodeSnippet_wrapper {lvalue}) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullProgram(Program)


Method resolution order:

NullProgram

Program

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

addInstruction(...)
C++ signature: addInstruction(TTAProgram::NullProgram {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

addProcedure(...)
C++ signature: addProcedure(TTAProgram::NullProgram {lvalue}, TTAProgram::Procedure {lvalue} proc) -> void*

entryAddress(...)
C++ signature: entryAddress(TTAProgram::NullProgram {lvalue}) -> TTAProgram::Address

firstInstruction(...)
C++ signature: firstInstruction(TTAProgram::NullProgram {lvalue}) -> TTAProgram::Instruction

firstProcedure(...)
C++ signature: firstProcedure(TTAProgram::NullProgram {lvalue}) -> TTAProgram::Procedure

globalScope(...)
C++ signature: globalScope(TTAProgram::NullProgram {lvalue}) -> TTAProgram::GlobalScope

globalScopeConst(...)
C++ signature: globalScopeConst(TTAProgram::NullProgram {lvalue}) -> TTAProgram::GlobalScope

instructionAt(...)
C++ signature: instructionAt(TTAProgram::NullProgram {lvalue}, unsigned int address) -> TTAProgram::Instruction

instructionReferenceManager(...)
C++ signature: instructionReferenceManager(TTAProgram::NullProgram {lvalue}) -> TTAProgram::InstructionReferenceManager

lastInstruction(...)
C++ signature: lastInstruction(TTAProgram::NullProgram {lvalue}) -> TTAProgram::Instruction

lastProcedure(...)
C++ signature: lastProcedure(TTAProgram::NullProgram {lvalue}) -> TTAProgram::Procedure

nextInstruction(...)
C++ signature: nextInstruction(TTAProgram::NullProgram {lvalue}, TTAProgram::Instruction arg0) -> TTAProgram::Instruction

nextProcedure(...)
C++ signature: nextProcedure(TTAProgram::NullProgram {lvalue}, TTAProgram::Procedure proc) -> TTAProgram::Procedure

procedure(...)
C++ signature:     procedure(TTAProgram::NullProgram {lvalue}, int index) -> TTAProgram::Procedure C++ signature:     procedure(TTAProgram::NullProgram {lvalue}, std::string name) -> TTAProgram::Procedure

procedureCount(...)
C++ signature: procedureCount(TTAProgram::NullProgram {lvalue}) -> int

relocate(...)
C++ signature: relocate(TTAProgram::NullProgram {lvalue}, TTAProgram::Procedure proc, unsigned int howMuch) -> void*

setEntryAddress(...)
C++ signature: setEntryAddress(TTAProgram::NullProgram {lvalue}, TTAProgram::Address address) -> void*

startAddress(...)
C++ signature: startAddress(TTAProgram::NullProgram {lvalue}) -> TTAProgram::Address

targetProcessor(...)
C++ signature: targetProcessor(TTAProgram::NullProgram {lvalue}) -> TTAMachine::Machine

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullProgram

Data and other attributes defined here:

__instance_size__ = 64

Methods inherited from Program:

addDataMemory(...)
C++ signature: addDataMemory(TTAProgram::Program {lvalue}, TTAProgram::DataMemory* dataMem) -> void*

assign(...)
C++ signature: assign(TTAProgram::Program {lvalue}, TTAProgram::Program old) -> TTAProgram::Program

copy(...)
C++ signature: copy(TTAProgram::Program {lvalue}) -> TTAProgram::Program*

dataMemory(...)
C++ signature:     dataMemory(TTAProgram::Program {lvalue}, int index) -> TTAProgram::DataMemory C++ signature:     dataMemory(TTAProgram::Program {lvalue}, std::string aSpaceName) -> TTAProgram::DataMemory

dataMemoryCount(...)
C++ signature: dataMemoryCount(TTAProgram::Program {lvalue}) -> int

moveProcedure(...)
C++ signature: moveProcedure(TTAProgram::Program {lvalue}, TTAProgram::Procedure {lvalue} proc, int howMuch) -> void*

procedureAtIndex(...)
C++ signature: procedureAtIndex(TTAProgram::Program {lvalue}, int index) -> TTAProgram::Procedure

removeProcedure(...)
C++ signature: removeProcedure(TTAProgram::Program {lvalue}, TTAProgram::Procedure {lvalue} proc) -> void*

replaceUniversalAddressSpaces(...)
C++ signature: replaceUniversalAddressSpaces(TTAProgram::Program {lvalue}, TTAMachine::AddressSpace space) -> void*

setStartAddress(...)
C++ signature: setStartAddress(TTAProgram::Program {lvalue}, TTAProgram::Address start) -> void*

Static methods inherited from Program:

loadFromTPEF(...)
C++ signature:     loadFromTPEF(std::string tpefFileName, TTAMachine::Machine theMachine, UniversalMachine umach) -> TTAProgram::Program* C++ signature:     loadFromTPEF(std::string tpefFileName, TTAMachine::Machine theMachine) -> TTAProgram::Program* C++ signature:     loadFromTPEF(std::string tpefFileName, UniversalMachine umach) -> TTAProgram::Program*

writeToTPEF(...)
C++ signature: writeToTPEF(TTAProgram::Program program, std::string tpefFileName) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullTerminal(Terminal)


Method resolution order:

NullTerminal

Terminal

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

copy(...)
C++ signature:     copy(TTAProgram::NullTerminal {lvalue}) -> TTAProgram::Terminal* C++ signature:     copy(NullTerminal_wrapper {lvalue}) -> TTAProgram::Terminal*

equals(...)
C++ signature:     equals(TTAProgram::NullTerminal {lvalue}, TTAProgram::Terminal other) -> bool C++ signature:     equals(NullTerminal_wrapper {lvalue}, TTAProgram::Terminal other) -> bool

functionUnit(...)
C++ signature: functionUnit(TTAProgram::NullTerminal {lvalue}) -> TTAMachine::FunctionUnit

immediateUnit(...)
C++ signature: immediateUnit(TTAProgram::NullTerminal {lvalue}) -> TTAMachine::ImmediateUnit

index(...)
C++ signature:     index(TTAProgram::NullTerminal {lvalue}) -> int C++ signature:     index(NullTerminal_wrapper {lvalue}) -> int

isFUPort(...)
C++ signature:     isFUPort(TTAProgram::NullTerminal {lvalue}) -> bool C++ signature:     isFUPort(NullTerminal_wrapper {lvalue}) -> bool

isGPR(...)
C++ signature:     isGPR(TTAProgram::NullTerminal {lvalue}) -> bool C++ signature:     isGPR(NullTerminal_wrapper {lvalue}) -> bool

isImmediate(...)
C++ signature:     isImmediate(TTAProgram::NullTerminal {lvalue}) -> bool C++ signature:     isImmediate(NullTerminal_wrapper {lvalue}) -> bool

isImmediateRegister(...)
C++ signature:     isImmediateRegister(TTAProgram::NullTerminal {lvalue}) -> bool C++ signature:     isImmediateRegister(NullTerminal_wrapper {lvalue}) -> bool

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAProgram::NullTerminal {lvalue}) -> bool C++ signature:     isOpcodeSetting(NullTerminal_wrapper {lvalue}) -> bool

operation(...)
C++ signature: operation(TTAProgram::NullTerminal {lvalue}) -> Operation

port(...)
C++ signature: port(TTAProgram::NullTerminal {lvalue}) -> TTAMachine::Port

registerFile(...)
C++ signature: registerFile(TTAProgram::NullTerminal {lvalue}) -> TTAMachine::RegisterFile

setIndex(...)
C++ signature:     setIndex(TTAProgram::NullTerminal {lvalue}, int index) -> void* C++ signature:     setIndex(NullTerminal_wrapper {lvalue}, int index) -> void*

setInstructionReference(...)
C++ signature:     setInstructionReference(TTAProgram::NullTerminal {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void* C++ signature:     setInstructionReference(NullTerminal_wrapper {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void*

setOperation(...)
C++ signature:     setOperation(TTAProgram::NullTerminal {lvalue}, Operation {lvalue} operation) -> void* C++ signature:     setOperation(NullTerminal_wrapper {lvalue}, Operation {lvalue} operation) -> void*

value(...)
C++ signature:     value(TTAProgram::NullTerminal {lvalue}) -> SimValue C++ signature:     value(NullTerminal_wrapper {lvalue}) -> SimValue

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAProgram::NullTerminal

Data and other attributes defined here:

__instance_size__ = 16

Methods inherited from Terminal:

__eq__(...)
C++ signature: __eq__(TTAProgram::Terminal {lvalue}, TTAProgram::Terminal) -> _object*

address(...)
C++ signature:     address(TTAProgram::Terminal {lvalue}) -> TTAProgram::Address C++ signature:     address(Terminal_wrapper {lvalue}) -> TTAProgram::Address

hintOperation(...)
C++ signature: hintOperation(TTAProgram::Terminal {lvalue}) -> Operation

instructionReference(...)
C++ signature: instructionReference(TTAProgram::Terminal {lvalue}) -> TTAProgram::InstructionReference

isAddress(...)
C++ signature:     isAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isAddress(Terminal_wrapper {lvalue}) -> bool

isInstructionAddress(...)
C++ signature:     isInstructionAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isInstructionAddress(Terminal_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isTriggering(Terminal_wrapper {lvalue}) -> bool

operationIndex(...)
C++ signature:     operationIndex(TTAProgram::Terminal {lvalue}) -> int C++ signature:     operationIndex(Terminal_wrapper {lvalue}) -> int

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Procedure(CodeSnippet)


Method resolution order:

Procedure

CodeSnippet

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, TTAMachine::AddressSpace space) -> void* C++ signature:     __init__(_object*, std::string name, TTAMachine::AddressSpace space, unsigned int startLocation) -> void*

add(...)
C++ signature:     add(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction* ins) -> void* C++ signature:     add(Procedure_wrapper {lvalue}, TTAProgram::Instruction* ins) -> void*

addFront(...)
C++ signature:     addFront(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction* arg0) -> void* C++ signature:     addFront(Procedure_wrapper {lvalue}, TTAProgram::Instruction* arg0) -> void*

address(...)
C++ signature:     address(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Address C++ signature:     address(Procedure_wrapper {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Address

alignment(...)
C++ signature: alignment(TTAProgram::Procedure {lvalue}) -> int

copy(...)
C++ signature:     copy(TTAProgram::Procedure {lvalue}) -> TTAProgram::CodeSnippet* C++ signature:     copy(Procedure_wrapper {lvalue}) -> TTAProgram::CodeSnippet*

insertAfter(...)
C++ signature:     insertAfter(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void* C++ signature:     insertAfter(Procedure_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void*

insertBefore(...)
C++ signature:     insertBefore(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void* C++ signature:     insertBefore(Procedure_wrapper {lvalue}, TTAProgram::Instruction pos, TTAProgram::Instruction* ins) -> void*

name(...)
C++ signature: name(TTAProgram::Procedure {lvalue}) -> std::string

remove(...)
C++ signature:     remove(TTAProgram::Procedure {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void* C++ signature:     remove(Procedure_wrapper {lvalue}, TTAProgram::Instruction {lvalue} ins) -> void*

Data and other attributes defined here:

__instance_size__ = 48

Methods inherited from CodeSnippet:

append(...)
C++ signature:     append(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     append(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     append(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet* cs) -> void* C++ signature:     append(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet* cs) -> void*

clear(...)
C++ signature:     clear(TTAProgram::CodeSnippet {lvalue}) -> void* C++ signature:     clear(CodeSnippet_wrapper {lvalue}) -> void*

deleteInstructionAt(...)
C++ signature:     deleteInstructionAt(TTAProgram::CodeSnippet {lvalue}, unsigned int address) -> void* C++ signature:     deleteInstructionAt(CodeSnippet_wrapper {lvalue}, unsigned int address) -> void*

endAddress(...)
C++ signature:     endAddress(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Address C++ signature:     endAddress(CodeSnippet_wrapper {lvalue}) -> TTAProgram::Address

firstInstruction(...)
C++ signature: firstInstruction(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Instruction

hasNextInstruction(...)
C++ signature:     hasNextInstruction(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction ins) -> bool C++ signature:     hasNextInstruction(CodeSnippet_wrapper {lvalue}, TTAProgram::Instruction ins) -> bool

instructionAt(...)
C++ signature: instructionAt(TTAProgram::CodeSnippet {lvalue}, unsigned int address) -> TTAProgram::Instruction

instructionAtIndex(...)
C++ signature: instructionAtIndex(TTAProgram::CodeSnippet {lvalue}, int index) -> TTAProgram::Instruction

instructionCount(...)
C++ signature:     instructionCount(TTAProgram::CodeSnippet {lvalue}) -> int C++ signature:     instructionCount(CodeSnippet_wrapper {lvalue}) -> int

isInProgram(...)
C++ signature:     isInProgram(TTAProgram::CodeSnippet {lvalue}) -> bool C++ signature:     isInProgram(CodeSnippet_wrapper {lvalue}) -> bool

lastInstruction(...)
C++ signature: lastInstruction(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Instruction

nextInstruction(...)
C++ signature: nextInstruction(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Instruction

parent(...)
C++ signature: parent(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Program

prepend(...)
C++ signature:     prepend(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     prepend(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet cs) -> void* C++ signature:     prepend(TTAProgram::CodeSnippet {lvalue}, TTAProgram::CodeSnippet* cs) -> void* C++ signature:     prepend(CodeSnippet_wrapper {lvalue}, TTAProgram::CodeSnippet* cs) -> void*

previousInstruction(...)
C++ signature: previousInstruction(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Instruction ins) -> TTAProgram::Instruction

removeLastInstruction(...)
C++ signature:     removeLastInstruction(TTAProgram::CodeSnippet {lvalue}) -> void* C++ signature:     removeLastInstruction(CodeSnippet_wrapper {lvalue}) -> void*

setParent(...)
C++ signature:     setParent(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Program {lvalue} prog) -> void* C++ signature:     setParent(CodeSnippet_wrapper {lvalue}, TTAProgram::Program {lvalue} prog) -> void*

setStartAddress(...)
C++ signature:     setStartAddress(TTAProgram::CodeSnippet {lvalue}, TTAProgram::Address start) -> void* C++ signature:     setStartAddress(CodeSnippet_wrapper {lvalue}, TTAProgram::Address start) -> void*

startAddress(...)
C++ signature:     startAddress(TTAProgram::CodeSnippet {lvalue}) -> TTAProgram::Address C++ signature:     startAddress(CodeSnippet_wrapper {lvalue}) -> TTAProgram::Address

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Program(Boost.Python.instance)


Method resolution order:

Program

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, TTAMachine::AddressSpace space) -> void* C++ signature:     __init__(_object*, TTAMachine::AddressSpace space, TTAProgram::Address start) -> void* C++ signature:     __init__(_object*, TTAMachine::AddressSpace space, TTAProgram::Address start, TTAProgram::Address entry) -> void*

addDataMemory(...)
C++ signature: addDataMemory(TTAProgram::Program {lvalue}, TTAProgram::DataMemory* dataMem) -> void*

addInstruction(...)
C++ signature: addInstruction(TTAProgram::Program {lvalue}, TTAProgram::Instruction* ins) -> void*

addProcedure(...)
C++ signature: addProcedure(TTAProgram::Program {lvalue}, TTAProgram::Procedure* proc) -> void*

assign(...)
C++ signature: assign(TTAProgram::Program {lvalue}, TTAProgram::Program old) -> TTAProgram::Program

copy(...)
C++ signature: copy(TTAProgram::Program {lvalue}) -> TTAProgram::Program*

dataMemory(...)
C++ signature:     dataMemory(TTAProgram::Program {lvalue}, int index) -> TTAProgram::DataMemory C++ signature:     dataMemory(TTAProgram::Program {lvalue}, std::string aSpaceName) -> TTAProgram::DataMemory

dataMemoryCount(...)
C++ signature: dataMemoryCount(TTAProgram::Program {lvalue}) -> int

entryAddress(...)
C++ signature: entryAddress(TTAProgram::Program {lvalue}) -> TTAProgram::Address

firstInstruction(...)
C++ signature: firstInstruction(TTAProgram::Program {lvalue}) -> TTAProgram::Instruction

firstProcedure(...)
C++ signature: firstProcedure(TTAProgram::Program {lvalue}) -> TTAProgram::Procedure

globalScope(...)
C++ signature: globalScope(TTAProgram::Program {lvalue}) -> TTAProgram::GlobalScope

globalScopeConst(...)
C++ signature: globalScopeConst(TTAProgram::Program {lvalue}) -> TTAProgram::GlobalScope

instructionAt(...)
C++ signature: instructionAt(TTAProgram::Program {lvalue}, unsigned int address) -> TTAProgram::Instruction

instructionReferenceManager(...)
C++ signature: instructionReferenceManager(TTAProgram::Program {lvalue}) -> TTAProgram::InstructionReferenceManager

lastInstruction(...)
C++ signature: lastInstruction(TTAProgram::Program {lvalue}) -> TTAProgram::Instruction

lastProcedure(...)
C++ signature: lastProcedure(TTAProgram::Program {lvalue}) -> TTAProgram::Procedure

moveProcedure(...)
C++ signature: moveProcedure(TTAProgram::Program {lvalue}, TTAProgram::Procedure {lvalue} proc, int howMuch) -> void*

nextInstruction(...)
C++ signature: nextInstruction(TTAProgram::Program {lvalue}, TTAProgram::Instruction arg0) -> TTAProgram::Instruction

nextProcedure(...)
C++ signature: nextProcedure(TTAProgram::Program {lvalue}, TTAProgram::Procedure proc) -> TTAProgram::Procedure

procedure(...)
C++ signature:     procedure(TTAProgram::Program {lvalue}, int index) -> TTAProgram::Procedure C++ signature:     procedure(TTAProgram::Program {lvalue}, std::string name) -> TTAProgram::Procedure

procedureAtIndex(...)
C++ signature: procedureAtIndex(TTAProgram::Program {lvalue}, int index) -> TTAProgram::Procedure

procedureCount(...)
C++ signature: procedureCount(TTAProgram::Program {lvalue}) -> int

removeProcedure(...)
C++ signature: removeProcedure(TTAProgram::Program {lvalue}, TTAProgram::Procedure {lvalue} proc) -> void*

replaceUniversalAddressSpaces(...)
C++ signature: replaceUniversalAddressSpaces(TTAProgram::Program {lvalue}, TTAMachine::AddressSpace space) -> void*

setEntryAddress(...)
C++ signature: setEntryAddress(TTAProgram::Program {lvalue}, TTAProgram::Address address) -> void*

setStartAddress(...)
C++ signature: setStartAddress(TTAProgram::Program {lvalue}, TTAProgram::Address start) -> void*

startAddress(...)
C++ signature: startAddress(TTAProgram::Program {lvalue}) -> TTAProgram::Address

targetProcessor(...)
C++ signature: targetProcessor(TTAProgram::Program {lvalue}) -> TTAMachine::Machine

Static methods defined here:

loadFromTPEF(...)
C++ signature:     loadFromTPEF(std::string tpefFileName, TTAMachine::Machine theMachine, UniversalMachine umach) -> TTAProgram::Program* C++ signature:     loadFromTPEF(std::string tpefFileName, TTAMachine::Machine theMachine) -> TTAProgram::Program* C++ signature:     loadFromTPEF(std::string tpefFileName, UniversalMachine umach) -> TTAProgram::Program*

writeToTPEF(...)
C++ signature: writeToTPEF(TTAProgram::Program program, std::string tpefFileName) -> void*

Data and other attributes defined here:

__instance_size__ = 60

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class ProgramWriter(Boost.Python.instance)


Method resolution order:

ProgramWriter

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, TTAProgram::Program prog) -> void*

createBinary(...)
C++ signature: createBinary(TTAProgram::ProgramWriter {lvalue}) -> TPEF::Binary*

Data and other attributes defined here:

__instance_size__ = 52

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Scope(Boost.Python.instance)


Method resolution order:

Scope

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*) -> void*

addChild(...)
C++ signature: addChild(Scope_wrapper {lvalue}, TTAProgram::Scope scope) -> void*

addCodeLabel(...)
C++ signature:     addCodeLabel(TTAProgram::Scope {lvalue}, TTAProgram::CodeLabel const* codeLabel) -> void* C++ signature:     addCodeLabel(Scope_wrapper {lvalue}, TTAProgram::CodeLabel const* codeLabel) -> void*

addDataLabel(...)
C++ signature:     addDataLabel(TTAProgram::Scope {lvalue}, TTAProgram::DataLabel const* dataLabel) -> void* C++ signature:     addDataLabel(Scope_wrapper {lvalue}, TTAProgram::DataLabel const* dataLabel) -> void*

addGlobalCodeLabel(...)
C++ signature: addGlobalCodeLabel(Scope_wrapper {lvalue}, TTAProgram::CodeLabel codeLabel, TTAProgram::Scope owner) -> void*

addGlobalDataLabel(...)
C++ signature: addGlobalDataLabel(Scope_wrapper {lvalue}, TTAProgram::DataLabel dataLabel, TTAProgram::Scope owner) -> void*

child(...)
C++ signature: child(Scope_wrapper {lvalue}, int index) -> TTAProgram::Scope

childCount(...)
C++ signature: childCount(Scope_wrapper {lvalue}) -> int

codeLabel(...)
C++ signature:     codeLabel(TTAProgram::Scope {lvalue}, std::string name) -> TTAProgram::CodeLabel C++ signature:     codeLabel(TTAProgram::Scope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::CodeLabel

codeLabelCount(...)
C++ signature: codeLabelCount(TTAProgram::Scope {lvalue}, TTAProgram::Address address) -> int

containsCodeLabel(...)
C++ signature: containsCodeLabel(TTAProgram::Scope {lvalue}, std::string name) -> bool

containsDataLabel(...)
C++ signature: containsDataLabel(TTAProgram::Scope {lvalue}, std::string name) -> bool

copy(...)
C++ signature:     copy(TTAProgram::Scope {lvalue}) -> TTAProgram::Scope* C++ signature:     copy(Scope_wrapper {lvalue}) -> void*

dataLabel(...)
C++ signature:     dataLabel(TTAProgram::Scope {lvalue}, std::string name) -> TTAProgram::DataLabel C++ signature:     dataLabel(TTAProgram::Scope {lvalue}, TTAProgram::Address address, int index) -> TTAProgram::DataLabel

dataLabelCount(...)
C++ signature: dataLabelCount(TTAProgram::Scope {lvalue}, TTAProgram::Address address) -> int

isGlobal(...)
C++ signature:     isGlobal(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isGlobal(Scope_wrapper {lvalue}) -> bool

isLocal(...)
C++ signature:     isLocal(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isLocal(Scope_wrapper {lvalue}) -> bool

isProcedure(...)
C++ signature:     isProcedure(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isProcedure(Scope_wrapper {lvalue}) -> bool

isUnit(...)
C++ signature:     isUnit(TTAProgram::Scope {lvalue}) -> bool C++ signature:     isUnit(Scope_wrapper {lvalue}) -> bool

parent(...)
C++ signature: parent(Scope_wrapper {lvalue}) -> TTAProgram::Scope

removeCodeLabels(...)
C++ signature:     removeCodeLabels(TTAProgram::Scope {lvalue}, unsigned int address) -> void* C++ signature:     removeCodeLabels(Scope_wrapper {lvalue}, unsigned int address) -> void*

setParent(...)
C++ signature: setParent(Scope_wrapper {lvalue}, TTAProgram::Scope {lvalue} scope) -> void*

Data and other attributes defined here:

__instance_size__ = 56

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Terminal(Boost.Python.instance)


Method resolution order:

Terminal

Boost.Python.instance

__builtin__.object

Methods defined here:

__eq__(...)
C++ signature: __eq__(TTAProgram::Terminal {lvalue}, TTAProgram::Terminal) -> _object*

__init__(...)
C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*) -> void*

address(...)
C++ signature:     address(TTAProgram::Terminal {lvalue}) -> TTAProgram::Address C++ signature:     address(Terminal_wrapper {lvalue}) -> TTAProgram::Address

copy(...)
C++ signature:     copy(TTAProgram::Terminal {lvalue}) -> TTAProgram::Terminal* C++ signature:     copy(std::auto_ptr<Terminal_wrapper> {lvalue}) -> void*

equals(...)
C++ signature:     equals(TTAProgram::Terminal {lvalue}, TTAProgram::Terminal other) -> bool C++ signature:     equals(std::auto_ptr<Terminal_wrapper> {lvalue}, TTAProgram::Terminal) -> void*

functionUnit(...)
C++ signature: functionUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::FunctionUnit

hintOperation(...)
C++ signature: hintOperation(TTAProgram::Terminal {lvalue}) -> Operation

immediateUnit(...)
C++ signature: immediateUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::ImmediateUnit

index(...)
C++ signature:     index(TTAProgram::Terminal {lvalue}) -> int C++ signature:     index(Terminal_wrapper {lvalue}) -> int

instructionReference(...)
C++ signature: instructionReference(TTAProgram::Terminal {lvalue}) -> TTAProgram::InstructionReference

isAddress(...)
C++ signature:     isAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isAddress(Terminal_wrapper {lvalue}) -> bool

isFUPort(...)
C++ signature:     isFUPort(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isFUPort(Terminal_wrapper {lvalue}) -> bool

isGPR(...)
C++ signature:     isGPR(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isGPR(Terminal_wrapper {lvalue}) -> bool

isImmediate(...)
C++ signature:     isImmediate(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isImmediate(Terminal_wrapper {lvalue}) -> bool

isImmediateRegister(...)
C++ signature:     isImmediateRegister(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isImmediateRegister(Terminal_wrapper {lvalue}) -> bool

isInstructionAddress(...)
C++ signature:     isInstructionAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isInstructionAddress(Terminal_wrapper {lvalue}) -> bool

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isOpcodeSetting(Terminal_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isTriggering(Terminal_wrapper {lvalue}) -> bool

operation(...)
C++ signature: operation(TTAProgram::Terminal {lvalue}) -> Operation

operationIndex(...)
C++ signature:     operationIndex(TTAProgram::Terminal {lvalue}) -> int C++ signature:     operationIndex(Terminal_wrapper {lvalue}) -> int

port(...)
C++ signature: port(TTAProgram::Terminal {lvalue}) -> TTAMachine::Port

registerFile(...)
C++ signature: registerFile(TTAProgram::Terminal {lvalue}) -> TTAMachine::RegisterFile

setIndex(...)
C++ signature:     setIndex(TTAProgram::Terminal {lvalue}, int index) -> void* C++ signature:     setIndex(Terminal_wrapper {lvalue}, int index) -> void*

setInstructionReference(...)
C++ signature:     setInstructionReference(TTAProgram::Terminal {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void* C++ signature:     setInstructionReference(Terminal_wrapper {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void*

value(...)
C++ signature:     value(TTAProgram::Terminal {lvalue}) -> SimValue C++ signature:     value(Terminal_wrapper {lvalue}) -> SimValue

Data and other attributes defined here:

__instance_size__ = 12

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class TerminalAddress(TerminalImmediate)


Method resolution order:

TerminalAddress

TerminalImmediate

Terminal

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, SimValue value, TTAMachine::AddressSpace space) -> void*

address(...)
C++ signature:     address(TTAProgram::TerminalAddress {lvalue}) -> TTAProgram::Address C++ signature:     address(TerminalAddress_wrapper {lvalue}) -> TTAProgram::Address

copy(...)
C++ signature:     copy(TTAProgram::TerminalAddress {lvalue}) -> TTAProgram::Terminal* C++ signature:     copy(TerminalAddress_wrapper {lvalue}) -> TTAProgram::Terminal*

equals(...)
C++ signature:     equals(TTAProgram::TerminalAddress {lvalue}, TTAProgram::Terminal other) -> bool C++ signature:     equals(TerminalAddress_wrapper {lvalue}, TTAProgram::Terminal other) -> bool

isAddress(...)
C++ signature:     isAddress(TTAProgram::TerminalAddress {lvalue}) -> bool C++ signature:     isAddress(TerminalAddress_wrapper {lvalue}) -> bool

Data and other attributes defined here:

__instance_size__ = 72

Methods inherited from TerminalImmediate:

isImmediate(...)
C++ signature:     isImmediate(TTAProgram::TerminalImmediate {lvalue}) -> bool C++ signature:     isImmediate(TerminalImmediate_wrapper {lvalue}) -> bool

value(...)
C++ signature:     value(TTAProgram::TerminalImmediate {lvalue}) -> SimValue C++ signature:     value(TerminalImmediate_wrapper {lvalue}) -> SimValue

Methods inherited from Terminal:

__eq__(...)
C++ signature: __eq__(TTAProgram::Terminal {lvalue}, TTAProgram::Terminal) -> _object*

functionUnit(...)
C++ signature: functionUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::FunctionUnit

hintOperation(...)
C++ signature: hintOperation(TTAProgram::Terminal {lvalue}) -> Operation

immediateUnit(...)
C++ signature: immediateUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::ImmediateUnit

index(...)
C++ signature:     index(TTAProgram::Terminal {lvalue}) -> int C++ signature:     index(Terminal_wrapper {lvalue}) -> int

instructionReference(...)
C++ signature: instructionReference(TTAProgram::Terminal {lvalue}) -> TTAProgram::InstructionReference

isFUPort(...)
C++ signature:     isFUPort(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isFUPort(Terminal_wrapper {lvalue}) -> bool

isGPR(...)
C++ signature:     isGPR(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isGPR(Terminal_wrapper {lvalue}) -> bool

isImmediateRegister(...)
C++ signature:     isImmediateRegister(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isImmediateRegister(Terminal_wrapper {lvalue}) -> bool

isInstructionAddress(...)
C++ signature:     isInstructionAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isInstructionAddress(Terminal_wrapper {lvalue}) -> bool

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isOpcodeSetting(Terminal_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isTriggering(Terminal_wrapper {lvalue}) -> bool

operation(...)
C++ signature: operation(TTAProgram::Terminal {lvalue}) -> Operation

operationIndex(...)
C++ signature:     operationIndex(TTAProgram::Terminal {lvalue}) -> int C++ signature:     operationIndex(Terminal_wrapper {lvalue}) -> int

port(...)
C++ signature: port(TTAProgram::Terminal {lvalue}) -> TTAMachine::Port

registerFile(...)
C++ signature: registerFile(TTAProgram::Terminal {lvalue}) -> TTAMachine::RegisterFile

setIndex(...)
C++ signature:     setIndex(TTAProgram::Terminal {lvalue}, int index) -> void* C++ signature:     setIndex(Terminal_wrapper {lvalue}, int index) -> void*

setInstructionReference(...)
C++ signature:     setInstructionReference(TTAProgram::Terminal {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void* C++ signature:     setInstructionReference(Terminal_wrapper {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class TerminalFUPort(Terminal)


Method resolution order:

TerminalFUPort

Terminal

Boost.Python.instance

__builtin__.object

Methods defined here:

HWOperationName(...)
C++ signature:     HWOperationName(TTAProgram::TerminalFUPort {lvalue}) -> std::string C++ signature:     HWOperationName(TerminalFUPort_wrapper {lvalue}) -> std::string

__init__(...)
C++ signature:     __init__(_object*, TTAMachine::BaseFUPort port) -> void* C++ signature:     __init__(_object*, TTAMachine::HWOperation {lvalue} operation, int opIndex) -> void*

copy(...)
C++ signature:     copy(TTAProgram::TerminalFUPort {lvalue}) -> TTAProgram::Terminal* C++ signature:     copy(TerminalFUPort_wrapper {lvalue}) -> TTAProgram::Terminal*

equals(...)
C++ signature:     equals(TTAProgram::TerminalFUPort {lvalue}, TTAProgram::Terminal other) -> bool C++ signature:     equals(TerminalFUPort_wrapper {lvalue}, TTAProgram::Terminal other) -> bool

functionUnit(...)
C++ signature: functionUnit(TTAProgram::TerminalFUPort {lvalue}) -> TTAMachine::FunctionUnit

hintOperation(...)
C++ signature: hintOperation(TTAProgram::TerminalFUPort {lvalue}) -> Operation

isFUPort(...)
C++ signature:     isFUPort(TTAProgram::TerminalFUPort {lvalue}) -> bool C++ signature:     isFUPort(TerminalFUPort_wrapper {lvalue}) -> bool

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAProgram::TerminalFUPort {lvalue}) -> bool C++ signature:     isOpcodeSetting(TerminalFUPort_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAProgram::TerminalFUPort {lvalue}) -> bool C++ signature:     isTriggering(TerminalFUPort_wrapper {lvalue}) -> bool

operation(...)
C++ signature: operation(TTAProgram::TerminalFUPort {lvalue}) -> Operation

operationIndex(...)
C++ signature:     operationIndex(TTAProgram::TerminalFUPort {lvalue}) -> int C++ signature:     operationIndex(TerminalFUPort_wrapper {lvalue}) -> int

port(...)
C++ signature: port(TTAProgram::TerminalFUPort {lvalue}) -> TTAMachine::Port

Data and other attributes defined here:

__instance_size__ = 32

Methods inherited from Terminal:

__eq__(...)
C++ signature: __eq__(TTAProgram::Terminal {lvalue}, TTAProgram::Terminal) -> _object*

address(...)
C++ signature:     address(TTAProgram::Terminal {lvalue}) -> TTAProgram::Address C++ signature:     address(Terminal_wrapper {lvalue}) -> TTAProgram::Address

immediateUnit(...)
C++ signature: immediateUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::ImmediateUnit

index(...)
C++ signature:     index(TTAProgram::Terminal {lvalue}) -> int C++ signature:     index(Terminal_wrapper {lvalue}) -> int

instructionReference(...)
C++ signature: instructionReference(TTAProgram::Terminal {lvalue}) -> TTAProgram::InstructionReference

isAddress(...)
C++ signature:     isAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isAddress(Terminal_wrapper {lvalue}) -> bool

isGPR(...)
C++ signature:     isGPR(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isGPR(Terminal_wrapper {lvalue}) -> bool

isImmediate(...)
C++ signature:     isImmediate(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isImmediate(Terminal_wrapper {lvalue}) -> bool

isImmediateRegister(...)
C++ signature:     isImmediateRegister(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isImmediateRegister(Terminal_wrapper {lvalue}) -> bool

isInstructionAddress(...)
C++ signature:     isInstructionAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isInstructionAddress(Terminal_wrapper {lvalue}) -> bool

registerFile(...)
C++ signature: registerFile(TTAProgram::Terminal {lvalue}) -> TTAMachine::RegisterFile

setIndex(...)
C++ signature:     setIndex(TTAProgram::Terminal {lvalue}, int index) -> void* C++ signature:     setIndex(Terminal_wrapper {lvalue}, int index) -> void*

setInstructionReference(...)
C++ signature:     setInstructionReference(TTAProgram::Terminal {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void* C++ signature:     setInstructionReference(Terminal_wrapper {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void*

value(...)
C++ signature:     value(TTAProgram::Terminal {lvalue}) -> SimValue C++ signature:     value(Terminal_wrapper {lvalue}) -> SimValue

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class TerminalImmediate(Terminal)


Method resolution order:

TerminalImmediate

Terminal

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, SimValue value) -> void*

copy(...)
C++ signature:     copy(TTAProgram::TerminalImmediate {lvalue}) -> TTAProgram::Terminal* C++ signature:     copy(TerminalImmediate_wrapper {lvalue}) -> TTAProgram::Terminal*

equals(...)
C++ signature:     equals(TTAProgram::TerminalImmediate {lvalue}, TTAProgram::Terminal other) -> bool C++ signature:     equals(TerminalImmediate_wrapper {lvalue}, TTAProgram::Terminal other) -> bool

isImmediate(...)
C++ signature:     isImmediate(TTAProgram::TerminalImmediate {lvalue}) -> bool C++ signature:     isImmediate(TerminalImmediate_wrapper {lvalue}) -> bool

value(...)
C++ signature:     value(TTAProgram::TerminalImmediate {lvalue}) -> SimValue C++ signature:     value(TerminalImmediate_wrapper {lvalue}) -> SimValue

Data and other attributes defined here:

__instance_size__ = 68

Methods inherited from Terminal:

__eq__(...)
C++ signature: __eq__(TTAProgram::Terminal {lvalue}, TTAProgram::Terminal) -> _object*

address(...)
C++ signature:     address(TTAProgram::Terminal {lvalue}) -> TTAProgram::Address C++ signature:     address(Terminal_wrapper {lvalue}) -> TTAProgram::Address

functionUnit(...)
C++ signature: functionUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::FunctionUnit

hintOperation(...)
C++ signature: hintOperation(TTAProgram::Terminal {lvalue}) -> Operation

immediateUnit(...)
C++ signature: immediateUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::ImmediateUnit

index(...)
C++ signature:     index(TTAProgram::Terminal {lvalue}) -> int C++ signature:     index(Terminal_wrapper {lvalue}) -> int

instructionReference(...)
C++ signature: instructionReference(TTAProgram::Terminal {lvalue}) -> TTAProgram::InstructionReference

isAddress(...)
C++ signature:     isAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isAddress(Terminal_wrapper {lvalue}) -> bool

isFUPort(...)
C++ signature:     isFUPort(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isFUPort(Terminal_wrapper {lvalue}) -> bool

isGPR(...)
C++ signature:     isGPR(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isGPR(Terminal_wrapper {lvalue}) -> bool

isImmediateRegister(...)
C++ signature:     isImmediateRegister(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isImmediateRegister(Terminal_wrapper {lvalue}) -> bool

isInstructionAddress(...)
C++ signature:     isInstructionAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isInstructionAddress(Terminal_wrapper {lvalue}) -> bool

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isOpcodeSetting(Terminal_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isTriggering(Terminal_wrapper {lvalue}) -> bool

operation(...)
C++ signature: operation(TTAProgram::Terminal {lvalue}) -> Operation

operationIndex(...)
C++ signature:     operationIndex(TTAProgram::Terminal {lvalue}) -> int C++ signature:     operationIndex(Terminal_wrapper {lvalue}) -> int

port(...)
C++ signature: port(TTAProgram::Terminal {lvalue}) -> TTAMachine::Port

registerFile(...)
C++ signature: registerFile(TTAProgram::Terminal {lvalue}) -> TTAMachine::RegisterFile

setIndex(...)
C++ signature:     setIndex(TTAProgram::Terminal {lvalue}, int index) -> void* C++ signature:     setIndex(Terminal_wrapper {lvalue}, int index) -> void*

setInstructionReference(...)
C++ signature:     setInstructionReference(TTAProgram::Terminal {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void* C++ signature:     setInstructionReference(Terminal_wrapper {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class TerminalInstructionAddress(TerminalImmediate)


Method resolution order:

TerminalInstructionAddress

TerminalImmediate

Terminal

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, TTAProgram::InstructionReference {lvalue} ref) -> void*

copy(...)
C++ signature:     copy(TTAProgram::TerminalInstructionAddress {lvalue}) -> TTAProgram::Terminal* C++ signature:     copy(TerminalInstructionAddress_wrapper {lvalue}) -> TTAProgram::Terminal*

equals(...)
C++ signature:     equals(TTAProgram::TerminalInstructionAddress {lvalue}, TTAProgram::Terminal other) -> bool C++ signature:     equals(TerminalInstructionAddress_wrapper {lvalue}, TTAProgram::Terminal other) -> bool

instructionReference(...)
C++ signature: instructionReference(TTAProgram::TerminalInstructionAddress {lvalue}) -> TTAProgram::InstructionReference

isInstructionAddress(...)
C++ signature:     isInstructionAddress(TTAProgram::TerminalInstructionAddress {lvalue}) -> bool C++ signature:     isInstructionAddress(TerminalInstructionAddress_wrapper {lvalue}) -> bool

setInstructionReference(...)
C++ signature:     setInstructionReference(TTAProgram::TerminalInstructionAddress {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void* C++ signature:     setInstructionReference(TerminalInstructionAddress_wrapper {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void*

value(...)
C++ signature:     value(TTAProgram::TerminalInstructionAddress {lvalue}) -> SimValue C++ signature:     value(TerminalInstructionAddress_wrapper {lvalue}) -> SimValue

Data and other attributes defined here:

__instance_size__ = 72

Methods inherited from TerminalImmediate:

isImmediate(...)
C++ signature:     isImmediate(TTAProgram::TerminalImmediate {lvalue}) -> bool C++ signature:     isImmediate(TerminalImmediate_wrapper {lvalue}) -> bool

Methods inherited from Terminal:

__eq__(...)
C++ signature: __eq__(TTAProgram::Terminal {lvalue}, TTAProgram::Terminal) -> _object*

address(...)
C++ signature:     address(TTAProgram::Terminal {lvalue}) -> TTAProgram::Address C++ signature:     address(Terminal_wrapper {lvalue}) -> TTAProgram::Address

functionUnit(...)
C++ signature: functionUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::FunctionUnit

hintOperation(...)
C++ signature: hintOperation(TTAProgram::Terminal {lvalue}) -> Operation

immediateUnit(...)
C++ signature: immediateUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::ImmediateUnit

index(...)
C++ signature:     index(TTAProgram::Terminal {lvalue}) -> int C++ signature:     index(Terminal_wrapper {lvalue}) -> int

isAddress(...)
C++ signature:     isAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isAddress(Terminal_wrapper {lvalue}) -> bool

isFUPort(...)
C++ signature:     isFUPort(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isFUPort(Terminal_wrapper {lvalue}) -> bool

isGPR(...)
C++ signature:     isGPR(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isGPR(Terminal_wrapper {lvalue}) -> bool

isImmediateRegister(...)
C++ signature:     isImmediateRegister(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isImmediateRegister(Terminal_wrapper {lvalue}) -> bool

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isOpcodeSetting(Terminal_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isTriggering(Terminal_wrapper {lvalue}) -> bool

operation(...)
C++ signature: operation(TTAProgram::Terminal {lvalue}) -> Operation

operationIndex(...)
C++ signature:     operationIndex(TTAProgram::Terminal {lvalue}) -> int C++ signature:     operationIndex(Terminal_wrapper {lvalue}) -> int

port(...)
C++ signature: port(TTAProgram::Terminal {lvalue}) -> TTAMachine::Port

registerFile(...)
C++ signature: registerFile(TTAProgram::Terminal {lvalue}) -> TTAMachine::RegisterFile

setIndex(...)
C++ signature:     setIndex(TTAProgram::Terminal {lvalue}, int index) -> void* C++ signature:     setIndex(Terminal_wrapper {lvalue}, int index) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class TerminalRegister(Terminal)


Method resolution order:

TerminalRegister

Terminal

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, TTAMachine::Port port, int index) -> void*

copy(...)
C++ signature:     copy(TTAProgram::TerminalRegister {lvalue}) -> TTAProgram::Terminal* C++ signature:     copy(TerminalRegister_wrapper {lvalue}) -> TTAProgram::Terminal*

equals(...)
C++ signature:     equals(TTAProgram::TerminalRegister {lvalue}, TTAProgram::Terminal other) -> bool C++ signature:     equals(TerminalRegister_wrapper {lvalue}, TTAProgram::Terminal other) -> bool

immediateUnit(...)
C++ signature: immediateUnit(TTAProgram::TerminalRegister {lvalue}) -> TTAMachine::ImmediateUnit

port(...)
C++ signature: port(TTAProgram::TerminalRegister {lvalue}) -> TTAMachine::Port

registerFile(...)
C++ signature: registerFile(TTAProgram::TerminalRegister {lvalue}) -> TTAMachine::RegisterFile

setIndex(...)
C++ signature:     setIndex(TTAProgram::TerminalRegister {lvalue}, int index) -> void* C++ signature:     setIndex(TerminalRegister_wrapper {lvalue}, int index) -> void*

Data and other attributes defined here:

__instance_size__ = 32

Methods inherited from Terminal:

__eq__(...)
C++ signature: __eq__(TTAProgram::Terminal {lvalue}, TTAProgram::Terminal) -> _object*

address(...)
C++ signature:     address(TTAProgram::Terminal {lvalue}) -> TTAProgram::Address C++ signature:     address(Terminal_wrapper {lvalue}) -> TTAProgram::Address

functionUnit(...)
C++ signature: functionUnit(TTAProgram::Terminal {lvalue}) -> TTAMachine::FunctionUnit

hintOperation(...)
C++ signature: hintOperation(TTAProgram::Terminal {lvalue}) -> Operation

index(...)
C++ signature:     index(TTAProgram::Terminal {lvalue}) -> int C++ signature:     index(Terminal_wrapper {lvalue}) -> int

instructionReference(...)
C++ signature: instructionReference(TTAProgram::Terminal {lvalue}) -> TTAProgram::InstructionReference

isAddress(...)
C++ signature:     isAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isAddress(Terminal_wrapper {lvalue}) -> bool

isFUPort(...)
C++ signature:     isFUPort(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isFUPort(Terminal_wrapper {lvalue}) -> bool

isGPR(...)
C++ signature:     isGPR(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isGPR(Terminal_wrapper {lvalue}) -> bool

isImmediate(...)
C++ signature:     isImmediate(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isImmediate(Terminal_wrapper {lvalue}) -> bool

isImmediateRegister(...)
C++ signature:     isImmediateRegister(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isImmediateRegister(Terminal_wrapper {lvalue}) -> bool

isInstructionAddress(...)
C++ signature:     isInstructionAddress(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isInstructionAddress(Terminal_wrapper {lvalue}) -> bool

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isOpcodeSetting(Terminal_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAProgram::Terminal {lvalue}) -> bool C++ signature:     isTriggering(Terminal_wrapper {lvalue}) -> bool

operation(...)
C++ signature: operation(TTAProgram::Terminal {lvalue}) -> Operation

operationIndex(...)
C++ signature:     operationIndex(TTAProgram::Terminal {lvalue}) -> int C++ signature:     operationIndex(Terminal_wrapper {lvalue}) -> int

setInstructionReference(...)
C++ signature:     setInstructionReference(TTAProgram::Terminal {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void* C++ signature:     setInstructionReference(Terminal_wrapper {lvalue}, TTAProgram::InstructionReference {lvalue} ref) -> void*

value(...)
C++ signature:     value(TTAProgram::Terminal {lvalue}) -> SimValue C++ signature:     value(Terminal_wrapper {lvalue}) -> SimValue

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T