Ввод/вывод тогда и сейчас. Чему мы радовались тогда и чему мы радуемся сейчас

//идеи 1) менеджер памяти (заказываем по XMS 1 MB и далее копируем туда
//нашу прогу)
 
//просмотр TSS, двоичной
 
//идея!!! определить обработчики для R-режима!!
//перед выходом назад вернуть
 
#include <stdio.h>
#include <process.h>
#include <conio.h>
//#include <fstream.h>
 
 
#include "pmode.h"
#include "console.h"
#include "xms.h"
#include "memorypm.h"
 
#include <iostream.h>
#include <alloc.h>
#include "virtual.h"
#include "interupt.h"
#include "debug.h"
 
DWORD Page_dir_base;
 
XMS_HANDLE XMS_Handle;
 
extern "C" void CppModule();
 
 
DWORD BaseLinearAddr=0, //базовый адрес программы в расширенной памяти/
        BaseCodeSegment,    //база сегмента кода относитльно
    BaseDataSegment,    //база сегмента данных
    BaseComportBuffer;  //адрес для данных из ком-порта
 
 
extern BYTE XmsErrorCode;
 
const BASE_HARDWARE=0x20;   //(32) база аппартных прерываний (IRQ0,IRQ1)
 
//void wait_key(BYTE n,DWORD=-1);   //ожидать скан
 
extern "C" void V86ModeProc();
 
extern DWORD TimerCounter;
 
//extern BYTE far * Code;
 
void V86ModeProc();
void Task();
extern "C" void pascal int13(...);
extern "C" void pascal int8(...);
void int80();
void timer_int();
void keyboard_int();
void int9einterrupt();
 
extern "C" void IntHandlers();
 
//-----------прерывания---------
void int14_page_fault();
void int12_stack_fault();
void Com2Interrupt();
void KeyboardInterrupt();
void MouseInterrupt();  //обслуживает аппаратные прерывания от мыши
void FloppyDiskInterrupt(); //обслуживает аппаратные прерывания от флоппика
void HardDiskInterrupt();   //обслуживает аппаратные прерывания от флоппика
void intE4_get_combuf();
void V86INT9E();
 
void SetOldBasesVector();
void SetNewBasesVector();
 
CONSOLE con;
 
WORD RealModeCS;
 
int ProtectedMode=0, VirtualMode=0;
 
void beep(int n=1)
{
    beep(200,1000+n*50);
    pause(100);
    beep(300,1500+n*50);
    pause(100);
    beep(400,1900+n*50);
    pause(100);
 
}
 
WORD tss_seg=SELECTOR::MAIN_TASK;
 
DWORD newcnt=0;
 
WINCONSOLE OperatorNewWindow(25,5,7," Operator New ");
 
WINCONSOLE OperatorDeleteConsole(25,5,7," Operator New ");
 
/*
void * operator new (WORD block_size)
{
    OperatorNewWindow.RealVirtualMode=TRUE;
    OperatorNewWindow.Show();
    OperatorNewWindow<<"cnt="<<++newcnt<<" <8> to continue";
    beep(9);
    wait_key(9);
    return 0;
}
 
DWORD delcnt=0;
void operator delete(void *)
{
    OperatorDeleteConsole.RealVirtualMode=TRUE;
    OperatorDeleteConsole.Show();
    OperatorDeleteConsole<<"cnt ="<<++delcnt<<" <10> to continue";
    beep(3);
    wait_key(11);
}*/
 
ALL_16BIT_REGISTER old;
 
//сегмент состояния первой задачи
TSS TSS_MAIN_TASK;
 
//сегмент состояния задачи и двоичная карта ввода-вывода
TSS VM86_TSS;
BYTE V86_IOMAP[4096];
 
extern "C"
{
    void initCS(WORD CodeSeg);
}
 
 
//глобальная дескрипторная таблица сегментов
//Внимание !!! Не изменяйте порядок следования дескрипторов!
//при необходимость их можно лишь добавлять/
 
WORD GLOBAL_DESCRIPTOR_COUNT=16;    //число элементов в GDT
 
