Return to alloc3.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / cifplot

Annotation of 41BSD/cmd/cifplot/alloc3.c, revision 1.1

1.1     ! root        1: /*******************************************************************
        !             2: *                                                                  *
        !             3: *    File: CIFPLOT/alloc3.c                                        *
        !             4: *    Written by Dan Fitzpatrick                                    *
        !             5: *    copyright 1980 -- Regents of the University of California     *
        !             6: *                                                                  *
        !             7: ********************************************************************/
        !             8: 
        !             9: #include <stdio.h>
        !            10: #include "defs.h"
        !            11: #include "globals.h"
        !            12: #include "parser_defs.h"
        !            13: #include "structs.h"
        !            14: #include "out_structs.h"
        !            15: 
        !            16: IMPORT GetQueue();
        !            17: IMPORT PutQueue();
        !            18: IMPORT InitQueue();
        !            19: IMPORT sbrk();
        !            20: 
        !            21: 
        !            22: #define REQUESTSIZE 64
        !            23: 
        !            24: Queue FreeLItems,FreeLTrans,FreeLIEdges,FreeLDesc,FreeLComm,FreeLEdges;
        !            25: Queue FreeLText,FreeHolders;
        !            26: 
        !            27: int acnt0,acnt1,acnt2,acnt3,acnt4,acnt5,acnt6,acnt7,acnt8,acnt9;
        !            28: int bcnt0,bcnt1,bcnt2,bcnt3,bcnt4,bcnt5,bcnt6,bcnt7,bcnt8,bcnt9;
        !            29: 
        !            30: InitGet()
        !            31: {
        !            32:     InitQueue(&FreeLItems);
        !            33:     InitQueue(&FreeLTrans);
        !            34:     InitQueue(&FreeLIEdges);
        !            35:     InitQueue(&FreeLEdges);
        !            36:     InitQueue(&FreeLDesc);
        !            37:     InitQueue(&FreeLComm);
        !            38:     InitQueue(&FreeLText);
        !            39:     InitQueue(&FreeHolders);
        !            40:     }
        !            41: 
        !            42: int *
        !            43: Get(q,n,id)
        !            44: Queue *q;
        !            45: int n,id;
        !            46: {
        !            47:     int i,*d;
        !            48:     char *p;
        !            49: #ifdef ADEBUG
        !            50:     switch(id) {
        !            51:        case 0x1234de5c:
        !            52:                acnt1++;
        !            53:                break;
        !            54:        case 0x1234ed9e:
        !            55:                acnt2++;
        !            56:                break;
        !            57:        case 0x1235ed9e:
        !            58:                acnt3++;
        !            59:                break;
        !            60:        case 0x123417e4:
        !            61:                acnt4++;
        !            62:                break;
        !            63:        case 0x123417e3:
        !            64:                acnt5++;
        !            65:                break;
        !            66:        case 0x12347ec7:
        !            67:                acnt6++;
        !            68:                break;
        !            69:        case 0x1234c033:
        !            70:                acnt7++;
        !            71:                break;
        !            72:        case 0x123477a8:
        !            73:                acnt8++;
        !            74:                break;
        !            75:        default:
        !            76:                acnt0++;
        !            77:                break;
        !            78:        }
        !            79: #endif
        !            80: 
        !            81:     if((p=(char *) GetQueue(q)) == NIL) {
        !            82:        p = (char *) sbrk(REQUESTSIZE*(sizeof(int) + n));
        !            83:        if(((int) p) <= 0) Error("No more memory",INTERNAL);
        !            84:        for(i=0; i < REQUESTSIZE * (sizeof(int) + n); i += (sizeof(int) + n))
        !            85:            PutQueue(&(p[i]),q);
        !            86:        p = (char *) GetQueue(q);
        !            87:        }
        !            88:     d = (int *) p;
        !            89:     *d = id;
        !            90:     return(++d);
        !            91:     }
        !            92: 
        !            93: nedge *
        !            94: AllocHolder()
        !            95: /* This is not handle by get because ID's are not used and
        !            96:  * storage is returned by concating onto the end of the queue */
        !            97: {
        !            98:     nedge *p;
        !            99:     int i;
        !           100: 
        !           101:     if((p = (nedge *) GetQueue(&FreeHolders)) == NIL) {
        !           102:        p = (nedge *) sbrk(REQUESTSIZE*sizeof(nedge));
        !           103:        if(((int) p) <= 0) Error("No more memory",INTERNAL);
        !           104:        for(i=0; i<REQUESTSIZE; i++) {
        !           105:                PutQueue(&(p[i]),&FreeHolders);
        !           106:                }
        !           107:        p = (nedge *) GetQueue(&FreeHolders);
        !           108:        }
        !           109:     return(p);
        !           110:     }
        !           111: 
        !           112: FreeGet(p,q,id)
        !           113: int *p;
        !           114: Queue *q;
        !           115: int id;
        !           116: {
        !           117: #ifdef ADEBUG
        !           118:     switch(id) {
        !           119:        case 0x1234de5c:
        !           120:                bcnt1++;
        !           121:                break;
        !           122:        case 0x1234ed9e:
        !           123:                bcnt2++;
        !           124:                break;
        !           125:        case 0x1235ed9e:
        !           126:                bcnt3++;
        !           127:                break;
        !           128:        case 0x123417e4:
        !           129:                bcnt4++;
        !           130:                break;
        !           131:        case 0x123417e3:
        !           132:                bcnt5++;
        !           133:                break;
        !           134:        case 0x12347ec7:
        !           135:                bcnt6++;
        !           136:                break;
        !           137:        case 0x1234c033:
        !           138:                bcnt7++;
        !           139:                break;
        !           140:        case 0x123477a8:
        !           141:                bcnt8++;
        !           142:                break;
        !           143:        default:
        !           144:                bcnt0++;
        !           145:                break;
        !           146:        }
        !           147: #endif
        !           148:     if(*(--p) != id)
        !           149:        Error("Bad ID number in Free",INTERNAL);
        !           150:     PutQueue(p,q);
        !           151:     }

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