Руководство по Clipper 5.0 > 5 Функции часть 2

-------------------------------------------------------------------
IF() Обеспечивает условную обработку выражения
-------------------------------------------------------------------


[I]IF(<вырL>,<выр1>,<выр2>) -->значение


Аргументы

<вырL> - вычисляемое логическое выражение.

<выр1> - значение, возвращаемое если <вырL> "истинно" (.Т.).

<выр1> - значение, возвращаемое если <вырL> "ложно" (.F.).

В отличии от других языков выражения <выр1> и <выр2> могут иметь
разные типы значений.

Результаты

IF() возвращает значение, на которое укажет аргумент логического
выражения. Два возвращаемых аргумента могут быть любого типа данных.

Применение

IF() является одним из наиболее сильных функций Clipper. Она
обеспечивает механизм вычисления условия внутри выражения. С помощью
этой возможности вы можете преобразовывать выражения логического
типа в выражения любого другого типа.

214

Пример использования

Пример преобразования логического значения в число:

lPaid = .T.
? IF(lPaid, 1, 0) // Результат: 1

Пример вывода символа в зависимости от значения логической
переменной:

@ ROW(), IF(InHospital, 10, 12) SAY "X"


Library: CLIPPER.LIB.

-------------------------------------------------------------------
INDEXEXT() Возвращает "NTX" или "NDX", указывая тип текущего индекса
-------------------------------------------------------------------


INDEXEXT() -->вырС

Результаты

INDEXEXT() возвращает "NDX" во время использования индексов
совместимых с dBASE III PLUS и "NTX" для индексных файлов, созданных
Clipper.

Применение

INDEXEXT() возвращает расширение индексного файла.

Пример использования

Пример использования, INDEXEXT() для проверки создания индексного
файла:

USE Customer NEW
//
IF .NOT. FILE("Customer" + INDEXEXT())
INDEX ON CustName TO Customer
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
INDEXKEY() Возвращает индексное выражение для заданного индекса
-------------------------------------------------------------------


INDEXKEY(<вырN>) -->вырC

215

Аргументы

<вырN> порядковый номер индексного файла в списке индексных файлов,
открытых в команде USE...INDEX или SET INDEX TO для базы данных
текущей рабочей области. Нулевое значение указывает на используемый
в данный момент индексный файл.

Результаты

INDEXKEY() возвращает ключевое выражение указанного индексного
файла. Если нет индексных файлов на которые указывает аргумент, то
возвращается нулевая строка ("").

Применение

INDEXKEY() определяет выражение для ключа в текущей рабочей области.
Для определения ключевого выражения указывайте INDEXKEY() как
макровыражение следующим образом: &(INDEXKEY(<вырN>)).

По умолчанию, INDEXKEY() работает в текущей рабочей области. Для
работы с другой рабочей областью используйте алиасное выражение.

Пример использования

Пример получения индексных выражений в текущей рабочей области:

#define ORD_NATURAL 0
#define ORD_NAME 1
#define ORD_SERIAL 2
//
USE Customer INDEX Name, Serial NEW
SET ORDER TO ORD_SERIAL
? INDEXKEY(ORD_NAME) // Результат: Name index exp
? INDEXKEY(ORD_SERIAL) // Результат: Serial index exp
? INDEXKEY(ORD_NATURAL) // Результат: Serial index exp

Пример получения индексных выражений используя другую рабочую
область:

USE Customer INDEX Name, Serial NEW
USE Sales INDEX Salesman NEW
? INDEXKEY(0), Customer->(INDEXKEY(0))

Пример использования INDEXKEY() как часть в TOTAL ON:

USE Sales INDEX Salesman NEW
TOTAL ON &(INDEXKEY(0)) FIELDS SaleAmount TO SalesSummary

Пример демонстрирует использование INDEXKEY() для определения
обновления экрана DBEDIT():

#include "Dbedit.ch"


216

#define ORD_NATURAL 0
//
FUNCTION FieldEdit()
LOCAL indexVal
// Сохранить текущее значение ключа
indexVal = &(INDEXKEY(ORD_NATURAL))
.
. <изменеие значений GET>
.
// Обновление экрана если было изменено значение ключа
IF indexVal != &(INDEXKEY(ORD_NATURAL))
nRequest = DE_REFRESH
ELSE
nRequest = DE_CONT
ENDIF
RETURN nRequest

Library: CLIPPER.LIB.

-------------------------------------------------------------------
INDEXORD() Возвращает номер управляющего индекса
-------------------------------------------------------------------


INDEXORD() -->вырN

Результаты

Функция INDEXORD() возвращает порядковый номер индексного файла в
списке открываемый индексных файлов. Нулевое значение указывает на
отсутствие управляющего индекса и вы получаете доступ в файлу базы
данных в естественном порядке записей.

Применение

INDEXORD() полезна для запоминания номера индексного файла,
используемого последним, чтобы потом при необходимости восстановить
данный порядок файлов.

Пример использования

Этот пример использует INDEXORD() для сохранения текущего
порядкового номера. После изменения нового порядкового номера
восстанавливается старый:

USE Customer INDEX Name, Serial NEW
nOrder := INDEXORD() // Результат: 1
SET ORDER TO 2
? INDEXORD() // Результат: 2
SET ORDER TO nOrder
? INDEXORD() // Результат: 1

217

Пример использования алиасного выражения для управления в
других рабочих областях:

USE Sales INDEX Salesman, CustNum NEW
USE Customer INDEX Name, Serial NEW
? Sales->(INDEXORD()) // Результат: 1

Library: CLIPPER.LIB.

-------------------------------------------------------------------
INKEY() Считывает символ с клавиатуры
-------------------------------------------------------------------


INKEY(<вырN>) -->вырN

Аргументы

<вырN> - определяет количество секунд в течении которых функция ждет
ввода с клавиатуры. Нулевое значение приостанавливает программу,
пока не будет нажата любая клавиша. Помните, что время, которое ждет
функция INKEY() определяется по системным часам и, поэтому, не
зависит от скорости процессора.

Результат

Функция INKEY() выдает число в диапазоне от 39 до 386,
соответствующие коду ASCII нажатой клавиши (это же значение
возвращает функция LASTKEY()). При пустом буфере клавиатуры, функция
выдает значение 0.

Функция INKEY() возвращает значение для всех клавиш и всех
комбинаций типа: Alt, Ctrl, Alt-символ и Ctrl-символ.

Применение

INKEY() извлекает следующую нажатую клавишу из буфера клавиатуры.
Значение клавиши может быть сохранено и возвращено функцией
LASTKEY(). Если указан аргумент и в буфере нет нажатых клавиш,
программа выполняет паузу пока клавиша не нажата или не истекло
указанное в аргументе время. INKEY() используется для опроса
клавиатуры и приостановки выполнения программы.

Вы, например, можете использовать INKEY() в командах выводящих
несколько записей, таких, как LIST, LABEL FORM и REPORT FORM, для
прекращения данной команды, включая в фразу WHILE.

Чтобы сделать обработку клавиш более простой, создайте несколько
переменных памяти, соответствующих значениям клавиш с помощью
функции CHR(). Далее в программе, вы сможете сравнивать возвращаемое
значение функции INKEY() с соответствующей переменной памяти
выражением CHR(INKEY).


218


Пример использования

Пример вывода символа и его кода после нажатия клавиши:

#include "Inkey.ch"
//
LOCAL nInkeyCode := 0
DO WHILE LASTKEY() != K_ESC
? "Нажмите любую клавишу: "
nInkeyCode := INKEY(0)
?? "Символ:", CHR(nInkeyCode),;
"INKEY() code:", LTRIM(STR(nInkeyCode))
ENDDO
RETURN

Пример использования INKEY() для прерывания пользователем вывода
отчета при нажатии определенной клавиши:

#include "Inkey.ch"
//
USE Sales INDEX Salesman NEW
REPORT FORM Monthly FOR MONTH(SalesDate) = MONTH(DATE());
WHILE INKEY() != K_ESC

Library: CLIPPER.LIB; Файл заголовка: Inkey.ch.

-------------------------------------------------------------------
INT() Преобразует числовое выражение в целое
-------------------------------------------------------------------


INT(<вырN>) -->вырN

Аргументы

<вырN> числовое выражение для преобразования.

Результат

Функция INT() возвращает целое числовое значение.

Применение

INT() преобразует числовое значение в целое путем отсечения дробной
части числа. Функция полезна в тех случаях, где не нужна дробная
часть числа.

Пример использования

? INT(100.00) // Результат: 100
? INT(.5) // Результат: 0


219

? INT(-100.75) // Результат: -100

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ISALPHA() Проверяет принадлежность символа в буквам
-------------------------------------------------------------------


ISALPHA(<вырС>) -->вырL

Аргументы

<вырС> проверяемая символьная строка.

Результат

ISALPHA() возвращает значение "истинно" (.T.) если первый символ
строки <вырС> является буквенным символом. Буквенные символы состоят
из букв от A до Z в верхнем и нижнем регистре. Если строка
начинается с других символов, то возвращается значение "ложно"
(.F.).

Пример использования

? ISALPHA("AbcDe") // Результат: .T.
? ISALPHA("aBcDE") // Результат: .T.
? ISALPHA("1BCde") // Результат: .F.
? ISALPHA(".FRED") // Результат: .F.

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ISCOLOR() Определяет наличие графической карта на компьютере
-------------------------------------------------------------------


ISCOLOR() | ISCOLOUR() --> вырL

Результат

ISCOLOR() возвращает значение "истинно" (.T.) если имеется
графическая карта (графический адаптер).

Применение

Функция ISCOLOR() позволяет вам определить тип экрана (цветной или
монохромный) и принять решение, какие атрибуты использовать.
Помните, что некоторые монохромные адаптеры с графическими
возможностями возвращают значение (.T.).

Пример использования


220


Следующий пример настраивает переменные атрибутов цветов во время
выполнения программы:

IF ISCOLOR()
cBox = "BG+/B, W/N"
cSays = "BG/B, W/N"
cGets = "W/N, N/W"
ELSE
cBox = "W+"
cSays = "W/N, N+/W"
cGets = "W/N, N/W"
ENDIF
.
. <комманды>
.
SETCOLOR(cSays)

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ISDIGIT() Определяет являются ли левые символы в строке цифрами
-------------------------------------------------------------------


ISDIGIT(<вырС>) --> вырL

Аргументы

<вырС> символьная строка для проверки.

Результат

ISDIGIT() возвращает "истинно" (.T.) если первые символы в строке
цифры в диапазоне от 0 до 9; в противном случае - возвращает "ложно"
(.F.).

Применение

ISDIGIT() определяет являются ли левые символы указанной строки
цифрами. Используется когда вам необходимо знать, что текущая
символьная строка является числом перед преобразованием строки в
число с помощью функции VAL() function.

Пример использования

? ISDIGIT("AbcDe") // Результат: .F.
? ISDIGIT("1abcd") // Результат: .T.
? ISDIGIT(".12345") // Результат: .F.

Library: CLIPPER.LIB.

221

-------------------------------------------------------------------
ISLOWER() Выдает принадлежность левого символа строки нижнему регистру
-------------------------------------------------------------------


ISLOWER(<вырС>) -->вырL

Аргументы

<вырС> проверяемая символьная строка.

Результаты

ISLOWER() возвращает значение (.T.) если первый символ строки
<вырС> является символом нижнего регистра. Если строка начинается с
других символов, то возвращается значение (.F.).

Применение

ISLOWER() определяет является ли первый символ в строке символом
нижнего регистра. Является обратной функцией ISUPPER().

Пример использования

? ISLOWER("aBcDe") // Результат: .T.
? ISLOWER("AbcDe") // Результат: .F.
? ISLOWER("1abcd") // Результат: .F.
? ISLOWER("abcd") // Результат: .T.

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ISPRINTER() Определяет готовность порта LPT1
-------------------------------------------------------------------


ISPRINTER() -->вырL

Результаты

Функция возвращает значение "истинно" (.T.) если порт LPT1: готов к
работе, если нет - "ложно" (.F.).

Пример использования

LOCAL nCount := 0, nTimes := 25, lReady
//
DO WHILE nCount++ <= nTimes .AND. !(lReady := ISPRINTER())
ENDDO
//
IF lReady
REPORT FORM Sales TO PRINTER


222

ELSE
? "Принтер не готов..."
BREAK
ENDIF

Library: CLIPPER.LIB; Исходный текст: EXAMPLEA.ASM.

-------------------------------------------------------------------
ISUPPER() Выдает принадлежность левого символа строки верхнему регистру
-------------------------------------------------------------------


ISUPPER(<вырС>) -->вырL

Аргументы

<вырС> проверяемая символьная строка.

Результаты

ISUPPER() возвращает значение (.T.) если первый символ строки <вырС>
является символом верхнего регистра. Если строка начинается с других
символов, то возвращается значение (.F.).

Применение

ISUPPER() определяет является ли первый символ строки символом
верхнего регистра. Является обратной функции ISLOWER().

Пример использования

? ISUPPER("AbCdE") // Результат: .T.
? ISUPPER("aBCdE") // Результат: .F.
? ISUPPER("$abcd") // Результат: .F.
? ISUPPER("8ABCD") // Результат: .F.

Library: CLIPPER.LIB.

-------------------------------------------------------------------
I2BIN() Преобразует целое выражение в формат числа
-------------------------------------------------------------------


I2BIN(<вырN>) -->вырС

Аргументы

<вырN> - целое число для преобразования. Помните, что дробная часть
отбрасывается.

Результаты

223

I2BIN() возвращает двух байтовую символьную строку как 16 битовое
беззнаковое целое.

Применение

I2BIN() используется вместе с функцией FWRITE() для преобразования
числовых данных Клиппер в двух байтовую символьную строку.

Пример использования

Этот пример открывает файл базы данных низкоуровневыми функциями
ввода/вывода и записывает в него дату последней корректировки (байты
1-3).

#include "Fileio.ch"
//
nHandle = FOPEN("Sales.dbf", FO_READWRITE)
//
// Считаем дату последней корректировки
nYear = I2BIN(90)
nMonth = I2BIN(12)
nDay = I2BIN(15)
//
// Указатель на последнем обновленном данном.
FSEEK(nHandle, 1, FS_SET)
//
// Запись новых измененных данных, используя первый байт
FWRITE(nHandle, nYear, 1)
FWRITE(nHandle, nMonth, 1)
FWRITE(nHandle, nDay, 1)
FCLOSE(nHandle)

Library: CLIPPER.LIB; Исходный текст: EXAMPLEA.ASM.

-------------------------------------------------------------------
LASTKEY() Определяет какая клавиша была нажата последней
-------------------------------------------------------------------


LASTKEY() --> вырN

Результат

LASTKEY() возвращает целое число в диапазоне от -39 до 386,
соответствующие коду ASCII.


Применение

LASTKEY() выдает значение последний клавиши из буфера клавиатуры в
состоянии ожидания. Работает в командах и функциях ожидания ввода
таких, как ACCEPT, INPUT, MENU TO, MEMOEDIT(), READ и WAIT. В


224

интерфейсных функциях ACCHOICE(), DBEDIT() и INKEY(). Наиболее
полезна при определении кода клавиши, прервавшей команду READ. К
тому же, вы можете выполнить определенную пользователем функцию с
фразой VALID для обработки клавиши прекращения редактирования
текущего GET. На основе возвращаемого значения, вы можете принять
разные типы решения. Возможно использование LASTKEY() в ACHOICE(),
DBEDIT() или MEMOEDIT() в пользовательской функции для расширения
возможностей этих функций.

Пример использования

Пример обычного использования LASTKEY() для проверки выхода из
комманды READ. Если пользователь нажал клавишу, отличную от Esc и
значения Get были изменены, то файл обновляется :

#include "Inkey.ch"
//
USE Customer NEW
MEMVAR->balance = Customer->Balance
@ 10, 10 SAY "Current Balance" GET MEMVAR->balance
READ
//
IF (LASTKEY() != K_ESC) .AND. UPDATED()
REPLACE Customer->Balance WITH MEMVAR->balance
ENDIF

Library: CLIPPER.LIB; Файл заголовка: Inkey.ch.

-------------------------------------------------------------------
LASTREC() Определяет количество физических записей в базе данных
-------------------------------------------------------------------


LASTREC() | RECCOUNT() -->вырN

Результат

LASTREC() возвращает количество физических записей в в текущей базе
данных. Это значит, что команды SET FILTER и SET DELETED не влияют на
значение функции.

LASTREC() возвращает значение 0, если нет файлов баз данных,
определенных в команде USE в текущей рабочей области.

Применение

LASTREC() определяет количество физических записей в текущем файле
базы данных. LASTREC() идентична RECCOUNT(), которая заменяется как
совместимая функция. По умолчанию, LASTREC() выполняется в текущей
рабочей области. Для использования другой рабочей области применяйте
алиасное выражение.

225

Пример использования

Пример, показывающий связь функций LASTREC(), RECCOUNT(), и
COUNT:

USE Sales NEW
? LASTREC(), RECCOUNT() // Результат: 84 84
//
SET FILTER TO Salesman = "1001"
COUNT TO nRecords
? nRecords, LASTREC() // Результат: 14 84