SEGMENT_DESCRIPTOR
    reserved,   //0-ой дескриптор зарезервирован intel
    text_buffer,    // 1 указывает на текстовый буфер
    code_selector,          // 2 сегмент кода
    data_selector,           // 3 данные
    stack_selector,          // 4 стек
    graph_buffer,   // 5
    dos_segment,    // 6
    main_task,      // 7
    xxxx_task,      // 8
    GlobalMemoryRO, // 9 вся память только для чтения
    VM86_task,      // 10
    GlobalMemoryRW, // 11 вся память только для чтения/записи
    DosSelector,        //12 селектор для преобразования дос-сегмента
    TempSelector, //13 для временного использования. должен каждый раз инициал.!
    xxxxxxx, //14
    xxxxxxxxx1 //15
    ;
 
SEGMENT_DESCRIPTOR * GlobalDescriptorTable=&reserved;
 
GDTR Gdtr;
IDTR Idtr;
 
//глобальная дескрипторная таблица прерываний
INTERRUPT_DESCRIPTOR InterruptDescriptorTable[256];
 
BYTE InitPmodeStack[4096];
//инициализация первых элементов глобальной дескрипторной таблицы
void initGDT()
{
    //устанавливаем сегмент кода
    //ВНИМАНИЕ !!! Даннные и код должны быть скопированы выше 1 Мг!!!
    code_selector.set(DWORD(_CS)<<4, 0xFFFF, CODE_PERFORM_READ);
 
//  code_selector.set(BaseCodeSegment, 0xFFFF, CODE_PERFORM_READ);
//        code.SetAr)
 
    //устанавливаем сегмент данных
    data_selector.set(DWORD(_DS)<<4, 0xFFFF,  DATA_READ_WRITE);
    //стек
    stack_selector.set(DWORD(_DS)<<4, 0xFFFF, DATA_READ_WRITE);
 
    //устанавливаем сегмент стека
    // напомним, что при использования типа сегмента STACK_READ_WRITE
    // лимит интерпретируется как минимуму адрес
    // а максимум - D=0, G=0 0xffff будет равен пределу
    //      D=1, G=1 0xffffffff
//  stack_selector.set(DWORD(_SS)<<4, 0x1000, STACK_READ_WRITE);
//  stack.SetD(0);
//  stack.SetG(0);
    // ВНИМАНИЕ !!!!! DS==SS !!!
//-------------------------------------------------------------------------
    //устанавливаем сегмент видеоданных (пять страниц 80x25)
    text_buffer.set(0xb8000ul, 80*25*2 *5, DATA_READ_WRITE);
 
    //графика
    graph_buffer.set(0xA0000l, 0xFFFF, DATA_READ_WRITE);
 
    //сегменты для выхода в DOS
    dos_segment.set(0, 0xFFFF, DATA_READ_WRITE);
 
    //вся память только для чтения
    GlobalMemoryRO.set(0, 0xFFFFFFFFUL, DATA_READ_ONLY);
    GlobalMemoryRO.SetG(1); //гранулярность
 
    //для чтения и записи
    GlobalMemoryRW.set(0, 0xFFFFFFFFUL, DATA_READ_WRITE);
    GlobalMemoryRW.SetG(1);
 
    //для чтения и записи
    DosSelector.set(0, 0xFFFFFFFFUL, DATA_READ_WRITE);
 
    TempSelector.set(MAKE_ABS(_DS,(WORD)&reserved), 0xFFFFFFFFUL, DATA_READ_WRITE);
 
//*********************************************************(************
//--------- Инициалзируем дескриптор (описатель) сегмента состояние задачи
//дескриптор сегмента состояния задачи TSS
        SEGMENT_DESCRIPTOR & a = main_task;
        a.Base( data_selector.GetBase() + WORD(&TSS_MAIN_TASK) );
        a.Limit( sizeof (TSS_MAIN_TASK) );
        a.SetD(0); //для TSS и LDT всегда 0
        a.SetSystem(SYSTEM_OBJECT);
        a.SetType(4); //дескриптор шлюза незанятой задачи
//_______________________________________________________________
        /////////////////// VM86_TSS ///////////////
        SEGMENT_DESCRIPTOR &b = VM86_task;
        b.Base( data_selector.GetBase() + WORD(&VM86_TSS) ); //!!!!!!!
        b.Limit( sizeof (VM86_TSS) + sizeof(V86_IOMAP)+2);
        b.SetD(0); //для TSS и LDT всегда 0
        b.SetSystem(SYSTEM_OBJECT);
        b.SetType(4); //дескриптор шлюза незанятой задачи
 
 
 // }
 
}
 
