c2e.convert_special: 0
e2c.convert_num: 0
-openfiles: /dos/z/16/doc/project.txt:0:0:1:
+openfiles: /dos/z/16/doc/project.txt:138:0:0:
openfiles: /dos/z/16/src/palettec.c:0:0:0:
openfiles: /dos/z/16/src/pcxtest.c:0:0:0:
openfiles: /dos/z/16/src/scroll.c:0:0:0:
openfiles: /dos/z/16/src/lib/ems1.c:0:0:0:
openfiles: /dos/z/16/src/lib/planar.h:0:0:0:
openfiles: /dos/z/16/src/lib/PLANAR.C:0:0:0:
+openfiles: /dos/z/16/src/lib/bitmap.c:0:0:0:
+openfiles: /dos/z/16/src/lib/bitmap.h:0:0:0:
+openfiles: /dos/z/16/src/lib/dos_kb.c:0:0:0:
+openfiles: /dos/z/16/src/lib/dos_kb.h:0:0:0:
+openfiles: /dos/z/16/src/lib/lib_head.cpp:0:0:0:
+openfiles: /dos/z/16/src/lib/lib_head.h:0:0:0:
+openfiles: /dos/z/16/src/lib/modex16.c:444:0:0:
+openfiles: /dos/z/16/src/lib/modex16.h:0:0:0:
+openfiles: /dos/z/16/src/lib/scroll.c:0:0:0:
+openfiles: /dos/z/16/src/lib/scroll.h:0:0:0:
+openfiles: /dos/z/16/src/lib/types.h:0:0:0:
+openfiles: /dos/z/bakac.c:0:0:1:
snr_recursion_level: 0
convertcolumn_horizontally: 0
adv_open_matchname: 0
default_mime_type: text/plain
e2c.convert_xml: 1
c2e.convert_iso: 0
-opendir: file:///dos/z/16/doc
+opendir: file:///dos/z
wrap_text_default: 0
bookmarks_filename_mode: 1
snr_casesens: 0
recent_files: file:///dos/z/16/src/lib/planar.h
recent_files: file:///dos/z/16/src/lib/PLANAR.C
recent_files: file:///dos/z/16/doc/project.txt
+recent_files: file:///dos/z/16/src/lib/bitmap.c
+recent_files: file:///dos/z/16/src/lib/bitmap.h
+recent_files: file:///dos/z/16/src/lib/dos_kb.c
+recent_files: file:///dos/z/16/src/lib/dos_kb.h
+recent_files: file:///dos/z/16/src/lib/lib_head.cpp
+recent_files: file:///dos/z/16/src/lib/lib_head.h
+recent_files: file:///dos/z/16/src/lib/modex16.h
+recent_files: file:///dos/z/16/src/lib/modex16.c
+recent_files: file:///dos/z/16/src/lib/scroll.c
+recent_files: file:///dos/z/16/src/lib/scroll.h
+recent_files: file:///dos/z/16/src/lib/types.h
+recent_files: file:///dos/z/rbaka.c
+recent_files: file:///dos/z/baka.c
+recent_files: file:///dos/z/bakac.c
snr_replacetype: 0
-savedir: file:///dos/z/16/src
+savedir: file:///dos/z
spell_check_default: 1
spell_insert_entities: 0
last_filefilter:
--- /dev/null
+// Cut this out as emm.c\r
+\r
+/* File: emm.c\r
+ * Module: All Modules\r
+ * Author(s): Chris Somers\r
+ * Date: December 1, 1992\r
+ * Version: V.1.1\r
+\r
+ minor mods by Alex Russell to simplify\r
+\r
+ Must use memory model with FAR code\r
+\r
+ */\r
+\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <mem.h>\r
+\r
+#include "memory.c"\r
+\r
+void TransformData(char *pEmmData, unsigned int len)\r
+{\r
+ while ( len )\r
+ {\r
+ (*pEmmData)++;\r
+ pEmmData++;\r
+\r
+ len--;\r
+ }\r
+}\r
+\r
+void main(void)\r
+{\r
+ char *pEmmData;\r
+ int hEData;\r
+\r
+ if ( OpenEMM() != SUCCESS )\r
+ { // make sure we got EMM\r
+ printf("EMM unavailable.\n");\r
+ exit(1);\r
+ }\r
+ else\r
+ printf("Emm available\n");\r
+\r
+ pEmmData = (char *)EMMalloc(&hEData, 6); // get 6 * 16K bytes - 96K\r
+ if ( pEmmData == NULL )\r
+ {\r
+ printf("Not enough EMM or out of handles.\n");\r
+ exit(2);\r
+ }\r
+ else\r
+ printf("emm alloced OK\n");\r
+\r
+\r
+ printf("Map 1st 4 pages\n");\r
+ MapEMM(hEData, 0, 4); // load 1st 4 pages into page frame: 0-3\r
+\r
+ memset(pEmmData, 0x0e, 64000u);\r
+ UnmapEMM(hEData, 0, 4); // not absolutely necessary\r
+ \r
+ printf("Map next 2 pages\n");\r
+ MapEMM(hEData, 4, 2); // map last 2 pages: 4-5\r
+ memset(pEmmData, 0x0e, 32768u);\r
+\r
+ MapEMM(hEData, 0, 4);\r
+ // do some stuff with the first 64K of file data.\r
+ printf("Transform data\n");\r
+ TransformData(pEmmData, 64000UL);\r
+ MapEMM(hEData, 4, 2); // only unmaps 1st two pages of prior 64k mapping\r
+ // do stuff with remaining 32K of data\r
+ TransformData(pEmmData, 32768UL);\r
+ UnmapEMM(hEData, 0, 4); // should unmap before freeing\r
+\r
+ printf("Close emm\n");\r
+ EMMFree(hEData); // finished with the file data\r
+ CloseEMM();\r
+}\r
--- /dev/null
+// AJR notes: some of these are not used by the emm code\r
+\r
+// Cut this out as emmret.h\r
+\r
+/* File: EmmRet.h\r
+ * Module: All Modules\r
+ * Author(s): Chris Somers\r
+ * Date: May 8, 1992\r
+ * Version: V.1.0\r
+ */\r
+\r
+#ifndef _EMM_RETURNS_DEF\r
+#define _EMM_RETURNS_DEF 1\r
+\r
+/* Module return values */\r
+\r
+/* Return Values */\r
+\r
+#define START 8\r
+#define END 7\r
+#define MOVABORT 6\r
+#define PRN_COMPLETE 5\r
+#define PRN_PROGRESS 4\r
+#define INCOMPLETE 3\r
+#define HAVEROOM 2\r
+#define SUCCESS 1\r
+#define TRUE 1\r
+#define YES 1\r
+#define FALSE 0\r
+#define NO 0\r
+#define NOTREADY 0\r
+#define NO_DATA 0\r
+#define NONE -1\r
+\r
+/* Start of Recoverable error codes */\r
+\r
+#define NO_SPACE -1001\r
+#define NOTPOLLING -1002\r
+#define ALREADYDONE -1003\r
+#define NO_PRN_DEV -1004\r
+#define OUTF_PAPER -1005\r
+#define NO_VIDEO -1006\r
+#define TIMEOUT -1007\r
+#define FILENOPEN -1008\r
+#define ABORT_REQ -1009\r
+#define DEV_IOERR -1010\r
+\r
+#define MAXRERR 10\r
+#define RECOVERABLE -1999 /* all above errors are recoverable */\r
+\r
+/* Start of Threadfatal error codes */\r
+\r
+#define NOT_OPEN -2001\r
+#define NOT_ATTACHED -2002\r
+#define NO_CONNECTION -2003\r
+#define INSUFF_MEM -2004\r
+#define NR_TIMEOUT -2005\r
+\r
+#define MAXTERR 5\r
+#define THREADFATAL -2999 /* above errors force task to cancel */\r
+\r
+/* Start of Systemfatal error codes */\r
+\r
+#define BAD_TASKNUM -3001\r
+#define BAD_HANDLE -3002\r
+#define BAD_HARDWARE -3003\r
+#define INVALIDACTION -3004\r
+#define NOFREEITEMS -3005\r
+#define NO_MEMORY -3006\r
+#define NO_EMS -3007\r
+#define VALUE_OUTF_RANGE -3008\r
+#define BAD_MODE -3009\r
+#define NO_PALETTE -3010\r
+#define BAD_DISPPAGE -3011\r
+#define NO_TSR -3012\r
+#define BUFTOOSMALL -3013\r
+#define BAD_NAME -3014\r
+#define BAD_DISPHW -3015\r
+#define NO_FLOPPY -3016\r
+\r
+#define MAXSERR 16\r
+#define SYSTEMFATAL -3999 /* above errors are fatal to system */\r
+\r
+#endif\r
--- /dev/null
+// Cut this out as emmsize.h\r
+\r
+/* File: EmmSize.h\r
+ * Module: All Modules\r
+ * Author(s): Chris Somers\r
+ * Date: May 8, 1992\r
+ * Version: V.1.0\r
+ */\r
+\r
+#ifndef _EMMSIZES_DEF\r
+#define _EMMSIZES_DEF 1\r
+\r
+\r
+/* Module size constants */\r
+\r
+#define MAXACTIONS 29\r
+#define MAXCHANNELS 4\r
+#define MAXFOCUS 3\r
+#define MAXBUFTYPES 64\r
+#define MAXEMHANDLES 64 /* up to a max of 255 */\r
+#define MAXTIMERS 32\r
+#define MAXTITEMS 128\r
+#define MAXQUEUES 24\r
+#ifdef PRINTER\r
+#define MAXPRNS 4\r
+#else\r
+#define MAXPRNS 0\r
+#endif\r
+#ifdef UTSCOM\r
+#define MAXUTSSCRNS 2\r
+#else\r
+#define MAXUTSSCRNS 0\r
+#endif\r
+#ifdef CAPTURE\r
+#define MAXCAPTURE 1\r
+#else\r
+#define MAXCAPTURE 0\r
+#endif\r
+#define MAXIRQS 10\r
+#define MAXTCPDSCPTITEMS 16 /*max # of TCP connections*/\r
+\r
+#define FREEBUFF 1 /* CallIODevice flag for BuffSize arrays */\r
+#define DSCONLY 2 /* allocate a BufDscpt, only - no buffer */\r
+\r
+#define EMMPAGESIZE 0x4000 /* 16K EMM page size */\r
+#define SETUPLEN 32\r
+#define NAMELEN 40\r
+#define UNIXLEN 32\r
+#define ADDRLEN 16\r
+#define TITLELEN 128\r
+#define TSLEN 80\r
+#define COMMENTLEN 65\r
+#define PALSIZE 768\r
+#define QSTRLEN 254\r
+#define PRNBUFSIZ 2048\r
+#define TXTSCRNSIZE 4096\r
+#define UTSBUFSIZ 4096\r
+#define UTSSCRNSIZ 1920\r
+#define QMEMSIZE 15\r
+#define KBUFLEN 16\r
+#define GXBUFFSIZE 0x4000\r
+#define TCPNDBUFFSIZE 0x1000 /*router auto-allocation buff size*/\r
+ /* graphics printing scale values */\r
+#define SCALE_HALF 1 /* value must not change */\r
+#define SCALE_ONE 2\r
+#define SCALE_QUART 3 /* value must not change */\r
+\r
+#define SIXTH_SECOND 3L /* shade over 1/6 of a second*/\r
+#define HALF_SECOND 9L\r
+#define ONE_SECOND 18L\r
+#define TWO_SECONDS 36L\r
+#define FIVE_SECONDS 91L\r
+#define TEN_SECONDS 182L\r
+#define HALF_MINUTE 182*3L /* same as 18.2*30, right? */\r
+#define ONE_MINUTE 182*6L /* same as 18.2*60, right? */\r
+#define TWO_MINUTES 182*12L /* same as 18.2*120, right? */\r
+#define FIVE_MINUTES 182*30L /* same as 18.2*300, right? */\r
+#define TEN_MINUTES 182*60L /* same as 18.2*600, right? */\r
+#define HALF_HOUR 182*180L /* same as 18.2*1800, right? */\r
+#define ONE_HOUR 182*360L /* same as 18.2*3600, right? */\r
+\r
+#define MAXROUTMOVES 24 /*max # of routing moves at one time*/\r
+ /*also max # of Move Complete Events*/\r
+/* Event Channel Defines */\r
+\r
+#define MAXRECALLEVENTS 1 /*max nm of Recall Event Channels*/\r
+#define MAXKBDEVENTS 1 /*max nm of Kbd Event Channels*/\r
+#define MAXPRNEVENTS 4 /*max nm of Prt Prog & Prt Cmplte Event Chan*/\r
+#define MAXUTSRCVEVENTS MAXUTSSCRNS /*max nm of Uts Rx Event Chans*/\r
+#define MAXUTSXMTEVENTS MAXUTSSCRNS /*max nm of Uts Tx Event Chans*/\r
+#define MAXCAPEVENTS 2 /* max number of capture event channels */\r
+#define MAXOP1CMPLTEVENTS 1 /*max nm of Operation 1 Cmplt Event Channels*/\r
+#define MAXOP2CMPLTEVENTS 1 /*max nm of Operation 2 Cmplt Event Channels*/\r
+#define MAXOP3CMPLTEVENTS MAXTCPDSCPTITEMS /*max nm of Op 3 Event Chans*/\r
+#define MAXTCPEVENTS MAXTCPDSCPTITEMS /* max nm of TCP Event types */\r
+\r
+#endif\r
--- /dev/null
+\r
+/* File: Memory.c\r
+ * Module: All Modules\r
+ * Author(s): Chris Somers\r
+ * Date: December 1, 1992\r
+ * Version: V.1.1\r
+\r
+ minor mods by Alex Russell to simplify\r
+\r
+ Must use memory model with FAR code\r
+\r
+ */\r
+\r
+\r
+\r
+#if !defined(__LARGE__) && !defined(__COMPACT__) && !defined(__HUGE__)\r
+#error Invalid memory model for compiling MEMORY.C\r
+#endif\r
+\r
+#include <stdio.h>\r
+#include <dos.h>\r
+#include <mem.h>\r
+\r
+#include "memory.h"\r
+\r
+// static globals --------------------------------\r
+\r
+static int ActiveEMList[MAXEMHANDLES];\r
+static unsigned int EMMSeg;\r
+\r
+// forward declarations ---------------------------------\r
+\r
+static int EMPresent(void);\r
+static int EMReady(void);\r
+static unsigned int GetEMMSeg(void);\r
+static int GetEMHandle(int NumPages);\r
+static int EMMap(int Handle, int LogPg, int PhyPg);\r
+static int FreeEMHandle(int Handle);\r
+static int GetNumPages(int Handle);\r
+static int EMStateSave(int Handle);\r
+static void EMStateRestore(int Handle);\r
+\r
+\r
+/********************************************************************/\r
+int\r
+OpenEMM(void)\r
+{\r
+ if (!EMPresent() || !EMReady()) return(NOTREADY);\r
+ if (!(EMMSeg = GetEMMSeg())) return(NOTREADY); /*lint !e720 */\r
+ return(SUCCESS);\r
+} /* End of OpenEMM() */\r
+\r
+/********************************************************************/\r
+\r
+void\r
+CloseEMM(void)\r
+{\r
+ int i;\r
+\r
+ if (!EMMSeg) return;\r
+ for (i = 0; i < MAXEMHANDLES; i++) {\r
+ if (ActiveEMList[i]) {\r
+ FreeEMHandle(ActiveEMList[i]);\r
+ ActiveEMList[i] = 0;\r
+ }\r
+ }\r
+ EMMSeg = 0;\r
+} /* End of CloseEMM() */\r
+\r
+/********************************************************************/\r
+\r
+int\r
+EMMInstalled(void)\r
+{\r
+ return((EMMSeg) ? TRUE : FALSE); /* successfully opened? */\r
+} /* End of EMMInstalled() */\r
+\r
+/********************************************************************/\r
+\r
+unsigned long\r
+EMMCoreLeft(void)\r
+{\r
+ unsigned Pages;\r
+ unsigned long RtnVal = 0UL;\r
+\r
+ _asm {\r
+ mov ah,0x42 /* get EMM free page count */\r
+ int 0x67\r
+ or ah,ah\r
+ //js InternalError /* returns 80, 81, or 84 hex on error */\r
+ mov Pages,bx /* number of unallocated 16K pages */\r
+ }\r
+ RtnVal = ((unsigned long)Pages << 14); /* Pages * 16K rtns bytes*/\r
+\r
+//InternalError:\r
+\r
+ return(RtnVal);\r
+} /* End of EMMCoreLeft() */\r
+\r
+/********************************************************************/\r
+\r
+void far *\r
+EMMalloc(int *Handle, int Pages)\r
+{\r
+ int i;\r
+ char *RtnPtr = NULL;\r
+\r
+ if (!EMMSeg) {\r
+ *Handle = NOTREADY;\r
+ return(NULL);\r
+ }\r
+ if ((Pages < 1) || (Pages > 1020)) {\r
+ *Handle = VALUE_OUTF_RANGE;\r
+ return (NULL);\r
+ }\r
+ for (i = 0; (i < MAXEMHANDLES) && (ActiveEMList[i]); i++) ;\r
+ if (i == MAXEMHANDLES) {\r
+ *Handle = NOFREEITEMS;\r
+ return (NULL);\r
+ }\r
+ if ((ActiveEMList[i] = GetEMHandle(Pages)) > 0) {\r
+ RtnPtr = MK_FP(EMMSeg, 0);\r
+ }\r
+ *Handle = ActiveEMList[i];\r
+ return((void far *)RtnPtr);\r
+} /* End of EMMalloc() */\r
+\r
+/********************************************************************/\r
+\r
+int\r
+EMMRealloc(int Handle, int Pages)\r
+{\r
+ int RtnCode = FALSE;\r
+\r
+ if (!EMMSeg || (Pages < 0) || (Pages > 1020)) {\r
+ return (FALSE);\r
+ }\r
+ _asm {\r
+ mov ah,0x51 /* change # of pages */\r
+ mov bx,Pages\r
+ mov dx,Handle\r
+ int 0x67\r
+ or ah,ah\r
+ //js NoGo /* returns 80 to 88 hex on error */\r
+ }\r
+ RtnCode = TRUE;\r
+\r
+//NoGo:\r
+\r
+ return(RtnCode);\r
+} /* End of EMMRealloc() */\r
+\r
+/********************************************************************/\r
+\r
+void\r
+EMMFree(int Handle)\r
+{\r
+ int i, j;\r
+\r
+ if (!EMMSeg) return;\r
+ for (i = 0; (i < MAXEMHANDLES) && (ActiveEMList[i] != Handle); i++) ;\r
+ if (i >= MAXEMHANDLES) return;\r
+ j = 16;\r
+ while (j--) {\r
+ if (FreeEMHandle(ActiveEMList[i])) break;\r
+ }\r
+ ActiveEMList[i] = 0;\r
+} /* End of EMMFree() */\r
+\r
+/********************************************************************/\r
+\r
+int /* EMM map for application */\r
+MapEMM(int Handle, int Start, int Pages)\r
+{\r
+ int i;\r
+\r
+ if (!EMMSeg) return(NOTREADY);\r
+ for (i = 0; (i < MAXEMHANDLES) && (ActiveEMList[i] != Handle); i++) ;\r
+ if (i == MAXEMHANDLES) return (NO_DATA);\r
+ if ((GetNumPages(Handle) < Pages) || (Pages < 1) || (Pages > 4)) {\r
+ return (VALUE_OUTF_RANGE);\r
+ }\r
+ for (i = Start; i < Start + Pages; i++) {\r
+ if (!EMMap(Handle, i, i - Start)) return(NO_DATA);\r
+ }\r
+ return(SUCCESS);\r
+} /* End of MapEMM() */\r
+\r
+/********************************************************************/\r
+\r
+void /* EMM unmap for application */\r
+UnmapEMM(int Handle, int Start, int Pages)\r
+{\r
+ int i, j;\r
+\r
+ if (!EMMSeg) return;\r
+ for (i = 0; (i < MAXEMHANDLES) && (ActiveEMList[i] != Handle); i++) ;\r
+ if (i == MAXEMHANDLES) return;\r
+ j = Start + Pages;\r
+ if ((Pages < 1) || (j > 4)) return;\r
+\r
+ for (i = Start; i < j; i++) {\r
+ EMMap(Handle, NONE, i);\r
+ }\r
+} /* End of UnmapEMM() */\r
+\r
+/********************************************************************/\r
+\r
+int /* EMM map for devices - saves EMM state */\r
+UseEMM(int Handle, int Start, int Pages)\r
+{\r
+ EMStateSave(Handle);\r
+ return(MapEMM(Handle, Start, Pages));\r
+} /* End of UseEMM() */\r
+\r
+/********************************************************************/\r
+\r
+void /* EMM unmap for devices - restores EMM state */\r
+SaveEMM(int Handle, int Start, int Pages)\r
+{\r
+ UnmapEMM(Handle, Start, Pages);\r
+ EMStateRestore(Handle);\r
+} /* End of SaveEMM() */\r
+\r
+/********************************************************************/\r
+\r
+static int\r
+EMPresent(void)\r
+{\r
+ int i, Segment;\r
+ char EMName[] = "EMMXXXX0";\r
+ char *s, *t;\r
+\r
+ _asm { /* can be replaced with getvect() */\r
+ push es\r
+ mov ax,0x3567 /* get vector for int 67h */\r
+ int 0x21\r
+ mov ax,es\r
+ mov Segment,ax\r
+ pop es\r
+ }\r
+ t = MK_FP(Segment, 0x0A); /* point to driver name */\r
+ s = EMName;\r
+ for (i = 0; (i < 8) && (*s++ == *t++); i++) ; /* strncmp equivalent */\r
+\r
+ if (i == 8) return(TRUE);\r
+ return(FALSE);\r
+} /*End of EMPresent() */\r
+\r
+/********************************************************************/\r
+\r
+static int\r
+EMReady(void)\r
+{\r
+ _asm {\r
+ mov ah,0x40 /* get EM Manager Status */\r
+ int 0x67\r
+ or ah,ah\r
+ //jns Ready /* returns 80, 81, or 84 hex on error */\r
+ }\r
+ return(FALSE);\r
+\r
+//Ready:\r
+ return(TRUE);\r
+} /* End of EMReady() */\r
+\r
+/********************************************************************/\r
+\r
+static unsigned int\r
+GetEMMSeg(void)\r
+{\r
+ unsigned int EMSegment;\r
+\r
+ _asm {\r
+ mov ah,0x41 /* get EMM page frame segment */\r
+ int 0x67\r
+ or ah,ah\r
+ //js NotReady /* returns 80, 81, or 84 hex on error */\r
+ mov EMSegment,bx\r
+ }\r
+ return(EMSegment); /*lint !e530 */\r
+\r
+//NotReady:\r
+ return(NOTREADY);\r
+} /* End of GetEMMSeg() */\r
+\r
+/********************************************************************/\r
+\r
+static int\r
+GetEMHandle(int NumPages)\r
+{\r
+ int NewHandle;\r
+\r
+ _asm {\r
+ mov ah,0x43 /* get handle and allocate EM */\r
+ mov bx,NumPages /* number of 16K pages to allocate */\r
+ int 0x67\r
+ or ah,ah /* returns 80 to 89 hex on error */\r
+ //js NoHandle\r
+ mov NewHandle,dx /* retrieve handle */\r
+ }\r
+ return(NewHandle);\r
+\r
+//NoHandle:\r
+ return(NO_DATA);\r
+} /* End of GetEMHandle() */\r
+\r
+/********************************************************************/\r
+\r
+static int\r
+EMMap(int Handle, int LogPg, int PhyPg)\r
+{\r
+ int RtnCode = NO_DATA;\r
+\r
+ _asm {\r
+ mov ax,PhyPg /* physical page: 0 - 3 in AL only */\r
+ mov ah,0x44 /* map logical to physical page */\r
+ mov bx,LogPg /* logical page: 0 - 1020 */\r
+ mov dx,Handle\r
+ int 0x67\r
+ or ah,ah /* returns 80 to 8B hex on error */\r
+ //js NoMapping\r
+ }\r
+ RtnCode = SUCCESS;\r
+\r
+//NoMapping:\r
+ return(RtnCode);\r
+} /* End of EMMap() */\r
+\r
+/********************************************************************/\r
+\r
+static int\r
+FreeEMHandle(int Handle)\r
+{\r
+ _asm {\r
+ mov ah,0x45 /* free handle and deallocate EM */\r
+ mov dx,Handle\r
+ int 0x67\r
+ or ah,ah /* returns 80 to 86 hex on error */\r
+ //js NotFreed\r
+ }\r
+ return(SUCCESS);\r
+\r
+//NotFreed: /* must retry if unsuccessful */\r
+ return(NO_DATA);\r
+} /* End of FreeEMHandle() */\r
+\r
+/********************************************************************/\r
+\r
+static int\r
+GetNumPages(int Handle)\r
+{\r
+ int NumPages = 0;\r
+\r
+ _asm {\r
+ mov ah,0x4C /* get allocated pages for Handle */\r
+ mov dx,Handle\r
+ int 0x67\r
+ or ah,ah /* returns 80 to 84 hex on error */\r
+ //js BadHandle\r
+ mov NumPages,bx\r
+ }\r
+//BadHandle:\r
+\r
+ return(NumPages);\r
+} /* End of GetNumPages() */\r
+\r
+/********************************************************************/\r
+\r
+static int\r
+EMStateSave(int Handle)\r
+{\r
+ int RtnCode = NO_MEMORY;\r
+ _asm {\r
+ mov ah,0x47 /* save page map under Handle */\r
+ mov dx,Handle\r
+ int 0x67\r
+ or ah,ah\r
+ //js Unsaved /* out of save space error */\r
+ }\r
+ RtnCode = SUCCESS;\r
+\r
+//Unsaved:\r
+ return(RtnCode);\r
+} /* End of EMStateSave() */\r
+\r
+/********************************************************************/\r
+\r
+static void\r
+EMStateRestore(int Handle)\r
+{\r
+ _asm {\r
+ mov ah,0x48 /* restore page map for Handle */\r
+ mov dx,Handle\r
+ int 0x67 /* ignore error */\r
+ }\r
+} /* End of EMStateRestore() */\r
--- /dev/null
+// Cut this out as memory.h\r
+\r
+/* File: Memory.h\r
+ * Module: All Modules\r
+ * Author(s): Chris Somers\r
+ * Date: August 5, 1993\r
+ * Version: V.1.1\r
+\r
+ modified by Alex Russell to simplify.\r
+ */\r
+\r
+\r
+#ifndef _MEMORY_DEF\r
+#define _MEMORY_DEF 1\r
+\r
+#include "emmret.h"\r
+#include "emmsize.h"\r
+\r
+#define CMM 0\r
+#define EMM 1\r
+\r
+extern int OpenEMM(void);\r
+extern void CloseEMM(void);\r
+extern int EMMInstalled(void);\r
+extern void far *EMMalloc(int *Handle, int Pages);\r
+extern int EMMRealloc(int Handle, int Pages);\r
+extern void EMMFree(int Handle);\r
+extern int MapEMM(int Handle, int Start, int Pages);\r
+extern void UnmapEMM(int Handle, int Start, int Pages);\r
+extern int UseEMM(int Handle, int Start, int Pages);\r
+extern void SaveEMM(int Handle, int Start, int Pages);\r
+extern unsigned long EMMCoreLeft(void);\r
+\r
+#endif\r
--- /dev/null
+"wcp -mh emm.c" at\r
--- /dev/null
+
+/*
+
+ Copyright 1994 Alec Russell, ALL rights reserved
+ Permission granted to use as you wish.
+
+ Slightly higher level xms calls than xmem.asm
+
+*/
+
+#include <stdio.h>
+#include <io.h>
+#include <string.h>
+#include <malloc.h>
+
+#include <xmem.h>
+
+xms_head_t xms_head={0}; // set handle to zero
+
+
+/* ---------------------- alloc_xms() ----------------- February 19,1994 */
+short alloc_xms(unsigned short far *size) // size in 16k blocks
+{
+ return(XMS_alloc(0, size));
+}
+
+/* ---------------------- xms_to_mem() ---------------- February 19,1994 */
+short xms_to_mem(unsigned short handle, void far *p, unsigned long off, unsigned short n)
+{
+ unsigned short block, boff;
+
+ block=off >> XMSBLOCKSHIFT;
+ boff=off - (block << XMSBLOCKSHIFT);
+
+ return(XMStoMem(handle, block, boff, n, p));
+}
+
+/* ---------------------- mem_to_xms() ---------------- February 19,1994 */
+short mem_to_xms(unsigned short handle, void far *p, unsigned long off, unsigned short n)
+{
+ unsigned short block, boff;
+
+ block=off >> XMSBLOCKSHIFT;
+ boff=off - (block << XMSBLOCKSHIFT);
+
+ return(MemToXMS(handle, block, boff, n, p));
+}
+
+/* ---------------------- qalloc_xms() -------------------- March 8,1994 */
+xms_node_t *qalloc_xms(unsigned long size)
+{
+ xms_node_t *node=NULL;
+ xms_node_t *t1;
+
+ if ( size <= xms_head.avail )
+ {
+ // look for existing node
+ t1=xms_head.next;
+ while ( t1 )
+ {
+ if ( t1->used == 0 && t1->size >= size )
+ {
+ t1->off=0;
+ t1->used=1;
+ node=t1;
+ break;
+ }
+ else
+ t1=t1->next;
+ }
+
+ if ( node == NULL ) // didn't find existing node
+ {
+ node=malloc(sizeof(xms_node_t));
+ if ( node )
+ {
+ node->off=0;
+ node->used=1;
+ node->size=size;
+ node->next=NULL;
+ node->start=xms_head.next_off;
+ xms_head.avail-=size;
+ xms_head.next_off+=size;
+ if ( xms_head.next == NULL )
+ {
+ xms_head.next=node;
+ }
+ else
+ {
+ t1=xms_head.next;
+ while ( t1->next )
+ t1=t1->next;
+ t1->next=node;
+ }
+ }
+ else
+ pr2("out of near mem in qalloc_xms");
+ }
+ }
+ else
+ pr2("out of xms mem in qalloc size %lu avail %lu", size, xms_head.avail);
+
+ return(node);
+}
+
+/* ---------------------- qfree_xms() --------------------- March 8,1994 */
+void qfree_xms(xms_node_t *node)
+{
+ xms_node_t *t1;
+
+ if ( xms_head.next )
+ {
+ t1=xms_head.next;
+ while ( t1 != node && t1 )
+ t1=t1->next;
+
+ if ( t1 )
+ {
+ t1->used=0;
+ }
+ else
+ pr2("ERROR didn't find node qfree");
+ }
+ else
+ {
+ pr2("ATTEMPTED to qfree empty list");
+ }
+}
+
+/* ---------------------- xms_open() ---------------------- March 8,1994 */
+xms_node_t *xms_open(char *file)
+{
+ int i;
+ xms_node_t *node=NULL;
+ FILE *fp;
+ char *buffer;
+ unsigned long off;
+
+ fp=fopen(file, "rb");
+ if ( fp )
+ {
+ node=qalloc_xms(filelength(fileno(fp)));
+ if ( node )
+ {
+ buffer=malloc(4096);
+ if ( buffer )
+ {
+ off=0l;
+ while ( (i=fread(buffer, 1, 4096, fp)) )
+ {
+ mem_to_xms(xms_head.handle, (char far *)buffer, off+node->start, i);
+ off+=i;
+ }
+
+ free(buffer);
+ }
+ else
+ pr2("out of mem in xms_open 1");
+ }
+
+ fclose(fp);
+ }
+ else
+ pr2("ERROR opening %s in xms_open", file);
+
+ return(node);
+}
+
+/* ---------------------- xms_read() ---------------------- March 8,1994 */
+short xms_read(void far *buffer, unsigned short n, xms_node_t *node)
+{
+
+ if ( node->off >= node->size )
+ return 0;
+
+ if ( n+node->off > node->size )
+ n=node->size - node->off;
+
+ xms_to_mem(xms_head.handle, buffer, node->start+node->off, n);
+ node->off+=n;
+
+ return(n);
+}
+
+/* ---------------------- xms_write() ---------------------- March 8,1994 */
+short xms_write(void far *buffer, unsigned short n, xms_node_t *node)
+{
+
+ if ( node->off >= node->size )
+ return 0;
+
+ if ( n+node->off > node->size )
+ n=node->size - node->off;
+
+ mem_to_xms(xms_head.handle, buffer, node->start+node->off, n);
+ node->off+=n;
+
+ return(n);
+}
+
+
+/* ---------------------- xms_tell() ---------------------- March 8,1994 */
+long xms_tell(xms_node_t *node)
+{
+ return node->off;
+}
+
+/* ---------------------- xms_seek() ---------------------- March 8,1994 */
+short xms_seek(xms_node_t *node, long off, short whence)
+{
+ short err=0;
+
+ switch ( whence )
+ {
+ case SEEK_SET:
+ if ( off < 0l || off > node->size )
+ err=1;
+ else
+ node->off=off;
+ break;
+
+ case SEEK_END:
+ if ( off > 0l || (node->size + off) < 0l )
+ err=1;
+ else
+ node->off=node->size + off;
+ break;
+
+ case SEEK_CUR:
+ if ( node->off + off < 0l || node->off + off > node->size )
+ err=1;
+ else
+ node->off+=off;
+ break;
+ }
+
+ return(err);
+}
+
+/* ---------------------- xms_close() --------------------- March 8,1994 */
+void xms_close(xms_node_t *node)
+{
+ qfree_xms(node);
+}
+
+/* ---------------------- init_xms() ---------------------- March 8,1994 */
+short init_xms(unsigned short min_blocks)
+{
+ unsigned short blocks;
+
+ blocks=XMSblk_available();
+ if ( blocks >= min_blocks )
+ {
+ memset(&xms_head, 0, sizeof(xms_head_t));
+ if ( (xms_head.handle=alloc_xms(&blocks)) )
+ {
+ pr2("blocks minus by = %u", blocks);
+ min_blocks-=blocks;
+ xms_head.avail=xms_head.total=(unsigned long)min_blocks*XMSBLOCK;
+ blocks=min_blocks;
+ }
+ else
+ blocks=0;
+ }
+ else
+ blocks=0;
+
+ return(blocks);
+}
+
+/* ---------------------- deinit_xms() -------------------- March 8,1994 */
+void deinit_xms(void)
+{
+ xms_node_t *t1, *t2;
+
+ if ( xms_head.handle )
+ {
+ XMS_dealloc(xms_head.handle);
+ if ( xms_head.next )
+ {
+ t1=xms_head.next;
+ t2=t1->next;
+ while ( t1 )
+ {
+ free(t1);
+ t1=t2;
+ t2=t1->next;
+ }
+ }
+
+ memset(&xms_head, 0, sizeof(xms_head_t));
+ }
+}
+/* --------------------------- end of file ------------------------- */
+
+/*
+
+Not sure how to use this?
+
+call init_xms(x) to allocate a big chunk of xms.
+x is in 'blocks' of 16Kb. Pick X big enough to buffer all the files
+you want to place in xms.
+
+call xms_open("filename); for each file to be buffered. This copies the file
+int xms.
+
+then use xms_read(), xms_write(), and xms_seek() to read the file from
+xms instead of disk.
+
+call deinit_xms() just before exit to clean up.
+
+You can also use the lower level calls directly.
+
+*/
OSDN Git Service
