00001
00002
00003
00004
00005 #include "copyright.h"
00006 #include "config.h"
00007 #include "macro.h"
00008 #include "commac.h"
00009
00010 #include "config.h"
00011 #include "flags.h"
00012 #include "powers.h"
00013 #include "db.h"
00014 #include "alloc.h"
00015
00016 extern dbref match_thing(dbref player, char *name);
00017
00018 MACENT macro_table[] = {
00019 {(char *) "add", do_add_macro},
00020 {(char *) "clear", do_clear_macro},
00021 {(char *) "chmod", do_chmod_macro},
00022 {(char *) "chown", do_chown_macro},
00023 {(char *) "create", do_create_macro},
00024 {(char *) "def", do_def_macro},
00025 {(char *) "del", do_del_macro},
00026 {(char *) "name", do_desc_macro},
00027 {(char *) "chslot", do_edit_macro},
00028 {(char *) "ex", do_ex_macro},
00029 {(char *) "gex", do_gex_macro},
00030 {(char *) "glist", do_list_macro},
00031 {(char *) "list", do_status_macro},
00032 {(char *) "undef", do_undef_macro},
00033 {(char *) NULL, NULL}
00034 };
00035
00036 void init_mactab(void)
00037 {
00038 MACENT *mp;
00039
00040 hashinit(&mudstate.macro_htab, 5 * HASH_FACTOR);
00041
00042 for(mp = macro_table; mp->cmdname; mp++)
00043 hashadd(mp->cmdname, (int *) mp, &mudstate.macro_htab);
00044 }
00045
00046 int do_macro(dbref player, char *in, char **out)
00047 {
00048 char *s;
00049 char *cmd;
00050 MACENT *mp;
00051 char *old;
00052
00053 cmd = in + 1;
00054
00055 if(!isPlayer(player)) {
00056 notify(player, "MACRO: Only players may use macros.");
00057 return 0;
00058 }
00059 old = alloc_lbuf("do_macro");
00060
00061 StringCopy(old, in);
00062
00063 for(s = cmd; *s && *s != ' '; s++);
00064 if(*s == ' ')
00065 *s++ = 0;
00066
00067 mp = (MACENT *) hashfind(cmd, &mudstate.macro_htab);
00068 if(mp != NULL) {
00069 (*(mp->handler)) (player, s);
00070 free_lbuf(old);
00071 return 0;
00072 }
00073 if((*out = do_process_macro(player, in, s)) != NULL) {
00074 free_lbuf(old);
00075 return 1;
00076 } else {
00077 StringCopy(in, old);
00078 free_lbuf(old);
00079 return 2;
00080
00081
00082
00083 }
00084
00085
00086 }
00087
00088 void do_list_macro(dbref player, char *s)
00089 {
00090 int i;
00091 int notified = 0;
00092 struct macros *m;
00093 char *unparse;
00094
00095 for(i = 0; i < nummacros; i++) {
00096 m = macros[i];
00097
00098 if(can_read_macros(player, m)) {
00099 if(!notified) {
00100 notify(player,
00101 "Num Description Owner LRW");
00102 notified = 1;
00103 }
00104 unparse = unparse_object(player, m->player, 0);
00105 notify_printf(player, "%-4d %-35.35s %-24.24s %c%c%c", i,
00106 m->desc, unparse, m->status & MACRO_L ? 'L' : '-',
00107 m->status & MACRO_R ? 'R' : '-',
00108 m->status & MACRO_W ? 'W' : '-');
00109 free_lbuf(unparse);
00110 }
00111 }
00112
00113 if(!notified)
00114 notify(player, "MACRO: There are no macro sets you can read.");
00115 }
00116
00117 void do_add_macro(dbref player, char *s)
00118 {
00119 int first;
00120 int set;
00121 struct macros *m;
00122 struct commac *c;
00123 int i;
00124
00125 c = get_commac(player);
00126
00127 first = -1;
00128 for(i = 0; i < 5 && first < 0; i++)
00129 if(c->macros[i] == -1)
00130 first = i;
00131
00132 if(first < 0) {
00133 notify(player,
00134 "MACRO: Sorry, you already have 5 sets defined on you.");
00135 } else if(is_number(s)) {
00136 set = atoi(s);
00137 if(set >= 0 && set < nummacros) {
00138 m = macros[set];
00139 if(can_read_macros(player, m)) {
00140 c->macros[first] = set;
00141 notify_printf(player,
00142 "MACRO: Macro set %d added in the %d slot.",
00143 set, first);
00144 } else {
00145 notify(player, "MACRO: Permission denied.");
00146 }
00147 } else {
00148 notify(player, "MACRO: That macro set does not exist.");
00149 return;
00150 }
00151 } else {
00152 notify(player,
00153 "MACRO: What set do you want to add to your macro system?");
00154 }
00155 }
00156
00157 void do_del_macro(dbref player, char *s)
00158 {
00159 struct commac *c;
00160 int set;
00161
00162 c = get_commac(player);
00163
00164 if(is_number(s)) {
00165 set = atoi(s);
00166 if(set >= 0 && set < 5 && c->macros[set] >= 0) {
00167 c->macros[set] = -1;
00168 notify_printf(player, "MACRO: Macro slot %d cleared.", set);
00169 if(set == c->curmac) {
00170 c->curmac = -1;
00171 notify(player,
00172 "MACRO: Deleted current slot, resetting to none.");
00173 }
00174 } else
00175 notify(player, "MACRO: That is not a legal macro slot.");
00176 } else
00177 notify(player,
00178 "MACRO: What set did you want to delete from your macro system?");
00179 }
00180
00181 void do_desc_macro(dbref player, char *s)
00182 {
00183 struct macros *m;
00184
00185 m = get_macro_set(player, -1);
00186 if(m) {
00187 free(m->desc);
00188 m->desc = (char *) malloc(strlen(s) + 1);
00189 StringCopy(m->desc, s);
00190 notify_printf(player, "MACRO: Current slot description to %s.", s);
00191 } else
00192 notify(player, "MACRO: You have no current slot set.");
00193 }
00194
00195 void do_chmod_macro(dbref player, char *s)
00196 {
00197 struct macros *m;
00198 int sign;
00199
00200 m = get_macro_set(player, -1);
00201
00202 if(m) {
00203 if((m->player != player) && !Wizard(player)) {
00204 notify(player, "MACRO: Permission denied.");
00205 return;
00206 }
00207 if(*s == '!') {
00208 sign = 0;
00209 s++;
00210 } else
00211 sign = 1;
00212
00213 switch (*s) {
00214 case 'L':
00215 case 'l':
00216 if(sign) {
00217 m->status |= MACRO_L;
00218 notify(player,
00219 "MACRO: Default Macro Slot is now locked and unwritable.");
00220 } else {
00221 m->status &= ~MACRO_L;
00222 notify(player, "MACRO: Default Macro Slot is now unlocked.");
00223 }
00224 break;
00225 case 'R':
00226 case 'r':
00227 if(sign) {
00228 m->status |= MACRO_R;
00229 notify(player,
00230 "MACRO: Default Macro Slot set to be readable by others");
00231 } else {
00232 m->status &= ~MACRO_R;
00233 notify(player,
00234 "MACRO: Default Macro Slot set to be not readable by others");
00235 }
00236 break;
00237 case 'W':
00238 case 'w':
00239 if(sign) {
00240 m->status |= MACRO_W;
00241 notify(player,
00242 "MACRO: Default Macro Slot set to be writable by others");
00243 } else {
00244 m->status &= ~MACRO_W;
00245 notify(player,
00246 "MACRO: Default Macro Slot set to be not writable by others");
00247 }
00248 break;
00249 default:
00250 notify(player,
00251 "MACRO: Sorry, unknown mode. Legal modes are: L R W");
00252 }
00253 } else
00254 notify(player, "MACRO: You have no current slot set.");
00255 }
00256
00257 void do_gex_macro(dbref player, char *s)
00258 {
00259 struct macros *m;
00260 int which;
00261 int i;
00262 char buffer[LBUF_SIZE];
00263
00264 if(!s || !*s) {
00265 notify(player, "MACRO: You need to specify a macro set.");
00266 return;
00267 }
00268 if(is_number(s)) {
00269 which = atoi(s);
00270 if((which >= nummacros) || (which < 0) || (nummacros == 0)) {
00271 notify_printf(player,
00272 "MACRO: Illegal Macro Set. Macros go from 0 to %d.",
00273 nummacros - 1);
00274 return;
00275 } else
00276 m = macros[which];
00277 } else {
00278 notify(player, "MACRO: I do not see that set here.");
00279 return;
00280 }
00281
00282 if(m && can_read_macros(player, m)) {
00283 notify_printf(player, "Macro Definitions for %s", m->desc);
00284 for(i = 0; i < m->nummacros; i++) {
00285 sprintf(buffer, " %-5.5s: %s", m->alias + i * 5, m->string[i]);
00286 notify(player, buffer);
00287 }
00288 } else
00289 notify(player, "MACRO: Permission denied.");
00290
00291 }
00292
00293 void do_edit_macro(dbref player, char *s)
00294 {
00295 struct commac *c;
00296 int set;
00297
00298 c = get_commac(player);
00299
00300 if(is_number(s)) {
00301 set = atoi(s);
00302 if(set >= 0 && set < 5 && GMac(c->macros[set])) {
00303 c->curmac = set;
00304 notify_printf(player, "MACRO: Current slot set to %d.", set);
00305 } else
00306 notify(player, "MACRO: That is not a legal macro slot.");
00307 } else
00308 notify(player, "MACRO: What slot did you want to make current?");
00309 }
00310
00311 void do_status_macro(dbref player, char *s)
00312 {
00313 int i;
00314 struct commac *c;
00315 struct macros *m;
00316 char *unparse;
00317
00318 c = get_commac(player);
00319
00320 notify(player,
00321 "#: Num Description Owner LRW");
00322 for(i = 0; i < 5; i++) {
00323 if(c->macros[i] >= 0)
00324 if(!(GMac(c->macros[i])))
00325 notify_printf(player, "%d: INVALID MACRO SET!", i);
00326 else {
00327 m = macros[c->macros[i]];
00328 unparse = unparse_object(player, m->player, 0);
00329 notify_printf(player,
00330 "%d: %-4d %-35.35s %-24.24s %c%c%c", i,
00331 c->macros[i], m->desc, unparse,
00332 m->status & MACRO_L ? 'L' : '-',
00333 m->status & MACRO_R ? 'R' : '-',
00334 m->status & MACRO_W ? 'W' : '-');
00335 free_lbuf(unparse);
00336 } else
00337 notify_printf(player, "%d:", i);
00338 }
00339 notify_printf(player, "Current Macro Slot: %d", c->curmac);
00340 }
00341
00342 void do_ex_macro(dbref player, char *s)
00343 {
00344 struct macros *m;
00345 int which;
00346 int i;
00347 char buffer[LBUF_SIZE];
00348
00349 if(is_number(s)) {
00350 which = atoi(s);
00351 m = get_macro_set(player, which);
00352 } else
00353 m = get_macro_set(player, -1);
00354
00355 if(m) {
00356 notify_printf(player, "Macro Definitions for %s", m->desc);
00357 for(i = 0; i < m->nummacros; i++) {
00358 sprintf(buffer, " %-5.5s: %s", m->alias + i * 5, m->string[i]);
00359 notify(player, buffer);
00360 }
00361 } else
00362 notify(player, "MACRO: Illegal macro set to examine.");
00363
00364 }
00365
00366 void do_chown_macro(dbref player, char *cmd)
00367 {
00368 struct macros *m;
00369 dbref thing;
00370 char *unparse;
00371
00372 m = get_macro_set(player, -1);
00373 thing = match_thing(player, cmd);
00374
00375 if(thing == NOTHING) {
00376 notify(player, "MACRO: I do not see that here.");
00377 return;
00378 }
00379 #if 0
00380 if(!m || !can_write_macros(player, m)) {
00381 notify(player, "MACRO: Permission denied.");
00382 }
00383 #endif
00384 if(!m) {
00385 notify(player, "MACRO: No current active macro.");
00386 return;
00387 }
00388 if(!Wizard(player)) {
00389 notify(player, "MACRO: Sorry, command limited to Wizards.");
00390 return;
00391 }
00392 m->player = thing;
00393 unparse = unparse_object(player, thing, 0);
00394 notify_printf(player, "MACRO: Macro %s chowned to %s.", m->desc, unparse);
00395 free_lbuf(unparse);
00396 }
00397
00398 extern void clear_macro_set(int set)
00399 {
00400 struct macros *m;
00401 struct commac *c;
00402 int i, j;
00403
00404 if(GMac(set)) {
00405 m = macros[set];
00406 for(i = 0; i < m->nummacros; i++) {
00407 free(m->string[i]);
00408 }
00409 free(m->alias);
00410 free(m->string);
00411 free(m);
00412
00413 nummacros--;
00414 for(i = set; i < nummacros; i++)
00415 macros[i] = macros[i + 1];
00416 macros[i] = NULL;
00417
00418 }
00419 for(i = 0; i < NUM_COMMAC; i++) {
00420 c = commac_table[i];
00421 while (c) {
00422 for(j = 0; j < 5; j++) {
00423 if(c->macros[j] == set) {
00424 c->macros[j] = -1;
00425 if(c->curmac == j)
00426 c->curmac = -1;
00427 } else if(c->macros[j] > set) {
00428 c->macros[j]--;
00429 }
00430 }
00431 c = c->next;
00432 }
00433 }
00434 }
00435
00436 void do_clear_macro(dbref player, char *s)
00437 {
00438 int set;
00439 struct macros *m;
00440 struct commac *c;
00441
00442 c = get_commac(player);
00443
00444 if(c->curmac == -1) {
00445 notify(player, "MACRO: You are not currently editing a macro set.");
00446 return;
00447 } else if(c->macros[c->curmac] == -1) {
00448 notify(player, "MACRO: That is not a valid macro set.");
00449 return;
00450 }
00451 set = c->macros[c->curmac];
00452 m = macros[set];
00453
00454 if(GMac(set)) {
00455 if((player != m->player) && !Wizard(player)) {
00456 notify(player, "MACRO: You may only CLEAR your own macro sets.");
00457 return;
00458 } else if((player == m->player) && (m->status & MACRO_L)) {
00459 notify(player, "MACRO: Sorry, that macro set is locked.");
00460 return;
00461 }
00462 }
00463 notify_printf(player, "MACRO: Clearing macro set %d: %s.", set,
00464 GMac(set) ? m->desc : "Nonexistent");
00465 clear_macro_set(set);
00466 }
00467
00468 void do_def_macro(dbref player, char *cmd)
00469 {
00470 int i, j, where;
00471 struct macros *m;
00472 char *alias;
00473 char *s;
00474 char buffer[LBUF_SIZE];
00475 char **ns;
00476 char *na;
00477
00478 m = get_macro_set(player, -1);
00479
00480 if(!m) {
00481 notify(player, "MACRO: No current set.");
00482 return;
00483 }
00484 if(!can_write_macros(player, m)) {
00485 notify(player, "MACRO: Permission denied.");
00486 return;
00487 }
00488 for(alias = cmd; *alias && *alias == ' '; alias++)
00489 *alias = 0;
00490
00491 cmd = alias;
00492 for(; *cmd && *cmd != ' ' && *cmd != '='; cmd++);
00493 while (*cmd && *cmd == ' ')
00494 *cmd++ = '\0';
00495 if(*cmd != '=') {
00496 notify(player,
00497 "MACRO: You must specify an = in your macro definition");
00498 return;
00499 }
00500 *cmd++ = 0;
00501 while (*cmd && *cmd == ' ')
00502 *cmd++ = 0;
00503
00504 s = cmd;
00505
00506 if(!*s) {
00507 notify(player, "MACRO: You must specify a string to substitute for.");
00508 return;
00509 } else if(strlen(alias) > 4) {
00510 notify(player, "MACRO: Please limit aliases to 4 chars or less.");
00511 return;
00512 }
00513 for(j = 0;
00514 j < m->nummacros && (strcasecmp(alias, m->alias + j * 5) > 0); j++);
00515 if(j < m->nummacros && !strcasecmp(alias, m->alias + j * 5)) {
00516 notify(player, "MACRO: That alias is already defined in this set.");
00517 sprintf(buffer, "%-4.4s:%s", m->alias + j * 5, m->string[j]);
00518 notify(player, buffer);
00519 return;
00520 }
00521 if(m->nummacros >= m->maxmacros) {
00522 m->maxmacros += 10;
00523 na = (char *) malloc(5 * m->maxmacros);
00524 ns = (char **) malloc(sizeof(char *) * m->maxmacros);
00525
00526 for(i = 0; i < m->nummacros; i++) {
00527 StringCopy(na + i * 5, m->alias + i * 5);
00528 ns[i] = m->string[i];
00529 }
00530 free(m->alias);
00531 free(m->string);
00532 m->alias = na;
00533 m->string = ns;
00534 }
00535 where = m->nummacros++;
00536 for(i = where; i > j; i--) {
00537 StringCopy(m->alias + i * 5, m->alias + (i - 1) * 5);
00538 m->string[i] = m->string[i - 1];
00539 }
00540
00541 where = j;
00542 StringCopy(m->alias + where * 5, alias);
00543 m->string[where] = (char *) malloc(strlen(s) + 1);
00544 StringCopy(m->string[where], s);
00545 sprintf(buffer, "MACRO: Macro %s:%s defined.", alias, s);
00546 notify(player, buffer);
00547 }
00548
00549 void do_undef_macro(dbref player, char *cmd)
00550 {
00551 int i;
00552 struct macros *m;
00553
00554 m = get_macro_set(player, -1);
00555
00556 if(!m || !can_write_macros(player, m)) {
00557 notify(player, "MACRO: Permission denied.");
00558 return;
00559 }
00560 for(i = 0; i < m->nummacros; i++) {
00561 if(!strcmp(m->alias + i * 5, cmd)) {
00562 free(m->string[i]);
00563 m->nummacros--;
00564 for(; i < m->nummacros; i++) {
00565 StringCopy(m->alias + i * 5, m->alias + i * 5 + 5);
00566 m->string[i] = m->string[i + 1];
00567 }
00568 notify(player, "MACRO: Macro deleted from set.");
00569 return;
00570 }
00571 }
00572 notify(player, "MACRO: That macro is not in this set.");
00573 }
00574
00575 char *do_process_macro(dbref player, char *in, char *s)
00576 {
00577 char *cmd;
00578 char *tar;
00579 char *next;
00580 struct macros *m;
00581 int first, last, current = 0;
00582 int dir;
00583 int i;
00584 struct commac *c;
00585 char *buff;
00586
00587 c = get_commac(player);
00588 buff = alloc_lbuf("do_process_macro");
00589 cmd = in + 1;
00590 buff[0] = '\0';
00591
00592
00593 for(i = 0; i < 5; i++) {
00594 if(GMac(c->macros[i])) {
00595 m = macros[c->macros[i]];
00596 if(m->nummacros > 0) {
00597 first = 0;
00598 last = m->nummacros - 1;
00599 dir = 1;
00600 next = in + 1;
00601 while (dir && (first <= last)) {
00602 current = (first + last) / 2;
00603 dir = strcmp(next, m->alias + 5 * current);
00604 if(dir < 0)
00605 last = current - 1;
00606 else
00607 first = current + 1;
00608 }
00609
00610 if(!dir) {
00611 tar = m->string[current];
00612 #if 1
00613 next = buff;
00614 while (*tar) {
00615 if(*tar == '%' && *(tar + 1) == '*') {
00616 *next++ = '*';
00617 tar += 2;
00618 } else if(*tar == '*') {
00619 *next = 0;
00620 strcat(next, s);
00621 tar++;
00622 next += strlen(next);
00623 } else
00624 *next++ = *tar++;
00625 }
00626 *next = 0;
00627 #else
00628 while (*tar) {
00629 switch (*tar) {
00630 case '*':
00631 if(!buff)
00632 StringCopy(buff, s);
00633 else
00634 strcat(buff, s);
00635 break;
00636 case '%':
00637 if(!buff)
00638 StringCopy(buff, tar + 1);
00639 else
00640 sprintf(buff, "%s%c", buff, tar + 1);
00641 *tar++;
00642 break;
00643 default:
00644 if(!buff)
00645 StringCopy(buff, tar);
00646 else
00647 sprintf(buff, "%s%c", buff, *tar);
00648 break;
00649 }
00650 *tar++;
00651 }
00652 #endif
00653 return buff;
00654 }
00655 }
00656 }
00657 }
00658 free_lbuf(buff);
00659 return NULL;
00660 }
00661
00662 struct macros *get_macro_set(dbref player, int which)
00663 {
00664 int set;
00665 struct commac *c;
00666
00667 c = get_commac(player);
00668
00669 if(c) {
00670 set = -1;
00671 if(which >= 0 && which < 5)
00672 set = c->macros[which];
00673 else if(c->curmac >= 0)
00674 set = c->macros[c->curmac];
00675
00676 if(set == -1)
00677 return NULL;
00678 else
00679 return macros[set];
00680 } else
00681 return NULL;
00682 }
00683
00684 void do_sort_macro_set(struct macros *m)
00685 {
00686 int i;
00687 int cont;
00688 char buffer[10];
00689 char *s;
00690
00691 cont = 1;
00692 while (cont) {
00693 cont = 0;
00694 for(i = 0; i < m->nummacros - 1; i++)
00695 if(strcasecmp(m->alias + i * 5, m->alias + (i + 1) * 5) > 0) {
00696 StringCopy(buffer, m->alias + i * 5);
00697 StringCopy(m->alias + i * 5, m->alias + (i + 1) * 5);
00698 StringCopy(m->alias + (i + 1) * 5, buffer);
00699 s = m->string[i];
00700 m->string[i] = m->string[i + 1];
00701 m->string[i + 1] = s;
00702 cont = 1;
00703 }
00704 }
00705 }
00706
00707 void do_create_macro(dbref player, char *s)
00708 {
00709 int first;
00710 int i;
00711 struct commac *c;
00712 struct macros **nm;
00713 int set;
00714
00715 c = get_commac(player);
00716 first = -1;
00717 for(i = 0; i < 5 && first < 0; i++)
00718 if(c->macros[i] == -1)
00719 first = i;
00720 if(first < 0) {
00721 notify(player,
00722 "MACRO: Sorry, you already have 5 sets defined on you.");
00723 return;
00724 }
00725 if(nummacros >= maxmacros) {
00726 maxmacros += 10;
00727 nm = (struct macros **) malloc(sizeof(struct macros *) * maxmacros);
00728
00729 for(i = 0; i < nummacros; i++)
00730 nm[i] = macros[i];
00731 free(macros);
00732 macros = nm;
00733 }
00734 set = nummacros++;
00735 macros[set] = (struct macros *) malloc(sizeof(struct macros));
00736
00737 macros[set]->player = player;
00738 macros[set]->status = 0;
00739 macros[set]->nummacros = 0;
00740 macros[set]->maxmacros = 0;
00741 macros[set]->alias = NULL;
00742 macros[set]->string = NULL;
00743 macros[set]->desc = (char *) malloc(strlen(s) + 1);
00744 StringCopy(macros[set]->desc, s);
00745 c->curmac = first;
00746 c->macros[first] = set;
00747
00748 notify_printf(player,
00749 "MACRO: Macro set %d created with description %s.", set, s);
00750 }
00751
00752 int can_write_macros(dbref player, struct macros *m)
00753 {
00754 if(m->status & MACRO_L)
00755 return 0;
00756
00757 if(m->player == player)
00758 return 1;
00759 else
00760 return m->status & MACRO_W;
00761 }
00762
00763 int can_read_macros(dbref player, struct macros *m)
00764 {
00765 if(Wizard(player))
00766 return 1;
00767
00768 if(!m)
00769 return 0;
00770
00771 if(m->player == player)
00772 return 1;
00773 else
00774 return m->status & MACRO_R;
00775 }
00776
00777 #define TST(cmd,msg) if (cmd) { fprintf(stderr, msg); exit(1); }
00778
00779 void load_macros(FILE * fp)
00780 {
00781 int i, j;
00782 char *c;
00783 char *t;
00784 char buffer[LBUF_SIZE];
00785 struct macros *m;
00786
00787 TST(fscanf(fp, "%d\n", &nummacros) != 1, "Error: Loading #macros\n");
00788 maxmacros = nummacros;
00789
00790 if(maxmacros > 0)
00791 macros =
00792 (struct macros **) malloc(sizeof(struct macros *) * nummacros);
00793 else
00794 macros = NULL;
00795
00796 for(i = 0; i < nummacros; i++) {
00797 macros[i] = (struct macros *) malloc(sizeof(struct macros));
00798
00799 m = macros[i];
00800
00801 fgets(buffer, LBUF_SIZE, fp);
00802 TST(sscanf(buffer, "%d %d %d\n", &(m->player), &(m->nummacros), &j)
00803 != 3, tprintf("Reading macro set #%d\n", i));
00804 m->status = j;
00805
00806 fgets(buffer, LBUF_SIZE, fp);
00807 if(*buffer)
00808 if(buffer[strlen(buffer) - 1] == '\n')
00809 buffer[strlen(buffer) - 1] = 0;
00810
00811 m->desc = (char *) malloc(strlen(buffer) - 1);
00812 StringCopy(m->desc, buffer + 2);
00813
00814 m->maxmacros = m->nummacros;
00815 if(m->nummacros > 0) {
00816 m->alias = (char *) malloc(5 * m->maxmacros);
00817 m->string = (char **) malloc(sizeof(char *) * m->nummacros);
00818
00819 for(j = 0; j < m->nummacros; j++) {
00820 t = m->alias + j * 5;
00821 fgets(buffer, LBUF_SIZE, fp);
00822 if(buffer[strlen(buffer) - 1] == '\n')
00823 buffer[strlen(buffer) - 1] = 0;
00824 for(c = buffer; *c && *c != ' '; c++);
00825 *c = 0;
00826 if(strlen(buffer) > 4) {
00827 fprintf(stderr, "Error reading macro set #%d!\n", i);
00828 exit(1);
00829 }
00830 if(!*buffer) {
00831
00832
00833 t[0] = 0;
00834 } else
00835 strcpy(t, buffer);
00836 c++;
00837 m->string[j] = (char *) malloc(strlen(c) + 1);
00838 StringCopy(m->string[j], c);
00839 }
00840 do_sort_macro_set(m);
00841 } else {
00842 m->alias = NULL;
00843 m->string = NULL;
00844 }
00845 }
00846 while (1) {
00847 for(i = 0; i < nummacros; i++)
00848 if(!isPlayer(macros[i]->player))
00849 break;
00850 if(i >= nummacros)
00851 break;
00852 clear_macro_set(i);
00853 }
00854 }
00855
00856 void save_macros(FILE * fp)
00857 {
00858 int i, j;
00859 struct macros *m;
00860
00861 fprintf(fp, "%d\n", nummacros);
00862
00863 for(i = 0; i < nummacros; i++) {
00864 m = macros[i];
00865 fprintf(fp, "%d %d %d\n", m->player, m->nummacros, (int) m->status);
00866 fprintf(fp, "D:%s\n", m->desc);
00867 for(j = 0; j < m->nummacros; j++)
00868 fprintf(fp, "%s %s\n", m->alias + j * 5, m->string[j]);
00869 }
00870 }
