void DLPreInsert (tDLList *L, int val) {
/*
** Vlo¾í prvek pøed aktivní prvek seznamu L.
** Pokud nebyl seznam L aktivní, nic se nedìje.
** V pøípadì, ¾e není dostatek pamìti pro nový prvek pøi operaci malloc,
** volá funkci DLError().
**/
if (L->Act == NULL)
return;
tDLElemPtr tmpPtr = malloc(sizeof(struct tDLElem));
if (tmpPtr == NULL) {
DLError();
return;
}
tmpPtr->data = val;
tmpPtr->rptr = NULL;
tmpPtr->lptr = NULL;
if (L->Act->lptr != NULL) {
L->Act->lptr->rptr = tmpPtr;
tmpPtr->lptr = L->Act->lptr;
} else
L->First = tmpPtr;
L->Act->lptr = tmpPtr;
tmpPtr->rptr = L->Act;
}
/** dlfunc wrappers
* These function abstract dlopen,dlsym and dlclose for win32, OS-X, BeOS
* and POSIX etc.
*/
void *
CqPluginBase::DLOpen( CqString *library )
{
void * handle = NULL;
Aqsis::log() << info << "Loading plugin \"" << library->c_str() << "\"" << std::endl;
#ifndef AQSIS_NO_PLUGINS
#ifdef AQSIS_SYSTEM_WIN32
handle = ( void* ) LoadLibrary( library->c_str() );
#else
CqString tstring = *library;
CqString::size_type pos = tstring.find ("/");
if (pos == CqString::npos)
tstring = CqString("./") + *library;
handle = ( void * ) dlopen( tstring.c_str(), RTLD_NOW);
#endif
#endif // AQSIS_NO_PLUGINS
if ( handle )
m_activeHandles.push_back( handle );
else
/** \todo <b>Code Review</b>: Re-evaluate how the error handling works
* here. For now we report the error, but perhaps it would be better
* to throw an exception and let the calling code handle the problem.
*/
Aqsis::log() << error << "Error loading plugin: \"" << DLError() << "\"\n";
return handle;
}
void DLInsertLast(tDLList *L, int val) {
/*
** Vlo¾í nový prvek na konec seznamu L (symetrická operace k DLInsertFirst).
** V pøípadì, ¾e není dostatek pamìti pro nový prvek pøi operaci malloc,
** volá funkci DLError().
**/
tDLElemPtr tmpPtr = malloc(sizeof(struct tDLElem));
if (tmpPtr == NULL) {
DLError();
return;
}
tmpPtr->data = val;
tmpPtr->rptr = NULL;
tmpPtr->lptr = L->Last; // nadviazanie na posledny prvok zoznamu
if (L->First == NULL)
L->First = tmpPtr;
if (L->Last != NULL)
L->Last->rptr = tmpPtr;
L->Last = tmpPtr;
}
void DLInsertFirst (tDLList *L, int val) {
/*
** Vlo¾í nový prvek na zaèátek seznamu L.
** V pøípadì, ¾e není dostatek pamìti pro nový prvek pøi operaci malloc,
** volá funkci DLError().
**/
tDLElemPtr tmpPtr = malloc(sizeof(struct tDLElem));
if (tmpPtr == NULL) {
DLError();
return;
}
tmpPtr->data = val;
tmpPtr->rptr = L->First; // nadviazanie na predchadzajuci L->First
tmpPtr->lptr = NULL;
if (L->First != NULL) // ak je to prvy prvok v zozname, tak je aj poslednym prvkom v zozname
L->Last = tmpPtr;
if (tmpPtr->rptr != NULL) // ak za prvkom nasleduje dalsi prvok, je potrebne ho na novy prvok nadviazat
tmpPtr->rptr->lptr = tmpPtr;
if (L->First == NULL) // ak v zozname este nebol ziadny prvok, musi na novy prvok smerovat aj L->Last
L->Last = tmpPtr;
L->First = tmpPtr; // nastavenie noveho prvku ako L->First
}
void DLCopyLast (tDLList *L, int *val) {
/*
** Prostøednictvím parametru val vrátí hodnotu posledního prvku seznamu L.
** Pokud je seznam L prázdný, volá funkci DLError().
**/
if (L->Last == NULL) {
DLError();
return;
}
*val = L->Last->data;
}
/** This returns a list of descriptors of calls to external DSO functions that
* implement a named shadeop, entries are returned for each polymorphic function
*/
std::list<SqDSOExternalCall*>*
CqDSORepository::getShadeOpMethods(CqString* pShadeOpName)
{
CqString strTableSymbol = *pShadeOpName + "_shadeops" ;
std::list<SqDSOExternalCall*>* oplist = new (std::list<SqDSOExternalCall*>);
std::list<CqString>::iterator itPathEntry;
SqShadeOp *pTableSymbol = NULL;
Aqsis::log() << debug << "Looking for DSO candidates for shadeop \"" << pShadeOpName->c_str() << "\"" << std::endl;
for ( itPathEntry = m_DSOPathList.begin() ; itPathEntry != m_DSOPathList.end() ; itPathEntry++ )
{
Aqsis::log() << debug << "Looking in shared library : " << itPathEntry->c_str() << std::endl;
void *handle = DLOpen( &(*itPathEntry) );
if( handle != NULL )
{
pTableSymbol = (SqShadeOp*) DLSym( handle, &strTableSymbol );
if ( pTableSymbol != NULL )
{
//We have an appropriate named shadeop table
SqShadeOp *pShadeOp = (SqShadeOp*) pTableSymbol;
while( ( pShadeOp->m_opspec )[0] != (char) NULL )
{
SqDSOExternalCall *pDSOCall = NULL;
pDSOCall = parseShadeOpTableEntry( handle, pShadeOp );
if ( pDSOCall != NULL )
oplist->push_back( pDSOCall );
pShadeOp++;
};
};
// Failure here does not neccesarily mean anything since
}
else
{
CqString strError = DLError();
Aqsis::log() << error << "DLOpen: " << strError.c_str() << std::endl;
};
};
std::stringstream resultStr;
if(oplist->empty())
resultStr << "(none found)";
else
resultStr << "(found " << oplist->size() << " possibilities)";
Aqsis::log() << debug << "Finished looking for DSO candidates "<< resultStr.str().c_str() << std::endl;
return ( oplist->empty() ? NULL : oplist );
};
void DLCopy (tDLList *L, int *val) {
/*
** Prostøednictvím parametru val vrátí hodnotu aktivního prvku seznamu L.
** Pokud seznam L není aktivní, volá funkci DLError ().
**/
if ( L -> Act == NULL )
{
DLError () ;
return ;
}
*val = L -> Act -> data ;
}
void DLCopyFirst (tDLList *L, int *val) {
/*
** Prostøednictvím parametru val vrátí hodnotu prvního prvku seznamu L.
** Pokud je seznam L prázdný, volá funkci DLError().
**/
if ( L -> First == NULL )
{
DLError () ;
}
else
{
*val = L -> First -> data ;
}
}
void DLPreInsert (tDLList *L, int val) {
/*
** Vlo¾í prvek pøed aktivní prvek seznamu L.
** Pokud nebyl seznam L aktivní, nic se nedìje.
** V pøípadì, ¾e není dostatek pamìti pro nový prvek pøi operaci malloc,
** volá funkci DLError().
**/
/* Preskoceni neaktivniho seznamu */
if ( L -> Act == NULL )
{
return ;
}
/* Alokovani pameti pro novy prvek a osetreni funkce malloc */
struct tDLElem *new_item ;
if ( ( new_item = malloc ( sizeof ( struct tDLElem ) ) ) == NULL )
{
DLError () ;
return ;
}
/* Naplneni noveho prvku seznamu */
new_item -> data = val ;
new_item -> rptr = NULL ;
new_item -> lptr = NULL ;
/* Pokud je pred aktivnim prvkem jeste nejaky jiny prvek */
if ( L -> Act -> lptr != NULL )
{
L -> Act -> lptr -> rptr = new_item ;
new_item -> lptr = L -> Act -> lptr ;
}
/* Pokud pred aktivnim prvkem zadny jiny prvek neni */
else
{
L -> First = new_item ;
}
/* Provazani aktivniho a nove pridaneho prvku */
L -> Act -> lptr = new_item ;
new_item -> rptr = L -> Act ;
}
void DLInsertLast(tDLList *L, int val) {
/*
** Vlo¾í nový prvek na konec seznamu L (symetrická operace k DLInsertFirst).
** V pøípadì, ¾e není dostatek pamìti pro nový prvek pøi operaci malloc,
** volá funkci DLError().
**/
/* Alokovani pameti pro novy prvek a osetreni funkce malloc */
struct tDLElem *new_item ;
if ( ( new_item = malloc ( sizeof ( struct tDLElem ) ) ) == NULL )
{
DLError () ;
return ;
}
/* Naplneni noveho prvku seznamu */
new_item -> data = val ;
new_item -> rptr = NULL ;
new_item -> lptr = NULL ;
/* Provazani s poslednim prvkem seznamu */
new_item -> lptr = L -> Last ;
/* Pokud je vlevo nejaky dalsi prvek */
if ( new_item -> lptr != NULL )
{
new_item -> lptr -> rptr = new_item ;
}
else
{
L -> First = new_item ;
}
/* Nastaveni noveho prvku na posledni prvek seznamu */
L -> Last = new_item ;
}
