int ListApplyToEach (list_t list, int ascending, ListApplicationFunc funcToApply, void *callbackData) { int result = 0, index; if (!list || !funcToApply) goto Error; if (ascending) { for (index = 1; index <= ListNumItems (list); index++) { result = funcToApply (index, ListGetPtrToItem (list, index), callbackData); if (result < 0) goto Error; } } else { for (index = ListNumItems (list); index > 0 && index <= ListNumItems (list); index--) { result = funcToApply (index, ListGetPtrToItem (list, index), callbackData); if (result < 0) goto Error; } } Error: return result; }
/// HIFN Disconnects a Source VChan from all its Sink VChans static BOOL disconnectSourceVChan (SourceVChan_type* srcVChan) { if (!srcVChan) return FALSE; SinkVChan_type* sinkVChan = NULL; for (size_t i = 1; i <= ListNumItems(srcVChan->sinkVChans); i++) { sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i); sinkVChan->sourceVChan = NULL; // if Sink VChan is open, close it if (sinkVChan->baseClass.isOpen) { sinkVChan->baseClass.isOpen = VChan_Closed; if (sinkVChan->baseClass.VChanStateChangeCBFptr) (*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen); } } ListClear(srcVChan->sinkVChans); // if Source VChan is open, close it if (srcVChan->baseClass.isOpen) { srcVChan->baseClass.isOpen = VChan_Closed; if (srcVChan->baseClass.VChanStateChangeCBFptr) (*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen); } return TRUE; }
int console_assign (int file, char *devname) { int flag, i; /* Check for valid file */ switch (file) { case stdin: flag = DEV_FLAGS_INPUT; break; case stdout: case stderr: flag = DEV_FLAGS_OUTPUT; break; default: return -1; } /* Check for valid device name */ for (i = 1; i <= ListNumItems (devlist); i++) { device_t *dev = ListGetPtrToItem (devlist, i); if (strcmp (devname, dev->name) == 0) { if (dev->flags & flag) return console_setfile (file, dev); return -1; } } return -1; }
int do_coninfo (cmd_tbl_t * cmd, int flag, int argc, char *argv[]) { int i, l; /* Scan for valid output and input devices */ puts ("List of available devices:\n"); for (i = 1; i <= ListNumItems (devlist); i++) { device_t *dev = ListGetPtrToItem (devlist, i); printf ("%-8s %08x %c%c%c ", dev->name, dev->flags, (dev->flags & DEV_FLAGS_SYSTEM) ? 'S' : '.', (dev->flags & DEV_FLAGS_INPUT) ? 'I' : '.', (dev->flags & DEV_FLAGS_OUTPUT) ? 'O' : '.'); for (l = 0; l < MAX_FILES; l++) { if (stdio_devices[l] == dev) { printf ("%s ", stdio_names[l]); } } putc ('\n'); } return 0; }
/// HIFN Given a Source VChan, the function returns the name of the Sink VChan attached to the source having the 1-based index sinkIdx. If index is out of range it returns NULL. char* GetSinkVChanName (SourceVChan_type* srcVChan, size_t sinkIdx) { SinkVChan_type* sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, sinkIdx); if (!sinkVChan) return NULL; return GetVChanName((VChan_type*)sinkVChan); }
int SendDataPacket (SourceVChan_type* srcVChan, DataPacket_type** dataPacketPtr, BOOL srcVChanNeedsPacket, char** errorMsg) { INIT_ERR size_t nSinks = ListNumItems(srcVChan->sinkVChans); SinkVChan_type* sinkVChan = NULL; size_t nPacketsSent = 0; // counts to how many Sink VChans the packet has been sent successfuly size_t nPacketRecipients = 0; // counts the number of packet recipients // set packet counter // Note: Since the Source VChan is open, an active Sink VChan is also an open Sink VChan if (srcVChanNeedsPacket) { nPacketRecipients = GetNumOpenSinkVChans(srcVChan)+1; nPacketsSent++; } else nPacketRecipients = GetNumOpenSinkVChans(srcVChan); if (*dataPacketPtr) SetDataPacketCounter(*dataPacketPtr, nPacketRecipients); // if there are no recipients then dispose of the data packet if (!nPacketRecipients) { ReleaseDataPacket(dataPacketPtr); return 0; } // send data packet for (size_t i = 1; i <= nSinks; i++) { sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans,i); if (!sinkVChan->baseClass.isOpen) continue; // forward packet only to open Sink VChans connected to this Source VChan // put data packet into Sink VChan TSQ CmtErrChk( CmtWriteTSQData(sinkVChan->tsqHndl, dataPacketPtr, 1, (int)sinkVChan->writeTimeout, NULL) ); nPacketsSent++; } *dataPacketPtr = NULL; // Data packet is considered to be consumed even if sending to some Sink VChans did not succeed // Sink VChans that did receive the data packet, can further process it and release it. return 0; CmtError: Cmt_ERR Error: // cleanup for (size_t i = 0; i < nPacketRecipients - nPacketsSent; i++) ReleaseDataPacket(dataPacketPtr); RETURN_ERR }
int device_deregister(char *devname) { int i,l,dev_index; device_t *dev = NULL; char temp_names[3][8]; dev_index=-1; for (i=1; i<=ListNumItems(devlist); i++) { dev = ListGetPtrToItem (devlist, i); if(strcmp(dev->name,devname)==0) { dev_index=i; break; } } if(dev_index<0) /* device not found */ return 0; /* get stdio devices (ListRemoveItem changes the dev list) */ for (l=0 ; l< MAX_FILES; l++) { if (stdio_devices[l] == dev) { /* Device is assigned -> report error */ return -1; } memcpy (&temp_names[l][0], stdio_devices[l]->name, sizeof(stdio_devices[l]->name)); } ListRemoveItem(devlist,NULL,dev_index); /* reassign Device list */ for (i=1; i<=ListNumItems(devlist); i++) { dev = ListGetPtrToItem (devlist, i); for (l=0 ; l< MAX_FILES; l++) { if(strcmp(dev->name,temp_names[l])==0) { stdio_devices[l] = dev; } } } return 0; }
void ListDisposePtrList (list_t list) { int index; int numItems; if (list) { numItems = ListNumItems (list); for (index = 1; index <= numItems; index++) free (*(void **) ListGetPtrToItem (list, index)); ListDispose (list); } }
static size_t GetNumOpenSinkVChans (SourceVChan_type* srcVChan) { SinkVChan_type* sinkVChan = NULL; size_t nSinkVChans = ListNumItems(srcVChan->sinkVChans); size_t nOpenSinkVChans = 0; for (size_t i = 1; i <= nSinkVChans; i++) { sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i); if (sinkVChan->baseClass.isOpen) nOpenSinkVChans++; } return nOpenSinkVChans; }
/// HIFN Checks if a VChan object exists among a list of VChans of VChan_type*. /// OUT idx 1-based index of the found VChan object within the VChan list.Pass 0 if this is not needed. If item is not found, *idx is 0. /// HIRET TRUE if VChan exists, FALSE otherwise. BOOL VChanExists (ListType VChanList, VChan_type* VChan, size_t* idx) { VChan_type* VChanItem = NULL; size_t nVChans = ListNumItems(VChanList); for (size_t i = 1; i <= nVChans; i++) { VChanItem = *(VChan_type**)ListGetPtrToItem(VChanList, i); if (VChanItem == VChan) { if (idx) *idx = i; return TRUE; } } if (idx) *idx = 0; return FALSE; }
/// HIFN Searches for a given VChan name from a VChan list of VChan_type* and if found, returns a pointer to the VChan object. /// OUT idx 1-based index of VChan object in the list of VChans. Pass 0 if this is not needed. If item is not found, *idx is 0. /// HIRET Pointer to the found VChan_type* if VChan exists, NULL otherwise. VChan_type* VChanNameExists (ListType VChanList, char VChanName[], size_t* idx) { VChan_type* VChan = NULL; size_t nVChans = ListNumItems(VChanList); for (size_t i = 1; i <= nVChans; i++) { VChan = *(VChan_type**)ListGetPtrToItem(VChanList, i); if (!strcmp(VChan->name, VChanName)) { if (idx) *idx = i; return VChan; } } if (idx) *idx = 0; return NULL; }
/* search a device */ device_t *search_device (int flags, char *name) { int i, items; device_t *dev = NULL; items = ListNumItems (devlist); if (name == NULL) return dev; for (i = 1; i <= items; i++) { dev = ListGetPtrToItem (devlist, i); if ((dev->flags & flags) && (strcmp (name, dev->name) == 0)) { break; } } return dev; }
void DAQLabModule_empty (ListType* modules) { DAQLabModule_type** modPtrPtr; size_t nummodules = ListNumItems(*modules); if (!(*modules)) return; for (size_t i = 1; i <= nummodules; i++) { modPtrPtr = ListGetPtrToItem(*modules, i); // call discard method specific to each module (*(*modPtrPtr)->Discard)(modPtrPtr); } ListDispose(*modules); *modules = 0; }
/// HIFN Connects a Source VChan and Sink VChan. If the provided Sink VChan is connected to another Source VChan, it is first disconnected from that Source VChan. /// HIFN If both Source and Sink VChans are active then they will be opened if they are closed. /// HIRET True if successful, False otherwise. BOOL VChan_Connect (SourceVChan_type* srcVChan, SinkVChan_type* sinkVChan) { if (!srcVChan || !sinkVChan) return FALSE; SinkVChan_type* connectedSinkVChan = NULL; size_t nSinks = ListNumItems(srcVChan->sinkVChans); // check if the provided Sink VChan is already connected to this Source VChan for (size_t i = 1; i <= nSinks; i++) { connectedSinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i); if (connectedSinkVChan == sinkVChan) return FALSE; } // if Sink VChan is already connected to another Source VChan, disconnect it from that Source VChan if (sinkVChan->sourceVChan) if(!VChan_Disconnect((VChan_type*)sinkVChan) ) return FALSE; // error // add sink to source's list of sinks if (!ListInsertItem(srcVChan->sinkVChans, &sinkVChan, END_OF_LIST)) return FALSE; // error // add Source VChan to Sink VChan sinkVChan->sourceVChan = srcVChan; // if both Sink and Source VChans are active, then open Sink VChan and also Source VChan if it is not open already if (srcVChan->baseClass.isActive && sinkVChan->baseClass.isActive) { // open Sink VChan sinkVChan->baseClass.isOpen = VChan_Open; if (sinkVChan->baseClass.VChanStateChangeCBFptr) (*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen); // open Source VChan if not open already if (!srcVChan->baseClass.isOpen) { srcVChan->baseClass.isOpen = VChan_Open; if (srcVChan->baseClass.VChanStateChangeCBFptr) (*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen); } } return TRUE; }
void SetSourceVChanDataType (SourceVChan_type* srcVChan, DLDataTypes dataType) { // disconnect Sink VChans if they are incompatible size_t nSinks = ListNumItems(srcVChan->sinkVChans); SinkVChan_type* sinkVChan; BOOL compatibleVChans; for (size_t i = 1; i <= nSinks; i++) { sinkVChan = *(SinkVChan_type**) ListGetPtrToItem(srcVChan->sinkVChans, i); compatibleVChans = FALSE; for (size_t j = 0; j < sinkVChan->nDataTypes; j++) if (srcVChan->dataType == sinkVChan->dataTypes[j]) { compatibleVChans = TRUE; break; } if (!compatibleVChans) VChan_Disconnect((VChan_type*)sinkVChan); } // change Source VChan data type srcVChan->dataType = dataType; }
static BOOL disconnectSinkVChan (SinkVChan_type* sinkVChan) { if (!sinkVChan) return FALSE; SinkVChan_type* connectedSinkVChan = NULL; SourceVChan_type* srcVChan = sinkVChan->sourceVChan; if (!srcVChan) return TRUE; // do nothing if there is no source to disconnect // remove Source VChan from Sink VChan sinkVChan->sourceVChan = NULL; // if Sink VChan is open, close it if (sinkVChan->baseClass.isOpen) { sinkVChan->baseClass.isOpen = VChan_Closed; if (sinkVChan->baseClass.VChanStateChangeCBFptr) (*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen); } // remove Sink VChan from Source VChan for (size_t i = 1; i <= ListNumItems(srcVChan->sinkVChans); i++) { connectedSinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i); if (connectedSinkVChan == sinkVChan) { ListRemoveItem(srcVChan->sinkVChans, 0, i); // if Source VChan is open and there are no more active Sinks, then close Source VChan if (srcVChan->baseClass.isOpen && !GetNumActiveSinkVChans(srcVChan)) { srcVChan->baseClass.isOpen = VChan_Closed; if (srcVChan->baseClass.VChanStateChangeCBFptr) (*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen); } return TRUE; } } return FALSE; }
void ListRemoveDuplicates (list_t list, CompareFunction compareFunction) { int numItems, index, startIndexForFind, duplicatesIndex; numItems = ListNumItems (list); for (index = 1; index < numItems; index++) { startIndexForFind = index + 1; while (startIndexForFind <= numItems) { duplicatesIndex = ListFindItem (list, ListGetPtrToItem (list, index), startIndexForFind, compareFunction); if (duplicatesIndex > 0) { ListRemoveItem (list, NULL, duplicatesIndex); numItems--; startIndexForFind = duplicatesIndex; } else { break; } } } }
int console_init_r (void) { device_t *inputdev = NULL, *outputdev = NULL; int i, items = ListNumItems (devlist); #ifdef CONFIG_SPLASH_SCREEN if (getenv("splashimage") != NULL) outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev"); #endif #ifdef CONFIG_SILENT_CONSOLE if (gd->flags & GD_FLG_SILENT) outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev"); #endif for (i = 1; (i <= items) && ((inputdev == NULL) || (outputdev == NULL)); i++ ) { device_t *dev = ListGetPtrToItem (devlist, i); if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) { inputdev = dev; } if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) { outputdev = dev; } } if (outputdev != NULL) { console_setfile (stdout, outputdev); console_setfile (stderr, outputdev); } if (inputdev != NULL) { console_setfile (stdin, inputdev); } gd->flags |= GD_FLG_DEVINIT; #ifndef CFG_CONSOLE_INFO_QUIET puts ("In: "); if (stdio_devices[stdin] == NULL) { puts ("No input devices available!\n"); } else { printf ("%s\n", stdio_devices[stdin]->name); } puts ("Out: "); if (stdio_devices[stdout] == NULL) { puts ("No output devices available!\n"); } else { printf ("%s\n", stdio_devices[stdout]->name); } puts ("Err: "); if (stdio_devices[stderr] == NULL) { puts ("No error devices available!\n"); } else { printf ("%s\n", stdio_devices[stderr]->name); } #endif for (i = 0; i < 3; i++) { setenv (stdio_names[i], stdio_devices[i]->name); } #if 0 if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) return (0); #endif return (0); }
void SetVChanActive (VChan_type* VChan, BOOL isActive) { // if it has the same active/inactive status, do nothing if (VChan->isActive == isActive) return; // update active/inactive VChan->isActive = isActive; // open/close VChans if neccessary switch (VChan->dataFlow) { case VChan_Source: if (VChan->isActive) { // Inactive -> Active // Source VChan is closed. Open Source VChan if it has at least an active Sink VChan if (GetNumActiveSinkVChans((SourceVChan_type*)VChan)) { VChan->isOpen = VChan_Open; if (VChan->VChanStateChangeCBFptr) (*VChan->VChanStateChangeCBFptr) (VChan, VChan->VChanOwner, VChan->isOpen); } // Sink VChans are closed. Open active Sink VChans. SinkVChan_type* sinkVChan = NULL; size_t nSinks = ListNumItems(((SourceVChan_type*)VChan)->sinkVChans); for (size_t i = 1; i <= nSinks; i++) { sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(((SourceVChan_type*)VChan)->sinkVChans, i); if (!sinkVChan->baseClass.isActive) continue; // skip inactive Sink VChans sinkVChan->baseClass.isOpen = VChan_Open; if (sinkVChan->baseClass.VChanStateChangeCBFptr) (*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen); } } else { // Active -> Inactive // If Source VChan is open, then close it if (VChan->isOpen) { VChan->isOpen = VChan_Closed; if (VChan->VChanStateChangeCBFptr) (*VChan->VChanStateChangeCBFptr) (VChan, VChan->VChanOwner, VChan->isOpen); } // Close all open Sink VChans SinkVChan_type* sinkVChan = NULL; size_t nSinks = ListNumItems(((SourceVChan_type*)VChan)->sinkVChans); for (size_t i = 1; i <= nSinks; i++) { sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(((SourceVChan_type*)VChan)->sinkVChans, i); if (!sinkVChan->baseClass.isOpen) continue; // skip closed Sink VChans sinkVChan->baseClass.isOpen = VChan_Closed; if (sinkVChan->baseClass.VChanStateChangeCBFptr) (*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen); } } break; case VChan_Sink: if (VChan->isActive) { // Inactive -> Active // Sink VChan is closed, open Sink VChan if a Source VChan is attached to it and is active SourceVChan_type* srcVChan = ((SinkVChan_type*)VChan)->sourceVChan; if (srcVChan && srcVChan->baseClass.isActive) { VChan->isOpen = VChan_Open; if (VChan->VChanStateChangeCBFptr) (*VChan->VChanStateChangeCBFptr) (VChan, VChan->VChanOwner, VChan->isOpen); } // If Sink VChan has a closed active Source VChan, then open the Source VChan if (srcVChan && srcVChan->baseClass.isActive && !srcVChan->baseClass.isOpen) { srcVChan->baseClass.isOpen = VChan_Open; if (srcVChan->baseClass.VChanStateChangeCBFptr) (*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen); } } else { // Active -> Inactive // Close Sink VChan if open if (VChan->isOpen) { VChan->isOpen = VChan_Closed; if (VChan->VChanStateChangeCBFptr) (*VChan->VChanStateChangeCBFptr) (VChan, VChan->VChanOwner, VChan->isOpen); } // If Sink has an open Source VChan and there are no more active Sinks, then close Source VChan SourceVChan_type* srcVChan = ((SinkVChan_type*)VChan)->sourceVChan; if (srcVChan && srcVChan->baseClass.isOpen && !GetNumActiveSinkVChans(srcVChan)) { srcVChan->baseClass.isOpen = VChan_Closed; if (srcVChan->baseClass.VChanStateChangeCBFptr) (*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen); } } break; } }
/* Called after the relocation - use desired console functions */ int console_init_r (void) { device_t *inputdev = NULL, *outputdev = NULL; int i, items = ListNumItems (devlist); #ifdef CONFIG_SPLASH_SCREEN /* suppress all output if splash screen is enabled and we have a bmp to display */ if (getenv("splashimage") != NULL) gd->flags |= GD_FLG_SILENT; #endif /* Scan devices looking for input and output devices */ for (i = 1; (i <= items) && ((inputdev == NULL) || (outputdev == NULL)); i++ ) { device_t *dev = ListGetPtrToItem (devlist, i); if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) { inputdev = dev; } if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) { outputdev = dev; } } /* Initializes output console first */ if (outputdev != NULL) { console_setfile (stdout, outputdev); console_setfile (stderr, outputdev); } /* Initializes input console */ if (inputdev != NULL) { console_setfile (stdin, inputdev); } gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */ #ifndef CFG_CONSOLE_INFO_QUIET /* Print information */ puts ("In: "); if (stdio_devices[stdin] == NULL) { puts ("No input devices available!\n"); } else { printf ("%s\n", stdio_devices[stdin]->name); } puts ("Out: "); if (stdio_devices[stdout] == NULL) { puts ("No output devices available!\n"); } else { printf ("%s\n", stdio_devices[stdout]->name); } puts ("Err: "); if (stdio_devices[stderr] == NULL) { puts ("No error devices available!\n"); } else { printf ("%s\n", stdio_devices[stderr]->name); } #endif /* CFG_CONSOLE_INFO_QUIET */ /* Setting environment variables */ for (i = 0; i < 3; i++) { setenv (stdio_names[i], stdio_devices[i]->name); } #if 0 /* If nothing usable installed, use only the initial console */ if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL)) return (0); #endif return (0); }
SinkVChan_type* GetSinkVChan (SourceVChan_type* srcVChan, size_t sinkIdx) { SinkVChan_type* sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, sinkIdx); return sinkVChan; }