Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

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