Пример использования алиасного выражения:

USE Sales NEW
USE Customer NEW
? LASTREC(), Sales->(LASTREC())

Library: CLIPPER.LIB;

-------------------------------------------------------------------
LEFT() Выделяет символы из левой части символьной строки
-------------------------------------------------------------------


LEFT(<вырС>,<вырN>) -->вырС

Аргументы

<вырС> - символьная строка, из которой выделяются символы.

<вырN> - количество символов для выделения.

Результат

Функция LEFT() возвращает <вырN> самых левых символов строки <вырС>.
Если <вырN> отрицательное или равно нулю, то возвращается нулевая
строка (""). Если <вырN> превышает количество символов в строке, то
возвращается вся строка.

Применение

LEFT() выделяет символы из левой части символьной строки.

Пример использования

Пример извлечения первых трех символов слева:

? LEFT("ABCDEF", 3) // Результат: ABC

Пример извлечения подстроки до запятой:

226

LOCAL cName := "James, William"
? LEFT(cName, AT(",", cName) - 1) // Результат: James

Library: EXTEND.LIB.

-------------------------------------------------------------------
LEN() Выдает длину выражения или кол-во элементов массива
-------------------------------------------------------------------


LEN(<вырС> | <массив>) -->вырN

Аргументы

<вырС> - символьная строка, размер которой определяется.

<массив> - массив, количество элементов которого подсчитывается.

Результат

LEN() возвращает длину символьной строки или число элементов массива
в виде целого числа. Если символьная строка нулевая (""), то
возвращается 0.

Применение

LEN() возвращает длину символьной строки или число элементов массива.
Если массив вложенный, подмассив подсчитывается как один элемент.

Пример использования

Применение LEN() с различными аргументами:

? LEN("string of characters") // Результат: 20
? LEN("") // Результат: 0
? LEN(CHR(0)) // Результат: 1
//
LOCAL aTest[10]
? LEN(aTest) // Результат: 10

Пример создания вложенного массива и затем определение длины массива
и подмассива:

LOCAL aArray := { {1, 2}, {1, 2}, {1, 2} }
? LEN(aArray) // Результат: 3
? LEN(aArray[1]) // Результат: 2

Применение LEN() для передвижения в подмассивах:

LOCAL aArray := { {1, 2}, {1, 2}, {1, 2} }
LOCAL nRow, nColumn, nRowCount, nColumnCount
//


227

nRowCount = LEN(aArray)
FOR nRow = 1 TO nRowCount
nColumnCount = LEN(aArray[nRow])
FOR nColumn = 1 TO nColumnCount
? nRow, nColumn, aArray[nRow][nColumn]
NEXT
NEXT

Пример функции, возвращающей массив числовых значений, описывающих
вложенные массивы:

FUNCTION Dimensions( aArray )
LOCAL aDims := {}
DO WHILE ( VALTYPE(aArray) == "A" )
AADD( aDims, LEN(aArray) )
aArray := aArray[1]
ENDDO
RETURN (aDims)


Library: CLIPPER.LIB;

-------------------------------------------------------------------
LOG() Вычисляет натуральный логарифм арифметического выражения
-------------------------------------------------------------------


LOG(<вырN>) -->вырN

Аргументы

<вырN> - число больше 0, преобразуемое в натуральный логарифм.

Результат

LOG() возвращает натуральный логарифм числа как целое. Обращение к
функции с аргументом меньше или равно 0 выдает числовое переполнение
(строка звездочек).

Применение

Натуральный логарифм имеет основание "e" равное 2.7183. Функция LOG
возвращает "x" из следующего равенства:

e в степени x = y

где: y - указанное числовое выражение. В соответствии с
математическим округлением, значения, выдаваемые функциями LOG () и
EXP() могут строго не совпадать.

Функция LOG() обратная для EXP().

228

Пример использования

? LOG(10) // Результат: 2.30
? LOG(10 * 2) // Результат: 3.00
? EXP(LOG(1)) // Результат: 1.00
? LOG(2.71) // Результат: 1.00


-------------------------------------------------------------------
LOWER() Преобразует символы строки из верхнего в нижний регистр
-------------------------------------------------------------------


LOWER(<вырС>) -->вырС

Аргументы

<вырС> - символьное выражение, конвертируемое в нижний регистр.

Результат

Функция LOWER() возвращает в нижнем регистре все алфавитные символы
аргументов виде символьной строки. Остальные символы игнорируются.

Пример использования

? LOWER("STRING") // Результат: string
? LOWER("1234 CHARS = ") // Результат: 1234 chars =

Library: CLIPPER.LIB.

-------------------------------------------------------------------
LTRIM() Удаляет пробелы справа из указанной символьной строки
-------------------------------------------------------------------

LTRIM(<вырС>) -->вырС

Аргументы

<вырС> - символьная строка, которая будет преобразовываться.

Результат

LTRIM() возвращает копию указанной строки без лидирующих пробелов.
Если аргумент нулевая строка (""), результат тоже нулевая строка.

Применение

LTRIM() полезна для форматирования текста в символьной строке,
содержащей ведущие пробелы. Это может быть, например, числа
преобразованные в строки функцией STR().

229

Пример использования

nNumber = 18
? STR(nNumber) // Результат: 18
? LEN(STR(nNumber)) // Результат: 10
? LTRIM(STR(nNumber)) // Результат: 18
? LEN(LTRIM(STR(nNumber))) // Результат: 2

Library: CLIPPER.LIB.


-------------------------------------------------------------------
LUPDATE() Определяет время последней корректировки базы данных
-------------------------------------------------------------------


LUPDATE() -->вырD

Результат

LUPDATE() возвращает дату изменений текущей базы данных. Если база
данных не определена в USE, то возвращается пустая дата. Помните,
дата корректировки текущей база данных не будет изменена пока вы не
закроете ее командой CLOSE.

Применение

LUPDATE() определяет время последней корректировки базы данных.

Пример использования

Пример показывает, что дата обновления файла базы данных не
изменится дотех пор, пока файл не будет закрыт:

? DATE() // Результат: 09/01/90
USE Sales NEW
? LUPDATE() // Результат: 08/31/90
//
APPEND BLANK
? LUPDATE() // Результат: 08/31/90
CLOSE DATABASES
//
USE Sales NEW
? LUPDATE() // Результат: 09/01/90

Пример использования алиасного выражения для доступа к другой
рабочей области:

USE Sales NEW
USE Customer NEW
? LUPDATE(), Sales->(LUPDATE())

230

Library: EXTEND.LIB.

-------------------------------------------------------------------
L2BIN() Преобразует целое в 4-х байтовую символьную строку
-------------------------------------------------------------------


L2BIN(<вырN>) -->вырС

Аргументы

<вырN> - целое число для преобразования. Дробная часть
отбрасывается.

Результат

L2BIN() возвращает четырех байтовую строку в формате 32 разрядного
целого.

Применение

Применяется вместе с FWRITE() для преобразования числовых значений в
форму необходимую для записи в двоичном формате.

Пример использования

Пример создания файла и затем запись ряда чисел, используя L2BIN()
для их преобразования:

#include "Fileio.ch"
//
LOCAL nNumber, nHandle
nHandle := FCREATE("MyFile", FC_NORMAL)
FOR nNumber := 1 TO 100
FWRITE(nHandle, L2BIN(nNumber) + CHR(0))
NEXT
FCLOSE(nHandle)

Library: EXTEND.LIB; Исходный текст: EXAMPLEA.ASM.

-------------------------------------------------------------------
MAX() Определяет большее из двух чисел или выражений даты
-------------------------------------------------------------------


MAX(<выр1>,<выр2>) -->вырN
MAX(<выр1>,<выр2>) -->вырD

Аргументы

<выр1> - первое число или выражение даты для сравнения.

231

<выр2> - второе число или выражение даты для сравнения.

Помните, что оба аргумента должны быть одного типа.

Результат

MAX() всегда возвращает больший из двух аргументов. Возвращаемое
значение имеет тот же тип, что и аргументы. На результат не влияет
пустой или нулевой аргумент.

Применение

Функция полезна, когда вы хотите быть уверенным, что значение
выражения больше, чем определенный минимум.

Пример использования

Пример использования MAX() с числами:

? MAX(1, 2) // Результат: 2
? MAX(2, 1) // Результат: 2

Пример сравнения дат:

? DATE() // Результат: 09/01/90
? MAX(DATE(), DATE() + 30) // Результат: 10/01/90
? MAX(DATE(), CTOD("")) // Результат: 09/01/90

Library: CLIPPER.LIB.

-------------------------------------------------------------------
MAXCOL() Определение максимально видимой позиции колонки на экране
-------------------------------------------------------------------


MAXCOL() --> вырN

Результат

MAXCOL() возвращает максимальную видимую позицию колонки для экрана.

Применение

MAXCOL() используется для определения максимальной правой видимой
колонки на экране. Начальная позиция колонки и ряда в Clipper
устанавливается в 0.

Пример использования

Применение MAXROW() и MAXCOL() для определения области для
рисования рамки и затем выполнение внутри этой области DBEDIT() :

232

CLS
@ 0, 0 TO MAXROW(), MAXROW() DOUBLE
DBEDIT(1, 1, MAXROW() + 1, MAXCOL() - 1)

Library: CLIPPER.LIB.

-------------------------------------------------------------------
MAXROW() Определение максимальной видимой позиции ряда на экране
-------------------------------------------------------------------


MAXROW() --> вырN

Результат

MAXROW() возвращает максимальную верхнюю позицию ряда на экране.

Применение

MAXROW() используется для определения максимальной позиции ряда на
экране. Начальная позиция колонки и ряда в Клиппер устанавливается в 0.

Пример использования

Пример пользовательской функции ScreenSize(), использующей MAXROW()
и MAXCOL() для возврата массива, содержащего размер текущего экрана.

FUNCTION ScreenSize
RETURN { MAXROW(), MAXCOL() }

Library: CLIPPER.LIB.

-------------------------------------------------------------------
MEMOEDIT() Вывод и редактирование символьной строки и поля памяти
-------------------------------------------------------------------


MEMOEDIT(<вырС1>,
[<вырN1>], [<вырN2>],
[<вырN3>], [<вырN4>]
[<вырL1>],
[<вырС2>],
[<вырN5>],
[<вырN6>],
[<вырN7>],
[<вырN8>],
[<вырN9>],
[<вырN10>]) -->текст

Аргументы

<вырС> - символьная строка или поле памяти для редактирования.


233


<вырN1>,<вырN2>,<вырN3>,<вырN4> - определяют координаты окна
редактирования в следующем порядке : верхняя, левая, нижняя и
правая. Если они опущены, то используется весь экран.

<вырL1> - определяет, будет ли мемо редактироваться или просто
просматриваться. Если Вы укажете (.T.), то включается режим
редактирования. Если (.F.), то режим просмотра. По умолчанию
подставляется (.T.).

<вырС2> - имя функции пользователя, которая исполняется при нажатии
клавиши, не определенной в MEMOEDIT(). Имя функции указывается без
скобок и аргументов.

<вырN5> - определяет длину строки. Если <вырN5> больше чем ширина
окна (<вырN4>-<вырN2>-1), то производится горизонтальная прокрутка.
Длина по умолчанию = (<вырN4>-<вырN2>-1).

<вырN6> - определяет размер шага табуляции; по умолчанию = 4.

<вырN7> - строка мемо, в которую поместить курсор в начале работы.

<вырN8> - столбец, в который поместить курсор в начале работы.

<вырN9> - начальная строка, в которую поместить курсор относительно
окна; по умолчанию = 0.

<вырN10> - начальный столбец, в который поместить курсор
относительно окна; по умолчанию = 0.

Результат

MEMOEDIT() возвращает модифицированный текст, если работа закончена
нажатием Ctrl-W, или исходный - при нажатии Esc.

Применение

MEMOEDIT() - это универсальная функция редактирования текстов,
которую Вы можете использовать в Ваши FOR nRow = 1 TO nRowCountLibrary: CLIPPEbr /br / R.LIB.br /х программах для различных
целей. Она поддерживает различные режимы, вbr //pключает в себя
пользовательскую функцию, позволяющую переназначать клавиши и
программировать другие действия для текущей задачи редактирования.

Клавиши перемещения для MEMOEDIT().
-----------------------------------------------------
Клавиша Назначение
-----------------------------------------------------
Вверх или Ctrl-E Перемещение вверх на одну строку
Вниз или Ctrl-X Перемещение вниз на одну строку
Влево или Ctrl-S Перемещение на символ влево
Вправо или Ctrl-D Перемещение на символ вправо

234

Сtrl-влево,Ctrl-A Перемещение на слово влево
Сtrl-вправо,Ctrl-F Перемещение на слово вправо
Home Начало текущей строки
End Конец текущей строки
Ctrl-Home Начало поля
Ctrl-End Конец поля
PgUp Предыдущее окно редактирования
PgDn Следующее окно редактирования
Ctrl-PgUp Начало текущего окна редактирования
Ctrl-PgDn Конец текущего окна редактирования
------------------------------------------------------

Клавиши редактирования MEMOEDIT()
-----------------------------------------------------
Клавиша Назначение
-----------------------------------------------------
Ctrl-Y Удаление текущей строки
Ctrl-T Удаление слова справа
Ctrl-B Переформатирование поля памяти в окне
-----------------------------------------------------


Клавиши прекращения работы MEMOEDIT()
-----------------------------------------------------
Клавиша Назначение
-----------------------------------------------------
Ctrl-W Конец редактирования и запоминание
ESC Прекращение и возвращение оригинала
-----------------------------------------------------


CFE Режим редактирования/просмотра

MEMOEDIT() поддерживает два режима отображения в зависимости от
значения <вырL1>. Если оно истинно (.T.), MEMOEDIT() входит в режим
редактирования; в противном случае MEMOEDIT() входит в режим
просмотра. В режиме просмотра все клавиши передвижения активны и
выполняют те же действия, что и при редактировании, с одним
исключением. При редактировании прокрутка отключена и Стрелка_вверх
и Стрелка_вниз передвигают курсор вверх или вниз на одну строку.
При просмотре прокрутка включена и Стрелка_вверх и Стрелка_вниз
прокручивают содержимое окна вверх или вниз на одну строку.

Пользовательская функция

Когда MEMOEDIT() вызывает пользовательскую функцию, она автоматически
передает ей три параметра: "режим"(mode), "строка"(line) и
"столбец"(col.). "Режим" показывает текущее состояние MEMOEDIT(),
зависящее от последней нажатой клавиши или последнего действия
предпринятого перед выполнением пользовательской функции.

Возможные значения режимов MEMOEDIT()


235

----------------------------------------------------------------
Режим Memoedit.ch Описание
----------------------------------------------------------------
0 ME_IDLE Действия не требуются
1 ME_UNKEY Переназначаемая или неизвестная клавиша
(мемо не изменилось)
2 ME_UNKEYX Переназначаемая или неизвестная клавиша
(мемо изменилось)
3 ME_INT Стартовый режим
----------------------------------------------------------------

Режим 3 - стартовый. Если Вы указали свою функцию, то MEMOEDIT
вызывает ее сразу же после своего запуска. В этот момент Вы
возвращаете код, конфигурирующий различные режимы MEMOEDITа :
перенос строки, прокрутка или вставка. MEMOEDIT повторно вызывает
Вашу функцию, оставаясь в стартовом режиме, пока Вы не вернете 0
(RETURN 0). После этого высвечивается текст и Вы начинаете работу в
режиме, определяемом <вырL1>.

Режимы 0, 1 и 2 используются для отработки нажатий клавиш. Режим 0
вызывается когда не осталось введенных клавиш, требующих обработки.
В этом режиме Вы обычно обновляете индикацию строк и столбцов.
MEMOEDIT() вызывает пользовательскую функцию при нажатии
"исключительных" клавиш, к которым относятся все управляющие,
функциональные и Alt клавиши. Поскольку эти клавиши не
обрабатываются MEMOEDIT(), то в своей функции Вы можете их
переопределить.

Два других параметра - "строка" и "столбец" указывают текущую
позицию курсора внутри окна на момент вызова пользовательской
функции. Параметр "строка" начинается с позиции 1, а "столбец" с 0.
Если режим равен 1, 2 или 3 Вы можете вернуть значение,
инструктирующее MEMOEDIT() что делать дальше. Следующая таблица
перечисляет возможные возвращаемые значения :

Коды, возвращаемые пользовательской функцией
----------------------------------------------------------------
Значение Memoedit.ch Действие
----------------------------------------------------------------
0 ME_DEFAULT Выполнить действия по умолчанию
1 - 31 ME_UNKEY Выполнить действия, соответствующие нажатой
клавише
32 ME_IGNORE Игнорировать данную клавишу (disable)
33 ME_DATA Обработать данную клавишу как данные
34 ME_TOGGLEWRAP Переключить режим переноса строк
35 ME_TOGGLESCROLL Переключить режим прокрутки
100 ME_WORDRIGHT На следующее слово
101 ME_BOTTOMRIGHT В конец окна
----------------------------------------------------------------
Для того, чтобы легче запомнить режимы и их значения, используйте
файл заголовка Memoedit.ch, находящийся в CLIPPER5\INCLUDE.

