G:/ScriptBasic/source/extensions/t/interface.c

Go to the documentation of this file.

/*
FILE: tools.c

ScriptBasic module with handy functions.

NTLIBS:
UXLIBS:
DWLIBS:
MCLIBS:

*/

#include <stdio.h>
#include "../../basext.h"

besVERSION_NEGOTIATE

  return (int)INTERFACE_VERSION;

besEND

besSUB_START
besEND

besSUB_FINISH
besEND

/*
This function calculates the size in terms of bytes (or characters) of the
variable after the conversion. This is needed to allocate the appropriate
size of STRING variable into which the program can put the serialized data.

The argument vVAR is the variable to be converted and pSt is the support table
pointer.

The return value is the size of the string converted.
*/
static long sersize(VARIABLE vVAR, pSupportTable pSt){
  long i;
  unsigned long size;

  /* get the real variable in case this is a reference variable pointing to
     another variable */
  besDEREFERENCE(vVAR);
  /* undef is stored in one byte that tells this is undef */
  if( vVAR == NULL )return 1;
  switch( TYPE(vVAR) ){
    case VTYPE_ARRAY :
      /* we need 1 byte for the type 'array' and two longs for low and high limits */
      size = 2*sizeof(long)+1;
      for( i = vVAR->ArrayLowLimit ; i <= vVAR->ArrayHighLimit ; i++ ){
        size += sersize(vVAR->Value.aValue[i-vVAR->ArrayLowLimit],pSt);
        }
      return size;
    case VTYPE_LONG: return sizeof(long)+1;
    case VTYPE_DOUBLE: return sizeof(double)+1;
    case VTYPE_STRING: return sizeof(long)+STRLEN(vVAR)+1;
    default: return 0;
    }
  }

static long serconv(VARIABLE vVAR, unsigned char *buf){
  long i;
  unsigned long size;
  unsigned long chunk;

  size = 0;
  if( vVAR == NULL ){
    *buf++ = VTYPE_UNDEF;
    return 1;
    }
  switch( TYPE(vVAR) ){
    case VTYPE_ARRAY :
      *buf++ = VTYPE_ARRAY;
      memcpy(buf,&(vVAR->ArrayLowLimit),sizeof(long));
      buf += sizeof(long);
      memcpy(buf,&(vVAR->ArrayHighLimit),sizeof(long));
      buf += sizeof(long);
      size = 2*sizeof(long)+1;
      for( i = vVAR->ArrayLowLimit ; i <= vVAR->ArrayHighLimit ; i++ ){
        chunk = serconv(vVAR->Value.aValue[i-vVAR->ArrayLowLimit],buf);
        buf += chunk;
        size += chunk;
        }
      return size;
    case VTYPE_LONG:
      *buf++ = VTYPE_LONG;
      memcpy(buf,&(LONGVALUE(vVAR)),sizeof(long));
      return sizeof(long)+1;
    case VTYPE_DOUBLE:
      *buf++ = VTYPE_DOUBLE;
      memcpy(buf,&(DOUBLEVALUE(vVAR)),sizeof(double));
      return sizeof(double)+1;
    case VTYPE_STRING:
      *buf++ = VTYPE_STRING;
      memcpy(buf,&(STRLEN(vVAR)),sizeof(long));
      buf += sizeof(long);
      memcpy(buf,STRINGVALUE(vVAR),STRLEN(vVAR));
      return sizeof(long)+STRLEN(vVAR)+1;
    default: return 0;
    }
  }

