Help needed: University of Washington Bothell

CSS$503$: System Programming

Program $3$

C$++$ Standard I$/$O Library

$1.$ Purpose

In this programming assignment you will design and implement your own core input and output functions of the C$/$C$++$ standard I$/$O library: stdio.h$.$

$$

$2.$ Linux I$/$O

Unix provide system calls for file I$/$O such as open$(),$ read$(),$ write$(),$ and lseek$().$ However, these system calls are not supported on non$-$Unix based systems such as Window. Therefore, the C$/$C$++$ standard I$/$O library was created so that applications which require these functions can be easily ported through recompilation across these systems.

$3.$ C$/$C$++$ Standard I$/$O Library Overview

The standard I$/$O library is an architecture independent library that allows C$/$C$++$ programs to read and write files instead of directly calling the underlying OS system calls. The library's functions add buffering and provide a user$-$friendly file stream interface $($FILE $*).$ The file stream interface is implemented by the standard I$/$O library utilizing the underlying system calls. When reading and$/$or writing small byte$-$counts $($e$.$g$.,$ reading one line at a time from a file$),$ buffered functions are faster.

The read$()$ and write$()$ system calls operate on file descriptors and read$/$write from$/$to buffers not strings. A file descriptor is just an integer referring to a currently open file. The OS uses that number as an index into the file descriptor table of files currently in use to access the actual device $($e$.$g$.,$ disk, network, terminal$).$

On the other hand, file streams operators $($fread$/$fwrite$)$ interact directly with file streams: FILE $*.$ File streams are dynamically allocated and allow reading$/$writing raw data. File stream operators, fread$()$ and fwrite$(),$ use the type void $*$ since there are no data$-$specific requirements.

The core input and output functions defined in include:

$$

Function name Description

fopen opens a file

fflush synchronizes an output stream with the actual file

setbuf, setvbuf sets the size of an input$/$output stream buffer

fpurge clears an input$/$output stream buffer

fread reads from a file

fwrite writes to a file

fgetc reads a character from a file stream

fputc writes a character to a file stream

fgets reads a character string from a file stream

fputs writes a character string to a file stream

fseek moves the file position to a specific location in a file

feof checks for the end$-$of$-$file

fclose closes a file

printf prints formatted output to stdout

Figure $1$ below shows how the standard I$/$O library utilizes a buffer to reduce the number of read and write system calls with filestreams.

Figure $1.$ This figure shows Standard I$/$O functions using FILE instead of file descriptor.

$$

$4.$ FILE Data Structure and fopen$()$

Upon a file open, fopen$()$ returns a pointer to a FILE object that maintains the attributes of the opened file.

On canvas is posted a version of the header file we will use for the project. The following shows the class FILE definition:

#ifndef $\_$MY$\_$STDIO$\_$H$\_$

#define $\_$MY$\_$STDIO$\_$H$\_$

#define BUFSIZ $8192//$ default buffer size

#define $\_$IONBF $0//$ unbuffered

#define $\_$IOLBF $1//$ line buffered. Do not need to implement this mode.

#define $\_$IOFBF $2//$ fully buffered

#define EOF $-1//$ end of file

class FILE

$\{$

public:

FILE$()$ :

fd$(0),$ pos$(0),$ buffer$(($char $*)0),$ size$(0,$ actual$\_$size$(0),$

mode$(\_$IONBF$),$ flag$(0),$ bufown$($false$),$ lastop$(0),$ eof$($false$)\{\}$

int fd; $//$ a Unix file descriptor of an opened file

int pos; $//$ the current file position in the buffer

char $*$buffer; $//$ an input or output file stream buffer

int size; $//$ the buffer size

int actual$\_$size; $//$ actual buffer size when read$()$ returns # bytes smaller than size

int mode; $//\_$IONBF, $\_$IOLBF, $\_$IOFBF. You do not need to implement $\_$IOLBF.

int flag; $//$ O$\_$RDONLY

$//$ O$\_$RDWR

$//$ O$\_$WRONLY $|$ O$\_$CREAT $|$ O$\_$TRUNC

$//$ O$\_$WRONLY $|$ O$\_$CREAT $|$ O$\_$APPEND

$//$ O$\_$RDWR $|$ O$\_$CREAT $|$ O$\_$TRUNC

$//$ O$\_$RDWR $|$ O$\_$CREAT $|$ O$\_$APPEND

bool bufown; $//$ true if allocated by stdio.h or false by a user

char lastop; $//\text{'}$r$\text{'}$ or $\text{'}$w$\text{'}$

bool eof; $//$ true if EOF is reached

$\}$;

#include "stdio.cpp$"$

#endif

$$

When opening a file, the fopen$()$ function receives not only the file name to open but also various file access modes:

r Open text file for reading.

r$+$ Open for reading and writing.

w Truncate file to zero length or create text file for writing.

w$+$ Open for reading and writing. The file is created if it does not exist, otherwise truncated.

a Open for appending $($writing at end of file$).$ The file is created if it does not exist.

a$+$ Open for reading and appending $($writing at end of file$).$ The file is created if it does not exist. The initial file position for reading is at the

beginning of the file, but output is alway appended to the end of the file.

$$

The fopen$()$ function