├── src └── lib │ ├── sfio │ ├── Make.state │ ├── features │ │ ├── stdio_lcl │ │ └── iffeio │ ├── Sfio_dc │ │ ├── sfdchdr.h │ │ ├── Makefile │ │ ├── sfdisc.h │ │ ├── sfdcslow.c │ │ └── sfdctee.c │ ├── Makestate.sh │ ├── _sfslen.c │ ├── Stdio_s │ │ ├── stdfgetc.c │ │ ├── stdgetc.c │ │ ├── stdputc.c │ │ ├── stdfputc.c │ │ ├── stdgetw.c │ │ ├── stdtmpfile.c │ │ ├── stdputw.c │ │ ├── stdio_s.h │ │ ├── stdfflush.c │ │ ├── stdfreopen.c │ │ ├── stdfopen.c │ │ ├── stdpopen.c │ │ ├── stdfread.c │ │ ├── stdprintf.c │ │ ├── stdfwrite.c │ │ ├── stdfdopen.c │ │ ├── stdscanf.c │ │ ├── stdfprintf.c │ │ ├── stdfscanf.c │ │ ├── stdsetvbuf.c │ │ ├── Makefile │ │ ├── stdgets.c │ │ └── stdsprintf.c │ ├── _sfeof.c │ ├── _sfgetc.c │ ├── _sfllen.c │ ├── _sfulen.c │ ├── _sfdlen.c │ ├── _sferror.c │ ├── _sfclrerr.c │ ├── _sffileno.c │ ├── _sfvalue.c │ ├── _sfstacked.c │ ├── _sfputc.c │ ├── sfputl.c │ ├── sfputu.c │ ├── sfputd.c │ ├── Stdio_t │ │ ├── stdtest.h │ │ ├── treopen.c │ │ ├── tputgetc.c │ │ ├── tlinux.c │ │ ├── twrrd.c │ │ ├── tmesg.h │ │ ├── tfseek.c │ │ ├── tlocale.c │ │ └── tlongjmp.c │ ├── Stdio_b │ │ ├── pclose.c │ │ ├── perror.c │ │ ├── flockfile.c │ │ ├── fpurge.c │ │ ├── funlockfile.c │ │ ├── ftrylockfile.c │ │ ├── setlinebuf.c │ │ ├── ungetc.c │ │ ├── setbuf.c │ │ ├── rewind.c │ │ ├── vsscanf.c │ │ ├── getc.c │ │ ├── putw.c │ │ ├── cleanup.c │ │ ├── gets.c │ │ ├── getw.c │ │ ├── puts.c │ │ ├── getchar.c │ │ ├── setbuffer.c │ │ ├── putc.c │ │ ├── putchar.c │ │ ├── ast54.sym │ │ ├── fclose.c │ │ ├── fileno.c │ │ ├── feof.c │ │ ├── ferror.c │ │ ├── vfprintf.c │ │ ├── vfscanf.c │ │ ├── vscanf.c │ │ ├── vprintf.c │ │ ├── doscan.c │ │ ├── clearerr.c │ │ ├── sscanf.c │ │ ├── doprnt.c │ │ ├── popen.c │ │ ├── vsnprintf.c │ │ ├── fputs.c │ │ ├── fgets.c │ │ ├── scanf.c │ │ ├── printf.c │ │ ├── vsprintf.c │ │ ├── fdopen.c │ │ ├── fprintf.c │ │ ├── fgetc.c │ │ ├── fscanf.c │ │ ├── stdio.def │ │ ├── fputc.c │ │ ├── setvbuf.c │ │ ├── fread.c │ │ ├── fwrite.c │ │ ├── tmpfile.c │ │ ├── fgetpos.c │ │ ├── snprintf.c │ │ ├── fsetpos.c │ │ ├── fflush.c │ │ ├── fopen.c │ │ ├── flsbuf.c │ │ ├── sprintf.c │ │ ├── freopen.c │ │ ├── filbuf.c │ │ ├── ftell.c │ │ ├── stdextern.c │ │ ├── fseek.c │ │ └── no_stdio.h │ ├── sfputm.c │ ├── sfnotify.c │ ├── sfllen.c │ ├── _sfgetl.c │ ├── _sfgetu.c │ ├── Sfio_rm │ │ ├── sffcvt.c │ │ ├── sfecvt.c │ │ └── sfpeek.c │ ├── Sfio_t │ │ ├── tputgetl.c │ │ ├── tputgetc.c │ │ ├── tputgetu.c │ │ ├── tputgetm.c │ │ ├── tleak.c │ │ ├── tlongdouble.c │ │ ├── tstatus.c │ │ ├── tfmt.c │ │ ├── twrrd.c │ │ ├── sftest.h │ │ ├── tputgetd.c │ │ ├── tshare.c │ │ ├── tsetfd.c │ │ ├── tputgetr.c │ │ ├── tswap.c │ │ ├── tatexit.c │ │ ├── topen.c │ │ ├── tpipemove.c │ │ ├── tstkpk.c │ │ ├── tnotify.c │ │ ├── trcrv.c │ │ ├── tpopen.c │ │ ├── tlocale.c │ │ ├── thole.c │ │ ├── tmpread.c │ │ ├── talign.c │ │ ├── ttmpfile.c │ │ ├── tpkrd.c │ │ ├── tsfstr.c │ │ ├── tgetr.c │ │ ├── tnoseek.c │ │ ├── tscanf1.c │ │ ├── twhole.c │ │ ├── tpopenrw.c │ │ ├── tmmap2read.c │ │ ├── tmode.c │ │ ├── tmove.c │ │ ├── tbadargs.c │ │ ├── tungetc.c │ │ ├── tappend.c │ │ ├── tflags.c │ │ ├── terrno.c │ │ ├── tmwrite.c │ │ └── tsetbuf.c │ ├── sffcvt.c │ ├── sfecvt.c │ ├── sfopen.c │ ├── _sfgetl2.c │ ├── _sfgetu2.c │ ├── sfdlen.c │ ├── sfgetu.c │ ├── sfio_s.h │ ├── sfgetm.c │ ├── sftell.c │ ├── sfclrlock.c │ ├── sfprints.c │ ├── sfmutex.c │ ├── sfgetl.c │ ├── NOTICE │ ├── sfgetd.c │ ├── sfnputc.c │ ├── _sfputu.c │ ├── sfresize.c │ ├── NOTES │ ├── _sfputm.c │ ├── _sfputl.c │ ├── _sfputd.c │ ├── sfscanf.c │ ├── sfpeek.c │ ├── sfset.c │ ├── sfprintf.c │ ├── sfpurge.c │ ├── sfraise.c │ ├── sfsk.c │ ├── sfungetc.c │ ├── sfsize.c │ ├── sfstack.c │ └── sfflsbuf.c │ └── vthread │ ├── Vthread_t │ ├── vttest.h │ └── runtest │ ├── vtextern.c │ ├── vtmtxclose.c │ ├── vtself.c │ ├── vtset.c │ ├── vtkill.c │ ├── vtrun.c │ ├── features │ └── vthread │ ├── vtonce.c │ ├── vtwait.c │ ├── vtclose.c │ ├── README │ ├── NOTICE │ ├── vtmtxtrylock.c │ ├── Makefile │ ├── vtmtxlock.c │ ├── vtmtxopen.c │ └── vtmtxclrlock.c ├── Runmake ├── NOTICE └── README /src/lib/sfio/Make.state: -------------------------------------------------------------------------------- 1 | unithreaded 2 | -------------------------------------------------------------------------------- /src/lib/sfio/features/stdio_lcl: -------------------------------------------------------------------------------- 1 | lcl stdio 2 | -------------------------------------------------------------------------------- /src/lib/vthread/Vthread_t/vttest.h: -------------------------------------------------------------------------------- 1 | #include "terror.h" 2 | #include 3 | -------------------------------------------------------------------------------- /src/lib/vthread/vtextern.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | Vtextern_t _Vtextern; 4 | Vtonce_t _Vtonce = VTONCE_INITDATA; 5 | -------------------------------------------------------------------------------- /Runmake: -------------------------------------------------------------------------------- 1 | mkdir -p ./lib 2 | mkdir -p ./include 3 | (cd ./src/lib/vthread; make install) 4 | (cd ./src/lib/sfio; make install) 5 | -------------------------------------------------------------------------------- /src/lib/sfio/features/iffeio: -------------------------------------------------------------------------------- 1 | iff SFSTDIO 2 | cat{ 3 | #include "FEATURE/common" 4 | #include "FEATURE/stdio.lcl" 5 | }end 6 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_dc/sfdchdr.h: -------------------------------------------------------------------------------- 1 | #ifndef _SFDCHDR_H 2 | #define _SFDCHDR_H 1 3 | 4 | #include "sfhdr.h" 5 | #include 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /src/lib/sfio/Makestate.sh: -------------------------------------------------------------------------------- 1 | if test "`cat Make.state`" != "$1" 2 | then rm *.o Stdio_b/*.o Stdio_s/*.o Sfio_f/*.o 3 | fi >/dev/null 2>&1 4 | echo "$1" > Make.state 5 | exit 0 6 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfslen.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfslen 4 | 5 | #if __STD_C 6 | ssize_t sfslen(void) 7 | #else 8 | ssize_t sfslen() 9 | #endif 10 | { 11 | return __sf_slen(); 12 | } 13 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfgetc.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | #if __STD_C 4 | int _stdfgetc(FILE* f) 5 | #else 6 | int _stdfgetc(f) 7 | FILE* f; 8 | #endif 9 | { 10 | return f ? sfgetc(f) : -1; 11 | } 12 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdgetc.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | #if __STD_C 4 | int _stdgetc(FILE* f) 5 | #else 6 | int _stdgetc(f) 7 | FILE* f; 8 | #endif 9 | { 10 | return f ? _std_getc(f) : -1; 11 | } 12 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfeof.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfeof 4 | 5 | #if __STD_C 6 | int sfeof(reg Sfio_t* f) 7 | #else 8 | int sfeof(f) 9 | reg Sfio_t* f; 10 | #endif 11 | { 12 | return __sf_eof(f); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfgetc.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfgetc 4 | 5 | #if __STD_C 6 | int sfgetc(reg Sfio_t* f) 7 | #else 8 | int sfgetc(f) 9 | reg Sfio_t* f; 10 | #endif 11 | { 12 | return __sf_getc(f); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfllen.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfllen 4 | 5 | #if __STD_C 6 | int sfllen(reg Sflong_t v) 7 | #else 8 | int sfllen(v) 9 | reg Sflong_t v; 10 | #endif 11 | { 12 | return __sf_llen(v); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfulen.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfulen 4 | 5 | #if __STD_C 6 | int sfulen(reg Sfulong_t v) 7 | #else 8 | int sfulen(v) 9 | reg Sfulong_t v; 10 | #endif 11 | { 12 | return __sf_ulen(v); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfdlen.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfdlen 4 | 5 | #if __STD_C 6 | int sfdlen(reg Sfdouble_t v) 7 | #else 8 | int sfdlen(v) 9 | reg Sfdouble_t v; 10 | #endif 11 | { 12 | return __sf_dlen(v); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/_sferror.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sferror 4 | 5 | #if __STD_C 6 | int sferror(reg Sfio_t* f) 7 | #else 8 | int sferror(f) 9 | reg Sfio_t* f; 10 | #endif 11 | { 12 | return __sf_error(f); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdputc.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | #if __STD_C 4 | int _stdputc(int c, FILE* f) 5 | #else 6 | int _stdputc(c, f) 7 | int c; 8 | FILE* f; 9 | #endif 10 | { 11 | return f ? _std_putc(c,f) : -1; 12 | } 13 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfclrerr.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfclrerr 4 | 5 | #if __STD_C 6 | int sfclrerr(reg Sfio_t* f) 7 | #else 8 | int sfclrerr(f) 9 | reg Sfio_t* f; 10 | #endif 11 | { 12 | return __sf_clrerr(f); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/_sffileno.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sffileno 4 | 5 | #if __STD_C 6 | int sffileno(reg Sfio_t* f) 7 | #else 8 | int sffileno(f) 9 | reg Sfio_t* f; 10 | #endif 11 | { 12 | return __sf_fileno(f); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfvalue.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfvalue 4 | 5 | #if __STD_C 6 | ssize_t sfvalue(reg Sfio_t* f) 7 | #else 8 | ssize_t sfvalue(f) 9 | reg Sfio_t* f; 10 | #endif 11 | { 12 | return __sf_value(f); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfstacked.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfstacked 4 | 5 | #if __STD_C 6 | int sfstacked(reg Sfio_t* f) 7 | #else 8 | int sfstacked(f) 9 | reg Sfio_t* f; 10 | #endif 11 | { 12 | return __sf_stacked(f); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfputc.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | #undef putc 3 | 4 | #if __STD_C 5 | int _stdfputc(int c, FILE* f) 6 | #else 7 | int _stdfputc(c, f) 8 | int c; 9 | FILE* f; 10 | #endif 11 | { 12 | return f ? sfputc(f,c) : -1; 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfputc.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfputc 4 | 5 | #if __STD_C 6 | int sfputc(reg Sfio_t* f, reg int c) 7 | #else 8 | int sfputc(f,c) 9 | reg Sfio_t* f; 10 | reg int c; 11 | #endif 12 | { 13 | return __sf_putc(f,c); 14 | } 15 | -------------------------------------------------------------------------------- /src/lib/sfio/sfputl.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfputl 4 | 5 | #if __STD_C 6 | int sfputl(reg Sfio_t* f, Sflong_t l) 7 | #else 8 | int sfputl(f,l) 9 | reg Sfio_t* f; 10 | reg Sflong_t l; 11 | #endif 12 | { 13 | return __sf_putl(f,l); 14 | } 15 | -------------------------------------------------------------------------------- /src/lib/sfio/sfputu.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfputu 4 | 5 | #if __STD_C 6 | int sfputu(reg Sfio_t* f, Sfulong_t u) 7 | #else 8 | int sfputu(f,u) 9 | reg Sfio_t* f; 10 | reg Sfulong_t u; 11 | #endif 12 | { 13 | return __sf_putu(f,u); 14 | } 15 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdgetw.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | #if __STD_C 4 | int _stdgetw(FILE* f) 5 | #else 6 | int _stdgetw(f) 7 | FILE* f; 8 | #endif 9 | { 10 | int w; 11 | 12 | return (f && sfread(f, &w, sizeof(int)) == sizeof(int)) ? w : -1; 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/sfputd.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfputd 4 | 5 | #if __STD_C 6 | int sfputd(reg Sfio_t* f, Sfdouble_t d) 7 | #else 8 | int sfputd(f,d) 9 | reg Sfio_t* f; 10 | reg Sfdouble_t d; 11 | #endif 12 | { 13 | return __sf_putd(f,d); 14 | } 15 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_t/stdtest.h: -------------------------------------------------------------------------------- 1 | #include "../FEATURE/sfio" 2 | #include "terror.h" 3 | #include 4 | #ifndef SEEK_SET 5 | #define SEEK_SET 0 6 | #endif 7 | #ifndef SEEK_CUR 8 | #define SEEK_CUR 1 9 | #endif 10 | #ifndef SEEK_END 11 | #define SEEK_END 2 12 | #endif 13 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/pclose.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Closing a popen stream 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int pclose(reg FILE* f) 10 | #else 11 | int pclose(f) 12 | reg FILE* f; 13 | #endif 14 | { 15 | return fclose(f); 16 | } 17 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdtmpfile.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Open a temp stream. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | Sfio_t* _stdtmpfile() 9 | { 10 | Sfio_t* f; 11 | 12 | if((f = sftmp(0)) ) 13 | f->flags |= SF_MTSAFE; 14 | 15 | return f; 16 | } 17 | -------------------------------------------------------------------------------- /src/lib/sfio/sfputm.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #undef sfputm 4 | 5 | #if __STD_C 6 | int sfputm(Sfio_t* f, Sfulong_t u, Sfulong_t m) 7 | #else 8 | int sfputm(f,u,m) 9 | Sfio_t* f; 10 | Sfulong_t u; 11 | Sfulong_t m; 12 | #endif 13 | { 14 | return __sf_putm(f, u, m); 15 | } 16 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdputw.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | #if __STD_C 4 | int _stdputw(int w, FILE* f) 5 | #else 6 | int _stdputw(w, f) 7 | int w; 8 | FILE* f; 9 | #endif 10 | { 11 | if(!f) 12 | return -1; 13 | 14 | (void)sfwrite(f, &w, sizeof(int)); 15 | return sferror(f); 16 | } 17 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_t/treopen.c: -------------------------------------------------------------------------------- 1 | #include "stdtest.h" 2 | 3 | MAIN() 4 | { 5 | FILE *fp; 6 | 7 | if(!(fp = freopen("/dev/null", "w", stdout)) ) 8 | terror("Can't reopen stdout\n"); 9 | if(fp != stdout) 10 | terror("Didn't get the right file pointer\n"); 11 | 12 | TSTEXIT(0); 13 | } 14 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdio_s.h: -------------------------------------------------------------------------------- 1 | #ifndef _STDIO_S_H 2 | #define _STDIO_S_H 1 3 | 4 | 5 | #include "FEATURE/sfio" 6 | 7 | #if _typ___FILE /* Redhat7.3 requires __FILE in wchar.h */ 8 | typedef struct _sfio_s *__FILE; 9 | #endif 10 | 11 | #include "sfhdr.h" 12 | #include "stdio.h" 13 | 14 | #endif /*_STDIO_S_H*/ 15 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/perror.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | #include "string.h" 3 | 4 | #if __STD_C 5 | void perror(const char* s) 6 | #else 7 | void perror(s) 8 | char* s; 9 | #endif 10 | { 11 | char* err; 12 | extern int errno; 13 | 14 | if((err = strerror(errno)) ) 15 | sfprintf(sfstderr,"%s: %s\n", s ? s : "", err); 16 | } 17 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/flockfile.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Lock a file stream. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | void flockfile(FILE* f) 9 | #else 10 | void flockfile(f) 11 | reg FILE* f; 12 | #endif 13 | { 14 | Sfio_t* sf; 15 | 16 | if(!(sf = _sfstream(f))) 17 | return; 18 | 19 | (void)sfmutex(sf, SFMTX_LOCK); 20 | } 21 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fpurge.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Junk all buffered data 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int fpurge(reg FILE* f) 10 | #else 11 | int fpurge(f) 12 | reg FILE* f; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | 17 | if(!(sf = _sfstream(f))) 18 | return -1; 19 | 20 | return sfpurge(sf); 21 | } 22 | -------------------------------------------------------------------------------- /src/lib/sfio/sfnotify.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | 4 | /* Set the function to be called when a stream is opened or closed 5 | ** 6 | ** Written by Kiem-Phong Vo. 7 | */ 8 | #if __STD_C 9 | int sfnotify(void (*notify)(Sfio_t*, int, int)) 10 | #else 11 | int sfnotify(notify) 12 | void (*notify)(); 13 | #endif 14 | { 15 | _Sfnotify = notify; 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/funlockfile.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Try to unlock a file 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | void funlockfile(FILE* f) 9 | #else 10 | void funlockfile(f) 11 | reg FILE* f; 12 | #endif 13 | { 14 | Sfio_t* sf; 15 | 16 | if(!(sf = _sfstream(f))) 17 | return; 18 | 19 | (void)sfmutex(sf, SFMTX_UNLOCK); 20 | } 21 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/ftrylockfile.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Try to lock a file 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int ftrylockfile(FILE* f) 9 | #else 10 | int ftrylockfile(f) 11 | reg FILE* f; 12 | #endif 13 | { 14 | Sfio_t* sf; 15 | 16 | if(!(sf = _sfstream(f))) 17 | return 0; 18 | 19 | return sfmutex(sf, SFMTX_TRYLOCK); 20 | } 21 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/setlinebuf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Set line mode 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int setlinebuf(reg FILE* f) 10 | #else 11 | int setlinebuf(f) 12 | reg FILE* f; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | 17 | if(!(sf = _sfstream(f))) 18 | return -1; 19 | 20 | sfset(sf,SF_LINE,1); 21 | return(0); 22 | } 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/ungetc.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Put back an input byte. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int ungetc(int c, FILE* f) 9 | #else 10 | int ungetc(c,f) 11 | reg int c; 12 | reg FILE* f; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | 17 | if(!(sf = _sfstream(f))) 18 | return -1; 19 | 20 | return sfungetc(sf,c); 21 | } 22 | -------------------------------------------------------------------------------- /src/lib/sfio/sfllen.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Get size of a long value coded in a portable format 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | #if __STD_C 8 | int _sfllen(Sflong_t v) 9 | #else 10 | int _sfllen(v) 11 | Sflong_t v; 12 | #endif 13 | { 14 | if(v < 0) 15 | v = -(v+1); 16 | v = (Sfulong_t)v >> SF_SBITS; 17 | return 1 + (v > 0 ? sfulen(v) : 0); 18 | } 19 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/setbuf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Change stream buffer 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | void setbuf(reg FILE* f, char* buf) 10 | #else 11 | void setbuf(f,buf) 12 | reg FILE* f; 13 | char* buf; 14 | #endif 15 | { 16 | reg Sfio_t* sf; 17 | 18 | if(!(sf = _sfstream(f))) 19 | return; 20 | 21 | (void)sfsetbuf(sf,(Void_t*)buf,BUFSIZ); 22 | } 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/rewind.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Reposition IO pointer to origin 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | void rewind(reg FILE* f) 10 | #else 11 | void rewind(f) 12 | reg FILE* f; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | 17 | if(!(sf = _sfstream(f))) 18 | return; 19 | 20 | (void)sfseek(sf, (Sfoff_t)0, 0|SF_SHARE); 21 | 22 | clearerr(f); 23 | } 24 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/vsscanf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Internal scanf engine to read from a string buffer 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int vsscanf(char* s, const char* form, va_list args) 9 | #else 10 | int vsscanf(s,form,args) 11 | reg char* s; 12 | reg char* form; 13 | va_list args; 14 | #endif 15 | { 16 | return (s && form) ? (int)sfvsscanf(s,form,args) : -1; 17 | } 18 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfgetl.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* 4 | * for backwards compatibility with pre-threaded sfgetl() inline 5 | */ 6 | 7 | #ifdef __EXPORT__ 8 | #define extern __EXPORT__ 9 | #endif 10 | 11 | extern 12 | #if __STD_C 13 | Sflong_t _sfgetl(reg Sfio_t* f) 14 | #else 15 | Sflong_t _sfgetl(f) 16 | reg Sfio_t* f; 17 | #endif 18 | { 19 | sfungetc(f, (unsigned char)_SF_(f)->val); 20 | return sfgetl(f); 21 | } 22 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfgetu.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* 4 | * for backwards compatibility with pre-threaded sfgetl() inline 5 | */ 6 | 7 | #ifdef __EXPORT__ 8 | #define extern __EXPORT__ 9 | #endif 10 | 11 | extern 12 | #if __STD_C 13 | Sfulong_t _sfgetu(reg Sfio_t* f) 14 | #else 15 | Sfulong_t _sfgetu(f) 16 | reg Sfio_t* f; 17 | #endif 18 | { 19 | sfungetc(f, (unsigned char)_SF_(f)->val); 20 | return sfgetu(f); 21 | } 22 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_rm/sffcvt.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #if __STD_C 4 | char *sffcvt(double dval, int n_digit, int* decpt, int* sign) 5 | #else 6 | char *sffcvt(dval,n_digit,decpt,sign) 7 | double dval; /* value to convert */ 8 | int n_digit; /* number of digits wanted */ 9 | int* decpt; /* to return decimal point */ 10 | int* sign; /* to return sign */ 11 | #endif 12 | { 13 | return _sfcvt(&dval,n_digit,decpt,sign,0); 14 | } 15 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_rm/sfecvt.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #if __STD_C 4 | char* sfecvt(double dval, int n_digit, int* decpt, int* sign) 5 | #else 6 | char* sfecvt(dval,n_digit,decpt,sign) 7 | double dval; /* value to convert */ 8 | int n_digit; /* number of digits wanted */ 9 | int* decpt; /* to return decimal point */ 10 | int* sign; /* to return sign */ 11 | #endif 12 | { 13 | return _sfcvt(&dval,n_digit,decpt,sign,F_EFORMAT); 14 | } 15 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/getc.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Get a byte 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int getc(reg FILE* f) 9 | #else 10 | int getc(f) 11 | reg FILE* f; 12 | #endif 13 | { 14 | return fgetc(f); 15 | } 16 | 17 | #if _lib_getc_unlocked && !_done_getc_unlocked && !defined(getc) 18 | #define _done_getc_unlocked 1 19 | #define getc getc_unlocked 20 | #include "getc.c" 21 | #undef getc 22 | #endif 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfflush.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | #if __STD_C 4 | int _stdfflush(FILE* f) 5 | #else 6 | int _stdfflush(f) 7 | FILE* f; 8 | #endif 9 | { 10 | if(!f) 11 | return -1; 12 | if(f->extent >= 0 && !(f->mode&SF_INIT)) 13 | (void)sfseek(f, (Sfoff_t)0, SEEK_CUR|SF_PUBLIC); 14 | if((f->mode&SF_WRITE) && sfsync(f) < 0) 15 | return -1; 16 | if((f->mode&SF_READ) && sfpurge(f) < 0) 17 | return -1; 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/putw.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Write out a word 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int putw( int c, FILE* f) 10 | #else 11 | int putw(c, f) 12 | int c; 13 | reg FILE* f; 14 | #endif 15 | { 16 | reg Sfio_t* sf; 17 | 18 | if(!(sf = _sfstream(f))) 19 | return -1; 20 | 21 | if(sfwrite(sf,(char*)(&c),sizeof(int)) <= 0) 22 | _stdseterr(f,sf); 23 | 24 | return sferror(sf); 25 | } 26 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/cleanup.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* 4 | ** Cleanup actions before exiting 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if !_PACKAGE_ast && !_lib_atexit && !_lib_on_exit && !_lib_onexit && _exit_cleanup 9 | static int _Sfio_already_has_cleanup; 10 | #else 11 | 12 | #if __STD_C 13 | void _cleanup(void) 14 | #else 15 | void _cleanup() 16 | #endif 17 | { 18 | if(_Sfcleanup) 19 | (*_Sfcleanup)(); 20 | } 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/gets.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Get a string from stdin. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | char* gets(char* buf) 9 | #else 10 | char* gets(buf) 11 | char* buf; 12 | #endif 13 | { 14 | reg Sfio_t* sf; 15 | reg char* rv; 16 | 17 | if(!buf || !(sf = _sfstream(stdin))) 18 | return NIL(char*); 19 | 20 | if(!(rv = _stdgets(sf,buf,BUFSIZ,1))) 21 | _stdseterr(stdin,sf); 22 | return rv; 23 | } 24 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/getw.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Get a word. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int getw(FILE* f) 10 | #else 11 | int getw(f) 12 | reg FILE* f; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | int w; 17 | 18 | if(!(sf = _sfstream(f))) 19 | return -1; 20 | 21 | if(sfread(sf,(char*)(&w),sizeof(int)) != sizeof(int)) 22 | { _stdseterr(f,sf); 23 | return -1; 24 | } 25 | else return w; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/puts.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Write out a string to stdout. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int puts(const char* str) 10 | #else 11 | int puts(str) 12 | reg char* str; 13 | #endif 14 | { 15 | reg int rv; 16 | reg Sfio_t* sf; 17 | 18 | if(!str || !(sf = _sfstream(stdout))) 19 | return -1; 20 | 21 | if((rv = sfputr(sfstdout,str,'\n')) < 0) 22 | _stdseterr(stdout,sf); 23 | return rv; 24 | } 25 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/getchar.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | 4 | /* Get a byte from stdin. 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | int getchar(void) 10 | #else 11 | int getchar() 12 | #endif 13 | { 14 | return fgetc(stdin); 15 | } 16 | 17 | #if _lib_getchar_unlocked && !_done_getchar_unlocked && !defined(getchar) 18 | #define _done_getchar_unlocked 1 19 | #define getchar getchar_unlocked 20 | #include "getchar.c" 21 | #undef getchar 22 | #endif 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/setbuffer.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Change stream buffer 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int setbuffer(reg FILE* f, char* buf, size_t size) 10 | #else 11 | int setbuffer(f,buf, size) 12 | reg FILE* f; 13 | char* buf; 14 | size_t size; 15 | #endif 16 | { 17 | reg Sfio_t* sf; 18 | 19 | if(!(sf = _sfstream(f))) 20 | return -1; 21 | 22 | sfsetbuf(sf,(Void_t*)buf, buf ? size : 0); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/putc.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Write out a byte 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int putc(int c, FILE* f) 10 | #else 11 | int putc(c, f) 12 | reg int c; 13 | reg FILE* f; 14 | #endif 15 | { 16 | return fputc(c,f); 17 | } 18 | 19 | #if _lib_putc_unlocked && !_done_putc_unlocked && !defined(putc) 20 | #define _done_putc_unlocked 1 21 | #define putc putc_unlocked 22 | #include "putc.c" 23 | #undef putc 24 | #endif 25 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tputgetl.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | int i, r; 6 | Sfio_t *fp; 7 | 8 | if(!(fp = sftmp(8))) 9 | terror("Can't open temp file\n"); 10 | 11 | for(i = -5448; i <= 5448; i += 101) 12 | if(sfputl(fp,(long)i) < 0) 13 | terror("Writing %d\n",i); 14 | 15 | sfseek(fp,(Sfoff_t)0,0); 16 | 17 | for(i = -5448; i <= 5448; i += 101) 18 | if((r = (int)sfgetl(fp)) != i) 19 | terror("Input=%d, Expect=%d\n",r,i); 20 | 21 | TSTEXIT(0); 22 | } 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tputgetc.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | 4 | MAIN() 5 | { Sfio_t *f; 6 | int i, c; 7 | 8 | if(!(f = sftmp(8))) 9 | terror("Can't open temp file\n"); 10 | 11 | for(i = 0; i < 10000; ++i) 12 | if(sfputc(f,(i%26)+'a') < 0) 13 | terror("Writing %c\n",(i%26)+'a'); 14 | 15 | sfseek(f,(Sfoff_t)0,0); 16 | 17 | for(i = 0; i < 10000; ++i) 18 | if((c = sfgetc(f)) != ((i%26)+'a')) 19 | terror("Input=%#o, Expect=%c\n",c,(i%26)+'a'); 20 | 21 | TSTEXIT(0); 22 | } 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/putchar.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Write out a byte to stdout. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int putchar(int c) 9 | #else 10 | int putchar(c) 11 | reg int c; 12 | #endif 13 | { 14 | return fputc(c,stdout); 15 | } 16 | 17 | #if _lib_putchar_unlocked && !_done_putchar_unlocked && !defined(putchar) 18 | #define _done_putchar_unlocked 1 19 | #define putchar putchar_unlocked 20 | #include "putchar.c" 21 | #undef putchar 22 | #endif 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tputgetu.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | unsigned int i, r; 6 | Sfio_t *fp; 7 | 8 | if(!(fp = sftmp(8))) 9 | terror("Can't open temp file\n"); 10 | 11 | for(i = 10000; i <= 100000; i += 9) 12 | if(sfputu(fp,i) < 0) 13 | terror("Writing %u\n",i); 14 | 15 | sfseek(fp,(Sfoff_t)0,0); 16 | 17 | for(i = 10000; i <= 100000; i += 9) 18 | if((r = (unsigned int)sfgetu(fp)) != i) 19 | terror("Input=%u, Expect=%u\n",r,i); 20 | 21 | TSTEXIT(0); 22 | } 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_t/tputgetc.c: -------------------------------------------------------------------------------- 1 | #include "stdtest.h" 2 | 3 | 4 | MAIN() 5 | { FILE *f; 6 | int i, c; 7 | 8 | if(!(f = fopen(tstfile(0), "w+")) ) 9 | terror("Can't open temp file\n"); 10 | 11 | for(i = 0; i < 10000; ++i) 12 | if(fputc((i%26)+'a', f) < 0) 13 | terror("Writing %c\n",(i%26)+'a'); 14 | 15 | fseek(f, 0L, 0); 16 | 17 | for(i = 0; i < 10000; ++i) 18 | if((c = fgetc(f)) != ((i%26)+'a')) 19 | terror("Input=%#o, Expect=%c\n",c,(i%26)+'a'); 20 | 21 | TSTEXIT(0); 22 | } 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/ast54.sym: -------------------------------------------------------------------------------- 1 | _Sfextern data 2 | _sfdlen 3 | _sffilbuf 4 | _sfflsbuf 5 | _sfllen 6 | _sfmode 7 | _sfputd 8 | _sfputl 9 | _sfputm 10 | _sfputu 11 | _sftype 12 | _stdgets 13 | sfclose 14 | sfclrlock 15 | sfmutex 16 | sfnew 17 | sfopen 18 | sfpopen 19 | sfpurge 20 | sfputr 21 | sfread 22 | sfseek 23 | sfset 24 | sfsetbuf 25 | sfsprintf 26 | sfsync 27 | sfstderr data 28 | sfstdin data 29 | sfstdout data 30 | sftmp 31 | sfungetc 32 | sfvprintf 33 | sfvscanf 34 | sfvsprintf 35 | sfvsscanf 36 | sfwrite 37 | -------------------------------------------------------------------------------- /src/lib/sfio/sffcvt.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #if __STD_C 4 | char *sffcvt(double dval, int n_digit, int* decpt, int* sign) 5 | #else 6 | char *sffcvt(dval,n_digit,decpt,sign) 7 | double dval; /* value to convert */ 8 | int n_digit; /* number of digits wanted */ 9 | int* decpt; /* to return decimal point */ 10 | int* sign; /* to return sign */ 11 | #endif 12 | { 13 | int len; 14 | static char buf[SF_MAXDIGITS]; 15 | 16 | return _sfcvt((Sfdouble_t)dval,buf,sizeof(buf),n_digit,decpt,sign,&len,0); 17 | } 18 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fclose.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Closing a stream. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int fclose(reg FILE* f) 9 | #else 10 | int fclose(f) 11 | FILE* f; 12 | #endif 13 | { 14 | reg int rv; 15 | reg Sfio_t* sf; 16 | 17 | if(!(sf = _sfstream(f))) 18 | return -1; 19 | 20 | if((rv = sfclose(sf)) >= 0 && f != stdin && f != stdout && f != stderr) 21 | { _sfunmap(f); /* remove the FILE to Sfio_t map */ 22 | free(f); 23 | } 24 | 25 | return rv; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/sfecvt.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | #if __STD_C 4 | char* sfecvt(double dval, int n_digit, int* decpt, int* sign) 5 | #else 6 | char* sfecvt(dval,n_digit,decpt,sign) 7 | double dval; /* value to convert */ 8 | int n_digit; /* number of digits wanted */ 9 | int* decpt; /* to return decimal point */ 10 | int* sign; /* to return sign */ 11 | #endif 12 | { 13 | int len; 14 | static char buf[SF_MAXDIGITS]; 15 | 16 | return _sfcvt((Sfdouble_t)dval,buf,sizeof(buf),n_digit,decpt,sign,&len,SFFMT_EFORMAT); 17 | } 18 | -------------------------------------------------------------------------------- /src/lib/sfio/sfopen.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* 4 | * _sfopen() wrapper to allow user sfopen() intercept 5 | */ 6 | 7 | extern Sfio_t* _sfopen _ARG_((Sfio_t*, const char*, const char*)); 8 | 9 | #if __STD_C 10 | Sfio_t* sfopen(Sfio_t* f, const char* file, const char* mode) 11 | #else 12 | Sfio_t* sfopen(f,file,mode) 13 | Sfio_t* f; /* old stream structure */ 14 | char* file; /* file/string to be opened */ 15 | reg char* mode; /* mode of the stream */ 16 | #endif 17 | { 18 | return _sfopen(f, file, mode); 19 | } 20 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfreopen.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Open a stream given a file descriptor. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | Sfio_t* _stdfreopen(const char* file, const char* mode, Sfio_t* f) 10 | #else 11 | Sfio_t* _stdfreopen(file,mode,f) 12 | char* file; 13 | char* mode; 14 | Sfio_t* f; 15 | #endif 16 | { 17 | if((f = sfopen(f, file, mode)) ) 18 | { int uflag; 19 | _sftype(mode, NIL(int*), &uflag); 20 | if(!uflag) 21 | f->flags |= SF_MTSAFE; 22 | } 23 | 24 | return f; 25 | } 26 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tputgetm.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | unsigned int i, r; 6 | Sfio_t *fp; 7 | 8 | if(!(fp = sftmp(8))) 9 | terror("Can't open temp file\n"); 10 | 11 | for(i = 10000; i <= 100000; i += 9) 12 | if(sfputm(fp, (Sfulong_t)i, (Sfulong_t)100000) < 0) 13 | terror("Writing %u\n",i); 14 | 15 | sfseek(fp,(Sfoff_t)0,0); 16 | 17 | for(i = 10000; i <= 100000; i += 9) 18 | if((r = (unsigned int)sfgetm(fp,(Sfulong_t)100000)) != i) 19 | terror("Input=%u, Expect=%u\n",r,i); 20 | 21 | TSTEXIT(0); 22 | } 23 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fileno.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Return file number. 4 | ** Written by Kiem-Phong Vo. 5 | */ 6 | 7 | #if __STD_C 8 | int fileno(FILE* f) 9 | #else 10 | int fileno(f) 11 | FILE* f; 12 | #endif 13 | { 14 | reg Sfio_t* sf; 15 | 16 | if(!(sf = _sfstream(f))) 17 | return -1; 18 | return sffileno(sf); 19 | } 20 | 21 | #if _lib_fileno_unlocked && !_done_fileno_unlocked && !defined(fileno) 22 | #define _done_fileno_unlocked 1 23 | #define fileno fileno_unlocked 24 | #include "fileno.c" 25 | #undef fileno 26 | #endif 27 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfopen.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Open a stream given a file descriptor. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | Sfio_t* _stdfopen(const char* file, reg const char* mode) 10 | #else 11 | Sfio_t* _stdfopen(file,mode) 12 | reg char* file; 13 | reg char* mode; 14 | #endif 15 | { 16 | Sfio_t* f; 17 | 18 | if((f = sfopen(NIL(Sfio_t*), file, mode)) ) 19 | { int uflag; 20 | _sftype(mode, NIL(int*), &uflag); 21 | if(!uflag) 22 | f->flags |= SF_MTSAFE; 23 | } 24 | 25 | return f; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdpopen.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Open a stream given a file descriptor. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | Sfio_t* _stdpopen(const char* file, reg const char* mode) 10 | #else 11 | Sfio_t* _stdpopen(file,mode) 12 | reg char* file; 13 | reg char* mode; 14 | #endif 15 | { 16 | Sfio_t* f; 17 | 18 | if((f = sfpopen((Sfio_t*)(-1), file, mode)) ) 19 | { int uflag; 20 | _sftype(mode, NIL(int*), &uflag); 21 | if(!uflag) 22 | f->flags |= SF_MTSAFE; 23 | } 24 | 25 | return f; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/feof.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Return the eof condition if any. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int feof(FILE* f) 9 | #else 10 | int feof(f) 11 | FILE* f; 12 | #endif 13 | { 14 | reg Sfio_t* sf; 15 | 16 | if(!(sf = _sfstream(f))) 17 | return -1; 18 | 19 | _stdseterr(f,sf); 20 | return sfeof(sf); 21 | } 22 | 23 | #if _lib_feof_unlocked && !_done_feof_unlocked && !defined(feof) 24 | #define _done_feof_unlocked 1 25 | #define feof feof_unlocked 26 | #include "feof.c" 27 | #undef feof 28 | #endif 29 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfread.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Read in a block of data 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | ssize_t _stdfread(Void_t* buf, size_t esize, size_t nelts, Sfio_t* f) 10 | #else 11 | ssize_t _stdfread(buf, esize, nelts, f) 12 | Void_t* buf; 13 | size_t esize; 14 | size_t nelts; 15 | Sfio_t* f; 16 | #endif 17 | { 18 | ssize_t rv; 19 | 20 | if(!f || !buf) 21 | return -1; 22 | 23 | if((rv = sfread(f, buf, esize*nelts)) >= 0) 24 | return esize == 0 ? 0 : rv/esize; 25 | else return 0; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdprintf.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | 4 | /* printf function 5 | ** 6 | ** Written by Kiem-Phong Vo. 7 | */ 8 | 9 | #if __STD_C 10 | int _stdprintf(const char *form, ...) 11 | #else 12 | int _stdprintf(va_alist) 13 | va_dcl 14 | #endif 15 | { 16 | va_list args; 17 | reg int rv; 18 | 19 | #if __STD_C 20 | va_start(args,form); 21 | #else 22 | reg char *form; 23 | va_start(args); 24 | form = va_arg(args,char*); 25 | #endif 26 | 27 | rv = form ? (int)sfvprintf(sfstdout,form,args) : -1; 28 | 29 | va_end(args); 30 | return rv; 31 | } 32 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfwrite.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Write out a block of data 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | ssize_t _stdfwrite(const Void_t* buf, size_t esize, size_t nelts, Sfio_t* f) 10 | #else 11 | ssize_t _stdfwrite(buf, esize, nelts, f) 12 | Void_t* buf; 13 | size_t esize; 14 | size_t nelts; 15 | Sfio_t* f; 16 | #endif 17 | { 18 | ssize_t rv; 19 | 20 | if(!f || !buf) 21 | return (ssize_t)(-1); 22 | 23 | if((rv = sfwrite(f, buf, esize*nelts)) > 0) 24 | return (esize == 0 ? 0 : rv/esize); 25 | else return 0; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfgetl2.c: -------------------------------------------------------------------------------- 1 | /* OBSOLETE 19961031 -- for shared library compatibility */ 2 | 3 | #include "sfhdr.h" 4 | 5 | #undef _sfgetl2 6 | 7 | _BEGIN_EXTERNS_ 8 | #if _BLD_sfio && defined(__EXPORT__) 9 | #define extern __EXPORT__ 10 | #endif 11 | 12 | extern long _sfgetl2 _ARG_((Sfio_t*, long)); 13 | 14 | #undef extern 15 | _END_EXTERNS_ 16 | 17 | #if __STD_C 18 | long _sfgetl2(reg Sfio_t* f, long v) 19 | #else 20 | long _sfgetl2(f, v) 21 | reg Sfio_t* f; 22 | long v; 23 | #endif 24 | { 25 | if (v < 0) 26 | return -1; 27 | sfungetc(f, v); 28 | return sfgetl(f); 29 | } 30 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfgetu2.c: -------------------------------------------------------------------------------- 1 | /* OBSOLETE 19961031 -- for shared library compatibility */ 2 | 3 | #include "sfhdr.h" 4 | 5 | #undef _sfgetu2 6 | 7 | _BEGIN_EXTERNS_ 8 | #if _BLD_sfio && defined(__EXPORT__) 9 | #define extern __EXPORT__ 10 | #endif 11 | 12 | extern long _sfgetu2 _ARG_((Sfio_t*, long)); 13 | 14 | #undef extern 15 | _END_EXTERNS_ 16 | 17 | #if __STD_C 18 | long _sfgetu2(reg Sfio_t* f, long v) 19 | #else 20 | long _sfgetu2(f, v) 21 | reg Sfio_t* f; 22 | long v; 23 | #endif 24 | { 25 | if (v < 0) 26 | return -1; 27 | sfungetc(f, v); 28 | return sfgetu(f); 29 | } 30 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/ferror.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Return the error condition if any. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int ferror(FILE* f) 9 | #else 10 | int ferror(f) 11 | FILE* f; 12 | #endif 13 | { 14 | reg Sfio_t* sf; 15 | 16 | if(!(sf = _sfstream(f))) 17 | return -1; 18 | 19 | _stdseterr(f,sf); 20 | return sferror(sf); 21 | } 22 | 23 | #if _lib_ferror_unlocked && _done_ferror_unlocked && !defined(ferror) 24 | #define _done_ferror_unlocked 1 25 | #define ferror ferror_unlocked 26 | #include "ferror.c" 27 | #undef ferror 28 | #endif 29 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/vfprintf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Internal printf engine. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int vfprintf(FILE* f, const char* form, va_list args) 9 | #else 10 | int vfprintf(f,form,args) 11 | FILE* f; 12 | char* form; /* format to use */ 13 | va_list args; /* arg list if argf == 0 */ 14 | #endif 15 | { 16 | reg int rv; 17 | reg Sfio_t* sf; 18 | 19 | if(!(sf = _sfstream(f))) 20 | return -1; 21 | 22 | if((rv = (int)sfvprintf(sf,form,args)) < 0) 23 | _stdseterr(f,sf); 24 | 25 | return rv; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/vfscanf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Internal scanf engine 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int vfscanf(FILE* f, const char* form, va_list args) 9 | #else 10 | int vfscanf(f,form,args) 11 | FILE* f; 12 | char* form; /* format to use */ 13 | va_list args; /* arg list if argf == 0 */ 14 | #endif 15 | { 16 | reg int rv; 17 | reg Sfio_t* sf; 18 | 19 | if(!form || !(sf = _sfstream(f))) 20 | return -1; 21 | 22 | if((rv = (int)sfvscanf(sf,form,args)) <= 0) 23 | _stdseterr(f,sf); 24 | 25 | return rv; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/vscanf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Internal scanf engine to read from stdin 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int vscanf(const char* form, va_list args) 9 | #else 10 | int vscanf(form,args) 11 | char* form; /* format to use */ 12 | va_list args; /* arg list if argf == 0 */ 13 | #endif 14 | { 15 | reg int rv; 16 | reg Sfio_t* sf; 17 | 18 | if(!form || !(sf = _sfstream(stdin))) 19 | return -1; 20 | 21 | if((rv = (int)sfvscanf(sf,form,args)) <= 0) 22 | _stdseterr(stdin,sf); 23 | 24 | return rv; 25 | } 26 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfdopen.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Open a stream given a file descriptor. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | Sfio_t* _stdfdopen(reg int fd, reg const char* mode) 10 | #else 11 | Sfio_t* _stdfdopen(fd,mode) 12 | reg int fd; 13 | reg char* mode; 14 | #endif 15 | { 16 | int sflags, uflag; 17 | 18 | if(fd < 0 || !mode || (sflags = _sftype(mode,NIL(int*),&uflag)) == 0) 19 | return NIL(Sfio_t*); 20 | if(!uflag) 21 | sflags |= SF_MTSAFE; 22 | return sfnew(NIL(Sfio_t*),NIL(Void_t*),(size_t)SF_UNBOUND,fd,sflags); 23 | } 24 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/vprintf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Internal printf engine to write to stdout 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int vprintf(const char* form, va_list args) 9 | #else 10 | int vprintf(form,args) 11 | char* form; /* format to use */ 12 | va_list args; /* arg list if argf == 0 */ 13 | #endif 14 | { 15 | reg int rv; 16 | reg Sfio_t* sf; 17 | 18 | if(!form || !(sf = _sfstream(stdout))) 19 | return -1; 20 | 21 | if((rv = (int)sfvprintf(sf,form,args)) < 0) 22 | _stdseterr(stdout,sf); 23 | 24 | return rv; 25 | } 26 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdscanf.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Read formatted data from a stream 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int _stdscanf(const char* form, ...) 10 | #else 11 | int _stdscanf(va_alist) 12 | va_dcl 13 | #endif 14 | { 15 | va_list args; 16 | reg int rv; 17 | 18 | #if __STD_C 19 | va_start(args,form); 20 | #else 21 | reg char *form; /* scanning format */ 22 | va_start(args); 23 | form = va_arg(args,char*); 24 | #endif 25 | 26 | rv = form ? (int)sfvscanf(sfstdin,form,args) : -1; 27 | va_end(args); 28 | return rv; 29 | } 30 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/doscan.c: -------------------------------------------------------------------------------- 1 | #define _in_doscan 1 2 | #include "sfstdio.h" 3 | 4 | /* The internal scanf engine in older stdios. 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | int _doscan(FILE *f, const char* form, va_list args) 10 | #else 11 | int _doscan(f,form,args) 12 | FILE* f; 13 | char* form; /* format to use */ 14 | va_list args; /* arg list if argf == 0 */ 15 | #endif 16 | { 17 | reg int rv; 18 | reg Sfio_t* sf; 19 | 20 | if(!(sf = _sfstream(f))) 21 | return -1; 22 | 23 | if((rv = (int)sfvscanf(sf,form,args)) <= 0) 24 | _stdseterr(f,sf); 25 | return rv; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_t/tlinux.c: -------------------------------------------------------------------------------- 1 | #include "stdtest.h" 2 | #include 3 | 4 | MAIN() 5 | { 6 | struct tm* tmbufp; 7 | time_t l1, l2; 8 | FILE* f; 9 | char buf[1024]; 10 | 11 | if(!(f = fopen(tstfile(0),"w+")) ) 12 | terror("Open file to write"); 13 | 14 | /* these sometimes call rare Stdio functions such as fread_unlocked. 15 | Hopefully, iffe did catch these and built them. 16 | */ 17 | l2 = time(&l1); 18 | tmbufp = localtime(&l2); 19 | 20 | fprintf(f, "%ld %ld %p", l1, l2, tmbufp); 21 | fseek(f, 0L, 0); 22 | fread(buf, 1, sizeof(buf), f); 23 | 24 | TSTEXIT(0); 25 | } 26 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/clearerr.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Clear error status from a stream 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | void clearerr(FILE* f) 10 | #else 11 | void clearerr(f) 12 | FILE* f; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | 17 | if(f && (sf = _sfstream(f)) ) 18 | { sfclrlock(sf); 19 | _stdclrerr(f); 20 | } 21 | } 22 | 23 | #if _lib_clearerr_unlocked && !_done_clearerr_unlocked && !defined(clearerr) 24 | #define _done_clearerr_unlocked 1 25 | #define clearerr clearerr_unlocked 26 | #include "clearerr.c" 27 | #undef clearerr 28 | #endif 29 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/sscanf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Scan data from a string 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int sscanf(const char* s, const char* form, ...) 9 | #else 10 | int sscanf(va_alist) 11 | va_dcl 12 | #endif 13 | { 14 | va_list args; 15 | reg int rv; 16 | #if __STD_C 17 | va_start(args,form); 18 | #else 19 | reg char* s; 20 | reg char* form; 21 | va_start(args); 22 | s = va_arg(args,char*); 23 | form = va_arg(args,char*); 24 | #endif 25 | 26 | rv = (s && form) ? (int)sfvsscanf(s,form,args) : -1; 27 | va_end(args); 28 | 29 | return rv; 30 | } 31 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/doprnt.c: -------------------------------------------------------------------------------- 1 | #define _in_doprnt 1 2 | #include "sfstdio.h" 3 | 4 | /* The internal printf engine in older stdios. 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int _doprnt(const char* form, va_list args, FILE* f) 10 | #else 11 | int _doprnt(form,args,f) 12 | char* form; /* format to use */ 13 | va_list args; /* arg list if argf == 0 */ 14 | FILE* f; 15 | #endif 16 | { 17 | reg int rv; 18 | reg Sfio_t* sf; 19 | 20 | if(!(sf = _sfstream(f)) ) 21 | return -1; 22 | 23 | if((rv = sfvprintf(sf,form,args)) < 0) 24 | _stdseterr(f,sf); 25 | return rv; 26 | } 27 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfprintf.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | 4 | /* fprintf function 5 | ** 6 | ** Written by Kiem-Phong Vo. 7 | */ 8 | 9 | #if __STD_C 10 | int _stdfprintf(Sfio_t* f, const char *form, ...) 11 | #else 12 | int _stdfprintf(va_alist) 13 | va_dcl 14 | #endif 15 | { 16 | va_list args; 17 | reg int rv; 18 | 19 | #if __STD_C 20 | va_start(args,form); 21 | #else 22 | reg Sfio_t* f; 23 | reg char* form; 24 | va_start(args); 25 | f = va_arg(args,Sfio_t*); 26 | form = va_arg(args,char*); 27 | #endif 28 | 29 | rv = (f && form) ? (int)sfvprintf(f,form,args) : -1; 30 | 31 | va_end(args); 32 | 33 | return rv; 34 | } 35 | -------------------------------------------------------------------------------- /src/lib/vthread/vtmtxclose.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | /* Free a mutex. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int vtmtxclose(Vtmutex_t* mtx) 10 | #else 11 | int vtmtxclose(mtx) 12 | Vtmutex_t* mtx; 13 | #endif 14 | { 15 | #if !vt_threaded 16 | return -1; 17 | #else 18 | 19 | if(!mtx) 20 | return -1; 21 | 22 | if(vtmtxclrlock(mtx) < 0) 23 | return -1; 24 | 25 | #if _WIN32 26 | DeleteCriticalSection(&mtx->lock); 27 | #else 28 | pthread_mutex_destroy(&mtx->lock); 29 | #endif /*_WIN32*/ 30 | 31 | if(mtx->state&VT_FREE) 32 | free(mtx); 33 | 34 | return 0; 35 | 36 | #endif /*vt_threaded*/ 37 | } 38 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/popen.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Opening a process as a stream 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | FILE* popen(const char* string,const char* mode) 10 | #else 11 | FILE* popen(string,mode) 12 | char* string; 13 | char* mode; 14 | #endif 15 | { 16 | reg Sfio_t* sf; 17 | reg FILE* f; 18 | 19 | if(!(sf = sfpopen((Sfio_t*)(-1), string, mode))) 20 | f = NIL(FILE*); 21 | else if(!(f = _stdstream(sf, NIL(FILE*)))) 22 | sfclose(sf); 23 | else 24 | { int uflag; 25 | _sftype(mode, NIL(int*), &uflag); 26 | if(!uflag) 27 | sf->flags |= SF_MTSAFE; 28 | } 29 | 30 | return(f); 31 | } 32 | -------------------------------------------------------------------------------- /src/lib/vthread/vtself.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | /* Identify self 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | Vthread_t* vtself() 9 | { 10 | #if !vt_threaded 11 | return NIL(Vthread_t*); 12 | #else 13 | Vthread_t* vt; 14 | _vtid_t id; 15 | int t; 16 | 17 | #if _WIN32 18 | #define IDEQUAL(id1,id2) (id1 == id2) 19 | id = GetCurrentThreadId(); 20 | #else 21 | #define IDEQUAL(id1,id2) pthread_equal(id1,id2) 22 | id = pthread_self(); 23 | #endif 24 | 25 | for(t = 0; t < _Vtnlist; ++t) 26 | if((vt = _Vtlist[t]) && IDEQUAL(id, vt->id) ) 27 | return vt; 28 | 29 | return NIL(Vthread_t*); 30 | 31 | #endif /*vt_threaded*/ 32 | } 33 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/vsnprintf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Internal printf engine to write to a string buffer 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int vsnprintf(char* s, size_t n, const char* form, va_list args) 9 | #else 10 | int vsnprintf(s,n,form,args) 11 | reg char* s; 12 | reg size_t n; 13 | reg char* form; 14 | va_list args; 15 | #endif 16 | { 17 | return (s && form) ? (int)sfvsprintf(s,n,form,args) : -1; 18 | } 19 | 20 | #if _lib___vsnprintf && !done_lib___vsnprintf && !defined(vsnprintf) 21 | #define done_lib___vsnprintf 1 22 | #define vsnprintf __vsnprintf 23 | #include "vsnprintf.c" 24 | #endif 25 | 26 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fputs.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Output a string. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int fputs(const char* s, FILE* f) 10 | #else 11 | int fputs(s, f) 12 | reg char* s; 13 | reg FILE* f; 14 | #endif 15 | { 16 | reg int rv; 17 | reg Sfio_t* sf; 18 | 19 | if(!s || !(sf = _sfstream(f))) 20 | return -1; 21 | 22 | if((rv = sfputr(sf,s,-1)) < 0) 23 | _stdseterr(f,sf); 24 | return rv; 25 | } 26 | 27 | #if _lib_fputs_unlocked && !_done_fputs_unlocked && !defined(fputs) 28 | #define _done_fputs_unlocked 1 29 | #define fputs fputs_unlocked 30 | #include "fputs.c" 31 | #undef fputs 32 | #endif 33 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdfscanf.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Read formatted data from a stream 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int _stdfscanf(Sfio_t* f, const char* form, ...) 10 | #else 11 | int _stdfscanf(va_alist) 12 | va_dcl 13 | #endif 14 | { 15 | va_list args; 16 | reg int rv; 17 | 18 | #if __STD_C 19 | va_start(args,form); 20 | #else 21 | reg Sfio_t* f; 22 | reg char* form; /* scanning format */ 23 | va_start(args); 24 | f = va_arg(args,Sfio_t*); 25 | form = va_arg(args,char*); 26 | #endif 27 | 28 | rv = (f && form) ? (int)sfvscanf(f,form,args) : -1; 29 | 30 | va_end(args); 31 | return rv; 32 | } 33 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fgets.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Get a line. 4 | ** Written by Kiem-Phong Vo. 5 | */ 6 | 7 | #if __STD_C 8 | char* fgets(char* buf, int n, FILE* f) 9 | #else 10 | char* fgets(buf,n,f) 11 | char* buf; 12 | int n; 13 | FILE* f; 14 | #endif 15 | { 16 | reg Sfio_t* sf; 17 | reg char* rv; 18 | 19 | if(!buf || !(sf = _sfstream(f)) ) 20 | return NIL(char*); 21 | if(!(rv = _stdgets(sf,buf,n,0))) 22 | _stdseterr(f,sf); 23 | return rv; 24 | } 25 | 26 | #if _lib_fgets_unlocked && !_done_fgets_unlocked && !defined(fgets) 27 | #define _done_fgets_unlocked 1 28 | #define fgets fgets_unlocked 29 | #include "fgets.c" 30 | #undef fgets 31 | #endif 32 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/scanf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Read input from stdin using a given format 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int scanf(const char* form, ...) 9 | #else 10 | int scanf(va_alist) 11 | va_dcl 12 | #endif 13 | { 14 | va_list args; 15 | reg int rv; 16 | reg Sfio_t* sf; 17 | #if __STD_C 18 | va_start(args,form); 19 | #else 20 | reg char* form; /* scanning format */ 21 | va_start(args); 22 | form = va_arg(args,char*); 23 | #endif 24 | 25 | if(!form || !(sf = _sfstream(stdin))) 26 | return -1; 27 | 28 | if((rv = (int)sfvscanf(sf,form,args)) <= 0) 29 | _stdseterr(stdin,sf); 30 | 31 | va_end(args); 32 | 33 | return rv; 34 | } 35 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/printf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Write out data to stdout using a given format. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int printf(const char* form, ...) 9 | #else 10 | int printf(va_alist) 11 | va_dcl 12 | #endif 13 | { 14 | va_list args; 15 | reg int rv; 16 | reg Sfio_t* sf; 17 | #if __STD_C 18 | va_start(args,form); 19 | #else 20 | reg char* form; /* print format */ 21 | va_start(args); 22 | form = va_arg(args,char*); 23 | #endif 24 | 25 | if(!form || !(sf = _sfstream(stdout))) 26 | return -1; 27 | 28 | if((rv = (int)sfvprintf(sf,form,args)) < 0) 29 | _stdseterr(stdout,sf); 30 | 31 | va_end(args); 32 | 33 | return rv; 34 | } 35 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/vsprintf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Internal printf engine to write to a string buffer 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int vsprintf(char* s, const char* form, va_list args) 9 | #else 10 | int vsprintf(s,form,args) 11 | reg char* s; 12 | reg char* form; 13 | va_list args; 14 | #endif 15 | { 16 | return (s && form) ? (int)sfvsprintf(s,SF_BUFSIZE,form,args) : -1; 17 | } 18 | 19 | 20 | #if __STD_C 21 | int vasprintf(char** as, const char* form, va_list args) 22 | #else 23 | int vasprintf(as,form,args) 24 | reg char** as; 25 | reg char* form; 26 | va_list args; 27 | #endif 28 | { 29 | return (as && form) ? (int)sfvaprints(as,form,args) : -1; 30 | } 31 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_t/twrrd.c: -------------------------------------------------------------------------------- 1 | #include "stdtest.h" 2 | 3 | 4 | MAIN() 5 | { 6 | int i; 7 | char wbuf[1023]; 8 | char rbuf[1023]; 9 | FILE *fp; 10 | 11 | for(i = 0; i < sizeof(wbuf); ++i) 12 | wbuf[i] = (i%26)+'a'; 13 | wbuf[sizeof(wbuf)-1] = '\0'; 14 | 15 | if(!(fp = fopen(tstfile(0), "w+")) ) 16 | terror("Opening temp file\n"); 17 | 18 | for(i = 0; i < 256; ++i) 19 | if(fwrite(wbuf,sizeof(wbuf),1,fp) != 1) 20 | terror("Writing\n"); 21 | 22 | fseek(fp,(long)0,0); 23 | 24 | for(i = 0; i < 256; ++i) 25 | { if(fread(rbuf,sizeof(rbuf),1,fp) != 1) 26 | terror("Reading\n"); 27 | 28 | if(strcmp(rbuf,wbuf) != 0) 29 | terror("Unmatched record\n"); 30 | } 31 | 32 | TSTEXIT(0); 33 | } 34 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tleak.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfoff_t m; 6 | 7 | if(sfopen(sfstdout, tstfile(0), "w") != sfstdout) 8 | terror("Can't open %s to write\n", tstfile(0)); 9 | if(sfputr(sfstdout,"012345678\n",-1) != 10) 10 | terror("Can't write to %s\n", tstfile(0)); 11 | 12 | if(sfopen(sfstdout, tstfile(1),"w") != sfstdout) 13 | terror("Can't open %s to write\n", tstfile(1)); 14 | 15 | if(sfopen(sfstdin, tstfile(0), "r") != sfstdin) 16 | terror("Can't open %s to read\n", tstfile(0)); 17 | 18 | if((m = sfmove(sfstdin,sfstdout, (Sfoff_t)SF_UNBOUND, -1)) != 10) 19 | terror("Moving data from %s to %s m=%lld\n", 20 | tstfile(0), tstfile(1), (Sflong_t)m); 21 | 22 | TSTEXIT(0); 23 | } 24 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tlongdouble.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | #if _typ_long_double 4 | #include 5 | #endif 6 | 7 | MAIN() 8 | { 9 | #if _typ_long_double 10 | long double ldval, ldmax; 11 | char *s, *str; 12 | 13 | ldmax = LDBL_MAX; 14 | 15 | if(!(s = sfprints("%Le",ldmax)) ) 16 | terror("sfprints failed1\n"); 17 | if(!(str = malloc(strlen(s)+1)) ) 18 | terror("Malloc failed\n"); 19 | strcpy(str,s); 20 | 21 | if(sfsscanf(str,"%Le",&ldval) != 1) 22 | terror("sfsscanf failed\n"); 23 | if(!(s = sfprints("%Le",ldval)) ) 24 | terror("sfprints failed2\n"); 25 | 26 | if(strcmp(s,str) != 0) 27 | terror("Bad conversion, expecting %s and getting %s\n",str,s); 28 | #endif 29 | 30 | TSTEXIT(0); 31 | } 32 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fdopen.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Opening a stream given a file descriptor. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | FILE* fdopen(int fd, const char* mode) 9 | #else 10 | FILE* fdopen(fd,mode) 11 | int fd; 12 | char* mode; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | reg FILE* f; 17 | int flags, uflag; 18 | 19 | if((flags = _sftype(mode,NIL(int*),&uflag)) == 0) 20 | return NIL(FILE*); 21 | if(!uflag) 22 | flags |= SF_MTSAFE; 23 | 24 | if(!(sf = sfnew(NIL(Sfio_t*), NIL(Void_t*), (size_t)SF_UNBOUND, fd, flags))) 25 | return NIL(FILE*); 26 | if(!(f = _stdstream(sf, NIL(FILE*)))) 27 | { sfclose(sf); 28 | return NIL(FILE*); 29 | } 30 | 31 | return(f); 32 | } 33 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fprintf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Format data. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int fprintf(FILE* f, const char* form, ...) 9 | #else 10 | int fprintf(va_alist) 11 | va_dcl 12 | #endif 13 | { 14 | va_list args; 15 | reg int rv; 16 | reg Sfio_t* sf; 17 | 18 | #if __STD_C 19 | va_start(args,form); 20 | #else 21 | reg FILE* f; /* file stream to print to */ 22 | reg char* form; /* print format */ 23 | va_start(args); 24 | f = va_arg(args,FILE*); 25 | form = va_arg(args,char*); 26 | #endif 27 | 28 | if(!form || !(sf = _sfstream(f))) 29 | return -1; 30 | 31 | if((rv = (int)sfvprintf(sf,form,args)) < 0) 32 | _stdseterr(f,sf); 33 | 34 | va_end(args); 35 | 36 | return rv; 37 | } 38 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_dc/Makefile: -------------------------------------------------------------------------------- 1 | # makefile for discipline functions 2 | # 3 | # Written by Kiem-Phong Vo 4 | 5 | # Compiler and flags to use 6 | LIBTYPE= 7 | CXFLAGS= 8 | CCMODE= -O 9 | CCFLAGS= -I. -I.. $(CCMODE) $(LIBTYPE) $(CXFLAGS) 10 | AR= ar 11 | CC= cc 12 | 13 | # sfdisc 14 | HDRS= sfdchdr.h sfdisc.h 15 | SRCS= sfdcdio.c sfdcdos.c sfdcfilter.c sfdclzw.c sfdcseekable.c sfdcslow.c \ 16 | sfdcsubstream.c sfdctee.c sfdcunion.c sfdcgzip.c 17 | OBJS= sfdcdio.o sfdcdos.o sfdcfilter.o sfdclzw.o sfdcseekable.o sfdcslow.o \ 18 | sfdcsubstream.o sfdctee.o sfdcunion.o sfdcgzip.o 19 | 20 | .c.o: 21 | $(CC) -c $(CCFLAGS) $*.c 22 | 23 | must: $(OBJS) 24 | 25 | 3dupdate: 26 | cp Makefile $(HDRS) $(SRCS) ... 27 | 28 | clean: 29 | -(rm $(OBJS); exit 0) >/dev/null 2>&1 30 | -------------------------------------------------------------------------------- /src/lib/sfio/sfdlen.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Return the length of a double value if coded in a portable format 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | int _sfdlen(Sfdouble_t v) 10 | #else 11 | int _sfdlen(v) 12 | Sfdouble_t v; 13 | #endif 14 | { 15 | #define N_ARRAY (16*sizeof(Sfdouble_t)) 16 | reg int n, w; 17 | Sfdouble_t x; 18 | int exp; 19 | 20 | if(v < 0) 21 | v = -v; 22 | 23 | /* make the magnitude of v < 1 */ 24 | if(v != 0.) 25 | v = frexpl(v,&exp); 26 | else exp = 0; 27 | 28 | for(w = 1; w <= N_ARRAY; ++w) 29 | { /* get 2^SF_PRECIS precision at a time */ 30 | n = (int)(x = ldexpl(v,SF_PRECIS)); 31 | v = x-n; 32 | if(v <= 0.) 33 | break; 34 | } 35 | 36 | return 1 + sfulen(exp) + w; 37 | } 38 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fgetc.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Get a byte. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int fgetc(reg FILE* f) 9 | #else 10 | int fgetc(f) 11 | reg FILE* f; 12 | #endif 13 | { 14 | reg Sfio_t* sf; 15 | reg int rv; 16 | 17 | if(!(sf = _sfstream(f))) 18 | return -1; 19 | if((rv = sfgetc(sf)) < 0) 20 | _stdseterr(f,sf); 21 | return rv; 22 | } 23 | 24 | #if _lib__IO_getc && !_done_IO_getc && !defined(fgetc) 25 | #define _done_IO_getc 1 26 | #define fgetc _IO_getc 27 | #include "fgetc.c" 28 | #undef fgetc 29 | #endif 30 | 31 | #if _lib_fgetc_unlocked && !_done_fgetc_unlocked && !defined(fgetc) 32 | #define _done_fgetc_unlocked 1 33 | #define fgetc fgetc_unlocked 34 | #include "fgetc.c" 35 | #undef fgetc 36 | #endif 37 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fscanf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Scan input data using a given format 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int fscanf(FILE* f, const char* form, ...) 9 | #else 10 | int fscanf(va_alist) 11 | va_dcl 12 | #endif 13 | { 14 | va_list args; 15 | reg int rv; 16 | reg Sfio_t* sf; 17 | 18 | #if __STD_C 19 | va_start(args,form); 20 | #else 21 | reg FILE* f; /* file to be scanned */ 22 | reg char* form; /* scanning format */ 23 | va_start(args); 24 | f = va_arg(args,FILE*); 25 | form = va_arg(args,char*); 26 | #endif 27 | 28 | if(!form || !(sf = _sfstream(f))) 29 | return -1; 30 | 31 | if((rv = (int)sfvscanf(sf,form,args)) <= 0) 32 | _stdseterr(f,sf); 33 | 34 | va_end(args); 35 | 36 | return rv; 37 | } 38 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/stdio.def: -------------------------------------------------------------------------------- 1 | LIBRARY STDIO 2 | EXPORTS 3 | _cleanup 4 | _doprnt 5 | _doscan 6 | _filbuf 7 | _flsbuf 8 | clearerr 9 | fclose 10 | fdopen 11 | feof 12 | ferror 13 | fflush 14 | fgetc 15 | fgetpos 16 | fgets 17 | fileno 18 | flockfile 19 | fopen 20 | fprintf 21 | fpurge 22 | fputc 23 | fputs 24 | fread 25 | freopen 26 | fscanf 27 | fseek 28 | fsetpos 29 | ftell 30 | ftrylockfile 31 | funlockfile 32 | fwrite 33 | getc 34 | getchar 35 | gets 36 | getw 37 | pclose 38 | popen 39 | printf 40 | putc 41 | putchar 42 | puts 43 | putw 44 | rewind 45 | scanf 46 | setbuf 47 | setbuffer 48 | setlinebuf 49 | setvbuf 50 | snprintf 51 | sprintf 52 | sscanf 53 | tmpfile 54 | ungetc 55 | vfprintf 56 | vfscanf 57 | vprintf 58 | vscanf 59 | vsnprintf 60 | vsprintf 61 | vsscanf 62 | -------------------------------------------------------------------------------- /src/lib/vthread/vtset.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | /* Set attributes of a thread 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | int vtset(Vthread_t* vt, int type, Void_t* val) 10 | #else 11 | int vtset(vt, type, val) 12 | Vthread_t* vt; 13 | int type; 14 | Void_t* val; 15 | #endif 16 | { 17 | #if !vt_threaded 18 | return -1; 19 | #else 20 | int rv; 21 | 22 | if(!vt) 23 | return -1; 24 | 25 | if(type == VT_STACK) 26 | { 27 | vt->stack = (size_t)val; 28 | #if _WIN32 29 | rv = 0; 30 | #else 31 | if((rv = pthread_attr_setstacksize(&vt->attrs, (size_t)val)) != 0) 32 | vt->error = rv; 33 | #endif 34 | } 35 | else 36 | { vt->error = EINVAL; 37 | rv = -1; 38 | } 39 | 40 | return rv ? -1 : 0; 41 | 42 | #endif /*vt_threaded*/ 43 | } 44 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fputc.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Write out a byte 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int fputc(int c, FILE* f) 10 | #else 11 | int fputc(c, f) 12 | reg int c; 13 | reg FILE* f; 14 | #endif 15 | { 16 | reg Sfio_t* sf; 17 | 18 | if(!(sf = _sfstream(f))) 19 | return -1; 20 | 21 | if((c = sfputc(sf,c)) < 0) 22 | _stdseterr(f,sf); 23 | return c; 24 | } 25 | 26 | #if _lib__IO_putc && !_done_IO_putc && !defined(fputc) 27 | #define _done_IO_putc 1 28 | #define fputc _IO_putc 29 | #include "fputc.c" 30 | #undef fputc 31 | #endif 32 | 33 | #if _lib_fputc_unlocked && !_done_fputc_unlocked && !defined(fputc) 34 | #define _done_fputc_unlocked 1 35 | #define fputc fputc_unlocked 36 | #include "fputc.c" 37 | #undef fputc 38 | #endif 39 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/setvbuf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Change buffer and set/unset line buffering. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | int setvbuf(reg FILE* f, char* buf, int flags, size_t size) 10 | #else 11 | int setvbuf(f, buf, flags, size) 12 | reg FILE* f; 13 | char* buf; 14 | int flags; 15 | size_t size; 16 | #endif 17 | { 18 | reg Sfio_t* sf; 19 | 20 | if(!(sf = _sfstream(f))) 21 | return -1; 22 | 23 | if(flags == _IOLBF) 24 | sfset(sf,SF_LINE,1); 25 | else if(flags == _IONBF) 26 | { sfsync(sf); 27 | sfsetbuf(sf,NIL(Void_t*),0); 28 | sfset(sf,SF_LINE,0); 29 | } 30 | else if(flags == _IOFBF) 31 | { if(size == 0) 32 | size = BUFSIZ; 33 | sfsync(sf); 34 | sfsetbuf(sf,buf,size); 35 | sfset(sf,SF_LINE,0); 36 | } 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tstatus.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t* ip; 6 | Sfio_t* op; 7 | int n; 8 | 9 | if(!(ip = sfopen((Sfio_t*)0, "/dev/null", "r"))) 10 | terror("/dev/null read open\n"); 11 | if(!(op = sfopen((Sfio_t*)0, tstfile(0), "w"))) 12 | terror("Write open\n"); 13 | 14 | n = (int)sfmove(ip, op, SF_UNBOUND, -1); 15 | 16 | if(n) 17 | terror("move count %d != 0\n", n); 18 | if(!sfeof(ip)) 19 | terror("sfeof(ip) expected\n"); 20 | if(sfeof(op)) 21 | terror("sfeof(op) not expected\n"); 22 | 23 | if(sferror(ip)) 24 | terror("sferror(ip) not expected\n"); 25 | if(sferror(op)) 26 | terror("sferror(op) not expected\n"); 27 | 28 | if(sfclose(ip)) 29 | terror("sfclose(ip)\n"); 30 | if(sfclose(op)) 31 | terror("sfclose(op)\n"); 32 | 33 | TSTEXIT(0); 34 | } 35 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tfmt.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | static char *Mystr = "abc"; 4 | #if __STD_C 5 | int myprint(Sfio_t* f, Void_t* v, Sffmt_t* fe) 6 | #else 7 | int myprint(f, v, fe) 8 | Sfio_t* f; 9 | Void_t* v; 10 | Sffmt_t* fe; 11 | #endif 12 | { 13 | switch(fe->fmt) 14 | { 15 | case 's' : 16 | *((char**)v) = Mystr; 17 | fe->flags |= SFFMT_VALUE; 18 | return 0; 19 | } 20 | 21 | return 0; 22 | } 23 | 24 | MAIN() 25 | { 26 | char buf1[1024], buf2[1024]; 27 | Sffmt_t fe; 28 | 29 | memset(&fe, 0, sizeof(Sffmt_t)); 30 | fe.version = SFIO_VERSION; 31 | fe.form = "%1$s"; 32 | fe.extf = myprint; 33 | 34 | sfsprintf(buf1,sizeof(buf1),"%s",Mystr); 35 | sfsprintf(buf2,sizeof(buf2),"%!", &fe); 36 | if(strcmp(buf1,buf2) != 0) 37 | terror("Failed testing $position\n"); 38 | 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_t/tmesg.h: -------------------------------------------------------------------------------- 1 | #if __STD_C 2 | void t_error(char* form, ...) 3 | #else 4 | void t_error(va_alist) 5 | va_dcl 6 | #endif 7 | { 8 | char *s, buf[1024]; 9 | int n; 10 | va_list args; 11 | #if __STD_C 12 | va_start(args,form); 13 | #else 14 | char* form; 15 | va_start(args); 16 | form = va_arg(args,char*); 17 | #endif 18 | 19 | s = buf; memset(buf, 0, sizeof(buf)); 20 | #ifdef __LINE__ 21 | sprintf(s,"Line=%d: ", Sftline); 22 | s += strlen(s); 23 | #endif 24 | vsprintf(s,form,args); 25 | va_end(args); 26 | 27 | if((n = strlen(buf)) > 0) 28 | { 29 | #if _PACKAGE_ast 30 | if(buf[n-1] == '\n') 31 | buf[n-1] = ' '; 32 | #else 33 | if(buf[n-1] != '\n') 34 | { buf[n] = '\n'; 35 | n += 1; 36 | } 37 | #endif 38 | write(2,buf,n); 39 | } 40 | 41 | sftcleanup(); 42 | exit(1); 43 | } 44 | -------------------------------------------------------------------------------- /src/lib/vthread/vtkill.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | /* Deleting a thread 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | int vtkill(Vthread_t* vt) 10 | #else 11 | int vtkill(vt) 12 | Vthread_t* vt; 13 | #endif 14 | { 15 | #if !vt_threaded 16 | return -1; 17 | #else 18 | int rv; 19 | 20 | if(!vt) 21 | return -1; 22 | 23 | if(!(vt->state&VT_RUNNING) ) 24 | { vt->error = 0; 25 | return -1; 26 | } 27 | 28 | #if _WIN32 29 | if((rv = TerminateThread(vt->self, 0)) == FALSE) 30 | { vt->error = GetLastError(); 31 | rv = -1; 32 | } 33 | else rv = 0; 34 | #else 35 | if((rv = pthread_cancel(vt->self)) != 0) 36 | { vt->error = rv; 37 | rv = -1; 38 | } 39 | #endif 40 | 41 | if(rv == 0) 42 | vt->state &= ~VT_RUNNING; 43 | 44 | return rv; 45 | 46 | #endif /*!vt_threaded*/ 47 | } 48 | -------------------------------------------------------------------------------- /src/lib/vthread/vtrun.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | /* Run a thread 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | int vtrun(Vthread_t* vt, Void_t* (*startf)(Void_t*), Void_t* arg) 10 | #else 11 | int vtrun(vt, startf, arg) 12 | Vthread_t* vt; 13 | Void_t* (*startf)(); 14 | Void_t* arg; 15 | #endif 16 | { 17 | #if !vt_threaded 18 | return -1; 19 | #else 20 | 21 | #if _WIN32 22 | vt->self = CreateThread(0, (DWORD)vt->stack, 23 | (LPTHREAD_START_ROUTINE)startf, (LPVOID)arg, 24 | 0, &vt->id); 25 | vt->error = vt->self ? 0 : EPERM; 26 | #else 27 | vt->error = pthread_create(&vt->self, ATTR(vt->attrs), startf, arg); 28 | vt->id = vt->self; 29 | #endif 30 | 31 | if(!vt->error) 32 | vt->state |= VT_RUNNING; 33 | 34 | return vt->error ? -1 : 0; 35 | 36 | #endif /*vt_threaded*/ 37 | } 38 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/twrrd.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | 4 | MAIN() 5 | { 6 | int i; 7 | char wbuf[1023]; 8 | char rbuf[1023]; 9 | Sfio_t *fp; 10 | 11 | for(i = 0; i < sizeof(wbuf); ++i) 12 | wbuf[i] = (i%26)+'a'; 13 | wbuf[sizeof(wbuf)-1] = '\0'; 14 | 15 | if(!(fp = sftmp(0))) 16 | terror("Opening temp file\n"); 17 | 18 | for(i = 0; i < 256; ++i) 19 | if(sfwrite(fp,wbuf,sizeof(wbuf)) != sizeof(wbuf)) 20 | terror("Writing\n"); 21 | 22 | sfseek(fp,(Sfoff_t)0,0); 23 | sfset(fp,SF_WRITE,0); 24 | sfsetbuf(fp,NIL(char*),0); 25 | sfsetbuf(fp,NIL(char*),(size_t)SF_UNBOUND); 26 | 27 | for(i = 0; i < 256; ++i) 28 | { if(sfread(fp,rbuf,sizeof(rbuf)) != sizeof(rbuf)) 29 | terror("Reading\n"); 30 | 31 | if(strcmp(rbuf,wbuf) != 0) 32 | terror("Unmatched record\n"); 33 | } 34 | 35 | TSTEXIT(0); 36 | } 37 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fread.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Read a set of data 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | size_t fread(Void_t* buf, size_t esize, size_t nelts, reg FILE* f) 9 | #else 10 | size_t fread(buf,esize,nelts,f) 11 | reg Void_t* buf; 12 | reg size_t esize; 13 | reg size_t nelts; 14 | reg FILE* f; 15 | #endif 16 | { 17 | reg Sfio_t* sf; 18 | reg ssize_t rv; 19 | 20 | if(!buf || !(sf = _sfstream(f))) 21 | return 0; 22 | 23 | if((rv = sfread(sf,buf,esize*nelts)) >= 0) 24 | return (esize == 0 ? 0 : rv/esize); 25 | else 26 | { _stdseterr(f,sf); 27 | return 0; 28 | } 29 | } 30 | 31 | #if _lib_fread_unlocked && !_done_fread_unlocked && !defined(fread) 32 | #define _done_fread_unlocked 1 33 | #define fread fread_unlocked 34 | #include "fread.c" 35 | #undef fread 36 | #endif 37 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdsetvbuf.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Stdio function setvbuf() 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int _stdsetvbuf(Sfio_t* f, char* buf, int type, size_t size) 10 | #else 11 | int _stdsetvbuf(f,buf,type,size) 12 | Sfio_t* f; 13 | char* buf; 14 | int type; 15 | size_t size; 16 | #endif 17 | { 18 | SFMTXSTART(f,-1); 19 | 20 | if(type == _IOLBF) 21 | { sfset(f,SF_LINE,1); 22 | } 23 | else if((f->flags&SF_STRING)) 24 | { SFMTXRETURN(f, -1); 25 | } 26 | else if(type == _IONBF) 27 | { sfsync(f); 28 | sfsetbuf(f,NIL(Void_t*),0); 29 | sfset(f,SF_LINE,0); 30 | } 31 | else if(type == _IOFBF) 32 | { if(size == 0) 33 | size = SF_BUFSIZE; 34 | sfsync(f); 35 | sfsetbuf(f,(Void_t*)buf,size); 36 | sfset(f,SF_LINE,0); 37 | } 38 | 39 | SFMTXRETURN(f, 0); 40 | } 41 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fwrite.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Write out a set of data 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | size_t fwrite(const Void_t* buf, size_t esize, size_t nelts, reg FILE* f) 9 | #else 10 | size_t fwrite(buf,esize,nelts,f) 11 | reg Void_t* buf; 12 | reg size_t esize; 13 | reg size_t nelts; 14 | reg FILE* f; 15 | #endif 16 | { 17 | reg ssize_t rv; 18 | reg Sfio_t* sf; 19 | 20 | if(!(sf = _sfstream(f))) 21 | return 0; 22 | 23 | if((rv = sfwrite(sf,buf,esize*nelts)) >= 0) 24 | return (esize == 0 ? 0 : rv/esize); 25 | else 26 | { _stdseterr(f,sf); 27 | return 0; 28 | } 29 | } 30 | 31 | #if _lib_fwrite_unlocked && !_done_fwrite_unlocked && !defined(fwrite) 32 | #define _done_fwrite_unlocked 1 33 | #define fwrite fwrite_unlocked 34 | #include "fwrite.c" 35 | #undef fwrite 36 | #endif 37 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/tmpfile.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Creating a temporary stream. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | FILE* tmpfile(void) 9 | #else 10 | FILE* tmpfile() 11 | #endif 12 | { 13 | reg Sfio_t* sf; 14 | reg FILE* f; 15 | 16 | if(!(sf = sftmp(0))) 17 | f = NIL(FILE*); 18 | else if(!(f = _stdstream(sf, NIL(FILE*)))) 19 | sfclose(sf); 20 | else sf->flags |= SF_MTSAFE; 21 | 22 | return f; 23 | } 24 | 25 | #if _lib___tmpfile64 && !_done___tmpfile64 && !defined(tmpfile) 26 | #define _done___tmpfile64 1 27 | #define tmpfile __tmpfile64 28 | #include "tmpfile.c" 29 | #undef tmpfile 30 | #endif 31 | 32 | #if _lib_tmpfile64 && !_done_tmpfile64 && !defined(tmpfile) 33 | #define _done_tmpfile64 1 34 | #define tmpfile tmpfile64 35 | #include "tmpfile.c" 36 | #undef tmpfile 37 | #endif 38 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/sftest.h: -------------------------------------------------------------------------------- 1 | #include "FEATURE/sfio" 2 | 3 | #if !_PACKAGE_ast 4 | #ifdef __STDC__ 5 | #include 6 | #else 7 | #include 8 | #endif 9 | #endif 10 | 11 | #if _SFIO_H_ONLY 12 | #include 13 | #else 14 | #include 15 | #endif 16 | 17 | #if _PACKAGE_ast 18 | #include 19 | #endif 20 | 21 | #if _hdr_unistd 22 | #include 23 | #endif 24 | 25 | #include 26 | 27 | #include "terror.h" 28 | 29 | #ifndef EINTR 30 | #define EINTR 4 31 | #endif 32 | #ifndef EBADF 33 | #define EBADF 9 34 | #endif 35 | #ifndef EAGAIN 36 | #define EAGAIN 11 37 | #endif 38 | #ifndef ENOMEM 39 | #define ENOMEM 12 40 | #endif 41 | #ifndef ESPIPE 42 | #define ESPIPE 29 43 | #endif 44 | 45 | #if _hdr_math 46 | #include 47 | #endif 48 | 49 | #if _hdr_float 50 | #include 51 | #endif 52 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fgetpos.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Get current stream position. 4 | ** Written by Kiem-Phong Vo. 5 | */ 6 | 7 | #if __STD_C 8 | int fgetpos(reg FILE* f, reg stdfpos_t* pos) 9 | #else 10 | int fgetpos(f, pos) 11 | reg FILE* f; 12 | reg stdfpos_t* pos; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | 17 | if(!(sf = _sfstream(f))) 18 | return -1; 19 | return (*pos = (stdfpos_t)sfseek(sf,(Sfoff_t)0,SEEK_CUR|SF_SHARE)) >= 0 ? 0 : -1; 20 | } 21 | 22 | #if _lib___fgetpos64 && !_done___fgetpos64 && !defined(fgetpos) 23 | #define _done___fgetpos64 1 24 | #define fgetpos __fgetpos64 25 | #include "fgetpos.c" 26 | #undef fgetpos 27 | #endif 28 | 29 | #if _lib_fgetpos64 && !_done_fgetpos64 && !defined(fgetpos) 30 | #define _done_fgetpos64 1 31 | #define fgetpos fgetpos64 32 | #include "fgetpos.c" 33 | #undef fgetpos 34 | #endif 35 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/snprintf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Format a string with given buffer size. 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int snprintf(char* s, size_t n, const char* form, ...) 9 | #else 10 | int snprintf(va_alist) 11 | va_dcl 12 | #endif 13 | { 14 | va_list args; 15 | reg int rv; 16 | #if __STD_C 17 | va_start(args,form); 18 | #else 19 | reg char* s; 20 | reg size_t n; 21 | reg char* form; 22 | va_start(args); 23 | s = va_arg(args,char*); 24 | n = va_arg(args,size_t); 25 | form = va_arg(args,char*); 26 | #endif 27 | 28 | rv = (s && form) ? (int)sfvsprintf(s,n,form,args) : -1; 29 | va_end(args); 30 | 31 | return rv; 32 | } 33 | 34 | #if _lib___snprintf && !done_lib___snprintf && !defined(snprintf) 35 | #define done_lib___snprintf 1 36 | #define snprintf __snprintf 37 | #include "snprintf.c" 38 | #endif 39 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tputgetd.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfdouble_t f, v; 6 | int i, flag; 7 | Sfio_t *fp; 8 | 9 | if(!(fp = sfopen(NIL(Sfio_t*), tstfile(0), "w+")) ) 10 | terror("Can't open temp file\n"); 11 | 12 | #define BEGV (Sfdouble_t)(1e-10) 13 | #define ENDV (Sfdouble_t)(1e-10 + 1) 14 | #define INCR (Sfdouble_t)(1e-3) 15 | 16 | for(f = BEGV; f < ENDV; f += INCR) 17 | if(sfputd(fp,f) < 0) 18 | terror("Writing %.12Lf\n",f); 19 | 20 | sfseek(fp,(Sfoff_t)0,0); 21 | for(flag = 0, f = BEGV, i = 0; f < ENDV; ++i, f += INCR) 22 | { if((v = sfgetd(fp)) == f) 23 | continue; 24 | if(v <= (f - 1e-10) || v >= (f + 1e-10) ) 25 | terror("Element=%d Input=%.12Lf, Expect=%.12Lf\n",i,v,f); 26 | else if(!flag) 27 | { twarn("Element=%d Input=%.12Lf, Expect=%.12Lf\n",i,v,f); 28 | flag = 1; 29 | } 30 | } 31 | 32 | TSTEXIT(0); 33 | } 34 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fsetpos.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Set IO position pointer 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int fsetpos(reg FILE* f, reg stdfpos_t* pos) 9 | #else 10 | int fsetpos(f, pos) 11 | reg FILE* f; 12 | reg stdfpos_t* pos; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | 17 | if(!pos || *pos < 0 || !(sf = _sfstream(f))) 18 | return -1; 19 | 20 | return (stdfpos_t)sfseek(sf, (Sfoff_t)(*pos), SEEK_SET|SF_SHARE) == *pos ? 0 : -1; 21 | } 22 | 23 | #if _lib___fsetpos64 && !_done___fsetpos64 && !defined(fsetpos) 24 | #define _done___fsetpos64 1 25 | #define fsetpos __fsetpos64 26 | #include "fsetpos.c" 27 | #undef fsetpos 28 | #endif 29 | 30 | #if _lib_fsetpos64 && !_done_fsetpos64 && !defined(fsetpos) 31 | #define _done_fsetpos64 1 32 | #define fsetpos fsetpos64 33 | #include "fsetpos.c" 34 | #undef fsetpos 35 | #endif 36 | -------------------------------------------------------------------------------- /src/lib/vthread/features/vthread: -------------------------------------------------------------------------------- 1 | hdr pthread 2 | lib pthread_mutexattr_settype -lpthread 3 | lib pthread_mutexattr_setkind -lpthread 4 | lib pthread_mutexattr_setkind_np -lpthread 5 | num PTHREAD_MUTEX_RECURSIVE pthread.h 6 | num PTHREAD_MUTEX_RECURSIVE_NP pthread.h 7 | num MUTEX_RECURSIVE_NP pthread.h 8 | num PTHREAD_MUTEX_ERRORCHECK pthread.h 9 | num PTHREAD_MUTEX_ERRORCHECK_NP pthread.h 10 | num MUTEX_NONRECURSIVE_NP pthread.h 11 | 12 | lib pthread_mutexattr_setkind -lcma 13 | lib pthread_mutexattr_setkind_np -lcma 14 | 15 | lib pthread_mutexattr_init pthread.h -lpthread 16 | lib pthread_mutexattr_destroy pthread.h -lpthread 17 | lib pthread_mutexattr_create -lcma 18 | lib pthread_mutexattr_delete -lcma 19 | 20 | lib pthread_attr_init pthread.h -lpthread 21 | lib pthread_attr_destroy pthread.h -lpthread 22 | lib pthread_attr_create -lcma 23 | lib pthread_attr_delete -lcma 24 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_t/tfseek.c: -------------------------------------------------------------------------------- 1 | #include "stdtest.h" 2 | 3 | MAIN() 4 | { 5 | FILE *fp; 6 | int i, c, e; 7 | 8 | if(!(fp = fopen(tstfile(0), "w+")) ) 9 | terror("Can't open temp file\n"); 10 | 11 | for(i = 0; i < 256; ++i) 12 | if(putc(i, fp) < 0) 13 | terror("Bad putc\n"); 14 | 15 | for(i = 1; i < 255; ++i) 16 | { if(fseek(fp, (long)(-i), SEEK_END) < 0) 17 | terror("fseek seek_end failed\n"); 18 | if((c = getc(fp)) != (e = 256-i) ) 19 | terror("Bad getc: expect %d, get %d\n", e, c); 20 | 21 | if(fseek(fp, (long)(i), SEEK_SET) < 0) 22 | terror("fseek seek_set failed\n"); 23 | if((c = getc(fp)) != i) 24 | terror("Bad getc: expect %d, get %d\n", i, c); 25 | 26 | if(fseek(fp, (long)(-1), SEEK_CUR) < 0) 27 | terror("fseek seek_cur failed\n"); 28 | 29 | if((c = getc(fp)) != i ) 30 | terror("Bad getc: expect %d, get %d\n", i, c); 31 | } 32 | 33 | TSTEXIT(0); 34 | } 35 | -------------------------------------------------------------------------------- /src/lib/vthread/vtonce.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | 4 | /* Execute some set of actions exactly once 5 | ** 6 | ** Written by Kiem-Phong Vo 7 | */ 8 | 9 | #if __STD_C 10 | int vtonce(Vtonce_t* once, void(*func)() ) 11 | #else 12 | int vtonce(once, func) 13 | Vtonce_t* once; 14 | void (*func)(); 15 | #endif 16 | { 17 | #if !vt_threaded 18 | return -1; 19 | #else 20 | int rv; 21 | 22 | if(!func) 23 | { once->error = EINVAL; 24 | return -1; 25 | } 26 | if(once->done) 27 | return 0; 28 | 29 | #if _WIN32 30 | if(InterlockedIncrement(&once->once) == 1) 31 | { (*func)(); 32 | once->done = 1; 33 | } 34 | else 35 | { once->once = 2; 36 | while(!once->done) 37 | Sleep(1); 38 | } 39 | rv = 0; 40 | #else 41 | if((rv = pthread_once(&once->once, func)) != 0) 42 | once->error = rv; 43 | else once->done = 1; 44 | #endif 45 | 46 | return rv ? -1 : 0; 47 | 48 | #endif /*vt_threaded*/ 49 | } 50 | -------------------------------------------------------------------------------- /src/lib/vthread/vtwait.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | /* Wait for a thread to end 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | int vtwait(Vthread_t* vt) 10 | #else 11 | int vtwait(vt) 12 | Vthread_t* vt; 13 | #endif 14 | { 15 | #if !vt_threaded 16 | return -1; 17 | #else 18 | int rv; 19 | 20 | if(!vt) 21 | return -1; 22 | 23 | if(!(vt->state&VT_RUNNING) ) 24 | { vt->error = 0; 25 | return -1; 26 | } 27 | 28 | #if _WIN32 29 | if((rv = WaitForSingleObject(vt->self, INFINITE)) == 0xffffffff) 30 | vt->error = GetLastError(); 31 | else 32 | { vt->exit = (Void_t*)rv; 33 | rv = 0; 34 | CloseHandle(vt->self); 35 | } 36 | #else 37 | if((rv = pthread_join(vt->self, &vt->exit)) != 0) 38 | vt->error = rv; 39 | #endif 40 | 41 | if(rv == 0) 42 | vt->state = (vt->state & ~VT_RUNNING) | VT_WAITED; 43 | 44 | return rv ? -1 : 0; 45 | 46 | #endif /*vt_threaded*/ 47 | } 48 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fflush.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Flushing buffered output data. 4 | ** This has been modified to work with both input&output streams. 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int fflush(reg FILE* f) 10 | #else 11 | int fflush(f) 12 | reg FILE* f; 13 | #endif 14 | { 15 | reg Sfio_t* sf; 16 | 17 | if(!f) 18 | return sfsync(NIL(Sfio_t*)); 19 | if(!(sf = _sfstream(f))) 20 | return -1; 21 | 22 | if(sf->extent >= 0 && !(sf->mode&SF_INIT) ) 23 | (void)sfseek(sf, (Sfoff_t)0, SEEK_CUR|SF_PUBLIC); 24 | 25 | if((sf->mode&SF_WRITE) && sfsync(sf) < 0) 26 | return -1; 27 | if((sf->mode&SF_READ) && sfpurge(sf) < 0) 28 | return -1; 29 | return 0; 30 | } 31 | 32 | #if _lib_fflush_unlocked && !_done_fflush_unlocked && !defined(fflush) 33 | #define _done_fflush_unlocked 1 34 | #define fflush fflush_unlocked 35 | #include "fflush.c" 36 | #undef fflush 37 | #endif 38 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tshare.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | char buf[1024], *s; 6 | Sfio_t* f; 7 | 8 | f = sfnew(NIL(Sfio_t*),NIL(Void_t*),(size_t)SF_UNBOUND,-1,SF_WRITE|SF_STRING); 9 | sfsetbuf(sfstdout,buf,sizeof(buf)); 10 | sfsetbuf(sfstderr,buf,sizeof(buf)); 11 | sfset(sfstdout,SF_SHARE,0); 12 | sfset(sfstderr,SF_SHARE,0); 13 | 14 | if(!sfpool(sfstdout,f,SF_SHARE) || !sfpool(sfstderr,f,SF_SHARE) ) 15 | terror("Pooling\n"); 16 | 17 | if(sfputr(sfstdout,"01234",-1) != 5) 18 | terror("Writing to stderr\n"); 19 | if(sfputr(sfstderr,"56789",-1) != 5) 20 | terror("Writing to stdout\n"); 21 | 22 | if(sfputc(f,'\0') < 0) 23 | terror("Writing to string stream\n"); 24 | 25 | sfseek(f,(Sfoff_t)0,0); 26 | if(!(s = sfreserve(f,SF_UNBOUND,1)) ) 27 | terror("Peeking\n"); 28 | sfwrite(f,s,0); 29 | if(strcmp(s,"0123456789") != 0) 30 | terror("Data is wrong\n"); 31 | 32 | TSTEXIT(0); 33 | } 34 | -------------------------------------------------------------------------------- /src/lib/sfio/sfgetu.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Read an unsigned long value coded in a portable format. 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | Sfulong_t sfgetu(reg Sfio_t* f) 10 | #else 11 | Sfulong_t sfgetu(f) 12 | reg Sfio_t* f; 13 | #endif 14 | { 15 | Sfulong_t v; 16 | reg uchar *s, *ends, c; 17 | reg int p; 18 | 19 | SFMTXSTART(f, (Sfulong_t)(-1)); 20 | 21 | if(f->mode != SF_READ && _sfmode(f,SF_READ,0) < 0) 22 | SFMTXRETURN(f, (Sfulong_t)(-1)); 23 | 24 | SFLOCK(f,0); 25 | 26 | for(v = 0;;) 27 | { if(SFRPEEK(f,s,p) <= 0) 28 | { f->flags |= SF_ERROR; 29 | v = (Sfulong_t)(-1); 30 | goto done; 31 | } 32 | for(ends = s+p; s < ends;) 33 | { c = *s++; 34 | v = (v << SF_UBITS) | SFUVALUE(c); 35 | if(!(c&SF_MORE)) 36 | { f->next = s; 37 | goto done; 38 | } 39 | } 40 | f->next = s; 41 | } 42 | done: 43 | SFOPEN(f,0); 44 | SFMTXRETURN(f, v); 45 | } 46 | -------------------------------------------------------------------------------- /src/lib/vthread/vtclose.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | /* Deleting a thread 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | int vtclose(Vthread_t* vt) 10 | #else 11 | int vtclose(vt) 12 | Vthread_t* vt; 13 | #endif 14 | { 15 | #if !vt_threaded 16 | return -1; 17 | #else 18 | int s; 19 | 20 | if(!vt ) 21 | return -1; 22 | 23 | vtmtxlock(_Vtmutex); 24 | 25 | for(s = 0; s < _Vtnlist; ++s) 26 | if(_Vtlist[s] == vt) 27 | break; 28 | 29 | if(s == _Vtnlist) 30 | { vt->error = EINVAL; 31 | vtmtxunlock(_Vtmutex); 32 | return -1; 33 | } 34 | else if((vt->state&VT_RUNNING) && vtwait(vt) < 0) 35 | { vtmtxunlock(_Vtmutex); 36 | return -1; 37 | } 38 | 39 | _Vtlist[s] = NIL(Vthread_t*); 40 | 41 | #if !_WIN32 42 | pthread_attr_destroy(&vt->attrs); 43 | #endif 44 | 45 | if(vt->state & VT_FREE) 46 | free(vt); 47 | 48 | vtmtxunlock(_Vtmutex); 49 | 50 | return 0; 51 | 52 | #endif /*vt_threaded*/ 53 | } 54 | -------------------------------------------------------------------------------- /src/lib/sfio/sfio_s.h: -------------------------------------------------------------------------------- 1 | #ifndef _SFIO_S_H 2 | #define _SFIO_S_H 1 3 | 4 | /* 5 | * sfio file structure used by sfio and the stdio source compatibility library 6 | */ 7 | 8 | #if !defined(_SFHDR_H) && defined(_SFIO_H) && SFIO_VERSION < 20020214L 9 | #define _data data 10 | #define _endb endb 11 | #define _next next 12 | #endif 13 | 14 | struct _sfio_s 15 | { unsigned char* _next; /* next position to read/write from */ 16 | unsigned char* _endw; /* end of write buffer */ 17 | unsigned char* _endr; /* end of read buffer */ 18 | unsigned char* _endb; /* end of buffer */ 19 | struct _sfio_s* _push; /* the stream that was pushed on */ 20 | unsigned short _flags; /* type of stream */ 21 | short _file; /* file descriptor */ 22 | unsigned char* _data; /* base of data buffer */ 23 | ssize_t _size; /* buffer size */ 24 | ssize_t _val; /* values or string lengths */ 25 | #ifdef _SFIO_PRIVATE 26 | _SFIO_PRIVATE 27 | #endif 28 | }; 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fopen.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Opening a stream 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | FILE* fopen(char* name,const char* mode) 9 | #else 10 | FILE* fopen(name,mode) 11 | char* name; 12 | char* mode; 13 | #endif 14 | { 15 | reg FILE* f; 16 | reg Sfio_t* sf; 17 | 18 | if(!(sf = sfopen(NIL(Sfio_t*), name, mode)) ) 19 | f = NIL(FILE*); 20 | else if(!(f = _stdstream(sf, NIL(FILE*)))) 21 | sfclose(sf); 22 | else 23 | { int uflag; 24 | _sftype(mode, NIL(int*), &uflag); 25 | if(!uflag) 26 | sf->flags |= SF_MTSAFE; 27 | } 28 | 29 | return(f); 30 | } 31 | 32 | #if _lib___fopen64 && !_done___fopen64 && !defined(fopen) 33 | #define _done___fopen64 1 34 | #define fopen __fopen64 35 | #include "fopen.c" 36 | #undef fopen 37 | #endif 38 | 39 | #if _lib_fopen64 && !_done_fopen64 && !defined(fopen) 40 | #define _done_fopen64 1 41 | #define fopen fopen64 42 | #include "fopen.c" 43 | #undef fopen 44 | #endif 45 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tsetfd.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t *f; 6 | int fd; 7 | off_t sk; 8 | 9 | if(!(f = sfopen((Sfio_t*)0,tstfile(0),"w+"))) 10 | terror("Opening file\n"); 11 | fd = sffileno(f); 12 | 13 | if(sfsetfd(f,-1) != -1 || sffileno(f) != -1) 14 | terror("setfd1\n"); 15 | if(sfputc(f,'a') >= 0) 16 | terror("sfputc\n"); 17 | 18 | if(sfsetfd(f,fd) != fd) 19 | terror("setfd2\n"); 20 | 21 | if(sfwrite(f,"123456789\n",10) != 10) 22 | terror("sfwrite\n"); 23 | 24 | sfseek(f,(Sfoff_t)0,0); 25 | if(sfgetc(f) != '1') 26 | terror("sfgetc1\n"); 27 | 28 | if(sfsetfd(f,-1) != -1 || sffileno(f) != -1) 29 | terror("setfd2\n"); 30 | if((sk = lseek(fd, (off_t)0, 1)) != (off_t)1) 31 | terror("Bad seek address %lld\n", (Sfoff_t)sk ); 32 | if(sfgetc(f) >= 0) 33 | terror("sfgetc2\n"); 34 | 35 | if(sfsetfd(f,fd) != fd) 36 | terror("setfd2\n"); 37 | if(sfgetc(f) != '2') 38 | terror("sfgetc3\n"); 39 | 40 | TSTEXIT(0); 41 | } 42 | -------------------------------------------------------------------------------- /src/lib/sfio/sfgetm.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Read an unsigned long value coded portably for a given range. 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | Sfulong_t sfgetm(reg Sfio_t* f, Sfulong_t m) 10 | #else 11 | Sfulong_t sfgetm(f, m) 12 | reg Sfio_t* f; 13 | Sfulong_t m; 14 | #endif 15 | { 16 | Sfulong_t v; 17 | reg uchar *s, *ends, c; 18 | reg int p; 19 | 20 | SFMTXSTART(f, (Sfulong_t)(-1)); 21 | 22 | if(f->mode != SF_READ && _sfmode(f,SF_READ,0) < 0) 23 | SFMTXRETURN(f, (Sfulong_t)(-1)); 24 | 25 | SFLOCK(f,0); 26 | 27 | for(v = 0;; ) 28 | { if(SFRPEEK(f,s,p) <= 0) 29 | { f->flags |= SF_ERROR; 30 | v = (Sfulong_t)(-1); 31 | goto done; 32 | } 33 | for(ends = s+p; s < ends;) 34 | { c = *s++; 35 | v = (v << SF_BBITS) | SFBVALUE(c); 36 | if((m >>= SF_BBITS) <= 0) 37 | { f->next = s; 38 | goto done; 39 | } 40 | } 41 | f->next = s; 42 | } 43 | done: 44 | SFOPEN(f,0); 45 | SFMTXRETURN(f, v); 46 | } 47 | -------------------------------------------------------------------------------- /src/lib/sfio/sftell.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Tell the current location in a given stream 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | Sfoff_t sftell(reg Sfio_t* f) 10 | #else 11 | Sfoff_t sftell(f) 12 | reg Sfio_t *f; 13 | #endif 14 | { 15 | reg int mode; 16 | Sfoff_t p; 17 | 18 | SFMTXSTART(f, (Sfoff_t)(-1)); 19 | 20 | /* set the stream to the right mode */ 21 | if((mode = f->mode&SF_RDWR) != (int)f->mode && _sfmode(f,mode,0) < 0) 22 | SFMTXRETURN(f, (Sfoff_t)(-1)); 23 | 24 | /* throw away ungetc data */ 25 | if(f->disc == _Sfudisc) 26 | (void)sfclose((*_Sfstack)(f,NIL(Sfio_t*))); 27 | 28 | if(f->flags&SF_STRING) 29 | SFMTXRETURN(f, (Sfoff_t)(f->next-f->data)); 30 | 31 | /* let sfseek() handle the hard case */ 32 | if(f->extent >= 0 && (f->flags&(SF_SHARE|SF_APPENDWR)) ) 33 | p = sfseek(f,(Sfoff_t)0,1); 34 | else p = f->here + ((f->mode&SF_WRITE) ? f->next-f->data : f->next-f->endb); 35 | 36 | SFMTXRETURN(f,p); 37 | } 38 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tputgetr.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | char buf[100]; 6 | Sfio_t *fp; 7 | int i; 8 | char *s; 9 | 10 | if(!(fp = sftmp(8))) 11 | terror("Can't open temp file\n"); 12 | 13 | sfset(fp,SF_LINE,1); 14 | for(i = 0; i < 1000; ++i) 15 | { sfsprintf(buf,sizeof(buf),"Number: %d",i); 16 | if(sfputr(fp,buf,'\n') <= 0) 17 | terror("Writing %s\n",buf); 18 | } 19 | 20 | sfseek(fp,(Sfoff_t)0,0); 21 | 22 | for(i = 0; i < 1000; ++i) 23 | { sfsprintf(buf,sizeof(buf),"Number: %d",i); 24 | if(!(s = sfgetr(fp,'\n',1))) 25 | terror("Reading %s\n",buf); 26 | if(strcmp(s,buf) != 0) 27 | terror("Input=%s, Expect=%s\n",s,buf); 28 | } 29 | 30 | sfseek(fp,(Sfoff_t)0,0); 31 | s = sfgetr(fp,'\0',1); 32 | if(s) 33 | terror("Expecting a null string\n"); 34 | s = sfgetr(fp,'\0',-1); 35 | if(!s) 36 | terror("Expecting a non-null string\n"); 37 | if(sfvalue(fp) != sfsize(fp)) 38 | terror("Wrong size\n"); 39 | 40 | TSTEXIT(0); 41 | } 42 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tswap.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t* f1; 6 | Sfio_t* f2; 7 | char* s; 8 | 9 | if(!(f1 = sfopen(NIL(Sfio_t*), tstfile(0),"w+")) ) 10 | terror("Can't open file\n"); 11 | if(sfwrite(f1,"0123456789\n",11) != 11) 12 | terror("Can't write to file\n"); 13 | 14 | sfclose(sfstdin); 15 | if(sfswap(f1,sfstdin) != sfstdin) 16 | terror("Can't swap with sfstdin\n"); 17 | sfseek(sfstdin,(Sfoff_t)0,0); 18 | if(!(s = sfgetr(sfstdin,'\n',1)) ) 19 | terror("sfgetr failed\n"); 20 | if(strcmp(s,"0123456789") != 0) 21 | terror("Get wrong data\n"); 22 | 23 | if(!(f1 = sfswap(sfstdin,NIL(Sfio_t*))) ) 24 | terror("Failed swapping to NULL\n"); 25 | if(!sfstack(sfstdout,f1) ) 26 | terror("Failed stacking f1\n"); 27 | 28 | if(!(f2 = sfopen(NIL(Sfio_t*), tstfile(0), "r")) ) 29 | terror("Can't open for read\n"); 30 | 31 | if(sfswap(f1,f2) != NIL(Sfio_t*) ) 32 | terror("sfswap should have failed\n"); 33 | 34 | TSTEXIT(0); 35 | } 36 | -------------------------------------------------------------------------------- /src/lib/sfio/sfclrlock.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Function to clear a locked stream. 4 | ** This is useful for programs that longjmp from the mid of an sfio function. 5 | ** There is no guarantee on data integrity in such a case. 6 | ** 7 | ** Written by Kiem-Phong Vo 8 | */ 9 | #if __STD_C 10 | int sfclrlock(reg Sfio_t* f) 11 | #else 12 | int sfclrlock(f) 13 | reg Sfio_t *f; 14 | #endif 15 | { 16 | int rv; 17 | 18 | /* already closed */ 19 | if(f && (f->mode&SF_AVAIL)) 20 | return 0; 21 | 22 | SFMTXSTART(f,0); 23 | 24 | /* clear error bits */ 25 | f->flags &= ~(SF_ERROR|SF_EOF); 26 | 27 | /* clear peek locks */ 28 | if(f->mode&SF_PKRD) 29 | { f->here -= f->endb-f->next; 30 | f->endb = f->next; 31 | } 32 | 33 | SFCLRBITS(f); 34 | 35 | /* throw away all lock bits except for stacking state SF_PUSH */ 36 | f->mode &= (SF_RDWR|SF_INIT|SF_POOL|SF_PUSH|SF_SYNCED|SF_STDIO); 37 | 38 | rv = (f->mode&SF_PUSH) ? 0 : (f->flags&SF_FLAGS); 39 | 40 | SFMTXRETURN(f, rv); 41 | } 42 | -------------------------------------------------------------------------------- /src/lib/vthread/README: -------------------------------------------------------------------------------- 1 | This directory contains the source code for the Vthread library. 2 | Despite the promise of the Posix pthread interface, multi-threading 3 | is still a haphazard as far as portable programming is concerned. 4 | For this reason, Vthread provides a set of functions for portable 5 | threads including mutex handling. Vthread is known to run on all 6 | known Unix flavors including Linux, BSD, Irix, HPUX, Solaris, etc. 7 | and all known Window versions. 8 | 9 | 10 | DIRECTORY HIERARCHY: 11 | 12 | . : source code for Vthread 13 | ./features: source code for generating configuration parameters. 14 | ./Vthread_t: regression tests. 15 | 16 | 17 | SOFTWARE CONSTRUCTION: 18 | 19 | To build the library, type: 20 | 21 | make -f Makefile install 22 | 23 | 24 | CORRESPONDENCE: 25 | 26 | Comments, etc. should be sent to: 27 | 28 | Phong Vo 29 | AT&T Labs - Research 30 | 180 Park Avenue 31 | Florham Park, NJ 07932 32 | e-mail: kpv@research.att.com 33 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tatexit.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | /* test to see if files created in atexit functions work ok */ 4 | 5 | void ae() 6 | { 7 | Sfio_t* f = sfopen(NIL(Sfio_t*), tstfile(0), "w"); 8 | 9 | if(!f) 10 | terror("Can't create file"); 11 | 12 | if(sfwrite(f,"1234\n",5) != 5) 13 | terror("Can't write to file"); 14 | } 15 | 16 | MAIN() 17 | { 18 | Sfio_t* f; 19 | 20 | if(argc <= 1) /* atexit function registered after some sfio access */ 21 | { if(!(f = sfopen(NIL(Sfio_t*), tstfile(1), "w")) ) 22 | terror("Can't create file"); 23 | if(sfwrite(f,"1234\n",5) != 5) 24 | terror("Can't write to file"); 25 | 26 | atexit(ae); 27 | 28 | system(sfprints("%s 1",argv[0])); 29 | } 30 | else /* atexit function registered before some sfio access */ 31 | { atexit(ae); 32 | 33 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(1), "w")) ) 34 | terror("Can't create file"); 35 | if(sfwrite(f,"1234\n",5) != 5) 36 | terror("Can't write to file"); 37 | } 38 | 39 | TSTEXIT(0); 40 | } 41 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_dc/sfdisc.h: -------------------------------------------------------------------------------- 1 | #ifndef _SFDISC_H 2 | #define _SFDISC_H 1 3 | 4 | #include 5 | 6 | #if _PACKAGE_ast 7 | #if _BLD_ast && defined(__EXPORT__) 8 | #define extern __EXPORT__ 9 | #endif 10 | #endif 11 | 12 | /* to create a user-defined event specific to some package */ 13 | #define SFDCEVENT(a,b,n) ((((a)-'A'+1)<<11)^(((b)-'A'+1)<<6)^(n)) 14 | 15 | _BEGIN_EXTERNS_ 16 | /* functions to create disciplines */ 17 | extern int sfdcdio _ARG_((Sfio_t*, size_t)); 18 | extern int sfdcdos _ARG_((Sfio_t*)); 19 | extern int sfdcfilter _ARG_((Sfio_t*, const char*)); 20 | extern int sfdcseekable _ARG_((Sfio_t*)); 21 | extern int sfdcslow _ARG_((Sfio_t*)); 22 | extern int sfdcsubstream _ARG_((Sfio_t*, Sfio_t*, Sfoff_t, Sfoff_t)); 23 | extern int sfdctee _ARG_((Sfio_t*, Sfio_t*)); 24 | extern int sfdcunion _ARG_((Sfio_t*, Sfio_t**, int)); 25 | 26 | extern int sfdclzw _ARG_((Sfio_t*)); 27 | extern int sfdcgzip(Sfio_t*, int); 28 | _END_EXTERNS_ 29 | 30 | #if _PACKAGE_ast 31 | #undef extern 32 | #endif 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/topen.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t* f; 6 | Sfio_t sf; 7 | 8 | if(sfopen(sfstdout,"abc","s") != sfstdout) 9 | terror("Bad reopening of sfstdout\n"); 10 | if(sfopen(sfstdin,"123","s") != sfstdin) 11 | terror("Bad reopening of sfstdin\n"); 12 | sfclose(sfstdin); 13 | 14 | if(!(f = sfopen(NIL(Sfio_t*),"123","s")) ) 15 | terror("Opening a stream\n"); 16 | sfclose(f); 17 | if(sfopen(f,"123","s") != NIL(Sfio_t*)) 18 | terror("can't reopen a closed stream!\n"); 19 | 20 | if(sfnew(&sf,NIL(char*),(size_t)SF_UNBOUND,0,SF_EOF|SF_READ) != &sf) 21 | terror("Did not open sf\n"); 22 | sfset(&sf,SF_STATIC,1); 23 | if(sfclose(&sf) < 0 || !(sfset(&sf,0,0)&SF_STATIC)) 24 | terror("Did not close sf\n"); 25 | 26 | /* test for exclusive opens */ 27 | unlink(tstfile(0)); 28 | if(!(f = sfopen(NIL(Sfio_t*),tstfile(0),"wx") ) ) 29 | terror("sfopen failed\n"); 30 | if((f = sfopen(f,tstfile(0),"wx") ) ) 31 | terror("sfopen should not succeed here\n"); 32 | 33 | TSTEXIT(0); 34 | } 35 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/Makefile: -------------------------------------------------------------------------------- 1 | # makefile for stdio-source compatibility code 2 | # 3 | # Written by Kiem-Phong Vo 4 | 5 | # Compiler and flags to use 6 | LIBTYPE= 7 | AR= ar 8 | CC= cc 9 | CXFLAGS= 10 | CCMODE= -O 11 | CCFLAGS= -I. -I.. $(CCMODE) $(LIBTYPE) $(CXFLAGS) 12 | 13 | HDRS= stdio.h 14 | SRCS= stdfgetc.c stdfprintf.c stdfputc.c stdfscanf.c stdgetc.c stdgets.c \ 15 | stdgetw.c stdfdopen.c stdprintf.c stdputc.c stdputw.c stdscanf.c \ 16 | stdsprintf.c stdsetvbuf.c stdfopen.c stdfreopen.c stdpopen.c stdtmpfile.c \ 17 | stdfwrite.c stdfread.c stdfflush.c 18 | 19 | OBJS= stdfgetc.o stdfprintf.o stdfputc.o stdfscanf.o stdgetc.o stdgets.o \ 20 | stdgetw.o stdfdopen.o stdprintf.o stdputc.o stdputw.o stdscanf.o \ 21 | stdsprintf.o stdsetvbuf.o stdfopen.o stdfreopen.o stdpopen.o stdtmpfile.o \ 22 | stdfwrite.o stdfread.o stdfflush.o 23 | 24 | .c.o: 25 | $(CC) -c $(CCFLAGS) $*.c 26 | 27 | must: $(OBJS) 28 | 29 | 3dupdate: 30 | cp Makefile $(HDRS) $(SRCS) ... 31 | 32 | clean: 33 | -(rm $(OBJS); exit 0) >/dev/null 2>&1 34 | -------------------------------------------------------------------------------- /src/lib/sfio/sfprints.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Construct a string with the given format and data. 4 | ** This function allocates space as necessary to store the string. 5 | ** This avoids overflow problems typical with sprintf() in stdio. 6 | ** 7 | ** Written by Kiem-Phong Vo. 8 | */ 9 | 10 | #if __STD_C 11 | char* sfprints(const char* form, ...) 12 | #else 13 | char* sfprints(va_alist) 14 | va_dcl 15 | #endif 16 | { 17 | va_list args; 18 | reg int rv; 19 | static Sfio_t* f; 20 | 21 | #if __STD_C 22 | va_start(args,form); 23 | #else 24 | reg char *form; 25 | va_start(args); 26 | form = va_arg(args,char*); 27 | #endif 28 | 29 | /* make a fake stream */ 30 | if(!f && 31 | !(f = sfnew(NIL(Sfio_t*),NIL(char*),(size_t)SF_UNBOUND, 32 | -1,SF_WRITE|SF_STRING)) ) 33 | return NIL(char*); 34 | 35 | sfseek(f,(Sfoff_t)0,0); 36 | rv = sfvprintf(f,form,args); 37 | va_end(args); 38 | 39 | if(rv < 0 || sfputc(f,'\0') < 0) 40 | return NIL(char*); 41 | 42 | _Sfi = (f->next - f->data) - 1; 43 | return (char*)f->data; 44 | } 45 | -------------------------------------------------------------------------------- /src/lib/sfio/sfmutex.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Obtain/release exclusive use of a stream. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | /* the main locking/unlocking interface */ 9 | #if __STD_C 10 | int sfmutex(Sfio_t* f, int type) 11 | #else 12 | int sfmutex(f, type) 13 | Sfio_t* f; 14 | int type; 15 | #endif 16 | { 17 | #if !vt_threaded 18 | NOTUSED(f); NOTUSED(type); 19 | return 0; 20 | #else 21 | 22 | SFONCE(); 23 | 24 | if(!f) 25 | return -1; 26 | 27 | if(!f->mutex) 28 | { if(f->bits&SF_PRIVATE) 29 | return 0; 30 | 31 | vtmtxlock(_Sfmutex); 32 | f->mutex = vtmtxopen(NIL(Vtmutex_t*), VT_INIT); 33 | vtmtxunlock(_Sfmutex); 34 | if(!f->mutex) 35 | return -1; 36 | } 37 | 38 | if(type == SFMTX_LOCK) 39 | return vtmtxlock(f->mutex); 40 | else if(type == SFMTX_TRYLOCK) 41 | return vtmtxtrylock(f->mutex); 42 | else if(type == SFMTX_UNLOCK) 43 | return vtmtxunlock(f->mutex); 44 | else if(type == SFMTX_CLRLOCK) 45 | return vtmtxclrlock(f->mutex); 46 | else return -1; 47 | #endif /*vt_threaded*/ 48 | } 49 | -------------------------------------------------------------------------------- /src/lib/sfio/sfgetl.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Read a long value coded in a portable format. 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | Sflong_t sfgetl(reg Sfio_t* f) 10 | #else 11 | Sflong_t sfgetl(f) 12 | reg Sfio_t* f; 13 | #endif 14 | { 15 | Sflong_t v; 16 | reg uchar *s, *ends, c; 17 | reg int p; 18 | 19 | SFMTXSTART(f,(Sflong_t)(-1)); 20 | 21 | if(f->mode != SF_READ && _sfmode(f,SF_READ,0) < 0) 22 | SFMTXRETURN(f, (Sflong_t)(-1)); 23 | SFLOCK(f,0); 24 | 25 | for(v = 0;;) 26 | { if(SFRPEEK(f,s,p) <= 0) 27 | { f->flags |= SF_ERROR; 28 | v = (Sflong_t)(-1); 29 | goto done; 30 | } 31 | for(ends = s+p; s < ends;) 32 | { c = *s++; 33 | if(c&SF_MORE) 34 | v = ((Sfulong_t)v << SF_UBITS) | SFUVALUE(c); 35 | else 36 | { /* special translation for this byte */ 37 | v = ((Sfulong_t)v << SF_SBITS) | SFSVALUE(c); 38 | f->next = s; 39 | v = (c&SF_SIGN) ? -v-1 : v; 40 | goto done; 41 | } 42 | } 43 | f->next = s; 44 | } 45 | done : 46 | SFOPEN(f,0); 47 | SFMTXRETURN(f, v); 48 | } 49 | -------------------------------------------------------------------------------- /NOTICE: -------------------------------------------------------------------------------- 1 | 2 | /******************************************************************************** 3 | * This product contains certain software code or other information * 4 | * ("AT&T Software") proprietary to AT&T Corp. ("AT&T"). * 5 | * The AT&T Software is provided to you "AS IS". YOU ASSUME TOTAL * 6 | * RESPONSIBILITY AND RISK FOR USE OF THE AT&T SOFTWARE. * 7 | * AT&T DOES NOT MAKE, AND EXPRESSLY DISCLAIMS, ANY EXPRESS OR * 8 | * IMPLIED WARRANTIES OF ANY KIND WHATSOEVER, INCLUDING, * 9 | * WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY OR * 10 | * FITNESS FOR A PARTICULAR PURPOSE, WARRANTIES OF TITLE OR * 11 | * NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS, * 12 | * ANY WARRANTIES ARISING BY USAGE OF TRADE, COURSE OF DEALING OR * 13 | * COURSE OF PERFORMANCE, OR ANY WARRANTY THAT THE AT&T SOFTWARE * 14 | * IS "ERROR FREE" OR WILL MEET YOUR REQUIREMENTS. * 15 | * * 16 | * All rights reserved. AT&T is a registered trademark of AT&T Corp. * 17 | ********************************************************************************/ 18 | 19 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/flsbuf.c: -------------------------------------------------------------------------------- 1 | #define _in_flsbuf 1 2 | #include "sfstdio.h" 3 | 4 | /* Flush output buffer. 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | FLSBUF(c,f) 9 | { 10 | reg Sfio_t* sf; 11 | 12 | if(!(sf = _sfstream(f))) 13 | return -1; 14 | 15 | if((c = sfputc(sf,c)) < 0) 16 | _stdseterr(f,sf); 17 | else if(!(sf->flags&(SF_LINE|SF_MTSAFE))) 18 | { /* fast access to buffer for putc benefit */ 19 | #if _FILE_writeptr 20 | f->std_writeptr = sf->next; 21 | f->std_writeend = sf->endb; 22 | #endif 23 | #if _FILE_readptr 24 | f->std_readptr = f->std_readend = NIL(uchar*); 25 | #endif 26 | #if _FILE_ptr || _FILE_p 27 | f->std_ptr = sf->next; 28 | #endif 29 | #if _FILE_cnt 30 | f->std_cnt = sf->endb - sf->next; 31 | #endif 32 | #if _FILE_w 33 | f->std_w = sf->endb - sf->next; 34 | #endif 35 | #if _FILE_r 36 | f->std_r = 0; 37 | #endif 38 | #if _FILE_writeptr || _FILE_cnt || _FILE_w 39 | /* internal protection against mixing of sfio/stdio */ 40 | sf->mode |= SF_STDIO; 41 | sf->endr = sf->endw = sf->data; 42 | #endif 43 | } 44 | 45 | return c; 46 | } 47 | -------------------------------------------------------------------------------- /src/lib/sfio/NOTICE: -------------------------------------------------------------------------------- 1 | 2 | /******************************************************************************** 3 | * This product contains certain software code or other information * 4 | * ("AT&T Software") proprietary to AT&T Corp. ("AT&T"). * 5 | * The AT&T Software is provided to you "AS IS". YOU ASSUME TOTAL * 6 | * RESPONSIBILITY AND RISK FOR USE OF THE AT&T SOFTWARE. * 7 | * AT&T DOES NOT MAKE, AND EXPRESSLY DISCLAIMS, ANY EXPRESS OR * 8 | * IMPLIED WARRANTIES OF ANY KIND WHATSOEVER, INCLUDING, * 9 | * WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY OR * 10 | * FITNESS FOR A PARTICULAR PURPOSE, WARRANTIES OF TITLE OR * 11 | * NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS, * 12 | * ANY WARRANTIES ARISING BY USAGE OF TRADE, COURSE OF DEALING OR * 13 | * COURSE OF PERFORMANCE, OR ANY WARRANTY THAT THE AT&T SOFTWARE * 14 | * IS "ERROR FREE" OR WILL MEET YOUR REQUIREMENTS. * 15 | * * 16 | * All rights reserved. AT&T is a registered trademark of AT&T Corp. * 17 | ********************************************************************************/ 18 | 19 | -------------------------------------------------------------------------------- /src/lib/vthread/NOTICE: -------------------------------------------------------------------------------- 1 | 2 | /******************************************************************************** 3 | * This product contains certain software code or other information * 4 | * ("AT&T Software") proprietary to AT&T Corp. ("AT&T"). * 5 | * The AT&T Software is provided to you "AS IS". YOU ASSUME TOTAL * 6 | * RESPONSIBILITY AND RISK FOR USE OF THE AT&T SOFTWARE. * 7 | * AT&T DOES NOT MAKE, AND EXPRESSLY DISCLAIMS, ANY EXPRESS OR * 8 | * IMPLIED WARRANTIES OF ANY KIND WHATSOEVER, INCLUDING, * 9 | * WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY OR * 10 | * FITNESS FOR A PARTICULAR PURPOSE, WARRANTIES OF TITLE OR * 11 | * NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS, * 12 | * ANY WARRANTIES ARISING BY USAGE OF TRADE, COURSE OF DEALING OR * 13 | * COURSE OF PERFORMANCE, OR ANY WARRANTY THAT THE AT&T SOFTWARE * 14 | * IS "ERROR FREE" OR WILL MEET YOUR REQUIREMENTS. * 15 | * * 16 | * All rights reserved. AT&T is a registered trademark of AT&T Corp. * 17 | ********************************************************************************/ 18 | 19 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/sprintf.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Format a string 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #if __STD_C 8 | int sprintf(char* s, const char* form, ...) 9 | #else 10 | int sprintf(va_alist) 11 | va_dcl 12 | #endif 13 | { 14 | va_list args; 15 | reg int rv; 16 | #if __STD_C 17 | va_start(args,form); 18 | #else 19 | reg char* s; 20 | reg char* form; 21 | va_start(args); 22 | s = va_arg(args,char*); 23 | form = va_arg(args,char*); 24 | #endif 25 | 26 | rv = (s && form) ? (int)sfvsprintf(s,SF_MAXINT,form,args) : -1; 27 | va_end(args); 28 | 29 | return rv; 30 | } 31 | 32 | #if __STD_C 33 | int asprintf(char** as, const char* form, ...) 34 | #else 35 | int asprintf(va_alist) 36 | va_dcl 37 | #endif 38 | { 39 | va_list args; 40 | reg int rv; 41 | #if __STD_C 42 | va_start(args,form); 43 | #else 44 | reg char** as; 45 | reg char* form; 46 | va_start(args); 47 | as = va_arg(args,char**); 48 | form = va_arg(args,char*); 49 | #endif 50 | 51 | rv = (as && form) ? (int)sfvaprints(as,form,args) : -1; 52 | va_end(args); 53 | 54 | return rv; 55 | } 56 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/freopen.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Reopening a stream 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | 8 | #if __STD_C 9 | FILE* freopen(char*name, const char* mode, reg FILE* f) 10 | #else 11 | FILE* freopen(name,mode,f) 12 | reg char* name; 13 | reg char* mode; 14 | reg FILE* f; 15 | #endif 16 | { 17 | Sfio_t* sf; 18 | 19 | if(f && (sf = _sfstream(f)) ) 20 | _sfunmap(f); 21 | 22 | if(!(sf = sfopen(sf, name, mode)) ) 23 | return NIL(FILE*); 24 | else 25 | { int uflag; 26 | _sftype(mode, NIL(int*), &uflag); 27 | if(!uflag) 28 | sf->flags |= SF_MTSAFE; 29 | 30 | if(_stdstream(sf,f) != f) 31 | { sfclose(sf); 32 | return NIL(FILE*); 33 | } 34 | else return f; 35 | } 36 | } 37 | 38 | #if _lib___freopen64 && !_done___freopen64 && !defined(freopen) 39 | #define _done___freopen64 1 40 | #define freopen __freopen64 41 | #include "freopen.c" 42 | #undef freopen 43 | #endif 44 | 45 | #if _lib_freopen64 && !_done_freopen64 && !defined(freopen) 46 | #define _done_freopen64 1 47 | #define freopen freopen64 48 | #include "freopen.c" 49 | #undef freopen 50 | #endif 51 | -------------------------------------------------------------------------------- /src/lib/sfio/sfgetd.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Read a portably coded double value 4 | ** 5 | ** Written by Kiem-Phong Vo 6 | */ 7 | 8 | #if __STD_C 9 | Sfdouble_t sfgetd(Sfio_t* f) 10 | #else 11 | Sfdouble_t sfgetd(f) 12 | Sfio_t* f; 13 | #endif 14 | { 15 | reg uchar *s, *ends, c; 16 | reg int p, sign, exp; 17 | Sfdouble_t v; 18 | 19 | SFMTXSTART(f,-1.); 20 | 21 | if((sign = sfgetc(f)) < 0 || (exp = (int)sfgetu(f)) < 0) 22 | SFMTXRETURN(f, -1.); 23 | 24 | if(f->mode != SF_READ && _sfmode(f,SF_READ,0) < 0) 25 | SFMTXRETURN(f, -1.); 26 | 27 | SFLOCK(f,0); 28 | 29 | v = 0.; 30 | for(;;) 31 | { /* fast read for data */ 32 | if(SFRPEEK(f,s,p) <= 0) 33 | { f->flags |= SF_ERROR; 34 | v = -1.; 35 | goto done; 36 | } 37 | 38 | for(ends = s+p; s < ends; ) 39 | { c = *s++; 40 | v += SFUVALUE(c); 41 | v = ldexpl(v,-SF_PRECIS); 42 | if(!(c&SF_MORE)) 43 | { f->next = s; 44 | goto done; 45 | } 46 | } 47 | f->next = s; 48 | } 49 | 50 | done: 51 | v = ldexpl(v,(sign&02) ? -exp : exp); 52 | if(sign&01) 53 | v = -v; 54 | 55 | SFOPEN(f,0); 56 | SFMTXRETURN(f, v); 57 | } 58 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tpipemove.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | int fd[2]; 6 | Sfio_t *fr, *fw; 7 | char *s; 8 | int n, w; 9 | 10 | if(pipe(fd) < 0) 11 | terror("Can't open pipe\n"); 12 | 13 | if(!(fr = sfnew(NIL(Sfio_t*),NIL(Void_t*),(size_t)SF_UNBOUND,fd[0],SF_READ)) || 14 | !(fw = sfnew(NIL(Sfio_t*),NIL(Void_t*),(size_t)SF_UNBOUND,fd[1],SF_WRITE)) ) 15 | terror("Can't open pipe streams\n"); 16 | sfset(fr,SF_SHARE,1); 17 | 18 | if(sfopen(sfstdout,tstfile(0),"w") != sfstdout) 19 | terror("Can't open for write\n"); 20 | if(sfopen(sfstdin,tstfile(0),"r") != sfstdin) 21 | terror("Can't open for read\n"); 22 | 23 | for(n = 0; n < 100; ++n) 24 | if((w = sfwrite(fw,"123456789\n",10)) != 10) 25 | terror("Writing to pipe w=%d\n",w); 26 | 27 | if((n = (int)sfmove(fr,sfstdout,(Sfoff_t)100,'\n')) != 100) 28 | terror("sfmove failed n=%d\n", n); 29 | sfclose(sfstdout); 30 | 31 | for(n = 0; n < 100; ++n) 32 | { if(!(s = sfgetr(sfstdin,'\n',1)) ) 33 | terror("Can't read data\n"); 34 | if(strcmp(s,"123456789") != 0) 35 | terror("Wrong data\n"); 36 | } 37 | 38 | TSTEXIT(0); 39 | } 40 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/filbuf.c: -------------------------------------------------------------------------------- 1 | #define _in_filbuf 1 2 | #include "sfstdio.h" 3 | 4 | /* Fill buffer. 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | FILBUF(f) 9 | { 10 | reg Sfio_t* sf; 11 | reg int rv; 12 | 13 | if(!(sf = _sfstream(f))) 14 | return -1; 15 | 16 | if((rv = sfgetc(sf)) < 0) 17 | _stdseterr(f,sf); 18 | else if(!(sf->flags&SF_MTSAFE) ) 19 | { 20 | #if _FILE_readptr /* Linux-stdio */ 21 | #if _under_flow && !_u_flow /* __underflow does not bump pointer */ 22 | f->std_readptr = sf->next-1; 23 | #else 24 | f->std_readptr = sf->next; 25 | #endif 26 | f->std_readend = sf->endb; 27 | #endif 28 | #if _FILE_writeptr 29 | f->std_writeptr = f->std_writeend = NIL(uchar*); 30 | #endif 31 | 32 | #if _FILE_ptr || _FILE_p /* old/BSD-stdio */ 33 | f->std_ptr = sf->next; 34 | #endif 35 | #if _FILE_cnt 36 | f->std_cnt = sf->endb - sf->next; 37 | #endif 38 | #if _FILE_r 39 | f->std_r = sf->endb - sf->next; 40 | #endif 41 | #if _FILE_w 42 | f->std_w = 0; 43 | #endif 44 | 45 | #if _FILE_readptr || _FILE_cnt || _FILE_r 46 | sf->mode |= SF_STDIO; 47 | sf->endr = sf->endw = sf->data; 48 | #endif 49 | } 50 | 51 | return(rv); 52 | } 53 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tstkpk.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t* f; 6 | char buf[1024]; 7 | char* s; 8 | int fd[2]; 9 | 10 | close(0); 11 | if(pipe(fd) < 0 || fd[0] != 0) 12 | terror("Making pipe\n"); 13 | 14 | strcpy(buf,"1234567890"); 15 | if(!(f = sfopen(NIL(Sfio_t*),buf,"s"))) 16 | terror("Opening string stream\n"); 17 | 18 | if(!sfstack(f,sfstdin)) 19 | terror("Stacking\n"); 20 | 21 | if(write(fd[1],"ab",2) != 2) 22 | terror("Writing ab to pipe\n"); 23 | if(!(s = sfreserve(f,SF_UNBOUND,1)) || sfvalue(f) != 2) 24 | terror("Peeking size1 = %d but should be 2\n", sfvalue(f)); 25 | sfread(f,s,0); 26 | if(strncmp(s,"ab",2) != 0) 27 | terror("Wrong data1\n"); 28 | 29 | if(write(fd[1],"cd",2) != 2) 30 | terror("Writing cd to pipe\n"); 31 | close(fd[1]); 32 | if(!(s = sfreserve(f,4,0)) ) 33 | terror("Peeking size2 = %d but should be 4\n", sfvalue(f)); 34 | if(strncmp(s,"abcd",4) != 0) 35 | terror("Wrong data2\n"); 36 | 37 | if(!(s = sfreserve(f,10,0)) ) 38 | terror("Peeking size3 = %d but should be 10\n", sfvalue(f)); 39 | if(strncmp(s,"1234567890",10) != 0) 40 | terror("Wrong data3\n"); 41 | 42 | TSTEXIT(0); 43 | } 44 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/ftell.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Tell current IO position pointer 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #ifndef lcloff_t 8 | #define lcloff_t long 9 | #endif 10 | 11 | #if __STD_C 12 | lcloff_t ftell(reg FILE* f) 13 | #else 14 | lcloff_t ftell(f) 15 | reg FILE* f; 16 | #endif 17 | { 18 | reg Sfio_t* sf; 19 | 20 | if(!(sf = _sfstream(f))) 21 | return (lcloff_t)(-1); 22 | 23 | return (lcloff_t)sfseek(sf, (Sfoff_t)0, SEEK_CUR|SF_SHARE); 24 | } 25 | 26 | 27 | #if _lib_ftello && !_done_ftello && !defined(ftell) 28 | #define _done_ftello 1 29 | #undef lcloff_t 30 | #define lcloff_t stdoff_t 31 | #define ftell ftello 32 | #include "ftell.c" 33 | #undef ftell 34 | #endif 35 | 36 | #if _lib___ftello64 && !_done___ftello64 && !defined(ftell) 37 | #define _done___ftello64 1 38 | #undef lcloff_t 39 | #define lcloff_t stdoff_t 40 | #define ftell __ftello64 41 | #include "ftell.c" 42 | #undef ftell 43 | #endif 44 | 45 | #if _lib___ftello64 && !_done_ftello64 && !defined(ftell) 46 | #define _done_ftello64 1 47 | #undef lcloff_t 48 | #define lcloff_t stdoff_t 49 | #define ftell ftello64 50 | #include "ftell.c" 51 | #undef ftell 52 | #endif 53 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/stdextern.c: -------------------------------------------------------------------------------- 1 | #define _in_stdextern 1 2 | #include "sfstdio.h" 3 | 4 | int _Stdextern = 0; /* symbol to force loading of this file */ 5 | 6 | #if _native_iob 7 | #define _have_streams 1 8 | #endif 9 | 10 | #if _do_iob && !_have_streams 11 | #define _have_streams 1 12 | FILE _iob[_NFILE]; 13 | #endif 14 | 15 | #if _do_sf && !_have_streams /* BSDI2.0 */ 16 | FILE _sf[_NFILE]; 17 | #endif 18 | 19 | #if _do_swbuf && _do_srget && !_have_streams /*BSDI3.0*/ 20 | #define _have_streams 1 21 | FILE __sstdin, __sstdout, __sstderr; 22 | #endif 23 | 24 | #if _do_self_stdin && !_have_streams /*Linux Redhat 6.0*/ 25 | #define _have_streams 1 26 | FILE _Stdin_, *stdin = &_Stdin_; 27 | FILE _Stdout_, *stdout = &_Stdout_; 28 | FILE _Stderr_, *stderr = &_Stderr_; 29 | #endif 30 | 31 | #if _do_ampersand_stdin && !_have_streams /*Linux Redhat 5.2*/ 32 | #define _have_streams 1 33 | FILE _IO_stdin_, _IO_stdout_, _IO_stderr_; 34 | #endif 35 | 36 | #if _do_star_stdin && !_have_streams /*Linux Redhat 5.2*/ 37 | #define _have_streams 1 38 | FILE _Stdin_, *_IO_stdin = &_Stdin_; 39 | FILE _Stdout_, *_IO_stdout = &_Stdout_; 40 | FILE _Stderr_, *_IO_stderr = &_Stderr_; 41 | #endif 42 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_t/tlocale.c: -------------------------------------------------------------------------------- 1 | #include "stdtest.h" 2 | #if _lib_locale 3 | #include 4 | #endif 5 | 6 | MAIN() 7 | { 8 | #if _lib_locale 9 | char buf[128], cmp[128]; 10 | float d; 11 | int n, decimal, thousand; 12 | struct lconv* lv; 13 | 14 | setlocale(LC_ALL, "en"); 15 | 16 | if(!(lv = localeconv())) 17 | TSTEXIT(0); 18 | 19 | decimal = '.'; 20 | if(lv->decimal_point && lv->decimal_point[0]) 21 | decimal = lv->decimal_point[0]; 22 | 23 | thousand = 0; 24 | if(lv->thousands_sep && lv->thousands_sep[0]) 25 | thousand = lv->thousands_sep[0]; 26 | 27 | if(thousand) 28 | sprintf(cmp,"1%c000", thousand); 29 | else sprintf(cmp,"1000"); 30 | sprintf(buf, "%'d", 1000); 31 | if(strcmp(buf, cmp) != 0) 32 | terror("Bad printing"); 33 | 34 | if(thousand) 35 | sprintf(cmp, "1%c000%c10", thousand, decimal); 36 | else sprintf(cmp, "1000%c10", decimal); 37 | d = 0.; 38 | if((n = sscanf(cmp, "%'f", &d)) != 1) 39 | terror("Scan error %d", n); 40 | if(d < 1000.099 || d > 1000.101) 41 | terror("Bad scanning"); 42 | sprintf(buf, "%.2f", d); 43 | if(strcmp(buf, "1000.10") != 0) 44 | terror("Deep formatting error"); 45 | #endif 46 | 47 | TSTEXIT(0); 48 | } 49 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tnotify.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | static int Type; 4 | 5 | #if __STD_C 6 | static void notify(Sfio_t* f, int type, int fd) 7 | #else 8 | static void notify(f, type, fd) 9 | Sfio_t* f; 10 | int type; 11 | int fd; 12 | #endif 13 | { 14 | switch(Type = type) 15 | { 16 | case SF_NEW: 17 | case SF_CLOSING: 18 | case SF_SETFD: 19 | case SF_READ: 20 | case SF_WRITE: 21 | return; 22 | default: 23 | terror("Unexpected nofity-type: %d\n",type); 24 | } 25 | } 26 | 27 | MAIN() 28 | { 29 | Sfio_t* f; 30 | int fd; 31 | 32 | sfnotify(notify); 33 | 34 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(0), "w")) && Type != SF_NEW) 35 | terror("Notify did not announce SF_NEW event\n"); 36 | fd = sffileno(f); 37 | close(fd+5); 38 | if(sfsetfd(f,fd+5) != fd+5 || Type != SF_SETFD) 39 | terror("Notify did not announce SF_SETFD event\n"); 40 | if(sfclose(f) < 0 || Type != SF_CLOSING) 41 | terror("Notify did not announce SF_CLOSING event\n"); 42 | 43 | if(sfputc(sfstdin,'a') >= 0 || Type != SF_WRITE) 44 | terror("Notify did not announce SF_WRITE event\n"); 45 | 46 | if(sfgetc(sfstdout) >= 0 || Type != SF_READ) 47 | terror("Notify did not announce SF_READ event\n"); 48 | 49 | TSTEXIT(0); 50 | } 51 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_dc/sfdcslow.c: -------------------------------------------------------------------------------- 1 | #include "sfdchdr.h" 2 | 3 | /* Make a stream op return immediately on interrupts. 4 | ** This is useful on slow streams (hence the name). 5 | ** 6 | ** Written by Glenn Fowler (03/18/1998). 7 | */ 8 | 9 | #if __STD_C 10 | static int slowexcept(Sfio_t* f, int type, Void_t* v, Sfdisc_t* disc) 11 | #else 12 | static int slowexcept(f, type, v, disc) 13 | Sfio_t* f; 14 | int type; 15 | Void_t* v; 16 | Sfdisc_t* disc; 17 | #endif 18 | { 19 | NOTUSED(f); 20 | NOTUSED(v); 21 | NOTUSED(disc); 22 | 23 | switch (type) 24 | { 25 | case SF_FINAL: 26 | case SF_DPOP: 27 | free(disc); 28 | break; 29 | case SF_READ: 30 | case SF_WRITE: 31 | if (errno == EINTR) 32 | return(-1); 33 | break; 34 | } 35 | 36 | return(0); 37 | } 38 | 39 | #if __STD_C 40 | int sfdcslow(Sfio_t* f) 41 | #else 42 | int sfdcslow(f) 43 | Sfio_t* f; 44 | #endif 45 | { 46 | Sfdisc_t* disc; 47 | 48 | if(!(disc = (Sfdisc_t*)malloc(sizeof(Sfdisc_t))) ) 49 | return(-1); 50 | 51 | disc->readf = NIL(Sfread_f); 52 | disc->writef = NIL(Sfwrite_f); 53 | disc->seekf = NIL(Sfseek_f); 54 | disc->exceptf = slowexcept; 55 | 56 | if(sfdisc(f,disc) != disc) 57 | { free(disc); 58 | return(-1); 59 | } 60 | 61 | return(0); 62 | } 63 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/trcrv.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | #if __STD_C 4 | ssize_t myread(Sfio_t* f, Void_t* buf, size_t n, Sfdisc_t* disc) 5 | #else 6 | ssize_t myread(f, buf, n, disc) 7 | Sfio_t* f; 8 | Void_t* buf; 9 | size_t n; 10 | Sfdisc_t* disc; 11 | #endif 12 | { 13 | return sfrd(f,buf,n,disc); 14 | } 15 | 16 | Sfdisc_t Disc = {myread, NIL(Sfwrite_f), NIL(Sfseek_f), NIL(Sfexcept_f)}; 17 | 18 | MAIN() 19 | { 20 | int fd[2]; 21 | 22 | if(pipe(fd) < 0) 23 | terror("Can't open pipe\n"); 24 | 25 | if(sfnew(sfstdin,NIL(Void_t*),(size_t)SF_UNBOUND,fd[0],SF_READ) != sfstdin) 26 | terror("Can't initialize sfstdin\n"); 27 | sfset(sfstdin,SF_SHARE,1); 28 | sfdisc(sfstdin,&Disc); 29 | 30 | if(sfnew(sfstdout,NIL(Void_t*),0,fd[1],SF_WRITE) != sfstdout) 31 | terror("Can't initialize sfstdout\n"); 32 | sfputr(sfstdout,"111\n222\n333\n",-1); 33 | sfsync(sfstdout); 34 | 35 | if(strcmp(sfgetr(sfstdin,'\n',1),"111") != 0) 36 | terror("sfgetr failed1\n"); 37 | if(sfstdin->_endb > sfstdin->_next) 38 | terror("sfgetr reads too much1\n"); 39 | 40 | if(strcmp(sfgetr(sfstdin,'\n',1),"222") != 0) 41 | terror("sfgetr failed2\n"); 42 | if(sfstdin->_endb > sfstdin->_next) 43 | terror("sfgetr reads too much2\n"); 44 | 45 | TSTEXIT(0); 46 | } 47 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tpopen.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | #include 3 | 4 | MAIN() 5 | { 6 | Sfio_t *f; 7 | char *s, *endos, *os = "one\ntwo\nthree\n"; 8 | int n; 9 | void(* handler)_ARG_((int)); 10 | 11 | if(argc > 1) 12 | { sfmove(sfstdin,sfstdout,(Sfoff_t)(-1),-1); 13 | return 0; 14 | } 15 | 16 | if(!(f = sfpopen((Sfio_t*)0, sfprints("%s -p > %s", argv[0], tstfile(0)), "w"))) 17 | terror("Opening for write\n"); 18 | if(sfwrite(f,os,strlen(os)) != (ssize_t)strlen(os)) 19 | terror("Writing\n"); 20 | 21 | #ifdef SIGPIPE 22 | if((handler = signal(SIGPIPE,SIG_DFL)) == SIG_DFL) 23 | terror("Wrong signal handler\n"); 24 | if((handler = signal(SIGPIPE,handler)) != SIG_DFL) 25 | terror("Weird signal handling"); 26 | #endif 27 | 28 | sfclose(f); 29 | 30 | if(!(f = sfpopen((Sfio_t*)0, sfprints("%s -p < %s", argv[0], tstfile(0)), "r"))) 31 | terror("Opening for read\n"); 32 | sleep(1); 33 | 34 | endos = os + strlen(os); 35 | while(s = sfgetr(f,'\n',0)) 36 | { n = sfvalue(f); 37 | if(strncmp(s,os,n) != 0) 38 | { s[n-1] = os[n-1] = 0; 39 | terror("Input=%s, Expect=%s\n",s,os); 40 | } 41 | os += n; 42 | } 43 | 44 | if(os != endos) 45 | terror("Does not match all data, left=%s\n",os); 46 | 47 | TSTEXIT(0); 48 | } 49 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tlocale.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | #if _lib_locale 3 | #include 4 | #endif 5 | 6 | MAIN() 7 | { 8 | #if _lib_locale 9 | char buf[128], cmp[128]; 10 | float d; 11 | int n, decimal, thousand; 12 | struct lconv* lv; 13 | 14 | setlocale(LC_ALL, ""); 15 | 16 | if(!(lv = localeconv())) 17 | TSTEXIT(0); 18 | 19 | decimal = '.'; 20 | if(lv->decimal_point && lv->decimal_point[0]) 21 | decimal = lv->decimal_point[0]; 22 | 23 | thousand = 0; 24 | if(lv->thousands_sep && lv->thousands_sep[0]) 25 | thousand = lv->thousands_sep[0]; 26 | 27 | if(thousand) 28 | sfsprintf(cmp, sizeof(cmp), "1%c000", thousand); 29 | else sfsprintf(cmp, sizeof(cmp), "1000"); 30 | sfsprintf(buf, sizeof(buf), "%'d", 1000); 31 | if(strcmp(buf, cmp) != 0) 32 | terror("Bad printing"); 33 | 34 | if(thousand) 35 | sfsprintf(cmp, sizeof(cmp), "1%c000%c10", thousand, decimal); 36 | else sfsprintf(cmp, sizeof(cmp), "1000%c10", decimal); 37 | d = 0.; 38 | if((n = sfsscanf(cmp, "%'f", &d)) != 1) 39 | terror("Scan error %d", n); 40 | if(d < 1000.099 || d > 1000.101) 41 | terror("Bad scanning"); 42 | sfsprintf(buf, sizeof(buf), "%.2f", d); 43 | if(strcmp(buf, "1000.10") != 0) 44 | terror("Deep formatting error"); 45 | #endif 46 | 47 | TSTEXIT(0); 48 | } 49 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/thole.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | /* Test for /dev/null and hole-preserving code */ 4 | 5 | MAIN() 6 | { 7 | Sfio_t* null; 8 | Sfio_t* f; 9 | int k, n; 10 | static char buf[256*1024], b[256*1024]; 11 | 12 | if(!(null = sfopen(NIL(Sfio_t*),"/dev/null","w")) ) 13 | terror("Opening /dev/null"); 14 | 15 | sfsetbuf(null,NIL(char*),(size_t)SF_UNBOUND); 16 | 17 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(0), "w+")) ) 18 | terror("Creating %s", tstfile(0)); 19 | sfwrite(f,"1234",4); 20 | sfseek(f,(Sfoff_t)1,0); 21 | sfsync(f); 22 | 23 | sfsetfd(null,-1); 24 | sfsetfd(null,sffileno(f)); 25 | sfsync(null); 26 | 27 | sfseek(f,(Sfoff_t)0,0); 28 | if(sfread(f,buf,4) != 4 || strncmp(buf,"1234",4) != 0) 29 | terror("Bad data"); 30 | 31 | for(k = 0; k < sizeof(buf); ++k) 32 | buf[k] = 1; 33 | for(k = sizeof(buf)/4; k < sizeof(buf)/2; ++k) /* make a big hole */ 34 | buf[k] = 0; 35 | 36 | if(!(f = sfopen(f, tstfile(0), "w+")) ) 37 | terror("Creating %s", tstfile(0)); 38 | n = sizeof(buf)-127; 39 | if(sfwrite(f,buf,n) != n) 40 | terror("Writing large buffer"); 41 | sfseek(f,(Sfoff_t)0,0); 42 | if(sfread(f,b,n) != n) 43 | terror("Reading large buffer"); 44 | for(k = 0; k < n; ++k) 45 | if(b[k] != buf[k]) 46 | terror("Bad data"); 47 | 48 | TSTEXIT(0); 49 | } 50 | -------------------------------------------------------------------------------- /src/lib/sfio/sfnputc.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Write out a character n times 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | ssize_t sfnputc(reg Sfio_t* f, reg int c, reg size_t n) 10 | #else 11 | ssize_t sfnputc(f,c,n) 12 | reg Sfio_t* f; /* file to write */ 13 | reg int c; /* char to be written */ 14 | reg size_t n; /* number of time to repeat */ 15 | #endif 16 | { 17 | reg uchar* ps; 18 | reg ssize_t p, w; 19 | uchar buf[128]; 20 | reg int local; 21 | 22 | SFMTXSTART(f,-1); 23 | 24 | GETLOCAL(f,local); 25 | if(SFMODE(f,local) != SF_WRITE && _sfmode(f,SF_WRITE,local) < 0) 26 | SFMTXRETURN(f, -1); 27 | 28 | SFLOCK(f,local); 29 | 30 | /* write into a suitable buffer */ 31 | if((size_t)(p = (f->endb-(ps = f->next))) < n) 32 | { ps = buf; p = sizeof(buf); } 33 | if((size_t)p > n) 34 | p = n; 35 | MEMSET(ps,c,p); 36 | ps -= p; 37 | 38 | w = n; 39 | if(ps == f->next) 40 | { /* simple sfwrite */ 41 | f->next += p; 42 | if(c == '\n') 43 | (void)SFFLSBUF(f,-1); 44 | goto done; 45 | } 46 | 47 | for(;;) 48 | { /* hard write of data */ 49 | if((p = SFWRITE(f,(Void_t*)ps,p)) <= 0 || (n -= p) <= 0) 50 | { w -= n; 51 | goto done; 52 | } 53 | if((size_t)p > n) 54 | p = n; 55 | } 56 | done : 57 | SFOPEN(f,local); 58 | SFMTXRETURN(f, w); 59 | } 60 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tmpread.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | /* This test checks to see if sfread() will always fill the buffer 4 | ** from a piped-stream correctly even if the other end of the pipe 5 | ** is writing odd amounts of bytes. 6 | */ 7 | #define RBUF 16 8 | #define ITER 1024 9 | 10 | MAIN() 11 | { 12 | Sfio_t *fr; 13 | int p[2]; 14 | char wbuf[1023], rbuf[RBUF*1023], *s; 15 | int i, r, n; 16 | 17 | if(pipe(p) < 0 ) 18 | terror("Making pipe for communication"); 19 | 20 | if(!(fr = sfnew(0, 0, (size_t)SF_UNBOUND, p[0], SF_READ)) ) 21 | terror("Making read stream"); 22 | 23 | for(i = 0; i < sizeof(wbuf); ++i) 24 | wbuf[i] = (i%10) + '0'; 25 | 26 | switch(fork()) 27 | { 28 | case -1 : 29 | terror("fork() failed"); 30 | case 0 : 31 | for(i = 0; i < RBUF*ITER; ++i) 32 | if(write(p[1], wbuf, sizeof(wbuf)) != sizeof(wbuf)) 33 | terror("Write to pipe failed i=%d", i); 34 | break; 35 | default: 36 | for(i = 0; i < ITER; ++i) 37 | { if(sfread(fr, rbuf, sizeof(rbuf)) != sizeof(rbuf)) 38 | terror("Read from pipe failed i=%d", i); 39 | for(r = 0, s = rbuf; r < RBUF; r += 1, s += n) 40 | for(n = 0; n < sizeof(wbuf); ++n) 41 | if(s[n] != (n%10)+'0') 42 | terror("Bad data i=%d n=%d", i, n); 43 | } 44 | break; 45 | } 46 | 47 | TSTEXIT(0); 48 | } 49 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfputu.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Write out an unsigned long value in a portable format. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int _sfputu(reg Sfio_t* f, Sfulong_t v) 10 | #else 11 | int _sfputu(f,v) 12 | reg Sfio_t* f; /* write a portable ulong to this stream */ 13 | Sfulong_t v; /* the unsigned value to be written */ 14 | #endif 15 | { 16 | #define N_ARRAY (2*sizeof(Sfulong_t)) 17 | reg uchar *s, *ps; 18 | reg ssize_t n, p; 19 | uchar c[N_ARRAY]; 20 | 21 | SFMTXSTART(f, -1); 22 | 23 | if(f->mode != SF_WRITE && _sfmode(f,SF_WRITE,0) < 0) 24 | SFMTXRETURN(f, -1); 25 | SFLOCK(f,0); 26 | 27 | /* code v as integers in base SF_UBASE */ 28 | s = ps = &(c[N_ARRAY-1]); 29 | *s = (uchar)SFUVALUE(v); 30 | while((v >>= SF_UBITS) ) 31 | *--s = (uchar)(SFUVALUE(v) | SF_MORE); 32 | n = (ps-s)+1; 33 | 34 | if(n > 8 || SFWPEEK(f,ps,p) < n) 35 | n = SFWRITE(f,(Void_t*)s,n); /* write the hard way */ 36 | else 37 | { switch(n) 38 | { 39 | case 8 : *ps++ = *s++; 40 | case 7 : *ps++ = *s++; 41 | case 6 : *ps++ = *s++; 42 | case 5 : *ps++ = *s++; 43 | case 4 : *ps++ = *s++; 44 | case 3 : *ps++ = *s++; 45 | case 2 : *ps++ = *s++; 46 | case 1 : *ps++ = *s++; 47 | } 48 | f->next = ps; 49 | } 50 | 51 | SFOPEN(f,0); 52 | SFMTXRETURN(f, (int)n); 53 | } 54 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/talign.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | 4 | static ssize_t Read; 5 | static int Count; 6 | 7 | #if __STD_C 8 | ssize_t readf(Sfio_t* f, Void_t* buf, size_t n, Sfdisc_t* disc) 9 | #else 10 | ssize_t readf(f,buf,n,disc) 11 | Sfio_t* f; 12 | Void_t* buf; 13 | size_t n; 14 | Sfdisc_t* disc; 15 | #endif 16 | { 17 | Count += 1; 18 | Read += (n = sfrd(f,buf,n,disc)); 19 | return n; 20 | } 21 | 22 | Sfdisc_t Disc = {readf, (Sfwrite_f)0, (Sfseek_f)0, (Sfexcept_f)0, (Sfdisc_t*)0}; 23 | 24 | MAIN() 25 | { 26 | Sfio_t* f; 27 | int i; 28 | char* s; 29 | char buf[1024], rbuf[128*1024]; 30 | 31 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(0), "w")) ) 32 | terror("Opening to write\n"); 33 | 34 | for(i = 0; i < sizeof(buf); ++i) 35 | buf[i] = 'a' + (i%26); 36 | 37 | for(i = 0; i < 1024; ++i) 38 | if(sfwrite(f,buf,sizeof(buf)) != sizeof(buf) ) 39 | terror("Write error\n"); 40 | sfclose(f); 41 | 42 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(0), "r")) ) 43 | terror("Opening to read\n"); 44 | sfsetbuf(f,rbuf,sizeof(rbuf)); 45 | 46 | sfdisc(f,&Disc); 47 | 48 | for(i = 0;; i += 64) 49 | { sfseek(f,(Sfoff_t)i,0); 50 | if(!(s = sfreserve(f,619,1)) ) 51 | break; 52 | sfread(f,s,64); 53 | } 54 | 55 | if(Read != 1024*sizeof(buf) ) 56 | terror("Count=%d Read=%d\n", Count, Read); 57 | 58 | TSTEXIT(0); 59 | } 60 | -------------------------------------------------------------------------------- /src/lib/sfio/sfresize.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Resize a stream. 4 | Written by Kiem-Phong Vo. 5 | */ 6 | 7 | #if __STD_C 8 | int sfresize(Sfio_t* f, Sfoff_t size) 9 | #else 10 | int sfresize(f, size) 11 | Sfio_t* f; 12 | Sfoff_t size; 13 | #endif 14 | { 15 | SFMTXSTART(f, -1); 16 | 17 | if(size < 0 || f->extent < 0 || 18 | (f->mode != SF_WRITE && _sfmode(f,SF_WRITE,0) < 0) ) 19 | SFMTXRETURN(f, -1); 20 | 21 | SFLOCK(f,0); 22 | 23 | if(f->flags&SF_STRING) 24 | { SFSTRSIZE(f); 25 | 26 | if(f->extent >= size) 27 | { if((f->flags&SF_MALLOC) && (f->next - f->data) <= size) 28 | { size_t s = (((size_t)size + 1023)/1024)*1024; 29 | Void_t* d; 30 | if(s < f->size && (d = realloc(f->data, s)) ) 31 | { f->data = d; 32 | f->size = s; 33 | f->extent = s; 34 | } 35 | } 36 | memclear((char*)(f->data+size), (int)(f->extent-size)); 37 | } 38 | else 39 | { if(SFSK(f, size, SEEK_SET, f->disc) != size) 40 | SFMTXRETURN(f, -1); 41 | memclear((char*)(f->data+f->extent), (int)(size-f->extent)); 42 | } 43 | } 44 | else 45 | { if(f->next > f->data) 46 | SFSYNC(f); 47 | #if _lib_ftruncate 48 | if(ftruncate(f->file, (sfoff_t)size) < 0) 49 | SFMTXRETURN(f, -1); 50 | #else 51 | SFMTXRETURN(f, -1); 52 | #endif 53 | } 54 | 55 | f->extent = size; 56 | 57 | SFOPEN(f, 0); 58 | 59 | SFMTXRETURN(f, 0); 60 | } 61 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/ttmpfile.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t* f; 6 | 7 | if(!(f = sftmp(1025))) 8 | terror("Can't open temp file\n"); 9 | if(sffileno(f) >= 0) 10 | terror("Attempt to create file detected\n"); 11 | if(sfputc(f,0) < 0) 12 | terror("Can't write to temp file\n"); 13 | if(sffileno(f) >= 0) 14 | terror("Attempt to create file detected\n"); 15 | if(sfclose(f) < 0) 16 | terror("Can't close temp file\n"); 17 | if(sffileno(f) >= 0) 18 | terror("Attempt to create file detected\n"); 19 | 20 | if(!(f = sftmp(8))) 21 | terror("Can't open temp file\n"); 22 | if(sffileno(f) >= 0) 23 | terror("Attempt to create file detected\n"); 24 | sfdisc(f,NIL(Sfdisc_t*)); 25 | if(sffileno(f) < 0) 26 | terror("Real file wasn't created\n"); 27 | if(sfclose(f) < 0) 28 | terror("Can't close temp file\n"); 29 | 30 | if(!(f = sftmp(8))) 31 | terror("Can't open temp file\n"); 32 | if(sffileno(f) >= 0) 33 | terror("Attempt to create file detected\n"); 34 | if(sfseek(f, (Sfoff_t)8, SEEK_SET) < 0) 35 | terror("Can't seek on temp file\n"); 36 | if(sffileno(f) >= 0) 37 | terror("Attempt to create file detected\n"); 38 | if(sfputc(f,0) < 0) 39 | terror("Can't write to temp file\n"); 40 | if(sffileno(f) < 0) 41 | terror("Real file wasn't created\n"); 42 | if(sfclose(f) < 0) 43 | terror("Can't close temp file\n"); 44 | 45 | TSTEXIT(0); 46 | } 47 | -------------------------------------------------------------------------------- /src/lib/vthread/vtmtxtrylock.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | 4 | /* Try to lock a mutex. 5 | ** 6 | ** Written by Kiem-Phong Vo. 7 | */ 8 | 9 | #if __STD_C 10 | int vtmtxtrylock(Vtmutex_t* mtx) 11 | #else 12 | int vtmtxtrylock(mtx) 13 | Vtmutex_t* mtx; 14 | #endif 15 | { 16 | #if !vt_threaded 17 | return -1; 18 | #else 19 | int rv; 20 | 21 | if(!mtx) 22 | return -1; 23 | 24 | #if _WIN32 25 | #define _did_trylock 1 26 | if(_Vttrylockf && (*_Vttrylockf)(&mtx->lock) ) 27 | { if(mtx->count <= 0) 28 | mtx->count = 1; 29 | else mtx->count += 1; 30 | return rv=0; 31 | } 32 | else 33 | { mtx->error = EBUSY; 34 | return -1; 35 | } 36 | #endif /*_WIN32*/ 37 | 38 | #if !_did_trylock && _mtx_recursive 39 | #define _did_trylock 1 40 | if((rv = pthread_mutex_trylock(&mtx->lock)) == MTXTRYLOCK_OK) 41 | { if(mtx->count <= 0) 42 | mtx->count = 1; 43 | else mtx->count += 1; 44 | return 0; 45 | } 46 | else 47 | { mtx->error = rv; 48 | return -1; 49 | } 50 | #endif 51 | 52 | #if !_did_trylock 53 | if((rv = pthread_mutex_trylock(&mtx->lock)) == MTXTRYLOCK_OK) 54 | { mtx->count = 1; 55 | mtx->owner = pthread_self(); 56 | return 0; 57 | } 58 | else if(MTXBUSY(rv) && pthread_equal(pthread_self(), mtx->owner) ) 59 | { mtx->count += 1; 60 | return 0; 61 | } 62 | else 63 | { mtx->error = rv; 64 | return -1; 65 | } 66 | #endif 67 | 68 | #endif /*vt_threaded*/ 69 | } 70 | -------------------------------------------------------------------------------- /src/lib/vthread/Makefile: -------------------------------------------------------------------------------- 1 | # libvthread.a makefile 2 | # Written by Kiem-Phong Vo 3 | 4 | INCDIR= ../../../include 5 | LIBDIR= ../../../lib 6 | BINDIR= ../../../bin 7 | 8 | CXFLAGS= 9 | CCMODE= -O 10 | CCFLAGS= $(CCMODE) -I. $(CXFLAGS) 11 | CC=cc 12 | 13 | HDRS= vthread.h vthdr.h 14 | SRCS= vtclose.c vtextern.c vtkill.c vtmtxclose.c vtmtxclrlock.c \ 15 | vtmtxlock.c vtmtxopen.c vtmtxtrylock.c vtmtxunlock.c \ 16 | vtonce.c vtopen.c vtrun.c vtself.c vtset.c vtwait.c 17 | OBJS= vtclose.o vtextern.o vtkill.o vtmtxclose.o vtmtxclrlock.o \ 18 | vtmtxlock.o vtmtxopen.o vtmtxtrylock.o vtmtxunlock.o \ 19 | vtonce.o vtopen.o vtrun.o vtself.o vtset.o vtwait.o 20 | 21 | .c.o : 22 | $(CC) -c $(CCFLAGS) $*.c 23 | 24 | all: install 25 | 26 | libvthread.a : ast_common.h FEATURE/vthread $(OBJS) 27 | ar cr libvthread.a $(OBJS) 28 | -(ranlib libvthread.a; exit 0) >/dev/null 2>&1 29 | 30 | ast_common.h : features/common 31 | $(BINDIR)/iffe - set cc $(CC) $(CCMODE) $(CXFLAGS) : \ 32 | run features/common > ast_common.h 33 | 34 | FEATURE/vthread : features/vthread 35 | $(BINDIR)/iffe set cc $(CC) $(CCMODE) $(CXFLAGS) : run features/vthread 36 | 37 | install : libvthread.a 38 | cp vthread.h ast_common.h $(INCDIR); 39 | cp libvthread.a $(LIBDIR); 40 | -(ranlib $(LIBDIR)/libvthread.a; exit 0) >/dev/null 2>&1 41 | 42 | clean : 43 | -(rm ast_common.h $(OBJS) libvthread.a FEATURE/*; exit 0) >/dev/null 2>&1 44 | -------------------------------------------------------------------------------- /src/lib/sfio/NOTES: -------------------------------------------------------------------------------- 1 | Wed May 28 21:51:59 EDT 2003 2 | Change terror.h and the runtest script in Sfio_t to strictly 3 | use Sfio functions when running regression tests. Previously, 4 | sprintf and vsprintf from Stdio were used. This causes linkage 5 | problems on some architecture. 6 | 7 | 8 | Sat Jun 21 09:36:05 EDT 2003 9 | sfsetbuf.c was changed to take a hint from sfsetbuf(f,f,blksz). 10 | blksz is used for aligning disk block boundary while reading data to 11 | optimize data transfer from disk (eg, via direct I/O). blksz can be 12 | at most f->size/2 so that data movement in buffer can be optimized. 13 | blksz should also be a power-of-2 for optimal disk seeks. 14 | 15 | features/common was changed so that the executable test to generate 16 | va_copy(), etc. will not dump core on certain platforms. 17 | 18 | Fri Aug 22 17:00:51 EDT 2003 19 | sfmove() was fixed so that record definition is done via sfgetr(). 20 | This clears up issue with partial records being multiply handled 21 | in different sfmove() calls. 22 | 23 | sfasprintf and sfvasprintf were added to reflect the new Stdio functions. 24 | 25 | Fix the use of argv.c and argv.i when processing %c in sfvprintf(). 26 | 27 | Prototypes of *printf and *scanf functions were changed to return ssize_t 28 | instead of int. This breaks compatibility with Stdio but in some sense is 29 | more correct. 30 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tpkrd.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | #include 3 | 4 | static int Fd[2]; 5 | 6 | #if __STD_C 7 | void alarmhandler(int sig) 8 | #else 9 | void alarmhandler(sig) 10 | int sig; 11 | #endif 12 | { 13 | if(write(Fd[1],"01234\n56789\n",12) != 12) 14 | terror("Writing to pipe\n"); 15 | } 16 | 17 | MAIN() 18 | { 19 | char* s; 20 | char buf[1024]; 21 | int n; 22 | 23 | if(pipe(Fd) < 0) 24 | terror("Can't make pipe\n"); 25 | 26 | if(sfnew(sfstdin,NIL(Void_t*),(size_t)SF_UNBOUND,Fd[0],SF_READ) != sfstdin) 27 | terror("Can't renew stdin\n"); 28 | sfset(sfstdin,SF_SHARE,1); 29 | 30 | if(sfpkrd(Fd[0],(Void_t*)buf,10,-1,1000,1) >= 0) 31 | terror("There isn't any data yet\n"); 32 | 33 | if((n = sfpkrd(Fd[0],(Void_t*)buf,sizeof(buf),-1,0L,0)) >= 0) 34 | terror("Wrong data size %d, expecting < 0", n); 35 | 36 | if(write(Fd[1],"abcd",4) != 4) 37 | terror("Couldn't write to pipe"); 38 | 39 | if((n = sfpkrd(Fd[0],(Void_t*)buf,sizeof(buf),-1,0L,0)) != 4) 40 | terror("Wrong data size %d, expecting 4", n); 41 | 42 | signal(SIGALRM,alarmhandler); 43 | alarm(2); 44 | if(!(s = sfgetr(sfstdin,'\n',1)) || strcmp(s,"01234") != 0) 45 | terror("Expecting 01234\n"); 46 | 47 | if(sfstdin->_next < sfstdin->_endb) 48 | terror("Sfgetr read too much\n"); 49 | 50 | if(!(s = sfgetr(sfstdin,'\n',1)) || strcmp(s,"56789") != 0) 51 | terror("Expecting 56789\n"); 52 | 53 | TSTEXIT(0); 54 | } 55 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tsfstr.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | 4 | MAIN() 5 | { 6 | Sfio_t *fp; 7 | char *s, buf[1024]; 8 | ssize_t n; 9 | 10 | if(!(fp = sfstropen()) ) 11 | terror("Can't open a string stream"); 12 | 13 | if(sfwrite(fp,"0123456789abcd",15) != 15) 14 | terror("sfwrite failed"); 15 | 16 | if(!(s = sfstrseek(fp, -5, SEEK_CUR)) ) 17 | terror("sfstrseek failed"); 18 | if(strcmp(s,"abcd") != 0) 19 | terror("Got wrong data"); 20 | 21 | if(!(s = sfstruse(fp)) ) 22 | terror("sfstruse failed"); 23 | if(strcmp(s,"0123456789") != 0) 24 | terror("Got bad data"); 25 | 26 | if(!(s = sfstrseek(fp, 0, SEEK_END)) ) 27 | terror("Bad sfstrseek"); 28 | 29 | if(!(s = sfstrrsrv(fp, 64*1024)) ) 30 | terror("Can't reserve space"); 31 | if(strcmp(sfstrbase(fp),"0123456789") != 0) 32 | terror("Lost data"); 33 | 34 | if(sfstrbuf(fp, buf, sizeof(buf), 0) < 0) 35 | terror("sfstrtmp failed"); 36 | if(sfstrbase(fp) != buf) 37 | terror("Wrong base"); 38 | if(sfstrsize(fp) != sizeof(buf)) 39 | terror("Wrong buffer size"); 40 | 41 | sfstrseek(fp,sizeof(buf),SEEK_SET); 42 | if(sfstruse(fp)) 43 | terror("sfstruse should have failed"); 44 | 45 | if(!(fp = sfstropen()) ) 46 | terror("Bad open"); 47 | if(!(s = (char*)sfreserve(fp, -1, SF_WRITE|SF_LOCKR)) ) 48 | terror("sfreserve failed"); 49 | if((n = sfvalue(fp)) < 1) 50 | terror("sfreserved failed size=%d", n); 51 | 52 | TSTEXIT(0); 53 | } 54 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfputm.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Write out an unsigned long value in a portable format. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int _sfputm(reg Sfio_t* f, Sfulong_t v, Sfulong_t m) 10 | #else 11 | int _sfputm(f,v,m) 12 | reg Sfio_t* f; /* write a portable ulong to this stream */ 13 | Sfulong_t v; /* the unsigned value to be written */ 14 | Sfulong_t m; /* the max value of the range */ 15 | #endif 16 | { 17 | #define N_ARRAY (2*sizeof(Sfulong_t)) 18 | reg uchar *s, *ps; 19 | reg ssize_t n, p; 20 | uchar c[N_ARRAY]; 21 | 22 | SFMTXSTART(f, -1); 23 | 24 | if(v > m || (f->mode != SF_WRITE && _sfmode(f,SF_WRITE,0) < 0) ) 25 | SFMTXRETURN(f, -1); 26 | SFLOCK(f,0); 27 | 28 | /* code v as integers in base SF_UBASE */ 29 | s = ps = &(c[N_ARRAY-1]); 30 | *s = (uchar)SFBVALUE(v); 31 | while((m >>= SF_BBITS) > 0 ) 32 | { v >>= SF_BBITS; 33 | *--s = (uchar)SFBVALUE(v); 34 | } 35 | n = (ps-s)+1; 36 | 37 | if(n > 8 || SFWPEEK(f,ps,p) < n) 38 | n = SFWRITE(f,(Void_t*)s,n); /* write the hard way */ 39 | else 40 | { switch(n) 41 | { 42 | case 8 : *ps++ = *s++; 43 | case 7 : *ps++ = *s++; 44 | case 6 : *ps++ = *s++; 45 | case 5 : *ps++ = *s++; 46 | case 4 : *ps++ = *s++; 47 | case 3 : *ps++ = *s++; 48 | case 2 : *ps++ = *s++; 49 | case 1 : *ps++ = *s++; 50 | } 51 | f->next = ps; 52 | } 53 | 54 | SFOPEN(f,0); 55 | SFMTXRETURN(f, (int)n); 56 | } 57 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tgetr.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t* f; 6 | char* s; 7 | char* string = "111\n222\n333"; 8 | 9 | f = sfopen(NIL(Sfio_t*),string,"s"); 10 | if(!(s = sfgetr(f,'\n',SF_STRING|SF_LOCKR)) || strcmp(s,"111") != 0) 11 | terror("sfgetr failed1\n"); 12 | 13 | if(sfgetr(f,'\n',0) != NIL(char*)) 14 | terror("sfgetr should have failed because of locking\n"); 15 | sfread(f,s,1); 16 | 17 | if(!(s = sfgetr(f,'\n',SF_STRING)) || strcmp(s,"222") != 0) 18 | terror("sfgetr failed2\n"); 19 | 20 | if((s = sfgetr(f,'\n',0)) != NIL(char*)) 21 | terror("sfgetr should have failed because of partial record\n"); 22 | 23 | if(!(s = sfgetr(f,0,SF_LASTR)) ) 24 | terror("sfgetr should have succeeded getting partial record\n"); 25 | 26 | /* test type == -1 and type == 1 modes */ 27 | sfseek(f,(Sfoff_t)0,0); 28 | if(!(s = sfgetr(f,'\n',1)) || strcmp(s,"111") != 0) 29 | terror("sfgetr failed in compatible mode\n"); 30 | 31 | if(!(s = sfgetr(f,'\n',SF_STRING|SF_LOCKR)) || strcmp(s,"222") != 0) 32 | terror("sfgetr failed3\n"); 33 | if(sfgetr(f,'\n',1) ) 34 | terror("sfgetr should have failed due to locking\n"); 35 | sfread(f,s,0); 36 | 37 | if(sfgetr(f,'\n',1) ) 38 | terror("sfgetr should have failed because record is incomplete\n"); 39 | 40 | if(!(s = sfgetr(f,0,-1)) || strcmp(s,"333") != 0) 41 | terror("sfgetr failed in getting last partial record\n"); 42 | 43 | TSTEXIT(0); 44 | } 45 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tnoseek.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | char* buffer; 4 | size_t size; 5 | size_t count; 6 | 7 | #if __STD_C 8 | Sfoff_t discseek(Sfio_t* f, Sfoff_t offset, int type, Sfdisc_t* disc) 9 | #else 10 | Sfoff_t discseek(f,offset,type,disc) 11 | Sfio_t* f; 12 | Sfoff_t offset; 13 | int type; 14 | Sfdisc_t* disc; 15 | #endif 16 | { 17 | return 0; 18 | } 19 | 20 | #if __STD_C 21 | ssize_t discwrite(Sfio_t* f, const Void_t* s, size_t n, Sfdisc_t* disc) 22 | #else 23 | ssize_t discwrite(f,s,n,disc) 24 | Sfio_t* f; 25 | Void_t* s; 26 | size_t n; 27 | Sfdisc_t* disc; 28 | #endif 29 | { 30 | buffer = (char*)s; 31 | size = n; 32 | count += 1; 33 | return n; 34 | } 35 | 36 | Sfdisc_t seekable = { (Sfread_f)0, discwrite, discseek, (Sfexcept_f)0 }; 37 | 38 | MAIN() 39 | { 40 | char buf[1024]; 41 | 42 | sfsetbuf(sfstdout,buf,sizeof(buf)); 43 | sfset(sfstdout,SF_LINE,0); 44 | 45 | if(sfdisc(sfstdout,&seekable) != &seekable) 46 | terror("Can't set discipline\n"); 47 | if(sfseek(sfstdout,(Sfoff_t)0,0) < 0) 48 | terror("Sfstdout should be seekable\n"); 49 | if(sfwrite(sfstdout,"123\n",4) != 4) 50 | terror("Can't write\n"); 51 | if(sfwrite(sfstdout,"123\n",4) != 4) 52 | terror("Can't write\n"); 53 | if(sfdisc(sfstdout,NIL(Sfdisc_t*)) != &seekable) 54 | terror("Can't pop discipline\n"); 55 | 56 | if(buffer != buf || size != 8 || count != 1) 57 | terror("Wrong calls to write\n"); 58 | 59 | TSTEXIT(0); 60 | } 61 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfputl.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Write out a long value in a portable format 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int _sfputl(reg Sfio_t* f, Sflong_t v) 10 | #else 11 | int _sfputl(f,v) 12 | reg Sfio_t* f; /* write a portable long to this stream */ 13 | Sflong_t v; /* the value to be written */ 14 | #endif 15 | { 16 | #define N_ARRAY (2*sizeof(Sflong_t)) 17 | reg uchar *s, *ps; 18 | reg ssize_t n, p; 19 | uchar c[N_ARRAY]; 20 | 21 | SFMTXSTART(f,-1); 22 | if(f->mode != SF_WRITE && _sfmode(f,SF_WRITE,0) < 0) 23 | SFMTXRETURN(f, -1); 24 | SFLOCK(f,0); 25 | 26 | s = ps = &(c[N_ARRAY-1]); 27 | if(v < 0) 28 | { /* add 1 to avoid 2-complement problems with -SF_MAXINT */ 29 | v = -(v+1); 30 | *s = (uchar)(SFSVALUE(v) | SF_SIGN); 31 | } 32 | else *s = (uchar)(SFSVALUE(v)); 33 | v = (Sfulong_t)v >> SF_SBITS; 34 | 35 | while(v > 0) 36 | { *--s = (uchar)(SFUVALUE(v) | SF_MORE); 37 | v = (Sfulong_t)v >> SF_UBITS; 38 | } 39 | n = (ps-s)+1; 40 | 41 | if(n > 8 || SFWPEEK(f,ps,p) < n) 42 | n = SFWRITE(f,(Void_t*)s,n); /* write the hard way */ 43 | else 44 | { switch(n) 45 | { 46 | case 8 : *ps++ = *s++; 47 | case 7 : *ps++ = *s++; 48 | case 6 : *ps++ = *s++; 49 | case 5 : *ps++ = *s++; 50 | case 4 : *ps++ = *s++; 51 | case 3 : *ps++ = *s++; 52 | case 2 : *ps++ = *s++; 53 | case 1 : *ps++ = *s++; 54 | } 55 | f->next = ps; 56 | } 57 | 58 | SFOPEN(f,0); 59 | SFMTXRETURN(f, n); 60 | } 61 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tscanf1.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | /* test to see sfvscanf still works ok with a discipline that 4 | ** returns one byte at a time. 5 | */ 6 | 7 | typedef struct _mydisc_s 8 | { 9 | Sfdisc_t disc; 10 | Sfio_t* f; 11 | } Mydisc_t; 12 | 13 | #if __STD_C 14 | static ssize_t oneread(Sfio_t* f, Void_t* buf, size_t size, Sfdisc_t* disc) 15 | #else 16 | static ssize_t oneread(f, buf, size, disc) 17 | Sfio_t* f; 18 | Void_t* buf; 19 | size_t size; 20 | Sfdisc_t* disc; 21 | #endif 22 | { 23 | Mydisc_t *dc = (Mydisc_t*)disc; 24 | 25 | if(!f || size <= 0) 26 | return -1; 27 | return sfread(dc->f, buf, 1); 28 | } 29 | 30 | static Mydisc_t Mydisc; 31 | 32 | MAIN() 33 | { 34 | int n; 35 | double d; 36 | int i; 37 | char s[10]; 38 | Sfio_t *f, *str; 39 | 40 | if((n = sfsscanf("ten 10 10", "%s %d %lf", s, &i, &d)) != 3) 41 | terror("Bad scanning %d", n); 42 | if(strncmp("ten",s,3) != 0 || i != 10 || d != 10) 43 | terror("Bad scanned values "); 44 | 45 | if(!(f = sfnew((Sfio_t*)0, (Void_t*)0, (size_t)SF_UNBOUND, 0, SF_READ) ) ) 46 | terror("Can't create stream f"); 47 | if(!(str = sfopen(0, "ten 10 10", "s")) ) 48 | terror("Can't open string stream str"); 49 | Mydisc.disc.readf = oneread; 50 | Mydisc.f = str; 51 | sfdisc(f,&Mydisc.disc); 52 | 53 | s[0] = 0; i = 0; d = 0; 54 | if((n = sfscanf(f, "%s %d %lf", s, &i, &d)) != 3) 55 | terror("Bad scanning %d", n); 56 | if(strncmp("ten",s,3) != 0 || i != 10 || d != 10) 57 | terror("Bad scanned values2"); 58 | 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/twhole.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | 4 | static int Count; 5 | static int Size; 6 | 7 | #if __STD_C 8 | ssize_t writef(Sfio_t* f, const Void_t* buf, size_t n, Sfdisc_t* disc) 9 | #else 10 | ssize_t writef(f,buf,n,disc) 11 | Sfio_t* f; 12 | Void_t* buf; 13 | size_t n; 14 | Sfdisc_t* disc; 15 | #endif 16 | { 17 | Count += 1; 18 | if((n % Size) != 0) 19 | terror("Wrong record size\n"); 20 | return write(sffileno(f),buf,n); 21 | } 22 | 23 | Sfdisc_t Disc = {(Sfread_f)0, writef, (Sfseek_f)0, (Sfexcept_f)0, (Sfdisc_t*)0}; 24 | 25 | MAIN() 26 | { 27 | Sfio_t* f; 28 | char buf[550]; 29 | int i; 30 | char* s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; 31 | 32 | Count = 0; 33 | Size = 52; 34 | 35 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(0), "w")) ) 36 | terror("Opening to write\n"); 37 | sfsetbuf(f,buf,sizeof(buf)); 38 | sfset(f,SF_WHOLE,1); 39 | sfdisc(f,&Disc); 40 | 41 | for(i = 0; i < 100; ++i) 42 | if(sfwrite(f,s,52) != 52) 43 | terror("sfwrite failed\n"); 44 | sfclose(f); 45 | if(Count != 10) 46 | terror("Wrong number of writes1\n"); 47 | 48 | Count = 0; 49 | Size = 53; 50 | 51 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(0),"w")) ) 52 | terror("Opening to write\n"); 53 | sfsetbuf(f,buf,sizeof(buf)); 54 | sfset(f,SF_WHOLE,1); 55 | sfdisc(f,&Disc); 56 | 57 | for(i = 0; i < 100; ++i) 58 | if(sfputr(f,s,'\n') != 53) 59 | terror("sfputr failed\n"); 60 | sfclose(f); 61 | if(Count != 10) 62 | terror("Wrong number of writes2\n"); 63 | 64 | TSTEXIT(0); 65 | } 66 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_t/tlongjmp.c: -------------------------------------------------------------------------------- 1 | #include "stdtest.h" 2 | #include 3 | #include 4 | 5 | /* this tests that stdio streams will not be locked even with longjmp */ 6 | 7 | jmp_buf Env; 8 | int Fd[2]; 9 | char Str[] = "Signal handler\n"; 10 | 11 | #if __STD_C 12 | void sighandler(int sig) 13 | #else 14 | void sighandler(sig) 15 | int sig; 16 | #endif 17 | { 18 | if(write(Fd[1], Str, strlen(Str)) != strlen(Str)) 19 | terror("Writing to pipe failed"); 20 | longjmp(Env,0); 21 | } 22 | 23 | MAIN() 24 | { 25 | FILE* f; 26 | char* s; 27 | char buf[128]; 28 | 29 | if(pipe(Fd) < 0) 30 | terror("Can't create pipe"); 31 | if(!(f = fdopen(Fd[0],"r"))) 32 | terror("Can't open read stream"); 33 | 34 | if(setjmp(Env) == 0) 35 | { /* set alarm handler */ 36 | tmesg("\tIf hung, send interrupt or quit signal\n"); 37 | signal(SIGALRM,sighandler); 38 | signal(SIGHUP,sighandler); 39 | signal(SIGQUIT,sighandler); 40 | alarm(2); 41 | 42 | /* we expect this to block on read */ 43 | fgets(buf,sizeof(buf),f); 44 | terror("fgets did not block!"); 45 | } 46 | else /* got back from longjmp() */ 47 | { 48 | #if _SFIO_H 49 | if((f->mode&SF_RDWR) == f->mode) 50 | terror("Stream should be locked"); 51 | #endif 52 | clearerr(f); /* make sure that stream is ok for IO */ 53 | 54 | /* this fgets should succeed */ 55 | if(!(s = fgets(buf,sizeof(buf),f)) ) 56 | terror("fgets returned NULL"); 57 | if(strcmp(s,Str) != 0) 58 | terror("fgets returned wrong data\n"); 59 | } 60 | 61 | TSTEXIT(0); 62 | } 63 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tpopenrw.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t* f; 6 | char buf[1024], *s; 7 | int n; 8 | #ifdef DEBUG 9 | Sfio_t* logf = sfopen(0,"LOG","a"); sfsetbuf(logf,NIL(Void_t*),0); 10 | #endif 11 | 12 | alarm(10); 13 | if(argc > 1) 14 | { /* coprocess only */ 15 | while((s = sfreserve(sfstdin,-1,0)) ) 16 | { 17 | #ifdef DEBUG 18 | sfwrite(logf, s, sfvalue(sfstdin)); 19 | #endif 20 | sfwrite(sfstdout, s, sfvalue(sfstdin)); 21 | } 22 | return 0; 23 | } 24 | 25 | /* make coprocess */ 26 | if(!(f = sfpopen(NIL(Sfio_t*), sfprints("%s -p",argv[0]), "r+"))) 27 | terror("Opening for read/write\n"); 28 | for(n = 0; n < 10; ++n) 29 | { sfsprintf(buf,sizeof(buf),"Line %d",n); 30 | sfputr(f,buf,'\n'); 31 | if(!(s = sfgetr(f,'\n',1))) 32 | terror("Did not read back line\n"); 33 | if(strcmp(s,buf) != 0) 34 | terror("Input=%s, Expect=%s\n",s,buf); 35 | } 36 | 37 | if(sfputr(f,"123456789",'\n') != 10) 38 | terror("Bad write"); 39 | 40 | if(sfread(f,buf,3) != 3) 41 | terror("Did not get data back\n"); 42 | if(strncmp(s,"123",3) != 0) 43 | terror("Wrong data\n"); 44 | 45 | if(sfwrite(f,"aaa",3) != 3 || sfputc(f,'\n') != '\n') 46 | terror("Fail on write\n"); 47 | 48 | if(!(s = sfgetr(f,'\n',1)) ) 49 | terror("Should have gotten 456789\n"); 50 | if(strcmp(s,"456789") != 0) 51 | terror("Wrong data2\n"); 52 | 53 | if(!(s = sfgetr(f,'\n',1)) ) 54 | terror("Should have gotten aaa\n"); 55 | if(strcmp(s,"aaa") != 0) 56 | terror("Wrong data3\n"); 57 | 58 | sfclose(f); 59 | 60 | TSTEXIT(0); 61 | } 62 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_rm/sfpeek.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Safe access to the internal stream buffer. 4 | ** This function is obsolete. sfreserve() should be used. 5 | ** 6 | ** Written by Kiem-Phong Vo (06/27/90). 7 | */ 8 | 9 | #if __STD_C 10 | ssize_t sfpeek(reg Sfio_t* f, Void_t** bp, reg size_t size) 11 | #else 12 | ssize_t sfpeek(f,bp,size) 13 | reg Sfio_t* f; /* file to peek */ 14 | Void_t** bp; /* start of data area */ 15 | reg size_t size; /* size of peek */ 16 | #endif 17 | { reg ssize_t n, sz; 18 | reg int mode; 19 | 20 | /* query for the extent of the remainder of the buffer */ 21 | if((sz = size) == 0 || !bp) 22 | { if(f->mode&SF_INIT) 23 | (void)_sfmode(f,0,0); 24 | 25 | if((f->flags&SF_RDWRSTR) == SF_RDWRSTR) 26 | { SFSTRSIZE(f); 27 | n = (f->data+f->here) - f->next; 28 | } 29 | else n = f->endb - f->next; 30 | 31 | if(!bp) 32 | return n; 33 | else if(n > 0) /* size == 0 */ 34 | { *bp = (Void_t*)f->next; 35 | return 0; 36 | } 37 | /* else fall down and fill buffer */ 38 | } 39 | 40 | if(!(mode = f->flags&SF_READ) ) 41 | mode = SF_WRITE; 42 | if((int)f->mode != mode && _sfmode(f,mode,0) < 0) 43 | return -1; 44 | 45 | *bp = sfreserve(f, sz <= 0 ? 0 : sz > f->size ? f->size : sz, 0); 46 | 47 | if(*bp && sz >= 0) 48 | return sz; 49 | 50 | if((n = sfvalue(f)) > 0) 51 | { *bp = (Void_t*)f->next; 52 | if(sz < 0) 53 | { f->mode |= SF_PEEK; 54 | f->endr = f->endw = f->data; 55 | } 56 | else 57 | { if(sz > n) 58 | sz = n; 59 | f->next += sz; 60 | } 61 | } 62 | 63 | return (sz >= 0 && n >= sz) ? sz : n; 64 | } 65 | -------------------------------------------------------------------------------- /src/lib/sfio/_sfputd.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Write out a floating point value in a portable format 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int _sfputd(Sfio_t* f, Sfdouble_t v) 10 | #else 11 | int _sfputd(f,v) 12 | Sfio_t* f; 13 | Sfdouble_t v; 14 | #endif 15 | { 16 | #define N_ARRAY (16*sizeof(Sfdouble_t)) 17 | reg ssize_t n, w; 18 | reg uchar *s, *ends; 19 | int exp; 20 | uchar c[N_ARRAY]; 21 | Sfdouble_t x; 22 | 23 | SFMTXSTART(f,-1); 24 | 25 | if(f->mode != SF_WRITE && _sfmode(f,SF_WRITE,0) < 0) 26 | SFMTXRETURN(f, -1); 27 | SFLOCK(f,0); 28 | 29 | /* get the sign of v */ 30 | if(v < 0.) 31 | { v = -v; 32 | n = 1; 33 | } 34 | else n = 0; 35 | 36 | /* make the magnitude of v < 1 */ 37 | if(v != 0.) 38 | v = frexpl(v,&exp); 39 | else exp = 0; 40 | 41 | /* code the sign of v and exp */ 42 | if((w = exp) < 0) 43 | { n |= 02; 44 | w = -w; 45 | } 46 | 47 | /* write out the signs and the exp */ 48 | SFOPEN(f,0); 49 | if(sfputc(f,n) < 0 || (w = sfputu(f,w)) < 0) 50 | SFMTXRETURN(f, -1); 51 | SFLOCK(f,0); 52 | w += 1; 53 | 54 | s = (ends = &c[0])+sizeof(c); 55 | while(s > ends) 56 | { /* get 2^SF_PRECIS precision at a time */ 57 | n = (int)(x = ldexpl(v,SF_PRECIS)); 58 | *--s = n|SF_MORE; 59 | v = x-n; 60 | if(v <= 0.) 61 | break; 62 | } 63 | 64 | /* last byte is not SF_MORE */ 65 | ends = &c[0] + sizeof(c) -1; 66 | *ends &= ~SF_MORE; 67 | 68 | /* write out coded bytes */ 69 | n = ends - s + 1; 70 | w = SFWRITE(f,(Void_t*)s,n) == n ? w+n : -1; 71 | 72 | SFOPEN(f,0); 73 | SFMTXRETURN(f,w); 74 | } 75 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/fseek.c: -------------------------------------------------------------------------------- 1 | #include "sfstdio.h" 2 | 3 | /* Reposition stream IO pointer 4 | ** Written by Kiem-Phong Vo 5 | */ 6 | 7 | #ifndef lcloff_t 8 | #define lcloff_t long 9 | #endif 10 | 11 | #if __STD_C 12 | int fseek(FILE* f, lcloff_t offset, int whence) 13 | #else 14 | int fseek(f,offset,whence) 15 | reg FILE* f; 16 | reg lcloff_t offset; 17 | reg int whence; 18 | #endif 19 | { 20 | reg Sfio_t* sf; 21 | 22 | if(!(sf = _sfstream(f))) 23 | return -1; 24 | 25 | /* ready for either read or write */ 26 | #if _FILE_cnt 27 | f->std_cnt = 0; 28 | #endif 29 | #if _FILE_r 30 | f->std_r = 0; 31 | #endif 32 | #if _FILE_w 33 | f->std_w = 0; 34 | #endif 35 | #if _FILE_readptr 36 | f->std_readptr = f->std_readend = NIL(uchar*); 37 | #endif 38 | #if _FILE_writeptr 39 | f->std_writeptr = f->std_writeend = NIL(uchar*); 40 | #endif 41 | 42 | return sfseek(sf, (Sfoff_t)offset, whence|SF_SHARE) < (Sfoff_t)0 ? -1 : 0; 43 | } 44 | 45 | 46 | #if _lib_fseeko && !_done_fseeko && !defined(fseek) 47 | #define _done_fseeko 1 48 | #undef lcloff_t 49 | #define lcloff_t stdoff_t 50 | #define fseek fseeko 51 | #include "fseek.c" 52 | #undef fseek 53 | #endif 54 | 55 | #if _lib___fseeko64 && !_done___fseeko64 && !defined(fseek) 56 | #define _done___fseeko64 1 57 | #undef lcloff_t 58 | #define lcloff_t stdoff_t 59 | #define fseek __fseeko64 60 | #include "fseek.c" 61 | #undef fseek 62 | #endif 63 | 64 | #if _lib_fseeko64 && !_done_fseeko64 && !defined(fseek) 65 | #define _done_fseeko64 1 66 | #undef lcloff_t 67 | #define lcloff_t stdoff_t 68 | #define fseek fseeko64 69 | #include "fseek.c" 70 | #undef fseek 71 | #endif 72 | -------------------------------------------------------------------------------- /README: -------------------------------------------------------------------------------- 1 | This directory contains the following: 2 | 3 | Standard directories: 4 | ./bin for generated executables 5 | ./include for package header files 6 | ./lib for constructed libraries 7 | ./man for manual pages 8 | ./src for source code of packages 9 | 10 | Package directories: 11 | ./src/lib/vthread 12 | ./src/lib/sfio 13 | 14 | Before building a package, you should add the above "bin" directory 15 | to your PATH environment variable. In most shell environments, the 16 | PATH variable can be set as follows: 17 | 18 | PATH=$PATH:$PWD/bin 19 | 20 | Changing the PATH variable as shown makes available the command "iffe" 21 | which is invoked by the "make" command while it builds the package(s). 22 | Iffe (IF Features Exist) is the interpreter of the IFFE language used 23 | to define probes for any configuration parameters needed from the local 24 | platform that you are building the software on. Examples of such probes 25 | can be found in the sub-directory "features" in each package directory. 26 | The iffe command carries its own documentation. Its manual pages can be 27 | obtained in either text or html forms as follows: 28 | 29 | iffe --man 30 | iffe --html 31 | 32 | 33 | The simplest way to build everything is to invoke the script "Runmake" 34 | available in this directory. Each package directory also has a README 35 | file that explains the local directory hierarchy and may give specific 36 | directions to build and test the respective package. 37 | 38 | Let me know of any problems. Good luck and have fun. 39 | 40 | Phong Vo 41 | AT&T Labs - Research 42 | 180 Park Avenue 43 | Florham Park, NJ07932 44 | kpv@research.att.com 45 | -------------------------------------------------------------------------------- /src/lib/sfio/sfscanf.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Read formated data from a stream 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int sfscanf(Sfio_t* f, const char* form, ...) 10 | #else 11 | int sfscanf(va_alist) 12 | va_dcl 13 | #endif 14 | { 15 | va_list args; 16 | reg int rv; 17 | 18 | #if __STD_C 19 | va_start(args,form); 20 | #else 21 | reg Sfio_t* f; 22 | reg char* form; 23 | va_start(args); 24 | f = va_arg(args,Sfio_t*); 25 | form = va_arg(args,char*); 26 | #endif 27 | 28 | rv = (f && form) ? sfvscanf(f,form,args) : -1; 29 | va_end(args); 30 | return rv; 31 | } 32 | 33 | #if __STD_C 34 | int sfvsscanf(const char* s, const char* form, va_list args) 35 | #else 36 | int sfvsscanf(s, form, args) 37 | char* s; 38 | char* form; 39 | va_list args; 40 | #endif 41 | { 42 | Sfio_t f; 43 | 44 | if(!s || !form) 45 | return -1; 46 | 47 | /* make a fake stream */ 48 | SFCLEAR(&f,NIL(Vtmutex_t*)); 49 | f.flags = SF_STRING|SF_READ; 50 | f.bits = SF_PRIVATE; 51 | f.mode = SF_READ; 52 | f.size = strlen((char*)s); 53 | f.data = f.next = f.endw = (uchar*)s; 54 | f.endb = f.endr = f.data+f.size; 55 | 56 | return sfvscanf(&f,form,args); 57 | } 58 | 59 | #if __STD_C 60 | int sfsscanf(const char* s, const char* form,...) 61 | #else 62 | int sfsscanf(va_alist) 63 | va_dcl 64 | #endif 65 | { 66 | va_list args; 67 | reg int rv; 68 | #if __STD_C 69 | va_start(args,form); 70 | #else 71 | reg char* s; 72 | reg char* form; 73 | va_start(args); 74 | s = va_arg(args,char*); 75 | form = va_arg(args,char*); 76 | #endif 77 | 78 | rv = (s && form) ? sfvsscanf(s,form,args) : -1; 79 | va_end(args); 80 | return rv; 81 | } 82 | -------------------------------------------------------------------------------- /src/lib/vthread/Vthread_t/runtest: -------------------------------------------------------------------------------- 1 | ######################################################################### 2 | # Invocation arguments are: # 3 | # -lLIBRARY: a library to be linked with, e.g., -lpthread # 4 | # -v: verbose, print the compilation command # 5 | # -c: continue testing after a test fails # 6 | # -whatever_else: bad argument, will be ignored. # 7 | # tests: test cases to be run. If no test specified, # 8 | # all tests will be run. # 9 | # # 10 | # Written by Kiem-Phong Vo # 11 | ######################################################################### 12 | 13 | verbose=0 14 | exit_on_fail=1 15 | files="" 16 | LIBS="../libvthread.a" 17 | HDRS="" 18 | DEFS="-Dvt_threaded=1" 19 | XLIBS="" 20 | 21 | while test "$1" != "" 22 | do 23 | case $1 in 24 | -l*) XLIBS="$XLIBS $1"; 25 | ;; 26 | -v) verbose=1; 27 | ;; 28 | -c) exit_on_fail=0; 29 | ;; 30 | -*) echo "Hmm, unknown argument: $1"; 31 | ;; 32 | *) files="${files} $1"; 33 | ;; 34 | esac 35 | shift 36 | done 37 | 38 | if test "$CC" = ""; then CC="cc"; fi 39 | 40 | if test "$files" = "" 41 | then 42 | files="*.c" 43 | fi 44 | 45 | LIBS="$LIBS $XLIBS" 46 | 47 | if test "$verbose" = 1 48 | then echo "Compiler invocation: $CC -g $DEFS -I. -I.. $HDRS xxx.c $LIBS -o ./t" 49 | fi 50 | 51 | for i in $files 52 | do 53 | echo "-- $i:" 54 | status="" 55 | if $CC -g $DEFS -I. -I.. $HDRS $i $LIBS -o ./t 56 | then 57 | if ./t 58 | then rm ./t; status=Passed 59 | else status=Failed 60 | fi 61 | else status="Not compiled" 62 | fi 63 | echo " $status" 64 | if test "$status" != "Passed" 65 | then if test "$exit_on_fail" = "1"; then exit; fi 66 | fi 67 | done 68 | -------------------------------------------------------------------------------- /src/lib/sfio/sfpeek.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Safe access to the internal stream buffer. 4 | ** This function is obsolete. sfreserve() should be used. 5 | ** 6 | ** Written by Kiem-Phong Vo (06/27/90). 7 | */ 8 | 9 | #if _BLD_sfio && defined(__EXPORT__) 10 | #define extern __EXPORT__ 11 | #endif 12 | 13 | #if __STD_C 14 | extern ssize_t sfpeek(reg Sfio_t* f, Void_t** bp, reg size_t size) 15 | #else 16 | extern ssize_t sfpeek(f,bp,size) 17 | reg Sfio_t* f; /* file to peek */ 18 | Void_t** bp; /* start of data area */ 19 | reg size_t size; /* size of peek */ 20 | #endif 21 | { reg ssize_t n, sz; 22 | reg int mode; 23 | 24 | /* query for the extent of the remainder of the buffer */ 25 | if((sz = size) == 0 || !bp) 26 | { if(f->mode&SF_INIT) 27 | (void)_sfmode(f,0,0); 28 | 29 | if((f->flags&SF_RDWRSTR) == SF_RDWRSTR) 30 | { SFSTRSIZE(f); 31 | n = (f->data+f->here) - f->next; 32 | } 33 | else n = f->endb - f->next; 34 | 35 | if(!bp) 36 | return n; 37 | else if(n > 0) /* size == 0 */ 38 | { *bp = (Void_t*)f->next; 39 | return 0; 40 | } 41 | /* else fall down and fill buffer */ 42 | } 43 | 44 | if(!(mode = f->flags&SF_READ) ) 45 | mode = SF_WRITE; 46 | if((int)f->mode != mode && _sfmode(f,mode,0) < 0) 47 | return -1; 48 | 49 | *bp = sfreserve(f, sz <= 0 ? 0 : sz > f->size ? f->size : sz, 0); 50 | 51 | if(*bp && sz >= 0) 52 | return sz; 53 | 54 | if((n = sfvalue(f)) > 0) 55 | { *bp = (Void_t*)f->next; 56 | if(sz < 0) 57 | { f->mode |= SF_PEEK; 58 | f->endr = f->endw = f->data; 59 | } 60 | else 61 | { if(sz > n) 62 | sz = n; 63 | f->next += sz; 64 | } 65 | } 66 | 67 | return (sz >= 0 && n >= sz) ? sz : n; 68 | } 69 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tmmap2read.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | #undef off_t 4 | #undef mmap 5 | #undef mmap64 6 | 7 | /* This test causes mmap() to fail so that read() must be used. 8 | On a system such as BSDI, malloc uses mmap() so if mmap() 9 | fails, not much else will work. In such a case, we make this 10 | test automatically success. 11 | */ 12 | 13 | static int Success = 1; 14 | 15 | #if __STD_C 16 | void* mmap(void* addr, size_t size, int x, int y, int z, off_t offset) 17 | #else 18 | void* mmap() 19 | #endif 20 | { 21 | if(Success) 22 | TSTEXIT(0); 23 | 24 | return (void*)(-1); 25 | } 26 | 27 | #if __STD_C 28 | void* mmap64(void* addr, size_t size, int x, int y, int z, Sfoff_t offset) 29 | #else 30 | void* mmap64() 31 | #endif 32 | { 33 | if(Success) 34 | TSTEXIT(0); 35 | 36 | return (void*)(-1); 37 | } 38 | 39 | MAIN() 40 | { 41 | Sfio_t* f; 42 | char buf[1024], buf2[1024], *data; 43 | int n, r; 44 | 45 | /* test to see if malloc() winds up calling mmap() */ 46 | if(!(data = (char*)malloc(8*1024)) ) 47 | terror("Malloc failed\n"); 48 | free(data); 49 | Success = 0; 50 | 51 | /* our real work */ 52 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(0),"w")) ) 53 | terror("Can't open to write\n"); 54 | 55 | for(n = 0; n < sizeof(buf); ++n) 56 | buf[n] = '0' + (n%10); 57 | 58 | for(n = 0; n < 10; ++n) 59 | sfwrite(f,buf,sizeof(buf)); 60 | 61 | if(!(f = sfopen(f, tstfile(0),"r")) ) 62 | terror("Can't open to read\n"); 63 | 64 | for(n = 0; n < 10; ++n) 65 | { if((r = sfread(f,buf2,sizeof(buf))) != sizeof(buf)) 66 | terror("Bad read size=%d\n",r); 67 | if(strncmp(buf,buf2,sizeof(buf)) != 0) 68 | terror("Get wrong data\n"); 69 | } 70 | 71 | TSTEXIT(0); 72 | } 73 | -------------------------------------------------------------------------------- /src/lib/sfio/sfset.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Set some control flags or file descript for the stream 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int sfset(reg Sfio_t* f, reg int flags, reg int set) 10 | #else 11 | int sfset(f,flags,set) 12 | reg Sfio_t* f; 13 | reg int flags; 14 | reg int set; 15 | #endif 16 | { 17 | reg int oflags; 18 | 19 | SFMTXSTART(f,0); 20 | 21 | if(flags == 0 && set == 0) 22 | SFMTXRETURN(f, (f->flags&SF_FLAGS)); 23 | 24 | if((oflags = (f->mode&SF_RDWR)) != (int)f->mode && _sfmode(f,oflags,0) < 0) 25 | SFMTXRETURN(f, 0); 26 | 27 | if(flags == 0) 28 | SFMTXRETURN(f, (f->flags&SF_FLAGS)); 29 | 30 | SFLOCK(f,0); 31 | 32 | /* preserve at least one rd/wr flag */ 33 | oflags = f->flags; 34 | if(!(f->bits&SF_BOTH) || (flags&SF_RDWR) == SF_RDWR ) 35 | flags &= ~SF_RDWR; 36 | 37 | /* set the flag */ 38 | if(set) 39 | f->flags |= (flags&SF_SETS); 40 | else f->flags &= ~(flags&SF_SETS); 41 | 42 | /* must have at least one of read/write */ 43 | if(!(f->flags&SF_RDWR)) 44 | f->flags |= (oflags&SF_RDWR); 45 | 46 | if(f->extent < 0) 47 | f->flags &= ~SF_APPENDWR; 48 | 49 | /* turn to appropriate mode as necessary */ 50 | if((flags &= SF_RDWR) ) 51 | { if(!set) 52 | { if(flags == SF_READ) 53 | flags = SF_WRITE; 54 | else flags = SF_READ; 55 | } 56 | if((flags == SF_WRITE && !(f->mode&SF_WRITE)) || 57 | (flags == SF_READ && !(f->mode&(SF_READ|SF_SYNCED))) ) 58 | (void)_sfmode(f,flags,1); 59 | } 60 | 61 | /* if not shared or unseekable, public means nothing */ 62 | if(!(f->flags&SF_SHARE) || f->extent < 0) 63 | f->flags &= ~SF_PUBLIC; 64 | 65 | SFOPEN(f,0); 66 | SFMTXRETURN(f, (oflags&SF_FLAGS)); 67 | } 68 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tmode.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t *f; 6 | 7 | if(argc > 1) 8 | { if(sfopen(sfstdin,argv[1],"r") != sfstdin) 9 | terror("Can't reopen stdin"); 10 | sfmove(sfstdin,sfstdout,(Sfoff_t)(-1),-1); 11 | return 0; 12 | } 13 | 14 | if(!(f = sfopen((Sfio_t*)0,tstfile(0),"w"))) 15 | terror("Opening to write\n"); 16 | if(sfputc(f,'a') != 'a') 17 | terror("sfputc\n"); 18 | if(sfgetc(f) >= 0) 19 | terror("sfgetc\n"); 20 | 21 | if(!(f = sfopen(f,tstfile(0),"r"))) 22 | terror("Opening to read\n"); 23 | if(sfgetc(f) != 'a') 24 | terror("sfgetc2\n"); 25 | if(sfputc(f,'b') >= 0) 26 | terror("sfputc2\n"); 27 | 28 | if(!(f = sfopen(f,tstfile(0),"r+"))) 29 | terror("Opening to read/write\n"); 30 | 31 | if(sfgetc(f) != 'a') 32 | terror("sfgetc3\n"); 33 | if(sfputc(f,'b') != 'b') 34 | terror("sfputc3\n"); 35 | if(sfclose(f) < 0) 36 | terror("sfclose\n"); 37 | 38 | if(!(f = sfpopen(NIL(Sfio_t*),sfprints("%s %s", argv[0], tstfile(0)),"r"))) 39 | terror("sfpopen\n"); 40 | if(sfgetc(f) != 'a') 41 | terror("sfgetc4\n"); 42 | if(sfgetc(f) != 'b') 43 | terror("sfgetc5\n"); 44 | if(sfgetc(f) >= 0) 45 | terror("sfgetc6\n"); 46 | 47 | if(!(f = sfopen(f,tstfile(0),"w")) ) 48 | terror("sfopen\n"); 49 | if(sfputc(f,'a') != 'a') 50 | terror("sfputc1\n"); 51 | sfsetfd(f,-1); 52 | if(sfputc(f,'b') >= 0) 53 | terror("sfputc2\n"); 54 | if(sfclose(f) < 0) 55 | terror("sfclose\n"); 56 | 57 | if(!(f = sfopen(NIL(Sfio_t*),tstfile(0),"a+")) ) 58 | terror("sfopen2\n"); 59 | sfset(f,SF_READ,0); 60 | if(!sfreserve(f,0,-1) ) 61 | terror("Failed on buffer getting\n"); 62 | if(sfvalue(f) <= 0) 63 | terror("There is no buffer?\n"); 64 | 65 | TSTEXIT(0); 66 | } 67 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tmove.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | char *s = "1234567890\n"; 6 | Sfoff_t n, i; 7 | Sfio_t *f; 8 | char buf[1024]; 9 | char* addr; 10 | 11 | if(sfopen(sfstdout,tstfile(0),"w+") != sfstdout) 12 | terror("Opening output file\n"); 13 | for(i = 0; i < 10000; ++i) 14 | if(sfputr(sfstdout,s,-1) < 0) 15 | terror("Writing data\n"); 16 | 17 | if(!(f = sfopen((Sfio_t*)0,tstfile(1),"w"))) 18 | terror("Opening output file \n"); 19 | 20 | sfseek(sfstdout,(Sfoff_t)0,0); 21 | if((n = sfmove(sfstdout,f,(Sfoff_t)SF_UNBOUND,'\n')) != i) 22 | terror("Move %d lines, Expect %d\n",n,i); 23 | 24 | sfseek(sfstdout,(Sfoff_t)0,0); 25 | sfseek(f,(Sfoff_t)0,0); 26 | sfsetbuf(sfstdout,buf,sizeof(buf)); 27 | if((n = sfmove(sfstdout,f,(Sfoff_t)SF_UNBOUND,'\n')) != i) 28 | terror("Move %d lines, Expect %d\n",n,i); 29 | 30 | sfopen(sfstdin,tstfile(0),"r"); 31 | sfopen(sfstdout,tstfile(1),"w"); 32 | sfmove(sfstdin,sfstdout,(Sfoff_t)SF_UNBOUND,-1); 33 | if(!sfeof(sfstdin)) 34 | terror("Sfstdin is not eof\n"); 35 | if(sferror(sfstdin)) 36 | terror("Sfstdin is in error\n"); 37 | if(sferror(sfstdout)) 38 | terror("Sfstdout is in error\n"); 39 | 40 | sfseek(sfstdin,(Sfoff_t)0,0); 41 | sfseek(sfstdout,(Sfoff_t)0,0); 42 | sfsetbuf(sfstdin,buf,sizeof(buf)); 43 | 44 | addr = (char*)sbrk(0); 45 | sfmove(sfstdin,sfstdout,(Sfoff_t)((unsigned long)(~0L)>>1),-1); 46 | if((ssize_t)((char*)sbrk(0)-addr) > 256*1024) 47 | terror("Too much space allocated in sfmove\n"); 48 | 49 | if(!sfeof(sfstdin)) 50 | terror("Sfstdin is not eof2\n"); 51 | if(sferror(sfstdin)) 52 | terror("Sfstdin is in error2\n"); 53 | if(sferror(sfstdout)) 54 | terror("Sfstdout is in error2\n"); 55 | 56 | TSTEXIT(0); 57 | } 58 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_b/no_stdio.h: -------------------------------------------------------------------------------- 1 | #ifndef _NO_STDIO_H 2 | #define _NO_STDIO_H 1 3 | 4 | /* While building the compatible stdio interface, we don't want 5 | ** to be included. Fortunately, these files tend to be protected by a single 6 | ** macro defined at the top of each file to prevent multiple inclusion. 7 | ** This header file defines the same macros here. 8 | ** 9 | ** Written by Kiem-Phong Vo. 10 | */ 11 | 12 | #ifndef __stdio_h__ 13 | #define __stdio_h__ 1 14 | #endif 15 | #ifndef _stdio_h_ 16 | #define _stdio_h_ 1 17 | #endif 18 | #ifndef _stdio_h 19 | #define _stdio_h 1 20 | #endif 21 | #ifndef __h_stdio__ 22 | #define __h_stdio__ 1 23 | #endif 24 | #ifndef _h_stdio_ 25 | #define _h_stdio_ 1 26 | #endif 27 | #ifndef _h_stdio 28 | #define _h_stdio 1 29 | #endif 30 | #ifndef __STDIO_H__ 31 | #define __STDIO_H__ 1 32 | #endif 33 | #ifndef _STDIO_H_ 34 | #define _STDIO_H_ 1 35 | #endif 36 | #ifndef _STDIO_H 37 | #define _STDIO_H 1 38 | #endif 39 | #ifndef __H_STDIO__ 40 | #define __H_STDIO__ 1 41 | #endif 42 | #ifndef _H_STDIO_ 43 | #define _H_STDIO_ 1 44 | #endif 45 | #ifndef _H_STDIO 46 | #define _H_STDIO 1 47 | #endif 48 | #ifndef _stdio_included 49 | #define _stdio_included 1 50 | #endif 51 | #ifndef _included_stdio 52 | #define _included_stdio 1 53 | #endif 54 | #ifndef _INCLUDED_STDIO 55 | #define _INCLUDED_STDIO 1 56 | #endif 57 | #ifndef _STDIO_INCLUDED 58 | #define _STDIO_INCLUDED 1 59 | #endif 60 | #ifndef _INC_STDIO 61 | #define _INC_STDIO 1 62 | #endif 63 | 64 | #ifndef _FILE_DEFINED 65 | #define _FILE_DEFINED 1 /* stop Windows from defining FILE */ 66 | #endif 67 | #ifndef _FILEDEFED 68 | #define _FILEDEFED 1 /* stop SUNOS5.8 ... */ 69 | #endif 70 | #ifndef __FILE_defined 71 | #define __FILE_defined 1 /* stop Linux ... */ 72 | #endif 73 | 74 | #endif/*_NO_STDIO_H*/ 75 | -------------------------------------------------------------------------------- /src/lib/sfio/sfprintf.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Print data with a given format 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int sfprintf(Sfio_t* f, const char* form, ...) 10 | #else 11 | int sfprintf(va_alist) 12 | va_dcl 13 | #endif 14 | { 15 | va_list args; 16 | reg int rv; 17 | 18 | #if __STD_C 19 | va_start(args,form); 20 | #else 21 | reg Sfio_t* f; 22 | reg char* form; 23 | va_start(args); 24 | f = va_arg(args,Sfio_t*); 25 | form = va_arg(args,char*); 26 | #endif 27 | rv = sfvprintf(f,form,args); 28 | 29 | va_end(args); 30 | return rv; 31 | } 32 | 33 | #if __STD_C 34 | ssize_t sfvsprintf(char* s, size_t n, const char* form, va_list args) 35 | #else 36 | ssize_t sfvsprintf(s, n, form, args) 37 | char* s; 38 | size_t n; 39 | char* form; 40 | va_list args; 41 | #endif 42 | { 43 | Sfio_t *f; 44 | ssize_t rv; 45 | 46 | /* make a temp stream */ 47 | if(!(f = sfnew(NIL(Sfio_t*),NIL(char*),(size_t)SF_UNBOUND, 48 | -1,SF_WRITE|SF_STRING)) ) 49 | return -1; 50 | 51 | if((rv = sfvprintf(f,form,args)) < 0 ) 52 | return -1; 53 | if(s) 54 | { if(sfputc(f, 0) < 0) 55 | return -1; 56 | if(n > 0) 57 | memcpy(s, f->data, rv < n ? rv+1 : n); 58 | } 59 | 60 | sfclose(f); 61 | 62 | _Sfi = rv; 63 | 64 | return rv; 65 | } 66 | 67 | #if __STD_C 68 | ssize_t sfsprintf(char* s, size_t n, const char* form, ...) 69 | #else 70 | ssize_t sfsprintf(va_alist) 71 | va_dcl 72 | #endif 73 | { 74 | va_list args; 75 | ssize_t rv; 76 | 77 | #if __STD_C 78 | va_start(args,form); 79 | #else 80 | reg char* s; 81 | reg size_t n; 82 | reg char* form; 83 | va_start(args); 84 | s = va_arg(args,char*); 85 | n = va_arg(args,size_t); 86 | form = va_arg(args,char*); 87 | #endif 88 | 89 | rv = sfvsprintf(s,n,form,args); 90 | va_end(args); 91 | 92 | return rv; 93 | } 94 | -------------------------------------------------------------------------------- /src/lib/vthread/vtmtxlock.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | 4 | /* Lock a mutex. 5 | ** 6 | ** Written by Kiem-Phong Vo. 7 | */ 8 | 9 | #if __STD_C 10 | int vtmtxlock(Vtmutex_t* mtx) 11 | #else 12 | int vtmtxlock(mtx) 13 | Vtmutex_t* mtx; 14 | #endif 15 | { 16 | #if !vt_threaded 17 | return -1; 18 | #else 19 | int rv; 20 | 21 | if(!mtx ) 22 | return -1; 23 | 24 | #if _WIN32 25 | #define _did_lock 1 26 | EnterCriticalSection(&mtx->lock); 27 | if(mtx->count <= 0) 28 | mtx->count = 1; 29 | else mtx->count += 1; 30 | return rv=0; 31 | #endif 32 | 33 | #if !_did_lock && _mtx_recursive 34 | #define _did_lock 1 35 | if((rv = pthread_mutex_lock(&mtx->lock)) == MTXLOCK_OK) 36 | { if(mtx->count <= 0) 37 | mtx->count = 1; 38 | else mtx->count += 1; 39 | return 0; 40 | } 41 | else 42 | { mtx->error = rv; 43 | return -1; 44 | } 45 | #endif 46 | 47 | #if !_did_lock && _mtx_errorcheck && !_hpux_pthread 48 | #define _did_lock 1 49 | if((rv = pthread_mutex_lock(&mtx->lock)) == MTXLOCK_OK) 50 | { mtx->count = 1; 51 | mtx->owner = pthread_self(); 52 | return 0; 53 | } 54 | else if(rv == EDEADLK && pthread_equal(pthread_self(), mtx->owner)) 55 | { mtx->count += 1; 56 | return 0; 57 | } 58 | else 59 | { mtx->error = rv; 60 | return -1; 61 | } 62 | #endif 63 | 64 | #if !_did_lock /* hpux,solaris,bsd */ 65 | if((rv = pthread_mutex_trylock(&mtx->lock)) == MTXTRYLOCK_OK) 66 | { mtx->count = 1; 67 | mtx->owner = pthread_self(); 68 | return 0; 69 | } 70 | else if(MTXBUSY(rv) && pthread_equal(pthread_self(), mtx->owner) ) 71 | { mtx->count += 1; 72 | return 0; 73 | } 74 | else if((rv = pthread_mutex_lock(&mtx->lock)) == MTXLOCK_OK) 75 | { mtx->count = 1; 76 | mtx->owner = pthread_self(); 77 | return 0; 78 | } 79 | else 80 | { mtx->error = rv; 81 | return -1; 82 | } 83 | #endif 84 | 85 | #endif /*vt_threaded*/ 86 | } 87 | 88 | -------------------------------------------------------------------------------- /src/lib/sfio/sfpurge.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Delete all pending data in the buffer 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | int sfpurge(reg Sfio_t* f) 10 | #else 11 | int sfpurge(f) 12 | reg Sfio_t* f; 13 | #endif 14 | { 15 | reg int mode; 16 | 17 | SFMTXSTART(f,-1); 18 | 19 | if((mode = f->mode&SF_RDWR) != (int)f->mode && _sfmode(f,mode|SF_SYNCED,0) < 0) 20 | SFMTXRETURN(f, -1); 21 | 22 | if((f->flags&SF_IOCHECK) && f->disc && f->disc->exceptf) 23 | (void)(*f->disc->exceptf)(f,SF_PURGE,(Void_t*)((int)1),f->disc); 24 | 25 | if(f->disc == _Sfudisc) 26 | (void)sfclose((*_Sfstack)(f,NIL(Sfio_t*))); 27 | 28 | /* cannot purge read string streams */ 29 | if((f->flags&SF_STRING) && (f->mode&SF_READ) ) 30 | goto done; 31 | 32 | SFLOCK(f,0); 33 | 34 | /* if memory map must be a read stream, pretend data is gone */ 35 | #ifdef MAP_TYPE 36 | if(f->bits&SF_MMAP) 37 | { f->here -= f->endb - f->next; 38 | if(f->data) 39 | { SFMUNMAP(f,f->data,f->endb-f->data); 40 | SFSK(f,f->here,SEEK_SET,f->disc); 41 | } 42 | SFOPEN(f,0); 43 | SFMTXRETURN(f, 0); 44 | } 45 | #endif 46 | 47 | switch(f->mode&~SF_LOCK) 48 | { 49 | default : 50 | SFOPEN(f,0); 51 | SFMTXRETURN(f, -1); 52 | case SF_WRITE : 53 | f->next = f->data; 54 | if(!f->proc || !(f->flags&SF_READ) || !(f->mode&SF_WRITE) ) 55 | break; 56 | 57 | /* 2-way pipe, must clear read buffer */ 58 | (void)_sfmode(f,SF_READ,1); 59 | /* fall through */ 60 | case SF_READ: 61 | if(f->extent >= 0 && f->endb > f->next) 62 | { f->here -= f->endb-f->next; 63 | SFSK(f,f->here,SEEK_SET,f->disc); 64 | } 65 | f->endb = f->next = f->data; 66 | break; 67 | } 68 | 69 | SFOPEN(f,0); 70 | 71 | done: 72 | if((f->flags&SF_IOCHECK) && f->disc && f->disc->exceptf) 73 | (void)(*f->disc->exceptf)(f,SF_PURGE,(Void_t*)((int)0),f->disc); 74 | 75 | SFMTXRETURN(f, 0); 76 | } 77 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdgets.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | /* Read a line into a buffer. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | char* _stdgets(reg Sfio_t* f, char* us, reg int n, int isgets) 10 | #else 11 | char* _stdgets(f,us,n,isgets) 12 | reg Sfio_t* f; /* stream to read from */ 13 | char* us; /* space to read into */ 14 | reg int n; /* max number of bytes to read */ 15 | int isgets; /* gets(), not fgets() */ 16 | #endif 17 | { 18 | reg int p; 19 | reg uchar *is, *ps; 20 | 21 | SFMTXSTART(f, NIL(char*)); 22 | 23 | if(n <= 0 || !us || (f->mode != SF_READ && _sfmode(f,SF_READ,0) < 0)) 24 | SFMTXRETURN(f, NIL(char*)); 25 | 26 | SFLOCK(f,0); 27 | 28 | n -= 1; 29 | is = (uchar*)us; 30 | 31 | while(n) 32 | { /* peek the read buffer for data */ 33 | if((p = f->endb - (ps = f->next)) <= 0 ) 34 | { f->getr = '\n'; 35 | f->mode |= SF_RC; 36 | if(SFRPEEK(f,ps,p) <= 0) 37 | break; 38 | } 39 | 40 | if(p > n) 41 | p = n; 42 | 43 | #if _lib_memccpy 44 | if((ps = (uchar*)memccpy((char*)is,(char*)ps,'\n',p)) != NIL(uchar*)) 45 | p = ps-is; 46 | is += p; 47 | ps = f->next+p; 48 | #else 49 | if(!(f->flags&(SF_BOTH|SF_MALLOC))) 50 | { while(p-- && (*is++ = *ps++) != '\n') 51 | ; 52 | p = ps-f->next; 53 | } 54 | else 55 | { reg int c = ps[p-1]; 56 | if(c != '\n') 57 | ps[p-1] = '\n'; 58 | while((*is++ = *ps++) != '\n') 59 | ; 60 | if(c != '\n') 61 | { f->next[p-1] = c; 62 | if((ps-f->next) >= p) 63 | is[-1] = c; 64 | } 65 | } 66 | #endif 67 | 68 | /* gobble up read data and continue */ 69 | f->next = ps; 70 | if(is[-1] == '\n') 71 | break; 72 | else if(n > 0) 73 | n -= p; 74 | } 75 | 76 | if((_Sfi = f->val = is - ((uchar*)us)) <= 0) 77 | us = NIL(char*); 78 | else if(isgets && is[-1] == '\n') 79 | is[-1] = '\0'; 80 | else *is = '\0'; 81 | 82 | SFOPEN(f,0); 83 | SFMTXRETURN(f, us); 84 | } 85 | -------------------------------------------------------------------------------- /src/lib/sfio/sfraise.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Invoke event handlers for a stream 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | #if __STD_C 9 | static int _sfraiseall(int type, Void_t* data) 10 | #else 11 | static int _sfraiseall(type, data) 12 | int type; /* type of event */ 13 | Void_t* data; /* associated data */ 14 | #endif 15 | { 16 | Sfio_t *f; 17 | Sfpool_t *p, *next; 18 | int n, rv; 19 | 20 | rv = 0; 21 | for(p = &_Sfpool; p; p = next) 22 | { 23 | for(next = p->next; next; next = next->next) 24 | if(next->n_sf > 0) 25 | break; 26 | for(n = 0; n < p->n_sf; ++n) 27 | { f = p->sf[n]; 28 | if(sfraise(f, type, data) < 0) 29 | rv -= 1; 30 | } 31 | } 32 | return rv; 33 | } 34 | 35 | #if __STD_C 36 | int sfraise(Sfio_t* f, int type, Void_t* data) 37 | #else 38 | int sfraise(f, type, data) 39 | Sfio_t* f; /* stream */ 40 | int type; /* type of event */ 41 | Void_t* data; /* associated data */ 42 | #endif 43 | { 44 | reg Sfdisc_t *disc, *next, *d; 45 | reg int local, rv; 46 | 47 | if(!f) 48 | return _sfraiseall(type,data); 49 | 50 | SFMTXSTART(f, -1); 51 | 52 | GETLOCAL(f,local); 53 | if(!SFKILLED(f) && 54 | !(local && 55 | (type == SF_NEW || type == SF_CLOSING || 56 | type == SF_FINAL || type == SF_ATEXIT)) && 57 | SFMODE(f,local) != (f->mode&SF_RDWR) && _sfmode(f,0,local) < 0) 58 | SFMTXRETURN(f, -1); 59 | SFLOCK(f,local); 60 | 61 | for(disc = f->disc; disc; ) 62 | { next = disc->disc; 63 | if(type == SF_FINAL) 64 | f->disc = next; 65 | 66 | if(disc->exceptf) 67 | { SFOPEN(f,0); 68 | if((rv = (*disc->exceptf)(f,type,data,disc)) != 0 ) 69 | SFMTXRETURN(f, rv); 70 | SFLOCK(f,0); 71 | } 72 | 73 | if((disc = next) ) 74 | { /* make sure that "next" hasn't been popped */ 75 | for(d = f->disc; d; d = d->disc) 76 | if(d == disc) 77 | break; 78 | if(!d) 79 | disc = f->disc; 80 | } 81 | } 82 | 83 | SFOPEN(f,local); 84 | SFMTXRETURN(f, 0); 85 | } 86 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tbadargs.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | #include 3 | 4 | 5 | int Code_line = 30; /* line number of CALL(sfclose(0)) */ 6 | 7 | #if defined(__LINE__) 8 | #define CALL(x) ((Code_line = __LINE__), (x)) 9 | #else 10 | #define CALL(x) ((Code_line += 1),(x)) 11 | #endif 12 | 13 | #if __STD_C 14 | void handler(int sig) 15 | #else 16 | void handler(sig) 17 | int sig; 18 | #endif 19 | { 20 | terror("Bad argument handling on code line %d", Code_line); 21 | } 22 | 23 | 24 | MAIN() 25 | { 26 | signal(SIGILL,handler); 27 | signal(SIGBUS,handler); 28 | signal(SIGSEGV,handler); 29 | 30 | CALL(sfclose(0)); 31 | CALL(sfclrlock(0)); 32 | CALL(sfopen(0,0,0)); 33 | CALL(sfdisc(0,0)); 34 | CALL(_sffilbuf(0,0)); 35 | CALL(_sfflsbuf(0,0)); 36 | CALL(sfgetd(0)); 37 | CALL(sfgetl(0)); 38 | CALL(sfgetm(0,0)); 39 | CALL(sfgetr(0,0,0)); 40 | CALL(sfgetu(0)); 41 | CALL(sfmove(0,0,0,0)); 42 | CALL(sfmutex(0,0)); 43 | CALL(sfnew(0,0,0,0,0)); 44 | CALL(sfnputc(0,0,0)); 45 | CALL(sfopen(0,0,0)); 46 | CALL(sfpoll(0,0,0)); 47 | CALL(sfpool(0,0,0)); 48 | CALL(sfpopen(0,0,0)); 49 | CALL(sfprintf(0,0)); 50 | CALL(sfvsprintf(0,0,0,0)); 51 | CALL(sfsprintf(0,0,0)); 52 | CALL(sfprints(0)); 53 | CALL(sfpurge(0)); 54 | CALL(sfputd(0,0)); 55 | CALL(sfputl(0,0)); 56 | CALL(sfputm(0,0,0)); 57 | CALL(sfputr(0,0,0)); 58 | CALL(sfputu(0,0)); 59 | CALL(sfraise(0,0,0)); 60 | CALL(sfrd(0,0,0,0)); 61 | CALL(sfread(0,0,0)); 62 | CALL(sfreserve(0,0,0)); 63 | CALL(sfresize(0,0)); 64 | CALL(sfscanf(0,0)); 65 | CALL(sfvsscanf(0,0,0)); 66 | CALL(sfsscanf(0,0)); 67 | CALL(sfseek(0,0,0)); 68 | CALL(sfset(0,0,0)); 69 | CALL(sfsetbuf(0,0,0)); 70 | CALL(sfsetfd(0,0)); 71 | CALL(sfsize(0)); 72 | CALL(sfsk(0, 0, 0, 0)); 73 | CALL(sfstack(0, 0)); 74 | CALL(sfswap(0, 0)); 75 | CALL(sfsync(0)); 76 | CALL(sftell(0)); 77 | CALL(sftmp(0)); 78 | CALL(sfungetc(0,0)); 79 | CALL(sfvprintf(0,0,0)); 80 | CALL(sfvscanf(0,0,0)); 81 | CALL(sfwr(0,0,0,0)); 82 | CALL(sfwrite(0,0,0)); 83 | 84 | TSTEXIT(0); 85 | } 86 | -------------------------------------------------------------------------------- /src/lib/vthread/vtmtxopen.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | /* Create or initialize a mutex. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | 8 | /* this get done once per process */ 9 | void _vtonce() 10 | { 11 | #if vt_threaded 12 | #if _WIN32 13 | char sys_dir[MAX_PATH]; 14 | int n; 15 | HANDLE hm; 16 | 17 | /* get the win32 TryEnterCriticalSection function */ 18 | n = GetSystemDirectory(sys_dir, sizeof(sys_dir)); 19 | sys_dir[n++] = '\\'; 20 | strcpy(&sys_dir[n], "kernel32"); 21 | if((hm = GetModuleHandle(sys_dir)) ) 22 | _Vttrylockf = (Vttrylock_f)GetProcAddress(hm,"TryEnterCriticalSection"); 23 | #endif 24 | 25 | _Vtinit = 1; 26 | 27 | /* initialize the global mutex that we use internally */ 28 | vtmtxopen(_Vtmutex, VT_INIT); 29 | #endif 30 | } 31 | 32 | #if __STD_C 33 | Vtmutex_t* vtmtxopen(Vtmutex_t* mtx, int flags) 34 | #else 35 | Vtmutex_t* vtmtxopen(mtx, flags) 36 | Vtmutex_t* mtx; 37 | int flags; 38 | #endif 39 | { 40 | #if !vt_threaded 41 | return NIL(Vtmutex_t*); 42 | #else 43 | Vtmutex_t* m; 44 | 45 | VTONCE(); 46 | 47 | if(!(m = mtx)) 48 | { if(!(m = (Vtmutex_t*)malloc(sizeof(Vtmutex_t))) ) 49 | return NIL(Vtmutex_t*); 50 | flags = VT_INIT|VT_FREE; 51 | } 52 | 53 | if(flags & VT_INIT) 54 | { m->count = 0; 55 | m->error = 0; 56 | m->state = 0; 57 | 58 | #if _WIN32 59 | #define _did_init 1 60 | InitializeCriticalSection(&m->lock); 61 | m->owner = 0; 62 | #endif /*_WIN32*/ 63 | 64 | #if !_did_init && defined(MTXTYPE) 65 | #define _did_init 1 66 | { pthread_mutexattr_t attr; 67 | pthread_mutexattr_init(&attr); 68 | pthread_mutexattr_settype(&attr, MTXTYPE); 69 | pthread_mutex_init(&m->lock, ATTR(attr)); 70 | pthread_mutexattr_destroy(&attr); 71 | m->owner = pthread_self(); 72 | } 73 | #endif 74 | 75 | #if !_did_init /*BSD or Solaris*/ 76 | pthread_mutex_init(&m->lock, NIL(pthread_mutexattr_t*)); 77 | m->owner = pthread_self(); 78 | #endif 79 | } 80 | 81 | m->state |= (flags&VT_FREE); 82 | 83 | return m; 84 | 85 | #endif /*vt_threaded*/ 86 | } 87 | -------------------------------------------------------------------------------- /src/lib/vthread/vtmtxclrlock.c: -------------------------------------------------------------------------------- 1 | #include "vthdr.h" 2 | 3 | 4 | /* Clear all locks on a mutex. 5 | ** 6 | ** Written by Kiem-Phong Vo. 7 | */ 8 | 9 | #if __STD_C 10 | int vtmtxclrlock(Vtmutex_t* mtx) 11 | #else 12 | int vtmtxclrlock(mtx) 13 | Vtmutex_t* mtx; 14 | #endif 15 | { 16 | #if !vt_threaded 17 | return -1; 18 | #else 19 | int rv; 20 | 21 | if(!mtx ) 22 | return -1; 23 | 24 | #if _WIN32 25 | #define _did_clrlock 1 26 | EnterCriticalSection(&mtx->lock); 27 | for(; mtx->count > 0; mtx->count -= 1) 28 | LeaveCriticalSection(&mtx->lock); 29 | mtx->count = 0; 30 | LeaveCriticalSection(&mtx->lock); 31 | return rv=0; 32 | #endif /*_WIN32*/ 33 | 34 | #if !_did_clrlock && _mtx_recursive 35 | #define _did_clrlock 1 36 | if((rv = pthread_mutex_lock(&mtx->lock)) == MTXLOCK_OK ) 37 | { for(; mtx->count > 0; mtx->count -= 1) 38 | pthread_mutex_unlock(&mtx->lock); 39 | mtx->count = 0; 40 | pthread_mutex_unlock(&mtx->lock); 41 | return 0; 42 | } 43 | else 44 | { mtx->error = rv; 45 | return -1; 46 | } 47 | #endif 48 | 49 | #if !_did_clrlock && _mtx_errorcheck && !_hpux_pthread 50 | #define _did_clrlock 1 51 | if((rv = pthread_mutex_lock(&mtx->lock)) == MTXLOCK_OK ) 52 | { mtx->count = 0; 53 | mtx->owner = pthread_self(); 54 | pthread_mutex_unlock(&mtx->lock); 55 | return 0; 56 | } 57 | else if(rv == EDEADLK && pthread_equal(pthread_self(), mtx->owner) ) 58 | { mtx->count = 0; 59 | pthread_mutex_unlock(&mtx->lock); 60 | return 0; 61 | } 62 | else 63 | { mtx->error = rv; 64 | return -1; 65 | } 66 | #endif 67 | 68 | #if !_did_clrlock 69 | if((rv = pthread_mutex_trylock(&mtx->lock)) == MTXTRYLOCK_OK ) 70 | { mtx->count = 0; 71 | mtx->owner = pthread_self(); 72 | pthread_mutex_unlock(&mtx->lock); 73 | return 0; 74 | } 75 | else if(MTXBUSY(rv) && pthread_equal(pthread_self(), mtx->owner) ) 76 | { mtx->count = 0; 77 | pthread_mutex_unlock(&mtx->lock); 78 | return 0; 79 | } 80 | else 81 | { mtx->error = rv; 82 | return -1; 83 | } 84 | #endif 85 | 86 | #endif /*vt_threaded*/ 87 | } 88 | -------------------------------------------------------------------------------- /src/lib/sfio/sfsk.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Seek function that knows discipline 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | #if __STD_C 8 | Sfoff_t sfsk(reg Sfio_t* f, Sfoff_t addr, reg int type, Sfdisc_t* disc) 9 | #else 10 | Sfoff_t sfsk(f,addr,type,disc) 11 | reg Sfio_t* f; 12 | Sfoff_t addr; 13 | reg int type; 14 | Sfdisc_t* disc; 15 | #endif 16 | { 17 | Sfoff_t p; 18 | reg Sfdisc_t* dc; 19 | reg ssize_t s; 20 | reg int local, mode; 21 | 22 | SFMTXSTART(f, (Sfoff_t)(-1)); 23 | 24 | GETLOCAL(f,local); 25 | if(!local && !(f->bits&SF_DCDOWN)) 26 | { if((mode = f->mode&SF_RDWR) != (int)f->mode && _sfmode(f,mode,0) < 0) 27 | SFMTXRETURN(f, (Sfoff_t)(-1)); 28 | if(SFSYNC(f) < 0) 29 | SFMTXRETURN(f, (Sfoff_t)(-1)); 30 | #ifdef MAP_TYPE 31 | if(f->mode == SF_READ && (f->bits&SF_MMAP) && f->data) 32 | { SFMUNMAP(f, f->data, f->endb-f->data); 33 | f->data = NIL(uchar*); 34 | } 35 | #endif 36 | f->next = f->endb = f->endr = f->endw = f->data; 37 | } 38 | 39 | if((type &= (SEEK_SET|SEEK_CUR|SEEK_END)) > SEEK_END) 40 | SFMTXRETURN(f, (Sfoff_t)(-1)); 41 | 42 | for(;;) 43 | { dc = disc; 44 | if(f->flags&SF_STRING) 45 | { SFSTRSIZE(f); 46 | if(type == SEEK_SET) 47 | s = (ssize_t)addr; 48 | else if(type == SEEK_CUR) 49 | s = (ssize_t)(addr + f->here); 50 | else s = (ssize_t)(addr + f->extent); 51 | } 52 | else 53 | { SFDISC(f,dc,seekf); 54 | if(dc && dc->seekf) 55 | { SFDCSK(f,addr,type,dc,p); 56 | } 57 | else 58 | { p = syslseekf(f->file,(sfoff_t)addr,type); 59 | } 60 | if(p >= 0) 61 | SFMTXRETURN(f,p); 62 | s = -1; 63 | } 64 | 65 | if(local) 66 | SETLOCAL(f); 67 | switch(_sfexcept(f,SF_SEEK,s,dc)) 68 | { 69 | case SF_EDISC: 70 | case SF_ECONT: 71 | if(f->flags&SF_STRING) 72 | SFMTXRETURN(f, (Sfoff_t)s); 73 | goto do_continue; 74 | default: 75 | SFMTXRETURN(f, (Sfoff_t)(-1)); 76 | } 77 | 78 | do_continue: 79 | for(dc = f->disc; dc; dc = dc->disc) 80 | if(dc == disc) 81 | break; 82 | disc = dc; 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tungetc.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t *f; 6 | char *str, *alpha, *s; 7 | char buf[128]; 8 | int n; 9 | 10 | str = "0123456789"; 11 | alpha = "abcdefghijklmnop"; 12 | 13 | if(!(f = sfopen((Sfio_t*)0,alpha,"s"))) 14 | terror("Opening stream\n"); 15 | 16 | for(n = 9; n >= 0; --n) 17 | if(sfungetc(f,n+'0') != n+'0') 18 | terror("Ungetc\n"); 19 | 20 | if(!(s = sfreserve(f,-1,0)) || sfvalue(f) != 10) 21 | terror("Peek stream1\n"); 22 | if(strncmp(s,str,10) != 0) 23 | terror("Bad data1\n"); 24 | 25 | if(!(s = sfreserve(f,-1,0)) || sfvalue(f) != (ssize_t)strlen(alpha)) 26 | terror("Peek stream2\n"); 27 | if(strncmp(s,alpha,strlen(alpha)) != 0) 28 | terror("Bad data2\n"); 29 | 30 | sfseek(f,(Sfoff_t)0,0); 31 | for(n = 9; n >= 0; --n) 32 | if(sfungetc(f,n+'0') != n+'0') 33 | terror("Ungetc2\n"); 34 | if(sfgetc(f) != '0') 35 | terror("Sfgetc\n"); 36 | sfseek(f,(Sfoff_t)0,0); 37 | if(!(s = sfreserve(f,-1,0)) || sfvalue(f) != (ssize_t)strlen(alpha)) 38 | terror("Peek stream3\n"); 39 | if(strncmp(s,alpha,strlen(alpha)) != 0) 40 | terror("Bad data2\n"); 41 | 42 | sfseek(f,(Sfoff_t)0,0); 43 | if(sfungetc(f,'0') != '0') 44 | terror("Ungetc3\n"); 45 | 46 | strcpy(buf,"0123456789\n"); 47 | if(!(f = sfopen(f,buf,"s+")) ) 48 | terror("Reopening string\n"); 49 | if(sfungetc(f,'\n') != '\n') 50 | terror("Can't unget new-line2\n"); 51 | if(sfungetc(f,'d') != 'd') 52 | terror("Can't unget d\n"); 53 | if(sfungetc(f,'c') != 'c') 54 | terror("Can't unget c\n"); 55 | if(sfungetc(f,'\n') != '\n') 56 | terror("Can't unget new-line\n"); 57 | if(sfungetc(f,'b') != 'b') 58 | terror("Can't unget b\n"); 59 | if(sfungetc(f,'a') != 'a') 60 | terror("Can't unget a\n"); 61 | 62 | if(!(s = sfgetr(f,'\n',1)) || strcmp(s,"ab") != 0) 63 | terror("Did not get ab\n"); 64 | if(!(s = sfgetr(f,'\n',1)) || strcmp(s,"cd") != 0) 65 | terror("Did not get cd\n"); 66 | if(!(s = sfgetr(f,'\n',1)) || strcmp(s,"0123456789") != 0) 67 | terror("Did not get 0123456789\n"); 68 | 69 | TSTEXIT(0); 70 | } 71 | -------------------------------------------------------------------------------- /src/lib/sfio/sfungetc.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Push back one byte to a given SF_READ stream 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | #if __STD_C 8 | static int _uexcept(reg Sfio_t* f, reg int type, Void_t* val, reg Sfdisc_t* disc) 9 | #else 10 | static int _uexcept(f,type,val,disc) 11 | reg Sfio_t *f; 12 | reg int type; 13 | Void_t* val; 14 | reg Sfdisc_t *disc; 15 | #endif 16 | { 17 | NOTUSED(val); 18 | 19 | /* hmm! This should never happen */ 20 | if(disc != _Sfudisc) 21 | return -1; 22 | 23 | /* close the unget stream */ 24 | if(type != SF_CLOSING) 25 | (void)sfclose((*_Sfstack)(f,NIL(Sfio_t*))); 26 | 27 | return 1; 28 | } 29 | 30 | #if __STD_C 31 | int sfungetc(reg Sfio_t* f, reg int c) 32 | #else 33 | int sfungetc(f,c) 34 | reg Sfio_t* f; /* push back one byte to this stream */ 35 | reg int c; /* the value to be pushed back */ 36 | #endif 37 | { 38 | reg Sfio_t* uf; 39 | 40 | SFMTXSTART(f, -1) 41 | 42 | if(c < 0 || (f->mode != SF_READ && _sfmode(f,SF_READ,0) < 0)) 43 | SFMTXRETURN(f, -1); 44 | SFLOCK(f,0); 45 | 46 | /* fast handling of the typical unget */ 47 | if(f->next > f->data && f->next[-1] == (uchar)c) 48 | { f->next -= 1; 49 | goto done; 50 | } 51 | 52 | /* make a string stream for unget characters */ 53 | if(f->disc != _Sfudisc) 54 | { if(!(uf = sfnew(NIL(Sfio_t*),NIL(char*),(size_t)SF_UNBOUND, 55 | -1,SF_STRING|SF_READ))) 56 | { c = -1; 57 | goto done; 58 | } 59 | _Sfudisc->exceptf = _uexcept; 60 | sfdisc(uf,_Sfudisc); 61 | SFOPEN(f,0); (void)sfstack(f,uf); SFLOCK(f,0); 62 | } 63 | 64 | /* space for data */ 65 | if(f->next == f->data) 66 | { reg uchar* data; 67 | if(f->size < 0) 68 | f->size = 0; 69 | if(!(data = (uchar*)malloc(f->size+16))) 70 | { c = -1; 71 | goto done; 72 | } 73 | f->flags |= SF_MALLOC; 74 | if(f->data) 75 | memcpy((char*)(data+16),(char*)f->data,f->size); 76 | f->size += 16; 77 | f->data = data; 78 | f->next = data+16; 79 | f->endb = data+f->size; 80 | } 81 | 82 | *--f->next = (uchar)c; 83 | done: 84 | SFOPEN(f,0); 85 | SFMTXRETURN(f, c); 86 | } 87 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tappend.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t *f1, *f2; 6 | char* s; 7 | Sfoff_t p; 8 | char buf[1024]; 9 | int r, w; 10 | 11 | if(!(f1 = sfopen(NIL(Sfio_t*), tstfile(0), "w")) ) 12 | terror("Can't open f1\n"); 13 | if(!(f1 = sfopen(f1, tstfile(0), "a+")) ) 14 | terror("Can't open f1\n"); 15 | 16 | if(!(f2 = sfopen(NIL(Sfio_t*), tstfile(0), "a+")) ) 17 | terror("Can't open f2\n"); 18 | 19 | if(sfwrite(f1,"012345678\n",10) != 10 || sfsync(f1) < 0) 20 | terror("Writing to f1\n"); 21 | if((p = sftell(f1)) != 10) 22 | terror("Bad sftell1 %ld\n",p); 23 | 24 | if(sfwrite(f2,"abcdefghi\n",10) != 10 || sfsync(f2) < 0) 25 | terror("Writing to f2\n"); 26 | if((p = sftell(f2)) != 20) 27 | terror("Bad sftell2\n"); 28 | 29 | if((p = sfseek(f1,(Sfoff_t)0,0)) != 0) 30 | terror("Bad seek\n"); 31 | if(!(s = sfgetr(f1,'\n',1)) ) 32 | terror("Bad getr1\n"); 33 | if(strcmp(s,"012345678") != 0) 34 | terror("Bad input1\n"); 35 | 36 | if((p = sftell(f1)) != 10) 37 | terror("Bad sftell3\n"); 38 | 39 | if(sfwrite(f1,"012345678\n",10) != 10 || sfsync(f1) < 0) 40 | terror("Writing to f1\n"); 41 | if((p = sftell(f1)) != 30) 42 | terror("Bad sftell4\n"); 43 | 44 | if((p = sfseek(f2,(Sfoff_t)10,0)) != 10) 45 | terror("Bad seek\n"); 46 | if(!(s = sfgetr(f2,'\n',1)) ) 47 | terror("Bad getr2\n"); 48 | if(strcmp(s,"abcdefghi") != 0) 49 | terror("Bad input2\n"); 50 | 51 | if(!(s = sfgetr(f2,'\n',1)) ) 52 | terror("Bad getr3\n"); 53 | if(strcmp(s,"012345678") != 0) 54 | terror("Bad input3\n"); 55 | 56 | if(!(f1 = sfopen(f1, tstfile(0), "w")) ) 57 | terror("Can't open file to write\n"); 58 | for(r = 0; r < 1024; ++r) 59 | buf[r] = 'a'; 60 | if((w = sfwrite(f1,buf,1024)) != 1024) 61 | terror("writing w=%d\n", w); 62 | if(!(f1 = sfopen(f1, tstfile(0), "a")) ) 63 | terror("Can't open file to append\n"); 64 | sfseek(f1,(Sfoff_t)0,0); 65 | if((w = sfwrite(f1,buf,64)) != 64) 66 | terror("writing w=%d\n", w); 67 | if((r = (int)sftell(f1)) != (1024+64) ) 68 | terror("seek position wrong s=%d\n", r); 69 | 70 | TSTEXIT(0); 71 | } 72 | -------------------------------------------------------------------------------- /src/lib/sfio/sfsize.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Get the size of a stream. 4 | ** 5 | ** Written by Kiem-Phong Vo. 6 | */ 7 | #if __STD_C 8 | Sfoff_t sfsize(reg Sfio_t* f) 9 | #else 10 | Sfoff_t sfsize(f) 11 | reg Sfio_t* f; 12 | #endif 13 | { 14 | Sfdisc_t* disc; 15 | reg int mode; 16 | Sfoff_t s; 17 | 18 | SFMTXSTART(f, (Sfoff_t)(-1)); 19 | 20 | if((mode = f->mode&SF_RDWR) != (int)f->mode && _sfmode(f,mode,0) < 0) 21 | SFMTXRETURN(f, (Sfoff_t)(-1)); 22 | 23 | if(f->flags&SF_STRING) 24 | { SFSTRSIZE(f); 25 | SFMTXRETURN(f, f->extent); 26 | } 27 | 28 | SFLOCK(f,0); 29 | 30 | s = f->here; 31 | 32 | if(f->extent >= 0) 33 | { if(f->flags&(SF_SHARE|SF_APPENDWR)) 34 | { for(disc = f->disc; disc; disc = disc->disc) 35 | if(disc->seekf) 36 | break; 37 | if(!_sys_stat || disc) 38 | { Sfoff_t e; 39 | if((e = SFSK(f,0,SEEK_END,disc)) >= 0) 40 | f->extent = e; 41 | if(SFSK(f,f->here,SEEK_SET,disc) != f->here) 42 | f->here = SFSK(f,(Sfoff_t)0,SEEK_CUR,disc); 43 | } 44 | #if _sys_stat 45 | else 46 | { sfstat_t st; 47 | if(sysfstatf(f->file,&st) < 0) 48 | f->extent = -1; 49 | else if((f->extent = st.st_size) < f->here) 50 | f->here = SFSK(f,(Sfoff_t)0,SEEK_CUR,disc); 51 | } 52 | #endif 53 | } 54 | 55 | if((f->flags&(SF_SHARE|SF_PUBLIC)) == (SF_SHARE|SF_PUBLIC)) 56 | f->here = SFSK(f,(Sfoff_t)0,SEEK_CUR,f->disc); 57 | } 58 | 59 | if(f->here != s && (f->mode&SF_READ) ) 60 | { /* buffered data is known to be invalid */ 61 | #ifdef MAP_TYPE 62 | if((f->bits&SF_MMAP) && f->data) 63 | { SFMUNMAP(f,f->data,f->endb-f->data); 64 | f->data = NIL(uchar*); 65 | } 66 | #endif 67 | f->next = f->endb = f->endr = f->endw = f->data; 68 | } 69 | 70 | if(f->here < 0) 71 | f->extent = -1; 72 | else if(f->extent < f->here) 73 | f->extent = f->here; 74 | 75 | if((s = f->extent) >= 0) 76 | { if(f->flags&SF_APPENDWR) 77 | s += (f->next - f->data); 78 | else if(f->mode&SF_WRITE) 79 | { s = f->here + (f->next - f->data); 80 | if(s < f->extent) 81 | s = f->extent; 82 | } 83 | } 84 | 85 | SFOPEN(f,0); 86 | SFMTXRETURN(f, s); 87 | } 88 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tflags.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | MAIN() 4 | { 5 | Sfio_t* f; 6 | 7 | if(!(f = sfopen(NIL(Sfio_t*),"ab","sr")) ) 8 | terror("Can't open stream\n"); 9 | if(sfeof(f) || sferror(f)) 10 | terror("Can't be eof or error yet\n"); 11 | if(sfgetc(f) != 'a') 12 | terror("Got wrong data\n"); 13 | if(sfeof(f) || sferror(f)) 14 | terror("Can't be eof or error yet2\n"); 15 | if(sfgetc(f) != 'b') 16 | terror("Got wrong data2\n"); 17 | if(sfeof(f) || sferror(f)) 18 | terror("Can't be eof or error yet3\n"); 19 | if(sfgetc(f) >= 0) 20 | terror("Got wrong data2\n"); 21 | if(!sfeof(f)) 22 | terror("Should be eof now\n"); 23 | if(sfseek(f,(Sfoff_t)(-1),2) != 1) 24 | terror("Seek error\n"); 25 | if(sfeof(f)) 26 | terror("Shouldn't be eof any more\n"); 27 | 28 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(0), "w+")) ) 29 | terror("Can't open stream2\n"); 30 | if(sfeof(f) || sferror(f)) 31 | terror("Can't be eof or error yet2\n"); 32 | if(sfwrite(f,"ab",2) != 2) 33 | terror("Can't write data\n"); 34 | if(sfseek(f,(Sfoff_t)0,0) != 0) 35 | terror("Can't seek back\n"); 36 | if(sfgetc(f) != 'a') 37 | terror("Got wrong data3\n"); 38 | if(sfeof(f) || sferror(f)) 39 | terror("Can't be eof or error yet4\n"); 40 | if(sfgetc(f) != 'b') 41 | terror("Got wrong data4\n"); 42 | if(sfeof(f) || sferror(f)) 43 | terror("Can't be eof or error yet5\n"); 44 | if(sfgetc(f) >= 0) 45 | terror("Got wrong data5\n"); 46 | if(!sfeof(f)) 47 | terror("Should be eof now2\n"); 48 | if(sfseek(f,(Sfoff_t)(-1),2) != 1) 49 | terror("Seek error2\n"); 50 | if(sfeof(f)) 51 | terror("Shouldn't be eof any more2\n"); 52 | 53 | if(!(f = sfopen(NIL(Sfio_t*), tstfile(0),"w+")) ) 54 | terror("Reopening %s\n", tstfile(0)); 55 | sfwrite(f,"1234567890",10); 56 | sfseek(f,(Sfoff_t)0,0); 57 | 58 | if(sfopen(sfstdout, tstfile(1), "w") != sfstdout) 59 | terror("Opening %s\n", tstfile(1)); 60 | 61 | if(sfmove(f,sfstdout,(Sfoff_t)(-1),-1) != 10) 62 | terror("sfmove failed\n"); 63 | if(!sfeof(f)) 64 | terror("f should be eof\n"); 65 | if(sferror(sfstdout)) 66 | terror("sfstdout should not be in error\n"); 67 | 68 | TSTEXIT(0); 69 | } 70 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/terrno.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | /* errnos tested for xopen-compliance */ 4 | 5 | MAIN() 6 | { 7 | Sfio_t* fw; 8 | Sfio_t* fr; 9 | int fds[2]; 10 | int lseek_errno; 11 | int rv; 12 | 13 | if(!(fw = sfopen(NIL(Sfio_t*), tstfile(0), "w")) ) 14 | terror("Can't create temp file %s to write", tstfile(0)); 15 | if(!(fr = sfopen(NIL(Sfio_t*), tstfile(0), "r")) ) 16 | terror("Can't open temp file %s to read", tstfile(0)); 17 | 18 | sfseek(fr, (Sfoff_t)0, SEEK_END); 19 | if(sfgetc(fr) >= 0 || !sfeof(fr)) 20 | terror("Should have seen eof"); 21 | 22 | errno = 0; 23 | if((rv = sfwrite(fr, "a", 1)) == 1) 24 | terror("sfwrite returns %d, expecting 1", rv); 25 | if(errno != EBADF) 26 | twarn("Wrong errno %d after sfwrite(%d), expecting %d",errno,rv,EBADF); 27 | 28 | /* on some system (eg, apple), lseek does not set errno for this case */ 29 | errno = 0; 30 | lseek(sffileno(fw), (off_t)(-2), SEEK_SET); 31 | lseek_errno = errno; 32 | lseek(sffileno(fw), (off_t)0, SEEK_SET); 33 | errno = 0; 34 | 35 | if(sfseek(fw, (Sfoff_t)(-2), SEEK_SET) != (Sfoff_t)(-1) ) 36 | terror("sfseek should have failed"); 37 | if(errno != lseek_errno) 38 | twarn("Wrong errno %d after sfseek, expecting %d", errno, lseek_errno); 39 | 40 | errno = 0; 41 | if(sfseek(fw, (Sfoff_t)0, SEEK_SET|SEEK_CUR|SEEK_END) >= 0) 42 | terror("sfseek should not have succeeded"); 43 | if(errno != EINVAL) 44 | twarn("Wrong errno %d after sfseek, expecting %d", errno, EINVAL); 45 | 46 | if(pipe(fds) < 0) 47 | terror("Can't create pipes"); 48 | 49 | if(!(fw = sfnew(fw, NIL(Void_t*), (size_t)SF_UNBOUND, fds[1], SF_WRITE)) ) 50 | terror("Can't create stream for pipe"); 51 | 52 | errno = 0; 53 | if(sfseek(fw, (Sfoff_t)0, SEEK_SET) >= 0) 54 | terror("sfseek should have failed on a pipe"); 55 | if(errno != ESPIPE) 56 | twarn("Wrong errno %d after sfseek, expecting %d", ESPIPE); 57 | 58 | close(sffileno(fw)); 59 | errno = 0; 60 | if(sfseek(fw, (Sfoff_t)0, SEEK_END) >= 0) 61 | terror("sfseek should have failed on a closed file descriptor"); 62 | if(errno != EBADF) 63 | twarn("Wrong errno %d after sfseek, expecting %d", EBADF); 64 | 65 | TSTEXIT(0); 66 | } 67 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_dc/sfdctee.c: -------------------------------------------------------------------------------- 1 | #include "sfdchdr.h" 2 | 3 | /* A discipline to tee the output to a stream to another stream. 4 | ** This is similar to what the "tee" program does. As implemented 5 | ** this discipline only works with file streams. 6 | ** 7 | ** Written by Kiem-Phong Vo, kpv@research.att.com, 03/18/1998. 8 | */ 9 | 10 | /* the discipline structure for tee-ing */ 11 | typedef struct _tee_s 12 | { Sfdisc_t disc; /* the sfio discipline structure */ 13 | Sfio_t* tee; /* the stream to tee to */ 14 | int status; /* if tee stream is still ok */ 15 | } Tee_t; 16 | 17 | /* write to the teed stream. */ 18 | #if __STD_C 19 | static ssize_t teewrite(Sfio_t* f, const Void_t* buf, size_t size, Sfdisc_t* disc) 20 | #else 21 | static ssize_t teewrite(f,buf,size,disc) 22 | Sfio_t* f; /* the stream being written to */ 23 | Void_t* buf; /* the buffer of data being output */ 24 | size_t size; /* the data size */ 25 | Sfdisc_t* disc; /* the tee discipline */ 26 | #endif 27 | { 28 | reg Tee_t* te = (Tee_t*)disc; 29 | 30 | /* tee data if still ok */ 31 | if(te->status == 0 && sfwrite(te->tee,buf,size) != (ssize_t)size) 32 | te->status = -1; 33 | 34 | /* do the actual write */ 35 | return sfwr(f,buf,size,disc); 36 | } 37 | 38 | /* on close, remove the discipline */ 39 | #if __STD_C 40 | static int teeexcept(Sfio_t* f, int type, Void_t* data, Sfdisc_t* disc) 41 | #else 42 | static int teeexcept(f,type,data,disc) 43 | Sfio_t* f; 44 | int type; 45 | Void_t* data; 46 | Sfdisc_t* disc; 47 | #endif 48 | { 49 | if(type == SF_FINAL || type == SF_DPOP) 50 | free(disc); 51 | 52 | return 0; 53 | } 54 | 55 | #if __STD_C 56 | int sfdctee(Sfio_t* f, Sfio_t* tee) 57 | #else 58 | int sfdctee(f, tee) 59 | Sfio_t* f; /* stream to tee from */ 60 | Sfio_t* tee; /* stream to tee to */ 61 | #endif 62 | { 63 | reg Tee_t* te; 64 | 65 | if(!(te = (Tee_t*)malloc(sizeof(Tee_t))) ) 66 | return -1; 67 | 68 | te->disc.readf = NIL(Sfread_f); 69 | te->disc.seekf = NIL(Sfseek_f); 70 | te->disc.writef = teewrite; 71 | te->disc.exceptf = teeexcept; 72 | te->tee = tee; 73 | te->status = 0; 74 | 75 | if(sfdisc(f,(Sfdisc_t*)te) != (Sfdisc_t*)te) 76 | { free(te); 77 | return -1; 78 | } 79 | 80 | return 0; 81 | } 82 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tmwrite.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | 3 | /* see if multiple writers do create a consistent set of records. */ 4 | 5 | #define N_WRITER 3 6 | #define N_RECORD 10000 7 | 8 | static long vrandom() 9 | { 10 | #define LOWBITS ((~((unsigned long)0)) >> 1) 11 | static unsigned long hash = 0xdeadbeef; 12 | 13 | return (hash = hash*0xbadbeef + 0xdeadbeef)&LOWBITS; 14 | } 15 | 16 | MAIN() 17 | { 18 | ssize_t size[N_WRITER][N_RECORD]; 19 | int count[N_WRITER]; 20 | char record[N_WRITER][128], *s; 21 | Sfio_t* fw[N_WRITER]; 22 | Sfio_t* fr; 23 | int i, r, done; 24 | 25 | /* create random record sizes */ 26 | for(i = 0; i < N_WRITER; ++i) 27 | for(r = 0; r < N_RECORD; ++r) 28 | size[i][r] = (ssize_t)(vrandom()%64) + 2; 29 | 30 | /* records for different processes */ 31 | for(i = 0; i < N_WRITER; ++i) 32 | for(r = 0; r < 128; ++r) 33 | record[i][r] = '0'+i; 34 | 35 | /* create file */ 36 | fr = sfopen(NIL(Sfio_t*),tstfile(0),"w+"); 37 | 38 | /* create records */ 39 | for(i = 0; i < N_WRITER; ++i) 40 | { fw[i] = sfopen(NIL(Sfio_t*),tstfile(0),"a"); 41 | count[i] = 0; 42 | } 43 | 44 | for(done = 0; done < N_WRITER; ) 45 | { i = (int)(vrandom()%N_WRITER); 46 | if(count[i] < N_RECORD) 47 | { r = size[i][count[i]]; 48 | if(!(s = sfreserve(fw[i],r,1)) || sfvalue(fw[i]) < r ) 49 | terror("sfreserve fails in process %d\n", i); 50 | memcpy(s,record[i],r-1); 51 | s[r-1] = '\n'; 52 | sfwrite(fw[i],s,r); 53 | 54 | if((count[i] += 1) == N_RECORD) 55 | { done += 1; 56 | sfclose(fw[i]); 57 | } 58 | } 59 | } 60 | 61 | for(i = 0; i < N_WRITER; ++i) 62 | count[i] = 0; 63 | 64 | while((s = sfgetr(fr,'\n',0)) ) 65 | { if((i = s[0] - '0') < 0 || i >= N_WRITER) 66 | terror("Wrong record type\n"); 67 | 68 | for(r = sfvalue(fr)-2; r > 0; --r) 69 | if(s[r] != s[0]) 70 | terror("Bad record%d, count=%d\n", i, count[i]); 71 | 72 | if(sfvalue(fr) != size[i][count[i]]) 73 | terror("Record%d count=%d size=%d sfvalue=%d\n", 74 | i, count[i], size[i][count[i]], sfvalue(fr)); 75 | 76 | count[i] += 1; 77 | } 78 | 79 | for(i = 0; i < N_WRITER; ++i) 80 | if(count[i] != N_RECORD) 81 | terror("Bad count%d %d\n", i, count[i]); 82 | 83 | TSTEXIT(0); 84 | } 85 | -------------------------------------------------------------------------------- /src/lib/sfio/Sfio_t/tsetbuf.c: -------------------------------------------------------------------------------- 1 | #include "sftest.h" 2 | #ifdef SF_APPEND 3 | #undef SF_APPEND 4 | #endif 5 | 6 | #if _hdr_stat 7 | #include 8 | #endif 9 | #if _sys_stat 10 | #include 11 | #endif 12 | 13 | 14 | Sfdisc_t Disc; 15 | 16 | MAIN() 17 | { 18 | int n, fd; 19 | Sfio_t *f; 20 | char *s, buf[1024]; 21 | int fdv[100]; 22 | 23 | buf[0] = 0; 24 | sfsetbuf(sfstdout,buf,sizeof(buf)); 25 | if(!sfstdout->pool) 26 | terror("No pool\n"); 27 | sfdisc(sfstdout,&Disc); 28 | sfset(sfstdout,SF_SHARE,0); 29 | sfputr(sfstdout,"123456789",0); 30 | if(strcmp(buf,"123456789") != 0) 31 | terror("Setting own buffer for stdout\n"); 32 | if(sfpurge(sfstdout) < 0) 33 | terror("Purging sfstdout\n"); 34 | 35 | if((fd = creat(tstfile(0),0666)) < 0) 36 | terror("Creating file\n"); 37 | 38 | if(write(fd,buf,sizeof(buf)) != sizeof(buf)) 39 | terror("Writing to file\n"); 40 | if(lseek(fd, (off_t)0, 0) < 0) 41 | terror("Seeking back to origin\n"); 42 | 43 | if(!(f = sfnew((Sfio_t*)0,buf,sizeof(buf),fd,SF_WRITE))) 44 | terror("Making stream\n"); 45 | 46 | if(!(s = sfreserve(f,SF_UNBOUND,1)) || s != buf) 47 | terror("sfreserve1 returns the wrong pointer\n"); 48 | sfwrite(f,s,0); 49 | 50 | #define NEXTFD 12 51 | if((fd+NEXTFD) < (sizeof(fdv)/sizeof(fdv[0])) ) 52 | { struct stat st; 53 | int i; 54 | for(i = 0; i < fd+NEXTFD; ++i) 55 | fdv[i] = fstat(i,&st); 56 | } 57 | if((n = sfsetfd(f,fd+NEXTFD)) != fd+NEXTFD) 58 | terror("Try to set file descriptor to %d but get %d\n",fd+NEXTFD,n); 59 | if((fd+NEXTFD) < (sizeof(fdv)/sizeof(fdv[0])) ) 60 | { struct stat st; 61 | int i; 62 | for(i = 0; i < fd+NEXTFD; ++i) 63 | if(i != fd && fdv[i] != fstat(i,&st)) 64 | terror("Fd %d changes status after sfsetfd %d->%d\n", 65 | i, fd, fd+NEXTFD); 66 | } 67 | 68 | if(!(s = sfreserve(f,SF_UNBOUND,1)) || s != buf) 69 | terror("sfreserve2 returns the wrong pointer\n"); 70 | sfwrite(f,s,0); 71 | 72 | if(sfsetbuf(f,NIL(Void_t*),(size_t)SF_UNBOUND) != buf) 73 | terror("sfsetbuf didnot returns last buffer\n"); 74 | 75 | sfsetbuf(f,buf,sizeof(buf)); 76 | 77 | if(sfreserve(f,SF_UNBOUND,1) != buf || sfvalue(f) != sizeof(buf) ) 78 | terror("sfreserve3 returns the wrong value\n"); 79 | sfwrite(f,s,0); 80 | 81 | TSTEXIT(0); 82 | } 83 | -------------------------------------------------------------------------------- /src/lib/sfio/Stdio_s/stdsprintf.c: -------------------------------------------------------------------------------- 1 | #include "stdio_s.h" 2 | 3 | 4 | /* sprintf functions 5 | ** 6 | ** Written by Kiem-Phong Vo. 7 | */ 8 | 9 | #if __STD_C 10 | int _stdvsnprintf(char* s, size_t n, const char* form, va_list args) 11 | #else 12 | int _stdvsnprintf(s, n, form, args) 13 | char* s; 14 | size_t n; 15 | char* form; 16 | va_list args; 17 | #endif 18 | { 19 | return (int)sfvsprintf(s,n,form,args); 20 | } 21 | 22 | 23 | #if __STD_C 24 | int _stdsnprintf(char* s, size_t n, const char* form, ...) 25 | #else 26 | int _stdsnprintf(va_alist) 27 | va_dcl 28 | #endif 29 | { 30 | va_list args; 31 | int rv; 32 | 33 | #if __STD_C 34 | va_start(args,form); 35 | #else 36 | reg char* s; 37 | reg size_t n; 38 | reg char* form; 39 | va_start(args); 40 | s = va_arg(args,char*); 41 | n = va_arg(args,size_t); 42 | form = va_arg(args,char*); 43 | #endif 44 | 45 | rv = (int)sfvsprintf(s,n,form,args); 46 | 47 | va_end(args); 48 | 49 | return rv; 50 | } 51 | 52 | #if __STD_C 53 | int _stdvasprintf(char** as, const char* form, va_list args) 54 | #else 55 | int _stdvasprintf(as, form, args) 56 | char** as; 57 | char* form; 58 | va_list args; 59 | #endif 60 | { 61 | return (int)sfvaprints(as, form, args); 62 | } 63 | 64 | 65 | #if __STD_C 66 | int _stdasprintf(char** as, const char* form, ...) 67 | #else 68 | int _stdasprintf(va_alist) 69 | va_dcl 70 | #endif 71 | { 72 | va_list args; 73 | int rv; 74 | 75 | #if __STD_C 76 | va_start(args,form); 77 | #else 78 | reg char** as; 79 | reg char* form; 80 | va_start(args); 81 | as = va_arg(args,char**); 82 | form = va_arg(args,char*); 83 | #endif 84 | 85 | rv = (int)sfvaprints(as, form, args); 86 | 87 | va_end(args); 88 | 89 | return rv; 90 | } 91 | 92 | 93 | #if __STD_C 94 | int _stdsprintf(char* s, const char* form, ...) 95 | #else 96 | int _stdsprintf(va_alist) 97 | va_dcl 98 | #endif 99 | { 100 | va_list args; 101 | reg int rv; 102 | 103 | #if __STD_C 104 | va_start(args,form); 105 | #else 106 | reg char* s; 107 | reg char* form; 108 | va_start(args); 109 | s = va_arg(args,char*); 110 | form = va_arg(args,char*); 111 | #endif 112 | 113 | rv = (s && form) ? (int)sfvsprintf(s,SF_BUFSIZE,form,args) : -1; 114 | 115 | va_end(args); 116 | 117 | return rv; 118 | } 119 | -------------------------------------------------------------------------------- /src/lib/sfio/sfstack.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | 4 | /* Push/pop streams 5 | ** 6 | ** Written by Kiem-Phong Vo. 7 | */ 8 | 9 | #define STKMTXLOCK(f1,f2) \ 10 | { if(f1) SFMTXLOCK(f1); \ 11 | if(f2) SFMTXLOCK(f2); \ 12 | } 13 | #define STKMTXRETURN(f1,f2,rv) \ 14 | { if(f1) SFMTXUNLOCK(f1); \ 15 | if(f2) SFMTXUNLOCK(f2); \ 16 | return(rv); \ 17 | } 18 | 19 | #if __STD_C 20 | Sfio_t* sfstack(Sfio_t* f1, Sfio_t* f2) 21 | #else 22 | Sfio_t* sfstack(f1,f2) 23 | Sfio_t* f1; /* base of stack */ 24 | Sfio_t* f2; /* top of stack */ 25 | #endif 26 | { 27 | reg int n; 28 | reg Sfio_t* rf; 29 | reg Sfrsrv_t* rsrv; 30 | reg Void_t* mtx; 31 | 32 | STKMTXLOCK(f1,f2); 33 | 34 | if(f1 && (f1->mode&SF_RDWR) != f1->mode && _sfmode(f1,0,0) < 0) 35 | STKMTXRETURN(f1,f2, NIL(Sfio_t*)); 36 | if(f2 && (f2->mode&SF_RDWR) != f2->mode && _sfmode(f2,0,0) < 0) 37 | STKMTXRETURN(f1,f2, NIL(Sfio_t*)); 38 | if(!f1) 39 | STKMTXRETURN(f1,f2, f2); 40 | 41 | /* give access to other internal functions */ 42 | _Sfstack = sfstack; 43 | 44 | if(f2 == SF_POPSTACK) 45 | { if(!(f2 = f1->push)) 46 | STKMTXRETURN(f1,f2, NIL(Sfio_t*)); 47 | f2->mode &= ~SF_PUSH; 48 | } 49 | else 50 | { if(f2->push) 51 | STKMTXRETURN(f1,f2, NIL(Sfio_t*)); 52 | if(f1->pool && f1->pool != &_Sfpool && f1->pool != f2->pool && 53 | f1 == f1->pool->sf[0]) 54 | { /* get something else to pool front since f1 will be locked */ 55 | for(n = 1; n < f1->pool->n_sf; ++n) 56 | { if(SFFROZEN(f1->pool->sf[n]) ) 57 | continue; 58 | (*_Sfpmove)(f1->pool->sf[n],0); 59 | break; 60 | } 61 | } 62 | } 63 | 64 | if(f2->pool && f2->pool != &_Sfpool && f2 != f2->pool->sf[0]) 65 | (*_Sfpmove)(f2,0); 66 | 67 | /* swap streams */ 68 | sfswap(f1,f2); 69 | 70 | /* but the reserved buffer and mutex must remain the same */ 71 | rsrv = f1->rsrv; f1->rsrv = f2->rsrv; f2->rsrv = rsrv; 72 | mtx = f1->mutex; f1->mutex = f2->mutex; f2->mutex = mtx; 73 | 74 | SFLOCK(f1,0); 75 | SFLOCK(f2,0); 76 | 77 | if(f2->push != f2) 78 | { /* freeze the pushed stream */ 79 | f2->mode |= SF_PUSH; 80 | f1->push = f2; 81 | rf = f1; 82 | } 83 | else 84 | { /* unfreeze the just exposed stream */ 85 | f1->mode &= ~SF_PUSH; 86 | f2->push = NIL(Sfio_t*); 87 | rf = f2; 88 | } 89 | 90 | SFOPEN(f1,0); 91 | SFOPEN(f2,0); 92 | 93 | STKMTXRETURN(f1,f2, rf); 94 | } 95 | -------------------------------------------------------------------------------- /src/lib/sfio/sfflsbuf.c: -------------------------------------------------------------------------------- 1 | #include "sfhdr.h" 2 | 3 | /* Write a buffer out to a file descriptor or 4 | ** extending a buffer for a SF_STRING stream. 5 | ** 6 | ** Written by Kiem-Phong Vo 7 | */ 8 | 9 | #if __STD_C 10 | int _sfflsbuf(reg Sfio_t* f, reg int c) 11 | #else 12 | int _sfflsbuf(f,c) 13 | reg Sfio_t* f; /* write out the buffered content of this stream */ 14 | reg int c; /* if c>=0, c is also written out */ 15 | #endif 16 | { 17 | reg ssize_t n, w; 18 | reg uchar* data; 19 | uchar outc; 20 | reg int local, isall; 21 | int inpc = c; 22 | 23 | SFMTXSTART(f,-1); 24 | 25 | GETLOCAL(f,local); 26 | 27 | for(;; f->mode &= ~SF_LOCK) 28 | { /* check stream mode */ 29 | if(SFMODE(f,local) != SF_WRITE && _sfmode(f,SF_WRITE,local) < 0) 30 | SFMTXRETURN(f, -1); 31 | SFLOCK(f,local); 32 | 33 | /* current data extent */ 34 | n = f->next - (data = f->data); 35 | 36 | if(n == (f->endb-data) && (f->flags&SF_STRING)) 37 | { /* extend string stream buffer */ 38 | (void)SFWR(f,data,1,f->disc); 39 | 40 | /* !(f->flags&SF_STRING) is required because exception 41 | handlers may turn a string stream to a file stream */ 42 | if(f->next < f->endb || !(f->flags&SF_STRING) ) 43 | n = f->next - (data = f->data); 44 | else 45 | { SFOPEN(f,local); 46 | SFMTXRETURN(f, -1); 47 | } 48 | } 49 | 50 | if(c >= 0) 51 | { /* write into buffer */ 52 | if(n < (f->endb - (data = f->data))) 53 | { *f->next++ = c; 54 | if(c == '\n' && 55 | (f->flags&SF_LINE) && !(f->flags&SF_STRING)) 56 | { c = -1; 57 | n += 1; 58 | } 59 | else break; 60 | } 61 | else if(n == 0) 62 | { /* unbuffered io */ 63 | outc = (uchar)c; 64 | data = &outc; 65 | c = -1; 66 | n = 1; 67 | } 68 | } 69 | 70 | if(n == 0 || (f->flags&SF_STRING)) 71 | break; 72 | 73 | isall = SFISALL(f,isall); 74 | if((w = SFWR(f,data,n,f->disc)) > 0) 75 | { if((n -= w) > 0) /* save unwritten data, then resume */ 76 | memcpy((char*)f->data,(char*)data+w,n); 77 | f->next = f->data+n; 78 | if(c < 0 && (!isall || n == 0)) 79 | break; 80 | } 81 | else if(w == 0) 82 | { SFOPEN(f,local); 83 | SFMTXRETURN(f, -1); 84 | } 85 | else if(c < 0) 86 | break; 87 | } 88 | 89 | SFOPEN(f,local); 90 | 91 | if(inpc < 0) 92 | inpc = f->endb-f->next; 93 | 94 | SFMTXRETURN(f,inpc); 95 | } 96 | --------------------------------------------------------------------------------