Return to argument.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  * argument.c
        !             3:  *
        !             4:  * This program demonstrated a method of passing parameters to a thread.
        !             5:  * Since Intel stacks grow down (High to low memory), and the PUSH instruction
        !             6:  * decrements the pointer BEFORE writing to the stack, we do the same in C.
        !             7:  *
        !             8:  * The decrement before writing is important since the line:
        !             9:  *
        !            10:  *     threadStack += STACK_SIZE
        !            11:  *
        !            12:  * will place the pointer one element BEYOND the end of the stack.
        !            13:  *
        !            14:  * Also note that the stack is defined as a WORD array.  This is so the
        !            15:  * decrement operator will adjust the stack by 2 with each push.
        !            16:  *
        !            17:  * One last caveat: what the thread expects upon the stack depends upon
        !            18:  * how each argument is declared and the model that the program is being
        !            19:  * compiled in.  KNOW YOUR C STACK STRUCTURE!
        !            20:  *
        !            21:  * Many of the C runtime library routines, including printf, are not
        !            22:  * re-entrant. DOSENTERCRITSEC & DOSEXITCRITSEC guarantee serial access
        !            23:  * to the screen.
        !            24:  *
        !            25:  */
        !            26: #include <doscalls.h>
        !            27: #include <stdio.h>
        !            28: 
        !            29: #define STACK_SIZE 256    /* stack size in WORDS (see malloc) */
        !            30: 
        !            31: main(ac, av)
        !            32: char *av[];
        !            33: int ac;
        !            34: {
        !            35:     void far thread();         /* address where thread gets control */
        !            36:     int far *threadStack;      /* far pointer to thread stack (word)*/
        !            37:     unsigned threadID;         /* thread ID */
        !            38:     unsigned rc;               /* return code */
        !            39: 
        !            40:     /* allocate stack space for thread */
        !            41:     /* since this is written in C, DOSALLOCSEG cannot be used here */
        !            42: 
        !            43:     if ((threadStack = (int *)malloc(sizeof(int) * STACK_SIZE)) == NULL) {
        !            44:        printf("thread stack malloc failed\n");
        !            45:        DOSEXIT(1, 1);  /* terminate all threads and return error */
        !            46:     }
        !            47:     threadStack += STACK_SIZE;         /* since stack grows down */
        !            48: 
        !            49:     *--threadStack = 0xFFFF;           /* Arg #5 = FFFF */
        !            50:     *--threadStack = 0xEEEE;           /* Arg #4 ...    */
        !            51:     *--threadStack = 0xDDDD;           /* Arg #3        */
        !            52:     *--threadStack = 0xCCCC;
        !            53:     *--threadStack = 0xBBBB;
        !            54: 
        !            55:     if (rc = DOSCREATETHREAD(thread, (unsigned far *)&threadID,
        !            56:        (char far *)threadStack)) {
        !            57:        printf("create of thread failed, error: %d\n", rc);
        !            58:        DOSEXIT(1, 1);
        !            59:     }
        !            60:     DOSENTERCRITSEC();
        !            61:     printf("Thread ID = %d\n", threadID);
        !            62:     DOSEXITCRITSEC();
        !            63: 
        !            64:     DOSEXIT(0, 0);             /* Terminate, Let the other thread run */
        !            65: }
        !            66: 
        !            67: 
        !            68: /*
        !            69:  * Thread process expects 5 arguments on the stack (normal C calling
        !            70:  * convention).
        !            71:  */
        !            72: void far
        !            73: thread(a1,a2,a3,a4,a5)
        !            74: int a1,a2,a3,a4,a5;
        !            75: {
        !            76:     DOSENTERCRITSEC();
        !            77:     printf("Argument 1 = %x\n", a1);
        !            78:     DOSEXITCRITSEC();
        !            79: 
        !            80:     DOSENTERCRITSEC();
        !            81:     printf("Argument 2 = %x\n", a2);
        !            82:     DOSEXITCRITSEC();
        !            83: 
        !            84:     DOSENTERCRITSEC();
        !            85:     printf("Argument 3 = %x\n", a3);
        !            86:     DOSEXITCRITSEC();
        !            87: 
        !            88:     DOSENTERCRITSEC();
        !            89:     printf("Argument 4 = %x\n", a4);
        !            90:     DOSEXITCRITSEC();
        !            91: 
        !            92:     DOSENTERCRITSEC();
        !            93:     printf("Argument 5 = %x\n", a5);
        !            94:     DOSEXITCRITSEC();
        !            95: 
        !            96:     DOSEXIT(0,0);
        !            97: }

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