palette

Платформа: DOS32
Синтаксис: include graphics.e
x = palette(i, s)
Описание: Изменяет оттенок для цвета номер i на s, где s является рядом интенсивностей составляющих цветов оттенка: {красный, зеленый, синий}. Каждая из составляющих s может иметь величину от 0 до 63. В случае успешного изменения выдает 3-х элементный ряд, содержащий величины составляющих цветов исходного цвета i, а все пикселы на экране, имевшие цвет i, приобретают новый оттенок. Если операция не удалась, выдается атом -1.
Пример:
x = palette(0, {15, 40, 10})
-- цвет номер 0 (обычно черный) изменен на оттенок
-- зеленоватого цвета.

См. также: all_palette

peek

Синтаксис: i = peek(a)
или ...
s = peek({a, i})
Описание: Выдает величину байта (в пределах от 0 до 255), считанного из памяти по машинному адресу a, или выдает ряд, содержащий i последовательных байтовых величин, начинающихся в памяти с адреса a.
Комментарии: Так как значения адресов выражаются 32-битными числами, они могут быть больше величины, представимой типом integer (31 бит). Поэтому переменные, которые содержат адреса, должны объявляться как atom.

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

Помните, что в функцию peek() подается единственный аргумент, который во второй форме является двухэлементным рядом.

Пример: Следующие записи равнозначны:

-- метод 1
s = {peek(100), peek(101), peek(102), peek(103)}

-- метод 2
s = peek({100, 4})

См. также: poke, peek4s, peek4u, allocate, free, allocate_low, free_low, call

peek4s

Синтаксис: a2 = peek4s(a1)
или ...
s = peek4s({a1, i})
Описание: Выдает 4-х байтную (32 бита) величину со знаком в диапазоне от -2147483648 до +2147483647, считанную с машинного адреса a1, или ряд, содержащий i последовательных 4-байтных величин со знаком, начинающихся с адреса a1 в памяти.
Комментарии: 32-х битные величины, выдаваемые функцией peek4s(), могут превышать допустимые для типа integer в Euphoria (31-бит), поэтому вы должны использовать переменные типа atom.

Так как машинные адреса являются 32-х битными числами, их величина может превышать допустимую для типа integer Euphoria. Поэтому переменные, в которых записываются адреса, должны быть объявлены как atom.

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

Не забывайте, что peek4s() требует единственного аргумента, который во второй форме является 2-х элементным рядом.

Пример: Следующие записи равнозначны:

-- метод 1
s = {peek4s(100), peek4s(104), peek4s(108), peek4s(112)}

-- метод 2
s = peek4s({100, 4})

См. также: peek4u, peek, poke4, allocate, free, allocate_low, free_low, call

peek4u

Синтаксис: a2 = peek4u(a1)
или ...
s = peek4u({a1, i})
Описание: Выдает 4-х байтную (32 бита) величину без знака в диапазоне от 0 до 4294967295, расположенную по машинному адресу a1, или выдает ряд из i таких величин, начинающийся с адреса a1 в памяти.
Комментарии: 32-х битная величина, выдаваемая peek4u(), может превышать допустимую для типа integer в Euphoria (31 бит), поэтому вы должны использовать переменные типа atom.

Так как машинные адреса являются 32-битными числами, они также могут быть за пределами типа integer Euphoria. Переменные, в которых содержатся адреса, должны быть объявлены как тип atom.

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

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

Пример: Следующие записи равнозначны:

-- метод 1
s = {peek4u(100), peek4u(104), peek4u(108), peek4u(112)}

-- метод 2
s = peek4u({100, 4})

См. также: peek4s, peek, poke4, allocate, free, allocate_low, free_low, call

PI

Синтаксис: include misc.e
PI
Описание: PI (3.14159...) число Пи определено как глобальная константа.
Комментарии: Принятое в определении число знаков Пи обеспечивает максимальную точность вычислений, возможную для типа atom в Euphoria.
Пример:
x = PI  -- x равно 3.14159...

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

pixel

Платформа: DOS32
Синтаксис: pixel(x1, s)
Описание: Включает один или несколько пикселов на пиксельно-графическом экране, начиная с точки s, где s является 2-х элементным рядом экранных координат {x, y}. Если x1 является атомом, включается один пиксел с цветом x1. Если x1 является рядом, включается ряд пикселов, начиная с точки s и вправо(возрастает x, y постоянное).
Комментарии: Когда x1 является рядом, применяется очень быстрый алгоритм включения пикселов на экране. Он значительно быстрее, чем поочередное включение пикселов через вызовы pixel() в цикле. Задавая ряд цветов пикселов, вы значительно быстрее выведете ряд пикселов, чем задавая ряд выводов разноцветных пикселов.

