OpenASIP  2.0
Public Types | Public Member Functions | Static Public Attributes | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
IPXactModel Class Reference

#include <IPXactModel.hh>

Inheritance diagram for IPXactModel:
Inheritance graph
Collaboration diagram for IPXactModel:
Collaboration graph

Public Types

enum  BusMode {
  INVALID, MASTER, MIRRORED_MASTER, SLAVE,
  MIRRORED_SLAVE, SYSTEM, MIRRORED_SYSTEM, MONITOR
}
 

Public Member Functions

 IPXactModel ()
 
 IPXactModel (const ObjectState *state)
 
virtual ~IPXactModel ()
 
virtual void loadState (const ObjectState *state)
 
virtual ObjectStatesaveState () const
 
void setVLNV (TCEString vendor, TCEString library, TCEString name, TCEString version)
 
void setHdlFile (const TCEString &file)
 
void setFile (const TCEString &file)
 
void setHdlFiles (const std::vector< TCEString > &files)
 
void addSignal (const HDLPort &signal)
 
void addParameter (const ProGe::Parameter &parameter)
 
void addBusInterface (IPXactInterface *interface)
 
void addAddressSpace (IPXactAddressSpace *addrSpace)
 
- Public Member Functions inherited from Serializable
virtual ~Serializable ()
 

Static Public Attributes

static const TCEString OSNAME_IPXACT_MODEL = "spirit:component"
 
static const TCEString OSNAME_VENDOR = "spirit:vendor"
 
static const TCEString OSNAME_LIBRARY = "spirit:library"
 
static const TCEString OSNAME_NAME = "spirit:name"
 
static const TCEString OSNAME_VERSION = "spirit:version"
 
static const TCEString OSNAME_BUS_INTERFACES = "spirit:busInterfaces"
 
static const TCEString OSNAME_BUS_INTERFACE = "spirit:busInterface"
 
static const TCEString OSNAME_BUS_TYPE = "spirit:busType"
 
static const TCEString OSNAME_BUS_ABS_TYPE = "spirit:abstractionType"
 
static const TCEString OSNAME_BUS_MASTER = "spirit:master"
 
static const TCEString OSNAME_BUS_MIRRORED_MASTER
 
static const TCEString OSNAME_BUS_SLAVE = "spirit:slave"
 
static const TCEString OSNAME_BUS_MIRRORED_SLAVE
 
static const TCEString OSNAME_BUS_SYSTEM = "spirit:system"
 
static const TCEString OSNAME_BUS_MIRRORED_SYSTEM
 
static const TCEString OSNAME_BUS_MONITOR = "spirit:monitor"
 
static const TCEString OSNAME_BUS_PORT_MAPS = "spirit:portMaps"
 
static const TCEString OSNAME_BUS_PORT_MAP = "spirit:portMap"
 
static const TCEString OSNAME_BUS_PORT_MAP_NAME = "spirit:name"
 
static const TCEString OSNAME_BUS_PORT_MAP_COMP
 
static const TCEString OSNAME_BUS_PORT_MAP_BUS
 
static const TCEString OSNAME_MODEL = "spirit:model"
 
static const TCEString OSNAME_PORTS = "spirit:ports"
 
static const TCEString OSNAME_WIRE = "spirit:wire"
 
static const TCEString OSNAME_VECTOR = "spirit:vector"
 
static const TCEString OSNAME_PORT = "spirit:port"
 
static const TCEString OSNAME_PORT_DIRECTION = "spirit:direction"
 
static const TCEString OSNAME_PORT_LEFT = "spirit:left"
 
static const TCEString OSNAME_PORT_RIGHT = "spirit:right"
 
static const TCEString OSNAME_FILESETS = "spirit:fileSets"
 
static const TCEString OSNAME_FILESET = "spirit:fileSet"
 
static const TCEString OSNAME_FILE = "spirit:file"
 
static const TCEString OSNAME_FILE_NAME = "spirit:name"
 
static const TCEString OSNAME_FILE_TYPE = "spirit:fileType"
 
static const std::string OSNAME_ADDRESS_SPACES = "spirit:addressSpaces"
 
static const std::string OSNAME_ADDRESS_SPACE = "spirit:addressSpace"
 
static const std::string OSNAME_AS_RANGE = "spirit:range"
 
static const std::string OSNAME_AS_WIDTH = "spirit:width"
 
static const std::string OSNAME_AS_MAU = "spirit:addressUnitBits"
 
static const TCEString OSNAME_MODEL_PARAMS = "spirit:modelParameters"
 
static const TCEString OSNAME_MODEL_PARAM = "spirit:modelParameter"
 
static const TCEString OSNAME_DISPLAY_NAME = "spirit:displayName"
 
static const TCEString OSNAME_VALUE = "spirit:value"
 
static const TCEString OSNAME_ATTR_DATA_TYPE = "spirit:dataType"
 
static const TCEString OSNAME_ATTR_FORMAT = "spirit:format"
 
static const TCEString OSNAME_ATTR_ID = "spirit:id"
 
static const TCEString OSNAME_ATTR_RESOLVE = "spirit:resolve"
 

Private Member Functions

 IPXactModel (const IPXactModel &old)
 
void addBusInterfaceObject (const IPXactInterface *bus, ObjectState *parent) const
 
void addAddressSpaceObject (const IPXactAddressSpace *as, ObjectState *parent) const
 
void addSignalObject (const HDLPort *port, ObjectState *parent) const
 
void addModelParamsObject (ObjectState *parent) const
 
void addFileObject (const TCEString &name, const TCEString &type, ObjectState *parent) const
 
void extractVLNV (const ObjectState *root)
 
IPXact::Vlnv extractVlnvFromAttr (const ObjectState *busType) const
 
void extractBusInterfaces (const ObjectState *busInterfaces)
 
void extractBusInterface (const ObjectState *busInterface)
 
void extractAddressSpaces (const ObjectState *addressSpaces)
 
void extractAddressSpace (const ObjectState *as)
 
BusMode extractBusMode (const ObjectState *busInterface) const
 
void extractPortMappings (const ObjectState *portMaps, IPXactInterface &interface) const
 
void extractPortMap (const ObjectState *portMap, IPXactInterface &interface) const
 
void extractSignals (const ObjectState *signals)
 
void extractModelParams (const ObjectState *modelParameters)
 
void extractModelParam (const ObjectState *modelParameter)
 
void extractFiles (const ObjectState *fileSets)
 
IPXactInterfaceinterfaceByType (const IPXact::Vlnv &type, const IPXact::Vlnv &absType, const TCEString instanceName, BusMode mode) const
 

Private Attributes

IPXact::Vlnv vlnv_
 
std::vector< HDLPort * > signals_
 
std::vector< ProGe::Parameterparameters_
 
std::vector< IPXactInterface * > busInterfaces_
 
std::vector< IPXactAddressSpace * > addressSpaces_
 
std::vector< TCEStringhdlFiles_
 
std::vector< TCEStringotherFiles_
 

Static Private Attributes

static const TCEString HDL_SET_ID = "hdlSources"
 
static const TCEString VHDL_FILE = "vhdlSource"
 
static const TCEString OTHER_FILE = "unknown"
 
static const TCEString RESOLVE_USER = "user"
 
static const TCEString STRING_PARAM = "string"
 
static const TCEString INTEGER_PARAM = "integer"
 
static const TCEString LONG_PARAM = "long"
 
static const TCEString DEV_FAMILY_GENERIC = "dev_family_g"
 

Detailed Description

Definition at line 47 of file IPXactModel.hh.

Member Enumeration Documentation

◆ BusMode

Enumerator
INVALID 
MASTER 
MIRRORED_MASTER 
SLAVE 
MIRRORED_SLAVE 
SYSTEM 
MIRRORED_SYSTEM 
MONITOR 

Definition at line 50 of file IPXactModel.hh.

50  {
51  INVALID,
52  MASTER,
54  SLAVE,
56  SYSTEM,
58  MONITOR
59  };

Constructor & Destructor Documentation

◆ IPXactModel() [1/3]

IPXactModel::IPXactModel ( )

Definition at line 110 of file IPXactModel.cc.

110  :
111  vlnv_("","","",""), signals_(), parameters_(), busInterfaces_(),
113 }

◆ IPXactModel() [2/3]

IPXactModel::IPXactModel ( const ObjectState state)

Definition at line 115 of file IPXactModel.cc.

116  : vlnv_("", "", "", ""),
117  signals_(),
118  parameters_(),
119  busInterfaces_(),
120  addressSpaces_(),
121  hdlFiles_(),
122  otherFiles_() {
123  loadState(state);
124 }

References loadState().

Here is the call graph for this function:

◆ ~IPXactModel()

IPXactModel::~IPXactModel ( )
virtual

Definition at line 126 of file IPXactModel.cc.

126  {
127 
128  for (unsigned int i = 0; i < signals_.size(); i++) {
129  delete signals_.at(i);
130  }
131  for (unsigned int i = 0; i < busInterfaces_.size(); i++) {
132  if (busInterfaces_.at(i) != NULL) {
133  delete busInterfaces_.at(i);
134  }
135  }
136  for (unsigned int i = 0; i < addressSpaces_.size(); i++) {
137  if (addressSpaces_.at(i) != NULL) {
138  delete addressSpaces_.at(i);
139  }
140  }
141 }

References addressSpaces_, busInterfaces_, and signals_.

◆ IPXactModel() [3/3]

IPXactModel::IPXactModel ( const IPXactModel old)
private

Member Function Documentation

◆ addAddressSpace()

void IPXactModel::addAddressSpace ( IPXactAddressSpace addrSpace)

Definition at line 307 of file IPXactModel.cc.

307  {
308 
309  addressSpaces_.push_back(addrSpace);
310 }

References addressSpaces_.

Referenced by IPXactFileGenerator::addAddressSpaces().

◆ addAddressSpaceObject()

void IPXactModel::addAddressSpaceObject ( const IPXactAddressSpace as,
ObjectState parent 
) const
private

Definition at line 381 of file IPXactModel.cc.

383  {
384 
385  ObjectState* name = new ObjectState(OSNAME_NAME);
386  name->setValue(as->name());
387  parent->addChild(name);
388 
390  range->setValue(as->memRange());
391  parent->addChild(range);
392 
394  width->setValue(as->memLocationWidth());
395  parent->addChild(width);
396 
397  if (as->mauWidth() > 0) {
399  mau->setValue(as->mauWidth());
400  parent->addChild(mau);
401  }
402 }

