Текст книги "Linux программирование в примерах"
Автор книги: Арнольд Роббинс
Жанры:
Программирование
,сообщить о нарушении
Текущая страница: 39 (всего у книги 55 страниц)
wordexp() и wordfree()Многие члены комитета POSIX чувствовали, что glob() делает недостаточно: им нужна была библиотечная процедура, способная делать все, что может делать оболочка разворачивание тильды ('echo ~arnold'), разворачивание переменных оболочки ('echo $HOME') и подстановку команд ('echo $(cd ; pwd)'). Многие другие чувствовали, что glob() не подходила для этой цели. Чтобы «удовлетворить» каждого, POSIX предоставляет две дополнительные функции, которые делают все:
#include
int wordexp(const char *words, wordexp_t *pwordexp, int flags);
void wordfree(wordexp_t *wordexp);
Эти функции работают сходным с glob() и globfree() образом, но со структурой wordexp_t:
typedef struct {
size_t we_wordc; /* Число подходящих слов */
char **we_wordv; /* Список развернутых слов */
size_t we_offs; /* Резервируемые в we_wordv слоты */
} wordexp_t;
Члены структуры полностью аналогичны описанным ранее для glob_t; мы не будем здесь повторять все описание.
Как и для glob(), поведение wordexp() управляется несколькими флагами. Флаги перечислены в табл. 12.5.
Таблица 12.5. Флаги для wordexp()
WRDE_APPEND | Добавить результаты текущего вызова к предыдущим |
WRDE_DOOFFS | Зарезервировать we_offs мест в начале we_wordv |
WRDE_NOCMD | Запретить подстановку команд |
WRDE_REUSE | Повторно использовать память, на которую указывает we_wordv |
WRDE_SHOWERR | Не молчать при возникновении во время разворачивания ошибок |
WRDE_UNDEF | Неопределенные переменные оболочки должны вызывать ошибку |
Возвращаемое значение равно 0, если все прошло хорошо, или одно из значений из табл. 12.6, если нет.
Таблица 12.6. Возвращаемые значения ошибок для wordexp()
WRDE_BADCHAR | Метасимвол (конец строки, '|', &, ;, <, >, (, ), {, или }) в недопустимом месте |
WRDE_BADVAL | Переменная не определена при установленном WRDE_UNDEF |
WRDE_CMDSUB | Попытка подстановки команды при установленном WRDE_NOCMD |
WRDE_NOSPACE | Была проблема с выделением динамической памяти |
WRDE_SYNTAX | Синтаксическая ошибка оболочки. |
Мы оставляем вам в качестве упражнения (см. далее) модификацию ch12-glob.c для использования wordexp() и wordfree(). Вот наша версия в действии:
$ ch12-wordexp 'echo $HOME' /* Развертывание переменных оболочки */
echo
/home/arnold
$ ch12-wordexp 'echo $HOME/*.gz' /* Переменные и символы подстановки */
echo
/home/arnold/48000.wav.gz
/home/arnold/ipmasq-HOWTO.tar.gz
/home/arnold/rc.firewall-examples.tar.gz
$ ch12-wordexp 'echo ~arnold' /* Развертывание тильды */
echo
/home/arnold
$ ch12-wordexp 'echo ~arnold/.p*' /* Тильда и символы подстановки */
echo
/home/arnold/.postitnotes
/home/arnold/.procmailrc
/home/arnold/.profile
$ ch12-wordexp "echo '~arnold/.p*'" /* Кавычки работают */
echo
~arnold/.p*
Регулярные выражения являются способом описания текстовых шаблонов для сопоставления. Если вы вообще сколько-нибудь использовали GNU/Linux или Unix, вы без сомнения знакомы с регулярными выражениями: они являются фундаментальной частью инструментария программиста Unix. Они неотъемлемы от таких повседневных программ, как grep, egrep, sed, awk, Perl, а также редакторы ed, vi, vim и Emacs. Если вы вообще не знакомы с регулярными выражениями, мы рекомендуем ознакомиться с некоторыми из книг или URL, указанных в разделе 12.9 «Рекомендуемая литература».
POSIX определяет два вида регулярных выражений: базовый и расширенный. Программы типа grep, sed и строчный редактор ed используют базовые регулярные выражения. Программы типа egrep и awk используют расширенные регулярные выражения. Следующие функции дают вам возможность использовать в своих программах любой вид.
#include
#include
int regcomp(regex_t *preg, const char *regex, int cflags);
int regexec(const regex_t *preg, const char *string, size_t nmatch,
regmatch_t pmatch[], int eflags);
size_t regerror(int errcode, const regex_t *preg,
char *errbuf, size_t errbuf_size);
void regfree(regex_t *preg);
Чтобы сопоставить регулярное выражение, нужно сначала откомпилировать строчную версию регулярного выражения. Компиляция преобразует регулярное выражение во внутренний формат. Затем откомпилированная форма исполняется для строки для проверки, совпадает ли она с первоначальным регулярным выражением. Функции следующие.
int regcomp(regex_t *preg, const char *regex, int cflags)
Компилирует регулярное выражение regex во внутреннее представление, сохраняя его в структуре regex_t, на которую указывает preg. cflags контролирует процесс компиляции; ее значение равно 0 или побитовому ИЛИ одного или более флагов из табл. 12.7
int regexec(const regex_t *preg, const char *string, size_t nmatch,
regmatch_t pmatch[], int eflags)
Выполняет откомпилированное регулярное выражение в *preg в строке string eflags контролирует способ выполнения; ее значение равно 0 или побитовому ИЛИ одного или более флагов из табл. 12.8. Вскоре мы обсудим другие аргументы.
size_t regerror(int errcode, const regex_t *preg,
char *errbuf, size_t errbuf_size)
Преобразует ошибку, возвращенную regcomp() или regexec(), в удобочитаемую строку.
void regfree(regex_t *preg)
Освобождает динамическую память, используемую откомпилированным регулярным выражением в *preg.
Заголовочный файл regcomp(); другие используются с regexec(). Однако, все они начинаются с префикса 'REG_'. В табл. 12.7 перечислены флаги для компиляции регулярных выражений с помощью regcomp().
Таблица 12.7. Флаги для regcomp()
REG_EXTENDED | Использовать расширенные регулярные выражения. По умолчанию используются базовые регулярные выражения |
REG_ICASE | Сопоставление regexec() игнорирует регистр символов |
REG_NEWLINE | Операторы, заменяющие любой символ, не включают символ конца строки |
REG_NOSUB | Информация о начале и конце вложенною шаблона не требуется (см текст) |
Флаги для сопоставления регулярных выражений с помощью regexec() приведены в табл. 12.8.
Таблица 12.8. Флаги дли regexec()
REG_NOTBOL | Оператор ^ (начало строки) не сопоставляется |
REG_NOTEOL | Оператор $ (конец строки) не сопоставляется |
Флаги REG_NEWLINE, REG_NOTBOL и REG_NOTEOL взаимодействуют друг с другом. Это немного запутано, поэтому мы будем продвигаться небольшими шажками.
• Когда в cflags не включен REG_NEWLINE, символ конца строки действует в качестве обычного символа. С ним может быть сопоставлен метасимвол '.' (любой символ), а также дополненные списки символов ('[^...]'). При этом $ не сопоставляется немедленно с началом вставленного символа новой строки, а ^ не сопоставляется немедленно с его концом.
• Когда в eflags установлен REG_NOTBOL, оператор ^ не соответствует началу строки. Это полезно, когда параметр string является адресом символа в середине сопоставляемого текста.
• Сходным образом, когда в eflags установлен REG_NOTEOL, оператор $ не соответствует концу строки.
• Когда в cflags включен REG_NEWLINE, то:
• Символ конца строки не соответствует '.' или дополненному списку символов.
• Оператор ^ всегда соответствует положению непосредственно за вставленным символом конца строки независимо от установки REG_BOL.
• Оператор $ всегда соответствует положению непосредственно перед вставленным символом конца строки независимо от установки REG_EOL.
Когда вы осуществляете построчный ввод/вывод, как в случае с grep, можно не включать REG_NEWLINE в cflags. Если в буфере несколько строк, и каждую из них нужно рассматривать как отдельную, с сопоставлением ^ и $, тогда следует включить REG_NEWLINE.
Структура regex_t по большей части непрозрачна. Код уровня пользователя может исследовать лишь один член этой структуры; остальное предназначено для внутреннего использования процедурами регулярных выражений:
typedef struct {
/* ...здесь внутренний материал... */
size_t re_nsub;
/* ...здесь внутренний материал... */
} regex_t;
В структуре regmatch_t есть по крайней мере два члена для использования кодом уровня пользователя:
typedef struct {
/* ...здесь возможный внутренний материал... */
regoff_t rm_so; /* Смещение начала вложенной строки в байтах */
regoff_t rm_eo; /* Смещение первого байта после вложенной строки */
/* ...здесь возможный внутренний материал... */
} regmatch_t;
Как поле re_nsub, так и структура regmatch_t предназначены для сопоставления вложенных выражений. Рассмотрим такое регулярное выражение:
[:пробел:]]+([[:цифра:]]+)[[:пробел:]]+([[:буква:]])+
Каждое из двух вложенных выражений в скобках могут соответствовать одному или более символам. Более того, текст, соответствующий каждому вложенному выражению, может начинаться и заканчиваться в произвольных участках строки.
regcomp() устанавливает в поле re_nsub число вложенных выражений в скобках внутри регулярного выражения, regexec() заполняет массив pmatch структур regmatch_t смещениями начальных и конечных байтов текста, соответствующих этим вложенным выражениям. Вместе эти данные позволяют заменять текст – удалять его или заменять другим текстом, точно так же, как в текстовом редакторе
pmatch[0] описывает часть строки, соответствующую всему регулярному выражению. Участок от pmatch[1] до pmatch[preg->re_nsub] описывает ту часть, которая соответствует каждому вложенному выражению в скобках. (Таким образом, вложенные выражения нумеруются начиная с 1.) Элементы rm_so и rm_eo не используемых элементов массива pmatch установлены в -1.
regexec() заполняет не более nmatch-1 элементов pmatch; поэтому следует убедиться, что имеется по крайней мере на 1 элемент больше, чем в preg->re_nsub.
Наконец, флаг REG_NOSUB для regcomp() означает, что начальная и завершающая информация не нужна. Этот флаг следует использовать, когда эти сведения не нужны; это потенциально может довольно значительно повысить производительность regexec().
Другими словами, если все, что вам нужно знать, это «соответствует ли?», включите REG_NOSUB. Однако, если нужно также знать, «где находится соответствующий текст?», этот флаг следует опустить.
В заключение, как regcomp(), так и regexec() возвращают 0, если они успешны, или определенный код ошибки, если нет. Коды ошибок перечислены в табл. 12.9.
Таблица 12.9. Коды ошибок regcomp() и regexec()
REG_BADBR | Содержимое '{...}' недействительно. |
REG_BADPAT | Регулярное выражение недействительно |
REG_BADRPT | Символу ?, + или * не предшествует действительное регулярное выражение. |
REG_EBRACE | Фигурные скобки ('{...}') не сбалансированы |
REG_EBRACK | Квадратные скобки ('[...]') не сбалансированы |
REG_ECOLLATE | В шаблоне использован недействительный элемент сортировки |
REG_ECTYPE | В шаблоне использован недействительный класс символов |
REG_EESCAPE | В шаблоне есть завершающий символ |
REG_EPAREN | Группирующие скобки ('(...)' или '(...)') не сбалансированы |
REG_ERANGE | Конечная точка в диапазоне не действительна |
REG_ESPACE | Функции не хватило памяти |
REG_ESUBREG | Цифра в 'цифра' недействительна |
REG_NOMATCH | Строка не соответствует шаблону |
Для демонстрации регулярных выражений ch12-grep.c предусматривает базовую реализацию стандартной программы grep, которая отыскивает соответствие шаблону. Наша версия использует по умолчанию базовые регулярные выражения. Для использования вместо этого расширенных регулярных выражений она принимает опцию -E, а для игнорирования регистра символов опцию -i. Как и настоящая grep, если в командной строке не указаны файлы, наша grep читает со стандартного ввода, а для обозначения стандартного ввода, как и в настоящей grep, может быть использовано имя файла '-'. (Эта методика полезна для поиска в стандартном вводе наряду с другими файлами.) Вот программа:
1 /* ch12-grep.c – Простая версия grep, использующая функции POSIX */
2
3 #define _GNU_SOURCE 1 /* для getline)) */
4 #include
5 #include
6 #include
7 #include
8 #include
9
10 char *myname; /* для сообщений об ошибках */
11 int ignore_case = 0; /* опция -i: игнорировать регистр */
12 int extended = 0; /* опция -E: использовать расширенные регулярные выражения */
13 int errors = 0; /* число ошибок */
14
15 regex_t pattern; /* шаблон для поиска */
16
17 void compile_pattern(const char *pat);
18 void process(const char *name, FILE *fp);
19 void usage(void);
Строки 10–15 объявляют глобальные переменные программы. Первый набор (строки 10–13) для опций и сообщений об ошибках. Строка 15 объявляет pattern, в которой хранится откомпилированный шаблон. Строки 17–19 объявляют другие функции программы.
21 /* main – обработка опций, открывание файлов */
22
23 int main(int argc, char **argv)
24 {
25 int с;
26 int i;
27 FILE *fp;
28
29 myname = argv[0];
30 while ((c = getopt(argc, argv, ":iE")) != -1) {
31 switch (c) {
32 case 'i':
33 ignore_case = 1;
34 break;
35 case 'E':
36 extended = 1;
37 break;
38 case '?':
39 usage();
40 break;
41 }
42 }
43
44 if (optind == argc) /* проверка исправности */
45 usage();
46
47 compile_pattern(argv[optind]); /* компилировать шаблон */
48 if (errors) /* ошибка компиляции */
49 return 1;
50 else
51 optind++;
В строке 29 устанавливается значение myname, а строки 30–45 анализируют опции. Строки 47–51 компилируют регулярное выражение, помещая результаты в pattern, compilе_раttern() увеличивает значение errors, если была проблема. (Соединение функций посредством глобальной переменной, как здесь, обычно считается плохой манерой. Для небольших программ, подобным этой, это сойдет, но для более крупных программ такое сопряжение может стать проблемой.) Если не было ошибок, строка 51 увеличивает значение optind так, что оставшиеся аргументы представляют файлы для обработки.
53 if (optind == argc) /* файлов нет, по умолчанию stdin */
54 process("standard input", stdin);
55 else {
56 /* цикл с файлами */
57 for (i = optind; i < argc; i++) {
58 if (strcmp(argv[i], "-") == 0)
59 process("standard input", stdin);
60 else if ((fp = fopen(argv[i], "r")) != NULL) {
61 process(argv[i], fp);
62 fclose(fp);
63 } else {
64 fprintf(stderr, "%s: %s: could not open: %sn",
65 argv[0], argv[i], strerror(errno));
66 errors++;
67 }
68 }
69 }
70
71 regfree(&pattern);
72 return errors != 0;
73 }
Строки 53–69 обрабатывают файлы, отыскивая соответствующие шаблону строки. Строки 53–54 обрабатывают случай, когда файлы не указаны: программа читает со стандартного ввода. В противном случае, строки 57–68 обрабатывают в цикле файлы. Строка 58 обрабатывает особый случай '-', обозначающий стандартный ввод, строки 60–62 обрабатывают обычные файлы, а строки 63–67 обрабатывают ошибки.
75 /* compile_pattern – компиляция шаблона */
76
77 void compile_pattern(const char *pat)
78 {
79 int flags = REG_NOSUB; /* информация о месте совпадения не требуется */
80 int ret;
81 #define MSGBUFSIZE 512 /* произвольно */
82 char error[MSGBUFSIZE];
83
84 if (ignore_case)
85 flags |= REG_ICASE;
86 if (extended)
87 flags |= REG_EXTENDED;
88
89 ret = regcomp(&pattern, pat, flags);
90 if (ret != 0) {
91 (void)regerror(ret, &pattern, error, sizeof error);
92 fprintf(stderr, "%s: pattern '%s': %sn", myname, pat, error);
93 errors++;
94 }
95 }
Строки 75–95 определяют функцию compile_pattern(). Она сначала устанавливает REG_NOSUB в flags, поскольку нам нужно знать лишь «подходит ли строка?», а не «где в строке располагается подходящий текст?»
Строки 84-85 добавляют дополнительные флаги в соответствии с опциями командной строки. Строка 89 компилирует шаблон, а строки 90–94 сообщают о возникших ошибках
97 /* process – читает строки текста и сопоставляет их с шаблоном */
98
99 void process(const char *name, FILE *fp)
100 {
101 char *buf = NULL;
102 size_t size = 0;
103 char error[MSGBUFSIZE];
104 int ret;
105
106 while (getline(&buf, &size, fp) != -1) {
107 ret = regexec(&pattern, buf, 0, NULL, 0);
108 if (ret != 0) {
109 if (ret != REG_NOMATCH) {
110 (void)regerror(ret, &pattern, error, sizeof error);
111 fprintf(stderr, "%s: file %s: %sn", myname, name, error);
112 free(buf);
113 errors++;
114 return;
115 }
116 } else
117 printf("%s: %s", name, buf); /* вывести подходящие строки */
118 }
119 free(buf);
120 }
Строки 97–120 определяют функцию process(), которая читает файл и выполняет сопоставление с регулярным выражением. Внешний цикл (строки 106–119) читает строки ввода. Для избежания проблем с длиной строки мы используем getline() (см. раздел 3.2.1.9 «Только GLIBC: чтение целых строк: getline() и getdelim()»). Строка 107 вызывает regexec(). Ненулевое возвращаемое значение означает либо неудачное сопоставление, либо какую-нибудь другую ошибку. Строки 109–115 соответственно проверяют REG_NOMATCН и выводят ошибку лишь тогда, когда возникла какая-нибудь другая проблема – неудачное сопоставление не является ошибкой
Если возвращаемое значение равно 0, строка совпала с шаблоном и соответственно строка 117 выводит имя файла и совпавшую строку.
122 /* usage – вывод сообщения об использовании и выход */
123
124 void usage(void)
125 {
126 fprintf(stderr, "usage: %s [-i] [-E] pattern [ files ... ]n", myname);
127 exit(1);
128 }
Функция usage() выводит сообщение об использовании и завершает программу. Она вызывается, когда предоставлены недействительные аргументы или не предоставлен шаблон (строки 38–40 и 44–45).
Вот и все! Скромная, но тем не менее полезная версия grep в 130 строк кода.
1. Programming Pearls, 2nd edition, by Jon Louis Bentley Addison-Wesley, Reading, Massachusetts, USA, 2000. ISBN– 0-201-65788-0. См. также веб-сайт этой книги.[131]131
http://www.cs.bell-labs.com/cm/cs/pearls/ – Примеч. автора.
[Закрыть]
Проектирование программы с операторами проверки является одной из главных тем в этой книге.
2. Building Secure Software How to Avoid Security Problems the Right Way, by John Viega and Gary McGraw Addison-Wesley, Reading, Massachusetts, USA, 2001. ISBN: 0-201-72152-X.
Состояния гонки являются одной из многих проблем, о которых нужно побеспокоиться при написании безопасного программного обеспечения. Другой проблемой являются случайные числа. Данная книга рассматривает наряду с другими обе эти проблемы (Мы упоминали о ней в предыдущей главе.)
3. The Art of Computer Programming. Volume 2. Seminumerical Algorithms, 3rd edition, by Donald E. Knuth Addison-Wesley, Reading, Massachusetts, USA, 1998. ISBN– 0-201-89684-2.[132]132
Русский перевод: Дональд E. Кнут. Искусство программирования. Том 2. Получисленные алгоритмы (3-е издание). Москва – Санкт-Петербург – Киев. Вильямс. 2000 – Примеч. науч. ред.
[Закрыть] См также веб-сайт этой книги.[133]133
http://www-cs-faculty.stanford.edu/~knuth/taocp.html – Примеч. автора.
[Закрыть]
Это классическое справочное руководство по генерации случайных чисел.
4. Random Number Generation and Monte Carlo Methods, 2nd edition, by James E. Gentle Springer-Verlag, Berlin, Germany. 2003. ISBN: 0-387-00178-6.
Данная книга широко освещает методы генерации и тестирования псевдослучайных чисел. Хотя для неё также требуется математическая и статистическая подготовка, уровень не такой высокий, как в книге Кнута. (Благодарим Nelson H.F. Beebe за указание этой ссылки.)
5. sed & awk, 2nd edition, by Dale Dougherty and Arnold Robbins. O'Reilly and Associates, Sebastopol, California, USA, 1997. ISBN: 1-56592-225-5.
Эта книга осторожно вводит в регулярные выражения и обработку текста, начиная с grep и продвигаясь к более мощным инструментам sed и awk.
6. Mastering Regular Expressions, 2nd edition, by Jeffrey E.F. Friedl. O'Reilly and Associates, Sebastopol, California, USA, 2002.[134]134
Русский перевод – Дж. Фридл. Регулярные выражения (2-е издание). C.-Петербург, Питер, 2003 – Прим. науч. ред.
[Закрыть] ISBN: 0-59600-289-0.
Регулярные выражения являются важной частью Unix. Чтобы научиться заменять, вырезать и распределять текст с использованием регулярных выражений, мы рекомендуем эту книгу
7. Руководство для GNU grep также объясняет регулярные выражения. На системе GNU/Linux для просмотра локальной копии вы можете использовать 'info grep'. Или использовать браузер для прочтения онлайн-документации проекта GNU для grep.[135]135
http://www.gnu.org/software/grep/doc/grep.html – Примеч. автора.
[Закрыть]
• Операторы проверки предоставляют способ сделать утверждения о предполагаемом состоянии программы. Они являются полезным инструментом для проектирования и отладки и обычно должны оставаться в коде изделия. Однако, будьте внимательны, чтобы не перепутать операторы проверки с проверками возможных ошибок времени исполнения.
• Функции memXXX() являются аналогичными более известным функциям strXXX(). Самой большой их ценностью является то. что они могут работать с двоичными данными; нулевые байты не отличаются от других байтов. Больше известна memcpy() против memmove(), обрабатывающей перекрывающиеся копии.
• Временные файлы полезны во многих приложениях. Функции API tmpfile() и mkstemp() являются предпочтительными способами создания временных файлов, в то же время позволяя избежать состояния гонки и связанных с ней проблем безопасности. Многие программы для указания местоположения своих временных файлов используют переменную окружения TMPDIR, а если она не определена, приемлемое значение по умолчанию (обычно /tmp). Это хорошее соглашение, которое следует принять на вооружение в своих программах.
• Функция abort() посылает вызывающему процессу сигнал SIGABRT. Результатом является завершение процесса и создание дампа ядра, предположительно для отладки.
• setjmp() и longjmp() обеспечивают нелокальный переход. Это мощная возможность, которая должна использоваться с осторожностью. sigsetjmp() и siglongjmp() сохраняют и восстанавливают маску сигналов процесса, когда программа осуществляет нелокальный переход. Проблемы с нелокальными переходами иногда перевешивают их преимущества, соответственно используйте эти процедуры лишь когда нет лучшего способа структурировать ваше приложение.
• Случайные числа полезны для множества приложений. Большинство программ используют псевдослучайные числа – последовательности номеров, которые кажутся случайными, но которые могут быть воспроизведены с помощью одного и того же начального значения. rand() и srand() являются первоначальными функциями API, стандартизованными языком С. На многих системах rand() использует низкокачественный алгоритм, random() и srandom() используют лучший алгоритм, включены в стандарт POSIX и являются предпочтительными по сравнению с rand() и srand(). Используйте специальные файлы /dev/random и /dev/urandom, если (а) они доступны и (б) если вам нужны случайные числа высокого качества.
• Три функции API предоставляют все более мощные возможности для развертывания метасимволов (подстановки символов).
• fnmatch() является простейшей, возвращающей true/false, если данная строка соответствует или не соответствует шаблону символов подстановки оболочки.
• glob() просматривает файловую систему, возвращая список путей, которые соответствуют данному шаблону. Когда требуются стандартные возможности glob(), следует использовать эту функцию. Хотя GLIBC версия glob() имеет некоторые расширения, переносимые программы, которым нужны дополнительные возможности, должны вместо этого использовать wordexp(). (Программы, которые будут работать лишь на системах GNU/Linux, не должны стесняться использовать полную мощь GLIBC glob().)
• wordexp() не только делает то, что делает glob(), но также выполняет полное развертывание слов в стиле оболочки, включая развертывание тильды, развертывание переменных оболочки и подстановку команд.
• Функции regcomp() и regexec() обеспечивают доступ к базовым и расширенным регулярным выражениям POSIX. Используя одну из этих функций, можно заставить свою программу вести себя идентично со стандартными утилитами, значительно упрощая использование программы пользователями, знакомыми с GNU/Linux и Unix.