В графическом режиме 19 процедура pixel() особенно высоко оптимизирована.

Пример 1:
pixel(BLUE, {50, 60})
-- в точке {50,60} включится пиксел с цветом BLUE(синий)

Пример 2:
pixel({BLUE, GREEN, WHITE, RED}, {50,60})
-- {50,60} включится BLUE (синий)
-- {51,60} включится GREEN (зеленый)
-- {52,60} включится WHITE (белый)
-- {53,60} включится RED (красный)

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

platform

Синтаксис: i = platform()
Описание: platform() является функцией, встроенной в интерпретатор. Она обозначает, в среде какой операционной системы запущена программа, DOS32, WIN32 или Linux.
Комментарии: Когда работает ex.exe, считается, что операционная система DOS32. Когда работает exw.exe, то операционная система WIN32. Когда работает exu, то операционная система Linux.

В файле misc.e определены следующие константы:

    global constant DOS32 = 1,
                    WIN32 = 2,
                    LINUX = 3
Используйте функцию platform(), когда вам необходимо исполнять различный код в зависимости от операционной системы, в среде которой запущена ваша программа.

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

Вызов platform() не несет обычных накладных расходов. Во время компиляции просто вырабатывается соответствующая целочисленная величина: 1, 2 или 3.

Пример 1:
if platform() = WIN32 then
    -- вызывается процедура системного Beep
    err = c_func(Beep, {0,0})
elsif platform() = DOS32 then
    -- вызывается звуковой сигнал
    sound(500)
    t = time()
    while time() < t + 0.5 do
    end while
    sound(0)
else
    -- не происходит ничего (Linux)
end if

См. также: platform.doc

poke

Синтаксис: poke(a, x)
Описание: Если x является атомом, в память по адресу a записывается один байт.

Если же x является рядом, в память, начиная с адреса a, записывается последовательность байтов, представленная этим рядом.

Комментарии: В память записываются младшие 8 битов величины x, т.е. remainder(x, 256), а не сама величина х.

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

Вывод в экранную память с помощью poke() может быть намного быстрее, чем стандартная запись на экран с помощью процедур puts() или printf(), но программировать такой вывод более сложно. В большинстве случаев сверхвысокая скорость не требуется. Например, в редакторе ed.ex из пакета Euphoria poke() никогда не используется.

Пример:
a = allocate(100)   -- выделяется 100 байтов в памяти

-- заносится в память один байт за один вызов poke():
poke(a, 97)
poke(a+1, 98)
poke(a+2, 99)

-- заносится 3 байта сразу:
poke(a, {97, 98, 99})

Пример программы: demo\dos32\callmach.ex
См. также: peek, poke4, allocate, free, allocate_low, free_low, call, safe.e

poke4

Синтаксис: poke4(a, x)
Описание: Если x является атомом, в память по адресу a записывается 4 байта (32 бита).

Если x является рядом, в память, начиная с адреса a, записывается последовательность 4-байтовых величин, представленная этим рядом.

Комментарии: Величина или величины, предназначенные к записи, не должны превышать 32-битного значения.

Более быстрой является процедура записи сразу нескольких 4-байтовых величин, чем поочередная запись этих величин в цикле.

Записываемые 4-байтовые величины могут быть положительными или отрицательными. Считаны они могут быть затем с помощью или peek4s(), или peek4u().

Пример:
a = allocate(100)   -- выделяется 100 байтов в памяти

