call

Синтаксис: call(a)
Описание: Вызывает процедуру на машинном языке, которая начинается по адресу a. Для обратной передачи управления Euphoria эта процедура должна выполнить инструкцию RET (#C3). Процедура должна сохранить и восстановить любые регистры, которые она использует.
Комментарии: Вы можете подготовить блок памяти для процедуры и затем по этим адресам разместить байты машинного кода. Вы можете подготовить другие блоки памяти для данных и параметров, которыми машинный код может оперировать. Адреса этих блоков могут быть размещены в машинном коде.
Пример программы: demo\dos32\callmach.ex
См. также: allocate, free, peek, poke, poke4

call_back

Платформа: WIN32, Linux
Синтаксис: include dll.e
a = call_back(i)
Описание: Получает машинный адрес для Euphoria-подпрограммы по идентификатору процедуры i. Этот адрес может использоваться Windows, или внешней функцией C в .dll, или общей библиотекой Linux (.so), как 32-битный "обратный" адрес для вызова вашей Euphoria-подпрограммы.
Комментарии: Вы можете установить столько обратных подпрограмм, сколько вам нужно, но все они должны быть Euphoria-функциями (или типами) с числом аргументов от 0 до 9.

Когда ваша подпрограмма вызвана, все аргументы будут 32-битными числами без знака (положительными), поэтому вы должны объявить каждый параметр в вашей подпрограмме как atom, независимо от вашего желания устроить более жесткий контроль. Ваша процедура должна выдавать 32-битную целочисленную величину.

Пример программы: demo\win32\window.exw, demo\linux\qsort.exu
См. также: routine_id, platform.doc

c_func

Платформа: WIN32, Linux
Синтаксис: a = c_func(i, s)
Описание: Вызывает C-функцию с идентификатором процедуры i. i должно быть разрешенным идентификатором, выданным функцией define_c_func(). s является рядом длины n, содержащим аргументы, где n - число аргументов, требуемых функцией. a будет содержать результат, выданный C-функцией.
Комментарии: Если C-функция не требует подачи никаких аргументов, тогда ряд s должен быть пустым рядом {}.

Если в качестве аргумента вы подаете величину, которая содержит дробную часть, когда С-функция ожидает тип integer С, аргумент будет округлен в сторону нуля, т.е. 5.9 будет подано как 5, а -5.9 будет подано как -5.

Функция C может входить в состав .dll, созданной транслятором с Euphoria на C.

Пример:
atom user32, hwnd, ps, hdc
integer BeginPaint

-- открывает user32.dll - она содержит С-функцию BeginPaint
user32 = open_dll("user32.dll")

-- C-функция  BeginPaint требует аргумент C-int и
-- C-указатель, и выдает C-int как результат:
BeginPaint = define_c_func(user32, "BeginPaint",
                           {C_INT, C_POINTER}, C_INT)

-- вызывает BeginPaint, подавая hwnd и ps как аргументы,
-- hdc содержит результат:
hdc = c_func(BeginPaint, {hwnd, ps})

См. также: c_proc, define_c_func, open_dll, platform.doc

c_proc

Платформа: WIN32, Linux
Синтаксис: c_proc(i, s)
Описание: Вызыает C-функцию, используя идентификатор процедуры i. i должен быть разрешенным идентификатором процедуры, выданным функцией define_c_proc(). s является рядом длины n, содержащим аргументы, где n - число аргументов, требуемых функцией.
Комментарии: Если C-функция не требует подачи никаких аргументов, то ряд s должен быть пустым рядом {}.

Если в качестве аргумента вы подаете величину, которая содержит дробную часть, когда С-функция ожидает тип integer С, аргумент будет округлен в сторону нуля, т.е. 5.9 будет подано как 5, а -5.9 будет подано как -5.

Пример:
atom user32, hwnd, rect
integer GetClientRect

-- открывает user32.dll - она содержит C-функцию GetClientRect
user32 = open_dll("user32.dll")

-- GetClientRect является VOID C-функцией, которая требует C-int
-- и C-указатель в качестве аргументов:
GetClientRect = define_c_proc(user32, "GetClientRect",
                              {C_INT, C_POINTER})

-- подает hwnd и rect как аргументы
c_proc(GetClientRect, {hwnd, rect})

См. также: c_func, define_c_proc, open_dll, platform.doc

call_func

Синтаксис: x = call_func(i, s)
Описание: Вызывает вами-определенную Euphoria-функцию с идентификатором процедуры i. i должен быть разрешенным идентификатором, выданным routine_id(). s является рядом длины n, содержащим аргументы, где n - число аргументов, требуемых функцией i. x будет содержать результат, выданный функцией i.
Комментарии: Если функция i не требует подачи никаких аргументов, тогда ряд s должен быть пустым рядом {}.
Пример программы: demo\csort.ex
См. также: call_proc, routine_id

call_proc

Синтаксис: call_proc(i, s)
Описание: Вызывает вами-определенную Euphoria-процедуру с идентификатором процедуры i. i должен быть разрешенным идентификатором, выданным routine_id(). s является рядом длины n, содержащим аргументы, где n - число аргументов, требуемых процедурой i.
Комментарии: Если процедура i не требует подачи никаких аргументов, тогда ряд s должен быть пустым рядом {}.
Пример:
global integer foo_id

procedure x()
    call_proc(foo_id, {1, "Hello World\n"})
end procedure

procedure foo(integer a, sequence s)
    puts(a, s)
end procedure

foo_id = routine_id("foo")

x()

См. также: call_func, routine_id

chdir

Синтаксис: include file.e
i = chdir(s)
Описание: Изменяет текущий каталог по пути, который задан рядом s. s должен содержать имя каталога, существующего на данной машине. В случае успешного изменения каталога chdir() выдает 1. Если перейти в заданный каталог не удалось, chdir() выдает 0.
Комментарии: Переходя в необходимый вам каталог, вы можете затем обращаться к файлам в этом каталоге, указывая только имя файла, без упоминания полного пути к этому файлу.

Функция current_dir() выдает имя текущего каталога.

Под DOS32 и WIN32 текущий каталог является общим для всех программ, исполняемых из одной оболочки. Под Linux дочерние программы могут изменять текущий каталог для своих нужд, но эти изменения не будут относиться к текущему каталогу родительской программы.

Пример:
if chdir("c:\\euphoria") then
    f = open("readme.doc", "r")
else
    puts(1, "Error: No euphoria directory?\n")
end if
См. также: current_dir

check_break

Синтаксис: include file.e
i = check_break()
Описание: выдает число нажатий control-c или control-Break, имевших место с момента последнего вызова check_break(), или с начала программы, если этот вызов первый.
Комментарии: Данная функция полезна, если действует allow_break(0), которая запрещает прерывание вашей программы по control-c и control-Break. Вы можете использовать check_break(), чтобы выяснить, не нажимал ли пользователь одно из этих сочетаний клавиш. Затем вы можете сделать то, что требуется для грациозного и изысканного завершения вашей программы без малейшего риска потери данных и повреждений файловой системы на диске.

Ни control-c, ни control-Break не будут выданы как управляющие символы, когда вы читаете клавиатуру. Вы можете только обнаружить их, вызвав check_break().

Пример:
k = get_key()
if check_break() then
    temp = graphics_mode(-1)
    puts(1, "Программа завершается...")
    save_all_user_data()
    abort(1)
end if

См. также: allow_break, get_key

clear_screen

Синтаксис: clear_screen()
Описание: Очищает экран, заполняя его текущим фоновым цветом (этот цвет может быть задан с помощью bk_color()).
Комментарии: Процедура работает во всех текстовых и графических режимах.
См. также: bk_color, graphics_mode

close

Синтаксис: close(fn)
Описание: Закрывает файл или устройство, завершив вывод символов, еще остававшихся в буфере.
Комментарии: Когда ваша программа завершается при нормальном ее течении, все открытые файлы закрываются автоматически, если не были закрыты ранее с помощью close(fn).
См. также: open, flush

command_line

Синтаксис: s = command_line()
Описание: Выдает ряд строк, где каждая строка является словом из командной строки, которой запущена ваша программа. В первом слове будет путь к интерпретатору Euphoria ex.exe, exw.exe или exu, или к вашему связанному исполняемому файлу. В следующем слове будет или имя вашего Euphoria .ex файла, или (опять же) путь к вашему связанному исполняемому файлу. Затем будут идти любые дополнительные слова, введенные пользователем. Вы можете использовать эти слова в вашей программе. Пользователь может брать серии из слов в кавычки, чтобы превратить серию в единственный аргумент.
Комментарии: Собственно интерпретаторы Euphoria не используют никаких аргументов командной строки. Вы можете использовать любые аргументы по своему усмотрению для своих собственных программ.

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

Пример 1:
-- Пользователь вводит:  ex myprog myfile.dat 12345 "the end"

cmd = command_line()

-- cmd будет равно:
      {"C:\EUPHORIA\BIN\EX.EXE",
       "myprog",
       "myfile.dat",
       "12345",
       "the end"}

Пример 2:
-- Ваша программа связана под именем "myprog.exe"
-- и помещена в каталог c:\myfiles
-- Пользователь вводит:  myprog myfile.dat 12345 "the end"

cmd = command_line()

-- cmd будет равно:
       {"C:\MYFILES\MYPROG.EXE",
        "C:\MYFILES\MYPROG.EXE", -- заполнитель
        "myfile.dat",
        "12345",
        "the end"}

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

См. также: getenv

compare

Синтаксис: i = compare(x1, x2)
Описание: Выдает 0, если объекты x1 и x2 идентичны, 1, если x1 больше чем x2, -1, если x1 меньше чем x2. Считается, что атомы меньше рядов. Ряды сравниваются "по алфавиту", начиная с первого элемента, пока не найдено различие.
Пример 1:
x = compare({1,2,{3,{4}},5}, {2-1,1+1,{3,{4}},6-1})
-- идентичны, x равно 0

Пример 2:
if compare("ABC", "ABCD") < 0 then   -- -1
    -- будет истина, так как ABC  "меньше", потому что короче
end if

Пример 3:
x = compare({12345, 99999, -1, 700, 2},
            {12345, 99999, -1, 699, 3, 0})
-- x будет равно 1, так как 700 > 699

Пример 4:
x = compare('a', "a")
-- x будет равно -1, так как 'a' является атомом
-- в то время как "a" является рядом

См. также: equal, операторы отношения, операции на рядах

cos

Синтаксис: x2 = cos(x1)
Описание: Вычисляет косинус x1, где x1 выражено в радианах.
Комментарии: Данная функция применима к атомам или ко всем элементам ряда.
Пример:
x = cos({.5, .6, .7})

-- x равно {0.8775826, 0.8253356, 0.7648422}

См. также: sin, tan, log, sqrt

crash_file

Синтаксис: include machine.e
crash_file(s)
Описание: Задает имя файла, s, предназначенного для вывода диагностической информации об ошибке, когда Euphoria вынуждена прервать исполнение вашей программы из-за ошибки времени компиляции или времени прогона.
Комментарии: Обычно Euphoria печатает диагностическое сообщение вроде "syntax error" или "divide by zero" на экране, одновременно распечатывая отладочную информацию в файле ex.err, расположенном в текущем каталоге. Вызывая crash_file(), вы можете управлять именами каталога и файла, в который будет записываться отладочная информация.

s может быть пустым, т.е. "". В этом случае диагностическая или отладочная информация не будет выводиться ни на экран, ни в файл. s может также быть "NUL" или "/dev/null", в этом случае диагностическая информация будет выводиться на экран, но в файл ex.err ничего не будет записано.

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

Пример:
crash_file("\\tmp\\mybug")

См. также: abort, crash_message, отладка и профилирование

crash_message

Синтаксис: include machine.e
crash_message(s)
Описание: Определяет строку s, которая будет выведена на экран в случае, если Euphoria остановит вашу программу из-за ошибки времени компиляции или времени прогона.
Комментарии: Обычно Euphoria печатает диагностическое сообщение на экране, такое как "syntax error"(синтаксическая ошибка) или "divide by zero" (деление на ноль), сопровождая его распечаткой отладочной информации в файле ex.err. Эти сообщения Euphoria об ошибках будут малопонятны для тех пользователей ваших программ, которые не являются программистами Euphoria. Вызывая crash_message(), вы сможете управлять сообщениями, появляющимися на экране. При этом отладочная информация будет еще и распечатываться в файле ex.err, так что вы не потеряете никаких данных об ошибке, пользуясь этой дополнительной возможностью.

s может содержать '\n', символ новой строки, поэтому ваше сообщение легко сделать исчерпывающе подробным, причем на вашем родном языке, а не на английском, на котором Euphoria делает свои сообщения. Перед выводом сообщения Euphoria переключит экран в текстовый режим, и начнет печать с верхней строки чистого экрана.

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

Пример:
crash_message("Обнаружена неизвестная ранее ошибка!\n" &
              "Пожалуйста, свяжитесь с john_doe@whoops.com\n" &
              "Не удаляйте файл file \"ex.err\".\n")

См. также: abort, crash_file, отладка и профилирование

current_dir

Синтаксис: include file.e
s = current_dir()
Описание: Выдает имя текущего рабочего каталога.
Пример:
sequence s
s = current_dir()
-- s будет равно "C:\EUPHORIA\DOC", если вы находитесь в этом каталоге

См. также: dir, chdir, getenv

cursor

Синтаксис: include graphics.e
cursor(i)
Описание: Изменяет форму курсора. graphics.e содержит константы:
    global constant NO_CURSOR = #2000,
             UNDERLINE_CURSOR = #0607,
       THICK_UNDERLINE_CURSOR = #0507,
            HALF_BLOCK_CURSOR = #0407,
                 BLOCK_CURSOR = #0007
Вторая и четвертая шестнадцатиричные цифры (слева) определяют верхний и нижний ряд пикселов в изображении курсора. От первой цифры зависит, будет курсор видимым или нет. Например, #0407 включает с 4-го по 7-ой ряд пикселов.
Комментарии: В графических режимах курсор не виден.
Пример:
cursor(BLOCK_CURSOR)

См. также: graphics_mode, text_rows

custom_sort

Синтаксис: include sort.e
s2 = custom_sort(i, s1)
Описание: Сортирует элементы ряда s1, используя сравнивающую функцию с идентификатором процедуры i.
Комментарии: Ваша сравнивающая функция должна быть функцией двух аргументов наподобие Euphoria-функции compare(). Она должна сравнивать два объекта и выдавать -1, 0 или +1.
Пример программы: demo\csort.ex
См. также: sort, compare, routine_id

date

Синтаксис: s = date()
Описание: Выдает ряд со следующей информацией:
             {  год,  -- начиная с 1900
              месяц,  -- январь = 1
               день,  -- день месяца, начиная с 1
                час,  -- от 0 до 23
             минута,  -- от 0 до 59
            секунда,  -- от 0 до 59
        день недели,  -- воскресенье = 1
          день года}  -- 1 января = 1
Пример:
now = date()
-- now содержит: {95,3,24,23,47,38,6,83}
-- т.е. 1995, март 24, в 11:47:38 пополудни, пятница, день 83 года

Комментарии: Величина, выдаваемая для года, является числом лет, начиная с 1900, а не последними 2 цифрами года. В 2000 году эта величина составит 100. В 2001 это будет 101 и т.д.
См. также: time

define_c_func

Платформа: WIN32, Linux
Синтаксис: include dll.e
i1 = define_c_func(a, s1, s2, i2)
Описание: Определяет характеристики C-функции, которую вы хотите вызвать из вашей Euphoria-программы. Выдает небольшое целое, известное как идентификатор процедуры, или -1, если функция не может быть найдена. a является адресом, выданным open_dll(). s1 является именем функции. s2 содержит список параметров типов для функции. i2 является выходным типом функции. Список C-типов находится в файле dll.e:
    global constant C_CHAR = #01000001,
                   C_UCHAR = #02000001,
                   C_SHORT = #01000002,
                  C_USHORT = #02000002,
                     C_INT = #01000004,
                    C_UINT = #02000004,
                    C_LONG = C_INT,
                   C_ULONG = C_UINT,
                 C_POINTER = C_ULONG,
                   C_FLOAT = #03000004,
                  C_DOUBLE = #03000008
Функция C, которую вы определяете, может быть создана транслятором с Euphoria на C, в этом случае вы можете подавать в нее и получать из нее данные Euphoria. Список констант для типов Euphoria, который содержится в dll.e:
    global constant
		 E_INTEGER = #06000004,
		 E_ATOM    = #07000004,
		 E_SEQUENCE= #08000004,
		 E_OBJECT  = #09000004
Комментарии: Идентификатор процедуры i1 может быть подан в c_func(), если вы хотите вызвать C-функцию.

Вы можете подавать или получать любой целочисленный C-тип или тип указатель. Вы можете также подать атом Euphoria как C-double или число с плавающей точкой, и получать C-double или число с плавающей точкой, выданное вам как атом Euphoria.

В C (под WIN32 и Linux) типы параметров, которые используют 4 байта или меньше, все подаются одним и тем же способом, так что нет необходимости быть совершeнно точным. Тем не менее, когда вы определяете тип величины, выдаваемой функцией, учет знака может быть важным.

В настоящее время нет возможности подавать C-структуру по значению или получать C-структуру в качестве результата. Вы можете только подать указатель на структуру и получить указатель на структуру как результат.

Если вы не предполагаете использовать величины, выдаваемые C-функцией, вы должны вместо действий, описанных выше, определить ее с помощью define_c_proc(), а затем вызвать c_proc().

Пример:
atom user32
integer LoadIcon

-- открывает user32.dll - библиотека содержит C-функцию LoadIconA 
user32 = open_dll("user32.dll")

-- принимает C-указатель и C-int как параметры.
-- выдает C-int как результат.
LoadIcon = define_c_func(user32, "LoadIconA",
                         {C_POINTER, C_INT}, C_INT)
if LoadIcon = -1 then
    puts(1, "не удалось найти LoadIconA!\n")
end if

См. также: c_func, define_c_proc, c_proc, open_dll, platform.doc

define_c_proc

Платформа: WIN32, Linux
Синтаксис: include dll.e
i1 = define_c_proc(a, s1, s2)
Описание: Определяет характеристики C-функции, которую вы хотите вызвать как процедуру из вашей Euphoria-программы. Выдает небольшое целое, известное как идентификатор процедуры, или -1, если функция не может быть найдена. a является адресом, выданным open_dll(). s1 содержит имя функции. В s2 находится список параметров типов для функции. Перечень C-типов включен в файл dll.e.

Функция C, которую вы определяете, может быть создана транслятором с Euphoria на C, в этом случае вы можете подавать в нее и получать из нее данные Euphoria. Перечень констант для типов Euphoria содержится в dll.e и показан выше.

Комментарии: Идентификатор процедуры i1 может быть подан в процедуру c_proc(), когда вы хотите вызвать C-функцию.

Вы можете подавать любой C-int тип или указатель. Вы можете подавать также атом Euphoria как C-double или число с плавающей точкой.

В C (под WIN32 и Linux), параметры типов, которые занимают 4 байта или меньше, подаются одним и тем же способом, так что нет необходимости быть исключительно точным.

В настоящее время нет возможности подавать C-структуру по значению. Вы можете только подать указатель на структуру.

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

Пример:
atom user32
integer ShowWindow

-- открывает user32.dll - эта библиотека содержит C-функцию ShowWindow 
user32 = open_dll("user32.dll")

-- функция имеет 2 параметра, оба типа C-int.
ShowWindow = define_c_proc(user32, "ShowWindow", {C_INT, C_INT})
if ShowWindow = -1 then
    puts(1, "ShowWindow не найдена!\n")
end if

См. также: c_proc, define_c_func, c_func, open_dll, platform.doc

define_c_var

Платформа: WIN32, Linux
Синтаксис: include dll.e
a1 = define_c_var(a2, s)
Описание: a2 является адресом общей библиотеки Linux или Windows .dll, выданным open_dll(). s является именем глобальной переменной C, определенной внутри библиотеки. a1 будет адресом в памяти переменной s.
Комментарии: Как только вы получили адрес переменной C, и если вы знаете ее тип, вы можете использовать peek() и poke(), чтобы читать или записывать величину этой переменной.
Пример программы: euphoria/demo/linux/mylib.exu
См. также: c_proc, define_c_func, c_func, open_dll, platform.doc

dir

Синтаксис: include file.e
x = dir(st)
Описание: Выдает информацию о каталоге или о файле с именем st. Если такой каталог или файл не существует, выдает -1. Под Windows и DOS st может содержать символы догадок * и ?, чтобы выбрать многие файлы с похожими именами.

Выдаваемая информация близка к той, которую вы получаете по команде DIR DOS. Ряд, формируемый функцией, содержит вложенные ряды, каждый из которых описывает один файл или подкаталог.

Если st именует каталог, вы можете получить входы для "." и "..", точно так же, как по команде DIR DOS. Если же st именует файл, тогда x будет иметь только один вход, т.е. length(x) будет равна 1. Если st содержит догадки (шаблоны), вы можете получить многочисленные входы.

Каждый вход содержит имя, атрибуты файла и его размер, год, месяц, день, час, минуту и секунду последнего изменения. Вы можете обращаться к элементам входа с помощью следующих констант, определенных в файле file.e:

    global constant D_NAME = 1,
              D_ATTRIBUTES = 2,
                    D_SIZE = 3,

                    D_YEAR = 4,
                   D_MONTH = 5,
                     D_DAY = 6,

                    D_HOUR = 7,
                  D_MINUTE = 8,
                  D_SECOND = 9
Элемент атрибутов является строковым рядом, содержащим символы, выбранные из:
    'd' -- каталог
    'r' -- файл только для чтения
    'h' -- скрытый файл
    's' -- системный файл
    'v' -- идентификатор тома
    'a' -- подлежащий архивированию файл (т.н. архивный)
Обычный файл без специальных атрибутов в соответствующих полях будет иметь пустые строки, "".
Комментарии: Каталог высшего уровня, корневой, т.е. c:\ не будет иметь входов "." или "..".

Данная функция часто нужна, чтобы просто проверить, существует ли требуемый файл или каталог.

Под WIN32 st может содержать длинное имя файла или каталога в любом месте пути.

Под Linux в настоящее время пока доступен единственный атрибут 'd'.

DOS32: Имя файла, выдаваемое в элементе D_NAME, будет стандартным 8.3 DOS-именем. (Посетите Web-страницу Архив файлов, если вас интересует лучшее решение).

WIN32: Имя файла, выдаваемое в элементе D_NAME, будет длинным именем.

Пример:
d = dir(current_dir())

-- d, может иметь:
  {
    {".",    "d",     0  1994, 1, 18,  9, 30, 02},
    {"..",   "d",     0  1994, 1, 18,  9, 20, 14},
    {"fred", "ra", 2350, 1994, 1, 22, 17, 22, 40},
    {"sub",  "d" ,    0, 1993, 9, 20,  8, 50, 12}
  }

d[3][D_NAME] будет "fred"

Примеры программ: bin\search.ex, bin\install.ex
См. также: wildcard_file, current_dir, open

display_image

Платформа: DOS32
Синтаксис: include image.e
display_image(s1, s2)
Описание: Выводит в точке s1 на графическом экране 2-мерный ряд пикселов, содержащийся в s2. s1 - двухэлементный ряд {x, y}. s2 содержит ряды, каждый из которых представляет горизонтальную строчку значений цветов пикселов, которые необходимо включить на экране. Первый пиксел первого ряда расположен в точке s1. Это верхний левый пиксел. Все остальные пикселы расположены правее или ниже этого первого.
Комментарии: s2 может быть результатом предшествовавшего вызова save_image(), или read_bitmap(), или тем, что секундой ранее вы рисовали в своем воображении.

Ряды (строчки) изображения могут быть разной длины.

Пример:
 display_image({20,30}, {{7,5,9,4,8},
                         {2,4,1,2},
                         {1,0,1,0,4,6,1},
                         {5,5,5,5,5,5}})
-- будет выведено небольшое изображение, состоящее из 4-х строчек
-- пикселов. Первый пиксел (7) верхней строчки будет в точке
-- {20,30}. Верхняя строчка содержит 5 пикселов. Последняя строчка
-- содержит 6 пикселов и заканчивается в точке {25,33}.

Пример программы: demo\dos32\bitmap.ex
См. также: save_image, read_bitmap, display_text_image

display_text_image

Платформа: DOS32, Linux
Синтаксис: include image.e
display_text_image(s1, s2)
Описание: Выводит на экран 2-мерный ряд символов и атрибутов, содержащийся в s2, начиная со строки s1[1], колонки s1[2]. s2 состоит из вложенных рядов, каждый из которых является строкой выводимых символов и атрибутов. Верхний левый символ выводится в позиции s1. Другие символы появляются правее и ниже этой позиции. Атрибут показывает цвет предшествующего символа и цвет фона. Под DOS32 атрибут должен состоять из цвета символа плюс умноженный на 16 цвет фона.
Комментарии: s2 обычно будет результатом предыдущего вызова save_text_image(), хотя вы можете сконструировать этот ряд и сами.

Данная процедура работает только в текстовых режимах.

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

Ряды текстового изображения могут иметь разную длину.

Пример:
clear_screen()
display_text_image({1,1}, {{'A', WHITE, 'B', GREEN},
                           {'C', RED+16*WHITE},
                           {'D', BLUE}})
-- выводит:
     AB
     C
     D
-- в верхнем левом углу экрана.
-- 'A' будет белым на черном (0) фоне,
-- 'B' будет зеленым на черном, 
-- 'C' будет красным на белом и
-- 'D' будет синим на черном.

См. также: save_text_image, display_image, put_screen_char

dos_interrupt

Платформа: DOS32
Синтаксис: include machine.e
s2 = dos_interrupt(i, s1)
Описание: Вызывает программное прерывание DOS номера i. s1 является 10-элементным рядом 16-битных значений, заносимых в регистры процессора перед входом в процедуру прерывания. Ряд s2 похож на первый 10-элементный ряд, в нем будут содержаться значения регистров после выхода из процедуры прерывания. В файле machine.e имеется следующее объявление констант, из которого ясен порядок значений регистров во входном и выходном рядах:
    global constant REG_DI = 1,
                    REG_SI = 2,
                    REG_BP = 3,
                    REG_BX = 4,
                    REG_DX = 5,
                    REG_CX = 6,
                    REG_AX = 7,
                    REG_FLAGS = 8,
                    REG_ES = 9,
                    REG_DS = 10
Комментарии: Значения регистров, выдаваемые в s2, всегда являются положительными целыми числами между 0 и #FFFF (65535).

Значения флагов в s1[REG_FLAGS] на входе игнорируются. На выходе младший значащий бит в s2[REG_FLAGS] соответствует флагу состояния, который обычно указывает на неудачу, если он установлен в 1.

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

С программными прерываниями DOS вы имеете доступ ко всему широкому кругу специализированных операций, любых, от форматирования вашего флоппи-диска до перезагрузки компьютера. Документацию по этим прерываниям можно найти в книге Питера Нортона "Библия программиста", или в файле "Список прерываний" на странице Web Ральфа Брауна по адресу:

http://www.cs.cmu.edu/afs/cs.cmu.edu/user/ralf/pub/WWW/files.html

Пример:
sequence registers

registers = repeat(0, 10)  -- установка регистров не требуется

-- вызывается прерывание 5 DOS: Print Screen(Печать Экрана)
registers = dos_interrupt(#5, registers)

Пример программы: demo\dos32\dosint.ex
См. также: allocate_low, free_low

draw_line

Платформа: DOS32
Синтаксис: include graphics.e
draw_line(i, s)
Описание: Чертит линию на экране в графическом режиме, соединяющую две или более точек с координатами в s, используя цвет i.
Пример:
draw_line(WHITE, {{100, 100}, {200, 200}, {900, 700}})

-- будут соединены три точки
-- белой линией, т.е.  линия пройдет от {100, 100} к
-- {200, 200} и вторая линия пройдет от {200, 200} к
-- {900, 700}.

См. также: polygon, ellipse, pixel

 

... продолжение от E до G