Обзор системных библиотек AROS

Ниже приведён список некоторых важных библиотек и их функций. Нет нужды запоминать всё, что написано о них здесь, так как они подробно рассматриваются далее.

• exec.library - наиболее важная библиотека. Она несёт ответственность за

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

• utility.library воплощает очень важные механизмы для обращения к

  библиотекам: taglist-ы, которые рассматриваются далее в этой главе и hook-и. Отдельно от этого, данная библиотека содержит разнообразные небольшие служебные функции.

• dos.library отвечает за обращение с файлами, операции с дисками и некоторые

  основные функции ввода-вывода. Без этой библиотеки AROS не имела бы возможности работать с файлами.

• intuition.library управляет графическими интерфейсами пользователя (GUI).

  При помощи этой библиотеки вы можете создавать окна и gadgets и, соответственно, управлять ими. Есть и другие библиотеки, которые работают поверх intuition и предоставляют более сложные и более специализированные функции для работы с графическим интерфейсом. Примером могут служить gadtools.library, которая реализует несколько более сложные gadgets, и asl.library, которая предоставляет функции формирования запросов к файлам и прочие формирователи запросов (requesters).

Как работают библиотеки AROS

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

В целом есть 2 типа библиотек: статические (link-time) и динамические (run-time). Статические библиотеки, как подсказывает название, используются только на этапе компоновки программы: компоновщик собирает все функции, которые нужны программе, из предоставленных библиотек и компонует их в исполняемый файл. Динамические библиотеки, вместо этого, доступны программам когда они запускаются или в процессе их выполнения посредством специальных запросов от программ. В большинстве систем динамические библиотеки используются выполняемыми программами совместно, вследствие чего в памяти загружается только одна копия библиотеки. В таких случаях их часто называют совместно используемыми библиотеками.

В то время как управление статическими библиотеками более или менее одинаково во всех операционных системах, т.к. они независимы от ОС сами по себе, управление динамическими библиотеками в разных операционных системах может осуществляться по-разному.

Перед тем как библиотека может быть использована в программе, она должна быть открыта. Это можно сделать выполнив функцию под названием OpenLibrary. После того как библиотека успешно открыта, возвращается указатель так называемой библиотечной базы. Библиотечная база - это область памяти, содержащая векторы функций и собственные данные библиотек [1]. Когда библиотеки открыты, они свободны выбирать будет их база одной и той же для всех копий или же каждый раз в памяти будет размещаться новая. Когда функция из библиотеки вызвана основное время библиотечная база передаёт функции следовательно данные напрямую могут быть использованы в библиотеке [2]. Библиотека может сделать часть данных или все данные целиком в библиотечной базе общедоступными по определению типа для базы. Если это имеет место, вы найдёте тип в файле включений proto/libname.h. Некоторые устаревшие библиотеки используют этот механизм, но более новые библиотеки не делают что-либо общедоступным и единственным способом изменить внутреннее состояние библиотеки является использование доступных функций.

Как воспользоваться совместно используемыми библиотеками AROS

Как уже объяснялось в предыдущем разделе, библиотеки надо открывать до того как их функции можно будет использовать. Единственная библиотека, которую нет необходимости открывать, это exec.library. Exec является всегда открытой и ваш компилятор знает как получить к ней доступ. Дополнительно вам необходимо подключить заголовок, чтобы сделать прототип функций известным коду. Этот файл включений находится в директории proto, так что если вы хотите воспользоваться функциями, например, из библиотеки dos.library, то вам надо использовать следующую строку:

#include <proto/dos.h>

Ваш компилятор или среда сборки могут дополнительно открыть для вас некоторые библиотеки, следовательно, вам нет необходимоси открывать их вручную. Прочтите руководство к вашему компилятору, чтобы узнать о подобных особенностях. В следующих параграфах будет рассказано о том, как это сделать при помощи инструментов, имеющихся в AROS, и как открывать библиотеки вручную.

Автоматическое открытие при помощи gcc из AROS SDK

Компилятор GCC из набора AROS SDK автоматически открывает следующие основные библиотеки:

• aros.library
• asl.library
• commodities.library
• cybergraphics.library
• datatypes.library
• diskfont.library
• dos.library
• expansion.library
• gadtools.library
• graphics.library
• icon.library
• iffparse.library
• intuition.library
• keymap.library
• layers.library
• locale.library
• muimaster.library (предоставляется в AROS проектом Zune)
• partition.library
• realtime.library
• utility.library
• workbench.library

Вы можете отключить автооткрытие этих библиотек, указав компилятору GCC флаг -nostdlibs. Для прочих библиотек предоставляемых AROS вы можете использовать соответствующие статические библиотеки, которые позаботятся от открытии библиотек. Следовательно, если, например, ваша программа использует библиотеку reqtools.library, то добавьте флаг -lreqtools в команду вызова компилятора GCC.