References ObjectState::addChild(), IPXactAddressSpace::mauWidth(), IPXactAddressSpace::memLocationWidth(), IPXactAddressSpace::memRange(), IPXactAddressSpace::name(), OSNAME_AS_MAU, OSNAME_AS_RANGE, OSNAME_AS_WIDTH, OSNAME_NAME, and ObjectState::setValue().

Referenced by saveState().

Here is the call graph for this function:

◆ addBusInterface()

void IPXactModel::addBusInterface ( IPXactInterface interface)

Definition at line 301 of file IPXactModel.cc.

301  {
302 
303  busInterfaces_.push_back(interface);
304 }

References busInterfaces_.

Referenced by IPXactFileGenerator::addBusInterfaces().

◆ addBusInterfaceObject()

void IPXactModel::addBusInterfaceObject ( const IPXactInterface bus,
ObjectState parent 
) const
private

Definition at line 314 of file IPXactModel.cc.

316  {
317 
318  ObjectState* busName = new ObjectState(OSNAME_NAME);
319  busName->setValue(bus->instanceName());
320  parent->addChild(busName);
321 
322  Vlnv busIfType = bus->busType();
323  ObjectState* busType = new ObjectState(OSNAME_BUS_TYPE);
324  busType->setAttribute(OSNAME_VENDOR, busIfType.vendor);
325  busType->setAttribute(OSNAME_LIBRARY, busIfType.library);
326  busType->setAttribute(OSNAME_NAME, busIfType.name);
327  busType->setAttribute(OSNAME_VERSION, busIfType.version);
328  parent->addChild(busType);
329 
330  Vlnv absType = bus->busAbstractionType();
331  ObjectState* busAbsType = new ObjectState(OSNAME_BUS_ABS_TYPE);
332  busAbsType->setAttribute(OSNAME_VENDOR, absType.vendor);
333  busAbsType->setAttribute(OSNAME_LIBRARY, absType.library);
334  busAbsType->setAttribute(OSNAME_NAME, absType.name);
335  busAbsType->setAttribute(OSNAME_VERSION, absType.version);
336  parent->addChild(busAbsType);
337 
338  ObjectState* mode = NULL;
339  BusMode busMode = bus->busMode();
340  if (busMode == MASTER) {
342  } else if (busMode == MIRRORED_MASTER) {
344  } else if (busMode == SLAVE) {
346  } else if (busMode == MIRRORED_SLAVE) {
348  } else {
349  TCEString msg = "Unknown bus mode!";
350  InvalidData exc(__FILE__, __LINE__, "IPXactModel", msg);
351  throw exc;
352  }
353  parent->addChild(mode);
354 
356  parent->addChild(portMaps);
357 
358  const SignalMappingList& signalMap = bus->interfaceMapping();
359  for (unsigned int i = 0; i < signalMap.size(); i++) {
360  ObjectState* portMapping = new ObjectState(OSNAME_BUS_PORT_MAP);
361  portMaps->addChild(portMapping);
362 
364  ObjectState* compPortName = new ObjectState(OSNAME_BUS_PORT_MAP_NAME);
365  compPortName->setValue(signalMap.at(i)->first);
366  compPort->addChild(compPortName);
367 
370  busPortName->setValue(signalMap.at(i)->second);
371  busPort->addChild(busPortName);
372 
373  // in IP-XACT 1.5 bus logical port comes before physical port
374  portMapping->addChild(busPort);
375  portMapping->addChild(compPort);
376  }
377 }

References ObjectState::addChild(), IPXactInterface::busAbstractionType(), IPXactInterface::busMode(), IPXactInterface::busType(), IPXactInterface::instanceName(), IPXactInterface::interfaceMapping(), IPXact::Vlnv::library, MASTER, MIRRORED_MASTER, MIRRORED_SLAVE, IPXact::Vlnv::name, OSNAME_BUS_ABS_TYPE, OSNAME_BUS_MASTER, OSNAME_BUS_MIRRORED_MASTER, OSNAME_BUS_MIRRORED_SLAVE, OSNAME_BUS_PORT_MAP, OSNAME_BUS_PORT_MAP_BUS, OSNAME_BUS_PORT_MAP_COMP, OSNAME_BUS_PORT_MAP_NAME, OSNAME_BUS_PORT_MAPS, OSNAME_BUS_SLAVE, OSNAME_BUS_TYPE, OSNAME_LIBRARY, OSNAME_NAME, OSNAME_VENDOR, OSNAME_VERSION, ObjectState::setAttribute(), ObjectState::setValue(), SLAVE, IPXact::Vlnv::vendor, and IPXact::Vlnv::version.

Referenced by saveState().

Here is the call graph for this function:

◆ addFileObject()

void IPXactModel::addFileObject ( const TCEString name,
const TCEString type,
ObjectState parent 
) const
private

Definition at line 503 of file IPXactModel.cc.

506  {
507 
508  ObjectState* fileName = new ObjectState(OSNAME_FILE_NAME);
509  fileName->setValue(name);
510  parent->addChild(fileName);
511  ObjectState* fileType = new ObjectState(OSNAME_FILE_TYPE);
512  fileType->setValue(type);
513  parent->addChild(fileType);
514 }

References ObjectState::addChild(), OSNAME_FILE_NAME, OSNAME_FILE_TYPE, and ObjectState::setValue().

Referenced by saveState().

Here is the call graph for this function:

◆ addModelParamsObject()

void IPXactModel::addModelParamsObject ( ObjectState parent) const
private

Definition at line 461 of file IPXactModel.cc.

461  {
462 
464  parent->addChild(params);
465  for (unsigned int i = 0; i < parameters_.size(); i++) {
467  if (parameters_.at(i).type().lower() == STRING_PARAM) {
469  } else if (parameters_.at(i).type().lower() == INTEGER_PARAM) {
471  } else {
472  // unsuppored type, ignore
473  delete param;
474  continue;
475  }
476  params->addChild(param);
477 
478  ObjectState* name = new ObjectState(OSNAME_NAME);
479  name->setValue(parameters_.at(i).name());
480  param->addChild(name);
481 
482  ObjectState* displayName = new ObjectState(OSNAME_DISPLAY_NAME);
483  displayName->setValue(parameters_.at(i).name());
484  param->addChild(displayName);
485 
486  ObjectState* value = new ObjectState(OSNAME_VALUE);
487  if (parameters_.at(i).type().lower() == STRING_PARAM) {
489  } else if (parameters_.at(i).type().lower() == INTEGER_PARAM) {
491  }
492  TCEString id;
493  id << parameters_.at(i).name().upper() << "_ID";
494  value->setAttribute(OSNAME_ATTR_ID, id);
496  value->setValue(parameters_.at(i).value());
497  param->addChild(value);
498  }
499 }

References ObjectState::addChild(), INTEGER_PARAM, LONG_PARAM, OSNAME_ATTR_DATA_TYPE, OSNAME_ATTR_FORMAT, OSNAME_ATTR_ID, OSNAME_ATTR_RESOLVE, OSNAME_DISPLAY_NAME, OSNAME_MODEL_PARAM, OSNAME_MODEL_PARAMS, OSNAME_NAME, OSNAME_VALUE, parameters_, RESOLVE_USER, ObjectState::setAttribute(), ObjectState::setValue(), and STRING_PARAM.

Referenced by saveState().

Here is the call graph for this function:

◆ addParameter()

void IPXactModel::addParameter ( const ProGe::Parameter parameter)

Definition at line 296 of file IPXactModel.cc.

296  {
297  parameters_.push_back(parameter);
298 }

References parameters_.

Referenced by IPXactFileGenerator::writeProjectFiles().

◆ addSignal()

void IPXactModel::addSignal ( const HDLPort signal)

Definition at line 290 of file IPXactModel.cc.

290  {
291 
292  signals_.push_back(new HDLPort(signal));
293 }

References signals_.

Referenced by IPXactFileGenerator::writeProjectFiles().

◆ addSignalObject()

void IPXactModel::addSignalObject ( const HDLPort port,
ObjectState parent 
) const
private

Definition at line 406 of file IPXactModel.cc.

407  {
408 
409  ObjectState* name = new ObjectState(OSNAME_NAME);
410  name->setValue(port->name());
411  parent->addChild(name);
412 
413  ObjectState* wire = new ObjectState(OSNAME_WIRE);
414  parent->addChild(wire);
415 
417  TCEString dir = "";
418  if (port->direction() == ProGe::IN) {
419  dir = "in";
420  } else if (port->direction() == ProGe::OUT) {
421  dir = "out";
422  } else if (port->direction() == ProGe::BIDIR) {
423  dir = "inout";
424  } else {
425  assert(false && "unknown direction");
426  }
427  direction->setValue(dir);
428  wire->addChild(direction);
429 
430  ObjectState* vector = NULL;
431  if (port->type() == ProGe::BIT_VECTOR) {
432  int leftBorder = 0;
433  int rightBorder = 0;
434  vector = new ObjectState(OSNAME_VECTOR);
435  if (port->hasRealWidth()) {
436  int width = port->realWidth();
437  if (width > 1) {
438  leftBorder = width-1;
439  }
440  } else {
441  // width is unknown, guessing 1
442  leftBorder = 0;
443  }
445  left->setValue(leftBorder);
446  vector->addChild(left);
448  right->setValue(rightBorder);
449  vector->addChild(right);
450  } else if (port->type() != ProGe::BIT) {
451  assert(false && "unknown port type");
452  }
453 
454  if (vector != NULL) {
455  wire->addChild(vector);
456  }
457 }

References ObjectState::addChild(), assert, ProGe::BIDIR, ProGe::BIT, ProGe::BIT_VECTOR, HDLPort::direction(), HDLPort::hasRealWidth(), ProGe::IN, HDLPort::name(), OSNAME_NAME, OSNAME_PORT_DIRECTION, OSNAME_PORT_LEFT, OSNAME_PORT_RIGHT, OSNAME_VECTOR, OSNAME_WIRE, ProGe::OUT, HDLPort::realWidth(), ObjectState::setValue(), and HDLPort::type().

Referenced by saveState().

Here is the call graph for this function:

◆ extractAddressSpace()