236

Отметьте, что клавиши управления курсором, Return, Backspace, Tab,
Del, и все символьные клавиши переопределять нельзя.

Перенос строк

Перенос строк - это состояние, которое Вы переключаете возвращая из
своей функции. По умолчанию оно включено; при этом Клиппер вставляет
символы "мягкого" возврата каретки и перевода строки в разрыв между
словами, ближайший к границе окна либо к заказанной длине строки
(смотря что случится раньше). При выключенном режиме переноса текст
горизонтально прокручивается до достижения конца строки. В этой
точке Вы должны нажать Return (вставляя "жесткие" символы возврата
каретки и перевода строки) чтобы перейти на следующую строку.

Символы "мягкого" возврата каретки могут мешать выдаче на экран
командами ? и REPORT FORM или обработке этого текста другим
текстовым процессором. При необходимости заменить эти символы на
"жесткие" пользуйтесь функциями HARDCR() и MEMOTRAN().

Символы табуляции

Если Вы назначаете аргумент размера табуляции (<expN6>), MEMOEDIT()
вводит в текст символы аппаратной табуляции (09H), когда нажимается
клавиша Tab. Если аргумент размера табуляции не задан, то MEMOEDIT()
вводит символы пробела. Размер табуляции является глобальной
переменной для целого memo и задается <expN6). По умолчанию
принимается 4.

Заметим, что MEMOEDIT() не преобразует символы табуляции в пробелы,
если включена истинная табуляция.

Пример использования

Пример использования MEMOEDIT() для просмотра текста:

USE Customer NEW
SET CURSOR OFF
MEMOEDIT(CustNotes, 5, 10, 20, 69, .F.)
SET CURSOR ON

Пример редактирования текста с последующей заменой отредактированных
значений в файле базы:

USE Customer NEW
REPLACE CustNotes WITH MEMOEDIT(CustNotes, 5, 10, 20, 69)

Пример создания символьной строки:

LOCAL cNotes
cNotes = MEMOEDIT()

Пример использования пользовательской функции, которая редактирует


237

строку в окне, выводимом с заголовком:

FUNCTION EditMemo( cString, cTitle, nTop, nLeft, nBottom, nRight )
LOCAL cScreen := SAVESCREEN(nTop, nLeft, nBottom, nRight)
@ nTop - 1, nLeft - 2 CLEAR TO nBottom + 1, nRight + 2
@ nTop - 1, nLeft - 2 TO nBottom + 1, nRight + 2
@ nTop - 1, nLeft SAY "[" + cTitle + "]"
cString = MEMOEDIT(cString, nTop, nLeft, nBottom, nRight)
RESTSCREEN(nTop, nLeft, nBottom, nRight, cScreen)
RETURN (cString)

Пример чтения содержимого тестового файла в символьную переменную,
редактирование файла и затем запись на диск:

LOCAL cString := MEMOREAD("Text.txt")
cString := MEMOEDIT(cString)
IF !MEMOWRIT("Text.txt", cString)
? "Ошибка чтения"
BREAK
ENDIF
RETURN

Library: EXTEND.LIB; Файлы заголовков: Memoedit.ch и Inkey.ch.

-------------------------------------------------------------------
MEMOLINE() Выделение отформатированной строки текста из поля
-------------------------------------------------------------------


MEMOLINE(<вырС>,
[<вырN1>],
[<вырN2>],
[<вырN3>],
[<вырL>]) -->вырС

Аргументы

<вырС> - поле памяти или символьное выражение, из которого
происходит выделение.

<вырN1> - количество символов в строке.

<вырN2> - номер строки для выделения. По умолчанию - 1.

<вырN3> - размер табуляции. По умолчаниию - 4. Если <вырN3> больше
или равно <вырN1>, то размер табуляции устанавливается равный
<вырN1> - 1.

<вырL> - переключает режим переноса слов (word wrap). Значение (.T.)
включает перенос слов, а (.F.) - выключает. По умолчанию (.T.)

Результат


238


MEMOLINE() возвращает строку текста, указанную <вырN2> в <вырС> как
символьную строку. Если номер строки больше, чем общее число строк в
<вырС>, возвращается пустая строка ("").

Применение

Функция MEMOLINE() выделяет строку текста из символьной строки и
поля памяти, основываясь на количестве символов в строке. Если конец
строки разрывает слово, то это слово переносится на следующую
строку. Если строка имеет меньше символов, чем указано в ширине, то
строка дополняется пробелами. Если номер строки больше общего
количества строк в выражении, то MEMOLINE() возвращает нулевую
строку ("").

Пример использования

Пример показывает основной метод для вывода полей памяти и длинных
символьных строк, используя комбинацию MLCOUNT() и MEMOLINE():

LOCAL nLineLength := 40, nTabSize := 3, lWrap := .T.
LOCAL nLines, nCurrentLine
USE Customer INDEX CustName NEW
//
nLines := MLCOUNT(CustNotes, nLineLength, nTabSize, lWrap)
//
SET PRINTER ON
FOR nCurrentLine := 1 TO nLines
? MEMOLINE(CustNotes, nLineLength, nCurrentLine, nTabSize, lWrap)
NEXT
SET PRINTER OFF

Library: EXTEND.LIB.

-------------------------------------------------------------------
MEMOREAD() Чтение содержимого текстового файла с диска
-------------------------------------------------------------------


MEMOREAD(<вырС>) -->вырС

Аргументы

<вырС> - имя файла, который вы хотите считать. Помните, имя должно
включать расширение, если оно есть, и при необходимости маршрут
поиска.

Результат

MEMOREAD() возвращает содержимое текстового файла как символьную
строку. Максимальный размер файла, который может быть считан: 65 535
символов ( 64 Кб) - максимальный размер символьной переменной


239

памяти.

Применение

MEMOREAD() читает файл с диска в память, где он может быть
обрабатываться как символьная строка или присваиваться полю памяти.
MEMOREAD() используется в комбинации с MEMOEDIT() и MEMOWRIT() для
редактирования файла и затем записи на диск.

MEMOREAD() осуществляет поиск для файла, указанного в <вырС>,
начиная с текущего дирекотрия DOS. Если файл не найден, MEMOREAD()
ищет по пути DOS. MEMOREAD() не использует указание пути Clipper.

Пример использования

Следующий пример использует функцию MEMOREAD() для чтения
содержимого текстового файла в поле памяти и символьную переменную:

REPLACE Notes WITH MEMOREAD("Temp.txt")
cString = MEMOREAD("Temp.txt")

Определение функции редактирования файла:

FUNCTION Editor( cFile )
LOCAL cString
IF (cString := MEMOREAD(cFile)) == ""
? "Ошибка чтения " + cFile
RETURN .F.
ELSE
MEMOWRIT(cFile, MEMOEDIT(cString))
RETURN .T.
ENDIF

Library: EXTEND.LIB.

-------------------------------------------------------------------
MEMORY() Определяет количество доступной памяти
-------------------------------------------------------------------


MEMORY(<вырN>) -->вырN

Аргументы

<вырN> - числовое выражение, определяющее тип значений MEMORY() и
имеющие следующие значения:

Аргументы MEMORY()
______________________________________________________________________
Значение Действие
______________________________________________________________________
0 Выдает размер свободной области для символьных значений


240

1 Самое большое ограничение для блока, возможное для
символьных значений
2 Возможная область для комманд RUN
_______________________________________________________________________

Результат

MEMORY возвращает размер свободной области данных как целое число в
килобайтах.

Применение

MEMORY() - функция среды, которая выдает различные состояния
свободной области пула памяти.

Пример использования

Пример использования MEMORY() перед использованием комманды RUN для
определения достаточно ли памяти для выполнения внешней программы:

#define MEM_CHAR 0
#define MEM_BLOCK 1
#define MEM_RUN 2
//
IF MEMORY(MEM_RUN) >= 128
RUN MYPROG
ELSE
? "Недостаточно памяти для выполнения RUN"
BREAK
ENDIF

Library: CLIPPER.LIB.
-------------------------------------------------------------------
MEMOTRAN() Заменяет символы перевод каретки и перевод строки
-------------------------------------------------------------------


MEMOTRAN(<вырС1>,
[<вырс2>],
[<вырс3>]) -->вырС

Аргументы

<вырС1> - символьная строка или поле памяти, в которых будут
заменены "мягкие" или фактические переводы каретки.

<вырС2> - символ, на который нужно заменить пару символов перевода
каретки/перевода строки.

<вырС3> - символ, на который заменяется "мягкий" перевод каретки.

Результат


241


Если вы не укажете символ <вырС2> и <вырС3>, MEMOTRAN() заменит все
символы перевода каретки на точку с запятой, "мягкие" переводы
каретки на пробелы, а все переводы строки уберет.

Применение

По умолчанию замена в функции MEMOTRAN() соответствует требованиям
команды REPORT FORM.

Если вы используете MEMOTRAN() в команде REPORT FORM и больше
нигде необходимо компоновщику объявить, что MEMOTRAN() внешняя
(EXTERNAL).

Пример использования

Удалить все символы форматирования из поля памяти:

REPLACE Notes WITH MEMOTRAN(Notes, " ", " ")

Library: CLIPPER.LIB.

-------------------------------------------------------------------
MEMOWRIT() Запись символьной строки или поля памяти в файл на диск
-------------------------------------------------------------------


MEMOWRIT(<вырС1>,<вырС2>) -->вырL

Аргументы

<вырС1> - имя файла на диске, должно включать расширение и при
необходимости маршрут поиска.

<вырС2> - символьная строка или поле памяти, содержание которого
будет выводиться в файл.

Результат

Функция MEMOWRIT() возвращает значение "истинно" (.T.) при удачной
записи в файл; в противном случае - возвращает значение "ложно"
(.F.).

Применение

MEMOWRIT() в основном используется в комбинации с MEMOREAD() для
загрузки текстовых файлов в память, где они редактируются, выводятся
и записываются обратно. MEMOWRIT() может быть использована для
быстрой передачи поля памяти в текстовый файл.

Пример использования

242

Пример использования MEMOWRIT() в комбинации с MEMOREAD() для
редактирования полей памяти с помощью внешнего редактора:

LOCAL cEditor := "MYEDIT.EXE"
USE Sales NEW
IF MEMOWRIT("Cliptmp.txt", Notes)
RUN (cEditor + " Cliptmp.txt")
REPLACE Notes WITH MEMOREAD("Cliptmp.txt")
ELSE
? "Ошибка чтения Cliptmp.txt"
BREAK
ENDIF


-------------------------------------------------------------------
MEMVARBLOCK() Возвращает блок для переменной памяти
-------------------------------------------------------------------


MEMVARBLOCK(<вырС>) --> блок

Аргументы

<вырС> имя переменной для установки блока, который ссылается на
указанную символьную строку.

Результат

MEMVARBLOCK() возвращает блок, который устанавливает (назначает) или
получает (восстанавливает) значение из переменной памяти. Если
указанной переменной не существует, MEMVARBLOCK() возвращает NIL.

Применение

Блок, созданный MEMVARBLOCK() имеет две зависимости от аргумента,
посылаемого в блок, когда он вычисляется. Если вычисляется с
аргументом, он назначает значение аргумента <вырC>. Если вычисляется
без аргумента, блок восстанавливает значение из <вырС>.

Замечание

MEMVARBLOCK() создает блоки только для переменных, чьи имена
известны во время выполнения. MEMVARBLOCK(), поэтому, не может быть
использована для создания блоков для локальных переменных. В некото-
рых случаях для создания блоков используют макрооператор.

Пример использования

Применение MEMVARBLOCK() и макро-оператора (&) для создания блока.

PRIVATE var := "Это строка"
//


243

// Определение блока макро-оператором
bSetGet := &( "{ |setVal| IF( setVal == NIL, var, var := setVal ) }" )

// Определение блока, используя MEMVARBLOCK()
bSetGet := MEMVARBLOCK("var")

Library: CLIPPER.LIB.

-------------------------------------------------------------------
MIN() Определяет наименьшее из двух числовых или выражений даты
-------------------------------------------------------------------


MIN(<вырN1>,<вырN2>) --> вырN
MIN(<вырD1>,<вырD2>) --> вырD

Аргументы

<выр1> - первое число или выражение даты для сравнения.

<выр2> - второе число или выражение даты для сравнения.

Результат

MIN() всегда возвращает наименьшее из двух аргументов. Возвращаемое
значение имеет тот же тип, что и аргументы.

Применение

Функция полезна, когда вы хотите быть уверенным, что значение
выражения меньше, чем определенный максимум.

Пример использования

Пример сравнения чисел:

? MIN(99, 100) // Результат: 99
? MIN(100, 99) // Результат: 99

Пример сравнения дат:

? DATE() // Результат: 09/01/90
? MIN(DATE(), DATE() + 30) // Результат: 09/01/90


Library: CLIPPER.LIB.

-------------------------------------------------------------------
MLCOUNT() Подсчитывает количество строк в тексте или в поле памяти.
-------------------------------------------------------------------


244

MLCOUNT(<вырС>, [<вырN1>],
[<вырN2>], [<вырL>]) --> вырN

Аргументы

<вырС> - символьная переменная или поле памяти, в которых
подсчитываются строки.

<вырN1> - количество символов в строке.

<вырN2> определяет размер табуляции. Если не указан, по умолчанию
равен 4. Если <вырN2> больше или равно <вырN1>, то размер табуляции
автоматически преобразуется в <вырN1> -1.

<вырL> переключает режим переноса слов. Если указано значение
"истинно" (.T.) - перенос слов включен; если указано значение
"ложно" (.F.) - перенос слов выключен.

Результат

MLCOUNT() возвращает число строк в <вырC> как целое числовое
значение, которое зависит от указанных значений <вырN1>, <вырN2> и
от режима переноса слов.

Применение

Функция MLCOUNT() подсчитывает количество строк в символьной
переменной, основываясь на количестве символов в строке. Если конец
строки разрывает слово, то это слово переносится на следующую
строку.

Функция MLCOUNT() обычно используется с MEMOEDIT() при
форматирования поля памяти или длинной символьной строки для печати.
Ддя этого, сначала используйте функцию MLCOUNT() для определения
количества строк. Затем, в цикле по строкам выделите каждую строку
функцией MEMOLINE() из всего поля памяти, пока не исчерпаются все
строки.

Пример использования

Пример вывода содержимого поля памяти Notes в файле базы данных
Sales:

USE Sales NEW
nLineLength = 65
//
DO WHILE !EOF()
nLines = MLCOUNT(Sales->Notes, nLineLength)
FOR nCurrLine = 1 TO nLines
? MEMOLINE(Sales->Notes, nCurrLine, nLineLength)
NEXT
SKIP


245

?
ENDDO

Library: EXTEND.LIB.

-------------------------------------------------------------------
MLPOS() Определяет данную позицию номера строки в тексте
-------------------------------------------------------------------


MLPOS(<вырС>, <вырN1>, <вырN2>, [<вырN3>], [<вырL>]) --> вырN

Аргументы

<вырС> - символьная строка или поле памяти.

<вырN1> - количество символов в строке.

<вырN2> - номер строки.

<вырN3> определяет размер табуляции. Если не указан, по умолчанию
равен 4. Если <вырN2> больше или равно <вырN1>, то размер табуляции
автоматически преобразуется в <вырN1> -1.

<вырL> переключает режим переноса слов. Если указано значение
"истинно" (.T.) - перенос слов включен; если указано значение
"ложно" (.F.) - перенос слов выключен.

Результаты

MLPOS() возвращает позицию в строке <вырС> указанного номера строки.
Если <вырN2> больше количества строк в <вырС>, то функция возвращает
значение LEN(<вырС>).

Пример использования

Этот пример загружает текстовый файл с диска и затем ищет в нем
позицию пятой строки по 40 символов в строке:

cString = MEMOREAD("Temp.txt")
nLineLength = 40
nLine = 5
nPosition = MLPOS(cString, nLineLength, nLine)
? SUBSTR(cString, nPosition, 12)

Library: EXTEND.LIB.

-------------------------------------------------------------------
MOD()* Возвращает dBASE III PLUS модуль двух чисел
-------------------------------------------------------------------


246

MOD(<вырN1>, <вырN2>) --> вырN

Аргументы

<вырN1> делимое операции деления.

<вырN2> делитель операции деления.

Результат

MOD() возвращает число представляющее остаток от деления <вырN1> на
<вырN2>.

Применение

MOD() эмулирует функцию MOD() dBASE III PLUS. В Клиппер для
вычисления модуля используется оператор (%). Но существуют отличия
между функцией MOD() dBASE III PLUS и оператором модуля системы
Clipper, которые описаны в следующей таблице:

--------------------------------------------------------------------------
Делимое Делитель Модуль MOD() dBASE III PLUS
оператор функция MOD()
--------------------------------------------------------------------------
3 0 Ошибка Ошибка 3
3 -2 1 -1 -1
-3 2 -1 1 1
-3 0 Ошибка Ошибка -3
-1 3 -1 2 2
-2 3 -2 1 1
2 -3 2 -1 -1
1 -3 1 -2 -2
--------------------------------------------------------------------------

MOD() совместимая функция и поэтому не рекомендована. Она заменяется
оператором модуля (%).

