kolibrios/programs/develop/scc/Libstd.c

#include "stdio.h"
#include "clib.h"

/*
** Write string to standard output. 
*/
puts(string) char *string; 
{fputs(string,stdout);
 OS_fputc('\n',stdout);
}

/*
** reverse string in place 
*/
reverse(s) char *s; 
{char *j; int c;

 j=s+strlen(s)-1;
 while(s<j) 
 {c=*s;
  *s++ =*j;
  *j-- =c;
 }
}

/*
** copy t to s 
*/
strcpy(s,t) char *s,*t;
{char *d;

 d=s;
 while(*s++ =*t++);
 return (d);
}

/*
** return length of string s (fast version)
*/
strlen(s) char *s;
{char *ptr;

 ptr=s;
 while(*ptr)
 {++ptr;
 }

  return (ptr-s);
  
#ifdef _INASM  
  #asm
  xor al,al        ; set search value to zero
  mov cx,65535     ; set huge maximum
  mov di,[bp+4]    ; get address of s
  cld              ; set direction flag forward
  repne scasb      ; scan for zero
  mov ax,65534
  sub ax,cx        ; calc and return length
  #endasm
#endif
}

/*
** return upper-case of c if it is lower-case, else c
*/
toupper(c) int c;
{if(c<='z' && c>='a') return (c-32);
 return (c);
}

/*
** atoi(s) - convert s to integer.
*/
atoi(s) char *s;
{int sign,n;

 while(isspace(*s)) ++s;
 sign = 1;
 switch(*s) 
 {case '-': sign=-1;
  case '+': ++s;
 }
 n=0;
 while(isdigit(*s)) n=10*n+*s++ -'0';
 return (sign*n);
}

/*
** atoib(s,b) - Convert s to "unsigned" integer in base b.
**              NOTE: This is a non-standard function.
*/
atoib(s,b) char *s; int b;
{int n, digit;

 n=0;
 while(isspace(*s)) ++s;
 while((digit=(127 & *s++))>='0')
 {     if(digit>='a') digit-=87;
  else if(digit>='A') digit-=55;
  else                digit -= '0';
  if(digit>=b) break;
  n=b*n+digit;
 }
 return (n);
}

/*
** Gets an entire string (including its newline
** terminator) or size-1 characters, whichever comes
** first. The input is terminated by a null character.
** Entry: str  = Pointer to destination buffer.
**        size = Size of the destination buffer.
**        fd   = File descriptor of pertinent file.
** Returns str on success, else NULL.
*/
fgets(str,size,fd) char *str; unsigned size,fd;
{return (_gets(str,size,fd,1));
}

/*
** Gets an entire string from stdin (excluding its newline
** terminator) or size-1 characters, whichever comes
** first. The input is terminated by a null character.
** The user buffer must be large enough to hold the data.
** Entry: str  = Pointer to destination buffer.
** Returns str on success, else NULL.
*/
gets(str) char *str;
{return (_gets(str,32767,stdin,0));
}

_gets(str,size,fd,nl) char *str; unsigned size,fd,nl;
{int backup; char *next;

 next=str;
 while(--size>0)
 {switch (*next=fgetc(fd)) 
  {case  EOF:
    *next=NULL;
    if(next==str) return (NULL);
    return (str);

   case '\n':
    *(next+nl)=NULL;
    return (str);

   case  RUB: /* \b */
    if(next>str) backup=1;
    else         backup=0;
    goto backout;

   case WIPE: /* \r */
    backup=next-str;
backout: 
    if(0/*iscons(fd)*/) 
    {++size;
     while(backup--) 
     {fputs("\b \b",stderr);
      --next;++size;
     }
     continue;
    }

   default: 
    ++next;
  }
 }
 *next = NULL;
 return (str);
}

/*
** fprintf(fd, ctlstring, arg, arg, ...) - Formatted print.
** Operates as described by Kernighan & Ritchie.
** b, c, d, o, s, u, and x specifications are supported.
** Note: b (binary) is a non-standard extension.
*/
fprintf(argc) int argc;
{int *nxtarg;

 nxtarg=CCARGC()+&argc;
 return(_print(*(--nxtarg),--nxtarg));
}