static long serconvXML(VARIABLE vVAR, unsigned char *buf,int copy){
  long i;
  unsigned long size;
  unsigned long chunk;
  unsigned char szBuffer[100]; /* just a buffer to store decimal numbers */
#define my_strcpy(a,b) do{if(copy)strcpy(a,b);}while(0)
  size = 0;
  if( vVAR == NULL ){
    my_strcpy(buf,"<U/>");
    buf += 4;
    return 4;
    }
  switch( TYPE(vVAR) ){
    case VTYPE_ARRAY :
      sprintf(szBuffer,"<A l=\"%d\" h=\"%d\">",vVAR->ArrayLowLimit,vVAR->ArrayHighLimit);
      my_strcpy(buf,szBuffer);
      buf += (size=strlen(szBuffer));
      for( i = vVAR->ArrayLowLimit ; i <= vVAR->ArrayHighLimit ; i++ ){
        chunk = serconvXML(vVAR->Value.aValue[i-vVAR->ArrayLowLimit],buf,copy);
        buf += chunk;
        size += chunk;
        }
      my_strcpy(buf,"</A>");
      buf += 4;
      size += 4;
      return size;
    case VTYPE_LONG:
      sprintf(szBuffer,"<I>%d</I>",LONGVALUE(vVAR));
      my_strcpy(buf,szBuffer);
      buf += (size=strlen(szBuffer));
      return size;
    case VTYPE_DOUBLE:
      sprintf(szBuffer,"<R>%f</R>",DOUBLEVALUE(vVAR));
      my_strcpy(buf,szBuffer);
      buf += (size=strlen(szBuffer));
      return size;
    case VTYPE_STRING:
      my_strcpy(buf,"<S>");
      buf += 3;
      size = 3;
      for( i=0 ; i < STRLEN(vVAR) ; i++ ){
        switch( STRINGVALUE(vVAR)[i] ) {
          case ';':  my_strcpy(buf,"&amp;");  buf += 5; size += 5; break;
          case '<':  my_strcpy(buf,"&lt;");   buf += 4; size += 4; break;
          case '>':  my_strcpy(buf,"&gt;");   buf += 4; size += 4; break;
          case '\"': my_strcpy(buf,"&quot;"); buf += 6; size += 6; break;
          default:
            if( (STRINGVALUE(vVAR)[i] < ' ') || (STRINGVALUE(vVAR)[i] > 127 ) ){
              sprintf(szBuffer, "&x%02X;", (unsigned char)(STRINGVALUE(vVAR)[i]) );
              my_strcpy(buf,szBuffer);
              buf  += (chunk=strlen(szBuffer));
              size += chunk;
            }else{
              if(copy)*buf++ = STRINGVALUE(vVAR)[i];
              size++;
            }
          }
        }
      my_strcpy(buf,"</S>");
      buf += 4;
      size += 4;
      return size;
    default: return 0;
    }
  }

static VARIABLE unserconv(pExecuteObject pEo, unsigned char **buf,int *piError){
  long i;
  pSupportTable pSt;
  VARIABLE vRET;
  long ArrayLowLimit,ArrayHighLimit;
  unsigned long StringLen;

  pSt = pEo->pST;
  *piError = COMMAND_ERROR_SUCCESS;
  switch( **buf ){
    case VTYPE_ARRAY :
      (*buf)++;
      memcpy(&ArrayLowLimit,*buf,sizeof(long));
      (*buf) += sizeof(long);
      memcpy(&ArrayHighLimit,*buf,sizeof(long));
      (*buf) += sizeof(long);
      vRET = besNEWARRAY(ArrayLowLimit,ArrayHighLimit);
      if( vRET == NULL ){ *piError = COMMAND_ERROR_MEMORY_LOW; return NULL;}
      for( i = ArrayLowLimit ; i <= ArrayHighLimit ; i++ ){
        vRET->Value.aValue[i-ArrayLowLimit] = unserconv(pEo,buf,piError);
        }
      return vRET;
    case VTYPE_LONG:
      (*buf)++;
      vRET = besNEWLONG;
      if( vRET == NULL ){ *piError = COMMAND_ERROR_MEMORY_LOW; return NULL;}
      memcpy(&(LONGVALUE(vRET)),*buf,sizeof(long));
      (*buf) += sizeof(long);
      return vRET;
    case VTYPE_DOUBLE:
      (*buf)++;
      vRET = besNEWDOUBLE;
      if( vRET == NULL ){ *piError = COMMAND_ERROR_MEMORY_LOW; return NULL;}
      memcpy(&(DOUBLEVALUE(vRET)),*buf,sizeof(double));
      (*buf) += sizeof(double);
      return vRET;
    case VTYPE_STRING:
      (*buf)++;
      memcpy(&StringLen,*buf,sizeof(long));
      (*buf) += sizeof(long);
      vRET = besNEWSTRING(StringLen);
      if( vRET == NULL ){ *piError = COMMAND_ERROR_MEMORY_LOW; return NULL;}
      memcpy(STRINGVALUE(vRET),*buf,StringLen);
      (*buf) += StringLen;
      return vRET;
    case VTYPE_UNDEF:
      (*buf)++;
      return NULL;
    default: *piError = COMMAND_ERROR_ARGUMENT_RANGE;
             return NULL;
    }
  }