Автоматическое открытие при помощи систмы сборки AROS

Автооткрытие библиотек системой сборки очень похоже на использование компилятора AROS GCC. Аналогично определению опции -l определите используемые вами библиотеки в параметре uselibs для %build_prog и макроса %build_module. Более подробную информацию вы можете найти в Руководстве по системе сборки.

Открытие библиотек вручную

Для открытия библиотеки вам надо использовать функцию из exec.library:

#include <proto/exec.h>

struct Library *OpenLibrary( STRPTR name, ULONG version );

Функции OpenLibrary() требуются 2 аргумента:

name

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

Примечание

Пути не работают с библиотеками, включёнными в ядро операционной системы. Используйте абсолютные пути только, если точно знаете, что делаете!

version

минимально допустимая версия открываемой библиотеки. Если названная библиотека найдена, но её версия ниже указанной, то библиотека не будет открыта, но будет возвращена ошибка. Версии важны поскольку допускается расширение библиотек. Некоторые функции доступны только начиная с определённых версий библиотеки. Например, функция AllocVec() из exec.library появилась в 36 версии этой библиотеки. Если вы попытаетесь вызвать эту функцию, имея установленной более старую версию exec.library, то случатся непредсказуемые вещи (скорее всего приложениеаварийно завершится).

Следующий порядок действий происходит при загрузке библиотеки для открытия:

1. Во-первых, имя библиотеки ищется в списке уже загруженных библиотек. Если эта библиотека была загружена в память ранее (например, другой программой) и всё ещё находится там, то всё замечательно и значение функции OpenLibrary() будет немедленно возвращено.

   Библиотеки, включённые в ядро, всегда находятся в списке загруженных библиотек.

   Примечание

   Поиск в этом списке чувствителен к регистру! Будьте уверены, что используете правильный регистр в name. Обычно все символы в названиях библиотек указываются в нижнем регистре.

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

3. Если было передано только простое очевидное имя, то библиотеку будут искать сначала в текущей директории. Если там она не будет найдена, то далее её попробуют найти в директории LIBS:.

OpenLibrary() вернёт либо указатель на структуру, описывающую библиотеку (struct Library * определённую в exec/libraries.h), либо NULL, означающий, что по каким-то причинам открыть библиотеку неудалось. Итоговый указатель сохраняется для использования компилятором. Обычно он хранится в переменной в форме: <имя_библиотеки>Base, например, IntuitionBase для указателя на библиотеку intuition.library.

После открытия библиотеки, вы можете использовать, предоставляемые ею функции, просто вызывая их как любые другие функции в вашей программе. Но, чтобы позволить вашему компилятору узнать что делать, вам надо подключить относящийся к библиотеке заголовочный файл. Для компиляторов C это обычно делается строкой proto/<имя_быблиотеки>.h.

Когда вы закончили использовать библиотеку, вам надо закрыть её для освобождения используемых ею ресурсов. Это делается при помощи:

#include <proto/exec.h>

void CloseLibrary( struct Library *base );

Функция CloseLibrary() закрывает библиотеку указанную базой. Это также может быть NULL, в случае которого CloseLibrary() не вернёт ничего.

Мы продемонстрируем использование библиотек созданием маленькой графической программы приветствия. Вместо вывода на экран сообщения Hello World!, мы будем показывать его в диалоге запроса. Функцией, показывающей диалог запроса, является EasyRequestArgs() из библиотеки intuition.library. Мы не будем здесь обсуждать её использование. Более подробную информацию смотрите в разделе Requesters.

Пример использования библиотек:

#include <proto/exec.h>          /* OpenLibrary() и CloseLibrary() */
#include <exec/libraries.h>      /* struct Library */
#include <dos/dos.h>             /* RETURN_OK и RETURN_FAIL */
#include <proto/intuition.h>     /* EasyRequestArgs() */
#include <intuition/intuition.h> /* struct EasyStruct */

/* Эта переменная будет хранить указатель на intuition.library */
struct IntuitionBase *IntuitionBase;

int main(int argc, char *argv[])
{
    /* Нужно для EasyRequestArgs(). */
    struct EasyStruct es = {
      sizeof(struct EasyStruct), 0UL,
      "Requester", "Hello World!", "Ok"
    };

    /* Сначала мы открываем intuition.library. Нам нужна версия 36 или
       новее, потому что EasyRequestArgs() была введена именно начиная
       с этой версии intuition.library.
    */
    IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);

    /* Надо проверить, действительно ли intuition.library была успешно
       открыта. Если нет, то мы не должны вызывать функции из неё, поэтому
       мы немедленно вернём ошибку.
    */
    if (!IntuitionBase)
        return RETURN_FAIL;

    /* После открытия intuition.library, мы вызваем EasyRequestArgs(). */
    EasyRequestArgs(NULL, &es, NULL, NULL);

    /* И, наконец, нам надо закрыть intuition.library. */
    CloseLibrary((struct Library *)IntuitionBase);

    return RETURN_OK;
}