/*
** printf(ctlstring, arg, arg, ...) - Formatted print.
** Operates as described by Kernighan & Ritchie.
** b, c, d, o, s, u, and x specifications are supported.
** Note: b (binary) is a non-standard extension.
*/
printf(argc) int argc;
{return(_print(stdout,CCARGC()+&argc-1));
}

/*
** _print(fd, ctlstring, arg, arg, ...)
** Called by fprintf() and printf().
*/
_print(fd,nxtarg) int fd,*nxtarg; 
{int arg,left,pad,cc,len,maxchr,width;
 char *ctl,*sptr,str[17];

 cc=0;                                         
 ctl=*nxtarg--;                          
 while(*ctl) 
 {if(*ctl!='%') {OS_fputc(*ctl++,fd); ++cc; continue;}
  else ++ctl;
  if(*ctl=='%') {OS_fputc(*ctl++,fd); ++cc; continue;}
  if(*ctl=='-') {left=1; ++ctl;} else left=0;       
  if(*ctl=='0') pad='0';
  else pad=' ';
  if(isdigit(*ctl))
  {width=atoi(ctl++);
   while(isdigit(*ctl)) ++ctl;
  }else width=0;
  if(*ctl=='.') 
  {maxchr=atoi(++ctl);
   while(isdigit(*ctl)) ++ctl;
  }else maxchr=0;
  arg=*nxtarg--;
  sptr=str;
  switch(*ctl++)
  {case 'c': str[0]=arg; str[1]=NULL; break;
   case 's': sptr=arg;          break;
   case 'd': itoa(arg,str);     break;
   case 'b': itoab(arg,str,2);  break;
   case 'o': itoab(arg,str,8);  break;
   case 'u': itoab(arg,str,10); break;
   case 'x': itoab(arg,str,16); break;
   default: return (cc);
  }
  len=strlen(sptr);
  if(maxchr && maxchr<len) len=maxchr;
  if(width>len) width=width-len; else width=0; 
  if(!left) while(width--) {OS_fputc(pad,fd); ++cc;}
  while(len--) {OS_fputc(*sptr++,fd); ++cc;}
  if(left) while(width--) {OS_fputc(pad,fd); ++cc;}  
 }
 return (cc);
}

/*
** Write a string to fd. 
** Entry: string = Pointer to null-terminated string.
**        fd     = File descriptor of pertinent file.
*/
fputs(string,fd) char *string; int fd;
{while(*string)
     OS_fputc(*string++,fd);
}

/*
** All character classification functions except isascii().
** Integer argument (c) must be in ASCII range (0-127) for
** dependable answers.
*/

#define ALNUM     1
#define ALPHA     2
#define CNTRL     4
#define DIGIT     8
#define GRAPH    16
#define LOWER    32
#define PRINT    64
#define PUNCT   128
#define BLANK   256
#define UPPER   512
#define XDIGIT 1024

int _is[128] =
{0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
 0x004, 0x104, 0x104, 0x104, 0x104, 0x104, 0x004, 0x004,
 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
 0x140, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459,
 0x459, 0x459, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
 0x0D0, 0x653, 0x653, 0x653, 0x653, 0x653, 0x653, 0x253,
 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
 0x253, 0x253, 0x253, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
 0x0D0, 0x473, 0x473, 0x473, 0x473, 0x473, 0x473, 0x073,
 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
 0x073, 0x073, 0x073, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x004
};

isalnum (c) int c; {return (_is[c] & ALNUM );} /* 'a'-'z', 'A'-'Z', '0'-'9' */
isalpha (c) int c; {return (_is[c] & ALPHA );} /* 'a'-'z', 'A'-'Z' */
iscntrl (c) int c; {return (_is[c] & CNTRL );} /* 0-31, 127 */
isdigit (c) int c; {return (_is[c] & DIGIT );} /* '0'-'9' */
isgraph (c) int c; {return (_is[c] & GRAPH );} /* '!'-'~' */
islower (c) int c; {return (_is[c] & LOWER );} /* 'a'-'z' */
isprint (c) int c; {return (_is[c] & PRINT );} /* ' '-'~' */
ispunct (c) int c; {return (_is[c] & PUNCT );} /* !alnum && !cntrl && !space */
isspace (c) int c; {return (_is[c] & BLANK );} /* HT, LF, VT, FF, CR, ' ' */
isupper (c) int c; {return (_is[c] & UPPER );} /* 'A'-'Z' */
isxdigit(c) int c; {return (_is[c] & XDIGIT);} /* '0'-'9', 'a'-'f', 'A'-'F' */

