parser3/operators.txt - diff

Return to operators.txt CVS log

Up to [parser3project] / parser3

Diff for /parser3/operators.txt between versions 1.253 and 1.260

-version 1.253, 2017/02/20 15:26:58
+version 1.260, 2024/12/20 17:37:19
  Line 1
- операторы
+ operators
-     ^eval(выражение)[формат] выражение, кроме обычных функций:
+     ^eval(expression)[format] expressions, apart from the usual functions, supports:
-         допустимы #комментарии
+         #comments allowed
-             работают до конца строки или закрывающейся круглой скобки
+             they work until the end of the line or the closing parenthesis
-             внутри комментария допустимы вложенные круглые скобки
+             nested parentheses are allowed inside comments
-         из неочевидных операторов:
+         among the non-obvious operators:
-             | побитный xor
+             | bitwise XOR
-             || логический xor
+             || logical XOR
-             ~ побитное отрицание
+             ~ bitwise negation
-             \ целочисленное деление 10\3=3
+             \ integer division 10\3=3
-         def для проверки defined,
+         def checks if defined:
-             пустая строка не defined
+             an empty string is not defined
-             пустая таблица не defined
+             an empty table is not defined
-             пустой hash не defined
+             an empty hash is not defined
-         eq ne lt gt le ge для сравнения строк,
+         eq ne lt gt le ge for string comparison,
-         in "/dir/" для проверки, находится ли текущий документ в каталоге
+         in "/dir/" to check if the current document is located in the specified directory
-             ["внутри не допустимы выражения, если надо сравнить со сложным,
+             ["no expressions allowed inside; if you need a complex comparison, assign it to a variable"]
-             пусть это будет переменная]
+         is 'type' to check the type of the left operand,
-         is 'type' для проверки типа левого операнда,
+             e.g., "is the method parameter not a hash?"
-             можно проверить, "не hash ли параметр метода?"
+         -f checks if a file exists on disk,
-         -f для проверки существования файла на диске,
+         -d checks if a directory exists on disk,
-         -d для проверки существования каталога на диске,
+         a quoted string (double or single quotes) is treated as a string, unquoted text is a string until the nearest whitespace
-         строка в кавычках или апострофах - строка, без кавычек или апострофов строка до
+         numeric literals can be in hex format like 0xABC
-             ближайшего whitespace
+         priorities:
-         числовой литерал бывает 0xABC
-         приоритеты:
              /* logical */
              %left "!||"
              %left "||"
              %left "&&"
-             %left '<' '>' "<=" ">="   "lt" "gt" "le" "ge"
+             %left '<' '>' "<=" ">=" "lt" "gt" "le" "ge"
-             %left "==" "!="  "eq" "ne"
+             %left "==" "!=" "eq" "ne"
              %left "is" "def" "in" "-f" "-d"
              %left '!'
-            /* bitwise */
+             /* bitwise */
              %left '!|'
              %left '|'
              %left '&'
              %left '~'
-            /* numerical */
+             /* numerical */
              %left '-' '+'
              %left '*' '/' '%' '\\'
              %left '~'     /* negation: unary */
-         литералы
+         literals:
              true
              false
-     ^if(условие){когда да}{когда нет}
+     ^if(condition){then}{else}
-     ^if(условие1){да}[(условие2){да}[(условие2){да}[...]]]{нет} -- количество доп. условий не ограничено (в общем elseif это :)
+     ^if(condition1){yes}[(condition2){yes}[(condition3){yes}[...]]]{no}
+         unlimited number of additional conditions (elseif)
-     ^switch[значение]{^case[вариант1[;вариант2...]]{действие}^case[DEFAULT]{действие по умолчанию}}
+     ^switch[value]{^case[var1[;var2...]]{action}^case[DEFAULT]{default action}}
-     ^while(условие){тело}[[разделитель]|{разделитель который выполняется перед непустым очередным не первым телом}]
+     ^while(condition){body}[[delimiter]|{delimiter executed before each non-empty non-first body}]
-     ^for[i](0;4){тело}[[разделитель]|{разделитель который выполняется перед непустым очередным не первым телом}]
+     ^for[i](0;4){body}[[delimiter]|{delimiter executed before each non-empty non-first body}]
      ^try{
          ...
-         ^throw[sql.connect[;вася[;болван]]] // был ^error[текст]
+         ^throw[sql.connect[;vasya[;mistaken]]] // previously ^error[text]
          ^throw[
              $.type[sql.connect]
-             $.source[вася]
+             $.source[vasya]
-             $.comment[болван]
+             $.comment[mistaken]
          ]
          ...
      }{
          ^if($exception.type eq "sql"){
-             $exception.handled(1|true)  ^rem{флаг, что exception обработан}
+             $exception.handled(1|true)  ^rem{flag that exception is handled}
              ....
          }
          ^switch[$exception.type]{
              ^case[sql;mail]{
                  $exception.handled(1)
-                 код, обрабатывающий sql ошибку
+                 code handling sql error
                  $exception.type = sql.connect
-                 $exception.file $exception.lineno $exception.colno [если не запрещены при компиляции]
+                 $exception.file $exception.lineno $exception.colno [if not disabled at compile time]
-                 $exception.source = вася
+                 $exception.source = vasya
-                 $exception.comment = болван
+                 $exception.comment = mistaken
              }
              ^case[DEFAULT]{
-                 код, обрабатывающий другую ошибку
+                 code handling another error
                  ^throw[$exception] << re-throw // DON'T! It's default behaviour!
              }
          }
      }
-     ^break[] - обрывает цикл
+     ^break[]
-     ^break(true|false) - обрывает цикл, если true
+         breaks the loop
+     ^break(true|false)
-     ^continue[] - обрывает итерацию цикла
+         breaks the loop if true
-     ^continue(true|false) - обрывает итерацию цикла, если true
+     ^continue[]
-     ^return[] - обрывает выполнение метода
+         breaks the current iteration of the loop
-     ^return[value] - присваивает $result значение value и обрывает выполнение метода
+     ^continue(true|false)
+         breaks the current iteration if true
+     ^return[]
+         stops method execution
+     ^return[value]
+         assigns $result the value and stops method execution
-     ^untaint[[as-is|file-spec|uri|http-header|mail-header|sql|js|json|parser-code|regex|xml|html|optimized-[as-is|xml|html]]]{код}
+     ^untaint[[as-is|file-spec|uri|http-header|mail-header|sql|js|json|parser-code|regex|xml|html|optimized-[as-is|xml|html]]]{code}
          default as-is
-     ^taint[[lang]][код]
+     ^taint[[lang]][code]
          default "just tainted, language unknown"
-     ^apply-taint[[lang;]текст]
+     ^apply-taint[[lang;]text]
-         выполняет заданные в строке преобразования, неопределенно грязное как lang, на выходе чистая строка
+         applies transformations specified in the string, "indefinitely dirty" is considered as lang, producing a clean string
-     ^process[[$caller.CLASS|$object|$КЛАСС:CLASS]]{строка, которая будет process-ed, как код}[
+     ^process[[$caller.CLASS|$object|$CLASS:CLASS]]{string to be processed as code}[
-         $.main[во что переименовать @main]
+         $.main[what to rename @main to]
-         $.file[имя файла из которого, якобы, данный текст]
+         $.file[name of the file supposedly containing this text]
-         $.lineno(номер строки в файле, откуда данный текст. можно отрицательный)
+         $.lineno(line number in the file from where this text originated, can be negative)
      ]
-     ^process..[путь][во что переименовать @main]
+     ^process..[path][what to rename @main to]
-         по умолчанию, методы компилируются в $self [в случае оператора, $self=$MAIN:CLASS]
+         by default, methods are compiled into $self [in case of operator, $self=$MAIN:CLASS]
-     ^connect[protocol://строка соединения]]{код с ^sql[...]-ями}
+     ^connect[protocol://connection-string]]{code with ^sql[...] calls}
-         mysql://user:pass@{host[:port]|[/unix/socket]}/database?
+         mysql://user:pass@{host[:port][, host[:port]]|[/unix/socket]}/database?
              ClientCharset=parser-charset << charset in which parser thinks client works
              charset=UTF-8&
              timeout=3&
              compress=0&
              named_pipe=1&
-             multi_statements=1& allow execute more then one query in one parser :sql{} request
+             multi_statements=1&  allow executing more than one query in a single :sql{} request
+             config_file=.my.cnf&
+             config_group=parser3&  use group name from .my.cnf
              autocommit=1
-             autocommit если выставить в 0, будет делать commit/rollback
+             if autocommit is set to 0, it will perform commit/rollback
          pgsql://user:pass@{host[:port]|[local]}/database?
              client_encoding=win,[to-find-out]
              &datestyle=ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO
              &ClientCharset=parser-charset << charset in which parser thinks client works
-         oracle://user:pass@service?
-             NLS_LANG=RUSSIAN_AMERICA.CL8MSWIN1251&
-             NLS_LANGUAGE  language-dependent conventions
-             NLS_TERRITORY  territory-dependent conventions
-             NLS_DATE_FORMAT=YYYY-MM-DD HH24:MI:SS
-             NLS_DATE_LANGUAGE  language for day and month names
-             NLS_NUMERIC_CHARACTERS  decimal character and group separator
-             NLS_CURRENCY  local currency symbol
-             NLS_ISO_CURRENCY  ISO currency symbol
-             NLS_SORT  sort sequence
-             ORA_ENCRYPT_LOGIN=TRUE
-             ClientCharset=parser-charset << charset in which parser thinks client works
          odbc://DSN=dsn^;UID=user^;PWD=password^;ClientCharset=parser-charset
              ClientCharset << charset in which parser thinks client works
- Line 148
+ Line 143
              ClientCharset=parser-charset& << charset in which parser thinks client works
              autocommit=1
-         для работы connect нужно, чтобы заранее(рекомендуется в системном конфигурационном auto.p)
+         to use ^connect, the $SQL table must be defined beforehand (recommended in the system configuration auto.p)
-         была определена таблица
  #sql drivers
  $SQL[
      $.drivers[^table::create{protocol   driver  client
- mysql   /www/parser3/libparser3mysql.so libmysqlclient.so
+ mysql   $prefix/libparser3mysql.so      libmysqlclient.so
- pgsql   /www/parser3/libparser3pgsql.so libpq.so
+ pgsql   $prefix/libparser3pgsql.so      libpq.so
- oracle  /www/parser3/libparser3oracle.so        /u01/app/oracle/product/8.1.5/lib/libclntsh.so?ORACLE_HOME=/u01/app/oracle/product/8.1.5&ORA_NLS33=/u01/app/oracle/product/8.1.5/ocommon/nls/admin/data
+ sqlite  $prefix/libparser3sqlite.so     sqlite3.so
- sqlite  /www/parser3/libparser3sqlite.so        sqlite3.so
+ odbc    parser3odbc.dll
- odbc    c:\drives\y\parser3project\odbc\debug\parser3odbc.dll
  }]
  ]
-         в таблице у oracle в столбце клиентской библиотеки
-         допустимо задать environment параметры инициализации(если они не заданы иначе заранее),
-         допустимы имена, начинающиеся на NLS_ ORA_ и ORACLE_, или оканчивающиеся на +
-         под win32
-             необходим PATH+=^;C:\Oracle\Ora81\bin
-         к сведению:
-           ORA_NLS33 нужен для считывания файлика с клиентской кодировкой(задаваемой NLS_LANG)
-              если кодировка не по-умолчанию, обязательно указать в .drivers,
-              иначе будет сообщение про неправильный NLS параметр
-              (имеют в виду, что не нашли кодировку из NLS_LANG)
-           ORACLE_HOME нужен для считывания текстов сообщений об ошибках,
-         можно указывать и в строке соединения, но глобален, и лучше вынести за скобки,
-         в отличие от клиентской кодировки NLS_LANG, и прочего.
-         ВНИМАНИЕ: при работе с большими текстовыми блоками в oracle&pgsql[а лучше всегда],
-         ставить такой префикс перед открывающим апострофом, впритык, везде без проблелов
-         /**имя_поля**/'literal'
      ^rem{}
-         комментарий, удаляется при компиляции
+         a comment, removed at compile time
-     ^cache[файл](секунд){код}[{catch код}]
+     ^cache[file](seconds){code}[{catch code}]
-         относительное задание времени
+         relative time assignment
-         скешировать строку, которая получается при выполнении кода на 'секунд' секунд
+         caches the string resulting from the code execution for 'seconds' seconds
-         если 0 секунд, значит не кешировать, а старый такой стереть
+         if 0 seconds, do not cache, and remove any existing old cache
-         в catch коде $exception.handled[cache]  ^rem{флаг, что exception обработан}
+         in the catch code, $exception.handled[cache]  ^rem{flag that exception is handled}
-     ^cache[файл][expires date]{код}[{catch код}]
+     ^cache[file][expires date]{code}[{catch code}]
-         абсолютное задание времени
+         absolute time assignment
-     ^cache[файл] удалить файл [не ругает, если его нет]
+     ^cache[file]
-     ^cache(секунд)
+         deletes the file [no error if it doesn't exist]
+     ^cache(seconds)
      ^cache[expires date]
-         сигнализирует вышестоящему ^cache "уменьши до стольких-то 'секунд'/'expires'"
+         signals to the upper-level ^cache "reduce it to these many 'seconds'/'expires'"
-         в пределе: ^cache(0) отменить кеширование
+         ultimately: ^cache(0) cancels caching
-     ^cache[] выдаёт текущую expires date
+     ^cache[]
+         returns the current expires date
-     у всех методов есть локальная переменная $result, если в неё что положить,
-     то это будет результатом метода, а не его тело
+     each method has a local variable $result. If you put something in it,
+     that will be the method's result, not its body
-     у всех методов есть локальная переменная $caller, в ней лежит родительский stack frame,
-     можно записать в его локальную переменную
+     each method has a local variable $caller, containing the parent stack frame,
+     you can write to its local variables
-     use(^use или @USE) ищет и подключает файл:
-. если путь начинается с /, то считается, что это путь от корня веб пространства
+     use(^use or @USE) searches for and includes a file:
-. относительно текущей директории.
+. If the path starts with /, it is considered a path from the web root
-. относительно строк из table $MAIN:CLASS_PATH, снизу вверх.
+. Relative to the current directory
-            $MAIN:CLASS_PATH - глобальная строка или таблица с путём или путями к каталогу
+. Relative to strings from the $MAIN:CLASS_PATH table, bottom-up
-            с классами (от корня веб пространства), задавайте её в конфигурационном auto.p
+            $MAIN:CLASS_PATH is a global string or table with a path or paths to a directory
+            with classes (from the web root), set it in the configuration auto.p
-     глобальная табличка $CHARSETS[$.название[имя файла]]
-     задаёт какие буквы считаются какими(whitespace, letter, etc), а также их unicode
+     A global table $CHARSETS[$.name[filename]]
-     формат: tab delimited файл, с заголовком:
+        defines which characters are considered what (whitespace, letter, etc.), as well as their Unicode
+     format: tab-delimited file, with a header:
          char    white-space    digit    hex-digit    letter    word    lowercase    unicode1    unicode2
-         A            x    x    x    a    0x0041    0xFF21
+         A       x              x        x            a        0x0041  0xFF21
-         где char и lowercase могут быть буквами, а могут быть и 0xКОДАМИ
+         where char and lowercase can be letters or 0xCODES
-         если символ имеет единственное unicode представление, равное самому символу, можно не указывать unicode
+         if the character has a single Unicode representation equal to itself, you can omit unicode
-     всегда есть кодировка UTF-8, она является кодировкой по-умолчанию для request и response
+     UTF-8 is always available and is the default encoding for request and response
-     ВНИМАНИЕ: имя кодировки case insensitive
+     WARNING: the encoding name is case-insensitive
- синтаксис
-     $имя[новое значение]
+ syntax
-     $имя(математическое выражение нового значения)
+     $name[new value]
-     $имя{код нового значения}
+     $name(arithmetic expression of new value)
-     $имя whitespace или ${имя}неважно  подстановка значения
+     $name{code of new value}
-     ^имя параметры  вызов
+     $name whitespace or ${name}something - variable value
-     $имя.CLASS класс значения
+     ^name parameters - call
-     $имя.CLASS_NAME имя класса
+     $name.CLASS - class of the value
-     $имя[$.key[] () {}]  конструктор элемента переменной-хэша $имя.key
+     $name.CLASS_NAME - name of the class
-     ^method[$.key[] () {}] конструктор элемента параметра-хеша $parameter.key
+     $name[$.key[] () {}] - constructor of a hash variable with element $name.key
-     $CLASS.имя  обращение к переменной класса
+     ^method[$.key[] () {}] - constructor of a hash parameter with element $parameter.key
+     $CLASS.name  access a class variable
-     имя заканчивается перед: пробел tab linefeed ; ] } ) " < >  + * / % & | = ! ' , ? {уточнить}
-         т.е. можно $имя,aaaa
+     the name ends before: space tab linefeed ; ] } ) " < > + * / % & | = ! ' , ?
-         но если нужно после имени букву, скажем -, то ${имя}-
+         i.e. you can do $name,aaaa
+         but if you need a character after the name, say -, then ${name}-
-     в выражениях + и - являются дополнительными концами имени
+     in expressions, + and - are additional name boundaries
-     можно обращаться к составным объектам так: $name.subname где subname бывает:
-         строка
+     you can access compound objects as: $name.subname where subname can be:
-         $переменная
+         a string
-         строка$переменная
+         a $variable
-         [код, вычисляющий строку]
+         a string$variable
-     например: $хэш[$.возраст(88)] $достать[$.поле[возраст]] ^хэш.[$достать.поле].format{%05d}
+         [code computing a string]
+     for example: $hash[$.age(88)] $get[$.field[age]] ^hash.[$get.field].format{%05d}
- параметры := один или много параметров
- параметр :=
+ parameters := one or more parameters
-     (математическое выражение) вычисляется много раз внутри вызова,
+ parameter :=
- |   [код] вычисляется один раз перед вызовом,
+     (arithmetic expression) evaluated multiple times inside the call,
- |   {код} вычисляется 0 или много раз внутри вызова,
+ |   [code] evaluated once before the call,
-     везде допустимы ; внутри - делает много параметров в одних скобках
+ |   {code} evaluated zero or many times inside the call,
+     ';' are allowed, making multiple parameters in a single bracket
  void
