Глава 15 - Разбор

Руководство пользователя REBOL/Core
Основное содержание
Отправьте нам отзыв

Содержание:

1. Обзор

При синтаксическом анализе последовательность символов или значений разбивается на более мелкие части. Его можно использовать для распознавания символов или значений, которые встречаются в определенном порядке. Помимо предоставления мощного, удобочитаемого и удобного в обслуживании подхода к сопоставлению с образцом регулярных выражений, синтаксический анализ позволяет вам создавать собственные настраиваемые языки для конкретных целей.

Функция parse имеет общий вид:

parse series rules

Серия аргумента является входом, который разбирается и может быть строка или блок. Если аргумент является строкой, он анализируется по символам. Если аргумент является блоком, он анализируется по значению.

Правила аргумента определяет , как серия будет разобранный аргумент. Правила аргумент может быть строкой для простых типов разбора или блока для сложного анализа.

Функция parse также принимает два уточнения: /all и /case. Уточнение /all разбирает все символы в строке, включая все разделители, такие как пробел, табуляция, перевод строки, запятой и точкой с запятой. Уточнение /case разбирает строку, основанную на случае. Если /case не указан, верхний и нижний регистры обрабатываются одинаково.

2. Простое разделение

Простая форма parse предназначена для разделения строк:

parse string none

Функция parse разбивает входной аргумент, строку, на блок из нескольких строк, разбивая каждую строку там, где она встречается с разделителем, например пробелом, табуляцией, новой строкой, запятой или точкой с запятой. Аргумент none указывает на то, что никакие другие разделители кроме них. Например:

probe parse "The trip will take 21 days" none
["The" "trip" "will" "take" "21" "days"]

По аналогии,

probe parse "here there,everywhere; ok" none
["here" "there" "everywhere" "ok"]

Обратите внимание, что в приведенном выше примере из результирующих строк были удалены запятые и точки с запятой.

Вы можете указать свои собственные разделители во втором аргументе для синтаксического анализа (parse). Например, следующий код анализирует номер телефона с разделителями тире (-):

probe parse "707-467-8000" "-"
["707" "467" "8000"]

