home *** CD-ROM | disk | FTP | other *** search
/ Phoenix CD 2.0 / Phoenix_CD.cdr / 01e / msjall.zip / MSJV3-1.ZIP / LIM4.ALL < prev    next >
Text File  |  1988-03-08  |  24KB  |  758 lines
  1. Microsoft Systems Journal
  2. Volume 3; Issue 1; January, 1988
  3.  
  4. Code Listings For:
  5.  
  6.     LIM 4 Programs
  7.     pp. 67-80
  8.  
  9. Author(s): Marion Hansen and John Driscoll
  10. Title:     LIM 4.0: A Definition For the Next Generation of Expanded Memory
  11.  
  12.  
  13.  
  14. Figure 2
  15. ========
  16.  
  17. /* THIS IS THE MAIN PROGRAM FOR SAVSCR */
  18.  
  19. #include <c:\msc\include\dos.h>
  20. #include <c:\msc\include\memory.h>
  21. #include <c:\msc\include\stdio.h>
  22. #include <c:\emm\demo\emm.h>
  23.  
  24. /* set up size and base of video ram */
  25. #define VIDEO_RAM_SIZE 4000
  26. #define VIDEO_RAM_BASE 0XB8000000
  27. union REGS    inregs,    outregs;
  28. struct SREGS     segregs ;
  29.  
  30. char far *video_ram_ptr =  {VIDEO_RAM_BASE}; /* video start 
  31.                         address (CGA) */
  32. unsigned long int video_ram_size ={4000};    /* bytes in video ram */
  33. unsigned int emm_handle ;                    /* emm handle */
  34. char emm_device_name[] = "EMMXXXX0";         /* Device Nmae of EMM */
  35. char emm_handle_name[8] ="shared" ;          /* name for handle to 
  36.                         be shared */
  37. char far *emm_ptr;                           /* pointer to page 
  38.                                                 frame */
  39. char far *(*page_ptr) ;                      /* pointer to page in 
  40.                         the frame */
  41. int pages_needed = 4;
  42. struct log_phys {
  43.   int log_page_number;
  44.   int phys_page_number;
  45.        } current_pages [4] ;
  46. struct log_phys far *map_unmap_ptr ;
  47. int  result ;         /* result passed back from function calls */
  48.  
  49. main ()
  50. {
  51.    /***************************************************************/
  52.    /* Check for a expanded memory manager of 4.0 or greater.      */
  53.    /***************************************************************/
  54.  
  55.    check_emm_version_number();
  56.    
  57.    /***************************************************************/
  58.    /* Cet four pages of expanded memory.                          */
  59.    /***************************************************************/
  60.    result = get_expanded_memory(&emm_ptr, pages_needed, 
  61.         &emm_handle, emm_handle_name);
  62.    if (result != 0) exit(1);
  63.    
  64.    /***************************************************************/
  65.    /* Map in needed pages                                         */
  66.    /***************************************************************/
  67.  
  68.    result = map_unmap_multiple_pages (current_pages, emm_handle, 1);
  69.  
  70.    /***************************************************************/
  71.    /* Copy video screen to logical page 0.                        */
  72.    /***************************************************************/
  73.  
  74.    move_exchg_to_expanded(MOVE_MEMORY_REGION, /* Move to */
  75.                           video_ram_ptr,      /* conventional RAM */
  76.                           emm_handle,         /* handle number*/
  77.                           0,                  /* to physical page */
  78.                           video_ram_size);    /* the number bytes */
  79.    
  80.    /* make a null video screen at logical page 1 */
  81.    
  82. page_ptr = (emm_ptr + 0x4000);
  83. memset (page_ptr, 0, VIDEO_RAM_SIZE);
  84.  
  85.    /***************************************************************/
  86.    /* Unmap all of the pages so that they are proteced.           */
  87.    /***************************************************************/
  88.  
  89.    result = map_unmap_multiple_pages (current_pages, emm_handle, 0);
  90.  
  91.    /* exit to Dos */
  92.    
  93. }
  94.  
  95.  
  96. Figure 3
  97. ========
  98.  
  99.  
  100. /******************************************************************/
  101. /* This function checks to see if an expanded memory manager is   */
  102. /* and then checks to see if the version number is >= 4.0. It     */
  103. /* uses emm function GET VERSION NUMBER.                          */
  104. /******************************************************************/
  105.  
  106. int check_emm_version_number()
  107. {  
  108.    char *emm_device_name_ptr ;
  109.    
  110.    /***************************************************************/
  111.    /* Use the dos get interrupt function (0x35) to get pointer    */
  112.    /* at interrupt vector 0x67, and check for emm device name.    */
  113.    /***************************************************************/
  114.  
  115.    inregs.h.ah = 0x35;
  116.    inregs.h.al =EMM_INT;
  117.    intdosx(&inregs, &outregs, &segregs);
  118.    emm_device_name_ptr = (segregs.es * 65536) + 10;
  119.    if (memcmp(emm_device_name, emm_device_name_ptr,8) !=0)
  120.      {
  121.        printf("Expanded memory manager not present\n");
  122.        exit(1);
  123.      }
  124.  
  125.    /***************************************************************/
  126.    /* Now check for version number >= 4.0                         */    
  127.    /***************************************************************/
  128.  
  129.    inregs.h.ah = GET_VERSION ;  /* set funciton code */
  130.    int86(EMM_INT,&inregs,&outregs);
  131.    if (outregs.h.ah != 0) exit(1);
  132.    if ((outregs.h.ah == 0) & (outregs.h.al < 0x40))
  133.    {
  134.      printf("Expanded memory manager does not support LIM 4.0");
  135.      exit(1) ;
  136.    }  
  137. }
  138.  
  139.  
  140. Figure 4
  141. ========
  142.  
  143.  
  144. /******************************************************************/
  145. /* This function gets the amount of exapnded memory needed and    */
  146. /* returns a pointer to the page from in emm_ptr_ptr.  It also    */
  147. /* assigns a name to the handle. It will return a result of 
  148. /* non-zero if it fails.                                          */
  149. /******************************************************************/
  150.  
  151. int get_expanded_memory(emm_ptr_ptr, pages, emm_handle_ptr, name)
  152.  
  153. char *(*emm_ptr_ptr);    /* pointer to expanded memory page frame */
  154. int pages;               /* number of pages to allocate */
  155. unsigned int *emm_handle_ptr;  /* pointer to emm handle */
  156. char *name;
  157.  
  158. {
  159.    /* check for number of expanded memory pages requested */
  160.  
  161.    inregs.h.ah = GET_UNALLOCATED_PAGE_COUNT ;
  162.    int86(EMM_INT, &inregs, &outregs);
  163.    if (outregs.h.ah != 0) return(1);
  164.    if (outregs.x.bx < pages) return(2);
  165.  
  166.    /* allocate pages pages - Function */
  167.  
  168.    inregs.h.ah = ALLOCATE_PAGES ;   /* Get a handle and allocate */
  169.    inregs.x.bx = pages;             /* 4 logical pages           */ 
  170.    int86(EMM_INT, &inregs, &outregs);
  171.    if (outregs.h.ah != 0) return(3);
  172.    *emm_handle_ptr = outregs.x.dx ;
  173.  
  174.    /* get page frame segment address - Function 2 */
  175.  
  176.    inregs.h.ah = GET_FRAME_ADDRESS;
  177.    int86(EMM_INT, &inregs, &outregs);
  178.    if (outregs.h.ah != 0) return(4);
  179.    *emm_ptr_ptr = (unsigned long int) (outregs.x.bx *65536);
  180.    
  181.  
  182.    /* assign name to handle  - Function 20          */
  183.  
  184.    inregs.x.ax = SET_HANDLE_NAME ;
  185.    inregs.x.dx = *emm_handle_ptr ;
  186.    inregs.x.si = FP_OFF(name) ;
  187.    segregs.ds  = FP_SEG(name);
  188.    int86x(EMM_INT, &inregs, &outregs, &segregs);
  189.    if (outregs.h.ah != 0) return(5);
  190.  
  191.    return(0);
  192.  
  193. }
  194.  
  195.  
  196. Figure 5
  197. ========
  198.  
  199.  
  200. /******************************************************************/
  201. /* This function implements MAP/UNMAP MULTIPLE PAGES emm function */
  202. /******************************************************************/
  203.  
  204. int map_unmap_multiple_pages (log_phys_pages,handle,map_unmap)
  205.  
  206. struct log_phys *log_phys_pages ;  /* pointer to log_phys struct */
  207. unsigned int handle;               /* handle to map or unmap */
  208. unsigned int map_unmap;            /* 0 = map, 1 = unmap */
  209. {
  210.  int i ;
  211.  struct log_phys *temp_ptr;
  212.  
  213.  /* Map mulitple logical pages 0 -3 to logical pages 0 - 3 */
  214.  
  215.  temp_ptr = log_phys_pages;
  216.    
  217.  for (i=0 ; i<=3; i++) 
  218.  {
  219.    log_phys_pages->phys_page_number = i;
  220.    if (map_unmap == 1)
  221.     log_phys_pages->log_page_number = i;
  222.    else
  223.     log_phys_pages->log_page_number = 0xFFFF ; 
  224.  
  225.    log_phys_pages++ ;
  226.        
  227.  }
  228.  
  229.  inregs.x.ax = MAP_UNMAP_MULTIPLE_PAGES ;
  230.  inregs.x.dx = handle;
  231.  inregs.x.cx = 4;
  232.  inregs.x.si = FP_OFF(temp_ptr);
  233.  segregs.ds  = FP_SEG(temp_ptr);
  234.  int86x(EMM_INT,&inregs,&outregs,&segregs);
  235.  if (outregs.h.ah != 0) return(1);
  236.  return(0);
  237. } 
  238.  
  239.  
  240. Figure 6
  241. ========
  242.  
  243.  
  244.  
  245.  
  246. /******************************************************************/
  247. /* This function implements MOVE or EXCHANGE MEMORY REGION        */
  248. /* function to move or exchange conventional memory with expanded */
  249. /* memory pages                                                   */
  250. /******************************************************************/
  251.  
  252. int move_exchg_to_expanded(function_number, conv_buffer,  handle, 
  253.                            page, length)
  254. unsigned int function_number ; /* Move or Exchange*/
  255. char far *conv_buffer ;        /* conventional memory with */
  256. int handle;                    /* EMM memory associated with 
  257.                                   this handle */
  258. int page ;                     /* at this physical page */
  259. unsigned long int length;      /* and this many bytes */
  260.  
  261. {
  262. struct move_exchg 
  263.  {
  264.    unsigned long int region_length;
  265.    char source_type ;
  266.    unsigned int source_handle ;
  267.    unsigned int source_offset ;
  268.    unsigned int source_seg_page;
  269.    char dest_type;
  270.    unsigned int dest_handle;
  271.    unsigned int dest_offset;
  272.    unsigned int dest_seg_page;
  273.   } move_exchg_struct;
  274. struct move_exchg *move_exchg_ptr;  
  275.  
  276.   /* START OF FUNCTION CODE */
  277.  
  278.   move_exchg_struct.region_length  = length ;
  279.   move_exchg_struct.source_type    = 0;
  280.   move_exchg_struct.source_handle  = 0;
  281.   move_exchg_struct.source_offset   = FP_OFF(conv_buffer);
  282.   move_exchg_struct.source_seg_page = FP_SEG(conv_buffer);
  283.   move_exchg_struct.dest_type      = 1;
  284.   move_exchg_struct.dest_handle    = handle;
  285.   move_exchg_struct.dest_offset    = 0 ;
  286.   move_exchg_struct.dest_seg_page  = page;
  287.  
  288.   /* Setup structure to make int86x call */
  289.  
  290.   inregs.x.ax = function_number;
  291.   move_exchg_ptr = &move_exchg_struct;
  292.   inregs.x.si = FP_OFF(move_exchg_ptr);
  293.   segregs.ds  = FP_SEG(move_exchg_ptr);
  294.   int86x(EMM_INT, &inregs, &outregs, &segregs);
  295.   if (outregs.h.ah != 0) exit(1);
  296.  
  297.   return(outregs.x.ax) ;
  298.          
  299. }
  300.  
  301.  
  302. Figure 7
  303. ========
  304.  
  305.  
  306. /* THIS IS THE MAIN PROGRAM FOR SWPSCR */
  307.  
  308. #include <c:\msc\include\dos.h>
  309. #include <c:\msc\include\memory.h>
  310. #include <c:\msc\include\stdio.h>
  311. #include <c:\emm\demo\emm.h>
  312.  
  313. /* set up size and base of video ram */
  314.  
  315. #define VIDEO_RAM_SIZE 4000
  316. #define VIDEO_RAM_BASE 0XB8000000
  317. union REGS    inregs,    outregs;
  318. struct SREGS     segregs ;
  319.  
  320. char far *video_ram_ptr =  {VIDEO_RAM_BASE}; /* video  start address
  321.                                                 (CGA) */
  322. unsigned long int video_ram_size ={4000};    /* bytes in video ram */
  323. unsigned int emm_handle ;                    /* emm handle */
  324. char emm_device_name[] = "EMMXXXX0";         /* Device Nmae of EMM */
  325. char emm_handle_name[8] ="shared" ;          /* name for handle to be 
  326.                                                 shared */
  327. char far *emm_ptr;                           /* pointer to page 
  328.                                                 frame */
  329. char far *(*page_ptr) ;                      /* pointer to page in 
  330.                                                 the frame */
  331. int pages_needed = 4;
  332. struct log_phys {
  333.   int log_page_number;
  334.   int phys_page_number;
  335.        } current_pages [4] ;
  336. struct log_phys far *map_unmap_ptr ;
  337. int  result ;  /* result passed back from function calls */
  338.  
  339. main ()
  340. {
  341.    /***************************************************************/
  342.    /* Check for a expanded memory manager of 4.0 or greater.      */
  343.    /***************************************************************/
  344.  
  345.    check_emm_version_number();
  346.    
  347.    /***************************************************************/
  348.    /* Cet four pages of expanded memory.                          */
  349.    /***************************************************************/
  350.  
  351.    result = get_expanded_memory(&emm_ptr, pages_needed, &emm_handle, 
  352.                                 emm_handle_name);
  353.    if (result != 0) exit(1);
  354.    
  355.    /***************************************************************/
  356.    /* Map in needed pages                                         */
  357.    /***************************************************************/
  358.  
  359.    result = map_unmap_multiple_pages (current_pages, emm_handle, 1);
  360.  
  361.    /***************************************************************/
  362.    /* Copy video screen to logical page 0.                        */
  363.    /***************************************************************/
  364.  
  365.    move_exchg_to_expanded(MOVE_MEMORY_REGION, /* Move to convent- */
  366.                           video_ram_ptr,      /* ional ram area   */
  367.                           emm_handle,         /* handle number    */
  368.                           0,                  /* to physical page */
  369.                           video_ram_size);    /* the number bytes */
  370.    
  371.    
  372.  
  373.    /* make a null video screen at logical page 1 */
  374.  
  375.    page_ptr = (emm_ptr + 0x4000);
  376.    memset (page_ptr, 0, VIDEO_RAM_SIZE);
  377.  
  378.    /***************************************************************/
  379.    /* Unmap all of the pages so that they are proteced.           */
  380.    /***************************************************************/
  381.  
  382.    result = map_unmap_multiple_pages (current_pages, emm_handle, 0);
  383.  
  384.    /* exit to Dos */
  385.    
  386. }
  387.  
  388.  
  389. Figure 8
  390. ========
  391.  
  392.  
  393. /* THIS IS THE  MAIN PROGRAM FOR MAPCALL */
  394.  
  395. #include <c:\msc\include\dos.h>
  396. #include <c:\msc\include\memory.h>
  397. #include <c:\msc\include\stdio.h>
  398. #include <c:\emm\demo\emm.h>
  399.  
  400. /* set up size and base of video ram */
  401.  
  402. union REGS    inregs,    outregs;
  403. struct SREGS     segregs ;
  404.  
  405. unsigned int emm_handle ;
  406. char emm_device_name[] = "EMMXXXX0";      /* Device Name of EMM */
  407. char far emm_handle_name[8] ="mapcall";   /* name for handle */
  408. char far mod1_name[] =
  409.      "c:\\emm\\demo\\module1.exe\0";      /* name of modules to be */                                                      
  410. char far mod2_name[] =                    /* to be loaded */
  411.      "c:\\emm\\demo\\module2.exe\0";
  412. char far *emm_ptr ;
  413. char far *(*page_ptr) ;
  414. int pages_needed = 16 ;
  415.  
  416. struct log_phys {
  417.   int log_page_number;
  418.   int phys_page_number;
  419.        } ;
  420.  
  421. struct log_phys far current_pages[4];
  422.  
  423. struct log_phys far map_call_pages ;
  424.  
  425. int  result;      
  426.  
  427. main ()
  428. {
  429.  
  430.  
  431.    /***************************************************************/
  432.    /* Check for a expanded memory manager of 4.0 or greater.      */
  433.    /***************************************************************/
  434.  
  435.    check_emm_version_number();
  436.    
  437.    /***************************************************************/
  438.    /* Cet four pages of expanded memory.                          */
  439.    /***************************************************************/
  440.  
  441.    result = get_expanded_meory(&emm_ptr, pages_needed, &emm_handle,
  442.                                emm_handle_name);
  443.    if (result != 0) exit(1);
  444.  
  445.    /***************************************************************/
  446.    /* Map in needed pages                                         */
  447.    /***************************************************************/
  448.  
  449.    result = map_unmap_multiple_pages (current_pages, emm_handle, 1);
  450.    
  451.    /***************************************************************/
  452.    /* Load map and calls executeables into expanded memory        */
  453.    /***************************************************************/
  454.  
  455.    *page_ptr = emm_ptr;   /* Module 1 will be loaded into logical */
  456.    load_overlay(mod1_name, page_ptr, 0);   /* and physical page 0 */
  457.  
  458.    /***************************************************************/
  459.    /* Load module 2 into logical page 1 and physical page 1.      */
  460.    /***************************************************************/
  461.  
  462.    load_overlay(mod2_name, page_ptr, 1);
  463.    
  464.    /***************************************************************/
  465.    /* Unmap all pages. The map and call will map in the pages     */
  466.    /* requested and restore the present mapping.                  */
  467.    /***************************************************************/
  468.  
  469.    result = map_unmap_multiple_pages (current_pages, emm_handle, 0);
  470.    
  471.    /***************************************************************/
  472.    /* Do map and call to module in logical page 1. Map logical    */
  473.    /* page to physical page 0 and have current mapping context    */
  474.    /* restored on the return from the map and call.               */
  475.    /***************************************************************/
  476.  
  477.     map_call_pages.log_page_number  = 0;
  478.     map_call_pages.phys_page_number = 0;
  479.     
  480.     map_and_call(&map_call_pages, 1, ¤t_pages, 0, emm_handle);
  481.    
  482.    /***************************************************************/
  483.    /* release handle befor exiting.  This also ummaps any pages   */
  484.    /* that are mapped.                                            */
  485.    /***************************************************************/
  486.  
  487.    inregs.h.ah = DEALLOCATE_PAGES ;
  488.    inregs.x.dx = emm_handle ;
  489.    int86(EMM_INT, &inregs, &outregs);
  490.    
  491.    exit(0);
  492. }
  493.  
  494.  
  495. Figure 9
  496. ========
  497.  
  498.  
  499. /******************************************************************/
  500. /* This function implements ALTER PAGE MAP AND CALL  emm function */
  501. /******************************************************************/
  502.  
  503. int map_and_call(new_map_ptr, new_length, old_map_ptr, 
  504.                  old_length, handle)
  505. struct log_phys *new_map_ptr;
  506. char new_length;
  507. struct log_phys *old_map_ptr;
  508. char old_length;
  509. unsigned int handle;
  510. {
  511.   struct map_call_struct {
  512.      unsigned int offset_target_address ;
  513.      unsigned int seg_target_address ;
  514.      char new_page_map_length ;
  515.      unsigned int offset_new_page_map;
  516.      unsigned int seg_new_page_map ;
  517.      char old_page_map_length ;
  518.      unsigned int offset_old_page_map;
  519.      unsigned int seg_old_page_map ;
  520.    } map_call; 
  521.    struct map_call_struct *map_call_ptr;  
  522.  
  523.   map_call_ptr = &map_call ;
  524.   map_call.offset_target_address = 0 ;
  525.   map_call.seg_target_address    =0xd000;
  526.   map_call.new_page_map_length   = new_length;
  527.   map_call.offset_new_page_map   = FP_OFF(new_map_ptr);
  528.   map_call.seg_new_page_map      = FP_SEG(new_map_ptr);
  529.   map_call.old_page_map_length   = old_length;
  530.   map_call.offset_old_page_map   = FP_OFF(old_map_ptr);
  531.   map_call.seg_old_page_map      = FP_SEG(old_map_ptr);
  532.  
  533.   /****************************************************************/
  534.   /* Set up for alter page map and call function                  */
  535.   /****************************************************************/
  536.  
  537.   inregs.h.ah =0x56;
  538.   inregs.h.al = 0;
  539.   inregs.x.dx = handle ;
  540.   map_call_ptr = &map_call ;
  541.   inregs.x.si = FP_OFF(map_call_ptr);
  542.   segregs.ds = FP_SEG(map_call_ptr);
  543.   int86x(EMM_INT,&inregs,&outregs,&segregs);
  544.   if (outregs.h.ah != 0) return(1);
  545.  
  546.   return(0) ;
  547. }
  548.  
  549.  
  550. Figure 10
  551. ========
  552.  
  553.  
  554. /******************************************************************/
  555. /* This function implements the DOS load function 0x4b. It sets   */
  556. /* AL to 3 which cause the function to load the exe and apply a   */
  557. /* relocation factor to it, but it does not execute the file.     */
  558. /******************************************************************/
  559.  
  560. int load_overlay(load_file_name,relocation_ptr,page)
  561. char *load_file_name ;
  562. char *(*relocation_ptr);
  563. unsigned int page; /* physical page at which to load */
  564.   
  565. {
  566. struct reloc {
  567.   unsigned int load_seg;
  568.   unsigned int reloc_factor;
  569.   } reloc_struct;
  570.   struct reloc *reloc_struct_ptr;
  571.  
  572.   /* setup up structure to pass to load call */
  573.  
  574.   reloc_struct.load_seg = FP_SEG(*relocation_ptr) + (page * 0x400);
  575.   reloc_struct.reloc_factor = FP_SEG(*relocation_ptr) + 
  576.                                (page * 0x400); 
  577.   
  578.   /* Set up register structures for Intdos call */
  579.  
  580.   inregs.h.ah = 0x4B ;   /* Dos Exec function code */
  581.   inregs.h.al = 3;       /* load but do not execute */
  582.   inregs.x.dx  = FP_OFF(load_file_name);
  583.   segregs.ds   = FP_SEG(load_file_name);
  584.  
  585.   reloc_struct_ptr = &reloc_struct ;
  586.   inregs.x.bx  = FP_OFF(reloc_struct_ptr);
  587.   segregs.es  = FP_SEG(reloc_struct_ptr);
  588.  
  589.   intdosx(&inregs, &outregs, &segregs);
  590.  
  591. }
  592.  
  593.  
  594. Figure 11
  595. ========
  596.  
  597.  
  598. NAME start
  599.  
  600. ; Use the DOSSEG directive to insure that the code segment is the 
  601. ; first segment in the module. Since this piece of code will be 
  602. ; loaded in at the page frame at D000:0000H the map and call use 
  603. ; D000:0000H as the entry point.
  604.  
  605. DOSSEG
  606.  
  607. data SEGMENT PUBLIC 'DATA'
  608. Data  ends
  609.  
  610. CODE SEGMENT PUBLIC 'CODE'
  611.     ASSUME CS:CODE, DS:DATA
  612. start proc far
  613.      push    ds
  614.      PUSH    dx
  615.      mov     DX,data               ; get my data seg into ds
  616.      mov     ds,dx
  617.      pop     dx
  618.      mov     ah, 09                ; set function for dos 
  619.                                    ; display string
  620.      mov     dx, offset enter_msg
  621.      int    21H
  622.  
  623. ;    Use search for handel to find handle
  624.  
  625.      mov    si, offset handle_name
  626.      mov    ax, 5401H              ; set function to serch for 
  627.                                    ; named handle
  628.      int    67H                    ; invoke emm
  629.      or ah, ah
  630.      jnz exit
  631.  
  632. ; DX = handle number     
  633. ;
  634. ;  Set Register for map and call and call EMM with INT 67
  635.  
  636.      mov     si, offset map_call  
  637.      mov     al, 0                 ; indicate that values are pages
  638.      mov     ah, 56H               ; set function to map and call
  639.      int     67H                   ; invoke emm 
  640.      or ah, ah
  641.      jnz exit
  642.      
  643.      mov     ah, 09                ; set function for dos 
  644.                                    ; display string
  645.      mov     dx, offset exit_msg
  646.      int 21H
  647. exit:
  648.      pop     ds
  649.      ret
  650. start endp
  651. CODE ENDS
  652.  
  653. data SEGMENT PUBLIC 'DATA'
  654.  
  655. ; EQUATES
  656.  
  657. cr    equ  0Dh
  658. lf    equ  0AH
  659.  
  660. ; Structures
  661.  
  662. log_phys_map_struct      STRUC
  663.    log_page_number     DW ? 
  664.    phys_page_number    DW ? 
  665. log_phys_map_struct      ENDS
  666.  
  667. map_call_struct      STRUC
  668.     target_address      DD ?       ; Pointer to which EMM will  
  669.                                    ; transfer control 
  670.     new_page_map_length DB ?       ; number new pages to be mapped 
  671.                                    ; on call
  672.     new_page_map_ptr    DD ?       ; pointer to array of 
  673.                                    ; log_phys_map_struc
  674.     old_page_map_length DB ?       ; number of pages to mapped on 
  675.                                    ; return
  676.     old_page_map_ptr    DD ?       ; pointer to array of 
  677.                                    ; log_phys_map_struc
  678.     reseved             DW 4 DUP (?)
  679. map_call_struct ENDS
  680.  
  681. ; Data decalrations
  682.  
  683. new_map  log_phys_map_struct <1,1> ; maping befor call
  684. old_map  log_phys_map_struct <0,0> ; mapping after call
  685.  
  686. map_call  map_call_struct <0D0004000H,1,new_map,1,old_map>
  687.  
  688. handle_name db 'mapcall',0         ; handle name is asciz string                                            
  689. enter_msg   db 'Entering Module 1',cr,lf,'$'
  690. exit_msg    db 'Exiting Module 1',cr,lf,'$'
  691.  
  692. Data  ends
  693.  
  694. end  start
  695.  
  696.  
  697. Figure 12
  698. ========
  699.  
  700.  
  701. NAME start
  702. DOSSEG
  703.  
  704. data SEGMENT PUBLIC 'DATA'
  705. Data  ends
  706.  
  707. CODE SEGMENT PUBLIC 'CODE'
  708.     ASSUME CS:CODE, DS:DATA
  709. start proc far
  710.      push    ds
  711.      PUSH    dx
  712.      mov     DX,data               ; get my data seg into ds
  713.      mov     ds,dx
  714.      pop     dx
  715.      mov     ah, 09                ; set function for dos 
  716.                                    ; display string
  717.      mov     dx, offset enter_msg
  718.      int 21H
  719.      mov     ah, 09                ; set function for dos 
  720.                                    ; display string
  721.      mov     dx, offset exit_msg
  722.      int 21H
  723.      pop     ds
  724.      ret
  725. start endp
  726. CODE ENDS
  727.  
  728. data SEGMENT PUBLIC 'DATA'
  729. cr    equ  0Dh
  730. lf    equ  0AH
  731. enter_msg   db 'Entering Module 2',cr,lf,'$'
  732. exit_msg    db 'Exiting Module 2',cr,lf,'$'
  733.  
  734. Data  ends
  735.  
  736. end  start
  737.  
  738.  
  739. Figure 13
  740. ========
  741.  
  742.  
  743. /* emm.h */
  744.  
  745.  
  746. #define EMM_INT 0x67
  747. #define GET_UNALLOCATED_PAGE_COUNT 0x42
  748. #define ALLOCATE_PAGES             0x43
  749. #define DEALLOCATE_PAGES           0X45
  750. #define GET_VERSION                0x46
  751. #define GET_FRAME_ADDRESS          0x41
  752. #define SET_HANDLE_NAME            0x5301
  753. #define SEARCH_FOR_HANDLE_NAME     0x5401
  754. #define MOVE_MEMORY_REGION         0x5700
  755. #define EXCHANGE_MEMORY_REGION     0x5701
  756. #define MAP_UNMAP_MULTIPLE_PAGES   0x5000
  757.  
  758.