Главная Описание Функции Вакансии Контакты

Функции AI (Artificial Intelligence).

Ассоциативные строки.

Текст 32 бит (юникод UTF-32LE).

Графика.

Пиксельная графика.

Пиксельный процессор 128 бит.

Графика сложная.

Видео.

Звук.

Интернет.

Служебные.

Специальные.

Время и дата.

Математические.

Контроллы.

Файлы.

Ресурсы, буфер обмена.

Переменные.

Пазлы (динамические базы данных).

Списки Arr (одномерные массивы).

Списки2 Dar (двумерные массивы).

Списки высоких измерений.

Макросы.

Функции VendorPint.

Функции PintLang.

Функции TulkoPint.

Функции VideoPint.

Функции PhotoPint.

Функции VardPint.

Функции DataBase.

Текст 32 бит (юникод UTF-32LE).


АртикулНаименованиеЦена, от
StruSear4V32 Поиск структуры [Arr1,X,Arr2] в Var1/Var11 с текущих параметров в диапазоне Midl1 байт. Выход: Var1 -для поиска, Var11 - копия Var1 для выдачи результата; VarB1 (или =0) фрагмент между структурами; VarA1, VarS, VarA2 (или =0) - начало, середина и конец найденной структуры (выдача из Var11); EAX=0 / JZ - Нет вхождения.
StruSear4V32, Var1, Var11, Arr1, Arr2, Midl1, VarB1, VarA1, VarS, VarA2
StruSear32 Поиск структуры [Arr1,X,Arr2] в Var1 с текущих параметров в диапазоне Midl1 байт. Выход: EAX Найденный адр. вхождения Arr1 в Var1 /=0, JZ- Нет вхождения; EBX Длина до вхождения Arr1 в Var1; ECX Адр. за вхождением Arr1 в Var1; EDX Длина за вхождением Arr1 в Var1; ESI Найденный адр. вхождения Arr2 в Var1; EDI Длина до вхождения Arr2 в Var1.
StruSear32, Var1, Arr1, Arr2, Midl1
PintToByte Перевод текста из Var1 (юникод32) в Var[EAX] (CodePage)
PintToByte, Var1, CodePage
PintFromTxt Перевод в Var2=EAX(Pint32) из Var1 (UTF16)
PintFromTxt, Var1
PintToTxt Перевод в Var2=EAX(UTF16) из Var1(Pint32), VarBom/0- заголовок, если он есть
PintToTxt, VarBom, Var1
FixVar32 Поиск вхождения Var2 в Var1 по адресу Adr1. Вых: EAX: Адрес за вхождением (Var1); EAX=0, JZ - Нет вхождения. EBX: Длина Var2 (байт!). ECX: 0= Достижение стоп-адреса Var1.
FixVar32, Var1, Var2, Adr1
На основе макроса StartAdr.
FixArr32 Поиск вхождения Arr1/0 в Var1 по адресу Adr1. Вых: EAX: Адрес за вхождением (Var1); 0= Нет вхождения/JZ - Нет вхождения. EBX: Длина Var2 (байт!). ECX: 0= Достижение стоп-адреса. ESI: Adr Arr1. EDI: Индекс входжения (0,1,2...).
FixArr32, Var1, Arr1, Adr1
На основе функции FixVar32.
NUMHEX ВЫВОД HEX из REG32 UNICODE
NUMHEX, REG32
NUMHEX32 Вывод шестнадцатеричного значения в формате [XXXX XXXXh] из REG32 UNICODE по линейному адресу ADLAB
NUMHEX32, REG32 :DWORD, ADLAB :DWORD
VARHEX32 Добавляет к переменной HEX-значение Dta
VARHEX32, Var1, Dta
VarByteHex Преобразует из Var1 младший байт слова-32 в его шестнадцатеричное значение в порядке младший-старший в Var2 (Var1 при Var2=0).
VarByteHex, Var2, Var1
Цикл с макросом Hex4Reg.
VarDec32 Добавление числа-32 N32 как текстового целого неформатированного десятичного числа со знаком в Var1. С использованием FPU. Вых: EAX=число значащих цифр числа. Портит EAX.
VarDec32, Var1, N32
Часто используемая функция. Удобна для получения имени файла, содержащего изменяемое число. Данные FPU не сохраняются.
VarDec64 Добавление целого числа-64 со знаком в неформатированное десятичное текстовое число Var1.
VarDec64, Var1, Nm64:QWORD
VarDecLen Дописывает в Var1 десятичное значение Dat32, дополняя ее слева нулями до общей длины Len1. Портит EAX, EBX.
VarDecLen Var1, Len1, Dat32
На основе функции VarFixLen.
Var16Dec Добавляет в Var1 десятичное число из Dat16 [16/16]. Разделитель - точка. Регистры не портит.
Var16Dec, Var1, Dat16
Var2Sign Добавляет в Var1 в текстовом виде 2 числа из Dat1 - 2 знака после запятой [16.16]. Портит EAX.
Var2Sign, Var1, Dat16
VarFpu Добавляет в Var1 текстовое десятичное значение с Frt1 знаков после запятой, освобождая St(0) FPU. Разделитель из Var2. EAX - число знаков после запятой, EBX- число знаков до запятой.
VarFpu Var1, Var2, Frt1
Сложная функция. При ошибках FPU инициализируется и загружается нулем.
VarFormatFpu Добавляет в Var1 текстовое десятичное число из FPU St(0) согласно формата Frt1, =0 - простое целое число, =1 - 2 фикс. знака после запятой, 3 - целое 4 знака с нулями слева, 4 - [16/16].//Разделитель (запятая) берется из Var2, 5 - 5 знаков после запятой. При Var2=0 записывается только целая часть.
VarFormatFpu, Var1, Var2, Sng1
На основе функции .
VarFromMsF2Arr32 Добавляем к 32-разрядной! Var1 десятичный рейтинг MsF2, знак табуляции и 32-разрядные элементы списка Arr1 через разделитель VarStp или 0.
VarFromMsF2Arr32, Var1, Arr1, VarStp
HexDec32 Преобразует текстовое-32 целое десятичное число со знаком из Var1 в EAX=HEX32. Поиск с конца переменной. JL - Ошибка, переменная некорректна, меньше 4 байт. Портит EBX, EAX.
HexDec32, Var1
Часто подвисает и не выходит из цикла!!!!!!!!!!!!!!!!!! Нет поиска
FpuDec32 Преобразует текстовое-32 десятичное число со знаком и плавающей запятой из Var1 в ST(0) и EAX=Fpu32. Поиск с конца переменной. Производится инициализация командой FINIT.
FpuDec32, Var1
Нет поиска! Сопроцессор загружается на 1 регистр!
CrossVar32 Находит наибольшее пересечение строк-32 целой Var1 и Var2 без учета крайних символов. EAX=Var Max, JLE - нет пересечения
CrossVar32, Var2, Var1
SupCross32 Добавляет в Arr1 все пересечения строк-32 целой Var2 и Var1 без учета крайних символов; JZ - нет пересечения
SupCross32, Arr1, Var2, Var1
MaxCross32 Добавляет в переменную =[EAX] наибольшее пересечение строк-32 Var1 и Var2. JZ - нет пересечения. Портит EAX.
MaxCross32, Var2, Var1
Применяется медленная функция ScanPn.
LeftCross32 VarL(EAX)= пересечение переменных слева, EBX - длина (32) VarL, JL - ошибка, нет вхождения
LeftCross32, Var1, Var2
Применяется сдвоенный цикл.
RightVar32 VarL(EAX)= пересечение переменных справа, EBX - длина (32) VarL, JZ - ошибка, нет вхождения
RightVar32, Var1, Var2
LeftInCross Проверка пересечения переменных Var2 в Var1 слева (с начала). Выход: JZ - входит, JL - нет вхождения, ошибка.
LeftInCross, Var1, Var2
Применяется сдвоенный цикл.
VarFixLen Дописывает в Var2 Var1, дополняя ее слева Dat1 до общей длины Len1. Портит EAX, EBX.
VarFixLen Var2, Var1, Len1, Dat1
На основе функции VarPlusQVal32.
RoubCross Дописывает в LPzl пересечения всех общих начал переменных из строк списка Arr1.
RoubCross, LPzl, Arr1
Многократный неполный цикл списка (N^2/2).
BothCrossVar Поиск пересечения начала Var1 с концом Var2. Вых: EAX: новая переменная вхождения/0, JZ - Нет пересечения.
BothCrossVar, Var1, Var2
BothCrossArr Запись в Arr2 пересечений начала Var1 с концами Arr1 и конца Var1 с началами Arr1.
BothCrossArr, Arr2, Arr1, Var1
В скриптах AI находит первичные разделители.
VarInVar32 Длина, включая вхождение Var2 в Var1 (1,2,...). Результат в EAX, JZ - нет вхождения. Портит регистр EAX.
VarInVar32, Var1, Var2
Ищет только до первого вхождения.Пример: VarInVar32, ['CPU'], ['P'] = 2. Допустимо использовать ту же переменную Var1, Var1.
QVarInVar32 Количество вхождений Var2 в Var1 (в EAX), JL - нет вхождения, шибка. Портит EAX.
QVarInVar32 Var1, Var2
В отличие от VarInVar32, проходит Var1 до конца.
VarInVarNR Длина (в байтах), включая регистронезависимое вхождение переменых-32 Var2 в Var1 (1,2,...). Результат в EAX, JZ - нет вхождения.
VarInVarNR Var1, Var2
Регистронезависимый аналог функции VarInVar32.
ArrInVar32 Последовательный поиск. Длина 1-го вхождения Arr1 в Var1. Результат: длина после вхождения=EAX, длина до вхождения=EBX, ссылка на вхождение =ECX, JZ - нет вхождения
ArrInVar32, Var1, Arr1
Проходит список по циклу. Переменные сравнивает функцией VarInVar32. Всю переменную просматривает для каждого элемента Arr1. При первом вхождении завершает поиск.
ArrInVarNE32 Последовательный поиск. Номер (1,2,..) позиции символа 32 бита 1-го вхождения Arr1 в Var1, не равного Var1. Результат: позиция конца вхождения=EAX, позиция начала вхождения=EBX, ссылка на вошедшую строку Arr1 =ECX, JZ - нет вхождения.
ArrInVarNE32, Var1, Arr1
Проходит список по циклу. Всю переменную просматривает для каждого элемента Arr1. Переменные сравнивает функцией VarInVar32. При первом вхождении неравных переменных завершает поиск.
VarInArr32 Установка MsF1=1 в строках Arr1, в которые входит Var1. Вых.(в EAX) - количество строк Arr1, имеющих вхожение. При EAX=0, JL - ошибка, нет вхождения.
VarInArr32 Arr1, Var1
На основе функции VarInVar32.
VarDivi32 Разделение Var1 на VarL/Var1/0 и VarR/Var1/0 по числу символов Len32 (Dir1=0 - с начала, <>0 - с конца).
VarDivi32, VarL, VarR, Var1, Len32, Dir1
Суперуниверсальная функция. На основе макросов StartVR и VarEAX4. Создает новые переменные (или переписывает исходную) определенной длины. Одна и та же переменная может являеться и источником и приемником (..Var1, Var1, ..).
FindFile32 Возвращает в EAX=список32 файлов из каталога VFlNm32 по образцу (Vpat32 или 0)
FindFile32, VFlNm, Vpat
Частоупотребляемая функция.
Dir32 Добавляет в Arr1=список32 файлов из каталога VFlNm32.
Dir32, Arr1, VFlNm
VarInDir32 Ищет в BIN-файлах каталога Dir32 (по образцу Pat32/0) Qe1 вхождений Var1, имена возвращает списком в EAX
VarInDir32, Dir32, Pat32, Var1, Qe1
Left32 Создает переменную-левую часть Var1 длиной Len32*4 байт в [EAX]. Ошибка - JL.
Left32, Var1, Len32
На основе макросов StartVR и VarEAX4. Создает новую переменную до определенной длины.
LeftToSea32 Создает в [EAX] переменную-левую часть Var1 до 1 вхождения в нее Var2; JZ - нет вхождения: выводится вся переменная целиком Var1. Если Var2 пустая, выводится пустая переменная. Портит EAX.
LeftToSea32, Var1, Var2
На основе функций VarInVar32 и Left32.
ArrLeftToSea32 Оставляет левую часть строк Arr1 до 1 вхождения в них Var1.
ArrLeftToSea32, Arr1, Var1
LeftArrInVar32 Создает переменную-левую часть Var1 до 1 вхождения в нее Arr1. Результат в EAX, JZ - нет вхождения
LeftArrInVar32, Var1, Arr1
VarRepFirstNR Перемещает на первое место в Var1 первое регистронезависимое вхождение участка Var2. При отсутствии вхождений дописывает Var2 в начало Var1.
VarRepFirstNR Var1, Var2
На основе макроса VarPlus32 и функции VarRepVarNR.
VarRepVar32 Добавление в VarR копии Var1 с заменой в ней 1-го вхождения Var2 на Var3/0 Qz1 раз (<1 - все). При VarR=0 замена самой Var1. Вых: EAX=Число замен Var1, JZ - нет вхождения. Портит EAX.
VarRepVar32, VarR, Var1, Var2, Var3, Qz1
Проверить все похожие ф. Перепроверить! Подставлен NextPn. Сложная функция. При Qz1<1 -только удаление вхождения, замена не учитывается.
VarRepVarNR Добавление в VarR копии Var1 с заменой в ней 1-го регистронезависимого вхождения Var2 на Var3 Qz1 раз (<1 - все). При VarR=0 замена самой Var1. Вых: EAX=Число замен Var1, JZ - нет вхождения. Портит EAX.
VarRepVarNR VarR, Var1, Var2, Var3, Qz1
Регистронезависимый аналог функции VarRepVar32.
VarRepCircleArr Добавление в VarR копии Var1 с заменой в ней вхождений Var2 по циклу последовательно на строки Arr1. При VarR=0 замена самой Var1. Вых: EAX=Число замен Var1, JZ - нет вхождения. Портит EAX.
VarRepCircleArr, VarR, Var1, Var2, Arr1
Модификация функции VarRepVar32.
VarDupDel32 Удаляет из Var1 двойные (и более) повторения Var2 (заменяет в самой Var1). Вых: EAX=Число замен.
VarDupDel32, Var1, Var2
На основе циклического вызова функции VarRepVar32. После функций замены может удалять возникающие лишние повторения.
DupDelDat32 Удаляет из Var1 двойные (и более) повторения Dat32. Вых: EAX=Число замен.
DupDelDat32, Var1, Dat32
На основе циклического вызова функции VarRepVar32. Удобна для удаления лишних пробелов из текста.
VarPlusQVal32 Добавление числа Val1 длиной 32 Qlt1 раз
VarPlusQVal32, Var1, Val1, Qlt1
На основе макроса VarEAX4. Заливка данных.
VarPlusQVar32 Добавление Var2 к Var1 Qlt1 раз.
VarPlusQVar32 Var1, Var2, Qlt1
На основе макроса VarPlus32 . Заливка переменных.
VarTab32 Добавляет к Var1 "табуляцию" - Var3 в количестве 8-len(Var2).
VarTab32 Var1, Var2, Var3
На основе функции VarPlusQVar32.
LenCompVar EAX: Позиция-32 (0,1,..) до 1-го комплексного вхождения в Var1 элемента Arr1. EBX: Длина Var2. ECX: 0= Достижение стоп-адреса. ESI: Adr Arr1. EDI: Индекс входжения (0,1,2...). Нет вхождения - в EAX вся длина32. JZ нет вхождения.
LenCompVar, Var1, Arr1
Длина после 1 вхождения EAX+EBX.
LenVarQVar Позиция-32 (0,1,..) до QLn1-го (1,2,..) вхождения Var2 в Var1. Нет вхождения - вся длина. Результат в EAX.
LenVarQVar, Var1, Var2, QLn1, Dup1
На основе макросов StartVR и функции FixVar32. Удобна для отрезания нескольких левых ячеек в CSV-файлах, отрезания начальных слов в строке и т.д.
LenQCompVar Позиция-32 (0,1,..) до QLn1-го (1,2,..) комплексного вхождения в Var1 элемента Arr1. Дубликаты более Dup1 раз подряд не учитываются. Нет вхождения - вся длина. Результат в EAX. JZ нет вхождения.
LenQCompVar, Var1, Arr1, QLn1, Dup1
На основе макросов StartVR и функции FixArr32. Удобна для отрезания нескольких левых ячеек в CSV-файлах, отрезания начальных слов в строке и т.д. (совместно с функциями LeftCut32, VarDivi32 и т.д.)
LeftQCompVar32 Левая часть до QLn1-го (1,2,..) комплексного вхождения в Var1 элемента Arr1. Дубликаты более Dup1 раз подряд не учитываются. Нет вхождения - вся длина. Результат в EAX, EBX - число вхождений, JZ - нет вхождения.
LeftQCompVar32, Var1, Arr1, QLn1, Dup1
На основе макросов StartVR и функции FixArr32. Удобна для отрезания нескольких левых ячеек в CSV-файлах, отрезания начальных слов в строке и т.д.
LeftCut32 Правую часть Var1 после LenL2 (=1,2,..) оставляем в Var1. Левую часть Var1 перед LenL1 (до LenL2 при LenL2
LeftCut32, VarL, Var1, LenL1, LenL2
На основе StartVR, VarEAX4, VarCopy. Если требуется только правая часть, можно писать VarL=0.
CutToSea32 Левую часть Var1 перед вхождением VarS добавляем в VarL. Возможо VarL=0. Правую часть Var1 за вхождением VarS оставляем в Var1. JZ - нет вхождения.
CutToSea32, VarL, Var1, VarS
Универсальная функция на основе VarInVar32 и LeftCut32. Последовательный поиск. Если требуется только правая часть, можно писать VarL=0. Проверить правую длину!-Научный тык
Перепроверить!!! VarL открывается не так!
CutToSeaArr32 Разрезаем Var1 на 3 части по первому вхождению в нее элементов ArrS для неравных переменных. Левую часть Var1 перед 1-м вхождением ArrS, не равнным Var1, добавляем в VarL. Правую часть Var1 за вхождением ArrS оставляем в Var1. Ссылка на вхождение = EAX. JZ - нет вхождения.
CutToSeaArr32, VarL, Var1, ArrS
Универсальная функция на основе ArrInVarNE32 и LeftCut32 - поиск первого вхождения неравных переменных. Последовательный поиск. Медленная, плохо применима для больших объемов.
MidCompVar32 Выделяет середину - часть строки после NStr1 (0,1,2,..) и до (не включая) NFin1 (0,1,2,..) номеров комплексного вхождения в Var1 элементов Arr1. Дубликаты более Dup1 раз подряд не учитываются. Результат в EAX, EBX - число вхождений, JZ - нет вхождения.
MidCompVar32, Var1, Arr1, NStr1, NFin1, Dup1
Эффективная функция. Пример применения (со списком AllDel32) - вырезание части строки со слова номер NStr1 до слова норер NFin1. Выбор 4 слова из строки Var1: Invoke MidCompVar32, Var1, AllDel32, 4, 4, 1
MidSear32 Ищет середину (в EAX) - промежуток между 1-ми вхождениями в Var1 переменных VarL, VarR. Правую часть Var1 за вхождением VarR(VarL) оставляем в Var1. JZ - нет вхождения.
MidSear32, Var1, VarL, VarR
На основе функции CutToSea32. Сходна с функциями StruSear. Может использоваться в цикле, т.к. исходная переменная обрезается. Выходная переменная создается в любом случае. Ее желательно удалить после использования.
DelMid32 Удаляет из Var1 середину - все промежутки между вхождениями в Var1 переменных VarL, VarR, включая их самих. Вых. EAX=число удалений. JL - нет удалений, ошибка.
DelMid32, Var1, VarL, VarR
На основе функции CutToSea32. Не самая эффективная функция. Производит многократное копирование данных. Для больших объемов не рекомендуется из-за потребления значительных ресурсов.
RemMid32 Замена в Var1 1-й середины - все промежутки между вхождениями в Var1 переменных VarL, VarR, включая их самих на Var2. Вых. EAX=число удалений. JL - нет удалений, ошибка.
RemMid32, Var1, VarL, VarR, Var2
На основе функции CutToSea32.
TagRemMid32 Замена в Var1 1-й середины - все промежутки между вхождениями в Var1 переменных L и R из VarTag = L
R, включая их самих на Var2. Вых. EAX=число удалений. JL - нет удалений, ошибка.
TagRemMid32, Var1, VarTag, Var2
На основе функции RemMid32. Вариант для VarEdit.
VarMid32 Середину Var1 после LenL1 и перед LenL2 (длина 1,2...) добавляем в Var2/0 (при Var2=0 переписываем в Var1).
VarMid32, Var2, Var1, LenL1, LenL2
Цикл StartVR от начала и до LenL2 с макросом VarEAX4.
VarRepN32 Последовательная замена в Var1 всех получающихся вхождений списка ArrFr на переменную Var3/0, Qz1 раз (<1 - все). Портит EAX. EAX=общее число замен, JZ - нет вхождения.
VarRepN32, Var1, ArrFr, Var3, Qz1
На основе функции VarRepVar32.
ArrRepVar32 Последовательная замена в строках Arr1 вхождений Var1 на переменную Var2, Qz1 раз (<1 - все). Портит EAX. EAX=общее число замен, JZ - нет вхождения.
ArrRepVar32, Arr1, Var1, Var2, Qz1
На основе функции VarRepVar32.
ArrRepA32 Последовательная замена в строках Arr1 всех получающихся вхождений списка ArrFr на переменную Var3/0, Qz1 раз (<1 - все). Портит EAX. EAX=общее число замен, JZ - нет вхождения.
ArrRepA32, Arr1, ArrFr, Var3, Qz1
На основе функции VarRepN32.
ArrRepInd Меняет местами строки из Arr1 с индексами Ind1 и Ind2 с заменой адресов. Вых. EAX=Arr1[Ind1], EBX=Arr1[Ind2] (новые), JL - ошибка. Портит EBX, EAX.
ArrRepInd Arr1, Ind1, Ind2
На основе функции VarVal. Медленная на длинных списках. Простая замена адресов переменных.
ArrMovInd Копирование ячейки Ind2 в Ind1 в списке Arr1.
ArrMovInd, Arr1, Ind1, Ind2
На основе функции VarVal. Медленная на длинных списках.
ArrPlusDat32 Добавление к списку новой переменной, содержащей значение 32 бита Dat32. EAX=адр. добавленной переменной. Изменяет только регистр EAX.
ArrPlusDat32, Arr1, Dat32
Простейшая функция. Удобна, если элемент списка содержит всего один 32-битный символ.
Var4Dat Очистка и вставка в переменную Var1 (создание ее при необходимости) 4 чисел-32 Dat40-Dat43. Вых. EAX - новая переменная. Портит EAX.
Var4Dat, Var1, Dat_40, Dat_41, Dat_42, Dat_43
На основе макроса NewIfNone, CleVar и VarEAX4.
VarPlus4Dat Добавление в переменную Var1 4 чисел-32 Dat40-Dat43. Портит EAX.
VarPlus4Dat, Var1, Dat_40, Dat_41, Dat_42, Dat_43
Добавляет к переменной сразу 4 числа-32
VarPlus20Dat Добавление к переменной-32 Var1 Dtt0-Dtt19 до значения Dtt=-1.
VarPlus20Dat, Var1, Dtt0, Dtt1, Dtt2, Dtt3, Dtt4, Dtt5, Dtt6, Dtt7, Dtt8, Dtt9, Dtt10, Dtt11, Dtt12, Dtt13, Dtt14, Dtt15, Dtt16, Dtt17, Dtt18, Dtt19
Позволяет набирать 32-разрядную латиницу в 1 строку.
SimpleVar32 Заменяет некоторые национальные символы на упрощенные (в латинице, кириллице и латышском) в самой переменной Var32. Портит EAX, EBX.
SimpleVar32, Var32
Незаменима при анализе некорректно написанных текстов.
SimpleArr Заменяет некоторые национальные символы на упрощенные (в латинице, кириллице и латышском) в самом списке.
SimpleArr, Arr1
HigFirstVar Заменяет в Var1 первую букву с прописной на заглавную в юникоде-32 (в латинице, кириллице и латышском). Регистры EAX, EBX изменяет. JL - пустая переменная/ошибка.
HigFirstVar, Var1
На основе макроса HigVar32.
HigVar Заменяет в Var1 с прописной на заглавную буквы в юникоде-32 (в латинице, кириллице и латышском).
HigVar, Var1
На основе макроса HigVar32.
LowVar Заменяет заглавные буквы на прописные в юникоде-32 (в латинице, кириллице и латышском) в самой переменной.
LowVar, Var32
На основе макроса LowVar32. Очень быстрая специализированная функция. Текст-32 должен быть без BOM! - иначе, произойдет смещение и распознать юникод будет проблематично. Буквы Ё, Й декодируются для 1 и 2-символьных вариантов.
LowArr Заменяет заглавные буквы на прописные в юникоде-32 - опускает в нижний регистр (в латинице, кириллице и латышском).
LowArr, Arr1
Очень быстрая специализированная функция на основе функции LowVar. Текст-32 должен быть без BOM! - иначе, произойдет смещение и распознать юникод будет проблематично. Буквы Ё, Й декодируются для 1 и 2-символьных вариантов.
LowPzl Заменяет в переменных строк VReff пазла Pzl1 в юникоде-32 на переменные с прописными буквами - опускает в нижний регистр (в латинице, кириллице и латышском). Вых: EAX=Счетчик вхождений.
LowPzl, Pzl1
Очень быстрая специализированная функция на основе функции LowVar. Текст-32 должен быть без BOM! - иначе, произойдет смещение и распознать юникод будет проблематично. Буквы Ё, Й декодируются для 1 и 2-символьных вариантов.
ArrFromVar32 Нарезает в Arr1 переменную Var1 по разделителю Var2. Результат в EAX - число вхождений, JZ - нет вхождения.
ArrFromVar32, Arr1, Var1, Var2
На основе функции FixVar32.
ArrFromVarDel Нарезает в Arr1 переменную Var1 по разделителю Var2, разделитель пишется отдельно с MsF1=0. Результат в EAX - число вхождений, JZ - нет вхождения.
ArrFromVarDel, Arr1, Var1, Var2
Модификация функции ArrFromVar32.
ArrFromCompVar32 Добавление в Arr2 фрагментов Var1, полученных разделением Var1 по комплексным вхождениям в нее элементов Arr1. При Flg1=0 сами вхождения не записываются, при Flg1=1 вхождения остаются в конце фрагментов, при Flg1=2 записываются, как отдельные фрагменты. Результат - EAX - число вхождений, JZ - нет вхождения.
ArrFromCompVar32, Arr2, Var1, Arr1, Flg1
Быстрая функция.
ArrFromLine Дописывает в список Arr1 из линейной памяти с адреса LineAdr Qy1 строк-32 шириной Qx1.
ArrFromLine, Arr1, Qx1, Qy1, LineAdr
VarEdit "Редактирование самой строки-32 Var1 по номеру функции Fun1 и переменных Var2/0, Var3/0 и списка из 100 ячеек Arr1/0. Функция Fun1 состоит из xxx[QQQ][NNN]h, QQQ - формат мат. результата, NNN - номер функции. Входные и выходные переменные определяет текстовое десятичное число в 1 строке Arr1.
VarEdit, Var1, Fun1, Var2, Var3, Arr1


Страница "Текст 32 бит (юникод UTF-32LE)." обновлена -

Бесплатная консультация:

Позвоните нам по телефону: +7 499 677-1694
или введите короткое сообщение
Текст 32 бит (юникод UTF-32LE). | © 2008-2015 | Все права защищены. | Создание сайта WebOptimal |
При полном или частичном использовании материалов сайта ссылка на http://PowerIntellect.com обязательна.