home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1994 #1 / monster.zip / monster / MAGAZINE / DDJ9309.ZIP / NETSQL.ZIP / BTRCNVT.CPP < prev    next >
C/C++ Source or Header  |  1993-04-30  |  11KB  |  438 lines
  1. /*-----------------------------------------------------------------------
  2.  
  3. 07/28/92  DR  Add support for BFTYP_TRSIGN type.
  4.  
  5. 08/04/92  DR  Add support for removing NULLS from LSTRING.
  6. -----------------------------------------------------------------------*/
  7.  
  8.  
  9. #include "stdio.h"
  10. #include "stdlib.h"
  11. #include "string.h"
  12. #include "bfile.h"
  13. #include "btrieve.h"
  14. extern "C" {
  15. #include "realcnvt.h"
  16. };
  17.  
  18. #define EOS '\0'
  19.  
  20. double bcdtof(char *,int );
  21. double numerictof(char *);
  22. int asc_bcd(char *dest,char *source,int no_bytes);
  23. char *numerictostr(double numf,int len=9,int decimals=2);
  24. int del_trsp(char *t);
  25.  
  26. int del_trzero(char *t)
  27. {
  28.    int loop;
  29.    for ( loop=(strlen(t))-1 ; t[loop]==' ' || t[loop]=='0' ; loop-- )
  30.    {
  31.       t[loop]=EOS;
  32.    }
  33.    return(loop);
  34. }
  35.  
  36. char *btrvConvert(int type,char *src,char *dst,int slen,int sdec,int dlen,int ddec)
  37. {
  38.    char temp[100];
  39.    char tdst[255];
  40.    int *i,ii;
  41.    long *l,ll;
  42.    double *d,dd;
  43.    float *f,ff;
  44.    double tempf;
  45.  
  46.    memset(dst,EOS,dlen);
  47.    switch(type)
  48.    {
  49.       case BFTYP_LOGICAL:
  50.       case BFTYP_STRING:
  51.          {
  52.             sprintf(tdst,"%-*.*s",dlen,dlen,src);
  53. /*******    for ( int loop=0 ; loop<slen ; loop++ )
  54.             {
  55.                if ( src[loop]==EOS )
  56.                {
  57.                   src[loop]=' ';
  58.                }
  59.             }************/
  60.             memcpy(dst,tdst,dlen);
  61.          }
  62.          break;
  63.       case BFTYP_AUTOINC:
  64.       case BFTYP_INT:
  65.          if ( slen==2 )
  66.          {
  67.             i=(int *)src;
  68.             sprintf(dst,"%*d",dlen,*i);
  69.          }
  70.          else if ( slen==4 )
  71.          {
  72.             l=(long *)src;
  73.             sprintf(dst,"%*ld",dlen,*l);
  74.          }
  75.          else if ( slen==1 )
  76.          {
  77.             char *c;
  78.             c=(char *)src;
  79.             sprintf(dst,"%*d",dlen,*c);
  80.          }
  81.          break;
  82.       case BFTYP_UNSIGNED:
  83.          if ( slen==2 )
  84.          {
  85.             unsigned *u;
  86.             u=(unsigned *)src;
  87.             sprintf(dst,"%*u",dlen,(unsigned)*u);
  88.          }
  89.          else if ( slen==4 )
  90.          {
  91.             unsigned long *ul;
  92.             ul=(unsigned long *)src;
  93.             sprintf(dst,"%*lu",dlen,(unsigned long)*ul);
  94.          }
  95.          else if ( slen==1 )
  96.          {
  97.             unsigned char *c;
  98.             c=(unsigned char *)src;
  99.             sprintf(dst,"%*u",dlen,(unsigned)*c);
  100.          }
  101.          break;
  102.       case BFTYP_FLOAT:
  103.          if ( slen==4 )
  104.          {
  105.             f=(float *)src;
  106.             if ( ddec==0 )
  107.             {
  108.                ddec=6;
  109.             }
  110.             sprintf(dst,"%*.*f",dlen,ddec,*f);
  111.          }
  112.          else if ( slen==8 )
  113.          {
  114.             d=(double *)src;
  115.             if ( ddec==0 )
  116.             {
  117.                ddec=6;
  118.             }
  119.             sprintf(dst,"%*.*f",dlen,ddec,*d);
  120.          }
  121.          break;
  122.       case BFTYP_DATE:
  123.          i=(int *)(src+2);
  124.          if ( dlen>=10 )
  125.          {
  126.             sprintf(temp,"%2d/%02d/%04d",src[1],src[0],*i);
  127.          }
  128.          else
  129.          {
  130.             sprintf(temp,"%2d/%02d/%02d",src[1],src[0],(*i)%100);
  131.          }
  132.          temp[dlen]=EOS;
  133.          strcpy(dst,temp);
  134.          break;
  135.       case BFTYP_TIME:
  136.          sprintf(temp,"%2d:%02d:%02d.%02d",src[3],src[2],src[1],src[0]);
  137.          temp[dlen]=EOS;
  138.          strcpy(dst,temp);
  139.          break;
  140.       case BFTYP_DECIMAL:
  141.       case BFTYP_MONEY:
  142.          {
  143.             tempf=(bcdtof(src,slen));
  144.             for ( int loop=0 ; loop<ddec ; loop++ )
  145.             {
  146.                tempf/=10.0;
  147.             }
  148.             sprintf(dst,"%*.*f",dlen,ddec,tempf);
  149.          }
  150.          break;
  151.       case BFTYP_NUMERIC:
  152.          {
  153.             char temp[255];
  154.             strncpy(temp,src,slen);
  155.             temp[slen]=EOS;
  156.             tempf=(numerictof(temp));
  157.             for ( int loop=0 ; loop<ddec ; loop++ )
  158.             {
  159.                tempf/=10.0;
  160.             }
  161.             sprintf(dst,"%*.*f",dlen,ddec,tempf);
  162.          }
  163.          break;
  164.       case BFTYP_TRSIGN:
  165.          {
  166.             char temp[255];
  167.             strncpy(temp,src,slen);
  168.             temp[slen]=EOS;
  169.             tempf=(atof(temp));
  170.             for ( int loop=0 ; loop<ddec ; loop++ )
  171.             {
  172.                tempf/=10.0;
  173.             }
  174.             if ( src[slen-1]=='-' && tempf )
  175.             {
  176.                sprintf(dst,"%*.*f",dlen,ddec,(tempf*-1.0));
  177.             }
  178.             else
  179.             {
  180.                sprintf(dst,"%*.*f",dlen,ddec,tempf);
  181.             }
  182.          }
  183.          break;
  184. #ifdef BTFILER
  185.       case BFTYP_PREAL:
  186.          {
  187.             char temp[20];
  188.             memcpy(temp,src,slen);
  189.             if ( slen==6 )
  190.             {
  191.                char temp[100];
  192.                tempf=(pasrealtodouble(src));
  193.                sprintf(temp,"%f",tempf);
  194.                del_trzero(temp);
  195.                sprintf(dst,"%*s",dlen,temp);
  196.             }
  197.             memcpy(src,temp,slen);
  198.          }
  199.          break;
  200. #endif
  201.       case BFTYP_BFLOAT:
  202.          {
  203.             char temp[20];
  204.             memcpy(temp,src,slen);
  205.             if ( slen==4 )
  206.             {
  207.                char temp[100];
  208.                tempf=(bassngltodouble(src));
  209.                sprintf(temp,"%f",tempf);
  210.                del_trzero(temp);
  211.                sprintf(dst,"%*s",dlen,temp);
  212.             }
  213.             else if ( slen==8 )
  214.             {
  215.                char temp[100];
  216.                tempf=(basdbletodouble(src));
  217.                sprintf(temp,"%f",tempf);
  218.                del_trzero(temp);
  219.                sprintf(dst,"%*s",dlen,temp);
  220.             }
  221.             memcpy(src,temp,slen);
  222.          }
  223.          break;
  224.       case BFTYP_LSTRING:
  225.          {
  226.             int tlen=dlen;
  227.             if ( (*src)<dlen )
  228.             {
  229.                tlen=*src;
  230.             }
  231.             memset(dst,EOS,dlen);
  232.             memcpy(dst,(src+1),tlen);
  233.             for ( int loop=0 ; loop<(*src) && loop<tlen ; loop++ )
  234.             {
  235.                if ( dst[loop]==EOS )
  236.                {
  237.                   dst[loop]=' ';
  238.                }
  239.             }
  240.             dst[dlen]=EOS;
  241.          }
  242.          break;
  243.       case BFTYP_ZSTRING:
  244.          {
  245.             memcpy(dst,EOS,dlen);
  246.             strncpy(dst,src,dlen);
  247.             dst[dlen]=EOS;
  248.             del_trsp(dst);
  249.          }
  250.          break;
  251.       case BFTYP_LOGICAL+100:
  252.       case BFTYP_STRING+100:
  253.          sprintf(tdst,"%-*.*s",dlen,dlen,src);
  254.          memcpy(dst,tdst,dlen);
  255. //       memcpy(dst,src,dlen);
  256. //       for ( int loop=0 ; loop<dlen ; loop++ )
  257. //       {
  258. //          if ( dst[loop]==EOS )
  259. //          {
  260. //             dst[loop]=' ';
  261. //          }
  262. //       }
  263.          break;
  264.       case BFTYP_AUTOINC+100:
  265.       case BFTYP_INT+100:
  266.          if ( dlen==2 )
  267.          {
  268.             ii=atoi(src);
  269.             memcpy((int *)dst,&ii,2);
  270.          }
  271.          else if ( dlen==4 )
  272.          {
  273.             ll=atol(src);
  274.             memcpy((long *)dst,&ll,4);
  275.          }
  276.          else if ( dlen==1 )
  277.          {
  278.             char cc;
  279.             cc=atoi(src);
  280.             memcpy((long *)dst,&cc,1);
  281.          }
  282.          break;
  283.       case BFTYP_UNSIGNED+100:
  284.          if ( dlen==2 )
  285.          {
  286.             unsigned uu;
  287.             uu=(unsigned)atoi(src);
  288.             memcpy((int *)dst,&uu,2);
  289.          }
  290.          else if ( dlen==4 )
  291.          {
  292.             unsigned long ulul;
  293.             ulul=(unsigned long)atol(src);
  294.             memcpy((long *)dst,&ulul,4);
  295.          }
  296.          else if ( dlen==1 )
  297.          {
  298.             unsigned char cc;
  299.             cc=(unsigned char)atoi(src);
  300.             memcpy((long *)dst,&cc,1);
  301.          }
  302.          break;
  303.       case BFTYP_FLOAT+100:
  304.          if ( dlen==4 )
  305.          {
  306.             ff=(float)(atof(src));
  307.             memcpy((double *)dst,&ff,4);
  308.          }
  309.          else if ( dlen==8 )
  310.          {
  311.             dd=(float)(atof(src));
  312.             memcpy((double *)dst,&dd,8);
  313.          }
  314.          break;
  315.       case BFTYP_DATE+100:
  316.          dst[1]=(char)(atoi(src));
  317.          dst[0]=(char)(atoi(&src[3]));
  318.          ii=(atoi(&src[6]));
  319.          memcpy((char *)&dst[2],&ii,2);
  320.          break;
  321.       case BFTYP_TIME+100:
  322.          sprintf(temp,"%2d:%02d:%02d.%02d",src[3],src[2],src[1],src[0]);
  323.          temp[dlen]=EOS;
  324.          strcpy(dst,temp);
  325.          dst[3]=(char)(atoi(src));
  326.          while ( (*src) && (*src)!=':' )
  327.          {
  328.             src++;
  329.          }
  330.          if ( src )
  331.          {
  332.             src++;
  333.             dst[2]=(char)(atoi(src));
  334.             while ( (*src) && (*src)!=':' )
  335.             {
  336.                src++;
  337.             }
  338.             if ( src )
  339.             {
  340.                src++;
  341.                dst[1]=(char)(atoi(src));
  342.                while ( (*src) && (*src)!=':' && (*src)!='.' )
  343.                {
  344.                   src++;
  345.                }
  346.                if ( src )
  347.                {
  348.                   src++;
  349.                   dst[0]=(char)(atoi(src));
  350.                }
  351.             }
  352.          }
  353.          break;
  354.       case BFTYP_DECIMAL+100:
  355.       case BFTYP_MONEY+100:
  356.          {
  357.             tempf=(atof(src));
  358.             for ( int loop=0 ; loop<sdec ; loop++ )
  359.             {
  360.                tempf*=10.0;
  361.             }
  362.             sprintf(temp,"%0*.0f",dlen*2,tempf);
  363.             asc_bcd(dst,temp,dlen);
  364.          }
  365.          break;
  366.       case BFTYP_NUMERIC+100:
  367.          {
  368.             char temp[255];
  369.             tempf=(atof(src));
  370.             for ( int loop=0 ; loop<sdec ; loop++ )
  371.             {
  372.                tempf*=10.0;
  373.             }
  374.             sprintf(temp,"%s",numerictostr(tempf,dlen,ddec));
  375.             memcpy(dst,temp,dlen);
  376.          }
  377.          break;
  378.       case BFTYP_TRSIGN+100:
  379.          {
  380.             char temp[255];
  381.             int sign='+';
  382.  
  383.             tempf=(atof(src));
  384.             if ( tempf<0.0 )
  385.             {
  386.                sign='-';
  387.                tempf*=-1.0;
  388.             }
  389.             for ( int loop=0 ; loop<sdec ; loop++ )
  390.             {
  391.                tempf*=10.0;
  392.             }
  393.             if ( tempf<0.0 )
  394.             {
  395.                sprintf(temp,"%0*.0f%c",dlen-1,tempf,sign);
  396.             }
  397.             else
  398.             {
  399.                sprintf(temp,"%0*.0f%c",dlen-1,tempf,sign);
  400.             }
  401.             memcpy(dst,temp,dlen);
  402.          }
  403.          break;
  404. #ifdef BTFILER
  405.       case BFTYP_PREAL+100:
  406.          if ( dlen==6 )
  407.          {
  408.             tempf=(atof(src));
  409.             doubletopasreal((pasreal *)dst,tempf);
  410.          }
  411.          break;
  412. #endif
  413.       case BFTYP_BFLOAT+100:
  414.          if ( dlen==4 )
  415.          {
  416.             tempf=(atof(src));
  417.             doubletobassngl((bassngl *)dst,tempf);
  418.          }
  419.          else if ( dlen==8 )
  420.          {
  421.             tempf=(atof(src));
  422.             doubletobasdble((basdble *)dst,tempf);
  423.          }
  424.          break;
  425.       case BFTYP_LSTRING+100:
  426.          memcpy(dst+1,(src),strlen(src));
  427.          *dst=(char)(strlen(src));
  428.          break;
  429.       case BFTYP_ZSTRING+100:
  430.          memcpy(dst,EOS,dlen);
  431.          strncpy(dst,src,dlen);
  432.          dst[dlen]=EOS;
  433.          del_trsp(dst);
  434.          break;
  435.    }
  436.    return(0);
  437. }
  438.