ADIR() | Заполняет группу массивов информацией директории. |
BZIP2CLOSE() | Закрывает bZIP2 файл. |
BZIP2OPEN() | Открывает bZIP2 файл. |
BZIP2READ() | Читает данные из bZIP2 файла. |
BZIP2WRITE() | Записывает данные в bZIP2 файл. |
CURDIR() | Возвращает имя текущей директории DOS. |
DIRCHANGE() | Change the current DOS directory |
DIRECTORY() | Создает массив с информацией о каталогах и файлах. |
DOSERROR() | Возвращает номер последней ошибки DOS. |
DOSPATH() | Возвращает имя файла как в DOS системах. |
FACCESS() | Проверка прав доступа к файлу. |
FCLOSE() | Закрывает открытый файл и записывает на диск буфер DOS. |
FCREATE() | Создает и/или сокращает двоичный файл до нулевой длины. |
FERASE() | Удаляет файл с диска. |
FERROR() | Проверяет наличие ошибок обработки двоичных файлов. |
FERRORSTR() | Under construction |
FILE() | Определяет, существует ли файл в текущей xClipper директории или по |
FILEATTR() | Under construction |
FILEATTRS() | Возвращает строку - атрибуты файла. |
FILEGETSTR() | Возвращает строку. |
FOPEN() | Открывает двоичный файл. |
FREAD() | Считывает символы из двоичного файла в буферную переменную. |
FREADSTR() | Считывает символы из двоичного файла. |
FRENAME() | Изменяет имя файла. |
FSEEK() | Устанавливает указатель двоичного файла на новую позицию. |
FT_DFCLOSE() | Close file displayed by FT_DISPFILE() |
FT_DFSETUP() | Set up parameters for FT_DISPFILE() |
FT_FAPPEND() | Appends a line to the currently selected text file |
FT_FBOF() | Determine if attempt to skip past beginning of text file |
FT_FDELETE() | Deletes a line from the currently selected text file |
FT_FEOF() | Determine if end of text file has been encountered |
FT_FERROR() | Return the error code for a text file operation |
FT_FGOBOT() | Go to the last record in a text file |
FT_FGOTO() | Move record pointer to specific record in a text file |
FT_FGOTOP() | Go to the first record in a text file |
FT_FINSERT() | Inserts a line in the currently selected text file |
FT_FLASTRE() | Get the no. of records in the currently selected text file |
FT_FREADLN() | Read a line from the currently selected text file |
FT_FRECNO() | Return the current record number of a text file |
FT_FSELECT() | Select a text file workarea |
FT_FSKIP() | Move the record pointer to a new position in a text file |
FT_FUSE() | Open or close a text file for use by the FT_F* functions |
FT_FWRITELN() | Write a line to the currently selected text file |
FWRITE() | Записывает информацию в открытый двоичный файл. |
GZIPCLOSE() | Закрывает GZIP файл. |
GZIPOPEN() | Открывает GZIP файл. |
GZIPREAD() | Читает данные из GZIP файла. |
GZIPWRITE() | Записывает данные в GZIP файл. |
MAKEPATH() | Возвращает путь к файлу в UNIX стиле. |
MEMOREAD() | Возвращает содержимое дискового файла как строку символов. |
MEMOWRIT() | Записывает символьную строку или memo-поле в дисковый файл. |
NETERR() | Индицирует сбой выполнения команд при работе в сети. |
OUTERR() | Выводит результаты вычисления выражений передаваемого списка на |
OUTSTD() | Записывает список выражений на стандартное устройство вывода. |
STARTPATH() | Возвращает полный путь и имя программы. |
TCPACCEPT() | Accept a connection on a socket. |
TCPCLOSE() | Закрыть соединение. |
TCPCONNECT() | Установить соединение с сервером. |
TCPLISTEN() | Слушать порт. |
TCPREAD() | Прочитать в буфер данные из соединения. |
TCPWRITE() | Передать данные из буфера в соединения. |
FACCESS(<sFileName>, <sMode>) --> TRUE || FALSE
Возвращает TRUE, если заданные права доступа к файлу истинны.
FACCESS() проверяет права доступа <sMode> к файлу <sFileName>.
<sMode> это строка в UNIX формате : "rwx-rwx-rwx" (владелец-группа-прочие)
FACCESS("/usr/home/user1/mbox", "rw--") // TRUE FACCESS("/usr/home/user1/mbox", "rw-rw-rw") // FALSE
FCLOSE(<номер файла>) --> признак ошибки
FCLOSE() возвращает "ложь"(.F.), если происходит ошибка при записи, в противном случае она возвращает "истину"(.Т.).
FCLOSE() является функцией обработки файлов низшего уровня, которая используется для закрытия двоичных файлов и чтобы обеспечить запись буферов DOS на диск. Если операция "неуспешна", FCLOSE() возвращает ложь" (.F.). Для установления точной причины "неуспеха" может быть использована функция FERROR(). Например, при попытке использовать FCLOSE() с неправильным значением номера файла возвращает "ложь" (.F.), a FERROR() возвращает код ошибки 6 DOS, "invalid handle". Смотрите полный список кодов ошибок в описании FERROR().
Предупреждение: Данная функция позволяет осуществлять доступ низкого уровня к файлам и устройствам DOS. Она должна использоваться чрезвычайно осторожно и требует хороших знаний операционной системы.
В следующем примере показано использование FCLOSE() для закрытия недавно созданного файла и выведение сообщения об ошибке, если его закрытие завершилось аварийно. #include "Fileio.ch" // nHandle = FCREATE("Testfile", FC_NORMAL) IF !FCLOSE(nHandle) ? "Ошибка закрытия файла, номер ошибки : ", FERROR() ENDIF
FCREATE(<имя файла>, [<атрибут>]) --> номер файла
<имя файла> | является именем файла, подлежащего созданию. Если файл |
уже существует, его длина сокращается до нуля без предупреждения. | |
<атрибут> | является одним из атрибутов двоичного файла, представленных |
в таблице ниже. Если этот аргумент пропущен, то его значение по | |
умолчанию равно нулю. | |
Атрибуты двоичного файла. --------------------------------------------------------------------- Значение Fileio.ch Атрибут Описание --------------------------------------------------------------------- 0 FC_NORMAL Обычный Создает обычный файл, доступный для чтения/записи (по умолчанию) 1 FC_READONLY Только для Создает файл только для чтения чтения 2 FC_HIDDEN Невидимый Создает невидимый файл 4 FC_SYSTEM Системный Создает системный файл --------------------------------------------------------------------- |
FCREATE() возвращает номер созданного нового двоичного файла DOS в диапазоне от 0 до 65535. Если в процессе создания файла происходит ошибка, FCREATE() возвращает значение (-1), а функция FERROR() устанавливается на соответствующий код ошибки.
FCREATE() является функцией обработки файлов низкого уровня, которая либо создает новый файл, либо открывает существующий файл и обрезает его до нулевой длины. Если файл с именем <имя файла> не существует, он создается и открывается для записи. Если же он существует и может быть открыт для записи, то сокращается до нулевой длины. Если его нельзя открыть для записи, FCREATE() возвращает значение (-1), а FERROR() устанавливается на соответствующий код ошибки.
Если функция FCREATE() успешно создает новый файл, он остается на все время работы до его закрытия доступным для ввода/вывода. Атрибут файла, устанавливаемый с помощью аргумента <атрибут>, подсоединяется к файлу при его закрытии, разрешая таким образом запись в новый созданный файл, даже если он был создан только для чтения. Список режимов доступа приводится в описании функции FOPEN().
Поскольку доступ других функций к открытому файлу производится через присвоенный ему номер, возвращаемое значение функции FCREATE() необходимо всегда переносить в переменную памяти.
Так же, как и на остальные функции обработки файлов, на функцию FCREATE() не влияют установки DEFAULT и PATH. Если явно не установлен маршрут, созданные файлы она размещает в текущей директории.
Предупреждение: Данная функция позволяет осуществлять доступ низкого уровня к файлам и устройствам DOS. Она должна использоваться чрезвычайно осторожно и требует хороших знаний операционной системы.
В следующем простом примере показано создание файла, называемого Testfile, и его открытие для чтения и записи: #include "Fileio.ch" // IF (nHandle := FCREATE("Testfile", FC_NORMAL)) = -1 ? "Файл не может быть создан: " FERROR() BREAK ELSE FWRITE(nHandle, "Привет Вам") FCLOSE(nHandle) ENDIF
FERASE(<имя файла>) --> признак завершения
При аварийном завершении FERASE() возвращает (-1) и 0, если удаление файла прошло успешно. В случае аварийного завершения функции для определения характера ошибки может быть использована функция FERROR().
FERASE() является функцией обработки файлов. Она удаляет указанный файл с диска. FERASE() аналогична команде ERASE, с той разницей, что она возвращает признак завершения и может использоваться как элемент выражения. Когда вызывается FERASE(), <имя файла> удаляется с диска только в том случае, если находится в текщей DOS директории, специфицированной как часть имени файла. Если путь доступа к удаляемому файлу не задан явно в аргументе <имя файла>, поиск удаляемого файла производится в текущей директории, так как установки SET DEFAULT и SET PATH на работу функции не влияют.
Предупреждение: Файлы должны быть закрыты перед удалением с помощью FERASE().
В данном примере показано, как удалить набор файлов, имена которых совпадают с произвольным шаблоном: #include "Directry.ch" AEVAL(DIRECTORY("*.BAK"), { | aFile | FERASE(aFile[F_NAME]) }) В следующем примере показано удаление файла и последующая выдача сообщения, если операция завершилась аварийно: IF FERASE("AFile.txt") = -1 ? "Ошибка удаления файла: ", FERROR() BREAK ENDIF
FILE(<шаблон поиска>) --> признак наличия
FILE() возвращает значение "истина"(.Т.), если найден хотя бы один файл, имя которого удовлетворяет шаблону поиска; в противном случае возвращается значение "ложь"(.F.).
FILE() является функцией среды и используется для определения, обнаружен ли какой-либо файл, имя которого соответствует заданному шаблону. Поиск производится в текущей директории или в соответствии с заданными явно именем устройства и маршрутом доступа. Если маршрут не задан, то FILE() просматривает текущую директорию, заданную в xClipper по умолчанию, а затем определенный в xClipper маршрут. Маршрут поиска, заданный в DOS, функцией ни в коем случае не учитывается. Следует также помнить, что FILE() не распознает в процессе поиска невидимые или системные файлы.
В данном примере показано, как FILE() пытается найти Sales.dbf в директории, которая не является текущей по умолчанию: ? FILE("Sales.dbf") // Результат: .F. ? FILE("\APPS\DBF\Sales.dbf") // Результат: .T. // SET PATH TO \APPS\DBF ? FILE("Sales.dbf") // Результат: .T. // SET PATH TO SET DEFAULT TO \APPS\DBF\ ? FILE("Sales.dbf") // Результат: .T. ? FILE("*.dbf") // Результат: .T.
FILEATTRS(<sFileName>) --> <sFileAttrs>
Возвращает строку <sFileAttrs>, содержащую атрибуты файла.
FILEATTRS() подобна функции FILEATTR(), но возвращает строку <sFileAttrs>, содержащую атрибуты файла.
SET("C:", "/usr/home/user1") sUnixFileName := "/usr/home/user1/test.prg" ? FILEATTR(sUnixFileName) // --> 32 ? FILEATTRS(sUnixFileName) // --> A
FILEGETSTR(<nFileHandle>, <nSize>) --> <sFileStr>
Возвращает строку <sFileStr>, прочитанную из файла <nFileHandle>.
FILEGETSTR() читает строку из ранее открытого файла. Размер строки ограничивается <CRLF> или <CR>, но не белее чем <nSize> символов.
nFile := FOPEN("test.txt") do while !feof(nFile) ? FILEGETSTR(nFile, 1024) ? enddo fclose()
FOPEN(<имя файла>, [<режим доступа>]) --> номер файла
<имя файла> | - это имя файла, подлежащего открытию, если необходимо, |
имя может включать в себя маршрут поиска. | |
<режим доступа> | является запрашиваемым режимом доступа к DOS, |
указывающим, как нужно осуществлять доступ к открытому файлу. | |
Ниже приведены допустимые режимы доступа: | |
FOPEN() Access Modes ------------------------------------------------------------------------ Mode Fileio.ch Operation ------------------------------------------------------------------------ 0 FO_READ Open for reading (default) 1 FO_WRITE Open for writing 2 FO_READWRITE Open for reading or writing ------------------------------------------------------------------------ | |
The Sharing Modes determine how other processes may access the file. | |
FOPEN() Sharing Modes ------------------------------------------------------------------------ Mode Fileio.ch Operation ------------------------------------------------------------------------ 0 FO_COMPAT Compatibility mode (default) 16 FO_EXCLUSIVE Exclusive use 32 FO_DENYWRITE Prevent others from writing 48 FO_DENYREAD Prevent others from reading 64 FO_DENYNONE Allow others to read or write 64 FO_SHARED Same as FO_DENYNONE ------------------------------------------------------------------------ | |
The Access Modes in combination (+) with the Sharing modes determine the | |
accessibility of the file in a network environment. |
FOPEN() возвращает номер открытого файла для дальнейшего использования в диапазоне от 0 до 65 535. Если при открытии файла возникает ошибка, FOPEN() возвращает (-1).
FOPEN() является функцией обработки файлов низкого уровня, которая открывает существующий двоичный файл для чтения или записи в зависимости от значения аргумента <режим доступа>. При аварийном завершении функции FOPEN() функция FERROR() возвращает код ошибки DOS. Например, если файл не существует, FOPEN() возвращает код (-1), а FERROR() возвращает код (2), что соответствует ошибке "файл не найден". Полный список кодов ошибок приведен в разделе FERROR().
Если заданный файл успешно открыт, возвращаемым значением является номер файла. Его значение подобно алиасу в системе базы данных и требуется для того, чтобы обеспечить доступ другим функциям для дальнейшей обработки файла. Поэтому всегда необходимо присваивать этот номер переменной, как показано ниже.
Предупреждение: Данная функция позволяет осуществлять доступ низкого уровня к файлам и устройствам DOS. Она должна использоваться чрезвычайно осторожно и требует хороших знаний операционной системы.
В следующем примере показано использование FOPEN() для открытия файла в режиме чтение/запись: #include "Fileio.ch" // nHandle = FOPEN("Temp.txt", FO_READWRITE) IF FERROR() != 0 ? "Не может открыть файл, ошибка DOS:", FERROR() BREAK ENDIF
FREAD (<номер обраб. файла>,@<имя переменной буфера>, <к-во байтов>) --> к-во байтов
<номер обраб. файла> | - это номер обрабатываемого файла, полученного с |
помощью функций FOPEN(), FCREATE() или предварительно определенный в | |
DOS. | |
<имя переменной буфера> | - имя существующей и проинициализированной |
переменной, используемой для сохранения данных, считанных из | |
заданного файла. Длина этой переменной должна быть больше или равна | |
значению аргумента <к-во байтов>. <имя переменной буфера> передается | |
по ссылке, и поэтому ему должен предшествовать оператор "передача по | |
ссылке" (@). | |
<к-во байтов> | - это количество байтов, которое должно быть считано в |
буфер. Значение, возвращаемое при успешном завершении FREAD(), должно | |
быть равно значению аргумента <к-во байтов>. |
FREAD() возвращает целое числовое значение, равное количеству успешно считанных байтов. Возвращаемое значение, меньшее чем <к-во байтов> или равное нулю, указывает на конец файла или какую-либо другую ошибку считывания.
FREAD() - это функция обработки файлов низкого уровня, которая считывает символы из двоичного файла в указанную переменную. Она считывает файл, начиная от текущей позиции указателя в файле DOS, продвигая этот указатель на количество считанных байтов. Считываются все символы, включая управляющие, нулевые и символы, имеющие значения кодов более CHR(127).
FREAD() до некоторой степени похожа на функции FREADSTR() и FSEEK(). FREADSTR() считывает заданное количество байтов из файла до следующего нулевого кода (CHR(0)). FSEEK() лишь перемещает указатель без считывания.
Если во время считывания файла возникает ошибка, то функция FERROR() возвращает код этой ошибки DOS. Для ознакомления с перечнем кодов ошибок смотри описание функции FERROR().
Предупреждение: Данная функция позволяет осуществлять доступ низкого уровня к файлам и устройствам DOS. Она должна использоваться чрезвычайно осторожно и требует хороших знаний операционной системы.
Следующий пример использует FREAD() после успешного открытия файла, чтобы считать 128 байтов в буферную область: #define F_BLOCK 128 // cBuffer = SPACE(F_BLOCK) nHandle = FOPEN("Temp.txt") // IF FERROR() != 0 ? "Ошибка открытия файла, номер ошибки:", FERROR() ELSE IF FREAD(nHandle, @cBuffer, F_BLOCK) <> F_BLOCK ? "Ошибка чтения файла Temp.txt" ENDIF ENDIF
FREADSTR(<номер обраб. файла>, <к-во байтов>) --> строка символов
FREADSTR() возвращает символьную строку длиной до 65 535 байтов (64К). Нулевое возвращаемое значение ("") указывает на ошибку или конец файла.
FREADSTR() - это функция обработки файлов низкого уровня, которая считывает символы из открытого двоичного файла, начиная с текущей позиции указателя файла DOS. Символы считываются до достижения значения аргумента <к-во байтов> или пока не будет встречен нулевой символ (CHR(0)). Затем указатель файла передвигается вперед на величину аргумента <к-во байтов>. Если <к-во байтов> больше, чем количество байтов от позиции указателя до конца файла, то указатель файла устанавливается на последний байт файла.
Предупреждение: Данная функция позволяет осуществлять доступ низкого уровня к файлам и устройствам DOS. Она должна использоваться чрезвычайно осторожно и требует хороших знаний операционной системы.
Следующий пример выводит значения кодов ASCII первых 16 байтов текстового файла: #include "Fileio.ch" // nHandle = FOPEN("New.txt", FC_NORMAL) IF FERROR() != 0 ? "Ошибка открытия файла:" FERROR() BREAK ELSE cString = FREADSTR(nHandle, 16) ? cString FCLOSE(nHandle) ENDIF
FRENAME(<старое имя файла>, <новое имя файла>) --> признак завершения
FRENAME() возвращает -1, если операция не удалась и 0, если она прошла успешно. В случае неудачи может быть использована функция FERROR() с тем, чтобы определить природу ошибки.
FRENAME() - это файловая функция, которая меняет старое имя файла на новое. Она идентична команде RENAME. При вызове FRENAME() файл с именем, заданным в аргументе <старое имя файла>, переименовывается только в том случае, если он расположен в текущей директории DOS или на заданном пути. FRENAME() не использует для поиска файла установки команд SET DEFAULT или SET PATH. Если исходная директория отличается от новой, то файл переносится в новую директорию. Если файл с именем <новое имя файла> существует, то FRENAME() возвращает (1). Это означает, что функция не выполнила предписанного ей действия. Характер ошибки может быть установлен с помощью функции FERROR().
Предупреждение: Файл должен быть закрыт перед переименованием. Попытка переименовать открытый файл приведет к непредсказуемым результатам. При переименовании файла базы данных, связанный с ним memo-файл (.dbt) также должен быть переименован. Невыполнение этих требований может нарушить правильность работы вашей программы.
Следующий пример демонстрирует, как переименовать файл: IF FRENAME ("OldFile.txt", "NewFile.txt") = -1 ? "Ошибка:", FERROR() BREAK ENDIF
FSEEK (<номер обраб. файла>, <смещение>, <начало перемещения>]) --> номер новой позиции
<номер обраб. файла> | - номер обрабатываемого файла, полученный с |
помощью функций FOPEN(), FCREATE() или предварительно определенный | |
в DOS. | |
<смещение> | - это количество байтов, на которые должен быть перемещен |
указатель файла с позиции, определенной аргументом <начало поиска>. | |
Его значение может быть положительным или отрицательным в зависимости | |
от направления перемещения указателя. | |
<начало перемещения> | - определяет начальное положение указателя файла |
перед выполнением FSEEK(). По умолчанию это нуль, соответствующий | |
началу файла. Если <начало поиска> - конец файла, то аргумент | |
<смещение> | должен быть нулевым или отрицательным. |
Методы перемещения указателя файла --------------------------------------------------------------------- Значение Fileio.ch Описание --------------------------------------------------------------------- 0 FS_SET Позиционирование от начала файла 1 FS_RELATIVE Позиционирование от текущей позиции указателя 2 FS_END Позиционирование от конца файла --------------------------------------------------------------------- |
FSEEK() возвращает значение новой позиции указателя файла относительно начала файла (позиции 0) в виде целого числа независимо от того, какой метод был выбран для перемещения.
FSEEK() - функция обработки файлов низкого уровня, которая перемещает указатель файла вперед или назад в открытом двоичном файле без реального считывания его содержания. Начальная позиция и смещение задаются как аргументы функции. Функция возвращает новую позицию указателя. Независимо от заданных аргументов функции указатель файла не может быть перемещен за границы начала и конца файла.
Предупреждение: Данная функция позволяет осуществлять доступ низкого уровня к файлам и устройствам DOS. Она должна использоваться чрезвычайно осторожно и требует хороших знаний операционной системы.
Следующий пример использует FSEEK(), чтобы определить длину файла путем установки указателя на последний байт файла. Затем указатель файла устанавливается на начало файла перемещением на нулевой байт: #include "Fileio.ch" // // Открытие файла IF (nHandle := FOPEN("Temp.txt") ) >= 0 // // Определение длины файла nLength := FSEEK(nHandle, 0, FS_END) // // Установка указателя на начало файла FSEEK (nHandle, 0) ELSE ? "Ошибка открытия файла:", FERROR() BREAK ENDIF Для позиционирования указателя на последний байт в двоичном файле используйте следующие псевдо-функции: define FileBottom(nHandle) (FSEEK(nHandle, 0, 2) ) Для позиционирования указателя на первый байт в двоичном файле используйте псевдо-функции, подобные этой: #define FileTop(nHandle) (FSEEK(nHandle, 0, 0) ) Чтобы получить текущую позицию указателя в заданном двоичном файле, используйте следующую псевдо-функцию: #define FilePos(nHandle) (FSEEK(nHandle, 0, 1) )
FT_DFCLOSE() -> NIL
No arguments
Closes the file opened by FT_DFSETUP()
@ 4,9 TO 11,71 FT_DFSETUP("test.txt", 5, 10, 10, 70, 1, 7, 15,; "AaBb" + Chr(143), .T., 5, 132, 4096) cKey = FT_DISPFILE() FT_DFCLOSE() @ 20,0 SAY "Key that terminated FT_DISPFILE() was: " + '[' + cKey + ']'
FT_DFSETUP( <cInFile>, <nTop>, <nLeft>, <nBottom>, <nRight>, ; <nStart>, <nCNormal>, <nCHighlight>, <cExitKeys>, ; <lBrowse>, <nColSkip>, <nRMargin>, <nBuffSize> ) -> nResult
<cInFile> | - text file to display (full path and filename) |
<nTop> | - upper row of window |
<nLeft> | - left col of window |
<nBottom> | - lower row of window |
<nRight> | - right col of window |
<nStart> | - line to place highlight at startup |
<nCNormal> | - normal text color (numeric attribute) |
<nCHighlight> | - text highlight color (numeric attribute) |
<cExitKeys> | - terminating key list (each byte of string is a |
key code) | |
<lBrowse> | - act-like-a-browse-routine flag |
<nColSkip> | - col increment for left/right arrows |
<nRMargin> | - right margin - anything to right is truncated |
<nBuffSize> | - size of the paging buffer |
0 if successful, FError() code if not
Note: make sure you allocate a buffer large enough to hold enough data for the number of lines that you have in the window. Use the following formula as a guideline:
buffer size = (# of line) + 1 * RMargin
This is the smallest you should make the buffer. For normal use, 4096 bytes is recommended
@ 4,9 TO 11,71 FT_DFSETUP("test.txt", 5, 10, 10, 70, 1, 7, 15,; "AaBb" + Chr(143), .T., 5, 132, 4096) cKey = FT_DISPFILE() FT_DFCLOSE() @ 20,0 SAY "Key that terminated FT_DISPFILE() was: " + '[' + cKey + ']'
FT_FAPPEND( [ < nLines > ] ) -> NIL
lSuccess. If FALSE, check ^bft_fError()^n for the error code.
This function appends a line of text to the file in the currently selected text file workarea. Text lines are delimited with a CRLF pair. The record pointer is moved to the last appended record.
Multiple lines may be appended with one call to FT_FAPPEND().
A text file "record" is a line of text terminated by a CRLF pair. Each line appended with this function will be empty.
NOTE: Occasionally a text file may contain a non-CRLF terminated line, at the end of the file ("stragglers"). This function assumes these stragglers to be the last line of the file, and begins appending the new lines after this line. In other words, if the last line in the text file is not terminated with a CRLF pair prior to calling FT_FAPPEND(), the function will terminate that last line before appending any new lines.
// add a blank line of text to a file FT_FUSE( "test.txt" ) ?FT_FRECNO() // displays 5 FT_FAPPEND() ?FT_FRECNO() // displays 6
FT_FBOF() -> lResult
No arguments
.T. if an attempt was made to skip past the first record of the currently selected text file, otherwise .F.
This function is similar to the CLIPPER Bof() function.
A text file "record" is a line of text terminated by a CRLF pair.
FT_FUSE( "FTTEXT.C" ) FT_FGOTOP() ? FT_FBOF() // .F. FT_FSKIP(-1) ? FT_FBOF() // .T.
FT_FDELETE( [ < nLines > ] ) -> lSuccess
No arguments
TRUE if successful, otherwise check ^ft_fError()^n for error code.
This function deletes one or several lines of text from the file in the currently selected text file workarea. Text lines are delimited with a CRLF pair. The record pointer is not moved, unless the deleted lines occur at the end of the file, in which case ^bft_fRecno()^n will equal ^bft_fLastRe()^n and ^bft_fEOF()^n will be set to TRUE.
// delete the next 4 lines from a file FT_FUSE( "test.txt" ) FT_FDELETE( 4 )
FT_FEOF() -> lResult
No arguments
.T. if an attempt was made to skip past the last record of the currently selected text file, otherwise .F.
This function is similar to the CLIPPER Eof() function.
A text file "record" is a line of text terminated by a CRLF pair.
FT_FUSE( "FTTEXT.C" ) ? FT_FEOF() // .F. FT_FSKIP() ? FT_FEOF() // .T.
FT_FERROR() -> nErrorNo
No arguments
The DOS error code if one occurred. See a reference on DOS error codes for an explanation of what the code means.
This function returns the DOS error code associated with a file operation on the currently selected text file.
Errors could stem from any open, create, read or write operation, among others.
if ft_fUse( "text.c" ) < 0 // open text file err := ft_fError(); QOUT( 'Error opening file "Text.c", error code (' + ; LTRIM( STR( err ) ) + ')' ) endif
FT_FGOBOT() -> NIL
No arguments
This function moves the record pointer to the last record of the file in the currently selected text file workarea.
If a read error occurs ^ft_fError()^n will contain the error code.
A text file "record" is a line of text terminated by a CRLF pair.
// read last line FT_FUSE( "text.c" ) FT_FGOBOT() ? FT_FREADLN()
FT_FGOTO( nLine ) -> NIL
This function moves the record pointer to a specific record in the file in the currently selected text file workarea. If the record number requested is greater than the number of records in the file, the record pointer will be positioned at the last record.
Internally, the function operates differently depending on how you invoke it. Passing a value for ^b<nLine>^n results in what is effectively a skip operation, which is fairly quick. However if you pass 0 for ^b<nLine>^n, e.g. ft_fGoTo( 0 ), the function internally goes to the top of the file, then skips down the required number of records. Hence if your file is relatively large and the current record is a high number, you may see some delay as ft_fGoTo(0) skips through the file.
A text file "record" is a line of text terminated by a CRLF pair.
// read 5th line of text from file ft_fUse( "FTTEXT.C" ) ft_fGoTo(5) cText := ft_fReadLN()
FT_FGOTOP() -> NIL
No arguments
This function moves the record pointer to the first record in the currently selected text file workarea.
A text file "record" is a line of text terminated by a CRLF pair.
FT_FUSE( "text.c" ) // open text file DO WHILE !FT_FEOF() ? FT_FREADLN() // read thru file FT_FSKIP() ENDDO FT_FGOTOP() // go back to top ? FT_FRECNO() // 1
FT_FINSERT( [ < nLines > ] ) -> lSuccess
No arguments
^blSuccess^n is TRUE if the insert succeeded, FALSE if not. If false check the return value of ^bft_fError()^n for the reason.
This function inserts a line of text in the file in the currently selected text file workarea. Text lines are delimited with a CRLF pair.
The record pointer is not moved.
A text file "record" is a line of text terminated by a CRLF pair. Each line inserted with this function will be empty.
// add a couple of blank lines of text to a file ft fUse( "test.txt" ) ft_fGoTo( 10 ) ft_fInsert( 5 )
FT_FLASTRE() -> nLastRecordNum
No arguments
An integer containing the number of records in the text file in the currently selected text file workarea, or zero if no file is currently open in the workarea.
This function returns the number of the last record in a text file.
A text file "record" is a line of text terminated by a CRLF pair.
FT_FUSE( "text.c" ) ? FT_FLASTRE()
FT_FREADLN() -> cLine
No arguments
A string containing the current record in a text file.
This function returns a line of text read from the file in the currently selected text file workarea. Text lines are delimited with a CRLF pair. The record pointer is not moved.
Currently the maximum record size is 4096 characters. You may increase the maximum record size by changing the value of ^b#define ^bBUFFSIZE^n in the C source and recompiling, however you should consider the performance implications if you do (all read and writes use this buffer size, including ft_fSkip()'s and ft_fGoto()'s).
If a read error occurs ^ft_fError()^n will contain the error code.
A text file "record" is a line of text terminated by a CRLF pair.
// display each record of a text file FT_FUSE( "text.c" ) DO WHILE ! FT_FEOF() ? FT_FREADLN() FT_FSKIP() ENDDO
FT_FRECNO() -> nRecNo
No arguments
The current record number of a text file or 0 if no file is open.
This function returns the current record number of the file open in the currently selected text file workarea.
A text file "record" is a line of text terminated by a CRLF pair.
FT_FUSE( "text.c" ) // open text file DO WHILE !FT_FEOF() ? FT_FREADLN() // read thru file FT_FSKIP() ENDDO FT_FGOTOP() // go back to top ? FT_FRECNO() // 1
FT_FSELECT( [ <nNewArea> ] ) -> nPreviousArea
No arguments
The current selected text file area.
This function selects a text file "workarea" from 1 to 10. A file may or may not be open in the selected area.
Passing 0 for ^b<nNewArea>^n selects the next available workarea, similar to Clipper's SELECT 0 command. If no more workareas are available the current workarea is not changed.
Each file is opened in its own "workarea", similar to the concept used by dbf files. As provided, a maximum of 10 files (in 10 workareas) can be opened (assuming there are sufficient file handles available). That number may be increased by modifying the #define TEXT_WORKAREAS in the C source code and recompiling.
All the FT_F*() file functions operate on the file in the currently selected text file workarea.
Text file workareas are separate from and independent of Clipper's database workareas.
FT_FSELECT(1) nFile1 := FT_FUSE( "temp.c" ) ? FT_FLASTRE() // no. of lines in temp.c FT_FSELECT(2) nFile2 := FT_FUSE( "temp.h" ) ? FT_FLASTRE() // no. of lines in temp.h
FT_FSKIP( [ <nLines> ] ) -> nLinesSkipped
The number of lines actually skipped. If the file's EOF or BOF was encountered before ^b<nLines>^n could be skipped, the return value will be less than ^b<nLines>^n.
This function moves the text file record pointer, similar to the CLIPPER SKIP command.
Use the return value to determine how many records were actually skipped, for example to write a custom skipper function for TBrowse'g text files.
If a read error occurs ^ft_fError()^n will contain the error code.
A text file "record" is a line of text terminated by a CRLF pair.
// display each record of a text file FT_FUSE( "text.c" ) DO WHILE ! FT_FEOF() ? FT_FREADLN() FT_FSKIP() ENDDO
FT_FUSE( [ <cFile> ] [, <nMode> ] ) -> nHandle | 0
No arguments
If ^b<cFile>^n is passed and the file is opened successfully, an integer containing the text file's workarea. If the file cannot be opened, -1 will be returned. In this case, check the return value of ^bft_fError()^n for the cause of the error.
If FT_FUSE() is called without any arguments, it will close the text file in the current "text area" and return 0.
If a read error occurs ^ft_fError()^n will contain the error code.
The FT_F*() file functions are for reading text files, that is, files where each line (record) is delimited by a CRLF pair.
Each file is opened in its own "workarea", similar to the concept use by dbf files. As provided, a maximum of 10 files (in 10 workareas) can be opened (assuming there are sufficient file handles available). That number may be increased by modifying the #define TEXT_WORKAREAS in the C source code and recompiling.
#include "fileio.ch" // open a text file for reading ft_fUse( "text.txt" ) // open a text file for reading and writing ft_fUse( "text.txt", FO_READWRITE + FO_SHARED ) // close file ft_fUse()
FT_FWRITELN( < cData >, [ < lInsert > ] ) -> lSuccess
<cData> | is a string of data to write to the file at the current |
record position. | |
<lInsert> | is a logical indicating whether the contents |
of the current record are to be preserved, that is, if lInsert | |
evaluates to .T., the a new record is inserted at the current | |
position. The current record then is pushed down to FT_FRECNO()+1. | |
If lInsert is .F. or omitted, the current record is replaced by | |
cData. | |
TRUE if successful, otherwise check ^ft_fError()^n for error code.
This function writes a line of text to the file in the currently selected text file workarea. Text lines are delimited with a CRLF pair. The record pointer is not moved.
The contents of the current record are updated to reflect the new new line written, unless the Insert option is selected.
Writing a null string has the effect of clearing the current line if in overstrike mode, else inserting a new line (same as FT_FINSERT()).
A text file "record" is a line of text terminated by a CRLF pair.
// write a line of text to a file FT_FUSE( "config.sys" ) DO WHILE UPPER( FT_FREADLN() ) != "FILES=" .AND. !F_FEOF() FT_FSKIP() ENDDO FT_FWRITELN( "FILES=30", FT_FEOF() )
FWRITE (<номер файла>, <символьная строка>, [<к-во записываемых байтов>]) --> к-во записанных байтов
<номер файла> | - номер обрабатываемого файла, полученный с помощью |
функций FOPEN(), FCREATE() или предварительно определенный в DOS. | |
<символьная строка> | - это строка для записи в заданный файл. |
<к-во записываемых байтов> | - указывает количество байтов для записи, |
начиная с текущей позиции указателя файла. Если этот аргумент опущен, | |
записывается все содержимое аргумента <символьная строка>. |
FWRITE() возвращает количество записанных байтов в виде целого числового значения. Если возвращаемое значение равно значению аргумента <к-во записываемых байтов>, то операция прошла успешно. Если возвращаемое значение меньше, чем <к-во записываемых байтов>, или равно нулю, то либо полностью заполнен диск, либо имеет место какая-то другая ошибка.
FWRITE() - функция обработки файлов низкого уровня, используемая для записи данных в двоичный файл из буферной символьной строки. Вы можете записать как весь буфер, так и часть его содержимого. Запись начинается с текущей позиции в файле. Функция возвращает реальное количество записанных байтов.
При аварийном завершении функции FWRITE() уточнить причину ошибки можно при помощи функции FERROR(), которая возвратит код ошибки DOS.
Предупреждение: Данная функция позволяет осуществлять доступ низкого уровня к файлам и устройствам DOS. Она должна использоваться чрезвычайно осторожно и требует хороших знаний операционной системы.
Этот пример копирует содержимое одного файла в другой: #include "Fileio.ch" #define F_BLOCK 512 // cBuffer = SPACE(F_BLOCK) nInfile = FOPEN("Temp.txt", FO_READ) nOutfile = FCREATE("Newfile.txt", FC_NORMAL) lDone = .F. // DO WHILE !lDone nBytesRead = FREAD(nInfile, @cBuffer, F_BLOCK) IF FWRITE (nOutfile, cBuffer, nBytesRead) < nBytesRead ? "Ошибка записи: ", FERROR() lDone = .T. ELSE lDone = (nBytesRead == 0) ENDIF ENDDO // FCLOSE(nInfile) FCLOSE(nOutfile)
OUTERR(<список выражений>) --> NIL
OUTERR() всегда возвращает NIL.
Функция OUTERR() идентична функции OUTSTD(), за исключением того, что вывод осуществляется на стандартное устройство для сообщений об ошибках, а не на стандартное устройство вывода. Вывод направляется на стандартное устройство вывода сообщений об ошибках, минуя xClipper-консоль и выходные устройства, тем же способом, как и переназначение вывода в DOS. Это обычно используется для ведения журнала сообщений об ошибках, отделяющего их от стандартного вывода на экран или на принтер.
Следующий пример демонстрирует вывод на экран сообщения об ошибке в сопровождении даты и времени: OUTERR( "Ошибка блокировки файла",DATE(),TIME() )
OUTSTD(<список выражений>) --> NIL
OUTSTD() всегда возвращает NIL.
Функция OUTSTD() похожа на функцию QOUT(), за исключением того, что вывод осуществляется на стандартное устройство вывода, а не на консоль. Программы с простыми требованиями к выходным форматам (не осуществляющие полноэкранного ввода или вывода) могут использовать эту функцию для того, чтобы избежать прикомпоновки подсистемы терминального вывода. Для переопределение команд ? и ?? с использованием функции OUTSTD() вместо QOUT() может использоваться файл описаний Simplio.ch.
Так как OUTSTD() посылает вывод на стандартное устройство вывода, то этот вывод может быть перенаправлен, используя символы DOS (>,|) в файл или канал. За более подробной информацией обратитесь к документации по операционной системе.
Следующий пример использует OUTSTD() для вывода списка выражений: OUTSTD(Name, PADR(RTRIM(City) + "," + State, 20), ZipCode) В этом примере показывается, как перенаправить вывод из xClipper-программы в новый файл, используя DOS-оператор >: C>MYPROG > FILE.TXT
Пред. | Начало | След. |
OBJECT | Уровень выше | DOS/BIOS |