\chapter{Popis Implementace Importního Systému}

Importní systém se skládá ze tří základních objektů, lexikálního analyzátoru, 
parseru a importního objektu. Lexikální analyzátor prochází vstupní soubor a 
generuje lexikální elementy s jejich atributy. Parser zpracovává zadanou gramatiku 
jazyka VHDL, jeho součástí je lexikální analyzátor. Při průchodu konstrukcemi 
gramatiky jazyka VHDL volá sémantické metody, které jsou definovány v importním 
objektu. Tyto sémantické metody se starají o převod jednotlivých konstrukcí 
jazyka VHDL do struktury HUBu. Importní objekt nastaví místo v hubu do kterého 
bude probíhat import a poté spustí syntaktický analyzátor který začíná na 
startovním symbolu gramatiky.

\section{Lexikální analyzátor}
Je realizován třídou \verb|LexanVhdl| která je potomkem třídy \verb|Lexan|. 
Třída \verb|Lexan| 
definuje obecné vlastnosti každého lexikálního analyzáru, obsahuje 
v sobě tedy souborový stream  který představuje zpracovávaný vstupní soubor. 
Dále jsou v ní obsaženy seznamy klíčových slov a symbolů. Každou položku těchto 
seznamů tvoří dvojice číslo tokenu a jméno symbolu nebo klíčového slova typu string
(Tyto dvojice do seznamu vkládá až analyzátor konkrétního jazyka). 
Také deklaruje proměnné do kterých se ukládají atributy lexikálních symbolů. Obsahuje 
abstraktní metodu \verb|NextToken| která slouží ke generování lexikálního elementu  procházením 
vstupního souboru. Konstruktor má jeden parametru typu \verb|char*| který definuje jméno 
vstupního souboru.

Třída \verb|LexanVhdl| by tedy měla definovat metodu \verb|NextToken| tak aby byli generovány 
lexikální elementy jazyka VHDL. Jelikož je syntaktický analyzátor vygenerovaný 
programem {\bf Bison} nebylo možno použít způsob zpracování takový že metoda 
\verb|NextToken| vrátí pouze identifikátor lexikálního elementu a  jeho případný 
atribut uloží do \verb|public| proměnné zděděné od třídy \verb|Lexan| ke které by poté měl 
přístup syntaktický analyzátor.
Syntaktický analyzátor vygenerovaný programem Bison vyžaduje aby funkce 
kterou volá lexikální analyzátor měla jako parametr ukazatel na typ atributu, 
kam lexikální analyzátor přiřadí případný atribut lexikálního elementu. 
Metoda \verb|NextToken| bez parametru byla tedy definována tak že vrací lex. 
element označující chybu a byla přidána nová metoda NextToken se 2 parametry. 
První parametr je ukazatel na atribut a druhý je ukazatel na proměnnou 
obsahující informace o umístění lex. elementu v souboru. Typ této proměnné 
rovněž definuje Bison. Funkce této metody je realizována konečným automatem.

\section{Parser}
Je realizován třídou \verb|VhdlParser|, která v sobě obsahuje Lexikální analyzátor 
VHDL a ukazatel na klienta parseru.
 Klient parseru je realizován třídou \verb|VhdlParserClient| a obsahuje deklarace 
 sémantických metod které budou volány parserem. 
 Definice těchto metod jsou prázdné, jedná se pouze o rozhraní, 
 definice těchto metod předefinuje importní třída jež 
 je potomkem tohoto klienta.
 
Konstruktor parseru má jeden parametr a to ukazatel na objekt typu klienta. 
Parser je konstruován importní třídou která jako paramter konstruktoru parseru 
zadá ukazatel sama na sebe a tím se zajistí že parser při průchodu gramatikou 
bude volat již správně definované sémantické metody.

Syntaktická analýza se spouští metodou \verb|run| která má jako parametru název 
vstupního souboru. Tato metoda po zavolání inicializuje 
lexikální analyzátor a vytvoří objekt typu \verb|VhdlBisonParser|. 
Jedná se o třídu vygenerovanou programem 
Bison která provádí syntaktickou analýzu vstupního souboru.

\begin{verbatim}
void VhdlParser::run (const std::string& f)
{
  l.init( f.c_str() );
  fn = f;
  yy::VhdlBisonParser parser( l , *this );
  parser.set_debug_level (trace_parsing);
  parser.parse ();
}
\end{verbatim}

