Subversion Repositories HelenOS-historic

Rev

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

  1. /*
  2.  * Copyright (C) 2001-2004 Jakub Jermar
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. #include <putchar.h>
  30. #include <print.h>
  31. #include <synch/spinlock.h>
  32. #include <arch/arg.h>
  33. #include <arch/asm.h>
  34. #include <arch/fmath.h>
  35.  
  36. #include <arch.h>
  37.  
  38. static char digits[] = "0123456789abcdef"; /**< Hexadecimal characters */
  39. static spinlock_t printflock;              /**< printf spinlock */
  40.  
  41. #define DEFAULT_DOUBLE_PRECISION 16
  42. #define DEFAULT_DOUBLE_BUFFER_SIZE 128
  43.  
  44. void print_double(double num, __u8 modifier, __u16 precision)
  45. {
  46.     double intval,intval2;
  47.     int counter;
  48.     int exponent,exponenttmp;
  49.     unsigned char buf[DEFAULT_DOUBLE_BUFFER_SIZE];
  50.     unsigned long in1,in2; 
  51.    
  52.  
  53.     if (fmath_is_nan(num)) {
  54.         print_str("NaN");
  55.         return;
  56.     }
  57.    
  58.     if (num<0.0) {
  59.         putchar('-');
  60.         num=num*-1.0;
  61.         }
  62.  
  63.  
  64.     if (fmath_is_infinity(num)) {
  65.         print_str("Inf");
  66.         return;
  67.         }
  68.  
  69.     if ((modifier=='E')||(modifier=='e')) {
  70.         intval2=fmath_fint(fmath_get_decimal_exponent(num),&intval);
  71.         exponent=intval;
  72.         if ((intval2<0.0)) exponent--;
  73.         num = num / ((fmath_dpow(10.0,exponent)));
  74.        
  75.         print_double(num,modifier+1,precision); //modifier+1 = E => F or e => f
  76.         putchar(modifier);
  77.         if (exponent<0) {
  78.             putchar('-');
  79.             exponent*=-1;
  80.             }
  81.         print_number(exponent,10);
  82.         return;
  83.         }
  84.        
  85.     //TODO: rounding constant - when we got fraction >= 0.5, we must increment last printed number
  86.  
  87.     /* Here is problem with cumulative error while printing big double values -> we will divide
  88.     the number with a power of 10, print new number with better method for small numbers and then print decimal point at correct position */
  89.    
  90.     fmath_fint(fmath_get_decimal_exponent(num),&intval);
  91.    
  92.     exponent=(intval>0.0?intval:0);
  93.    
  94.     precision+=exponent;
  95.    
  96.     if (exponent>0) num = num / ((fmath_dpow(10.0,exponent)));
  97.        
  98.     num=fmath_fint(num,&intval);
  99.    
  100.     if (precision>0) {
  101.         counter=precision-1;
  102.         if (exponent>0) counter++;
  103.        
  104.         if (counter>=DEFAULT_DOUBLE_BUFFER_SIZE) {
  105.             counter=DEFAULT_DOUBLE_BUFFER_SIZE;
  106.         }
  107.         exponenttmp=exponent;
  108.         while(counter>=0) {
  109.             num *= 10.0;
  110.             num = fmath_fint(num,&intval2);
  111.             buf[counter--]=((int)intval2)+'0';
  112.             exponenttmp--;
  113.             if ((exponenttmp==0)&&(counter>=0)) buf[counter--]='.';
  114.         }
  115.         counter=precision;
  116.         if ((exponent==0)&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) buf[counter]='.';
  117.         counter++; 
  118.     } else {
  119.         counter=0; 
  120.     }
  121.    
  122.     in1=intval;
  123.     if (in1==0.0) {
  124.         if (counter<DEFAULT_DOUBLE_BUFFER_SIZE) buf[counter++]='0';
  125.     } else {
  126.         while(( in1>0 )&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) {
  127.            
  128.             in2=in1;
  129.             in1/=10;
  130.             buf[counter]=in2-in1*10 + '0';
  131.             counter++;
  132.         }
  133.     }
  134.    
  135.     counter = (counter>=DEFAULT_DOUBLE_BUFFER_SIZE?DEFAULT_DOUBLE_BUFFER_SIZE:counter);
  136.     while (counter>0) {
  137.         putchar(buf[--counter]);
  138.     };
  139.     return;
  140. }
  141.  
  142. /** Print NULL terminated string
  143.  *
  144.  * Print characters from str using putchar() until
  145.  * \x00 character is reached.
  146.  *
  147.  * @param str Characters to print.
  148.  *
  149.  */
  150. void print_str(const char *str)
  151. {
  152.     int i = 0;
  153.     char c;
  154.    
  155.     while (c = str[i++])
  156.         putchar(c);
  157. }
  158.  
  159.  
  160. /** Print hexadecimal digits
  161.  *
  162.  * Print fixed count of hexadecimal digits from
  163.  * the number num. The digits are printed in
  164.  * natural left-to-right order starting with
  165.  * the width-th digit.
  166.  *
  167.  * @param num   Number containing digits.
  168.  * @param width Count of digits to print.
  169.  *
  170.  */
  171. void print_fixed_hex(const __u64 num, const int width)
  172. {
  173.     int i;
  174.    
  175.     for (i = width*8 - 4; i >= 0; i -= 4)
  176.         putchar(digits[(num>>i) & 0xf]);
  177. }
  178.  
  179.  
  180. /** Print number in given base
  181.  *
  182.  * Print significant digits of a number in given
  183.  * base.
  184.  *
  185.  * @param num  Number to print.
  186.  * @param base Base to print the number in (should
  187.  *             be in range 2 .. 16).
  188.  *
  189.  */
  190. void print_number(const __native num, const unsigned int base)
  191. {
  192.     int val = num;
  193.     char d[sizeof(__native)*8+1];       /* this is good enough even for base == 2 */
  194.     int i = sizeof(__native)*8-1;
  195.    
  196.     do {
  197.         d[i--] = digits[val % base];
  198.     } while (val /= base);
  199.    
  200.     d[sizeof(__native)*8] = 0; 
  201.     print_str(&d[i + 1]);
  202. }
  203.  
  204.  
  205. /** General formatted text print
  206.  *
  207.  * Print text formatted according the fmt parameter
  208.  * and variant arguments. Each formatting directive
  209.  * begins with % (percentage) character and one of the
  210.  * following character:
  211.  *
  212.  * %    Prints the percentage character.
  213.  * s    The next variant argument is treated as char*
  214.  *      and printed as a NULL terminated string.
  215.  * c    The next variant argument is treated as a single char.
  216.  * p    The next variant argument is treated as a maximum
  217.  *      bit-width integer with respect to architecture
  218.  *      and printed in full hexadecimal width.
  219.  * P    As with 'p', but '0x' is prefixed.
  220.  * q    The next variant argument is treated as a 64b integer
  221.  *      and printed in full hexadecimal width.
  222.  * Q    As with 'q', but '0x' is prefixed.
  223.  * l    The next variant argument is treated as a 32b integer
  224.  *      and printed in full hexadecimal width.
  225.  * L    As with 'l', but '0x' is prefixed.
  226.  * w    The next variant argument is treated as a 16b integer
  227.  *      and printed in full hexadecimal width.
  228.  * W    As with 'w', but '0x' is prefixed.
  229.  * b    The next variant argument is treated as a 8b integer
  230.  *      and printed in full hexadecimal width.
  231.  * N    As with 'b', but '0x' is prefixed.
  232.  * d    The next variant argument is treated as integer
  233.  *      and printed in standard decimal format (only significant
  234.  *      digits).
  235.  * x    The next variant argument is treated as integer
  236.  *      and printed in standard hexadecimal format (only significant
  237.  *      digits).
  238.  * X    As with 'x', but '0x' is prefixed.
  239.  *
  240.  * All other characters from fmt except the formatting directives
  241.  * are printed in verbatim.
  242.  *
  243.  * @param fmt Formatting NULL terminated string.
  244.  *
  245.  */
  246. void printf(const char *fmt, ...)
  247. {
  248.     int irqpri, i = 0;
  249.     va_list ap;
  250.     char c;
  251.    
  252.     __u16 precision;
  253.    
  254.     va_start(ap, fmt);
  255.  
  256.     irqpri = cpu_priority_high();
  257.     spinlock_lock(&printflock);
  258.  
  259.     while (c = fmt[i++]) {
  260.         switch (c) {
  261.  
  262.            
  263.            
  264.             /* control character */
  265.             case '%':
  266.            
  267.                 precision = DEFAULT_DOUBLE_PRECISION;
  268.                 if (fmt[i]=='.') {
  269.                     precision=0;
  270.                     c=fmt[++i];
  271.                         while((c>='0')&&(c<='9')) {
  272.                             precision = precision*10 + c - '0';
  273.                             c=fmt[++i];
  274.                             }
  275.                        
  276.                 }
  277.            
  278.                 switch (c = fmt[i++]) {
  279.  
  280.                 /* percentile itself */
  281.                 case '%':
  282.                     break;
  283.  
  284.                 /*
  285.                  * String and character conversions.
  286.                  */
  287.                 case 's':
  288.                     print_str(va_arg(ap, char_ptr));
  289.                     goto loop;
  290.  
  291.                 case 'c':
  292.                     c = (char) va_arg(ap, int);
  293.                     break;
  294.  
  295.                 /*
  296.                          * Hexadecimal conversions with fixed width.
  297.                          */
  298.                 case 'P':
  299.                     print_str("0x");
  300.                 case 'p':
  301.                         print_fixed_hex(va_arg(ap, __native), sizeof(__native));
  302.                     goto loop;
  303.  
  304.                 case 'Q':
  305.                     print_str("0x");
  306.                 case 'q':
  307.                         print_fixed_hex(va_arg(ap, __u64), INT64);
  308.                     goto loop;
  309.  
  310.                 case 'L':
  311.                     print_str("0x");
  312.                 case 'l':
  313.                         print_fixed_hex(va_arg(ap, __native), INT32);
  314.                     goto loop;
  315.  
  316.                 case 'W':
  317.                     print_str("0x");
  318.                 case 'w':
  319.                         print_fixed_hex(va_arg(ap, __native), INT16);
  320.                     goto loop;
  321.  
  322.                 case 'B':
  323.                     print_str("0x");
  324.                 case 'b':
  325.                         print_fixed_hex(va_arg(ap, __native), INT8);
  326.                     goto loop;
  327.  
  328.                 /*
  329.                          * Floating point conversions.
  330.                          */
  331.                
  332.                 case 'F':
  333.                         print_double(va_arg(ap, double),'F',precision);
  334.                     goto loop;
  335.                    
  336.                 case 'f':
  337.                         print_double(va_arg(ap, double),'f',precision);
  338.                     goto loop;
  339.                
  340.                 case 'E':
  341.                         print_double(va_arg(ap, double),'E',precision);
  342.                     goto loop;
  343.                 case 'e':
  344.                         print_double(va_arg(ap, double),'e',precision);
  345.                     goto loop;
  346.                
  347.                 /*
  348.                          * Decimal and hexadecimal conversions.
  349.                          */
  350.                 case 'd':
  351.                         print_number(va_arg(ap, __native), 10);
  352.                     goto loop;
  353.  
  354.                 case 'X':
  355.                             print_str("0x");
  356.                 case 'x':
  357.                         print_number(va_arg(ap, __native), 16);
  358.                     goto loop;
  359.        
  360.                 /*
  361.                  * Bad formatting.
  362.                  */
  363.                 default:
  364.                     goto out;
  365.                 }
  366.  
  367.             default: putchar(c);
  368.         }
  369.    
  370. loop:
  371.         ;
  372.     }
  373.  
  374. out:
  375.     spinlock_unlock(&printflock);
  376.     cpu_priority_restore(irqpri);
  377.    
  378.     va_end(ap);
  379. }
  380.