00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 #include "XdlUnpack.hpp"
00017 #include "RcFactory.hpp"
00018 #include <iostream>
00019
00020 namespace torc {
00021 namespace physical {
00022
00023 DesignSharedPtr XdlUnpack::operator() (const DesignSharedPtr& inDesignPtr) {
00024
00025
00026 DesignSharedPtr designPtr(inDesignPtr);
00027 const Design& design = *designPtr;
00028 DesignSharedPtr newDesign = unpack(design);
00029
00030 return newDesign;
00031
00032
00033 }
00034
00035 void XdlUnpack::unpack(const Circuit& circuit, CircuitSharedPtr newCircuit ) {
00036
00037
00038 Circuit::NetSharedPtrConstIterator pn = circuit.netsBegin();
00039 Circuit::NetSharedPtrConstIterator en = circuit.netsEnd();
00040 while(pn < en){
00041 NetSharedPtr netPtr = unpack(**pn++);
00042 newCircuit->addNet(netPtr);
00043 }
00044
00045
00046 Circuit::InstanceSharedPtrConstIterator pi = circuit.instancesBegin();
00047 Circuit::InstanceSharedPtrConstIterator ei = circuit.instancesEnd();
00048 while(pi < ei) {
00049 unpack(**pi++, newCircuit);
00050 }
00051 }
00052
00053 DesignSharedPtr XdlUnpack::unpack(const Design& design) {
00054 string designName;
00055 designName = design.getName();
00056 designName += "_unpacked";
00057
00058 DesignSharedPtr newDesign = Factory::newDesignPtr (designName, design.getDevice(), "", "", design.getXdlVersion());
00059
00060 string deviceName = design.getDevice();
00061 deviceName += ".xdlrc";
00062 readPrimitives(deviceName.c_str());
00063 removeExtraElements(*primitives->findPrimitive("SLICEL"));
00064 removeExtraElements(*primitives->findPrimitive("SLICEM"));
00065
00066 if(!design.configIsEmpty()) {
00067 newDesign->addConfigs(static_cast<const ConfigMap&>(design));
00068 }
00069
00070
00071 Design::ModuleSharedPtrConstIterator p = design.modulesBegin();
00072 Design::ModuleSharedPtrConstIterator e = design.modulesEnd();
00073 while(p < e){
00074 ModuleSharedPtr modulePtr= unpack(**p++);
00075 newDesign->addModule(modulePtr);
00076 }
00077
00078 unpack(static_cast<Circuit>(design), static_cast<CircuitSharedPtr>(newDesign));
00079
00080 return newDesign;
00081
00082 }
00083
00084 ModuleSharedPtr XdlUnpack::unpack(const Module& module) {
00085
00086 ModuleSharedPtr newModule = Factory::newModulePtr (module.getName(), module.getAnchor());
00087
00088 if(!module.configIsEmpty())
00089 {newModule->addConfigs(static_cast<const ConfigMap&>(module)); }
00090
00091
00092 Module::PortSharedPtrConstIterator p = module.portsBegin();
00093 Module::PortSharedPtrConstIterator e = module.portsEnd();
00094 while(p < e){
00095 PortSharedPtr portPtr = unpack(**p++);
00096 newModule->addPort(portPtr);
00097 }
00098
00099
00100 unpack(static_cast<Circuit>(module), static_cast<CircuitSharedPtr>(newModule));
00101
00102 return newModule;
00103 }
00104
00105 PortSharedPtr XdlUnpack::unpack(const Port& port) {
00106 InstanceSharedPtr instPtr = port.getInstancePtr().lock();
00107 PortSharedPtr newPort = Factory::newPortPtr (port.getName(), instPtr, port.getPinName());
00108 return newPort;
00109 }
00110
00111 void XdlUnpack::unpack(Instance& instance, CircuitSharedPtr newCircuit) {
00112
00113
00114 if((instance.getType()=="SLICEL")||(instance.getType()=="SLICEM")){
00115 InstanceSharedPtrVector affInstances,bffInstances,cffInstances,dffInstances, xffInstances, yffInstances;
00116 InstanceSharedPtrVector alutInstances,blutInstances,clutInstances,dlutInstances,xlutInstances,ylutInstances;
00117 ConfigMap instanceConfigs;
00118 ConfigMap affConfigs, bffConfigs, cffConfigs, dffConfigs,xffConfigs,yffConfigs;
00119 ConfigMap alutConfigs, blutConfigs, clutConfigs, dlutConfigs,xlutConfigs,ylutConfigs;
00120 PrimitiveSet::PrimitiveSharedPtrIterator it = primitives->findPrimitive(instance.getType());
00121 PrimitiveSharedPtr primitivePtr = *it;
00122 ConfigMap::const_iterator p = instance.configBegin();
00123 ConfigMap::const_iterator e = instance.configEnd();
00124 InstanceReferenceSharedPtr instanceReferencePtr = instance.getInstanceReferencePtr();
00125 InstanceReferenceSharedPtr newInstanceReferencePtr;
00126
00127 if(instanceReferencePtr.get() != 0) {
00128 const InstanceReference& instanceReference = *instanceReferencePtr;
00129 std::string instanceName = instanceReference.getInstancePtr().expired()
00130 ? "[expired instance]" : instanceReference.getInstancePtr().lock()->getName();
00131 newInstanceReferencePtr = Factory::newInstanceReferencePtr (
00132 instanceName, instanceReference.getModulePtr().lock(), instanceReference.getInstancePtr().lock());
00133 }
00134
00135
00136 while(p != e) {
00137 const std::string& setting = p->first;
00138
00139
00140 if(setting == "_NO_USER_LOGIC")
00141 return;
00142 Primitive::ElementSharedPtrIterator elemIter = primitivePtr->findElement(setting);
00143 if(elemIter == primitivePtr->elementsEnd()){
00144 ++p;
00145 continue;
00146 }
00147 string newName = instance.getName();
00148
00149 const Config& config = p->second;
00150 newName = newName + ":" + setting + ":" + config.getName() ;
00151 string typeName;
00152
00153
00154 if(isExtraMux(setting)){
00155 instanceConfigs.setConfig(setting, config);
00156 ++p;
00157 continue;
00158 }
00159
00160 if(strstr(setting.c_str(),"INV")!= NULL){
00161 if(strstr(config.getValue().c_str() , "_B") == NULL){
00162 instanceConfigs.setConfig(setting, config);
00163 ++p;
00164 continue;
00165 }
00166 typeName = "INV";
00167 instanceConfigs.setConfig(setting, config);
00168 }
00169
00170 else if((strstr(setting.c_str(),"LUT")!= NULL)|| (setting == "G")|| (setting == "F")){
00171 typeName = "LUT";
00172 instanceConfigs.setConfig(setting, config);
00173 }
00174 else if((strstr(setting.c_str(),"AND")!= NULL)){
00175 typeName = "AND";
00176 instanceConfigs.setConfig(setting, config);
00177 }
00178 else if((strstr(setting.c_str(),"XOR")!= NULL)){
00179 typeName = "XOR";
00180 instanceConfigs.setConfig(setting, config);
00181 }
00182 else if((setting == "AFF") || (setting == "BFF") || (setting == "CFF") || (setting == "DFF") || (setting == "FFX") || (setting == "FFY")){
00183 typeName = "DFF";
00184 instanceConfigs.setConfig(setting, config);
00185 }
00186 else if( ( setting == "AFFSR") ||
00187 (setting == "AFFINIT") ){
00188 affConfigs.setConfig(setting,config);
00189 ++p;
00190 continue;
00191 }
00192 else if( ( setting == "BFFSR") ||
00193 (setting == "BFFINIT") ){
00194 bffConfigs.setConfig(setting,config);
00195 ++p;
00196 continue;
00197 }
00198 else if( ( setting == "CFFSR") ||
00199 (setting == "CFFINIT") ){
00200 cffConfigs.setConfig(setting,config);
00201 ++p;
00202 continue;
00203 }
00204 else if( ( setting == "DFFSR") ||
00205 (setting == "DFFINIT") ){
00206 dffConfigs.setConfig(setting,config);
00207 ++p;
00208 continue;
00209 }
00210 else if( ( setting == "FFY_INIT_ATTR") ||
00211 (setting == "FFY_SR_ATTR") ){
00212 yffConfigs.setConfig(setting,config);
00213 ++p;
00214 continue;
00215 }
00216 else if( ( setting == "FFX_INIT_ATTR") ||
00217 (setting == "FFX_SR_ATTR") ){
00218 xffConfigs.setConfig(setting,config);
00219 ++p;
00220 continue;
00221 }
00222 else if(setting == "A6RAMMODE"){
00223 alutConfigs.setConfig(setting,config);
00224 ++p;
00225 continue;
00226 }
00227 else if(setting == "B6RAMMODE"){
00228 blutConfigs.setConfig(setting,config);
00229 ++p;
00230 continue;
00231 }
00232 else if(setting == "C6RAMMODE"){
00233 clutConfigs.setConfig(setting,config);
00234 ++p;
00235 continue;
00236 }
00237 else if(setting == "D6RAMMODE"){
00238 dlutConfigs.setConfig(setting,config);
00239 ++p;
00240 continue;
00241 }
00242 else if(setting == "D6RAMMODE"){
00243 dlutConfigs.setConfig(setting,config);
00244 ++p;
00245 continue;
00246 }
00247 else if(setting == "F_ATTR"){
00248 xlutConfigs.setConfig(setting,config);
00249 ++p;
00250 continue;
00251 }
00252 else if(setting == "G_ATTR"){
00253 ylutConfigs.setConfig(setting,config);
00254 ++p;
00255 continue;
00256 }
00257 else if((strstr(setting.c_str(), "MUX")!=NULL)||(strstr(setting.c_str(), "CY0")!=NULL)||
00258 (setting=="PRECYINIT")){
00259 typeName = "MUX";
00260 instanceConfigs.setConfig(setting, config);
00261 if(isExtraMux(setting)){
00262 ++p;
00263 continue;
00264 }
00265 }
00266 else if(strstr(setting.c_str(),"SYNC_ATTR")!= NULL){
00267 affConfigs.setConfig(setting,config);
00268 bffConfigs.setConfig(setting,config);
00269 cffConfigs.setConfig(setting,config);
00270 dffConfigs.setConfig(setting,config);
00271 xffConfigs.setConfig(setting,config);
00272 yffConfigs.setConfig(setting,config);
00273
00274 ++p;
00275 continue;
00276 }
00277 else if((setting == "_INST_PROP") || (setting == "_ROUTETHROUGH")){
00278 ++p;
00279 continue;
00280 }
00281 else{
00282 typeName = setting;
00283 instanceConfigs.setConfig(setting, config);
00284 }
00285
00286
00287 InstanceSharedPtr newInst = Factory::newInstancePtr(newName, typeName, "",
00288 "", instance.getBonding(), newInstanceReferencePtr);
00289 if(typeName == "DFF") {
00290 if(setting == "AFF")
00291 affInstances.push_back(newInst);
00292 else if(setting == "BFF")
00293 bffInstances.push_back(newInst);
00294 else if(setting == "CFF")
00295 cffInstances.push_back(newInst);
00296 else if(setting == "DFF")
00297 dffInstances.push_back(newInst);
00298 else if(setting == "FFX")
00299 xffInstances.push_back(newInst);
00300 else if(setting == "FFY")
00301 yffInstances.push_back(newInst);
00302 } else if(typeName == "LUT") {
00303 if(setting == "A6LUT")
00304 alutInstances.push_back(newInst);
00305 else if(setting == "B6LUT")
00306 blutInstances.push_back(newInst);
00307 else if(setting == "C6LUT")
00308 clutInstances.push_back(newInst);
00309 else if(setting == "D6LUT")
00310 dlutInstances.push_back(newInst);
00311 else if(setting == "F")
00312 xlutInstances.push_back(newInst);
00313 else if(setting == "G")
00314 ylutInstances.push_back(newInst);
00315 } else if((typeName != "INV") && (typeName != "MUX") && (typeName != "AND") && (typeName != "XOR") && (typeName != "WSGEN")) {
00316 newInst->setConfig(p->first, config);
00317 }
00318 newCircuit->addInstance(newInst);
00319 p++;
00320 }
00321
00322
00323 for(Circuit::InstanceSharedPtrIterator it = affInstances.begin(); it != affInstances.end(); ++it)
00324 (*it)->addConfigs(affConfigs);
00325 for(Circuit::InstanceSharedPtrIterator it = bffInstances.begin(); it != bffInstances.end(); ++it)
00326 (*it)->addConfigs(bffConfigs);
00327 for(Circuit::InstanceSharedPtrIterator it = cffInstances.begin(); it != cffInstances.end(); ++it)
00328 (*it)->addConfigs(cffConfigs);
00329 for(Circuit::InstanceSharedPtrIterator it = dffInstances.begin(); it != dffInstances.end(); ++it)
00330 (*it)->addConfigs(dffConfigs);
00331 for(Circuit::InstanceSharedPtrIterator it = xffInstances.begin(); it != xffInstances.end(); ++it)
00332 (*it)->addConfigs(xffConfigs);
00333 for(Circuit::InstanceSharedPtrIterator it = yffInstances.begin(); it != yffInstances.end(); ++it)
00334 (*it)->addConfigs(yffConfigs);
00335
00336
00337 for(Circuit::InstanceSharedPtrIterator it = alutInstances.begin(); it != alutInstances.end(); ++it)
00338 (*it)->addConfigs(alutConfigs);
00339 for(Circuit::InstanceSharedPtrIterator it = blutInstances.begin(); it != blutInstances.end(); ++it)
00340 (*it)->addConfigs(blutConfigs);
00341 for(Circuit::InstanceSharedPtrIterator it = clutInstances.begin(); it != clutInstances.end(); ++it)
00342 (*it)->addConfigs(clutConfigs);
00343 for(Circuit::InstanceSharedPtrIterator it = dlutInstances.begin(); it != dlutInstances.end(); ++it)
00344 (*it)->addConfigs(dlutConfigs);
00345 for(Circuit::InstanceSharedPtrIterator it = xlutInstances.begin(); it != xlutInstances.end(); ++it)
00346 (*it)->addConfigs(xlutConfigs);
00347 for(Circuit::InstanceSharedPtrIterator it = ylutInstances.begin(); it != ylutInstances.end(); ++it)
00348 (*it)->addConfigs(ylutConfigs);
00349
00350 Circuit::NetSharedPtrConstIterator pn = newCircuit->netsBegin();
00351 Circuit::NetSharedPtrConstIterator en = newCircuit->netsEnd();
00352 while(pn < en){
00353 NetSharedPtr netPtr = *pn++;
00354
00355
00356
00357
00358 Net::InstancePinSharedPtrIterator sop = netPtr->sourcesBegin();
00359 while(sop < netPtr->sourcesEnd()){
00360
00361 if((*sop)->getInstancePtr().lock()->getName()==instance.getName()){
00362 string pinName = (*sop)->getPinName();
00363 netPtr->removeSource(*sop);
00364 PrimitivePinSharedPtr pinTmp = *primitivePtr->findPrimitivePin(pinName);
00365 ElementSharedPtr elementTmp = *primitivePtr->findElement(pinName);
00366 Element::ConnectionSharedPtrIterator cb = elementTmp->connectionsBegin();
00367 ConnectionPin pinPtr = * (*cb)->getSource();
00368 string newName = instance.getName();
00369 Config config;
00370 instanceConfigs.getConfig(pinPtr.getElementName(), config);
00371
00372 if(isExtraMux(pinPtr.getElementName())){
00373 ElementSharedPtr muxElement = *primitivePtr->findElement(pinPtr.getElementName());
00374 Element::ConnectionSharedPtrIterator cb1 = muxElement->connectionsBegin();
00375 Element::ConnectionSharedPtrIterator ce1 = muxElement->connectionsEnd();
00376 while(cb1 < ce1){
00377 ConnectionPin pinPtr1 = * (*cb1)->getSink();
00378 if(pinPtr1.getPinName()== config.getValue()){
00379 pinPtr = * (*cb1)->getSource();
00380 instanceConfigs.getConfig(pinPtr.getElementName(),config);
00381 break;
00382 }
00383 ++cb1;
00384 }
00385 }
00386 if(!instanceConfigs.hasConfig(pinPtr.getElementName())){
00387 ++sop;
00388 continue;
00389 }
00390 newName = newName + ":" + pinPtr.getElementName()+ ":" +config.getName();
00391 InstanceSharedPtr instPtr = *newCircuit->findInstance(newName);
00392 InstancePinSharedPtr instPin = Factory::newInstancePinPtr (instPtr, pinPtr.getPinName());
00393 netPtr->addSource(instPin);
00394 sop = netPtr->sourcesBegin();
00395 }
00396 else
00397 ++sop;
00398 }
00399
00400
00401
00402 Net::InstancePinSharedPtrIterator sip = netPtr->sinksBegin();
00403 while(sip != netPtr->sinksEnd()){
00404 if((*sip)->getInstancePtr().lock()->getName()==instance.getName()){
00405 string pinName = (*sip)->getPinName();
00406
00407 netPtr->removeSink(*sip);
00408 PrimitivePinSharedPtr pinTmp = *primitivePtr->findPrimitivePin(pinName);
00409 ElementSharedPtr elementTmp = *primitivePtr->findElement(pinName);
00410 Element::ConnectionSharedPtrIterator cb = elementTmp->connectionsBegin();
00411 Element::ConnectionSharedPtrIterator ce = elementTmp->connectionsEnd();
00412 while(cb < ce){
00413 ConnectionPin pinPtr = * (*cb)->getSink();
00414 if(!instanceConfigs.hasConfig(pinPtr.getElementName())){
00415 ++cb;
00416 continue;
00417 }
00418
00419 Config config;
00420 instanceConfigs.getConfig(pinPtr.getElementName(),config);
00421 if(isExtraMux(pinPtr.getElementName()) || (strstr(pinPtr.getElementName().c_str() , "INV")!=NULL && strstr(config.getValue().c_str(), "_B")==NULL)){
00422
00423 if(config.getValue() != pinPtr.getPinName()){
00424 ++cb;
00425 continue;
00426 }
00427 ElementSharedPtr muxElement = *primitivePtr->findElement(pinPtr.getElementName());
00428 Element::ConnectionSharedPtrIterator cb1 = muxElement->connectionsBegin();
00429 Element::ConnectionSharedPtrIterator ce1 = muxElement->connectionsEnd();
00430 while(cb1 < ce1){
00431 ConnectionPin pinPtr1 = * (*cb1)->getSource();
00432 if(pinPtr1.getElementName()== muxElement->getName()){
00433 pinPtr = * (*cb1)->getSink();
00434 if(!instanceConfigs.getConfig(pinPtr.getElementName(),config)){
00435 ++cb1;
00436 continue;
00437 }
00438
00439 if(isExtraMux(pinPtr.getElementName()) || (strstr(pinPtr.getElementName().c_str() , "INV")!=NULL && strstr(config.getValue().c_str(), "_B")==NULL)){
00440
00441 if(config.getValue() != pinPtr.getPinName()){
00442 ++cb1;
00443 continue;
00444 }
00445 muxElement = *primitivePtr->findElement(pinPtr.getElementName());
00446 cb1 = muxElement->connectionsBegin();
00447 ce1 = muxElement->connectionsEnd();
00448 continue;
00449 }
00450 string newName = instance.getName();
00451 newName = newName + ":" + pinPtr.getElementName() + ":" + config.getName();
00452
00453 InstanceSharedPtr instPtr = *newCircuit->findInstance(newName);
00454 InstancePinSharedPtr instPin = Factory::newInstancePinPtr (instPtr, pinPtr.getPinName());
00455 netPtr->addSink(instPin);
00456 }
00457 ++cb1;
00458 }
00459 }
00460 else{
00461
00462 string newName = instance.getName();
00463 newName = newName + ":" + pinPtr.getElementName() + ":" + config.getName();
00464
00465 InstanceSharedPtr instPtr = *newCircuit->findInstance(newName);
00466 InstancePinSharedPtr instPin = Factory::newInstancePinPtr (instPtr, pinPtr.getPinName());
00467 netPtr->addSink(instPin);
00468 }
00469 ++cb;
00470 }
00471 sip = netPtr->sinksBegin();
00472 }
00473 else
00474 ++sip;
00475 }
00476
00477 }
00478
00479
00480 p = instanceConfigs.configBegin();
00481 e = instanceConfigs.configEnd();
00482 while(p != e) {
00483 const std::string& setting = p->first;
00484 Config config=p->second;
00485 if(isExtraMux(setting)|| (strstr(setting.c_str() , "INV")!=NULL && strstr(config.getValue().c_str(), "_B")==NULL)){
00486 ++p;
00487 continue;
00488 }
00489 string instName = instance.getName();
00490 instName = instName + ":" + setting + ":" +config.getName();
00491
00492 ElementSharedPtr elemPtr = * primitivePtr->findElement(setting);
00493 Element::ConnectionSharedPtrIterator cb = elemPtr->connectionsBegin();
00494 Element::ConnectionSharedPtrIterator ce = elemPtr->connectionsEnd();
00495 while(cb != ce){
00496 ConnectionPin srcPtr = * (*cb)->getSource();
00497 ConnectionPin sinkPtr = * (*cb)->getSink();
00498 if(srcPtr.getElementName() == elemPtr->getName()){
00499 string netName = instName;
00500 netName += ":" + srcPtr.getPinName();
00501 if(instanceConfigs.hasConfig(sinkPtr.getElementName())){
00502 if(isExtraMux(sinkPtr.getElementName())){
00503 Config config;
00504 instanceConfigs.getConfig(sinkPtr.getElementName(),config);
00505 if(config.getValue() != sinkPtr.getPinName()){
00506 ++cb;
00507 continue;
00508 }
00509 ElementSharedPtr muxElement = *primitivePtr->findElement(sinkPtr.getElementName());
00510 Element::ConnectionSharedPtrIterator cb1 = muxElement->connectionsBegin();
00511 Element::ConnectionSharedPtrIterator ce1 = muxElement->connectionsEnd();
00512 while(cb1 < ce1){
00513 ConnectionPin pinPtr1 = * (*cb1)->getSource();
00514 if(pinPtr1.getElementName()== muxElement->getName()){
00515 sinkPtr = * (*cb1)->getSink();
00516 instanceConfigs.getConfig(sinkPtr.getElementName(),config);
00517 break;
00518 }
00519 ++cb1;
00520 }
00521 }
00522 if(isExtraMux(sinkPtr.getElementName())){
00523 Config config;
00524 instanceConfigs.getConfig(sinkPtr.getElementName(),config);
00525 if(config.getValue() != sinkPtr.getPinName()){
00526 ++cb;
00527 continue;
00528 }
00529 ElementSharedPtr muxElement = *primitivePtr->findElement(sinkPtr.getElementName());
00530 Element::ConnectionSharedPtrIterator cb1 = muxElement->connectionsBegin();
00531 Element::ConnectionSharedPtrIterator ce1 = muxElement->connectionsEnd();
00532 while(cb1 < ce1){
00533 ConnectionPin pinPtr1 = * (*cb1)->getSource();
00534 if(pinPtr1.getElementName()== muxElement->getName()){
00535 sinkPtr = * (*cb1)->getSink();
00536 instanceConfigs.getConfig(sinkPtr.getElementName(),config);
00537 break;
00538 }
00539 ++cb1;
00540 }
00541 }
00542 if(!instanceConfigs.hasConfig(sinkPtr.getElementName())){
00543 ++cb;
00544 continue;
00545 }
00546 Circuit::NetSharedPtrIterator netIt = newCircuit->findNet(netName);
00547 if(netIt == newCircuit->netsEnd()){
00548 NetSharedPtr newNet = Factory::newNetPtr (netName);
00549 InstanceSharedPtr instPtr = *newCircuit->findInstance(instName);
00550 InstancePinSharedPtr instPin = Factory::newInstancePinPtr (instPtr, srcPtr.getPinName());
00551 newNet->addSource(instPin);
00552 newCircuit->addNet(newNet);
00553 netIt = newCircuit->findNet(netName);
00554 }
00555 Config config;
00556 instanceConfigs.getConfig(sinkPtr.getElementName(),config);
00557 string sinkInstName = instance.getName()+":"+sinkPtr.getElementName()+":"+config.getName();
00558 InstanceSharedPtr instPtr = *newCircuit->findInstance(sinkInstName);
00559 InstancePinSharedPtr instPin = Factory::newInstancePinPtr (instPtr, sinkPtr.getPinName());
00560 (*netIt)->addSink(instPin);
00561
00562 }
00563 }
00564 ++cb;
00565 }
00566 ++p;
00567 }
00568
00569
00570 return;
00571 }
00572
00573 InstanceReferenceSharedPtr instanceReferencePtr = instance.getInstanceReferencePtr();
00574 InstanceReferenceSharedPtr newInstanceReferencePtr;
00575 if(instanceReferencePtr.get() != 0) {
00576 const InstanceReference& instanceReference = *instanceReferencePtr;
00577 std::string instanceName = instanceReference.getInstancePtr().expired()
00578 ? "[expired instance]" : instanceReference.getInstancePtr().lock()->getName();
00579 newInstanceReferencePtr = Factory::newInstanceReferencePtr (
00580 instanceName, instanceReference.getModulePtr().lock(), instanceReference.getInstancePtr().lock());
00581 }
00582 string typeName;
00583 typeName = instance.getType();
00584
00585 InstanceSharedPtr newInst = Factory::newInstancePtr(instance.getName(), typeName, instance.getTile(),
00586 instance.getSite(), instance.getBonding(), newInstanceReferencePtr);
00587 if(!instance.configIsEmpty())
00588 { newInst->addConfigs(static_cast<const ConfigMap&>(instance)); }
00589
00590 newCircuit->addInstance(newInst);
00591
00592 }
00593
00594 NetSharedPtr XdlUnpack::unpack(const Net& net) {
00595
00596 NetSharedPtr newNet = Factory::newNetPtr (net.getName(), net.getNetType());
00597
00598
00599 size_t left = net.getSourceCount() + net.getSinkCount() + net.getPipCount()
00600 + (net.configIsEmpty() ? 0 : 1);
00601
00602
00603 Net::InstancePinSharedPtrConstIterator sop = net.sourcesBegin();
00604 Net::InstancePinSharedPtrConstIterator soe = net.sourcesEnd();
00605 while(sop < soe){
00606 InstancePinSharedPtr instPin = unpack(*sop++, ePinDirectionOutpin, --left > 0);
00607 newNet->addSource(instPin);
00608 }
00609
00610 Net::InstancePinSharedPtrConstIterator sip = net.sinksBegin();
00611 Net::InstancePinSharedPtrConstIterator sie = net.sinksEnd();
00612 while(sip < sie) {
00613 InstancePinSharedPtr instPin = unpack(*sip++, ePinDirectionInpin, --left > 0);
00614 newNet->addSink(instPin);
00615 }
00616
00617
00618 if(!net.configIsEmpty()) {
00619 newNet->addConfigs(static_cast<const ConfigMap&>(net));
00620 }
00621 return newNet;
00622 }
00623
00624 InstancePinSharedPtr XdlUnpack::unpack(const InstancePinSharedPtr instancePinSharedPtr, EPinDirection pinDirection,
00625 bool comma) {
00626
00627 InstancePinSharedPtr instPin = Factory::newInstancePinPtr (instancePinSharedPtr->getInstancePtr().lock(), instancePinSharedPtr->getPinName());
00628 return instPin;
00629 }
00630
00631 Pip XdlUnpack::unpack(const Pip& pip, bool comma) {
00632 RoutethroughSharedPtr newRoutethrough;
00633 if(pip.isRoutethrough())
00634 newRoutethrough = unpack(*pip.getRoutethroughPtr());
00635 else
00636 newRoutethrough = RoutethroughSharedPtr();
00637 Pip newPip = Factory::newPip(pip.getTileName(), pip.getSourceWireName(), pip.getSinkWireName(), pip.getDirection(), RoutethroughSharedPtr());
00638
00639 return newPip;
00640 }
00641
00642 RoutethroughSharedPtr XdlUnpack::unpack(const Routethrough& routethrough) {
00643 RoutethroughSharedPtr newRoutethrough = Factory::newRoutethroughPtr (
00644 routethrough.getSetting(), routethrough.getName(), routethrough.getValue(), routethrough.getInstancePtr(),
00645 routethrough.getSourceWireName(), routethrough.getSinkWireName());
00646 return newRoutethrough;
00647 }
00648
00649 void XdlUnpack::removeExtraElements(PrimitiveSharedPtr primPtr){
00650 Primitive::ElementSharedPtrIterator elemIt;
00651 ElementSharedPtr elemPtr;
00652 for(elemIt=primPtr->elementsBegin(); elemIt != primPtr->elementsEnd(); ++elemIt){
00653 if(strstr((*elemIt)->getName().c_str(), "USED")!=NULL){
00654 primPtr->removeElement(*elemIt);
00655 continue;
00656 }
00657
00658 char names[1024] ;
00659 strcpy(names,elementNames.c_str());
00660 string pch;
00661 pch = strtok (names," ");
00662 while (pch!="END")
00663 {
00664 if(pch == (*elemIt)->getName()){
00665 primPtr->removeElement(*elemIt);
00666 break;
00667 }
00668 pch = strtok (NULL," ");
00669 }
00670 }
00671 }
00672
00673 }
00674 }
00675