\subsection{Vstupní soubor programu Bison}
Gramatika jazyka VHDL je zapsána v souboru \verb|vhdl_bison_parser.ypp|. 
Po přeložení tohoto souboru Bisonem vzniknou soubory \verb|vhdl_bison_parser.hpp| a  
\verb|vhdl_bison_parser.cpp| které obsahují deklaraci a implementace třídy 
\verb|VhdlBisonParser| která provádí syntaktickou analýzu.
Zároveň s nimi jsou vytvořeny soubory location.hh a postion.hh obsahující 
třídy  \verb|yy::location| a \verb|yy::position| nesoucí informaci 
o poloze symbolů v souboru. 
Rozhraní těchto tříd je popsáno v manuálu programu Bison viz. \cite{BisonManual}.

Uvodní část vstupního souboru obsahuje informaci o tom že bude generován 
parser v jazyce C++ s použitou kostrou \verb|lalr1.c| . 
Dále je zde definováno jméno třídy parseru která bude vytvořena 
 a je zde definováno makro které určuje funkci 
 kterou bude volán lexikální analyzátor: 
\begin{verbatim}
  #define yylex(yylval, location) lex.NextToken( (yylval) , (location) )
\end{verbatim}

Datové struktury které představují sémantické typy symbolů jsou deklarovány 
v souborech \verb|vhdl_parser_struct.h| a \verb|vhdl_expressions.h| .
Za úvodní částí následují deklarace neterminálních symbolů a určení 
sémantických typů jednotlivých symbolů. 

Sémantické typy jsou následující:
\begin{itemize}
\item Seznam identifikátorů \verb|IdentifierList|
\item	Asociativní element \verb|GenAssocElem|
\item	Seznam asociativních elementů \verb|GenAssocList|
\item	Jméno \verb|SigName|
\item	Typ \verb|Type| 
\item	\verb|StringToken|: identifikátor + informace o umístění tohoto identifikátoru v souboru
\item	Výraz \verb|Expr|
\end{itemize}

Dále následuje část s pravidly gramatiky VHDL (IEEE Std 1076-2002), soubor s touto
gramatikou je přiložen na CD. 
Tato gramatika po přeložení ve stejném tvaru jako byla dodána obsahovala 
konflikty, musela být mírně pozměněna ale jednalo se jen o drobné 
změny základ zůstal stejný a analyzátor je schopen rozpoznat kompletní 
syntaxi jazyka VHDL.

\section{Přidané třídy výjimek}
Každá výjimka v HUBu se skládá z důvodu, místa (v souboru, v bloku),
 kontextu a systémové kategorie. 
 Určení místa je realizováno tak že se 
 zjistí z lexikálního analyzátoru kde se právě nachází. 
 Tento způsob ale nebylo možné použít při importu vhdl protože 
 zde může dojít k tomu že chyba je identifikována až později a 
 informace z lexikáního analyzátoru by neodpovídaly skutečnosti. 
 K tomuto může dojít např. při zpracování příkazu přiřazení kdy je 
 nejprve sestaven syntakticý strom výrazu a až poté se kontroluje 
 zda v něm obsažené identifikátory spojů nebo portů existují. 
 
Je to tedy vyřešeno tak že pro každý identifikátor který je rozpoznán 
parserem je vytvořen nový objekt typu \verb|StringToken| který v sobě 
obsahuje zároveň jméno identifikátoru i informaci o jeho umístění v souboru 
kterou definuje objekt třídy \verb|yy::Location| který rovněž poskytne parser. 

Při konstrukci výjimky se poté nepoužije místo které udává lexikální 
analyzátor ale použije se na to objekt třídy \verb|yy::Locatation| který je 
součástí každého identifikátoru třídy \verb|StringToken|.
K tomu musely být definovány nové třídy vyjímek které jsou 
definovány v souboru \verb|vhdl_err.h| . 

\section{Importní modul}
Tento modul je tvořen třídou \verb|VhdlImport| která dědí ze dvou tříd. 
První z nich je třída \verb|VhdlParserClient| která obsahuje metody pro 
zpracování sémantických konstrukcí jazyka. Třída \verb|VhdlImport| tyto 
metody předefinovává. Druhá třída jejímž je potomkem je třída 
\verb|Import| která tvoří obecné rozhraní pro importní moduly HUBu.