/*void bep(int n)
{
// return;
    delay(100);
    sound(200*n); delay(15); nosound();
    sound(300*n); delay(25); nosound();
    sound(400*n); delay(25); nosound();
    delay(100);
 
}
*/
 
WINCONSOLE ExitConsole(35,4,7+8, "Terminate procedure",-1,-1);
//стек, используемый в процедуре выхода
BYTE TerminateStack[256];
//внимание! здесь не должно содержаться локальных параметров!!! ???
//Эта процедура должна вызываться из защищенного режима
void Terminate()
{
    asm cli
 
//  con<<"start terminate\r\n";
 
    //настраиваем временный стек
    _SS=SELECTOR::DATA;
    _ESP=(WORD)TerminateStack+sizeof(TerminateStack);
 
/*  _AX=SELECTOR::EXIT_TO_DOS;
    _DS=_AX;    //почему то виснет если расскоментировать
    _ES=_AX;
    _FS=_AX;
    _GS=_AX;
    _SS=_AX;*/
 
    //перед выходом в реальный режим
    //необходимо загрузить
    //загрузить регистры с пределом 0xFFFF, база любая, G=0,D=0
 
    asm cli
    paging_disable();
//  initCS(old.CS);
//  asm jmp $+2 //очистка кэша
    realmode(); //сбрасываем бит 1 в CR0
    initCS(old.CS); //меняем селектор
 
    //загружаем значения для REAL-MODE
    _DS=old.DS;
    _ES=old.ES;
    _SS=old.SS;
    _FS=old.FS;
    _GS=old.GS;
 
    Idtr.Base=0;
    Idtr.Limit=1024-1;
    Idtr.Load();
 
    ProtectedMode=0;
 
    SetOldBasesVector();
 
    asm mov al,0x20     //если нарушение возникло в обработчике
    asm out 0x20,al     // аппаратного прерывание. чтобы система
//  asm out 0xa0,al     //не блокировалось
 
    _ESP=old.ESP;
    _AX=old.BP;
    _BP=_AX;
 
//  printf("BP=%i",_BP);
    ExitConsole.numberSystem=16;
    ExitConsole.Show();
    ExitConsole<<"Realmode. Press <ESC> to exit.";
    ExitConsole<<"\r\nold.BP="<<old.BP<<" _BP="<<_BP;
 
//  wait_key(2);
 
//  beep(100,2000);
//  beep(200,2000);
 
/*  asm pushad
    asm push ds es fs gs cs ss
    asm mov bx,0
    asm mov dx,1
    asm call PrintAllRegister*/
 
    asm sti
    asm leave   //если в main() есть локальные перемееные - то нужно
                //Terminate!!! не дожна соде. лок. перемен.!!
    asm ret
 
}
 
