stdio.c

guide and some example with visualC++

		ch = (*input)(arg);
	    }
	    (*uget)(ch,arg);
	    if(p == field)
		return v;
	    *p = '\0';
	    if(!wast){
		double d = strtod(field,NULL);
		if(!type || type == 'h')
		    *(float*)vptr = (float)d;
		else if(type == 'l' || type == 'L')
		    *(double*)vptr = d;
	    }
	    break;
	  case 'n':
	    if(type == 'l')
		*(long*)vptr = cnt;
	    else if(type == 'h')
		*(short*)vptr = cnt;
	    else
		*(int*)vptr = cnt;
	    v--;
	    break;	    
	  default:
	    switch(*fmt) {
	    case 'b': base = 2; break;
	    case 'i':
	    case 'd':
	    case 'u':
		ch = (*input)(arg);
		if(ch == '0') base = 8;
		else  base = 10;

		(*uget)(ch,arg);
		break;
	    case 'o': base = 8;  break;
	    case 'x':
	    case 'X': 
	    case 'p': base = 16; break;
	    default:
		return v;
	    }
	    p = field;
	    while(width-- && !isspace(ch=(*input)(arg)) && ch != EOF) {
		*p++ = ch;
		++cnt;
	    }
	    if(width > 0)
		(*uget)(ch,arg);	
	    if(wast)
		break;
	    if(p == field)
		return v;
	    *p = '\0';
	{
	    char *endptr;
	    if(*fmt == 'd' || *fmt == 'i') { /* signed conversion */
		long lval = strtol(field,&endptr,base);
		if(type) {
		    if(type == 'h')
			*(short *)vptr =(short) lval;
		    else 
			*(long *)vptr = lval;
		} else
		    *(int *)vptr = (int) lval;
			
	    } else {
		unsigned long ulval = strtoul(field,&endptr,base);
		if(type) {
		    if(type == 'h')
			*(unsigned short *)vptr =(unsigned short) ulval;
		    else
			*(unsigned long *)vptr = ulval;
		} else
		    *(unsigned *)vptr = (unsigned)ulval;
	    }
	    if(endptr == field) /* failed */
		return v;
	    while(--p >= endptr)
		(*uget)(*p,arg);
	}
	    break;
	}
	++fmt;
	++v;
    }
    /*Gris begin*/
    *arg -= cnt;
    /*Gris end*/
    return v;
}

#ifndef NO_PIPE
val_t eic_popen()
{
    val_t v;
    arg_list ap = getargs();

#ifdef WIN32
    v.p.sp = v.p.p = _popen(arg(0,ap,ptr_t).p,arg(1,ap,ptr_t).p);
#else
    v.p.sp = v.p.p = popen(arg(0,ap,ptr_t).p,arg(1,ap,ptr_t).p);
#endif

    if((FILE *)(v.p.p) != NULL) {
      int i;
      for(i=1;i<FOPEN_MAX;i++)
	if(book1[i] == 0)
	  break;
      book1[i] = NextFopenEntry++;
      book2[i] = (FILE *)(v.p.p);
    }
    setEp( v.p, sizeof(FILE) );
    
    return  v;
}
val_t eic_pclose()
{
  FILE *ptr;
  val_t v;
  int i;

  arg_list ap = getargs();
  
  ptr = arg(0,ap,ptr_t).p;

#ifdef WIN32
  v.ival = _pclose(ptr);
#else
  v.ival = pclose(ptr);
#endif
  
  for(i=0;i<FOPEN_MAX;i++)
    if(ptr == book2[i])
      break;
  if(i<FOPEN_MAX) {
    book1[i] = 0;
    book2[i] = NULL;
  }
  return  v;
}
#endif


/* STDIO.C STUFF */
val_t _get_stdin(void)
{
    val_t v;
    /*
     * This function exists so that EiC can get the address stdin.
     */
    v.p.sp = v.p.p = stdin;
    setEp( v.p, sizeof(*stdin) );
    return v;
}
val_t _get_stdout(void)
{
    val_t v;
    /*
     * This function exists so that EiC can get the address stdout.
     */
    v.p.sp = v.p.p = stdout;
    setEp( v.p, sizeof(*stdout) );
    return v;
}
val_t _get_stderr(void)
{
    val_t v;
    /*
     * This function exists so that EiC can get the address stderr.
     */
    v.p.sp = v.p.p = stderr;
    setEp( v.p, sizeof(*stderr) );
    return v;
}


