/*************************************************************************** * Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, * * Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. * * * * Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael * * Chastain, Michael Quan, and Mitchell Tse. * * * * In order to use any part of this Merc Diku Mud, you must comply with * * both the original Diku license in 'license.doc' as well the Merc * * license in 'license.txt'. In particular, you may not remove either of * * these copyright notices. * * * * Thanks to abaddon for proof-reading our comm.c and pointing out bugs. * * Any remaining bugs are, of course, our work, not his. :) * * * * Much time and thought has gone into this software and you are * * benefitting. We hope that you share your changes too. What goes * * around, comes around. * ***************************************************************************/ /*************************************************************************** * ROM 2.4 is copyright 1993-1996 Russ Taylor * * ROM has been brought to you by the ROM consortium * * Russ Taylor (rtaylor@pacinfo.com) * * Gabrielle Taylor (gtaylor@pacinfo.com) * * Brian Moore (rom@rom.efn.org) * * By using this code, you have agreed to follow the terms of the * * ROM license, in the file Tartarus/doc/rom.license * ***************************************************************************/ /*************************************************************************** * Tartarus code is copyright (C) 1997-1998 by Daniel Graham * * In using this code you agree to comply with the Tartarus license * * found in the file /Tartarus/doc/tartarus.doc * ***************************************************************************/ // // Infinate bitmask system. // // Code by Runter. #include "include.h" int remove_bit(BITMASK *mask, sh_int bit) { BMlist *pBlist, *last = 0; if (!is_set(mask, bit)) // nothing doing. It isn't set. return FALSE; --bit; for(pBlist = mask->int_list;pBlist;pBlist = pBlist->next) { if (pBlist->set == bit / 32) { pBlist->tar_mask &= ~(1 << (bit % 32)); // remove it. --mask->bits; if (pBlist->tar_mask == 0) { if (last) last->next = pBlist->next; else mask->int_list = pBlist->next; free(pBlist); --mask->masks; } return TRUE; } last = pBlist; } return FALSE; } int set_bit(BITMASK *mask, sh_int bit) { BMlist *pBlist; --bit; for(pBlist = mask->int_list;pBlist;pBlist = pBlist->next) { if (pBlist->set == bit / 32) { if (pBlist->tar_mask & (1 << (bit % 32))) return FALSE; pBlist->tar_mask |= 1 << (bit % 32); ++mask->bits; return 1; } } pBlist = malloc(sizeof(BMlist)); ++mask->masks; pBlist->next = mask->int_list; mask->int_list = pBlist; pBlist->tar_mask = 0; pBlist->set = bit / 32; pBlist->tar_mask |= 1 << (bit % 32); ++mask->bits; return 2; } int is_set(BITMASK *mask, sh_int bit) { BMlist *pBlist; --bit; for(pBlist = mask->int_list;pBlist;pBlist = pBlist->next) { if (pBlist->set == bit / 32) { if (pBlist->tar_mask & 1 << (bit % 32)) return TRUE; else return FALSE; } } return FALSE; } int *serialize_bitmask(BITMASK *mask, int *len) { BMlist *pBlist; if (mask->bits <= 0) return NULL; int *ilist = (int *)malloc(sizeof(int) * mask->bits), i = 0, z; *len = mask->bits; if (!ilist) return NULL; ilist[mask->bits - 1] = 0; for(pBlist = mask->int_list;pBlist;pBlist = pBlist->next) { for(z = 0;z < 32;++z) { if (i > mask->bits) { break; } if (pBlist->tar_mask & 1 << z) ilist[i++] = pBlist->set * 32 + z + 1; } } if (i < mask->bits + 1) { // Problem } return ilist; } void free_bitmask(BITMASK *pBmask) { BMlist *pBMlist, *next; int found = 1; for(pBMlist = pBmask->int_list;pBMlist;pBMlist = next) { next = pBMlist->next; free_mem(pBMlist, sizeof(pBMlist) ); found = 2; } return; } BITMASK init_bitmask(BITMASK *bm) { static BITMASK bmzero; if (bm == 0) return bmzero; *bm = bmzero; return bmzero; } void load_bitmask(BITMASK *pBmask, FILE *fp) { int i; BMlist *pBMlist; pBmask->masks = fread_number(fp); pBmask->bits = fread_number(fp); for(i = 0;i < pBmask->masks;i++) { pBMlist = malloc(sizeof(BMlist)); pBMlist->set = fread_number(fp); pBMlist->tar_mask = fread_number(fp); //if (pBmask->int_list) pBMlist->next = pBmask->int_list; //else // pBMlist->next = NULL; pBmask->int_list = pBMlist; } } void save_bitmask(BITMASK *pBmask, FILE *fp) { BMlist *pBMlist = pBmask->int_list; int i; fprintf(fp, "%ld %ld", pBmask->masks, pBmask->bits); for(i = 0;i < pBmask->masks;i++) { fprintf(fp, " %ld %ld", pBMlist->set, pBMlist->tar_mask); pBMlist = pBMlist->next; } /*//Bug fix - prevent next = self which was causing pfile bitmask duplications for(pBMlist = pBmask->int_list;pBMlist && pBMlist != last;pBMlist = pBMlist->next) { last = pBMlist; }*/ fprintf(fp, "\n"); } void load_old_bits(BITMASK *pBmask, FILE *fp) { long temp; int i = 0; temp = fread_flag( fp ); for( i = 0; i < 32 ; i++ ) { if(IS_SET( temp, 1 << i ) ) set_bit(pBmask, i+1); } return; } void multi_set_bit(BITMASK *bm, int bits) { int i; for(i = 0; i < 32;i++) if (IS_SET(bits, 1 << i)) set_bit(bm, i+1); return; } BITMASK dup_bitmask(BITMASK *bm) { int ilist_len; int *ilist = (int *)serialize_bitmask(bm, &ilist_len),i; BITMASK dup = init_bitmask(NULL); if (!ilist) return dup; for(i = 0; i < ilist_len; i++) { set_bit(&dup, ilist[i]); } free(ilist); return dup; } char * bitmask_string( BITMASK *bm, const struct flag_type *flags ) { int i; static char string[MSL]; string[0] = '\0'; for( i = 0 ; flags[i].name != NULL ; i++ ) { if(is_set(bm, flags[i].bit) ) { strcat(string, flags[i].name); strcat(string, " "); } } return string; }