Return to alloc3.c CVS log

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

Annotation of 40BSD/cmd/cifplot/alloc3.c, revision 1.1.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.