void int07handler();
void trace_int();
void int08();
void int06_InvalidOperationCode();
void initIDT()
{
    #define intdes InterruptDescriptorTable
 
    //по умолчанию заполняем
    for(int i=0; i<sizeof(intdes)/sizeof(INTERRUPT_DESCRIPTOR);i++)
    {
        intdes[i].SetSelector(SELECTOR::CODE);
        intdes[i].SetOffset( WORD(IntHandlers)+i*8);
        intdes[i].SetDPL(0);
    }
 
    intdes[1].SetOffset( (WORD)trace_int );//отладка
 
    intdes[6].SetOffset(WORD(int06_InvalidOperationCode));
 
    intdes[7].SetOffset( (WORD)int07handler);
    intdes[7].SetDPL(3);
 
    intdes[8].SetOffset( (WORD)int08);
    intdes[13].SetOffset( WORD(int13) );
    intdes[12].SetOffset((WORD)int12_stack_fault);
    intdes[14].SetOffset((WORD)int14_page_fault);
 
    //############ аппаратные прерывания ###################
    intdes[BASE_HARDWARE+0].SetOffset( WORD(timer_int) );   //таймер IRQ0
    intdes[BASE_HARDWARE+1].SetOffset( WORD(KeyboardInterrupt) );   //клавиатура IRQ1
                                                                    //irq2
    intdes[BASE_HARDWARE+3].SetOffset( WORD(Com2Interrupt) );   //IRQ3
    intdes[BASE_HARDWARE+4].SetOffset( (WORD)MouseInterrupt);   //IRQ 4
    intdes[BASE_HARDWARE+6].SetOffset( (WORD)FloppyDiskInterrupt);  //IRQ6
    intdes[BASE_HARDWARE+14].SetOffset( (WORD)HardDiskInterrupt);   //IRQ14
void Interrupt_Number_2F();
    intdes[BASE_HARDWARE+15].SetOffset( (WORD)Interrupt_Number_2F); //IRQ15);
// выводы сделали такие. При работе в V-режиме при значении IOPL=3
// могут напрямую вызываться прерывания защищенного режима, если
// DPL дескрипотра обработчика = 3
// также при IOPL=3 команды CLI, STI,PUSHF,POPF не вызывают GPF#13
// если же IOPL=0,1,2 то команда int всегда вызывает GPF#13
    intdes[0x9E].SetDPL(3);
    intdes[0x9E].SetOffset( WORD(int9einterrupt) );
    intdes[0x9E].SetType(TRAPS_GATE_i486);  //ловушка, прерывания не запрещаются
 
 
    #undef intdes
}
 
BYTE ring0_stack[2048];
 
//BYTE VirtualModeStack[2048];
 
BYTE stack_MainTSS[512];
BYTE stack_Ring0_MainTSS[512];
 
 
}

#ifndef _PMODE__H
#define _PMODE__H
 
#include "mytypes.h"
 
DWORD       GetBase(WORD selector);
DWORD       SetInt13HandlerFlag(DWORD flag);
DWORD       ResetInt13HandlerFlag(DWORD flag);
int         SaveTextScreenBuffer();
void        RestoreTextScreenBuffer();
void        ShowTextScreenBuffer(int);
void        Terminate();
 
//установка свойства 13 обработчик прерываний
#define INT13HANDLER_VIRTUAL_INT_AUTO                   0x00000001ul
#define INT13HANDLER_VIRTUAL_IRET_AUTO                  0x00000002ul
#define INT13HANDLER_VIRTUAL_PUSHFD_AUTO                0x00000004ul
#define INT13HANDLER_VIRTUAL_POPFD_AUTO                 0x00000008ul
#define INT13HANDLER_VIRTUAL_PUSHF_AUTO                 0x00000010ul
#define INT13HANDLER_VIRTUAL_POPF_AUTO                  0x00000020ul
#define INT13HANDLER_VIRTUAL_CLI_AUTO                   0x00000040ul
#define INT13HANDLER_VIRTUAL_STI_AUTO                   0x00000080ul
#define INT13HANDLER_VIRTUAL_INT15_MOVE_BLOCK_AUTO      0x00000100ul
#define INT13HANDLER_SHOWDEBUG                          0x00001000ul
 
DWORD InputNumber(char * mes, WORD digitcount=4);
 
void MemoryDump();
BYTE wait_key(BYTE,DWORD=0);
void beep(DWORD,WORD);
void pause(DWORD);
 
//сегмент состояния задачи
class TSS
{
public:
    WORD    LinkCS, rs1;
    DWORD   ESP0;
    WORD    SS0, rs2;
    DWORD   ESP1;
    WORD    SS1, rs3;
    DWORD   ESP2;
    WORD    SS2, rs4;
 
