![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lists.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / ld|
Return to lists.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / ld |
1.1 ! root 1: static char ID[] = "@(#) lists.c: 1.3 5/27/83"; ! 2: #include "system.h" ! 3: ! 4: #include "list.h" ! 5: #include "structs.h" ! 6: #include "sgsmacros.h" ! 7: ! 8: #define NULL 0 ! 9: /*eject*/ ! 10: listadd(seqid, ownerp, memp) ! 11: int seqid; /* sequence id */ ! 12: LISTOWN *ownerp; /* ptr to owner structure */ ! 13: char *memp; /* ptr to member structure */ ! 14: { ! 15: ! 16: /* ! 17: * Add a member structure to a linked list. ! 18: * ! 19: * This function is implemented as one function in case a general ! 20: * Storage Management System capability ever becomes available. ! 21: * ! 22: * Currently, the l_AI, l_IF, l_IS, l_OS, and l_INC lists are ! 23: * implemented as queues. The l_REG, l_MEM, and l_ADR lists are ! 24: * ordered lists. ! 25: */ ! 26: ! 27: switch (seqid) { ! 28: ! 29: case l_AI: ! 30: if (ownerp->tail == NULL) ! 31: ownerp->head = memp; ! 32: else ! 33: ((ACTITEM *) ownerp->tail)->ldlbry.ainext = (ACTITEM *) memp; ! 34: ownerp->tail = memp; ! 35: ((ACTITEM *) memp)->ldlbry.ainext = NULL; ! 36: break; ! 37: case l_IF: ! 38: if (ownerp->tail == NULL) ! 39: ownerp->head = memp; ! 40: else ! 41: ((INFILE *) ownerp->tail)->flnext = (INFILE *) memp; ! 42: ownerp->tail = memp; ! 43: ((INFILE *) memp)->flnext = NULL; ! 44: break; ! 45: case l_IS: ! 46: if (((INFILE *) ownerp)->flishead == NULL) ! 47: ((INFILE *) ownerp)->flishead = (INSECT *) memp; ! 48: else ! 49: ((INFILE *) ownerp)->flistail->isnext = (INSECT *) memp; ! 50: ((INFILE *) ownerp)->flistail = (INSECT *) memp; ! 51: ((INSECT *) memp)->isnext = NULL; ! 52: ((INSECT *) memp)->isfilptr = (INFILE *) ownerp; ! 53: break; ! 54: case l_OS: ! 55: if (ownerp->head == NULL) ! 56: ownerp->head = memp; ! 57: else ! 58: ((OUTSECT *) ownerp->tail)->osnext = (OUTSECT *) memp; ! 59: ownerp->tail = memp; ! 60: ((OUTSECT *) memp)->osnext = NULL; ! 61: break; ! 62: case l_INC: ! 63: if (((OUTSECT *) ownerp)->osinclhd == NULL) ! 64: ((OUTSECT *) ownerp)->osinclhd = (INSECT *) memp; ! 65: else ! 66: ((OUTSECT *) ownerp)->osincltl->isincnxt = (INSECT *) memp; ! 67: ((OUTSECT *) ownerp)->osincltl = (INSECT *) memp; ! 68: ((INSECT *) memp)->isincnxt = NULL; ! 69: ((INSECT *) memp)->isoutsec = (OUTSECT *) ownerp; ! 70: break; ! 71: case l_GRP: ! 72: if (((OUTSECT *) ownerp)->osinclhd == NULL) ! 73: ((OUTSECT *) (((OUTSECT *) ownerp)->osinclhd)) = (OUTSECT *) memp; ! 74: else ! 75: ((OUTSECT *) (((OUTSECT *) ownerp)->osincltl))->osnext = (OUTSECT *) memp; ! 76: ((OUTSECT *) ownerp)->osincltl = (INSECT *) memp; ! 77: ((OUTSECT *) memp)->osnext = NULL; ! 78: break; ! 79: case l_REG: ! 80: /* ! 81: * REGIONS list is ordered on address ! 82: */ ! 83: if (ownerp->head == NULL) { ! 84: ownerp->head = memp; ! 85: ownerp->tail = memp; ! 86: } ! 87: else { ! 88: REGION *rp, *prevrp; ! 89: rp = (REGION *) ownerp->head; ! 90: prevrp = NULL; ! 91: while( rp ) { ! 92: if(rp->rgorig > ((REGION *) memp)->rgorig){ ! 93: if (prevrp) ! 94: prevrp->rgnext = (REGION *) memp; ! 95: else ! 96: ownerp->head = memp; ! 97: ((REGION *) memp)->rgnext = rp; ! 98: return; ! 99: } ! 100: prevrp = rp; ! 101: rp = rp->rgnext; ! 102: } ! 103: prevrp->rgnext = (REGION *) memp; ! 104: ownerp->tail = memp; ! 105: } ! 106: break; ! 107: case l_MEM: ! 108: /* ! 109: * MEMORY list is ordered on address ! 110: */ ! 111: if (ownerp->head == NULL) { ! 112: ownerp->head = memp; ! 113: ownerp->tail = memp; ! 114: ((MEMTYPE *) memp)->mtnext = NULL; ! 115: } ! 116: else { ! 117: MEMTYPE *mp, *prevmp; ! 118: mp = (MEMTYPE *) ownerp->head; ! 119: prevmp = NULL; ! 120: while( mp ) { ! 121: if(mp->mtorig > ((MEMTYPE*)memp)->mtorig) { ! 122: if( prevmp ) ! 123: prevmp->mtnext = (MEMTYPE *) memp; ! 124: else ! 125: ownerp->head = memp; ! 126: ((MEMTYPE *) memp)->mtnext = mp; ! 127: return; ! 128: } ! 129: prevmp = mp; ! 130: mp = mp->mtnext; ! 131: } ! 132: prevmp->mtnext = (MEMTYPE *) memp; ! 133: ownerp->tail = memp; ! 134: } ! 135: break; ! 136: case l_ADR: ! 137: /* ! 138: * ADDR NODE list is ordered on address ! 139: */ ! 140: if(ownerp->head == NULL) { ! 141: ownerp->head = ownerp->tail = memp; ! 142: ((ANODE *) memp)->adprev = ((ANODE *) memp)->adnext = NULL; ! 143: } ! 144: else { ! 145: ANODE *p; ! 146: p = (ANODE *) ownerp->head; ! 147: while( p ) { ! 148: if(p->adpaddr >= ((ANODE *) memp)->adpaddr){ ! 149: if( p->adprev ) ! 150: p->adprev->adnext = (ANODE *) memp; ! 151: else ! 152: ownerp->head = memp; ! 153: ((ANODE *) memp)->adprev = p->adprev; ! 154: ((ANODE *) memp)->adnext = p; ! 155: p->adprev = (ANODE *) memp; ! 156: return; ! 157: } ! 158: p = p->adnext; ! 159: } ! 160: p = (ANODE *) ownerp->tail; ! 161: ownerp->tail = memp; ! 162: ((ANODE *) memp)->adnext = NULL; ! 163: ((ANODE *) memp)->adprev = p; ! 164: p->adnext = (ANODE *) memp; ! 165: } ! 166: break; ! 167: case l_DS: ! 168: if (ownerp->tail == NULL) ! 169: ownerp->head = memp; ! 170: else ! 171: ((OUTSECT *) ownerp->tail)->osdsnext = (OUTSECT *) memp; ! 172: ownerp->tail = memp; ! 173: ((OUTSECT *) memp)->osdsnext = NULL; ! 174: break; ! 175: } ! 176: } ! 177: /*eject*/ ! 178: listins(seqid, ownerp, basep, memp) ! 179: int seqid; /* sequence id */ ! 180: LISTOWN *ownerp; /* ptr to owner structure */ ! 181: char *basep; /* ptr to insertion point in sequence */ ! 182: char *memp; /* ptr to member structure */ ! 183: { ! 184: ! 185: /* ! 186: * Insert a member structure into a linked list, after a specified ! 187: * existing list member. ! 188: * ! 189: * If the insertion member pointer (= basep) is NULL, then the list ! 190: * is empty, and the new member will become the first list element ! 191: * ! 192: * This function is implemented as one function in case a general ! 193: * Storage Management System capability ever becomes available. ! 194: * ! 195: * Currently, the l_AI, l_IF, l_IS, l_OS, and l_INC lists are ! 196: * implemented as queues. The l_REG, l_MEM, and l_ADR lists are ! 197: * ordered lists. ! 198: */ ! 199: ! 200: if( basep == NULL ) { ! 201: listadd(seqid, ownerp, memp); ! 202: return; ! 203: } ! 204: ! 205: switch (seqid) { ! 206: ! 207: case l_AI: ! 208: ((ACTITEM *) memp)->ldlbry.ainext = ((ACTITEM *) basep)->ldlbry.ainext; ! 209: ((ACTITEM *) basep)->ldlbry.ainext = (ACTITEM *) memp; ! 210: if( ownerp->tail == basep ) ! 211: ownerp->tail = memp; ! 212: break; ! 213: case l_IF: ! 214: ((INFILE *) memp)->flnext = ((INFILE *) basep)->flnext; ! 215: ((INFILE *) basep)->flnext = (INFILE *) memp; ! 216: if( ownerp->tail == basep ) ! 217: ownerp->tail = memp; ! 218: break; ! 219: case l_IS: ! 220: ((INSECT *) memp)->isnext = ((INSECT *) basep)->isnext; ! 221: ((INSECT *) basep)->isnext = (INSECT *) memp; ! 222: if( ((INFILE *) ownerp)->flistail == ((INSECT *) basep) ) ! 223: ((INFILE *) ownerp)->flistail = (INSECT *) memp; ! 224: break; ! 225: case l_OS: ! 226: ((OUTSECT *) memp)->osnext = ((OUTSECT *) basep)->osnext; ! 227: ((OUTSECT *) basep)->osnext = (OUTSECT *) memp; ! 228: if( ownerp->tail == basep ) ! 229: ownerp->tail = memp; ! 230: break; ! 231: case l_INC: ! 232: ((INSECT *) memp)->isincnxt = ((INSECT *) basep)->isincnxt; ! 233: ((INSECT *) basep)->isincnxt = (INSECT *) memp; ! 234: if( ((OUTSECT *) ownerp)->osincltl == ((INSECT *) basep) ) ! 235: ((OUTSECT *) ownerp)->osincltl = (INSECT *) memp; ! 236: break; ! 237: case l_GRP: ! 238: ((OUTSECT *) memp)->osnext = ((OUTSECT *) basep)->osnext; ! 239: ((OUTSECT *) basep)->osnext = ((OUTSECT *) memp); ! 240: if( ((OUTSECT *) ownerp)->osincltl == ((INSECT *) basep) ) ! 241: ((OUTSECT *) ownerp)->osincltl = ((INSECT *) memp); ! 242: break; ! 243: case l_REG: ! 244: ((REGION *) memp)->rgnext = ((REGION *) basep)->rgnext; ! 245: ((REGION *) basep)->rgnext = ((REGION *) memp); ! 246: if( ownerp->tail == basep ) ! 247: ownerp->tail = memp; ! 248: break; ! 249: case l_MEM: ! 250: ((MEMTYPE *) memp)->mtnext = ((MEMTYPE *) basep)->mtnext; ! 251: ((MEMTYPE *) basep)->mtnext = ((MEMTYPE *) memp); ! 252: if( ownerp->tail == basep ) ! 253: ownerp->tail = memp; ! 254: break; ! 255: case l_ADR: ! 256: ((ANODE *) memp)->adnext = ((ANODE *) basep)->adnext; ! 257: ((ANODE *) basep)->adnext = ((ANODE *) memp); ! 258: ((ANODE *) memp)->adprev = ((ANODE *) basep); ! 259: if (((ANODE *) memp)->adnext) ! 260: ((ANODE *) memp)->adnext->adprev = ((ANODE *) memp); ! 261: if( ownerp->tail == basep ) ! 262: ownerp->tail = memp; ! 263: break; ! 264: case l_DS: ! 265: ((OUTSECT *) memp)->osdsnext = ((OUTSECT *) basep)->osdsnext; ! 266: ((OUTSECT *) basep)->osdsnext = (OUTSECT *) memp; ! 267: if( ownerp->tail == basep ) ! 268: ownerp->tail = memp; ! 269: break; ! 270: } ! 271: } ! 272: /*eject*/ ! 273: listdel(seqid, headp, prevp, memp) ! 274: int seqid; /* sequence id */ ! 275: LISTOWN *headp; /* ptr to head-of-list structure */ ! 276: char *prevp; /* ptr to member preceeding the member to delete +/ ! 277: char *memp; /* ptr to member to delete */ ! 278: { ! 279: ! 280: /* ! 281: * Delete a member structure from a linked list ! 282: * ! 283: * If the member structure is null, this function is a noop ! 284: * ! 285: * This function is implemented as one function in case a general ! 286: * Storage Management System capability ever becomes available. ! 287: * ! 288: * Currently, the l_AI, l_IF, l_IS, l_OS, and l_INC lists are ! 289: * implemented as queues. The l_REG, l_MEM, and l_ADR lists are ! 290: * ordered lists. ! 291: */ ! 292: ! 293: if( memp == NULL ) ! 294: return; ! 295: ! 296: switch( seqid ) { ! 297: ! 298: case l_AI: ! 299: if( prevp ) ! 300: ((ACTITEM *) prevp)->ldlbry.ainext = ((ACTITEM *) memp)->ldlbry.ainext; ! 301: else ! 302: headp->head = (char *) ((ACTITEM *) memp)->ldlbry.ainext; ! 303: if( headp->tail == (char *) memp ) ! 304: headp->tail = prevp; ! 305: break; ! 306: case l_IF: ! 307: if( prevp ) ! 308: ((INFILE *) prevp)->flnext = ((INFILE *) memp)->flnext; ! 309: else ! 310: headp->head = (char *) ((INFILE *) memp)->flnext; ! 311: if( headp->tail == (char *) memp ) ! 312: headp->tail = prevp; ! 313: break; ! 314: case l_IS: ! 315: if( prevp ) ! 316: ((INSECT *) prevp)->isnext = ((INSECT *) memp)->isnext; ! 317: else ! 318: ((INFILE*) headp)->flishead = ((INSECT *) memp)->isnext; ! 319: if( ((INFILE *) headp)->flistail == ((INSECT *) memp) ) ! 320: ((INFILE *) headp)->flistail = (INSECT *) prevp; ! 321: break; ! 322: case l_OS: ! 323: if( prevp ) ! 324: ((OUTSECT *) prevp)->osnext = ((OUTSECT *) memp)->osnext; ! 325: else ! 326: headp->head = (char *) ((OUTSECT *) memp)->osnext; ! 327: if( headp->tail == (char *) memp ) ! 328: headp->tail = prevp; ! 329: break; ! 330: case l_INC: ! 331: if( prevp ) ! 332: ((INSECT *) prevp)->isincnxt = ((INSECT *) memp)->isincnxt; ! 333: else ! 334: ((OUTSECT *) headp)->osinclhd = ((INSECT *) memp)->isincnxt; ! 335: if( ((OUTSECT *) headp)->osincltl == ((INSECT *) memp) ) ! 336: ((OUTSECT *) headp)->osincltl = (INSECT *) prevp; ! 337: break; ! 338: case l_GRP: ! 339: if( prevp ) ! 340: ((OUTSECT *) prevp)->osnext = ((OUTSECT *) memp)->osnext; ! 341: else ! 342: ((OUTSECT *) headp)->osinclhd = ((INSECT *) ((OUTSECT *) memp)->osnext); ! 343: if( ((OUTSECT *) headp)->osincltl == ((INSECT *) memp) ) ! 344: ((OUTSECT *) headp)->osincltl = ((INSECT *) prevp); ! 345: break; ! 346: case l_REG: ! 347: if( prevp ) ! 348: ((REGION *) prevp)->rgnext = ((REGION *) memp)->rgnext; ! 349: else ! 350: headp->head = (char *) ((REGION *) memp)->rgnext; ! 351: if( headp->tail == (char *) memp ) ! 352: headp->tail = prevp; ! 353: break; ! 354: case l_MEM: ! 355: if( prevp ) ! 356: ((MEMTYPE *) prevp)->mtnext = ((MEMTYPE *) memp)->mtnext; ! 357: else ! 358: headp->head = (char *) ((MEMTYPE *) memp)->mtnext; ! 359: if( headp->tail == (char *) memp ) ! 360: headp->tail = prevp; ! 361: break; ! 362: case l_ADR: ! 363: if( prevp ) ! 364: ((ANODE *) prevp)->adnext = ((ANODE *) memp)->adnext; ! 365: else ! 366: headp->head = (char *) ((ANODE *) memp)->adnext; ! 367: if( headp->tail == (char *) memp ) ! 368: headp->tail = prevp; ! 369: else ! 370: ((ANODE *) memp)->adnext->adprev = (ANODE *) prevp; ! 371: break; ! 372: case l_DS: ! 373: if( prevp ) ! 374: ((OUTSECT *) prevp)->osdsnext = ((OUTSECT *) memp)->osdsnext; ! 375: else ! 376: headp->head = (char *) ((OUTSECT *) memp)->osdsnext; ! 377: if( headp->tail == (char *) memp ) ! 378: headp->tail = prevp; ! 379: break; ! 380: } ! 381: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.