
*** Типы аргументов в строках описания: ***

        'd' : integer (размер 4 байта)
        'D' : back_int (integer обратный big-endian (4 байта, первый байт - старший)
        'c' : byte / char (размер 1 байт)
        'f' : double (размер 8 байт, float)
        'p' : single (размер 4 байта, float)
        'h' : word (размер 2 байта)
        'H' : back_word (word обратный big-endian)
        'q' : int64 (размер 8 байта)
        's' : WideString  (размер - до  первых нулевых байт)
        'w' : WideStr[byte] (размер - первый байт)
        'b' : array[int]  // массив, первый инт (первые 4 байта) - размер. общий размер = +4 байта.
        'x' : array[byte] // массив,  первый байт - размер, общий размер = +1 байт
        '-' :  пропуск размером '0000' '-(0000Desc)'
        'z' : array[const] // блок фикс. размером '0000'.  'z(0000Desc)'
                  // можно указывать десятичные: z(1234desc), 
                  // или 16-ые: z($FFFdesc), в последнем случае только 3 цифры
                  // это также действительно и для 'a','l'
        'a' : Ascii[const] // ANSI фикс. размером '0000'.  'a(0000Desc)'
        't' : Ascii[byte]  // ANSI,  первый байт - размер, общий размер= +1 байт
        'l' : AsciiZ/const   // 'l(0000Desc)'
          // ANSI до первого нулевого символа
          // либо до максимальной фиксированной длины '0000',
          // если макс. = 0 то максимальная фиксированная длина ограничена размером пакета.
        'v': vardat' // аргумент-полиморф. 
                     // по умолчанию размер равен нулю (т.е. не производит сдвиг на следующее значение строки описателя)
                     // значение, размер и цвет аргумента зависит от суффиксных ф-ций
                     // см. описание суффиксных арг-ф-ций 'GET','GT2','GT3','FOR','SVn','LVn' и другие
        'R' : remark // R(любая строка отображаемая ниже описания пакета)
       
*** Суффиксные функции: ***

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

== Циклы: ==
> ':FOR.xxyy', ':FOR.xxyyy', ':FOR.xxyyyy'
зацикливание нескольких последующих аргументов по значению текущего аргумента
циклы могут быть вложенными.
после первой части суффикса 'For.' идут от 3 до 6 символов, образующие 2 числа.
первое число 'xx' является количеством пропуска аргументов после данного,
второе число 'yy'..'yyyy' является количеством аргументов участвующих в цикле.
число 'xx' должно быть строго 2 символа, число 'yy' может быть от 1 до 4 символов (например For.xxyyyy)
размером цикла является значение самого аргумента (или возвращаемое суффиксом перед FOR)
использование FOR возможно только на целочисленных аргументах ('c','h','d','D','q' и отчасти 'v')
[ на примерах: ]
h(Count:For.0065)  - здесь: берется WORD (h) как значение для цикла следущих 65 аргументов. 'Count' - название данного аргумента.
c(Счетчик:For.0004) - здесь: берется BYTE (c) как значение для цикла следущих 4 аргументов. 'Счетчик' - название данного аргумента.
c(Счетчик:For.0104) - здесь: берется BYTE (c) как значение для цикла следущих 4 аргументов, пропуская перед этим один аргумент
c(Счетч:For.03120) - здесь: цикл 120 аргументов, пропускаются 3.
d(desc:GT3.fname.For.0002) - здесь: вызывается ф-ция GT3.fnamе, далее значение передается в цикл (параметр 'ar1' ф-ции)


== Вызов определенной ф-ции в скрипте описателя ==
> ':GET.name'
h(Get.FName) - значение аргумента (здесь:h - word) передается в функцию скрипта описателя с именем GetFName.
возвращаемое функцией значение является текстовой строкой, которая отображается в описателе пакета в данном аргументе.
прототип ф-ции в скрипте:
function GetFname(ar: variant): string;
тип 'ar' зависит от ожидаемого аргумента:
для c,d,h,q - integer; для p,f - double; для s,w,b,x,-,z,a,t,l - string)
возвращаемое значение является строкой, которая будет отображена вместо значения аргумента.
[ примеры: ]
d(Get.MyFnc) - значение как 32 бит целое ('d') передается в функцию GetMyFnc()
s(Get.fstr) - значение аргумента тип 's' передается в функцию Getfstr()

Внимание! вызов функции суффикса 'Get.' может быть автоматизирован в обход функции скрипта.
(пример см. AutoItemList в скрипте описателя TT2 трафика.)


> ':GT2.name'
аналогично GET. но имеет больший функционал:
прототип:
function GT2.name(ar1,pos,psize,pcol: integer): string;
// ar1 - значение аргумента(для v-type тут 1 байт); idx - индекс в пакете (buf[idx]);
// psize - указатель на size аргумента; pcol - указатель на color аргумента
// pcol^: 0- int, 1- str, 2- dbl, 3- byte, 4- word, 5- int64, 6- arr.
// если pcol^ больше >15 - цвет в виде '00FFFFFF' (т.е. любой пользователя)
[ пример: ]
 аргумент v(GT2.TimeT), в данной ф-ции значение как 8байтовый time_t конвертируется в DateTime:
