Subversion Repositories HelenOS

Rev

Rev 228 | Go to most recent revision | 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.    
  59.     if (fmath_is_negative(num)) {
  60.         putchar('-');
  61.         }
  62.    
  63.     num=fmath_abs(num);
  64.  
  65.     if ((modifier=='E')||(modifier=='e')) {
  66.         intval2=fmath_fint(fmath_get_decimal_exponent(num),&intval);
  67.         exponent=intval;
  68.         if ((intval2<0.0)&&(exponent<0)) exponent--;
  69.         num = num / ((fmath_dpow(10.0,exponent)));
  70.        
  71.         print_double(num,modifier+1,precision); //modifier+1 = E => F or e => f
  72.         putchar(modifier);
  73.         if (exponent<0) {
  74.             putchar('-');
  75.             exponent*=-1;
  76.             }
  77.         print_number(exponent,10);
  78.         return;
  79.         }
  80.        
  81.  
  82.     /*
  83.     if (fmath_is_infinity(num)) {
  84.         print_str("Inf");
  85.         }
  86.     */
  87.     //TODO: rounding constant - when we got fraction >= 0.5, we must increment last printed number
  88.  
  89.     /* Here is problem with cumulative error while printing big double values -> we will divide
  90.     the number with a power of 10, print new number with better method for small numbers and then print decimal point at correct position */
  91.    
  92.     fmath_fint(fmath_get_decimal_exponent(num),&intval);
  93.    
  94.     exponent=(intval>0.0?intval:0);
  95.    
  96.     precision+=exponent;
  97.    
  98.     if (exponent>0) num = num / ((fmath_dpow(10.0,exponent)));
  99.        
  100.     num=fmath_fint(num,&intval);
  101.    
  102.     if (precision>0) {
  103.         counter=precision-1;
  104.         if (exponent>0) counter++;
  105.        
  106.         if (counter>=DEFAULT_DOUBLE_BUFFER_SIZE) {
  107.             counter=DEFAULT_DOUBLE_BUFFER_SIZE;
  108.         }
  109.         exponenttmp=exponent;
  110.         while(counter>=0) {
  111.             num *= 10.0;
  112.             num = fmath_fint(num,&intval2);
  113.             buf[counter--]=((int)intval2)+'0';
  114.             exponenttmp--;
  115.             if ((exponenttmp==0)&&(counter>=0)) buf[counter--]='.';
  116.         }
  117.         counter=precision;
  118.         if ((exponent==0)&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) buf[counter]='.';
  119.         counter++; 
  120.     } else {
  121.         counter=0; 
  122.     }
  123.    
  124.     if (intval==0.0) {
  125.         if (counter<DEFAULT_DOUBLE_BUFFER_SIZE) buf[counter++]='0';
  126.     } else {
  127.         in1=intval;
  128.         while(( in1>0 )&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) {
  129.            
  130.             in2=in1;
  131.             in1/=10;
  132.             buf[counter]=in2-in1*10 + '0';
  133.             counter++;
  134.         }
  135.     }
  136.    
  137.     counter = (counter>=DEFAULT_DOUBLE_BUFFER_SIZE?DEFAULT_DOUBLE_BUFFER_SIZE:counter);
  138.     while (counter>0) {
  139.         putchar(buf[--counter]);
  140.     };
  141.     return;
  142. }
  143.  
  144. /** Print NULL terminated string
  145.  *
  146.  * Print characters from str using putchar() until
  147.  * \x00 character is reached.
  148.  *
  149.  * @param str Characters to print.
  150.  *
  151.  */
  152. void print_str(const char *str)
  153. {
  154.     int i = 0;
  155.     char c;
  156.    
  157.     while (c = str[i++])
  158.         putchar(c);
  159. }
  160.  
  161.  
  162. /** Print hexadecimal digits
  163.  *
  164.  * Print fixed count of hexadecimal digits from
  165.  * the number num. The digits are printed in
  166.  * natural left-to-right order starting with
  167.  * the width-th digit.
  168.  *
  169.  * @param num   Number containing digits.
  170.  * @param width Count of digits to print.
  171.  *
  172.  */
  173. void print_fixed_hex(const __u64 num, const int width)
  174. {
  175.     int i;
  176.    
  177.     for (i = width*8 - 4; i >= 0; i -= 4)
  178.         putchar(digits[(num>>i) & 0xf]);
  179. }
  180.  
  181.  
  182. /** Print number in given base
  183.  *
  184.  * Print significant digits of a number in given
  185.  * base.
  186.  *
  187.  * @param num  Number to print.
  188.  * @param base Base to print the number in (should
  189.  *             be in range 2 .. 16).
  190.  *
  191.  */
  192. void print_number(const __native num, const unsigned int base)
  193. {
  194.     int val = num;
  195.     char d[sizeof(__native)*8+1];       /* this is good enough even for base == 2 */
  196.     int i = sizeof(__native)*8-1;
  197.    
  198.     do {
  199.         d[i--] = digits[val % base];
  200.     } while (val /= base);
  201.    
  202.     d[sizeof(__native)*8] = 0; 
  203.     print_str(&d[i + 1]);
  204. }
  205.  
  206.  
  207. /** General formatted text print
  208.  *
  209.  * Print text formatted according the fmt parameter
  210.  * and variant arguments. Each formatting directive
  211.  * begins with % (percentage) character and one of the
  212.  * following character:
  213.  *
  214.  * %    Prints the percentage character.
  215.  * s    The next variant argument is treated as char*
  216.  *      and printed as a NULL terminated string.
  217.  * c    The next variant argument is treated as a single char.
  218.  * p    The next variant argument is treated as a maximum
  219.  *      bit-width integer with respect to architecture
  220.  *      and printed in full hexadecimal width.
  221.  * P    As with 'p', but '0x' is prefixed.
  222.  * q    The next variant argument is treated as a 64b integer
  223.  *      and printed in full hexadecimal width.
  224.  * Q    As with 'q', but '0x' is prefixed.
  225.  * l    The next variant argument is treated as a 32b integer
  226.  *      and printed in full hexadecimal width.
  227.  * L    As with 'l', but '0x' is prefixed.
  228.  * w    The next variant argument is treated as a 16b integer
  229.  *      and printed in full hexadecimal width.
  230.  * W    As with 'w', but '0x' is prefixed.
  231.  * b    The next variant argument is treated as a 8b integer
  232.  *      and printed in full hexadecimal width.
  233.  * N    As with 'b', but '0x' is prefixed.
  234.  * d    The next variant argument is treated as integer
  235.  *      and printed in standard decimal format (only significant
  236.  *      digits).
  237.  * x    The next variant argument is treated as integer
  238.  *      and printed in standard hexadecimal format (only significant
  239.  *      digits).
  240.  * X    As with 'x', but '0x' is prefixed.
  241.  *
  242.  * All other characters from fmt except the formatting directives
  243.  * are printed in verbatim.
  244.  *
  245.  * @param fmt Formatting NULL terminated string.
  246.  *
  247.  */
  248. void printf(const char *fmt, ...)
  249. {
  250.     int irqpri, i = 0;
  251.     va_list ap;
  252.     char c;
  253.    
  254.     __u16 precision;
  255.    
  256.     va_start(ap, fmt);
  257.  
  258.     irqpri = cpu_priority_high();
  259.     spinlock_lock(&printflock);
  260.  
  261.     while (c = fmt[i++]) {
  262.         switch (c) {
  263.  
  264.            
  265.            
  266.             /* control character */
  267.             case '%':
  268.            
  269.                 precision = DEFAULT_DOUBLE_PRECISION;
  270.                 if (fmt[i]=='.') {
  271.                     precision=0;
  272.                     c=fmt[++i];
  273.                         while((c>='0')&&(c<='9')) {
  274.                             precision = precision*10 + c - '0';
  275.                             c=fmt[++i];
  276.                             }
  277.                        
  278.                 }
  279.            
  280.                 switch (c = fmt[i++]) {
  281.  
  282.                 /* percentile itself */
  283.                 case '%':
  284.                     break;
  285.  
  286.                 /*
  287.                  * String and character conversions.
  288.                  */
  289.                 case 's':
  290.                     print_str(va_arg(ap, char_ptr));
  291.                     goto loop;
  292.  
  293.                 case 'c':
  294.                     c = (char) va_arg(ap, int);
  295.                     break;
  296.  
  297.                 /*
  298.                          * Hexadecimal conversions with fixed width.
  299.                          */
  300.                 case 'P':
  301.                     print_str("0x");
  302.                 case 'p':
  303.                         print_fixed_hex(va_arg(ap, __native), sizeof(__native));
  304.                     goto loop;
  305.  
  306.                 case 'Q':
  307.                     print_str("0x");
  308.                 case 'q':
  309.                         print_fixed_hex(va_arg(ap, __u64), INT64);
  310.                     goto loop;
  311.  
  312.                 case 'L':
  313.                     print_str("0x");
  314.                 case 'l':
  315.                         print_fixed_hex(va_arg(ap, __native), INT32);
  316.                     goto loop;
  317.  
  318.                 case 'W':
  319.                     print_str("0x");
  320.                 case 'w':
  321.                         print_fixed_hex(va_arg(ap, __native), INT16);
  322.                     goto loop;
  323.  
  324.                 case 'B':
  325.                     print_str("0x");
  326.                 case 'b':
  327.                         print_fixed_hex(va_arg(ap, __native), INT8);
  328.                     goto loop;
  329.  
  330.                 /*
  331.                          * Floating point conversions.
  332.                          */
  333.                
  334.                 case 'F':
  335.                         print_double(va_arg(ap, double),'F',precision);
  336.                     goto loop;
  337.                    
  338.                 case 'f':
  339.                         print_double(va_arg(ap, double),'f',precision);
  340.                     goto loop;
  341.                
  342.                 case 'E':
  343.                         print_double(va_arg(ap, double),'E',precision);
  344.                     goto loop;
  345.                 case 'e':
  346.                         print_double(va_arg(ap, double),'e',precision);
  347.                     goto loop;
  348.                
  349.                 /*
  350.                          * Decimal and hexadecimal conversions.
  351.                          */
  352.                 case 'd':
  353.                         print_number(va_arg(ap, __native), 10);
  354.                     goto loop;
  355.  
  356.                 case 'X':
  357.                             print_str("0x");
  358.                 case 'x':
  359.                         print_number(va_arg(ap, __native), 16);
  360.                     goto loop;
  361.        
  362.                 /*
  363.                  * Bad formatting.
  364.                  */
  365.                 default:
  366.                     goto out;
  367.                 }
  368.  
  369.             default: putchar(c);
  370.         }
  371.    
  372. loop:
  373.         ;
  374.     }
  375.  
  376. out:
  377.     spinlock_unlock(&printflock);
  378.     cpu_priority_restore(irqpri);
  379.    
  380.     va_end(ap);
  381. }
  382.