ttyio.c

来自「在ARM7和UC/OSII的平台上实现了GPS自动报站的功能,涉及GPS模块LE」· C语言 代码 · 共 771 行 · 第 1/2 页

/*
 * FILENAME: ttyio.c
 * 
 * Copyright 1995- 2000 By InterNiche Technologies Inc. All rights reserved
 *
 * This printf was 
 * originally designed to work on large model C on Intel 80x86 CPUs 
 * even if the stack segment != data segment. It assumes a "putchar" 
 * that does \n expansions and puts chars to stdout. An sprintf cound 
 * be built by redirecting putchar() to a buffer. (ie "#define 
 * putchar(c) bufchar(c, buf)").
 *
 * It currently understands: %d, %x, %u, %ld, %lx, %s, %c, %p.
 * %lu is treated as %ld; This only works for values up to 2147483647.
 *
 * This code is is NOT reentrant or sharable. It 
 * is designed for DOS TSRs, device drivers, etc. not for a system 
 * library. If you are working on an embedded system which already 
 * supports a printf, you should try to use that. Field width support 
 * is switchable via FIELDWIDTH below. This files routines take about 
 * 928 bytes with FIELDWIDTH switched out and about 720 bytes more 
 * with it switched in. (Compiled without stack probes on Microsoft c 
 * 5.1 small model ). Numerics are not trucated to fit field widths.
 *
 * MODULE: MISCLIB
 *
 * ROUTINES: dprintf(), printf(), sprintf(), doprint(), declong(),
 *
 * PORTABLE: yes
 */

/* Additional Copyrights: */
/* Portions Copyright 1990-1994 by NetPort Software */


#define  _IN_TTYIO_  1  /* switch to help out ipport.h */

#include "ipport.h"

#ifdef PRINTF_STDARG
#include <stdarg.h>
#endif
#include "zprint.h"
#include "errtask.h"
/* if target should not use target build environment's printf */
#ifndef NATIVE_PRINTF

#define  FIELDWIDTH     1        /* flag to switch in Field Width code */
#define  LINESIZE       144      /* max # chars per field */

int      maxfieldlen = LINESIZE; /* this can be set to control precision */

#ifdef FIELDWIDTH
int   setnum(char **);           /* fetch fieldwidth value from string */
int   fplen(char *, void *);     /* get field length of var */
#endif   /* FIELDWIDTH */

char     digits[] =  {"0123456789ABCDEF"};

/* local doprint helper routines. All take target as in doprint() */
static   void   hexbyte(char ** target, unsigned  x);
static   void   hexword(char ** target, unsigned  x);
static   void   declong(char ** target, long lg);

#ifdef PRINTF_STDARG
void   doprint(char * target, char * sp, va_list va);
#else
void   doprint(char * target, char * sp, int * vp);
#endif

/* (yaxon del) */
/*void  dputchar(int chr);          port-defined putchar substitue */

#ifdef dprintf
#undef dprintf
#endif

#ifdef printf
#undef printf
#endif

#define  doputchar(c)   {  if(target) *   target++ =  c; else  dputchar(c);   }

#ifdef PRINTF_STDARG

/* FUNCTION: dprintf()
 * 
 * PARAM1: char * fmt
 * PARAM2: ...
 *
 * RETURNS: 
 */

void 
dprintf(char * fmt, ...)
{
   /*va_list a;

   va_start(a, fmt);
   doprint(NULL, fmt, a);
   va_end(a);*/
   Printu(fmt);
}



/* FUNCTION: printf()
 * 
 * PARAM1: char * fmt
 * PARAM2: ...
 *
 * RETURNS: 
 */

void 
printf(char * fmt, ...)
{
 /*  va_list a;

   va_start(a, fmt);
   doprint(NULL, fmt, a);
   va_end(a);*/
   Printu(fmt);
}

#ifndef NATIVE_SPRINTF


/* FUNCTION: sprintf()
 * 
 * PARAM1: char * buf
 * PARAM2: char * fmt
 * PARAM3: ...
 *
 * RETURNS: 
 */
/* (yaxon modify) */
/*
void
sprintf(char * buf, char *   fmt, ...)
{
   va_list a;

   va_start(a, fmt);
   doprint(buf, fmt, a);
   va_end(a);

} */
int
sprintf_t(char * buf, const char *   fmt, ...)
{
   va_list a;

   va_start(a, fmt);
   doprint(buf, (char *)fmt, a);
   va_end(a);
   return 0;
}
#endif   /* NATIVE_SPRINTF */

#else    /* PRINTF_STDARG */

/* FUNCTION: dprintf()
 * 
 * PARAM1: char *sp
 * PARAM2: int var
 *
 * RETURNS: 
 */

void
dprintf(char * sp,      /* pointer to format string */
   int   var)  /* 1st of n variables on stack */
{
   doprint(NULL, sp, &var);   /* printf to stdio */
}



/* FUNCTION: printf()
 * 
 * PARAM1: char *sp
 * PARAM2: int var
 *
 * RETURNS: 
 */

void
printf(char * sp, /* pointer to format string */
   int   var)  /* 1st of n variables on stack */
{
   doprint(NULL, sp, &var);   /* printf to stdio */
}

#ifndef NATIVE_SPRINTF