Замечания

Деление на 0 в dBASE III PLUS: В dBASE III PLUS, при делении на 0
возвращается делимое. В Клиппер при делении на 0 возникает ошибка
выполнения.

Деление на 0 в ранних версиях: В версии Клиппер Summer '87 для
операции модуля при делении на 0 возвращался 0 для каждого делителя.
В последующих версиях в этом случае возникает ошибка выполнения.

Library: EXTEND.LIB; Исходный файл: Examplep.prg.
-------------------------------------------------------------------
MONTH() Преобразует дату в число соответствующее номеру месяца в году
-------------------------------------------------------------------

247


MONTH(<вырD>) -->вырN

Аргументы

<вырD> - дата, которая будет преобразовываться.

Результат

Функция MONTH() возвращает число в диапазоне от 1 до 12. Указание
нулевой даты возвращает 0.

Применение

Функция MONTH() полезна когда требуется числовое значение месяца во
время вычислений таких, как периодические отчеты.

Пример использования

Пример использования системной даты:

? DATE() // Результат: 09/01/90
? MONTH(DATE()) // Результат: 9
? MONTH(DATE()) + 1 // Результат: 10

Пример использования MONTH() с нулевой датой:

#define NULL_DATE (CTOD(""))
? MONTH(NULL_DATE) // Результат: 0

Library: CLIPPER.LIB.

-------------------------------------------------------------------
NETERR() Выдает ошибку возникающую при работе в сети
-------------------------------------------------------------------


NETERR() --> вырL

Результат

NETERR() возвращает значение "истинно" (.T.) если команда из следую-
щей таблицы закончились неудачно.

Причины возвращения функцией NETERR() значения "истинно".
-----------------------------------------------------
Команда Причины
-----------------------------------------------------
USE USE EXCLUSIVE в другой программе
USE...EXCLUSIVE USE EXCLUSIVE или USE в другой
программе

248

APPEND BLANK FLOCK или RLOCK() другим пользователем
-----------------------------------------------------

Применение

NETTER() является функцией сети. NETERR() в основном применяется в
программе для проверки комманд USE или APPEND BLANK. Если возвратила
значение "ложно" (.F.), вы можете выполнить следующую комманду.


Пример использования

USE Customer SHARED NEW
IF !NETERR()
SET INDEX TO CustNum, CustOrders, CustZip
ELSE
? "Файл используется другим пользователем"
BREAK
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
NETNAME() Определяет имя текущей рабочей станции
-------------------------------------------------------------------


NETNAME() --> вырС

Результат

NETNAME() возвращает имя рабочей станции в виде символьной строки
длинной 15 символов. Если имя станции не определено или программное
приложение функционирует не в среде сети IBM PC, то возвращается
нулевая строка.

Пример использования

? NETNAME() // Результат: ""


-------------------------------------------------------------------
NEXTKEY() Считывает следующее значение клавиши из буфера клавиатуры
-------------------------------------------------------------------


NEXTKEY() --> вырN

Результат

Функция NEXTKEY() выдает число в диапазоне от 39 до 386,
соответствующие коду ASCII нажатой клавиши. При пустом буфере


249

клавиатуры, функция выдает значение 0.

Применение

Функция NEXTKEY() не убирает клавишу из буфера клавиатуры. Вы можете
использовать ее для опроса клавиатуры и, потом, передавать
управление на программу читающую коды клавиш из буфера. Эти же коды
возвращают функции LASTKEY() и INKEY().

NEXTKEY() подобна INKEY(), но имеет отличие. INKEY() удаляет нажатую
клавишу из буфера клавиатуры и обновляет функцию LASTKEY() новым
значением. NEXTKEY() читает и не удаляет клавишу из буфера
клавиатуры и не обновляет LASTKEY().

Пример использования

Пример записи клавиши Esc в буфер клавиатуры и затем сравнение
комманд INKEY(), LASTKEY(), и NEXTKEY():

#include "Inkey.ch"
//
CLEAR TYPEAHEAD
KEYBOARD CHR(K_ESC)
//
? NEXTKEY(), LASTKEY() // Результат: 27 0
? INKEY(), LASTKEY() // Результат: 27 27
? NEXTKEY() // Результат: 0

Library: EXTEND.LIB; Файл заголовка: Inkey.ch.

-------------------------------------------------------------------
NOSNOW() Подавление снега
-------------------------------------------------------------------


NOSNOW(<вырL>) --> NIL

Аргументы

<вырL> - логическое значение, которое переключает состояние
подавления снега. Значение "истинно" подавляет снег, значение
"ложно" не подавляет снег.

Применение

NOSNOW() используется для подавления снега в CGA мониторах.

-------------------------------------------------------------------
OS() Возвращает имя операционной системы
-------------------------------------------------------------------


250

OS() --> вырС

Результат

OS() возвращает имя операционной системы как символьную строку

Применение

OS() - функция среды. OS() возвращает имя операционной системы.

Пример использования

? OS() // Результат: DOS 3.3

Library: CLIPPER.LIB.

-------------------------------------------------------------------
OUTERR() Запись списка значений на стандартное устройство ошибки
-------------------------------------------------------------------


OUTERR(<список выражений>) --> NIL

Аргументы

<список выражений> - список значений для вывода; может содержать
любую комбинацию типов данных, включая memo.

Результат

OUTERR() всегда возвращает NIL.

Применение

OUTERR() идентична OUTSTD() с той лишь разницей, что записывает на
стандартное устройство ошибки, а не на стандартное устройство
вывода. Обычно используется для регистрации сообщений об ошибках.

Пример использования

OUTERR("File lock failure", DATE(), TIME())

Library: CLIPPER.LIB.

-------------------------------------------------------------------
OUTSTD() Запись списка значений на стандартное устройство вывода
-------------------------------------------------------------------


OUTSTD(<список выражений>) --> NIL

Аргументы


251


<список выражений> - список значений для вывода; может содержать
комбинации любых типов данных, включая поле памяти (memo).

Результат

OUTSTD() всегда возвращает NIL.

Применение

OUTSTD() простейшая функция вывода и является подобной функции
QOUT(), отличаясь лишь тем, что она записывает на STDOUT устройство.
Файл заголовка Simplio.ch переопределяет комманды ? и ?? для исполь-
зования функции OUTSTD().

OUTSTD() направляет вывод на стандартное устройство вывода, вывод
может быть перенаправлен, используя символы управления DOS (>,>,|).

Пример использования

Следующий пример использует OUTSTD() для вывода списка выражений:

OUTSTD(Name, PADR(RTRIM(City) + "," + State, 20), ZipCode)

Пример показывает как перенаправить вывод программы Клиппер в новый
файл используя оператор DOS (>):

C>MYPROG > FILE.TXT

Library: CLIPPER.LIB; Файл заголовка: Simplio.ch.

-------------------------------------------------------------------
PAD() Заполняет символ, дату и число с символом заполнения
-------------------------------------------------------------------


PADL(<выр>, <вырN>, [<вырС1>]) --Функция MEMOWRIT() возвращает значение /p (.T.) - перенос слов включен; если указано значение> вырС
PADC(<выр>, <вырN>, [<вырС1>]) --> вырС
P 1 ME_UNKEY Переназначаемая или неизвестная клавиша если включена истинная табуляция. ENDIFbr /ADR(<выр>, <вырN>, [<вырС1>]) --> вырС

Аргументы

<выр> - символ, число или дата для заполнения с символом заполнения.

<вырN> - длина символьной строки для возврата.

<вырС1> - символ заполнения <выр>. Если не указан, по умолчанию
принимается пробел.

Результат

PADC(), PADL(), and PADR() возвращает <выр> как символ строки


252

заполненной <вырС1> с итоговой длиной равной <вырN>.

Применение

PADC(), PADL(), and PADR() заполняют символы, даты или числа
символами заполнения для создания новых символьных строк указанной
длины. PADC() центрирует <выр> внутри указанного значения <вырN>,
добавляя символы заполнения слева и справа; PADL() добавляет символы
заполнения с левой стороны; и PADR() добавляет символы заполнения с
правой стороны. Если длина <выр> превышает <вырN>, все функции PAD()
отбрасывают результирующую строку до значения <вырN>.

PADC(), PADL(), и PADR() используются для вывода строк переменной
длины внутри области фиксированной длины. Они могут использоваться
для обеспечения выравнивания последовательности комманд ??. Другое
использование - вывод текста фиксированной ширины с перезаписью
предыдущего текста.

Пример использования

Применение PADR() для форматирования номера записи в строке
статуса:

