Return to cust.c CVS log

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

Annotation of os2sdk/demos/examples/queues/cust.c, revision 1.1

1.1     ! root        1: /* Customer.c
        !             2:  *
        !             3:  * This program emulates the gatekeeper placing requests in a queue that
        !             4:  * will be read by the headwaiter (see server.c). The following functions
        !             5:  * are illustrated here:
        !             6:  *      DOSOPENQUEUE, DOSWRITEQUEUE, DOSCLOSEQUEUE
        !             7:  *
        !             8:  * This example first allocates a shared segment. It loops trying to open
        !             9:  * the queue until successful. It loops (for an arbitrary number of times)
        !            10:  * placing data in the shared segment and writing an element (with
        !            11:  * DataAddress pointing to the data in the shared segment) to the queue.
        !            12:  * The data is contained in the static array CustData. Each word represents
        !            13:  * a byte containing the priority of the request and a byte for the table.
        !            14:  * It writes the last element with RequestID set to indicate that this
        !            15:  * will be the last element to be written to the queue. It then frees the
        !            16:  * shared segment and then closes the queue.
        !            17:  *
        !            18:  * Compile as: cl -AL -G2 -Lp customer.c
        !            19:  *
        !            20:  * Copyright (C) Microsoft Corp. 1986
        !            21:  */
        !            22: 
        !            23: #include <doscalls.h>                   /* 286DOS function declarations */
        !            24: #include "defines.h"                    /* definitions for example programs */
        !            25: #include <dos.h>                        /* contains FP_SEG and FP_OFF macros */
        !            26: 
        !            27: #define ERROR_QUE_NAME_NOT_EXIST        343
        !            28: 
        !            29: void main (argc, argv, envp)
        !            30:     int argc;
        !            31:     char *argv[];
        !            32:     char *envp;
        !            33: {
        !            34:         register unsigned i;    /* loop control variable         */
        !            35:         unsigned  TableID,      /* table where a customer group is seated */
        !            36:                   Priorty,       /* Priority of Table */
        !            37:                   *SharedSeg;   /* pointer to shared segment     */
        !            38:         unsigned OwnerPID,      /* queue owner's PID             */
        !            39:                  QueueHandle,   /* handle of queue               */
        !            40:                  SharedSel;     /* selector to shared segment    */
        !            41:         char     type;          /* type of example selected      */
        !            42:         static unsigned CustData[MAXQWRITES] = {0x0600, 0x0501, 0x0802, 0x0003,
        !            43:                                                 0x0104, 0x0305, 0x0406, 0x0707};
        !            44:                                 /* represents customers requests */
        !            45:                                 /* in Format PPTT, where PP is   */
        !            46:                                 /* priority and TT is table number */
        !            47: 
        !            48:         if (argc > 1){
        !            49:            ++argv;
        !            50:            type = *argv[0];
        !            51:         }
        !            52:         else type = 'd';
        !            53: 
        !            54:         /* allocate shared segment */
        !            55:         DOSALLOCSHRSEG ((unsigned) SEGSIZE, SEGNAME, &SharedSel);
        !            56: 
        !            57:         /* open the queue */
        !            58:         while (DOSOPENQUEUE (&OwnerPID, &QueueHandle, QUEUENAME) ==
        !            59:                ERROR_QUE_NAME_NOT_EXIST) /* keep trying to open the queue...*/
        !            60:                   DOSSLEEP(1000L);       /* ...until the server creates it  */
        !            61: 
        !            62:         /* compute the address to the shared segment */
        !            63:         FP_SEG(SharedSeg) = SharedSel;
        !            64:         FP_OFF(SharedSeg) = 0;
        !            65: 
        !            66:         /* write some requests to the queue, emulating customer's requests  */
        !            67:         TableID = 1;
        !            68:         if ((type == 'L') || (type == 'l')){
        !            69:            /* write data in LIFO format */
        !            70: 
        !            71:            DOSWRITEQUEUE (QueueHandle, NOMORE, DATALENGTH,
        !            72:                           (char *) &SharedSeg[TableID++], /* any prio OK - not used */
        !            73:                           LIFOPRIO);
        !            74: 
        !            75:            for (i = 0; i < MAXQWRITES; ++i){
        !            76:              SharedSeg[TableID] = CustData[i];
        !            77:              DOSWRITEQUEUE (QueueHandle, REQWAITER, DATALENGTH,
        !            78:                             (char *) &SharedSeg[TableID++], LIFOPRIO);
        !            79: 
        !            80:            } /* endfor */
        !            81: 
        !            82:         } else {
        !            83:            /* write data in fifo/prio format */
        !            84: 
        !            85:            for (i = 0; i < MAXQWRITES; ++i){
        !            86:              SharedSeg[TableID] = CustData[i];
        !            87:              Priorty = CustData[i] >> 8;      /* Priority must be a WORD */
        !            88:              DOSWRITEQUEUE (QueueHandle, REQWAITER, DATALENGTH,
        !            89:                            (char *) &SharedSeg[TableID++], Priorty);
        !            90:            } /* endfor */
        !            91: 
        !            92: 
        !            93:            /* indicate there are no more customers */
        !            94:            DOSWRITEQUEUE (QueueHandle, NOMORE, DATALENGTH,
        !            95:                           (char *) &SharedSeg[TableID], /* any prio OK - not used */
        !            96:                           ELEMPRIORITY);
        !            97:         } /* endif */
        !            98: 
        !            99: 
        !           100:         /* free the shared segment */
        !           101:         DOSFREESEG (SharedSel);
        !           102: 
        !           103:         /* close the queue */
        !           104:         DOSCLOSEQUEUE (QueueHandle);
        !           105: }

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