可移植printf源码

最新推荐文章于 2024-09-01 18:54:53 发布
最新推荐文章于 2024-09-01 18:54:53 发布
阅读量3.7k 收藏 4
点赞数
分类专栏： ASM/WTL/MFC/QT

keil uvision 里常用到的函数~~


/* tab space = 4 */ 
/*********************************************************************
* DISCLAIMER:                                                        *
* The software supplied by Renesas Technology America Inc. is        *
* intended and supplied for use on Renesas Technology products.      *
* This software is owned by Renesas Technology America, Inc. or      *
* Renesas Technology Corporation and is protected under applicable   *
* copyright laws. All rights are reserved.                           *
*                                                                    *
* THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, *
* IMPLIED OR STATUTORY, INCLUDING BUT NOT LIMITED TO IMPLIED      *
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE *
* APPLY TO THIS SOFTWARE. RENESAS TECHNOLOGY AMERICA, INC. AND       *
* AND RENESAS TECHNOLOGY CORPORATION RESERVE THE RIGHT, WITHOUT      *
* NOTICE, TO MAKE CHANGES TO THIS SOFTWARE. NEITHER RENESAS          *
* TECHNOLOGY AMERICA, INC. NOR RENESAS TECHNOLOGY CORPORATION SHALL, *
* IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR        *
* CONSEQUENTIAL DAMAGES FOR ANY REASON WHATSOEVER ARISING OUT OF THE *
* USE OR APPLICATION OF THIS SOFTWARE.                               *
*********************************************************************/

/*-----------------------------------------------------------------------------
  FILE NAME: simple_printf.c
-----------
DESCRIPTION: Simplified printf and sprintf. (float and signed values no supported)
-----------
    DETAILS: 

------------------
 Revision History
------------------
   1.6 April 7, 2007
       Changed "..." access over to using standard "va_" macros for compatibility with other compilers.
   1.5 July 16, 2006
       Initialized local "s" in _print_out() in order to suppress compiler warning.
   1.4 April 28, 2006
       ROM/RAM reductions. Also NC30WA V.5.40 compatable.
   1.3 Feb 21, 2006
       Combined printf and sprintf functions
   1.2 Nov 15, 2005
       Fixed bug when using "%lx" or %lX
   1.1 Sept 8, 2005
       Fixed bug when using "%Ld"
       Fixed bug for sprintf (did not add NULL at end)
   1.0 ??, 2005
       Initial Version

-----------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdarg.h>

#if defined NC308
#define FAR _far
#elif defined NC30
#define FAR _far
#else
#define FAR
#endif

enum { UI, UH, UL, SI, SH, SL };
enum { LEFT_SPACE, PREFIX, ZERO_PAD, VALUE_TXT, RIGHT_SPACE, OUT_DONE};

static const struct
{
  char c[2];
  char size;
} prefix[]=
{
  {{0,0},0},      /* 0: default, no prefix */
  {{'-',0},1},    /* 1: minus sign */
  {{'+',0},1},    /* 2: plus sign */
  {{' ',0},1},    /* 3: space */
  {{'0','x'},2},  /* 4: hex 0x */
  {{'0','X'},2},  /* 5: hex 0X */
};

/* Function Prototypes */
int _print_out(char FAR *s, const char FAR *format, va_list sp);

int sprintf(char FAR *s, const char FAR *format, ...)
{
  int return_count;
  va_list sp;

  va_start(sp, format);

  return_count = _print_out(s, format, sp);
  va_end(sp);
  return (return_count);
}

int printf(const char FAR *format, ...)
{
  int return_count;
  va_list sp;

  va_start(sp, format);
  return_count = _print_out(NULL, format, sp);
  va_end(sp);
  return (return_count);
}