В следующем примере в качестве разделителей используется равенство (=) и двойная кавычка ("):

probe parse <IMG SRC="test.gif" WIDTH="123"> {="}
["IMG" "SRC" "test.gif" "WIDTH" "123"]

В следующем примере строка анализируется только на основе запятых; любые другие разделители игнорируются. Следовательно, пробелы внутри строк не удаляются:

Обычно при синтаксическом анализе строк любые пробелы (пробел, табуляция, строки) автоматически обрабатываются как разделители. Чтобы избежать этого действия, вы можете использовать уточнение /any. Сравните эти два примера:

parse "Test This" ""
["Test" "This"]
parse/all "Test This" ""
["Test This"]

Во втором случае вы можете видеть, что пробел не рассматривался как разделитель.

Вот еще один пример:

probe parse/all "Harry, 1011 Main St., Ukiah" ","
["Harry" " 1011 Main St." " Ukiah"]

Вы также можете анализировать строки, содержащие нулевые символы в качестве разделителей (например, определенные типы файлов данных):

parse/all nulled-string "^(null)"

3. Грамматические правила

Функция parse принимает грамматические правила, написанные на диалекте REBOL. Диалекты - это подязыки REBOL, которые используют одну и ту же лексическую форму для всех типов данных, но допускают различный порядок значений внутри блока. В рамках этого диалекта грамматика и словарь REBOL изменены, чтобы сделать его похожим по структуре на хорошо известную BNF (Backus-Naur Form), которая обычно используется для определения языковых грамматик, сетевых протоколов, форматов заголовков и т.д..

Чтобы определить правила, используйте блок, чтобы указать последовательность входных данных. Например, если вы хотите проанализировать строку и вернуть символы "the phone", вы можете использовать правило:

parse string ["the phone"]

Чтобы разрешить любое количество пробелов или отсутствие пробелов между словами, напишите правило следующим образом:

parse string ["the" "phone"]

Вы можете указать альтернативные правила с помощью вертикальной черты (|). Например:

["the" "phone" | "a" "radio"]

принимает строки, соответствующие любому из следующего:

the phone
a radio

Правило может содержать блоки, которые рассматриваются как вспомогательные правила. Следующая строка:

[ ["a" | "the"] ["phone" | "radio"] ]

принимает строки, соответствующие любому из следующего:

a phone
a radio
the phone
the radio

Для повышения удобочитаемости запишите подправила как отдельный блок и дайте им имя, которое поможет указать их цель:

article: ["a" | "the"]
device: ["phone" | "radio"]
parse string [article device]

В дополнение к сопоставлению одного экземпляра строки вы можете указать счетчик или диапазон, который повторяет совпадение. В следующем примере показано количество:

[3 "a" 2 "b"]

который принимает строки, которые соответствуют:

aaabb

В следующем примере представлен диапазон:

[1 3 "a" "b"]

который принимает строки, соответствующие любому из следующего:

ab aab aaab

Начальная точка диапазона может быть нулевой, что означает, что это необязательно.

[0 3 "a" "b"]

принимает строки, соответствующие любому из следующего:

b ab aab aaab

Используйте some, чтобы указать, что совпадают один или несколько символов. Используйте any, чтобы указать, что совпадают ноль или более символов. Например, some используются в следующей строке:

[some "a" "b"]

принимает строки, содержащие один или несколько символов a и b::

ab aab aaab aaaab

В следующем примере используются any:

[any "a" "b"]

который принимает строки, содержащие ноль или более символов a или b:

b ab aab aaab aaaab

Слова some и any также могут использоваться в блоках. Например:

[some ["a" | "b"]]

принимает строки, содержащие любую комбинацию символов a и b.

Другой способ выразить необязательность символа - предоставить альтернативный вариант none:

["a" | "b" | none]

Этот пример принимает строки , которые содержат a или b или none.

Параметр none полезен для указания дополнительных шаблонов или для выявления случаев ошибок, когда ни один шаблон не совпадает.

4. Пропуск ввода

Skip, to и thru слова разрешают вводу быть пропущен.

Используйте skip (пропустить), чтобы пропустить один символ, или используйте его с repeat (повторять), чтобы пропустить несколько символов:

["a" skip "b"]
["a" 10 skip "b"]
["a" 1 10 skip]

Чтобы пропустить, пока не будет найден конкретный символ, используйте to: (для):

["a" to "b"]

В предыдущем примере анализ начинается с a и заканчивается на b, но не включает b.

Чтобы включить конечный символ, используйте thru (через):

["a" thru "b"]

В предыдущем примере анализ начинается с a, заканчивается на b и включает b.

Следующее правило находит заголовок HTML-страницы и распечатывает его:

page: read http://www.rebol.com/
parse page [thru <title> copy text to </title>]
print text
REBOL Technologies

Первый thru находит тег заголовка (title) и сразу проходит мимо него. Затем входная строка копируется в переменную с именем text до тех пор, пока не будет найден конечный тег (/title) (но он не пройдет мимо него, иначе текст будет включать тег).

5. Типы соответствия

При синтаксическом анализе строк эти типы данных и слова могут использоваться для сопоставления символов во входной строке:

Тип соответствия	Описание
"abc"	соответствовать всей строке
#"c"	соответствовать одному символу
tag	сопоставить строку тега
end	совпадать с концом ввода
(bitset)	соответствует любому указанному символу в наборе

Чтобы использовать все эти слова (кроме bitset, который объясняется ниже) в одном правиле, используйте:

[<B> ["excellent" | "incredible"] #"!" </B> end]

В этом примере анализируются входные строки:

<B>excellent!</B>
<B>incredible!</B>

В end указывает, что ничего не следует во входном потоке. Все входные данные были проанализированы. Это необязательно в зависимости от того, нужно ли проверять возвращаемое значение функции parse. Обратитесь к разделу "Оценка" ниже для получения дополнительной информации.

Тип данных bitset заслуживает более подробного объяснения. Битовые наборы используются для эффективного задания наборов символов. Функция charset позволяет вам указывать отдельные символы или диапазоны символов. Например, строка:

digit: charset "0123456789"

определяет набор символов, содержащий цифры. Это допускает такие правила, как:

[3 digit "-" 3 digit "-" 4 digit]

который может анализировать телефонные номера в форме:

707-467-8000

Чтобы принять любое количество цифр, обычно пишут правило:

digits: [some digit]

Набор символов (character) также может указывать диапазоны символов. Например, набор символов digit можно было бы записать как:

digit: charset [#"0" - #"9"]

В качестве альтернативы вы можете комбинировать определенные символы и диапазоны символов:

the-set: charset ["+-." #"0" - #"9"]

Чтобы расширить это, вот буквенно-цифровой набор символов:

alphanum: charset [#"0" - #"9" #"A" - #"Z" #"a" - #"z"]

Наборы символов также могут быть изменены с помощью функций insert (вставить) и remove (удалить), или комбинации наборов могут быть созданы с помощью функций union (объединение) и intersect (пересечение). Эта строка копирует набор символов цифр и добавляет к нему точку:

digit-dot: insert copy digit "."

Следующие строки определяют полезные наборы символов для синтаксического анализа:

digit: charset [#"0" - #"9"]
alpha: charset [#"A" - #"Z" #"a" - #"z"]
alphanum: union alpha digit

6. Рекурсивные правила

Вот пример набора правил, который анализирует математические выражения и дает приоритет (приоритет) используемым математическим операторам:

expr:    [term ["+" | "-"] expr | term]
term:    [factor ["*" | "/"] term | factor]
factor:  [primary "**" factor | primary]
primary: [some digit | "(" expr ")"]
digit:   charset "0123456789"

Теперь мы можем анализировать многие типы математических выражений. Следующие примеры возвращают true (истину), указывая, что выражения действительны:

probe parse "1 + 2 * ( 3 - 2 ) / 4" expr
true
probe parse "4/5+3**2-(5*6+1)" expr
true

Обратите внимание, что в примерах некоторые правила относятся к самим себе. Например, expr правило включает в себя expr . Это полезный метод определения повторяющихся последовательностей и комбинаций. Правило recursive (рекурсивное) - оно относится к самому себе.

При использовании рекурсивных правил необходимо соблюдать осторожность, чтобы предотвратить бесконечную рекурсию. Например:

expr: [expr ["+" | "-"] term]

создает бесконечный цикл, потому что первое, что делает expr, - снова использует expr.

7. Оценка

Обычно вы анализируете строку, чтобы получить какой-то результат. Вы хотите сделать больше, чем просто проверить правильность строки, вы хотите что-то сделать во время ее анализа. Например, вы можете выбрать подстроки из различных частей строки, создать блоки связанных значений или вычислить значение.

7.1 Возвращаемое значение

Примеры в предыдущих главах показали, как анализировать строки, но результатов не было. Это делается только для проверки того, что строка соответствует указанной грамматике; значение, возвращаемое сb>parse, указывает на его успех. Следующие примеры показывают это:

probe parse "a b c" ["a" "b" "c"]
true
probe parse "a b" ["a" "c"]
false

Функция parse возвращает true (истину), только если достигает конца входной строки. Неудачное совпадение останавливает разбор серии. Если сparse исчерпывает значения для поиска до достижения конца серии, он не просматривает серию и возвращает false:

probe parse "a b c d" ["a" "b" "c"]
false
probe parse "a b c d" [to "b" thru "d"]
true
probe parse "a b c d" [to "b" to end]
true

7.2 Выражения в правилах

Внутри правила вы можете включить выражение REBOL, которое будет оцениваться, когда parse достигает этой точки в правиле. Круглые скобки используются для обозначения таких выражений:

string: "there is a phone in this sentence"
probe parse string [
    to "a"
    to "phone" (print "found phone")
    to end
]
found phone
true

В приведенном выше примере анализируется строка a phone и печатается сообщение found phone после завершения сопоставления. Если строки a или phone отсутствуют и анализ не может быть выполнен, выражение не оценивается.

Выражения могут появляться в любом месте правила, а несколько выражений могут встречаться в разных частях правила. Например, следующий код печатает разные строки в зависимости от того, какие входные данные были найдены:

parse string [
    "a" | "the"
    to "phone" (print "answer") |
    to "radio" (print "listen") |
    to "tv"    (print "watch")
]
answer
string: "there is the radio on the shelf"

parse string [
    "a" | "the"
    to "phone" (print "answer") |
    to "radio" (print "listen") |
    to "tv"    (print "watch")
]
listen

Вот пример, который подсчитывает, сколько раз тег предварительного форматирования HTML появляется в текстовой строке:

count: 0
page: read http://www.rebol.com/docs/dictionary.html
parse page [any [thru <pre> (count: count + 1)]]
print count
777

7.3 Копирование ввода

Наиболее распространенное действие, выполняемое с помощью parse, - это выбор части анализируемой строки. Это делается с помощью copy, за которым следует имя переменной, в которую вы хотите скопировать строку. В следующем примере анализируется заголовок веб-страницы:

parse page [thru <title> copy text to </title>]
print text
REBOL/Core Dictionary

В этом примере текст пропускается до тех пор, пока не будет найден тег <title>. Вот где он начинает делать копию входного потока и устанавливать переменную с именем text для его хранения. Операция копирования продолжается до тех пор, пока не будет найден закрывающий тег <title>.

Действие копирования также можно использовать с целыми блоками правил. Например, для правила:

[copy heading ["H" ["1" | "2" | "3"]]

строка заголовка содержит всю строку H1, H2 или H3. Это также работает для больших правил с несколькими блоками.

7.4 Маркировка ввода

Действие copy создает копию найденной подстроки, но это не всегда желательно. В некоторых случаях лучше сохранить текущую позицию входного потока в переменной.

ПРИМЕЧАНИЕ. Слово copy, используемое при синтаксическом анализе, отличается от функции copy, используемой в выражениях REBOL. Анализировать использует диалект REBOL, и copy имеет различное значение в пределах этого диалекта.

В следующем примере переменная begin содержит ссылку на строку ввода page сразу после <title>. Ending ссылается на page строки непосредственно перед <title>. Эти переменные можно использовать так же, как и с любыми другими сериями.

parse page [
    thru <title> begin: to </title> ending:
    (change/part begin "Word Reference Guide" ending)
]

Вы можете видеть, что приведенное выше выражение синтаксического анализа фактически изменило содержимое заголовка:

parse page [thru <title> copy text to </title>]
print text
Word Reference Guide

Вот еще один пример, который отмечает позицию каждого тега таблицы в файле HTML:

page: read http://www.rebol.com/index.html
tables: make block! 20
parse page [
    any [to "<table" mark: thru ">"
        (append tables index? mark)
    ]
]

Блок tables теперь содержит позицию каждого тега:

foreach table tables [
    print ["table found at index:" table]
]
table found at index: 836
table found at index: 2076
table found at index: 3747
table found at index: 3815
table found at index: 4027
table found at index: 4415
table found at index: 6050
table found at index: 6556
table found at index: 7229
table found at index: 8268

ПРИМЕЧАНИЕ. Текущая позиция во входной строке также может быть изменена. В следующем разделе объясняется, как это делается.

7.5 Изменение строки

Теперь, когда вы знаете, как получить позицию входного ряда, вы также можете использовать для него другие функции ряда, включая вставку (insert), удаление (remove) и изменение (change). Чтобы написать сценарий, в котором все вопросительные знаки (?) Заменяются восклицательными знаками (!), Напишите:

str: "Where is the turkey? Have you seen the turkey?"
parse str [some [to "?" mark: (change mark "!") skip]]
print str
Where is the turkey! Have you seen the turkey!

Skip в хвосте опережает ввод над новым персонажем, который не является необходимым в этом случае, но это хорошая практика.

В качестве другого примера, чтобы вставить текущее время везде, где в тексте встречается слово time (время), напишите:

str: "at this time, I'd like to see the time change"
parse str [
    some [to "time"
        mark:
        (remove/part mark 4  mark: insert mark now/time)
        :mark
    ]
]
print str
at this 14:42:12, I'd like to see the 14:42:12 change

Обратите внимание на слово :mark, использованное выше. Он устанавливает вход в новую позицию. Функция insert возвращает новую позицию сразу после вставки текущего времени. Слово :mark используется для установки ввода в эту позицию.

7.6 Использование объектов

При разборе большой грамматики из набора правил используются переменные, чтобы сделать грамматику более читаемой. Однако переменные являются глобальными и могут быть перепутаны с другими переменными, имеющими такое же имя где-то еще в программе.

Решение этой проблемы - использовать объект, чтобы сделать все слова правила локальными для контекста. Например:

tag-parser: make object! [
    tags: make block! 100
    text: make string! 8000
    html-code: [
        copy tag ["<" thru ">"] (append tags tag) |
        copy txt to "<" (append text txt)
    ]
    parse-tags: func [site [url!]] [
        clear tags clear text
        parse read site [to "<" some html-code]
        foreach tag tags [print tag]
        print text
    ]
]
tag-parser/parse-tags http://www.rebol.com

7.7 Отладка

Поскольку правила написаны, иногда требуется отладка. В частности, вы можете захотеть узнать, как далеко вы продвинулись в синтаксическом анализе правила.

Функция trace может быть использована для наблюдения за прогрессом операции синтаксического анализа, но это может выводить тысячи строк, которые трудно рассмотреть.

Лучше всего вставить отладочные выражения в правила синтаксического анализа. Например, для отладки правила:

[to "<IMG" "SRC" "=" filename ">"]

вставьте функцию print после ключевых разделов, чтобы следить за тем, как вы выполняете правило:

[to "<IMG" (print 1) "SRC" "=" (print 2)
    filename (print 3) ">"]

В этом примере печатаются 1, 2 и 3 по мере обработки правила.

Другой подход - распечатать часть входной строки по мере выполнения синтаксического анализа:

[
   to "<IMG" here: (print here)
   "SRC" "=" here: (print here)
    filename here: (print here) ">"
]

Если это делается часто, вы можете создать для этого правило:

here: [where: (print where)]

[
   to "<IMG" here
   "SRC" "=" here
    filename here ">"
]

Функция copy также может использоваться, чтобы указать, какие подстроки были проанализированы при обработке правила.

8. Работа с пространствами

Функция parse обычно игнорирует все пробелы между сканируемыми шаблонами. Например, правило:

["a" "b" "c"]

возвращает строки, которые соответствуют:

abc
a bc
ab c
a b c
a  b  c

и другие аналогично расположенные комбинации.

Чтобы обеспечить соблюдение определенного соглашения об интервале, используйте b>parse с уточнением /all. В предыдущем примере это уточнение заставляет parse соответствовать только первому регистру (abc).

parse/all "abc" ["a" "b" "c"]

Указание /all уточнения заставляют обрабатывать каждый символ во входном потоке, включая разделители по умолчанию, такие как пробел, табуляция, новая строка.

Чтобы обрабатывать пробелы в ваших правилах, создайте набор символов, который определяет допустимые символы пробела:

spacer: charset reduce [tab newline #" "]

Если вы хотите, чтобы между каждой буквой был один пробел, напишите:

["a" spacer "b" spacer "c"]

Чтобы разрешить использование нескольких пробелов, напишите:

spaces: [some spacer]
["a" spaces "b" spaces "c"]

Для более сложных грамматик создайте набор символов, который позволяет сканировать строку до символа пробела.

non-space: complement spacer
to-space: [some non-space | end]
words: make block! 20
parse/all text [
    some [copy word to-space (append words word) spacer]
]

В предыдущем примере строится блок из всех слов. Функция complement инвертирует набор символов. Теперь он содержит все, кроме пробелов (non-space), которые вы определили ранее. Набор символов без пробела содержит все символы, кроме символов пробела. to-space правило принимает один или несколько символов до символа пробела или конца входного потока. Основное правило предполагает, что нужно начинать со слова, копировать это слово до пробела, затем пропускать пробел и начинать следующее слово.

9. Блоки синтаксического анализа и диалекты

Блоки анализируются аналогично строкам. Набор правил определяет порядок ожидаемых значений. Однако, в отличие от синтаксического анализа строк, синтаксический анализ блоков не связан с символами или разделителями. Анализ блоков выполняется на уровне значений, что упрощает определение правил грамматики и во много раз ускоряет работу.

Блочный синтаксический анализ - это самый простой способ создания диалектов REBOL . Диалекты - это подязыки REBOL, которые используют одну и ту же лексическую форму для всех типов данных, но допускают различный порядок значений в блоке. Значения не обязательно должны соответствовать нормальному порядку, требуемому аргументами функции REBOL. Диалекты способны обеспечить большую выразительность в определенных областях использования. Например, сами правила парсера указаны как диалект.

9.1 Соответствующие слова

При синтаксическом разборе блока для сопоставления со словом укажите слово как литерал:

'name
'when
'empty

9.2 Соответствие типов данных

Вы можете сопоставить значение любого типа данных, указав слово типа данных. См. Раздел «Соответствие типов данных» ниже.

Тип данных слова	Описание
string!	соответствует любой строке в кавычках
time!	соответствует в любому времени
date!	соответствует любой дате
tuple!	соответствует любому кортежу

ПРИМЕЧАНИЕ: не забывайте "!" это часть имени, иначе будет вызвона ошибка.

9.3 Запрещенные символы

Для блоков разрешены операции parse которые имеют дело с конкретными символами. Например, нельзя указать совпадение ни с первой буквой слова или строки, ни с пробелами или символами новой строки.

9.4 Примеры диалектов

Несколько кратких примеров помогают проиллюстрировать парсинг блоков:

block: [when 10:30]
print parse block ['when 10:30]
print parse block ['when time!]
parse block ['when set time time! (print time)]

Обратите внимание, что конкретное слово можно сопоставить, используя его буквальное слово в правиле (как в случае 'when). Можно указать тип данных, а не значение, как в строках выше, содержащих time!. Кроме того, переменной можно присвоить значение с помощью операции set.

Как и в случае со строками, при синтаксическом анализе блоков можно указать альтернативные правила:

rule: [some [
    'when set time time! |
    'where set place string! |
    'who set persons [word! | block!]
]]

Эти правила позволяют вводить информацию в любом порядке:

parse [
    who Fred
    where "Downtown Center"
    when 9:30
] rule
print [time place persons]

В этом примере можно было бы использовать присвоение переменных, но он показывает, как обеспечить альтернативный порядок ввода.

Вот еще один пример, оценивающий результаты синтаксического анализа:

rule: [
    set count integer!
    set str string!
    (loop count [print str])
]
parse [3 "great job"] rule
parse [3 "hut" 1 "hike"] [some rule]

Наконец, вот более сложный пример:

rule: [
    set action ['buy | 'sell]
    set number integer!
    'shares 'at
    set price money!
    (either action = 'sell [
            print ["income" price * number]
            total: total + (price * number)
        ][
            print ["cost" price * number]
            total: total - (price * number)
        ]
    )
]

total: 0
parse [sell 100 shares at $123.45] rule
print ["total:" total]

total: 0
parse [
    sell 300 shares at $89.08
    buy  100 shares at $120.45
    sell 400 shares at $270.89
] [some rule]
print ["total:" total]

Следует отметить, что это один из способов оценки выражений, использующих концепцию диалекта, впервые описанную в главе 4.

9.5 Разбор субблоков

Если при синтаксическом анализе блока найден подблок, он обрабатывается как одно значение блока - тип данных block!. Однако для синтаксического анализа субблока необходимо рекурсивно вызывать синтаксический анализатор для этого субблока. Слове into обеспечивает эту возможность. Ожидается, что следующее значение во входном блоке будет подблоком для анализа. Это как бы тип данных block! был предоставлен. Если into значение не тип данных block!, сравнение не удается, и в поиск чередуется или выходит из этого правила. Если следующим значением является блок, то правило синтаксического анализатора, которое следует за словом into, используется для начала синтаксического анализа субблока. Он обрабатывается так же, как и подправило.

rule: [date! into [string! time!]]
data: [10-Jan-2000 ["Ukiah" 10:30]]
print parse data rule

Все обычные операции синтаксического анализа могут быть применены к into.

rule: [
    set date date!
    set info into [string! time!]]
]
data: [10-Jan-2000 ["Ukiah" 10:30]]
print parse data rule

print info

rule: [date! copy items 2 into [string! time!]]
data: [10-Jan-2000 ["Ukiah" 10:30] ["Rome" 2:45]]
print parse data rule

probe items

10. Краткое описание операций синтаксического анализа

10.1 Общие формы

Оператор	Описание
|	альтернативное правило
[блок]	подправило
(выражение)	оценить выражение REBOL

10.2 Указание количества

Оператор	Описание
none	ничего не совпадает
opt	ноль или один раз
some	один или несколько раз
any	ноль или более раз
12	повторить шаблон 12 раз
1 12	повторить шаблон от 1 до 12 раз
0 12	повторить шаблон от 0 до 12 раз

10.3 Пропуск значений

Оператор	Описание
skip	пропустить значение (или несколько, если задано повторение)
to	предварительный ввод значения или типа данных
thru	предварительный ввод через значение или тип данных

10.4 Получение значений

Оператор	Описание
set	установить следующее значение переменной
copy	скопировать следующую последовательность совпадений в переменную

10.5 Использование слов

Оператор	Описание
word	значение слова
word:	отметить текущую позицию входной серии
:word	установить текущую позицию входной серии
'word	буквально соответствует слову (блок синтаксического анализа)

10.6 Соответствие значений (только анализ блока)

Оператор	Описание
"fred"	совпадает со строкой "fred"
%data	совпадает с именем файла %data
10:30	совпадает с временем 10:30
1.2.3	соответствует кортежу 1.2.3

10.7 Слова типа данных

Слово	Описание
type!	соответствует чему-либо с заданным типом данных