    DWORD   CR3, EIP, EFLAGS,
        EAX, ECX, EDX, EBX,
        ESP, EBP, ESI, EDI;
 
    WORD    ES, rs5,
        CS, rs6,
        SS, rs7,
        DS, rs8,
        FS, rs9,
        GS, rs10,
        LDT, rs11,
        Trap, BinaryMapIO;
    WORD    LastByte;
    //конструктор по умолчанию
    TSS() : LastByte(0), Trap(0), BinaryMapIO(0), LDT(0), CR3(0),
        LinkCS(0),
        rs1(0),rs2(0),rs3(0),rs4(0),rs5(0),
        rs6(0),rs7(0),rs8(0),rs9(0), rs10(0),rs11(0) {}
 
};
 
class SELECTOR
{
public:
    enum
    {
        TEXT_BUFFER =       1*8,
        DATA        =       3*8,
        CODE        =       2*8,
        nnnnnnxxxxSTACK     =       4*8,
        MAIN_TASK       =   7*8,
        SUB_TASK        =   8*8,
        GLOBAL_MEMORY_RO=   9*8,
        GLOBAL_MEMORY_RW=   11*8,
        DOS_SELECTOR    =   12*8,
        TEMP_SELECTOR   =   13*8
    };
};
 
 
extern "C"
{
    void pmode();
    void realmode();
}
 
struct ALL_16BIT_REGISTER
{
    WORD AX,BX,CX,DX,
        SI, DI,ESP, BP;
    WORD DS, ES, FS, GS, SS, CS;
};
 
/*struct ALL_REG
{
    DWORD _EAX,_EBX,_ECX,_EDX,
        _ESI, _EDI,_ESP;
    WORD
        _DS, _ES, _FS, _GS,
        _SS, _SP,
        _CS;
};*/
 
 
/*
;----------------- Формат дескриптора в GDT (64 бита) --------------------
;'BBBBBBBB'GDXU LLLL'PПрS ТипA'BBBB BBBB'BBBBBBBB'BBBBBBBB'LLLLLLLL'LLLLLLLL'
;BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB 32-битная база (абсолютный адрес) объекта
;LLLLLLLLLLLLLLLLLLLL 20-битный предел (размер) объекта
;G (Granularity) =0 максимальный предел 1Mb, =1 максимальный предел 4Gb
;D (Default size) =0 операнды в объекте 16-битные, =1 операнды 32-битные
;X не должен изменяться
;U (User) бит пользователя
;P (Present) =0 не присутствует в памяти, =1 присутствует в памяти
;Пр_ивелегии (DPL, Descriptor Privilege Level) уровень привелегий объекта
; =00, =01, =10, =11 от большего (=00) к меньшему (=11)
;S (System) =0 несистемный обьект, =1 системный обьект
;Тип (Type)  =000 данные, только читать(ROM)
;       =001 данные, можно читать и писать(RAM)
;       =010 стек ROM (на практике не применяются)
;       =011 cтек RAM
;       =100 код читать нельзя
;       =101 код читать можно
;       =110 подчиненный код, читать нельзя
;       =111 подчиненный код, читать можно
;Тип можно интерпретировать так:
; E - тип исполняемости (=1 код, =0 данные)
 
; |E=1|C|R| сегмент кода C
;R - бит разрешения считывания вводится для сегмента программ и разрешает
;при R=1 производить считывание его содержимого. При R=0 допускается только
;выборка его содержимого. Попытка считывания сегмента в этом случае вызовет
;прерывание типа 13.Отметим, что прерывание этого типа возникнет также при
;попытке записи в сегмент программ независимо от значение типа R
; Бит подчинения C определяет дополнительные правила обращения, которые
; обеспечивают защиту сегментов программ
 
; |E=0|ED|W|    сегмент данных
; W - бит разрешения записи. При W=1 разрешается, при W=0 запрещается запись
; в сегмент данных
; Бит направление расширения. При ED=0 расширение вверх, ED=1 расширение вниз
 
;A (Access) =0 обращения к сегменту не было,=1 обращение к сегменту было(автомат)
;-------------------------------------------------------------------------------
*/
 
    // возможные типы (Present) бит присутствия сегмента
    enum {
        PRESENT=1,  //присутствует в памяти
        NOT_PRESENT=0   //сегмент не присутствует
    };
 
 
    //возможные типы (Type) сегментов
    enum {
        DATA_READ_ONLY  =0, // данные, только читать(ROM)
        DATA_READ_WRITE =1, // данные, можно читать и писать(RAM)
//      STACK_READ_ONLY =2, //стек ROM (на практике не применяются)
        STACK_READ_WRITE=3, // cтек RAM
        CODE_PERFORM_ONLY=4,    //код читать нельзя, только выполнять
        CODE_PERFORM_READ=5,    //код читать можно
        CODE_SPECIAL_CANTREAD=6,// подчиненный код, читать нельзя
        CODE_SPECIAL_READOK=7   //подчиненный код, читать можно
    };
 
    // типы объектов (System)
    enum {
        SYSTEM_OBJECT=0,    //системный объект
        SEGMENT_OBJECT=1    //несистменый объект
    };
 
 
 
