|
version 1.12, 2002/02/20 09:13:07
|
version 1.271, 2026/05/06 20:33:38
|
|
Line 1
|
Line 1
|
| !сделано |
operators |
| Xне сделано, видимо, не будет сделано |
^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: |
| !^eval(выражение)[формат] выражение, кроме обычных функций:: |
| bitwise XOR |
| !из неочевидных операторов: |
|| logical XOR |
| # побитный xor |
~ bitwise negation |
| ## логический xor |
\ integer division 10\3=3 |
| ~ побитное отрицание |
def checks if defined: |
| \ целочисленное деление 10\3=3 |
an empty string is not defined |
| !def для проверки defined, |
an empty table is not defined |
| пустая строка не defined |
an empty hash is not defined |
| пустая таблица не defined |
eq ne lt gt le ge for string comparison, |
| пустой hash не defined |
in "/dir/" to check if the current document is located in the specified directory |
| !eq ne lt gt le ge для сравнения строк, |
["no expressions allowed inside; if you need a complex comparison, assign it to a variable"] |
| !in "/dir/" для проверки[раньше ^start] |
is 'type' to check the type of the left operand, |
| ["внутри не допустимы, если надо сравнить со сложным, |
e.g., "is the method parameter not a hash?" |
| пусть это будет переменная]. |
-f checks if a file exists on disk, |
| !is 'type' для проверки типа левого операнда, |
-d checks if a directory exists on disk, |
| скажем, можно проверить, "не hash ли параметр метода?" |
a quoted string (double or single quotes) is treated as a string, unquoted text is a string until the nearest whitespace |
| !-f для проверки существования файла на диске, |
numeric literals can be in hex format like 0xABC |
| !-d для проверки существования каталога на диске, |
priorities: |
| !строка в кавычках|апострофах - строка, без кавычек|апострофов строка до |
/* logical */ |
| ближайшего whitespace |
%left "!||" |
| !числовой литерал бывает 0xABC |
%left "||" |
| !приоритеты: |
%left "&&" |
| /* logical */ |
%left '<' '>' "<=" ">=" "lt" "gt" "le" "ge" |
| %left "##" |
%left "==" "!=" "eq" "ne" |
| %left "||" |
%left "is" "def" "in" "-f" "-d" |
| %left "&&" |
%left '!' |
| %left '<' '>' "<=" ">=" "lt" "gt" "le" "ge" |
|
| %left "==" "!=" "eq" "ne" |
/* bitwise */ |
| %left "is" "def" "in" "-f" "-d" |
%left '!|' |
| %left '!' |
%left '|' |
| |
%left '&' |
| /* bitwise */ |
%left '~' |
| %left '#' |
|
| %left '|' |
/* numerical */ |
| %left '&' |
%left '-' '+' |
| %left '~' |
%left '*' '/' '%' '\\' |
| |
%left '~' /* negation: unary */ |
| /* numerical */ |
|
| %left '-' '+' |
literals: |
| %left '*' '/' '%' '\\' |
true |
| %left NEG /* negation: unary - */ |
false |
| !^if(условие){когда да}{когда нет} |
|
| !^switch[значение]{^case[вариант1[;вариант2...]]{действие}^case[DEFAULT]{действие по умолчанию}} |
^if(condition){then}{else} |
| !^while(условие){тело} |
^if(condition1){yes}[(condition2){yes}[(condition3){yes}[...]]]{no} |
| !^for[i](0;4){тело}[[разделитель]|{разделитель который выполняется перед непустым очередным не первым телом}] |
unlimited number of additional conditions (elseif) |
| X^exit[] + - прекращяет обработку запроса. |
|
| удобно сделать после выставления 401 ошибки |
^switch[value]{^case[var1[;var2...]]{action}^case[DEFAULT]{default action}} |
| X^return[результат] + - отваливает из выполнения метода, |
|
| выдавая нестандартный результат |
^while(condition){body}[[delimiter]|{delimiter executed before each non-empty non-first body}] |
| X^break[] + - обрывает цикл |
|
| X^continue[] + - обрывает итерацию цикла |
^for[i](0;4){body}[[delimiter]|{delimiter executed before each non-empty non-first body}] |
| !^use[модуль] |
|
| X^try{код}{...catch...} пока не придумал, как лучше |
^try{ |
| !^untaint[[as-is|file-spec|http-header|mail-header|uri|table|sql|js|xml|html|optimized-html]]{код} |
... |
| |
^throw[sql.connect[;vasya[;mistaken]]] // previously ^error[text] |
| |
^throw[ |
| |
$.type[sql.connect] |
| |
$.source[vasya] |
| |
$.comment[mistaken] |
| |
] |
| |
... |
| |
}{ |
| |
^if($exception.type eq "sql"){ |
| |
$exception.handled(1|true) ^rem{flag that exception is handled} |
| |
.... |
| |
} |
| |
^switch[$exception.type]{ |
| |
^case[sql;mail]{ |
| |
$exception.handled(1) |
| |
code handling sql error |
| |
$exception.type = sql.connect |
| |
$exception.file $exception.lineno $exception.colno [if not disabled at compile time] |
| |
$exception.source = vasya |
| |
$exception.comment = mistaken |
| |
} |
| |
^case[DEFAULT]{ |
| |
code handling another error |
| |
^throw[$exception] << re-throw // DON'T! It's default behaviour! |
| |
} |
| |
} |
| |
} |
| |
|
| |
^break[] |
| |
breaks the loop |
| |
^break(true|false) |
| |
breaks the loop if true |
| |
|
| |
^continue[] |
| |
breaks the current iteration of the loop |
| |
^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]]]{code} |
| default as-is |
default as-is |
| !^taint[[lang]][код] |
|
| |
^taint[[lang]][code] |
| default "just tainted, language unknown" |
default "just tainted, language unknown" |
| !^process[строка, которая будет process-ed, как код] |
|
| !^connect[protocol://строка соединения]]{код с ^sql[...]-ями} |
|
| !mysql://user:pass@{host[:port]|[/unix/socket]}/database? |
|
| charset=cp1251_koi8& |
|
| timeout=3& |
|
| compress=1& |
|
| named_pipe=1 |
|
| |
|
| !pgsql://user:pass@{host[:port]|[local]}/database |
^apply-taint[[lang;]text] |
| |
applies transformations specified in the string, "indefinitely dirty" is considered as lang, producing a clean string |
| 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 |
|
| |
|
| !odbc://DSN=dsn^;UID=user^;PWD=password |
^process[[$caller.CLASS|$object|$CLASS:CLASS]]{string to be processed as code}[ |
| |
$.main[what to rename @main to] |
| |
$.file[name of the file supposedly containing this text] |
| |
$.lineno(line number in the file from where this text originated, can be negative) |
| |
] |
| |
^process..[path][what to rename @main to] |
| |
by default, methods are compiled into $self [in case of operator, $self=$MAIN:CLASS] |
| |
|
| |
^connect[protocol://connection-string]]{code with ^sql[...] calls} |
| |
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 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 |
| |
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 |
| |
|
| |
odbc://DSN=dsn^;UID=user^;PWD=password^;ClientCharset=parser-charset |
| |
ClientCharset << charset in which parser thinks client works |
| |
|
| |
sqlite://DBfile? |
| |
ClientCharset=parser-charset& << charset in which parser thinks client works |
| |
autocommit=1 |
| |
|
| для работы connect нужно, чтобы заранее(рекомендуется в системном parser3) |
to use ^connect, the $SQL table must be defined beforehand (recommended in the system configuration auto.p) |
| была определена таблица |
|
| #sql drivers |
#sql drivers |
| $SQL[ |
$SQL[ |
| $.drivers[^table::set{protocol driver client |
$.drivers[^table::create{protocol driver client |
| mysql /www/parser3/libparser3mysql.so /usr/local/lib/mysql/libmysqlclient.so |
mysql $prefix/libparser3mysql.so libmysqlclient.so |
| pgsql /www/parser3/libparser3pgsql.so /usr/local/pgsql/lib/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 |
| odbc c:\drives\y\parser3project\odbc\debug\parser3odbc.dll |
odbc parser3odbc.dll |
| }] |
}] |
| ] |
] |
| !в таблице у oracle в столбце клиентской библиотеки |
^rem{} |
| допустимо задать environment параметры инициализации(если они не заданы иначе заранее), |
a comment, removed at compile time |
| допустимы имена, начинающиеся на NLS_ ORA_ и ORACLE_, или оканчивающиеся на + |
|
| под win32 |
^syslog[ident;message[;info|warning|error|debug]] |
| необходим PATH+=^;C:\Oracle\Ora81\bin |
writes a message to syslog |
| к сведению: |
|
| ORA_NLS33 нужен для считывания файлика с клиентской кодировкой(задаваемой NLS_LANG) |
^cache[file](seconds){code}[{catch code}] |
| если кодировка не по-умолчанию, обязательно указать в .drivers, |
relative time assignment |
| иначе будет сообщение про неправильный NLS параметр |
caches the string resulting from the code execution for 'seconds' seconds |
| (имеют в виду, что не нашли кодировку из NLS_LANG) |
if 0 seconds, do not cache, and remove any existing old cache |
| ORACLE_HOME нужен для считывания текстов сообщений об ошибках, |
in the catch code, $exception.handled[cache] ^rem{flag that exception is handled} |
| можно указывать и в строке соединения, но глобален, и лучше вынести за скобки, |
^cache[file][expires date]{code}[{catch code}] |
| в отличие от клиентской кодировки NLS_LANG, и прочего. |
absolute time assignment |
| |
^cache[file] |
| ВНИМАНИЕ: при работе с большими текстовыми блоками в oracle&pgsql[а лучше всегда], |
deletes the file [no error if it doesn't exist] |
| ставить такой префикс перед открывающим апострофом, впритык, везде без проблелов |
^cache(seconds) |
| /**имя_поля**/'literal' |
^cache[expires date] |
| !^rem{} |
signals to the upper-level ^cache "reduce it to these many 'seconds'/'expires'" |
| !^error[текст] |
ultimately: ^cache(0) cancels caching |
| !^cache[файл](секунд){код} |
^cache[] |
| !скэшировать строку, которая получается при выполнении кода на 'секунд' секунд |
returns the current expires date |
| !если 0секунд, значит не кэшировать, а старый такой стереть |
|
| |
each method has a local variable $result. If you put something in it, |
| Xесть глобальный флажок в свойствах/командной строке "не оптимизировать" |
that will be the method's result, not its body |
| !и есть исключение: ^untaint[html]{код} не оптимизируется безотностительно флажка |
|
| |
each method has a local variable $caller, containing the parent stack frame, |
| !у всех макросов есть локальная переменная $result, если в неё что положить, |
you can write to its local variables |
| !то _это_ будет результатом макроса, а не его тело |
|
| |
use(^use or @USE) searches for and includes a file: |
| !use(^use или @USE) ищет файл... |
1. If the path starts with /, it is considered a path from the web root |
| !1. ...если путь начинается с /, то считается, что это путь от корня веб пространства |
2. Relative to the current directory |
| !есть глобальная строка/таблица $MAIN:CLASS_PATH с путём/путями к каталогу с классами. |
3. Relative to strings from the $MAIN:CLASS_PATH table, bottom-up |
| !корень путя/путей считается от корня веб пространства. |
$MAIN:CLASS_PATH is a global string or table with a path or paths to a directory |
| !2. ...относительно строчки из table $MAIN:CLASS_PATH, снизу вверх |
with classes (from the web root), set it in the configuration auto.p |
| задавайте её в parser3.conf вашего сайта |
|
| |
A global table $CHARSETS[$.name[filename]] |
| !глобальная табличка $CHARSETS[$.название[имя файла]] |
defines which characters are considered what (whitespace, letter, etc.), as well as their Unicode |
| !задаёт какие буквы считаются какими(whitespace, letter, etc), а также их unicode |
format: tab-delimited file, with a header: |
| !формат: tab delimited файл, с заголовком: |
char white-space digit hex-digit letter word lowercase unicode1 unicode2 |
| ! 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 |
where char and lowercase can be letters or 0xCODES |
| ! где char и lowercase могут быть буквами, а могут быть и 0xКОДАМИ |
if the character has a single Unicode representation equal to itself, you can omit unicode |
| ! если символ имеет единственное unicode представление, равное самому символу, |
UTF-8 is always available and is the default encoding for request and response |
| ! можно не указывать unicode |
WARNING: the encoding name is case-insensitive |
| !всегда есть кодировка UTF-8, |
|
| !она является кодировкой по-умолчанию для request и response |
syntax |
| !ВНИМАНИЕ: имя кодировки case sensitive |
$name[new value] |
| |
$name(arithmetic expression of new value) |
| синтаксис |
$name{code of new value} |
| !$имя[новое значение] |
$name whitespace or ${name}something - variable value |
| !$имя(математическое выражение нового значения) |
^name parameters - call |
| !$имя{код нового значения} |
$name.CLASS - class of the value |
| !$имя whitespace или ${имя}неважно подстановка значения |
$name.CLASS_NAME - name of the class |
| !^имя параметры вызов |
$name[$.key[] () {}] - constructor of a hash variable with element $name.key |
| !$имя.CLASS класс значения |
^method[$.key[] () {}] - constructor of a hash parameter with element $parameter.key |
| !$имя[$.key[] () {}] конструктор элемента переменной-хэша $имя.key |
$CLASS.name access a class variable |
| !^method[$.key[] () {}] конструктор элемента параметра-хеша $parameter.key |
|
| $CLASS.имя обращение к переменной класса |
the name ends before: space tab linefeed ; ] } ) " < > + * / % & | = ! ' , ? |
| |
i.e. you can do $name,aaaa |
| имя заканчивается перед: пробел tab linefeed ; ] } ) " < > + * / % & | = ! ' , ? {уточнить} |
but if you need a character after the name, say -, then ${name}- |
| т.е. можно |
|
| $имя,aaaa |
in expressions, + and - are additional name boundaries |
| но если нужно после имени букву, скажем -, то |
|
| ${имя}- |
you can access compound objects as: $name.subname where subname can be: |
| в выражениях + и - являются дополнительными концами имени |
a string |
| !можно обращаться к составным объектам так: $name.subname |
a $variable |
| !где subname бывает: |
a string$variable |
| ! строка |
[code computing a string] |
| ! $переменная |
for example: $hash[$.age(88)] $get[$.field[age]] ^hash.[$get.field].format{%05d} |
| ! строка$переменная |
|
| ! [код, вычисляющий строку] |
parameters := one or more parameters |
| например: $хэш[$.возраст(88)] $достать[$.поле[возраст]] ^хэш.[$достать.поле].format{%05d} |
parameter := |
| |
(arithmetic expression) evaluated multiple times inside the call, |
| параметры:=один или много параметров |
| [code] evaluated once before the call, |
| параметр:= |
| {code} evaluated zero or many times inside the call, |
| !(математическое выражение) вычисляется много раз внутри вызова, |
';' are allowed, making multiple parameters in a single bracket |
| | ![код] вычисляется один раз перед вызовом, |
|
| | !{код} вычисляется 0 или много раз внутри вызова, |
|
| !везде допустимы ; внутри - делает много параметров в одних скобках |
void |
| |
all methods present in the string class object are available, the result behaves as if it were an empty string |
| |
^void:sql{query without result}{$.bind[see table::sql]} |
| !void |
|
| !^имя.int[] (default) |
int,double |
| 0 или default |
^name.int[] |
| !^имя.double[] (default) |
integer value |
| 0 или default |
^name.double[] |
| !^void:sql{запрос без результата} |
double value |
| |
^name.bool[] ^name.bool(true|false) |
| !int,double |
boolean value |
| !^имя.int[] целочисленное значение |
^name.inc(how much +) |
| !^имя.double[]+ double значение |
^name.dec(how much -) |
| !^имя.inc(на сколько +) |
^name.++[] output the value, then increment by 1 |
| !^имя.dec(на сколько -) |
^name.--[] output the value, then decrement by 1 |
| !^имя.mul(на сколько *) |
^name.mul(how much *) |
| !^имя.div(на сколько /) |
^name.div(how much /) |
| !^имя.mod(на сколько %) |
^name.mod(how much %) |
| !^имя.format[формат] |
^name.format[format] |
| !^int/double:sql{query}[[$.limit(2) $.offset(4) $.default(0)]] |
^int/double:sql{query}[[$.limit(2) $.offset(4) $.default{0} $.bind[see table::sql]]] |
| запрос, результат которого должен быть один столбец/одна строка |
the query result should be one column/one row |
| |
|
| !string |
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) not empty? |
| ^if(def $form:name) не пуста? |
^if($user.isAlive) true? [auto-convert to number, not zero?] |
| ^if($user.isAlive) истина? [автопреобразование к числу, не ноль?] |
^string:sql{query}[[$.limit(1) $.offset(4) $.default{n/a} $.bind[see table::sql]]] |
| !^string::sql{query}[[$.limit(2) $.offset(4) $.default[n/a]]] |
the query result should be one column/one row |
| результат запроса должен быть один столбец/одна строка |
^string.int[] ^string.int(default) |
| !^имя.int[] .int(default) целочисленное значение строки. |
integer value of the string, if conversion fails, default is taken |
| если ломается преобразование, берётся default |
^string.double[] ^string.double(default) |
| !^имя.double[]+ .double(default) double значение строки |
double value of the string, if conversion fails, default is taken |
| если ломается преобразование, берётся default |
^string.bool[] ^string.bool(default) |
| !^имя.format[формат] %d %.2f %02d... |
boolean value of the string, if conversion fails, default is taken |
| !^строка.match[шаблон][[опции поиска]] $prematch $match $postmatch $1 $2... |
^string.format[format] %d %.2f %02d... |
| опции поиска= |
^string.match[string-pattern|regex-pattern][[search options]] $prematch $match $postmatch $1 $2... |
| i CASELESS |
search options: |
| x whitespace in regex ignored |
i CASELESS |
| s singleline = $ считается концом всего текста |
x whitespace in regex ignored |
| m multiline = $ считается концом строки[\n], не концом всего текста |
s singleline = $ matches end of entire text |
| g найти все вхождения, а не одно |
m multiline = $ matches end of line[\n], not end of entire text |
| !^строка.match[шаблон][опции поиска]{замена} |
g find all occurrences, not just one |
| опции поиска+= |
' create columns prematch, match, postmatch |
| g заменить все вхождения, а не одно |
n return the number of matches instead of a table |
| !^строка.{l|r}split[разделитель] таблица из столбца $piece |
U invert the meaning of the '?' modifier |
| !^строка.upper|lower[] |
^string.match[string-pattern|regex-pattern][search options]{replacement} |
| X^строка.truncate(предел терпенья) стиль :( |
additional search option: |
| !^строка.length[] |
g replace all occurrences, not just one |
| !^строка.mid(P[;N]) |
^string.split[delimiter|regex][[lrhva]][[column name for vertical splitting]] |
| без N - "до конца строки" |
l left to right [default] |
| !^строка.left(N) |
r right to left |
| !^строка.right(N) |
h nameless table with keys 0, 1, 2, ... |
| !^строка.pos[подстрока] |
v table of one column 'piece' or as provided [default] |
| <0 = не найдено |
a array |
| !^строка.replace[$таблица_подстановок_строка_на_строку] |
^string.{l|r}split[delimiter] a table from the $piece column |
| !^строка.save[[append;]путь] |
kept for compatibility |
| |
^string.upper|lower[] |
| !table |
^string.length[] |
| в выражении |
^string.mid(P[;N]) |
| логическое значение равно "не пуста?" |
without N - "until the end of the string" |
| числовое значение равно count[] |
^string.left(N), -1 returns the entire string |
| !^table::create[[nameless]]{данные} старое имя "set" |
^string.right(N) |
| !^table::create[table] |
^string.pos[substring] |
| клонирует таблицу |
^string.pos[substring](position from which to search) |
| !^table::load[[nameless;]путь] |
<0 = not found |
| !если не nameless, названия колонок берутся из первой строки |
^string.replace[$table_of_substitutions_string_to_string] |
| !пустые строки, и строки в первой колонке содержащие '#', игнорируются |
^string.replace[$what;$to] |
| !^table::sql{query}[[$.limit(2) $.offset(4)]] |
^string.save[[append;]path] |
| !^таблица.save[[nameless|append;]путь] |
^string.save[path[;$.charset[in which encoding save] $.append(true)]] |
| !$таблица.поле |
saves the string to a file |
| !$таблица.fields+ из named таблицы выдаёт текущую запись как Hash |
^string.trim[start|both|end|left|right[;chars]] |
| !^таблица.menu{тело}[разделитель] |
removes chars from the start/end/or both start and end |
| !^таблица.offset[[whence]](5) сдвигает; без параметра - печатает offset |
default 'chars' = whitespace chars |
| !whence=cur|set |
^string.trim[chars] |
| !без whence - это cur |
removes chars from start and end |
| !^таблица.count[] |
^string.base64[ $.pad(bool) $.wrap(bool) $.url-safe(bool) ] encode |
| !^таблица.line[] 1-based offset |
^string:base64[encoded[; $.pad(bool) $.strict(bool) $.url-safe(bool) ]] decode |
| !^таблица.sort{{ключеделатель строка}|(ключеделатель число)}[{desc|asc}] default=asc |
^string.idna[] |
| !^таблица.append{данные} |
IDNA encoding, supports Cyrillic domains |
| X^таблица.insert{данные}[(n)] добавить запись |
^string:idna[encoded] |
| на текущую позицию [добавить запись на позицию n] |
IDNA decoding, supports Cyrillic domains |
| X^таблица.remove(position[;count]) - стирает запись |
^string.js-escape[] |
| из текущей позиции [стирает запись из конкретной позиции] |
encoding for passing to JS (%uXXXX) |
| [стирает count записей] |
^string:js-unescape[escaped] |
| !^таблица.join[таблица] - добавляет записи из таблицы. |
decoding from js |
| таблицы должны иметь одинаковую структуру. |
^string:unescape[js|uri;escaped; $.charset[] ] |
| !^таблица.flip[] выдаёт транспонированную, надо куда-то сложить, потом пользовать |
decoding passed from js or uri |
| !^таблица.locate[поле;значение] выдаёт bool |
^string.contains[key] |
| !^таблица.hash[поле, что будет ключом][[поле значений|table поля значений]]+ |
for compatibility with hashtable |
| значением $hash.ключ будет hash в котором поля значений будут ключами |
|
| поля значений могут быть не указаны, тогда ими будут все столбцы, включая ключевой |
table |
| !^таблица.columns[]+ таблица из одного столбца $column |
in expression |
| |
logical value means "not empty?" |
| !hash |
numerical value equals count[] |
| !в выражении |
$table.field |
| !логическое значение равно "не пуста?" |
$table.field[new value] |
| !числовое значение равно _count[] |
$table.fields |
| !$hash.ключ |
from a named table returns the current record as a Hash |
| !_default - специальный ключ, если задан, |
^table::create[[nameless]]{data}[[$.separator[^#09] $.encloser[]]] |
| то при обращении по ключу, которому нет соответствия, выдаётся _default значение |
^table::create[table][[$.limit(1) $.offset(5) $.offset[cur] $.reverse(1)]] |
| !^hash::create[[!copy_from_hash|!copy_from_hashfile]] |
clones the table |
| создаёт новый hash, копию старого |
reverse - in reverse order |
| !^hash.add[слагаемое] |
^table::load[[nameless;]path[;options]] |
| перезаписывает одноимённые |
if not nameless, column names are taken from the first line |
| !^hash.sub[вычитаемое] |
empty lines, and lines in the first column containing '#' are ignored |
| !^a.union[b] = объединение |
$.separator[^#09] |
| !^a.intersection[b] = пересечение |
$.encloser["] by default, none |
| !^a.intersects[b] = bool |
^table::sql{query}[[$.limit(2) $.offset(4) $.bind[hash]]] |
| !^hash::sql{запрос}[[$.limit(2) $.offset(4)]] |
bind associates variables in the query with their values |
| получается hash(ключи=значения первая колонка ответа) |
currently implemented only for oracle |
| of hash(ключи=названия остальных колонкок ответа) |
in the query you need to write ":name" |
| !^hash._keys[]+ таблица из одного столбца $key |
in the bind parameter pass a hash from which the value is taken (or where it is written) |
| !^hash._count[] |
^table.save[[nameless|append;]path[;options, see load]] |
| !^foreach[key;value]{тело}[[разделитель]|{разделитель который выполняется перед непустым очередным не первым телом}] |
saves the table to a file |
| !^delete[ключ] удалить ключ |
^table.menu{body}[[delimiter]] |
| |
executes the body code for each row of the table |
| !form |
^table.foreach[position;value]{body}[[delimiter]] |
| [берётся первый элемент из одноимённых из GET, потом первый из POST] |
^table.line[] |
| !$form:поле = string/file |
current table row, starting from 1 |
| !$form:fields = hash со всеми полями формы |
^table.offset[] |
| !$form:tables.поле = table с одним столбцом "field" со значениями "поля" |
offset of the current row from the start, starting from 0 |
| |
^table.offset[[whence]](5) |
| !env |
shifts whence=cur|set, without whence = cur |
| !$env:переменная |
^table.count[], ^table.count[rows] |
| |
number of rows in the table |
| !cookie |
^table.count[columns] |
| !$cookie:имя считать старое или свежезаданное |
number of columns |
| !$cookie:имя[значение] на 90 дней |
^table.count[cells] |
| !$cookie:имя[$.value[значение] $.expires(дней) или $.expires[session]] |
number of cells in the current row |
| |
^table.sort{{string-key-maker}|(numeric-key-maker)}[{desc|asc}] default=asc |
| !request |
^table.append{data} |
| !$request:query |
^table.append[ $.column_name[column_value] ] |
| !$request:uri |
^table.insert{data} add a record at the current position |
| X!$request:browser это hash, поля: |
^table.insert[ $.column_name[column_value] ] |
| !$type = ie/nn и !$version = номер, скажем 5.5 |
^table.delete[] |
| X$request:user |
deletes the record at the current position |
| X$request:password |
^table.join[table][$.limit(1) $.offset(5) $.offset[cur]] |
| !$request:charset |
adds records from the table, tables must have the same structure |
| Кодировка исходного документа |
^table.flip[] |
| !используется при upper/lower и match[][i] |
returns the transposed version |
| ПРЕДУПРЕЖДЕНИЕ: класс form получает свои поля после обработки всех auto класса MAIN |
^table.locate[field;value][[$.limit(1) $.offset(5) $.offset[cur] $.reverse(1)]] |
| поэтому необходимо задать $request/response:charset в одном из них. не после. |
moves the current row if found. returns bool |
| |
^table.locate(logical expression)[[$.limit(1) $.offset(5) $.offset[cur] $.reverse(1)]] |
| !response |
moves the current row if found. returns bool |
| !$response:поле[значение] и можно считать старое -- $response:поле |
^table.hash{[field]|{code}|(expression)}[[value field(s)|table of value fields]{value code}][[$.distinct(1) $.distinct[tables] $.type[hash]]] |
| !значение может быть string а может быть hash: |
by default $hash.key value is a hash where value fields are keys |
| ! $value[abc] field: {abc}<<часть |
value fields may not be specified, then they are all columns including the key |
| ! $attribute[zzz] field: abc; {attribute=zzz}<<часть |
if distinct is true, no error if duplicate keys |
| !$response:body[DATA] замещает стандартный ответ |
if distinct is tables, a hash of tables is created, containing rows with that key |
| !^response:clear[] забыть все заданные response поля |
$.type[string/table] changes the element value to a string (specify one column) or a table |
| !$response:charset |
^table.columns[[column name]] |
| кодировка клиента т.е. та, |
table of one column 'column' or as provided |
| 1) из которой будут перекодированы $form:поля после забирания из browser'а |
^table.cells[], ^table.cells(limit) |
| 2) в которую документ будет перекодирован перед отдаванием в browser |
returns an array of cells of the current row |
| 3) в которую будет перекодирован текст языка uri |
^table.array[] |
| не добавляет к content-type ничего, если хочется, это надо сделать вручную |
returns an array of hashes, each hash representing the data of one row |
| ПРЕДУПРЕЖДЕНИЕ: класс form получает свои поля после обработки всех auto класса MAIN |
^table.array[column] |
| поэтому необходимо задать $request/response:charset в одном из них. не после. |
returns an array of values from the specified column |
| |
^table.array{code} |
| !hashfile |
returns an array of results from executing the given code for each row |
| !^hashfile::open[$DB_HOME;filename] |
^table.rename[column name;new column name] ^table.rename[ $.column_name[new column name] ...] |
| !^hashfile.clear[] |
renames a column or multiple columns |
| забыть всё |
$selected[^table.select(expression)] |
| !.ключ[значение] положить значение навечно |
a table from those columns and rows where the condition matched |
| !.ключ[$.value[значение] $.expires(секунд)} положить значение на expires секунд |
$adults[^man.select($man.age>=18)] |
| !.ключ достать |
^table.color[color1;color2] |
| !^cache[ключ](секунд){код} |
alternates color1 and color2 for each row |
| !суть то же, что и "положить+достать", но за один раз и компактнее |
|
| !если 0секунд, значит не кэшировать, а старый такой стереть |
hash |
| !внутри {кода} может быть вызван ^delete[] |
in expression |
| !^delete[[ключ]] удалить ключ |
logical value means "not empty?", a hash with _default is already not empty |
| !буде вызван без параметра изнутри cache, отменяет кэширование блока: |
numerical value equals count[] |
| !блок не будет скэширован, его старое значение будет стёрто |
$hash.key |
| !^hash[] |
_default - a special key, if defined, |
| преобразовать в обычный hash |
then when accessing a non-existing key, _default value is returned |
| !^foreach[key|value]{тело}[[разделитель]|{разделитель который выполняется перед непустым очередным не первым телом}] |
$hash.fields |
| |
returns $hash, making hash class more similar to table class |
| |
^hash::create[[|copy_from_hash|copy_from_hashfile]] |
| примеры: |
creates a new hash, a copy of the old one |
| $uids[^hashfile::assign[/db/uids]] |
^hash.add[term] |
| $code:clear[/db/cache]] |
overwrites entries with the same name |
| $code[^hashfile::assign[/db/cache]] |
^hash.sub[subtracted] |
| |
^hash.union[b] |
| $random[23847387taduigh345XGHWElxjgdjg] |
union, same-named remain |
| $uids.$random[$.value[$uid] $.expires(60*30)] |
^hash.intersection[b][[$.order[self|arg]]] |
| $uid[$persistent.logins.$random] |
intersection, new hash, order defines the element order (as in the source hash or parameter hash) |
| |
^hash.intersects[b] = bool |
| ^code.cache[заголовки новостей](35){....} |
^hash::sql{query}[[$.distinct(1) $.limit(2) $.offset(4) $.type[hash|string|table]]] |
| |
results is hash(keys = values of the first column of the response) of hash(keys = names of the other columns), or |
| !mail |
string = each element's value is a string (need exactly two columns), or |
| !:send[$.header-field[] $.charset[кодировка письма] $.body[когда body не строка, |
table = each element's value is a table |
| а hash, отсылается multipart письмо]] |
^hash.keys[[name of key column]] |
| !если charset указан, письмо перекодируется в этот charset |
a table of one 'key' column or as provided |
| !content-type.charset не влияет на перекодирование |
^hash.count[] |
| !если body указан строкой, то это текст письма, никаких вложений. |
^hash.foreach[key;value]{body}[[delimiter]|{delimiter executed before each non-empty non-first body}] |
| !если body указан hash, то это части, будут собраны текстовые блоки, затем вложения |
^hash.delete[key] |
| !если имя части начинается со слова text, то это текстовый блок. |
delete key |
| !если имя части начинается со слова attach, то это вложение, формат задания:: |
^hash.contains[key] |
| !$attach[$.format[!uue|Xbase64] $.value[DATA] $.file-name[user-file-name]] |
checks if hash contains a key (bool) |
| !после имени части может идти целое число, части пойдут в порядке чисел. |
^hash.at[first|last][[key|value|hash]] |
| !важно: при multipart не указывать content-type |
^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.array[[keys|values]] |
| |
is equivalent to ^array::copy[$hash] or returns an array of the hash’s keys or values |
| |
^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] |
| |
^hashfile.clear[] |
| |
forget all |
| |
$hashfile.key[value] |
| |
put value |
| |
$hashfile.key[$.value[value] $.expires[VALUE]] |
| |
put value until expires |
| |
expires can be a date, or number of days (0days=forever) |
| |
$hashfile.key retrieve |
| |
^hashfile.delete[key] delete key |
| |
^hashfile.delete[] delete files containing data |
| |
^hashfile.hash[] |
| |
convert to a regular hash |
| |
removing expired pairs along the way |
| |
^hashfile.foreach[key;value]{body}[[delimiter]|{delimiter executed before each non-empty non-first body}] |
| |
^hashfile.release[] |
| |
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.contains(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 |
| |
|
| |
date |
| |
date type can be used in expressions, substituting the number of days since epoch [1 January 1970 (UTC)], fractional |
| |
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 |
| |
by default the OS-defined timezone is used |
| |
|
| |
^date::now[] |
| |
^date::now(days offset) |
| |
returns now+offset |
| |
^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[date in format %Y-%m-%d %H:%M:%S] |
| |
convenient creation from a value from a database |
| |
format1: %Y[-%m[-%d[ %H[:%M[:%S]]]]] |
| |
format2: %H:%M[:%S] |
| |
^date::create[date in format %Y-%m-%dT%H:%M[:%S]TZ] |
| |
for creation from ISO 8601 format |
| |
TZ format: Z(UTC) or +-hour[:minute] (offset from UTC) |
| |
^date::unix-timestamp() |
| |
^date.unix-timestamp[] |
| |
$date.year month day hour minute second weekday yearday(0...) daylightsaving TZ weekyear |
| |
TZ="" << local zone |
| |
$date.year month day hour minute second can be set to new values, others are read-only |
| |
^date.double[] ^date.int[] |
| |
the number of days since epoch [1 January 1970 (UTC)], fractional or truncated |
| |
^date.roll[year|month|day](+-offset) |
| |
shifts the date |
| |
^date.roll[TZ;New zone] |
| |
says that the date is in such a timezone: affects .hour & Co |
| |
^date:roll[TZ;New zone] |
| |
says that by default all dates are in that timezone |
| |
^date.sql-string[[datetime|date|time]] |
| |
datetime or without parameter - %Y-%m-%d %H:%M:%S |
| |
date - %Y-%m-%d |
| |
time - %H:%M:%S |
| |
where published='^date.sql-string[]' |
| |
^date:sql-string[[datetime|date|time]] |
| |
sql-string for now |
| |
^date:calendar[rus|eng](year;month) |
| |
returns an unnamed table, columns: 0..6, week, year |
| |
^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:gmt-string[] |
| |
gmt-string for now |
| |
^date.iso-string[] |
| |
2001-03-23T12:32:23+03 |
| |
^date:iso-string[] |
| |
iso-string for now |
| |
|
| |
file |
| |
$uploaded_file_from_post.name |
| |
$uploaded_file_from_post.size |
| |
$uploaded_file_from_post.text |
| |
^file.save[text|binary;filename[;$.charset[which charset to save in] $.append(false)]] |
| |
^file:delete[filename] |
| |
^file:find[filename][{if not found}] |
| |
^file:list[path[;pattern-string|pattern-regex]] |
| |
table with columns name dir |
| |
^file:list[path;$.filter[pattern-string|pattern-regex] $.stat(true)] |
| |
table with columns name dir size [mca]date |
| |
^file::load[text|binary;big.zip[;domain_press_release_2001_03_01.zip][;options]] |
| |
^file::create[text|binary;filename;data] |
| |
^file::create[text|binary;filename;data[;$.charset[charset of the created file] $.content-type[...]]] |
| |
^file::create[string-or-file-content[;$.name[name] $.mode[text|binary] $.content-type[...] $.charset[...]]] |
| |
$loaded_file.size |
| |
$loaded_or_created_file.mode = text/binary |
| |
^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;]filename[;env hash[;1cmd[;2line[;3ar[;4g[;5s;...under unix max 50 args]]]]]]] |
| |
any argument can be string or array of strings |
| |
options: |
| |
$.stdin[text|file] if empty, disables automatic passing of HTTP-POST data |
| |
^file:move[oldfilename;newfilename] |
| |
can rename and move directories [win32: but not across disk boundaries] |
| |
directories for dest are created with 775 permissions |
| |
source directory is removed if empty after move |
| |
^file:copy[filename;copy_filename[; $.append(1) ]] |
| |
can only copy files |
| |
^file:lock[filename]{code} |
| |
the file is created if necessary |
| |
locked |
| |
code executed |
| |
unlocked |
| |
^file:dirname[/a/some.tar.gz|file]=/a (works like *nix command) |
| |
^file:dirname[/a/b/|file]=/a (works like *nix command) |
| |
^file:basename[/a/some.tar.gz|file]=some.tar.gz (like *nix) |
| |
^file:basename[/a/b/|file]=b (like *nix) |
| |
^file:justname[/a/some.tar.gz|file]=some.tar |
| |
^file:justext[/a/some.tar.gz|file]=gz |
| |
/some/page.html: ^file:fullpath[a.gif] => /some/a.gif |
| |
^file.sql-string[] |
| |
inside ^connect gives a correctly escaped string that can be used in queries |
| |
^file::sql{query}[[ $.name[filename_for_download] $.content-type[user 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) ] |
| |
encode |
| |
^file:base64[filename[; $.pad(bool) $.wrap(bool) $.url-safe(bool) ]] |
| |
encode |
| |
^file::base64[encoded string[; $.pad(bool) $.strict(bool) $.url-safe(bool) ]] |
| |
decode |
| |
^file::base64[mode;filename;encoded string[; $.content-type[...] $.pad(bool) $.strict(bool) $.url-safe(bool) ]] |
| |
decode |
| |
^file:crc32[filename] |
| |
calculates crc32 of the specified file |
| |
^file.crc32[] |
| |
calculates crc32 of the object |
| |
^file.md5[], ^file:md5[filename] |
| |
returns the file's digest, 16 bytes as a string, |
| |
bytes in hex, contiguous, lowercase |
| |
|
| |
image |
| |
$image[^image::measure[DATA[; $.exif(bool) $.xmp(bool) $.xmp-charset[] $.video(bool) ]]] |
| |
checks the file extension case-insensitively |
| |
can measure gif, jpg, tiff, bmp, webp and mp4 (mov) |
| |
$image.exif << hash after measure jpeg with exif information and $.exif(true) |
| |
$image.exif.DateTime & co |
| |
[full list see https://exiftool.org/TagNames/EXIF.html] |
| |
numbers as int/double, |
| |
dates as date, |
| |
enumerations as hash with keys 0..count-1 |
| |
$image.src .width .height |
| |
$image.line-width number=line width |
| |
$image.line-style string=line style '*** * '='*** * *** * *** * ' |
| |
^image.html[[hash]] |
| |
<img ...> |
| |
^image::load[background.gif] |
| |
only gif so far |
| |
^image::create(width X;height Y[;background color default white]]) |
| |
^image.line(x0;y0;x1;y1;0xffFFff) |
| |
^image.fill(x;y;0xffFFff) |
| |
^image.rectangle(x0;y0;x1;y1;0xffFFff) |
| |
^image.bar(x0;y0;x1;y1;0xffFFff) |
| |
^image.replace(hex-color1;hex-color2)[table x:y polygon_vertices] |
| |
^image.polyline(color)[table x:y points] |
| |
^image.polygon(color)[table x:y polygon_vertices] |
| |
^image.polybar(color)[table x;y polygon_vertices] |
| |
^image.font[set_of_letters;font_file.gif][(space_width[;char_width])] |
| |
the character height = image height/number of letters in the set |
| |
if char_width is specified, then monospaced, if 0, char_width = gif width |
| |
^image.font[set_of_letters;font_file.gif; |
| |
$.space(space_width) // default = gif width |
| |
$.width(char_width) // see above, default proportional |
| |
$.spacing(letter_spacing) // default = 1 |
| |
] |
| |
^image.text(x;y)[text] AS_IS |
| |
^image.length[text] AS_IS |
| |
^image.gif[optional filename] |
| |
encodes to FILE with content-type=image/gif the filename will be used by $response:download |
| |
^image.arc(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) |
| |
^image.circle(center x;center y;r;color) |
| |
^image.copy[source](src x;src y;src w;src h;dst x;dst y[;dest w[;dest h[;tolerance]]]) |
| |
if dest_w/dest_h are specified, resizes the piece |
| |
when reducing size, does resample |
| |
only suitable for simplifying low-color graphics like charts/pie, |
| |
not suitable for thumbnails |
| |
if dest_h is not specified, aspect ratio is kept |
| |
tolerance - a number [square distance in RGB space to the target color], |
| |
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 |
| |
^image.pixel(x;y)[(color)] |
| |
get or set pixel color |
| |
|
| |
regex |
| |
in expression |
| |
logical value is always true |
| |
numerical value is equal to the number of bytes of the compiled pattern |
| |
^regex::create[pattern-string|regex][[search options]] |
| |
^pattern.size[] |
| |
number of bytes of the compiled pattern |
| |
if the value is very large - it is worth consulting pcre documentation and possibly rewriting the pattern |
| |
^pattern.study_size[] |
| |
size of the study-structure. if == 0 - the pattern cannot be "studied" |
| |
$pattern.pattern |
| |
the text of the pattern |
| |
$pattern.options |
| |
the string with the original text of the options |
| |
|
| |
console |
| |
$console:timeout |
| |
$console:line |
| |
read/write string |
| |
|
| |
cookie |
| |
$cookie:name read old or newly set cookie |
| |
$cookie:name[value] for 90 days |
| |
$cookie:name[$.value[value] $.expires[VALUE] $.secure(true) $.domain[domain name] $.httponly(true)] |
| |
the expires field value can be 'session', a date, or a number of days (0days=forever) |
| |
if it's a date, it will be converted to "Sun, 25-Aug-2002 12:03:45 GMT" |
| |
$cookie:fields |
| |
hash with all cookies |
| |
|
| |
curl |
| |
^curl:load[[ |
| |
$.url[http://URL] |
| |
$.timeout(N) |
| |
$.ssl_verifypeer(0) |
| |
$.mode[text|binary] type of the created file |
| |
]] |
| |
downloads a file from a remote server, can be called multiple times within one session; |
| |
any libcurl option can be specified, option names in lowercase without the CURLOPT_ prefix |
| |
^curl:options[[ |
| |
$.library[libcurl.so.4] |
| |
$.charset[UTF-8] |
| |
... |
| |
]] |
| |
subsequent ^curl:load calls inherit the specified options, the path to libcurl must be set before using curl |
| |
^curl:session{code} |
| |
creates a cURL session, common options can be set, multiple downloads performed |
| |
^curl:info[name], ^curl:info[] |
| |
information about the last request (a value or a hash) |
| |
^curl:version[] |
| |
the version of the cURL library in use |
| |
|
| |
env |
| |
$env:variable |
| |
$env:fields hash with environment variables |
| |
$env:PARSER_VERSION parser version |
| |
|
| |
form |
| |
[the first element with the same name is taken from GET, then from POST] |
| |
$form:field |
| |
string/file |
| |
$form:nameless |
| |
field with a value from a nameless parameter "?value&...", "...&value&...", "...&value" |
| |
$form:qtail |
| |
string with the value after the second "?xxxxx" if there was no ',' [imap] |
| |
$form:fields |
| |
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 |
| |
|
| |
inet |
| |
^inet:ntoa(long) |
| |
^inet:aton[IP] |
| |
^inet:name2ip[name][[ $.ipv[4|6|any] $.table(true) ]] |
| |
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-string-[; |
| |
$.depth(maximum depth, default == 19) |
| |
$.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) 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] how duplicate keys in objects are handled |
| |
first - keep the first encountered element |
| |
last - keep the last encountered element |
| |
all - keep all elements. starting from the 2nd, |
| |
they get numeric suffixes (key_2 etc) |
| |
by default duplicate keys cause an exception |
| |
$.object[method-junction] user method[key;object], called for all parsed |
| |
objects and object keys; method returns a new object |
| |
$.array[method-junction] user method called for arrays |
| |
$.taint[taint language] sets the transformation language for all result strings |
| |
]] |
| |
parses a json-string into a hash |
| |
|
| |
^json:string[system or user object[; |
| |
$.skip-unknown(false) disable exception and output 'null' when serializing objects of types |
| |
other than void, bool, string, int, double, date, table, hash, and file |
| |
$.indent(true) format the resulting string with indentation according to nesting depth |
| |
$.date[sql-string|gmt-string|iso-string|unix-timestamp] |
| |
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",...],...] |
| |
$.file[text|base64|stat] output file content in the specified mode (by default file content |
| |
is not included in output) |
| |
$.xdoc[hash] parameters for converting xdoc to string (as in ^xdoc.string[]) |
| |
$.type[method-junction] any type can be output using a user method |
| |
that must take 3 parameters: key, object of that type, and options |
| |
of the ^json:string[] call |
| |
$._default[method] user method, called to output all user-class objects. |
| |
The method must take 3 parameters: key, object, and call options. |
| |
$._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) |
| |
or as an empty string |
| |
]] |
| |
serializes a system or user object into a json-string |
| |
|
| |
mail |
| |
$mail.received=MESSAGE: |
| |
.from |
| |
.reply-to |
| |
.subject |
| |
.date of class date |
| |
.message-id |
| |
.raw[ |
| |
.RAW_USER_HEADER_FIELD |
| |
] |
| |
$.{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]] << in which it arrived, now already transcoded |
| |
$.USER_DEFINED_HEADER_FIELD |
| |
] |
| |
$.description |
| |
$.content-id |
| |
$.content-md5 |
| |
$.content-location |
| |
.raw[ |
| |
.RAW_USER_HEADER_FIELD |
| |
] |
| |
$.value[string|FILE] |
| |
] |
| |
$.message#[MESSAGE] (message, message2, ...) |
| |
|
| |
^mail:send[ |
| |
$.options[-odd] |
| |
unix: a string that will be added to the sendmail startup command |
| |
-odd means "quickly put in the queue without email checking" |
| |
win32: ignored |
| |
$.charset[the encoding of the headers and text blocks] |
| |
$.any-header-field |
| |
$.text[string] |
| |
$.text[ |
| |
$.any-header-field |
| |
$.value[string] |
| |
] |
| |
$.html{string} |
| |
$.html[ |
| |
$.any-header-field |
| |
$.value{string} |
| |
] |
| |
$.file#[FILE] |
| |
$.file#[ |
| |
$.any-header-field |
| |
$value[FILE] |
| |
] |
| |
] |
| |
if charset is specified, the email is transcoded to this charset |
| |
content-type.charset does not affect transcoding |
| |
after the part name a # number can follow |
| |
|
| |
^mail:send[ |
| |
# by default, matches the source encoding. |
| |
# sets the body encoding |
| |
$.charset[windows-1251] |
| |
# no default |
| |
$.content-type[$.value[text/plain] $.charset[windows-1251]] |
| |
$.from["vasya" <vasya@design.ru>] |
| |
$.to["petya" <petya@design.ru>] |
| |
$.subject[subject] |
| |
$.body[ |
| |
text |
| |
] |
| |
] |
| |
|
| |
^mail:send[$.header-field[] $.charset[mail encoding] $.body[if body is not a string, but a hash, a multipart email is sent]] |
| |
if charset is specified, the email is transcoded to that charset |
| |
content-type.charset does not affect transcoding |
| |
after the part name, an integer can follow, parts go in numerical order. |
| |
if body is a string, then it's just the email text, no attachments. |
| |
if body is a hash, then these are parts, text blocks first, then attachments |
| |
this is the old format, supported for backward compatibility |
| |
if the part name begins with "text", it's a text block. |
| |
if the part name begins with "file", it's an attachment, format: |
| |
$file[$.format[uue|base64] $.value[DATA] $.name[user-file-name]] |
| |
important: for multipart do not specify content-type |
| |
|
| ^mail:send[ |
^mail:send[ |
| # по-умолчанию, совпадает с source encoding. |
# by default, matches the source encoding |
| # задаёт кодировку body |
# sets the body encoding |
| $.charset[windows-1251] |
$.charset[windows-1251] |
| # нет умолчания |
# no default |
| $.content-type[$.value[text/plain] $.charset[windows-1251]] |
$.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[ |
$.body[ |
| слова |
text |
| ] |
] |
| ] |
] |
| |
|
| ^mail:send[ |
^mail:send[ |
| $.from["вася" <vasya@design.ru>] |
$.from["vasya" <vasya@design.ru>] |
| $.to["петя" <petya@design.ru>] |
$.to["petya" <petya@design.ru>] |
| $.subject[пойдём пивка] |
$.subject[subject] |
| $.body[ |
$.body[ |
| $.text[ |
$.text[ |
| # задаёт кодировку body |
# sets the body encoding |
| $.charset[windows-1251] |
$.charset[windows-1251] |
| # нет умолчания |
# no default |
| $.content-type[$.value[text/plain] $.charset[windows-1251]] |
$.content-type[$.value[text/plain] $.charset[windows-1251]] |
| $.body[слова] |
$.body[words] |
| |
] |
| |
# for convenience you can specify only one part, then it won't be multipart |
| |
$.file[ |
| |
$.value[^file::load[my beloved.doc]] |
| |
$.name[my beloved.doc] |
| |
$.format[base64] |
| ] |
] |
| #для удобства скриптования можно указать только одну часть, при этом не будет multipart |
$.file2[ |
| $.attach[ |
$.value[^file::load[my beloved.doc]] |
| $.value[^file::load[my beloved.doc]] |
$.name[my beloved.doc] |
| $.file-name[мой любимый.doc] |
|
| ] |
] |
| $.attach2[ |
|
| $.value[^file::load[my beloved.doc]] |
|
| $.file-name[мой любимый.doc] |
|
| ] |
|
| ] |
] |
| ] |
] |
| !для отправки используется программа с параметрами, задаваемая |
under unix, the program with arguments is used, set by |
| $MAIL.sendmail[команда] |
$MAIL.sendmail[command] |
| если не будет задана, проверяется, доступна ли |
if not specified, checks if /usr/sbin/sendmail or |
| /usr/sbin/sendmail или |
/usr/lib/sendmail is available and if so, runs with "-t". |
| /usr/lib/sendmail |
|
| и, если доступна, то запускается с параметром "-t". |
under Windows, SMTP protocol is used, server is set by |
| |
$MAIL.SMTP[smtp.domain.ru] |
| !image |
|
| !$картинка[^image::measure[DATA]] |
math |
| смотрит на .ext case insensitive, |
$math:PI |
| умеет мерить пока только .gif и .jpg .jpeg |
^math:round floor ceiling |
| !$картинка.src .width .height |
^math:trunc frac |
| !$картинка.line-width число=ширина линий |
^math:abs sign |
| !$картинка.line-style строка=стиль линий '*** * '='*** * *** * *** * ' |
^math:exp log log10 |
| !^картинка.html[[hash]] = <img ...> |
^math:sin asin cos acos tan atan atan2 |
| !^image::load[фон.gif] |
^math:degrees radians |
| только gif пока |
^math:pow sqrt |
| !^image::create(размер X;размер Y[;цвет фона default белый]]) |
^math:random(range_width) |
| !^картинка.line(x0;y0;x1;y1;0xffFFff) |
^math:convert[number|file](base-from;base-to)[[ $.format[string|file] ]] |
| !^картинка.fill(x;y;0xffFFff) |
^math:convert[number|file][alphabet](base-to)[[ $.format[string|file] ]] |
| !^картинка.rectangle(x0;y0;x1;y1;0xffFFff) |
^math:convert[number|file](base-from)[alphabet][[ $.format[string|file] ]] |
| !^картинка.bar(x0;y0;x1;y1;0xffFFff) |
converts a string or file with a number from one numeral system to another |
| !^картинка.replace(hex-цвет1;hex-цвет2)[table x:y вершины_многоугольника] |
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) |
| !^картинка.polyline+(цвет)[table x:y точки] |
^math:eq(a;b[;max ULP]) |
| !^картинка.polygon(цвет)[table x:y вершины_многоугольника] |
true if difference between doubles less or equal max ULPs (default 3) |
| !^картинка.polybar(цвет)[table x;y вершины_многоугольника] |
^math:uuid[ $.lower(bool) $.solid(bool) ] |
| !^картинка.font[набор_букв;имя_файла_шрифта.gif](ширина_пробела[;ширина_символа]) |
22C0983C-E26E-4169-BD07-77ECE9405BA5 |
| высота символа = высота картинки/количество букв в наборе |
win32: uses cryptapi |
| если указана ширина_символа, то monospaced, если 0, то ширина_символа = ширине gif |
unix: uses /dev/urandom, |
| !^картинка.text(x;y)[текст_надписи] AS_IS |
if not present, /dev/random, |
| !^картинка.length[текст_надписи] AS_IS |
if not, rand |
| !^картинка.gif[] -- кодирует в FILE с content-type=image/gif |
^math:uuid7[ $.lower(bool) $.solid(bool) ] |
| !^картинка.arc(center x;center y;width;height;start in degrees;end in degrees;color) |
0193CBF0-7898-7000-A391-AC513CC15658 |
| !^картинка.sector(center x;center y;width;height;start in degrees;end in degrees;color) |
https://www.rfc-editor.org/rfc/rfc9562.html#name-uuid-version-7 |
| !^картинка.circle(center x;center y;r;color) |
^math:uid64[ $.lower(bool) ] |
| !^картинка.copy[source](src x;src y;src w;src h;dst x;dst y[;dest w[;dest h[;tolerance]]]) |
BA39BAB6340BE370 |
| при заданных dest_w/dest_h делает изменение размера кусочка |
^math:md5[string] |
| при уменьшении делает resample |
returns the digest of the string, 16 bytes as a string, |
| годится только для уменьшения простой[малоцветной] дребедени вроде графиков/pie, |
bytes in hex, contiguous, lowercase |
| для thumbnais не годится. |
^math:crypt[password;salt] |
| при не указанном dest_h сохраняет aspect ratio |
salt prefix $apr1$ triggers built-in MD5 algorithm, |
| tolerance - некое число[квадрат расстояния в RGB пространстве до искомого цвета], |
if salt body is empty, it is generated randomly |
| определяющее прожорливость выделялки цветов из палитры [default=150] |
$1$ calls the OS 'crypt' MD5 algorithm if supported. |
| меньше - точнее приближает цвета, но они быстро кончаются |
for other salts see OS 'crypt' documentation. |
| больше - неточно приближает цвет, но бОльшей части хватит |
^math:crc32[string] |
| |
calculates crc32 of the string |
| !file |
^math:sha1[string] |
| !$файл_из_post.name |
^math:digest[[md5|sha1|sha256|sha512];string or file][[ $.format[hex|base64|file] $.hmac[key string|key file] ]] |
| !$файл_из_post.size |
combines the ability to use various cryptographic hashing algorithms. |
| !$файлtиз_post.text |
$.hmac[key] for verifying the integrity of transmitted data |
| !^файл.save[text|binary;имя файла] |
|
| !^file:delete[имя файла] |
memory |
| !^file:find[имя файла][{когда не нашли}] |
^memory:compact[] |
| !^file:list[путь[;шаблон]] = table с колонкой name |
collect garbage, freeing space for new data (warning: process memory is never released) |
| !^file::load[text|binary;!big.zip[;!domain_press_release_2001_03_01.zip]] |
useful before XSL transform |
| !$файл_который_был_loaded.size |
^memory:auto-compact(frequency) |
| !^file::stat[имя файла] |
sets automatic garbage collection frequency, from 0 (off) up to 5 (max) |
| !$файл_который_был_stated.size !.adate !.mdate !.cdate |
|
| !^file::cgi[имя файла[;env hash[;1cmd[;2line[;3ar[;4g[;5s]]]]]]] |
reflection |
| возвращённый заголовок рассыпается на $поля |
^reflection:create[class;constructor[;pa[;ra[;ms]]]] |
| $status |
calls the specified class constructor (no more than 100 parameters) |
| $stderr |
^reflection:create[ $.class[name] $.constructor[name] $.arguments[ $.1[pa] $.2[ra] $.3[ms] ] ] |
| !^file::exec[имя файла[;env hash[;1cmd[;2line[;3ar[;4g[;5s;...under win32 max 10 args]]]]]]] |
calls the specified class constructor |
| !^file:move[старое имя файла;новое имя файла] |
^reflection:classes[] |
| можно переименовывать и двигать каталоги[win32: но не через границу дисков] |
a hash of all classes. key = class name, value can be methoded (a class with methods) or void |
| каталоги для dest создаются с правами 775 |
^reflection:class[object] |
| каталог старого файла стирается, если после move он остаётся пуст |
the class of the given object |
| !^file:lock[имя файла]{код} |
^reflection:class_name[object] |
| файл при необходимости создаётся |
the class name of the given object |
| блокируется |
^reflection:base[object] |
| выполняется код |
the parent class of the given object |
| разблокируется |
^reflection:base_name[object] |
| |
the parent class name of the given object |
| !math |
^reflection:class_by_name[class name] |
| !$math:PI |
obtains the class by name |
| !^math:round floor ceiling |
^reflection:class_alias[class name;new class name] |
| !^math:trunc frac |
sets an alias for the specified class |
| !^math:abs sign |
^reflection:def[class;class name] |
| !^math:exp log |
checks if the class exists |
| !^math:sin asin cos acos tan atan |
^reflection:methods[class] |
| !^math:degrees radians |
a hash with a list of methods of the specified class, values are strings 'native' or 'parser' |
| !^math:pow sqrt |
^reflection:method[class or object;method name] |
| !^math:random(ширина диапазона) |
returns the junction-method of the class or object |
| |
^reflection:filename[object or class or method] |
| !date |
returns the filename where the object, class or method is defined |
| !время типа time можно использовать в выражениях, подставляет |
^reflection:fields[class or object] |
| количество дней с epoch [1 января 1970 (UTC)], дробное |
a hash with the list of static fields of the specified class or dynamic fields of the specified object |
| !всё происходит в localtime, |
^reflection:fields_reference[object] |
| !временная зона задаётся вне parser средствами OS |
an editable hash of the dynamic fields of the specified object |
| !^date::now[] |
^reflection:field[class or object;field name] |
| !^date::create(дней с epoch) // старое имя set |
returns the value of the specified field of the class or object. getters are ignored. |
| !^date::create(year;month;day[;hour[;minute[;second]]]) // старое имя set |
^reflection:copy[source;destination] |
| !$date.year month day hour minute second weekday read-only |
copies fields from one object or class to another |
| !^date.roll[year|month|day](+/- 1) сдвигает дату |
^reflection:uid[class or object] |
| !^date.sql-string[] %Y-%m-%d %H:%M:%S |
returns the identifier of the object or class |
| where published='$дата.sql-string[]' |
^reflection:method_info[class;method] |
| !^date:calendar[rus|eng;год;месяц] выдаёт таблицу |
a hash with parameters of the specified class method |
| !^date:calendar[rus|eng;год;месяц;день] выдаёт таблицу |
$.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] |
| |
for parser classes a hash is returned: |
| |
key is parameter number (0, 1, ...), value is parameter name |
| |
^reflection:dynamical[[object or class, caller if absent]] |
| |
returns true if the method was called from a dynamic context when passing |
| |
a parameter returns true if a dynamic object was passed, false if a class |
| |
^reflection:delete[class or object;variable name] |
| |
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 |
| |
^reflection:override[method[; $.to[target] $.name[new_name]]] |
| |
overrides or defines a method |
| |
|
| |
request |
| |
https://site.name/a%20b/?name=some%20value |
| |
$request:query |
| |
name=some%20value |
| |
$request:uri |
| |
/a%20b/?name=value |
| |
$request:path |
| |
/a b/ |
| |
$request:document-root |
| |
directory relative to which paths are considered in parser, default = $env:DOCUMENT_ROOT |
| |
$request:argv |
| |
hash with command-line parameters. keys 0, 1, ... [0 - name of the processed file] |
| |
$request:charset |
| |
the source document encoding |
| |
used in upper/lower and match[][i] |
| |
WARNING: you must set $request/response:charset before using form class fields |
| |
$request:method |
| |
request method (GET|POST|PUT) |
| |
$request:body |
| |
POST-request body as text |
| |
$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:field[value] and can read old - $response:field |
| |
the value can be string or hash: |
| |
$value[abc] field: {abc}<<part |
| |
$attribute[zzz] field: abc; {attribute=zzz}<<part |
| |
field or attribute value can be string or date |
| |
if date, it will be converted to "Sun, 25-Aug-2002 12:03:45 GMT" |
| |
$response:headers |
| |
accumulated fields |
| |
$response:body[DATA] |
| |
replaces the standard response |
| |
$response:download[DATA] |
| |
replaces the standard response, sets a flag causing the browser to suggest download |
| |
$response:status |
| |
^response:clear[] forget all set response fields |
| |
$response:charset |
| |
client encoding, i.e.: |
| |
1) from which $form: fields will be transcoded after retrieval from browser |
| |
2) into which the document will be transcoded before sending to browser |
| |
3) into which URI language text will be transcoded |
| |
does not add anything to content-type; if needed, do it manually |
| |
WARNING: you must set $request/response:charset before using form class fields |
| |
|
| |
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(xnode) |
| |
$xdoc.search-namespaces hash, where keys=prefixes, values=urls |
| |
|
| DOM1 attributes: |
DOM1 attributes: |
| !readonly attribute DocumentType doctype |
readonly attribute DocumentType doctype |
| Xreadonly attribute DOMImplementation implementation |
readonly attribute Element documentElement |
| !readonly attribute Element documentElement |
|
| |
|
| DOM1 methods: |
DOM1 methods: |
| !Element createElement(in DOMString tagName) |
Element createElement(in DOMString tagName) |
| !DocumentFragment createDocumentFragment() |
DocumentFragment createDocumentFragment() |
| !Text createTextNode(in DOMString data) |
Text createTextNode(in DOMString data) |
| !Comment createComment(in DOMString data) |
Comment createComment(in DOMString data) |
| !CDATASection createCDATASection(in DOMString data) |
CDATASection createCDATASection(in DOMString data) |
| !ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) |
ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) |
| !Attr createAttribute(in DOMString name) |
Attr createAttribute(in DOMString name) |
| !EntityReference createEntityReference(in DOMString name) |
EntityReference createEntityReference(in DOMString name) |
| !NodeList getElementsByTagName(in DOMString tagname) |
NodeList getElementsByTagName(in DOMString tagname) |
| |
|
| DOM2 some methods: |
DOM2 some methods: |
| !^.getElementById[elementId] = xnode |
^.getElementById[elementId] = xnode |
| The DOM implementation must have information that says which attributes are of type ID. |
The DOM implementation must have information that says which attributes are of type ID. |
| Attributes with the name "ID" are not of type ID unless so defined. |
Attributes with the name "ID" are not of type ID unless so defined. |
| Implementations that do not know whether attributes are of type ID or not |
Implementations that do not know whether attributes are of type ID or not |
| are expected to return null. |
are expected to return null. |
| |
|
| !кодировка строк и умолчание для $.encoding |
String encoding and default for $.encoding equals the current output page encoding, $response:charset |
| !равно текущей кодировке выходной страницы, |
|
| $response:charset |
|
| ::sql{...} |
::sql{...} |
| !::create{<string/>} старое имя 'set' |
::create[[URI]]{<?xml?><string/>} old name 'set' |
| !::create[qualifiedName] |
::create[[URI]][qualifiedName] |
| !::load[file.xml] |
URI default = disk path to requested document |
| !.transform[rules.xsl][[params hash]] выдаёт dom |
for directories a trailing / is mandatory |
| шаблон кэшируется, кэш обновляется при изменении даты файла шаблона, |
::create[file] can be usable: |
| или изменении даты файла "имя шаблона.stamp"[проверка даты stamp приоритетнее] |
$f[^file::load[binary;http://;some HTTP options here...]] |
| |
$x[^xdoc::create[$f]] |
| |
::load[file.xml[;options]] |
| |
.transform[rules.xsl|xdoc][[params hash]] returns dom |
| |
the template is cached, cache is updated if the template file date changes, |
| |
or the date of "template_name.stamp" changes [stamp date check has priority] |
| <xsl:output |
<xsl:output |
| !method = "xml" | "html" | "text" |
method = "xml" | "html" | "text" |
| X| qname-but-not-ncname |
version = nmtoken |
| !version = nmtoken |
encoding = string |
| !encoding = string |
omit-xml-declaration = "yes" | "no" |
| !omit-xml-declaration = "yes" | "no" |
standalone = "yes" | "no" |
| !standalone = "yes" | "no" |
cdata-section-elements = qnames |
| X[передал, но xsltSaveResultTo не использовал его]doctype-public = string |
indent = "yes" | "no" |
| Xесли начинается с "-//W3C//DTD XHTML" то будет выводить XHTML |
media-type = string /> |
| X[передал, но xsltSaveResultTo не использовал его]doctype-system = string |
parameters are passed as is, not xpath expressions |
| !cdata-section-elements = qnames |
|
| !indent = "yes" | "no" |
.string[[output options]] |
| !media-type = string /> |
.save[file.xml[;output options]] with header |
| |
.file[[output options]] = file |
| !.string[output options] |
output options are identical to xsl:output attributes |
| !.save[file.xml;output options] с шапкой |
[exception: cdata-section-elements ignored] |
| !.file[output options] = file |
returns media-type when substituting $response:body[here] |
| output options идентичны атрибутам xsl:output |
|
| [исключение: игнорируется cdata-section-elements, нужно будет, сделаю] |
if the document is referenced as: |
| выдаёт media-type при подстановке $response:body[сюда] |
parser://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 |
| !xnode |
|
| DOM1 attributes: |
DOM1 attributes: |
| !$node.nodeName |
$node.nodeName |
| !$node.nodeValue |
$node.nodeValue |
| !$node.nodeType = int |
read |
| ELEMENT_NODE = 1 |
write |
| ATTRIBUTE_NODE = 2 |
$node.nodeType = int |
| TEXT_NODE = 3 |
ELEMENT_NODE = 1 |
| CDATA_SECTION_NODE = 4 |
ATTRIBUTE_NODE = 2 |
| ENTITY_REFERENCE_NODE = 5 |
TEXT_NODE = 3 |
| ENTITY_NODE = 6 |
CDATA_SECTION_NODE = 4 |
| PROCESSING_INSTRUCTION_NODE = 7 |
ENTITY_REFERENCE_NODE = 5 |
| COMMENT_NODE = 8 |
ENTITY_NODE = 6 |
| DOCUMENT_NODE = 9 |
PROCESSING_INSTRUCTION_NODE = 7 |
| DOCUMENT_TYPE_NODE = 10 |
COMMENT_NODE = 8 |
| DOCUMENT_FRAGMENT_NODE = 11 |
DOCUMENT_NODE = 9 |
| NOTATION_NODE = 12 |
DOCUMENT_TYPE_NODE = 10 |
| |
DOCUMENT_FRAGMENT_NODE = 11 |
| |
NOTATION_NODE = 12 |
| $vasyaNode.type==$xnode:ELEMENT_NODE |
$vasyaNode.type==$xnode:ELEMENT_NODE |
| !$node.parentNode |
$node.parentNode |
| !$node.childNodes = array of nodes |
$node.childNodes = array of nodes |
| !$node.firstChild |
$node.firstChild |
| !$node.lastChild |
$node.lastChild |
| !$node.previousSibling |
$node.previousSibling |
| !$node.nextSibling |
$node.nextSibling |
| !$node.ownerDocument = xdoc |
$node.ownerDocument = xdoc |
| !$element_node.attributes = hash of xnodes |
$node.prefix |
| !$element_node.tagName |
$node.namespaceURI |
| !$attribute_node.specified = boolean |
$element_node.attributes = hash of xnodes |
| true if the attribute received its value explicitly in the XML document, |
$element_node.tagName |
| or if a value was assigned programatically with the setValue function. |
$attribute_node.specified = boolean |
| false if the attribute value came from the default value declared in the document's DTD. |
true if the attribute received its value explicitly in the XML document, |
| |
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 |
$text_node/cdata_node/comment_node.substringData |
| !$pi_node.target = target of this processing instruction |
$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. |
that begins the processing instruction. |
| |
$pi_node.data = The content of this processing instruction |
| |
From the first non-whitespace character after the target |
| |
to the character immediately preceding the ?>. |
| document_node. |
document_node. |
| readonly attribute DocumentType doctype |
readonly attribute DocumentType doctype |
| readonly attribute DOMImplementation implementation |
readonly attribute DOMImplementation implementation |
| readonly attribute Element documentElement |
readonly attribute Element documentElement |
| document_type_node. |
document_type_node. |
| !readonly attribute DOMString name |
readonly attribute DOMString name |
| readonly attribute NamedNodeMap entities |
readonly attribute NamedNodeMap entities |
| readonly attribute NamedNodeMap notations |
readonly attribute NamedNodeMap notations |
| !notation_node. |
notation_node. |
| !readonly attribute DOMString publicId |
readonly attribute DOMString publicId |
| !readonly attribute DOMString systemId |
readonly attribute DOMString systemId |
| |
|
| !DOM1 node methods: |
DOM1 node methods: |
| !Node insertBefore(in Node newChild,in Node refChild) |
Node insertBefore(in Node newChild,in Node refChild) |
| !Node replaceChild(in Node newChild,in Node oldChild) |
Node replaceChild(in Node newChild,in Node oldChild) |
| !Node removeChild(in Node oldChild) |
Node removeChild(in Node oldChild) |
| !Node appendChild(in Node newChild) |
Node appendChild(in Node newChild) |
| !boolean hasChildNodes() |
boolean hasChildNodes() |
| !Node cloneNode(in boolean deep) |
Node cloneNode(in boolean deep) |
| |
|
| !DOM1 element methods: |
DOM1 element methods: |
| !DOMString getAttribute(in DOMString name) |
DOMString getAttribute(in DOMString name) |
| !void setAttribute(in DOMString name, in DOMString value) raises(DOMException) |
void setAttribute(in DOMString name, in DOMString value) raises(DOMException) |
| !void removeAttribute(in DOMString name) raises(DOMException) |
void removeAttribute(in DOMString name) raises(DOMException) |
| !Attr getAttributeNode(in DOMString name) |
Attr getAttributeNode(in DOMString name) |
| !Attr setAttributeNode(in Attr newAttr) raises(DOMException) |
Attr setAttributeNode(in Attr newAttr) raises(DOMException) |
| !/*Attr*/ removeAttributeNode(in Attr oldAttr) raises(DOMException) |
Attr removeAttributeNode(in Attr oldAttr) raises(DOMException) |
| !NodeList getElementsByTagName(in DOMString name) |
NodeList getElementsByTagName(in DOMString name) |
| !void normalize() |
void normalize() |
| |
|
| |
Introduced in DOM Level 2: |
| !Introduced in DOM Level 2: |
Node importNode(in Node importedNode, in boolean deep) raises(DOMException) |
| !Node importNode(in Node importedNode, in boolean deep) raises(DOMException) |
NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName) |
| !NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName); |
boolean hasAttributes() |
| |
|
| !XPath: |
XPath: |
| !^node.select[xpath/query/expression] = array of nodes, |
^node.select[xpath/query/expression] = array of nodes, |
| empty array if nothing found |
empty array if nothing found |
| !^node.selectSingle[xpath/query/expression] = first node if any |
^node.selectSingle[xpath/query/expression] = first node if any |
| !^node.selectBool[xpath/query/expression] = bool if any |
^node.selectBool[xpath/query/expression] = bool if any or die |
| !^node.selectNumber[xpath/query/expression] = double if any |
^node.selectNumber[xpath/query/expression] = double if any or die |
| !^node.selectString[xpath/query/expression] = string if any |
^node.selectString[xpath/query/expression] = string if any or die |
| |
|
| !error codes(пока придут как текст в случае соответствующих ошибок): |
DATA::=string | file | hash |
| INDEX_SIZE_ERR |
hash of the form |
| If index or size is negative, or greater |
[ |
| than the allowed value |
$.file[filename on disk] |
| DOMSTRING_SIZE_ERR |
$.name[filename for user] |
| If the specified range of text does not |
$.mdate[date] |
| fit into a DOMString |
] |
| HIERARCHY_REQUEST_ERR |
|
| If any node is inserted somewhere it |
MAIN |
| doesn't belong |
this is the class automatically loaded from the configuration auto.p, a bunch of auto.p and the requested document: |
| WRONG_DOCUMENT_ERR |
configuration auto.p |
| If a node is used in a different |
cgi: |
| document than the one that created it |
1. either full path from environment variable CGI_PARSER_SITE_CONFIG or next to parser binary |
| (that doesn't support it) |
|
| INVALID_CHARACTER_ERR |
|
| If an invalid character is specified, |
|
| such as in a name. |
|
| NO_DATA_ALLOWED_ERR |
|
| If data is specified for a node which |
|
| does not support data |
|
| NO_MODIFICATION_ALLOWED_ERR |
|
| If an attempt is made to modify an |
|
| object where modifications are not |
|
| allowed |
|
| NOT_FOUND_ERR |
|
| If an attempt was made to reference a |
|
| node in a context where it does not |
|
| exist |
|
| NOT_SUPPORTED_ERR |
|
| If the implementation does not support |
|
| the type of object requested |
|
| INUSE_ATTRIBUTE_ERR |
|
| If an attempt is made to add an |
|
| attribute that is already inuse |
|
| elsewhere |
|
| |
|
| !status |
|
| !чтобы класс был доступен, в apache нужно сказать |
|
| <Location /parser-status.html> |
|
| ParserStatusAllowed |
|
| </Location> |
|
| !в cgi доступен везде |
|
| !в isapi не доступен нигде |
|
| |
|
| !$status:sql hash |
|
| !cache table |
|
| url time |
|
| url time |
|
| url time |
|
| !$status:db hash |
|
| !cache hash db_home=>tables table |
|
| name time users |
|
| name time users |
|
| name time users |
|
| !$status:stylesheet |
|
| !cache table |
|
| file time |
|
| file time |
|
| file time |
|
| !$status:charset hash |
|
| !cache table |
|
| file |
|
| file |
|
| file |
|
| |
|
| !$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 |
|
| |
|
| !MAIN |
|
| это класс, загружаемый на автомате из parser3.conf, |
|
| кучи auto.p и запрашиваемого документа: |
|
| !parser3.conf |
|
| cgi: |
|
| 1.0) полный путь из переменной окружения PARSER_ROOT_CONFIG |
|
| 1.1) configure sysconfdir|windows directory |
|
| 2)рядом с бинарником parser'а |
|
| isapi: windows directory |
isapi: windows directory |
| apache module: |
apache module: |
| 1) ParserRootConfig [httpd.conf only] |
1) ParserConfig [can be in .htaccess] |
| 2) ParserSiteConfig [can be in .htaccess] |
auto.p goes down from DOCUMENT_ROOT/ through the directory tree to the directory of the processed file, inclusive |
| !auto.p вниз от DOCUMENT_ROOT/ по дереву до каталога с обрабатываемым файлом включительно |
the class is assembled from all these files, subsequent ones become parents of the previous ones |
| класс собирается из всех этих файлов, последующие становятся родителями предыдущих |
the name of the last loaded is MAIN, previous ones have no names |
| имя последнего загруженного MAIN, имён у предыдущих нет |
|
| |
after loading MAIN class, its @main[] is called |
| !после загрузки MAIN класса вызывается его @main[] |
the result is passed to its @postprocess[data] if($data is string) ... |
| !результат которого передаётся в его @post-process[data] if($data is string) ... |
the result is then returned to the user |
| !результат которого отдаётся пользователю |
|
| |
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 string "type of problem" |
| !@exception[origin;source;comment;type;code;stack] |
$exception.file $exception.lineno $exception.colno file, line and position where the problem occurred [if not disabled at compile time] |
| !origin файл(строка) где случилась проблема |
$exception.source line that caused the problem |
| !source строка, из-за которой случилась проблема |
$exception.comment English comment |
| !comment комментарий english |
stack table with columns file line name, |
| !type строка "тип проблемы" (пока пусто) |
in reverse order the names[name] and places[file line] of the operators/methods that caused the error. |
| !code строка "код проблемы" (пока пусто) |
|
| !stack табличка из колонок origin name, |
when loading a file (file::load, table::load, xdoc::load) you can specify such a filename: |
| там лежат в обратном порядке имена[name] и места вызовов[origin] |
http://domain/document[?params<<deprecated, use $.form[...]] |
| операторов/методов, приведших к ошибке. |
and possibly specify options: |
| |
$.method[GET|POST|HEAD] |
| !нужно выключить русский apache: CharsetDisable on |
$.timeout(3) << in seconds, default=2 |
| |
$.cookies[ |
| |
$.name[value] |
| !DATA::=string | file |
] |
| |
$.headers[ |
| --- |
$.field[value] << value format like $response:HEADER |
| если в MAIN будет определён флаг $ORIGINS(1) то вместо обычного вывода страницы будет |
] |
| выдан список фрагментов результата с указанием их происхождения |
$.enctype[multipart/form-data] |
| |
$.form[ |
| |
$.field1[string] |
| |
$.field2[^table::create{one_column_only^#0Avalue1^#0Avalue2}] |
| |
$.field3[file] |
| |
] |
| |
$.body[string|file] |
| |
default user-agent=parser3 |
| |
by default, getting http status != 200 >> creates http.status error, can be disabled by $.any-status(1) |
| |
$.charset[default encoding of remote documents], if server returns content-type:charset - IT OVERRIDES |
| |
$.response-charset[encoding of remote documents], not overridden by content-type:charset |
| |
$.user[user] |
| |
$.password[password] |
| |
file::load writes additional fields |
| |
FIELD:value (response field names in uppercase) |
| |
tables << a hash of FIELD->table with a single column "value" |
| |
in such tables you can get repeating headers, e.g. multiple set-cookies |
| |
todo: make separate cookies |
| |
|
| |
system error types: |
| |
parser.compile ^test[} compilation (unmatched bracket, ...) |
| |
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 |
| |
file.missing ^file:delete[delme] not found |
| |
file.access ^table::load[.] no rights |
| |
file.read ^file::load[...] error while reading file |
| |
file.seek seek failed |
| |
file.execute ^file::cgi[...] incorrect cgi header/can't execute |
| |
image.format ^image::measure[index.html] not gif/jpg |
| |
sql.connect ^connect[mysql://baduser:pass@host/db]{} not found/timeout |
| |
sql.execute ^void:sql{select bad} syntax error |
| |
sql.duplicate |
| |
sql.access |
| |
sql.missing |
| |
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.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 does not accept connections |
| |
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 |
| |
|
| |
if $SIGPIPE(1) is defined in MAIN, then if processing was interrupted by the user, a message |
| |
about this is written to parser3.log |
| |
|
| |
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 |
| |
|
| |
$Id$ |
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to operators.txt CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3