Třída \verb|VhdlImport| má přetížen operátor volání funkce s 
parametrem který určuje místo v hubu do kterého se bude importovan. 
Místo v hubu určuje třída 
\verb|Location| která jejímž potomkem je třída \verb|Import|. Místo v HUBu je tvořeno 
ukazatelem na knihovnu, entitu a architekturu.Jelikož jazyk VHDL zná 
pojem entita i architektura není povoleno aby před spuštěním byly 
specifikovány. Je povoleno pouze nastavit knihovnu do které se bude 
importovat, pokud není zvolena vytvoří se pracovní 
knihovna {\bf work}.

Konstruktor třídy má dva parametry první specifikuje místo v HUBu a 
druhý obsahuje jméno souboru z kterého se bude importovat.

Kromě kontextu který je určen členskými proměnnými \verb|theEntity_| , 
\verb|theArch| a \verb|theLib| 
které jsou zděděny ze třídy \verb|Location|, jsou definovány ve  
třídě \verb|VhdlImport| ještě další další členské proměnné které 
se využívají při importu jednotlivých konstrukcí: 
\begin{verbatim}
hub::StructArch*    theArchImpl_;		// current structure
hub::Instance* 	    theInstance_;	  // current instance
hub::Name		        synthLibName_;	// library name for existing primitives
hub::Library*	      theSynthLib_;		// library for synthesized primitives
hub::Entity*	      theComponent_;	// current component (declaration)
hub::number_t	      compPortsCount;	// port count of current component 

hub::Joinable* lastPort_;           // last port in expression
\end{verbatim}

Tato třída v sobě také obsahuje objekt parseru jehož je tato třída klientem, 
tzn. že parser volá sémantické funkce které jsou definovány v této třídě. 
Operace importu se spustí zavoláním přetíženého operátoru třídy \verb|VhdlImport|.
Ta nejprve nastaví místo v HUBu a poté zavolá metodu parseru run kterou 
parser spustí jako parametr nastaví jméno souboru ze kterého bude import probíhat. 

Zde je výpis deklarací všech sémantických metod starajících se o import 
implementovaných konstrukcí jazyka VHDL do hubu:
\begin{verbatim}
virtual void haveUnit(void);
virtual void endUnit(void);
    //primary & secondary units 
virtual void haveEntity( const StringToken& entName );
virtual void endEntity(void);
virtual void haveArch(const StringToken& archName,const StringToken& entName );
virtual void endArch(const StringToken& archName ="" );
    //entity interface port declaration
virtual void havePort(InterfaceDecl& intDecl );
		//signal declaration
virtual void haveSignalDeclar( InterfaceDecl intDecl );
		//component declaration
virtual void haveComponent(const StringToken& compName);
virtual void endComponent(const StringToken& compName);
virtual void haveComponentPort(InterfaceDecl& intDecl );
		// component instantion
virtual void haveComponentInst(const StringToken& label, 
        const StringToken& compName,const StringToken& archName);
virtual void havePortAssoc(const StringToken& compPortName,
        const StringToken& NetName);
virtual void havePosPortAssoc(int portPosition, const StringToken& NetName);
virtual void endComponentInst(void);
		//signal_assignment
virtual StringToken* haveSymFunc(const std::list<StringToken> listInputNames,
		const std::string& func, bool createNet = true);
virtual void haveOperand(const StringToken& portName ); 
virtual void haveSignalAssignment(StringToken targetName, Expr* waveform );
\end{verbatim}

\section{Import jednotlivých konstrukcí VHDL}
\subsection{Entita}
\begin{verbatim}
entity_declaration :
    LEX_V_ENTITY  LEX_V_IDENT 
    {
      driver.client_->haveEntity(StringToken(*$2,@2));
      delete $2;
    }
    LEX_V_IS
          entity_header
          entity_declarative_part 
          opt_entity_statement_part
    LEX_V_END opt_entity_end LEX_V_SEMICOL
    {
      driver.client_->endEntity();
    }
    ;
\end{verbatim}
Metoda \verb|haveEntity| vytvoří v aktuálně nastavené knihovně entitu se 
jménen které je obsaženo v proměnné typu \verb|StringToken| v paramteru metody. 
Na tuto entitu bude ukazovat proměnná \verb|theEnt_|. Pokud stejně pojmenovaná 
entita již v knihovně existuje je vyhozena výjimka s chybou. 
Metoda \verb|endEntity| zruší nastavení aktuální entity \verb|theEnt_|.

Hlavička entity může obsahovat deklaraci portů:
\begin{verbatim}
opt_formal_port_clause :
    /* nothing */ 
    | port_clause
    {   
        for(InterfaceList::iterator i=$1->begin(); i != $1->end(); ++i)
          driver.client_->havePort(*i);
    }
    ;
