Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.         function for format output to the string
  3. */
  4.  
  5. #include <kolibrisys.h>
  6. #include <string.h>
  7. #include <stdio.h>
  8. //#include <ctype.h>
  9. #include <math.h>
  10.  
  11. int formatted_double_to_string(long double number,int format1,int format2,char *s)
  12. {
  13.         double  n;
  14.         double  nbefor;
  15.         double  nafter;
  16.         double  v,v2;
  17.         long    intdigit;
  18.         long    beforpointdigit;
  19.         long    div;
  20.         int             i;
  21.         int             pos;
  22.         int             size;
  23.         int             fmt1;
  24.         int             fmt2;
  25.         long    mul;
  26.         char            buf[200];
  27.  
  28.         size=(int)s;
  29.         n=(double)number;
  30.         if (n<0) {*s='-';s++;n=-n;}
  31.  
  32.         fmt1=format1;
  33.         fmt2=format2;
  34.         if (fmt2>18) {fmt2=18;} //maximum of size long long type
  35.  
  36.         //clear array befor output
  37.         for(i=0;i<=200;i++) {buf[i]=0;}
  38.  
  39.         if ((fmt1>=0) && (n<1))
  40.         {       //formatted output if 0<=n<1
  41.                 mul=1;
  42.                 for(i=0;i<fmt2;i++)
  43.                 {n=n*10;mul=mul*10;}
  44.  
  45.                 n=n*10;
  46.                 n=ceil(n);
  47.                 intdigit=floor(n);
  48.                 //intdigit=n;
  49.                 intdigit=(intdigit/10);
  50.  
  51.                 pos=0;
  52.                 mul=mul/10;
  53.                 for(i=0;i<fmt2-1;i++)
  54.                 {
  55.                         div=intdigit/mul;
  56.                         buf[pos]=(char)div;
  57.                         pos++;
  58.                         intdigit=intdigit-div*mul;
  59.                         mul=mul/10;
  60.                         if (mul==1) break;
  61.                 }
  62.                 buf[pos]=(char)intdigit;
  63.                 *s='0';s++;
  64.                 *s='.';s++;
  65.                 for(i=0;i<format2;i++)
  66.                 {
  67.                         if ((buf[i]>=0) && (buf[i]<=9)) {*s='0'+buf[i];}
  68.                         else {*s='0';}
  69.                         s++;
  70.                 }
  71.         }
  72.         else
  73.         {       //if n>=1
  74.                 //v=floorf(n+0.00000000000001);
  75.                 beforpointdigit=floor(n+0.00000000000001);
  76.                 //beforpointdigit=n;
  77.                 nbefor=beforpointdigit;
  78.                 nafter=n-nbefor;
  79.  
  80.                 //print part of number befor point
  81.                 mul=1;
  82.                 for(i=0;i<200-2;i++)
  83.                 {
  84.                         mul=mul*10;
  85.                         if ((beforpointdigit/mul)==0) {fmt1=i+1;break;}
  86.                 }
  87.  
  88.                 pos=0;
  89.                 mul=mul/10;
  90.                 for(i=0;i<fmt1-1;i++)
  91.                 {
  92.                         div=beforpointdigit/mul;
  93.                         buf[pos]=(char)div;
  94.                         pos++;
  95.                         beforpointdigit=beforpointdigit-div*mul;
  96.                         mul=mul/10;
  97.                         if (mul==1) break;
  98.                 }
  99.                 buf[pos]=(char)beforpointdigit;
  100.  
  101.                 for(i=0;i<fmt1;i++)
  102.                 {
  103.                         if ((buf[i]>=0) && (buf[i]<=9)) {*s='0'+buf[i];}
  104.                         s++;
  105.                 }
  106.  
  107.                 //print part of number after point
  108.                 mul=1;
  109.                 for(i=0;i<fmt2;i++)
  110.                 {nafter=nafter*10;mul=mul*10;}
  111.  
  112.                 nafter=nafter*10;
  113.                 nafter=ceil(nafter);
  114.                 intdigit=floor(nafter);
  115.                 //intdigit=nafter;
  116.                 intdigit=intdigit/10;
  117.  
  118.                 pos=0;
  119.                 mul=mul/10;
  120.                 for(i=0;i<fmt2-1;i++)
  121.                 {
  122.                         div=intdigit/mul;
  123.                         buf[pos]=(char)div;
  124.                         pos++;
  125.                         intdigit=intdigit-div*mul;
  126.                         mul=mul/10;
  127.                         if (mul==1) break;
  128.                 }
  129.                 buf[pos]=(char)intdigit;
  130.                 *s='.';s++;
  131.                 for(i=0;i<format2;i++)
  132.                 {
  133.                         if ((buf[i]>=0) && (buf[i]<=9)) {*s='0'+buf[i];}
  134.                         else {*s='0';}
  135.                         s++;
  136.                 }
  137.  
  138.         }
  139.         size=(int)s-size;
  140.         return(size);
  141. }
  142.  
  143. int formatted_long_to_string(long long number,int fmt1,char *s)
  144. {
  145.         int             i;
  146.         int             pos;
  147.         int             fmt;
  148.         int             size;
  149.         int             difference_pos;
  150.         long    digit;
  151.         long    mul;
  152.         long    div;
  153.         char            buf[200];
  154.  
  155.         //clear array befor output
  156.         for(i=0;i<200;i++) {buf[i]=0;}
  157.         digit=number;
  158.  
  159.         size=(int)s;
  160.         if (digit<0) {*s='-';s++;digit=-digit;}
  161.         if (digit==0) {*s='0';s++;goto end;}
  162.  
  163.         mul=1;
  164.                 for(i=0;i<200-2;i++)
  165.                 {
  166.                         mul=mul*10;
  167.                         if ((digit/mul)==0) {fmt=i+1;break;}
  168.                 }
  169.  
  170.                 difference_pos=i+1;
  171.  
  172.                 pos=0;
  173.                 mul=mul/10;
  174.                 for(i=0;i<fmt-1;i++)
  175.                 {
  176.                         div=digit/mul;
  177.                         buf[pos]=(char)div;
  178.                         pos++;
  179.                         digit=digit-div*mul;
  180.                         mul=mul/10;
  181.                         if (mul==1) break;
  182.                 }
  183.                 buf[pos]=(char)digit;
  184.  
  185.                 if (fmt1>=difference_pos) fmt=fmt1;
  186.                 else
  187.                   fmt=difference_pos;
  188.  
  189.                 for(i=0;i<fmt;i++)
  190.                 {
  191.                         if (i<difference_pos)
  192.                         {
  193.                                 if ((buf[i]>=0) && (buf[i]<=9)) {*s='0'+buf[i];}
  194.                         }
  195.                         else
  196.                         {
  197.                                 *s=' ';
  198.                         }
  199.                         s++;
  200.                 }
  201.         end:
  202.         size=(int)s-size;
  203.         return(size);
  204. }
  205.  
  206. int formatted_hex_to_string(long long number,int fmt1,char flag_register,char *s)
  207. {
  208.         long    n;
  209.         int             i,pos;
  210.         int             fmt;
  211.         long    size;
  212.         int             difference_pos;
  213.         char            xdigs_lower[16]="0123456789abcdef";
  214.         char            xdigs_upper[16]="0123456789ABCDEF";
  215.         char            buf[200];
  216.  
  217.         n=(long)number;
  218.         size=(int)s;
  219.         if (n<0) {*s='-';s++;n=-n;}
  220.  
  221.         if (n==0) {*s='0';s++;goto end;}
  222.         for(i=0;i<200;i++) {buf[i]=0;}
  223.  
  224.         i=0;
  225.         if (flag_register==0)
  226.         {
  227.                 while (n>0)
  228.                 {
  229.                         buf[i]=xdigs_lower[n & 15];
  230.                         n=n>>4;
  231.                         i++;
  232.                 }
  233.         }
  234.         else
  235.         {
  236.                 while (n>0)
  237.                 {
  238.                         buf[i]=xdigs_upper[n & 15];
  239.                         n=n>>4;
  240.                         i++;
  241.                 }
  242.         }
  243.  
  244.         pos=i;
  245.         difference_pos=i;
  246.  
  247.         for(i=pos-1;i>=0;i--)
  248.         {
  249.                 *s=buf[i];
  250.                 s++;
  251.         }
  252.  
  253.         if (fmt1-difference_pos>0)
  254.         {
  255.                 for(i=difference_pos+1;i<=fmt1;i++)
  256.                 {
  257.                         *s=' ';
  258.                         s++;
  259.                 }
  260.         }
  261.         end:size=(int)s-size;
  262.         return(size);
  263. }
  264.  
  265. int formatted_octa_to_string(long long number,int fmt1,char flag_register,char *s)
  266. {
  267.         long    n;
  268.         int             i,pos;
  269.         int             fmt;
  270.         long    size;
  271.         int             difference_pos;
  272.         char            xdigs_lower[16]="012345678";
  273.         char            buf[200];
  274.  
  275.         n=number;
  276.         size=(int)s;
  277.         if (n<0) {*s='-';s++;n=-n;}
  278.  
  279.         if (n==0) {*s='0';s++;goto end;}
  280.         for(i=0;i<200;i++) {buf[i]=0;}
  281.  
  282.         i=0;
  283.         if (flag_register==0)
  284.         {
  285.                 while (n>0)
  286.                 {
  287.                         buf[i]=xdigs_lower[n & 7];
  288.                         n=n>>3;
  289.                         i++;
  290.                 }
  291.         }
  292.  
  293.         pos=i;
  294.         difference_pos=i;
  295.  
  296.         for(i=pos-1;i>=0;i--)
  297.         {
  298.                 *s=buf[i];
  299.                 s++;
  300.         }
  301.  
  302.         if (fmt1-difference_pos>0)
  303.         {
  304.                 for(i=difference_pos+1;i<=fmt1;i++)
  305.                 {
  306.                         *s=' ';
  307.                         s++;
  308.                 }
  309.         }
  310.         end:size=(int)s-size;
  311.         return(size);
  312. }
  313.  
  314. int format_print(char *dest, size_t maxlen,const char *fmt0, va_list argp)
  315. {
  316.         int                     i,j,k;
  317.         int                     length;
  318.         int                     fmt1,fmt2,stepen;
  319.         size_t                  pos,posc;
  320.         long    long            intdigit;
  321.         long    double          doubledigit;
  322.         float                   floatdigit;
  323.         const   char            *fmt,*fmtc;
  324.         char                    *s;
  325.         char                    *str;
  326.         char                    buffmt1[30];
  327.         char                    buffmt2[30];
  328.         char                    buf[1024];
  329.         char                    format_flag;
  330.         char                    flag_point;
  331.         char                    flag_noformat;
  332.         char                    flag_long;
  333.         char                    flag_unsigned;
  334.         char                    flag_register;
  335.         char                    flag_plus;
  336.  
  337.         fmt=fmt0;
  338.         s=dest;
  339.         pos=0;
  340.         while(pos<maxlen)
  341.         {
  342.                 if (*fmt=='%')
  343.                 {
  344.  
  345.                         if (*(fmt+1)=='%')
  346.                         {
  347.                                 *s='%';
  348.                                 s++;
  349.                                 fmt=fmt+2;
  350.                                 pos++;
  351.                                 goto exit_check;
  352.                         }
  353.                         //checking to containg format in the string
  354.                         fmtc=fmt;
  355.                         posc=pos;
  356.                         format_flag=0;
  357.                         flag_long=0;
  358.                         flag_unsigned=0;
  359.                         flag_register=0;
  360.                         flag_plus=0;
  361.                         while((*fmtc!='\0') || (*fmtc!=0))
  362.                         {
  363.                                 fmtc++;
  364.                                 posc++;
  365.                                 switch(*fmtc)
  366.                                 {
  367.                                         case 'c':
  368.                                         case 'C':
  369.                                         format_flag=1;
  370.                                         break;
  371.                                         case 'd':
  372.                                         case 'D':
  373.                                         case 'i':
  374.                                         case 'I':
  375.                                         format_flag=1;
  376.                                         break;
  377.                                         case 'e':
  378.                                         format_flag=1;
  379.                                         break;
  380.                                         case 'E':
  381.                                         format_flag=1;
  382.                                         flag_long=1;
  383.                                         break;
  384.                                         case 'f':
  385.                                         format_flag=1;
  386.                                         break;
  387.                                         case 'F':
  388.                                         format_flag=1;
  389.                                         flag_long=1;
  390.                                         break;
  391.                                         case 'g':
  392.                                         format_flag=1;
  393.                                         break;
  394.                                         case 'G':
  395.                                         format_flag=1;
  396.                                         flag_long=1;
  397.                                         break;
  398.                                         case 'l':
  399.                                         flag_long=1;
  400.                                         break;
  401.                                         case 'L':
  402.                                         flag_long=2;
  403.                                         break;
  404.                                         case 'o':
  405.                                         format_flag=1;
  406.                                         break;
  407.                                         case 's':
  408.                                         case 'S':
  409.                                         format_flag=1;
  410.                                         break;
  411.                                         case 'u':
  412.                                         case 'U':
  413.                                         format_flag=1;
  414.                                         flag_unsigned=1;
  415.                                         break;
  416.                                         case 'x':
  417.                                         format_flag=1;
  418.                                         break;
  419.                                         case 'X':
  420.                                         flag_register=1;
  421.                                         format_flag=1;
  422.                                         break;
  423.                                         case 'z':
  424.                                         case 'Z':
  425.                                         format_flag=1;
  426.                                         flag_unsigned=1;
  427.                                         break;
  428.                                         case '+':
  429.                                         flag_plus=1;
  430.                                         break;
  431.  
  432.                                         default:;
  433.                                 }
  434.                                 if ((*fmtc=='%') || (*fmtc==' ')) break;
  435.                                 if (format_flag==1) break;
  436.                         }
  437.  
  438.                         if (format_flag==0)
  439.                         {
  440.                                 *s=*fmt;
  441.                                 fmt++;
  442.                                 s++;
  443.                                 pos++;
  444.                         }
  445.                         else
  446.                         {
  447.                                 if ((posc-pos)==1)
  448.                                 {//simbols % and format simbol near tothere(for example %c )
  449.                                         fmt=fmtc+1;
  450.                                         switch(*fmtc)
  451.                                         {
  452.                                                 case 'c':
  453.                                                 case 'C':
  454.                                                 if ((pos+1)<maxlen)
  455.                                                 {
  456.                                                         //*s=(int)va_arg(argp,char*);
  457.                                                         *s=*((char *)argp);
  458.                                                         argp=argp+4;
  459.                                                         *s++;pos++;
  460.                                                 }
  461.                                                 break;
  462.                                                 case 's':
  463.                                                 case 'S':
  464.                                                 str=va_arg(argp,char*);
  465.                                                 length=strlen(str);
  466.                                                 if ((pos+length)<maxlen)
  467.                                                 {
  468.                                                         memcpy(s,str,length);
  469.                                                         s=s+length;pos=pos+length;
  470.                                                 }
  471.                                                 break;
  472.                                                 case 'd':
  473.                                                 case 'D':
  474.                                                 case 'i':
  475.                                                 case 'I':
  476.                                                 if (flag_long==0) {intdigit=va_arg(argp,int);}
  477.                                                 if (flag_long==1) {intdigit=va_arg(argp,long);}
  478.                                                 if (flag_long==2) {intdigit=va_arg(argp,long long);}
  479.                                                 //intdigit=*((long*)argp);
  480.                                                 //argp=argp+4;
  481.                                                 if ((intdigit>0) && (flag_plus==1) && (pos+1<maxlen))
  482.                                                 {
  483.                                                         *s='+';
  484.                                                         s++;
  485.                                                         pos++;
  486.                                                 }
  487.                                                 length=formatted_long_to_string(intdigit,0,buf);
  488.                                                 if ((pos+length)<maxlen)
  489.                                                 {
  490.                                                         memcpy(s,buf,length);
  491.                                                         s=s+length;pos=pos+length;
  492.                                                 }
  493.                                                 break;
  494.                                                 case 'o':
  495.                                                 if (flag_long==0) {intdigit=va_arg(argp,int);}
  496.                                                 if (flag_long==1) {intdigit=va_arg(argp,long);}
  497.                                                 if (flag_long==2) {intdigit=va_arg(argp,long long);}
  498.                                                 //intdigit=*((long int *)argp);
  499.                                                 //argp=argp+4;
  500.  
  501.                                                 length=formatted_octa_to_string(intdigit,0,flag_register,buf);
  502.                                                 if ((pos+length)<maxlen)
  503.                                                 {
  504.                                                         memcpy(s,buf,length);
  505.                                                         s=s+length;pos=pos+length;
  506.                                                 }
  507.                                                 break;
  508.                                                 case 'u':
  509.                                                 case 'U':
  510.                                                 if (flag_long==0) {intdigit=va_arg(argp,int);}
  511.                                                 if (flag_long==1) {intdigit=va_arg(argp,long int);}
  512.                                                 if (flag_long==2) {intdigit=va_arg(argp,long long);}
  513.  
  514.                                                 if (flag_unsigned==1) {
  515.                                                         if (intdigit<0) {intdigit=-intdigit;}
  516.                                                 }
  517.  
  518.                                                 length=formatted_long_to_string(intdigit,0,buf);
  519.                                                 if ((pos+length)<maxlen)
  520.                                                 {
  521.                                                         memcpy(s,buf,length);
  522.                                                         s=s+length;pos=pos+length;
  523.                                                 }
  524.                                                 break;
  525.                                                 case 'x':
  526.                                                 case 'X':
  527.                                                 if (flag_long==0) {intdigit=va_arg(argp,int);}
  528.                                                 if (flag_long==1) {intdigit=va_arg(argp,long);}
  529.                                                 if (flag_long==2) {intdigit=va_arg(argp,long long);}
  530.                                                 //intdigit=*((long int *)argp);
  531.                                                 //argp=argp+4;
  532.  
  533.                                                 length=formatted_hex_to_string(intdigit,0,flag_register,buf);
  534.                                                 if ((pos+length)<maxlen)
  535.                                                 {
  536.                                                         memcpy(s,buf,length);
  537.                                                         s=s+length;pos=pos+length;
  538.                                                 }
  539.                                                 break;
  540.                                                 case 'z':
  541.                                                 case 'Z':
  542.                                                 intdigit=va_arg(argp,size_t);
  543.  
  544.                                                 if (flag_unsigned==1) {
  545.                                                         if (intdigit<0) {intdigit=-intdigit;}
  546.                                                 }
  547.  
  548.                                                 length=formatted_long_to_string(intdigit,0,buf);
  549.                                                 if ((pos+length)<maxlen)
  550.                                                 {
  551.                                                         memcpy(s,buf,length);
  552.                                                         s=s+length;pos=pos+length;
  553.                                                 }
  554.                                                 break;
  555.                                                 default:;
  556.  
  557.                                         }
  558.                                 }
  559.                                 else
  560.                                 {
  561.                                         fmt++;
  562.                                         flag_point=0;
  563.                                         flag_noformat=0;
  564.                                         fmt1=0;
  565.                                         fmt2=0;
  566.                                         j=0;
  567.                                         k=0;
  568.                                         for(i=pos+1;i<posc;i++)
  569.                                         {
  570.                                                 switch(*fmt)
  571.                                                 {
  572.                                                         case '0':
  573.                                                         case '1':
  574.                                                         case '2':
  575.                                                         case '3':
  576.                                                         case '4':
  577.                                                         case '5':
  578.                                                         case '6':
  579.                                                         case '7':
  580.                                                         case '8':
  581.                                                         case '9':
  582.                                                         if (flag_point==0)
  583.                                                         {
  584.                                                                 buffmt1[j]=*fmt-'0';
  585.                                                                 j++;
  586.                                                         }
  587.                                                         else
  588.                                                         {
  589.                                                                 buffmt2[k]=*fmt-'0';
  590.                                                                 k++;
  591.                                                         }
  592.                                                         break;
  593.                                                         case '.':
  594.                                                         flag_point=1;
  595.                                                         break;
  596.                                                         case 'l':
  597.                                                         case 'L':
  598.                                                         break;
  599.                                                         case '+':
  600.                                                         break;
  601.                                                         default:flag_noformat=1;
  602.                                                 }
  603.                                                 if (flag_noformat==1) break;
  604.                                                 fmt++;
  605.                                         }
  606.                                         if (flag_noformat==0)
  607.                                         {
  608.                                                 stepen=1;
  609.                                                 for(i=j-1;i>=0;i--)
  610.                                                 {
  611.                                                         fmt1=fmt1+buffmt1[i]*stepen;
  612.                                                         stepen=stepen*10;
  613.                                                 }
  614.                                                 stepen=1;
  615.                                                 for(i=k-1;i>=0;i--)
  616.                                                 {
  617.                                                         fmt2=fmt2+buffmt2[i]*stepen;
  618.                                                         stepen=stepen*10;
  619.                                                 }
  620.                                                 switch(*fmtc)
  621.                                                 {
  622.                                                         case 'f':
  623.                                                         case 'F':
  624.                                                         if (flag_long==0) {doubledigit=va_arg(argp,double);}
  625.                                                         if (flag_long>=1) {doubledigit=va_arg(argp,long double);}
  626.                                                         //doubledigit=*((double *)argp);
  627.                                                         //sargp=argp+8;
  628.                                                         length=formatted_double_to_string(doubledigit,fmt1,fmt2,buf);
  629.                                                         if ((pos+length)<maxlen)
  630.                                                         {
  631.                                                                 memcpy(s,buf,length);
  632.                                                                 s=s+length;pos=pos+length;
  633.                                                         }
  634.                                                         break;
  635.                                                         case 'd':
  636.                                                         case 'D':
  637.                                                         case 'i':
  638.                                                         case 'I':
  639.                                                         if (flag_long==0) {intdigit=va_arg(argp,int);}
  640.                                                         if (flag_long==1) {intdigit=va_arg(argp,long);}
  641.                                                         if (flag_long==2) {intdigit=va_arg(argp,long long);}
  642.  
  643.                                                         if ((intdigit>0) && (flag_plus==1) && (pos+1<maxlen))
  644.                                                         {
  645.                                                                 *s='+';
  646.                                                                 s++;
  647.                                                                 pos++;
  648.                                                         }
  649.                                                         length=formatted_long_to_string(intdigit,fmt1,buf);
  650.                                                         if ((pos+length)<maxlen)
  651.                                                         {
  652.                                                                 memcpy(s,buf,length);
  653.                                                                 s=s+length;pos=pos+length;
  654.                                                         }
  655.                                                         break;
  656.                                                         case 'o':
  657.                                                         if (flag_long==0) {intdigit=va_arg(argp,int);}
  658.                                                         if (flag_long==1) {intdigit=va_arg(argp,long);}
  659.                                                         if (flag_long==2) {intdigit=va_arg(argp,long long);}
  660.                                                         length=formatted_octa_to_string(intdigit,fmt1,flag_register,buf);
  661.                                                         if ((pos+length)<maxlen)
  662.                                                         {
  663.                                                                 memcpy(s,buf,length);
  664.                                                                 s=s+length;pos=pos+length;
  665.                                                         }
  666.                                                         break;
  667.                                                         case 'u':
  668.                                                         case 'U':
  669.                                                         if (flag_long==0) {intdigit=va_arg(argp,int);}
  670.                                                         if (flag_long==1) {intdigit=va_arg(argp,long int);}
  671.                                                         if (flag_long==2) {intdigit=va_arg(argp,long long);}
  672.  
  673.                                                         if (flag_unsigned==1) {
  674.                                                                 if (intdigit<0) {intdigit=-intdigit;}
  675.                                                         }
  676.  
  677.                                                         length=formatted_long_to_string(intdigit,fmt1,buf);
  678.                                                         if ((pos+length)<maxlen)
  679.                                                         {
  680.                                                                 memcpy(s,buf,length);
  681.                                                                 s=s+length;pos=pos+length;
  682.                                                         }
  683.                                                         break;
  684.                                                         case 'x':
  685.                                                         case 'X':
  686.                                                         if (flag_long==0) {intdigit=va_arg(argp,int);}
  687.                                                         if (flag_long==1) {intdigit=va_arg(argp,long int);}
  688.                                                         if (flag_long==2) {intdigit=va_arg(argp,long long);}
  689.                                                         length=formatted_hex_to_string(intdigit,fmt1,flag_register,buf);
  690.                                                         if ((pos+length)<maxlen)
  691.                                                         {
  692.                                                                 memcpy(s,buf,length);
  693.                                                                 s=s+length;pos=pos+length;
  694.                                                         }
  695.                                                         break;
  696.                                                         case 'z':
  697.                                                         case 'Z':
  698.                                                         intdigit=va_arg(argp,size_t);
  699.  
  700.                                                         if (flag_unsigned==1) {
  701.                                                                 if (intdigit<0) {intdigit=-intdigit;}
  702.                                                         }
  703.  
  704.                                                         length=formatted_long_to_string(intdigit,fmt1,buf);
  705.                                                         if ((pos+length)<maxlen)
  706.                                                         {
  707.                                                                 memcpy(s,buf,length);
  708.                                                                 s=s+length;pos=pos+length;
  709.                                                         }
  710.                                                         break;
  711.                                                         default:;
  712.                                                 }
  713.                                         }
  714.                                         fmt=fmtc+1;
  715.                                 }
  716.                         }
  717.                 }
  718.                 else
  719.                 {
  720.                         if (*fmt=='\0') {break;}
  721.                         *s=*fmt;
  722.                         fmt++;
  723.                         s++;
  724.                         pos++;
  725.                 }
  726.                 exit_check:;
  727.         }
  728.         return(pos);
  729. }
  730.