int _print_out(char FAR *s, const char FAR *format, va_list sp)
{
  int total = 0;

  char tmp_buf[12];                         /* maximum tmp_buf usage is 12 in %d */

  /* Loop through format string */
  while ( *format )                         /* loop till hit NULL */
  {
    unsigned char tmp_char, index, out_state;
    unsigned char left_justify = 0;         /* set default to right justify */
    unsigned char prefix_select = 0;        /* set default prefix to none */
    int  min_width = 0;            /* set default field min_width to 0 */
    int  precision = 0;            /* set default precision to 0 */
    unsigned char size_type = UI;           /* set default type to unsigned int */
    char const FAR * str_ptr = tmp_buf;    /* set default string source to buffer */

    union
    {
      unsigned long UL;
      signed long SL;
    } value;

    int str_len = 0;
    tmp_buf[0] = 0;

    if ( *format == '%' )                   /* start of escape characters */
    {
      out_state = PREFIX;
      do
      {
        format++;                           /* point to next character */

        /* Decode the flags */
        switch (*format)
        {
          case '0':
            precision = -1;                 /* if precision not explicitly set, this will zero fill min_width */
            break;
          case '#':
            prefix_select = 4;              /* exact prefix will be determined during type decode */
            break;
          case '+':
            prefix_select = 2;              /* this will be overriden if number is negative */
            break;
          case ' ':
            prefix_select = 3;              /* this will be overriden if number is negative */
            break;
          case '-':
            left_justify = 1;               /* left justification */
            break;
          default:
            out_state = OUT_DONE;           /* no flags left */
            break;
          }
        } while( out_state != OUT_DONE );

      /* check for minimum width */
      index = 0;
      while ( (*format >= '0') && (*format <= '9') )
      {
        min_width = (min_width * index * 10) + (*format - '0');
        index++;
        format++;
      }

      /* check for precision */
      if (*format == '.')
      {
        format++;
        index = 0;
        while ( (*format >= '0') && (*format <= '9') )
        {
          precision = (precision * index * 10) + (*format - '0');
          index++;
          format++;
        }
      }

      /* check for size specifier */
      switch(*format)
      {
        case 'h':
          size_type = UH;
          format++;
          break;
        case 'l':
          size_type = UL;
          format++;
          break;
        default:
          break;
      }


      /* check which type of varaible to print */
      switch(*format)
      {
        case '%':
        {
          /* output a '%' */
          tmp_buf[0] = '%';
          tmp_buf[1] = 0;
          str_len = 1;
          break;
        }
        
        case 'c':
        {
          /* output a single character */
          tmp_buf[0] = (char)va_arg(sp, int);
          tmp_buf[1] = 0;
          str_len = 1;
          break;
        }

        case 'd':
        case 'i':
          size_type += SI;
          /* flow through to decimal processing */

        case 'u':
        {
          /* output decimal value from stack */
          static const unsigned long base10[] = {1000000000,100000000,10000000,1000000,100000,10000,1000,100,10,1};

          /* convert all data types to long to ease later processing */
          switch (size_type)
          {
            default:
            case UI:
              value.UL = (unsigned long)va_arg(sp, unsigned int);
              break;

            case SI:
              value.SL = (signed long)va_arg(sp, signed int);
              break;

            case UH:
              value.UL = (unsigned long)(unsigned short)va_arg(sp, unsigned int);
              break;

            case SH:
              value.SL = (signed long)(signed short)va_arg(sp, signed int);
              break;

            case UL:
            case SL:
              value.UL = va_arg(sp, unsigned long);
              break;
          }

          /* convert signed values to positive as necessary and set prefix appropriately */
          if (size_type >= SI)
          {
            if (value.SL < 0)
            {
              value.SL = -value.SL;
              prefix_select = 1;
            }
          }

          /* write out decimal values to buffer...after suppressing zeros */
          for (index = 0; index < 10; index++)
          {
            tmp_char = (unsigned char)(value.UL/base10[index]);
            value.UL -= tmp_char * base10[index];
            tmp_buf[str_len] = tmp_char + '0';
            if ((tmp_char != 0) || (str_len !=0))
              str_len++;
          }

          if (str_len == 0)
            str_len = 1; /* if value was zero, we need to increment length */
          
          tmp_buf[str_len] = 0;
          break;
        }

        case 'X':
          if (prefix_select != 0) prefix_select++;
          /* fall through to processing */
        case 'x':  
        {
          /* output hex value from stack */
          static const char ascii_table_lower[] = "0123456789abcdef";
          static const char ascii_table_upper[] = "0123456789ABCDEF";
          static const char hex_shift[] = { 28, 24, 20, 16, 12, 8, 4, 0};

          /* convert all data types to long to ease later processing */
          switch (size_type)
          {
            default:
            case UI:
            case SI:
              value.UL = (unsigned long)va_arg(sp, unsigned int);
              break;

            case UH:
            case SH:
              value.UL = (unsigned long)(unsigned short)va_arg(sp, unsigned int);
              break;

            case UL:
            case SL:
              value.UL = va_arg(sp, unsigned long);
              break;
          }


          /* write out hex values to buffer...after suppressing initial zeros */
          for (index = 0; index < 8; index++)
          {
            tmp_char = (unsigned char)(value.UL >> hex_shift[index]) & 0x0F;
            tmp_buf[str_len] = (*format == 'x') ? ascii_table_lower[tmp_char] : ascii_table_upper[tmp_char];
            if ((tmp_char != 0) || (str_len !=0))
              str_len++;
          }

          if (str_len == 0)
            str_len = 1; /* if value was zero, we need to increment length */
          
          tmp_buf[str_len] = 0;
          break;
        }

        case 's':
        case 'S':
        {
          /* Add string from stack */
          char const FAR * t_str_ptr;

          str_ptr = t_str_ptr = va_arg(sp, char FAR *);
          while(*t_str_ptr)    /* find string length */
          {
            str_len++;
            t_str_ptr++;
          }
          break;
        }

        default:
        {
          /* non-processed format...inform user and try not to crash */
          static const char err_msg[]="!!NG!!";
          static const char err_fmt[]=" ";

          str_ptr = err_msg;
          str_len = (int)sizeof(err_msg)-1;
          format=err_fmt;
          
          break;
        }
      } /* switch end */
    } /* escape processing end */
    else
    {
      /* pass through Standard ASCII */
      index = 0;
      if( *format == '\n')    /* Add CR to LF */
        tmp_buf[str_len++] = '\r';

      tmp_buf[str_len++] = *format;
      tmp_buf[str_len] = 0;
    }

/*
if numeric format
    default precision = 0
    if width specified set precision to width-prefix size if zero pad
    if precision specified set precision to it
    set precision to str_len if str_len is greater

    space = min_width - precision - prefix size if greater than zero
    if left justify, space to right, else space to left, 
if string format
    if precision > 0, use to truncate string
 */    
    out_state=LEFT_SPACE;

    /* if precision is -1, field has been requested to zero pad */
    if (precision == -1)
      precision = min_width - prefix[prefix_select].size;

    if ((precision > 0) && (*format == 's'))
    {
      /* requesting string truncation... */
      if (str_len > precision)
        str_len = precision;

      /* zero precision to prevent zero padding */
      precision = 0;
    }

    /* precision now equals number of zero pads */
    precision = precision - str_len;

    /* min_width now equals number of spaces to add...left_justify will control at beginning or end of min_width */
    min_width = (min_width - str_len) - prefix[prefix_select].size;
    min_width -= (precision > 0) ? precision : 0;

    do
    {
      tmp_char = 0;

      switch (out_state)
      {
        case LEFT_SPACE:
        {
          if ((min_width > 0) && (left_justify == 0))
          {
            tmp_char = ' ';
            min_width--;
          }
          else
          {
            /* advance state */
            index = 0;
            out_state = PREFIX;
          }
          break;
        }
        case PREFIX:
        {
          tmp_char = prefix[prefix_select].c[index++];
          if (index >= prefix[prefix_select].size)
          {
            /* advance state */
            out_state = ZERO_PAD;
          }
          break;
        }
        case ZERO_PAD:
        {
          if (precision > 0)
          {
            tmp_char = '0';
            precision--;
          }
          else
          {
            /* advance state */
            precision = 0;
            out_state = VALUE_TXT;
          }
          break;
        }
        case VALUE_TXT:
        {
          tmp_char = str_ptr[precision++];    /* use precision for indexing because is type "int" */
          if (precision >= str_len)
          {
            /* advance state */
            out_state = RIGHT_SPACE;
          }
          break;
        }
        case RIGHT_SPACE:
        {
          if (min_width > 0)
          {
            tmp_char = ' ';
            min_width--;
          }
          else
          {
            /* advance state */
            out_state = OUT_DONE;
          }
          break;
        }
        default:
        {
          /* output complete */
          out_state = OUT_DONE;
          break;
        }
      }

      if (tmp_char != 0)
      {
        if(s != NULL)
          *s++ = tmp_char;
        else
          (void)putchar(tmp_char);
        total++;
      }

    }
    while (out_state!=OUT_DONE);

    format++;
  }   /* while format */

  /* Insert NULL at the end of the string */
  if(s != NULL)
    *s = 0;

  return total;
}