-     доступны все методы, присутствующие у объекта класса string, результат как у пустой строки
+     all methods present in the string class object are available, the result behaves as if it were an empty string
-     ^void:sql{запрос без результата}{$.bind[см. table::sql]}
+     ^void:sql{query without result}{$.bind[see table::sql]}
  int,double
-     ^имя.int[]  целочисленное значение
+     ^name.int[]
-     ^имя.double[] double значение
+          integer value
-     ^имя.bool[] .bool(true|false)  bool значение
+     ^name.double[]
-     ^имя.inc(на сколько +)
+          double value
-     ^имя.dec(на сколько -)
+     ^name.bool[] ^name.bool(true|false)
-     ^имя.mul(на сколько *)
+          boolean value
-     ^имя.div(на сколько /)
+     ^name.inc(how much +)
-     ^имя.mod(на сколько %)
+     ^name.dec(how much -)
-     ^имя.format[формат]
+     ^name.mul(how much *)
-     ^int/double:sql{query}[[$.limit(2) $.offset(4) $.default{0} $.bind[см. table::sql]]]
+     ^name.div(how much /)
-         запрос, результат которого должен быть один столбец/одна строка
+     ^name.mod(how much %)
+     ^name.format[format]
+     ^int/double:sql{query}[[$.limit(2) $.offset(4) $.default{0} $.bind[see table::sql]]]
+         the query result should be one column/one row
  string
-     в выражении
+     in expression
-         def значение равно "не пуста?"
+         def value means "not empty?"
-         логическое/числовое значение равно попытке преобразовывания к double,
+         logical/numerical value equals an attempt to convert to double,
-             пустая строка тихо преобразуется к 0
+             an empty string quietly converts to 0
-         пример:
+         example:
-         ^if(def $form:name) не пуста?
+         ^if(def $form:name) not empty?
-         ^if($user.isAlive) истина? [автопреобразование к числу, не ноль?]
+         ^if($user.isAlive) true? [auto-convert to number, not zero?]
+     ^string:sql{query}[[$.limit(1) $.offset(4) $.default{n/a} $.bind[see table::sql]]]
-     ^string:sql{query}[[$.limit(1) $.offset(4) $.default{n/a} $.bind[см. table::sql]]]
+         the query result should be one column/one row
-         результат запроса должен быть один столбец/одна строка
+     ^string.int[] ^string.int(default)
+         integer value of the string, if conversion fails, default is taken
-     ^строка.int[] .int(default) целочисленное значение строки.
+     ^string.double[] ^string.double(default)
-         если ломается преобразование, берётся default
+         double value of the string, if conversion fails, default is taken
+     ^string.bool[] ^string.bool(default)
-     ^строка.double[] .double(default)  double значение строки
+         boolean value of the string, if conversion fails, default is taken
-         если ломается преобразование, берётся default
+     ^string.format[format] %d  %.2f %02d...
+     ^string.match[string-pattern|regex-pattern][[search options]] $prematch $match $postmatch $1 $2...
-     ^строка.bool[] .bool(default)  bool значение строки
+         search options:
-         если ломается преобразование, берётся default
-     ^строка.format[формат] %d  %.2f %02d...
-     ^строка.match[шаблон-строка|шаблон-regex][[опции поиска]]  $prematch $match $postmatch $1 $2...
-         опции поиска=
          i CASELESS
          x whitespace in regex ignored
-         s singleline = $ считается концом всего текста
+         s singleline = $ matches end of entire text
-         m multiline = $ считается концом строки[\n], не концом всего текста
+         m multiline = $ matches end of line[\n], not end of entire text
-         g найти все вхождения, а не одно
+         g find all occurrences, not just one
-         ' создавать столбцы prematch, match, postmatch
+         ' create columns prematch, match, postmatch
-         n вернуть цисло с количеством найденных совпадений, а не таблицу с результатами
+         n return the number of matches instead of a table
-         U инвертировать смысл модификатора '?'
+         U invert the meaning of the '?' modifier
+     ^string.match[string-pattern|regex-pattern][search options]{replacement}
-     ^строка.match[шаблон-строка|шаблон-regex][опции поиска]{замена}
+         additional search option:
-         опции поиска+=
+         g replace all occurrences, not just one
-         g заменить все вхождения, а не одно
+     ^string.split[delimiter|regex][[lrhva]][[column name for vertical splitting]]
+         l left to right [default]
-     ^строка.split[разделитель][[lrhv]][[название столбца для вертикального разбиения]]
+         r right to left
-         l слева направо [default]
+         h nameless table with keys 0, 1, 2, ...
-         r справа налево
+         v table of one column 'piece' or as provided [default]
-         h nameless таблица с ключами 0, 1, 2, ...
+         a array
-         v таблица из 1 столбца 'piece' или как передадут [default]
+     ^string.{l|r}split[delimiter] a table from the $piece column
+         kept for compatibility
-     ^строка.{l|r}split[разделитель] таблица из столбца $piece
+     ^string.upper|lower[]
-         оставлен для совместимости
+     ^string.length[]
+     ^string.mid(P[;N])
-     ^строка.upper|lower[]
+         without N - "until the end of the string"
+     ^string.left(N), -1 returns the entire string
-     ^строка.length[]
+     ^string.right(N)
+     ^string.pos[substring]
-     ^строка.mid(P[;N])
+     ^string.pos[substring](position from which to search)
-         без N - "до конца строки"
+         <0 = not found
+     ^string.replace[$table_of_substitutions_string_to_string]
-     ^строка.left(N), -1 выдает всю строку
+     ^string.replace[$what;$to]
+     ^string.save[[append;]path]
-     ^строка.right(N)
+     ^string.save[path[;$.charset[in which encoding save] $.append(true)]]
+         saves the string to a file
-     ^строка.pos[подстрока]
+     ^string.trim[start|both|end|left|right[;chars]]
+         removes chars from the start/end/or both start and end
-     ^строка.pos[подстрока](позиция, с которой ищем)
+         default 'chars' = whitespace chars
-         <0 = не найдено
+     ^string.trim[chars]
+         removes chars from start and end
-     ^строка.replace[$таблица_подстановок_строка_на_строку]
+     ^string.base64[ $.pad(bool) $.wrap(bool) $.url-safe(bool) ] encode
+     ^string:base64[encoded[; $.pad(bool) $.strict(bool) $.url-safe(bool) ]] decode
-     ^строка.replace[$что;$на-что]
+     ^string.idna[]
+         IDNA encoding, supports Cyrillic domains
-     ^строка.save[[append;]путь]
-     ^строка.save[путь[;$.charset[в какой кодировке сохраняем] $.append(true)]]
-     ^строка.trim[start|both|end|left|right[;chars]] выкидывает chars из начала/конца/и начала и конца
-         default 'chars' -- whitespace chars
-     ^строка.trim[chars] выкидывает chars из начала и конца
-     ^строка.base64[] encode
-     ^string:base64[encoded[;$.strict(true)]] decode
-     ^строка.idna[]
-         IDNA кодирование, поддержка кириллических доменов
      ^string:idna[encoded]
