Return to huge.c CVS log

Up to [OS/2 SDKs] / os2sdk / demos / examples / huge

Annotation of os2sdk/demos/examples/huge/huge.c, revision 1.1

1.1     ! root        1: /* This example illustrates allocating a huge segment, addressing
        !             2:  * the segment, growing & shrinking the segment and freeing the
        !             3:  * segment. The following 286DOS functions are illustrated here:
        !             4:  *     DOSALLOCHUGE, DOSREALLOCHUGE, DOSFREESEG
        !             5:  *
        !             6:  * This example allocates a huge segment. It writes a value to one of the
        !             7:  * words in the huge segment. It grows the segment and then shrinks the
        !             8:  * segment back to its original size. It then checks if the segment contains 
        !             9:  * the value that was written previously. If not, it prints an error message. 
        !            10:  * It then frees the huge segment. This example is intended to illustrate
        !            11:  * how to manage and access huge segments - it doesn't perform any useful
        !            12:  * function.
        !            13:  *
        !            14:  * Copyright (C) Microsoft Corp. 1986
        !            15:  */    
        !            16: 
        !            17: #include       <doscalls.h>    /* contains CP/DOS function declarations     */
        !            18: #include       <dos.h>         /* contains FP_SEG and FP_OFF macros         */
        !            19: 
        !            20: /* used in DOSALLOCHUGE call  */
        !            21: #define NUMSEGA 3              /* number of segments in huge segment        */
        !            22: #define SIZEA  8000            /* number of bytes in last segment           */
        !            23: #define PRIVATE 0              /* huge segment will not be shared           */
        !            24: #define MAXSEGS 6              /* max number of 64k segments in huge segment*/
        !            25: #define        WORDA   35000           /* a word in segment 2 in huge segment        */
        !            26: #define VALUEA  15             /* value to write into WORDA                 */
        !            27: 
        !            28: /* used in DOSREALLOCHUGE call (growing the segment) */
        !            29: #define        NUMSEGR 5               /* number of segments in huge segment        */
        !            30: #define SIZER   12000          /* number of bytes in last segment           */
        !            31: 
        !            32: main ()
        !            33: {
        !            34:        unsigned        FirstSelector;  /* first selector for huge segment */
        !            35:        int /*huge*/    *HugeSeg;       /* pointer to a huge segment       */
        !            36: 
        !            37:        /* allocate a huge segment */
        !            38:        DOSALLOCHUGE (NUMSEGA, SIZEA, &FirstSelector, MAXSEGS, PRIVATE);
        !            39: 
        !            40:        /* compute the address to the huge segment */
        !            41:        FP_SEG(HugeSeg) = FirstSelector;
        !            42:        FP_OFF(HugeSeg) = 0;
        !            43:        HugeSeg[WORDA] = VALUEA;
        !            44: 
        !            45:        /* grow the huge segment */
        !            46:         DOSREALLOCHUGE (NUMSEGR, SIZER, FirstSelector);
        !            47: 
        !            48:        /* shrink the huge segment to its orginal size */
        !            49:         DOSREALLOCHUGE (NUMSEGA, SIZEA, FirstSelector);
        !            50: 
        !            51:        /* WORDA should still contain VALUEA */
        !            52:        if (HugeSeg[WORDA] != VALUEA)
        !            53:           printf ("*** error: unexpected value in huge segment ***\n");
        !            54: 
        !            55:         DOSFREESEG (FirstSelector);    /* free the huge segment */
        !            56: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.