汪宁宇
关注
专栏目录
printf系列教程 - 源码工程.zip
06-03
8. **兼容性与跨平台**：了解`printf`在不同操作系统和编译器上的行为差异，以及如何确保代码的移植性。 9. **安全编程**：讨论`printf`函数在处理用户输入时的安全隐患，如格式字符串攻击，并提供预防措施。 通过...
单片机 printf 移植过程
shutcec的专栏
10-19 1624
在网上看到有人在单片机上使用printf函数，心痒痒，也想用，看了网上的一些方法， 大都是51单片机的，说的是在51单片机编译软件库中有自带printf函数，也有自己实现 一个自己的printf函数的，但是讲的不详细，看了好几个博客，东拼西凑，也在自己的 单片机上弄出来了。 1，先进行用到的知识讲解： 宏va_start(ap,fmt) 、 va_end(ap) 、va_arg(A,
一个移植十分方便的类似printf函数
ZHONGkunjia的专栏
04-22 1175
一个十分便于移植的类似printf函数，已测试通过。只需要实现SendChar()函数，把你要外发的字符（比如：发送到串口，显示屏等）写在这里即可。里面部分使用Renasas的源码，在这里尊重其版权。供大家使用，也请尊重我个人的辛勤汗水哈~ 源码如下： /*---------------------------------------------------------------------
scanf和printf介绍
最新发布
2302_80161960的博客
09-01 1015
scanf和printf介绍
利用C标准库函数vsprintf()实现多路串口使用“printf（）”输出
XL的博客
01-13 2455
在集成开发环境MDK下进行裸机开发，总避免不了使用printf（）函数，通过串口打印数据，进行通讯或者进行程序的可视化调试（通过串口，将调试信息打印到电脑端，进行分析），通常，会对printf()函数进行输出重定向。其中printf是c标准的库函数，包含在<stdio>文件里边，具体怎么实现我们不去深究，只要了解printf（）主要是通过调用fputc（）函数进行数据的输出，所以可以重写fputc()函数，重定向输出接口，例如，原子的例程如下： int fputc(int ch, FILE*
对printf源码的分析
Nod_Mouse的博客
03-11 4719
对printf源码的分析 一、printf的源码如下 #include <stdio.h> #include <stdarg.h> //va_start(arg,format),初始化参数指针arg，将函数参数format右边第一个参数地址赋值给arg //format必须是一个参数的指针，所以，此种类型函数至少要有一个普通的参数, //从而提供给va_start ,这样va_start才能找到可变参数在栈上的位置。 //va_arg(arg,char),获得arg指向参
C语言printf函数实现解读
WKYFP的博客
11-10 4406
C语言printf函数源码实现解读
printf_c#console._DEMO_printf_zip_源码
10-02
本示例代码"printf_c#console._DEMO_printf_zip_源码"提供了一个在C#中模拟`printf`功能的实现。 `printf`函数在C和C++中是一个非常强大的工具，它允许程序员以灵活的方式控制输出格式，包括整数、浮点数、字符串和...
printf.rar
08-13
"printf.rar"这个压缩包中包含的正是针对OK6410平台进行裸机开发时移植`printf`和`scanf`函数的相关代码，这对于调试和交互式程序设计至关重要。`printf`和`scanf`是C语言中的标准输入输出函数，用于格式化输出和...
stm32f103min移植liteos_重定向printf.zip
05-17
3. **LiteOS内核移植**：获取LiteOS源码，按照官方文档指导配置内核，适配STM32的启动代码，包括中断向量表、堆栈初始化等。 4. **编译与烧录**：使用IAR编译LiteOS内核及应用代码，生成可烧录的二进制文件，通过...
Linux下MFC的CString源码移植
12-11
4. **格式化功能**：MFC的CString支持类似于`printf`的格式化字符串插入，移植时需要实现类似的功能，如使用`snprintf`或`vsnprintf`等函数。 5. **其他操作**：CString提供了一些高级操作，如查找子串、替换子串、...
printf源代码分析
03-19
printf()函数是格式化输出函数, 一般用于向标准输出设备按规定格式输出信息。 printf()函数的调用格式为: printf("", )。 格式输出，它是c语言中产生格式化输出的函数（在 stdio.h 中定义）。用于向终端（显示器、控制台等）输出字符。格式控制由要输出的文字和数据格式说明组成。要输出的的文字除了可以使用字母、数字、空格和一些数字符号以外，还可以使用一些转义字符表示特殊的含义。
printf源码
ucas_123的博客
01-18 5891
int printf(const char *fmt, ...) { int i; int len; va_list args; va_start(args, fmt); len = vsprintf(g_pcOutBuf,fmt,args); va_end(args); for (i = 0; i < strlen(g_pcOutBuf); i
printf 函数：典型源码编写样例（摘录自 debian os 源码库）
ken2232的博客
01-20 936
printf 函数：典型源码编写样例（摘录自 debian os 源码库）
预编译宏写作规范
chenxq1111的专栏
09-17 513
对于代码中使用
C语言中printf、sprintf和fprintf的区别及示例源代码
BugHunterX的博客
10-06 178
这些函数在输出文本时提供了不同的目标位置，使得开发者能够根据需要选择适合的输出方式。无论是输出到控制台、字符串缓冲区还是文件，这些函数都提供了灵活且方便的方法来处理输出任务。本文将详细解释它们的区别，并提供相应的示例源代码。上述代码将在当前目录下创建一个名为"output.txt"的文本文件，并将"The number is: 10"写入该文件中。上述代码将输出"The number is: 10"到控制台。上述代码将输出"The number is: 10"到控制台。
printf()函数的底层实现
zion--6135的博客
06-05 1553
printf()的源码如下:需要了解va_list及我的上一篇博客va_start()的基本使用作为这篇文章的基础 static char sprint_buf[1024]; int printf(const char *fmt, ...) { va_list args; int n; va_start(args, fmt); //以传入的形参为内存基准 n = vsprintf(sprint_buf, fmt, args); va_end(args); //args指针置0 r
C语言 printf源码详解,从头一起学c语言（六）————printf函数的详解
weixin_36225248的博客
05-19 3785
这段时间很忙，更新的晚了，见谅。当然同样有今天我们的主角十分复杂，之前介绍了这个手记并非是面对新手的，而是我的复习手记。所以我们会讲头文件，或许有错误，如果有大手子看到，希望能够提出我的错误。printf函数的全称为格式化输出函数。之所以叫做格式化输出，是因为这个函数提供有多种格式化输出方式，可以向标准输出中输出某种格式的内容。本次的手记的目标是详细的讲述printf函数的用法，写法，原理。pri...
STM32 SPI方式FATFS移植笔记与源码分享
1. **获取FATFS源码**：推荐使用官方网站（）的R0.09版本，这是移植的基础。 2. **解压并理解文件结构**：从下载的zip包中，解压后有两个主要文件夹：doc包含文件系统的使用文档和详细说明，为后续编程提供参考；...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值