Листинг 7-5. EMMFUNC.C
------------------------------------------------------------------
#include
#include "emmconst.h"
#include "emmtypes.h"
#pragma check_stack(off)
#define CONTINUE_COL 32 /*колонка продолж-я сообщ-я об ошибке*/
static union REGS inregs, outregs;
static struct SREGS segregs;
static unt result;
void ShowEMMErr(errcode, lineno, filename)
unsigned int errcode;
unsigned int lineno;
char *filename;
{
unsigned int ec, func, len, line;
char *bp, *lp, *cp;
extern char *emmermsg[];
ec = errcode & 0x00FF;
func = inregs.x.ax;
printf("EMM error detected at line (%d) in source file(%s)\n",
lineno, filename);
if (ec < FRSTEMER || ec > LASTEMER)
printf("EMM Function (%04X) Error(%02X): Unknown Error
Code!\n", func, ec);
else {
printf("EMM Function (%04X) Error(%02X): ", func, ec);
lp = emmermsg[ec-FRSTEMERR];
line = 0;
while (*lp) {
for (cp = lp, len = 80 - CONTINUE_COL; *cp && len;
cp++, len --)
if (*cp == ' ')
bp = cp;
if (*cp)
*bp++ = '\0';
if (line++)
printf(" ");
printf("%s\n", lp);
lp = (*cp) ? bp : cp;
}
}
}
EMGGetStatus() /*тестирует наличие работающего менеджера расширен-
ной памяти*/
{
inregs.h.ah = 0x40; /*функция "Получить состояние" спе-
цификации расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
return(result);
}
EMSGetFrameAddr(pfa) /*возвращает удаленный адрес кадра
страниц менеджера расширенной памяти*/
char far **pfa;
{
inregs.h.ah = 0x41; /*функция "Получить адрес кадра
страниц" спецификации расширенной памя-
ти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
if (!result) {
FP_SEG(*pfa) = outregs.x.bx;
FP_OFF(*pfa) = 0;
}
return(result);
}
EMSGetPageCnt(una, tot) /*возвращает кол-во общих и неразме-
щенных страниц спецификации расширенной
памяти*/
unsigned int *una, *tot;
{
inregs.h.ah = 0x42; /*функция "Получить кол-во неразме-
щенных страниц" спецификации расширен-
ной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
if (!result) {
*una = outregs.x.bx;
*tot = outregs.x.dx;
}
return(result);
}
EMSAllocatePages(handle, pages) /*размещает обработчик с 'pages'
логических страниц*/
unsigned int *handle, pages;
{
inregs.h.ah = 0x43; /*функция "Разместить страницы"
спецификации расширенной памяти*/
inregs.x.bx = pages; /*кол-во логических страниц для
размещения*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
if (!result) /*функция завершилась успешно*/
*handle = outregs.x.dx; /*обработчик менеджера
расширенной памяти для работы с
этими страницами*/
return(result);
}
EMSMapHandlePage(handle, page, frame) /*отображает логическую
страницу в 'кадр'*/
unsigned int handle, page, frame;
{
inregs.h.ah = 0x44; /*функция "Отобразить/перестать отоб-
ражать страницы спецификации расширенной памяти*/
inregs.h.al = frame & 0x00ff; /*кадр целевой страницы*/
inregs.x.bx = page; /*номер логической страницы, в которую
отображать*/
inregs.x.dx = handle; /*обработчик, которому принадлежит
логическая страница*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
return(result);
}
EMSDeallocatePages(handle) /*освобождает обработчик и все его
страницы*/
unsigned int handle;
{
inregs.h.ah = 0x45; /*функция "Освободить страницы"
спецификации расширенной памяти*/
inregs.x.dx = handle; /*обработчик, назначенный для осво-
бождения менеджеру расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
return(result);
}
EMSGetVersion(emsver) /*возвращает номер версии программного
обеспечения менеджера расширенной памяти*/
char *emsver;
{
inregs.h.ah = 0x46; /*функция "Получить версию"
спецификации расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs);
if (!(result & 0xFF00)) { /*функция завершилась успешно*/
emsver[0] = ((result & 0x00F0) >> 4) + '0';
emsver[1] = '.';
emsver[2] = (result & 0x000F) + '0';
emsver[3] = '\0';
}
return(result >> 8);
}
EMSSavePageMap(handle) /*сохраняет контекст менеджера расширенной
памяти в области сохранения контекста
менеджера расширенной памяти*/
unsigned int handle;
{
inregs.h.ah = 0x47; /*функция "Сохранить отображение страниц"
спецификации расширенной памяти*/
inregs.x.dx = handle; /*обработчик, для которого выполняет-
ся сохранение*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
return(result);
}
EMSRestorePageMap(handle) /*восстанавливает контекст менеджера
расширенной памяти из области сохране-
ния контекста менеджера расширенной памяти*/
unsigned int handle;
{
inregs.h.ah = 0x48; /*функция "Восстановить отображение стра-
ниц" спецификации расширенной памяти*/
inregs.x.dx = handle; /*область контекста, откуда выполня-
ется восстановление*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
return(result);
}
EMSGetHandleCnt(hcnt) /*возвращает кол-во открытых обработчиков
(1 - 255*/
unsigned int *hсnt;
{
inregs.h.ah = 0x4B; /*функция "Получить кол-во обработ-
чиков спецификации расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
if (!result) { /*функция завершилась успешно*/
*hcnt = outregs.x.bx;
}
return(result);
}
EMSGetHandlePages(handle, pages) /*возвращает кол-во страниц,
размещенных для обработчика*/
unsigned int handle, *pages;
{
inregs.h.ah = 0x4С; /*функция "Получить страницы обработ-
чика" спецификации расширенной памяти*/
inregs.x.dx = handle; /*обработчик, которому, полагается,
принадлежат страницы*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>>8;
if (!result) /*функция завершилась успешно*/
*pages = outregs.x.bx;
return(result);
}
EMSGetAllHandlePages(hp, hpcnt) /*возвращает кол-во страниц,
размещенных всем обработчикам*/
HANDLE_PAGE *hp;
unsigned int *hpcnt;
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.h.ah = 0x4D; /*функция "Получить страницы всех
обработчиков" спецификации расширенной памяти*/
segregs.es = segregs.ds; /*сегмент массива HANDLE_PAGE*/
inregs.x.di = (unsigned int) hp; /*смещение массива HANDLE_
PAGE*/
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
if (!result) /*функция завершилась успешно*/
*hpcnt = outregs.x.bx;
return(result);
}
EMSGetPageMap(map) /*получает контекст менеджера расширенной па-
мяти в область сохранения контекста пользователя*/
PMAP *map;
{
segread(&segregs); /*заполнить регистры сегментов*/
segregs.es = segregs.ds; /*использовать es = ds*/
inregs.x.ax = 0x4E00; /*функция "Получить отображение стра-
ниц" спецификации расширенной памяти*/
inregs.x.di = (unsigned int) map; /*указатель на массив отоб-
ражения*/
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSSetPageMap(map) /*устанавливает контекст менеджера расширенной
памяти из области сохранения контекста пользователя*/
PMAP *map;
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax = 0x4E01; /*функция "Установить отображение стра-
ниц" спецификации расширенной памяти*/
inregs.x.si = (unsigned int) map; /*указатель на массив отоб-
ражения*/
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSGetSetPageMap(srcmap, destmap) /*сохраняет контекст менеджера
сширенной памяти в destmap и затем устанавливает
контекст менеджера расширенной памяти из srcmap*/
PMAP *srcmap, *destmap;
{
segread(&segregs); /*заполнить регистры сегментов*/
segregs.es = segregs.ds; /*оба отображения в ds*/
inregs.x.ax = 0x4E02; /*функция "Получить и установить отоб-
ражение страниц" спецификации расширенной памяти*/
inregs.x.si = (unsigned int) srcmap; /*указатель на массив
отображения-источника*/
inregs.x.di = (unsigned int) destmap; /*указатель на массив
отображения-приемника*/
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSGetPageMapeSize(size) /*получает размер области сохранения
контекста пользователя*/
unsigned int *size;
{
inregs.x.ax = 0x4E03; /*функция "Получить размер отображе-
ния страниц" спецификации расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs);
if (!(result) & 0xFF00)) /*функция завершилась успешно*/
*size = outregs.h.al;
return(result >> 8);
}
EMSGetPPageMap(pmap, savearea) /*получает частичный контекст ме-
неджера расширенной памяти в область со-
хранения пользователя*/
PPMAP *pmap;
PCONTEXT *savearea;
{
segread(&segregs); /*заполнить регистры сегментов*/
segregs.es = segregs.ds; /*использует es = ds*/
inregs.x.ax = 0x4F00; /*функция "Получить частичное отобра-
жение страниц" спецификации расширенной памяти*/
inregs.x.si = (unsigned int) pmap; /*какие кадры мы хотим*/
inregs.x.di = (unsigned int) savearea; /*указатель на массив
отображения*/
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSSetPPageMap(savearea) /*устанавливает частичный контекст ме-
неджера расширенной памяти из области
сохранения пользователя*/
PCONTEXT *savearea;
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax = 0x4F01; /*функция "Установить частичное отобра-
жение страниц" спецификации расширенной памяти*/
inregs.x.si = (unsigned int) savearea; /*кадры, которые мы хо-
тим восстановить*/
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSGetPPageMapeSize(count,size) /*получает размер области, необ-
ходимой для сохранения*/
unsigned int count,*size;
{
inregs.x.ax =0x4F02; /*функция "Получить размер частично-
го отображения страниц" специфи-
кации расширенной памяти*/
inregs.x.bx = count; /*кол-во кадров для сохранения*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs);
if (!(result) & 0xFF00)) /*функция завершилась успешно*/
*size = outregs.h.al;
return(result >> 8);
}
EMSMapMultPages(handle, map, method, count) /*отображает count
страниц в map для handle*/
unsigned int handle; /*обработчик, для которого отображаются
страницы*/
LOG_TO_PHYS *map; /*отображение логических страниц в физи-
ческие*/
unsigned int method; /*используются номера кадра страниц или
адреса отображаемых сегментов*/
unsigned int count; /*кол-во элементов в отображении*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.h.ah =0x50; /*функция "Отобразить много страниц
обработчика" спецификации расширенной памяти*/
inregs.h.al = (unsigned char) method;
inregs.x.cx = count; /*кол-во страниц для отображения*/
inregs.x.dx = handle; /*обработчик, которому эти страницы
принадлежат*/
inregs.x.si = (unsigned int) map; /*страницы для отображения*/
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSReallocPages(handle, pages) /*изменяет размещение handle для
pages*/
unsigned int handle, *pages;
{
inregs.h.ah =0x51; /*функция "Переразместить страницы"
спецификации расширенной памяти*/
inregs.x.bx = *pages; /*кол-во логических страниц, которое
будет после выполнения*/
inregs.x.dx = handle; /*обработчик, для которого переразме-
щается страница*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >> 8;
if (!result) /*функция завершилась успешно*/
*pages = outregs.x.bx; /*новое кол-во страниц*/
return(result);
}
EMSGetHandleAttr(handle, attr) /*получает атрибут обработчика*/
unsigned int handle, *attr;
{
inregs.x.ax =0x5200; /*функция "Получить атрибут обра-
ботчика спецификации расширенной памяти*/
inregs.x.dx = handle;
result = (unsigned int) int86(EMM_INT, &inregs, &outregs);
if (!(result & 0xFF00)) /*функция завершилась успешно*/
*attr = outregs.h.al; /*атрибут*/
return(result >> 8);
}
EMSSetHandleAttr(handle, attr) /*устанавливает атрибут обработ-
чика*/
unsigned int handle, attr;
{
inregs.x.ax =0x5201; /*функция "Установить атрибут об-
работчика спецификации расширенной памяти*/
inregs.x.dx = handle;
inregs.h.bl = attr & 0x00FF;
result = (unsigned int) int86(EMM_INT, &inregs, &outregs)>> 8;
return(result);
}
EMSGetAttrCap(cap) /*получить возможности атрибута*/
unsigned int *cap;
{
inregs.x.ax =0x5202; /*функция "Получить возможности ат-
рибута спецификации расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs);
if (!(result & 0xFF00)) /*успех */
*cap = outregs.h.al;
return(result >> 8);
}
EMSGetHandleName(handle, name) /*получает имя обработчика handle*/
unsigned int handle; /*обработчик, для которого получается имя*/
char *name; /*буфер для получения имени обработчика*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax =0x5300; /*функция "Получить имя обработчика"*/
segregs.es = segregs.ds;
inregs.x.di = (unsigned int) name;
inregs.x.dx = handle;
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSSetHandleName(handle, name) /*устанавливает имя обработчика
handle*/
unsigned int handle; /*обработчик, для которого устанавл. имя*/
char *name; /*буфер с именем обработчика*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax =0x5301; /*функция "Установить имя обработч."*/
inregs.x.si = (unsigned int) name;
inregs.x.dx = handle;
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSGetHandleDir(hnt, hn_cnt) /*получает имя каталога обработчика
handle*/
HANDLE_NAMES *hnt; /*указатель на таблицу имен обработчиков*/
unsigned int *hn_cnt; /*возвращенное кол-во элементов*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax =0x5400; /*функция "Получить каталог обработчи-
ка" спецификации расширенной памяти*/
inregs.x.di = (unsigned int) hnt;
segregs.es = segregs.ds;
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs);
if (!(result & 0xFF00)) /*функция завершилась успешно*/
*hn_cnt = outregs.h.al; /*возврат кол-ва полученных
имен обработчиков*/
return(result >> 8);
}
EMSSearhHandleName(name, handle) /*поиск названного обработчика*/
char *name; /*имя, которое нужно искать*/
unsigned int *handle; /*возвращаемый номер обработчика*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax =0x5401; /*функция "Поиск названного обработчи-
ка" спецификации расширенной памяти*/
inregs.x.si = (unsigned int) name;
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
if (!result) /*функция завершилась успешно*/
*handle = outregs.x.dx; /*возврат значения обработчика*/
return(result);
}
EMSGetTotalHandles(handle_count) /*Получить общее кол-во обработ-
чиков*/
unsigned int *handle_count;
{
inregs.x.ax =0x5402; /*подфункция "Получить общее кол-во
обработчиков" спецификации расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
if (!result)
*handle_count = outregs.x.bx;
return(result);
}
EMSMoveRegion(rp) /*передвинуть область*/
MOVE_XCHG *rp; /*указатель на дескриптор области*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax =0x5700; /*функция "Передвинуть область"
спецификации расширенной памяти*/
inregs.x.si = (unsigned int) rp;
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSExchangeRegion(rp) /*обменять область*/
MOVE_XCHG *rp; /*указатель на дескриптор области*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax =0x5701; /*функция "Обменять область"
спецификации расширенной памяти*/
inregs.x.si = (unsigned int) rp;
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSGetMapAddrArray(mpaa, mpa_cnt) /*получить массив отображаемых
физических адресов*/
MAP_PHYS_PAGE *mpaa; /*указатель на массив отображаемых
физических адресов*/
unsigned int *mpa_cnt; /*кол-во возвращенных элементов*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax =0x5800; /*функция "Получить массив
отображаемых физических адресов"*/
inregs.x.di = (unsigned int) mpaa;
segregs.es = segregs.ds;
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
if (!result) >> 8); /*функция завершилась успешно*/
*mpa_cnt = outregs.x.cx; /*возврат кол-ва отображаемых
физических страниц*/
return(result);
}
EMSGetMapAddrCount(mpa_cnt) /*получить кол-во отображаемых
физических адресов*/
unsigned int *mpa_cnt; /*кол-во отображаемых физических
страниц*/
{
inregs.x.ax =0x5801; /*функция "Получить кол-во
отображаемых физических адресов"*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
if (!result) /*функция завершилась успешно*/
*mpa_cnt = outregs.x.cx; /*возврат кол-ва отображаемых
физических страниц*/
return(result);
}
EMSGetHardwareInfo(hwp) /*получить информацию об обору-
довании спецификации расширенной памяти*/
HARDWARE_INFO *hwp; /*указатель на область для получе-
ния информации об оборудовании*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax =0x5900; /*функция "Получить информацию об
оборудовании спецификации расширенной памяти*/
inregs.x.di = (unsigned int) hwp;
segregs.es = segregs.ds;
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
return(result);
}
EMSGetRawPageCount(rpg_cnt, urpg_cnt) /*получить кол-во исходных
страниц*/
unsigned int *rpg_cnt; /*кол-во исходных страниц*/
unsigned int *urpg_cnt; /*кол-во неразмещенных исходных страниц*/
{
inregs.x.ax =0x5901; /*функция "Получить кол-во исходных
страниц спецификации расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
if (!result) { /*функция завершилась успешно*/
*rpg_cnt = outregs.x.dx; /*общее кол-во исходных страниц*/
*urpg_cnt = outregs.x.bx; /*кол-во неразмещенных исходных
страниц*/
}
return(result);
}
EMSAllocateStdPages(handle, pages) /*размещает обработчик с 'pag-
es' стандартных страниц*/
unsigned int handle, *pages;
{
inregs.x.ax =0x5A00; /*функция "Разместить стандартные
страницы" спецификации расширенной памяти*/
inregs.x.bx = pages; /*кол-во логических страниц для раз-
мещения*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >> 8;
if (!result) /*функция завершилась успешно*/
*handle = outregs.x.dx; /*обработчик менеджера расширенной
памяти для применения с этими страницами*/
return(result);
}
EMSAllocateRawPages(handle, pages) /*размещает обработчик с 'pag-
es' исходных страниц*/
unsigned int handle, *pages;
{
inregs.x.ax =0x5A01; /*функция "Разместить исходные стра-
ницы" спецификации расширенной памяти*/
inregs.x.bx = pages; /*кол-во логических страниц для раз-
мещения*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >> 8;
if (!result) /*функция завершилась успешно*/
*handle = outregs.x.dx; /*обработчик менеджера расширенной
памяти для применения с этими страницами*/
return(result);
}
EMSGetAltMapRegSet(set,pmap) /*получает альтернативный набор ре-
гистров отображения спецификации расширенной памяти*/
unsigned int *set; /*текущий альтернативный набор ре-
гистров отображения*/
PMAP far **pmap; /*указатель на указатель области со-
хранения контекста*/
{
inregs.x.ax =0x5B00; /*функция "Получить альтернативный на-
бор регистров отображения"*/
segread(&segregs);
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
if (!result) {
*set = outregs.h.bi; /*текущий активный набор*/
if (*set == 0) { /*фальшивый альтернативный набор ре-
гистров*/
FP_OFF(*pmap) = outregs.x.di; /*смещение области кон-
текста операционной среды (OS)*/
FP_SEG(*pmap) = segregs.es; /*сегмент области кон-
текста операционной среды (OS)*/
}
}
return(result);
}
EMSSetAltMapRegSet(set,pmap) /*устанавливает альтернативный набор
регистров отображения спецификации расширенной памяти*/
unsigned int set; /*новый альтернативный набор ре-
гистров отображения*/
PMAP *pmap; /*указатель области сохранения контекста*/
{
segread(&segregs); /*заполнить регистры сегментов*/
inregs.x.ax =0x5B01; /*функция "Установить альтернативный на-
бор регистров отображения"*/
inregs.h.bl = set & 0x00FF;
if (set == 0) { /*фальшивый альтернативный набор ре-
гистров*/
inregs.x.di = (unsigned int) pmap;
segregs.es = segregs.ds;
}
result = (unsigned int) int86x(EMM_INT, &inregs, &outregs,
&segregs) >> 8;
if (!result)
}
EMSGetAltMapArraySize(size) /*получает размер массива сохранения
альтернативного отображения*/
unsigned int size; /*кол-во отображаемых физических
страниц*/
{
inregs.x.ax =0x5B02; /*функция "Получить размер массива со-
хранения альтернативного отображения"*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
if (!result) /*успех*/
*size = outregs.x.dx; /*размер массива*/
return(result);
}
EMSAllocAltMapRegSet(set) /*размещает альтернативный набор регис-
тров отображения*/
unsigned int *set; /*номер, размещенного набора*/
{
inregs.x.ax =0x5B03; /*функция "Разместить альтернативный
набор регистров отображения"*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
if (!result) /*успех*/
*set = outregs.h.bl; /*номер размещенного набора*/
return(result);
}
EMSDeallocAltMapRegSet(set) /*освобождает альтернативный набор ре-
гистров отображения*/
unsigned int set; /*номер, освобождаемого набора*/
{
inregs.x.ax =0x5B04; /*функция "Освободить альтернативный
набор регистров отображения"*/
inregs.h.bl = set & 0x00FF;
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
return(result);
}
EMSAllocDMARegSet(set) /*размещает набор регистров ПДП*/
unsigned int *set; /*номер, размещаемого набора*/
{
inregs.x.ax =0x5B05; /*функция "Разместить набор регистров
ПДП" спецификации расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
if (!result) /*успех*/
*set = outregs.h.bl; /*номер размещенного набора*/
return(result);
}
EMSEnableDMARegSet(set, channel) /*разрешает набор регистров ПДП*/
unsigned int set; /*номер, разрешаемого набора*/
unsigned int channel; /*номер канала ПДП для связыва-*/
ния с регистром отображения*/
{
inregs.x.ax =0x5B06; /*функция "Разрешить набор регис-
тров ПДП" спецификации расширенной памяти*/
inregs.h.bl = set & 0x00FF;
inregs.h.dl = channel & 0x00FF;
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
return(result);
}
EMSDisableDMARegSet(set) /*запрещает набор регистров ПДП*/
unsigned int set; /*номер запрещаемого набора*/
{
inregs.x.ax =0x5B07; /*функция "Запретить набор регистров
ПДП" спецификации расширенной памяти*/
inregs.h.bl = set & 0x00FF;
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
return(result);
}
EMSDDeallocDMARegSet(set) /*освобождает набор регистров ПДП*/
unsigned int set; /*номер освобождаемого набора*/
{
inregs.x.ax =0x5B08; /*функция "Освободить набор регистров
ПДП" спецификации расширенной памяти*/
inregs.h.bl = set & 0x00FF;
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
return(result);
}
EMSPrepareForWarmboot() /*подготавливает оборудование специфи-
кации расширенной памяти к программному перезапуску*/
{
inregs.h.ah =0x5C; /*функция "Подготовиться к программному
перезапуску" спецификации расширенной памяти*/
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
return(result);
}
EMSEnableOSFunc(key) /*разрешить набор функций операционной
среды*/
long *key; /*ключ доступа к операционной среде - должен быть
равен 0, когда применяется первый раз*/
{
inregs.x.ax =0x5D00; /*функция "Разрешить набор функций опе-
рационной среды" спецификации расширенной памяти*/
if (*key !=0) {
inregs.x.bx = FP_OFF(*key);
inregs.x.cx = FP_SEG(*key);
}
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
if (!result) {
FP_OFF(*key) = outregs.x.bx;
FP_SEG(*key) = outregs.x.cx;
}
}
return(result);
}
EMSDisableOSFunc(key) /*запретить набор функций операционной
среды*/
long *key; /*ключ доступа к операционной среде - должен быть
равен 0, когда применяется первый раз*/
{
inregs.x.ax =0x5D01; /*функция "Запретить набор функций опе-
рационной среды" спецификации расширенной памяти*/
if (*key !=0) {
inregs.x.bx = FP_OFF(*key);
inregs.x.cx = FP_SEG(*key);
}
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
if (!result) {
FP_OFF(*key) = outregs.x.bx;
FP_SEG(*key) = outregs.x.cx;
}
}
return(result);
}
EMSReturnAccessKey(key) /*возвращает ключ доступа к операционной
среде менеджеру расширенной памяти*/
long *key; /*ключ доступа к операционной среде*/
{
inregs.x.ax =0x5D02; /*функция "Возвратить ключ доступа к
операционной среде" спецификации расширенной памяти*/
inregs.x.bx = FP_OFF(key);
inregs.x.cx = FP_SEG(key);
result = (unsigned int) int86(EMM_INT, &inregs, &outregs) >>8;
return(result);
}
------------------------------------------------------------------
|