Попробуйте скомпилировать и запустить программу. Это представит вам красивую программу, показывающую диалог запроса "Hello, world!" с кнопкой Ok.

Присвоение библиотекам номеров версий

Совместно используемые библиотеки могут со временем развиваться и предоставлять новые возможности. Теперь, когда программа использует возможности более свежей версии библиотеки и её запускают в системе имеющей более старую версию, то наиболее вероятно, что это приведёт к аварийному завершению программы. Тем не менее нумерация версий библиотек введена для того, чтобы программы могли проверить, подходит ли версия библиотеки и элегантно завершиться или соответствующим образом ограничить свою функциональность, если нет. В AROS и Amiga-подобных операционных системах версия определяется старшим (major) и младшим (minor) номером (также им соответствуют "версия" и "ревизия"). Старший номер указывает на введение новых возможностей, в то время как увеличение младшего указывает лишь на некоторую оптимизацию и/или исправление ошибок, но с сохранением совместимости. Версию библиотеки часто указывают как major.minor [3], и её можно узнать при помощи команды version:

5.System:> version dos.library
dos.library 41.7

При открытии библиотеки вы можете указать номер версии и процесс открытия завершится неудачно, если версия библиотеки меньше, чем указанное значение:

mylibbase = OpenLibrary("my.library", 2);

Здесь будет возвращено значение NULL если установлена только версия 1 библиотеки my.library. Если вы используете автооткрытие библиотек, то будет открыта та версия библиотеки, которая использовалась во время компоновки. Эта версия может быть перезагружена при помощи переменной libbasename_version. В данный момент dos.library имеет версию 41 и это значит, что скомпилированные программы будут работать только в таких других системах, которые имеют 41-ю версию библиотеки dos.library. Если вы уверены, что используете возможности только версий до 36-й, то можете допустить вашу программу в эти системы со следующим оператором где-нибудь в вашем программном коде:

const LONG DOSBase_version = 36;

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

Если вы действительно хотите изменить поведение функции с определённым именем, вам надо сделать это, поместив её в другое место в таблице соответствия. Затем на старом месте расположите совместимую функцию, которая всё ещё будет совместима с поведением более старой версии библиотеки. Например, это было успешно проделано для функции OpenLibrary из exec.library. В первой версии AmigaOS она не имела такого параметра как версия и была размещена на месте 68. В более поздних версиях была введена функция OpenLibrary, имеющая парметр версии, и размещена на месте 92. Функция на позиции 68 была переименована в OldOpenLibrary.

Отличия от других систем с динамическими библиотеками

Совместно используемые библиотеки AROS имеют уникальную архитектуру со своими преимуществами и недостатками. Некоторые аспекты будут рассмотрены далее в этой главе. В основном при этом мы будем ссылаться на Windows и UNIX(-подобные) системы.

Загрузка совместно используемых библиотек

В AROS динамически компонуемые библиотеки являются перемещаемыми ELF-объктами. В первое время после открытия библиотеки она загружается с диска и размещается по начальному адресу, в который она была загружена. В AROS и Amiga-подобных системах весь код, запущенный в системе использует одну большую область памяти. Это означает, что программы могут использовать библиотеки, также загруженные в память.

Другие системы, включая Windows и UNIX, имеют разные виртуальные адресные пространства для каждого процесса. В этом случае, операционная система также пытается загрузить совместно используемую библиотеку только однажды и затем пытается отобразить её в адресное пространство каждого процесса, использующего эту библиотеку. Таким образом, библиотека может располагаться по разным адресам в разных адресных пространствах и операционная система должна управлять этой ситуацией.

Windows пытается расположить совместно используемые библиотеки в определённом месте памяти и отобразить их в ту же область памяти, в которой находится каждый использующий её процесс. Если это невозможно, библиотека дублируется в памяти. В большинстве систем UNIX эта проблема обойдена путём разрешения компилятору генерировать позиционно-независимый код, например, код, который работает на любой позиции в памяти без необходимости его перемещения. В зависимости от архитектуры этот тип кода может иметь меньшее или большее влияние на скорость работы компилятора.

Динамическая компоновка функций

Програмисты, использующие высокоуровневые языки программирования для доступа к функциям совместно используемых библиотек, будут использовать то имя функции, которое захотят. Когда микропроцессор выполняет программу, то использует адреса памяти для перехода к определённой функции. Соответственно имя, используемое программистом, должно быть преобразовано в адрес в памяти.