function GT2TimeT(ar1,idx : integer;psize,pcol : pointer) : string;
// внешняя ф-ция, вызывается не из скрипта, а по аргументу
// v(:GT2.TimeT) - берем аргумент как time_t (unix UNC time)
var i : integer;
    i6 : int64;
    td : TDateTime;
begin
  dWriteMemory(psize, 8); // установим фактический размер аргумента (может быть любым в пределах всего пакета)
  dWriteMemory(pcol, 5); // установим цвет аргумента
  i6 := GInt(buf, idx, 8); // берем реальное значение по размеру (какой хотим такой и берем)
  td := EncodeDate( 1970, 1, 1 ) + (i6 / 86400)+ EncodeTime(3, 0, 0, 0);
  result := DateTimeToStr(td); // возвращаем строку для отображения результата в описателе данного пакета
end;


>':GT3.name<.nextSuffix>'
аналогично GT2, но значение аргумента может быть изменено.
function GT3.name(var ar1: variant; pos,psize,pcol: integer): string;
- значение аргумента строки описателя (в ar1) может быть изменено и возвращено.
ф-ция GT3 является проникающей, т.е. после нее может стоять другой суффикс (иначе не имеет смысла возврат значения)



== Локальные переменные и их использование в строке описания. ==
В пределах одной строки описания могут быть записаны и далее использованы до 10 локальных суффиксных значения.
Суффиксы 'SVn и LVn' проникающие, т.е. после них могут стоять другие суффиксы.
> ':SVn', где n Э 0..9 ( ':SV0' .. ':SV9' )
- записывает значение данного аргумента в переменную номер n
> ':LVn.{GET./GT2./FOR.}', где n Э 0..9 ( :LVn.For.0000 :LVn.Get.name :LVn.GT2.name )
- подставляет в данный аргумент значение из ранее записанной локальной переменной.
> ':ZVn' - обнуляет локальное значение 'n' и значение текущего аргумента (используется далее в суффиксах условий)
> ':EVn' - установка локальному 'n' (и аргументу) значения -1 (integer 32бит)
[ пример: ]
c(char:SV0)d(0)..(другие аргументы)..h(0)v(count:LV0.For.0002)d(1)d(2)
- запишет значение аргумента c(char) в локальную переменную V0
и потом подставит значение в аргументе с циклом
а так как vardat ('v') по умолчанию имеет нулевой размер, 
то сам по себе аргумент v(count:LV0.For.0002) не произведет сдвиг позиции, 
но в качестве значения цикла будет взято из ранее записанной локальной переменной V0
[ пример2: ]
c(val:SV0) .. v(count1:LV0.For.0002)d(1)d(2) .. v(count1:LV0.For.0003)d(1)d(2)d(3)
- c(val:SV0) запишет значение в локальную V0
после из нее дважды будут взяты одинаковые значения для двух циклов.



== Суффиксы расширенного функционала ==
':Skip.xx' (допускается указывать от 1 до 4 символов, например skip.023)
- пропустить следующие xx аргументов строки описателя
':HSkip.xx' (допускается указывать от 1 до 4 символов, например hskip.1234)
- не показывать текущий аргумент и пропустить следующие xx аргументов строки описателя.
Суффиксы 'Skip' и 'HSkip' обычно используются совместно с суффиксами условий.

= суффиксы условий: =
'ExEQ.xxxx' - если значение аргумента равно xxxx тогда выполнить следующие суффиксы данного аргумента строки описателя.
'ExNE.xxxx' - если значение аргумента не равно xxxx тогда выполнить следующие суффиксы
'ExLE.xxxx' - если значение аргумента меньше или равно чем xxxx ..
'ExBE.xxxx' - если значение аргумента больше или равно чем xxxx ..
'ExL.xxxx' - если значение аргумента меньше чем xxxx ..
'ExB.xxxx' - если значение аргумента больше чем xxxx ..
цифровое значение 'xxxx' может иметь от одного символа до восьми, а также шестнадцетиричное с '$' (например :ExB.$10EA4FF)
Суффиксы условий по определению являются проникающими.
использование суффиксов условий возможно только на целочисленных аргументах ('c','h','d','D','q' и отчасти 'v')
[ пример: ]
d(desc:ExEQ.101.Skip.10) - если значение аргумента равно 101 тогда будет выполнен суффикс Skip.0010 который пропустит следующие 10 аргументов строки описателя.
(суффиксы условий возможно использовать с локальными переменными, например LVn.ExEQ... - будет взято значение из локальной переменной 'Vn' (см. локальные суффиксные переменные))