\end{verbatim}
Pravidlo \verb|port_clause| vrátí seznam elementů rozhraní, pro každý element tohoto 
rozhraní je zavolána metoda \verb|havePort|.
Každý element rozhraní obsahuje jméno portu, mód a ukazatel na datový typ.
Obsahuje také metodu \verb|GeneratePortNames| která na základě typu portu vygeneruje 
vektor jmen portů.  Existují 2 typy \verb|SimpleType| a \verb|ArrayType|, 
pokud je port typu \verb|ArrayType| je vygenerováno 
tolik jmen jako je rozsah pole a jména jsou 
indexována.
Metoda \verb|HavePort| tedy nejprve vygeneruje seznam jmen portů a poté pro každé
jméno vytvoří v rozhraní entity jeden prototyp portu.

\subsection{Architektura}
\begin{verbatim}
architecture_body :
    LEX_V_ARCHITECTURE LEX_V_IDENT LEX_V_OF entity_name LEX_V_IS
    {
      driver.client_->haveArch(StringToken(*$2,@2),*$4);
      delete $2;
      delete $4;
    }
          architecture_declarative_part 
    LEX_V_BEGIN
          architecture_statement_part 
    LEX_V_END opt_arch_end LEX_V_SEMICOL
     {
      driver.client_->endArch();
    }
    ;
\end{verbatim}
Metoda \verb|haveArch|  vyhledá v aktuálně nastavené knihovně zda v ní existuje 
entita se jménem které je dodáno jako druhý parametr této metody. 
Pokud byla entita nalezena vytvoří se k ní architektura se strukturním popisem:
\begin{verbatim}
theArch_ = theEntity_->CreateArch <StructArch> (archName);
theArchImpl_ = theArch_->Impl<StructArch>();
\end{verbatim} 
Proměnná \verb|theArchImpl_| je nastavena aby ukazovala na tuto nově vytvořenou
 architekturu. Poté se z prototypů portů nadřazené entity vytvoří 
 instance portů v architektuře.

\subsection{Deklarace Signálu}
\begin{verbatim}
block_declarative_item :
 ...
| signal_declaration 
    	{ 
     	 for(InterfaceList::iterator i=$1->begin(); i != $1->end(); ++i)
        	  driver.client_->haveSignalDeclar(*i);
       	 delete $1;
   	 }
;
\end{verbatim}

Symbol \verb|signal_declaration| vrací seznam elementů rozhraní. 
Pro každý element tohoto rozhraní je zavolána metoda 	haveSignalDeclar. 
Ta vygeneruje vektor se jmény signálů a pro každé jméno vytvoří v aktuálně 
nastavené architektuře nový spoj. Kontroluje zda již stejně pojmenovanný 
signál nebo port rozhraní v architektuře neexistuje.

\subsection{Deklarace Komponenty}
Při rozpoznání konstrukce deklarace komponenty je zavolána metoda 
\verb|haveComponent| s parametrem udávajícím jméno komponenty. 
Tato metoda vyhledá v aktuálně nastavené knihovně entitu se jménem 
odpovídajícím jménu komponenty. Pokud je nalezena je do proměnné \verb|theComponent_| 
uložen ukazatel na tuto entitu. 

Pokud komponenta obsahuje porty je vrácen seznam elementů rozhraní. 
Pro každý element tohoto rozhraní je zavolána metoda \verb|haveComponentPort|. 
Tato metoda kontroluje zda entita  na kterou ukazuje 
proměnná \verb|theComponent_| 
obsahuje prototyp portu který je stejně pojmenován a má shodný mód.

Na konci deklarace komponenty je zavolána metoda \verb|endComponent| která zruší 
ukazatel na aktuální komponentu a zkontroluje zda se počet portů komponenty 
které byly porovnávany shoduje s počtem portů nastavené entity.

\subsection{Příkaz přiřazení signálu}
\begin{verbatim}
conditional_signal_assignment :
    target  LEX_V_LOEQ opt_guarded delay_mechanism conditional_waveforms LEX_V_SEMICOL
    {
     driver.client_->haveSignalAssignment( $1->GenerateName() , $5 );
     delete $1;
     delete $5;
    }
;
\end{verbatim}

\paragraph{Syntaktický strom výrazu}