/* FUNCTION: sprintf()
 * 
 * PARAM1: char * buf
 * PARAM2: char * fmt
 * PARAM3: int arg1
 *
 * RETURNS: 
 */

void
sprintf_t(char * buf, char * fmt, int arg1)
{
   doprint(buf, fmt, &arg1);
}
#endif   /* NATIVE_SPRINTF */

#endif   /* PRINTF_STDARG */



/* FUNCTION: doprint()
 * 
 * PARAM1: char * target
 * PARAM2: NULL for output to stdio
 * PARAM3: char * sp
 * PARAM4: va_list va
 *
 * RETURNS: 
 */

void
doprint(char * target,     /* NULL for output to stdio, else buffer pointer */
   char *   sp,      /* printf format string */
#ifdef PRINTF_STDARG
   va_list va) /* pointer to variables */
#else
   int * vp)      /* pointer to variables */ 
#endif   /* PRINTF_STDARG */
{
   char *   cp;
   unsigned prefill, postfill, fieldlen;     /* varibles for field len padding */
   int   swap;       /* flag and temp holder for prefill-postfill swap */
   unsigned char fillchar;
   unsigned minfieldlen;
   int   i  =  0;
   unsigned tmp = 0;
   unsigned long lng = 0;
#ifdef PRINTF_STDARG
   unsigned w0 = 0;
#ifdef SEG16_16
   unsigned w1;
#endif
   int   i0 = 0;
   unsigned char c = 0;
   char *   cap = 0;
   void *   varp;
#endif   /* PRINTF_STDARG */

   while (*sp)
   {
      if (*sp != '%')
      {
         doputchar(*sp++);
         continue;
      }

      /* fall to here if sp ==> '%' */
      sp++;       /* point past '%' */

      /* see if any field width control stuff is present */
      cp = sp;       /* save pointer to filed width data in cp */

      while (*sp == '-' || (*sp >= '0' && *sp <= '9') || *sp == '.')
         sp++;       /* scan past field control goodies */

#ifdef PRINTF_STDARG
      switch (*sp)
      {
      case 'p':      /* '%p' - pointer */
#ifdef SEG16_16   /* do seg:offset variety */
         w0 = va_arg(va, unsigned);
         w1 = va_arg(va, unsigned);
#else /* 32 bit flat */
         lng = va_arg(va, unsigned long);
#endif /* SEG16_16 */   /* else fall to 32 bit code */
         break;
      case 'x':      /* '%x' - this always does 0 prefill */
         tmp = va_arg(va, unsigned);
         break;
      case 'd':      /* '%d' */
         i0 = va_arg(va, int);
         break;
      case 'u':      /* '%u' */
         w0 = va_arg(va, unsigned);
         break;
      case 'c':      /* '%c' */
         c = (unsigned char)va_arg(va, unsigned);
         break;
      case 's':      /* '%s' */
         cap = va_arg(va, char *);
         break;
      case 'l':
         if (sp[1] == 'x' || sp[1] == 'd' || sp[1] == 'u')  /* '%lx', '%ld', or '%lu' */
         {
            lng = va_arg(va, unsigned long);
         }
         /*  else   '%l?', ignore it */
         break;
         default:       /* %?, ignore it */
         break;
      }  /* end switch *sp */
#endif   /* PRINTF_STDARG */

#ifdef FIELDWIDTH
      prefill = postfill = 0;       /* default to no filling */
      fillchar = ' ';               /* ...but fill with spaces, if filling */
      swap = TRUE;                  /* ...and swap prefill & postfill */
      if (sp != cp)  /* if there's field control stuff... */
      {
         if (*cp == '-')      /* field is to be left adjusted */
         {
            swap = FALSE;     /* leave pXXfill unswaped */
            cp++;
         }
         else swap = TRUE;    /* we will swap prefill & postfill later */

            /* set prefill, postfill for left adjustment */
         if (*cp == '0')   /* fill char is '0', not space default */
         {
            cp++;
            fillchar = '0';
         }
         else fillchar = ' ';

            minfieldlen = setnum(&cp);    /* get number, advance cp */
#ifdef PRINTF_STDARG
         switch (*sp)
         {
         case 's':
            varp = (void *)&cap;
            break;
         case 'd':
            varp = (void *)&i0;
            break;
         case 'u':
            varp = (void *)&w0;
            break;
         case 'l':
            varp = (void *)&lng;
            break;
            default:
            varp = NULL;
            break;
         }
         fieldlen = fplen(sp, varp);
#else
         fieldlen = fplen(sp, vp);        /* figger display size of this var */
#endif   /* PRINTF_STDARG */
         if (*cp == '.')   /* do we have a max field size? */
         {
            cp++;       /* point to number past '.' */
            maxfieldlen = setnum(&cp);
         }
         else
         {
            maxfieldlen = LINESIZE;
         }

         if (maxfieldlen < (int)fieldlen)
         {
            fieldlen = maxfieldlen;
         }
         if (minfieldlen > fieldlen)
         {
            postfill = minfieldlen - fieldlen;
         }
         else
         {
            postfill = 0;
         }
         if ((postfill + fieldlen) > LINESIZE)
         {
            postfill = 0;   /* sanity check*/
         }
      }

      if (swap)      /* caller wanted right adjustment, swap prefill/postfill */
      {
         swap = (int)prefill;