//класс Global Descriptor Table Register - класс глобальной дескрипторной
//таблицы
class GDTR
{
public:
    WORD Limit; //максимальная длина дескрипторной таблицы
    DWORD Base; //абсолютный 32-битный адрес дескрипторной таблицы
    void Load();
};
 
//класс Interrupt Descriptor Table Register - класс глобальной дескрипторной
//таблицы прерываниц
class IDTR
{
public:
    WORD Limit; //максимальная длина дескрипторной таблицы
    DWORD Base; //абсолютный 32-битный адрес дескрипторной таблицы
    void Load();
};
 
    // (DPL) Descriptor Privilege Level - уровень привелегий сегмента
    enum {
        HIGH_PRIVILEGE  =0, //высший уровень привелегии
        MEDIUM_PRIVILEGE=1,
        SMALL_PRIVILEGE =2,
        TINY_PRIVILEGE  =3  //низший уровень привелегий
    };
 
    // типы системных дескрипторов (SYSTEM_OBJECT)
    enum //DescriptorTypes
    {
        // 0 - не используется
        // 1 - доступен TSS 80286
        // 2 - таблица LDT
        // 3 - TSS 80286 занят
        // 4 - шлюз вызова 80286
        TASK_GATE_80286_i486    =5, //шлюз задачи 80286 и i486
        INTERRUPT_GATE_80286    =6, //шлюз прерывания 80286
        TRAPS_GATE_80286    =7, //шлюз ловушки 80286
        // 8 - не используется
        // 9 - доступен TSS i486
        // A - резерв
        // B - TSS i486 занят
        INTERRUPT_GATE_i486 =14,    //шлюз прерывания i486
        TRAPS_GATE_i486     =15 //шлюз ловушки i486
    };
 
//этот класс описывает дескриптор сегмента
class SEGMENT_DESCRIPTOR
{
protected:
    //возможные гранулярности сегментов
    enum { BYTE_GRANULARY=0, PAGE_GRANULARY=1 };
 
//private:
public:
    WORD limit0_15; //размер сегмента (биты 0-15)
    WORD base0_15;  //база сегмента (биты 0-15)
    BYTE base16_23; //база сегмента (биты 16-23)
    //байт прав доступа
//  union {
  //      BYTE AccessRight;
    BYTE
        Access:1,   // (Access) =0 обращения к сегменту не было, =1 было
        Type:3,     // (Type) тип объекта
        System:1,   // (System) =0 несистемный , =1 системный объект
        DPL:2,      // уровень привелегий сегмента
            // =00 =01 =10 =11 от большего (=00) к меньшему (==11)
        Present:1;  // P (Present) =0 не присутствует в памяти,
            //         =1 присутствует в памяти
//  }
//protected:
    BYTE limit16_19:4,  //размер сегмента (биты 16-19)
        User:1,     // User - бит пользователя, может иметь любое
        X:1,        //зарезервировано и должно быть равно нулю
        D:1,        //бит разрядности по умолчанию
                // D=0 - 16 разрядов
                // D=1 - 32 разряда
        G:1;        //бит гранулярности
    BYTE base24_31; //база
 
public:
 