void IPXactModel::extractAddressSpace ( const ObjectState as)
private

Definition at line 649 of file IPXactModel.cc.

649  {
650 
651  assert(as->name() == OSNAME_ADDRESS_SPACE);
652  TCEString errorMsg = "Address space has no ";
653  if (!as->hasChild(OSNAME_NAME)) {
654  errorMsg << "name.";
657  __FILE__, __LINE__, "IPXactModel", errorMsg);
658  throw exc;
659  } else if (!as->hasChild(OSNAME_AS_RANGE)) {
660  errorMsg << "range.";
663  __FILE__, __LINE__, "IPXactModel", errorMsg);
664  throw exc;
665  } else if (!as->hasChild(OSNAME_AS_WIDTH)) {
666  errorMsg << "width.";
669  __FILE__, __LINE__, "IPXactModel", errorMsg);
670  throw exc;
671  }
673  int range = as->childByName(OSNAME_AS_RANGE)->intValue();
674  int width = as->childByName(OSNAME_AS_WIDTH)->intValue();
675  int mau = 0;
676  if (as->hasChild(OSNAME_AS_MAU)) {
677  mau = as->childByName(OSNAME_AS_WIDTH)->intValue();
678  }
679  IPXactAddressSpace* ipXactAs =
680  new IPXactAddressSpace(name, range, width, mau);
681  addressSpaces_.push_back(ipXactAs);
682 }

References addressSpaces_, assert, ObjectState::childByName(), ObjectState::hasChild(), ObjectState::intValue(), ObjectState::name(), OSNAME_ADDRESS_SPACE, OSNAME_AS_MAU, OSNAME_AS_RANGE, OSNAME_AS_WIDTH, OSNAME_NAME, and ObjectState::stringValue().

Referenced by extractAddressSpaces().

Here is the call graph for this function:

◆ extractAddressSpaces()

void IPXactModel::extractAddressSpaces ( const ObjectState addressSpaces)
private

Definition at line 633 of file IPXactModel.cc.

633  {
634 
635  assert(addressSpaces->name() == OSNAME_ADDRESS_SPACES);
636  if (!addressSpaces->hasChild(OSNAME_ADDRESS_SPACE)) {
637  return;
638  }
639  for (int i = 0; i < addressSpaces->childCount(); i++) {
640  const ObjectState* as = addressSpaces->child(i);
641  if (as->name() == OSNAME_ADDRESS_SPACE) {
643  }
644  }
645 }

References assert, ObjectState::child(), ObjectState::childCount(), extractAddressSpace(), ObjectState::hasChild(), ObjectState::name(), OSNAME_ADDRESS_SPACE, and OSNAME_ADDRESS_SPACES.

Referenced by loadState().

Here is the call graph for this function:

◆ extractBusInterface()

void IPXactModel::extractBusInterface ( const ObjectState busInterface)
private

Definition at line 578 of file IPXactModel.cc.

578  {
579 
580  assert(busInterface->name() == OSNAME_BUS_INTERFACE);
581  if (!busInterface->hasChild(OSNAME_NAME)) {
582  TCEString msg = "Bus has no name";
584  new ObjectStateLoadingException(__FILE__, __LINE__,
585  "IPXactModel", msg);
586  throw exc;
587  }
588  if (!busInterface->hasChild(OSNAME_BUS_TYPE)) {
589  TCEString msg = "Bus has no type";
591  new ObjectStateLoadingException(__FILE__, __LINE__,
592  "IPXactModel", msg);
593  throw exc;
594  }
595  if (!busInterface->hasChild(OSNAME_BUS_ABS_TYPE)) {
596  TCEString msg = "Bus has no abstraction type";
598  new ObjectStateLoadingException(__FILE__, __LINE__,
599  "IPXactModel", msg);
600  throw exc;
601  }
602 
603  TCEString instanceName =
604  busInterface->childByName(OSNAME_NAME)->stringValue();
605  const ObjectState* busType =
606  busInterface->childByName(OSNAME_BUS_TYPE);
607  const ObjectState* busAbsType = busInterface->childByName(
609  IPXact::Vlnv type = extractVlnvFromAttr(busType);
610  IPXact::Vlnv absType = extractVlnvFromAttr(busAbsType);
611  BusMode mode = extractBusMode(busInterface);
612 
613  IPXactInterface* interface =
614  interfaceByType(type, absType, instanceName, mode);
615  if (!interface) {
616  TCEString msg = "Unknown bus type";
618  new ObjectStateLoadingException(__FILE__, __LINE__,
619  "IPXactModel", msg);
620  throw exc;
621  }
622 
623  if (busInterface->hasChild(OSNAME_BUS_PORT_MAPS)) {
624  const ObjectState* portMaps =
625  busInterface->childByName(OSNAME_BUS_PORT_MAPS);
626  extractPortMappings(portMaps, *interface);
627  }
628  busInterfaces_.push_back(interface);
629 }

References assert, busInterfaces_, ObjectState::childByName(), extractBusMode(), extractPortMappings(), extractVlnvFromAttr(), ObjectState::hasChild(), interfaceByType(), ObjectState::name(), OSNAME_BUS_ABS_TYPE, OSNAME_BUS_INTERFACE, OSNAME_BUS_PORT_MAPS, OSNAME_BUS_TYPE, OSNAME_NAME, and ObjectState::stringValue().

Referenced by extractBusInterfaces().

Here is the call graph for this function:

◆ extractBusInterfaces()

void IPXactModel::extractBusInterfaces ( const ObjectState busInterfaces)
private

Definition at line 562 of file IPXactModel.cc.

562  {
563 
564  assert(busInterfaces->name() == OSNAME_BUS_INTERFACES);
565  if (!busInterfaces->hasChild(OSNAME_BUS_INTERFACE)) {
566  return;
567  }
568  for (int i = 0; i < busInterfaces->childCount(); i++) {
569  const ObjectState* bus = busInterfaces->child(i);
570  if (bus->name() == OSNAME_BUS_INTERFACE) {
571  extractBusInterface(bus);
572  }
573  }
574 }

References assert, ObjectState::child(), ObjectState::childCount(), extractBusInterface(), ObjectState::hasChild(), ObjectState::name(), OSNAME_BUS_INTERFACE, and OSNAME_BUS_INTERFACES.

Referenced by loadState().

Here is the call graph for this function:

◆ extractBusMode()

IPXactModel::BusMode IPXactModel::extractBusMode ( const ObjectState busInterface) const
private

Definition at line 686 of file IPXactModel.cc.

686  {
687 
688  assert(busInterface->name() == OSNAME_BUS_INTERFACE);
689  BusMode mode = INVALID;
690  if (busInterface->hasChild(OSNAME_BUS_MASTER)) {
691  mode = MASTER;
692  } else if (busInterface->hasChild(OSNAME_BUS_MIRRORED_MASTER)) {
694  } else if (busInterface->hasChild(OSNAME_BUS_SLAVE)) {
695  mode = SLAVE;
696  } else if (busInterface->hasChild(OSNAME_BUS_MIRRORED_SLAVE)) {
698  } else if (busInterface->hasChild(OSNAME_BUS_SYSTEM)) {
699  mode = SYSTEM;
700  } else if (busInterface->hasChild(OSNAME_BUS_MIRRORED_SYSTEM)) {
702  } else if (busInterface->hasChild(OSNAME_BUS_MONITOR)) {
703  mode = MONITOR;
704  } else {
705  assert(false && "Unknown bus mode!");
706  }
707  assert(mode != INVALID && "Bus mode is invalid");
708  return mode;
709 }

References assert, ObjectState::hasChild(), INVALID, MASTER, MIRRORED_MASTER, MIRRORED_SLAVE, MIRRORED_SYSTEM, MONITOR, ObjectState::name(), OSNAME_BUS_INTERFACE, OSNAME_BUS_MASTER, OSNAME_BUS_MIRRORED_MASTER, OSNAME_BUS_MIRRORED_SLAVE, OSNAME_BUS_MIRRORED_SYSTEM, OSNAME_BUS_MONITOR, OSNAME_BUS_SLAVE, OSNAME_BUS_SYSTEM, SLAVE, and SYSTEM.

Referenced by extractBusInterface().

Here is the call graph for this function:

◆ extractFiles()

void IPXactModel::extractFiles ( const ObjectState fileSets)
private

Definition at line 851 of file IPXactModel.cc.

851  {
852 
853  assert(fileSets->name() == OSNAME_FILESETS);
854  for (int i = 0; i < fileSets->childCount(); i++) {
855  const ObjectState* fs = fileSets->child(i);
856  if (fs->name() != OSNAME_FILESET) {
857  continue;
858  }
859  if (!fs->hasChild(OSNAME_FILE_NAME)) {
860  TCEString msg = "Fileset has no name!";
861  InvalidData exc(__FILE__, __LINE__, "IPXactModel", msg);
862  throw exc;
863  }
865  if (fsName != HDL_SET_ID) {
866  // unknown stuff, ignore
867  continue;
868  }
869 
870  for (int j = 0; j < fs->childCount(); j++) {
871  const ObjectState* file = fs->child(j);
872  if (file->name() != OSNAME_FILE) {
873  continue;
874  }
875  TCEString fileName = "";
876  TCEString fileType = "";
877  if (file->hasChild(OSNAME_NAME)) {
878  fileName = file->childByName(OSNAME_NAME)->stringValue();
879  }
880  if (file->hasChild(OSNAME_FILE_TYPE)) {
881  fileType = file->childByName(OSNAME_FILE_TYPE)->stringValue();
882  }
883 
884  if (fileType == VHDL_FILE) {
885  hdlFiles_.push_back(fileName);
886  } else if (fileType == OTHER_FILE) {
887  otherFiles_.push_back(fileName);
888  } else {
889  // unknown file type, ignore
890  continue;
891  }
892  }
893  }
894 }

References assert, ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), ObjectState::hasChild(), HDL_SET_ID, hdlFiles_, ObjectState::name(), OSNAME_FILE, OSNAME_FILE_NAME, OSNAME_FILE_TYPE, OSNAME_FILESET, OSNAME_FILESETS, OSNAME_NAME, OTHER_FILE, otherFiles_, ObjectState::stringValue(), and VHDL_FILE.

Referenced by loadState().

Here is the call graph for this function:

◆ extractModelParam()

