#include "includes.h"
#define EXT extern
#include "main.h"


/*********************************************************************/

/* printp() ------------ a simply version of printf()                */

/**********************************************************************/
/* with the help of printp() function, you can get the out format as below:
   printp("This first line outputs the format string.\n");
   printp("%s\n","This second line outputs a string.");
   printp( "Notice that the first %s\n","two output lines had CR/LF at the end.");
   printp( "%c%c%c%c line outputs 'This' as chars.\n",'T', 'h', 'i', 's');
   printp( "Dec values: %d  %d   Hex value: %x\n",dec_value, neg_value, hex_value);
   printp( "Long dec values: %ld  %ld\n",ldec_value,lneg_value);
   printp( "Output sized strings: %20s %-20s\n","Right string","Left string");
   printp( "Output sized values:  %20d %-20d\n",dec_value,neg_value);
   printp( "                      %20x %-20x\n",hex_value,hex_value);
   printp( "                      %20ld %-20ld\n",ldec_value,ldec_value);
where the variables can be as:
   int hex_value = 0x1234;
   int dec_value = 1234;
   int neg_value = -1234;
   long ldec_value = 12345678L;
   long lneg_value = -12345678L;


修改了部分printp()代碼，
 打印時如果 %后面的x,d為大寫，打印的數作為無符號數
                      為小寫，作為有符號數
                 加l為取長型變量。

例如打印如下語句：

	printp("\n here i is 0xF123ABCD, j is 0xF123");
	printp("\n 1 : %%lX i is: %lX",i);
	printp("\n 2 : %%lx i is: %lx",i);
	printp("\n 3 : %%lD i is: %lD",i);
	printp("\n 4 : %%ld i is: %ld",i);
	printp("\n 5 : %%8X i is: %8X",i);
	printp("\n 6 : %%8x i is: %8x",i);
	printp("\n 7 : %%8D i is: %8D",i);
	printp("\n 8 : %%8d i is: %8d",i);
	printp("\n 9 :  %%X j is: %X",j);
	printp("\n 10:  %%x j is: %x",j);
	printp("\n 11:  %%D j is: %D",j);
	printp("\n 12:  %%d j is: %d",j);
結果為：
	 here i is 0xF123ABCD, j is 0xF123
	 1 : %lX i is: F123ABCD
	 2 : %lx i is: -EDC5433
	 3 : %lD i is: 4045646797
	 4 : %ld i is: -249320499
	 5 : %8X i is:     F123
	 6 : %8x i is:     -EDD
	 7 : %8D i is:    61731
	 8 : %8d i is:    -3805
	 9 :  %X j is: F123
	 10:  %x j is: -EDD
	 11:  %D j is: 61731
	 12:  %d j is: -3805  */
 
/************************************************************************/
#include <ctype.h>
#include <string.h>
#include <stdarg.h>

#ifndef  TRUE
#define  TRUE 1
#endif
#ifndef  FALSE
#define  FALSE 0
#endif

#define CR_as_CRLF  TRUE             // if true , you can use "\n" to act as CR/LF, 
                                     // if false , you have to use "\n\r",but can get a higher speed
static int do_padding;
static int left_flag;
static int len;
static int num1;					//number before dot. as 45 in %45.34s format.
static int num2;					//number after  dot. as 34 in %45.34s format. and num2 is only used in s format
static char pad_character;
/*---------------------------------------------------*/
/*                                                   */
/* This routine puts pad characters into the output  */
/* buffer.                                           */
/*                                                   */
static void padding(void (*PortToPut)(), const int l_flag)
{
   int i;

   if (do_padding && l_flag && (len < num1))
      for (i=len; i<num1; i++)
          PortToPut( pad_character);
   }

/*---------------------------------------------------*/
/*                                                   */
/* This routine moves a string to the output buffer  */
/* as directed by the padding and positioning flags. */
/*                                                   */
static void outs(void (*PortToPut)(), char* lp)
{
   /* pad on left if needed                          */
   len = strlen( lp);
   padding(PortToPut, !left_flag);

   /* Move string to the buffer                      */
   while (*lp && num2--)
      PortToPut( *lp++);

   /* Pad on right if needed                         */
   len = strlen( lp);
   padding(PortToPut, left_flag);
   }

/*---------------------------------------------------*/
/*                                                   */
/* This routine moves a number to the output buffer  */
/* as directed by the padding and positioning flags. */
/*                                                   */
static void reoutnum(void (*PortToPut)(),unsigned long num, unsigned int negative, const long base ) 
{
   char* cp;
   char outbuf[32];
   const char digits[] = "0123456789ABCDEF";
   
   /* Build number (backwards) in outbuf             */
   cp = outbuf;
   do {
      *cp++ = digits[(int)(num % base)];
      } while ((num /= base) > 0);
   if (negative)
      *cp++ = '-';
   *cp-- = 0;								//add a 0 in buffer is to use strlen function below

   /* Move the converted number to the buffer and    */
   /* add in the padding where needed.               */
   len = strlen(outbuf);
   padding(PortToPut, !left_flag);
   while (cp >= outbuf)
      PortToPut( *cp--);
   padding(PortToPut, left_flag);
}