-- записывается одна 4-байтовая величина за каждый вызов poke4():
poke4(a, 9712345)
poke4(a+4, #FF00FF00)
poke4(a+8, -12345)

-- записывается три 4-байтовых величины сразу:
poke4(a, {9712345, #FF00FF00, -12345})

См. также: peek4u, peek4s, poke, allocate, allocate_low, call

polygon

Платформа: DOS32
Синтаксис: include graphics.e
polygon(i1, i2, s)
Описание: Вычерчивается многоугольник с 3-мя или более вершинами, заданными в s, на пиксельно-графическом экране с использованием цвета i1. Внутренняя область закрашивается, если i2 равно 1. Не закрашивается, если i2 равно 0.
Пример:
polygon(GREEN, 1, {{100, 100}, {200, 200}, {900, 700}})
-- вычерчивается сплошной зеленый треугольник.

См. также: draw_line, ellipse

position

Синтаксис: position(i1, i2)
Описание: Перемещает курсор на строку i1, в колонку i2, верхний левый угол экрана соответствует строке 1, колонке 1. Символ, выводимый на экран после этой команды, появится именно в назначенном месте. position() сообщит об ошибке, если предпринимается попытка задания знакоместа за пределами экрана.
Комментарии: position() работает и в текстовом, и в пиксельно-графическом режимах.

Система координат при отображении текста отличается от системы координат при отображении пикселов. Пикселы отображаются так, что верхний левый угол экрана соответствует координатам (x=0,y=0), а первая координата задает положение по горизонтали, слева направо. В пиксельно-графических режимах вы можете отображать и текст, и пикселы. Процедура position() действует только в отношении текста, положением пикселов она не управляет. Аналогичной процедуры для назначения следующей пиксельной позиции не существует.

Пример:
position(2,1)
-- курсор сдвигается к началу второй линии
-- сверху

См. также: get_position, puts, print, printf

power

Синтаксис: x3 = power(x1, x2)
Описание: Возводит x1 в степень x2
Комментарии: Аргументами данной функции могут быть атомы или ряды. В последнем случае применяются правила операций с рядами.

Степени 2 вычисляются очень быстро.

Пример 1:
? power(5, 2)
-- печатается 25

Пример 2:
? power({5, 4, 3.5}, {2, 1, -0.5})
-- печатается {25, 4, 0.534522}

Пример 3:
? power(2, {1, 2, 3, 4})
-- {2, 4, 8, 16}

Пример 4:
? power({1, 2, 3, 4}, 2)
-- {1, 4, 9, 16}

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

prepend

Синтаксис: s2 = prepend(s1, x)
Описание: Присоединяет x к началу ряда s1. Длина s2 будет равна length(s1) + 1.
Комментарии: Если x атом, эта операция дает то же, что и s2 = x & s1. Если же x ряд, то результат будет иным.

Случай, когда s1 и s2 являются одной и той же переменной, обрабатывается очень эффективно.

Пример 1:
prepend({1,2,3}, {0,0})   -- {{0,0}, 1, 2, 3}

-- Сравните со сцеплением (конкатенацией):

{0,0} & {1,2,3}           -- {0, 0, 1, 2, 3}

Пример 2:
s = {}
for i = 1 to 10 do
    s = prepend(s, i)
end for
-- s равно {10,9,8,7,6,5,4,3,2,1}

См. также: append, оператор сцепления &, оператор формирования ряда

print

Синтаксис: print(fn, x)
Описание: Выводит в файл или на устройство fn объект x со скобками { , , , }, чтобы показать (сохранить) его структуру.
Пример 1:
print(1, "ABC")  -- выводится:  {65, 66, 67}
puts(1, "ABC")   -- выводится:  ABC

Пример 2:
print(1, repeat({10,20}, 3))
-- выводится: {{10,20},{10,20},{10,20}}

См. также: ?, puts, printf, get

printf

Синтаксис: printf(fn, st, x)
Описание: Выводит x в файл или на устройство fn, используя строку формата st. Если x является атомом, печатается единственная величина. Если x ряд, формат из st применяется к следующим один за другим элементам ряда. Таким образом, printf() всегда ожидает точно трех аргументов. Длина последнего аргумента, содержащего выводимую величину, будет изменяться. Изменения могут происходить и в строке формата. Основные форматы:

%d - печатать атом как десятичное целое
%x - печатать атом как шестнадцатиричное целое
%o - печатать атом как восьмиричное целое
%s - печатать ряд как строку символов, или печатать атом как отдельный символ
%e - печатать атом как число с плавающей точкой в экспоненциальной форме
%f - печатать атом как число с плавающей точкой в форме с десятичной точкой, а не в экспоненциальной
%g - печатать атом как число с плавающей точкой, используя оба формата - %f или %e, какой окажется более подходящим
%% - печатать собственно символ '%'

К основным форматам может быть добавлена ширина полей, т.е. %5d, %8.2f, %10.4s. Число перед десятичной точкой дает максимальную ширину поля. Число после десятичной точки дает число точных знаков.

Если ширина поля отрицательная, т.е. %-5d, тогда величина будет выравниваться по левой границе поля. Обычно выравнивание производится по правой границе поля. Если ширина поля начинается с нуля, т.е. %08d, поле будет спереди заполняться до заданной ширины нулями, когда значащих цифр меньше, чем зарезервировано знакомест под ширину поля. Если ширина поля предваряется знаком '+', т.е. %+7d, тогда положительные величины будут начинаться со знака '+'.

Комментарии: Обратите внимание на следующие общие ошибки:
    name="John Smith"
    printf(1, "%s", name)     -- ошибка!
В этом случае будет напечатан только первый символ имени, J, так как каждый из символов имени форматируется как отдельная величина. Чтобы вывести все имя, вы должны вместо предыдущей дать команду:
    name="John Smith"
    printf(1, "%s", {name})   -- правильно
Теперь третий аргумент, поданный в printf(), является одноэлементным рядом, содержащим все то, что должно быть отформатировано.
Пример 1:
rate = 7.875
printf(myfile, "The interest rate is: %8.2f\n", rate)

      The interest rate is:     7.88

Пример 2:
name="John Smith"
score=97
printf(1, "%15s, %5d\n", {name, score})

      John Smith,    97

Пример 3:
printf(1, "%-10.4s $ %s", {"ABCDEFGHIJKLMNOP", "XXX"})

      ABCD       $ XXX

См. также: sprintf, puts, open

profile

Синтаксис: profile(i)
Описание: Включает или выключает режим профилирования во время прогона. Оператор действует в отношении обоих профилей - профиля команд и профиля времени. Если i равно 1, профилирование включается и отчет будет создан. Если i равно 0, профилирование выключается и отчет не генерируется.
Комментарии: После операторов "with profile" или "with profile_time" профилирование включается автоматически. Используйте profile(0), чтобы выключить его. Используйте profile(1) для включения профилирования в том месте программы, начиная с которого оно вам необходимо.
Пример 1:
with profile_time
profile(0)
  ...
procedure slow_routine()
profile(1)
  ...
profile(0)
end procedure

См. также: trace, профилирование, специальные операторы высшего уровня

prompt_number

Синтаксис: include get.e
a = prompt_number(st, s)
Описание: Приглашает пользователя ввести число с клавиатуры. st является текстовой строкой с приглашением, которая отображается на экране. s является рядом, состоящим из двух величин {меньшая, большая}, определяющих диапазон величин, которые пользователь вправе ввести. Если пользователь выйдет из этого диапазона допустимых значений, приглашение повторяется. s может быть пустым рядом, {}, если ограничений нет.
Комментарии: Если данная процедура слишком проста и не отвечает вашим потребностям, не стесняйтесь скопировать ее и затем сделать из нее свою собственную более специализированную версию.
Пример 1:
age = prompt_number("What is your age? ", {0, 150})

Пример 2:
t = prompt_number("Enter a temperature in Celcius:\n", {})

См. также: get, prompt_string

prompt_string

Синтаксис: include get.e
s = prompt_string(st)
Описание: Приглашает пользователя ввести строку текста. st включает в себя текст приглашения, отображаемый на экране. Строка, которую ввел пользователь, размещается в ряде s за вычетом любых служебных символов перевода строки и возврата каретки.
Комментарии: Если пользователь введет control-Z (метка конца файла), s получит значение "" - пустого ряда.
Пример:
name = prompt_string("What is your name? ")

См. также: gets, prompt_number

put_screen_char

Платформа: DOS32, Linux
Синтаксис: include image.e
put_screen_char(i1, i2, s)
Описание: Выводит ноль или более символов на экран вместе с их атрибутами. i1 определяет строку, а i2 - колонку, где должен быть выведен первый из символов. Ряд s выглядит следующим образом: {ascii-код1, атрибут1, ascii-код2, атрибут2, ...}. Каждая пара элементов ряда описывает один символ. Атом ascii-код содержит код ASCII символа. Атом атрибутов содержит информацию о цвете символа, цвете фона и, возможно, другие платформенно-зависимые данные, управляющие внешним видом символа на экране.
Комментарии: Длина s должна быть кратна 2. Если s имеет длину 0, на экран не будет ничего выводиться.

Более быстро выводятся несколько символов в одном вызове put_screen_char(), чем поочередно в цикле по одному на вызов.

Пример:
-- записывает AZ в верхний левый угол экрана
-- (атрибуты зависят от платформы)
put_screen_char(1, 1, {'A', 152, 'Z', 131}) 
См. также: get_screen_char, display_text_image

puts

Синтаксис: puts(fn, x)
Описание: Выводит в файл или на устройство fn единственный байт (атом) или ряд байтов. Выводятся только младшие 8 битов каждой из величин, подаваемых в процедуру. Если fn - экран, вы увидите вывод символов текста.
Комментарии: Когда вы выводите ряд байтов, внутри него не должно быть вложенных рядов. Он должен быть только лишь рядом атомов. (В типовом случае строка кодов ASCII).

Избегайте вывода 0-й на экран или стандартный выход. Такой вывод может быть усечен.

Пример 1:
puts(SCREEN, "Enter your first name: ")

Пример 2:
puts(output, 'A')  -- на вывод будет послан единственный байт 65

См. также: printf, gets, open

rand

Синтаксис: x2 = rand(x1)
Описание: Выдает случайное целое в пределах от 1 до x1, где x1 может быть от 1 до наибольшей допустимой положительной величины типа integer (1073741823).
Комментарии: Данная функция применима к атому или ко всем элементам ряда.
Пример:
s = rand({10, 20, 30})
-- s может быть: {5, 17, 23} или {9, 3, 12} и т.д.

См. также: set_rand

read_bitmap

Синтаксис: include image.e
x = read_bitmap(st)
Описание: st является именем .bmp-файла - "биткарты". Файл должен быть именно в формате bitmap. Поддерживается большинство общих вариаций этого формата. Если файл прочитан успешно, результатом будет 2-элементный ряд. Первым элементом будет палитра, содержащая величины интенсивностей цветов в диапазоне от 0 до 255. Вторым элементом будет 2-х мерный ряд, содержащий собственно пиксельно-графическое изображение. Вы можете подать полученную палитру в процедуру all_palette() (после деления ее на 4 для правильного масштабирования). Изображение может быть подано в процедуру display_image() для вывода на экран.

Поддерживаются биткарты с 2, 4, 16 или 256 цветами. Если файл имеет негодный формат, вместо изображения выдается код ошибки (atom):

    global constant BMP_OPEN_FAILED = 1,
                 BMP_UNEXPECTED_EOF = 2,
             BMP_UNSUPPORTED_FORMAT = 3
Комментарии: Необходимые вам изображения в формате bitmap вы можете создавать, используя графический редактор Paintbrush из пакета Windows или многие другие графические программы. Эти изображения затем могут быть включены в ваши программы, написанные на Euphoria.
Пример:
x = read_bitmap("c:\\windows\\arcade.bmp")
-- примечание: двойная косая черта в адресе файла необходима,
-- чтобы в операционную систему была выдана штатная одинарная

Пример программы: demo\dos32\bitmap.ex
См. также: palette, all_palette, display_image, save_bitmap

register_block

Синтаксис: include machine.e --(или safe.e)
register_block(a, i)
Описание: Добавляет (регистрирует) блок памяти в список безопасных блоков, поддерживаемый файлом safe.e (отладочная версия machine.e). Блок начинается с адреса a. Длина блока составляет i байтов.
Комментарии: Данная процедура предназначена только для отладочных целей. safe.e трассирует блоки памяти, которые вашей программе разрешено использовать в подпрограммах peek(), poke(), mem_copy() и т.п. Процедура нормально работает только с теми блоками, которые выделены вами для своих целей путем выполнения команд Euphoria allocate() или allocate_low(), и которые еще не освобождены с помощью команд Euphoria free() или free_low(). В некоторых случаях вы можете затребовать добавочные, внешние, блоки памяти, например, в результате вызова C-процедуры. Если вы отлаживаете вашу программу с использованием safe.e, вы должны также регистрировать эти внешние блоки памяти, иначе safe.e будет препятствовать вашему доступу к ним. Когда вы закончите использование внешнего блока, вы сможете отменить его регистрацию с помощью команды unregister_block().

Когда вы включаете machine.e, у вас вызываются другие версии процедур register_block() и unregister_block(), которые не производят никаких операций. Подобный прием делает простыми и легкими переходы между отладочными и штатными прогонами вашей программы.

Пример 1:
atom addr

addr = c_func(x, {})
register_block(addr, 5)
poke(addr, "ABCDE")
unregister_block(addr)
См. также: unregister_block, safe.e

remainder

Синтаксис: x3 = remainder(x1, x2)
Описание: Вычисляет остаток от деления x1 на x2. Результат будет иметь тот же знак, что и x1, а величина результата будет меньше, чем величина x2.
Комментарии: Аргументы, подаваемые в эту функцию, могут быть атомами или рядами. В случае рядов применяются правила действий с рядами.
Пример 1:
a = remainder(9, 4)
-- a равно 1

Пример 2:
s = remainder({81, -3.5, -9, 5.5}, {8, -1.7, 2, -4})
-- s равно {1, -0.1, -1, 1.5}

Пример 3:
s = remainder({17, 12, 34}, 16)
-- s равно {1, 12, 2}

Пример 4:
s = remainder(16, {2, 3, 5})
-- s равно {0, 1, 1}
  
См. также: floor

repeat

Синтаксис: s = repeat(x, a)
Описание: Создает ряд длины a, где каждый элемент является x.
Комментарии: Когда вы повторяете с помощью данной функции ряд или число с плавающей точкой, интерпретатор фактически не создает множественные копии в памяти. Напротив, единственная копия помечается числом экземпляров.
Пример 1:
repeat(0, 10)      -- {0,0,0,0,0,0,0,0,0,0}

Пример 2:
repeat("JOHN", 4)  -- {"JOHN", "JOHN", "JOHN", "JOHN"}
-- интерпретатор создаст только одну копию "JOHN"
-- в памяти

См. также: append, prepend, оператор формирования ряда

reverse

Синтаксис: include misc.e
s2 = reverse(s1)
Описание: Оборачивает порядок элементов в ряде.
Комментарии: Создается новый ряд, в котором элементы высшего уровня имеют порядок, обратный по отношению к исходному ряду.
Пример 1:
reverse({1,3,5,7})          -- {7,5,3,1}

Пример 2:
reverse({{1,2,3}, {4,5,6}}) -- {{4,5,6}, {1,2,3}}

Пример 3:
reverse({99})               -- {99}

Пример 4:
reverse({})                 -- {}

См. также: append, prepend, repeat

routine_id

Синтаксис: i = routine_id(st)
Описание: Функция выдает целое число i, известное как идентификатор подпрограммы, который присваивается процедуре или функции Euphoria, уже определенной программистом. Имя подпрограммы задается символьным рядом st. Если подпрограмма с таким именем еще не определена, выдается -1.
Комментарии: Полученный с помощью данной функции идентификатор подпрограммы может быть затем подан в call_proc() или call_func() для косвенного вызова подпрограммы с именем st.

Подпрограмма с именем st должна быть видимой, т.е. доступной для вызова в той точке вашей программы, где вызвана функция routine_id() для получения необходимого идентификатора. Косвенные вызовы подпрограммы могут появляться в программе ранее собственно определения подпрограммы, но непосредственно идентификатор (номер) подпрограммы может быть получен только после определения подпрограммы - внимательно просмотрите пример 2 ниже.

Однажды полученный, законный идентификатор подпрограммы может быть использован в любом месте вашей программы для косвенного вызова подпрограммы по этому ее номеру через call_proc()/call_func().

Некоторые типовые применения routine_id():

1. Указание на процедуру, которая в программе будет определена позже.
2. Создание подпрограмм, которые вызывают другие подпрограммы через параметр. (См. Пример 2 ниже)
3. Использование ряда идентификаторов процедур для создания оператора переключения по условиям.
4. Установка объектно-ориентированной системы.
5. Получение идентификатора процедуры при необходимости подачи его в call_back(). (См. platform.doc)

Обратите внимание, что функции C, вызов которых возможен в Euphoria, также имеют идентификаторы процедуры. См. define_c_proc() и define_c_func().

Пример 1:
procedure foo()
    puts(1, "Hello World\n")
end procedure

integer foo_num
foo_num = routine_id("foo")

call_proc(foo_num, {})  -- то же самое, что и вызов foo()

Пример 2:
function apply_to_all(sequence s, integer f)
    -- функция применяется ко всем элементам ряда
    sequence result
    result = {}
    for i = 1 to length(s) do
        -- мы можем вызвать add1() здесь,
        -- хотя определение идет в программе позже
        result = append(result, call_func(f, {s[i]}))
    end for
    return result
end function

function add1(atom x)
    return x + 1
end function

-- add1() видна здесь, поэтому мы можем
-- запросить ее идентификатор процедуры
? apply_to_all({1, 2, 3}, routine_id("add1"))
-- отображается {2,3,4}

См. также: call_proc, call_func, call_back, define_c_func, define_c_proc, platform.doc

 

... продолжение от S до T