Платформа:	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

Синтаксис:	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

Синтаксис:	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

Синтаксис:	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

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

Платформа:	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

Синтаксис:	i = platform()
Описание:	Значение, выдаваемое функцией platform(), встроено в интерпретатор. Это значение показывает, с каким именно интерпретатором запущена программа, с интерпретатором для DOS32, WIN32, Linux или FreeBSD.
Комментарии:	Когда работает ex.exe, считается, что операционная система DOS32. Когда работает exw.exe, операционная система WIN32. Когда работает exu, операционная система Linux (или FreeBSD). В библиотеке misc.e определены следующие глобальные константы:
	global constant DOS32 = 1, WIN32 = 2, LINUX = 3, FREEBSD = 3
	Используйте функцию platform(), когда вам необходимо исполнять различный код в зависимости от операционной системы, в среде которой запущена ваша программа. Дополнительные значения констант будут вводиться в Euphoria по мере освоения других машин и операционных систем. Вызов функции platform() не влечёт никаких расходов. Во время компиляции просто вырабатывается соответствующая целочисленная величина: 1, 2 или 3.
Пример:
	if platform() = WIN32 then -- вызов системной подпрограммы Beep под Windows err = c_func(Beep, {0,0}) elsif platform() = DOS32 then -- запуск звука на встроенном динамике под DOS sound(500) t = time() while time() < t + 0.5 do end while sound(0) else -- пропуск команды под Linux/FreeBSD end if
См. также:	platformr.doc

Синтаксис:	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\callmach.ex
См. также:	peek, poke4, allocate, free, allocate_low, free_low, call, safe.e

Синтаксис:	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

Платформа:	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(i1, i2)
Описание:	Перемещает курсор на строку i1, в колонку i2, верхний левый угол экрана соответствует строке 1, колонке 1. Символ, выводимый на экран после этой команды, появится именно в назначенном месте. position() сообщит об ошибке, если предпринимается попытка задания знакоместа за пределами экрана.
Комментарии:	position() работает и в текстовом, и в пиксельно-графическом режимах. Система координат при отображении текста отличается от системы координат при отображении пикселов. Пикселы отображаются так, что верхний левый угол экрана соответствует координатам (x=0,y=0), а первая координата задает положение по горизонтали, слева направо. В пиксельно-графических режимах вы можете отображать и текст, и пикселы. Процедура position() устанавливает только строку и колонку для текста, положением пикселов она не управляет. Аналогичной процедуры для назначения следующей пиксельной позиции не существует.
Пример:
	position(2,1) -- курсор устанавливается в начало второй строки сверху
См. также:	get_position, puts, print, printf

Синтаксис:	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

Синтаксис:	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, concatenation operator &, sequence-formation operator

Синтаксис:	include misc.e pretty_print(fn, x, s)
Описание:	Печатает в файле или на устройстве fn объект x, используя скобки { , , , }, отступы и последовательные строки, чтобы показать структуру объекта x в удобном для вас представлении s. Доступен ряд режимов печати, отличающихся представлением s. Подавайте вместо s {}, если хотите воспользоваться режимом по умолчанию (исходным), или задавайте свой любимый режим в элементах ряда s как указано ниже (в квадратных скобках номер элемента ряда s): [1] показывать символы ASCII: * 0: никогда * 1: вместе с любыми целыми в диапазоне ASCII 32..127 (исходный) * 2: подобно 1, плюс показывать как "строку", когда все целые ряда находятся в диапазоне ASCII * 3: подобно 2, но показывать *только* буквы в кавычках, а не числа, для любых целых в диапазоне ASCII, а также символы пробела: \t \r \n [2] число отступов для каждого уровня вложения ряда - исходный: 2 [3] колонка, в которой начинается печать - исходный: 1 [4] область колонки, где начинается перенос строки - исходный: 78 [5] формат для вывода целых - исходный: "%d" [6] формат для вывода чисел с плавающей точкой - исходный: "%.10g" [7] минимальная величина кода для символов ASCII - исходный: 32 [8] максимальная величина кода для символов ASCII - исходный: 127 [9] максимальное число выводимых строк. Если длина s меньше 8, все незаданные опции до конца ряда будут иметь величины по умолчанию, исходные, т.е. {0, 5} даст "никогда не показывать ASCII", плюс 5-символьный отступ, а все остальные величины будут исходными.
Комментарии:	Отображение начнётся из текущей позиции курсора. Обычно вы ожидаете, что печать начинается в колонке 1, но чтобы так было при вызове pretty_print(), необходимо иметь курсор уже именно в первой колонке. Этого можно добиться, просто выведя символ '\n' перед вызовом pretty_print(). Если вы хотите, чтобы печать началась в другой колонке, вам нужно вызвать position() и задать необходимую величину для режима [3]. Тем самым будет обеспечено вертикальное выравнивание скобок в заданном столбце. Задавая формат для вывода чисел, целых и с плавающей точкой, можно добавить некоторые украшения, т.е. "(%d)" или "$ %.2f".
Пример 1:
	pretty_print(1, "ABC", {}) {65'A',66'B',67'C'}