Symbol \verb|conditional_waveforms| vrací ukazatel  na proměnnou typu \verb|Expr|
ta představuje kořen syntaktického stromu který byl vytvořen při 
zpracovávání výrazu syntaktickým analyzátorem. 
Třída  \verb|Expr| je abstraktní a tvoří rozhraní pro třídy které se mohou 
vyskytnout v syntaktickém stromu výrazu, deklararuje abstraktní metodu \verb|Connect|:
\begin{verbatim}
virtual StringToken* Connect(VhdlParserClient* client,bool createNet=true)=0;
\end{verbatim}
Strom výrazu se může skládat z objektů tříd představujících: 
\begin{itemize}
\item binární operátor \verb|BinOp|
\item	unární operátor \verb|UnOp|
\item	Literál \verb|LiteralExpr|
\item	Jméno signálu \verb|NameExpr|
\end{itemize}
Třída \verb|NameExpr| jejíž objekty představují jmenné operandy ve výrazu, má 
definovánu metodu connect tak že vrací jméno operandu které 
představuje spoj nebo port.

Třída \verb|BinOp| obsahuje odkaz na levý a pravý podstrom a jméno operátoru. 
Metoda \verb|Connect| u binárního operátoru slouží k vytvoření instance primitivní entity
(odpovídající operátoru)v architektuře. Metoda funguje tak že nejprve 
zavolá \verb|Connect| na levý a pravý podstrom tím získá jména spojů které 
představují vstupy do dané instance primitivní entity. 
Poté zavolá metodu klienta:
\begin{verbatim}
StringToken* output = client->haveSymFunc(inputs,operator_,createNet);
\end{verbatim}
Tato metoda vytvoří v architektuře instanci primitivní entity, 
její návratovou hodnotu je jméno výstupního této instance. 
Toto jméno následně vrátí i metoda \verb|Connect|.

Druhý parametr typu \verb|boolean| metody \verb|Connect| říká zda má 
být vytvořen port, využívá se toho u třídy \verb|BinOp| a \verb|UnOp|. 
Pokud je parametr nastaven na \verb|false| nepřipojí se na výstup instance spoj.

\paragraph{Metoda haveSignalAssignment}

\begin{verbatim}
driver.client_->haveSignalAssignment( $1->GenerateName() , $5 );
\end{verbatim}

První parametr představuje jméno cílového spoje nebo portu. 
Druhý parametr je ukazatel na kořen syntaktického stromu výrazu. 
Metoda nejprve vyhledá zda existuje cílový spoj. Pokud spoj daného jména 
nebyl nalezen pokusí se vyhledat zda existuje port s takovým jménem, 
pokud byl nalezen je k němu vytvořen stejně pojmenovaný spoj. 
Poté je na kořen syntakticého 
stromu zavolána metoda \verb|Connect s parametrem \verb|CreateNet| nastaveným na \verb|false|. 
Tím se zajistí že dojde k propojení výrazu. Port který má být připojen k 
cílovému spoji bude nastaven v proměnné \verb|lastPort_|, tato proměnná byla 
nastavena během zpracování syntaktického stromu metodou klienta \verb|haveSymFunc| 
nebo \verb|haveOperand|. 

Pokud proměnná \verb|lastPort_| nebyla nastavena znamená to že na pravé 
straně příkazu přiřazení byl pouze spoj nebo neexistující port a 
zapojení nemůže být provedeno. Pokud proměnná \verb|lastPort_| byla nastavena 
je port na který ukazuje připojen k cílovému spoji příkazu přiřazení.

\paragraph{Vytvoření instance primitivní entity}

\begin{verbatim}
StringToken* VhdlImport::haveSymFunc(const list<StringToken>  listInputNames,
            const std::string& func, bool createNet );
\end{verbatim}
V tomto případě se budou vytvářet instance entity jejíž architektuta je popsána
symetrickou funkcí kterou popisuje třída \verb|SymFunc|.
Nejprve je třeba zjistit jestli entita popisující danou symetrickou funkci v 
knihovně primitiv již neexistuje. Je tedy potřeba vytvořit knihovního agenta symetrické 
funkce pomocí kterého lze vyhledávat v knihovně:
\begin{verbatim}
BehavAgent* agent=new SymFuncAgent(decodeFunc(func),listInputNames.size());
\end{verbatim}
V knihovně primitiv se pokusíme pomocí tohoto agenta nalézt opovídající 
popis pokud byl nalezen vráti metoda \verb|Find| ukazatel na požadovanou architekturu. 
Tato architektura nám poskytne informaci o entitě jíž je podřízena. 
Z této entity již lze vytvořit instanci požadované symetrické funkce.