    //конструктор по умолчанию
    SEGMENT_DESCRIPTOR()
    {
        Base(0);
        Limit(0);
        Type=DATA_READ_WRITE;
        DPL=HIGH_PRIVILEGE;
        Access=1;
        System=1;
        Present=1;
        D=0;
        User=0;
        X=0;
        G=0;
    }
 
    void set(DWORD base, DWORD limit, BYTE tp)
    {
        Base(base);
        Limit(limit);
        Type=tp;
    }
 
    //установка предела
    // limit - предел сегмента (0x00001..0xfffff)
    // granulary - тип дробности сегмента
    // если G=BYTE_GRANULARY - установлена байтовая гранулярность,
    // и предел сегмента в точности равен значению limit. При этом
    // предел сегмента не может быть более 1Мг
    // если G=PAGE_GRANULARY - установлена страничная гранулярность
    // фактический предел сегмент будет равен limit*4028 байт. В этом
    // случае можно установить предел сегмента в 4Гб
    void Limit(DWORD limit, BYTE granulary=BYTE_GRANULARY)
    {
        G=granulary;
        limit0_15=limit & 0xffff;
        limit16_19=limit>>16;
    }
 
    //возврашает базу
    DWORD GetBase()
    {
        return (DWORD(base24_31)<<24 ) + (DWORD(base16_23)<<16 )+
        base0_15;
    }
 
    //установка базы
    void Base(DWORD base)
    {
        base0_15=base & 0xffff;
        base16_23=(base>>16) & 0xff;
        base24_31=base>>24;
    }
 
    //установка типа сегмента
    void SetType(BYTE tp);
 
    //установка прав доступа сегмента
//  void SetAR(BYTE aces)
  //    {
      //        access=aces;
    //  }
 
//  //установка уровня привелегий сегмента
//  void SetDPL(BYTE dpl)
//  {
//      access.SetDPL(dpl);
//  }
 
    void SetG(BYTE n) { G=n;}
 
    void SetSystem(BYTE n) { System=n;}
    void SetD(BYTE n) { D=n;}
 
};
 
//класс описания дескриптора прерываний
class INTERRUPT_DESCRIPTOR
{
    WORD Offset0_15;    //смещение до обработчика прерываний биты (0.15)
    WORD Selector;      //селектор обработчика прерываний
    BYTE WordCounter:5, //счетчик слов
        res1:3;     //резерв
    BYTE Type:4,        //тип дескриптора
        res2:1,     //резерв
        DPL:2,      //уровень привелегий
        P:1;        //бит присутствия
    WORD Offset16_31;   //смещение (биты 16..31)
 
public:
    //заполняем по умолчанию
    INTERRUPT_DESCRIPTOR
        (
            WORD selector=0,
            DWORD offset=0,
            BYTE type=INTERRUPT_GATE_i486,
            BYTE dpl=HIGH_PRIVILEGE,
            BYTE present=PRESENT
        )
    {
        Selector=selector;
        Type=type;
        DPL=dpl;
        P=present;
        SetOffset(offset);
        WordCounter=0;
    }
    //установка смещения
    void SetOffset(DWORD offs)
    {
        Offset0_15=offs & 0xffff;
        Offset16_31=offs>>16;
    }
 
    DWORD GetOffset()
    {
        return Offset0_15 + (DWORD(Offset16_31)<<16);
    }
 
    BYTE GetDPL() {return DPL;}
    BYTE GetType() {return Type;}
    BYTE GetPresent() {return P;}
    WORD GetSelector() {return Selector;}
    BYTE GetWordCounter() {return WordCounter;}
 
    //установка селектора
    void SetSelector(WORD sel)
    {
        Selector=sel;
    }
 
    //установка уровня привелегий DPL
    void SetDPL(BYTE dpl)
    {
        DPL=dpl;
    }
 
    //установка типа дескриптора
    void SetType(BYTE tp) { Type=tp;}
};
 
#endif