besCOMMAND(serialize)
  NODE nItem;
  VARIABLE vARR;
  unsigned long size;

  besASSERT_COMMAND

  /* this is a function and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = besPARAMETERLIST;
  if( ! nItem ){
    RESULT = NULL;
    RETURN;
    }
  vARR = _besEVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;
  size = sersize(vARR,pSt);
  RESULT = besNEWMORTALSTRING(size);
  if( RESULT == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  serconv(vARR,STRINGVALUE(RESULT));
besEND_COMMAND

besCOMMAND(xmlserialize)
  NODE nItem;
  VARIABLE vARR;
  unsigned long size;

  besASSERT_COMMAND

  /* this is a function and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = besPARAMETERLIST;
  if( ! nItem ){
    RESULT = NULL;
    RETURN;
    }
  vARR = _besEVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;
#define XMLSTART "<?xml version=\"1.0\" encoding=\"UTF-8\"?><V>"
#define XMLEND   "</V>"
  size = serconvXML(vARR,NULL,0) + strlen(XMLSTART) + strlen(XMLEND);
  RESULT = besNEWMORTALSTRING(size);
  if( RESULT == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  strcpy(STRINGVALUE(RESULT),XMLSTART);
  serconvXML(vARR,STRINGVALUE(RESULT)+strlen(XMLSTART),1);
  strcat(STRINGVALUE(RESULT),XMLEND);
besEND_COMMAND

besFUNCTION(unserialize)
  VARIABLE Argument;
  LEFTVALUE Lval;
  int iError;
  unsigned long __refcount_;
  unsigned char *s;

  Argument = besARGUMENT(1);
  besLEFTVALUE(Argument,Lval);
  Argument = besARGUMENT(2);
  besDEREFERENCE(Argument);
  Argument = besCONVERT2STRING(Argument);
  s = STRINGVALUE(Argument);
  if( Lval ){
    besRELEASE(*Lval);
    *Lval = unserconv(pSt->pEo,&s,&iError);
    }
  return iError;
besEND

besFUNCTION(savestring)
  unsigned char *pszString;
  char *pszFileName;
  unsigned long cbString;
  FILE *fp;
  VARIABLE Argumentum;

  if( besARGNR < 2 )return COMMAND_ERROR_MANDARG;

  Argumentum = besARGUMENT(1);
  besDEREFERENCE(Argumentum);
  Argumentum = besCONVERT2STRING(Argumentum);
  besCONVERT2ZCHAR(Argumentum,pszFileName);

  Argumentum = besARGUMENT(2);
  besDEREFERENCE(Argumentum);
  Argumentum = besCONVERT2STRING(Argumentum);

  pszString = STRINGVALUE(Argumentum);
  cbString = STRLEN(Argumentum);
  fp = besHOOK_FOPEN(pszFileName,"wb");
  if( fp == NULL ){
    besFREE(pszFileName);
    return COMMAND_ERROR_FILE_CANNOT_BE_OPENED;
    }
  besHOOK_FWRITE(pszString,1,cbString,fp);
  besHOOK_FCLOSE(fp);

  besFREE(pszFileName);

besEND

besFUNCTION(loadstring)
  char *pszFileName;
  unsigned long cbString;
  FILE *fp;
  VARIABLE Argumentum;

  if( besARGNR < 1 )return COMMAND_ERROR_MANDARG;

  Argumentum = besARGUMENT(1);
  besDEREFERENCE(Argumentum);
  Argumentum = besCONVERT2STRING(Argumentum);
  besCONVERT2ZCHAR(Argumentum,pszFileName);

  cbString = besHOOK_SIZE(pszFileName);
  besRETURNVALUE = besNEWMORTALSTRING(cbString);
  if( besRETURNVALUE == NULL ){
    besFREE(pszFileName);
    return COMMAND_ERROR_MEMORY_LOW;
    }

  fp = besHOOK_FOPEN(pszFileName,"rb");
  if( fp == NULL ){
    besFREE(pszFileName);
    return COMMAND_ERROR_FILE_CANNOT_BE_OPENED;
    }
  besHOOK_FREAD(STRINGVALUE(besRETURNVALUE),1,cbString,fp);
  besHOOK_FCLOSE(fp);

  besFREE(pszFileName);

besEND

besFUNCTION(md5fun)
  VARIABLE Argument;
  MD5_CTX Md5Context;

  besASSERT_FUNCTION

  /* md5() or md5(undef) is undef */
  besRETURNVALUE = NULL;
  if( besARGNR < 1 )return COMMAND_ERROR_SUCCESS;
  Argument = besARGUMENT(1);
  if( Argument == NULL )return COMMAND_ERROR_SUCCESS;
  besDEREFERENCE(Argument);

  besALLOC_RETURN_STRING(16);

  Argument = besCONVERT2STRING(Argument);

  besMD5INIT( &Md5Context);
  besMD5UPDATE(&Md5Context,STRINGVALUE(Argument),STRLEN(Argument));

  besMD5FINAL(STRINGVALUE(besRETURNVALUE),&Md5Context);

