Данная статья является продолжением серии статей посвященных Системе разработки клиентских приложений (KISS Virtual XML DBCS). В этой статье рассматривается синтаксис языка программирования ULCA (Universal Language for Client Application) , используемого этой Системой.
Язык ULCA создавался с нуля. У Разработчика языка не было никаких ограничений в определении синтаксиса этого языка. Он руководствовался исключительно лишь собственным опытом (как положительным, так и отрицательным), полученным при работе с другими языками программирования.
Целью разработки языка ULCA было создание строго формализованного предельно простого универсального языка программирования совместимого со всеми объектно-ориентированными языками, как по синтаксису, так и по типам используемых данных.
Синтаксис языка ULCA, по замыслу его разработчика, должен использовать универсальные синтаксические конструкции, которые были бы понятны (семантически) всем объектно-ориентированным языкам. То есть программный код, написанный на языке ULCA, должен иметь возможность однозначно транспилироваться в текст любого другого объектно-ориентированного языка (принимающего языка). Набор используемых синтаксических конструкций должен быть минимальным (необходимым и достаточным). Лексические единицы должны быть атомарными (неделимыми). Синтаксис язык ULCA не должен использовать неоднозначные понятия, смысл которых зависит от контекста.
Язык ULCA - это новый язык, и учебник для него еще не написан. Эту статью можно рассматривать как краткий справочник, в котором подробно описан синтаксис языка. В данной статье используются понятия и определения, сделанные в предыдущей статье, посвященной объектной модели, являющейся основой языка ULCA.
Базовые типы данных.
Язык ULCA является жестко типизированным. Состав допустимых типов данных минимальный и не может быть пополнен. Это обеспечивает совместимость по данным со всеми объектно-ориентированными языками программирования (в том числе и со скриптовыми языками программирования, такими, как JavaScript и PHP), а таже с типами данных внешних источников данных (реляционные базы данных).Для обозначения типа данных используется одна прописная латинская буква. Состав базовых типов данных, используемых языком ULCA:
c - char - строка символов в любой кодировке
n - numeric - вещественное число
i - integer - целое число
l - logical - логическое значение
d - date - дата
t - time - время
s - stamp - штамп (дата и время)
o - object - ссылка на объект
a - array - ссылка на массив
f - function - ссылка на процедуру
u - variant - неопределенное значение
Строка символов: c - char
Символьный тип. Строка символов переменной длины в любой кодировке. Может содержать буквы, цифры, знаки пунктуации, пробелы, спецсимволы, нулевые байты и любые другие двоичные данные.
Минимальная длина строки: 0 байтов
Максимальная длина строки: 16777184 байтов
Константы:
строка символов, заключенная в двойные или одинарные кавычки: "[X]..." или '[Y]...', где: X - любой печатный символ, включая одинарные кавычки и исключая двойные кавычки, а Y - любой печатный символ, включая двойные кавычки и исключая одинарные кавычки
шестнадцатеричная строковая константа: 0h[FF...], где: FF - шестнадцатеричное представление одного байта
Пустое значение: "",0h
Автоматическое преобразование типов:
с <-> s, d, t
Вещественное число: n - numeric
Числовой тип. Может содержать только целые или десятичные числа. Занимает 8 байтов памяти. Максимальная точность содержимого составляет 15 десятичных разрядов.
Константы:
[+|-][XXXXX][.][XXXX][eXXX]
X - десятичное число
Минимальное значение: -1.79769313486223157e308
Максимальное значение: +1.79769313486223157e308
Пустое значение: 0
Автоматическое преобразование типов:
n <-> t, i
Целое число: i - integer
Целое число. Занимает 4 байта памяти
Константы:
десятичная константа [+|-][XXXXX], где X - десятичное число
шестнадцатеричная числовая константа: 0x[FF...], где: FF - шестнадцатеричное представление одного байта
Минимальное значение: -2147483647
Максимальное значение: +2147483647
Пустое значение: 0, 0x
Автоматическое преобразование типов:
i <- (int(n))
i -> n
i <-> l (0|1)
Логическое значение: l - logical
Логический тип. Занимает 1 байт памяти и может принимать только два значения - истина или ложь
Константы:
true - именованная константа (истина)
false - именованная константа (ложь)
Пустое значение: false
Автоматическое преобразование типов:
l <-> i (0|1)
Дата: d - date
Дата в формате YYYYMMDD. Строка фиксированной длины (9 байтов).
Константа: {d [YYYY-MM-DD]},где:
YYYY - год (1-9999)
MM - месяц (1-12)
DD - день (1-31)
Минимальное значение: {d 0001-01-01}
Максимальное значение: {d 9999-12-31}
Пустое значение: {d}
Автоматическое преобразование типов:
d <-> s, c
Время: t - time
Время в формате HHMMSSmmm. Строка фиксированной длины (9 байтов).
Константа: {t [HH:MM:SS[.mmm]]}, где:
HH - часы (00-23)
MM - минуты (00-59)
SS - секунды (00-59)
mmm - миллисекунды (000-999)
Минимальное значение: {t 00:00:00.000}
Максимальное значение: {t 23:59:59.999}
Пустое значение: {t}
Автоматическое преобразование типов:
t <-> c, n (seconds()), s
Штамп: s - stamp
Занимает в памяти 10 байтов и содержит дату, время и номер пользователя, создавший этот штамп.
Константа: {s [YYYY-MM-DD[,HH:MM:SS[.mmm]]]}, где:
YYYY - год (1-9999)
MM - месяц (1-12)
DD - день (1-31)
HH - часы (0-23)
MM - минуты (0-59)
SS - секунды (0-59)
mmm - миллисекунды (0-999)
Минимальное значение: {s 0001-01-01,00:00:00.000}
Максимальное значение:{s 9999-12-31,23:59:59.999}
Пустое значение: {s}
Автоматическое преобразование типов:
s <-> c, d, t
Ссылка на объект: o - object
Константа: nothing - именованная константа означает пустую ссылку (содержит адрес объекта базового класса empty)
Пустое значение: nothing
Автоматическое преобразование типов: нет
Ссылка на массив: a - array
Используется для ссылки на массив. Массив относится к ссылочным типам данных и его можно использовать в качестве аргумента процедуры и возвращать в качестве значения процедуры.
Пустое значение: ссылка на пустой массив (нет строк, только дескриптор)
Автоматическое преобразование типов: нет
Ссылка на процедуру: f - function
Используется для передачи ссылки на функцию (на точку входа в нее). Её можно использовать в качестве аргумента процедуры и возвращать в качестве значения процедуры. Обычно используется, как инструмент для вызова callback процедур. Этот тип данных доступен только для переменных и не недоступен для свойств.
Пустое значение: точка входа не определена
Автоматическое преобразование типов: нет
Произвольное значение: u - variant
Произвольный тип данных. Как только будет присвоено значение переменной этого типа, переменная принимает тот тип данных, который содержит присваиваемое значение (без всякого преобразования). Произвольный тип данных используется в качестве "аэродрома подскока" для временного хранения данных в локальных переменных до момента их использования или сохранения. Этот тип данных доступен только для переменных и не недоступен для свойств.
Произвольный тип данных может принимать значение любого типа данных (в том числе и типов данных, явно не поддерживаемых языком ULCA).
Процедуры
Процедура представляет собой текст из строк, разделенных символом перевода строки.
Процедура состоит из набора команд.
Каждая команда начинается с новой строки. Если текст команды не помещается на одной строке, то в конце текущей строки ставится символ продолжения команды на следующую строку (точка с запятой). Количество строк продолжения не ограничено.
Команда начинается с ключевого слова, однозначно определяющего вид команды. Перед ключевым словом команды может быть произвольное количество пробелов.
Блок команд - это набор команд, которые в командах структурного программирования рассматриваются как единое целое. Для выделения этого блока используются, не фигурные скобки, как это делается во многих языках программирования, а ключевые слова, так как это сделано, например, в языке Visual Basic, что значительно повышает читабельность исходного кода процедуры, особенно при глубокой вложенности управляющих структур.
В языке ULCA используется следующие типы процедур:
методы (methods)
события (events)
системные функции (system functions)
функции, определенные пользователем (UDF)
внешние функции (API functions)
Все перечисленные выше типы процедур приведены к единому стандарту, что позволяет работать с ними в едином стиле, независимо от их особенностей. Это, прежде всего, касается средств IntelliSense. Термин "процедура" в дальнейшем используется для ссылок на любой указанный выше тип, хотя в некоторых языках процедура и функция являются различными понятиями (функция возвращает значение, а процедура только выполнят определенные действия). Все процедуры, используемые в языке ULCA, возвращают какое либо допустимое для данной процедуры значение.
Команды
Команды подразделяются на следующие группы:
Команды определения
par
var
tip ... endtip
with ... endwith
Команды присвоения /слияния
=
\
Управляющие структуры (команды структурного программирования)
if ... [else ...] endif
do while | until ... enddo
choose case ... [otherwise ...] endcase
for ... endfor
try ... [catch ....] endtry
Команды передачи управления
exit
loop
break
nodefault
cancel
quit
return
Комментарии
*
/* */
Как можно понять из приведенного выше списка команд, язык ULCA имеет предельно ограниченный список команд. Эти команды присутствуют, в том или ином виде, во всех языках программирования высокого уровня. Синтаксис команд может сильно отличаться, но смысл (семантика) одна и та же. Если Вы знакомы с каким-либо языком программирования, то Вам, без лишних комментариев, понятен смысл приведенных выше команд.
Возникает вопрос, является набор допустимых команд достаточным для решения тех задач, для которых предназначен язык ULCA? Язык ULCA является чисто объектным языком, и его возможности определяются не столько синтаксическими конструкциями, сколько возможностями используемой им объектной модели. Для языка ULCA указанный состав команд является необходимым и достаточным. Особенности языка ULCA связаны с его объектной природой. Об этих особенностях Вы узнаете, если внимательно прочитаете оставшиеся разделы статьи.
Элементы языка программирования
В командах можно использовать следующие элементы:
константы
переменные
обращения
функции
выражения
Константы
Логические константы
true/*истина
false/*ложь
Пустая объектная ссылка
nothing
Строка
"Text" /* текст, заключенный в двойные или одинарные кавычки
0hXX.../*текст в шестнадцатеричном представлении
Дата
{d [CCYY-MM-DD]}
Время
{t [HH:MM[:SS[.mmm]]]]}
Штамп
{s [CCYY-MM-DD[,HH:MM[:SS[.mmm]]]]}
Целые числа
[+|-]9999999999 /* целое число в десятичном представлении
0xXX... /* целое число в шестнадцатеричном представлении
Действительные числа
[+|-]999999999.999 десятичное представление
[+|-]0.9999999999е[+|-]999 - научная нотация.
Отметим некоторые особенности использования строковых констант.
Поскольку имена переменных, функций, команд, операций и ключевых слов не могут состоять только из одной буквы, то все одиночные буквы, используемые в тексте процедуры, рассматриваются как строковые константы. Например, goDate(dDate,1,M) эквивалентно goDate(dDate,1,"M")
Имена классов также нет необходимости заключать в кавычки. Например, form.TestForm эквивалентно "form.TestForm". Более того, указание имен классов без кавычек является более предпочтительным, поскольку в этом случае можно воспользоваться средствами IntelliSense для выбора имени класса из списка доступных классов. Например, поставив точку после имени базового класса, Вы получите список всех доступных классов указанного базового класса.
Переменные
Переменная - это поименованная область памяти для временного хранения данных. Обращение к значению переменной осуществляется по имени этой переменной.
Имя переменной должно начинаться с прописной латинской буквы, определяющей тип данных для этой переменной. Переменные, в отличие от свойств, могут иметь любой из базовых типов данных. Вторым символом имени должна быть любая буква. Остальными символами в имени переменной могут быть буквы, числа и знак подчеркивания. Длина имени может варьироваться от 2 до 128 символов.
Переменные определяются командами определения par или var в начале выполнения процедуры (par) или в любом месте текста процедуры (var). Все используемые в процедуре переменные должны быть определены явно с помощью указанных выше команд. При создании новой переменной ей автоматически присваивается пустое значение в соответствии с типом данных этой переменной.
Переменные, в зависимости от области видимости и время жизни, подразделяются на три следующих вида:
Локальные переменные (local variables). Доступны только внутри процедуры и автоматически удаляются при завершении процедуры.
Внешние параметры (external parameters). Определяются в одной процедуре, но доступны для чтения и корректировки в цепочке всех вызванных из нее процедур (неявная передача параметров по цепочке вызовов). Автоматически удаляются после завершения процедуры, в которой эти параметры были созданы. Признаком внешнего параметра является префикс e. , который ставится перед именем переменной и является обязательной частью этого имени при его определении и ссылки на него, например e.cText.
Глобальные переменные (global variables). Могут быть определены в любой процедуре и, после определения, становятся доступны из любой процедуры. Автоматически удаляются при закрытии приложения. Наиболее удачным местом для определения глобальных переменных является событие my.Init(). Признаком глобальной переменной является префикс g. , который ставится перед именем переменной и является обязательной частью этого имени при его определении и ссылки на него, например g.aArray. Имеется единственная системная глобальная переменная my (o-типа), которая позволяет с помощью квалификационных имен обратиться к любому созданному объекту. Переменная my ссылается на объект application, который является корневым объектом Приложения.
Обращения
Обращение - это ссылка на объект, элемент объекта или подложки. Обращение к элементам объекта из процедуры осуществляется с помощью квалификационных имен (имен, разделенных точками):
oRefer.MembName
При обращении к элементам подложки объекта необходимо после точки поставить знак двоеточия:
oRefer.:PropName
oRefer.:ProcName()
При обращении к элементам подложки свойства или процедуры нужно после имени свойства или процедуры поставить двоеточие:
oRefer.PropName:ElName
oRefer.ProcName:ElName
В качестве якоря обращения (oRefer) можно указать глобальное имя my или одну из системных локальных доступных только для чтения переменных This или ThisForm. При вызове процедуры на выполнение автоматически определяются локальные переменные This или ThisForm и им присваивается значение ссылки на объект выполняемой процедуры и на содержащую объект This форму соответственно.
Функции
Язык ULCA использует три типа функций:
Системные функции
Функции пользователя
API-функции
Системные функции
Системные функции - это методы скрытого объекта базового класса datatypes. Этот объект скрыт, поскольку состав системных функций не может быть переопределен. Системные функции предназначены для выполнения операций с различными типами данных. Язык ULCA имеет очень скромный список системных функций по сравнению с другими объектно-ориентированными языками программирования. Это объясняется не ограниченностью функциональных возможностей языка ULCA, а принципом, по которому этот список был сформирован. Проще всего это объяснить на примере функции InsMode(), которая позволяет программно переключать режим ввода текста с клавиатуры. Эта функция, по своему предназначению, не имеет отношения к операциям с типами данных, поэтому в языке ULCA нет аналогичной системной функции. Тем не менее, указанная функциональность реализована объектными средствами посредством свойства .InsMode объекта my.Keyboard. Пример использования этого свойства:
with my.Keyboard
if .InsMode
.InsMode = false
else
.InsMode = true
endif
endwith
Имена системных функций, также как и имена команд, ключевых слов и именованных констант, являются уникальными глобальными именами (зарезервированным именами). Поэтому в языке ULCA запрещено использовать указанные выше имена в качестве имен переменных и параметров. Вызов системной функции выглядит следующим образом:
[?.]FuncName([список аргументов]), где в качестве символа ? указывается имя одного из пространств имен, в которое включена данная функция. Ниже приведен список всех используемых функциями пространств имен.
Группировка по типу возвращаемого значения
c. char /* Строка символов
i. integer /* Целое число
n. numeric /* Вещественное число
l. logical /* Логическое значение
d. date /* Дата
t. time /* Время
s. stamp /* Штамп
o. object /* Ссылка на объект
u. variant /* Произвольное значение
Группировка по типу основного параметра
m. math /* Математические операции
c. string /* Операции со строками
h. chrono /* Операции над хронологическими данными
a. array /* Операции над массивами
b. bits /* Операции с битовым представлением строк и чисел
u. variant - Операции с variant-данными
o. Операции с объектами (создание и обращение)
Функции пользователя
Функции пользователя - это методы объекта my.UDF. Они могут использоваться для пополнения списка системных функций или для определения callback функций. Особенностью функций пользователя является то, что они не имеют собственного контента выполнения. В этих функциях можно использовать относительную ссылку This, но она будет указывать не на объект, в котором определена эта функция (my.UDF), а на объект для той процедуры, из которой данная функция вызвана. Имена функции пользователя являются глобальными и вызываются на выполнение так же, как и системные функции:
uValue = [f.]FuncName().
Для функций пользователя доступно только пространство имен (f.). Его можно указать перед именем функции, чтобы получить список всех функций, определенных в библиотеке my.UDF. Функции пользователя являются обычными методами, которые можно переопределять и вызывать стандартным способом:
uValue = my.UDF.FuncName().
Не стоит засорять библиотеку my.UDF функциями, для которых можно найти или создать соответствующий их назначению объект.
API функции
API функции - это функции, определенные в какой-либо dll библиотеке. Для вызова API функции на выполнение используются ее прототип, текст которого адаптирован к стандартам языка ULCA и хранится в библиотеке My.DLL. API функции вызываются также, как и системные функции. При вызове API функции на выполнение используется имя (алиас), под которым она известна в библиотеке My.DLL. Это имя либо не должно совпадать с именами системных и пользовательских функций, либо при ее вызове необходимо указывать имя пространства имен (x.), выделенное специально для API функций:
[x.]APIFunc([...])
Подробному описанию работы с API функциями посвящена отдельная статья.
Все описанные выше функции соответствуют стандарту языка ULCA, поэтому средства IntelliSense использует их в одном и том же стиле.
Выражения
Выражением называют элемент языка или их совокупность, которая в результате обработки приводит к одному значению определенного типа данных. Выражение состоит из одного операнда или нескольких однотипных операндов, объединенных знаками операций (операторами). В качестве операнда можно использовать один из следующих элементов языка:
переменная
константа
вызов функции
обращение к элементу объекта или подложки
Все операнды, участвующие в выражении должны быть совместимы по типу данных (автоматического преобразования типов в выражении не происходит). Допустимые типы операторов определяются типом данных операндов выражения.
Арифметические операторы (тип данных - n,i)
() /* Повышение приоритета операции: действие в скобках выполняется первым
^ /* Возведение в степень
* /* Умножение
/ /* Деление
+ /* Сложение или плюс
- /* Вычитание или минус
Логические операторы (тип данных - l)
() /* Повышение приоритета операции: действие в скобках выполняется первым
not /* Логическое отрицание (не)
and /* Логическое умножение (и)
or /* Логическое исключение (или)
Оператор конкатенации (тип данных - c,d,t,s)
& /* Объединяет несколько строковых выражений в одну строку
Объединять можно строковые и хронологические выражения. Объединенная строка будет строкой c-типа.
Операторы сравнения (тип данных - с,n,i,d,t,s,l,o)
== /* Равно
<> /* Не равно
< /* Меньше
> /* Больше
<= /* Меньше или равно
>= /* Больше или равно
Операторы сравнения используются для сравнения выражений. Для объектных ссылок и логического типа данных допустимы только операторы сравнение на равенство (==, <>).
Определение переменных
Переменные определяются в списке параметров процедуры (команда par) и посредством команды var.
Переменная может использоваться в качестве аргумента для вызываемой процедуры. При этом значение переданной переменной может быть изменено в вызванной процедуре, если соответствующий аргументу параметр объявлен как возвращаемый (символ @ перед именем параметра). Для того чтобы предотвратить изменение значения переданной переменной, нужно в списке передаваемых аргументов заключить имя переменной в круглые скобки (превратить переменную в выражение). По завершении процедуры все локальные переменные автоматически удаляются и их значения теряются, если только эти значения не сохранены в качестве значений свойств каких либо объектов или не возвращены в вызывающую процедуру в качестве возвращаемого значения.
Для имен переменных предусмотрены следующие пространства имен:
p. - имена параметров, определенных командой par
v. - имена переменных, определенных командами var
Указанные выше пространства имен предназначены для выбора из списка предварительно определенных переменных или параметров нужного имени. Это сокращает время ввода имен и предотвращает ошибки в их написании.
Команда var
Синтаксис команды:
var <Список переменных>
Список переменных представляет собой список имен, разделенных запятыми. Количество переменных не ограничено. В процедуре можно использовать произвольное количество команд var. Команда var является исполняемой командой, которая не только определяет указанные в ней переменные, но и присваивает им пустые значения в соответствие с их типом. Указать не пустое начальное значение переменной можно для переменной o-типа, например:
var cText, oObject = my.Calendar
Это определение эквивалентно двум следующим командам:
var cText, oObject
oObject = my.Calendar
При определении массива можно в круглых (!) скобках указать его первоначальную размерность (количество строк и колонок), например:
var aArrName(3,4)
Как было указано выше, все используемые в процедуре переменные должны быть объявлены явно. Это касается также глобальных переменных и внешних параметров. Определение глобальных и внешних переменных имеет одну важную особенность, связанную с присвоением им начальных значений. Прежде чем присвоить им начальные значения, проверяется, являются эти переменные новыми или уже определены в других процедурах. Если эти переменные уже существуют, то новое определение просто игнорируется, в противном случае, они определяются и им присваивается начальное значение стандартным способом.
Команда par
Команда par предназначена для определения списка параметров, которым присваиваются значения соответствующих им аргументов, переданных из вызывающей процедуры. В процедуре может быть только одна команда parameters, и она должна быть первой исполняемой командой процедуры.
Синтаксис команды:
par <Список параметров>
Список параметров представляет собой список имен переменных, разделенных запятыми. Количество параметров в процедуре не может быть больше 24. Способ передачи значений параметров - позиционный (за исключением плавающих параметров), т.е. порядок передачи значений из списка аргументов в вызывающей процедуре определяется порядком расположения параметров в списке параметров вызванной процедуры. В списке параметров (и только в нем!) можно использовать в качестве элементов языка следующие метасимволы:
| - Признак альтернативы
[ ] - Скобки для необязательной конструкции
... - Признак повторения предыдущей конструкции.
Альтернативные параметры
Одному аргументу процедуры в списке параметров может быть назначена не одна, а несколько разнотипных переменных, разделенных символом "|", например:
par oObject | cClass, uPar
Для первого параметра в списке параметров определены две разнотипные переменные (альтернативные имена параметра). При вызове процедуры значение первого переданного аргумента будет присвоено только одной из указанных переменных (той переменной, тип данных которой совпадает с типом данных переданного аргумента). Другой переменной присвоится пустое значение в соответствии с ее типом данных. Чтобы определить, какая переменная получила значение переданного аргумента, можно воспользоваться методом подложки процедуры :ArgNo(cVarName),возвращающей для указанной переменной номер позиции в списке аргументов. Если указанной переменной ничего не передавалось из списка аргументов, функция возвращает значение 0.
Параметр может быть одного из следующих типов:
- обязательный(mandatory)
- необязательный (optional)
- условно обязательный (conditional)
- плавающий (floating)
Обязательные параметры.
Параметры, не заключенные в квадратные скобки получают тип обязательный и, при отсутствии переданного значения, выдается сообщение об ошибке. Обязательные параметры должны быть определены в начале списка параметров до начала области необязательных параметров.
Необязательные параметры
Некоторые или все параметры могут быть необязательными, т.е. при вызове процедуры значения для них передавать не обязательно и количество аргументов в вызывающей процедуре может быть меньше количества объявленных параметров в вызванной процедуре. Для указания необязательных параметров используются квадратные скобки, уточняющие тип параметра. Необязательные параметры должны быть заключены в квадратные скобки. Открывающаяся квадратная скобка должна быть поставлена либо перед именем первого параметра, либо перед запятой, определяющей позицию необязательного параметра. Все следующие за ним параметры попадают в область необязательных параметров. Закрывающаяся квадратная скобка для необязательного параметра должна быть указана в конце списка параметров.
Условно обязательный параметр
Условно обязательный параметр не заключается в квадратные скобки, но находится в области необязательных параметров. Этот параметр считается обязательным, если указано значение для предыдущего необязательного параметра.Плавающие параметр
Плавающий параметр
Плавающие параметры должны быть размещены в списке параметров после всех обязательных, необязательных и условных параметров (если таковые параметры имеются). Плавающий параметр должен быть необязательным параметром и заключаться в квадратные скобки. Открывающаяся квадратная скобка должна быть поставлена либо перед именем параметра (если он является первым параметром), либо перед запятой, определяющей позицию плавающего параметра. Закрывающаяся квадратная скобка должна быть поставлена не в конце списка параметров (как для необязательных параметров), а сразу после имени этого параметра. Плавающие параметры должны быть параметрами с различными типами данных, поскольку именно по типу данных устанавливается соответствие между переданным аргументом и параметром.
Пример:
par cMandatory|lAlt [,dOptional, lConditional [,cFloatable] [,nFloatable]]
cMandatory|lAlt /* Обязательный параметр (не заключен в квадратные скобки).
dOptional/*Необязательный параметр; заключен в квадратные скобки, закрывающая скобка указана в конце списка параметров. Первая квадратная скобка обозначает начало области необязательных параметров.
lConditional/*Условно обязательный параметр (не заключен в квадратные скобки, но находится в области необязательных параметров). Параметр является обязательным, если указано значение для параметра dOptional.
cFloatable/*плавающий параметр (заключен в квадратные скобки и скобки закрываются после имени этого параметра). Значение аргумента для плавающего параметра может быть опущено в списке аргументов или указано в любом месте в области плавающих параметров. Первый плавающий параметр обозначает начало области плавающих параметров. Эта область всегда расположена в конце списка параметров.
Дополнительное определение параметра o-типа
Параметр o-типа может быть уточнен одним именем допустимого класса объекта, например:
par oForm as form.MayForm | oText as textbox
В данном примере, сначала проверяется класс переданного аргумента и, если передана ссылка на форму указанного в списке параметров класса, то параметру <oForm> будет присвоена эта ссылка. В противном случае, параметру oForm присвоится пустое значение nothing.
Список однотипных параметров
Для сокращенного определения однотипных параметров в списке параметров можно использовать символы повторения параметров (...), например:
par cText[,...]
par uValue[,cText,nVal[,...]
В списке параметров определена только одна переменная для первого параметра. Получить значение остальных переданных в процедуру аргументов можно с помощью метода подложки процедуры :ArgValue(iArgNo) по номеру позиции параметра. Несмотря на то, что имена параметров не указаны, автоматически проверяется соответствие числа и типа параметров числу и типу переданных аргументов. Образцом для контроля типов данных является тип данных предыдущего перед символами повторения параметра (cText) или типами данных списка условных параметров (cText,nVal).
Возвращаемые параметры
Параметры могут использоваться не только для передачи данных из вызывающей процедуры в вызываемую, но и для возврата в вызывающую процедуру измененных в вызываемой процедуре значений параметров. Для указания на то, что измененное значение назначенной параметру переменной должно вернуться в вызывающую процедуру, нужно в списке параметров поставить символ "@" перед именем этой переменной, например:
par nVal|@cVal,dDate
Обратите внимание, что символ возврата значения относится к конкретной переменной, а не ко всем назначенным параметру переменным. В нашем примере, процедура вернет измененное значение переменной cVal в вызывающую процедуру только в том случае, если вызывающая процедура передала значение с-типа в качестве первого аргумента. Для того чтобы предотвратить изменение значения переменной-аргумента, указанной для возвращаемого параметра, нужно заключить переменную в круглые скобки (сделать из нее выражение).
Средства подложки процедуры для работы с параметрами.
Для полного контроля над параметрами и аргументами процедуры предоставляется следующий набор элементов подложки процедуры:
:ArgCount /* Возвращает количество переданных процедуре аргументов.
:ArgNo(cParName) /* Возвращает номер аргумента, назначенный указанному параметру. Возвращает значение ноль, если для указанного параметра нет соответствующего ему аргумента.
:ArgType(iArgNo) /* Возвращает тип переданного аргумента. Если iArgNo больше :ArgCount или максимально допустимого количества аргументов, то возвращаемое значение равно u(unknown).
:ArgValue(iArgNo) /* Возвращает значение переданного процедуре аргумента до его присвоения параметру.
Эти элементы подложки можно использовать только внутри выполняемой процедуры, и к ним обращаются без указания имени выполняемой процедуры, например:
iArgCount = :ArgCount
uValue = :ArgValue(1)
Автоматическое преобразование типов данных.
Передача значения параметра в вызываемую процедуру аналогична операции присвоения параметру значения переданного аргумента. Возврат значения параметра - это присвоение текущего значения параметра соответствующему ему аргументу. Таким образом, при передаче и возврате значения параметров автоматически выполняются стандартные действия по преобразованию типов данных. При возврате значения параметра тип данных переданного аргумента не изменяется. Автоматическое преобразование типов не происходит для альтернативных и плавающих параметров, поскольку именно по типу данных переданного аргумента определяется соответствующий этому аргументу параметр.
Блок команд tip ... endtip.
Формат:
tip ParName [= <Default Value>]
[* comment]
[...]
[* comment]
[endtip]
Блок команд предназначен для описания отдельных параметров процедуры. Это описание может включить любые комментарии, которые будут использованы средствами IntelliSense.
Всем необязательным параметрам, которым не назначены аргументы, присваиваются пустые значения в соответствии с типом данных этих параметров. Однако в команде tip можно определить для необязательных параметров иные значения по умолчанию.
Блок команд with ... endwith.
Формат:
with oRefer
.MembName
endwith
Команда with определяет пространство имен элементов указанного в ней объекта. Внутри конструкции with ... endwith можно ссылаться на любой элемент этого объект (свойство, процедуру или ссылку на вложенный объект), указав только одну точку перед именем элемента без указания пути до данного элемента. Команды with могут быть вложенными.
Команда присваивания значения (=)
Формат:
[<Variable>|<Property>] = <Expression>
Команда присваивает значение указанного выражения переменной или свойству. Обратите внимание, что в командах присваивания можно не указывать свойство и переменную. В этом случае лишь выполняется указанное выражение без выполнения операции присваивания. Более того, если в начале строки отсутствует какая-нибудь команда, то командой по умолчанию считается команда присваивания без указания переменной или свойства. Однако, желательно (для ясности), все-таки поставить в начале строки символ равенства. При выполнении операции присваивания осуществляется автоматическое преобразование типов данных в случае, если тип данных выражения не совпадает с типом данных свойства или переменной, указанных в команде.
Команда слияния (\)
\[text...]•cExpr•[text...]...
Команды слияния предназначены для формирования строк потока текста (text stream), полученных в результате конкатенации (слияния) фрагментов текста и значений символьных выражений, определенных внутри пары символов-разделителей "•".
Управляющие структуры.
Если программный код записан в виде простой последовательности команд, то они будут выполняться последовательно от начала до конца. С помощью непрерывной последовательности команд нельзя реализовать условное выполнение команд. Для этих целей необходимы средства управления последовательностью выполнения команд. К таковым относятся управляющие структуры.
Управляющие структуры – это набор команд для управления порядком выполнения команд. Они представлена управляющими командами, которые сами по себе не приводят к каким-либо результатам, а лишь определяют структуру программного кода в виде блоков команд, включенных в управляющие структуры. Управляющие структуры могут быть вложенными, то есть блок команд структуры может содержать другую управляющую структуру (того же или другого типа). Максимальный уровень вложенности структур не ограничен.
Структура if.
Управляющая структура if ... [else] ... endif обеспечивает простое ветвление кода в зависимости от заданного условия.
Логика работы структуры:
if lExpr
* блок команд if выполняется если условие lExpr выполнено
* переход на первую команду после endif
[else
* блок команд else (необязательный) выполняется если условие lExpr не выполнено
]
endif
command
В качестве условия (lExpr) может быть использовано любое логическое выражение. Если условие выполнено (true) , то выполняется блок команд if, в противном случае выполняется блок команд else (если он имеется). В качестве команды любого блока может использоваться управляющая структура if (вложенное условие) или любая другая управляющая структура, описанная ниже.
Структура choose.
Структура choose case … [otherwise …] endcase обеспечивает сложное ветвление кода в зависимости от произвольного числа условий.
Логика работы структуры:
choose
case lExpr1
* блок команд case выполняется если условие lExpr1 выполнено
* переход на первую команду после endcase
case lExpr2
* блок команд case выполняется если условие lExpr2 выполнено
* переход на первую команду после endcase
[otherwise
* блок команд otherwise выполняется если ни одно из предыдущих условий не выполнено
]
endcase
* первая команда после endcase
command
Структура for ... endfor.
Формат:
for nCtrlVar = nInitExpr to nToExpr [step nStepExpr]
* тело цикла - блок команд for
command
[exit]
[loop]
command
...
endfor
command
Структура for ... endfor предназначена для организации циклического выполнения блока команд, расположенных в теле цикла (между командой for и endfor) под контролем управляющей переменной nCtrlVar.
В начале выполнения цикла переменной nCtrlVar присваивается начальное значение nInitExpr (выражения nInitExpr и nToExpr должны быть положительными целыми или дробными числами).
После каждого выполнения тела цикла, к значению переменной nCtrlVar прибавляется значение nStepExpr или 1(если пункт step опущен). Значение выражения nStepExpr может быть как положительным, так и отрицательным целым или дробным числом.
Перед первым выполнением тела цикла, а так же после приращения значения переменной nCtrlVar, проверяется условие завершения цикла. Цикл завершается, когда значение переменной nCtrlVar становится больше значения nToExpr (nStepExpr>0) или меньше значения nToExpr (nStepExpr<0). Контроль на завершение цикла выполняется перед первой и последующими итерациями! При завершении цикла управление передается команде, следующей за командой endfor.
Цикл for можно завершить досрочно, выполнив внутри тела цикла команду exit. Команда loop позволяет перейти на следующую итерацию внутри цикла, пропустив все нижележащие команды тела цикла.
Значение переменной nCtrlVar можно изменять программно внутри тела цикла, для того чтобы пропустить или повторить определенное количество итераций цикла. Значения nToExpr и nStepExpr вычисляются и запоминаются в начале первой итерации цикла, и не могут быть изменены внутри цикла!
Структура do while | until ... enddo.
Формат:
do while | until lExpr
* тело цикла - блок команд do
command
[exit]
[loop]
command
...
endfor
command
Структура do ... enddo предназначена для организации циклического выполнения блока команд, расположенных в теле цикла (между командой do и enddo) пока (while) или до тих пор (until), пока выполняется логическое условие, заданное выражением lExpr. Использование параметра until гарантирует выполнение цикла хотя бы один раз, поскольку условие выполнения цикла проверяется в конце тела цикла, а не в его начале, как это предусмотрено параметром while.Цикл do можно завершить досрочно, выполнив внутри тела цикла команду exit. Команда loop позволяет перейти на следующую итерацию внутри цикла, пропустив все нижележащие команды тела цикла.
Структура try ... catch ... endtry.
Структура try ... catch ... endtry обеспечивает управление ошибками и исключительными ситуациями, возникающими при выполнении блока программного кода.
Формат:
try
* блок команд try, где может возникнуть ошибка или исключительная ситуация.
command
...
catch
* блок команд catch, который получает управление только в случае возникновения ошибки в блоке try.
Command
...
endtry
Структура try ... catch ... endtry может быть вложенной, т.е. в блок try или catch могут быть включены структуры try ... catch ... endtry
Команда exit
Команда exit предназначена для выхода из цикла
Команда loop
Команда loop позволяет перейти на следующую итерацию внутри цикла, пропустив все нижележащие команды тела цикла.
Команда break.
Формат:
break [lExpr]
Если не указано выражение lExpr (безусловное прерывание) или если lExpr = true, то команда break прерывает выполнение текущей процедуры и вызывает отладчик для пошагового выполнения процедуры. В противном случае команда break игнорируется.
Команда nodefault.
Команда nodefault используется для того, чтобы отменить стандартные действия события при выполнении базовых процедур. Например, игнорировать введенный с клавиатуры символ в событии .KeyPress().
Команда nodefault игнорируется в случае выполнения методов пользователя или в случае, если базовое событие не предусматривает каких либо стандартных действий.
Команда cancel.
Команда cancel вызывает немедленное завершение выполнения текущей процедуры и возврат значения по умолчанию, определенного для этой процедуры. Кроме этого, устанавливается свойство-переключатель подложки процедуры :Cancel, т.е. процедура помечается как снятая. При последующих вызовах процедуры текст процедуры не выполняется, а сразу возвращается значение по умолчанию. Указанный выше переключатель можно установить или сбросить программным путем, например:
oRefer.ProcName:Cancel = false
Обратите внимание на то, что снятие процедуры только подавляет выполнение текста процедуры, но не приводит к завершению сеанса работы Приложения, как это принято в других языках. Такой подход, наряду с другими средствами, обеспечивает высокую "живучесть" Приложения.
Команда quit
Команда quit вызывает принудительное завершение сеанса работы Приложения. Действие этой команды равносильно выбору пункта System.Quit из Основного меню Приложения.
Команда return.
Формат:
return [uExpr]
Команда return завершает выполнение процедуры и возвращает указанное в команде значение.
Если тип данных указанного выражения не соответствует типу данных процедуры, то выдается сообщение об ошибке и возвращается значение по умолчанию.
Если не указано возвращаемое значение или если выполнена последняя команда процедуры, а команда return не встретилась, то возвращается значение по умолчанию.
Если значение по умолчанию для данной процедуры не определено, то возвращается пустое значение в соответствии с типом данных процедуры.
Команда return может быть размещена в любом блоке управляющей структуры.
Строка комментариев *text
Команда * указывает на то, что весть текст строки является комментарием и пропускается компилятором. Символ продолжения строки (точка с запятой в конце строки) игнорируется, т.е. строка комментариев не может иметь строк продолжения.
Внутри-строчный комментарий /*text*/
Данный вид комментария можно использовать в любом месте исходного текста процедуры, где допускается использование пробела. Текст комментария начинается после пары символов /* и заканчивается перед парой символов /. Символы закрытия комментария (/) могут быть опущены. В этом случае, весть текст до конца строки рассматривается как текст комментария, за исключением символа продолжения строки, если, конечно, он присутствует.
Кроме описанных выше типов комментариев, любой текст, расположенный после кода команды, не имеющей параметров, рассматривается как текст комментариев, например:
endif Конец какого-то условия
Системные функции.
В этом разделе представлен список наиболее важных системных функций, сгруппированный по типу основного параметра функции.
Список используемых пространств имен:
m. Операции с числовыми данными
c. Операции со строками
h. Операции над хронологическими данными
a. Операции над массивами
b. Операции с битовым представлением строк и чисел
u. Операции с variant-данными
o. Операции с объектами (создание и обращение)
Операции с числовыми данными (m.)
abs(nExpr) - Возвращает абсолютное значение заданного числового выражения.
sign(nExpr) Возвращает числовое значение: 1, –1, или 0, для соответствующих параметров функции: положительных, отрицательных, или равных нулю.
asin(nExpr) - Возвращает в радианах арксинус числового выражения.
acos(nExpr) - Возвращает арккосинус (ArcCos) для заданного числового выражения.
atan(nExpr) - Возвращает в радианах арктангенс числового выражения.
atn2(iXCoord,iYCoord) - Возвращает арктангенс заданного значения в любом из четырех квадрантов.
sin(nExpr) Возвращает значение Синуса заданного угла. sqrt(nExpr) Возвращает Квадратный Корень от заданного числового выражения tan(nExpr) Это тригонометрическая функция, возвращающая Тангенс заданного угла
cos(nExpr) - Возвращает значение косинуса для числового выражения.
tan(nExpr); Это тригонометрическая функция, возвращающая Тангенс заданного угла.
log(nExpr) Возвращает значение Натурального Логарифма (основание Е) для заданного числового выражения.
log10(nExpr) Возвращает десятичный логарифм (по основанию 10) указанного числового выражения.
exp(nExpr) - Возвращает значение экспоненты: e(x) для заданного числового выражения.
degree(nRadian) - Преобразует Радианы в соответствующие Градусы.
radian(nDegree) Преобразует Градусы (единицы измерения углов) в соответствующие Радианы.
PI() - Возвращает числовое выражение, равное числу Пи.
ceiling(nExpr) - Возвращает следующее большее целое число, которое больше чем или равно указанному числовому выражению.
floor(nExpr) - Возвращает ближайшее целое число, которое меньше или равно заданному числовому выражению.
integer(nExpr) Возвращает целую часть числа. Дробная часть числа отбрасывается без округления.
FV(nPayment,nInterestRate,iPeriods) - Возвращает будущую величину Финансовой Инвестиции (Financial Investment).
payment(nPrincipal,nInterestRate,nPayments) - Возвращает сумму периодического платежа по ссуде с фиксированным процентом.
PV(nPayment,nInterestRate,nTotalPayments) - Вычисляет существующее значение инвестиций, основанных на ряде равных периодических платежей при постоянной процентной ставке.
mod(nDividend,nDivisor); Выполняет деление одного числового выражения на другое числовое выражение, и возвращает Остаток от Деления (деление по модулю).
rand(nSeedValue) Возвращает псевдослучайное число в диапазоне от 0 до 1.
RGB(iRed,iGreen,iBlue) Возвращает одно значение Цветовой гаммы на основании заданных компонент: Красного, Зеленого и Синего: iRGB = iRed + 255*iGreen + 255*255*iBlue
round(nExpr, iDecPlaces); Возвращает числовое выражение, округленное до указанного количества десятичных знаков.
val(cExpr) Возвращает числовое значение из символьного выражения, состоящего из цифр.
Операции со строками (c.)
allTrim(cExpr[,iFlags[,cParseChar [,...]]]); Удаляет все ведущие и конечные пробелы или символы синтаксического анализа (cParseChar) из указанного символьного выражения (cExpr).
tip iFlags default 0
0 - Trimming is case-sensitive
1 - Trimming is case-insensitive
endtip
ASC(cExpr); Возвращает значение ANSI для крайнего левого символа в символьном выражении.
at(cSearchExpr,cExpr[,iOccur]) Возвращает целое число, указывающее позицию первого символа для символьного выражения в пределах другого символьного выражения, начинающегося с крайнего левого символа. iOccur указывает, какое вхождение выражения cSearchExpr (начиная слева и продвигаясь вправо) функция at() ищет в cExpr. По умолчанию, at() ищет первое вхождение cSearchExpr (iOccur = 1). Если iOccur равно 2, at() ищет второе вхождение, и так далее.
atc(cSearchExpr,cExpr[,iOccur]); Возвращает начальную позицию первого вхождения символьного выражения в другое символьное выражение, независимо от регистра этих двух выражений.
chr(iASC); Возвращает символ, ассоциированный с определенным числовым ANSI кодом.
left(cExpr,iExpr) - Возвращает из символьной строки заданное количество символов, начиная с левого края строки.
leftTrim(cExpr[,iFlags[,cParseChar [,...]]])); Удаляет все ведущие пробелы или символы синтаксического анализа (cParseChar) из указанного символьного выражения (cExpr)
len(cExpr); Определяет количество символов в символьном выражении, указывая длину заданного символьного выражения.
lower(cExpr); Возвращает заданное символьное выражение в нижнем регистре (малыми буквами).
occurs(cSearchExpr,cExpr); Возвращает количество вхождений строки cExpr в строку cSearchExpr.
padCenter(cExpr, iResultSize [,cPadChar]); Возвращает строку из выражения, дополненную пробелами или указанными символами с обеих сторон.
padLeft(cExpr, iResultSize [,cPadChar]); Возвращает строку из выражения, дополненную пробелами или указанными символами до указанной длины слева.
padRight(cExpr, iResultSize [,cPadChar]); Возвращает строку из выражения, дополненную пробелами или указанными символами до указанной длины справа.
rat(cSearchExpr,cExpr[,iOccur]); Возвращает числовую позицию последнего вхождения символьного выражения cSearchExpr в другое символьное выражение cExpr. iOccur указывает, какое вхождение выражения cSearchExpr (справа на лево) функция rat() ищет в cExpr. По умолчанию, rat() ищет последнее вхождение cSearchExpr (iOccur = 1). Если iOccur равно 2, rat() ищет предпоследнее вхождение, и так далее.
right(cExpr,iExpr); Возвращает из символьной строки заданное количество символов, начиная с правого края.
rightTrim(cExpr[,iFlags [,cParseChar [,...]]]); Удаляет все конечные пробелы или символы синтаксического анализа (cParseChar) из указанного символьного выражения (cExpr)
space(iSpaces); Возвращает символьную строку, составленную из заданного числа пробелов.
str(nExpr[,iLength [,iDecimalPlaces)]]); Возвращает символьный эквивалент числового выражения.
encode(cExpr[,cFormat]) - Перекодирует содержимое строки cExpr в формат, указанный параметром cFormat
tip cFormat = b
b - base64Binary
h - hexBinary
s - bitString (0|1 ...)
u - ascii -> unicode
endtip
decode(cExpr[,cFormat]) - Преобразует содержимое строки cExpr из формата, указанного параметром cFormat, в исходный декодированный формат данных.
tip cFormat = b
b - base64Binary
h - hexBinary
s - bitString (0|1 ...)
u - unicode -> ascii
endtip
stuff(cExpr, iPos, iChars, cText) - Возвращает символьную строку, в которой указанное количество символов (iChars) в заданной позиции (iPos) заменяется указанным текстом (cText).
substr(cExpr, iPos [,iChars]) - Возвращает подстроку из заданного символьного выражения (cExpr), начиная с указанной позиции в этом символьном выражении (iPos) и содержащую указанное количество символов (iChars).
upper(cExpr) - Возвращает заданное символьное выражение, преобразованное в Верхний регистр (заглавными буквами).
Операции над хронологическими данными (h.)
date([iDay,iMonth,iYear]) - Возвращает текущую системную дату, если параметры отсутствуют или создает константу d-типа по заданным параметрам
day(dExpr) - Возвращает номер дня месяца для заданного выражения.
dayName(dExpr[,lAbbr]) - Возвращает наименование дня недели.
dayOfWeek(dExpr[,iFirstDayOfWeek]) - Возвращает номер дня недели для заданного выражения.
tip iFirstDayOfWeek
0 - Default setting
1 - Sunday
2 - Monday
3 - Tuesday
4 - Wednesday
5 - Thursday
6 - Friday
7 - Saturday
endtip
days(dFromDate,dToDate[,cDayType]) - Рассчитывает количество дней между начальной и конечной датой.
tip cDayType default C
C - Calendar days
W - Work days
F - Days off
H - Holy Days
B - Banking days (30-days month)
endtip
dayType(dExpr) - Возвращает вид дня для заданного выражения.
tip
W - Work day
F - Day off
H - Holy Day
U - Unknown
endtip
goDate(dExpr,iStep[,cPart]) - Изменяет (увеличивает или уменьшает) значение даты (dExpr) на указанную величину (+/-iStep) дней, месяцев или лет в зависимости от значения параметра cPart.
tip cPart default D
D - Days
M - Months
Y - Years
endtip
goTime(tExpr, nStep[,cPart]) - Изменяет (увеличивает или уменьшает) значение времени (tExpr) на указанную величину (+/-nStep) секунд, минут или часов в зависимости от значения параметра cPart.
tip cPart default S
S - Seconds
M - Minutes
H - Hours
endtip
hour(tExpr) - Возвращает количество часов для указанного выражения.
julianDay(dExpr) - Преобразует дату в Юлианский номер дня.
longDate(dExpr) - Преобразует указанную дату в формат день-месяц-год (например, 31 May 2017).
minute(tExpr) - Возвращает количество минут для указанного выражения.
month(dExpr) - Возвращает номер месяца для указанного выражения.
monthName(dExpr[,lAbbr]) - Возвращает наименование месяца для указанного выражения.
quarter(dExpr[,iMonth]) - Возвращает номер квартала для указанного выражения.
sec(tExpr) - Возвращает количество секунд для указанного выражения.
seconds() - Возвращает время в секундах, которое прошло с полуночи (с начала суток) 0-86400.
stamp([dExpr,tExpr]) - Возвращает значение штампа, формированное для указанной даты и времени. Если параметры не указаны, то используется системное значение даты и времени.
time([iHour,iMinute,nSecond]) - Возвращает текущее системное время, если параметры отсутствуют или создает константу t-типа по заданным параметрам.
userCode([iUserNo]) - Возвращает двухсимвольный код работающего пользователя или преобразует указанный номер пользователя в двухсимвольный код.
userNo([cUserCode]) - Возвращает номер работающего пользователя или преобразует указанный двухсимвольный код пользователя в номер пользователя.
week(dExpr[,iFirstWeekOfYear[,iFirstDayOfWeek]]) - Возвращает номер недели для указанного выражения.
tip iFirstWeekOfYear
0 - Default setting
1 - Contains January 1st
2 - First 4-day week
3 - First full week
endtip
tip iFirstDayOfWeek
0 - Default setting
1 - Sunday
2 - Monday
3 - Tuesday
4 - Wednesday
5 - Thursday
6 - Friday
7 - Saturday
endtip
year(dExpr) - Возвращает номер года для указанного выражения.
Операции над массивами (a.)
Массив представляет собой именованную совокупность пронумерованных переменных. Переменные массива (элементы массива) имеют тип данных variant, т.е. могут содержать данные любого типа (в том числе и массивы). Каждому элементу присваивается порядковый номер (индекс) начиная с единицы (в большинстве других языков программирования нумерация начинается с нуля). Обращение к элементу массива (для записи или чтения) происходит по его номеру. Массив в языке ULCA представлен в виде таблицы (строк и колонок). Одномерный массив рассматривается как таблица с одной колонкой. Количество строк и колонок массива запоминаются в дескрипторе массива, который используется для интерпретации обращения к элементам массива.
Доступ к элементам массива возможен двумя способами:
по последовательному номеру элемента (iItemNo)
по номеру строки и колонки (iRow,iCol)
Таким образом, двумерный массив можно, в зависимости от конкретных целей использования, рассматривать как одномерный или двумерный массив. Массивы, как и другие переменные, могут быть использованы в качестве глобальных переменных или внешних параметров. Пример объявления массивов:
par aParArray,e.aParArray
var aVarArray(1,2),g.aGlbArray,e.aArray(0,2)
Признаком массива-переменной является первая буква в имени переменной или параметра, указывающая на тип данных (a - array).Перед именем переменной может быть указан префикс пространства имен, определяющий область видимости переменной или параметра:
e. - внешний параметр (можно определять в командах par и var)
g. - глобальная переменная (можно определить только в команде var)
В команде var можно дополнительно определить размерность создаваемого массива, указав в КРУГЛЫХ скобках размерность в виде (iRowCount[iColCount]). Если размерность массива не указана, то подразумевается пустой одномерный массив - (0) - это то же самое, что и (0,1). Если массив не пустой (есть элементы), то всем элементам созданного массива присваивается пустое логическое значение (false). Для внешних и глобальных массивов можно также определить размерность, но если эти массивы уже существуют, то не создается новых массивов и не меняется их размерность, т.е. определение полностью игнорируется. Если же массив с указанным именем не существует, то создается новый массив в указанной областью видимости указанной размерности и инициируется его элементы пустыми значениями. Подробнее о глобальных переменных и внешних параметрах можно посмотреть в соответствующем разделе.
Стандартное обращение к элементам массива:
uValue = aArray(iRow[,iCol]) /* получить значение элемента массива
aArray(iRow[,iCol]]) = uValue /* изменить значение элемента массива
Обращение к элементам массива с использованием функций:
aGet(aArray,iRowNo[,iColNo]) /* получить значение элемента массива
aSet(aArray,uExpr,iRowNo[,iColNo]) /* изменить значение элемента массива
aCopy(aFromArray, aToArray,[iFromItem[,iCount[,iToItem]]]) Копировать iCount ЭЛЕМЕНТОВ массива aFromArray, начиная с элемента iFromItem массива aToArray в позицию iToItem массива aToArray.
aItemNo(@aArray,iRowNo,iColNo) возвращает позицию элемента по заданной строке и колонке.
aDim(aArray,iRowCount[,iColCount]) Изменяет размерность массива.
aLen(@aArray[,iFlags]) Возвращает количество элементов, строк или колонок массива aArray в зависимости от значения параметра iFlag
tip iFlag
0 - возвращает количество элементов массива
1 - возвращает количество строк
2 - возвращает количество колонок
endtip
aLines(aArray, cExpr, iFlags, [cParseChar[,...]]) Копирует каждую строку символьного выражения (cExpr) в соответствующий элемент массива и возвращает количество строк созданного массива. Параметр cParseChar задает одну или более символьных строк, которые будут определять конец строки в cExpr (символы синтаксического анализа). Когда cParseChar определен, функция будет искать его вхождение в символьной строке cExpr и, если это вхождение будет найдено, оно и будет являться концом строки, которая копируется в первый элемент массива. Следующая строка продолжится с символа, стоящего после cParseChar. По умолчанию символами разделения строк считаются символы перевода строк и возврата каретки.
tip iFlags additive
1 - Удаляются ведущие и завершающие пробелы из символьной строки
2 - В массив добавляется последний "пустой" элемент.
4 - В массив не включаются пустые элементы.
8 - Определяет синтаксический анализ без учета регистра.
16 - В элемент массива строка будет помещаться вместе с символами синтаксического анализа
endtip
aSubscript(aArray, iItemNo,iSubscript) Возвращает номер строки или номер колонки элемента массива no указанному значению номера элемента.
tip iSubscript
1 - возвращает номер строки
2 - возвращает номер колонки
endtip
aInsRow(@aArray[,iRowNo[,iCount]])
Вставляет в указанную позицию одну или несколько новых строк. Параметр iRowNo указывает номер строки, ПЕРЕД которой будет вставлено указанное параметром iCount количество строк, содержащих пустые значения элементов (false). Если параметр iRowNo не указан или его значение равно 0, то новые строки будут добавлены ПОСЛЕ последней строки массива. Параметр iCount должен быть больше или равен 1. Если этот параметр не указан, то добавляется одна строка. В результате выполнения операции добавления новых строк, размерность массива автоматически увеличивается на указанное количество строк. Если массив не пустой и строки добавляются не после последней строки массива, то значения всех элементов строк, начиная с колонки, указанной параметром iRowNo, построчно перемещаются вниз на количество добавленных строк.
aDelRow(aArray, iRowNo[,iCount])
Удалить одну или несколько строк массива aArray. Параметр iRowNo указывает номер первой или единственной удаляемой строки массива. Если значение этого параметра не указано, то удаляется первая строка. Параметр iCount указывает количество удаляемых смежных строк. Параметр iCount должен быть больше или равен 1. Если этот параметр не указан, то удаляется одна строка. Если массив не пустой и удаляются не последние строки массива, то значения всех элементов строк, расположенных ниже удаленных строк построчно перемещаются вверх на количество удаленных строк. В результате выполнения операции удаления строк, размерность массива автоматически уменьшается на количество фактически удаленных строк. Можно удалить единственную строку массива, поскольку массив может быть пустым (без строк)
aCopyRow(aFromArray, aToArray[,iFromRow[,iCount[,iToRow]]])
Копирует содержимое одной или нескольких строк из массива aFromArray в массив aToArray. Параметры iFromRow и iCount указывают соответственно номер первой копируемой строки и количество копируемый строк массива aFromArray. Если не указано значение параметра iFromRow, то по умолчанию подразумевается первая строка массива aFromArray. Если не указан параметр iCount, то копируются все строки массива, начиная с указанной в параметре iFromRow строки до последней строки массива aFromArray. Параметр iToRow указывает номер первой строки массива aToArray, начиная с которой происходит замена строк массива aToArray указанным количеством строк массива aFromArray. Если параметр iToRow не указан, то подразумевается первая строка массива aToArray. Массивы aFromArray и aToArray должны иметь одинаковое количество колонок
aSortRows(@aArray,[iCol[,iBegRow[,iEndRow[,iFlags]]]])
Сортировка строк массива по указанной колонке, начиная со строки iBegRow и кончая строкой iEndRow.
tip nFlags additive
1 - Case insensitive
2 - Sort descending
endtip
aInsCol(@aArray[,iColNo[,iCount]])
Вставить в указанную позицию одну или несколько новых колонок. Параметр iColNo указывает номер колонки, ПЕРЕД которой будет вставлено указанное параметром iCount количество пустых колонок, содержащих пустые значения элементов (false). Если параметр iColNo не указан или его значение равно 0, то новые колонки будут добавлены ПОСЛЕ последней колонки массива. Параметр iCount должен быть больше или равен 1. Если этот параметр не указан, то добавляется одна колонка. В результате выполнения операции добавления новых колонок размерность массива автоматически увеличивается на указанное количество колонок. Если массив не пустой и колонки добавляются не после последней колонки массива, то значения всех элементов колонок, начиная с колонки, указанной параметром iColNo по колонкам перемещаются вправо на количество добавленных колонок. Используются одинаковые (симметричные) алгоритмы как для добавления и удаления колонок, так и для добавления и удаления строк.
aDelCol(@aArray[,iColNo[,iCount]])
Удаляет одну или несколько колонок массива. Параметр iColNo указывает номер первой или единственной удаляемой колонки. Если значение этого параметра не указано, то удаляется первая колонка. Параметр iCount указывает количество удаляемых смежных колонок. Параметр iCount должен быть больше или равен 1. Если этот параметр не указан, то удаляется одна колонка. Нельзя удалить единственную колонку. Если массив не пустой и удаляются не последние колонки массива, то значения всех элементов колонок, расположенных справа от удаленных колонок по колонкам перемещаются влево на количество удаленных колонок. В результате выполнения операции удаления колонок размерность массива автоматически уменьшается на количество удаленных колонок.
aCopyCol(aFromArray, aToArray[,iFromCol[,iCount[,iToCol]]])
Копирует построчно содержимое элементов одной ли нескольких колонок из массива aFromArray в массив aToArray. Параметры iFromCol и iCount указывают соответственно номер первой копируемой колонки и количество копируемый колонок из массива aFromArray. Если не указано значение параметра iFromCol, то по умолчанию подразумевается первая колонка массива aFromArray. Если не указан параметр iCount, то копируются все колонки массива, начиная с указанной в параметре iFromCol колонки до последней колонки массива aFromArray. Параметр iToCol указывает номер колонки массива aToArray, НАЧИНАЯ с которой содержимое элементов копируемых колонок массива aFromArray затирает значения элементов колонок массива aToArray. Массивы aFromArray и aToArray должны иметь одинаковое количество строк
aScanCol(@aArray, uValue[,iCol[,iBegRow[,iEndRow[,iFlags]]]])
Поиск номера строки в указанной колонке массива по значению элемента в пределах указанных строк: от iBegRow до iEndRow.
tip nFlags additive
1 - Case insensitive
2 - Exactness
endtip
Операции с битовым представлением строк и чисел (b.)
Физическим представлением целого числа в оперативной памяти является строка длиной 4 байта, которую можно представить в виде строки, состоящей из 32 битов. Каждому биту соответствует своя позиция (от 0 до 31). Нумерация производится слева на право и начинается не с единицы, а с нуля. Представление целого числа в двоичном виде часто используется для определения списка и комбинаций допустимых целочисленных значений перечисляемых типов данных (см. tip additive ... endtip) в виде суммы чисел, каждое из которых является какой-то степенью двойки (от 0 до 31).
Операции над битовым представлением целых чисел
Для клиентского приложения интерес представляют только следующие функции:
binSet(iExpr, iBitNumber) - Устанавливает в 1 значение указанного бита двоичного представления целочисленного выражения.
binClear(iExpr, iBitNumber) - Сбрасывает в ноль указанный бит двоичного представления целочисленного выражения.
binTest(iExpr, iBitNumber) - Возвращается true, если значение указанного бита двоичного представления целочисленного выражения равно 1. В противном случае, возвращается значение false.
Операции над битовым представлением строк
В языке ULCA нет отдельного базового типа данных binary. Строковые данные (тип данных char) не подразделяется на символьные и двоичные данные. Как рассматривать строку символов зависит от контекста и целей использования строковых значений. Тип данных binary является производным от базового типа данных char и используется только в свойствах-атрибутах, предназначенных для определения полей записи таблицы и/или атрибутов XML-документа. Для поля записи таблицы использование типа данных binary означает всего лишь запрет на автоматическое преобразование кодовой страницы данных при чтении/записи значений данного поля таблицы. Для атрибута XML-документа выбор типа данных binary означает, что значение этого атрибута будет представлено в XML-документе в шестнадцатеричном формате.
bitAnd(сExpr, сExpr1[,...]) - Выполняет побитовую операцию И (AND) над двоичным представлением двух или более символьных выражений.
bitClear(cExpr[,iStartBit[,iBitCount]]) - В двоичном представлении символьного выражения (cExpr) сбрасывается в 0 указанное количество битов (iBitCount), начиная с указанной позиции (iStartBit). Если не указана начальная позиция, то сбрасываются все биты двоичного представления строки.
bitNot(cExpr[,iStartBit[,iBitCount]]) - В двоичном представлении символьного выражения (cExpr) выполняет побитовую операцию НЕ (NOT) над указанным количеством битов (iBitCount), начиная с указанной позиции (iStartBit). Если не указана начальная позиция, то операция выполняется над всеми битами двоичного представления строки.
bitOr(сExpr, сExpr1[,...]) - Выполняет побитовую операцию ИЛИ (OR) для двоичного представления двух или нескольких символьных выражений.
bitSet(cExpr[,iStartBit[,iBitCount]]) - В двоичном представлении символьного выражения (cExpr) устанавливается в 1 указанное количество битов (iBitCount), начиная с указанной позиции (iStartBit). Если не указана начальная позиция, то сбрасываются все биты двоичного представления строки.
bitTest(cExpr, iBitNumber) - Возвращается true, если значение указанного бита двоичного представления символьного выражения равно 1. В противном случае, возвращается значение false.
bitXOr(сExpr, сExpr1[,...]) - Выполняет побитовую операцию ИЛИ (exclusive OR ) над двоичным представлением двух или более символьных выражений.
Операции с variant-данными (u.)
between(uTestValue,uLowValue,uHighValue) - Определяет, находится ли заданное некоторое выражение между значениями двух заданных выражений того же типа данных. Возвращается значение = true, если заданный первым аргумент функции равен или больше нижней границы (второй параметр) заданного диапазона и не больше верхнего предела диапазона, заданного третьим аргументом. В противном случае, возвращается значение = false.
convert(uExpr,cDataType) - Преобразует значение выражения uExpr в один из указанных параметром cDataType тип данных.
dataType(uExpr) - Возвращает тип данных указанного выражения uExpr.
emptyValue(cDataType) - Возвращает пустое значение указанного типа данных.
evaluate(cExprText) - Вычисляет символьное выражение и возвращает результат.
icase(lCond1,uResult1[,lCond2,uResult2[, ...]]) - Вычисляет некоторый результат в зависимости от нескольких заданных условий. Возвращает первое значение заданного параметра uResult, если условие lCond = true.
iif(lExpr ,uTrueExpr ,uFalseExpr)) - Возвращает одно из двух заданных значений (uTrueExpr или uFalseExpr) в зависимости от величины логического выражения lExpr.
inList(uExpr,uExpr1[,...]) - Определяет, совпадает ли выражение uExpr с каким-либо другим выражением из заданной группы выражений.
isEmpty(uExpr) - Определяет, является ли выражение пустым.
max(uExpr,uExpr1[,...]) - Обрабатывает заданные выражения и возвращает одно из них, которое имеет Максимальное значение. Все выражения должны быть одного и того же типа данных.
min(uExpr,uExpr1[,...]) - Обрабатывает заданные выражения и возвращает одно из них, которое имеет Минимальное значение. Все выражения должны быть одного и того же типа данных.
Операции с объектами (создание и обращение) (o.)
clone(oObject) - Создает клона указанного объекта данных.
create(cClass[,uInitPar1,...]) - Создает объект данных указанного класса и вызывает процедуру :Init([,uInitPar1,...]).
instance(cClass) - Создает и возвращает ссылку на образец объекта указанного класса.
reference(cObjPath) - Возвращает ссылку на объект с указанным путем.
function(cProcPath) - Возвращает ссылку на указанную процедуру
В языке ULCA имеется набор функций, предназначенный для работы с внешними типами данных. Эти функции будут рассмотрены в статьях, посвященных API функциям, реляционной модели данных и СОМ модели.