#ifndef NO_FSEEK
val_t eic_ftell(void)
{
    val_t v;
    v.lval = ftell(arg(0,getargs(),ptr_t).p);
    return v;
}

val_t eic_fseek(void)
{
    val_t v;
    v.ival = fseek(arg(0,getargs(),ptr_t).p,
		   arg(1,getargs(),long),
		   arg(2,getargs(),int));
    return v;
}
#endif


val_t eic_printf(void)
{
    val_t v;
    arg_list ap = getargs();
    char *fmt;
    
    fmt = nextarg(ap,ptr_t).p;
    #ifdef PPCLIB
    v.ival = _eicUprintf(outbyte,stdout,fmt,ap);
    #else
    v.ival = _eicUprintf(fputc,stdout,fmt,ap);
    #endif
    return v;
}

val_t eic_fprintf(void)
{
    val_t v;
    arg_list ap = getargs();
    FILE *fp;
    char *fmt;
    
    fp = nextarg(ap,ptr_t).p;
    fmt = nextarg(ap,ptr_t).p;
    v.ival = _eicUprintf(fputc,fp,fmt,ap);
    return v;
}

val_t eic_vfprintf(void)
{
    val_t v;
    arg_list ap = getargs();
    arg_list ags;
    FILE *fp;
    char *fmt;
    
    fp = nextarg(ap,ptr_t).p;
    fmt = nextarg(ap,ptr_t).p;
    ags = nextarg(ap,arg_list);
    v.ival = _eicUprintf(fputc,fp,fmt,ags);
    return v;
}

val_t eic_sprintf(void)
{
    val_t v;
    arg_list ap = getargs();
    char *fmt, *str; 
    str = nextarg(ap,ptr_t).p;
    fmt = nextarg(ap,ptr_t).p;    
    v.ival = _eicUprintf(charout_,&str,fmt,ap);
    return v;
}


val_t eic_vsprintf(void)
{
    val_t v;
    arg_list ap = getargs();
    arg_list ags;
    char * str;
    char *fmt;
    
    str = nextarg(ap,ptr_t).p;
    fmt = nextarg(ap,ptr_t).p;
    ags = nextarg(ap,arg_list);
    v.ival = _eicUprintf(charout_,&str,fmt,ags);
    return v;
}

#ifndef NO_FILEIO
val_t eic_freopen(void)
{
    val_t v;
    arg_list ap = getargs();
    v.p.sp = v.p.p = freopen(arg(0,ap,ptr_t).p,
			     arg(1,ap,ptr_t).p,
			     arg(2,ap,ptr_t).p);
    
    setEp( v.p, sizeof(FILE) );
    return v;
}

val_t eic_fopen(void)
{
    val_t v;
    arg_list ap = getargs();
    v.p.sp = v.p.p = fopen(arg(0,ap,ptr_t).p,
			   arg(1,ap,ptr_t).p);
    if((FILE *)(v.p.p) != NULL) {
      int i;
      for(i=1;i<FOPEN_MAX;i++)
	if(book1[i] == 0)
	  break;
      book1[i] = NextFopenEntry++;
      book2[i] = (FILE *)(v.p.p);
    }
    setEp( v.p, sizeof(FILE) );
    return v;
}

val_t eic_ungetc(void)
{
    val_t v;
    arg_list ap = getargs();
    v.ival = ungetc(arg(0,ap,int),
		    arg(1,ap,ptr_t).p);
    return v;
}
    
val_t eic_fgetc(void)
{
    val_t v;
    v.ival = fgetc(nextarg(getargs(),ptr_t).p);
    return v;
}
val_t eic_fclose(void)
{
  FILE *ptr;
  val_t v;
  int i;

  ptr = nextarg(getargs(),ptr_t).p;

  for(i=0;i<FOPEN_MAX;i++)
    if(ptr == book2[i])
      break;
  if(i<FOPEN_MAX) {
    book1[i] = 0;
    book2[i] = NULL;
  }

  v.ival = fclose(ptr);
  return v;
}
val_t eic_fflush(void)
{
    val_t v;
    v.ival = fflush(nextarg(getargs(),ptr_t).p);
    return v;
}