void IPXactModel::extractModelParam ( const ObjectState modelParameter)
private

Definition at line 942 of file IPXactModel.cc.

942  {
943 
944  assert(modelParameter->name() == OSNAME_MODEL_PARAM);
945  if (!modelParameter->hasChild(OSNAME_NAME)) {
946  TCEString msg = "Model parameter has no name";
948  new ObjectStateLoadingException(__FILE__, __LINE__,
949  "IPXactModel", msg);
950  throw exc;
951  }
952  if (!modelParameter->hasChild(OSNAME_VALUE)) {
953  TCEString msg = "Model parameter has no value";
955  new ObjectStateLoadingException(__FILE__, __LINE__,
956  "IPXactModel", msg);
957  throw exc;
958  }
959  ProGe::Parameter parameter;
960  const ObjectState* nameObj = modelParameter->childByName(OSNAME_NAME);
961  parameter.setName(nameObj->stringValue());
962 
963  parameter.setType(STRING_PARAM);
964  if (nameObj->hasAttribute(OSNAME_ATTR_DATA_TYPE)) {
965  TCEString typeAttr =
967  if (typeAttr.lower() == STRING_PARAM) {
968  parameter.setType(STRING_PARAM);
969  } else if (typeAttr.lower() == LONG_PARAM) {
970  parameter.setType(INTEGER_PARAM);
971  }
972  }
973 
974  const ObjectState* valueObj = modelParameter->childByName(OSNAME_VALUE);
975  parameter.setValue(valueObj->stringValue());
976  parameters_.push_back(parameter);
977 }

References assert, ObjectState::childByName(), ObjectState::hasAttribute(), ObjectState::hasChild(), INTEGER_PARAM, LONG_PARAM, TCEString::lower(), ObjectState::name(), OSNAME_ATTR_DATA_TYPE, OSNAME_MODEL_PARAM, OSNAME_NAME, OSNAME_VALUE, parameters_, ProGe::Parameter::setName(), ProGe::Parameter::setType(), ProGe::Parameter::setValue(), STRING_PARAM, ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by extractModelParams().

Here is the call graph for this function:

◆ extractModelParams()

void IPXactModel::extractModelParams ( const ObjectState modelParameters)
private

Definition at line 930 of file IPXactModel.cc.

930  {
931 
932  assert(modelParameters->name() == OSNAME_MODEL_PARAMS);
933  for (int i = 0; i < modelParameters->childCount(); i++) {
934  TCEString childName = modelParameters->child(i)->name();
935  if (childName == OSNAME_MODEL_PARAM) {
936  extractModelParam(modelParameters->child(i));
937  }
938  }
939 }

References assert, ObjectState::child(), ObjectState::childCount(), extractModelParam(), ObjectState::name(), OSNAME_MODEL_PARAM, and OSNAME_MODEL_PARAMS.

Referenced by loadState().

Here is the call graph for this function:

◆ extractPortMap()

void IPXactModel::extractPortMap ( const ObjectState portMap,
IPXactInterface interface 
) const
private

Definition at line 729 of file IPXactModel.cc.

731  {
732 
733  assert(portMap->name() == OSNAME_BUS_PORT_MAP);
734  if (!(portMap->hasChild(OSNAME_BUS_PORT_MAP_BUS) &&
735  portMap->hasChild(OSNAME_BUS_PORT_MAP_COMP))) {
736 
737  TCEString msg = "Bus interface port map is invalid";
739  new ObjectStateLoadingException(__FILE__, __LINE__,
740  "IPXactModel", msg);
741  throw exc;
742  }
743 
744  const ObjectState* busPort =
746  const ObjectState* compPort =
748  if (!busPort->hasChild(OSNAME_BUS_PORT_MAP_NAME) ||
749  !compPort->hasChild(OSNAME_BUS_PORT_MAP_NAME)) {
750 
751  TCEString msg = "Port name missing from port map";
753  new ObjectStateLoadingException(__FILE__, __LINE__,
754  "IPXactModel", msg);
755  throw exc;
756  }
757  TCEString compPortName =
759  TCEString busPortName =
761 
762  if (busPortName.empty() || compPortName.empty()) {
763  TCEString msg = "Port name is empty in port map";
765  new ObjectStateLoadingException(__FILE__, __LINE__,
766  "IPXactModel", msg);
767  throw exc;
768  }
769  interface.addSignalMapping(compPortName, busPortName);
770 }

References IPXactInterface::addSignalMapping(), assert, ObjectState::childByName(), ObjectState::hasChild(), ObjectState::name(), OSNAME_BUS_PORT_MAP, OSNAME_BUS_PORT_MAP_BUS, OSNAME_BUS_PORT_MAP_COMP, OSNAME_BUS_PORT_MAP_NAME, and ObjectState::stringValue().

Referenced by extractPortMappings().

Here is the call graph for this function:

◆ extractPortMappings()

void IPXactModel::extractPortMappings ( const ObjectState portMaps,
IPXactInterface interface 
) const
private

Definition at line 712 of file IPXactModel.cc.

714  {
715 
716  assert(portMaps->name() == OSNAME_BUS_PORT_MAPS);
717  if (!portMaps->hasChild(OSNAME_BUS_PORT_MAP)) {
718  return;
719  }
720  for (int i = 0; i < portMaps->childCount(); i++) {
721  const ObjectState* map = portMaps->child(i);
722  if (map->name() == OSNAME_BUS_PORT_MAP) {
723  extractPortMap(map, interface);
724  }
725  }
726 }

References assert, ObjectState::child(), ObjectState::childCount(), extractPortMap(), ObjectState::hasChild(), ObjectState::name(), OSNAME_BUS_PORT_MAP, and OSNAME_BUS_PORT_MAPS.

Referenced by extractBusInterface().

Here is the call graph for this function:

◆ extractSignals()

void IPXactModel::extractSignals ( const ObjectState signals)
private

Definition at line 773 of file IPXactModel.cc.

773  {
774 
775  assert(signals->name() == OSNAME_PORTS);
776 
777  for (int i = 0; i < signals->childCount(); i++) {
778  const ObjectState* signal = signals->child(i);
779  if (signal->name() != OSNAME_PORT) {
780  continue;
781  }
782 
783  TCEString name = "";
784  ProGe::Direction direction = ProGe::IN;
786  int width = 0;
787 
788  if (signal->hasChild(OSNAME_NAME)) {
789  name = signal->childByName(OSNAME_NAME)->stringValue();
790  }
791  if (!signal->hasChild(OSNAME_WIRE)) {
792  TCEString msg = "Wire node not found from Port!";
793  InvalidData exc(__FILE__, __LINE__, "IPXactModel", msg);
794  throw exc;
795  }
796  const ObjectState* wire = signal->childByName(OSNAME_WIRE);
797  if (wire->hasChild(OSNAME_PORT_DIRECTION)) {
798  TCEString dir =
800  if (dir == "in") {
801  direction = ProGe::IN;
802  } else if (dir == "out") {
803  direction = ProGe::OUT;
804  } else if (dir == "inout") {
805  direction = ProGe::BIDIR;
806  } else {
807  assert(false && "Unknown direction");
808  }
809  } else {
810  TCEString msg = "Port does not have direction!";
811  InvalidData exc(__FILE__, __LINE__, "IPXactModel", msg);
812  throw exc;
813  }
814 
815  if (wire->hasChild(OSNAME_VECTOR)) {
816  type = ProGe::BIT_VECTOR;
817  int leftBorder = 0;
818  int rightBorder = 0;
819  const ObjectState* vector = wire->childByName(OSNAME_VECTOR);
820  if (vector->hasChild(OSNAME_PORT_LEFT)) {
821  leftBorder =
823  assert(leftBorder >= 0);
824  }
825  if (vector->hasChild(OSNAME_PORT_RIGHT)) {
826  rightBorder =
828  assert(rightBorder >= 0);
829  }
830  if (leftBorder < rightBorder) {
831  TCEString msg = "Reversed bit order is not supported";
832  UnexpectedValue* exc =
833  new UnexpectedValue(__FILE__, __LINE__, "IPXactModel",
834  msg);
835  throw exc;
836  }
837  width = leftBorder - rightBorder + 1;
838  } else {
839  type = ProGe::BIT;
840  width = 0;
841  }
842 
843  TCEString widthFormula = Conversion::toString(width);
844  HDLPort* port = new HDLPort(name, widthFormula, type, direction,
845  false, width);
846  signals_.push_back(port);
847  }
848 }

References assert, ProGe::BIDIR, ProGe::BIT, ProGe::BIT_VECTOR, ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), ObjectState::hasChild(), ProGe::IN, ObjectState::intValue(), ObjectState::name(), OSNAME_NAME, OSNAME_PORT, OSNAME_PORT_DIRECTION, OSNAME_PORT_LEFT, OSNAME_PORT_RIGHT, OSNAME_PORTS, OSNAME_VECTOR, OSNAME_WIRE, ProGe::OUT, signals_, ObjectState::stringValue(), and Conversion::toString().

Referenced by loadState().

Here is the call graph for this function:

◆ extractVLNV()

void IPXactModel::extractVLNV ( const ObjectState root)
private

Definition at line 518 of file IPXactModel.cc.

518  {
519 
520  assert(root->name() == OSNAME_IPXACT_MODEL);
521  TCEString vendor = "";
522  TCEString library = "";
523  TCEString name = "";
524  TCEString version = "";
525  if (root->hasChild(OSNAME_VENDOR)) {
526  vendor = root->childByName(OSNAME_VENDOR)->stringValue();
527  }
528  if (root->hasChild(OSNAME_LIBRARY)) {
529  library = root->childByName(OSNAME_LIBRARY)->stringValue();
530  }
531  if (root->hasChild(OSNAME_NAME)) {
532  name = root->childByName(OSNAME_NAME)->stringValue();
533  }
534  if (root->hasChild(OSNAME_VERSION)) {
535  version = root->childByName(OSNAME_VERSION)->stringValue();
536  }
537  setVLNV(vendor, library, name, version);
538 }

References assert, ObjectState::childByName(), ObjectState::hasChild(), ObjectState::name(), OSNAME_IPXACT_MODEL, OSNAME_LIBRARY, OSNAME_NAME, OSNAME_VENDOR, OSNAME_VERSION, setVLNV(), and ObjectState::stringValue().

