coding第12天1.1

标准库fopen和getc的一种实现方法

标准库的文件不是通过文件描述符实现的，而是通过文件指针描述的，文件指针是一个指向包含文件各种信息的结构的指针。该结构包含以下内容：
（1）指向缓冲区的指针（可以一次读入文件一大块内容）
（2）一个记录缓冲区中剩余字符的计数器
（3）指向缓冲区下一个字符的指针
（4）文件描述符
（5）描写读写模式的标志,描述错误状态的标志

可以写成
typedef struct _iobuf
{
char *base;
int cnt;
char *ptr;
int fd;
int flag;
}FILE;

关于文件的访问模式，值通过一个枚举型常量来规定
enum _flags
{
_READ =01,
_WRITE =02;
_UNBUF=04;
_EOF=010;
_ERR=020
};
上述的定义的量类型为 enum _flags类型，可以定义这样一个变量
enum _flags flag_a;此时flag_a就是一个枚举型变量，可以上述五个值，其中的五个值是常量。
_READ等值用的是八进制表示。

分析可知上述的文件访问模式用的是int型，而非enum _flags类型。这样也是可以的，也是必须的，此时因为flag可能取值_READ|_WRITE,也即值为03，不仅仅局限于上述五个枚举型值。

其他一些宏定义

#define NULL 0
#define EOF (-1)
#define BUFSIZ 1024
#define OPEN_MAX 20

上述的宏定义是定义在<stdio.h>中。

下面声明一个指针数组，打开的文件指针都存在这个数组里面，这是一个全局变量数组，也是在<stdio.h>中定义的，能直接使用。

extern FILE _iob[OPEN_MAX];

在上述声明中，<stdio.h>对此进行了初始化，于是
FILE _iob[OPEN_MAX]=
{
(char *)0,0,(char *)0,0,_READ,
(char *)0，0，(char *)0,1,_WRITE,
(char *)0,0,(char *)0,2,_WRITE|UNBUF
};

再对文件定向

#define stdin （&_iob[0]）
#define stdout (&_iob[1])
#dedfine stderr (&_iob[2])

这样就将初始时候，打开的文件为stdin，stdout，stderr对应的文件描述符0、1、2.

#define feof(fp) (((fp)->flag&_EOF)!=0)
#define ferror(fp) (((fp)->flag&_ERR)!=0)
#definel fileno(fp) ((fp)->fd)

上述判定文件信息以及取文件描述符

下面宏定义getc函数以及putc函数

#define getc((fp)) (–(fp)->cnt>=0?(unsigned char)*(fp)->ptr++:_fillbuf(fp))

_fillbuf函数的功能是填充缓冲区，并且返回第一个字符。具体实现

int _fillbuf(FILE *fp)
{
	int bufsize;

	if(fp->flag&(_READ|_EOF|ERR)!=_READ)
	{
		return EOF;
	}
	bufsize=(f->flag&_UNBUF)?1:BUFSIZ;
	if(fp->base==NULL)
	{
		if(((fp->base)=(char *)malloc(bufsize))=NULL)
		{
			return EOF;
		}
	}
	fp->ptr=f->base;
	fp->cnt=read(fp->fd,fp->ptr,bufsize);
	if(--fp->cnt<0)
	{
		if(fp->cnt==-1)
		{
			fp->flag|=_EOF;
		}
		else
		{
			fp->flag|=_ERR;
		}
		fp->cnt=0;
		return EOF;
	}
	return (unsigned char)*fp->ptr++;
}

上述的缓冲区填充函数可知，先通过标志位判定是否文件可读，然后通过标志位判定填充缓冲区，然后建立缓冲区，并通过read调用，更新文件的内容。并最后更新标志位。
也即更新缓冲区之后，文件结构中的所有值除了文件描述符都需要更新。

在getc基础上，得到getchar函数
#define getchar() getc(stdin)

再来获得putc函数

#define putc((x),(fp)) (–(fp)->cnt>=0)?(*(fp)->ptr++=(x)):_flushbuf((x),fp)

_flushbuf函数的作用是刷新缓冲区，我们可以仿照上述的_fillbuf函数的写法写_flushbuf.

int _flushbuf(int x,FILE *fp)
{
	unsigned nc;
	int bufsize;
	if(fp<_iob||fp>_iob+OPEN_MAX)
	{
		return EOF;
	}
	if(fp->flag&(_ERR|_WRITE)!=_WRITE)
	{
		return EOF;
	}
	bufsize=(fp->flag&_UNBUF)?1,BUFSIZ;
	if(fp->base==NULL)
	{
		if((fp->base=(cahr *)malloc(bufsize))==NULL)
		{
			fp->flag|=ERR;
			return EOF;
		}
		else
		{
			nc=fp->ptr-fp->base;
			if(write(fp->fd,fd->base,nc)!=nc)
			{
				fp->flag|=_ERR;
				return EOF;
			}
		}
	}
	fp->ptr=fp->base;
	*fp->ptr++=(char)x;
	fp->cnt=bufsize-1;
	return x;
	
}

函数_flushbuf实现的功能，当文件没有缓冲区的时候，建立缓冲区，当有缓冲区的时候，将缓冲区写入文件。最后将字符填入缓冲区。正常情况返回该字符，否则返回EOF。

于是可以写putchar函数

#define putchar(x) putc((x),stdout)

fopen函数

最后我们着手编写fopen函数，fopen函数的主要功能是打开文件，定位到合适的位置，设置标志位，它不分配任何缓冲区空间。

#include <fcntl.h>
#include <unistd>

#define PERMS 0666

FILE *fopen(char *name,char *mode)
{
	int fd;
	FILE *fp;

	if(*mode!='r'&&*mode!='w'&&*mode!='a')
	{
		return NULL;
	}
	for(fp=_iob;fp<_iob+OPEN_MAX;fp++)
	{
		if((fp->flag&(_READ|_WRITE))==0)
		{
			break;
		}
	}
	if(fp>=_iob+OPEN_MAX)
	{
		return NULL;
	}

	if(*mode=='w')
	{
		fd=creat(name,PERMS);
	}
	else if(*mode=='a')
	{
		if((fd=open(name,O_WRONLY,0))=-1)
		{
			fd=creat(name,PERMS);
		}
		Iseek(fd,0L,2);
	}
	else
	{
		fd=open(name,O_RDONLY,0);
	}
	if(fd=-1)
	{
		return NULL;
	}
	fp->fd=fd;
	fp->cnt=0;
	fp->base=NULL;
	fp->flag=(*mode=='r')?_READ:_WRITE;
	return fp;
} 

标注：
在System V UNIX中，
O_RDONLY
O_WRONLY
O_RDWR
等在头文件<fcntl.h>中定义。