SYSTEM

Function COMPILEFILE()

 COMPILEFILE(<sFileName>, <sFlags>, <@sError>) 	--> TRUE || FALSE

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
 

Function COMPILESTRING()

 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
 

Function DEFPATH()

 DefPath() --> <cPath>

Возвращает путь, установленный по 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:'

Function DIRECTORY()

 DIRECTORY(<шаблон поиска>,[<атрибуты>]) -> массив файлов

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

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

Для удобства пользования элементами подмассива в комплект поставки xClipper входит файл описаний directory.ch, помещаемый в директорию \include, определяющий имена элементов подмассива.

Атрибуты функции DIRECTORY().
---------------------------------------------------------------------
Атрибут       Значение
---------------------------------------------------------------------
H             Включаются скрытые файлы
S             Включаются системные файлы
D             Включаются имена каталогов
V             Ищется метка тома DOS. Все остальные файлы исключаются
---------------------------------------------------------------------

Структура подмассивов функции DIRECTORY().
 ---------------------------------------------------------------------
 Позиция          Метасимвол           Directry.ch
 ---------------------------------------------------------------------
 1               cName                 F_NAME
 2               nSize                 F_SIZE
 3               dDate                 F_DATE
 4               cTime                 F_TIME
 5               cAttributes           F_ATT
 ---------------------------------------------------------------------
 

 В этом примере формируется массив информации о файлах в текущем
 каталоге, а затем распечатывается список имен этих файлов. В
 примере используются функции AEVAL() и QOUT():
 
 
 #include "directry.ch"
 //
 aDirectory := DIRECTORY("*.*", "D")
 AEVAL( aDirectory, { | aFile | QOUT( aFile[F_NAME]) } )

Function DOSERROR()

 DOSERROR([<новый код ошибки>]) --> код ошибки

DOSERROR() - это функция обработки ошибок, которая возвращает код последней ошибки DOS, связанный с активизацией блока ошибок времени выполнения.

При возникновении ошибки в процессе выполнения программы, если это ошибка DOS, функция DOSERROR() примет значение ее кода. Это значение сохранится до возникновения следующей ошибки. Если возникшая ошибка не является ошибкой DOS, DOSERROR() примет значение 0. При возникновении ошибок в процессе низкоуровневой обработки файлов значение функций FERROR() и DOSERROR() одинаковы.

Function 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

Function ERRORLEVEL()

 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

Function FERROR()

 FERROR() --> код ошибки

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

Function GETENV()

 GETENV (<переменная среды OS>) --> строка

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")

Function LOAD()

 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!
 

Function LOADBLOCK()

 LOADBLOCK(<sFileName>) 	--> <CodeBlock>

LOADBLOCK() загружает байт-код файл <sFileName> и возвращает кодовый блок. Байт-код файл может быть создан:

clip -p filename.prg

Правила и структура файла filename.prg должны соответствовать правилам для строки из функции COMPILESTRING().

  block := LOADBLOCK("test.po")
 
 eval(block, "1", 2)
 

Function MEMORY()

 MEMORY(<арифметическое выражение>) --> к-во байтов

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

 Значения аргументов MEMORY()
---------------------------------------------------------------------
Значение Описание
---------------------------------------------------------------------
0       Оценивает общий доступный объем для символьных значений
1       Наибольший непрерывный блок, доступный для символьных значений
2       Область, доступная для программ, вызываемых командой 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

Function NETERR()

 NETERR([<признак новой ошибки>]) --> признак ошибки

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

Function NETNAME()

 NETNAME() --> имя рабочей станции

 Этот пример демонстрирует функцию NETNAME(), когда рабочая станция
 является узлом сети и имеет идентификатор "СТАНЦИЯ 1":
 
 ? NETNAME()               // Результат: "СТАНЦИЯ 1"

Function OS()

 OS() --> имя операционной системы

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

 В этом примере функция OS() возвращает имя операционной системы.
 
 ? OS()                 // Результат: LINUX

Function PCOUNT()

 PCOUNT() --> позиция последнего аргумента

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

Аргументы, пропущенные в середине списка, из списка не исключаются, а замещаются значениями NIL.

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

 В этом примере показана функция пользователя, которая открывает
 файл базы данных, используя функцию PCOUNT(), определяет, передала
 ли вызывающая процедура имя файла, который следует открыть. Если
 имя не передано, то функция OpenFile() запрашивает его имя:
 
 FUNCTION OpenFile( cFile)
 IF PCOUNT() = 0
 ACCEPT "Открыть файл : " TO cFile
 ENDIF
 USE (cFile)
 RETURN (NETERR())

Function PROCLINE()

 PROCLINE([<номер вызова>]) --> номер строки исходной программы

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

Текущий вызов - это номер строки вызова PROCLINE().

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

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

 В этом примере определяется номер строки, возвращаемый функцией
 PROCLINE() для текущего и предыдущего вызовов:
 
 //Первая строка исходной программы
 MyFunction()
 RETURN
 
 FUNCTION MyFunction
 ? PROCLINE()           // Результат: 6 (текущий вызов)
 ? PROCLINE(1)          // Результат: 2 (предыдущий вызов)
 RETURN NIL

Function 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

Function QOUT()

 QOUT([<список выражений>]) --> NIL
 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) })
 
 

Function SET()

 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)

Function SLEEP()

 SLEEP(<nSec>) 	--> NIL

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

  do while 100
 ? time()
 SLEEP(10.50)
 enddo
 

Function SYSCMD()

 SYSCMD(<sCmd>, <sStdin>, @<sResult>, @<sError>) 	--> <nResultCode>

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
 ?
 

Function ULIMIT()

 ULIMIT(<sResName>, <vLimitVal>) 	--> <vOldLimitValue>

ULIMIT() устанавливает новое значение <vLimitVal> на использование системного ресурса с именем <sResName> и возвращает старое значение этого ресурса.

Список возможных значений ресурсов см. в ulimit.ch

  #include <ulimit.ch>
 
 /* set the max size for stack */
 
 ? ULIMIT( ULIMIT_STACK, 1024 )
 

Function VERSION()

 VERSION() --> номер версии

VERSION() - функция среды, которая возвращает номер версии xClipper библиотеки EXTEND.LIB.