static void outnum(void (*PortToPut)(),long num, const long base ,unsigned char sign)//1, signed  0 unsigned
{   unsigned int negative;

   if ( (num < 0L) && sign ) 
   {  negative=1;
      num = -num;
      }
   else negative=0;
   
   reoutnum(PortToPut,num,negative,base);  
} 
/*---------------------------------------------------*/
/*                                                   */
/* This routine gets a number from the format        */
/* string.                                           */
/*                                                   */
static int getnum( char** linep)						//in this routine ,the return value is the number after % or dot、－、l.
{														//and the ctrl(pointer to the format string) will change too.
   int n;
   char* cp;

   n = 0;
   cp = *linep;
   while (isdigit(*cp))
      n = n*10 + ((*cp++) - '0');
   *linep = cp;
   return(n);
}

/*---------------------------------------------------*/
/*                                                   */
/* This routine operates just like a printf/sprintf  */
/* routine. It outputs a set of data under the       */
/* control of a formatting string. Not all of the    */
/* standard C format control are supported. The ones */
/* provided are primarily those needed for embedded  */
/* systems work. Primarily the floaing point         */
/* routines are omitted. Other formats could be      */
/* added easily by following the examples shown for  */
/* the supported formats.                            */
/*                                                   */

void printp(void (*PortToPut)(), char* ctrl, ...)
{

   int long_flag;
   int dot_flag;										//dot_flag is only used in s format

   char ch;
   va_list argp;

   va_start( argp, ctrl);

   for ( ; *ctrl; ctrl++) {								//at the begin of for loop, check the char pointed by ctrl
														//if a %, extract numbers after % if they exist;
      /* move format string chars to buffer until a  */ //        then begin the format conversion and putout.
      /* format control is found.                    */ //if not a %, putout the char and start next for loop.
      if (*ctrl != '%') {
         PortToPut(*ctrl);
#if CR_as_CRLF==TRUE         
         if(*ctrl=='\n') PortToPut('\r');
#endif         
         continue;
         }

      /* initialize all the flags for this format.   */
      dot_flag   =
      long_flag  =
      left_flag  =
      do_padding = 0;
      pad_character = ' ';
      num2=32767;					// largest unsigned number

try_next:
      ch = *(++ctrl);

      if (isdigit(ch)) {
         if (dot_flag)
            num2 = getnum(&ctrl);
         else {
            if (ch == '0')
               pad_character = '0';

            num1 = getnum(&ctrl);		//in getnum function, ctrl is changed to point to the next value after numbers 
            do_padding = 1;				//in the format string.
         }
         ctrl--;				//here, adjust ctrl point to the last char in numbers to fit the sentense ch = *(++ctrl);
         goto try_next;
      }

      switch (tolower(ch)) {		//the ch is the char after % or %numbers in format string
         case '%':
              PortToPut( '%');
              continue;				//if %, putout % and start next for loop

         case '-':
              left_flag = 1;
              break;				//if -,  left align    out switch and goto try_next to see the next char
									//go to try_next to get another format char
         case '.':
              dot_flag = 1;
              break;				//a number after dot is used in s format to direct the out char number
									//go to try_next to get another format char
         case 'l':
              long_flag = 1;		
              break;				//l means long
									//go to try_next to get another format char
         case 'd':		//D unsigned ,  d signed
              if (long_flag ==1 ) {
              		if(ch == 'D')                {outnum(PortToPut, va_arg(argp, unsigned long), 10L , 0);continue;}
              	        else  /* ch == 'd' */        {outnum(PortToPut, va_arg(argp, long), 10L,1);continue;}
                 }								//va_arg will extract a special type argument from the stack
              else {							//and adjust the argp to point to next argument in stack
              		if(ch == 'D')                {outnum(PortToPut, va_arg(argp, unsigned int),10L,0);continue;}
              		else  /* ch == 'd' */        {outnum(PortToPut, va_arg(argp, int), 10L,1);continue;}
                }
                
         case 'x':    // X unsigned ， x  signed
              if (long_flag ==1 )  {
              	        if(ch == 'X')                {outnum(PortToPut, va_arg(argp, unsigned long), 16L,0);continue;}
              	        else  /* ch == 'x' */        {outnum(PortToPut, va_arg(argp, long), 16L,1);continue;} 
                 }
              else {
              		if(ch == 'X')                {outnum(PortToPut, va_arg(argp, unsigned int), 16L,0);continue;}
              		else  /* ch == 'x' */        {outnum(PortToPut, va_arg(argp, int), 16L,1);continue;}
                 } 

         case 's':
              outs(PortToPut, va_arg( argp, char*));
              continue;				//output a string with special format as -10.8s and start next for loop

         case 'c':
              PortToPut( va_arg( argp, int));
              continue;				//output a char and start next for loop

         default:
              continue;
         }
      goto try_next;				//execute only if there is '-' or '.' or 'l' in format
      }								//end of for loop
   va_end( argp);					//end arguments extraction
   }


/***********delay(long j)*************/

void delay(long j){
long i;
for(i=0;i<j;i++)
{};
}