Referenced by loadState().

Here is the call graph for this function:

◆ extractVlnvFromAttr()

IPXact::Vlnv IPXactModel::extractVlnvFromAttr ( const ObjectState busType) const
private

Definition at line 541 of file IPXactModel.cc.

541  {
542 
543  assert(busType->name() == OSNAME_BUS_TYPE ||
544  busType->name() == OSNAME_BUS_ABS_TYPE);
545  IPXact::Vlnv vlnv;
546  if (busType->hasAttribute(OSNAME_VENDOR)) {
547  vlnv.vendor = busType->stringAttribute(OSNAME_VENDOR);
548  }
549  if (busType->hasAttribute(OSNAME_LIBRARY)) {
550  vlnv.library = busType->stringAttribute(OSNAME_LIBRARY);
551  }
552  if (busType->hasAttribute(OSNAME_NAME)) {
553  vlnv.name = busType->stringAttribute(OSNAME_NAME);
554  }
555  if (busType->hasAttribute(OSNAME_VERSION)) {
556  vlnv.version = busType->stringAttribute(OSNAME_VERSION);
557  }
558  return vlnv;
559 }

References assert, ObjectState::hasAttribute(), IPXact::Vlnv::library, IPXact::Vlnv::name, ObjectState::name(), OSNAME_BUS_ABS_TYPE, OSNAME_BUS_TYPE, OSNAME_LIBRARY, OSNAME_NAME, OSNAME_VENDOR, OSNAME_VERSION, ObjectState::stringAttribute(), IPXact::Vlnv::vendor, and IPXact::Vlnv::version.

Referenced by extractBusInterface().

Here is the call graph for this function:

◆ interfaceByType()

IPXactInterface * IPXactModel::interfaceByType ( const IPXact::Vlnv type,
const IPXact::Vlnv absType,
const TCEString  instanceName,
BusMode  mode 
) const
private

Definition at line 898 of file IPXactModel.cc.

902  {
903 
904  IPXactInterface* interface = NULL;
905 
906  vector<IPXactInterface*> available;
907  available.push_back(new IPXactClkInterface());
908  available.push_back(new IPXactResetInterface());
909  available.push_back(new IPXactHibiInterface());
910 
911  bool found = false;
912  for (unsigned int i = 0; i < available.size(); i++) {
913  if (!found) {
914  if (available.at(i)->busType() == type &&
915  available.at(i)->busAbstractionType() == absType &&
916  available.at(i)->busMode() == mode) {
917  interface = available.at(i);
918  interface->setInstanceName(instanceName);
919  found = true;
920  continue;
921  }
922  }
923  delete available.at(i);
924  }
925  return interface;
926 }

References IPXactInterface::setInstanceName().

Referenced by extractBusInterface().

Here is the call graph for this function:

◆ loadState()

void IPXactModel::loadState ( const ObjectState state)
virtual

Loads the state of the object from the given ObjectState object.

Parameters
stateObjectState object from which (and the children of which) the state is loaded.

Implements Serializable.

Definition at line 145 of file IPXactModel.cc.

145  {
146 
147  extractVLNV(state);
148 
149  if (state->hasChild(OSNAME_BUS_INTERFACES)) {
151  }
152 
153  if (state->hasChild(OSNAME_ADDRESS_SPACES)) {
155  }
156 
157  if (state->hasChild(OSNAME_MODEL)) {
158  const ObjectState* model = state->childByName(OSNAME_MODEL);
159  if (model->hasChild(OSNAME_PORTS)) {
161  }
162  if (model->hasChild(OSNAME_MODEL_PARAMS)) {
163  const ObjectState* modelParams =
165  if (modelParams->hasChild(OSNAME_MODEL_PARAM)) {
166  extractModelParams(modelParams);
167  }
168  }
169  }
170 
171  if (state->hasChild(OSNAME_FILESETS)) {
173  }
174 }

References ObjectState::childByName(), extractAddressSpaces(), extractBusInterfaces(), extractFiles(), extractModelParams(), extractSignals(), extractVLNV(), ObjectState::hasChild(), OSNAME_ADDRESS_SPACES, OSNAME_BUS_INTERFACES, OSNAME_FILESETS, OSNAME_MODEL, OSNAME_MODEL_PARAM, OSNAME_MODEL_PARAMS, and OSNAME_PORTS.

Referenced by IPXactModel().

Here is the call graph for this function:

◆ saveState()

ObjectState * IPXactModel::saveState ( ) const
virtual

Saves the objects state into an ObjectState object and maybe its child objects.

Returns
The root of the ObjectState tree created.

Implements Serializable.

Definition at line 178 of file IPXactModel.cc.

178  {
179 
181 
182  // add VLNV
183  ObjectState* vendor = new ObjectState(OSNAME_VENDOR);
184  vendor->setValue(vlnv_.vendor);
185  root->addChild(vendor);
186  ObjectState* library = new ObjectState(OSNAME_LIBRARY);
187  library->setValue(vlnv_.library);
188  root->addChild(library);
189  ObjectState* compName = new ObjectState(OSNAME_NAME);
190  compName->setValue(vlnv_.name);
191  root->addChild(compName);
192  ObjectState* compVersion = new ObjectState(OSNAME_VERSION);
193  compVersion->setValue(vlnv_.version);
194  root->addChild(compVersion);
195 
196  // add bus interfaces
197  ObjectState* busInterfaces = new ObjectState(OSNAME_BUS_INTERFACES);
198  root->addChild(busInterfaces);
199  for (unsigned int i = 0; i < busInterfaces_.size(); i++) {
200  ObjectState* busInterface = new ObjectState(OSNAME_BUS_INTERFACE);
201  addBusInterfaceObject(busInterfaces_.at(i), busInterface);
202  busInterfaces->addChild(busInterface);
203  }
204 
205  // add address spaces
206  ObjectState* addressSpaces = new ObjectState(OSNAME_ADDRESS_SPACES);
207  root->addChild(addressSpaces);
208  for (unsigned int i = 0; i < addressSpaces_.size(); i++) {
209  ObjectState* addressSpace = new ObjectState(OSNAME_ADDRESS_SPACE);
210  addAddressSpaceObject(addressSpaces_.at(i), addressSpace);
211  addressSpaces->addChild(addressSpace);
212  }
213 
214  // create model and add signals
215  ObjectState* model = new ObjectState(OSNAME_MODEL);
216  root->addChild(model);
217  ObjectState* signals = new ObjectState(OSNAME_PORTS);
218  model->addChild(signals);
219  for (unsigned int i = 0; i < signals_.size(); i++) {
220  ObjectState* signal = new ObjectState(OSNAME_PORT);
221  addSignalObject(signals_.at(i), signal);
222  signals->addChild(signal);
223  }
224 
225  // add model parameters if any
226  if (parameters_.size() > 0) {
227  addModelParamsObject(model);
228  }
229 
230  // add hdl files
231  ObjectState* fileSets = new ObjectState(OSNAME_FILESETS);
232  root->addChild(fileSets);
233  ObjectState* fileSet = new ObjectState(OSNAME_FILESET);
234  ObjectState* fileSetName = new ObjectState(OSNAME_FILE_NAME);
235  fileSetName->setValue(HDL_SET_ID);
236  fileSet->addChild(fileSetName);
237  fileSets->addChild(fileSet);
238  for (unsigned int i = 0; i < hdlFiles_.size(); i++) {
239  ObjectState* file = new ObjectState(OSNAME_FILE);
240  addFileObject(hdlFiles_.at(i), VHDL_FILE, file);
241  fileSet->addChild(file);
242  }
243  // add other files (memory init files etc)
244  for (unsigned int i = 0; i < otherFiles_.size(); i++) {
245  ObjectState* file = new ObjectState(OSNAME_FILE);
246  addFileObject(otherFiles_.at(i), OTHER_FILE, file);
247  fileSet->addChild(file);
248  }
249  return root;
250 }

References addAddressSpaceObject(), addBusInterfaceObject(), ObjectState::addChild(), addFileObject(), addModelParamsObject(), addressSpaces_, addSignalObject(), busInterfaces_, HDL_SET_ID, hdlFiles_, IPXact::Vlnv::library, IPXact::Vlnv::name, OSNAME_ADDRESS_SPACE, OSNAME_ADDRESS_SPACES, OSNAME_BUS_INTERFACE, OSNAME_BUS_INTERFACES, OSNAME_FILE, OSNAME_FILE_NAME, OSNAME_FILESET, OSNAME_FILESETS, OSNAME_IPXACT_MODEL, OSNAME_LIBRARY, OSNAME_MODEL, OSNAME_NAME, OSNAME_PORT, OSNAME_PORTS, OSNAME_VENDOR, OSNAME_VERSION, OTHER_FILE, otherFiles_, parameters_, ObjectState::setValue(), signals_, IPXact::Vlnv::vendor, IPXact::Vlnv::version, VHDL_FILE, and vlnv_.

Referenced by IPXactSerializer::writeIPXactModel().

Here is the call graph for this function:

◆ setFile()

void IPXactModel::setFile ( const TCEString file)

Definition at line 274 of file IPXactModel.cc.

274  {
275 
276  otherFiles_.push_back(file);
277 }

References otherFiles_.

Referenced by IPXactFileGenerator::writeProjectFiles().

◆ setHdlFile()

void IPXactModel::setHdlFile ( const TCEString file)

Definition at line 268 of file IPXactModel.cc.

268  {
269 
270  hdlFiles_.push_back(file);
271 }

References hdlFiles_.

Referenced by setHdlFiles().

◆ setHdlFiles()

void IPXactModel::setHdlFiles ( const std::vector< TCEString > &  files)

Definition at line 281 of file IPXactModel.cc.

281  {
282 
283  for (unsigned int i = 0; i < files.size(); i++) {
284  setHdlFile(files.at(i));
285  }
286 }

References setHdlFile().

Referenced by IPXactFileGenerator::writeProjectFiles().

Here is the call graph for this function:

◆ setVLNV()

void IPXactModel::setVLNV ( TCEString  vendor,
TCEString  library,
TCEString  name,
TCEString  version 
)

Definition at line 254 of file IPXactModel.cc.

258  {
259 
260  vlnv_.vendor = vendor;
261  vlnv_.library = library;
262  vlnv_.name = name;
263  vlnv_.version = version;
264 }