val_t eic_fputc(void)
{
    val_t v;
    arg_list ap = getargs();
    v.ival = fputc(arg(0,ap,int),
		   arg(1,ap,ptr_t).p);
    return v;
}

val_t eic_puts(void)
{
    val_t v;
    arg_list ap = getargs();
    v.ival = puts(arg(0,ap,ptr_t).p);
    return v;
}

val_t eic_fputs(void)
{
    val_t v;
    arg_list ap = getargs();
    v.ival = fputs(arg(0,ap,ptr_t).p,
		   arg(1,ap,ptr_t).p);
    return v;
}

val_t eic_fgets(void)
{
    val_t v;
    int n;
    arg_list ap = getargs();
    getptrarg(0,v.p);

    n = arg(1,ap,int);
    checkEp(v.p,n);

    v.p.p = fgets(v.p.p,n, arg(2,ap,ptr_t).p);
    return v;
}

val_t eic_gets(void)
{
    int n;
    val_t v;
    getptrarg(0,v.p);

    n = (char*)v.p.ep - (char*)v.p.sp;
    v.p.p = fgets(v.p.p,n,stdin);
    return v;
}

val_t eic_fread(void)
{
    val_t v;
    arg_list ap = getargs();
    v.szval = fread(arg(0,ap,ptr_t).p,
		   arg(1,ap,size_t),
		   arg(2,ap,size_t),
		   arg(3,ap,ptr_t).p);
    return v;
}

val_t eic_fwrite(void)
{
    val_t v;
    arg_list ap;
    ap = getargs();
    v.szval = fwrite(arg(0,ap,ptr_t).p,
		   arg(1,ap,size_t),
		   arg(2,ap,size_t),
		   arg(3,ap,ptr_t).p);
    return v;
}

val_t eic_fscanf(void)
{
    val_t v;
    arg_list ap = getargs();
    v.ival = _eicUscanf(fgetc,ungetc,
		     arg(0,ap,ptr_t).p,
		     arg(1,ap,ptr_t).p,ap-2);
    return v;
}

val_t eic_feof(void)
{
    val_t v;
    getptrarg(0,v.p);
    v.ival = feof((FILE *)(v.p.p));
    return v;
}

val_t eic_ferror(void)
{
    val_t v;
    getptrarg(0,v.p);
    v.ival = ferror((FILE *)(v.p.p));
    return v;
}

val_t eic_rewind(void)
{
    val_t v;
    getptrarg(0,v.p);
    rewind((FILE *)(v.p.p));
    return v;
}

val_t eic_fsetpos(void)
{
    val_t v;
    arg_list ap = getargs();
    v.ival = fsetpos(arg(0,ap,ptr_t).p,
		   arg(1,ap,ptr_t).p);
    return v;
}

val_t eic_fgetpos(void)
{
    val_t v;
    arg_list ap = getargs();
    v.ival = fgetpos(arg(0,ap,ptr_t).p,
		   arg(1,ap,ptr_t).p);
    return v;
}

#endif

val_t eic_scanf(void)
{
    val_t v;
    arg_list ap = getargs();
    v.ival = _eicUscanf(fgetc,ungetc,
		     stdin,
		     arg(0,ap,ptr_t).p,ap-1);
    return v;
}

val_t eic_sscanf(void)
{
    val_t v;
    char * str;
    arg_list ap = getargs();
    str = arg(0,ap,ptr_t).p;
    v.ival = _eicUscanf(charin_,charback_,
		     &str,
		     arg(1,ap,ptr_t).p,ap-2);
    return v;
}

val_t eic_setvbuf(void)
{
    val_t v;
    arg_list ap = getargs();
    v.ival = setvbuf(arg(0,ap,ptr_t).p,
		     arg(1,ap,ptr_t).p,
		     arg(2,ap,int),
		     arg(3,ap,size_t));
    return v;
}