Pokud ale nebyla architektura nalezana znamená to že zatím neexistuje entita 
popisující danou symetrickou funkci a musí tedy výt vytvořena. 
Nejprve se v knihovně primitiv vytvoří unikátní entita která bude představovat 
tuto funkci. Poté je k ní vytvořena behaviorální architektura. 
Její popis vytvoří behaviorální agent který byl 
vytvořen pro vyhledáváni v knihovně:

\begin{verbatim}
  Architecture* stdArch = stdEnt->CreateArch <BehavArch>("vhdl");
  stdEnt->CurrentArch (stdArch);
  BehavAech* behavArch = dynamic_cast <BehavArch*> (stdArch->Impl());
  behavArch->description (agent->CreateDescr());
\end{verbatim}

Nakonec jsou vytvořeny porty rozhraní této entity jeden výstupní port a 
tolik vstupních portů kolik obsahuje seznam vstupních portů této metody.

V tomto okamžiku již tedy máme entitu odpovídající požadované funkci 
která byla buď nalezena v knihovně nebo vytvořena a přidána do knihovny. 
Z této entity je v architektuře vytvořena instance jejíž jméno je stejné 
jako jméno entity ale navíc je oindexováno aby byli rozlišeny jednotlivé 
instance téže entity. Dále je k instanci vytvořen a připojen výstupní 
spoj pokud byl parametr \verb|createNet| nastaven jako \verb|true|. 
Proměnná \verb|lastPort_| je nastavena aby ukazovala na výstupní port této instance. 
Nakonec se prochází seznam vstupních signálů funkce, pro každý 
prvek tohoto seznamu se pokusí vyhledat zda existuje spoj odpovídající 
tomuto jménu. Pokud byl nalezen je připojen do vstupního portu této instance. 
Pokud nalezen nebyl vyhledává se zda existuje port architektury se stejným jménen.
V případě že byl nalezen vytvoří se k němu spoj a ten ho propojí se vstupem instance.

\subsection{Příkaz instalace komponenty}
Pokud syntaktický analyzátor rozpozná konstrukci instalace 
komponenty zavolá nejprve metodu klienta:
\begin{verbatim}
void haveComponentInst(const StringToken& label, const StringToken& compName,
                       const StringToken& archName);
\end{verbatim}
První parametr udává jméno instance, druhý jméno komponenty a třetí jméno 
architektury s kterou má být instance zapojena. Pokud není architektura 
specifikována vytvoří se instance s naposled přeloženou architekturou. 
Tato metoda tedy vyhledá v knihovně entitu odpovídající jménu komponenty 
a poté k ní vyhledá příslušnou architekturu. 
Nakonec z ní vytvoří pojmenovanou instanci a ukazatel na tuto 
instanci uloží do proměnné \verb|theInstance_|.

Příkaz instalace komponenty dále obsahuje část ve které se mapují porty komponenty. 
Syntaktický analyzátor při zpracovávání pravidla \verb|association_list| vytvoří 
seznam asociativních elemetů.  Pro každý asociativní element je zavolána 
metoda metoda klienta \verb|havePosPortAssoc| pokud jsou porty mapovány pozičně 
nebo \verb|havePortAssoc| pokud jsou mapovány jmenným přiřazením. 

\paragraph{Poziční mapování}
\begin{verbatim}
virtual void havePosPortAssoc(int portPosition, const StringToken& NetName);
\end{verbatim}
Nejprve je v architektuře vyhledán spoj který odpovídá jménu uloženém v 
parametru \verb|NetName|, pokud není spoj nalezen pokusí se vyhledat port 
architektury se stejným jménem.
Pokud je tento port nalezen vytvoří se k němu příslušný spoj.
Dále je potřeba najít port komponenty který se mapuje. 
Odkaz na aktuálně mapovanou instanci je v proměnné \verb|theInstance_|,
zavolání metody find s parametrem udávajícim číslo portu se vyhledá požadovaný port.  
Pokud je port nalezen je propojen s dříve nalezeným spojem.

\paragraph{Jmenné mapování}
\begin{verbatim}
virtual void havePortAssoc(const StringToken& compPortName,const StringToken& NetName);
\end{verbatim}
Funguje stejným způsobem jako poziční mapování akorát porty instance 
jsou vyhledávány podle jména.