References IPXact::Vlnv::library, IPXact::Vlnv::name, IPXact::Vlnv::vendor, IPXact::Vlnv::version, and vlnv_.

Referenced by extractVLNV(), and IPXactFileGenerator::writeProjectFiles().

Member Data Documentation

◆ addressSpaces_

std::vector<IPXactAddressSpace*> IPXactModel::addressSpaces_
private

Definition at line 205 of file IPXactModel.hh.

Referenced by addAddressSpace(), extractAddressSpace(), saveState(), and ~IPXactModel().

◆ busInterfaces_

std::vector<IPXactInterface*> IPXactModel::busInterfaces_
private

Definition at line 203 of file IPXactModel.hh.

Referenced by addBusInterface(), extractBusInterface(), saveState(), and ~IPXactModel().

◆ DEV_FAMILY_GENERIC

const TCEString IPXactModel::DEV_FAMILY_GENERIC = "dev_family_g"
staticprivate

Definition at line 217 of file IPXactModel.hh.

◆ HDL_SET_ID

const TCEString IPXactModel::HDL_SET_ID = "hdlSources"
staticprivate

Definition at line 210 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ hdlFiles_

std::vector<TCEString> IPXactModel::hdlFiles_
private

Definition at line 207 of file IPXactModel.hh.

Referenced by extractFiles(), saveState(), and setHdlFile().

◆ INTEGER_PARAM

const TCEString IPXactModel::INTEGER_PARAM = "integer"
staticprivate

Definition at line 215 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ LONG_PARAM

const TCEString IPXactModel::LONG_PARAM = "long"
staticprivate

Definition at line 216 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ OSNAME_ADDRESS_SPACE

const std::string IPXactModel::OSNAME_ADDRESS_SPACE = "spirit:addressSpace"
static

Definition at line 126 of file IPXactModel.hh.

Referenced by extractAddressSpace(), extractAddressSpaces(), and saveState().

◆ OSNAME_ADDRESS_SPACES

const std::string IPXactModel::OSNAME_ADDRESS_SPACES = "spirit:addressSpaces"
static

Definition at line 125 of file IPXactModel.hh.

Referenced by extractAddressSpaces(), loadState(), and saveState().

◆ OSNAME_AS_MAU

const std::string IPXactModel::OSNAME_AS_MAU = "spirit:addressUnitBits"
static

Definition at line 129 of file IPXactModel.hh.

Referenced by addAddressSpaceObject(), and extractAddressSpace().

◆ OSNAME_AS_RANGE

const std::string IPXactModel::OSNAME_AS_RANGE = "spirit:range"
static

Definition at line 127 of file IPXactModel.hh.

Referenced by addAddressSpaceObject(), and extractAddressSpace().

◆ OSNAME_AS_WIDTH

const std::string IPXactModel::OSNAME_AS_WIDTH = "spirit:width"
static

Definition at line 128 of file IPXactModel.hh.

Referenced by addAddressSpaceObject(), and extractAddressSpace().

◆ OSNAME_ATTR_DATA_TYPE

const TCEString IPXactModel::OSNAME_ATTR_DATA_TYPE = "spirit:dataType"
static

Definition at line 134 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ OSNAME_ATTR_FORMAT

const TCEString IPXactModel::OSNAME_ATTR_FORMAT = "spirit:format"
static

Definition at line 135 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ OSNAME_ATTR_ID

const TCEString IPXactModel::OSNAME_ATTR_ID = "spirit:id"
static

Definition at line 136 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ OSNAME_ATTR_RESOLVE

const TCEString IPXactModel::OSNAME_ATTR_RESOLVE = "spirit:resolve"
static

Definition at line 137 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ OSNAME_BUS_ABS_TYPE

const TCEString IPXactModel::OSNAME_BUS_ABS_TYPE = "spirit:abstractionType"
static

Definition at line 99 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractBusInterface(), and extractVlnvFromAttr().

◆ OSNAME_BUS_INTERFACE

const TCEString IPXactModel::OSNAME_BUS_INTERFACE = "spirit:busInterface"
static

◆ OSNAME_BUS_INTERFACES

const TCEString IPXactModel::OSNAME_BUS_INTERFACES = "spirit:busInterfaces"
static

Definition at line 96 of file IPXactModel.hh.

Referenced by extractBusInterfaces(), loadState(), and saveState().

◆ OSNAME_BUS_MASTER

const TCEString IPXactModel::OSNAME_BUS_MASTER = "spirit:master"
static

Definition at line 100 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractBusMode().

◆ OSNAME_BUS_MIRRORED_MASTER

const TCEString IPXactModel::OSNAME_BUS_MIRRORED_MASTER
static
Initial value:
=
"spirit:mirroredMaster"

Definition at line 101 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractBusMode().

◆ OSNAME_BUS_MIRRORED_SLAVE

const TCEString IPXactModel::OSNAME_BUS_MIRRORED_SLAVE
static
Initial value:
=
"spirit:mirroredSlave"

Definition at line 103 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractBusMode().

◆ OSNAME_BUS_MIRRORED_SYSTEM

const TCEString IPXactModel::OSNAME_BUS_MIRRORED_SYSTEM
static
Initial value:
=
"spirit:mirroredSystem"

Definition at line 105 of file IPXactModel.hh.

Referenced by extractBusMode().

◆ OSNAME_BUS_MONITOR

const TCEString IPXactModel::OSNAME_BUS_MONITOR = "spirit:monitor"
static

Definition at line 106 of file IPXactModel.hh.

Referenced by extractBusMode().

◆ OSNAME_BUS_PORT_MAP

const TCEString IPXactModel::OSNAME_BUS_PORT_MAP = "spirit:portMap"
static

Definition at line 108 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractPortMap(), and extractPortMappings().

◆ OSNAME_BUS_PORT_MAP_BUS

const TCEString IPXactModel::OSNAME_BUS_PORT_MAP_BUS
static
Initial value:
=
"spirit:logicalPort"

Definition at line 111 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractPortMap().

◆ OSNAME_BUS_PORT_MAP_COMP

const TCEString IPXactModel::OSNAME_BUS_PORT_MAP_COMP
static
Initial value:
=
"spirit:physicalPort"

Definition at line 110 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractPortMap().

◆ OSNAME_BUS_PORT_MAP_NAME

const TCEString IPXactModel::OSNAME_BUS_PORT_MAP_NAME = "spirit:name"
static

Definition at line 109 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractPortMap().

◆ OSNAME_BUS_PORT_MAPS

const TCEString IPXactModel::OSNAME_BUS_PORT_MAPS = "spirit:portMaps"
static

Definition at line 107 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractBusInterface(), and extractPortMappings().

◆ OSNAME_BUS_SLAVE

const TCEString IPXactModel::OSNAME_BUS_SLAVE = "spirit:slave"
static

Definition at line 102 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractBusMode().

◆ OSNAME_BUS_SYSTEM

const TCEString IPXactModel::OSNAME_BUS_SYSTEM = "spirit:system"
static

Definition at line 104 of file IPXactModel.hh.

Referenced by extractBusMode().

◆ OSNAME_BUS_TYPE

const TCEString IPXactModel::OSNAME_BUS_TYPE = "spirit:busType"
static

Definition at line 98 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractBusInterface(), and extractVlnvFromAttr().

◆ OSNAME_DISPLAY_NAME

const TCEString IPXactModel::OSNAME_DISPLAY_NAME = "spirit:displayName"
static

Definition at line 132 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ OSNAME_FILE

const TCEString IPXactModel::OSNAME_FILE = "spirit:file"
static

Definition at line 122 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ OSNAME_FILE_NAME

const TCEString IPXactModel::OSNAME_FILE_NAME = "spirit:name"
static

Definition at line 123 of file IPXactModel.hh.

Referenced by addFileObject(), extractFiles(), and saveState().

◆ OSNAME_FILE_TYPE

const TCEString IPXactModel::OSNAME_FILE_TYPE = "spirit:fileType"
static

Definition at line 124 of file IPXactModel.hh.

Referenced by addFileObject(), and extractFiles().

◆ OSNAME_FILESET

const TCEString IPXactModel::OSNAME_FILESET = "spirit:fileSet"
static

Definition at line 121 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ OSNAME_FILESETS

const TCEString IPXactModel::OSNAME_FILESETS = "spirit:fileSets"
static

Definition at line 120 of file IPXactModel.hh.

Referenced by extractFiles(), loadState(), and saveState().

◆ OSNAME_IPXACT_MODEL

const TCEString IPXactModel::OSNAME_IPXACT_MODEL = "spirit:component"
static

Definition at line 91 of file IPXactModel.hh.

Referenced by extractVLNV(), and saveState().

◆ OSNAME_LIBRARY

const TCEString IPXactModel::OSNAME_LIBRARY = "spirit:library"
static

Definition at line 93 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractVLNV(), extractVlnvFromAttr(), and saveState().

◆ OSNAME_MODEL

const TCEString IPXactModel::OSNAME_MODEL = "spirit:model"
static

Definition at line 112 of file IPXactModel.hh.

Referenced by loadState(), and saveState().

◆ OSNAME_MODEL_PARAM

const TCEString IPXactModel::OSNAME_MODEL_PARAM = "spirit:modelParameter"
static

◆ OSNAME_MODEL_PARAMS

const TCEString IPXactModel::OSNAME_MODEL_PARAMS = "spirit:modelParameters"
static

Definition at line 130 of file IPXactModel.hh.

Referenced by addModelParamsObject(), extractModelParams(), and loadState().

◆ OSNAME_NAME

const TCEString IPXactModel::OSNAME_NAME = "spirit:name"
static

◆ OSNAME_PORT

const TCEString IPXactModel::OSNAME_PORT = "spirit:port"
static

Definition at line 116 of file IPXactModel.hh.

Referenced by extractSignals(), and saveState().

◆ OSNAME_PORT_DIRECTION

const TCEString IPXactModel::OSNAME_PORT_DIRECTION = "spirit:direction"
static

Definition at line 117 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OSNAME_PORT_LEFT

const TCEString IPXactModel::OSNAME_PORT_LEFT = "spirit:left"
static

Definition at line 118 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OSNAME_PORT_RIGHT

const TCEString IPXactModel::OSNAME_PORT_RIGHT = "spirit:right"
static

