Объявляет целочисленную переменную без знака длиной в один байт.
Формат: величина
| ....... |
Биты: 7 0
Диапазон: от 0 до 255
начальное значение
Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность переменной как массива.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
BYTE
объявляет целочисленную переменную без знака длиной в один байт.
Пример:
Count1 BYTE ! Объявить целочисленную со знаком
Count2 BYTE,OVER(Count1) ! Объявить “поверх” нее еще одну
Count4 BYTE,DIM(5) ! Объявить массив из 5-и однобайтовых целых
Count4 BYTE(5) ! Объявить и присвоить начальное значение
Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность переменной как массива.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор SНОRТ объявляет двухбайтовую целочисленную переменную со знаком в формате слова Intel 8086. Старший бит в этом формате представляет собой знак (0 -положительный, 1 - отрицательный). Отрицательные значения представляются в стандартном дополнительном (до 2-х) коде.
Пример:
Count1 SHORT ! Объявить двухбайтовую целочисленную со знаком
Count2 SHORT,OVER(Count1) ! Объявить “поверх” нее еще одну
Count3 SHORT,DIM(4) ! Объявить массив из 4-х двухбайтовых целых
Count4 SHORT(5) ! Объявить и присвоить начальное значение
Count5 SHORT,EXTERNAL ! Объявить как внешнюю переменную
Count6 SHORT,EXTERNAL,DLL ! Объявить как внешнюю переменную в библиотеке DLL
Count7 SHORT,NAME('SixCount') ! Объявить с внешним именем
Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное внешнее имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор USНОRТ объявляет двухбайтовую целочисленную переменную без знака в формате слова Intel 8086. Знакового разряда нет.
Пример:
Count1 USHORT ! Объявить двухбайтовую целочисленную без знака
Count2 USHORT,OVER(Count1) ! Объявить поверх нее еще одну
Count3 USHORT,DIM(4
) ! Объявить массив из 4-х двухбайтовых целых
Count4 USHORT(5) ! Объявить и присвоить начальное значение
Count5 USHORT,EXTERNAL ! Объявить как внешнюю переменную
Count6 USHORT,EXTERNAL,DLL ! Объявить как внешнюю переменную в библиотеке DLL
Четырехбайтовая целочисленная переменная со знаком.
Формат: ± величина
| |................... |
Биты: 31 30 0
Диапазон: от -2 147 483 648 до 2 147 483 647
начальное значение
Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS..ГЛАВА
Оператор
LONG объявляет четырехбайтовую целочисленную переменную со знаком в формате двойного слова Intel 8086. Старший бит представляет собой знак (0 - положительный, 1 - отрицательный). Отрицательные значения представляются в стандартном дополнительном (до 2-х) коде.
Пример:
Count1 LONG ! Объявить четырехбайтовую целочисленную со знаком
Count2 LONG,OVER(Count1) ! Объявить поверх нее еще одну
Count3 LONG,DIM(4) ! Объявить массив из 4-х длинных целых
Count4 LONG(5) ! Объявить и присвоить начальное значение
Count5 LON
G,EXTERNAL ! Объявить как внешнюю переменную
Count6 LONG,EXTERNAL,DLL ! Объявить как внешнюю переменную в библиотеке DLL
Count7 LONG,NAME('SixCount') ! Объявить с внешним именем
Четырехбайтовая целочисленная переменная без знака.
Формат: величина
|...................|
Биты
: 31 0
Диапазон: от 0 до 4 294 967 295
начальное значение
Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное внешнее имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
ULONG
объявляет четырехбайтовую целочисленную переменную без знака в формате двойного слова Intel 8086. Знакового разряда нет.
Пример:
Count1 ULONG ! Объявить четырехбайтовую целочисленную без знака
Count2 ULONG,OVER(Count1) ! Объявить поверх нее еще одну
Count3 ULONG,DIM(4) ! Объявить массив из 4-х длинных целых без знака
Count4 ULONG(5) ! Объявить и присвоить начальное значение
Count5 ULONG,EXTERNAL ! Объявить как внешнюю переменную
Count6 ULONG,EXTERNAL,DLL ! Объявить как внешнюю переменную в библиотеке DLL
Count7 ULONG,NAME('SixCount') ! Объявить с внешним именем
Целочисленная переменная со знаком, описанная как LONG.
начальное значение Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
SIGNED
объявляет целочисленную переменную, которая трактуется как LONG. Тип данных SIGNED полезен при объявлении вызовов Windows API.
Целочисленная переменная без знака, трактуемая как LONG.
начальное значение Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное внешнее имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указывает на то, что переменная невидима вне методов базового и произведенных CLASS . Действительно только в CLASS.
UNSIGNED
объявляет целочисленную переменную без знака, которая может быть типа LONG. Вообще, это не тип данных, но EQUATE определен в EQUATES.CLW.
Тип данных UNSIGNED наиболее полезен для прототипирования запросов Windows API, использующих параметр LONG (или ULONG) в их тридцатидвухбитной версии.
Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор
SREAL объявляет четырехбайтовую переменную со знаком в формате с плавающей точкой Intel 8087 (одинарной точности).
Пример:
Count1 SREAL ! Объявить переменную с плавающей точкой
! 4 байта со знаком
Count2 SREAL,OVER(Count1) ! Объявить поверх нее еще одну
Count3 SREAL,DIM(4) ! Объявить массив из 4-х переменных
Count4 SREAL(5) ! Объявить и присвоить начальное значение
Count5 SREAL,EXTERNAL ! Объявить как внешнюю переменную
Count6 SREAL,EXTERNAL,DLL ! Объявить как внешнюю переменную в библиотеке DLL
Count7 SREAL,NAME('SixCount') ! Объявить с внешним именем
Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное внешнее имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор
REAL объявляет восьмибайтовую переменную со знаком в формате с плавающей точкой Intel 8087 (двойной точности).
Пример:
Count1 REAL ! Объявить переменную с плавающей точкой 8 байт со знаком
Count2 REAL,OVER(Count1) ! Объявить “поверх” нее еще одну
Count3 REAL,DIM(4) ! Объявить массив из 4-х переменных
Count4 REAL(5) ! Объявить и присвоить начальное значение
Count5 REAL,EXTERNAL ! Объявить как внешнюю переменную
Count6 REAL,EXTERNAL,DLL ! Объявить как внешнюю переменную в библиотеке DLL
Count7 REAL,NAME('SixCount') ! Объявить с внешним именем
Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор
BFLOAT4 объявляет четырехбайтовую переменную со знаком с плавающей точкой в формате Microsoft BASIC (одинарной точности). Этот тип данных обычно используется для совместимости с существующими данными, поскольку перед всеми арифметическими операциями он преобразуется в REAL.
Пример:
Count1 BFLOAT4 ! Объявить переменную с плавающей точкой 4 байта со знаком
Count2 BFLOAT4,OVER(Count1) ! Объявить поверх нее еще одну
Count3 BFLOAT4,DIM(4) ! Объявить массив из 4-х переменных
Count4 BFLOAT4(5) ! Объявить и присвоить начальное значение
Count5 BFLOAT4,EXTERNAL ! Объявить как внешнюю переменную
Count6 BFLOAT4,EXTERNAL,DLL ! Объявить как внешнюю переменную в библиотеке DLL
Count7 BFLOAT4,NAME('SixCount') ! Объявить с внешним именем
Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
BFLOAT8
объявляет восьмибайтовую переменную со знаком с плавающей точкой в формате Microsoft BASIC (двойной точности). Этот тип данных обычно используется для совместимости с существующими данными, поскольку перед всеми арифметическими операциями он преобразуется в REAL.
Пример:
Count1 BFLOAT8 !
Объявить переменную с плавающей точкой 8 байт со знаком
Count2 BFLO
AT8,OVER(Count1) ! Объявить поверх нее еще одну
Count3 BFLOAT8,DIM(4) ! Объявить массив из 4-х переменных
Count4 BFLOAT8(5) ! Объявить и присвоить начальное значение
Count5 BFLOAT8,EXTERNAL ! Объявить как внешнюю переменную
Count6 BFLOAT8,EXTERNAL,DLL
! Объявить как внешнюю переменную в библиотеке DLL
Count7 BFLOAT8,NAME('SixCount') ! Объявить с внешним именем
Упакованная десятичная переменная с плавающей точкой.
Формат: ± мантисса
| . | ................................. |
Биты
: 127 124 0
Диапазон
: от -9 999 999 999 999 999 999 999 999 999 999 до
+9 999 999 999 999 999 999 999 999 999 999
длина
Обязательно требующаяся числовая константа, содержащая общее число десятичных цифр (целой и дробной частей вместе без учета запятой) в переменной. Максимальная длина 31 цифра.
длина дробной части
Числовая константа, которая устанавливает число десятичных цифр в дробной части переменной (справа от запятой). Она должна быть меньше или равна параметру длина. Если этот параметр опущен, то объявляется целочисленная переменная.
начальное значение Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор DЕСIМАL объявляет переменной длины упакованную десятичную переменную со знаком. Каждый байт DЕСIМАL переменной содержит две десятичные цифры (по 4 бита на цифру). Самый левый байт содержит знак переменной в старших 4-х разрядах (0 - положительный, любая другая комбинация - отрицательный) и одну десятичную цифру. Таким образом, десятичная переменная всегда содержит нечетное число цифр (и DЕСIМАL(10),
и DЕСIМАL(11) занимают 6 байт).
Пример:
Count1 DECIMAL(5,0) !
Объявить десятичную упакованную переменную в 3 байта
Count2
DECIMAL,OVER(Count1) ! Объявить поверх нее еще одну
Count3
DECIMAL,DIM(4) ! Объявить массив из 4-х переменных
Count4
DECIMAL(5) ! Объявить и присвоить начальное значение
Count5
DECIMAL,EXTERNAL ! Объявить как внешнюю переменную
Count6
DECIMAL,EXTERNAL,DLL ! Объявить как внешнюю переменную в библиотеке DLL
Count7
DECIMAL,NAME('SixCount') ! Объявить с внешним именем
ExampleFile FILE
,DRIVER('Btrieve') ! Объявить файл
Record RECORD
Count8
DECIMAL,NAME('Counter') ! Объявить с внешним именем
Упакованная десятичная переменная с плавающей точкой.
Формат: мантисса
±
| ................................... | . |
Биты
: 127 4 0
Диапазон
: от -9 999 999 999 999 999 999 999 999 999 999 до
+9 999 999 999 999 999 999 999 999 999 999
длина
Обязательно требующаяся числовая константа, содержащая общее число десятичных цифр (целой и дробной частей вместе без учета запятой) в переменной. Максимальная длина 31 цифра.
длина дробной части
Числовая константа, которая устанавливает число десятичных цифр в дробной части переменной (справа от запятой). Она должна быть меньше или равна параметру длина. Если этот параметр опущен, то объявляется целочисленная переменная.
начальное значение Числовая константа. Если параметр опущен, то начальное значение устанавливается в 0, за исключением случаев, когда присутствует атрибут AUTO.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор PDЕСIМАL объявляет переменной длины упакованную десятичную переменную со знаком в формате Btrieve и IBM/EBCDIC. Каждый байт PDЕСIМАL переменной содержит две десятичные цифры (по 4 бита на цифру). Самый правый байт содержит знак переменной в младших 4-х разрядах (0Fh или 0Ch - положительный, 0Dh - отрицательный) и одну десятичную цифру. Таким образом, переменная PDЕСIМАL всегда содержит нечетное число цифр (и PDЕСIМАL(10), и PDЕСIМАL(11) занимают 6 байт).
Пример:
Count1 PDECIMAL(5,0) !
Объявить десятичную упакованную переменную в 3 байта
Count2 P
DECIMAL,OVER(Count1) ! Объявить поверх нее еще одну
Count3 P
DECIMAL,DIM(4) ! Объявить массив из 4-х переменных
Count4 P
DECIMAL(5) ! Объявить и присвоить начальное значение
Count5 P
DECIMAL,EXTERNAL ! Объявить как внешнюю переменную
Count6 P
DECIMAL,EXTERNAL,DLL ! Объявить как внешнюю переменную в библиотеке DLL
Count7 P
DECIMAL,NAME('SixCount') ! Объявить с внешним именем
Числовая константа, которая определяет число байт в строке. Значение этого параметра не инициализировано, если не задана строковая константа.
строковая константа
Устанавливает начальное значение строки. Длина строки (в байтах) устанавливается равной длине этой строковой константы
.
шаблон
Используется для форматирования значения, присваиваемого строке. Длина переменной в этом случае устанавливается равной числу байтов, требующихся, чтобы вместить форматированную строку.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор
STRING объявляет строку символов фиксированной длины. Если не указан атрибут AUTO, память, выделяемая для переменной типа STRING, заполняется пробелами.
Теперь стало возможным объявление типов STRING переменных размеров. Ограничение те же, что и для переменных размеров массивов: объявления возможны только внутри локальных процедур или подпрограмм, а также должны быть определены все переменные использованные в выражении в момент создания переменной. Смотри также:
Дополнительно к явному объявлению, все символьные строки неявно объявляются как STRING(1),DIM(длина строки). Это позволяет адресовать каждый символ строки как элемент массива. В случае если оператор SТRING уже имеет атрибут DIM, то это неявное объявление массива представляет собой самый последний (необязательный) уровень индексов (справа от объявленных явно).
Кроме того, можно непосредственно адресоваться к нескольким символам внутри строки, используя технологию “частей строки”. Эта технология выполняет действия подобные функции SUB, только гораздо более гибкая и эффективная (но только не проверяет границы). Более гибкая потому, что “часть строки” может использоваться в операции присвоения с обеих сторон от знака равно (=), а функция SUB может использоваться только в качестве источника данных. А более эффективна потому, что требует меньших затрат памяти, чем присвоение отдельных символов или функция SUB.
Для того чтобы взять “часть” строки, номера начального и конечного символов в этой части разделяются двоеточием и помещаются в квадратных скобках ([ ]) как индексы неявно объявленного массива. Номера символов могут быть целочисленными константами, переменными или выражениями. Если используются переменные, то между именами переменных и двоеточием должен быть, по крайней мере, один пробел, чтобы избежать путаницы с префиксами.
Пример:
Name STRING(20) ! Объявить 20-ти байтовое поле названия
ArrayString STRING(5),DIM(20) ! Объявить массив
Company STRING('SoftVelocity Corporation') ! Программистская компания - 20 байтов
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
ASTRING
(подобна Win32 ATOM) объявляет ссылку на строковую переменную (признак строки) с максимальным размером 64k. Хотя размер признака строки может быть вплоть до 64k, он рекомендован для использования в строках меньшей длины. Место хранения ASTRING выделяется динамически столько, сколько необходимо во время жизни процедуры, в которой он создан. Однако выделенная память не будет освобождена; вместо этого она будет многократно использована для таких же текстовых величин.
ASTRING хорошо использовать при хранении и сравнении похожего текста. Всякий раз, когда создается новый ASTRING, для него выделяется память. Когда ASTRING назначено значение, которое уже существует в памяти, ASTRING просто указывает на существующий ASTRING. Это сохраняет память и позволяет значительно ускорять сравнение строк.
ASTRING не поддерживается ни одним из файловых драйверов.
ASTRING может передаваться в процедуру по значению или как ссылка. Также может передаваться как нетипизированный параметр-значение или нетипизированная параметр-переменная. ASTRING может быть возвращено из процедуры только как значение.
Соответствие типов ASTRING при использовании в выражениях, параметрах процедур и обработке очередей является необходимым
.
Что каcается выражений, если одним из операндов выражения является ASTRING, то другой также должен быть ASTRING. Если это невозможно, быстрее и меньше занимать ресурсы будет использование типов STRING и CSTRING. Каждая строка, использованная как начальное значение переменной ASTRING, располагается в памяти как минимум дважды.
Если прототип параметра процедуры объявлен как ASTRING, фактический параметр, получающий переданное значение, также должен быть объявлен как тип ASTRING. В противном случае, значение фактического параметра будет добавлено в хэш таблицы ASTRING.
Пример
:
В определении CLASS:
Match PROCEDURE(ASTRING DocumentToSearch, ASTRING SearchExp),BYTE
Если в очереди определены поля ASTRING и программе необходимо обработать GET по ключу из этой очереди, значения любого поля ASTRING, используемого в ключе, также должно быть ASTRING. В противном случае, значение фактического параметра будет добавлено в хэш таблицы ASTRING.
Пример
:
DbNameQueue QUEUE,TYPE
FileName ASTRING
FieldName ASTRING
Ptr USHORT
END
NameQueue &DbNameQueue,PROTECTED
SELF.NameQueue.FileName = SELF.TriggerQueue.FileName !SELF.TriggerQueue.FileName is ASTRING
GET(SELF.NameQueue,SELF.NameQueue.Filename)
Еще примеры прототипов
:
PROC1(ASTRING a)
PROC2(*ASTRING a)
PROC3(? a)
PROC4(*? a)
PROC5(),ASTRING
!
Дополнительный пример:
PROGRAM
MAP
END
FLAG LONG
AS1 ASTRING,OVER(FLAG)
AS2 ASTRING
CODE
AS1 = 'SoftVelocity' ! хранит расположение в памяти для строки 'SoftVelocity'
AS2 = 'SoftVelocity' ! не занимает память, вместо AS1 и AS2 ссылается на ту же величину
AS2 = 'Hello' ! новое хранение в памяти для строки Hello
AS2 = 'SoftVelocity' ! нет нового хранения, ссылка для AS1 теперь равна AS2
в период проектирования. Может быть расширено, используя NEW в процессе работы программы.
длина
Числовая константа, которая определяет число байт, которое будет храниться в строке. В него должен включаться байт для нулевого завершающего символа. Значение этого параметра не инициализировано, если не задана строковая константа.
строковая константа
Строковая константа, содержащая начальное значение строки. Длина строки устанавливается равной длине этой строковой константы плюс завершающий нулевой символ.
шаблон Шаблон, использующийся для форматирования значения, присваиваемого строке. Длина переменной в этом случае устанавливается равной числу байтов, требующихся, чтобы вместить форматированную строку плюс завершающий нулевой символ.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор
CSTRING объявляет строку символов, заканчивающуюся нулевым символом (ASCII код равный 0). Если не указан атрибут AUTO, переменная типа CSTRING инициализируется строкой нулевой длины.
Эта строка соответствует типу, используемому в языке С и типу поля ZSTRING в Btrieve Record Manager. Хотя память для строки выделяется в соответствии с объявленной длиной, завершающий нулевой символ помещается сразу после введенных данных. Тип данных CSTRING следует использовать для достижения совместимости с внешними файлами или процедурами.
Дополнительно к явному объявлению все символьные строки неявно объявляются как STRING(1),DIM(длина строки). Это позволяет адресовать каждый символ строки как элемент массива. В случае если оператор CSТRING уже имеет атрибут DIM, то это неявное объявление массива представляет собой самый последний (необязательный) уровень индексов (справа от объявленных явно).
Кроме того, можно непосредственно адресоваться к нескольким символам внутри строки, используя технологию “частей строки”. Эта технология выполняет действия подобные функции SUB, только гораздо более гибкая и эффективная (но только не проверяет границы). Более гибкая потому, что “часть строки” может использоваться в операции присвоения с обеих сторон от знака равно (=), а функция SUB может использоваться только в качестве источника данных. А более эффективна потому, что требует меньших затрат памяти, чем присвоение отдельных символов или функция SUB.
Для того чтобы взять “часть” строки, номера начального и конечного символов в этой части разделяются двоеточием и помещаются в квадратных скобках как индексы неявно объявленного массива. Номера символов могут быть целочисленными константами, переменными или выражениями. Если используются переменные, то между именами переменных и двоеточием должен быть, по крайней мере, один пробел, чтобы избежать путаницы с префиксами.
Поскольку строка типа CSТRING должна заканчиваться нулевым кодом ASCII, то в случае обращения к символам строки только как к элементам массива (а не как строке в целом) ответственность за то, что после всех данных в строку помещен нулевой байт, лежит на программисте. Кроме того, в строке типа CSTRING после нулевого символа могут иметься остатки предыдущего значения. Из-за этого внутри групп такая строка может работать неправильно.
Пример:
Name CSTRING(21
) ! Объявить поле названия в 21 байт - 20 байт данных
OtherName CSTRING(21),OVER(Name) ! Объявить поверх него массив
Contact CSTRING(21),DIM(4) ! Массив полей по 21 байт - 80 байт данных
Company CSTRING('SoftVelocity Corporation') ! Строка в 21 байт - 20 байт данных
Phone CSTRING(@P(###)###-####P) ! Объявить 14 байт - 13 байт данных
Числовая константа, которая определяет число байт, которое будет содержаться в строке. В нее должен включаться байт в начале строки для хранения длины.
строковая константа
Строковая константа, содержащая начальное значение строки. Длина строки устанавливается равной длине этой строковой константы плюс байт длины в начале строки.
шаблон Шаблон, использующийся для форматирования значения, присваиваемого строке. Длина переменной в этом случае устанавливается равной числу байтов, требующихся, чтобы вместить форматированную строку плюс байт длины в начале строки. Строковая переменная не инициализирована, если не установлена строковая константа.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор
PSTRING объявляет строку символов, состоящую из байта длины и идущих следом байтов данных. Если не указан атрибут AUTO, переменная типа PSTRING инициализируется строкой нулевой длины. Эта строка соответствует типу, используемому в языке Паскаль и типу поля LSTRING в Btrieve Record Manager. Хотя память для строки выделяется в соответствии с объявленной длиной, байт длины во время выполнения будет содержать действительную длину строки. Для использования во время выполнения программы PSTRING неявно преобразуется в промежуточное значение типа STRING. Тип данных PSTRING следует использовать для достижения совместимости с внешними файлами или процедурами.
Дополнительно к явному объявлению все символьные строки неявно объявляются как PSTRING(1),DIM(длина строки). Это позволяет адресовать каждый символ строки как элемент массива. В случае если оператор PSТRING уже имеет атрибут DIM, то это неявное объявление массива представляет собой самый последний (необязательный) уровень индексов (справа от объявленных явно).
Кроме того, можно непосредственно адресоваться к нескольким символам внутри строки, используя технологию “частей строки”. Эта технология выполняет действия подобные функции SUB, только гораздо более гибкая и эффективная (но только не проверяет границы). Более гибкая потому, что “часть строки” может использоваться в операции присвоения с обеих сторон от знака равно (=), а функция SUB может использоваться только в качестве источника данных. А более эффективна потому, что требует меньших затрат памяти, чем присвоение отдельных символов или функция SUB. Для того чтобы взять “часть” строки, номера начального и конечного символов в этой части разделяются двоеточием и помещаются в квадратных скобках как индексы неявно объявленного массива. Номера символов могут быть целочисленными константами, переменными или выражениями
. Если используются переменные, то между именами переменных и двоеточием должен быть, по крайней мере, один пробел, чтобы избежать путаницы с префиксами.
Поскольку строка типа PSТRING должна начинаться байтом длины, то в случае обращения к символам строки как к элементам массива (а не как строке в целом) ответственность за то, что байт длины содержит корректное значение, лежит на программисте. Байт длины строки PSТRING адресуется как нулевой элемент массива (единственный случай в Clarion, когда массив имеет нулевой элемент). Поэтому, для строки PSТRING(30) допустимый диапазон индексов массива от 0 до 29. Кроме того, в строке типа PSTRING после нулевого символа может иметься остатки предыдущего значения. Из-за этого внутри групп такая строка может работать неправильно.
Пример:
Name PSTRING(21) ! Объявить поле названия в 21 байт - 20 байт
OtherName PSTRING(21),OVER(Name) ! Объявить поле поверх поля Name
Contact PSTRING(21),DIM(4) ! Массив полей по 21 байт - 80 байт данных
Company PSTRING('SoftVelocity Corpora
tion') ! Строка в 21 байт - 20 байт данных
Phone PSTRING(@P(###)###-####P) ! Объявить 14 байт - 13 байт данных
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор DATE объявляет переменную длиной 4 байта для даты. Этот формат соответствует типу поля “DATE”, использующемуся в Btrieve Record Manager. Переменная типа DATE, используемая в выражениях, преобразуется в число дней, прошедших с 28 декабря 1800 (стандартная дата Clarion, обычно хранимая как LONG). Допустимый диапазон дат в стандартном формате Clarion с 1 января 1801 года по 31 декабря 9999 года. При присвоении значения, выходящего за границы допустимого диапазона, результат непредсказуем. Тип данных DATE следует использовать для достижения совместимости с внешними файлами или процедурами.
Пример:
DueDate DATE ! Объявить переменную даты
OtherDate DATE,OVER(DueDate) ! Объявить поверх нее еще одну
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
AUTO
Указывает, что переменная не имеет начального значения.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
Оператор
TIME объявляет переменную длиной 4 байта для времени. Этот формат соответствует типу поля TIME, использующемуся в Btrieve Record Manager. Переменная типа TIME, используемая в выражениях, преобразуется в число сотых долей секунды, прошедших с полуночи (стандартный формат времени в Clarion, обычно хранимый как LONG). Тип данных TIME следует использовать для достижения совместимости с внешними файлами или процедурами.
Пример:
ChkoutTime TIME ! Объявить переменную времени
OtherTime TIME,OVER(CheckoutTime) ! Объявить поверх нее еще одну
ContactTime TIME,DIM(4) ! Объявить массив дат
ExampleFile FILE,DRIVER('B
trieve') ! Объявить файл
Record RECORD
TimeRecd TIME,NAME('TimeField') ! Объявить с внешним именем
ANY [,DIM( )] [,NAME( )] [,EXTERNAL] [,DLL] [,STATIC] [,THREAD]
[,PRIVATE] [,PROTECTED]
ANY
Переменная, которая может иметь любое значение (численное или строковое) или ссылку на любой простой тип данных.
DIM
Размерность переменной как массива.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
PRIVATE
Указывает, что переменная не видна вне границ модуля, содержащего методы класса. Этот атрибут допустим только внутри структуры CLASS.
PROTECTED
Указать переменную невидимой вне основного CLASS или дочерних CLASS. Действительно только в CLASS.
ANY
объявляет переменную, которая может иметь любое значение (численное или строковое) или ссылку на любой простой тип данных. Это позволяет переменной ANY использоваться в качестве “общего” типа данных. Переменная ANY может быть объявлена в структурах CLASS, GROUP или QUEUE и не может быть объявлена в структуре FILE. ANY может быть указана в качестве USE-переменной любого объекта в окне или отчете при условии, что ANY содержит указатель на переменную, а не само значение. (Смотри правила указания переменных как USE-переменных).
Когда переменная ANY является назначением простого оператора присваивания (назначение
= источник), она получает значение источника. Переменная ANY использует тип REAL в качестве базового для численных операций, что может означать потерю точности при назначении значений DECIMAL более чем с 14 значимыми разрядами. Когда переменная ANY является назначением ссылочного оператора присваивания (назначение &= источник), она получает ссылку на переменную источника. Вы не можете использовать переменную ANY в качестве переменной-параметра (передаваемой по адресу) за исключением случаев, когда получающая процедура прототипирована для получения нетипизированного параметра-переменной(*?) и когда передаваемая переменная ANY содержит указатель.
Когда переменная ANY объявлена в структуре QUEUE, за ней должны следовать некоторые особые рассмотрения в связи с внутренним образом переменной и ее полиморфной структурой.
Использование CLEAR() и ссылочных присваиваний с объектами QUEUE.
Как только переменной ANY в структуре QUEUE было присвоено значение, другой простой оператор присваивания назначит новое значение переменной ANY. Это значит, что предыдущее значение будет заменено новым значением. Если первое значение уже было добавлено в очередь, то этот элемент будет указывать на значение, которого больше не существует.
Как только переменная ANY в структуре QUEUE была адресована переменной (AnyVar &= SomeVariable), другое выражение адресации присвоит ANY новую переменную. Это значит, что предыдущий “указатель” удален и заменен новым “указателем”. Если первая ссылка уже была добавлена в QUEUE, то этот элемент будет “указывать” на более не существующий “указатель”.
В обоих случаях запись QUEUE (или только поля типа ANY) должна быть очищена перед установкой новых значений для последующих ADD() или PUT().
К тому же нужно адресовать переменной ANY значение NULL (AnyVar &= NULL) до удаления элемента очереди, чтобы предохранить QUEUE от получения “мусора”.
Как описано выше, переменная ANY оперирует своей областью данных, где она хранит значение или “указатель” ссылочной переменной. Присваивание нового значения переменной ANY оператором &= очищает предыдущие внутренние данные. Оператор CLEAR(переменная) устанавливает значение переменной ANY как NULL, не очищая ее внутренние данные.
Пример:
MyQueue QUEUE
AnyField ANY !Объявить переменную содержащую значение any
Type STRING(1)
END
DueDate DATE !Объявить переменную даты
CODE
MyQueue.AnyField = 'SoftVelocity'!Присвоить значение строки
MyQueue.Type = 'S' !Указать тип данных
ADD(MyQueue)
CLEAR(MyQueue) !Очистить ссылки
MyQueue.AnyField &= DueDate !Присвоить ссылку DATE
MyQueue.Type = 'R' !Указать тип данных
ADD(MyQueue)
MyQueue.AnyField &= NULL !Указателю назначен NULL для очистки
LOOP X# = RECORDS(MyQueue) TO 1 BY -1 !Цикл по QUEUE
GET(MyQueue,X#)
ASSERT(~ERRORCODE())
CASE MyQueue.Type
OF 'S'
DO StringRoutine
OF 'R'
DO ReferenceRoutine
END
MyQueue.AnyField &= NULL !Указателю назначить NULL перед удалением
DELETE(MyQueue)
ASSERT(~ERRORCODE())
END
Использование ANY в определениях CLASS/
GROUP.
Если вы присваиваете указатель или значение переменной типа ANY, которая является членом класса или группы, то перед тем как уничтожить класс, вы должны отчистить указатель, иначе память, занятая указателем, не будет освобождена.
Пример
:
AClass CLASS
AnyVar ANY,PRIVATE
AMethod PROCEDURE(FILE f)
Destruct PROCEDURE()
END
TextFile FILE,DRIVER('ASCII')
RECORD
Line STRING(255)
END
END
CODE
AClass.AMethod(TextFile)
AClass.AMethod PROCEDURE(FILE TextFile)
AGroup &GROUP
CODE
AGroup &= TextFile{PROP:Record}
SELF.AnyVar &= WHAT(AGroup, 1)
AClass.Destruct PROCEDURE()
CODE
SELF.AnyVar &= NULL !Без этой строки программа будет иметь утечку памяти
Объявляет переменную, тип данных которой наследуется от другой переменной.
новая метка Метка нового объявления элемента данных.
существующая метка
Метка элемента данных, чье объявление будет использоваться. Это может быть любой простой тип данных либо ссылка на него (исключая &STRING) или метка структуры GROUP или QUEUE.
DIM
Размерность, если это массив переменных такого типа.
OVER
Использование памяти, выделенной другой переменной.
PRE
Объявляет префикс для переменных в новой структуре (если LIKE объявляет составную структуру данных). Префикс необязателен, поскольку при непосредственном обращении к любым компонентам новой структуры можно использовать новое имя в контексте синтаксиса уточнения имен.
NAME
Указывает альтернативное “внешнее” имя для переменной.
EXTERNAL
Указывает на то, что переменная объявляется, а память для нее выделяется во внешней библиотеке. Не допустим в объявлениях внутри структур FILE, QUEUE или GROUP.
DLL
Указывает, что переменная определена в библиотеке DLL. В дополнение к этому атрибуту обязателен атрибут EXTERNAL.
STATIC
Указывает, что память для переменной резервируется во время компиляции.
THREAD
Указывает, что память для переменной выделяется отдельно для каждого исполняемого процесса. Для данных локальных для процедуры неявно добавляется также атрибут STATIC.
BINDABLE
Указывает, что все переменные в группе можно использовать в динамических выражениях.
Оператор LIKE предписывает компилятору определить новую метку, используя то же самое определение как для существующей метки, включая все атрибуты. Если изменяется описание существующей метки, то изменяются и свойства новой метки.
Для новой метки дополнительно можно использовать атрибуты DIM и OVER. Однако если существующая метка имеет атрибут DIM, то
новая метка становится массивом автоматически. Если в операторе LIKE для новой метки добавляется дополнительный атрибут DIM, то заданная им размерность массива расширяет уже имеющуюся размерность.
При необходимости могут использоваться атрибуты PRE и NAME. Если существующая метка уже имеет эти атрибуты, то новая метка их унаследует, что вызовет появление ошибок при компиляции. Для того чтобы избежать этого, укажите новые атрибуты, чтобы заместить наследуемые.
Если существующая метка представляет структуру QUEUE, то оператор LIKE не создает новую структуру QUEUE, поскольку новая метка рассматривается просто как структура GROUP. Это справедливо и для случая, когда существующая метка представляет структуру RECORD. Аналогично, если существующая метка - МЕМО, новая метка становится переменной типа STRING размером МЕМО.
Оператор LIKE можно использовать для того, чтобы создать новый экземпляр класса. Однако, простое объявление нового экземпляра, указывая класс в качестве типа данных, работает как неявный оператор LIKE. В обоих способах объявления нового экземпляра недопустимо использование атрибутов DIM, OVER, PRE и NAME, в то же время другие атрибуты в объявлении нового экземпляра класса можно использовать.
Пример:
Amount REAL ! Объявить поле
QTDAmount LIKE(Amount
) ! Использовать то же самое объявление
YTDAmount LIKE(QTDAmount) ! Снова использовать то же самое объявление
MonthlyAmts LIKE(Amount),DIM(12) ! Использовать то же объявление для массива 12-ти
! элементов
AmtPrPerson LIKE(MonthlyAmts),DIM(10)
! Использовать то же объявление для массива в 120 элементов (12,10)
Construct GROUP ! Объявить группу
Field1 LIKE(Amount) ! Construct.field1 - real
Field2 STRING(10) ! Construct.field2 - string(10)
END
NewGroup LIKE(Construct) ! Объявить новую группу, содержащую
! NewGroup.field1 - real
! NewGroup.field2 - string(10)
MyQue QUEUE ! Определить очередь
Field1 STRING(10)
Field2 STRING(10)
END
MyGroup LIKE(MyQue) ! Определить новую GROUP, такую как QUEUE
AmountFile FILE,DRIVER('Clarion'),PRE(Amt)
Record RECORD
Amount REAL ! Объявить поле
QTDAmount LIKE(Amount) ! Использовать то же самое объявление
END
END
Animal CLASS
Feed PROCEDURE(short amount),VIRTUAL
Die PROCEDURE
Age LONG
Weight LONG
END
Cat LIKE(Animal) ! Новый экземпляр класса Animal
Bird Animal ! Новый экземпляр класса Animal (неявный LIKE)
Некоторые переменные не объявляются. Они создаются компилятором при первом их упоминании в тексте программы. Неявно объявленные переменные автоматически инициализируются пробельным или нулевым значением; нет необходимости присваивать значение перед использованием. Можно смело полагать, что перед тем как неявным переменным в программе впервые присваиваются значения, они содержат пробелы или нуль. Неявно объявленные переменные обычно используются для индексов массивов, логических переключателей (истина/ложь), промежуточных переменных в сложных вычислениях, управляющих переменных цикла и т.д.
В языке Clarion имеется три типа неявно объявленных переменных:
# Метка, заканчивающаяся знаком фунта, именует переменную типа LONG.
$ Метка, заканчивающаяся знаком доллара, именует переменную типа REAL.
‘’ Метка, заканчивающаяся двойной кавычкой, именует переменную типа STRING(32).
Любым неявно объявленным переменным, использованным в секции объявления глобальных данных (между ключевыми словами PROGRAM и CODE) назначается статическая память и они доступны в любом месте программы. Любые неявно объявленные переменные, использованные между ключевыми словами MEMBER и PROCEDURE в модуле данных становятся данными модуля тоже статическими и видимыми только тем процедурам, которые определены в модуле. Остальные неявно объявленные переменные являются локальными данными, которым выделяется динамическая память в стеке программы. Эти переменные видимы только в процедуре. Неявно объявленные переменные в подпрограммах приносят больше издержек, чем объявленные вне подпрограмм, поэтому используйте их умеренно или не используйте вообще.
Поскольку компилятор создает неявно объявленные переменные по мере их упоминания в программе, существует опасность, что могут возникать проблемы, которые трудно отследить. Проблемы, связанные с отсутствием сообщения об ошибке во время компиляции и проверки типа неявно объявленной переменной. Например, вы набрали неверно имя ранее использованной неявной переменной и компилятор не сообщит об этом, а просто создаст новую неявно объявленную переменную с новым именем. Когда в вашей программе будет проверяться значение первой переменной, оно будет неверным. Поэтому неявно объявленные переменные следует использовать внимательно и осторожно, и только в ограниченном контексте (или не использовать вообще).
Переменные-указатели содержат ссылку на объявление других данных (целевых данных или цель). Объявляется переменная-указатель добавлением спереди амперсанда (&) к типу соответствующей ей цели (например: &BYTE, &FILE, &LONG и т.д.) или объявлением переменной типа ANY. В зависимости от типа данных цели указатель может содержать адрес памяти или более сложную внутреннюю структуру (описывающую расположение и тип целевых данных).
Для объявления указателей типа &STRING, &CSTRING, &PSTRING, &DECIMAL и &PDECIMAL не требуется указание параметра длина, поскольку необходимая информация о целевых данных содержится в ссылке. Это значит, что переменная-указатель &STRING может содержать ссылку на переменную типа ST
RING произвольной длины.
Переменная-указатель, объявленная как &WINDOW, может содержать ссылку на структуру типа APPLICATION, WINDOW или на структуру REPORT. Ссылки на эти структуры внутренне обрабатываются точно так же, как и рабочей библиотекой Clarion.
Переменная ANY может содержать ссылку на любой простой тип данных, и таким образом эквивалентна любому из них, кроме &GROUP, &QUEUE, &FILE, &KEY, &BLOB, &VIEW и &WINDOW.
Присвоение указателя
Оператор &= выполняет операцию
присвоения указателя (назначение &= источник). Он присваивает переменной-указателю значение указателя на объект. Вы можете использовать операцию присвоения указателя в условном выражении.
Встроенная переменная NULL используется, чтобы “дезактивировать” ссылочную переменную или определить “дезактивированную” ссылочную переменную в условном выражении.
Использование ссылочных переменных
Использование переменной-указателя синтаксически допустимо в любом контексте, в котором допустимо использование целевой переменной или структуры. Это значит, что любое выражение, использующее метку WINDOW как параметр, также может использовать метку ссылочной переменной &WINDOW, которая была ссылочно соотнесена структуре WINDOW.
При использовании в исполняемом операторе, переменная-указатель автоматически “разыменовывается”, представляя в оператор значение целевого объекта. Единственным исключением является операция присвоения указателей, когда указателю присваивается ссылка на данные, на которые он указывает. Например:
Var1 LONG ! Var1 есть LONG
RefVar1 &LONG ! RefVar1 есть ссылка на LONG
RefVar2 &LONG ! RefVar2 есть также ссылка на LONG
CODE
RefVar1 &= Var1 ! RefVar1 ссылается на Var1
RefVar2 &= RefVar1 ! RefVar2 также ссылается на Var1
RefVar1 &= NULL ! RefVar1 не ссылается ни на что
Объявления указателей-переменных
122
CLARION 4д ОПИСАНИЕ ЯЗЫКА
Указатели-переменные не могут быть объявлены в структурах FILE или VIEW, но могут быть объявлены в структурах GROUP, QUEUE и CLASS. Назначение CLEAR(ИмяСтруктуры) для структур GROUP, QUEUE или CLASS, содержащих указатели-переменные, эквивалентно адресации ссылки NULL к указателю-переменной.
Глобальные указатели не ограничены рамками исполняемого процесса, и таким образом, могут использоваться для ссылок на элементы данных в другом исполняемом процессе.
Указатель-переменная, используемая в любом атрибуте управляющего объекта, поля, в объявлении окна или отчета, должна получить значение (то есть, указывать на некое расположение данных) перед обработкой этого объявления при входе в ту область видимости, в которой она объявлена. Например, если окно объявлено в процедуре, указатель-переменная должна быть объявлена и ей присвоена своя величина перед входом в процедуру или объявлена в той же процедуре перед окном и получить свое значение в конструкторе некоего класса, объявленного перед объявлением окна.
Именованные указатели QUEUE и CLASS
Дополнительно к приведенному выше списку можно получить указатели на “поименованные” очереди (&QueueName) и “поименованные” классы (&
ClassName). Это позволяет использовать указатели для передачи “поименованных групп” в качестве параметров, что позволит получающей процедуре получить доступ к полям “поименованной” структуры.
Ссылка на поименованную очередь или класс может быть ссылкой “вперед”. То есть, поименованные очередь или класс, на которые указывает переменная-указатель, могут быть еще не объявлены. Тем не менее, ссылка “вперед” должна быть разрешена прежде, чем переменная-указатель будет использована. В случае, когда переменная-указатель содержится внутри объявления структуры CLASS, ссылка “вперед” должна быть разрешена прежде, чем объекту будет присвоено значение, иначе ссылка будет пуста и непригодна для использования.
Есть несколько преимуществ использования ссылок "вперед". Вы можете иметь QUEUE из объектных ссылок, каждая из которых содержит QUEUE из объектных ссылок, каждая из которых содержит QUEUE из объектных ссылок… Например, в структуре CLASS вы можете создать очередь из “наследников” таким образом:
FamilyQ QUEUE
Sibling &FamilyClass !
ссылка вперед
END
FamilyClass CLASS
Family &FamilyQ !
END
Другое преимущество - в возможности “скрывать” объекты ссылок PRIVATE в объявлениях CLASS. Например:
! Включаемый файл (MyFile.inc) содержит:
WidgetManager CLASS,TYPE
WidgetList &WidgetQ,PRIVATE !
DoSomething PROCEDURE
END
! Другой файл (MyFile.CLW) содержит:
MEMBER('MyApp')
INCLUDE('MyFile.INC')
WidgetQ QUEUE,TYPE
Widget STRING(40)
WidgetNumber LONG
END
MyWidget WidgetManager ! Действительное подтверждение должно следовать
! за разрешением ссылочной переменной
MyWidget.DoSomething PROCEDURE
CODE
SELF.WidgetList &= NEW(WidgetQ) ! Действительный код
SELF.WidgetList.Widget = 'Widget One'
SELF.WidgetList.WidgetNumber = 1
ADD(SELF.WidgetList)
В этом примере ссылки на SELF.WidgetList действительны только в файле MyFile.CLW.
Пример:
App1 APPLICATION('Hello')
END
App2 APPLICATION('Buenos Dias')
END
AppRef &WINDOW ! Ссылка на APPLICATION, WINDOW или REPORT
Animal CLASS
Feed PROCEDURE(SHORT amount),VIRTUAL
Die PROCEDURE
Age LONG
Weight LONG
END
Carnivore CLASS(Animal),TYPE
Feed PROCEDURE(Animal)
END
Cat CLASS(Carnivore)
Feed PROCEDURE(SHORT amount),VIRTUAL
Potty BYTE
END
Bird Animal ! Экземпляр класса Animal
AnimalRef &Animal ! ссылка на класс Animal
CODE
IF CTL:Language = 'Spanish' ! Если пользователь испаноязычный
AppRef &= App2 ! установить ссылку на испаноязычное окно
ELSE
AppRef &= App1 ! иначе установить ссылку на англоязычное окно
Операторы объявления данных автоматически распределяют память для хранения значений данных. Термины “глобальные, локальные, статические и динамические данные” описывают тип выделяемой памяти.
Термины “глобальные” и “локальные” данные говорят об области распространения данных (также известная как “область видимости”):
Глобальные данные доступны в любой процедуре программы.
Локальные данные имеют ограниченную доступность. Их область распространения может ограничиваться рамками одной процедуры или подпрограммы, а также пределами нескольких процедур в одном исходном модуле.
Термины “статические” и “динамические” данные указывают на момент времени, когда для данных выделяется место в памяти:
“Статический” означает, что данным распределяется память, которая освобождается только после завершения выполнение всей программы в целом.
“Динамический” - означает, что данным память выделяется во время исполнения программы. Данные объявленные локально для процедуры или подпрограммы располагаются в стеке процесса, вызванного этой процедурой или подпрограммой. Память в стеке освобождается, когда процедура, распределившая стек, возвращает управление в точку, из которой к ней произошло обращение.
“Динамический” также означает, что память для данных в программе можно выделить использованием явно – NEW или неявно - некоторыми библиотечными операторами во время исполнения программы (присваивание переменной ANY значения, добавлением в очереди и т.д.). Память в стеке не освободится, пока ее явно не освободят: DISPOSE для новых переменных, созданных NEW, FREE или DELETE для очередей и т.д.
В программе на языке Clarion существует четыре области, в которых можно объявить данные:
В программном модуле после ключевого слова PROGRAMM и до оператора CODE. Это секция глобальных данных.
В member-модуле после ключевого слова MEMBER и до первого оператора PROCEDUURE. Это секция данных модуля
.
В процедуре после ключевого слова PROCEDUURE и до оператора CODE. Это секция локальных данных
.
В подпрограмме, после ключевого слова DATA и до оператора CODE. Это секция локальных
данных подпрограммы.
Глобальные данные доступны для использования в исполняемых операторах и выражениях в любой процедуре этой программы. Глобальные данные всегда находятся в памяти. Глобальные данные распределяются в статической памяти и доступны каждой процедуре в программе.
Данные модуля доступны для использования в исполняемых операторах и выражениях только в процедурах, содержащихся в данном модуле. Если нужно, они могут передаваться в качестве параметров в процедуры в другие модули. Модульные данные входят в область действия при вызове любой из PROCEDURE модуля. Модульные данные также распределяются в статической памяти.
Локальные данные доступны в пределах процедуры, в которой они объявлены или любом локальном дочернем методе объявленном в процедуре. Локальные данные находятся в памяти при вызове процедуры, в которой они объявлены и освобождают память при выполнении оператора RETURN (явно или неявно). Их можно передавать в качестве параметров в любые другие процедуры. Локальным данным выделяется динамическая память. Такая память выделяется в области программного стека для переменных, размер которых меньше для ограничения для стека (по умолчанию 5К), в противном случае память для них выделяется из “кучи”. Механизм распределения памяти можно изменить, используя атрибут STATIC, тем самым, делая возможным существование значения этой переменной и в промежутке между обращениями к процедуре. Объявления FILE всегда находятся в статической памяти (в “куче”), даже при объявлении в области локальных данных.
Динамическое распределение памяти для локальных данных делает процедуры истинно рекурсивными, получающими при каждом обращении к ним новые копии локальных переменных.
Локальные данные подпрограммы видны только в подпрограмме, в которой они объявлены. Они могут быть переданы в качестве параметра любой другой процедуре. Локальные данные подпрограммы активизируются при вызове подпрограммы и становятся неактивными при выходе из подпрограммы. Локальные данные подпрограммы занимают динамическую память. Память размещена в стеке программы для переменных, по объему меньших, чем порог стека (по умолчанию-5К), иначе они автоматически помещаются в "кучу". У подпрограммы есть собственная область имен, так что метки, используемые для Локальных данных подпрограммы, могут повторять имена переменных, использованных в других подпрограммах или даже процедурах, использующих подпрограмму. Переменные, объявленные в ROUTINE, не могут иметь атрибутов STATIC или THREAD.
Неявно объявленные строковые массивы и части строк
Дополнительно к явному объявлению все символьные строки неявно объявляются как массив из односимвольных строк, размеренных по длине строки. Такое неявное объявление эквивалентно объявлению второй переменной:
Неявное объявление позволяет адресовать каждый символ строки как элемент массива, не требуя второго оператора объявления. Байт длины строки PSTRING адресуется как нулевой элемент массива или первый байт BLOB (только два случая, когда в Clarion допустима ссылка на нулевой элемент массива)
.
В случае, если строка уже имеет атрибут DIM, то это неявное объявление массива представляет собой самый последний (необязательный) уровень индексов (справа от объявленных явно). Процедура MAXIMUM не работает с неявным уровнем размерности, вместо нее следует использовать функцию SIZE. Проверка выхода за границы осуществляется системой проекта проверки индекса.
Кроме того, можно непосредственно адресоваться к нескольким символам внутри строки, используя технологию “частей строки”. Эта технология выполняет действия подобные процедуре SUB, только гораздо более гибкая и эффективная. Более гибкая потому, что “часть строки” может использоваться в операции присваивания с обеих сторон от знака равно (=), а процедура SUB может использоваться только в качестве источника данных. А более эффективна потому, что требует меньших затрат памяти, чем присваивание отдельных символов или процедура SUB.
Для того чтобы взять “часть” строки, номера начального и конечного символов в этой части разделяются двоеточием и помещаются в квадратных скобках ([]) как индексы неявно объявленного массива. Номера символов могут быть целочисленными константами, переменными или выражениями (преобразуясь в базовый тип LONG). Если используются переменные, то между именами переменных и двоеточием должен быть, по крайней мере, один пробел, чтобы избежать путаницы с префиксами.
Операции "части строки" выполняются в строковых переменных (STRING, CSTRING и т.п.) и результатом всегда является переменная типа STRING. Если часть строки используется как часть выражения, то переменная STRING разыменовывается в свое значение. Это сильно отличается от SUB, поскольку SUB работает с целевым значением строки, а результатом является другое значение строки.
Отдельные элементы могут быть очищены использованием оператора
CLEAR. Например:
CLEAR( MyString[ n : m ] )
или CLEAR( MyString[ n : m ], 0 ) для заполнения пробелами ( 20h )
CLEAR( MyString[ n : m ], -1 )
для заполнения наименьшими значениями ( 00h )
CLEAR( MyString[ n : m ] , 1 )
для заполнения наибольшими значениями ( 0FFh )
В общих чертах, при получении любого элемента массива, массив всегда рассматривается как переменная, и результатом элемента массива также является переменная. Массивы могут быть прототипированы в процедуре и передаваться только как параметры-переменные. Если элемент массива используется как часть выражения, он всегда разыменовывается.
Пример:
Name STRING(15)
CONTACT STRING(15),DIM(4)
CODE
Name = 'Tammi' ! Присвоить значение
Name[5] = 'y' ! затем изменить пятый символ
Name[6] = 's' ! затем добавить шестой символ
Name[0] = '<6>' ! и поменять байт длины
Name[5:6] = 'ie' ! и изменить “часть” строки – пятый и шестой символы
Contact[1] = 'First' ! присвоить значение первому элементу
Contact[1,2] = 'u' ! изменить второй символ первого элемента
Con
tact[1,2:3] = Name[5:6] ! присвоить часть строки первого элемента подстроки 2-го
Теперь стало возможным объявлять переменные подобные STRING и DECIMAL/PDECIMAL переменного размера для компилятора.
Ограничения такие же, как и для переменных-размеров массива (см. ниже): такие объявления доступны только в памяти процедуры или подпрограммы, а все переменные, использованные в выражении, должны быть определены на момент создания переменной.
Пример:
VarLength LONG
VarString STRING(VarLength)
CODE
VarLength = 200
VarString = `String of up to 200 characters’
Переменные-размеры массива
Рассмотрим следующий пример:
VariableArray ROUTINE
Element LONG
DynArray CSTRING(100),DIM(Element) !объявлен массив переменной длины
CODE
!
просчитать DynArray
Имеется 3 ограничения использования такой технологии:
1) Переменная, предназначенная для установки количества элементов в массиве (
Elements), должна быть локально объявлена в соответствующей процедуре или подпрограмме и не иметь атрибутов STATIC, THREAD или EXTERNAL.
2) Эта переменная не должна быть полем в любой из составных структур (GROUP,QUEUE, CLASS, RECORD).
3) Все переменные, используемые в выражениях определяющих количество измерений в массиве, должны быть инициализированы на момент инициализации массива, т.е. они должны быть объявлены перед объявлением массива, или они должны быть объявлены во внешней области и получить значение перед вызовом в процедуру или подпрограмму, или они могут быть параметром процедуры.
NEW (выделить память из кучи)
указатель
&= NEW( тип данных )
указатель
Метка переменной-указателя, которая соответствует типу данных.
NEW
Создает новый экземпляр типа данных в “куче”.
тип данных Метка ранее объявленной структуры CLASS или QUEUE, или оператор объявления любого простого типа данных. Параметр может включать переменную как параметр типа данных, чтобы обеспечить истинно динамические объявления.
Оператор
NEW создает новый экземпляр типа данных в “куче”. Ключевое слово NEW допустимо только с правой стороны от оператора присваивания указателя. Память, созданная NEW, автоматически заполняется нолями или пробелами и должна освобождаться явно, оператором DISPOSE (иначе вы создадите “утечку памяти”).
Использование типа данных, заключенного в скобки необязательно.
Пример:
StringRef &STRING ! Указатель на любую переменную типа STRING
LongRef &LONG ! Указатель на любую переменную типа LONG
Animal CLASS
Feed PROCEDURE(short amount)
Weight LONG
END
AnimalRef &Animal ! Указатель на любой класс типа Animal
NameQ QUEUE
Name STRING(30)
END
QueRef &NameQ ! Указатель на любую очередь из STRING(30)
CODE
AnimalRe
f &= NEW(Animal) ! Создать новый экземпляр класса Animal
QueRef &= NEW(NameQ) ! Создать новый экземпляр очереди NameQ
StringRef &= NEW(STRING(50)) ! Создать новую переменную STRING(50)
X# = 35 ! присвоить 35 переменной и затем
StringRef &= NEW(STRING(X
#)) ! использовать ее для создания новой переменной
! STRING(35)
LongRef &= NEW(LONG) ! Создать новую переменную типа LONG
DISPOSE (освободить память в куче)
DISPOSE(
указатель )
DISPOSE
Освободить память в куче, ранее распределенную оператором NEW.
указатель Имя переменной-указателя ранее использовавшегося в операторе присвоения указателя с оператором NEW. Этот указатель может быть NULL и никакого нежелательно эффекта не произойдет.
Оператор
DISPOSE освобождает память в куче, ранее распределенную оператором NEW. Если DISPOSE не вызывается, память не возвращается для повторного использования операционной системой (создается "утечка" памяти). Однако если вы освобождаете указатель, который в этот момент используется (такой как очередь, показанная в объекте LIST), то скорее всего вы получите GPF, что очень трудно отследить.
DISPOSE(SELF) предназначен для делокализации текущего экземпляра объекта. Если он используется, он должен быть последним оператором процедуры, иначе следующие указатели на объект могут вызвать проблемы.
Возможна передача указателя &STRING в процедуру, в которой он, в некотором отношении, может быть освобожден. Хотя *STRING нельзя освободить, рассмотрим следующий код:
MyProc PROCEDURE (*STRING S)
Ref &STRING,AUTO
CODE
Ref &= S
DISPOSE (Ref)
Параметр/результат типа *STRING может использоваться только для чтения значения &STRING: можно изменить строку, на которую он указывает, но нельзя установить указатель на другую строку. DISPOSE устанавливает указатель в NULL и следовательно, параметры *STRING и результаты не могут быть освобождены напрямую, но назначение их ссылки на переменную-указатель даст результат. Это справедливо и для других типов
данных.
Пример:
StringRef &STRING ! Указатель на переменную типа STRING
Animal CLASS,TYPE
Feed PROCEDURE(short amount),VIRTUAL
Weight LONG
END
AnimalRef &Animal ! Указатель на класс Animal
NameQ QUEUE
Name STRING(30)
END
QueRef &NameQ ! Указатель на очередь из STRING(30)
CODE
AnimalRef &= NEW(Animal) ! Создать новый экземпляр класса Animal
DISPOSE(AnimalRef) ! освободить память класса Animal
QueRef &= NEW(NameQ) ! Создать новую очередь NameQ
Шаблоны обеспечивают заданный формат представления значений отображаемых и редактируемых переменных. Существует семь типов шаблонов: числовые и денежные, научной записи чисел, строковые шаблоны, даты, времени, шаблоны пользователя и шаблоны редактирования вводимых строк.
валюта Или знак доллара ($) или любая заключенная в тильды (~) строковая константа. Когда отсутствует индикатор заполнения и обозначение валюты предшествует знаку, тогда обозначение валюты “плавает” слева от старшей значащей цифры. Если есть индикатор заполнения, то обозначение валюты постоянно находится в крайней левой позиции. Если обозначение валюты следует после размера и символа разбиения, то оно ставится в конце выводимого числа.
знак Указывает формат отрицательных чисел. Если дефис в шаблоне стоит до размера и индикатора заполнения
, то отрицательные числа будут отображаться с минусом перед числом. Если минус в шаблоне стоит после размера, символа разбиения, индикаторов длины дробной части и валюты, то отрицательные числа будут отображаться с минусом после числа. Если в обеих возможных позициях знака в шаблоне стоят круглые скобки, то отрицательные числа будут отображаться в скобках.
заполнение Указывает заполнение позиций незначащих нулей пробелами, нулями или звездочками (*) и подавление по умолчанию символа разбиения. Если индикатор заполнения опущен, то незначащие нули подавляются (пробелами).
размер Размер требуется для того, чтобы указать общее число значащих цифр, включая число цифр в дробной части и любые символы форматирования.
символ разбиения Для того, чтобы указать разбиение по трем цифрам (по тысячам), справа от размера может помещаться символ разбиения отличный от запятой, которая используется по умолчанию.
. (точка) Разбивает группы точками
- (дефис) Разбивает группы дефисами
_ (знак подчеркивания) Разбивает группы пробелами
длина дробной части
Указывает количество цифр в дробной части и символ, разделяющий дробную и целую части числа. Число цифр в дробной части должно быть меньше чем длина, обозначенная в индикаторе размера. Разделителем целой и дробной части может быть точка (.), одинарная кавычка (‚) (разбивает на группы, если не указано другое) или буква “v”, используемая только в объявлении переменных типа STRING, но не в форматах отображения.
. (точка) указывает, что разделителем целой и дробной частей является точка.
‚ (одиночная кавычка) указывает, что разделителем целой и дробной частей является запятая.
v Указывает, что нет разделителя целой и дробной частей.
B
Указывает, что всякий раз, когда значение равно нулю, шаблон отображается пробельным.
Числовые и денежные шаблоны форматируют числовое значение для вывода на экран или в отчет. Если величина больше максимально возможной для данного шаблона, то выводится строка #.
Шаблон
Результат Формат
@N9 4,550,000 Девять цифр разбиваются на тысячи запятой (по умолчанию)
@N_9B 4550000 Девять цифр, на тысячи не разбиваются, пробелы если 0
@N09 004550000 Девять цифр, незначащие нули не подавляются
@N*9 ***45,000 Девять цифр, незначащие нули заменяются звездочками,
разбиваются по три цифры запятой. ГЛАВА
@N9_ 4 550 000 Девять цифр разбиваются на тысячи пробелом
@N9. 4.550.000 Девять цифр разбиваются на тысячи точкой
С дробной частью РезультатФормат
@N9.2 4,550.75 Две цифры дробной части отделяются точкой
@N_9.2B 4550.75 Две цифры дробной части отделяются точкой, по 3 разряда не группируются, пробелы, если значение равно 0.
@N_9'2 4550,75 Две цифры дробной части отделяются запятой
@N9.'2 4.550,75 Разделитель целой и дробной частей запятая, разбиение на
тысячи точкой
@N9_'2 4 550,75 Разделитель целой и дробной частей запятая, разбиение на тысячи
Пробелом
Со знаком РезультатФормат
@N-9.2B -2,347.25 Минус перед числом, пробелы если 0
@N9.2- 2,347.25- Минус после числа
@N(10.2) (2,347.25) Отрицательное значение в скобках
Валюта $ РезультатФормат
@N$9.2B $2,347.25 Знак доллара перед числом, пробелы если 0
@N$10.2- $2,347.25- Знак доллара перед числом, если отрицательное значение минус
после числа
@N$(11.2) $(2,347.25) Знак доллара перед числом, отрицательное значение в скобках
Другая валюта РезультатФормат
@N12_'2~ F~ 1 5430,50 F France
@N~L. ~12' L. 1.430.050 Italy
@N~Ј~12.2 Ј1,240.50 United Kingdom
@N~kr~12'2 kr1.430,50 Norway
@N~DM~12'2 DM1.430,50 Germany
@N12_'2~ mk~ 1 430,50 mk Finland
@N12'2~ kr~ 1.430,50 kr Sweden
Шаблоны хранения данных:
Variable1 STRING(@N_6v2) ! Объявить 6 байт для чисел без десятичной точки
CODE
Variable1 = 1234.56 ! Присвоить значение, кот. будет
! храниться в файле как 123456
MESSAGE(FORMAT(Variable1,@N_7.2)) ! Отобразить с десятичной точкой: '1234.56'
Определяет общее число символов в формате, получающемуся по данному шаблону.142 CLARION 4д ОПИСАНИЕ ЯЗЫКА
s
Задает символ десятичной точки и символ разбиения мантиссы на группы из трех цифр, когда значение n больше 3.
. (точка) точка и запятая
.. (точка точка) точка и точка
‘ (верхняя кавычка) запятая и точка
_.(подчеркивание точка) точка и пробел
n
Число цифр слева от десятичной точки.
B
Указывает, что всякий раз, когда значение равно нулю, шаблон отображается пробельным.
По шаблонам научной записи чисел форматируются очень маленькие или очень большие числа. Этот формат представляет собой десятичную смешанную дробь и степень десяти.
Строковый шаблон описывает неформатированную строку заданной длины
.
Пример:
Name STRING(@S20) ! Строковое поле длиной 20 символов
Шаблоны дат
@Dn
[s] [направление [диапазон] ] [B]
@D
Все шаблоны дат начинаются с @D.
n
Определяет номер формата даты. Существует 18 форматов представления дат. Ноль перед номером шаблона означает наличие незначащего нуля в числе или месяце.
s
Символ-разделитель между днем, месяцем и годом. По умолчанию в различных форматах представления дат между днем, месяцем и годом вставляется слеш (/). Альтернативные символы-разделители:
. (точка) в формате используется точка
‘ (верхняя кавычка) в формате используется запятая
- (дефис) в формате используется дефис
_ (знак подчеркивания) в формате используется пробел
направление Правая или левая угловая скобка (> или <), которая указывает направление для параметра диапазон (> означает будущее, < означает прошлое). Допустимо только в шаблонах дат с изображением года из двух цифр.
диапазон Целочисленная константа в диапазоне от 0 до 99, которая задает столетие для параметра направление. Допустимо только в шаблонах дат с изображением года из двух цифр. Если параметр опущен, то по умолчанию принимается 80.
B
Указывает, что всякий раз, когда значение равно нулю, шаблон отображается пробельным.
ГЛАВА
Даты могут храниться в числовых переменных (обычно LONG), переменных типа DATA (для совместимости с Btrieve) или в строковых переменных, объявленных с шаблоном даты. Даты, хранящиеся в числовых переменных, называются “стандартными датами Clarion”. Хранящееся значение представляет собой число дней прошедших с 28 декабря 1800 года.
Согласно шаблону, это число преобразуется в один из форматов даты. Для шаблонов с изображением года двумя цифрами преобразование дат осуществляется с привлечением “интеллектуальной логики”. Для шаблонов дат, в которых отсутствуют параметры направление и диапазон подразумевается, что даты находятся в диапазоне “80 лет назад - 20 лет вперед”. Этот диапазон по умолчанию можно изменить с помощью параметров направление и диапазон. Параметр направление указывает, изменяет ли параметр диапазон границу 100-летнего диапазона в прошлом или в будущем. А противоположная граница диапазона принимает соответствующее значение, такое при котором диапазон составлял бы 100 лет и для любого года, изображенного двумя цифрами не возникало неоднозначности при определении остальных двух цифр года.
Например, шаблон @D1>60 задает нахождение соответствующего столетия для любого года в диапазоне 60 лет вперед - 40 лет назад. Если текущий год 1996-й (т.о. диапазон 1956-2056 г.г), и пользователь ввел “5/01/40”, то правильный год 2040 (1940 не попадает в диапазон правильных дат), а если пользователь ввел “5/01/60”, то дата приходится на 1960-й год.
Для шаблонов даты, содержащих название месяцев, реальные названия задаются (настраиваются) в файле среды (.ENV). Для получения более полной информации смотри раздел Интернационализация.
Пример:
Шаблон
ФорматРезультат
@D1 mm/dd/yy 10/31/59
@D1>40 mm/dd/yy 10/31/59
@D01 mm/dd/yy 01/01/95
@D2 mm/dd/yyyy 10/31/1959
@D3 mmm dd,yyyy OCT 31,1959
@D4 mmmmmmmmm dd, yyyy October 31, 1959
@D5 dd/mm/yy 31/10/59
@D6 dd/mm/yyyy 31/10/1959
@D7 dd mmm yy 31 OCT 59
@D8 dd mmm yyyy 31 OCT 1959
@D9 yy/mm/dd 59/10/31
@D10 yyyy/mm/dd 1959/10/31
@D11 yymmdd 591031
@D12 yyyymmdd 19591031
@D13 mm/yy 10/59
@D14 mm/yyyy 10/1959
@D15 yy/mm 59/10
@D16 yyyy/mm 1959/10
@D17 Сокращенный формат даты, установленный в Windows
Определяет номер формата времени. Существует 8 форматов представления времени. Ноль перед номером шаблона означает наличие незначащего нуля в часах или минутах.
s
Символ-разделитель. По умолчанию в различных форматах представления времени между часами, минутами и секундами вставляется двоеточие (:). Альтернативные символы-разделители:
. (точка) в формате используется точка
‘ (верхняя кавычка) в формате используется запятая
- (дефис) в формате используется дефис
_ (знак подчеркивания) в формате используется пробел
B
Указывает, что всякий раз, когда значение равно нулю, шаблон отображается пробельным.
Время может храниться в числовых переменных (обычно LONG), переменных типа TIME (для совместимости с Btrieve) или в строковых переменных, объявленных с шаблоном времени. Время, хранящееся в числовых переменных, называются “стандартными временем”. Хранящееся значение представляет собой число сотых долей секунды, прошедших с полуночи. Согласно шаблону это число преобразуется в один из 6-ти форматов.
Для шаблонов времени, содержащих символьные данные, реальные названия задаются (настраиваются) в файле среды (.ENV). Для получения более полной информации смотри раздел Интернационализация.
Пример:
Шаблон
ФорматРезультат
@T1 hh:mm 17:30
@T2 hhmm 1730
@T3 hh:mmXM 5:30PM
@T03 hh:mmXM 05:30PM
@T4 hh:mm:ss 17:30:00
@T5 hhmmss 173000
@T6 hh:mm:ssXM 5:30:00PM
@T7 Сокращенный формат времени, установленный в Windows
@T8 Полный формат времени, установленный в Windows
Все пользовательские шаблоны начинаются с @P и заканчиваются разделителем P. Обе буквы P (латинские) должны быть либо прописные, либо строчные.
<
Задает десятичную цифру с подавлением незначащего нуля.
#
Задает десятичную цифру без подавления незначащего нуля.
x
Указывает необязательные символы для вывода в строке. Эти символы без изменений выводятся в отформатированной строке.
P
Все пользовательские шаблоны должны заканчиваться символом P. Он должен быть таким же, как в сочетании @P, начинающем шаблон.
B
Указывает, что всякий раз, когда значение равно нулю, шаблон отображается пробельным.
Пользовательский шаблон содержит необязательные позиции десятичных цифр и необязательные символы редактирования. Любые символы отличные от < и # рассматриваются как символы редактирования и попадают в форматированную строку без изменений. Регистр разделителей @P и P (строчная или прописная буква) различается. Таким образом, если для обоих ограничителей используется прописная “P”, то строчную “p” можно использовать как символ редактирования и наоборот.
Для того чтобы допустить использование точки в качестве символа редактирования, в шаблонах пользователя не распознается десятичная точка. Поэтому, значение, форматирующееся по шаблону пользователя должно быть целочисленным. Если по шаблону пользователя форматируется величина с плавающей точкой, то в результате будет отражена только целая часть числа.
Все шаблоны редактирования строк начинаются с @K и заканчиваются разделителем K. Обе буквы K (латинские) должны быть либо прописные, либо строчные.
@
Устанавливает, что в строке только строчные и прописные буквы.
#
Задает десятичную цифру от 0 до 9.
<
Задает десятичную цифру с подавлением незначащего нуля.
x
Указывает необязательные постоянные символы для вывода в строке (любые отображаемые символы). Эти символы без изменений выводятся в отформатированной строке.
\
Показывает, что следом идет символ для вывода в строке. Позволяет использовать символы форматирования (@, #, <, \, ?, ^, _,|) в качестве символов, включаемых в строку-результат.
?
Указывает, что в данной позиции может помещаться любой символ.
^
Указывает, что в данной позиции могут помещаться только прописные буквы.
_
Указывает, что в данной позиции могут помещаться только строчные буквы.
|
Позволяет при вводе данных пользователю “остановиться здесь”, если вводить в эту строку больше нечего. В отформатированную строку будут помещены только введенные данные и символы для вывода в строке, указанные до точки в шаблоне, отмеченной символом (|).
K
Все шаблоны редактирования строк должны заканчиваться символом K. Он должен быть таким же, как в сочетании @K, начинающем шаблон. Если был использован нижний регистр @k, заканчивающий символ k, также должен быть в нижнем регистре.
B
Указывает, что всякий раз, когда значение равно нулю, шаблон отображается пробельным.
Шаблоны редактирования строк могут содержать позиции десятичных цифр (# <), позиции букв (@ ^ _ ), позиции, в которых могут находиться любые символы (?) и символы для вывода в строке. Любой символ отличный от символов форматирования, рассматривается как символ для вывода в строке, который без изменений выводится в отформатированной строке. Регистр разделителей @K и K (строчная или прописная буква) различается. Таким образом, если для обоих ограничителей используется прописная “K”, то строчную “K” можно использовать как символ для вывода в строке и наоборот.
Шаблоны редактирования строк используются с полями типа STRING, PSTRING и CSTRING для того, чтобы обеспечить пользователю управление редактированием поля и проверку правильности данных. Использование шаблонов редактирования строк, содержащих любой из буквенных символов редактирования (@ ^), с числовым полем ввода приводит к непредсказуемым результатам.
Использование режима вставки при вводе в поле с таким шаблоном тоже могло бы привести к непредсказуемым результатам. Поэтому, даже если для поля указан атрибут INS, ввод данных в поле происходит в режиме замещения.
Знаете ли Вы, что конструкторы - это операции, которые используют в качестве аргументов объекты соответствующего им типа и создают другие объекты такого же типа. Например, операция сложения матриц создает новую матрицу.