Пример 2:
	pretty_print(1, {{1,2,3}, {4,5,6}}, {}) { {1,2,3}, {4,5,6} }
Пример 3:
	pretty_print(1, {"Euphoria", "Programming", "Language"}, {2}) { "Euphoria", "Programming", "Language" }
Пример 4:
	puts(1, "word_list = ") -- курсор остановится в колонке 13 pretty_print(1, {{"Euphoria", 8, 5.3}, {"Programming", 11, -2.9}, {"Language", 8, 9.8}}, {2, 4, 13, 78, "%03d", "%.3f"}) -- первые 6 из 8 подрежимов word_list = { { "Euphoria", 008, 5.300 }, { "Programming", 011, -2.900 }, { "Language", 008, 9.800 } }
См. также:	?, print, puts, printf

Синтаксис:	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}}
См. также:	?, pretty_print, puts, printf, get

Синтаксис:	printf(fn, st, x)
Описание:	Выводит x в файл или на устройство fn, используя строку формата st. Если x является рядом, то очередные элементы формата из st применяются к соответствующим элементам ряда x. Если x является атомом, тогда обычно st будет содержать единственный элемент формата, который будет применён к x, однако, если элементов формата несколько, каждый элемент формата будет применён к единственной величине x. Таким образом, printf() всегда ожидает точно 3 аргумента. Только длина последнего аргумента, содержащего выводимые величины, будет изменяться. Изменения могут происходить и в строке формата. Основные форматы: %d - печатать атом как десятичное целое %x - печатать атом как шестнадцатеричное целое. Отрицательные числа печатаются как двоичное дополнение, т.е. -1 будет выведено как FFFFFFFF %o - печатать атом как восьмеричное целое %s - печатать ряд как строку символов, или печатать атом как отдельный символ %e - печатать атом как число с плавающей точкой в экспоненциальной форме %f - печатать атом как число с плавающей точкой в форме с десятичной точкой, а не в экспоненциальной %g - печатать атом как число с плавающей точкой в наиболее подходящем формате, исходя из величины числа %% - печатать собственно символ '%' К основным форматам может быть добавлена ширина полей, т.е. %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
Пример 4:
	printf(1, "%d %e %f %g", 7.75) -- одна и та же величина в разных форматах 7 7.750000e+000 7.750000 7.75
См. также:	sprintf, puts, open

Синтаксис:	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, profiling, special top-level statements

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

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

Синтаксис:	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(fn, x)
Описание:	Выводит в файл или на устройство fn единственный байт (атом) или ряд байтов. Выводятся только младшие 8 битов каждой из величин, подаваемых в процедуру. Если fn - экран, вы увидите вывод символов текста.
Комментарии:	Когда выводится ряд байтов, внутри ряда не должно быть вложенных рядов. Этот ряд должен состоять только лишь из атомов. (В типовом случае ряд кодов ASCII). Избегайте наличия нулей среди кодов, выводимых на экран или стандартный выход. Такой вывод может быть усечён. Не забывайте, что если файл для вывода был открыт в текстовом режиме, DOS и Windows будут заменять \n (10) на \r\n (13 10). Открывайте файл в двоичном режиме, если вам не нужны подобные услуги.
Пример 1:
	puts(SCREEN, "Введите своё имя: ")
Пример 2:
	puts(output, 'A') -- на вывод будет послан единственный байт 65
См. также:	printf, gets, open

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

Синтаксис:	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

Синтаксис:	include machine.e (or 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(). В некоторых случаях вы можете затребовать добавочные, внешние, участки памяти, например, в результате вызова функции Си. Если вы отлаживаете вашу программу с использованием safe.e, вы должны также регистрировать эти внешние участки памяти, иначе safe.e будет препятствовать вашему доступу к ним. Когда вы закончите использование внешнего блока, вы сможете отменить его регистрацию с помощью команды unregister_block(). Когда вы включаете machine.e, у вас вызываются другие версии процедур register_block() и unregister_block(), которые не производят никаких операций. Подобный приём делает простыми и лёгкими переходы между отладочным и штатным режимами исполнения вашей программы.
Пример :
	atom addr addr = c_func(x, {}) register_block(addr, 5) poke(addr, "ABCDE") unregister_block(addr)
См. также:	unregister_block, safe.e

Синтаксис:	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

Синтаксис:	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, оператор формирования ряда

Синтаксис:	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

Синтаксис:	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() - см. platformr.doc. Обратите внимание, что функции Си, вызов которых возможен в 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() через некоторый, пока неизвестный, номер f, -- хотя определение самой add1() и численное значение -- номера f появятся по ходу программы позже 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(), которая, -- на момент её определения, ещё ничего "не знала" о функции -- add1(), но уже предусматривала вызов некой, неизвестной -- тогда, функции по её номеру f. ? apply_to_all({1, 2, 3}, routine_id("add1")) -- отображается {2,3,4}
См. также:	call_proc, call_func, call_back, define_c_func, define_c_proc, platformr.doc