руководство пользователя для gnu awk
15. библиотека функций awk
эта глава представляет библиотеку полезных функций awk. в примерах программ, представленных ниже, (см. главу 16 [практические awk-программы], стр.205) используются эти функции. функции здесь представлены в порядке от простых к сложным. раздел 16.2.7 [извлечение программ из файлов texinfo source], стр. 238, представляет программу, которую можно использовать для извлечения исходного кода этих примеров библиотечных функций и программ из texinfo source для этой книги. (это было уже сделано как часть распространения gawk. если вы написали одну или более полезных awk-функций общего назначения и готовы предложить их для издания в этой книге, вступите в контакт с ее автором. см. раздел b.7 [сообщения о проблемах и ошибках], стр. 292, для информации о том, как это сделать. не ограничивайтесь только посылкой кода, когда вам предложат поместить его в область публичного доступа, опубликовать в рамках gpl (см. [gnu general public license], стр. 309), или передать copyright в free software foundation. 15.1 моделирование специальных свойств gawkпрограммы в этой главе и в главе 16 [практические программы awk], стр. 205, используют возможности, специфичные для gawk. в этой главе коротко обсуждается, как вы можете переписать эти программы для других различных реализаций awk. диагностические сообщения об ошибках посылаются в `/dev/stderr'. пишите `| "cat 1>&2"' вместо `> "/dev/stderr"', если ваша система не имеет `/dev/stderr', или если не можете использовать gawk. некоторые программы используют nextfile (см. раздел 9.8 [оператор nextfile], стр. 112), для пропуска остатка ввода в входном файле. раздел 15.2 [реализация nextfile как функции], стр. 170, показывает, как написать функцию, которая делает то же самое. наконец, некоторые программы предпочитают игнорировать различие верхнего и нижнего регистров в своем вводе. они делают это присваиванием единицы переменной ignorecase. тот же самый эффект можно получить, добавив следующее правило к началу программы: # ignore case { $0 = tolower($0) }проверьте также, что все константы regexp и строковые константы, используемые в сравнениях, состоят только из букв нижнего регистра. 15.2 реализация nextfile как функцииоператор nextfile, описанный в разделе 9.8 [оператор nextfile], стр. 112, есть специальное расширение gawk. он недоступен в других реализациях awk. в настоящем разделе приведены две версии функции nextfile, которые можно использовать для моделирования соответствующего оператора gawk, если невозможно использовать gawk.
вот первая попытка написать функцию nextfile.
# nextfile --- пропустить оставшиеся записи в текущем файле
# это должно быть прочитано до "главной" программы awk
function nextfile() { _abandon_ = filename; next }
_abandon_ == filename { next }
этот файл должен быть вставлен перед главной программой, потому что он содержит правило, которое должно выполняться c самого начала. это правило сравнивает имя текущего файла данных (которое всегда находится в переменной filename) с индивидуальной переменной, названной _abandon_. если имя файла соответствует, то действие правила выполняет оператор next, то есть перейти к следующей записи. (употребление `_' в имени перемененной есть соглашение. оно подробнее обсуждается в разделе 15.13 [наименование глобальных переменных библиотечных функций], стр. 202). использование оператора next фактически создает цикл, который читает все записи из текущего файла с данными. в итоге достигается конец файла и открывается новый файл с данными, изменяющий значение filename. когда это произойдет, сравнение _abandon_ с filename выдает false и выполнение продолжается с первого правила "реальной" программы. сама функция nextfile просто устанавливает значение _abandon_ и затем выполняет оператор next для запуска цикла.1 эта начальная версия имеет некоторую неточность. что произойдет, если тот же самый файл с данными указан дважды в командной строке, два раза подряд, или даже с присваиванием значения переменной между двумя указаниями имени файла? в таком случае программа пропустит второй файл, даже если она должна остановиться, когда достигнет конец первого из указанных. вот вторая версия nextfile, которая решает эту проблему. 1 некоторые реализации awk не позволяют вам выполнять next внутри тела функции. необходимы какие-то другие приемы, если вы используете такую версию.
# nextfile --- пропустить оставшиеся в текущем файле записи
# правильно обрабатывать последовательные появления того же файла
# arnold robbins, arnold@gnu.org, public domain
# may, 1993
# это должно быть прочтено до "главной" awk-программы
function nextfile() { _abandon_ = filename; next }
_abandon_ == filename {
if (fnr == 1)
_abandon_ = ""
else
next
}
действия nextfile не меняются. она устанавливает _abandon_ равным текущему имени файла и выполняет оператор next. он читает следующую запись и увеличивает fnr, так что fnr получает по крайней мере значение два. однако, если nextfile вызван для последней записи в файле, то awk закроет текущий файл с данными и перейдет к следующему. при этом filename получит значение имени нового файла и fnr получит значение один. если этот следующий файл есть тот же, что и предыдущий, _abandon_ будет еще равно filename. однако, fnr будет равно единице, говоря нам, что мы имеем дело с новым файлом, не тем, который читали при выполнении функции nextfile. в этом случае _abandon_ получает значение пустой цепочки, дальнейшего выполнения этого правила не происходит (пока nextfile не будет вызвана в следующий раз). если же fnr имеет значением не единицу, то мы еще находимся в прежнем файле и программа выполняет оператор next для пропуска его конца. важным вопросом в этой точке будет такой: "если действия nextfile моделируются библиотечной функцией, зачем этот оператор встроен в gawk?" это действительно важный вопрос. дополнительные свойства при малой надобности приводят к более сложной и медленной программе, которую труднее поддерживать. ответ состоит в том, что встраивание nextfile в gawk дает значительный выигрыш в эффективности. если функция nextfile выполняется в начале большого файла, awk будет сканировать весь файл, расщепляя его на записи, чтобы пропустить его обработку. встроенный оператор nextfile может просто закрыть немедленно файл и перейти к следующему, экономя много времени. это особенно важно в awk, поскольку awk-программы обычно ориентированы на i/o (т.е. они большую часть времени тратят на ввод и вывод, а не на вычисления. 15.3 контрольпри написании больших программ часто полезно быть в состоянии проверить, что некоторое условие или множество условий соблюдаются. перед переходом к некоторым вычислениям следует проверить, что перед вами лежит именно нужный случай. такие операторы называются "утверждениями" ("assertion"). в языке си есть файлы с заголовком !assert.h? и соответствующие макро assert, которые программист может использовать для утверждений. если утверждение ложно, макро assert печатает диагностическое сообщение, описывающее нарушенное условие, и убивает программу. в си, использование утверждения выглядит так:
#include
язык ansi c дает возможность превратить условие в цепочку для печати диагностики. это невозможно в awk, так что здесь функция assert требует цепочечную версию проверяемого условия.
# assert --- подтвердить что условие выполнено. иначе exit.
# arnold robbins, arnold@gnu.org, public domain
# may, 1993
function assert(condition, string)
{
if (! condition) {
printf("%s:%d: assertion failed: %s\n",
filename, fnr, string) > "/dev/stderr"
_assert_exit = 1
exit 1
}
}
end {
if (_assert_exit)
exit 1
}
функция assert проверяет параметр condition. если оно дает false, она печатает сообщение в standard error, используя цепочку string для описания ошибки. затем устанавливает переменную _assert_exit в единицу и выполняет оператор exit, который передает управление в правило end. если правила end находят, что _assert_exit есть true, происходит немедленный выход. назначение правила end с тестом --- удержать от выполнения всякие другие end. когда assertion выдает false, программа должна немедленно заканчиваться. если ни один assertion не выдает fflse, то _assert_exit остается со значением false, когда правило end выполняется нормально и остаток программных правил end будет выполнен. чтобы все это работало правильно, `assert.awk' должен быть первым входным файлом, прочтенным awk.
вы должны использовать эту функцию в своих программах следующим образом:
function myfunc(a, b)
{
assert(a <= 5 && b >= 17.1, "a <= 5 && b >= 17.1")
...
}
если assertion потерпит неудачу, вы получите сообщение:
mydata:1357: assertion failed: a <= 5 && b >= 17
проблема с этой версией assert в том, что она может не сработать со стандартным awk. правило end автоматически добавляется к программе, вызывающей assert. обычно, если программа состоит только из правила begin, то входные файлы и/или стандартный ввод не читаются. однако теперь, когда программа имеет правило end, awk будет пытаться прочесть входные файлы с данными или стандартный ввод (см. раздел 8.1.5.1 [стартовые и завершающие действия], стр. 100), очень вероятно, что программа зависнет, ожидая ввода. 15.4 округление чиселспособ округления в printf и sprintf (см. раздел 6.5 [употребление операторов printf для декоративной печати], стр. 64) часто зависит от подпрограммы sprintf системы си. на многих машинах sprintf округляет "unbiased " ("беспристрастно"), что означает, что округление при отбрасывании `.5' не всегда происходит с избытком, в противоположность наивному ожиданию. при беспристрастном округлении `.5' округляется до четного, а не всегда с избытком, так что 1.5 округляется до 2, а 4.5 до 4. в результате если вы пользуетесь форматом без округления (например, "%.0f"), вы должны проверять, что делает ваша система. следующая функция округляет традиционно; она может оказаться полезной, если ваша awk printf округляет беспристрастно.
# round --- делать нормальное округление
# # arnold robbins, arnold@gnu.org, august, 1996
# public domain
function round(x, ival, aval, fraction)
{
ival = int(x) # integer part, int() truncates
# see if fractional part
if (ival == x) # no fraction
return x
if (x < 0) {
aval = -x # absolute value
ival = int(aval)
fraction = aval - ival
if (fraction >= .5)
return int(x) - 1 # -2.5 --> -3
else
return int(x) # -2.3 --> -2
} else {
fraction = x - ival
if (fraction >= .5)
return ival + 1
else
return ival
}
}
# для проверки
{ print $0, round($0) }
15.5 перевод символов в числовой кододна из коммерческих реализаций awk имеет встроенную функцию ord, которая получает символ и возвращает численное значение этого символа в машинном множестве символов. если цепочка, переданная ord, содержит более одного символа, используется только первый из них. обратная функция есть chr (аналогична функции с тем же именем в паскале), которая получает число и возвращает символ. обе функции могут быть просто написаны в awk; нет существенных причин для встраивания их в интерпретатор.
# ord.awk --- делает ord и chr # # глобальными идентификаторами:
# _ord_: численное значение символа
# _ord_init: функция инициализации _ord_
# # arnold robbins # arnold@gnu.org # public domain # 16 january, 1992
# 20 july, 1992, revised
begin { _ord_init() }
function _ord_init( low, high, i, t)
{
low = sprintf("%c", 7) # bel is ascii 7
if (low == "\a") { # regular ascii
low = 0
high = 127
} else if (sprintf("%c", 128 + 7) == "\a") {
# ascii, mark parity
low = 128
high = 255
} else { # ebcdic(!)
low = 0
high = 255
}
for (i = low; i <= high; i++) {
t = sprintf("%c", i)
_ord_[t] = i
}
}
следует дать некоторые объяснения о числах, используемых в chr. наиболее известное сейчас множество символов есть ascii. хотя восьмибитовый байт может иметь 256 различных значений (от нуля до 255), ascii определяет только символы со значениями от 0 до 127. *2* по крайней мере один изготовитель компьютеров, которого мы знаем, использует ascii с отмеченной четностью, означающей, что самый левый бит в байте имеет всегда значение 1. это значит, что на таких системах 2 ascii используется во многих странах для представления в значениях от 128 до 255 специальных символов этой страны. если ваша система использует такое расширение, вы можете упростить _ord_init до простого цикла от 0 до 255. символы имеют численное значение от 128 to 255. наконец, большие универсальные системы используют систему символов ebcdic, которая использует все 256 значений. хотя на некоторых старых системах используются другие множества символов, о них не стоит говорить.
function ord(str, c)
{
# интерес представляет только первый символ
c = substr(str, 1, 1) return .ord.[c]
}
function chr(c)
{
# превращайте с в число добавлением 0
return sprintf("%c", c + 0)
}
#### test code ####
# begin \
# {
# for (;;) {
# printf("enter a character: ")
# if (getline var <= 0)
# break
# printf("ord(%s) = %d\n", var, ord(var))
# }
# }
очевидным усовершенствованием для этих функций было бы перенести код функции _ord_init в тело правила begin. это и было так написано первоначально для облегчения разработки. имеется и "тестовая программа" в правиле begin для проверки функции. она превращена в комментарий для увеличения производительности. 15.6 соединение компонент массива в цепочкупри обработке цепочек часто оказывается удобным соединить все цепочки в массиве в одну длинную цепочку. следующая функция, join , выполняет эту задачу. она используется далее в нескольких прикладных программах (см. главу 16 [практические awk-программы], стр. 205). важно хорошо спланировать эту функцию; она должна быть общей, но должна также иметь разумное поведение по умолчанию. она вызывается с массивом и начальным и конечным индексами для объединяемых элементов массива. тем самым предполагается, что индексы являются числами -- разумное предположение, поскольку массив, вероятно, создавался с split (см. раздел 12.3 [встроенные функции для действий с цепочками], стр. 137).
# join.awk --- join an array into a string
function join(array, start, end, sep, result, i)
{
if (sep == "")
sep = " "
else if (sep == subsep) # magic value
sep = ""
result = array[start]
for (i = start + 1; i <= end; i++)
result = result sep array[i]
return result
}
необязательный дополнительный аргумент есть сепаратор для использования при соединении цепочек в одну цепочку. если в вызове указано непустое значение, то join использует его. если такового нет, он считается пустым. в таком случае join использует один пробел как сепаратор по умолчанию. если указанное значение равно subsep, то join соединяет цепочки без сепараторов между ними. subsep служит как "магическое" значение для указания того, что не должно быть никаких сепараторов между цепочками-компонентами. было бы очень хорошо, если бы awk имел оператор присваивания для конкатенации. отсутствие явного оператора для конкатенации делает операции над цепочками более трудными, чем они должны быть на самом деле. 15.7 превращения дат в отметки временифункция systime, встроенная в gawk, возвращает текущее время дня как отметку времени в секундах от начала века. эта отметка может быть превращена в пригодную для печати дату в одном из множества форматов с помощью встроенной функции strftime. (подробности о systime и strftime см. в разделе 12.5 [функции для действий с отметками времени], стр. 148.) интересную и трудную проблему представляет превращение читаемого представления обратно в отметку времени. библиотека ansi cи имеет функцию mktime, которая делает основную работу превращения канонического представления даты в отметку времени. с первого взгляда может показаться, что gawk должна иметь встроенную функцию mktime, которая копирует версию языка си. приведем версию mktime для awk. она берет простое представление даты и времени и сворачивает их в метку времени. код, представленный здесь, перемешан с словесными пояснениями. в разделе 16.2.7 [извлечение программ из файлов texinfo source], стр. 238, вы увидите, как должен обрабатываться файл texinfo source этой книги для извлечения кода в отдельный исходный файл. программа начинается с описывающего комментария и правила begin, которое инициализирует таблицу _tm_months. эта таблица есть двумерный массив, содержащий длины месяцев. первый индекс есть 0 для регулярных годов и 1 для високосных. значения длин одинаковы для годов обоих типов, за исключением февраля; поэтому нужно использовать кратное присваивание.
# mktime.awk --- преобразует каноническое представление даты
# в отметку времени# arnold robbins, arnold@gnu.org, public domain # may 1993
begin \
{
# инициализация таблицы длин месяцев
_tm_months[0,1] = _tm_months[1,1] = 31 _tm_months[0,2] = 28;
_tm_months[1,2] = 29 _tm_months[0,3] = _tm_months[1,3] = 31
_tm_months[0,4] = [1,4] = 30 _tm_months[0,5] = _tm_months[1,5] = 31
_tm_months[0,6] = _tm_months[1,6] = 30 _tm_months[0,7] = _tm_months[1,7] = 31
_tm_months[0,8] = _tm_months[1,8] = 31 _tm_months[0,9] = _tm_months[1,9] = 30
_tm_months[0,10] = _tm_months[1,10] = 31
_tm_months[0,11] = _tm_months[1,11] = 30
_tm_months[0,12] = _tm_months[1,12] = 31
}
польза от смешивания кратных правил begin (см. раздел 8.1.5 [специальные образцы begin and end], стр. 100) особенно очевидна при написании библиотечных файлов. функции в библиотечных файлах правильно инициализируют их частные данные и также обеспечивают завершающие действия в частных правилах end. следующая простая функция вычисляет, является или нет данный год високосным. если год точно делится на 4, но не делится на 100 или если он точно делится на 400, то это високосный год, 1900 не был, а 2000 будет високосным.
# определяет високосность года
function _tm_isleap(year, ret)
{
ret = (year % 4 == 0 && year % 100 != 0) ||
(year % 400 == 0)
return ret
}
эта функция используется только несколько раз в этом файле, и операторы, входящие в нее, могли бы быть выписаны в каждой точке, где она используется. выделение ее в отдельную функцию облегчает настоящее изложение и также помогает избежать ошибки набора при повторении кода в нескольких местах. следующая функция более интересна. она делает большую часть работы timestamp, которая превращает дату и время в число секунд с начала века. вызов передает массив, (не очень удачно названный a), содержащий 6 значений: год со столетиями, месяц как число между 1 и 12, день месяца, час как число между 0 и 23, минуты в часе и секунды в пределах одной минуты. функция использует несколько локальных переменных для предвычисления количества секунд в часе, секунд в дне и секунд в году. часто в подобных си-кодах просто пишут выражения друг за другом, ожидая, что компилятор заменит их константами. например, большинство си-компиляторов превратят `60 * 60' в `3600' во время компиляции вместо пере вычисления их каждый раз при выполнении программы. предвычисление этих значений делает функцию более эффективной.
# перевести дату в секунды
function _tm_addup(a, total, yearsecs, daysecs,hoursecs, i, j)
{
hoursecs = 60 * 60 daysecs = 24 * hoursecs yearsecs = 365 * daysecs
total = (a[1] - 1970) * yearsecs
# лишний день для високосных годов for (i = 1970; i ! a[1]; i++)
if (_tm_isleap(i))
total += daysecs
j = _tm_isleap(a[1]) for (i = 1; i < a[2]; i++)
total += _tm_months[j, i] * daysecs
total += (a[3] - 1) * daysecs total += a[4] * hoursecs
total += a[5] * 60 total += a[6]
return total
}
функция сначала находит приближенное значение числа секунд между полночью 1 января 1970 года *3* и началом текущего года. затем просматривает эти годы и для каждого високосного года добавляет дневную порцию секунд. переменная j есть 0 или 1 , если текущий год соответственно високосный или нет. для каждого месяца в текущем году (до текущего месяца) добавляется число секунд в месяце с помощью соответствующего элемента в массиве _tm_months. наконец, добавляется в секундах количество дней до текущего дня и часы, минуты и секунды текущего дня. в результате получаем количество секунд, истекших с 1 января 1970 года. это значение --- еще не то, что нужно. опишем коротко, почему. главная функция mktime берет один аргумент --- цепочку символов. эта цепочка представляет дату и время в "канонической" форме. она должна быть "год месяц день час минуты секунды".
# mktime --- превращение даты в секунды,
# компенсация на часовой пояс
function mktime(str, res1, res2, a, b, i, j, t, diff)
{
i = split(str, a, " ") # не полагайтесь на fs
if (i != 6)
return -1
# превращение в число
for (j in a) a[j] += 0
}
3 это начало века в системах posix systems. оно может быть другим в других системах.
# проверка
if (a[1] < 1970 || a[2] < 1 || a[2] > 12 || a[3] < 1 || a[3] > 31 || a[4] < 0 ||
a[4] > 23 || a[5] < 0 || a[5] > 59 || a[6] < 0 || a[6] > 60 )
return -1
res1 = _tm_addup(a) t = strftime("%y %m %d %h %m %s", res1)
if (_tm_debug)
printf("(%s) -? (%s)\n", str, t) > "/dev/stderr"
split(t, b, " ") res2 = _tm_addup(b)
diff = res1 { res2 if (_tm_debug)
printf("diff = %d seconds\n", diff) > "/dev/stderr"
res1 += diff return res1 }
функция сначала разделяет цепочку в массив, используя пробелы и tab в качестве сепараторов. если в массиве оказываются не 6 элементов, она возвращает ошибку, указанную как значение \gamma 1. затем превращает каждый элемент массива в число, добавляя к ним 0. следующий оператор `if' проверяет, находится ли каждый элемент в допустимых границах. (эта проверка может быть расширена, например, проверкой того, что день месяца соответствует размерам указанного месяца.) все это по существу представляет предварительную подготовку и проверку на ошибки. вспомним, что _tm_addup дает время в секундах с полночи 1 января 1970 года. эта величина не представляет непосредственно желаемый результат, поскольку вычисление не принимало в расчет часовой пояс. другими словами, полученное значение представляет время в секундах, прошедшее с начала века, но только для utc (универсального координированного времени). если местный часовой пояс лежит к востоку или западу от utc, то некоторое количество часов должно быть добавлено или вычтено из полученной отметки времени. например, 6:23 p.m. в атланте, georgia (usa), нормально на 5 часов западнее (позже) utc. это только на 4 часа позже utc, если введено декретное время. если вы вызываете mktime в атланте с аргументом "1993 5 23 18 23 12", результат от _tm_addup будет выдан для 6:23 p.m. utc, что соответствует только 2:23 p.m. в атланте. необходимо добавить еще 4 часа в секундах для правильного результата. как mktime может определить свое отличие от utc? это на удивление легко. выданная отметка времени представляет время, переданное в mktime как utc. эта отметка должна быть передана опять в strftime, которая превратит ее в местное время; то есть, как будто разница с utc уже добавлена к ней. это делается посредством передачи "%y %m %d %h %m %s" в strftime в качестве аргумента format. она возвратит отмету времени в исходном строчном формате. результат представляет время, которое учитывает разность с utc. когда новое время будет опять превращено в отметку времени, разность между двумя отметками будет разностью (в секундах) между местным временем и utc. эта разность добавляется к полученному ранее результату. демонстрирующий это пример приведен ниже.
наконец, имеется "главная" программа для проверки функции:
begin {
if (_tm_test) {
printf "enter date as yyyy mm dd hh mm ss: " getline _tm_test.date
t = mktime(_tm_test.date) r = strftime("%y %m %d %h %m %s", t) printf
"got back (%s)\n", r } }
вся программа использует две переменных, которые могут быть заданы из командной строки, для управления отладочным выходом и запуска теста в конечном правиле begin. вот результат пропуска теста. (заметим, что отладочный выход идет как стандартная ошибка, а выход теста направлен в стандартный выход). $ gawk -f mktime.awk -v _tm_test=1 -v _tm_debug=1 -| enter date as yyyy mm dd hh mm ss: 1993 5 23 15 35 10 error (1993 5 23 15 35 10) -> (1993 05 23 11 35 10) error diff = 14400 seconds -| got back (1993 05 23 15 35 10) введенное время составляло 3:35 p.m. (15:35 по 24-часовым часам), 23 мая 1993 года. первая строка отладочного выхода показывает результат как время utc-- на четыре часа перед локальным часовым поясом. вторая строка показывает, что разность составляет 14400 секунд, т.е. четыре часа. (разность только четыре часа, поскольку в мае действует декретное время.) последняя строка выхода теста показывает, что алгорифм компенсации на часовой пояс работает; возвращенное время совпадает с введенным. эта программа не решает общую проблему преобразования произвольного представления даты в отметку времени. эта проблема очень запутанная. однако функция mktime дает фундамент для ее решения. другие программы должны заменять имена месяцев числами и время am/pm в 24-часовые данные для генерирования канонического формата, требуемого mktime. 15.8 представление текущего временифункции systime и strftime, описанные в разделе 12.5 [функции для действий с метками времени], стр. 148, обеспечивают минимум усилий, необходимых для действий с временем в удобной для чтения форме. хотя strftime и велика, управляющие форматы не необходимо запоминать или понимать при чтении программы. следующая функция, gettimeofday, заполняет данный пользователем массив пред форматированной временной информацией. она возвращает цепочку с текущим временем в том же формате как и утилиты даты.
# gettimeofday --- выдать время дня в обычном формате
# arnold robbins, arnold@gnu.org, public domain, may 1993
# # возвращает цепочку в формате выхода date(1)
# заполняет массив аргументов времени индивидуальными значениями:
# time["second"] -- секунды (0 - 59) # time["minute"] -- минуты (0 - 59)
# time["hour"] -- часы (0 - 23) # time["althour"] -- часы (0 - 12)
# time["monthday"] -- день месяца (1 - 31)
# time["month"] -- месяц года (1 - 12)
# time["monthname"] -- имя месяца
# time["shortmonth"] -- сокращенное имя месяца
# time["year"] -- год в пределах века (0 - 99)
# time["fullyear"] -- год со столетиями (19xx or 20xx)
# time["weekday"] -- день недели (воскресенье = 0)
# time["altweekday"] -- день недели (понедельник = 0)
# time["weeknum"] -- номер недели, воскресенье первый день
# time["altweeknum"] -- номер недели, понедельник первый день
# time["dayname"] -- имя дня недели
# time["shortdayname"] -- сокращенное имя дня недели
# time["yearday"] -- день в году (0 - 365)
# time["timezone"] -- сокращение для time
function gettimeofday(time, ret, now, i) -
# выдает время сразу, избегая не необходимых обращений к системе
now = systime()
# возвращает вывод типа date(1)
ret = strftime("%a %b %d %h:%m:%s %z %y", now)
# чистка выходного массива
for (i in time) delete time[i]
# заполнение его значениями, числовые цепочки превращаются в числа
# добавлением 0
time["second"] = strftime("%s", now) + 0
time["minute"] = strftime("%m", now) + 0
time["hour"] = strftime("%h", now) + 0
time["althour"] = strftime("%i", now) + 0
time["monthday"] = strftime("%d", now) + 0
time["month"] = strftime("%m", now) + 0
time["monthname"] = strftime("%b", now)
time["shortmonth"] = strftime("%b", now)
time["year"] = strftime("%y", now) + 0
time["fullyear"] = strftime("%y", now) + 0
time["weekday"] = strftime("%w", now) + 0
time["altweekday"] = strftime("%u", now) + 0
time["dayname"] = strftime("%a", now)
time["shortdayname"] = strftime("%a", now)
time["yearday"] = strftime("%j", now) + 0
time["timezone"] = strftime("%z", now)
time["ampm"] = strftime("%p", now)
time["weeknum"] = strftime("%u", now) + 0
time["altweeknum"] = strftime("%w", now) + 0
return ret ""
цепочки-индексы легче использовать и читать, чем различные форматы, требуемые для strftime. программа alarm, представленная в разделе 16.2.2 [программа-будильник], стр.228, использует эту функцию. функция gettimeofday, представлена выше в той форме в какой была написана. более общая форма этой функции должна снабжать пользователя по выбору отметкой времени, которая могла бы использоваться вместо текущего времени. 15.9 отметка границ файлов с даннымиправила из begin и end каждое вычисляются только один раз, в начале и в конце awk-программ (см. раздел 8.1.5 [специальные образцы begin и end], стр. 100). мы (авторы gawks) однажды встретили пользователя, который ошибочно полагал, что правило begin должно выполняться при начале каждого файла с данными, а end --- в конце каждого файла. когда ему объяснили, что дело обстоит не так, он попросил, чтобы в gawk добавили новые специальные образцы, называемые begin.file end.file с желаемым им поведением. он даже снабдил нас кодом, реализующим эти действия. после некоторых раздумий, я вышел с следующей библиотечной программой. она организует вызов написанных пользователем функций, beginfile и endfile, в начале и конце каждого файла с данными. кроме решения проблемы посредством только девяти(!) строк кода, она переносима: работает с любой реализацией awk.
# transfile.awk # # дает пользователю возможность переноса имени файла #
# пользователь должен определить функции beginfile() и endfile()
#каждая берет имя файла соответственно при старте или окончании
# # arnold robbins, arnold@gnu.org, january 1992 # public domain
filename != .oldfilename \
{
if (_oldfilename != "")
endfile(_oldfilename) _oldfilename = filename beginfile(filename)
}
end { endfile(filename) }
этот файл должен быть загружен перед "главной" программой пользователя, так чтобы правило, которое он содержит, вычислялось первым. это правило полагается на awk-переменную filename, которая автоматически меняется для каждого нового файла с данными. текущее имя файла сохраняется в частной переменной _oldfilename. если filename не равно _oldfilename, то обрабатывается новый файл с данными и необходимо вызывать endfile для старого файла. поскольку endfile должен вызываться только когда обработка файла закончена, программа сначала проверяет, что .oldfilename не пуста. затем программа присваивает имя текущего файла переменной _oldfilename и вызывает beginfile для нового файла. поскольку, подобно всем awk-переменным, _oldfilename инициализируется пустой строкой, это правило правильно выполняется и для первого файла с данными. программа также имеет правило end для завершающей обработки последнего файла. поскольку это правило end приходит перед всеми правилами end в "главной" программе, сначала будет вызвана endfile. и опять значение кратных правил begin end должно быть ясно. эта версия сталкивается с теми же трудностями, что и первая версия nextfile (см. раздел 15.2 [реализация nextfile в виде функции], стр. 170). если один и тот же файл с данными встретится два раза подряд в командной строке, то endfile и beginfile не будут выполняться в конце первого прохода и в начале второго. проблему решает следующая версия.
# ftrans.awk --- обрабатывает переходы файлов с данными
# # пользователь определяет функции beginfile() и endfile()
# # arnold robbins, arnold@gnu.org, november 1992 # public domain
fnr == 1
{
if (_filename_ != "")endfile(_filename_)
_filename_ = filename beginfile(filename) }
end { endfile(_filename_) }
в разделах 16.1.7 [подсчеты], стр. 225, вы увидите, как эти библиотечные функции могут использоваться и как это упрощает написание главной программы. |
| <<< | оглавление | >>> |