-         IDNA декодирование, поддержка кириллических доменов
+         IDNA decoding, supports Cyrillic domains
+     ^string.js-escape[]
-     ^строка.js-escape[] кодирование для передачи в JS (%uXXXX)
+         encoding for passing to JS (%uXXXX)
+     ^string:js-unescape[escaped]
-     ^string:js-unescape[escaped] декодирование переданного из js
+         decoding from js
+     ^string:unescape[js|uri;escaped; $.charset[] ]
-     ^string:unescape[js|uri;escaped; $.charset[] ] декодирование переданного из js или uri
+         decoding passed from js or uri
+     ^string.contains[key]
+         for compatibility with hashtable
  table
-     в выражении
+     in expression
-         логическое значение равно "не пуста?"
+         logical value means "not empty?"
-         числовое значение равно count[]
+         numerical value equals count[]
-     ^table::create[[nameless]]{данные}[[$.separator[^#09] $.encloser[]]]
+     $table.field
+     $table.field[new value]
+     $table.fields
+         from a named table returns the current record as a Hash
+     ^table::create[[nameless]]{data}[[$.separator[^#09] $.encloser[]]]
      ^table::create[table][[$.limit(1) $.offset(5) $.offset[cur] $.reverse(1)]]
-         клонирует таблицу
+         clones the table
-         reverse - в обратном порядке
+         reverse - in reverse order
-     ^table::load[[nameless;]путь[;опции]]
+     ^table::load[[nameless;]path[;options]]
-         если не nameless, названия колонок берутся из первой строки
+         if not nameless, column names are taken from the first line
-         пустые строки, и строки в первой колонке содержащие '#', игнорируются
+         empty lines, and lines in the first column containing '#' are ignored
          $.separator[^#09]
-         $.encloser["] по-умолчанию, нет.
+         $.encloser["] by default, none
      ^table::sql{query}[[$.limit(2) $.offset(4) $.bind[hash]]]
-         bind привязывает переменные в запросе к их значениям
+         bind associates variables in the query with their values
-         пока реализован только для oracle
+         currently implemented only for oracle
-         в запросе надо написать ":имя"
+         in the query you need to write ":name"
-         в параметре bind передать hash, из которого возьмётся (или куда запишется) значение
+         in the bind parameter pass a hash from which the value is taken (or where it is written)
-     ^таблица.save[[nameless|append;]путь[;опции, см. load]]
+     ^table.save[[nameless|append;]path[;options, see load]]
-     $таблица.поле
+         saves the table to a file
-     $таблица.поле[новое значение]
+     ^table.menu{body}[[delimiter]]
-     $таблица.fields  из named таблицы выдаёт текущую запись как Hash
+         executes the body code for each row of the table
-     ^таблица.menu{тело}[[разделитель]]
+     ^table.foreach[position;value]{body}[[delimiter]]
-     ^таблица.foreach[позиция;значение]{тело}[[разделитель]]
+     ^table.line[]
-     ^таблица.line[] 1-based offset
+         current table row, starting from 1
-     ^таблица.offset[] печатает offset
+     ^table.offset[]
-     ^таблица.offset[[whence]](5) сдвигает
+         offset of the current row from the start, starting from 0
-         whence=cur|set, без whence - это cur
+     ^table.offset[[whence]](5)
-     ^таблица.count[], ^таблица.count[rows] - количество строк в таблице
+         shifts whence=cur|set, without whence = cur
-     ^таблица.count[columns] - количество столбцов таблицы
+     ^table.count[], ^table.count[rows]
-     ^таблица.count[cells] - количество ячеек в текущей строке таблицы
+         number of rows in the table
-     ^таблица.sort{{ключеделатель строка}|(ключеделатель число)}[{desc|asc}] default=asc
+     ^table.count[columns]
-     ^таблица.append{данные}
+         number of columns
-     ^таблица.append[ $.имя столбца[значение столбца] ]
+     ^table.count[cells]
-     ^таблица.insert{данные} добавить запись на текущую позицию
+         number of cells in the current row
-     ^таблица.insert[ $.имя столбца[значение столбца] ]
+     ^table.sort{{string-key-maker}|(numeric-key-maker)}[{desc|asc}] default=asc
-     ^таблица.delete[] - стирает запись с текущей позиции
+     ^table.append{data}
-     ^таблица.join[таблица][$.limit(1) $.offset(5) $.offset[cur]] - добавляет записи из таблицы.
+     ^table.append[ $.column_name[column_value] ]
-         таблицы должны иметь одинаковую структуру.
+     ^table.insert{data} add a record at the current position
-     ^таблица.flip[] выдаёт транспонированную, надо куда-то сложить, потом пользовать
+     ^table.insert[ $.column_name[column_value] ]
-     ^таблица.locate[поле;значение][[$.limit(1) $.offset(5) $.offset[cur] $.reverse(1)]]
+     ^table.delete[]
-         передвигает текущую строку, если найдёт. выдаёт bool
+         deletes the record at the current position
-     ^таблица.locate(логическое выражение)[[$.limit(1) $.offset(5) $.offset[cur] $.reverse(1)]]
+     ^table.join[table][$.limit(1) $.offset(5) $.offset[cur]]
-         передвигает текущую строку, если найдёт. выдаёт bool
+         adds records from the table, tables must have the same structure
-     ^таблица.hash{[поле]|{код}|(выражение)}[[поле значений|table поля значений]{код значения}][[$.distinct(1) $.distinct[tables] $.type[hash]]]
+     ^table.flip[]
-         по умолчанию значением $hash.ключ будет hash в котором поля значений будут ключами
+         returns the transposed version
-         поля значений могут быть не указаны, тогда ими будут все столбцы, включая ключевой
+     ^table.locate[field;value][[$.limit(1) $.offset(5) $.offset[cur] $.reverse(1)]]
-         если distinct содержит true, то не будет ошибки при повторяющихся ключах
+         moves the current row if found. returns bool
-         если distinct содержит tables, то будет создан hash из таблиц, содержащих строки с ключом
+     ^table.locate(logical expression)[[$.limit(1) $.offset(5) $.offset[cur] $.reverse(1)]]
-         $.type[string/table] поменять значение элемента на строку (указать одну колонку) или таблицу
+         moves the current row if found. returns bool
-     ^таблица.columns[[название столбца]] + таблица из одного столбца 'column' или как передадут
+     ^table.hash{[field]|{code}|(expression)}[[value field(s)|table of value fields]{value code}][[$.distinct(1) $.distinct[tables] $.type[hash]]]
-     $отобранное[^таблица.select(выражение)] = таблица из тех же столбцов и строк, у которых условие совпало
+         by default $hash.key value is a hash where value fields are keys
+         value fields may not be specified, then they are all columns including the key
+         if distinct is true, no error if duplicate keys
+         if distinct is tables, a hash of tables is created, containing rows with that key
+         $.type[string/table] changes the element value to a string (specify one column) or a table
+     ^table.columns[[column name]]
+         table of one column 'column' or as provided
+     ^table.cells[], ^table.cells(limit)
+         returns an array of cells of the current row
+     ^table.array[]
+         returns an array of hashes, each hash representing the data of one row
+     ^table.array[column]
+         returns an array of values from the specified column
+     ^table.array{code}
+         returns an array of results from executing the given code for each row
+     ^table.rename[column name;new column name] ^table.rename[ $.column_name[new column name] ...]
+         renames a column or multiple columns
+     $selected[^table.select(expression)]
+         a table from those columns and rows where the condition matched
          $adults[^man.select($man.age>=18)]
-     ^таблица.color[цвет1;цвет2]
+     ^table.color[color1;color2]
+         alternates color1 and color2 for each row
  hash
-     в выражении
+     in expression
-         логическое значение равно "не пуст?", хеш с _default уже не пуст
+         logical value means "not empty?", a hash with _default is already not empty
-         числовое значение равно count[]
+         numerical value equals count[]
-     $хеш.ключ
+     $hash.key
-         _default - специальный ключ, если задан,
+         _default - a special key, if defined,
-         то при обращении по ключу, которому нет соответствия, выдаётся _default значение
+         then when accessing a non-existing key, _default value is returned
-     $хеш.fields выдает $hash. чтобы класс hash был чуть больше похож на класс table
+     $hash.fields
+         returns $hash, making hash class more similar to table class
      ^hash::create[[|copy_from_hash|copy_from_hashfile]]
-         создаёт новый hash, копию старого
+         creates a new hash, a copy of the old one
-     ^хеш.add[слагаемое]
+     ^hash.add[term]
-         перезаписывает одноимённые
+         overwrites entries with the same name
-     ^хеш.sub[вычитаемое]
+     ^hash.sub[subtracted]
-     ^хеш.union[b] = объединение
+     ^hash.union[b]
-         одноимённые остаются
+         union, same-named remain
-     ^хеш.intersection[b] = пересечение
+     ^hash.intersection[b][[$.order[self|arg]]]
-         значения хеш
+         intersection, new hash, order defines the element order (as in the source hash or parameter hash)
-     ^хеш.intersects[b] = bool
+     ^hash.intersects[b] = bool
-     ^hash::sql{запрос}[[$.distinct(1) $.limit(2) $.offset(4) $.type[hash|string|table]]]
+     ^hash::sql{query}[[$.distinct(1) $.limit(2) $.offset(4) $.type[hash|string|table]]]
-         получается hash(ключи=значения первая колонка ответа) of hash(ключи=названия остальных колонкок ответа) или
+         results is hash(keys = values of the first column of the response) of hash(keys = names of the other columns), or
-         string=значение каждого элемента - строка, при надо указать ровно два столбца или
+         string = each element's value is a string (need exactly two columns), or
-         table=значение каждого элемента - таблица
+         table = each element's value is a table
-     ^хеш.keys[[название колонки с ключами]] + таблица из одного столбца key или как передадут
+     ^hash.keys[[name of key column]]
-     ^хеш.count[]
+         a table of one 'key' column or as provided
-     ^хеш.foreach[key;value]{тело}[[разделитель]|{разделитель который выполняется перед непустым очередным не первым телом}]
+     ^hash.count[]
-     ^хеш.delete[ключ]  удалить ключ
+     ^hash.foreach[key;value]{body}[[delimiter]|{delimiter executed before each non-empty non-first body}]
-     ^хеш.contain[ключ] - существует ли в хеше ключ (bool)
+     ^hash.delete[key]
-     ^хэш.at[first|last][[key|value|hash]]
+         delete key
-     ^хэш.at([-]N)[[key|value|hash]]
+     ^hash.contain[key]
-         доступ к заданным элементам упорядоченного хеша
+         checks if hash contains a key (bool)
-     ^хэш.sort[key;value]{{ключеделатель строка}|(ключеделатель число)}[[desc|asc]] default=asc
+     ^hash.at[first|last][[key|value|hash]]
+     ^hash.at([-]N)[[key|value|hash]]
+         access specified elements of an ordered hash
+     ^hash.set[first|last;value]
+     ^hash.set([-+]N)[value]
+         sets the value of the specified ordered hash element
+     ^hash.rename[old_key;new_key]
+     ^hash.rename[ $.old_key[new_key] ...]
+         renames the specified hash keys
+     ^hash.sort[key;value]{{string-key-maker}|(numeric-key-maker)}[[desc|asc]] default=asc
+     $reversed_hash[^hash.reverse[]]
+     $selected[^hash.select[key;value](expression)[ $.limit(N) $.reverse(bool) $.default(bool) ]]
+         a hash of keys and values for which the condition is true
  hashfile
      ^hashfile::open[filename]
-     ^хешфайл.clear[]  забыть всё
+     ^hashfile.clear[]
-     $хешфайл.ключ[значение]  положить значение
+         forget all
-     $хешфайл.ключ[$.value[значение] $.expires[ЗНАЧЕНИЕ]}
+     $hashfile.key[value]
-       положить значение до expires
+         put value
-       значение поля expires может быть date, или число дней(0дней=на вечно)
+     $hashfile.key[$.value[value] $.expires[VALUE]]
-     $хешфайл.ключ  достать
+         put value until expires
-     ^хешфайл.delete[ключ]  удалить ключ
+         expires can be a date, or number of days (0days=forever)
-     ^хешфайл.delete[]  удалить файлы, содержащие данные
+     $hashfile.key retrieve
-     ^хешфайл.hash[]
+     ^hashfile.delete[key] delete key
-         преобразовать в обычный hash
+     ^hashfile.delete[] delete files containing data
-         попутно стирает устаревшие пары
+     ^hashfile.hash[]
-     ^хешфайл.foreach[key;value]{тело}[[разделитель]|{разделитель который выполняется перед непустым очередным не первым телом}]
+         convert to a regular hash
-     ^хешфайл.release[]
+         removing expired pairs along the way
-         записать данные и снять блокировки.
+     ^hashfile.foreach[key;value]{body}[[delimiter]|{delimiter executed before each non-empty non-first body}]
-         при повторном обращении к элементам откроется автоматически.
+     ^hashfile.release[]
-     ^хешфайл.cleanup[]  пробежаться по всем элементам и удалить устаревшие.
+         write data and release locks.
+         next access to elements will reopen automatically.
+     ^hashfile.cleanup[]
+         iterate all elements and delete expired ones.
-     пример:
+     example:
      $sessions[^hashfile::open[/db/sessions]]
      $sid[^math:uuid[]]
      $sessions.$sid[$.value[$uid] $.expires(1)]
      $uid[$sessions.$sid]
+ array
+     in expression
+         logical value means "not empty?"
+         numerical value equals count[]
+     $array.index, $array.(expression)
+         returns the value at the given index
+     $array.index[value], $array.(expression)[value]
+         assigns a value by index
+     $array[value;value;...]
+         creates an array with the given values
+     ^array::create[]
+     ^array::create[value;value;...]
+         creates an array with the given values or an empty array
+     ^array::copy[array or hash with numeric keys]
+         copies an array or a hash with numeric keys
+     ^array.add[array or hash with numeric keys]
+         adds elements from another array or hash, overwriting values for matching indexes
+     ^array.join[array or any hash]
+         appends elements from another array or hash to the end of the array
+     ^array.append[value;value;...]
+         appends elements to the end of the array
+     ^array.insert(index)[value;value;...]
+         inserts elements at the specified position in the array
+     ^array.left(n)
+         returns a new array of the first n elements
+     ^array.right(n)
+         returns a new array of the last n elements
+     ^array.mid(m;n)
+         returns a new array containing n initialized elements starting from position m
+     ^array.delete(index)
+         deletes an array element, leaving an empty spot
+     ^array.remove(index)
+         deletes an element and shifts subsequent elements to fill the gap
+     ^array.push[value]
+         adds an element to the end of the array
+     ^array.pop[]
+         returns the last element and removes it from the array
+     ^array.contain(index)
+         checks if an element exists at the given index (bool)
+     ^array::sql{query}[ $.sparse(false|true) $.distinct(false|true) $.limit(n) $.offset(n) $.type[hash|string|table] ]
+         creates an array based on a database query
+         $.sparse(false), default - create a normal array. Row values from the query are added sequentially
+         $.sparse(true) - create a sparse array. The first column must contain indexes
+         at which values will be placed (similar to ^hash::sql{})
+         result is an array of hash (keys=column names of the rest of the answer) or
+         string = each element's value is a string (need exactly two columns), or
+         table = each element's value is a table
+     ^array.keys[[column name for keys]]
+         a table of one 'key' column (or as provided) with the indexes of initialized elements
+     ^array.count[]
+         the number of initialized elements in the array
+     ^array.count[all]
+         the total number of elements, including uninitialized ones
+     ^array.foreach[index;value]{code}[[delimiter]|{delimiter executed before each non-empty non-first body}]
+         iterates over all initialized elements
+     ^array.for[index;value]{code}[[delimiter]|{delimiter executed before each non-empty non-first body}]
+         iterates over all elements
+     ^array.at[first|last][[key|value|hash]]
+     ^array.at([-]number)[[key|value|hash]]
+         accesses an array element by its ordinal number
+     ^array.set[first|last][value]
+     ^array.set([-]number)[value]
+         sets the value of an array element by ordinal number
+     ^array.compact[]
+         removes uninitialized elements
+     ^array.compact[undef]
+         removes uninitialized and empty elements
+     ^array.sort[key;value]{{string-key-maker}|(numeric-key-maker)}[[desc|asc]] default=asc
+         sorts the array
+     $reversed_array[^array.reverse[]]
+         returns a new array with elements in reverse order
+     $selected[^array.select[key;value](expression)[ $.limit(N) $.reverse(bool) ]]
+         selects array elements for which the condition is true
  form
-     [берётся первый элемент из одноимённых из GET, потом первый из POST]
+     [the first element with the same name is taken from GET, then from POST]
-     $form:поле = string/file
+     $form:field
-     $form:nameless = поле со значением поля без имени "?value&...", "...&value&...", "...&value"
+         string/file
-     $form:qtail = строка со значением текста после второго "?xxxxx", если там не было ',' [imap]
+     $form:nameless
-     $form:fields = hash со всеми полями формы
+         field with a value from a nameless parameter "?value&...", "...&value&...", "...&value"
-     $form:tables.поле = table с одним столбцом "field" со значениями "поля", для множественных значений
+     $form:qtail
-     $form:files.поле = hash со значениями полей типа файл, ключи - 0, 1, ..., значение - файл
+         string with the value after the second "?xxxxx" if there was no ',' [imap]
-     $form:imap = хэш с ключами 'x' и 'y'
+     $form:fields
-         со значением ?1,2 приписки при использовании server-site image map
+         hash with all form fields
+     $form:elements.field
+         array with all values of the field - both string and file
+     $form:tables.field
+         table with one column "field" containing the values for multiple entries
+     $form:files.field
+         hash with file-type field values, keys - 0, 1, ..., value - file
+     $form:imap
+         a hash with keys 'x' and 'y' with ?1,2 suffixes when using server-side image map
  env
-     $env:переменная
+     $env:variable
-     $env:fields хэш с переменными окружения
+     $env:fields hash with environment variables
-     $env:PARSER_VERSION версия парсера
+     $env:PARSER_VERSION parser version
  cookie
-     $cookie:имя считать старое или свежезаданное
+     $cookie:name read old or newly set cookie
-     $cookie:имя[значение] на 90 дней
+     $cookie:name[value] for 90 days
-     $cookie:имя[$.value[значение] $.expires[ЗНАЧЕНИЕ] $.secure(true) $.domain[имя домена] $.httponly(true)]
+     $cookie:name[$.value[value] $.expires[VALUE] $.secure(true) $.domain[domain name] $.httponly(true)]
-         значение поля expires может быть 'session', date, или число дней(0дней=session)
+         the expires field value can be 'session', a date, or a number of days (0days=forever)
-         если дата, она будет преобразована к формату "Sun, 25-Aug-2002 12:03:45 GMT"
+         if it's a date, it will be converted to "Sun, 25-Aug-2002 12:03:45 GMT"
-     $cookie:fields = hash со всеми cookies
+     $cookie:fields
+         hash with all cookies
  request
      $request:query
      $request:uri
      $request:document-root
-         каталог, относительно которого считаются пути в parser, по-умолчанию = $env:DOCUMENT_ROOT
+         directory relative to which paths are considered in parser, default = $env:DOCUMENT_ROOT
-     $request:argv = hash с параметрами коммандной строки. ключи 0, 1, ... [0 -- имя обрабатываемого файла].
+     $request:argv
+         hash with command-line parameters. keys 0, 1, ... [0 - name of the processed file]
      $request:charset
-         Кодировка исходного документа
+         the source document encoding
-         используется при upper/lower и match[][i]
+         used in upper/lower and match[][i]
-         ПРЕДУПРЕЖДЕНИЕ: необходимо задать $request/response:charset до использования полей класса form
+         WARNING: you must set $request/response:charset before using form class fields
-     $request:method метод запроса (GET|POST|PUT)
+     $request:method
-     $request:body тело POST-запроса в виде текста
+         request method (GET|POST|PUT)
-     $request:body-file тело POST-запроса в виде файла
+     $request:body
-     $request:body-charset кодировка POST-запроса
+         POST-request body as text
-     $request:headers хэш с заголовками запроса (без префикса HTTP_)
+     $request:body-file
+         POST-request body as a file
+     $request:body-charset
+         POST-request encoding
+     $request:headers
+         hash with request headers (without HTTP_ prefix)
  response
-     $response:поле[значение]  и можно считать старое - $response:поле
+     $response:field[value] and can read old - $response:field
-         значение может быть string а может быть hash:
+         the value can be string or hash:
-             $value[abc] field: {abc}<<часть
+             $value[abc] field: {abc}<<part
-             $attribute[zzz] field: abc; {attribute=zzz}<<часть
+             $attribute[zzz] field: abc; {attribute=zzz}<<part
-         значение поля или атрибута может быть string или date
+         field or attribute value can be string or date
-             если дата, она будет преобразована к формату "Sun, 25-Aug-2002 12:03:45 GMT"
+             if date, it will be converted to "Sun, 25-Aug-2002 12:03:45 GMT"
-     $response:headers накопленные поля
+     $response:headers
-     $response:body[DATA]  замещает стандартный ответ
+          accumulated fields
-     $response:download[DATA]  замещает стандартный ответ,
+     $response:body[DATA]
-         выставляет флаг, заставляющий browser предложить download
+         replaces the standard response
+     $response:download[DATA]
+         replaces the standard response, sets a flag causing the browser to suggest download
      $response:status
-     ^response:clear[] забыть все заданные response поля
+     ^response:clear[] forget all set response fields
      $response:charset
-         кодировка клиента т.е. та,
+         client encoding, i.e.:
-) из которой будут перекодированы $form:поля после забирания из browser'а
+) from which $form: fields will be transcoded after retrieval from browser
-) в которую документ будет перекодирован перед отдаванием в browser
+) into which the document will be transcoded before sending to browser
-) в которую будет перекодирован текст языка uri
+) into which URI language text will be transcoded
-         не добавляет к content-type ничего, если хочется, это надо сделать вручную
+         does not add anything to content-type; if needed, do it manually
-         ПРЕДУПРЕЖДЕНИЕ: необходимо задать $request/response:charset до использования полей класса form
+         WARNING: you must set $request/response:charset before using form class fields
  regex
-     в выражении
+     in expression
-         логическое значение всегда равно true
+         logical value is always true
-         числовое значение равно количеству байт скомпилированного шаблона.
+         numerical value is equal to the number of bytes of the compiled pattern
-     ^regex::create[шаблон-строка][[опции поиска]]
+     ^regex::create[pattern-string|regex][[search options]]
-     ^шаблон.size[] количество байт скомпилированного шаблона
+     ^pattern.size[]
-         если значение очень большое - стоит почитать документацию по pcre и, возможно, переписать шаблон.
+         number of bytes of the compiled pattern
-     ^шаблон.study_size[] размер study-структуры. если==0 - шаблон не может быть "изучен"
+         if the value is very large - it is worth consulting pcre documentation and possibly rewriting the pattern
-     $шаблон.pattern текст шаблона
+     ^pattern.study_size[]
-     $шаблон.options строка с исходным текстом опций
+         size of the study-structure. if == 0 - the pattern cannot be "studied"
+     $pattern.pattern
+         the text of the pattern
- TODO: reflection
+     $pattern.options
-     ^reflection:create[класс;конструктор[;пара;[мет[;ры]]]]  вызывает указанный конструктор класса (не более 100 параметров)
+         the string with the original text of the options
-     ^reflection:classes[]                 хеш со всеми классами. ключ -- имя класса, значение бывает methoded (класс с методами) или void
-     ^reflection:class[объект]             класс переданного объекта
+ reflection
-     ^reflection:class_name[объект]        имя класса переданного объекта
+     ^reflection:create[class;constructor[;pa[;ra[;ms]]]]
-     ^reflection:base[объект]              родительский класс переданного объекта
+         calls the specified class constructor (no more than 100 parameters)
-     ^reflection:base_name[объект]         имя родительского класса переданного объекта
+     ^reflection:create[ $.class[name] $.constructor[name] $.arguments[ $.1[pa] $.2[ra] $.3[ms] ] ]
-     ^reflection:class_by_name[имя класса] получение класса по имени
+         calls the specified class constructor
-     ^reflection:def[class;имя класса]     проверка класса на существование
+     ^reflection:classes[]
-     ^reflection:methods[класс]            хеш со списком методов указанного класса, значения -- строки 'native' или 'parser'
+         a hash of all classes. key = class name, value can be methoded (a class with methods) or void
-     ^reflection:method[класс или объект;имя метода] возвращает junction-method класса или объекта
+     ^reflection:class[object]
-     ^reflection:fields[класс или объект]  хеш со списком статических полей указанного класса или динамических полей указанного объекта
+         the class of the given object
-     ^reflection:field[класс или объект;имя поля]  возвращает значение указанного поля класса или объекта. getter-ы игнорируются.
+     ^reflection:class_name[object]
-     ^reflection:uid[класс или объект]     возвращает идентификатор объекта или класса
+         the class name of the given object
-     ^reflection:method_info[класс;метод]  хеш с параметрами указанного метода класса
+     ^reflection:base[object]
-         $.inherited[класс]                имя класса, где метод был определён (возвращается только если метод был определён в предке)
+         the parent class of the given object
-         $.overridden[класс]               имя класса, где метод был определён (возвращается только если метод был определён в предке)
+     ^reflection:base_name[object]
-         для native классов возвращается хеш:
+         the parent class name of the given object
-             .min_params(минимально необходимое число параметров)
+     ^reflection:class_by_name[class name]
-             .max_params(максимально возможное число параметров)
+         obtains the class by name
+     ^reflection:class_alias[class name;new class name]
+         sets an alias for the specified class
+     ^reflection:def[class;class name]
+         checks if the class exists
+     ^reflection:methods[class]
+         a hash with a list of methods of the specified class, values are strings 'native' or 'parser'
+     ^reflection:method[class or object;method name]
+         returns the junction-method of the class or object
+     ^reflection:filename[object or class or method]
+         returns the filename where the object, class or method is defined
+     ^reflection:fields[class or object]
+         a hash with the list of static fields of the specified class or dynamic fields of the specified object
+     ^reflection:fields_reference[object]
+         an editable hash of the dynamic fields of the specified object
+     ^reflection:field[class or object;field name]
+         returns the value of the specified field of the class or object. getters are ignored.
+     ^reflection:copy[source;destination]
+         copies fields from one object or class to another
+     ^reflection:uid[class or object]
+         returns the identifier of the object or class
+     ^reflection:method_info[class;method]
+         a hash with parameters of the specified class method
+         $.inherited[class] name of the class where the method was defined (returned only if the method was defined in an ancestor)
+         $.overridden[class] name of the class where the method was defined (returned only if the method was defined in an ancestor)
+         for native classes a hash is returned:
+             .min_params(minimum required number of parameters)
+             .max_params(maximum possible number of parameters)
              .call_type[dynamic|static|any]
-         для parser классов возвращается хеш:
+         for parser classes a hash is returned:
-             ключ -- номер параметра (0, 1, ...), значение - имя параметра
+             key is parameter number (0, 1, ...), value is parameter name
      ^reflection:dynamical[[object or class, caller if absent]]
-         возвращает true, если метод был вызван из динамического контекста при передаче
+         returns true if the method was called from a dynamic context when passing
-         параметра возвращает true, если передан динамический объект, false если класс
+         a parameter returns true if a dynamic object was passed, false if a class
-     ^reflection:delete[класс или объект;имя переменной]      удаляет переменную с указанным именем в указанном классе или объекте
+     ^reflection:delete[class or object;variable name]
-     ^reflection:is[имя элемента;имя класса][[контекст]]      аналог оператора is, позволяющий определить, является ли элемент кодом.
+         deletes the variable with the specified name in the specified class or object
+     ^reflection:is[element name;class name][[context]]
+         analogous to the 'is' operator, allowing to determine if the element is code.
+     ^reflection:tainting[[language|tainted|optimized];string]
+         a string in which each character of the original string corresponds to a character with a transformation code
+     ^reflection:stack[ $.args(false/true) $.locals(false/true) $.limit(n) $.offset(o)]
+         the current state of the method call stack in the parser
+     ^reflection:mixin[source; $.to[target] $.name[name] $.methods(true/false) $.fields(true/false) $.overwrite(false/true)]
+         copies methods and fields from one class to another
  mail
      $mail.received=MESSAGE:
          .from
          .reply-to
          .subject
-         .date класса date
+         .date of class date
          .message-id
          .raw[
-             .СЫРОЕ_ПОЛЬЗОВАТЕЛЬСКОЕ-ПОЛЕ-ЗАГОЛОВКА
+             .RAW_USER_HEADER_FIELD
          ]
-         $.{text|html|file#}[ << нумеруется как и в mail:send (text, text2, ...) (file, file2, ...)
+         $.{text|html|file#}[ << numbered as in mail:send (text, text2, ...) (file, file2, ...)
              $.content-type[
                  $.value[{text|...|x-unknown}/{plain|html|...|x-unknown}]
-                 [$.charset[windows-1251]] << в каком пришло, сейчас уже перекодировано
+                 [$.charset[windows-1251]] << in which it arrived, now already transcoded
-                 $.ПОЛЬЗОВАТЕЛЬСКИЙ-ПАРАМЕТР-ЗАГОЛОВКА
+                 $.USER_DEFINED_HEADER_FIELD
              ]
              $.description
              $.content-id
              $.content-md5
              $.content-location
              .raw[
-                 .СЫРОЕ_ПОЛЬЗОВАТЕЛЬСКОЕ-ПОЛЕ-ЗАГОЛОВКА
+                 .RAW_USER_HEADER_FIELD
              ]
-             $.value[строка|FILE]
+             $.value[string|FILE]
          ]
          $.message#[MESSAGE] (message, message2, ...)
      ^mail:send[
          $.options[-odd]
-             unix: строка, которая будет добавлена к команде запуска sendmail
+             unix: a string that will be added to the sendmail startup command
-                 -odd означает "быстро поставь в очередь без проверки email"
+                 -odd means "quickly put in the queue without email checking"
-             win32: игнорируется
+             win32: ignored
-         $.charset[кодировка заголовка и текстовых блоков]
+         $.charset[the encoding of the headers and text blocks]
          $.any-header-field
          $.text[string]
          $.text[
-            $.any-header-field
+             $.any-header-field
-            $.value[string]
+             $.value[string]
          ]
          $.html{string}
          $.html[
- Line 631  mail
+ Line 750  mail
              $value[FILE]
          ]
      ]
-     если charset указан, письмо перекодируется в этот charset
+     if charset is specified, the email is transcoded to this charset
-     content-type.charset не влияет на перекодирование
+     content-type.charset does not affect transcoding
-     после имени части может идти # число
+     after the part name a # number can follow
      ^mail:send[
- #       по-умолчанию, совпадает с source encoding.
+ #       by default, matches the source encoding.
- #       задаёт кодировку body
+ #       sets the body encoding
          $.charset[windows-1251]
- #       нет умолчания
+ #       no default
          $.content-type[$.value[text/plain] $.charset[windows-1251]]
-         $.from["вася" <vasya@design.ru>]
+         $.from["vasya" <vasya@design.ru>]
-         $.to["петя" <petya@design.ru>]
+         $.to["petya" <petya@design.ru>]
-         $.subject[пойдём пивка]
+         $.subject[subject]
          $.body[
-             слова
+             text
          ]
      ]
-     ^mail:send[$.header-field[] $.charset[кодировка письма] $.body[когда body не строка, а hash, отсылается multipart письмо]]
+     ^mail:send[$.header-field[] $.charset[mail encoding] $.body[if body is not a string, but a hash, a multipart email is sent]]
-         если charset указан, письмо перекодируется в этот charset
+         if charset is specified, the email is transcoded to that charset
-         content-type.charset не влияет на перекодирование
+         content-type.charset does not affect transcoding
-         после имени части может идти целое число, части пойдут в порядке чисел.
+         after the part name, an integer can follow, parts go in numerical order.
-         если body указан строкой, то это текст письма, никаких вложений.
+         if body is a string, then it's just the email text, no attachments.
-         если body указан hash, то это части, будут собраны текстовые блоки, затем вложения
+         if body is a hash, then these are parts, text blocks first, then attachments
-         это старый формат, поддерживается для обратной совместимости
+         this is the old format, supported for backward compatibility
-         если имя части начинается со слова text, то это текстовый блок.
+         if the part name begins with "text", it's a text block.
-         если имя части начинается со слова file, то это вложение, формат задания::
+         if the part name begins with "file", it's an attachment, format:
              $file[$.format[uue|base64] $.value[DATA] $.name[user-file-name]]
-         важно: при multipart не указывать content-type
+         important: for multipart do not specify content-type
          ^mail:send[
- #           по-умолчанию, совпадает с source encoding.
+ #           by default, matches the source encoding
- #           задаёт кодировку body
+ #           sets the body encoding
              $.charset[windows-1251]
- #           нет умолчания
+ #           no default
              $.content-type[$.value[text/plain] $.charset[windows-1251]]
-             $.from["вася" <vasya@design.ru>]
+             $.from["vasya" <vasya@design.ru>]
-             $.to["петя" <petya@design.ru>]
+             $.to["petya" <petya@design.ru>]
-             $.subject[пойдём пивка]
+             $.subject[subject]
              $.body[
-                 слова
+                 text
              ]
          ]
          ^mail:send[
-             $.from["вася" <vasya@design.ru>]
+             $.from["vasya" <vasya@design.ru>]
-             $.to["петя" <petya@design.ru>]
+             $.to["petya" <petya@design.ru>]
-             $.subject[пойдём пивка]
+             $.subject[subject]
              $.body[
                  $.text[
- #                   задаёт кодировку body
+ #                   sets the body encoding
                      $.charset[windows-1251]
- #                   нет умолчания
+ #                   no default
                      $.content-type[$.value[text/plain] $.charset[windows-1251]]
-                     $.body[слова]
+                     $.body[words]
                  ]
- #               для удобства можно указать только одну часть, при этом не будет multipart
+ #               for convenience you can specify only one part, then it won't be multipart
                  $.file[
-                    $.value[^file::load[my beloved.doc]]
+                     $.value[^file::load[my beloved.doc]]
-                    $.name[мой любимый.doc]
+                     $.name[my beloved.doc]
-                    $.format[base64]
+                     $.format[base64]
                  ]
                  $.file2[
-                    $.value[^file::load[my beloved.doc]]
+                     $.value[^file::load[my beloved.doc]]
-                    $.name[мой любимый.doc]
+                     $.name[my beloved.doc]
-                ]
+                 ]
              ]
          ]
-     для отправки под unix используется программа с параметрами, задаваемая
+     under unix, the program with arguments is used, set by
-         $MAIL.sendmail[команда]
+         $MAIL.sendmail[command]
-     если не будет задана, проверяется, доступна ли /usr/sbin/sendmail или
+     if not specified, checks if /usr/sbin/sendmail or
-     /usr/lib/sendmail и, если доступна, то запускается с параметром "-t".
+     /usr/lib/sendmail is available and if so, runs with "-t".
-     под win32 используется SMTP протокол, сервер задаётся
+     under Windows, SMTP protocol is used, server is set by
          $MAIL.SMTP[smtp.domain.ru]
  image
-     $картинка[^image::measure[DATA]]
+     $image[^image::measure[DATA[; $.exif(bool) $.xmp(bool) $.xmp-charset[] $.video(bool) ]]]
-         смотрит на .ext case insensitive,
+         checks the file extension case-insensitively
-         умеет мерить пока только .gif и .jpg .jpeg
+         can measure gif, jpg, tiff, bmp, webp and mp4 (mov)
-     $картинка.exif << hash после measure jpeg с exif информацией
+     $image.exif << hash after measure jpeg with exif information and $.exif(true)
          $image.exif.DateTime & co
-             [полный список см. http://www.ba.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html]
+             [full list see https://exiftool.org/TagNames/EXIF.html]
-         числа типа int/double,
+         numbers as int/double,
-         даты типа date
+         dates as date,
-         перечисления в виде hash с ключами 0..count-1
+         enumerations as hash with keys 0..count-1
-     $картинка.src .width .height
+     $image.src .width .height
-     $картинка.line-width  число=ширина линий
+     $image.line-width  number=line width
-         $картинка.line-style строка=стиль линий '*** * '='*** * *** * *** * '
+     $image.line-style  string=line style '*** * '='*** * *** * *** * '
-     ^картинка.html[[hash]] = <img ...>
+     ^image.html[[hash]]
-     ^image::load[фон.gif]
+         <img ...>
-         только gif пока
+     ^image::load[background.gif]
-     ^image::create(размер X;размер Y[;цвет фона default белый]])
+         only gif so far
-     ^картинка.line(x0;y0;x1;y1;0xffFFff)
+     ^image::create(width X;height Y[;background color default white]])
-     ^картинка.fill(x;y;0xffFFff)
+     ^image.line(x0;y0;x1;y1;0xffFFff)
-     ^картинка.rectangle(x0;y0;x1;y1;0xffFFff)
+     ^image.fill(x;y;0xffFFff)
-     ^картинка.bar(x0;y0;x1;y1;0xffFFff)
+     ^image.rectangle(x0;y0;x1;y1;0xffFFff)
-     ^картинка.replace(hex-цвет1;hex-цвет2)[table x:y вершины_многоугольника]
+     ^image.bar(x0;y0;x1;y1;0xffFFff)
-     ^картинка.polyline(цвет)[table x:y точки]
+     ^image.replace(hex-color1;hex-color2)[table x:y polygon_vertices]
-     ^картинка.polygon(цвет)[table x:y вершины_многоугольника]
+     ^image.polyline(color)[table x:y points]
-     ^картинка.polybar(цвет)[table x;y вершины_многоугольника]
+     ^image.polygon(color)[table x:y polygon_vertices]
-     ^картинка.font[набор_букв;имя_файла_шрифта.gif][(ширина_пробела[;ширина_символа])]
+     ^image.polybar(color)[table x;y polygon_vertices]
-         высота символа = высота картинки/количество букв в наборе
+     ^image.font[set_of_letters;font_file.gif][(space_width[;char_width])]
-         если указана ширина_символа, то monospaced, если 0, то ширина_символа = ширине gif
+         the character height = image height/number of letters in the set
-     ^картинка.font[набор_букв;имя_файла_шрифта.gif;
+         if char_width is specified, then monospaced, if 0, char_width = gif width
-            $.space(ширина_пробела)             // по умолчанию = ширине gif
+     ^image.font[set_of_letters;font_file.gif;
-            $.width(ширина_символа)             // см. выше, по умолчанию proportional
+         $.space(space_width)      // default = gif width
-            $.spacing(расстояние между буквами) // по умолчанию = 1
+         $.width(char_width)       // see above, default proportional
+         $.spacing(letter_spacing) // default = 1
      ]
-     ^картинка.text(x;y)[текст_надписи] AS_IS
+     ^image.text(x;y)[text] AS_IS
-     ^картинка.length[текст_надписи] AS_IS
+     ^image.length[text] AS_IS
-     ^картинка.gif[возможно, имя файла] -- кодирует в FILE с content-type=image/gif
+     ^image.gif[optional filename]
-         имя файла будет использовано при $response:download
+         encodes to FILE with content-type=image/gif the filename will be used by $response:download
-     ^картинка.arc(center x;center y;width;height;start in degrees;end in degrees;color)
+     ^image.arc(center x;center y;width;height;start in degrees;end in degrees;color)
-     ^картинка.sector(center x;center y;width;height;start in degrees;end in degrees;color)
+     ^image.sector(center x;center y;width;height;start in degrees;end in degrees;color)
-     ^картинка.circle(center x;center y;r;color)
+     ^image.circle(center x;center y;r;color)
-     ^картинка.copy[source](src x;src y;src w;src h;dst x;dst y[;dest w[;dest h[;tolerance]]])
+     ^image.copy[source](src x;src y;src w;src h;dst x;dst y[;dest w[;dest h[;tolerance]]])
-         при заданных dest_w/dest_h делает изменение размера кусочка
+         if dest_w/dest_h are specified, resizes the piece
-             при уменьшении делает resample
+             when reducing size, does resample
-             годится только для уменьшения простой[малоцветной] дребедени вроде графиков/pie,
+             only suitable for simplifying low-color graphics like charts/pie,
-             для thumbnais не годится.
+             not suitable for thumbnails
-         при не указанном dest_h сохраняет aspect ratio
+         if dest_h is not specified, aspect ratio is kept
-         tolerance - некое число[квадрат расстояния в RGB пространстве до искомого цвета],
+         tolerance - a number [square distance in RGB space to the target color],
-         определяющее прожорливость выделялки цветов из палитры [default=150]
+             defining how greedy the color approximation from the palette is [default=150]
-             меньше - точнее приближает цвета, но они быстро кончаются
+             smaller - more accurate but colors run out quickly
-             больше - неточно приближает цвет, но бОльшей части хватит
+             larger - less accurate approximation, but covers a bigger part
-     ^картинка.pixel(x;y)[(color)]
+     ^image.pixel(x;y)[(color)]
-         узнать или задать цвет пиксела
+         get or set pixel color
  file
-     $файл_из_post.name
+     $uploaded_file_from_post.name
-     $файл_из_post.size
+     $uploaded_file_from_post.size
-     $файлt_из_post.text
+     $uploaded_file_from_post.text
-     ^файл.save[text|binary;имя файла[;$.charset[в какой кодировке сохраняем]]]
+     ^file.save[text|binary;filename[;$.charset[which charset to save in]]]
-     ^file:delete[имя файла]
+     ^file:delete[filename]
-     ^file:find[имя файла][{когда не нашли}]
+     ^file:find[filename][{if not found}]
-     ^file:list[путь[;шаблон-строка|шаблон-regex]] = table с колонками name dir
+     ^file:list[path[;pattern-string|pattern-regex]]
-     ^file:list[путь;$.filter[шаблон-строка|шаблон-regex] $.stat(true)] = table с колонками name dir size [mca]date
+         table with columns name dir
-     ^file::load[text|binary;big.zip[;domain_press_release_2001_03_01.zip][;опции]]
+     ^file:list[path;$.filter[pattern-string|pattern-regex] $.stat(true)]
-     ^file::create[text|binary;имя;data]
+         table with columns name dir size [mca]date
-     ^file::create[text|binary;имя;data[;$.charset[кодировка букв в создаваемом файле] $.content-type[...]]]
+     ^file::load[text|binary;big.zip[;domain_press_release_2001_03_01.zip][;options]]
-     ^file::create[string-or-file-content[;$.name[имя] $.mode[text|binary] $.content-type[...] $.charset[...]]]
+     ^file::create[text|binary;filename;data]
-     $файл_который_был_loaded.size
+     ^file::create[text|binary;filename;data[;$.charset[charset of the created file] $.content-type[...]]]
-     $файл_который_был_loaded_или_created.mode = text/binary
+     ^file::create[string-or-file-content[;$.name[name] $.mode[text|binary] $.content-type[...] $.charset[...]]]
-     ^file::stat[имя файла]
+     $loaded_file.size
-     $файл_который_был_stated_или_loaded.size .adate .mdate .cdate
+     $loaded_or_created_file.mode = text/binary
-     ^file::cgi[[text|binary;]имя файла[;env hash +options[;1cmd[;2line[;3ar[;4g[;5s]]]]]]]
+     ^file::stat[filename]
-         возвращённый заголовок рассыпается на $поля
+     $stated_or_loaded_file.size .adate .mdate .cdate
+     ^file::cgi[[text|binary;]filename[;env hash +options[;1cmd[;2line[;3ar[;4g[;5s]]]]]]]
+         any argument can be string or array of strings
+         the returned header is split into $fields
          $status
          $stderr
-     ^file::exec[[text|binary;]имя файла[;env hash[;1cmd[;2line[;3ar[;4g[;5s;...under unix max 50 args]]]]]]]
+     ^file::exec[[text|binary;]filename[;env hash[;1cmd[;2line[;3ar[;4g[;5s;...under unix max 50 args]]]]]]]
+         any argument can be string or array of strings
          options:
-             $.stdin[текст|файл]  если пусто, отключается автоматическое пересовывание данных HTTP-POST
+             $.stdin[text|file] if empty, disables automatic passing of HTTP-POST data
-     ^file:move[старое имя файла;новое имя файла]
+     ^file:move[oldfilename;newfilename]
-         можно переименовывать и двигать каталоги[win32: но не через границу дисков]
+         can rename and move directories [win32: but not across disk boundaries]
-         каталоги для dest создаются с правами 775
+         directories for dest are created with 775 permissions
-         каталог старого файла стирается, если после move он остаётся пуст
+         source directory is removed if empty after move
-     ^file:copy[имя файла;имя копии файла]
+     ^file:copy[filename;copy_filename[; $.append(1) ]]
-         можно копировать только файлы
+         can only copy files
-     ^file:lock[имя файла]{код}
+     ^file:lock[filename]{code}
-         файл при необходимости создаётся
+         the file is created if necessary
-         блокируется
+         locked
-         выполняется код
+         code executed
-         разблокируется
+         unlocked
-     ^file:dirname[/a/some.tar.gz]=/a (работает аналогично комманде *nix)
+     ^file:dirname[/a/some.tar.gz|file]=/a (works like *nix command)
-     ^file:dirname[/a/b/]=/a (работает аналогично комманде *nix)
+     ^file:dirname[/a/b/|file]=/a (works like *nix command)
-     ^file:basename[/a/some.tar.gz]=some.tar.gz (работает аналогично комманде *nix)
+     ^file:basename[/a/some.tar.gz|file]=some.tar.gz (like *nix)
-     ^file:basename[/a/b/]=b (работает аналогично комманде *nix)
+     ^file:basename[/a/b/|file]=b (like *nix)
-     ^file:justname[/a/some.tar.gz]=some.tar
+     ^file:justname[/a/some.tar.gz|file]=some.tar
-     ^file:justext[/a/some.tar.gz]=gz
+     ^file:justext[/a/some.tar.gz|file]=gz
      /some/page.html: ^file:fullpath[a.gif] => /some/a.gif
-     ^файл.sql-string[] внутри ^connect даст правильно escaped строку, которую можно в запрос отдать
+     ^file.sql-string[]
-     ^file::sql{query}[[
+         inside ^connect gives a correctly escaped string that can be used in queries
-         $.name[имя_файла_для_download]
+     ^file::sql{query}[[ $.name[filename_for_download] $.content-type[user content-type] ]]
-         $.content-type[пользовательский content-type]
+         the query result should be "one row".
-     ]]
+         columns:
-         результат запроса должен быть "одна строка".
+         first column - data
-         колонки:
+         if second exists - filename
-         первая колонка - данные
+         if third - content-type
-         если есть вторая - это имя файла
+     ^file.base64[ $.pad(bool) $.wrap(bool) $.url-safe(bool) ]
-         если есть третья - это content-type
+         encode
-     ^файл.base64[] encode
+     ^file:base64[filename[; $.pad(bool) $.wrap(bool) $.url-safe(bool) ]]
-     ^file:base64[имя файла]
          encode
-     ^file::base64[encoded string]
+     ^file::base64[encoded string[; $.pad(bool) $.strict(bool) $.url-safe(bool) ]]
-     ^file::base64[mode;имя файла;encoded string[;$.content-type[...]]]
          decode
-     ^file:crc32[имя файла]
+     ^file::base64[mode;filename;encoded string[; $.content-type[...] $.pad(bool) $.strict(bool) $.url-safe(bool) ]]
-         вычисляет crc32 файла с указанным именем
+         decode
-     ^файл.crc32[]
+     ^file:crc32[filename]
-         вычисляет crc32 объекта
+         calculates crc32 of the specified file
-     ^файл.md5[]
+     ^file.crc32[]
-     ^file:md5[имя файла]
+         calculates crc32 of the object
-         выдает digest файла, длиной 16 байт в виде строки,
+     ^file.md5[], ^file:md5[filename]
-         где байты digest выданы в hex виде, впритык, в нижнем регистре
+         returns the file's digest, 16 bytes as a string,
+         bytes in hex, contiguous, lowercase
  math
      $math:PI
      ^math:round floor ceiling
      ^math:trunc frac
      ^math:abs sign
-     ^math:exp log
+     ^math:exp log log10
-     ^math:sin asin cos acos tan atan
+     ^math:sin asin cos acos tan atan atan2
      ^math:degrees radians
      ^math:pow sqrt
-     ^math:random(ширина диапазона)
+     ^math:random(range_width)
-     ^math:convert[number](base-from;base-to)
+     ^math:convert[number|file](base-from;base-to)[[ $.format[string|file] ]]
-         преобразует строку с числом из одной системы исчисления в другую
+     ^math:convert[number|file][alphabet](base-to)[[ $.format[string|file] ]]
-     ^math:uuid[]
+     ^math:convert[number|file](base-from)[alphabet][[ $.format[string|file] ]]
+         converts a string or file with a number from one numeral system to another
+         the numeral system can be set by an alphabet, a number from 2 to 16 (equivalent to the alphabet 0123456789ABCDEF), or 256 (all ASCII characters)
+     ^math:uuid[ $.lower(bool) $.solid(bool) ]
 C0983C-E26E-4169-BD07-77ECE9405BA5
-         win32: пользуется cryptapi
+         win32: uses cryptapi
-         unix: пользуется /dev/urandom,
+         unix: uses /dev/urandom,
-             если нет, /dev/random,
+             if not present, /dev/random,
-             если нет, rand
+             if not, rand
-             [на solaris /dev/random можно добавить]
+     ^math:uuid7[ $.lower(bool) $.solid(bool) ]
-     ^math:uid64[]
+CBF0-7898-7000-A391-AC513CC15658
+         https://www.rfc-editor.org/rfc/rfc9562.html#name-uuid-version-7
+     ^math:uid64[ $.lower(bool) ]
          BA39BAB6340BE370
      ^math:md5[string]
-         выдает digest строки, длиной 16 байт в виде строки,
+         returns the digest of the string, 16 bytes as a string,
-         где байты digest выданы в hex виде, впритык, в нижнем регистре
+         bytes in hex, contiguous, lowercase
      ^math:crypt[password;salt]
-         salt prefix $apr1$ вызывает встроенный MD5 алгоритм,
+         salt prefix $apr1$ triggers built-in MD5 algorithm,
-         если нет тела salt, оно создаётся случайным
+         if salt body is empty, it is generated randomly
-         $1$ вызывает MD5 алгоритм функции OS 'crypt', если поддерживается [заведомо нет на solaris].
+         $1$ calls the OS 'crypt' MD5 algorithm if supported.
-         другие salt читайте документацию по функции OS 'crypt'.
+         for other salts see OS 'crypt' documentation.
      ^math:crc32[string]
-         вычисляет crc32 строки
+         calculates crc32 of the string
      ^math:sha1[string]
-     ^math:digest[[md5|sha1|sha256|sha512];строка или файл][[ $.format[hex|base64] $.hmac[ключ] ]]
+     ^math:digest[[md5|sha1|sha256|sha512];string or file][[ $.format[hex|base64|file] $.hmac[key string|key file] ]]
-         объединяет в себе возможность работы с разными алгоритмами криптографического хеширования.
+         combines the ability to use various cryptographic hashing algorithms.
-         $.hmac[ключ] для проверки целостности переданных данных
+         $.hmac[key] for verifying the integrity of transmitted data
  inet
      ^inet:ntoa(long)
      ^inet:aton[IP]
-     ^inet:name2ip[name][[ $.ipv[4|6|any] $.table(true) ]] прямое преобразование имени в IP адрес
+     ^inet:name2ip[name][[ $.ipv[4|6|any] $.table(true) ]]
-     ^inet:ip2name[ip][ $.ipv[4|6|any] ]] обратное преобразование из IP адреса в имя
+         direct conversion of a name to an IP address
+     ^inet:ip2name[ip][ $.ipv[4|6|any] ]
+         reverse conversion from IP address to name
+     ^inet:hostname[]
+         host name
  json
-     ^json:parse[-json-строка-[;
+     ^json:parse[-json-string-[;
-         $.depth(максимальная глубина, default == 19)
+         $.depth(maximum depth, default == 19)
-         $.double(false)              отключить встроенный парсинг чисел с плавающей точкой (по умолчанию включен)
+         $.double(false)              disable built-in parsing of floating-point numbers (enabled by default)
-                                      в этом случае они попадут в результирующий объект как строки
+                                      in this case they will appear in the resulting object as strings
-         $.int(false)                 отключить встроенный парсинг целых чисел (по умолчанию включен)
+         $.int(false)                 disable built-in parsing of integers (enabled by default)
-                                      в этом случае они попадут в результирующий объект как строки
+                                      in this case they will appear in the resulting object as strings
-         $.distinct[first|last|all]   как будет происходить разбор дублирующихся ключей у объектов
+         $.distinct[first|last|all]   how duplicate keys in objects are handled
-                                      first -- будет оставлен первый встретившийся элемент
+                                      first - keep the first encountered element
-                                      last  -- будет оставлен последний встретившийся элемент
+                                      last  - keep the last encountered element
-                                      all   -- будут оставлены все элементы. при этом элементы, начиная со 2
+                                      all   - keep all elements. starting from the 2nd,
-                                               получат числовые суффиксы (key_2 итд)
+                                               they get numeric suffixes (key_2 etc)
-                                      по умолчанию дублирующиеся ключи приведут к exception
+                                      by default duplicate keys cause an exception
-         $.object[method-junction]    пользовательский метод[ключ;объект], которому будут передаваться все разобранные
+         $.object[method-junction]    user method[key;object], called for all parsed
-                                      объекты и ключи объекта, метод возвращает новый объект
+                                      objects and object keys; method returns a new object
-         $.array[method-junction]     пользовательский метод, которому будут передаваться массивы
+         $.array[method-junction]     user method called for arrays
-         $.taint[язык преобразования] задаёт язык преобразования для всех строк результата
+         $.taint[taint language]      sets the transformation language for all result strings
      ]]
-         парсит json-строку в хэш
+         parses a json-string into a hash
      ^json:string[system or user object[;
-         $.skip-unknown(false)    отключить exception и выдавать 'null' при сериализации объектов с типами
+         $.skip-unknown(false)    disable exception and output 'null' when serializing objects of types
-                                  отличных от void, bool, string, int, double, date, table, hash и file
+                                  other than void, bool, string, int, double, date, table, hash, and file
-         $.indent(true)           форматировать результирующую строку табуляциями по глубине вложенности
+         $.indent(true)           format the resulting string with indentation according to nesting depth
-         $.date[sql-string|gmt-string|iso-string|unix-timestamp]    формат вывода даты, по умолчанию -- sql-string
+         $.date[sql-string|gmt-string|iso-string|unix-timestamp]
-         $.table[object|array|compact]    формат вывода таблицы, по умолчанию -- object
+                                  date output format, default = sql-string
+         $.table[object|array|compact]
+                                  format for tables, default=object
                                   object: [{"c1":"v11","c2":"v12",...},{"c1":"v21","c2":"v22",...},...]
                                   array:  [["c1","c2",...] || null (for nameless),["v11","v12",...],...]
-                                  compact:  ["v11" || ["v11","v12",...],...]
+                                  compact: ["v11" || ["v11","v12",...],...]
-         $.file[text|base64|stat] вывести тело файла в указанном виде (по умолчание тело файла
+         $.file[text|base64|stat] output file content in the specified mode (by default file content
-                                  не попадает в output)
+                                  is not included in output)
-         $.xdoc[hash]             параметры преобразования xdoc в строку (как в ^xdoc.string[])
+         $.xdoc[hash]             parameters for converting xdoc to string (as in ^xdoc.string[])
-         $.тип[method-junction]   любой тип можно вывести с помощью пользовательского метода, который
+         $.type[method-junction]  any type can be output using a user method
-                                  должен принимать 3 параметра: ключ, объект данного типа и опции
+                                  that must take 3 parameters: key, object of that type, and options
-                                  вызова ^json:string[]
+                                  of the ^json:string[] call
-         $._default[метод]        пользовательский метод, будет вызываться для вывода всех объектов пользовательских
+         $._default[method]       user method, called to output all user-class objects.
-                                  классов. Метод должен принимать 3 параметра: ключ, объект и опции вызова.
+                                  The method must take 3 parameters: key, object, and call options.
-         $._default[имя метода]   имя пользователького метода, при его наличии он будет вызван для
+         $._default[method name]  method name of a user method, if present it will be called for serialization
-                                  сериализации
+         $.void[null|string]      undefined value will be output as null (default)
-         $.void[null|string]      неопределенное значение будет выдано в виде null (по умолчанию)
+                                  or as an empty string
-                                  или пустой строки
      ]]
-         сериализует системный или пользовательский объект в json-строку
+         serializes a system or user object into a json-string
  date
-     время типа time можно использовать в выражениях, подставляет количество дней с epoch [1 января 1970 (UTC)], дробное.
+     date type can be used in expressions, substituting the number of days since epoch [1 January 1970 (UTC)], fractional
-     Строковое значение в местном времени, численное в UTC, диапазон от 0000-00-00 00:00:00 до 9999-12-31 23:59:59.
+     the string value is in local time, numerically in UTC, range from 0000-00-00 00:00:00 to 9999-12-31 23:59:59
-     по умолчанию используется установленная средствами OS временная зона
+     by default the OS-defined timezone is used
      ^date::now[]
-     ^date::now(смещение в днях) выдаёт сейчас+смещение
+     ^date::now(days offset)
-     ^date::today[] дата на 00:00:00 текущего дня
+         returns now+offset
-     ^date::create(дней с epoch)
+     ^date::today[]
+         date at 00:00:00 of the current day
+     ^date::today(integer days offset)
+         date at 00:00:00 of current day+offset
+     ^date::create(days since epoch)
      ^date::create(year;month[;day[;hour[;minute[;second[;TZ]]]]])
-     ^date::create[дата в формате %Y-%m-%d %H:%M:%S]
+     ^date::create[date in format %Y-%m-%d %H:%M:%S]
-         для удобного создания по значению из базы
+         convenient creation from a value from a database
-         формат1: %Y[-%m[-%d[ %H[:%M[:%S]]]]]
+         format1: %Y[-%m[-%d[ %H[:%M[:%S]]]]]
-         формат2: %H:%M[:%S]
+         format2: %H:%M[:%S]
-     ^date::create[дата в формате %Y-%m-%dT%H:%M[:%S]TZ]
+     ^date::create[date in format %Y-%m-%dT%H:%M[:%S]TZ]
-         для создания по значению в формате ISO 8601
+         for creation from ISO 8601 format
-         формат TZ: Z(UTC) или +-hour[:minute] (смещение от UTC)
+         TZ format: Z(UTC) or +-hour[:minute] (offset from UTC)
      ^date::unix-timestamp()
-     ^дата.unix-timestamp[]
+     ^date.unix-timestamp[]
-     $дата.year month day hour minute second weekday yearday(0...) daylightsaving TZ weekyear
+     $date.year month day hour minute second weekday yearday(0...) daylightsaving TZ weekyear
-         TZ="" << локальная зона
+         TZ="" << local zone
-     $дата.year month day hour minute second можно задать новое значение, остальные read only
+     $date.year month day hour minute second can be set to new values, others are read-only
-     ^дата.roll[year|month|day](+-смещение) сдвигает дату
+     ^date.double[] ^date.int[]
-     ^дата.roll[TZ;Новая зона] говорит, что дата в таком-то часовом поясе: влияет на .hour & Co
+         the number of days since epoch [1 January 1970 (UTC)], fractional or truncated
-     ^date:roll[TZ;Новая зона] говорит, что по умолчанию все даты в таком-то часовом поясе
+     ^date.roll[year|month|day](+-offset)
-     ^дата.sql-string[[datetime|date|time]]
+         shifts the date
-         datetime или без параметра -- %Y-%m-%d %H:%M:%S
+     ^date.roll[TZ;New zone]
-         date                       -- %Y-%m-%d
+         says that the date is in such a timezone: affects .hour & Co
-         time                       -- %H:%M:%S
+     ^date:roll[TZ;New zone]
-         where published='^дата.sql-string[]'
+         says that by default all dates are in that timezone
-     ^date:calendar[rus|eng](год;месяц) выдаёт неименованную таблицу
+     ^date.sql-string[[datetime|date|time]]
-         столбцы: 0..6, week, year
+         datetime or without parameter - %Y-%m-%d %H:%M:%S
-     ^date:calendar[rus|eng](год;месяц;день) выдаёт именнованную таблицу
+         date                          - %Y-%m-%d
-         столбцы: year, month, day, weekday
+         time                          - %H:%M:%S
-     ^date:last-day(год;месяц) вернёт последний день месяца
+         where published='^date.sql-string[]'
-     ^дата.last-day[] вернёт последний день месяца $дата
+     ^date:calendar[rus|eng](year;month)
-     ^дата.gmt-string[]  Fri, 23 Mar 2001 09:32:23 GMT
+         returns an unnamed table, columns: 0..6, week, year
-     ^дата.iso-string[]  2001-03-23T12:32:23+03
+     ^date:calendar[rus|eng](year;month;day)
+         returns a named table, columns: year, month, day, weekday
+     ^date:last-day(year;month)
+         returns the last day of the month
+     ^date.last-day[]
+         returns the last day of $date's month
+     ^date.gmt-string[]
+         Fri, 23 Mar 2001 09:32:23 GMT
+     ^date.iso-string[]
+-03-23T12:32:23+03
+ console
+     $console:timeout
+     $console:line
+         read/write string
+ memory
+     ^memory:compact[]
+         collect garbage, freeing space for new data (warning: process memory is never released)
+         useful before XSL transform
+     ^memory:auto-compact(frequency)
+         sets automatic garbage collection frequency, from 0 (off) up to 5 (max)
+ status
+     $status:sql
+         cache table
+             url    time
+             url    time
+             url    time
+     $status:stylesheet
+         cache table
+             file    time
+             file    time
+             file    time
+     $status:rusage hash
+         utime user time used
+         stime system time used
+         maxrss max resident set size
+         ixrss integral shared text memory size
+         idrss integral unshared data size
+         isrss integral unshared stack size
+         tv_sec
+         tv_usec
+            $s[$status:rusage]
+            ^s.tv_sec.format[%.0f].^s.tv_usec.format[%06.0f]
+     $status:memory hash
+         used
+             includes some pages that were allocated but never written
+         free
+         ever_allocated_since_compact
+             return the number of bytes allocated since the last collection
+         ever_allocated_since_start
+             return the total number of bytes [EVER(c)PAF] allocated in this process,
+             never decreases
+     $status:pid
+         process id
+     $status:tid
+         thread id
+     $status:mode
+         working mode, cgi|console|mail|httpd|apache|isapi
+     $status:log-filename
+         path to parser3.log error log
  xdoc(xnode)
      $xdoc.search-namespaces hash, where keys=prefixes, values=urls
- Line 982  xdoc(xnode)
+ Line 1175  xdoc(xnode)
          Implementations that do not know whether attributes are of type ID or not
          are expected to return null.
-     кодировка строк и умолчание для $.encoding
+     String encoding and default for $.encoding equals the current output page encoding, $response:charset
-     равно текущей кодировке выходной страницы,
-         $response:charset
      ::sql{...}
-     ::create[[URI]]{<?xml?><string/>} старое имя 'set'
+     ::create[[URI]]{<?xml?><string/>} old name 'set'
      ::create[[URI]][qualifiedName]
-       URI default = disk path to requested document
+         URI default = disk path to requested document
-       для каталогов конечный / обязателен
+         for directories a trailing / is mandatory
      ::create[file] can be usable:
          $f[^file::load[binary;http://;some HTTP options here...]]
          $x[^xdoc::create[$f]]
-     ::load[file.xml[;опции]]
+     ::load[file.xml[;options]]
-     .transform[rules.xsl|xdoc][[params hash]] выдаёт dom
+     .transform[rules.xsl|xdoc][[params hash]] returns dom
-         шаблон кешируется, кеш обновляется при изменении даты файла шаблона,
+         the template is cached, cache is updated if the template file date changes,
-         или изменении даты файла "имя шаблона.stamp"[проверка даты stamp приоритетнее]
+         or the date of "template_name.stamp" changes [stamp date check has priority]
          <xsl:output
          method = "xml" | "html" | "text"
          version = nmtoken
          encoding = string
          omit-xml-declaration = "yes" | "no"
          standalone = "yes" | "no"
          cdata-section-elements = qnames
          indent = "yes" | "no"
          media-type = string />
-         параметры передаются как есть, не xpath выражения
+         parameters are passed as is, not xpath expressions
      .string[[output options]]
-     .save[file.xml[;output options]] с шапкой
+     .save[file.xml[;output options]] with header
      .file[[output options]] = file
-         output options идентичны атрибутам xsl:output
+         output options are identical to xsl:output attributes
-             [исключение: игнорируется cdata-section-elements, нужно будет, сделаю]
+             [exception: cdata-section-elements ignored]
-         выдаёт media-type при подстановке $response:body[сюда]
+         returns media-type when substituting $response:body[here]
-     если на документ ссылаются так:
+     if the document is referenced as:
          parser://method/param/to/that/method
-         то в качестве документа используется ^MAIN:method[/param/to/that/method]
+         then ^MAIN:method[/param/to/that/method] is used as the document
-         [примечание: в параметр всегда приходит лидирующая /, даже, если параметров вообще не было]
+         [note: the parameter always comes with a leading /, even if there were no parameters]
  xnode
      DOM1 attributes:
- Line 1054  xnode
+ Line 1245  xnode
      $element_node.tagName
      $attribute_node.specified = boolean
          true if the attribute received its value explicitly in the XML document,
-         or if a value was assigned programatically with the setValue function.
+         or if a value was assigned programmatically with the setValue function.
          false if the attribute value came from the default value declared in the document's DTD.
      $attribute_node.name
      $attribute_node.value
      $text_node/cdata_node/comment_node.substringData
      $pi_node.target = target of this processing instruction
-         XML defines this as being the first token following the markup
+         XML defines this as the first token following the markup
          that begins the processing instruction.
      $pi_node.data = The content of this processing instruction
-         This is from the first non white space character after the target
+         From the first non-whitespace character after the target
          to the character immediately preceding the ?>.
      document_node.
          readonly attribute DocumentType doctype
- Line 1095  xnode
+ Line 1286  xnode
      NodeList getElementsByTagName(in DOMString name)
      void normalize()
      Introduced in DOM Level 2:
      Node importNode(in Node importedNode, in boolean deep) raises(DOMException)
      NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName)
      boolean hasAttributes()
      XPath:
      ^node.select[xpath/query/expression] = array of nodes,
          empty array if nothing found
      ^node.selectSingle[xpath/query/expression] = first node if any
      ^node.selectBool[xpath/query/expression] = bool if any or die
      ^node.selectNumber[xpath/query/expression] = double if any or die
      ^node.selectString[xpath/query/expression] = string if any or die
- memory
-     ^memory:compact[] собрать мусор, освободив место под новые данные
-     (предупреждение: память процесса никогда не освобождается)
-     полезно делать перед XSL transform.
- status
-     $status:sql
-         cache table
-             url    time
-             url    time
-             url    time
-     $status:stylesheet
-         cache table
-             file    time
-             file    time
-             file    time
-     $status:rusage hash
-         utime user time used
-         stime system time used
-         maxrss max resident set size
-         ixrss integral shared text memory size
-         idrss integral unshared data size
-         isrss integral unshared stack size
-         tv_sec
-         tv_usec
-            $s[$status:rusage]
-            ^s.tv_sec.format[%.0f].^s.tv_usec.format[%06.0f]
-     $status:memory hash
-         used
-             Includes some pages that were allocated but never written.
-         free
-         ever_allocated_since_compact
-             Return the number of bytes allocated since the last collection.
-         ever_allocated_since_start
-             Return the total number of bytes [EVER(c)PAF] allocated in this process.
-             Never decreases.
-     $status:pid process id
-     $status:tid thread id
- console
-     $console:timeout
-     $console:line
-         read/write строку
  DATA::=string | file | hash
+     hash of the form
-     hash вида
      [
-         $.file[имя файла на диске]
+         $.file[filename on disk]
-         $.name[имя файла для пользователя]
+         $.name[filename for user]
          $.mdate[date]
      ]
  MAIN
-     это класс, загружаемый на автомате из конфигурационного auto.p, кучи auto.p и запрашиваемого документа:
+     this is the class automatically loaded from the configuration auto.p, a bunch of auto.p and the requested document:
-         конфигурационный auto.p
+         configuration auto.p
              cgi:
-. или полный путь из переменной окружения CGI_PARSER_SITE_CONFIG или рядом с бинарником parser'а
+. either full path from environment variable CGI_PARSER_SITE_CONFIG or next to parser binary
              isapi: windows directory
              apache module:
 ) ParserConfig [can be in .htaccess]
-         auto.p вниз от DOCUMENT_ROOT/ по дереву до каталога с обрабатываемым файлом включительно
+         auto.p goes down from DOCUMENT_ROOT/ through the directory tree to the directory of the processed file, inclusive
-     класс собирается из всех этих файлов, последующие становятся родителями предыдущих
+     the class is assembled from all these files, subsequent ones become parents of the previous ones
-     имя последнего загруженного MAIN, имён у предыдущих нет
+     the name of the last loaded is MAIN, previous ones have no names
-     после загрузки MAIN класса вызывается его @main[]
+     after loading MAIN class, its @main[] is called
-     результат которого передаётся в его @postprocess[data] if($data is string) ...
+     the result is passed to its @postprocess[data] if($data is string) ...
-     результат которого отдаётся пользователю
+     the result is then returned to the user
- если встречается ошибка и try не задан, её можно красиво сообщить пользователю, определив
+ if an error occurs and try is not specified, it can be nicely reported to the user by defining
      @unhandled_exception[exception;stack]
-         $exception.type  строка "тип проблемы"
+         $exception.type  string "type of problem"
-         $exception.file $exception.lineno $exception.colno файл, строка и позиция, где случилась проблема [если не запрещены при компиляции]
+         $exception.file $exception.lineno $exception.colno file, line and position where the problem occurred [if not disabled at compile time]
-         $exception.source строка, из-за которой случилась проблема
+         $exception.source line that caused the problem
-         $exception.comment комментарий english
+         $exception.comment English comment
-         stack табличка из колонок file line name,
+         stack table with columns file line name,
-             там лежат в обратном порядке имена[name] и места вызовов[file line]
+             in reverse order the names[name] and places[file line] of the operators/methods that caused the error.
-             операторов/методов, приведших к ошибке.
- при загрузке файла (file::load, table::load, xdoc::load) можно указать такое имя файла:
+ when loading a file (file::load, table::load, xdoc::load) you can specify such a filename:
      http://domain/document[?params<<deprecated, use $.form[...]]
-     а также, возможно, указать опции:
+     and possibly specify options:
          $.method[GET|POST|HEAD]
-         $.timeout(3)  << в секундах, по-умолчанию =2
+         $.timeout(3)  << in seconds, default=2
          $.cookies[
-             $.имя[значение]
+             $.name[value]
          ]
          $.headers[
-             $.поле[значение] << значение имеет формат, как $response:ЗАГОЛОВОК
+             $.field[value] << value format like $response:HEADER
          ]
          $.enctype[multipart/form-data]
          $.form[
- Line 1213  MAIN
+ Line 1350  MAIN
              $.field3[file]
          ]
          $.body[string|file]
-         по-умолчанию, user-agent=parser3
+         default user-agent=parser3
-         по-умолчанию, получение http status != 200 >> создает http.status ошибку, это можно отключить, передав $.any-status(1)
+         by default, getting http status != 200 >> creates http.status error, can be disabled by $.any-status(1)
-         $.charset[кодировка удалённых документов по-умолчанию], если сервер вернёт content-type:charset - ОНА_ПЕРЕБИВАЕТ
+         $.charset[default encoding of remote documents], if server returns content-type:charset - IT OVERRIDES
-         $.response-charset[кодировка удалённых документов], не перебиваеся content-type:charset
+         $.response-charset[encoding of remote documents], not overridden by content-type:charset
-         $.user[пользователь]
+         $.user[user]
-         $.password[пароль]
+         $.password[password]
-     file::load в дополнительные поля записывает
+     file::load writes additional fields
-         ПОЛЕ:значение (имена полей ответа заглавными буквами)
+         FIELD:value (response field names in uppercase)
-         tables << хеш их ПОЛЕ->table с единственным столбцом "value".
+         tables << a hash of FIELD->table with a single column "value"
-             в таких таблицах можно брать повторяющиеся заголовки. например, несколько set-cookies
+             in such tables you can get repeating headers, e.g. multiple set-cookies
-             todo:сделать отдельный cookies
+             todo: make separate cookies
- системные типы ошибок:
+ system error types:
-     parser.compile       ^test[}                компиляция (непарная скобка, ...)
+     parser.compile       ^test[}                compilation (unmatched bracket, ...)
-     parser.runtime       ^if(0).                параметры (больше/меньше, чем нужно, не тех типов, ...)
+     parser.runtime       ^if(0).                parameters (more/less than needed, wrong types, ...)
      number.zerodivision  ^eval(1/0) ^eval(1%0)
      number.format        ^eval(abc*5)
      file.lock                                                        shared/exclusive lock error
- Line 1245  MAIN
+ Line 1382  MAIN
      xml                  ^xdoc::create{<forgot?>}                    any error in xml/xslt libs
      smtp.connect                                                     not found/timeout
      smtp.execute                                                     communication error
-     email.format         hren tam@null.ru                            wrong email format(bad chars/empty)
+     email.format         hren tam@null.ru                            wrong email format (bad chars/empty)
      email.send           $MAIL.sendmail[/shit]                       sendmail not executable
      http.host            ^file::load[http://notfound/there]          host not found
-     http.connect         ^file::load[http://not_accepting/there]     host found, but do not accept connections
+     http.connect         ^file::load[http://not_accepting/there]     host found, but does not accept connections
-     http.timeout         ^file::load[http://host/doc]                whole load operation failed to complete in # seconds
+     http.timeout         ^file::load[http://host/doc]                load operation failed to complete in # seconds
      http.response        ^file::load[http://ok/there]                host found, connection accepted, bad answer
      http.status          ^file::load[http://ok/there]                host found, connection accepted, status!=200
      date.range           ^date::create(10000;1;1)                    date out of valid range
- если в MAIN определён $SIGPIPE(1) то в случае, если обработка была прервана пользователем, сообщение
+ if $SIGPIPE(1) is defined in MAIN, then if processing was interrupted by the user, a message
-     об этом будет записано в parser3.log
+     about this is written to parser3.log
- если описание метода содержит локальную переменную result в явном виде (есть и неявная переменная)
+ if the method description explicitly contains the local variable result (there is also an implicit variable),
-     то код вывода пробельных литералов не попадает в конечный байт-код.
+     then the code for outputting whitespace literals does not get into the final bytecode

E-mail:

Removed from v.1.253
changed lines
	Added in v.1.260