Главная страница
Навигация по странице:

  • 8.3. Открытие, создание, закрытие и расцепление (UNLINK).

  • Упражнение 8-1.

  • 8.4. Произвольный доступ - SEEK и LSEEK.

  • Упражнение 8-2. Очевидно, что SEEK может быть написана в терминалах LSEEK и наоборот. напишите каждую функцию через другую.8.5. Пример - реализация функций FOPEN и GETC.

  • Упражнение 8-3. Перепишите функции FOPEN и _FILEBUF, используя поля вместо явных побитовых операций.Упражнение 8-4.

  • Упражнение 8-5.

  • 8.6. Пример - распечатка справочников

  • Язык С (Керниган, Ричи). Язык сиБ. В. Керниган, Д. М. Ричи


    Скачать 1.46 Mb.
    НазваниеЯзык сиБ. В. Керниган, Д. М. Ричи
    АнкорЯзык С (Керниган, Ричи).pdf
    Дата23.04.2018
    Размер1.46 Mb.
    Формат файлаpdf
    Имя файлаЯзык С (Керниган, Ричи).pdf
    ТипДокументы
    #18413
    страница17 из 23
    1   ...   13   14   15   16   17   18   19   20   ...   23
    8.2. Низкоуровневый ввод/вывод - операторы READ и WRITE.
    Самый низкий уровень ввода/вывода в системе UNIX не предусматривает ни какой-либо буферизации, ни какого-либо другого сервиса; он по существу является непосредственным входом в операционную систему. Весь ввод и вывод осуществляется двумя функциями: READ и WRITE. Первым аргумен- том обеих функций является дескриптор файла. Вторым аргументом является буфер в вашей программе, откуда или куда должны поступать данные. Третий аргумент - это число подлежащих пересылке байтов. Обращения к этим функциям имеют вид:
    N_READ=READ(FD,BUF,N);
    N_WRITTEN=WRITE(FD,BUF,N);
    При каждом обращении возвращается счетчик байтов, указывающий фактическое число переданных байтов. При чтении возвращенное число байтов может оказаться меньше, чем запрошенное число. Возвращенное нулевое число байтов означает конец файла, а “-1” указывает на наличие какой-либо ошибки. При записи возвращенное значение равно числу фактически записанных байтов; несовпадение этого числа с числом байтов,
    которое предполагалось записать, обычно свидетельствует об ошибке.
    Количество байтов, подлежащих чтению или записи, может быть совершенно произвольным. Двумя самыми распространенными величинами являются “1”, которая означает передачу одного символа за обращение (т.е.
    Без использования буфера), и “512”, которая соответствует физическому размеру блока на многих периферийных устройствах. Этот последний размер будет наиболее эффективным, но даже ввод или вывод по одному символу за обращение не будет необыкновенно дорогим.
    Объединив все эти факты, мы написали простую программу для

    «Язык С» Б.В. Керниган, Д.М. Ричи
    167
    копирования ввода на вывод, эквивалентную программе копировки файлов,
    написанной в главе 1. На системе UNIX эта программа будет копировать что угодно куда угодно, потому что ввод и вывод могут быть перенаправлены на любой файл или устройство.
    #DEFINE BUFSIZE 512 /*BEST SIZE FOR PDP-11 UNIX*/
    MAIN() /*COPY INPUT TO OUTPUT*/
    \(
    CHAR BUF[BUFSIZE];
    INT N;
    WHILE((N=READ(0,BUF,BUFSIZE))>0)
    WRITE(1,BUF,N);
    \)
    Если размер файла не будет кратен BUFSIZE, то при некотором обращении к READ будет возвращено меньшее число байтов, которые затем записываются с помощью WRITE; при следующем после этого обращении к READ будет возвращен нуль.
    Поучительно разобраться, как можно использовать функции READ и
    WRITE для построения процедур более высокого уровня, таких как
    GETCHAR, PUTCHAR и т.д. Вот, например, вариант функции GETCHAR,
    осуществляющий ввод без использования буфера.
    #DEFINE CMASK 0377 /*FOR MAKING CHAR’S > 0*/
    GETCHAR() /*UNBUFFERED SINGLE CHARACTER INPUT*/
    \(
    CHAR C;
    RETURN((READ(0,&C,1)>0 7 & CMASK : EOF);
    \)
    Переменная “C” должна быть описана как CHAR, потому что функция
    READ принимает указатель на символы. Возвращаемый символ должен быть маскирован числом 0377 для гарантии его положительности; в противном случае знаковый разряд может сделать его значение отрицательным. (Константа
    0377 подходит для эвм PDP-11, но не обязательно для других машин).
    Второй вариант функции GETCHAR осуществляет ввод большими порциями, а выдает символы по одному за обращение.
    #DEFINE CMASK 0377 /*FOR MAKING CHAR’S>0*/
    #DEFINE BUFSIZE 512
    GETCHAR() /*BUFFERED VERSION*/
    \(
    STATIC CHAR BUF[BUFSIZE];
    STATIC CHAR *BUFP = BUF;
    STATIC INT N = 0;
    IF (N==0) \( /*BUFFER IS EMPTY*/

    168
    «Язык С» Б.В. Керниган, Д.М. Ричи
    N=READ(0,BUF,BUFSIZE);
    BUFP = BUF;
    \)
    RETURN((—N>=0) ? *BUFP++ & CMASK : EOF);
    \)
    8.3. Открытие, создание, закрытие и расцепление (UNLINK).
    Кроме случая, когда по умолчанию определены стандартные файлы ввода,
    вывода и ошибок, вы должны явно открывать файлы, чтобы затем читать из них или писать в них. Для этой цели существуют две точки входа: OPEN и CREAT.
    Функция OPEN весьма сходна с функцией FOPEN, рассмотренной в главе
    7, за исключением того, что вместо возвращения указателя файла она возвращает дескриптор файла, который является просто целым типа INT.
    INT FD;
    FD=OPEN(NAME,RWMODE);
    Как и в случае FOPEN, аргумент NAME является символьной строкой,
    соответствующей внешнему имени файла. Однако аргумент, определяющий режим доступа, отличен: RWMODE равно: 0 - для чтения, 1 - для записи, 2 - для чтения и записи. Если происходит какая-то ошибка, функция OPEN возвращает
    “-1”; в противном случае она возвращает действительный дескриптор файла.
    Попытка открыть файл, который не существует, является ошибкой. Точка входа CREAT предоставляет возможность создания новых файлов или перезаписи старых. В результате обращения
    FD=CREAT(NAME,PMODE);
    возвращает дескриптор файла, если оказалось возможным создать файл с именем NAME, и “-1” в противном случае. Если файл с таким именем уже существует, CREAT усечет его до нулевой длины; создание файла, который уже существует, не является ошибкой.
    Если файл является совершенно новым, то CREAT создает его с определенным режимом защиты, специфицируемым аргументом PMODE.
    В системе файлов на UNIX с файлом связываются девять битов защиты информации, которые управляют разрешением на чтение, запись и выполнение для владельца файла, для группы владельцев и для всех остальных пользователей. Таким образом, трехзначное восьмеричное число наиболее удобно для спецификации разрешений. Например, число 0755
    свидетельствует о разрешении на чтение, запись и выполнение для владельца и о разрешении на чтение и выполнение для группы и всех остальных.
    Для иллюстрации ниже приводится программа копирования одного файла в другой, являющаяся упрощенным вариантом утилиты CP системы UNIX.
    (Основное упрощение заключается в том, что наш вариант копирует только

    «Язык С» Б.В. Керниган, Д.М. Ричи
    169
    один файл и что второй аргумент не должен быть справочником).
    #DEFINE NULL 0
    #DEFINE BUFSIZE 512
    #DEFINE PMODE 0644/*RW FOR OWNER,R FOR GROUP,OTHERS*/
    MAIN(ARGC,ARGV) /*CP: COPY F1 TO F2*/
    INT ARGC;
    CHAR *ARGV[];
    \(
    INT F1, F2, N;
    CHAR BUF[BUFSIZE];
    IF (ARGC ! = 3)
    ERROR(“USAGE:CP FROM TO”, NULL);
    IF ((F1=OPEN(ARGV[1],0))== -1)
    ERROR(“CP:CAN’T OPEN %S”, ARGV[1]);
    IF ((F2=CREAT(ARGV[2],PMODE))== -1)
    ERROR(“CP: CAN’T CREATE %S”, ARGV[2]);
    WHILE ((N=READ(F1,BUF,BUFSIZE))>0)
    IF (WRITE(F2,BUF,N) !=N)
    ERROR(“CP: WRITE ERROR”, NULL);
    EXIT(0);
    \)
    ERROR(S1,S2) /*PRINT ERROR MESSAGE AND DIE*/
    CHAR *S1, S2;
    \(
    PRINTF(S1,S2);
    PRINTF(“\N”);EXIT(1);
    \)
    Существует ограничение (обычно 15 - 25) на количество файлов, которые программа может иметь открытыми одновременно. В соответствии с этим любая программа, собирающаяся работать со многими файлами, должна быть подготовлена к повторному использованию дескрипторов файлов. Процедура
    CLOSE прерывает связь между дескриптором файла и открытым файлом и освобождает дескриптор файла для использования с некоторым другим файлом. Завершение выполнения программы через EXIT или в результате возврата из ведущей программы приводит к закрытию всех открытых файлов.
    Функция расцепления UNLINK (FILENAME) удаляет из системы файлов файл с именем FILENAME ( из данного справочного файла. Файл может быть сцеплен с другим справочником, возможно, под другим именем - примеч.переводчика).
    Упражнение 8-1.
    Перепишите программу CAT из главы 7, используя функции READ,
    WRITE, OPEN и CLOSE вместо их эквивалентов из стандартной библиотеки.

    170
    «Язык С» Б.В. Керниган, Д.М. Ричи
    Проведите эксперименты для определения относительной скорости работы этих двух вариантов.
    8.4. Произвольный доступ - SEEK и LSEEK.
    Нормально при работе с файлами ввод и вывод осуществляется последовательно: при каждом обращении к функциям READ и WRITE чтение или запись начинаются с позиции, непосредственно следующей за предыдущей обработанной. Но при необходимости файл может читаться или записываться в любом произвольном порядке. Обращение к системе с помощью функции LSEEK позволяет передвигаться по файлу, не производя фактического чтения или записи. В результате обращения
    LSEEK(FD,OFFSET,ORIGIN);
    текущая позиция в файле с дескриптором FD передвигается на позицию
    OFFSET (смещение), которая отсчитывается от места, указываемого аргументом ORIGIN (начало отсчета). Последующее чтение или запись будут теперь начинаться с этой позиции. Аргумент OFFSET имеет тип LONG; FD
    и ORIGIN имеют тип INT.
    Аргумент ORIGIN может принимать значения 0,1 или 2, указывая на то,
    что величина OFFSET должна отсчитываться соответственно от начала файла,
    от текущей позиции или от конца файла. Например, чтобы дополнить файл,
    следует перед записью найти его конец:
    LSEEK(FD,0L,2);
    чтобы вернуться к началу (“перемотать обратно”), можно написать:
    LSEEK(FD,0L,0);
    обратите внимание на аргумент 0L; его можно было бы записать и в виде
    (LONG) 0.
    Функция LSEEK позволяет обращаться с файлами примерно так же, как с большими массивами, правда ценой более медленного доступа. следующая простая функция, например, считывает любое количество байтов, начиная с произвольного места в файле.
    GET(FD,POS,BUF,N) /*READ N BYTES FROM POSITION POS*/
    INT FD, N;
    LONG POS;
    CHAR *BUF;
    \(
    LSEEK(FD,POS,0); /*GET TO POS*/
    RETURN(READ(FD,BUF,N));
    \)

    «Язык С» Б.В. Керниган, Д.М. Ричи
    171
    В более ранних редакциях, чем редакция 7 системы UNIX, основная точка входа в систему ввода-вывода называется SEEK. Функция SEEK идентична функции LSEEK, за исключением того, что аргумент OFFSET имеет тип INT, а не LONG. в соответствии с этим, поскольку на PDP-11 целые имеют только 16
    битов, аргумент OFFSET, указываемый функции SEEK, ограничен величиной
    65535; по этой причине аргумент ORIGIN может иметь значения 3, 4, 5, которые заставляют функцию SEEK умножить заданное значение OFFSET на 512
    (количество байтов в одном физическом блоке) и затем интерпретировать ORI-
    GIN, как если это 0, 1 или 2 соответственно. Следовательно, чтобы достичь произвольного места в большом файле, нужно два обращения к SEEK: сначала одно, которое выделяет нужный блок, а затем второе, где ORIGIN имеет значение
    1 и которое осуществляет передвижение на желаемый байт внутри блока.
    Упражнение 8-2.
    Очевидно, что SEEK может быть написана в терминалах LSEEK и наоборот. напишите каждую функцию через другую.
    8.5. Пример - реализация функций FOPEN и GETC.
    Давайте теперь на примере реализации функций FOPEN и GETC из стандартной библиотеки подпрограмм продемонстрируем, как некоторые из описанных элементов объединяются вместе.
    Напомним, что в стандартной библиотеке файлы описыватся посредством указателей файлов, а не дескрипторов. Указатель файла является указателем на структуру, которая содержит несколько элементов информации о файле: указатель буфера, чтобы файл мог читаться большими порциями; счетчик числа символов,
    оставшихся в буфере; указатель следующей позиции символа в буфере; некоторые признаки, указывающие режим чтения или записи и т.д.; дескриптор файла.
    Описывающая файл структура данных содержится в файле STDIO.H,
    который должен включаться (посредством #INCLUDE) в любой исходный файл, в котором используются функции из стандартной библиотеки. Он также включается функциями этой библиотеки. В приводимой ниже выдержке из файла STDIO.H имена, предназначаемые только для использования функциями библиотеки, начинаются с подчеркивания, с тем чтобы уменьшить вероятность совпадения с именами в программе пользователя.
    DEFINE _BUFSIZE 512
    DEFINE _NFILE 20 /*FILES THAT CAN BE HANDLED*/
    TYPEDEF STRUCT _IOBUF \(
    CHAR*_PTR; /*NEXT CHARACTER POSITION*/
    INT _CNT; /*NUMBER OF CHARACTERS LEFT*/
    CHAR*_BASE;
    /*LOCATION OF BUFFER*/
    INT _FLAG; /*MODE OF FILE ACCESS*/
    INT _FD;
    /*FILE DESCRIPTOR*/
    ) FILE;

    172
    «Язык С» Б.В. Керниган, Д.М. Ричи
    XTERN FILE _IOB[_NFILE];
    DEFINE STDIN
    (&_IOB[0])
    DEFINE STDOUT
    (&_IOB[1])
    DEFINE STDERR
    (&_IOB[2])
    DEFINE _READ 01 /* FILE OPEN FOR READING */
    DEFINE _WRITE 02 /* FILE OPEN FOR WRITING */
    DEFINE _UNBUF 04 /* FILE IS UNBUFFERED */
    DEFINE _BIGBUF 010 /* BIG BUFFER ALLOCATED */
    DEFINE _EOF 020 /* EOF HAS OCCURRED ON THIS FILE */
    DEFINE _ERR 040 /* ERROR HAS OCCURRED ON THIS FILE */
    DEFINE NULL 0
    DEFINE EOF (-1)
    DEFINE GETC(P) (—(P)->_CNT >= 0 \
    ? *(P)->_PTR++ & 0377 : _FILEBUF(P))
    DEFINE GETCHAR() GETC(STDIN)
    DEFINE PUTC(X,P) (—(P)->_CNT >= 0 \
    ? *(P)->_PTR++ = (X) : _FLUSHBUF((X),P))
    DEFINE PUTCHAR(X)
    PUTC(X,STDOUT)
    В нормальном состоянии макрос GETC просто уменьшает счетчик, передвигает указатель и возвращает символ. (Если определение #DEFINE слишком длинное,
    то оно продолжается с помощью обратной косой черты). Если однако счетчик становится отрицательным, то GETC вызывает функцию _FILEBUF, которая снова заполняет буфер, реинициализирует содержимое структуры и возвращает символ.
    Функция может предоставлять переносимый интерфейс и в то же время содержать непереносимые конструкции: GETC маскирует символ числом 0377, которое подавляет знаковое расширение, осуществляемое на PDP-11, и тем самым гарантирует положительность всех символов.
    Хотя мы не собираемся обсуждать какие-либо детали, мы все же включили сюда определение макроса PUTC, для того чтобы показать, что она работает в основном точно также, как и GETC, обращаясь при заполнении буфера к функции _FLUSHBUF.
    Теперь может быть написана функция FOPEN. Большая часть программы функции FOPEN связана с открыванием файла и расположением его в нужном месте, а также с установлением битов признаков таким образом, чтобы они указывали нужное состояние. Функция FOPEN не выделяет какой-либо буферной памяти; это делается функцией _FILEBUF при первом чтении из файла.
    #INCLUDE
    #DEFINE PMODE 0644 /*R/W FOR OWNER;R FOR OTHERS*/
    FILE *FOPEN(NAME,MODE) /*OPEN FILE,RETURN FILE PTR*/
    REGISTER CHAR *NAME, *MODE;
    \(
    REGISTER INT FD;

    «Язык С» Б.В. Керниган, Д.М. Ричи
    173
    REGISTER FILE *FP;
    IF(*MODE !=’R’&&*MODE !=’W’&&*MODE !=’A’) \(
    FPRINTF(STDERR,”ILLEGAL MODE %S OPENING %S\N”, MODE,NAME);
    EXIT(1);
    \)
    FOR (FP=_IOB;FP<_IOB+_NFILE;FP++)
    IF((FP->_FLAG & (_READ \! _WRITE))==0)
    BREAK; /*FOUND FREE SLOT*/
    IF(FP>=_IOB+_NFILE) /*NO FREE SLOTS*/
    RETURN(NULL);
    IF(*MODE==’W’) /*ACCESS FILE*/
    FD=CREAT(NAME,PMODE);
    ELSE IF(*MODE==’A’) \(
    IF((FD=OPEN(NAME,1))==-1)
    FD=CREAT(NAME,PMODE);
    LSEEK(FD,OL,2);
    \) ELSE
    FD=OPEN(NAME,0);
    IF(FD==-1) /*COULDN’T ACCESS NAME*/
    RETURN(NULL);
    FP->_FD=FD;
    FP->_CNT=0;
    FP->_BASE=NULL;
    FP->_FLAG &=(_READ \! _WRITE);
    FP->_FLAG \!=(*MODE==’R’) ? _READ : _WRITE;
    RETURN(FP);
    \)
    Функция _FILEBUF несколько более сложная. Основная трудность заключается в том, что _FILEBUF стремится разрешить доступ к файлу и в том случае, когда может не оказаться достаточно места в памяти для буферизации ввода или вывода. если пространство для нового буфера может быть получено обращением к функции CALLOC, то все отлично; если же нет, то _FILEBUF осуществляет небуферизованный ввод/ вывод, используя отдельный символ, помещенный в локальном массиве.
    #INCLUDE
    _FILLBUF(FP) /*ALLOCATE AND FILL INPUT BUFFER*/
    REGISTER FILE *FP;
    (
    STATIC CHAR SMALLBUF(NFILE);/*FOR UNBUFFERED 1/0*/
    CHAR *CALLOC(); IF((FR->_FLAG&_READ)==0\!\!(FP
    >_FLAG&(EOF\!_ERR))\!=0
    RETURN(EOF);
    WHILE(FP->_BASE==NULL) /*FIND BUFFER SPACE*/

    174
    «Язык С» Б.В. Керниган, Д.М. Ричи
    IF(FP->_FLAG & _UNBUF) /*UNBUFFERED*/ FP
    >_BASE=&SMALLBUF[FP->_FD];
    ELSE IF((FP->_BASE=CALLOC(_BUFSIZE,1))==NULL)
    FP->_FLAG \!=_UNBUF; /*CAN’T GET BIG BUF*/
    ELSE
    FP->_FLAG \!=_BIGBUF; /*GOT BIG ONE*/ FP->_PTR=FP
    >_BASE; FP->_CNT=READ(FP->_FD, FP->_PTR,
    FP->_FLAG & _UNBUF ? 1 : _BUFSIZE); FF(—FP->_CNT<0) \(
    IF(FP->_CNT== -1)
    FP->_FLAG \! = _EOF;
    ELSE
    FP->_FLAG \! = _ ERR;
    FP->_CNT = 0;
    RETURN(EOF);
    \)
    RETURN(*FP->_PTR++ & 0377); /*MAKE CHAR POSITIVE*/ )
    При первом обращении к GETC для конкретного файла счетчик оказывается равным нулю, что приводит к обращению к _FILEBUF. Если функция _FILEBUF найдет, что этот файл не открыт для чтения, она немедленно возвращает EOF. В противном случае она пытается выделить большой буфер, а если ей это не удается, то буфер из одного символа. При этом она заносит в _FLAG соответствующую информацию о буферизации.
    Раз буфер уже создан, функция _FILEBUF просто вызывает функцию
    READ для его заполнения, устанавливает счетчик и указатели и возвращает символ из начала буфера.
    Единственный оставшийся невыясненным вопрос состоит в том, как все начинается. Массив _IOB должен быть определен и инициализирован для
    STDIN, STDOUT и STDERR:
    FILE _IOB[NFILE] = \(
    (NULL,0,_READ,0), /*STDIN*/
    (NULL,0,NULL,1), /*STDOUT*/
    (NULL,0,NULL,_WRITE \! _UNBUF,2) /*STDERR*/
    );
    Из инициализации части _FLAG этого массива структур видно, что файл
    STDIN предназначен для чтения, файл STDOUT - для записи и файл STDERR
    - для записи без использования буфера.
    Упражнение 8-3.
    Перепишите функции FOPEN и _FILEBUF, используя поля вместо явных побитовых операций.
    Упражнение 8-4.
    Разработайте и напишите функции _FLUSHBUF и FCLOSE.

    «Язык С» Б.В. Керниган, Д.М. Ричи
    175
    Упражнение 8-5.
    Стандартная библиотека содержит функцию
    FSEEK(FP, OFFSET, ORIGIN)
    которая идентична функции LSEEK, исключая то, что FP является указателем файла, а не дескриптором файла. Напишите FSEEK. Убедитесь,
    что ваша FSEEK правильно согласуется с буферизацией, сделанной для других функций библиотеки.
    8.6. Пример - распечатка справочников
    Иногда требуется другой вид взаимодействия с системой файлов - определение информации о файле, а не того, что в нем содержится. Примером может служить команда LS (“список справочника”) системы UNIX. По этой команде распечатываются имена файлов из справочника и, необязательно,
    другая информация, такая как размеры, разрешения и т.д.
    Поскольку, по крайней мере, на системе UNIX справочник является просто файлом, то в такой команде, как LS нет ничего особенного; она читает файл и выделяет нужные части из находящейся там информации. Однако формат информации определяется системой, так что LS должна знать, в каком виде все представляется в системе.
    Мы это частично проиллюстрируем при написании программы FSIZE.
    Программа FSIZE представляет собой специальную форму LS, которая печатает размеры всех файлов, указанных в списке ее аргументов. Если один из файлов является справочником, то для обработки этого справочника программа FSIZE обращается сама к себе рекурсивно. если же аргументы вообще отсутствуют, то обрабатывается текущий справочник.
    Для начала дадим краткий обзор структуры системы файлов. Справочник
    - это файл, который содержит список имен файлов и некоторое указание о том, где они размещаются. Фактически это указание является индексом для другой таблицы, которую называют “I - узловой таблицей”. Для файла I-узел
    - это то, где содержится вся информация о файле, за исключением его имени.
    Запись в справочнике состоит только из двух элементов: номера I-узла и имени файла. Точная спецификация поступает при включении файла SYS/
    DIR.H, который содержит
    #DEFINE DIRSIZ 14 /*MAX LENGTH OF FILE NAME*/
    STRUCT DIRECT /*STRUCTURE OF DIRECTORY ENTRY*/
    \(
    INO_T&_INO; /*INODE NUMBER*/
    CHAR &_NAME[DIRSIZ]; /*FILE NAME*/
    \);
    “Тип” INO_T - это определяемый посредством TYPEDEF тип, который описывает индекс I-узловой таблицы. На PDP-11 UNIX этим типом

    176
    «Язык С» Б.В. Керниган, Д.М. Ричи
    оказывается UNSIGNED, но это не тот сорт информации, который помещают внутрь программы: на разных системах этот тип может быть различным.
    Поэтому и следует использовать TYPEDEF. Полный набор “системных”
    типов находится в файле SYS/TUPES.H.
    Функция STAT берет имя файла и возвращает всю содержащуюся в I-ом узле информацию об этом файле (или -1, если имеется ошибка). Таким образом, в результате
    STRUCT STAT STBUF;
    CHAR *NAME;
    STAT(NAME,&STBUF);
    структура STBUF наполняется информацией из I-го узла о файле с именем
    NAME. Структура, описывающая возвращаемую функцией STAT
    информацию, находится в файле SYS/STAT.H и выглядит следующим образом:
    STRUCT STAT /*STRUCTURE RETURNED BY STAT*/
    \(
    DEV_T
    ST_DEV;
    /* DEVICE OF INODE */
    INO_T
    ST_INO;
    /* INODE NUMBER */
    SHORT
    ST_MODE
    /* MODE BITS */
    SHORT
    ST_NLINK;
    / *NUMBER OF LINKS TO FILE */
    SHORT
    ST_UID;
    /* OWNER’S USER ID */
    SHORT
    ST_GID;
    /* OWNER’S GROUP ID */
    DEV_T
    ST_RDEV;
    /* FOR SPECIAL FILES */
    OFF_T
    ST_SIZE;
    /* FILE SIZE IN CHARACTERS */
    TIME_T ST_ATIME; /* TIME LAST ACCESSED */
    TIME_T ST_MTIME; /* TIME LAST MODIFIED */
    TIME_T ST_CTIME; /* TIME ORIGINALLY CREATED */
    \)
    Большая часть этой информации объясняется в комментариях. Элемент
    ST.MODE содержит набор флагов, описывающих файл; для удобства определения флагов также находятся в файле SYS/STAT.H.
    #DEFINE S_IFMT
    0160000 /* TYPE OF FILE */
    #DEFINE S_IFDIR 0040000 /* DIRECTORY */
    #DEFINE S_IFCHR 0020000 /* CHARACTER SPECIAL */
    #DEFINE S_IFBLK 0060000 /* BLOCK SPECIAL */
    #DEFINE S_IFREG 0100000 /* REGULAR */
    #DEFINE S_ISUID 04000 /* SET USER ID ON EXECUTION */
    #DEFINE S_ISGID 02000 /* SET GROUP ID ON EXECUTION */
    #DEFINE S_ISVTX 01000 /*SAVE SWAPPED TEXT AFTER USE*/
    #DEFINE S_IREAD 0400 /* READ PERMISSION */

    «Язык С» Б.В. Керниган, Д.М. Ричи
    177
    #DEFINE S_IWRITE 0200 /* WRITE PERMISSION */
    #DEFINE S_IEXEC 0100 /* EXECUTE PERMISSION */
    Теперь мы в состоянии написать программу FSIZE. Если полученный от функции STAT режим указывает, что файл не является справочником, то его размер уже под рукой и может быть напечатан непосредственно. Если же он оказывается справочником, то мы должны обрабатывать этот справочник отдельно для каждого файла; так как справочник может в свою очередь со- держать подсправочники, этот процесс обработки является рекурсивным.
    Как обычно, ведущая программа главным образом имеет дело с командной строкой аргументов; она передает каждый аргумент функции FSIZE в большой буфер.
    #INCLUDE
    #INCLUDE /*TYPEDEFS*/
    #INCLUDE /*DIRECTORY ENTRY STRUCTURE*/
    #INCLUDE /*STRUCTURE RETURNED BY STAT*/
    #DEFINE BUFSIZE 256
    MAIN(ARGC,ARGV) /*FSIZE:PRINT FILE SIZES*/
    CHAR *ARGV[];
    \(
    CHAR BUF[BUFSIZE];
    IF(ARGC==1) \( /*DEFAULT:CURRENT DIRECTORY*/
    ATRCPY(BUF,”.”);
    FSIZE(BUF);
    \) ELSE
    WHILE(—ARGC>0) \(
    STRCPY(BUF,*++ARGV);
    FSIZE(BUF);
    \)
    \)
    Функция FSIZE печатает размер файла. Если однако файл оказывается справочником, то FSIZE сначала вызывает функцию DIRECTORY для обработки всех указанных в нем файлов. Обратите внимание на использование имен флагов S_IFMT и _IFDIR из файла STAT.H.
    FSIZE(NAME) /*PRINT SIZE FOR NAME*/
    CHAR *NAME;
    \(
    STRUCT STAT STBUF;
    IF(STAT(NAME,&STBUF)== -1) \(
    FPRINTF(STDERR,”FSIZE:CAN’T FIND %S\N”,NAME); RETURN;
    \)
    IF((STBUF.ST_MODE & S_IFMT)==S_IFDIR)
    DIRECTORY(NAME);

    178
    «Язык С» Б.В. Керниган, Д.М. Ричи
    PRINTF(“%8LD %S\N”,STBUF.ST_SIZE,NAME);
    \)
    Функция DIRECTORY является самой сложной. Однако значительная ее часть связана с созданием для обрабатываемого в данный момент файла его полного имени, по которому можно восстановить путь в дереве.
    DIRECTORY(NAME)
    /*FSIZE FOR ALL FILES IN NAME*/
    CHAR *NAME;
    (
    STRUCT DIRECT DIRBUF;
    CHAR *NBP, *NEP;
    INT I, FD;
    NBP=NAME+STRLEN(NAME);
    *NBP++=’/’; /*ADD SLASH TO DIRECTORY NAME*/
    IF(NBP+DIRSIZ+2>=NAME+BUFSIZE) /*NAME TOO LONG*/
    RETURN;
    IF((FD=OPEN(NAME,0))== -1)
    RETURN;
    WHILE(READ(FD,(CHAR *)&DIRBUF,SIZEOF(DIRBUF))>0) \(
    IF(DIRBUF.D_INO==0) /*SLOT NOT IN USE*/ CONTINUE;
    IF(STRCMP (DIRBUF.D_NAME,”.”)==0
    \!\! STRCMP(DIRBUF.D_NAME,”..”)==0
    CONTINUE; /*SKIP SELF AND PARENT*/
    FOR (I=0,NEP=NBP;I*NEP++=DIRBUF.D_NAME[I];
    *NEP++=’\0';
    FSIZE(NAME);
    \)
    CLOSE(FD);
    *—NBP=’\0'; /*RESTORE NAME*/
    )
    Если некоторая дыра в справочнике в настоящее время не используется
    (потому что файл был удален), то в соответствующее I-узловое число равно нулю, и эта позиция пропускается. Каждый справочник также содержит запись в самом себе, называемую “.”, и о своем родителе, “..”; они, очевидно, также должны быть пропущены, а то программа будет работать весьма и весьма долго.
    Хотя программа FSIZE довольно специализированна, она все же демонстрирует пару важных идей. во-первых, многие программы не являются “системными программами”; они только используют информацию, форма или содержание которой определяется операционной системой. Во-вторых, для таких программ существенно, что представление этой информации входит только в стандартные
    “заголовочные файлы”, такие как STAT.H и DIR.H, и что программы включают эти файлы, а не помещают фактические описания внутрь самих программ.

    «Язык С» Б.В. Керниган, Д.М. Ричи
    179
    1   ...   13   14   15   16   17   18   19   20   ...   23


    написать администратору сайта