linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- changed formatValue for custom formats

Browse Source 
- changed internalID of HipadabaCallbacks to void*
This commit is contained in:
zolliker
2008-01-18 07:29:59 +00:00
parent 3cd46c4c83
commit 07ad4ab978
1 changed files with 49 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
sicshipadaba.c
View File

@ -71,7 +71,7 @@ pHdbCallback MakeCheckPermissionCallback(int priv){
return NULL; return NULL;
} }
*testPriv = priv; *testPriv = priv;
return MakeHipadabaCallback(SICSCheckPermissionCallback, testPriv,free,-1,-1); return MakeHipadabaCallback(SICSCheckPermissionCallback, testPriv,free,-1,NULL);
} }
/*-------------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------------*/
static int SICSSetUpdateCallback(void *userData, void *callData, pHdb node, static int SICSSetUpdateCallback(void *userData, void *callData, pHdb node,
@ -80,7 +80,7 @@ static int SICSSetUpdateCallback(void *userData, void *callData, pHdb node,
} }
/*-------------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------------*/
pHdbCallback MakeSetUpdateCallback(){ pHdbCallback MakeSetUpdateCallback(){
return MakeHipadabaCallback(SICSSetUpdateCallback, NULL,NULL,-1,-1); return MakeHipadabaCallback(SICSSetUpdateCallback, NULL,NULL,-1,NULL);
} }
/*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/
static int SICSReadOnlyCallback(void *userData, void *callData, pHdb node, static int SICSReadOnlyCallback(void *userData, void *callData, pHdb node,
@ -96,7 +96,7 @@ static int SICSReadOnlyCallback(void *userData, void *callData, pHdb node,
} }
/*-------------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------------*/
pHdbCallback MakeReadOnlyCallback(){ pHdbCallback MakeReadOnlyCallback(){
return MakeHipadabaCallback(SICSReadOnlyCallback, NULL,NULL,-1,-1); return MakeHipadabaCallback(SICSReadOnlyCallback, NULL,NULL,-1,NULL);
} }
/*-------------------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------------------*/
static int SICSDriveCallback(void *userData, void *callData, pHdb node, static int SICSDriveCallback(void *userData, void *callData, pHdb node,
@ -118,7 +118,7 @@ static int SICSDriveCallback(void *userData, void *callData, pHdb node,
} }
/*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/
pHdbCallback MakeSICSDriveCallback(void *sicsObject){ pHdbCallback MakeSICSDriveCallback(void *sicsObject){
return MakeHipadabaCallback(SICSDriveCallback, sicsObject,NULL,-1,-1); return MakeHipadabaCallback(SICSDriveCallback, sicsObject,NULL,-1,NULL);
} }
/*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/
static int SICSReadDriveCallback(void *userData, void *callData, pHdb node, static int SICSReadDriveCallback(void *userData, void *callData, pHdb node,
@ -181,11 +181,11 @@ static int SICSFuncCallback(void *userData, void *callData, pHdb node,
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
pHdbCallback MakeSICSFuncCallback(void *obj){ pHdbCallback MakeSICSFuncCallback(void *obj){
return MakeHipadabaCallback(SICSFuncCallback, obj,NULL,-1,-1); return MakeHipadabaCallback(SICSFuncCallback, obj,NULL,-1,NULL);
} }
/*--------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------*/
pHdbCallback MakeSICSReadDriveCallback(void *sicsObject){ pHdbCallback MakeSICSReadDriveCallback(void *sicsObject){
return MakeHipadabaCallback(SICSReadDriveCallback, sicsObject,NULL,-1,-1); return MakeHipadabaCallback(SICSReadDriveCallback, sicsObject,NULL,-1,NULL);
} }
/*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/
typedef struct { typedef struct {
@ -341,7 +341,7 @@ static int SICSNotifyCallback(void *userData, void *callData, pHdb node,
} }
} }
if(v.arrayLength < 100){ if(v.arrayLength < 100){
printedData = formatValue(v); printedData = formatValue(v, node);
if(pPath == NULL || printedData == NULL || result == NULL){ if(pPath == NULL || printedData == NULL || result == NULL){
SCWriteInContext(cbInfo->pCon,"ERROR: out of memory formatting data" , SCWriteInContext(cbInfo->pCon,"ERROR: out of memory formatting data" ,
eEvent,cbInfo->context); eEvent,cbInfo->context);
@ -377,7 +377,7 @@ pHdbCallback MakeNotifyCallback(SConnection *pCon, int id){
} }
cbInfo->pCon = pCon; cbInfo->pCon = pCon;
cbInfo->context = SCGetContext(pCon); cbInfo->context = SCGetContext(pCon);
return MakeHipadabaCallback(SICSNotifyCallback, cbInfo,free,id,pCon->ident); return MakeHipadabaCallback(SICSNotifyCallback, cbInfo,free,id,pCon);
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int TreeChangeCallback(void *userData, void *callData, pHdb node, static int TreeChangeCallback(void *userData, void *callData, pHdb node,
@ -414,7 +414,7 @@ pHdbCallback MakeTreeChangeCallback(SConnection *pCon, int id){
} }
cbInfo->pCon = pCon; cbInfo->pCon = pCon;
cbInfo->context = SCGetContext(pCon); cbInfo->context = SCGetContext(pCon);
return MakeHipadabaCallback(TreeChangeCallback, cbInfo,free,id,pCon->ident); return MakeHipadabaCallback(TreeChangeCallback, cbInfo,free,id,pCon);
} }
/*----------------------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------------------*/
static int SICSScriptWriteCallback(void *userData, void *callData, pHdb node, static int SICSScriptWriteCallback(void *userData, void *callData, pHdb node,
@ -430,7 +430,7 @@ static int SICSScriptWriteCallback(void *userData, void *callData, pHdb node,
assert(command != NULL && pCon != NULL); assert(command != NULL && pCon != NULL);
newVal = formatValue(v); newVal = formatValue(v, node);
if(newVal == NULL){ if(newVal == NULL){
SCWrite(pCon,"ERROR: out of memory setting parameter",eError); SCWrite(pCon,"ERROR: out of memory setting parameter",eError);
return 0; return 0;
@ -459,7 +459,7 @@ static int SICSScriptWriteCallback(void *userData, void *callData, pHdb node,
} }
/*---------------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------------*/
static pHdbCallback MakeSICSWriteScriptCallback(char *script){ static pHdbCallback MakeSICSWriteScriptCallback(char *script){
return MakeHipadabaCallback(SICSScriptWriteCallback, strdup(script),free,-1,-1); return MakeHipadabaCallback(SICSScriptWriteCallback, strdup(script),free,-1,NULL);
} }
/*----------------------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------------------*/
static int SICSScriptReadCallback(void *userData, void *callData, pHdb node, static int SICSScriptReadCallback(void *userData, void *callData, pHdb node,
@ -519,7 +519,7 @@ static int SICSScriptReadCallback(void *userData, void *callData, pHdb node,
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
static pHdbCallback MakeSICSReadScriptCallback(char *script){ static pHdbCallback MakeSICSReadScriptCallback(char *script){
return MakeHipadabaCallback(SICSScriptReadCallback, strdup(script), return MakeHipadabaCallback(SICSScriptReadCallback, strdup(script),
free,-1,-1); free,-1,NULL);
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
typedef struct { typedef struct {
@ -560,7 +560,7 @@ pHdbCallback MakeIntRangeCallback(int min, int max){
range->min = min; range->min = min;
range->max = max; range->max = max;
return MakeHipadabaCallback(SICSIntRangeCallback, range, return MakeHipadabaCallback(SICSIntRangeCallback, range,
free,-1,-1); free,-1,NULL);
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
typedef struct { typedef struct {
@ -601,7 +601,7 @@ pHdbCallback MakeFloatRangeCallback(double min, double max){
range->min = min; range->min = min;
range->max = max; range->max = max;
return MakeHipadabaCallback(SICSFloatRangeCallback, range, return MakeHipadabaCallback(SICSFloatRangeCallback, range,
free,-1,-1); free,-1,NULL);
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int MemReadCallback(void *userData, void *callData, pHdb node, static int MemReadCallback(void *userData, void *callData, pHdb node,
@ -649,12 +649,12 @@ static int MemGenReadCallback(void *userData, void *callData, pHdb node,
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
pHdbCallback MakeMemGenReadCallback(void *address){ pHdbCallback MakeMemGenReadCallback(void *address){
return MakeHipadabaCallback(MemReadCallback, address, return MakeHipadabaCallback(MemReadCallback, address,
NULL,-1,-1); NULL,-1,NULL);
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
pHdbCallback MakeMemReadCallback(float *address){ pHdbCallback MakeMemReadCallback(float *address){
return MakeHipadabaCallback(MemReadCallback, address, return MakeHipadabaCallback(MemReadCallback, address,
NULL,-1,-1); NULL,-1,NULL);
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static int MemSetCallback(void *userData, void *callData, pHdb node, static int MemSetCallback(void *userData, void *callData, pHdb node,
@ -707,12 +707,12 @@ static int MemGenSetCallback(void *userData, void *callData, pHdb node,
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
pHdbCallback MakeMemSetCallback(float *address){ pHdbCallback MakeMemSetCallback(float *address){
return MakeHipadabaCallback(MemSetCallback, address, return MakeHipadabaCallback(MemSetCallback, address,
NULL,-1,-1); NULL,-1,NULL);
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
pHdbCallback MakeMemGenSetCallback(void *address){ pHdbCallback MakeMemGenSetCallback(void *address){
return MakeHipadabaCallback(MemSetCallback, address, return MakeHipadabaCallback(MemSetCallback, address,
NULL,-1,-1); NULL,-1,NULL);
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
static void killHdbValue(void *pData){ static void killHdbValue(void *pData){
@ -762,7 +762,7 @@ pHdbCallback MakeIntFixedCallback(int *data, int length){
} }
memcpy(v->v.intArray,data,length*sizeof(int)); memcpy(v->v.intArray,data,length*sizeof(int));
return MakeHipadabaCallback(SICSIntFixedCallback, v, return MakeHipadabaCallback(SICSIntFixedCallback, v,
killHdbValue,-1,-1); killHdbValue,-1,NULL);
} }
/*============= Parameter Creation ===========================================*/ /*============= Parameter Creation ===========================================*/
pHdb MakeSICSHdbPar(char *name, int priv, hdbValue v){ pHdb MakeSICSHdbPar(char *name, int priv, hdbValue v){
@ -1236,7 +1236,7 @@ int ProcessSICSHdbPar(pHdb root, SConnection *pCon,
if(status != 1){ if(status != 1){
return 0; return 0;
} }
parData = formatValue(input); parData = formatValue(input, parNode);
if(parData == NULL){ if(parData == NULL){
SCWrite(pCon,"ERROR: out of memory reading parameter data",eError); SCWrite(pCon,"ERROR: out of memory reading parameter data",eError);
return 0; return 0;
@ -1263,7 +1263,7 @@ void PrintSICSParList(pHdb node, SConnection *pCon, char *prefix){
while(child != NULL){ while(child != NULL){
if(child->value.dataType != HIPNONE){ if(child->value.dataType != HIPNONE){
GetHipadabaPar(child,&v,pCon); GetHipadabaPar(child,&v,pCon);
value = formatValue(child->value); value = formatValue(child->value, child);
if(value != NULL){ if(value != NULL){
SCPrintf(pCon,eValue,"%s%s = %s", prefix, child->name, SCPrintf(pCon,eValue,"%s%s = %s", prefix, child->name,
GetCharArray(value)); GetCharArray(value));
@ -1288,7 +1288,7 @@ void SaveSICSHipadaba(FILE *fd, pHdb node, char *prefix){
currentChild = node->child; currentChild = node->child;
while(currentChild != NULL){ while(currentChild != NULL){
if(currentChild->value.dataType != HIPNONE && !isSICSHdbRO(currentChild)){ if(currentChild->value.dataType != HIPNONE && !isSICSHdbRO(currentChild)){
data = formatValue(currentChild->value); data = formatValue(currentChild->value, currentChild);
if(data != NULL){ if(data != NULL){
fprintf(fd,"%s%s %s\n", prefix, currentChild->name, GetCharArray(data)); fprintf(fd,"%s%s %s\n", prefix, currentChild->name, GetCharArray(data));
DeleteDynString(data); DeleteDynString(data);
@ -1311,10 +1311,11 @@ void SaveSICSHipadaba(FILE *fd, pHdb node, char *prefix){
} }
} }
/*================ value helpers ============================================*/ /*================ value helpers ============================================*/
pDynString formatValue(hdbValue v){ pDynString formatValue(hdbValue v, pHdb node){
pDynString result = NULL; pDynString result = NULL;
int i; int i;
char number[30]; char number[30];
char format[16];
result = CreateDynString(64,64); result = CreateDynString(64,64);
if(result == NULL){ if(result == NULL){
@ -1328,7 +1329,11 @@ pDynString formatValue(hdbValue v){
DynStringCopy(result,number); DynStringCopy(result,number);
break; break;
case HIPFLOAT: case HIPFLOAT:
snprintf(number,30,"%12.4f", v.v.doubleValue); if (GetHdbProperty(node, "fmt", format, sizeof format -1)) {
snprintf(number,30,format, v.v.doubleValue);
} else {
snprintf(number,30,"%12.4f", v.v.doubleValue);
}
DynStringCopy(result,number); DynStringCopy(result,number);
break; break;
case HIPTEXT: case HIPTEXT:
@ -1343,8 +1348,13 @@ pDynString formatValue(hdbValue v){
break; break;
case HIPFLOATAR: case HIPFLOATAR:
case HIPFLOATVARAR: case HIPFLOATVARAR:
if (!GetHdbProperty(node, "fmt", format+1, sizeof format -2)) {
format[0]=' ';
} else {
strcpy(format, " %12.4f");
}
for(i = 0; i < v.arrayLength; i++){ for(i = 0; i < v.arrayLength; i++){
snprintf(number,30," %12.4f", v.v.floatArray[i]); snprintf(number,30,format, v.v.floatArray[i]);
DynStringConcat(result,number); DynStringConcat(result,number);
} }
break; break;
@ -1546,7 +1556,8 @@ static int MakeHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
pHdb parent = NULL; pHdb parent = NULL;
pHdb child = NULL; pHdb child = NULL;
char buffer[512], buffer2[512]; char buffer[512], buffer2[512];
hdbValue val;
if(!SCMatchRights(pCon,usMugger)){ if(!SCMatchRights(pCon,usMugger)){
return 0; return 0;
} }
@ -1603,7 +1614,9 @@ static int MakeHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
return 0; return 0;
} }
if(type != HIPNONE){ if(type != HIPNONE){
child = MakeSICSHdbPar(pPtr, priv, makeHdbValue(type,length)); val = makeHdbValue(type,length);
child = MakeSICSHdbPar(pPtr, priv, val);
ReleaseHdbValue(&val);
} else { } else {
child = MakeHipadabaNode(pPtr,type,length); child = MakeHipadabaNode(pPtr,type,length);
} }
@ -1940,7 +1953,7 @@ static int GetHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
} }
memset(&newValue,0,sizeof(hdbValue)); memset(&newValue,0,sizeof(hdbValue));
GetHipadabaPar(targetNode, &newValue, pCon); GetHipadabaPar(targetNode, &newValue, pCon);
parData = formatValue(newValue); parData = formatValue(newValue, targetNode);
if(parData == NULL){ if(parData == NULL){
SCWrite(pCon,"ERROR: out of memory formatting data",eError); SCWrite(pCon,"ERROR: out of memory formatting data",eError);
return 0; return 0;
@ -1981,7 +1994,7 @@ static int GetHdbVal(SConnection *pCon, SicsInterp *pSics, void *pData,
} }
memset(&newValue,0,sizeof(hdbValue)); memset(&newValue,0,sizeof(hdbValue));
GetHipadabaPar(targetNode, &newValue, pCon); GetHipadabaPar(targetNode, &newValue, pCon);
parData = formatValue(newValue); parData = formatValue(newValue, targetNode);
if(parData == NULL){ if(parData == NULL){
SCWrite(pCon,"ERROR: out of memory formatting data",eError); SCWrite(pCon,"ERROR: out of memory formatting data",eError);
return 0; return 0;
@ -2056,7 +2069,7 @@ static int HdbNodeVal(SConnection *pCon, SicsInterp *pSics, void *pData,
} }
memset(&newValue,0,sizeof(hdbValue)); memset(&newValue,0,sizeof(hdbValue));
GetHipadabaPar(targetNode, &newValue, pCon); GetHipadabaPar(targetNode, &newValue, pCon);
parData = formatValue(newValue); parData = formatValue(newValue, targetNode);
if(parData == NULL){ if(parData == NULL){
SCWrite(pCon,"ERROR: out of memory formatting data",eError); SCWrite(pCon,"ERROR: out of memory formatting data",eError);
return 0; return 0;
@ -2122,7 +2135,7 @@ static pDynString formatJSONList(pHdb node){
DynStringConcat(result,current->name); DynStringConcat(result,current->name);
DynStringConcat(result,"\""); DynStringConcat(result,"\"");
if(current->value.dataType != HIPNONE){ if(current->value.dataType != HIPNONE){
data = formatValue(current->value); data = formatValue(current->value, current);
if(data != NULL){ if(data != NULL){
DynStringConcat(result,": "); DynStringConcat(result,": ");
DynStringConcat(result,GetCharArray(data)); DynStringConcat(result,GetCharArray(data));
@ -2155,7 +2168,7 @@ static pDynString formatListWithVal(pHdb node){
while(current != NULL){ while(current != NULL){
if(current->value.dataType != HIPNONE){ if(current->value.dataType != HIPNONE){
DynStringConcat(result,current->name); DynStringConcat(result,current->name);
data = formatValue(current->value); data = formatValue(current->value, current);
if(data != NULL){ if(data != NULL){
DynStringConcat(result," = "); DynStringConcat(result," = ");
DynStringConcat(result,GetCharArray(data)); DynStringConcat(result,GetCharArray(data));
@ -2437,7 +2450,7 @@ static int ChainHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
return 0; return 0;
} }
kalle = MakeHipadabaCallback(ChainCallback,slave, NULL, -1,-1); kalle = MakeHipadabaCallback(ChainCallback,slave, NULL, -1,NULL);
if(kalle == NULL){ if(kalle == NULL){
SCWrite(pCon,"ERROR: out of memory creating callback",eError); SCWrite(pCon,"ERROR: out of memory creating callback",eError);
return 0; return 0;
@ -2527,7 +2540,7 @@ static int CommandSetCallback(void *userData, void *callData, pHdb node,
DynStringConcat(cmd," "); DynStringConcat(cmd," ");
current = node->child; current = node->child;
while(current != NULL){ while(current != NULL){
par = formatValue(current->value); par = formatValue(current->value, current);
if(par != NULL){ if(par != NULL){
DynStringConcat(cmd, GetCharArray(par)); DynStringConcat(cmd, GetCharArray(par));
DynStringConcat(cmd," "); DynStringConcat(cmd," ");
@ -2597,14 +2610,14 @@ static int SicsCommandNode(SConnection *pCon, SicsInterp *pSics, void *pData,
node->value.arrayLength = strlen(argv[2]); node->value.arrayLength = strlen(argv[2]);
SetHdbProperty(node,"sicscommand", argv[2]); SetHdbProperty(node,"sicscommand", argv[2]);
kalle = MakeHipadabaCallback(CommandSetCallback,NULL, NULL, -1,-1); kalle = MakeHipadabaCallback(CommandSetCallback,NULL, NULL, -1,NULL);
if(kalle == NULL){ if(kalle == NULL){
SCWrite(pCon,"ERROR: out of memory in hcommand",eError); SCWrite(pCon,"ERROR: out of memory in hcommand",eError);
return 0; return 0;
} }
AppendHipadabaCallback(node,HCBSET, kalle); AppendHipadabaCallback(node,HCBSET, kalle);
kalle = MakeHipadabaCallback(CommandGetCallback,NULL, NULL, -1,-1); kalle = MakeHipadabaCallback(CommandGetCallback,NULL, NULL, -1,NULL);
if(kalle == NULL){ if(kalle == NULL){
SCWrite(pCon,"ERROR: out of memory in hcommand",eError); SCWrite(pCon,"ERROR: out of memory in hcommand",eError);
return 0; return 0;