IF EOF()
@ 23, 45 PADR("EOF/" + LTRIM(STR(LASTREC())), 20)
ELSEIF BOF()
@ 23, 45 PADR("BOF/" + LTRIM(STR(LASTREC())), 20)
ELSE
@ 23, 45 SAY PADR("Record " + LTRIM(STR(RECNO()) + "/" + ;
LTRIM(STR(LASTREC())), 20)
ENDIF

Library: EXTEND.LIB.

-------------------------------------------------------------------
PCOL() Определяет текущую позицию печатающей головки принтера
-------------------------------------------------------------------


PCOL() --> вырN

Результат

PCOL() возвращает числовое значение, соответствующие последней
позиции колонки печатающей головки принтера плюс один. Начальное
значение позиции равно 0.

Применение

PCOL() выдает текущую позицию колонки печатающей головки принтера
после выполнения последней операции печати. PCOL() обновляется когда
выполняются установки SET DEVICE TO PRINTER или SET PRINTER ON.


253

PCOL() аналогична функции COL() с той лишь разницей, что COL()
работает с экраном. PCOL() обновляется в следующих случаях:

Начальная установка программой PCOL() в 0.

EJECT устанавливает PCOL() в 0.

Операция печати устанавливает PCOL() на последнюю позицию колонки
печатающей головки плюс один.

SETPRC() устанавливает PCOL() на указанную позицию.

PCOL() используется в комбинации с PROW() для печати позиции
печатающей головки. Это позволяет легче выравнивать колонки при
печати отчета. Значение печатается со следующей колонки с указанием
позиции PCOL() + <пропуск>. Но PCOL() эффективна при выводе колонок
фиксированной длины. Необходимо форматировать вывод, используя
TRANSFORM(), предложение PICTURE в комманде @...SAY, или функции
PAD().

Замечания

Управляющие коды принтера: Перед передачей управляющих кодов на
принтер сохраните текущие значения PCOL() и PROW(). Затем передайте
управляющие коды на принтер и восстановите позицию печатающей
головки с помощью SETPRC().

SET MARGIN: PCOL() не может быть использована в комбинации с SET
MARGIN для вывода с помощью комманд @...SAY. Когда печатается
@...SAY, значение текущего MARGIN всегда добавляется к указанной
колонке перед выводом на принтер.

Пример использования

Пример использования PCOL() для создания простейшего отчета, который
выводит на принтер список имен покупателей (Customer), адреса и
номера телефонов:

LOCAL nLine := 99, nPage := 1
USE Customer INDEX CustName NEW
SET DEVICE TO PRINTER
DO WHILE !EOF()
IF nLine > 55
PageTop(nPage)
nLine := 1
nPage++
ENDIF
@ nLine, 10 SAY CustName
@ nLine, PCOL() + 2;
SAY RTRIM(City) + ", " + RTRIM(State) + ZipCode;
PICTURE REPLICATE("X", 35)
@ nLine, PCOL() + 2;


254

SAY Phone;
PICTURE "@R (999) 999-9999"
nLine++
SKIP
ENDDO
SET DEVICE TO SCREEN
CLOSE

Library: CLIPPER.LIB.

-------------------------------------------------------------------
PCOUNT() Определяет количество переданных параметров процедуры
-------------------------------------------------------------------


PCOUNT() --> вырN

Результат

PCOUNT() возвращает количество переданных параметров. Если не один
параметр не передан, то PCOUNT() возвращает ноль. Помните, что
PCOUNT() сохраняет свое значение пока вы не попытаетесь передать
параметры в другую функцию или процедуру.

Применение

PCOUNT() выдает позицию последнего аргумента в списке передаваемых
аргументов когда процедура или пользовательская функция была
вызвана. Для определения получил ли параметр передаваемое значение,
проверьте его на NIL. Пропущенные параметры не инициализируются, и
поэтому, при обращении к ним возвращают NIL. Другой метод проверки
параметров - использование функции VALTYPE().

Пример использования

Пример пользовательской функции, которая открывает файл базы данных
и использует PCOUNT() для определения вызываемой процедуры,
передающей имя файла базы данных для открытия. Если имя не было
передано OpenFile() запрашивает имя:

FUNCTION OpenFile( cFile )
IF PCOUNT() = 0
ACCEPT "Файл для использования: " TO cFile
ENDIF
USE (cFile)
RETURN (NETERR())

Library: CLIPPER.LIB.

-------------------------------------------------------------------
PROCLINE() Возвращает номер строки текущей или предыдущей активации
-------------------------------------------------------------------


255

PROCLINE([<вырN1>]) --> вырN

Аргументы

<вырN1> - числовое значение, которое указывает какая активация
запроса. 0 указывает на текущую активацию, 1 ссылается на предыдущую
активацию и т. д. Если не указано - по умолчанию 0.

Результат

PROCLINE() возвращает номер строки последней выполненной строки в
текущей выполняемой процедуре, функции или блоке как целое число.
Если используется опция компилятора /L, PROCLINE() 0.

Применение

PROCLINE() запрашивает стэк активаций Клиппер для определения
последней строки, выполненной в текущей выполняемой процедуре. Стэк
активаций является внутренней структурой, который сохраняет запись о
вызове каждой процедуры, функции или блоке.

Для текущей активации, PROCLINE() возвращает номер текущей строки.
Для предыдущей активации, PROCLINE() возвращает номер строки, где
процедура или пользовательская функция была вызвана.

PROCLINE() используется в комбинации с PROCNAME() для вывода
отладочной информации.

Пример использования

Пример показывает номер строки, возвращаемый PROCLINE() для текущей
активации, затем номер строки предыдущей активации:

// Первая строка исходного файла
MyFunction()
RETURN

FUNCTION MyFunction
? PROCLINE() // Резкльтат: 6 (Текущая активация)
? PROCLINE(1) // Результат: 2 (Предыдущая активация)
RETURN NIL

Library: CLIPPER.LIB.

-------------------------------------------------------------------
PROCNAME() Возвращает имя процедуры или пользовательской функции
-------------------------------------------------------------------


PROCNAME([<вырN>]) --> вырС


256


Аргументы

<вырN> указывает какая активация запрашивается. 0 указывает на
текущую активацию, 1 ссылается на предыдущую активацию и т. д. Если
не указано - по умолчанию 0.

Результат

PROCNAME() возвращает имя текущей программы или процедуры, которая
выполняется в данный момент.

Применение

PROCNAME() запрашивает стэк активаций Клиппер для определения имени
текущей выполняемой процедуры, пользовательской функции или блока.
Стэк активаций является внутренней структурой, который сохраняет
запись о вызове каждой процедуры, функции или блоке.

Для текущей активации, PROCNAME() возвращает имя текущей процедуры
или пользовательской функции. Для предыдущей активации PROCNAME()
возвращает имя процедуры или пользовательской функции, которая
вызвала текущую процедуру.

PROCNAME() используется в комбинации с PROCLINE() для вывода
отладочной информации.

Пример использования

Пример пользовательской функции, которая может быть вызвана во время
отладки программы для вывода стэка активаций с номерами строк:

FUNCTION ListStack( cMessage )
LOCAL nActivation := 1
? cMessage
DO WHILE !(PROCNAME(nActivation) == "")
? "Вызвана из:", PROCNAME(nActivation),;
"(" + LTRIM(STR(PROCLINE(nActivation))) + ")"
nActivation++
ENDDO
QUIT
RETURN NIL

Library: CLIPPER.LIB.

-------------------------------------------------------------------
PROW() Возвращает номер текущей строки печати.
-------------------------------------------------------------------


PROW() -->вырN

257

Результат

PROW() возвращает номер текущей строки, посылаемой на принтер как
целое число.

Применение

PROW() выдает позицию строки печатающей головки после выполнения
последней операции печати. PROW() обновляется когда выполняются
установки SET DEVICE TO PRINTER или SET PRINTER ON. PROW()
аналогична функции ROW() с той лишь разницей, что ROW() работает с
экраном. PROW() обновляется в следующих случаях:

Начальная установка программой PROW() в 0.

EJECT устанавливает PROW() в 0.

Операция печати устанавливает PROW() на последнюю позцию колонки
печатающей головки плюс один.

SETPRC() устанавливает PROW() на указанную позицию.

PROW() используется в комбинации с PCOL() для вывода новой позиции
печатающей головки. Если печатающая головка позиционируется на новую
строку с управляющими кодами, значение PROW() не обновляется. В этом
случае необходимо установить PROW() с откорректированным значением с
помощью SETPRC() после передачи управляющих кодов на принтер.

Пример использования

Пример использования PROW() и SETPRC() для создания небольшой метки,
которая использует для вывода комманды @...SAY вместо ?:

USE Customer INDEX CustName NEW
SET DEVICE TO PRINTER
SETPRC(2, 0)
DO WHILE !EOF()
@ PROW(), 3 SAY CustName
@ PROW() + 1, 3 SAY RTRIM(City) + ", " + RTRIM(State) + ZipCode
@ PROW() + 1, 3 SAY Phone PICTURE "@R (999) 999-9999"
SETPRC(2, 0)
SKIP
ENDDO
SET DEVICE TO SCREEN
CLOSE

Library: CLIPPER.LIB.

-------------------------------------------------------------------
QOUT() Вывод списка выражений на консоль
-------------------------------------------------------------------

258


QOUT([<список выражений>]) --> NIL
QQOUT([<список выражений>]) --> NIL

Аргументы

<список выражений> список выражений, разделенный запятыми ( данные
любого типа кроме массив или блока) для вывода на консоль. Если
аргумент не указан и указан QOUT(), то каретка переводится на
следующую строку. Если QQOUT() выводится без аргументов, то ничего
не выводится.

Результат

QOUT() и QQOUT() всегда возвращает NIL.

Применение

QOUT() и QQOUT() - функции консоли. Они идентичны коммандам ? и ??
соответственно и используются для вывода результатов одного или более
выражений на консоль. QOUT() осуществляет вывод с переводом каретки
перед выводом результатов <список выражений>.

QQOUT() выводит результаты <список выражений> с текущей позиции
ROW() и COL(). Когда QOUT() и QQOUT() осуществляют вывод на консоль,
ROW() и COL() обновляют свои значения.

Если установлено SET PRINTER ON, то PROW() и PCOL() обновляют свои
значения. При выводе результатов выражений QOUT() и QQOUT() выводит
пробелы между результатами каждого выражения.

Пример использования

Пример вывода содержимого буквенного массива:

LOCAL aElements := { 1, 2, 3, 4, 5 }
AEVAL(aElements, { |element| QOUT(element) })

Library: CLIPPER.LIB.

-------------------------------------------------------------------
RAT() Осуществляет поиск последнего вхождения подстроки в строке
-------------------------------------------------------------------


RАT(<вырС1>,<вырС2>) -->вырN

Аргументы

<вырС1> - подстрока поиска.

<вырС2> - строка, в которой осуществляется поиск.


259


Результат

Если подстрока поиска находится в указанной строке, то функция RAT()
возвращает номер позиции, с которой начинается подстрока. Если
подстрока поиска в строке не находится, то возвращается 0.

Применение

Действие функции RAT() аналогично AT(), за исключением того, что
RAT() начинает поиск подстроки справа, пытаясь найти последнее
вхождение подстроки поиска.

Пример использования

Пример использования RAT() для создания пользовательской функции
FilePath(), которая извлекает путь из спецификации файла. Если нет
указания пути, FilePath() возвращает пустую строку (""):

? FilePath("C:\DBF\Sales.dbf") // Результат: C:\DBF\

FUNCTION FilePath( cFile )
LOCAL nPos, cFilePath
IF (nPos := RAT("\", cFile)) != 0
cFilePath = SUBSTR(cFile, 1, nPos)
ELSE
cFilePath = ""
ENDIF
RETURN cFilePath

Library: EXTEND.LIB.

-------------------------------------------------------------------
READEXIT() Переключает клавиши Uparrow и Dnarrow как окончание READ
-------------------------------------------------------------------


READEXIT([<вырL1>]) --> вырL

Аргументы

<вырL1> переключает использование клавиш Uparrow (стрелка вверх) и
Dnarrow (стрелка вниз) как клавиши окончания комманды READ. При
указании значения "истинно" (.T.) возможно использование этих клавиш
как клавиш выхода, и значение "ложно" (.F.) не позволяет их
использовать для окончания комманды READ.

Результат

READEXIT() возвращает текущее состояние установленного логического
значения.

260

Применение

READEXIT() выдает текущее состояние клавиш Uparrow и Dnarrow,
которые пользователь может нажать для окончания комманды READ из
первого или последнего Get объекта в списке Get. Если указано
<вырL1>, то клавиши Uparrow и Dnarrow имеют возможность или не имеют
возможности заканчивать комманду READ. При старте программы эти
клавиши не имеют такой возможности. Обычно клавишами выхода из
комманды READ являются только клавиши PgUp, PgDn, Esc, или Return в
последнем GET.

Пример использования


cMyvar = SPACE(10)
lLastExit = READEXIT(.T.) // Результат: Установка клавиши выхода
//
@ 10, 10 SAY "Введите: " GET cMyvar
READ
READEXIT(lLastExit) // Результат: Восстановление предыдущей установки

Library: CLIPPER.LIB.

-------------------------------------------------------------------
READINSERT() Переключает текущий режим вставки для READ и MEMOEDIT()
-------------------------------------------------------------------


READINSERT([<вырL1>]) --> вырL

Аргументы

<вырL1> переключает режим вставки. "Истинно" (.T.) обеспечивает
режим вставки, "ложно" (.F.) выключает режим вставки. По умолчанию
(.F.) или последний выбранный пользователем режим в READ или в
MEMOEDIT()

Результат

READINSERT() возвращает состояние текущего режима вставки как
логическое значение.

Применение

READINSERT() выдает текущее значение режима вставки для READ и
MEMOEDIT(), и может установить режим вставки в зависимости от
указанного значения <вырL>.

READINSERT() может быть выполнена раньше или во время выполнения
READ или MEMOEDIT(). Если выполняется внутри READ, READINSERT()
может быть вызвана внутри предложения WHEN или VALID комманды
@...GET или внутри процедуры SET KEY. Если выполняется в MEMOEDIT(),


261

READINSERT() может быть вызвана пользовательской функции или
процедурой SET KEY.

Пример использования

USE Sales NEW
lInsMode = READINSERT(.T.) // Установка режима вставки
Sales->Notes := MEMOEDIT(Sales->Notes)
READINSERT(lInsMode) // Восстановление предыдущего состояния

Library: CLIPPER.LIB.

-------------------------------------------------------------------
READKEY()* Определяет клавишу окончания комманды READ
-------------------------------------------------------------------


READKEY() --> вырN

Результат

READKEY() возвращает код клавиши, нажатой для окончания READ.
Следующие клавиши являются стандартными клавишами окончания комманды
READ в Клиппер со следующими кодами, возвращаемыми READKEY():

-----------------------------------------------------------------
Клавиша выхода Код
-----------------------------------------------------------------
Uparrow 5
Dnarrow 2
PgUp 6
PgDn 7
Ctrl-PgUp 31
Ctrl-PgDn 30
Esc 12
Ctrl-End, Ctrl-W 14
Return 15
-----------------------------------------------------------------

Применение

READKEY() эмулирует функцию READKEY() в dBASE III PLUS. Основная ее
цель - определить какая клавиша была нажата пользователем для выхода
из комманды READ. Если UPDATED() имеет значение "истинно" (.T.),
READKEY() возвращает код плюс 256. Клавиши Uparrow и Dnarrow
заканчивают READ только, если READEXIT() возвращает значение
"истинно" (.T.). По умолчанию установлено значение "ложно". Чтобы
обеспечить совместимость для этих клавиш, выполните READEXIT(.T.) в
начале вашей процедуры.

READKEY() используется как совместимая функция и поэтому ее
использование строго ограничено. Она заменяется функцией LASTKEY()


262

для определения последней клавиши из буфера клавиатуры.

Library: EXTEND.LIB.

-------------------------------------------------------------------
READMODAL() Активизирует полно-экранное редактирование для Get
-------------------------------------------------------------------


READMODAL(<массив>) --> NIL

Аргумент

<массив> массив, содержащий список объектов Get для редактирования.

Результат

READMODAL() всегда возвращает NIL.

Применение

READMODAL() обеспечивает режим полно-экранного редактирования для
GET и является частью архитектуры Клиппер 5.0. READMODAL() подобна
комманде READ, но использует массив GetList как аргумент и не
переинициилизирует массив когда функция заканчивает выполнение.

Для того, чтобы сохранить совместимость с предыдущими версиями
Clipper, система GET в Клиппер 5.0 обеспечивает использование гло-
бального массива GetList. Каждый раз, когда выполняется комманда
@... GET, Get объект создается и добавляется текущий видимый массив
GetList. Стандартная комманда READ обрабатывается пре-процессором в
вызове функции READMODAL() используя массив GetList как аргумент.
Если предложение SAVE не указано, переменной GetList назначается
пустой массив после окончания функции READMODAL().

Library: CLIPPER.LIB; Исходный текст: Getsys.prg.

-------------------------------------------------------------------
READVAR() Определяет имя текущей переменной для GET/MENU
-------------------------------------------------------------------


READVAR() -->вырС

Результат

Функция READVAR() возвращает имя переменной текущего GET или текущей
комманды MENU TO как символьную строку в верхнем регистре.

Применение

READVAR() используется для обеспечения помощи в Get и светящихся


263

меню. READVAR() работает только в коммандах READ или MENU TO. Если
используется в других коммандах как ACCEPT, INPUT, WAIT, ACHOICE(),
DBEDIT(), или MEMOEDIT(), возвращается пустая строка ("").
Допускается внутри процедуры SET KEY procedure или внутри
пользовательской функции, вызываемой из предложения WHEN или VALID в
Get.

Пример использования

Пример обеспечивает простейшую помощь для Get используя файл базы
данных для хранения текста помощи. Когда пользователь нажимает F1,
осуществляется поиск файла помощи с помощью READVAR() по анализу
клавиши и файл выводится в окне:

#include "Inkey.ch"
//
SET KEY K_F1 TO HelpLookup
cString = SPACE(10)
@ 5, 5 SAY "Введите:" GET cString
READ
RETURN

FUNCTION HelpLookup
USE Help INDEX Help NEW
SEEK READVAR()
IF FOUND()
DisplayHelp(Help->Topic)
ELSE
DisplayHelp("Нет подсказкм для " + READVAR())
ENDIF
CLOSE Help
RETURN NIL

FUNCTION DisplayHelp( cTopic )
LOCAL cScreen := SAVESCREEN(5,5,15,70), cColor := SETCOLOR("BG+/B")
//
SET CURSOR OFF
@ 5, 5 CLEAR TO 15, 70
@ 5, 5 TO 15, 70 DOUBLE
@ 5, 30 SAY " Подсказка для " + READVAR() + " "
MEMOEDIT(cTopic, 6, 7, 14, 68, .F.)
//
RESTSCREEN(5, 5, 15, 70, cScreen)
SETCOLOR(cColor)
SET CURSOR ON
//
RETURN NIL

Library: CLIPPER.LIB.

264

-------------------------------------------------------------------
RECCOUNT()* Определяет количество записей в текущей базе данных
-------------------------------------------------------------------


RECCOUNT()* | LASTREC() --> вырN

Результат

RECCOUNT() возвращает количество физических записей в в текущей базе
данных. Это значит, что команды SET FILTER и SET DELETED не влияют
на значение функции.

RECCOUNT() возвращает значение 0, если нет файлов баз данных,
определенных в команде USE в текущей рабочей области.

Применение

RECCOUNT() является функцией, аналогичной функции LASTREC(). По
умолчанию, RECCOUNT() выполняется в текущей рабочей области. Для
работы с другой невыбранной рабочей областью используйте алиасное
выражение.

Пример использования

Пример иллюстрирует связь между COUNT и RECCOUNT():

USE Sales NEW
? RECCOUNT() // Результат: 84
//
SET FILTER TO Salesman = "1001"
COUNT TO nRecords
? nRecords // Результат: 14
? RECCOUNT() // Результат: 84

Пример использования алиасного выражения:

USE Sales NEW
USE Customer NEW
? RECCOUNT(), Sales->(RECCOUNT())

Library: CLIPPER.LIB.

-------------------------------------------------------------------
RECNO() Определяет количество записей в текущей рабочей области
-------------------------------------------------------------------


RECNO() --> вырN

Результат

265

Если файл базы данных не содержит записей, то RECNO() возвращает
значение 1 и BOF() и EOF(), выдают значение "истинно" (.T.).

Если указатель записи установлен за последней записью файла
(использование команды SKIP для перехода через последнюю запись),
RECNO() возвращает значение равное LASTREC() + 1 и EOF() выдает
(.T.). Если сделана попытка установки указателя записи перед первой
записью, то RECNO() возвращает значение 1, а BOF() возвращает
"истинно" (.T.).

Применение

Функция полезна для определения номера записи в программе. По
умолчанию, функция выполняется в текущей рабочей области.

Пример использования

Пример запросов RECNO() после передвижения указателя записи:

USE Customers NEW
GO 3
? RECNO() // Результат: 3
GO TOP
? RECNO() // Результат: 1
nRecord := 3
GO nRecord
? RECNO() // Результат: 3
GO BOTTOM
SKIP
? RECNO(), LASTREC() // Результат: 11 10

Пример использования алиасного выражения:

USE Sales NEW
USE Customer NEW
//
? Sales->(RECNO())
? Customer->(RECNO())

Library: CLIPPER.LIB.

-------------------------------------------------------------------
RECSIZE() Определяет длину записи файла базы данных (.dbf)
-------------------------------------------------------------------


RECSIZE() --> вырN

Результат

RECSIZE() возвращает длину записи открытого файла базы данных в
текущей рабочей области в байтах . Если файл базы данных не открыт,


266

RECSIZE() возвращает 0.

Применение

RECSIZE() определяет длину записи путем суммирования длин полей,
включая поля со статусом на удаление DELETED().

RECSIZE() используется в программах для автоматического дублирования
файла. По умолчанию выполняется в текущей рабочей области. Для
работы с другой не выбранной рабочей областью, используйте алиасное
выражение.

Пример использования

Пример пользовательской функции DbfSize(), использующей RECSIZE()
для вычисления размера текущего файла базы данных:

FUNCTION DbfSize
RETURN ((RECSIZE() * LASTREC()) + HEADER())

Пример использования алиасного выражения:

USE Customer NEW
USE Sales NEW
//
? RECSIZE(), Customer->(RECSIZE())
? DbfSize(), Customer->(DbfSize())

Library: EXTEND.LIB.

-------------------------------------------------------------------
REPLICATE() Повторение символьной строки определенное количество раз
-------------------------------------------------------------------


REPLICATE(<вырС>,<вырN>) -->вырС

Аргументы

<вырС> - строка для повторения.

<вырN> - число повторений строки <вырС>.

Результат

Максимальный размер возвращаемой строки может быть 65 535 (64 Кб).
Указание 0 как количества повторений, возвращает нулевую строку.

Применение

REPLICATE() полезна там, где необходим повторяющийся вывод или
заполнение буфера клавиатуры одинаковыми символами.


267


Пример использования

Пример использования REPLICATE() для повторений:

? REPLICATE("*", 5) // Результат: *****
? REPLICATE("Hi ", 2) // Результат: Hi Hi
? REPLICATE(CHR(42), 5) // Результат: *****

Пример использования REPLICATE() для заполнения буфера клавиатуры
несколькими клавишами Dnarrow:

#include "Inkey.ch"
KEYBOARD REPLICATE(CHR(K_DN), 25)

Library: CLIPPER.LIB.

-------------------------------------------------------------------
RESTSCREEN() Выводит предварительно сохраненную часть экрана
-------------------------------------------------------------------


RESTSCREEN(<вырN1>, <вырN2>, <вырN3>, <вырN4>, <вырС>) --> NIL

Аргументы

<вырN1...вырN4> - координаты вывода окна на экран.

<вырС> - символьная строка содержащая данные окна.

Результаты

RESTSCREEN() всегда возвращает 0.

Применение

Функция применяется для перевывода части экрана, запомненного
функцией SAVESCREEN(). Размещение выводимого экрана может быть
другим или тем же. Если вы указываете новые координаты экрана, то
проверьте чтобы область вывода была достаточного размера.

Пример использования

Пример использования RESTSCREEN() в функции PopMenu():

? PopMenu({1, 1, 3, 10, {"ItemOne", "ItemTwo"}, "BG+/B"})

FUNCTION PopMenu( aList )
LOCAL cScreen, nChoice, cOldColor := SETCOLOR(aList[6])
cScreen := SAVESCREEN(aList[1], aList[2], aList[3], aList[4])
@ aList[1], aList[2], TO aList[3], aList[4] DOUBLE
nChoice := ACHOICE(++aList[1], ++aList[2],;


268

--aList[3], --aList[4], aList[5])
SETCOLOR(cOldColor)
RESTSCREEN(--aList[1], --aList[2], ++aList[3], ++aList[4], cScreen)
RETURN nChoice

Library: EXTEND.LIB.

-------------------------------------------------------------------
RIGHT() Выделяет символы с правого конца строки
-------------------------------------------------------------------


RIGHT(<вырС>,<вырN>) -->вырС

Аргументы

<вырС> - символьная строка из которой будут выделяться символы.

<вырN> - количество выделяемых символов.

Результат

Функция возвращает подстроку, как правую часть символьной строки
размера <вырN> символов. Если <вырN> отрицательно или 0, то
возвращается нулевая строка. Если <вырN> больше, чем длина строки,
RIGHT() возвращает <вырС>. Максимальный размер строки - 64,535
(64К).

Применение

RIGHT() извлекает подстроку, начиная с самых правых символов в
<вырС>. Это аналогично выражению, SUBSTR(<вырС>, -<вырN>). Например,
RIGHT("ABC", 1) аналогично SUBSTR("ABC", -1).

RIGHT(), LEFT(), и SUBSTR() функции часто используются в комбинации
с AT() и RAT() .

Пример использования

Пример связи между RIGHT() and SUBSTR():

? RIGHT("ABCDEF", 3) // Результат: DEF
? SUBSTR("ABCDEF", -3) // Результат: DEF

Пример извлечения подстроки с конца строки до запятой:

LOCAL cName := "James,William"
? RIGHT(cName,;
LEN(cName) - RAT(",", cName) - 1) // Результат: William

Library: CLIPPER.LIB.

269

-------------------------------------------------------------------
RLOCK() Блокирует текущую запись в текущей рабочей области.
-------------------------------------------------------------------


RLOCK() --> вырL

Результат

RLOCK() возвращает значение "истинно" (.T.) если вы успешно
заблокировали запись. В других случаях - "ложно" (.F.).

Применение

RLOCK() является функцией сети . RLOCK() блокирует текущую запись в
выбранной рабочей области. Она остается заблокированной пока не
будет выполнена блокировка другой записи или команды UNLOCK, CLOSE
DATABASE или FLOCK().

Пример использования

USE Sales SHARED NEW
USE Customer SHARED NEW
//
-------------------------------------------------------------------
Sales->(RLOCK())
-------------------------------------------------------------------

? "Текущая запись Sales используется другим"
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ROUND() Округление выражения до указанного количества цифр после запятой.
-------------------------------------------------------------------


ROUND(<вырN1>,<вырN2>) -->вырN

Аргументы

<вырN1> - выражение, которое будет округляться.

<вырN2> - количество цифр после запятой.

Результат

ROUND() округляет выражение <вырN1> до числа, с количеством цифр
после запятой в соответствии с <вырN2>. Определение нуля или
отрицательного <вырN2> позволяет округлять все число. Отрицательное
значение <вырN2> определяет количество цифр слева от запятой после


270

округления.

На вывод значения после округления не влияет команда SET DECIMALS,
если не указано SET FIXED ON. Вывод возвращаемого значения содержит
столько цифр, сколько вы укажете в выражении <вырN2> или нолgt;, все функции PAD() ь, если
<вырN2> меньше ноля.

Применение

Функция ROUND() полезна, когда вы хотитеp использовать числа с
точностью меньшей, чем они имеют.

Пример использования

Пример округления чисел :

SET DECIMALS TO 2

SET FIXED ON
//
? ROUND(10.4, 0) // Result: 10.00
? ROUND(10.5, 0) // Result: 11.00
? ROUND(10.51, 0) // Result: 11.00
? ROUND(10.49999999999999, 2) // Result: 10.50

Пример использования отрицательного аргумента <вырN2>:

? ROUND(101.99, -1) // Результат: 100.00
? ROUND(109.99, -1) // Результат: 110.00
? ROUND(109.99, -2) // Результат: 100.00

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ROW() Возвращает текущую позицию строки курсора на экране
-------------------------------------------------------------------


ROW() -->вырN

Результат

Возвращает число в диапазоне от 0 до 24, с нулем в первой строке
экрана. Когда вы очистите экран командой CLEAR, функция ROW()
возвращает значение 0. После окончания команды READ, ROW() выдает
число 23.

Применение

Функция ROW() полезна при использовании относительной адресации
позиции курсора.

271

Пример использования

Пример использования ROW() в комманде LIST :

LOCAL nRow
USE Customer INDEX CustName NEW
DO WHILE .NOT. EOF()
CLS
@ 1, 1 SAY PADR("Name", LEN(CustName))
@ ROW(), COL() + 2 SAY PADR("Address", LEN(Address))
@ ROW(), COL() + 2 SAY PADR("Phone", LEN(Phone))
nRow = 0
DO WHILE nRow++ <= 15 .AND. (!EOF())
@ ROW() + 1, 1 SAY CustName
@ ROW(), COL() + 2 SAY Address
@ ROW(), COL() + 2 SAY Phone
SKIP
ENDDO
WAIT
ENDDO
CLOSE Customer

Library: CLIPPER.LIB.

-------------------------------------------------------------------
RTRIM() Удаление пробелов из символьного выражения.
-------------------------------------------------------------------


[R]TRIM(<вырС>) -->вырС

Аргументы

<вырС> - строка, из которой удаляются ограничивающие пробелы.

Результат

RTRIM() возвращает копию строки <вырС> без лидирующих пробелов.

Применение

Функция RTRIM() полезна для удаления пробелов из строки перед
сцеплением ее с другой.

Пример использования

Пример пользовательской функции, которая использует RTRIM() для
форматирования полей при выводе:

FUNCTION CityState(cCity, cState, cZip)
RETURN RTRIM(cCity) + ", " + RTRIM(cState) + " " + cZip

272

Пример использования CityState() для вывода записи из Customer.dbf:

USE Customer INDEX CustName NEW
SEEK "Kate"
? CityState(City, State, ZipCode) // Результат: Athens, GA 10066

Library: CLIPPER.LIB.

-------------------------------------------------------------------
SAVESCREEN() Запоминает область экрана для дальнейшего вывода
-------------------------------------------------------------------


SAVESCREEN(<вырN1>, <вырN2>, <вырN3>, <вырN4>) --> вырС

Аргументы

<вырN1...вырN4> -коордионаты области экрана для запоминания.

Результат

SAVESCREEN() возвращает указанную область экрана как, символьную
строку.

Применение

Функция SAVESCREEN() используется для сохранения области экрана в
переменную памяти. Для восстановления части экрана используется
функция RESTSCREEN().

Обычно, вы будете использовать сохранение и восстановление области
экрана при обработки спускающегося меню или перемещения объекта на
экране.

Пример использования

Следующая определенная пользователем функция создает спускающееся
меню используя функцию ACHOICE() в комбинации с SAVESCREEN() и
RESTSCREEN(), возвращяющих выбор в массиве выбора.

FUNCTION PopMenu( nTop, nLeft, nBottom, nRight, aItems, cColor )
LOCAL cScreen, nChoice, cLastColor := SETCOLOR(cColor)
//
cScreen = SAVESCREEN(nTop, nLeft, nBottom, nRight)
@ nTop, nLeft TO nBottom, nRight DOUBLE
//
nChoice = ACHOICE(++nTop, ++nLeft, --nBottom, --nRight, aItems)
//
RESTSCREEN(--nTop, --nLeft, ++nBottom, ++nRight, cScreen)
SETCOLOR(cLastColor)
RETURN nChoice

273

Library: EXTEND.LIB.

-------------------------------------------------------------------
SCROLL() Производит сдвиг экрана вверх, вниз или очистку
-------------------------------------------------------------------


SCROLL(<вырN1>, <вырN2>, <вырN3>, <вырN4>, <вырN5>) --> NIL

Аргументы

<вырN1> - верх окна.

<вырN2> - левая граница окна.

<вырN3> - низ окна.

<вырN4> - правая граница окна.

<вырN5> - количество строк сдвига. Число больше ноля сдвигает окно
вверх на указанное число. Значение выражения больше ноля сдвигает
окно вниз, а ноль очищает окно.

Результат

SCROLL() всегда возвращает NIL.

Применение

Функция SCROLL() нужна для моделирования окон. Это полезно для
определения списка в какой то части экрана и перемещения его по
экрану куда удобнее пользователю.

Пример использования

Пример пользовательской функции, которая выводит сообщение в верхней
части экрана после перемещения на одну строку:

FUNCTION ScrollUp( nTop, nLeft, nBottom, nRight, expDisplay )
//
SCROLL(nTop, nLeft, nBottom, nRight, 1)
@ nBottom, nLeft SAY expDisplay
//
RETURN NIL

Library: EXTEND.LIB.

-------------------------------------------------------------------
SECONDS() Определяет количество прошедших с 12 часов дня секунд
-------------------------------------------------------------------


274

SECONDS() --> вырN

Результат

SECONDS() - возвращает системное время в формате "тысяч секунд".
Числовое значение соответствует количеству прошедших с полудня
секунд и основывается часах с двадцати четырех часовым циклом, от 0
до 86399.

Применение

На основе значений, возвращаемых функцией SECONDS(), можно измерять
промежутки времени в вашей программе.

Пример использования

Пример отличия значений функции TIME() от функции SECONDS():

? TIME() // Результат: 10:00:00
? SECONDS() // Результат: 36000.00

Library: CLIPPER.LIB.

-------------------------------------------------------------------
SELECT() Возвращает число, соответствующие текущей рабочей области
-------------------------------------------------------------------


SELECT([<алиас>]) --> вырN

Аргументы

<алиас> имя псевдонима рабочей области.

Результат

SELECT() возвращает номер рабочей области как цело число.

Применение

SELECT() возвращает номер рабочей области при указанном псевдониме
рабочей области. Если в текущей рабочей области не было команды USE,
то все равно SELECT() возвращает номер рабочей области.

Пример использования

USE Sales NEW
SELECT 1
? SELECT("Sales") // Результат: 4

275

-------------------------------------------------------------------
SET() Проверка или изменение глобальных установок
-------------------------------------------------------------------


SET(<вырN1>, [<вырN2>]) --> текущая установка

Аргументы

<вырN1> числовое значение, которое указывает проверяемую или
изменяемую установку. <вырN1> может быть заменено константой.

<вырN2> - необязательный параметр, который указывает новое значение
для указанной установки. Тип <вырN2> зависит от <вырN1>.

Результат

SET() возвращает текущее значение указанной установки.

Применение

SET() позволяет вам проверить или изменить значения глобальных
установок Clipper.

Установки проверяются или изменяются с помощью констант. Эти
константы определены в файле заголовка Set.ch. Этот файл заголовка
необходимо включать в начало программы при использовании SET().

Set.ch также определяет константу _SET_COUNT. Эта константа равна
числу установок, которые могут быть изменены или проверены с SET().

Если <вырN1> или <вырN2> неправильны, вызов функции SET()
игнорируется..

Значения, определенные в Set.ch
--------------------------------------------------------------------------
Константа Тип Соответствующая ей комманда или функция
--------------------------------------------------------------------------
_SET_EXACT Logical SET EXACT
_SET_FIXED Logical SET FIXED
_SET_DECIMALS Numeric SET DECIMALS
_SET_DATEFORMAT Character SET DATE
_SET_EPOCH Numeric SET EPOCH
_SET_PATH Character SET PATH
_SET_DEFAULT Character SET DEFAULT
_SET_EXCLUSIVE Logical SET EXCLUSIVE
_SET_SOFTSEEK Logical SET SOFTSEEK
_SET_UNIQUE Logical SET UNIQUE
_SET_DELETED Logical SET DELETED
_SET_CANCEL Logical SETCANCEL()
_SET_DEBUG Logical ALTD()
_SET_COLOR Character SETCOLOR()


276

_SET_CURSOR Numeric SETCURSOR()
_SET_CONSOLE Logical SET CONSOLE
_SET_ALTERNATE Logical SET ALTERNATE
_SET_ALTFILE Character SET ALTERNATE TO
_SET_DEVICE Character SET DEVICE
_SET_PRINTER Logical SET PRINTER
_SET_PRINTFILE Character SET PRINTER TO
_SET_MARGIN Numeric SET MARGIN
_SET_BELL Logical SET BELL
_SET_CONFIRM Logical SET CONFIRM
_SET_ESCAPE Logical SET ESCAPE
_SET_INSERT Logical READINSERT()
_SET_EXIT Logical READEXIT()
_SET_INTENSITY Logical SET INTENSITY
_SET_SCOREBOARD Logical SET SCOREBOARD
_SET_DELIMITERS Logical SET DELIMITERS
_SET_DELIMCHARS Character SET DELIMITERS TO
_SET_WRAP Logical SET WRAP
_SET_MESSAGE Numeric SET MESSAGE
_SET_MCENTER Logical SET MESSAGE
--------------------------------------------------------------------------

Пример использования

Пример пользовательской функции, которая сохраняет или
восстанавливает все глобальные установки:

#include "Set.ch"
//
FUNCTION SetAll( aNewSets )
LOCAL aCurrentSets[_SET_COUNT], nCurrent
IF ( aNewSets != NIL ) // Установить новые и возвратить текущие
FOR nCurrent := 1 TO _SET_COUNT
aCurrentSets[n] := SET(n, aNewSets[n])
NEXT
ELSE // Только возвратить текущие
FOR n := 1 TO _SET_COUNT
aCurrentSets[n] := SET(nCurrent)
NEXT
ENDIF
RETURN (aCurrentSets)

Library: CLIPPER.LIB; Файл заголовка: Set.ch.
-------------------------------------------------------------------
SETBLINK() Переключение мерцания (*) для SETCOLOR()
-------------------------------------------------------------------


SETBLINK([<вырL1>]) --> вырL

Аргументы

277

<вырL1> переключает возможность использования символа (*) для
мерцания в SETCOLOR(). При указании значения "истинно" (.T.)
вызывается мерцание, при указании значения "ложно" возвращается
прежняя интенсивность. По умолчанию устанавливается (.T.).

Результат

SETBLINK() возвращает текущую установку как логическое значение.

Применение

SETBLINK() переключает мерцание атрибутов и выдает текущее состояние
SETBLINK().

Пример использования

Пример сохранения текущего состояния SETBLINK() перед передачей
управления в пользовательскую функцию. После возврата, SETBLINK()
восстанавливает свое значение:

lOldBlink := SETBLINK()
MyFunc()
SETBLINK(lOldBlink)

Library: CLIPPER.LIB.

-------------------------------------------------------------------
SETCANCEL() Переключает использование Alt-C как окончание программы
-------------------------------------------------------------------


SETCANCEL([<вырL1>]) -->вырL


Аргументы

<вырL1> переключает возможность окончания программы. Если указано
значение (.T.), то включается возможность окончания, и (.F.) -
выключает такую возможность. По умолчанию установлено значение
(.T.).

Результат

Функция SETCANCEL() возвращает старое значение установки
переключателя или устанавливает новое значение, если указан аргумент
как логическое значение.

Применение


SETCANCEL() обслуживает две основные цели: переключение состояния
клавиши окончания <Alt-C> и определение состояния этой клавиши.


278


Замечание

SET KEY имеет более высокий над клавишей <Alt-C>, когда окончание
по этой клавише включено.

ПРЕДУПРЕЖДЕНИЕ: SETCANCEL() не останавливает выполнение других
загружаемых из Клиппер программ если в них не имеется своего
механизма прекращения выполнения.

Пример использования

Этот пример демонстрирует как создать подпрограмму выхода из
программы функцией SETCANCEL(), установленной в значение (.F.).

#define K_ALTC 302
//
SETCANCEL(.F.) // Отмена Alt-C
SET KEY K_ALTC TO AltC // Переопределение Alt-C
.
. <комманды>
.
RETURN

FUNCTION AltC
LOCAL cScreen, nChoice, cLastColor := SETCOLOR("W/B, N/G")
//
SAVE SCREEN TO cScreen
@ 6, 20 CLEAR TO 9, 58
@ 6, 20 TO 9, 58 DOUBLE
@ 7, 26 SAY "Alt-C: Вы желаете закончить?"
@ 8, 35 PROMPT " Yes "
@ 8, 41 PROMPT " No "
MENU TO nChoice
SETCOLOR(cLastColor)
RESTORE SCREEN FROM cScreen
//
IF nChoice = 1
QUIT
ENDIF
//
RETURN NIL

Library: CLIPPER.LIB.

-------------------------------------------------------------------
SETCOLOR() Определение текущей или предыдущей установки цветов
-------------------------------------------------------------------


SETCOLOR([<вырС1>]) --> вырС

279

Аргументы

<вырС> - символьная строка, содержащая список атрибутов для создания
текущего цвета.

Установки цвета
---------------------------------------------------------------------------
Установки Область действия
---------------------------------------------------------------------------
Стандартный Весь экран
Расширенный GETы и выбираемые светящиеся строки
Бордюр Бордюр вокруг экрана, не поддерживается на EGA и VGA
Фон Не поддерживается
Не выбранный Не выбранные GETы
---------------------------------------------------------------------------

Каждая установка является приоритетной и фоновой, разделенная
символом (/) и указывается через запятые. Все установки обязательны.

Результат

SETCOLOR() возвращает текущие установки цвета как символьную строку.

Применение

SETCOLOR() используется для сохранения текущих установок цвета и
установления новых. Строка установки цвета содержит несколько
атрибутов, которые соответствуют различным областям экрана.

В Clipper, существует несколько цветовых установок:

Стандартный: Стандартная установка, используемая всем экраном,
коммандами вывода, функциями при выводе на экран. Включают такие
комманды как @...PROMPT, @...SAY, and ?, и функции ACHOICE(),
DBEDIT(), и MEMOEDIT().

Расширенный: Расширенная установка используется для яркого
изображения. Включает GETы с INTENSITY ON, и MENU TO, DBEDIT(),
яркие выборы ACHOICE().

Бордюр: Бордюр - область вокруг экрана.

Фон: Фон не поддерживается.

Не выбранный: Не выбранные установки обеспечивают вывод текущего GET в
расширенном цвете, а вывод других GET - в не выбранном цвете.

Высокая интенсивность цвета обозначается символом "+". Для мерцания
используйте символ "*".

280

Поддерживаются следующие цвета:

----------------------------------------------------------------------
Цвет Буква Монохромный
----------------------------------------------------------------------
Черный N,Space Черный
Синий B Подчеркивание
Зеленый G Белый
Голубой BG Белый
Красный R Белый
Фиолетовый RB Белый
Коричневый GR Белый
Белый W Белый
Серый N+ Белый
Ярко синий B+ Яркое подчеркивание
Ярко зеленый G+ Ярко белый
Ярко голубой BG+ Ярко белый
Ярко красный R+ Ярко белый
Ярко фиолетовый RB+ Ярко белый
Желтый GR+ Ярко белый
Ярко белый W+ Ярко белый
Черный U Подчеркивание
Невидимый X Невидимый
----------------------------------------------------------------------

Замечание

В отличии от SET COLOR TO, функция SETCOLOR() без аргументов не
восстанавливает цвета в значения, используемые по умолчанию.

Заметьте, SETCOLOR() поддерживает только цвета указанные в символах,
а не в числах.

Пример использования

Пример назначения текущих установок цвета переменной cColor:

cColor = SETCOLOR()

Пример сохранения текущих установок и назначение новых:

cNewColor = "BR+/N, R+/N"
cOldColor = SETCOLOR(cNewColor)

Пример использования SET COLOR TO для возвращения цветов,
установленных по умолчанию:

SET COLOR TO
? SETCOLOR() // Результат: W/N, N/W, N, N, N/W


Пример использования SETCOLOR() в комбинации с ISCOLOR():


281


FUNCTION DefaultColors
IF ISCOLOR()
cForm := "W+/N, BG+/B,,,W/N"
cDialog := "N/N+, BG+/B,,,N/N+"
cAlert := "W+/R, BG+/B,,,W+/R"
ELSE
cForm := "W+/N, N/W,,,W/N"
cDialog := "W+/N, N/W,,,W/N"
cAlert := "W+/N, N/W,,,W/N"
ENDIF
RETURN NIL

Library: CLIPPER.LIB.

-------------------------------------------------------------------
SETCURSOR() Установка формы курсора
-------------------------------------------------------------------


SETCURSOR([<вырN1>]) --> вырN

Аргументы

<вырN1> - число, инициирующее форму курсора. Используйте файл
заголовка Setcurs.ch, который содержит возможные значения форм
курсора и представлены в следующей таблице:

----------------------------------------------------------------------
Форма Значение Setcur.ch
----------------------------------------------------------------------
Пусто 0 SC_NONE
Подчеркивание 1 SC_NORMAL
Нижняя половинка блока 2 SC_INSERT
Полный блок 3 SC_SPECIAL1
Верхняя половинка блока 4 SC_SPECIAL2
----------------------------------------------------------------------

Результат

SETCURSOR() возвращает форму текущего курсора как число.

Применение

SETCURSOR() управляет формой курсора экрана. Указанные формы
применяются на IBM-PC и совместимых компьютерах.

SETCURSOR(0) то же, что и SET CURSOR OFF, и SETCURSOR(1) то же, что и
SET CURSOR ON.

Пример использования

282


#include "Setcurs.ch"
//
USE Customer NEW
@ 10, 10 GET Customer->Name
@ 11, 10 GET Customer->Phone
//
SETCURSOR(SC_SPECIAL1) // Поменять курсор
READ
SETCURSOR(SC_NONE) // Выключить курсор

Library: CLIPPER.LIB; Файл заголовка : Setcurs.ch.

-------------------------------------------------------------------
SETKEY() Назначает блок клавише
-------------------------------------------------------------------


SETKEY(<вырN>, [<блок1>]) --> блок

Аргументы

<вырN> значение клавиши, возвращаемое INKEY() для назначения или
запроса.

<блок1> указывает блок, который выполняется автоматически при
нажатии указанной клавиши в момент состояния ожидания.

Результат

SETKEY() возвращает текущий блок, назначаемый указанной клавишей или
NIL, если указанная клавиша не назначает текущий блок.

Применение

SETKEY() используется для установки или запроса автоматических
действий, назначаемых клавишей в момент состояния ожидания.
Состояние ожидания возникает при выполнении ACHOICE(), DBEDIT(),
MEMOEDIT(), ACCEPT, INPUT, READ и WAIT. Можно назначить до 32 клавиш
одновременно. Но клавиша F1 назначается системой при старте программ
для выполнения процедур или пользовательских функций помощи,
называемых Help.

Когда назначенная клавиша нажимается в момент состояния ожидания,
<блок> передается PROCNAME(), PROCLINE(), и READVAR() как параметры
и используется функция EVAL().

SETKEY() подобна комманде SET KEY, которая связывает процедуру с
вызванной клавишей.

Пример использования

283

Фрагмент показывает как связать блок с клавишей и затем выполнить
его с функцией EVAL():

#include "Inkey.ch"
SETKEY(K_DN, {|cProc, nLine, cVar| MyProc(cProc, nLine, cVar)})
.
. <комманды>
.
DO WHILE .T.
nKey := INKEY(0)
DO CASE
CASE (bAction := SETKEY(nKey)) != NIL
EVAL(bAction, PROCNAME(), PROCLINE(), READVAR())
CASE nKey = K_PGUP
Previous()
CASE nKey = K_PGDN
Next()
CASE nKey = K_ESC
EXIT
ENDCASE
ENDDO

Library: CLIPPER.LIB; Файл заголовка: Inkey.ch.

-------------------------------------------------------------------
SETMODE() Изменяет режим вывода для указания числа ряда и колонок
-------------------------------------------------------------------


SETMODE(<вырN1>, <вырN2>) --> вырL

Аргументы

<вырN1> - число рядов, в требуемом режиме вывода.

<вырN2> - число колонок, в требуемом режиме вывода.

Результат

SETMODE() возвращает значение "истинно" (.T.), если изменение режима
прошло успешно; в противном случае - возвращается значение "ложно"
(.F.).

Применение

SETMODE() допускает изменение числа рядов и колонок при выводе.

Пример использования

Пример переключения вывода в режим на 43 строки:

IF SETMODE(43, 80)


284

? "43-строчный режим установлен"
ELSE
? "43-строчный режим не возможен"
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
SETPOS() Передвижение курсора на новую позицию
-------------------------------------------------------------------


SETPOS(<вырN1>, <вырN2>) --> NIL

Аргументы

<вырN1> и <вырN2> определяют новую позицию курсора. Эти значения
могут быть в диапазоне от 0 до MAXROW() и от 0 до MAXCOL().

Результат

SETPOS() всегда возвращает NIL.

Применение

SETPOS() передвигает курсор на новую позицию экрана. После
установления курсора обновляются значения функций, ROW() и COL().
Для управления формой и видимостью курсора используйте функцию
SETCURSOR().

Пример использования

Пример передвижения курсора на новую позицию и затем вывод строки с
помощью комманды ??:

SETPOS(1, 1)
?? "Привет!!!"

Library: CLIPPER.LIB.

-------------------------------------------------------------------
SETPRC() Установка значений для функций PROW() и PCOL()
-------------------------------------------------------------------


SETPRC(<вырN1>,<вырN2>) -->NIL

Аргументы

<вырN1> - новое значение позиции строки.

<вырN2> - новое значение позиции колонки.


285


Результат

SETPRC() всегда возвращает NIL.

Применение

Это может быть полезно для посылки на принтер строки символов
настройки без изменения позиции печатающей головки для программы. К
тому же, SETPRC() можно использовать для подавления перевода
страницы.

Пример использования

Пример пользовательской функции PrintCodes(),показывающий
использование SETPRC() для передачи управляющих кодов на принтер:

#include "Set.ch"
#define ITALICS_ON CHR(27) + "I"
#define ITALICS_OFF CHR(27) + "E"
//
SET DEVICE TO PRINTER
@ 12, 10 SAY "This is an"
@ PROW(), PCOL() + 2 SAY PrintCodes(ITALICS_ON) + "important"
@ PROW(), PCOL() + 2 SAY PrintCodes(ITALICS_OFF) + "meeting"
SET DEVICE TO SCREEN
RETURN

FUNCTION PrintCodes( cCtrlCode )
LOCAL nRow, nCol, lPrinter
lPrinter := SET(_SET_PRINTER, .T.) // SET PRINTER ON
nRow = PROW() // сохранение позиций
nCol = PCOL()
//
?? cCtrlCode // Послать коды
//
SETPRC(nRow, nCol)
SET(_SET_PRINTER, lPrinter) // Восстановить установки
RETURN "" // Возврат пустой строки ("")

Library: CLIPPER.LIB.

-------------------------------------------------------------------
SOUNDEX() Преобразование строки для поиска
-------------------------------------------------------------------


SOUNDEX([<вырС1>]) -->вырС

Аргументы

<вырС1> символьная строка для преобразования в фонетическую форму.


286


Результат

Возвращаемая строка имеет формат A9999.

Применение

Эта функция полезна для создания индексов и шаблонов поиска для
строк, для которых неизвестно фонетическая правильность
содержимого. Алгоритм функции SOUNDEX() основан на алгоритме
Дональда Кнута изложенный в: Кнут Дональд Е (1973) Сортировка и
поиск. Искусство программирования (том 3).

Пример использования

Пример построения индекса с помощью SOUNDEX() для создания ключа.
Затем осуществляется поиск значения.

USE Sales
INDEX ON SOUNDEX(Salesman) TO Salesman
SEEK SOUNDEX("Smith")
? FOUND(), Salesman // Результат: .T. Smith

Library : EXTEND.LIB; Исходный текст: EXAMPLEC.C.

-------------------------------------------------------------------
SPACE() Возвращает строку из пробелов
-------------------------------------------------------------------


SPACE(<вырN>) -->вырС

Аргументы

<вырN> - возвращаемое количество пробелов, максимум 65 535 (64Кб),

Результат

SPACE() возвращает символьную строку. SPACE(0) возвращает нулевую
строку.

Применение

Функция SPACE() применяется для создания строк и может быть
использована для нескольких различных целей: инициализация
переменных памяти для ввода данных, форматирование строки, для
создания функций, что помещают курсор не разрушая изображения на
экране.

Пример использования

Пример использования SPACE() для инициализации переменной :


287


USE Customer NEW
MEMVAR->Name = SPACE(LEN(Customer->Name))
@ 10,10 SAY "Customer Name" GET MEMVAR->Name
READ

Library: CLIPPER.LIB.

-------------------------------------------------------------------
SQRT() Возвращает квадратный корень арифметического выражения.
-------------------------------------------------------------------


SQRT(<вырN1>) -->вырN

Аргументы

<вырN1> - числовое выражение, из которого вычисляется корень. SQRT()
работает только с положительными числами.

Результат

SQRT() возвращает числовое значение, вычисленное с двойной точностью.
Число знаков после запятой определяется в зависимости от
установленного значения SET DECIMALS.

Применение

SQRT() применяется в математических операциях.

Пример использования

SET DECIMALS TO 5
//
? SQRT(2) // Результат: 1.41421
? SQRT(4) // Результат: 2.00000
? SQRT(4) ** 2 // Результат: 4.00000
? SQRT(2) ** 2 // Результат: 2.00000

Library: CLIPPER.LIB.

-------------------------------------------------------------------
STR() Преобразование арифметического выражения в символьную строку
-------------------------------------------------------------------


STR(<вырN1>, [<вырN2>], [<вырЧ3>]) -->вырС

Аргументы

<вырN1> - арифметическое выражение для преобразования.

288

<вырN2> - длинна строки возвращаемой функцией, включая десятичную
точку, десятичные знаки и знак минус.

<вырN3> - количество чисел после запятой для преобразуемой строки.

Результат

Если не указано общее количество чисел после запятой, то функция
возвращает строку из 10 символов, включая ведущие пробелы,
десятичную точку и дробную часть. STR() возвращает <вырN1>,
сформатировано как символьная строка. Если остальные аргументы
не указаны, STR() возвращает символьную строку в соответствии со
следующими правилами:

Результаты функции STR() без указания дополнительных аргументов
----------------------------------------------------------------------
Выражение Длина возвращаемого значения
----------------------------------------------------------------------
Переменная Поле Длина поля, включая десятичную точку
Выражения/константы Минимум 10 цифр с десятичной точкой
VAL() Минимум 3 цифры
MONTH()/DAY() 3 цифры
YEAR() 5 цифр
RECNO() 7 цифр
----------------------------------------------------------------------

Применение

STR() преобразует числовые значения в символьные строки. В основном
применяется для конкатенации числовых величин со строками. STR()
также применяется при выводе, создании индексов.

Замечания

Если <вырN2> меньше, чем размер всего числа в выражении <вырN1>, то
STR() возвращает строку из звездочек вместо цифр.

Если указан аргумент <вырN2> меньше количества цифр, требуемых для
дробной числа после запятой, то Клиппер округляет число до
допустимого количества десятичных знаков.

Если указан <вырN2>, а <вырN3> пропущен, то возвращаемое значение
округляется до целого.

Пример использования

Пример использования STR() с различными аргументами:

nNumber = 123.45
? STR(nNumber) // Результат: 123.45
? STR(nNumber, 4) // Результат: 123
? STR(nNumber, 2) // Результат: **


289

? STR(nNumber * 10, 7, 2) // Результат: 1234.50
? STR(nNumber * 10, 12, 4) // Результат: 1234.5000
? STR(nNumber, 10, 1) // Результат: 1234.5

Пример использования STR() для создания индекса:

USE Customer NEW
INDEX ON STR(NumOrders, 9) + CustName TO CustOrd

Library: CLIPPER.LIB.

-------------------------------------------------------------------
STRTRAN() Поиск и замена в символьной строке
-------------------------------------------------------------------


STRTRAN(<вырС1>, <вырС2>, [<вырС3>], [<вырN1>], [<вырN2>]) -->вырС

Аргументы

<вырС1> - строка в которой происходит замена.

<вырС2> - подстрока поиска.

<вырС3> - последовательность символов для замены. Если этот аргумент
не указан, то все найденные подстроки заменяются на нулевую
подстроку ("").

<вырN1> - номер вхождения для замены. По умолчанию - первое
вхождение.

<вырN2> - количество вхождений для замены. Если аргумент не указан,
то заменяются все вхождения.

Результат

STRTRAN() возвращает новую символьную строку.

Применение

STRTRAN() представляет стандартный поиск подстроки внутри символьной
строки. Когда соответствие найдено, то происходит замена найденной
подстроки на указанную подстроку замены. Все вхождения подстрок
поиска заменяются.

Помните, что STRTRAN() заменяет подстроки, а не полные слова. Режим,
устанавливаемый командой SET EXACT ON на порядок работы функции
STRTRAN() не влияет. Она всегда работает, как-будто установлен режим
SET EXACT ON.

Пример использования

290

String = "считать или не считать?"
? STRTRAN(cString, "считать", "быть") // Результат: быть или не быть?

Library: CLIPPER.LIB.

----------------------------------------------------- Yes --------------
STUFF() Умножение и замена символов в символьной строке
-----------------------------------------/p--------------------------


STUFF(<вырС1>, <вырN1>, &ltp /p;вырN2>, <вырС2>) --> вырС

Аргументы

<вырС1> - символьная строка - источник для замены в ней символов.

<вырN1> - начальная позиция в строке источнике с которой будет
замена.

<вырN2> - количество символов для замены в строке источнике
(<вырС1>).

<вырС2> - строка на которую осуществляется замена.

Результат

Функция STUFF() заменяет <вырN2> символов в строке источнике
(<вырС1>) начиная с позиции <вырN1> на подстроку <вырС2>.

Применение

Функция осуществляет шесть следующих операций:

Вставка: Если вы укажете ноль для аргумента <вырN2>, то строка
<вырС2> будет вставлена с позиции <вырN1> и эта новая строка будет
возвращена функцией.

Замена: Если вы укажете строку для замещения <вырС2> с длиной равной
<вырN2>, то функция сделает замену в строке <вырС2> начиная с
позиции <вырN1> в этой строке.

Удаление: Если строка для замещения (<вырС2>) будет нулевой строкой
(""), то количество символов, определенное аргументом <вырN2> будет
удалено из строки <вырС1>, и строка без этих символов будет
возвращена.

Замена и вставка: Если строка для замещения (<вырС2>) длиннее, чем
<вырN2>, все символы начиная с <вырN1> будут заменены, а остаток
замещаемой строки <вырС1> будет вставлен.

Замена и удаление: Если длина строки замещения (<вырС2>) меньше чем
<вырN2>, то все символы строки источника с конца <вырС2> до <вырN2>


291

будут удалены.

Замена и удаление остатка: Если <вырN2> больше длины строки <вырС1>,
строка для замещения <вырС2> будет вставлена в позиции <вырN1> и
остаток строки <вырС2> будет удален.

Пример использования
// Вставка
? STUFF("ABCDEF", 2, 0, "xyz") // Результат: AxyzBCDEF

// Замена
? STUFF("ABCDEF", 2, 3, "xyz") // Результат: AxyzEF

// Удаление
? STUFF("ABCDEF", 2, 2, "") // Результат: ADEF

// Замена и вставка
? STUFF("ABCDEF", 2, 1, "xyz") // Результат: AxyzCDEF

// Замена и удаление
? STUFF("ABCDEF", 2, 4, "xyz") // Результат: AxyzF

// Замена и удаление остатка
? STUFF("ABCDEF", 2, 10, "xyz") // Результат: Axyz

Library: EXTEND.LIB; Исходный текст: EXAMPLEC.C.

-------------------------------------------------------------------
SUBSTR() Возвращает часть символьной строки
-------------------------------------------------------------------


SUBSTR(<вырС>,<вырN1>[,<вырN2>]) -->вырС

Аргументы

<вырС> - строка источник. Максимальна подстрока, из которой вы
можете извлечь подстроку, может иметь размер 65535 символов (64 Кб).

<вырN1>- начальная позиция в строке источнике, с которой будет
выделяться подстрока. Если начальная позиция положительна, то она
указывает на начало подстроки с левой стороны строки источника.
Отрицательное значение стартовой позиции соответствует выделению
подстроки начиная с правой стороны строки.

<вырN2> - количество возвращаемых символов. Если этот аргумент
опущен, то возвращается подстрока начиная со стартовой позиции и до
конца строки источника. Если размер указан больше существующих
символов, то аргумент игнорируется.

Результат

292

SUBSTR() возвращает символьную строку.

Применение

Функция SUBSTR() полезна, когда вы хотите вывести часть строки.

Пример использования

Пример извлечения имени и фамилии из переменной:

cName = "Biff Styvesent"
? SUBSTR(cName, 1, 4) // Результат: Biff
? SUBSTR(cName, 6) // Результат: Styvesent
? SUBSTR(cName, LEN(cName) + 2) // Результат: пустая строка
? SUBSTR(cName, -9) // Результат: Styvesent
? SUBSTR(cName, -9, 3) // Результат: Sty

Пример использования SUBSTR() в комбинации с AT() и RAT() для
создания пользовательской функции извлечения имени файла из
спецификации файла:

? FileBase("C:\PRG\MYFILE.OBJ") // Результат: MYFILE.OBJ

FUNCTION FileBase( cFile )
LOCAL nPos
IF (nPos := RAT("\", cFile)) != 0
RETURN SUBSTR(cFile, nPos + 1)
ELSEIF (nPos := AT(":", cFile)) != 0
RETURN SUBSTR(cFile, nPos + 1)
ELSE
RETURN cFile
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
TIME() Возвращает системное время
-------------------------------------------------------------------


TIME() -->вырС

Возвращает

TIME() возвращает системное время как символьную строку в формате
"чч:мм:сс", где "чч" это часы, "мм" - минуты а "сс" - секунды. Часы,
минуты и секунды разделены двоеточием.

Применение

TIME() полезна, когда вы хотите включать время в отчеты или выводить
на экран.


293


Пример использования

? TIME() // Результат: 10:37:17
? SUBSTR(TIME, 1, 2) // Результат: 10
? SUBSTR(TIME, 4, 2) // Результат: 37
? SUBSTR(TIME, 7, 2) // Результат: 17

Library: CLIPPER.LIB.

-------------------------------------------------------------------
TONE() Вывод звука указанной продолжительности и частоты
-------------------------------------------------------------------


TONE(<вырN1>, <вырN2>) --> NIL

Аргументы

<вырN1> - частота звука.

<вырN2> - длительность звучания, измеренная в 1/18 частях секунды.
Одна секунда, поэтому, равна 18.

Результат

TONE() всегда возвращает NIL.

Применение

Функция TONE() генерирует звук указанной частоты и длительности.
Длительность измеряется в 1/18 частях секунды. Частота измеряется в
герцах (количество колебаний в секунду) Частота меньше 20
невозможна. Ниже приводится частота стандартных музыкальных нот:

Частота музыкальных нот.
----------------------------------------------------
Обозначение Частота Обозначение Частота
----------------------------------------------------
C 130.80 mid C 261.70
C# 138.60 C# 277.20
D 146.80 D 293.70
D# 155.60 D# 311.10
E 164.80 E 329.60
F 174.60 F 349.20
F# 185.00 F# 370.00
G 196.00 G 392.00
G# 207.70 G# 415.30
A 220.00 A 440.00
A# 233.10 A# 466.20
B 246.90 B 523.30
----------------------------------------------------


294


-----------------------------------------------------------------------
ВНИМАНИЕ

TONE() работает только на IBM-PC или на 100% совместимых компьютерах.
-----------------------------------------------------------------------

Пример использования

Следующие примеры показывают функции создания сигнала:

FUNCTION DoneBeep
TONE(300, 1)
TONE(100, 1)
TONE(300, 1)
TONE(100, 1)
RETURN NIL

Этой функцией можно указывать на неверное нажатие клавиши:

FUNCTION ErrorBeep
TONE(100, 3)
RETURN NIL

Library: EXTEND.LIB; Исходный текст: EXAMPLEA.ASM.

-------------------------------------------------------------------
TRANSFORM() Преобразует результат выражения в указанный формат данных
-------------------------------------------------------------------


TRANSFORM(<выр>,<вырС1>) -->вырС

Аргументы

<выр> - выражение, которое будет форматироваться.

<вырС1> - определяет формат возвращаемой символьной строки.

Результат

TRANSFORM() принимает на входе любое выражение и вычисляет его,
затем, преобразует его в символьную строку по шаблону, задаваемому
аргументом <вырС>. Помните, так как функция TRANSFORM() выдает
символьную строку, то она не решает проблем форматирования итоговых
полей в команде REPORT FORM.

Применение

Функция TRANSFORM() позволяет вам форматировать символы, даты или
числовые выражения таким же образом, как в команде @...PICTURE,
преобразуя символьную строку, соответствующую указанному формату.


295

Ниже приводится полный список элементов, задающих формат.
Обращайтесь к описанию команды @...PICTURE для полной информации о
том, как работает форматирование и шаблоны формата.

Функции шаблонов формата.
---------------------------------------------------
Шаблон Действие
---------------------------------------------------
B Выводит выровненное влево число
C Выводит перевод каретки после положительного
числа
D Выводит дату в формате команды SET DATE
E Выводит дату в английском формате
R Вставляется не шаблонный символ
X Выводит DB (дебет/кредит) после числа
Z Выводит пробелы вместо нулей
( Заключает отрицательные числа в скобки
! Преобразует символы в верхний регистр
----------------------------------------------------

Шаблоны функции TRANSFORM().
----------------------------------------------------
Шаблон Действие
----------------------------------------------------
A,N,X,9,# Выводит числа для любого типа данных
L Выводит логически значения как "T" и "L"
Y Выводит логически значения как "Y" и "N"
! Преобразует символы в верхний регистр
$ Выводит знак доллара перед числом вместо
ведущих пробелов
* Выводит знак звёздочки перед числом вместо
ведущих пробелов
. Определяет положение десятичной точки
, Определяет положение запятой
----------------------------------------------------

Пример использования

Следующий пример форматирует в валютный формат:

? TRANSFORM(123456, "$999.999" // Результат: $123.456

Следующий пример форматирует символьную строку используя
функцию:

? TRANSFORM("to upper", "@!") // Результат: TO UPPER

Library: CLIPPER.LIB.

-------------------------------------------------------------------
TYPE() Возвращает тип данных указанного символьного выражения
-------------------------------------------------------------------


296

TYPE(<вырС1>) -->вырС

Аргументы

<вырС1> - выражение тип которого определяется. Может включать поля
(можно с именем псевдонима), переменные памяти или выражения любого
типа.

Результат

TYPE() возвращает один из следующих символов:

______________________________________________________
Возврат Значение
______________________________________________________
A массив
B блок
С символ
D дата
L логическая переменная
N цифра
M поле памяти (memo)
U NIL, локальное или статическое
UE синтаксическая ошибка
UI неопределенная ошибка
______________________________________________________

Применение

TYPE() возвращает тип указанного выражения. Она может быть
использована для проверки правильности выражения, используемого
функциями CLIPPER.LIB и не ссылаемыми на локальные или статические
переменные, пользовательские функции или встроенные функции
EXTEND.LIB.

Замечания

Ссылки на массивы: ссылки на описанные (DECLAREd) массивы возвращают
"A". Ссылки на элементы массива возвращают тип элемента массива.
Ошибочные ссылки возвращают "U".

IF(): Чтобы возвратить соответствующий тип данных для для IF(),
TYPE() оценивает условие и, затем, возвращает тип полученного
результата для ветви, по которой проводилась оценка. Если условие
оператора IF() или вычисленное значение для ветви оператора
ошибочны, то TYPE() возвращает "UE".

Проверяемые параметры: TYPE() может только проверять правильность
параметров, получаемых при указании комманды PARAMETERS. Проверяемые
параметры объявляются при определении FUNCTION или PROCEDURE и


297

всегда возвращают "U." Для определения был ли аргумент пропущен,
сравните полученный параметр с NIL или используйте VALTYPE() как
показано в примере.

Функции, определенные пользователем, и функции из EXTEND.LIB: Если
ссылка сделана где-нибудь в выражении на функцию, которая не найдена
в CLIPPER.LIB (определенные пользователем или функции из
EXTEND.LIB), то TYPE() возвращает "UI".

Пример использования

Пример демонстрации различных результатов использования TYPE():

? TYPE('SUBSTR("Hi There", 4, 5)') // Результат: C
? TYPE("UDF()") // Результат: UI
? TYPE('IF(.T., "true", 12)') // Результат: C

Пример использования двух методов для проверки существования и типа
параметров:

FUNCTION TestParams( cParam1, nParam2 )
IF cParam1 = NIL
? "Параметр не был передан"
cParam1 := "Значение по умолчанию"
ENDIF
//
IF VALTYPE(nParam2) != "N"
? "Параметр не был передан или неправильного типа"
ENDIF
.
. <комманды>
.
RETURN NIL

Library: CLIPPER.LIB.

-------------------------------------------------------------------
UPDATED() Определяет сделаны ли изменения данных в команде GET
-------------------------------------------------------------------


UPDATED() --> вырL

Результат

Функция UPDATED() возвращает значение "истинно" (.T.), если данные в
команде GET были изменены или добавлены; в противном случае -
"ложно" (.F.).

Применение

Во время каждого выполнения команды READ, значение функции UPDATE


298

устанавливается как "ложно" (.F.), а изменения любого GET внутри
команды READ устанавливает значение как "истинно" (.T.).
Следовательно, проверка состояния GET функцией UPDATE внутри
процедуры команды SET KEY или фразы VALID отражает статус GET.

Пример использования

Пример назначает значение поля из Customer.dbf в переменную и затем
редактирует ее. Если пользователь изменил значение переменной, то
происходит обновление в соответствующей записи файла базы данных:

USE Customer NEW
CLEAR
MEMVAR->Customer = Customer->Customer
MEMVAR->Address = Customer->Address
@ 1, 1 SAY "Name:" GET MEMVAR->Customer
@ 2, 1 SAY "Address:" GET MEMVAR->Address
READ
//
IF UPDATED()
Customer->Customer := MEMVAR->Customer
Customer->Address := MEMVAR->Address
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
UPPER() Преобразует символы нижнего регистра в верхний
-------------------------------------------------------------------


UPPER(<вырС1>) -->вырС

Аргументы

<вырС1> - преобразуемая символьная строка.

Результат

UPPER() возвращает копию указанной символьной строки с
преобразованием символов в верхний регистр.

Применение

Функция UPPER() имеет несколько разных приложений. Обычное
применяется в сравнении строк, в которых неизвестно в каких
регистрах находятся символы. UPPER() полезна для создания независимых
от регистра индексных ключевых выражений.

Пример использования

Пример различных результатов при применении UPPER():


299


? UPPER("a string") // Результат: A STRING
? UPPER("123 char = <>") // Результат: 123 CHAR = <>

Применение UPPER() как часть условия:

USE Customer INDEX CustName NEW
LIST CustName FOR "KATE" $ UPPER(Customer)

Применение UPPER() для создания индекса:

USE Customer NEW
INDEX ON UPPER(Last) TO CustLast


-------------------------------------------------------------------
USED() Определяет использовался ли файл базы данных в USE
-------------------------------------------------------------------


USED() -->вырL

Результат

USED() возвращает значение "истинно" (.T.), если файл базы данных
использовался в USE; в противном случае - значение "ложно" (.F.).

Применение

USED() определяет был ли файл базы данных открыт с помощью комманды
USE в текущей рабочей области. По умолчанию, USED() работает в
текущей рабочей области. Для работы с другой не выбранной рабочей об-
ластью, используйте алиасное выражение.

Пример использования

Пример использования USED() в текущей рабочей области:

USE Customer NEW
? USED() // Результат: .T.
CLOSE
? USED() // Результат: .F.

Пример использования USED() с алиасным выражением:

USE Customer NEW
USE Sales NEW
USE Invoices NEW
SELECT 0
//
? Customer->(USED()) // Результат: .T.
? Sales->(USED()) // Результат: .T.


300

? Invoices->(USED()) // Результат: .T.
? BackOrder->(USED()) // Результат: .F.

Library: CLIPPER.LIB.

-------------------------------------------------------------------
VAL() Преобразует число из символьного выражения в число
-------------------------------------------------------------------


VAL(<вырС>) -->вырN

Аргументы

<вырС> - символьное выражение для преобразования.

Результат

Функция VAL() возвращает <вырС>, преобразованное в число, включая
десятичные цифры.

Применение

VAL() применяется когда необходимо произвести вычисления с числами,
содержащимися в строковых выражениях.

Пример использования

SET DECIMALS TO 2
SET FIXED ON
//
? VAL("12.1234") // Результат: 12.12
? VAL("12.1256") // Результат: 12.13
? VAL("12A1234") // Результат: 12.00
? VAL("A121234") // Результат: 00.00
? VAL(SPACE(0)) // Результат: 00.00
? VAL(SPACE(1)) // Результат: 00.00
? VAL(" 12.12") // Результат: 12.12
? VAL("12. 12") // Результат: 12.00

-------------------------------------------------------------------
VALTYPE() Определяет тип данных, возвращенного выражения
-------------------------------------------------------------------


VALTYPE(<выр>) --> вырС

Аргументы

<выр> - выражение любого типа.

Результат


301


VALTYPE() возвращает простейший символ, соответствующий типу данных,
<выр>. VALTYPE() возвращает однин из следующих символов:

______________________________________________________
Возврат Значение
______________________________________________________
A массив
B блок
С символ
D дата
L логическая переменная
N цифра
M поле памяти (memo)
O объект
U NIL
______________________________________________________


Применение

VALTYPE() подобна TYPE(), но отличается тем, что оценивает указанный
аргумент и определяет тип возвращаемого значения. Вы можете
определить тип локальных и статических переменных, пользовательской
функции, и функции EXTEND.LIB. TYPE() использует макро-оператор (&)
для использования оценки аргументов.

Пример использования

Пример, показывающий различные возвращаемые значения:

VALTYPE(1) // Результат: N
? VALTYPE("GOOB") // Результат: C
? VALTYPE(NIL) // Результат: U
? VALTYPE(array) // Результат: A
? VALTYPE(block) // Результат: B

Library: CLIPPER.LIB.

-------------------------------------------------------------------
VERSION() Возвращает версию Clipper
-------------------------------------------------------------------


VERSION() --> вырС

Результат

VERSION() возвращает версию библиотеки Clipper, EXTEND.LIB, как
символьное значение.

Применение


302


VERSION() возвращает версию библиотеки Clipper, EXTEND.LIB, как
символьное значение.

Library: EXTEND.LIB.

-------------------------------------------------------------------
WORD()* Преобразует числовой параметр CALL из типа DOUBLE в тип INT
-------------------------------------------------------------------


WORD(<вырN>) -->NIL

Аргументы

<вырN> - преобразуемое числовое выражение.

Результат

При использовании в комманде CALL, WORD() возвращает целое число. В
других случаях, возвращает NIL.

Применение

Используется для преобразования параметра из типа DOUBLE в INT,
чтобы уменьшить преобразования в процедуре, вызываемой командой
CALL. WORD() - совместимая функция и поэтому не рекомендована.

Пример использования

Пример типичного использования WORD() как аргумента в комманде CALL:

CALL Cproc WITH WORD(30000), "Some text"

Library: CLIPPER.LIB.

-------------------------------------------------------------------
YEAR() Преобразует выражение даты в число, соответствующие году
-------------------------------------------------------------------

YEAR(<вырD>) -->вырN

Аргументы

<вырD> - дата для преобразования.

Результат

Функция YEAR() возвращает число, соответствующие году, включая год
столетия.

303

Применение

Используется для арифметических операций с датами.

Пример использования

Пример использования YEAR() с системной датой:

? DATE() // Результат: 09/01/90
? YEAR(DATE()) // Результат: 1990
? YEAR(DATE()) + 11 // Результат: 2001

Пример создания пользовательской функции:

? Mdy(DATE()) // Результат: September 20, 1990

FUNCTION Mdy( dDate )
RETURN CMONTH(dDate) + " " + LTRIM(STR(DAY(dDate)));
+ "," + STR(YEAR(dDate))

Library: CLIPPER.LIB.