/[svn]/liblscp/trunk/src/common.c

Diff of /liblscp/trunk/src/common.c

Parent Directory | Revision Log | View Patch Patch

-revision 132 by capela,
Fri Jun 18 14:19:19 2004 UTC
+revision 171 by capela,
Mon Jul  5 16:26:44 2004 UTC
 Line 1
- // client.c
+ // common.c
  //
  /****************************************************************************
     liblscp - LinuxSampler Control Protocol API
 Line 25
  #include <ctype.h>
- // Chunk size magic:
+ // Split chunk size magic:
- // LSCP_SPLIT_CHUNK1 = 2 ^ LSCP_SPLIT_CHUNK2
+ // LSCP_SPLIT_CHUNK1 := 2 ^ LSCP_SPLIT_CHUNK2
  #define LSCP_SPLIT_CHUNK1   4
  #define LSCP_SPLIT_CHUNK2   2
  // Chunk size legal calculator.
 Line 419 
 int lscp_isplit_size ( int *piSplit )
  #endif // LSCP_ISPLIT_COUNT
+ // Split a string into a null terminated array of parameter items.
+ lscp_param_t *lscp_psplit_create ( const char *pszCsv, const char *pszSeps1, const char *pszSeps2 )
+ {
+     char *pszHead, *pch;
+     int iSize, i, j, cchSeps1, cchSeps2;
+     lscp_param_t *ppSplit, *ppNewSplit;
+     pszHead = strdup(pszCsv);
+     if (pszHead == NULL)
+         return NULL;
+     iSize = LSCP_SPLIT_CHUNK1;
+     ppSplit = (lscp_param_t *) malloc(iSize * sizeof(lscp_param_t));
+     if (ppSplit == NULL) {
+         free(pszHead);
+         return NULL;
+     }
+     cchSeps1 = strlen(pszSeps1);
+     cchSeps2 = strlen(pszSeps2);
+     i = 0;
+     while ((pch = strpbrk(pszHead, pszSeps1)) != NULL) {
+         ppSplit[i].key = pszHead;
+         pszHead = pch + cchSeps1;
+         *pch = (char) 0;
+         ppSplit[i].value = lscp_unquote(&pszHead, 0);
+         if ((pch = strpbrk(pszHead, pszSeps2)) != NULL) {
+             pszHead = pch + cchSeps2;
+             *pch = (char) 0;
+         }
+         if (++i >= iSize) {
+             iSize += LSCP_SPLIT_CHUNK1;
+             ppNewSplit = (lscp_param_t *) malloc(iSize * sizeof(lscp_param_t));
+             if (ppNewSplit) {
+                 for (j = 0; j < i; j++) {
+                     ppNewSplit[j].key   = ppSplit[j].key;
+                     ppNewSplit[j].value = ppSplit[j].value;
+                 }
+                 free(ppSplit);
+                 ppSplit = ppNewSplit;
+             }
+         }
+     }
+     if (i < 1)
+         free(pszHead);
+     for ( ; i < iSize; i++) {
+         ppSplit[i].key   = NULL;
+         ppSplit[i].value = NULL;
+     }
+     return ppSplit;
+ }
+ // Destroy a parameter list array.
+ void lscp_psplit_destroy ( lscp_param_t *ppSplit )
+ {
+     if (ppSplit && ppSplit[0].key)
+         free(ppSplit[0].key);
+     if (ppSplit)
+         free(ppSplit);
+ }
+ #ifdef LSCP_PSPLIT_COUNT
+ // Compute a parameter list valid item count.
+ int lscp_psplit_count ( lscp_param_t *ppSplit )
+ {
+     int i = 0;
+     while (ppSplit && ppSplit[i].key)
+         i++;
+     return i;
+ }
+ // Compute a parameter list size.
+ int lscp_psplit_size ( lscp_param_t *ppSplit )
+ {
+     return LSCP_SPLIT_SIZE(lscp_psplit_count(ppSplit));
+ }
+ #endif // LSCP_PSPLIT_COUNT
+ // Allocate a parameter list, optionally copying an existing one.
+ void lscp_plist_alloc (lscp_param_t **ppList)
+ {
+     lscp_param_t *pParams;
+     int iSize, i;
+     if (ppList) {
+         iSize = LSCP_SPLIT_CHUNK1;
+         pParams = (lscp_param_t *) malloc(iSize * sizeof(lscp_param_t));
+         if (pParams) {
+             for (i = 0 ; i < iSize; i++) {
+                 pParams[i].key   = NULL;
+                 pParams[i].value = NULL;
+             }
+         }
+         *ppList = pParams;
+     }
+ }
+ // Destroy a parameter list, including all it's contents.
+ void lscp_plist_free ( lscp_param_t **ppList )
+ {
+     lscp_param_t *pParams;
+     int i;
+     if (ppList) {
+         if (*ppList) {
+             pParams = *ppList;
+             for (i = 0; pParams && pParams[i].key; i++) {
+                 free(pParams[i].key);
+                 free(pParams[i].value);
+             }
+             free(pParams);
+         }
+         *ppList = NULL;
+     }
+ }
+ // Add an item to a parameter list, growing it as fit.
+ void lscp_plist_append ( lscp_param_t **ppList, const char *pszKey, const char *pszValue )
+ {
+     lscp_param_t *pParams;
+     lscp_param_t *pNewParams;
+     int iSize, iNewSize;
+     int i = 0;
+     if (ppList && *ppList) {
+         pParams = *ppList;
+         while (pParams[i].key)
+             i++;
+         iSize = LSCP_SPLIT_SIZE(i);
+         pParams[i].key   = strdup(pszKey);
+         pParams[i].value = strdup(pszValue);
+         if (++i >= iSize) {
+             iNewSize   = iSize + LSCP_SPLIT_CHUNK1;
+             pNewParams = (lscp_param_t *) malloc(iNewSize * sizeof(lscp_param_t));
+             for (i = 0; i < iSize; i++) {
+                 pParams[i].key   = pParams[i].key;
+                 pParams[i].value = pParams[i].value;
+             }
+             for ( ; i < iNewSize; i++) {
+                 pNewParams[i].key   = NULL;
+                 pNewParams[i].value = NULL;
+             }
+             free(pParams);
+             *ppList = pNewParams;
+         }
+     }
+ }
+ // Compute a parameter list valid item count.
+ int lscp_plist_count ( lscp_param_t **ppList )
+ {
+     lscp_param_t *pParams;
+     int i = 0;
+     if (ppList && *ppList) {
+         pParams = *ppList;
+         while (pParams[i].key)
+             i++;
+     }
+     return i;
+ }
+ // Compute the legal parameter list size.
+ int lscp_plist_size ( lscp_param_t **ppList )
+ {
+     return LSCP_SPLIT_SIZE(lscp_plist_count(ppList));
+ }
  //-------------------------------------------------------------------------
  // Engine info struct helper functions.
-Line 492 
 void lscp_driver_info_reset ( lscp_drive
+Line 674 
 void lscp_driver_info_reset ( lscp_drive
  }
+ //-------------------------------------------------------------------------
+ // Device info struct functions.
+ void lscp_device_info_init ( lscp_device_info_t *pDeviceInfo )
+ {
+     pDeviceInfo->driver = NULL;
+     lscp_plist_alloc(&(pDeviceInfo->params));
+ }
+ void lscp_device_info_reset ( lscp_device_info_t *pDeviceInfo )
+ {
+     if (pDeviceInfo->driver)
+         free(pDeviceInfo->driver);
+     lscp_plist_free(&(pDeviceInfo->params));
+     lscp_device_info_init(pDeviceInfo);
+ }
+ //-------------------------------------------------------------------------
+ // Device channel/port info struct functions.
+ void lscp_device_port_info_init ( lscp_device_port_info_t *pDevicePortInfo )
+ {
+     pDevicePortInfo->name = NULL;
+     lscp_plist_alloc(&(pDevicePortInfo->params));
+ }
+ void lscp_device_port_info_reset ( lscp_device_port_info_t *pDevicePortInfo )
+ {
+     if (pDevicePortInfo->name)
+         free(pDevicePortInfo->name);
+     lscp_plist_free(&(pDevicePortInfo->params));
+     lscp_device_port_info_init(pDevicePortInfo);
+ }
+ //-------------------------------------------------------------------------
+ // Parameter struct helper functions.
+ void lscp_param_info_init ( lscp_param_info_t *pParamInfo )
+ {
+     pParamInfo->type          = LSCP_TYPE_NONE;
+     pParamInfo->description   = NULL;
+     pParamInfo->mandatory     = 0;
+     pParamInfo->fix           = 0;
+     pParamInfo->multiplicity  = 0;
+     pParamInfo->depends       = NULL;
+     pParamInfo->defaultv      = NULL;
+     pParamInfo->range_min     = NULL;
+     pParamInfo->range_max     = NULL;
+     pParamInfo->possibilities = NULL;
+ }
+ void lscp_param_info_reset ( lscp_param_info_t *pParamInfo )
+ {
+     if (pParamInfo->description)
+         free(pParamInfo->description);
+     lscp_szsplit_destroy(pParamInfo->depends);
+     if (pParamInfo->defaultv)
+         free(pParamInfo->defaultv);
+     if (pParamInfo->range_min)
+         free(pParamInfo->range_min);
+     if (pParamInfo->range_max)
+         free(pParamInfo->range_max);
+     lscp_szsplit_destroy(pParamInfo->possibilities);
+     lscp_param_info_init(pParamInfo);
+ }
+ //-------------------------------------------------------------------------
+ // Concatenate a parameter list (key='value'...) into a string,
+ // appending a crlf terminator.
+ int lscp_param_concat ( char *pszBuffer, int cchMaxBuffer, lscp_param_t *pParams )
+ {
+     int cchBuffer, cchParam, i;
+     if (pszBuffer == NULL || pParams == NULL)
+         return 0;
+     cchBuffer = strlen(pszBuffer);
+     for (i = 0; pParams[i].key && pParams[i].value; i++) {
+         cchParam = strlen(pParams[i].key) + strlen(pParams[i].value) + 4;
+         if (cchBuffer + cchParam + 2 < cchMaxBuffer) {
+             sprintf(pszBuffer + cchBuffer, " %s='%s'", pParams[i].key, pParams[i].value);
+             cchBuffer += cchParam;
+         }
+     }
+     if (cchBuffer + 2 < cchMaxBuffer) {
+         pszBuffer[cchBuffer++] = '\r';
+         pszBuffer[cchBuffer++] = '\n';
+     }
+     return cchBuffer;
+ }
  // end of common.c

 Legend:



Removed from v.132
 


changed lines


 
Added in v.171
 Legend:



Removed from v.132
 


changed lines


 
Added in v.171
-Removed from v.132
+Added in v.171

	ViewVC Help
Powered by ViewVC