Subversion Repositories Kolibri OS

#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

 {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

  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;

}