Return to list.c CVS log

Up to [contributed] / early-roguelike / srogue

Annotation of early-roguelike/srogue/list.c, Revision 1.1

1.1     ! rubenllo    1: /*
        !             2:  * Functions for dealing with linked lists of goodies
        !             3:  *
        !             4:  * @(#)list.c  9.0     (rdk)    7/17/84
        !             5:  *
        !             6:  * Super-Rogue
        !             7:  * Copyright (C) 1984 Robert D. Kindelberger
        !             8:  * All rights reserved.
        !             9:  *
        !            10:  * Based on "Rogue: Exploring the Dungeons of Doom"
        !            11:  * Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
        !            12:  * All rights reserved.
        !            13:  *
        !            14:  * See the file LICENSE.TXT for full copyright and licensing information.
        !            15:  */
        !            16:
        !            17: #include <stdlib.h>
        !            18: #include "rogue.h"
        !            19: #include "rogue.ext"
        !            20:
        !            21: /*
        !            22:  * detach:
        !            23:  *     Takes an item out of whatever linked list it might be in
        !            24:  */
        !            25:
        !            26: void
        !            27: _detach(struct linked_list **list, struct linked_list *item)
        !            28: {
        !            29:        if (*list == item)
        !            30:                *list = next(item);
        !            31:        if (prev(item) != NULL)
        !            32:                item->l_prev->l_next = next(item);
        !            33:        if (next(item) != NULL)
        !            34:                item->l_next->l_prev = prev(item);
        !            35:        item->l_next = NULL;
        !            36:        item->l_prev = NULL;
        !            37: }
        !            38:
        !            39: /*
        !            40:  * _attach:    add an item to the head of a list
        !            41:  */
        !            42: void
        !            43: _attach(struct linked_list **list, struct linked_list *item)
        !            44: {
        !            45:        if (*list != NULL)      {
        !            46:                item->l_next = *list;
        !            47:                (*list)->l_prev = item;
        !            48:                item->l_prev = NULL;
        !            49:        }
        !            50:        else    {
        !            51:                item->l_next = NULL;
        !            52:                item->l_prev = NULL;
        !            53:        }
        !            54:        *list = item;
        !            55: }
        !            56:
        !            57: /*
        !            58:  * _free_list: Throw the whole blamed thing away
        !            59:  */
        !            60: void
        !            61: _free_list(struct linked_list **ptr)
        !            62: {
        !            63:        register struct linked_list *item;
        !            64:
        !            65:        while (*ptr != NULL) {
        !            66:                item = *ptr;
        !            67:                *ptr = next(item);
        !            68:                discard(item);
        !            69:        }
        !            70: }
        !            71:
        !            72: /*
        !            73:  * discard:  free up an item
        !            74:  */
        !            75: void
        !            76: discard(struct linked_list *item)
        !            77: {
        !            78:        total -= 2;
        !            79:        FREE(item->l_data);
        !            80:        FREE(item);
        !            81: }
        !            82:
        !            83: /*
        !            84:  * new_item:   get a new item with a specified size
        !            85:  */
        !            86: struct linked_list *
        !            87: new_item(int size)
        !            88: {
        !            89:        register struct linked_list *item;
        !            90:
        !            91:        item = (struct linked_list *) new(sizeof *item);
        !            92:        item->l_data = new(size);
        !            93:        item->l_next = item->l_prev = NULL;
        !            94:        return item;
        !            95: }
        !            96:
        !            97: char *
        !            98: new(int size)
        !            99: {
        !           100:        register char *space = ALLOC(size);
        !           101:
        !           102:        if (space == NULL) {
        !           103:                sprintf(prbuf,"Rogue ran out of memory (%ld).", md_memused());
        !           104:                fatal(prbuf);
        !           105:        }
        !           106:        total++;
        !           107:        return space;
        !           108: }