COMPILEFILE() | Компиляция файла. |
COMPILESTRING() | Компиляция строки. |
DEFPATH() | Возвращает правильный путь, установленный по SET DEFAULT. |
DIRECTORY() | Создает массив с информацией о каталогах и файлах. |
DOSERROR() | Возвращает номер последней ошибки DOS. |
ERRORBLOCK() | Отправляет блок кода на выполнение при возникновении ошибки времени |
ERRORLEVEL() | Устанавливает код завершения xClipper-программы. |
FERROR() | Проверяет наличие ошибок обработки двоичных файлов. |
GETENV() | Возвращает значение переменной среды OS. |
LOAD() | Загрузка байт-кода или динамической библиотеки. |
LOADBLOCK() | Загрузка байт-кода. |
MEMORY() | Определяет количество байтов свободной оперативной памяти. |
NETERR() | Индицирует сбой выполнения команд при работе в сети. |
NETNAME() | Возвращает идентификатор текущей рабочей станции. |
OS() | Возвращает имя операционной системы. |
PCOUNT() | Определяет позицию последнего переданного аргумента. |
PROCLINE() | Возвращает номер строки исходной программы текущего или предыдущего вызова. |
PROCNAME() | Возвращает имя текущей или предыдущей процедуры или функции |
QOUT() | Выводит список выражений на консоль. |
SET() | Возвращает и изменяет глобальные установки. |
SLEEP() | Остановить выполнение программы на заданное количество секунд и(или) милисекунд. |
SYSCMD() | Выполнить системную команду. |
ULIMIT() | Установить лимит на использование системных ресурсов. |
VERSION() | Возвращает номер версии xClipper. |
COMPILEFILE(<sFileName>, <sFlags>, <@sError>) --> TRUE || FALSE
Возвращает TRUE, если файл скомпилировался без ошибок.
COMPILEFILE() компилирует файл <sFileName> с флагами <sFlags> и возвращает TRUE в случае успеха, иначе возвращает FALSE и <sError> содержит описание ошибки.
sFileName := FILEDIALOG("*.prg") err := "" lCF := COMPILEFILE(sFileName,,@err) if iCF qout("Compiller: OK") else qout("Compiller: error"+ err) endif
COMPILESTRING(<sString>, <@sError>) --> <CodeBlock>
Возвращает блок кода, что был скомпилирован из исходной строки.
COMPILESTRING() компилирует строку <sString> и возвращает полученный кодовый блок. <sError> содержит описание ошибки, если таковая возникла в процессе компиляции.
Исходная строка может содержать любые CLIP конструкции, команды, за исключением описания нестатических функций. <sString> должна начинаться с описания параметров (если они есть) без описания названий функции или процедуры. См пример.
/* source string */ str:=" parameters p1,p2 qout(p1,p2) localfunc1(p1,p2) return p1+p2 static function localfunc1(fp1,fp2) qout('called local function in string compiled block') return p1-p2" /* compile string */ block:=COMPILESTRING(str,@err) if empty(err) x:=eval(block,1,2) // returns values p1 and p2 ? x // returns values p1+p2 else ? err // error description endif
DefPath() -> <cPath>
No arguments
Новый путь.
Возвращает путь, установленный по SET DEFAULT, с завершающим символом PATH_DELIM или :. Если SET DEFAULT специально не задан (пуст), то ничего не добавляет.
SET DEFAULT TO c:\FOX ? Set(_SET_DEFAULT) // 'c:\fox' ? DefPath() // 'c:\fox\' SET DEFAULT TO D ? Set(_SET_DEFAULT) // 'D' ? DefPath() // 'D:'
Функция DefPath() не документирована (но активно используется) в xClipper.
Евгений Бондарь
Завершающий символ PATH_DELIM зависит от платформы. Это "\" в DOS/WINDOWS и "/" в UNIX.
DIRECTORY(<шаблон поиска>,[<атрибуты>]) -> массив файлов
<шаблон поиска> | - определяет устройство, директорию и спецификацию |
файлов для поиска. Допустимо использование произвольных символов. | |
Если аргумент <шаблон поиска> не указан, по умолчанию принимается | |
(*.*). | |
Аргумент <атрибуты> определяет необходимость включения в информации | |
о файлах со специальными атрибутами. Аргумент <атрибуты> состоит из | |
строки, содержащей один или более символов, представленных в таблице | |
Атрибуты функции DIRECTORY(). --------------------------------------------------------------------- Атрибут Значение --------------------------------------------------------------------- H Включаются скрытые файлы S Включаются системные файлы D Включаются имена каталогов V Ищется метка тома DOS. Все остальные файлы исключаются --------------------------------------------------------------------- | |
Информация о файлах может присутствовать в подмассивах, только если | |
не используется атрибут V. |
DIRECTORY() возвращает массив, в котором каждый элемент является подмассивом, содержащим информацию об очередном файле, выбранном в соответствии с аргументом <шаблон поиска>. Подмассив имеет следующую структуру:
Структура подмассивов функции DIRECTORY(). --------------------------------------------------------------------- Позиция Метасимвол Directry.ch --------------------------------------------------------------------- 1 cName F_NAME 2 nSize F_SIZE 3 dDate F_DATE 4 cTime F_TIME 5 cAttributes F_ATT ---------------------------------------------------------------------
Если не найдено файлов, соответствующих <шаблон поиска>, или в <шаблон поиска> указан неверный маршрут доступа или спецификация файла, то функция DIRECTORY() возвращает пустой ({}) массив.
DIRECTORY() - это функция среды, которая возвращает информацию о файлах в текущем или заданном каталоге. Она похожа на ADIR(), но возвращает единственный массив вместо того, чтобы заносить значения в группу созданных массивов, передаваемых по ссылке.
DIRECTORY() может быть использована для обработки групп файлов. Создав блок кода, который сможет обрабатывать все файлы, выбираемые в соответствии со значением <шаблон поиска>, можно использовать DIRECTORY() в комбинации с функцией AEVAL().
Для удобства пользования элементами подмассива в комплект поставки xClipper входит файл описаний directory.ch, помещаемый в директорию \include, определяющий имена элементов подмассива.
В этом примере формируется массив информации о файлах в текущем каталоге, а затем распечатывается список имен этих файлов. В примере используются функции AEVAL() и QOUT(): #include "directry.ch" // aDirectory := DIRECTORY("*.*", "D") AEVAL( aDirectory, { | aFile | QOUT( aFile[F_NAME]) } )
DOSERROR([<новый код ошибки>]) --> код ошибки
DOSERROR() возвращает номер ошибки DOS в виде целого арифметического значения.
DOSERROR() - это функция обработки ошибок, которая возвращает код последней ошибки DOS, связанный с активизацией блока ошибок времени выполнения.
При возникновении ошибки в процессе выполнения программы, если это ошибка DOS, функция DOSERROR() примет значение ее кода. Это значение сохранится до возникновения следующей ошибки. Если возникшая ошибка не является ошибкой DOS, DOSERROR() примет значение 0. При возникновении ошибок в процессе низкоуровневой обработки файлов значение функций FERROR() и DOSERROR() одинаковы.
ERRORBLOCK([<блок обработки ошибки>]) --> текущий блок обработки ошибки
ERRORBLOCK() возвращает текущий блок кода обработки ошибки. Если с начала работы программы не было ни одного отправленного блока кода, ERRORBLOCK() возвращает блок кода для обработки ошибки, принятый по умолчанию.
ERRORBLOCK() - это функция обработки ошибок, определяющая обработчик ошибок, который выполняется при возникновении ошибки времени выполнения. Обработчик ошибок описывается в виде блока кода в следующей форме:
{ | <ERROR-объект> | <список выражений>, ... }
При этом <ERROR-объект> - это ERROR-объект, содержащий информацию об ошибке. Для получения информации об ошибке вместе с блоком кода в ERROR объект могут быть переданы соответствующие сообщения. Возвратив значение "истина" (.T.), блок обработки ошибки пытается повторно выполнить операцию, приведшую к ошибке, после чего возвращает значение "ложь" (.F.).
Блок кода, обрабатывающий ошибку, может быть описан как список выражений или как вызов функции пользователя. Вызов из блока кода функции пользователя более предпочтителен, так как в этом случае можно вместо выражений использовать операторы и команды xClipper для обработки ошибок.
Обычным является прием программирования, когда программа содержит управляющую структуру BEGIN SEQUENCE, и при возникновении ошибки вы хотите управление передать командой BREAK на первую команду предложения RECOVER. Предполагается, что блок обработки ошибок может использоваться с управляющей структурой BEGIN SEQUENCE...END. При помощи блока обработки ошибок можно контролировать работу устройств, обычных ошибок и ошибок низшего уровня, так как это - универсальный механизм восстановления.
Если требуются нестандартные действия по обработке ошибки, необходимо определить BEGIN SEQUENCE и затем командой BREAK передать управление на первый оператор предложения RECOVER, возвратив ERROR-объект для локальной обработки ( смотри пример ниже ).
Если при помощи ERRORBLOCK() не было определено ни одного блока кода <блок обработки ошибки> и возникла ошибка времени выполнения, выполнится блок обработки ошибок, заданный по умолчанию. При этом на экран будет выдано сообщение об ошибке, ERRORLEVEL() примет значение 1, после чего выполнится команда QUIT.
После того, как ERRORBLOCK() возвратит текущий блок обработки ошибок, появляется возможность определить блок обработки ошибок с последующим его восстановлением после того, как завершатся операции. И еще, важным свойством обработчиков ошибок, описываемых как блоки кода, является тот факт, что они могут быть переданы процедурам и функциям пользователя и могут быть их возвращаемыми значениями.
За более подробной информацией о структуре и операциях ERROR-объекта обращайтесь в раздел "Error класс" в главе " Стандартные классы".
Следующий фрагмент программы показывает, как блок обработки ошибок передан и затем вызван при возникновении ошибки внутри управляющей структуры BEGIN SEQUENCE: LOCAL bErrorHandler, bLastHandler, objError bErrorHandler := { | objError | MyErrorHandler( objError ) } // bLastHandler := ERRORBLOCK( bErrorHandler ) // Сохранить текущий обработчик BEGIN SEQUENCE ... ...<операторы> ... RECOVER USING objErrorInfo // Принять объект-ошибку из BREAK ... ...<операторы восстановления> ... END ERRORBLOCK(bLastHandler) // Восстановить обработчик RETURN FUNCTION MyErrorHandler( objError ) // BREAK objError // Возвратить объект-ошибку в RECOVER RETURN NIL
ERRORLEVEL([<код завершения>]) --> текущий код завершения
ERRORLEVEL() возвращает текущий код завершения xClipper как числовое значение, если он был установлен путем использования ERRORLEVEL() с аргументом; в противном случае она возвращает нуль.
ERRORLEVEL() является функцией среды с двойным назначением. Она возвращает текущий код завершения xClipper и необязательно устанавливает новый код завершения. Код завершения является значением, установленным дочерним процессом, чтобы родительский процесс мог проверить состояние завершения дочернего процесса. Типичный случай - когда родительским процессом является OS, а дочерним процессом - прикладная программа. Код завершения может быть получен с помощью команды OS ERRORLEVEL или прерывания INT 21 функции 4Dh.
При завершении xClipper-программы код завершения устанавливается в 1, если процесс заканчивается фатальной ошибкой. При нормальном завершении программы код завершения устанавливается в нуль или в значение последней ERRORLEVEL(), установленное в программе.
Обычно устанавливают код завершения при помощью ERRORLEVEL(), чтобы указать тип ошибки программе, которая вызвала текущую программу xClipper. В большинстве случаев это командный файл прикладной программы. Здесь проверяется код завершения путем использования команды OS ERRORLEVEL. За более подробной информацией обращайтесь к руководству по OS.
В примере показано сохранение текущего кода завершения xClipper и последующая установка нового значения: nOldCode = ERRORLEVEL() // Прочитать текущую установку ошибки ERRORLEVEL(1) // Установить новое значение Этот пример показывает использование ERRORLEVEL() для установки кода завершения, который может быть проверен родительским процессом: #define ERR_FILE_MISSING 255 #define ERR_POST_INCOMPLETE 254 // IF !FILE("Sysfile.dbf") @ 0, 0 @ 1, 0 @ 0, 0 SAY "Фатальная ошибка: Файл отсутствует... завершение" ERRORLEVEL(ERR_FILE_MISSING) QUIT ENDIF
FERROR() --> код ошибки
No arguments
FERROR() возвращает код ошибки DOS выполнения последней операции над файлом в виде целого числа. Если ошибки не было, FERROR() возвращает 0.
FERROR() является функцией обработки файлов низкого уровня. Она используется для уточнения ошибки DOS после применения какой-либо из функций обработки файлов. К этим функциям относятся: FCLOSE(), FCREATE(), FERASE(), FOPEN(), FREAD(), FREADSTR() и FRENAME(). Функция FERROR() сохраняет свое значение до следующего выполнения вышеуказанных функций.
Предупреждение: Данная функция позволяет осуществлять доступ низкого уровня к файлам и устройствам DOS. Она должна использоваться чрезвычайно осторожно и требует хороших знаний операционной системы.
В следующем примере показано, как проверить при помощи функции FERROR() успешность создания файла: #include "Fileio.ch" // nHandle = FCREATE("Temp.txt", FC_NORMAL) IF FERROR() != 0 ? "Невозможно открыть файл, ошибка DOS: ", FERROR() ENDIF
GETENV (<переменная среды OS>) --> строка
GETENV() возвращает содержимое заданной переменной среды OS в виде символьной строки. Если переменная не может быть найдена, GETENV() возвращает пустую строку ("").
GETENV() - это функция среды, которая позволяет вам получать в прикладной программе информацию о конфигурации среды OS. Как правило, это информация о размещении файлов ( базы данных, индекса, меток или отчетов). Эта функция особенно полезна в сетевой среде.
Этот пример считывает текущую установку маршрута доступа в OS, делая его текущим для xClipper: cPath = GETENV("PATH") SET PATH TO (cPath) Этот пример демонстрирует, как использовать переменные среды, чтобы получить нужную конфигурацию размещения файлов. Когда вы устанавливаете систему, опишите переменные среды, которые определяют размещение различных типов файлов наряду с переменной среды xClipper. SET LOC_DBF=<путь доступа к файлу базы данных> SET LOC_NTX=<путь доступа к индексам> SET LOC_RPT=<путь доступа к файлам отчета> В разделе конфигурации вашей прикладной программы присвойте параметры среды этим переменным. Затем, когда вы получите доступ к файлу, сформируйте ссылку с помощью переменной PATH, как показано ниже: cDbfDirectory = GETENV("LOC_DBF") USE (cDbfDirectory + "Invoices")
LOAD(<sFileName>) --> <CodeBlock>
Возвращает кодовый блок, загруженный из файла.
LOAD() зачитывает файл <sFileName> и возвращает кодовый блок. <sFile> это байт-код файл "filename.po" или динамическая библиотека "filename.so". Все не статик функции, объявленные в файле, становятся доступными для использования.
/* test.po */ local a a := "Hello, world!" return a ///////////////////////// block := LOAD("test.po") qout( eval(block) ) // --> Hello, world!
LOADBLOCK(<sFileName>) --> <CodeBlock>
Возвращает кодовый блок, загруженный из байт-код файла.
LOADBLOCK() загружает байт-код файл <sFileName> и возвращает кодовый блок. Байт-код файл может быть создан:
clip -P filename.prg
Правила и структура файла filename.prg должны соответствовать правилам для строки из функции COMPILESTRING().
block := LOADBLOCK("test.po") eval(block, "1", 2)
MEMORY(<арифметическое выражение>) --> к-во байтов
<арифметическое выражение> | - арифметическое выражение, определяющее |
тип значения, которое возвращает MEMORY(), согласно таблице. | |
Значения аргументов MEMORY() --------------------------------------------------------------------- Значение Описание --------------------------------------------------------------------- 0 Оценивает общий доступный объем для символьных значений 1 Наибольший непрерывный блок, доступный для символьных значений 2 Область, доступная для программ, вызываемых командой RUN --------------------------------------------------------------------- |
MEMORY() возвращает количество доступной памяти в виде целого числа с дискретностью 1 килобайт.
MEMORY() - функция среды, которая сообщает различные состояния пула свободной оперативной памяти. В этой области располагаются символьные строки и программы, вызываемые командой RUN.
Этот пример демонстрирует, как 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
NETERR([<признак новой ошибки>]) --> признак ошибки
<признак новой ошибки> | - если задан, устанавливает значение, |
возвращаемое NETERR(), в дальнейшем. <признак новой ошибки> может | |
быть или "истина" (.T.), или "ложь" (.F.). Установка значения, | |
возвращаемого функцией NETERR(), позволяет управлять обработчиком | |
ошибок в некоторых ситуациях. Более подробную информацию смотрите | |
в Errorsys.prg. |
Значение, возвращаемое NETERR(), устанавливается функцией DefError() программы Errorsys.prg, назначаемой обработчиком исключительных ситуаций по умолчанию. Если не назначен (с помощью функции ERRORBLOCK()) другой обработчик ошибок, то NETERR() возвращает "истина" (.T.) при неудачном выполнении команд APPEND BLANK и USE. Начальное значение NETERR() - "ложь" (.F.). Если текущий процесс выполняется под управлением несетевого программного обеспечения, NETERR() всегда возвращает "ложь" (.F.).
NETERR() - это сетевая функция. Она используется для проверки прикладной программой успешности выполнения команд USE, USE EXCLUSIVE и APPEND BLANK в сети. В следующую далее таблицу сведены условия возвращения функцией NETERR() (устанавливаемые в DefError()) значения "истина" (.T.):
Значения NETERR() - "истина" (.T.). --------------------------------------------------------------------- Команда Ситуация --------------------------------------------------------------------- USE Команда USE EXCLUSIVE в другом процессе USE EXCLUSIVE Команды USE или USE EXCLUSIVE в другом процессе APPEND BLANK FLOCK() другим пользователем или RLOCK() для записи LASTREC()+1 ---------------------------------------------------------------------
Если возвращенное функцией NETERR() значение - "ложь" (.F.), то можно выполнять следующую команду. Например, после успешного выполнения USE можно открывать индексный файл, а после успешного выполнения APPEND BLANK можно заполнять поля записи командами REPLACE или @...GET. В противном случае, необходимо обработать ошибку и либо повторить команды USE и APPEND BLANK, либо прервать операцию командами BREAK или RETURN.
В этом примере демонстрируется типичное использование функции NETERR(). Если команда USE выполнена успешно, то открывается индексный файл, и процесс продолжается. Если команда USE выполнена с ошибкой, то на экран выдается сообщение об ошибке: USE Customer SHARED NEW IF !NETERR() SET INDEX TO CustNum, CustOrders, CustZip ELSE ? "База данных используется другим пользователем" ENDIF
NETNAME() --> имя рабочей станции
No arguments
NETNAME() возвращает идентификатор рабочей станции в виде символьной строки длиной не более 15 символов. Если идентификатор рабочей станции не установлен или станция работает в сети, отличной от IBM PC Network, функция NETNAME() возвращает нулевую строку ("").
Этот пример демонстрирует функцию NETNAME(), когда рабочая станция является узлом сети и имеет идентификатор "СТАНЦИЯ 1": ? NETNAME() // Результат: "СТАНЦИЯ 1"
OS() --> имя операционной системы
No arguments
OS() возвращает имя операционной системы в виде символьной строки.
OS() - функция среды, которая возвращает имя дисковой операционной системы, под управлением которой работает данный компьютер. Имя, которое возвращает функция OS(), состоит из двух частей: названия операционной системы и номера версии.
В этом примере функция OS() возвращает имя операционной системы. ? OS() // Результат: LINUX
PCOUNT() --> позиция последнего аргумента
No arguments
PCOUNT() возвращает позицию последнего переданного аргумента в виде целого числа. Если аргументы не были переданы, PCOUNT() возвращает ноль.
PCOUNT() возвращает позицию последнего аргумента в списке аргументов, передаваемых при вызове процедуры или функции пользователя. Эта информация полезна при определении, были ли аргументы опущены в конце списка аргументов.
Аргументы, пропущенные в середине списка, из списка не исключаются, а замещаются значениями NIL.
Чтобы определить, получил ли параметр значение, необходимо проверить, имеет ли он значение NIL. Пропущенные параметры являются неинициализированными, следовательно, при обращении к ним возвращают NIL. Другой метод проверки параметров - с помощью функции VALTYPE(). Она может устанавливать, был ли аргумент передан и в то же время проверяет корректность его типа. Если параметр не был определен, то подразумевается значение по умолчанию.
В этом примере показана функция пользователя, которая открывает файл базы данных, используя функцию PCOUNT(), определяет, передала ли вызывающая процедура имя файла, который следует открыть. Если имя не передано, то функция OpenFile() запрашивает его имя: FUNCTION OpenFile( cFile) IF PCOUNT() = 0 ACCEPT "Открыть файл : " TO cFile ENDIF USE (cFile) RETURN (NETERR())
PROCLINE([<номер вызова>]) --> номер строки исходной программы
PROCLINE() возвращает номер строки последней выполняемой команды в текущей процедуре, функции пользователя или блоке кода в виде целого числа. Если при компиляции была использована опция /L компилятора, то функция PROCLINE() всегда возвратит ноль.
PROCLINE() запрашивает стек вызова xClipper для определения последней выполняемой строки в текущей процедуре, функции пользователя или блоке кода. Стек вызова - это внутренняя структура, которая поддерживает запись каждого вызова процедуры, функции пользователя, блока кода. Номер строки считывается относительно начала исходного файла программы. Строка содержит в себе комментарии, пустые строки, директивы компилятору и препроцессору, продолжение строки. Строка может содержать несколько операторов.
Текущий вызов - это номер строки вызова PROCLINE().
Предыдущий вызов - это номер строки процедуры или функции пользователя, откуда была вызвана процедура или функция пользователя, содержащая функцию PROCLINE().
Если вызов требует вычисления блока кода, то PROCLINE() возвращает номер строки процедуры, где этот блок кода был определен. PROCLINE() используется в сочетании с функцией PROCNAME() для выдачи отладочной информации.
В этом примере определяется номер строки, возвращаемый функцией PROCLINE() для текущего и предыдущего вызовов: //Первая строка исходной программы MyFunction() RETURN FUNCTION MyFunction ? PROCLINE() // Результат: 6 (текущий вызов) ? PROCLINE(1) // Результат: 2 (предыдущий вызов) RETURN NIL
PROCNAME([<номер вызова>]) --> имя процедуры
PROCNAME() возвращает имя процедуры, выполняемой в текущий момент, функции или блока кода в виде символьной строки.
PROCNAME() запрашивает стек вызовов активации xClipper для определения имени выполняемых в текущий момент процедуры, функции пользователя или блока кодов. Стек вызовов активации - это внутренняя структура, хранящая запись о каждом вызове процедуры, функции или блока кодов.
Для текущего вызова 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
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() выводят пробел между результатами каждого выражения.
QOUT() и QQOUT() могут быть использованы для вывода на консоль внутри выражения. Это особенно полезно для блоков итерационных функций, таких как AEVAL() и DBEVAL(), и в списке операторов в выходном шаблоне команд, определенных пользователем.
Следующий пример демонстрирует как QOUT() может быть использована вместе с AEVAL() для вывода содержимого массива литералов на консоль: LOCAL aElements := {1, 2, 3, 4, 5 } AEVAL(aElements, { |element| QOUT(element) })
SET(<режим>, [<новое значение режима>], [<признак режима добавления>]) --> текущее значение режима
<режим> | - является числовым значением, которое задает режим, |
подлежащий проверке или изменению. Значение аргумента <режим> должно | |
задаваться в виде явной константы (см. ниже). | |
<новое значение режима> | является необязательным параметром, который |
задает новое значение для заданного режима. Тип аргумента <новое | |
значение режима> зависит от значения аргумента <режим>. | |
<признак режима добавления> | логическое значение, которое указывает, |
будут ли файлы, открытые для следующих установок: | |
_SET_ALTFILE,_SET_PRINTFILE,_SET_EXTRAFILE | |
обрезаться до нулевой длины или открываться в режиме добавления. | |
Значение "ложь" (.F.) означает, что файл должен быть обрезан до | |
нулевой длины. Значение "истина" (.T.) означает, что файл должен быть | |
открыт в режиме добавления. В любом случае, если файл не существует, | |
то он создается. | |
При отсутствии этого аргумента по умолчанию принимается режим | |
добавления. |
SET() возвращает текущее значение заданного режима.
SET() является системной функцией, которая разрешает проверку или изменение значений глобальных режимов xClipper. Для получения информации о смысловом значении и диапазоне допустимых значений для конкретного режима обратитесь к соответствующей команде или функции.
Режим, подлежащий проверке или изменению, задается путем использования явной константы. Эти константы определяются в файле описаний Set.ch.
Этот файл описаний должен быть включен в начало любого исходного файла, использующего функцию SET().
Файл Set.ch определяет также константу, названную _SET_COUNT. Ее значение - количество режимов, которые могут быть изменены или проверены при помощи функции SET(), позволяя осуществить построение функции, сохраняющей все режимы (см. пример, приведенный ниже).
Примечание: Числовые значения явных констант в файле Set.ch зависят от версии, и они никогда не должны использоваться прямо. Допускается использование только явных констант.
Если значения аргументов <режим> или <новое значение режима> являются недопустимыми, вызов SET() игнорируется.
Значения режимов, устанавливаемых функцией SET() и определенных в файле Set.ch. --------------------------------------------------------------------- Константа Тип значения Соответствующая команда или функция --------------------------------------------------------------------- _SET_EXACT Логическое SET EXACT _SET_FIXED Логическое SET FIXED _SET_DECIMALS Числовое SET DECIMALS _SET_DATEFORMAT Символьное SET DATE _SET_EPOCH Числовое SET EPOCH _SET_PATH Символьное SET PATH _SET_DEFAULT Символьное SET DEFAULT _SET_EXCLUSIVE Логическое SET EXCLUSIVE _SET_SOFTSEEK Логическое SET SOFTSEEK _SET_UNIQUE Логическое SET UNIQUE _SET_DELETED Логическое SET DELETED _SET_CANCEL Логическое SETCANCEL() _SET_DEBUG Логическое ALTD() _SET_COLOR Символьное SETCOLOR() _SET_CURSOR Числовое SETCURSOR() _SET_CONSOLE Логическое SET CONSOLE _SET_ALTERNATE Логическое SET ALTERNATE _SET_ALTFILE Символьное SET ALTERNATE TO _SET_DEVICE Символьное SET DEVICE _SET_PRINTER Логическое SET PRINTER _SET_PRINTFILE Символьное SET PRINTER TO _SET_MARGIN Числовое SET MARGIN _SET_BELL Логическое SET BELL _SET_CONFIRM Логическое SET CONFIRM _SET_ESCAPE Логическое SET ESCAPE _SET_INSERT Логическое READINSERT() _SET_EXIT Логическое READEXIT() _SET_INTENSITY Логическое SET INTENSITY _SET_SCOREBOARD Логическое SET SCOREBOARD _SET_DELIMITERS Логическое SET DELIMITERS _SET_DELIMCHARS Символьное SET DELIMITERS TO _SET_WRAP Логическое SET WRAP _SET_MESSAGE Числовое SET MESSAGE _SET_MCENTER Логическое SET MESSAGE ---------------------------------------------------------------------
В этом примере показана функция пользователя, сохраняющая или восстанавливающая все глобальные режимы. Эта функция может быть использована при входе в подсистему для обеспечения того, чтобы подсистема не оказывала влияния на состояние вызывающей программы: #include "Set.ch" // FUNCTION SetAll( aNewSets ) LOCAL aCurrentSets[_SET_COUNT], nCurrent IF (aNewSets != NIL ) // Устанавливает новый и возвращает текущий FOR nCurrent := 1 TO _SET_COUNT aCurrentSets[nCurrent] := SET(nCurrent, aNewSets[nCurrent]) NEXT ELSE // Только возвращает текущий FOR nCurrent := 1 TO _SET_COUNT aCurrentSets[nCurrent] := SET(nCurrent) NEXT ENDIF RETURN (aCurrentSets)
SLEEP(<nSec>) --> NIL
Возвращает NIL.
SLEEP() останавливает программу на время, пока не истекли указанные секунды.
do while 100 ? time() SLEEP(10.50) enddo
Никаких гарантий на заданное количество МИЛИСЕКУНД нет, если такой гарантии не дает операционная система.
SYSCMD(<sCmd>, <sStdin>, @<sResult>, @<sError>) --> <nResultCode>
Возвращает -1 если произошла ошибка или возвращает статус завершения команды.
SYSCMD() выполняет системную команду <sCmd>, посылая ей на входной стандартный поток строку <sStdin>. Весь stdout будет записан в буфер <sResult>, а весь stderr - в <sErr>.
<sResult> и <sError> не могут быть объявлены как константы.
err_buf1=space(0) res_buf1=space(0) err_buf2=space(0) res_buf2=space(0) result_code1 := SYSCMD("ls -l", "", @res_buf1, @err_buf1) ? result_code1 ? res_buf1 ? err_bus1 ? result_code2 := SYSCMD("grep test ", res_buf1, @res_buf2, @err_buf2) ? result_code2 ? res_buf2 ? err_bus2 ?
Не зависит от платформ
ULIMIT(<sResName>, <vLimitVal>) --> <vOldLimitValue>
Возвращает старое значение предельной величины для системного ресурса <sResName>.
ULIMIT() устанавливает новое значение <vLimitVal> на использование системного ресурса с именем <sResName> и возвращает старое значение этого ресурса.
Список возможных значений ресурсов см. в ulimit.ch
#include <ulimit.ch> /* set the max size for stack */ ? ULIMIT( ULIMIT_STACK, 1024 )
Не зависит от платформ
VERSION() --> номер версии
No arguments
VERSION() возвращает номер версии xClipper библиотеки EXTEND.LIB в виде символьной строки.
VERSION() - функция среды, которая возвращает номер версии xClipper библиотеки EXTEND.LIB.
Пред. | Начало | След. |
CLIP Functions | Уровень выше | C-API |