Return to circleq.c CVS log

Up to [OS/2 SDKs] / pmsdk / samples / comtalk

Annotation of pmsdk/samples/comtalk/circleq.c, revision 1.1

1.1     ! root        1: /*
        !             2:     Circular Queue buffer implementation (which gets read by AVIO module)
        !             3:     Created by Microsoft Corporation, 1989
        !             4: */
        !             5: #define INCL_DOSSEMAPHORES
        !             6: #include <os2.h>               /* Need USHORT for global.h */
        !             7: #include <string.h>            /* One strcpy call */
        !             8: #include "global.h"
        !             9: #include "circleq.h"
        !            10: 
        !            11: #define        TIMEOUT 1000L           /* A second */
        !            12: 
        !            13: LineInfo aliRing[QUEUESIZE];   /* The Circular Queue...*/
        !            14: int  iHead, iTail;
        !            15: BOOL fFirst;                   /* Are we just starting? */
        !            16: LONG lSemMyQueue;              /* Queue lock */
        !            17: 
        !            18: void LineCopy(Line, Line);
        !            19: void QueFill(void);
        !            20: 
        !            21: #define QueLock()   DosSemRequest(&lSemMyQueue, -1L)
        !            22: #define QueUnlock() DosSemClear(&lSemMyQueue)
        !            23: 
        !            24: #define Fix(n) (((n) >= 0) ? (n) : ((n) + QUEUESIZE))
        !            25: #define Circle(x)      ((x) % QUEUESIZE)
        !            26: #define Incr(x)        (x = Circle(x + 1))
        !            27: #define Decr(x)                (x = (x > 0) ? (x - 1) : (QUEUESIZE - 1))
        !            28: 
        !            29: void QueFill(void) {
        !            30:     int i, j;
        !            31: 
        !            32:     for (i = 0; i < 25; i++) {
        !            33:        aliRing[i].cch = MAXLINELEN;
        !            34:        for (j = 0; j < MAXLINELEN; j++)
        !            35:            aliRing[i].szText[j] = (char) ((i * j) % 10) + '0';
        !            36:     }
        !            37:     iHead = 0; iTail = 24;
        !            38: }
        !            39: 
        !            40: void QueInit(void) {
        !            41:     int i;
        !            42: 
        !            43:     fFirst = TRUE;
        !            44:     QueLock();
        !            45:     iHead = 0; iTail = 0;
        !            46:     for (i = 0; i < QUEUESIZE; i++) aliRing[i].cch = 0;
        !            47:     QueUnlock();
        !            48: }
        !            49: 
        !            50: void QueAdvance(int n) {
        !            51:     QueLock();
        !            52:     iHead = Circle(iHead + n);
        !            53:     QueUnlock();
        !            54: }
        !            55: 
        !            56: Line QueQuery(int LineNum) { return &aliRing[Circle(iHead + LineNum)]; }
        !            57: 
        !            58: BOOL QueInsertLine(Line pli) {
        !            59: /*
        !            60:     Return FALSE if we try to overwrite the head
        !            61: */
        !            62:     QueLock();
        !            63:     /*
        !            64:        Initialize the queue
        !            65:     */
        !            66:     if (fFirst) fFirst = FALSE;
        !            67:     /*
        !            68:        Increment TAIL, act if queue full
        !            69:        Overwrite if last entry was incomplete
        !            70:     */
        !            71:     else if (aliRing[iTail].fComplete && (Incr(iTail) == iHead)) {
        !            72:        /*
        !            73:            We are overflowing...
        !            74:        */
        !            75:        Decr(iTail);
        !            76:        QueUnlock();
        !            77:        return FALSE;
        !            78:     }
        !            79:     /*
        !            80:        Insert the element
        !            81:     */
        !            82:     LineCopy(pli, &aliRing[iTail]);
        !            83:     QueUnlock();
        !            84:     return TRUE;
        !            85: }
        !            86: 
        !            87: BOOL QueCompleteLine(void) { return aliRing[iTail].fComplete; }
        !            88: 
        !            89: void LineCopy(Line pliSrc, Line pliDst) {
        !            90:     int i;
        !            91: 
        !            92:     pliDst->fDrawn             = pliSrc->fDrawn;
        !            93:     pliDst->fComplete          = pliSrc->fComplete;
        !            94:     pliDst->cch                        = pliSrc->cch;
        !            95:     for (i = 0; i < pliSrc->cch; i++) pliDst->szText[i] = pliSrc->szText[i];
        !            96: }
        !            97: 
        !            98: int QueUpdateHead(int nRows, BOOL bPage, BOOL bPaging) {
        !            99:     int i, nLines;
        !           100: 
        !           101:     nLines = Fix(Circle(iTail - iHead));
        !           102:     nLines = (nLines >= nRows) ? (nLines - nRows + 1) : 0;
        !           103:     if ((nLines = Min(nLines, nRows)) > 0) {
        !           104:        if (bPage) {
        !           105:            if (nLines < nRows) {
        !           106:                QueLock();
        !           107:                for (i = nLines; i < nRows; i++)
        !           108:                    aliRing[Circle(iHead + nRows + i)].cch = 0;
        !           109:                QueUnlock();
        !           110:            }
        !           111:            nLines = nRows;
        !           112:        }
        !           113:        else if (bPaging) nLines = 0;
        !           114:        QueLock();
        !           115:        iHead = Circle(iHead + nLines);
        !           116:        QueUnlock();
        !           117:     }
        !           118:     return nLines;
        !           119: }
        !           120: 
        !           121: Line QueLastLine(void) {
        !           122:     QueLock();
        !           123:     aliRing[iTail].szText[aliRing[iTail].cch] = '\0';
        !           124:     QueUnlock();
        !           125:     return &aliRing[iTail];
        !           126: }
        !           127: 
        !           128: int QuePageUp(int nRows) {
        !           129:     int i, nLines;
        !           130: 
        !           131:     QueLock();
        !           132:     nLines = Min((QUEUESIZE - 1) - Fix(Circle(iTail - iHead)), nRows);
        !           133:     if (nLines) {
        !           134:        iHead = Fix(Circle(iHead - nLines));
        !           135:        for (i = 0; i < nLines; i++)
        !           136:            aliRing[Circle(iHead + nRows + i)].fDrawn = FALSE;
        !           137:     }
        !           138:     QueUnlock();
        !           139:     return nLines;
        !           140: }

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