Definition at line 119 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OSNAME_PORTS

const TCEString IPXactModel::OSNAME_PORTS = "spirit:ports"
static

Definition at line 113 of file IPXactModel.hh.

Referenced by extractSignals(), loadState(), and saveState().

◆ OSNAME_VALUE

const TCEString IPXactModel::OSNAME_VALUE = "spirit:value"
static

Definition at line 133 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ OSNAME_VECTOR

const TCEString IPXactModel::OSNAME_VECTOR = "spirit:vector"
static

Definition at line 115 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OSNAME_VENDOR

const TCEString IPXactModel::OSNAME_VENDOR = "spirit:vendor"
static

Definition at line 92 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractVLNV(), extractVlnvFromAttr(), and saveState().

◆ OSNAME_VERSION

const TCEString IPXactModel::OSNAME_VERSION = "spirit:version"
static

Definition at line 95 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractVLNV(), extractVlnvFromAttr(), and saveState().

◆ OSNAME_WIRE

const TCEString IPXactModel::OSNAME_WIRE = "spirit:wire"
static

Definition at line 114 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OTHER_FILE

const TCEString IPXactModel::OTHER_FILE = "unknown"
staticprivate

Definition at line 212 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ otherFiles_

std::vector<TCEString> IPXactModel::otherFiles_
private

Definition at line 208 of file IPXactModel.hh.

Referenced by extractFiles(), saveState(), and setFile().

◆ parameters_

std::vector<ProGe::Parameter> IPXactModel::parameters_
private

Definition at line 201 of file IPXactModel.hh.

Referenced by addModelParamsObject(), addParameter(), extractModelParam(), and saveState().

◆ RESOLVE_USER

const TCEString IPXactModel::RESOLVE_USER = "user"
staticprivate

Definition at line 213 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ signals_

std::vector<HDLPort*> IPXactModel::signals_
private

Definition at line 199 of file IPXactModel.hh.

Referenced by addSignal(), extractSignals(), saveState(), and ~IPXactModel().

◆ STRING_PARAM

const TCEString IPXactModel::STRING_PARAM = "string"
staticprivate

Definition at line 214 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ VHDL_FILE

const TCEString IPXactModel::VHDL_FILE = "vhdlSource"
staticprivate

Definition at line 211 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ vlnv_

IPXact::Vlnv IPXactModel::vlnv_
private

Definition at line 197 of file IPXactModel.hh.

Referenced by saveState(), and setVLNV().