/*
** itoa(n,s) - Convert n to characters in s 
*/
itoa(n,s) char *s; int n;
{int sign;
 char *ptr;

 ptr=s;
 if((sign=n)<0) n=-n;
 do
 {*ptr++ =n%10+'0';
 }while((n=n/10)>0);
 if(sign<0) *ptr++='-';
 *ptr='\0';
 reverse(s);
}

/*
** itoab(n,s,b) - Convert "unsigned" n to characters in s using base b.
**                NOTE: This is a non-standard function.
*/
itoab(n,s,b) int n; char *s; int b;
{char *ptr;
 int lowbit;
 ptr=s;
 b >>= 1;
 do
 {lowbit=n&1;
  n=(n>>1)&32767;
  *ptr=((n%b)<<1)+lowbit;
  if(*ptr<10) *ptr+='0'; 
  else        *ptr+=55;
  ++ptr;
 }while(n/=b);
 *ptr=0;
 reverse(s);
}

/*
** itod -- convert nbr to signed decimal string of width sz
**         right adjusted, blank filled; returns str
**
**        if sz > 0 terminate with null byte
**        if sz = 0 find end of string
**        if sz < 0 use last byte for data
*/
itod(nbr,str,sz) int nbr; char str[]; int sz;
{char sgn;

 if(nbr<0) {nbr=-nbr; sgn='-';}
 else sgn=' ';
      if(sz>0) str[--sz]=NULL;
 else if(sz<0) sz=-sz;
 else while(str[sz]!=NULL) ++sz;
 while(sz)
 {str[--sz]=(nbr%10+'0');
  if((nbr=nbr/10)==0) break;
 }
 if(sz) str[--sz]=sgn;
 while(sz>0) str[--sz]=' ';
 return str;
}

/*
** itoo -- converts nbr to octal string of length sz
**         right adjusted and blank filled, returns str
**
**        if sz > 0 terminate with null byte
**        if sz = 0 find end of string
**        if sz < 0 use last byte for data
*/
itoo(nbr,str,sz) int nbr; char str[]; int sz;
{int digit;

      if(sz>0) str[--sz]=0;
 else if(sz<0) sz=-sz;
 else while(str[sz]!=0) ++sz;
 while(sz)
 {digit=nbr&7;nbr=(nbr>>3)&8191;
  str[--sz]=digit+48;
  if(nbr==0) break;
 }
 while(sz) str[--sz]=' ';
 return str;
}

/*
** itou -- convert nbr to unsigned decimal string of width sz
**         right adjusted, blank filled; returns str
**
**        if sz > 0 terminate with null byte
**        if sz = 0 find end of string
**        if sz < 0 use last byte for data
*/
itou(nbr,str,sz) int nbr; char str[]; int sz;
{int lowbit;

      if(sz>0) str[--sz]=NULL;
 else if(sz<0) sz=-sz;
 else while(str[sz]!=NULL) ++sz;
 while(sz)
 {lowbit=nbr&1;
  nbr=(nbr>>1)&32767;  /* divide by 2 */
  str[--sz]=((nbr%5)<<1)+lowbit+'0';
  if((nbr=nbr/5)==0) break;
 }
 while(sz) str[--sz]=' ';
 return str;
}

/*
** itox -- converts nbr to hex string of length sz
**         right adjusted and blank filled, returns str
**
**        if sz > 0 terminate with null byte
**        if sz = 0 find end of string
**        if sz < 0 use last byte for data
*/

itox(nbr,str,sz) int nbr; char str[]; int sz;
{int digit,offset;

      if(sz>0) str[--sz]=0;
 else if(sz<0) sz=-sz;
 else while(str[sz]!=0)	++sz;
 while(sz)
 {digit=nbr&15;
  nbr=nbr/16;
/*
  nbr=(nbr>>4)&4095; // 268435455; // 0xFFFFFFF
*/
  if(digit<10) offset=48;
  else         offset=55;
  str[--sz]=digit+offset;
  if(nbr==0) break;
 }
 while(sz) str[--sz]=' ';
 return str;
}