besEND

besCOMMAND(md5serialize)
  NODE nItem;
  VARIABLE vARR;
  unsigned long size;
  MD5_CTX Md5Context;

  besASSERT_COMMAND

  /* this is a function and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  nItem = besPARAMETERLIST;
  if( ! nItem ){
    RESULT = NULL;
    RETURN;
    }
  vARR = _besEVALUATEEXPRESSION_A(CAR(nItem));
  ASSERTOKE;
  size = sersize(vARR,pSt);
  RESULT = besNEWMORTALSTRING(size + 16);
  if( RESULT == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  serconv(vARR,STRINGVALUE(RESULT));
  besMD5INIT( &Md5Context);
  besMD5UPDATE(&Md5Context,STRINGVALUE(RESULT),size);

  besMD5FINAL(STRINGVALUE(RESULT)+size,&Md5Context);

besEND_COMMAND

besFUNCTION(md5unserialize)
  VARIABLE Argument;
  LEFTVALUE Lval;
  int iError;
  unsigned long __refcount_;
  unsigned char *s;
  MD5_CTX Md5Context;
  unsigned char MD5[16];

  Argument = besARGUMENT(1);
  besLEFTVALUE(Argument,Lval);
  Argument = besARGUMENT(2);
  besDEREFERENCE(Argument);
  Argument = besCONVERT2STRING(Argument);
  s = STRINGVALUE(Argument);
  besMD5INIT( &Md5Context);
  besMD5UPDATE(&Md5Context,s,STRLEN(Argument)-16);
  besMD5FINAL(MD5,&Md5Context);
  if( memcmp(s+STRLEN(Argument)-16,MD5,16) )return COMMAND_ERROR_ARGUMENT_RANGE;

  if( Lval ){
    besRELEASE(*Lval);
    *Lval = unserconv(pSt->pEo,&s,&iError);
    }
  return iError;
besEND

besFUNCTION(toolExit)
  VARIABLE Argument;
  long retcode;

  besASSERT_FUNCTION;
  /* md5() or md5(undef) is undef */
  besRETURNVALUE = NULL;
  if( besARGNR < 1 )return COMMAND_ERROR_SUCCESS;
  Argument = besARGUMENT(1);
  if( Argument == NULL )return COMMAND_ERROR_SUCCESS;
  besDEREFERENCE(Argument);
  retcode = besGETLONGVALUE(Argument);
  exit(retcode);
besEND

---