The documentation for this class was generated from the following files:
IPXactModel::addressSpaces_
std::vector< IPXactAddressSpace * > addressSpaces_
Definition: IPXactModel.hh:205
IPXactModel::OSNAME_VECTOR
static const TCEString OSNAME_VECTOR
Definition: IPXactModel.hh:115
IPXactModel::SYSTEM
@ SYSTEM
Definition: IPXactModel.hh:56
IPXactInterface::instanceName
virtual TCEString instanceName() const
Definition: IPXactInterface.cc:49
ObjectState::hasAttribute
bool hasAttribute(const std::string &name) const
Definition: ObjectState.cc:205
IPXactModel::SLAVE
@ SLAVE
Definition: IPXactModel.hh:54
IPXactInterface::setInstanceName
void setInstanceName(const TCEString &name)
Definition: IPXactInterface.cc:89
IPXactClkInterface
Definition: IPXactClkInterface.hh:37
IPXactModel::OTHER_FILE
static const TCEString OTHER_FILE
Definition: IPXactModel.hh:212
TCEString::lower
TCEString lower() const
Definition: TCEString.cc:78
mode
mode
Definition: tceopgen.cc:45
ObjectState::stringAttribute
std::string stringAttribute(const std::string &name) const
Definition: ObjectState.cc:249
IPXactModel::extractAddressSpace
void extractAddressSpace(const ObjectState *as)
Definition: IPXactModel.cc:649
ProGe::Parameter::setValue
void setValue(const TCEString &value)
Definition: Parameter.cc:128
IPXactModel::OSNAME_BUS_INTERFACES
static const TCEString OSNAME_BUS_INTERFACES
Definition: IPXactModel.hh:96
IPXactAddressSpace::mauWidth
int mauWidth() const
Definition: IPXactAddressSpace.cc:69
IPXact::Vlnv
Definition: Vlnv.hh:41
IPXactModel::extractVlnvFromAttr
IPXact::Vlnv extractVlnvFromAttr(const ObjectState *busType) const
Definition: IPXactModel.cc:541
HDLPort
Definition: PlatformIntegrator/HDLPort.hh:48
IPXactModel::OSNAME_BUS_MASTER
static const TCEString OSNAME_BUS_MASTER
Definition: IPXactModel.hh:100
ProGe::BIT_VECTOR
@ BIT_VECTOR
Several bits.
Definition: ProGeTypes.hh:48
ObjectStateLoadingException
Definition: Exception.hh:551
IPXactInterface::addSignalMapping
virtual void addSignalMapping(const TCEString &actualSignal, const TCEString &busSignal)
Definition: IPXactInterface.cc:79
ObjectState::intValue
int intValue() const
IPXactModel::OSNAME_ADDRESS_SPACES
static const std::string OSNAME_ADDRESS_SPACES
Definition: IPXactModel.hh:125
IPXactAddressSpace::name
TCEString name() const
Definition: IPXactAddressSpace.cc:51
IPXactInterface::busMode
virtual IPXactModel::BusMode busMode() const
Definition: IPXactInterface.cc:66
IPXactModel::OSNAME_PORT_LEFT
static const TCEString OSNAME_PORT_LEFT
Definition: IPXactModel.hh:118
PlatInt::SignalMappingList
std::vector< SignalMapping * > SignalMappingList
Definition: PlatformIntegratorTypes.hh:44
IPXactModel::addSignalObject
void addSignalObject(const HDLPort *port, ObjectState *parent) const
Definition: IPXactModel.cc:406
IPXactModel::OSNAME_BUS_SLAVE
static const TCEString OSNAME_BUS_SLAVE
Definition: IPXactModel.hh:102
IPXactModel::OSNAME_LIBRARY
static const TCEString OSNAME_LIBRARY
Definition: IPXactModel.hh:93
IPXactModel::addFileObject
void addFileObject(const TCEString &name, const TCEString &type, ObjectState *parent) const
Definition: IPXactModel.cc:503
IPXactModel::extractBusMode
BusMode extractBusMode(const ObjectState *busInterface) const
Definition: IPXactModel.cc:686
IPXactModel::extractVLNV
void extractVLNV(const ObjectState *root)
Definition: IPXactModel.cc:518
IPXactModel::MIRRORED_MASTER
@ MIRRORED_MASTER
Definition: IPXactModel.hh:53
ObjectState
Definition: ObjectState.hh:59
IPXactModel::OSNAME_BUS_PORT_MAP_COMP
static const TCEString OSNAME_BUS_PORT_MAP_COMP
Definition: IPXactModel.hh:110
IPXactModel::OSNAME_FILESET
static const TCEString OSNAME_FILESET
Definition: IPXactModel.hh:121
ProGe::BIDIR
@ BIDIR
Bidirectional port.
Definition: ProGeTypes.hh:55
HDLPort::type
ProGe::DataType type() const
Definition: HDLPort.cc:117
IPXactModel::OSNAME_BUS_INTERFACE
static const TCEString OSNAME_BUS_INTERFACE
Definition: IPXactModel.hh:97
IPXactModel::OSNAME_BUS_MIRRORED_SYSTEM
static const TCEString OSNAME_BUS_MIRRORED_SYSTEM
Definition: IPXactModel.hh:105
IPXactModel::OSNAME_BUS_MONITOR
static const TCEString OSNAME_BUS_MONITOR
Definition: IPXactModel.hh:106
IPXactInterface::busAbstractionType
virtual IPXact::Vlnv busAbstractionType() const
Definition: IPXactInterface.cc:60
IPXactModel::extractPortMap
void extractPortMap(const ObjectState *portMap, IPXactInterface &interface) const
Definition: IPXactModel.cc:729
IPXactModel::OSNAME_FILE
static const TCEString OSNAME_FILE
Definition: IPXactModel.hh:122
IPXactModel::addBusInterfaceObject
void addBusInterfaceObject(const IPXactInterface *bus, ObjectState *parent) const
Definition: IPXactModel.cc:314
IPXact::Vlnv::version
TCEString version
Entity version.
Definition: Vlnv.hh:62
Conversion::toString
static std::string toString(const T &source)
IPXactModel::signals_
std::vector< HDLPort * > signals_
Definition: IPXactModel.hh:199
IPXactInterface::busType
virtual IPXact::Vlnv busType() const
Definition: IPXactInterface.cc:54
IPXact::Vlnv::vendor
TCEString vendor
Vendor name.
Definition: Vlnv.hh:56
IPXactModel::HDL_SET_ID
static const TCEString HDL_SET_ID
Definition: IPXactModel.hh:210
IPXactModel::VHDL_FILE
static const TCEString VHDL_FILE
Definition: IPXactModel.hh:211
IPXactModel::RESOLVE_USER
static const TCEString RESOLVE_USER
Definition: IPXactModel.hh:213
ObjectState::childByName
ObjectState * childByName(const std::string &name) const
Definition: ObjectState.cc:443
IPXactHibiInterface
Definition: IPXactHibiInterface.hh:38
IPXactModel::INVALID
@ INVALID
Definition: IPXactModel.hh:51
IPXactModel::OSNAME_BUS_PORT_MAP_NAME
static const TCEString OSNAME_BUS_PORT_MAP_NAME
Definition: IPXactModel.hh:109
assert
#define assert(condition)
Definition: Application.hh:86
IPXactModel::OSNAME_BUS_PORT_MAPS
static const TCEString OSNAME_BUS_PORT_MAPS
Definition: IPXactModel.hh:107
IPXactModel::OSNAME_DISPLAY_NAME
static const TCEString OSNAME_DISPLAY_NAME
Definition: IPXactModel.hh:132
IPXact::Vlnv::library
TCEString library
Library name.
Definition: Vlnv.hh:58
IPXactModel::OSNAME_BUS_MIRRORED_SLAVE
static const TCEString OSNAME_BUS_MIRRORED_SLAVE
Definition: IPXactModel.hh:103
IPXactModel::otherFiles_
std::vector< TCEString > otherFiles_
Definition: IPXactModel.hh:208
IPXactModel::OSNAME_NAME
static const TCEString OSNAME_NAME
Definition: IPXactModel.hh:94
IPXactInterface
Definition: IPXactInterface.hh:41
InvalidData
Definition: Exception.hh:149
IPXactModel::BusMode
BusMode
Definition: IPXactModel.hh:50
UnexpectedValue
Definition: Exception.hh:455
IPXactModel::parameters_
std::vector< ProGe::Parameter > parameters_
Definition: IPXactModel.hh:201
IPXactModel::setHdlFile
void setHdlFile(const TCEString &file)
Definition: IPXactModel.cc:268
IPXactModel::interfaceByType
IPXactInterface * interfaceByType(const IPXact::Vlnv &type, const IPXact::Vlnv &absType, const TCEString instanceName, BusMode mode) const
Definition: IPXactModel.cc:898
ProGe::Parameter::setName
void setName(const TCEString &name)
Definition: Parameter.cc:118
IPXactModel::OSNAME_ADDRESS_SPACE
static const std::string OSNAME_ADDRESS_SPACE
Definition: IPXactModel.hh:126
ProGe::Parameter
Definition: Parameter.hh:62
IPXactModel::OSNAME_MODEL_PARAMS
static const TCEString OSNAME_MODEL_PARAMS
Definition: IPXactModel.hh:130
IPXactModel::OSNAME_BUS_SYSTEM
static const TCEString OSNAME_BUS_SYSTEM
Definition: IPXactModel.hh:104
IPXactModel::OSNAME_PORT_RIGHT
static const TCEString OSNAME_PORT_RIGHT
Definition: IPXactModel.hh:119
IPXactModel::OSNAME_AS_MAU
static const std::string OSNAME_AS_MAU
Definition: IPXactModel.hh:129
IPXactModel::OSNAME_FILESETS
static const TCEString OSNAME_FILESETS
Definition: IPXactModel.hh:120
IPXactModel::OSNAME_FILE_NAME
static const TCEString OSNAME_FILE_NAME
Definition: IPXactModel.hh:123
IPXactModel::OSNAME_VENDOR
static const TCEString OSNAME_VENDOR
Definition: IPXactModel.hh:92
ObjectState::child
ObjectState * child(int index) const
Definition: ObjectState.cc:471
ObjectState::addChild
void addChild(ObjectState *child)
Definition: ObjectState.cc:376
IPXactAddressSpace
Definition: IPXactAddressSpace.hh:38
IPXactModel::OSNAME_BUS_ABS_TYPE
static const TCEString OSNAME_BUS_ABS_TYPE
Definition: IPXactModel.hh:99
ObjectState::childCount
int childCount() const
HDLPort::name
TCEString name() const
Definition: HDLPort.cc:87
IPXactModel::OSNAME_PORTS
static const TCEString OSNAME_PORTS
Definition: IPXactModel.hh:113
IPXactModel::extractPortMappings
void extractPortMappings(const ObjectState *portMaps, IPXactInterface &interface) const
Definition: IPXactModel.cc:712
ProGe::BIT
@ BIT
One bit.
Definition: ProGeTypes.hh:47
ObjectState::hasChild
bool hasChild(const std::string &name) const
Definition: ObjectState.cc:358
IPXactModel::addModelParamsObject
void addModelParamsObject(ObjectState *parent) const
Definition: IPXactModel.cc:461
IPXactModel::LONG_PARAM
static const TCEString LONG_PARAM
Definition: IPXactModel.hh:216
IPXactModel::extractModelParams
void extractModelParams(const ObjectState *modelParameters)
Definition: IPXactModel.cc:930
IPXactModel::OSNAME_AS_RANGE
static const std::string OSNAME_AS_RANGE
Definition: IPXactModel.hh:127
IPXactModel::extractBusInterface
void extractBusInterface(const ObjectState *busInterface)
Definition: IPXactModel.cc:578
ObjectState::name
std::string name() const
IPXactModel::extractBusInterfaces
void extractBusInterfaces(const ObjectState *busInterfaces)
Definition: IPXactModel.cc:562
ProGe::OUT
@ OUT
Output port.
Definition: ProGeTypes.hh:54
IPXactModel::MIRRORED_SYSTEM
@ MIRRORED_SYSTEM
Definition: IPXactModel.hh:57
IPXactModel::OSNAME_WIRE
static const TCEString OSNAME_WIRE
Definition: IPXactModel.hh:114
IPXactModel::OSNAME_PORT_DIRECTION
static const TCEString OSNAME_PORT_DIRECTION
Definition: IPXactModel.hh:117
IPXactModel::OSNAME_BUS_MIRRORED_MASTER
static const TCEString OSNAME_BUS_MIRRORED_MASTER
Definition: IPXactModel.hh:101
HDLPort::direction
ProGe::Direction direction() const
Definition: HDLPort.cc:112
IPXactAddressSpace::memLocationWidth
int memLocationWidth() const
Definition: IPXactAddressSpace.cc:63
IPXactModel::busInterfaces_
std::vector< IPXactInterface * > busInterfaces_
Definition: IPXactModel.hh:203
IPXactModel::extractAddressSpaces
void extractAddressSpaces(const ObjectState *addressSpaces)
Definition: IPXactModel.cc:633
ProGe::Parameter::setType
void setType(const TCEString &type)
Definition: Parameter.cc:123
IPXactModel::extractSignals
void extractSignals(const ObjectState *signals)
Definition: IPXactModel.cc:773
ProGe::DataType
DataType
Data types of hardware ports.
Definition: ProGeTypes.hh:46
IPXactModel::OSNAME_AS_WIDTH
static const std::string OSNAME_AS_WIDTH
Definition: IPXactModel.hh:128
IPXactModel::OSNAME_ATTR_FORMAT
static const TCEString OSNAME_ATTR_FORMAT
Definition: IPXactModel.hh:135
TCEString
Definition: TCEString.hh:53
IPXactInterface::interfaceMapping
virtual const PlatInt::SignalMappingList & interfaceMapping() const
Definition: IPXactInterface.cc:73
IPXactModel::OSNAME_BUS_TYPE
static const TCEString OSNAME_BUS_TYPE
Definition: IPXactModel.hh:98
IPXactModel::vlnv_
IPXact::Vlnv vlnv_
Definition: IPXactModel.hh:197
IPXactModel::MIRRORED_SLAVE
@ MIRRORED_SLAVE
Definition: IPXactModel.hh:55
ObjectState::stringValue
std::string stringValue() const
IPXactModel::extractModelParam
void extractModelParam(const ObjectState *modelParameter)
Definition: IPXactModel.cc:942
IPXactModel::OSNAME_MODEL
static const TCEString OSNAME_MODEL
Definition: IPXactModel.hh:112
IPXactModel::INTEGER_PARAM
static const TCEString INTEGER_PARAM
Definition: IPXactModel.hh:215
IPXactModel::OSNAME_BUS_PORT_MAP
static const TCEString OSNAME_BUS_PORT_MAP
Definition: IPXactModel.hh:108
IPXactModel::OSNAME_FILE_TYPE
static const TCEString OSNAME_FILE_TYPE
Definition: IPXactModel.hh:124
IPXactModel::MONITOR
@ MONITOR
Definition: IPXactModel.hh:58
IPXactModel::OSNAME_BUS_PORT_MAP_BUS
static const TCEString OSNAME_BUS_PORT_MAP_BUS
Definition: IPXactModel.hh:111
IPXactModel::extractFiles
void extractFiles(const ObjectState *fileSets)
Definition: IPXactModel.cc:851
HDLPort::hasRealWidth
bool hasRealWidth() const
Definition: HDLPort.cc:102
IPXactModel::OSNAME_ATTR_DATA_TYPE
static const TCEString OSNAME_ATTR_DATA_TYPE
Definition: IPXactModel.hh:134
IPXactModel::loadState
virtual void loadState(const ObjectState *state)
Definition: IPXactModel.cc:145
HDLPort::realWidth
int realWidth() const
Definition: HDLPort.cc:107
IPXactResetInterface
Definition: IPXactResetInterface.hh:37
IPXactModel::hdlFiles_
std::vector< TCEString > hdlFiles_
Definition: IPXactModel.hh:207
IPXactModel::addAddressSpaceObject
void addAddressSpaceObject(const IPXactAddressSpace *as, ObjectState *parent) const
Definition: IPXactModel.cc:381
IPXact::Vlnv::name
TCEString name
Entity name.
Definition: Vlnv.hh:60
ProGe::Direction
Direction
Direction of the port.
Definition: ProGeTypes.hh:52
IPXactModel::STRING_PARAM
static const TCEString STRING_PARAM
Definition: IPXactModel.hh:214
ObjectState::setValue
void setValue(const std::string &value)
IPXactModel::MASTER
@ MASTER
Definition: IPXactModel.hh:52
IPXactModel::OSNAME_ATTR_ID
static const TCEString OSNAME_ATTR_ID
Definition: IPXactModel.hh:136
IPXactModel::OSNAME_VALUE
static const TCEString OSNAME_VALUE
Definition: IPXactModel.hh:133
ProGe::IN
@ IN
Input port.
Definition: ProGeTypes.hh:53
IPXactAddressSpace::memRange
int memRange() const
Definition: IPXactAddressSpace.cc:57
IPXactModel::OSNAME_PORT
static const TCEString OSNAME_PORT
Definition: IPXactModel.hh:116
ObjectState::setAttribute
void setAttribute(const std::string &name, const std::string &value)
Definition: ObjectState.cc:100
IPXactModel::OSNAME_ATTR_RESOLVE
static const TCEString OSNAME_ATTR_RESOLVE
Definition: IPXactModel.hh:137
IPXactModel::OSNAME_MODEL_PARAM
static const TCEString OSNAME_MODEL_PARAM
Definition: IPXactModel.hh:131
IPXactModel::OSNAME_IPXACT_MODEL
static const TCEString OSNAME_IPXACT_MODEL
Definition: IPXactModel.hh:91
IPXactModel::setVLNV
void setVLNV(TCEString vendor, TCEString library, TCEString name, TCEString version)
Definition: IPXactModel.cc:254
IPXactModel::OSNAME_VERSION
static const TCEString OSNAME_VERSION
Definition: IPXactModel.hh:95