stdio.c

这是又一个C语言解释器, 我们可以方便地扩展其功能, 并将其用于我们的工作中

                }
            }
            if((ch == 'e' || ch == 'E') && width--) {
                *p++ = ch;
                ch = (*input)(arg);
                if(ch != '+' && ch != '-' && !isdigit(ch) &&
                   ch != EOF && !isspace(ch)) {
                    (*uget)(ch,arg);
                    ch = *--p;
                } else
                    cnt++;
                    
            }
            if((ch == '+' || ch == '-') && width--) {
                *p++ = ch;
                ++cnt;
                ch = (*input)(arg);
            }           
            while(isdigit(ch) && width--) {
                *p++ = ch;
                ++cnt;
                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;
    }
    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

}