В Amiga преобразование происходит, когда код компилируется или когда программа или модуль компонуются. Каждая libbase библиотеки AROS содержит таблицу соответствия для функций библиотеки. В процессе компиляции (или компоновки) имя функции преобразуется в позицию в этой таблице, в которой может быть найден адрес функции [4]. Таким образом, функции в совместно используемых библиотеках AROS доступны с одним уровнем преобразования. В зависимости от архитектуры ЦПУ этот уровень преобразования может иметь большее или меньшее влияние на скорость работы кода. К счастью, подобный тип преобразования используется для вызова виртуальных функций в классах C++ и наиболее современные ЦПУ оптимизированы для управления преобразованием без (большого) влияния на скорость. Так как таблица соответствия прикреплена к libbase, то её надо дублировать для библиотек, использующих per-opener base.

В Windows и UNIX-подобных системах преобразование имени функции в адрес происходит когда программа загружается в память и динамически компонуется с совместно используемыми библиотеками [5]. Когда программа компонуется во время компилирования, список библиотек помещается в исполняемый файл вместе со списком используемых функций. Эти списки являются ASCII строками. Когда программа впоследствии загружается, имена функций конвертируются в их адреса (или в указатель в таблице соответствия). Сначала библиотеки из списка библиотек открываются, после чего каждая функция ищется в библиотеках. Для поиска имён функций используются различные механизмы. Например, в Windows доступные функции помещаются в отсортированный массив, так что может быть произведён двоичный поиск, а в Linux для ускорения поиска используются хэши.

Глобальные и статические переменные в библиотеках

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

int globvar;

Глобальная переменная будет доступна из всех частей библиотеки. Когда совместно используемая библиотека загружена в память, ваша переменная также будет размещена в памяти, занятой библиотекой и будет всегда оставаться на одном и том же месте, пока библиотека не будет выгружена из памяти. Статические переменные, определённые в функции, управляются аналогичным способом. Это также подразумевает, что код в библиотеке обращающийся к глобальной переменной будет всегда загружаться в одно и тоже место в памяти, неважно сколько раз библиотека будет открываться или какая программа вызовет код из библиотеки. В настоящее время единственным способом получить переменную, которая имеет различное значение для каждого открывающего библиотеку, является библиотека с per-opener base и хранение библиотеки в этой базе. Также в данный момент глобальные переменные не экспортируются из совместно используемых библиотек AROS. Они могут быть доступны только внутри самой библиотеки, программа, использующая библиотеку, не имеет прямого доступа к глобальным переменным библиотеки. В этом отношении переменные в совместно используемых библиотеках AROS управляются отличным образом от переменных в статических библиотеках. Глобальная переменная определённая в статической библиотеке тоже доступна программе, с которой библиотека скомпонована, и каждая программа, скомпонованная с этой же статической библиотекой, будет иметь свою собственную версию глобальной переменной.

В UNIX, совместно используемые библиотеки были введены после того, как статические библиотеки уже интенсивного использовались. Одним из преимуществ дизайна стало то, что поведение совместно используемых библиотек было таким же, как и поведение статических. Поэтому каждый раз, когда программа открывала совместно используемую библиотеку, делалась копия переменных. В этом случае каждая программа, открывшая совместно используемую библиотеку, получала свой собственнй набор глобальных переменных. Также глобальные переменные совместно используемой библиотеки автоматически экспортировались из этой библиотеки, вследствие чего были доступны напрямую из программы, использующей эту библиотеку.

В Windows можно выбрать поведение глобальных переменных как в AROS, либо как в UNIX, но по умолчанию они управляются как в UNIX.

Для портирования совместно используемых библиотек в AROS или Amiga эти отличия в упрвлении перменными должны учитываться. Некоторые библиотеки зависят от того, как переменные управляются в совместно используемых библиотеках UNIX и Windows, и их портирование в AROS может оказаться затруднительным.

Библиотеки, использующие другие библиотеки

Библиотека может открыть другую библиотеку. После того, как библиотека открыла другую библиотеку, она получает базу этой библиотеки. Это означает, что библиотека, имеющая базу per-opener , вернёт другой библиотеке уникальный указатель базы. Когда программа открывает библиотеку с per-opener base, обратно она получит базу. Теперь, когда программа открывает вторую библиотеку, которая открывает первую библиотеку, другая база будет возвращена второй библиотеке, и затем - программе. Те, кто создаёт библиотеки с per-opener libbase должны это учитывать.

Как уже говорилось выше, в UNIX и Windows всё основано на процессах. Когда программа загружается, создаётся новый процесс, каждая совместно используемая библиотека используемая этим процессом будет только однажды динамически скомпонована с процессом. Это значит, что программа и совместно используемая библиотека, имеющие доступ к другой совместно используемой библиотеке, будут использовать одну и туже копию этой другой библиотеки. Это различие в поведении может сделать портирование совместно используемых библиотек из UNIX/Windows затруднительным.