#ifndef NO_TMPFILE
val_t eic_tmpnam(void)
{
    val_t v;
    v.p.sp = v.p.p = tmpnam(arg(0,getargs(),ptr_t).p);
    setEp( v.p, strlen(v.p.p) + 1 );
    return v;
}
val_t eic_tmpfile(void)
{
    val_t v;
    v.p.sp = v.p.p = tmpfile();
    setEp( v.p, strlen(v.p.p) + 1 );
    return v;
}

val_t eic_rename(void)
{
    val_t v;
#ifdef WIN32
    v.ival = rename(arg(0,getargs(),ptr_t).p,
		  arg(1,getargs(),ptr_t).p);
#else
    v.ival = link(arg(0,getargs(),ptr_t).p,
		  arg(1,getargs(),ptr_t).p);
    if(v.ival == 0)
	v.ival =  unlink(arg(0,getargs(),ptr_t).p);
#endif
    return v;
}

val_t eic_clearerr(void)
{
    val_t v;
    clearerr((FILE *)(arg(0,getargs(),ptr_t).p));
    return v;
}

val_t eic_perror(void)
{
    val_t v;
    perror(arg(0,getargs(),ptr_t).p);
    return v;
}
#endif

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

void module_stdio(void)
{

    book2[0] = stdin;
    book2[1] = stdout;
    book2[2] = stderr;

    /* stdio.h stuff that were macros */
    EiC_add_builtinfunc("puts", eic_puts);
    EiC_add_builtinfunc("feof", eic_feof);
    EiC_add_builtinfunc("ferror", eic_ferror);
    EiC_add_builtinfunc("rewind", eic_rewind);
    EiC_add_builtinfunc("fsetpos", eic_fsetpos);
    EiC_add_builtinfunc("fgetpos", eic_fgetpos);

    /* stdio.h stuff */
    EiC_add_builtinfunc("_get_stdin",_get_stdin);
    EiC_add_builtinfunc("_get_stdout",_get_stdout);
    EiC_add_builtinfunc("_get_stderr",_get_stderr);
    EiC_add_builtinfunc("ftell", eic_ftell);
    EiC_add_builtinfunc("freopen",eic_freopen);	
    EiC_add_builtinfunc("fopen",eic_fopen);	
    EiC_add_builtinfunc("printf", eic_printf);
    EiC_add_builtinfunc("fprintf", eic_fprintf);
    EiC_add_builtinfunc("sprintf", eic_sprintf);
    EiC_add_builtinfunc("vfprintf", eic_vfprintf);
    EiC_add_builtinfunc("vsprintf", eic_vsprintf);
    EiC_add_builtinfunc("ungetc", eic_ungetc);
    EiC_add_builtinfunc("fgetc", eic_fgetc);
    EiC_add_builtinfunc("fputc", eic_fputc);
    EiC_add_builtinfunc("fputs", eic_fputs);
    EiC_add_builtinfunc("fgets", eic_fgets);
    EiC_add_builtinfunc("gets", eic_gets);
    EiC_add_builtinfunc("fread", eic_fread);
    EiC_add_builtinfunc("fwrite", eic_fwrite);
    EiC_add_builtinfunc("fflush", eic_fflush);
    EiC_add_builtinfunc("fclose", eic_fclose);
    EiC_add_builtinfunc("fscanf", eic_fscanf);
    EiC_add_builtinfunc("sscanf", eic_sscanf);
    EiC_add_builtinfunc("scanf", eic_scanf);
    EiC_add_builtinfunc("setvbuf", eic_setvbuf);
    EiC_add_builtinfunc("tmpnam", eic_tmpnam);
    EiC_add_builtinfunc("tmpfile", eic_tmpfile);
    EiC_add_builtinfunc("rename",eic_rename);
    EiC_add_builtinfunc("fseek", eic_fseek);
    EiC_add_builtinfunc("clearerr", eic_clearerr);
    EiC_add_builtinfunc("perror", eic_perror);
   

#ifndef NO_PIPE
    EiC_add_builtinfunc("popen", eic_popen);
    EiC_add_builtinfunc("pclose", eic_pclose);
#endif

}