ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/loader.l
(Generate patch)

Comparing deliantra/server/common/loader.l (file contents):
Revision 1.5 by root, Mon Jun 26 21:46:04 2006 UTC vs.
Revision 1.12 by root, Mon Aug 28 07:07:41 2006 UTC

1%{ 1%{
2/* 2/*
3 * static char *rcsid_object_c = 3 * static char *rcsid_object_c =
4 * "$Id: loader.l,v 1.5 2006/06/26 21:46:04 root Exp $"; 4 * "$Id: loader.l,v 1.12 2006/08/28 07:07:41 root Exp $";
5 */ 5 */
6 6
7/* 7/*
8 CrossFire, A Multiplayer game for X-windows 8 CrossFire, A Multiplayer game for X-windows
9 9
… …
35#include <global.h> 35#include <global.h>
36#include <loader.h> 36#include <loader.h>
37#include <newserver.h> 37#include <newserver.h>
38#include <sproto.h> 38#include <sproto.h>
39 39
40#define YY_DECL int lex_load(object *op, int map_flags) 40#define YY_DECL int lex_load(object *op, object_thawer &thawer, int map_flags)
41 41
42static char *yval(); 42static char *yval();
43 43
44static int lex_error; 44static int lex_error;
45static char msgbuf[HUGE_BUF]; 45static char msgbuf[65536];
46static char lorebuf[HUGE_BUF]; 46static char lorebuf[65536];
47 47
48/* Maps the MOVE_* values to names */ 48/* Maps the MOVE_* values to names */
49static const char *const move_name[] = {"walk", "fly_low", "fly_high", "swim", "boat", 49static const char *const move_name[] = {"walk", "fly_low", "fly_high", "swim", "boat",
50 NULL}; 50 NULL};
51 51
… …
57 * If you are adding a new spell, you should not modify this - you 57 * If you are adding a new spell, you should not modify this - you
58 * new spell won't have been used, and thus won't have any legacy object. 58 * new spell won't have been used, and thus won't have any legacy object.
59 * NULL entries in this table are valid - to denote objects that should 59 * NULL entries in this table are valid - to denote objects that should
60 * not be updated for whatever reason. 60 * not be updated for whatever reason.
61 */ 61 */
62const char *const spell_mapping[] = { 62const char *spell_mapping[] = {
63"spell_magic_bullet", /* 0 */ 63"spell_magic_bullet", /* 0 */
64"spell_small_fireball", /* 1 */ 64"spell_small_fireball", /* 1 */
65"spell_medium_fireball", /* 2 */ 65"spell_medium_fireball", /* 2 */
66"spell_large_fireball", /* 3 */ 66"spell_large_fireball", /* 3 */
67"spell_burning_hands", /* 4 */ 67"spell_burning_hands", /* 4 */
… …
693^name_pl{S} { char *yv=yval(); 693^name_pl{S} { char *yv=yval();
694 694
695 if (*yv=='\0') LOG(llevError,"Name without val\n"); 695 if (*yv=='\0') LOG(llevError,"Name without val\n");
696 else FREE_AND_COPY(op->name_pl, yv); 696 else FREE_AND_COPY(op->name_pl, yv);
697 } 697 }
698^attach{S} { char *yv=yval();
699 if (*yv)
700 op->attach = add_string (yv);
701 }
698^skill{S} FREE_AND_COPY(op->skill,yval()); 702^skill{S} FREE_AND_COPY(op->skill,yval());
699^custom_name{S} { char *yv=yval(); 703^custom_name{S} { char *yv=yval();
700 704
701 if (*yv=='\0') LOG(llevError,"Custom name without val\n"); 705 if (*yv=='\0') LOG(llevError,"Custom name without val\n");
702 else FREE_AND_COPY(op->custom_name, yv); 706 else FREE_AND_COPY(op->custom_name, yv);
… …
712 */ 716 */
713 if (op->arch) { 717 if (op->arch) {
714 object *tmp; 718 object *tmp;
715 char *yv=yval(); 719 char *yv=yval();
716 720
717 tmp=get_object();
718 tmp->arch = find_archetype(yv); 721 archetype *arch = find_archetype(yv);
719 if (tmp->arch!=NULL) 722 if (arch!=NULL)
720 copy_object(&tmp->arch->clone,tmp); 723 tmp = arch_to_object (arch);
721 else { 724 else {
725 tmp = get_object ();
722 if (tmp->name) free_string(tmp->name); 726 if (tmp->name) free_string(tmp->name);
723 /* record the name of the broken object */ 727 /* record the name of the broken object */
724 tmp->name = add_string(yv); 728 tmp->name = add_string(yv);
725 } 729 }
726 strcpy(msgbuf, ""); 730 strcpy(msgbuf, "");
727 strcpy(lorebuf, ""); 731 strcpy(lorebuf, "");
728 lex_load(tmp, map_flags); 732 lex_load(tmp, thawer, map_flags);
729 if (tmp->arch) { 733 if (tmp->arch) {
730 insert_ob_in_ob(tmp,op); 734 insert_ob_in_ob(tmp,op);
731 } 735 }
732 else { 736 else {
733 LOG(llevDebug,"Discarding object without arch: %s\n", tmp->name?tmp->name:"(null)"); 737 LOG(llevDebug,"Discarding object without arch: %s\n", tmp->name?tmp->name:"(null)");
… …
737 /* This is the actual archetype definition then */ 741 /* This is the actual archetype definition then */
738 else { 742 else {
739 char *yv=yval(); 743 char *yv=yval();
740 744
741 op->arch=find_archetype(yv); 745 op->arch=find_archetype(yv);
742 if (op->arch!=NULL) copy_object(&op->arch->clone,op); 746 if (op->arch!=NULL) {
743 else if (!arch_init) { 747 copy_object(&op->arch->clone,op);
748 } else if (!arch_init) {
744 if (op->name) free_string(op->name); 749 if (op->name) free_string(op->name);
745 /* record the name of the broken object */ 750 /* record the name of the broken object */
746 op->name = add_string(yv); 751 op->name = add_string(yv);
747 } 752 }
748 } 753 }
… …
762^more{WS}$ { /* We need to record that this is a multipart object, 767^more{WS}$ { /* We need to record that this is a multipart object,
763 * so the calling function can glue things back together 768 * so the calling function can glue things back together
764 */ 769 */
765 ismore=1; 770 ismore=1;
766 } 771 }
767
768^end{WS}$ { check_loaded_object(op); 772^end{WS}$ { check_loaded_object(op);
773
774 if (!arch_init)
775 op->instantiate ();
776
769 if (ismore) return LL_MORE; 777 if (ismore) return LL_MORE;
770 else return LL_NORMAL; 778 else return LL_NORMAL;
771 } 779 }
780^oid{S} {
781 thawer.get (op, IVAL);
782 }
772^last_heal{S} op->last_heal = IVAL; 783^last_heal{S} op->last_heal = IVAL;
773^last_sp{S} op->last_sp = IVAL; 784^last_sp{S} op->last_sp = IVAL;
774^last_grace{S} op->last_grace = IVAL; 785^last_grace{S} op->last_grace = IVAL;
775^last_eat{S} op->last_eat = IVAL; 786^last_eat{S} op->last_eat = IVAL;
776^speed{S} { op->speed = FVAL; 787^speed{S} { op->speed = FVAL;
… …
984^resist_disease{S} SET_RESIST(op, ATNR_DISEASE, IVAL); 995^resist_disease{S} SET_RESIST(op, ATNR_DISEASE, IVAL);
985 996
986 /* Old style resistances */ 997 /* Old style resistances */
987^immune{S} set_protection(op, IVAL, RESIST_IMMUNE); 998^immune{S} set_protection(op, IVAL, RESIST_IMMUNE);
988^protected{S} set_protection(op, IVAL, RESIST_PROT); 999^protected{S} set_protection(op, IVAL, RESIST_PROT);
989^vulnerable{S} set_protection(op, IVAL, RESIST_VULN); 1000^vulnerable{S} set_protection(op, IVAL, (uint16) RESIST_VULN);
990 1001
991 /* old values - keep them around for now, but they should be removed at some point */ 1002 /* old values - keep them around for now, but they should be removed at some point */
992^has_ready_rod{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL); 1003^has_ready_rod{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);
993^has_ready_horn{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL); 1004^has_ready_horn{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);
994^has_ready_wand{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL); 1005^has_ready_wand{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);
… …
1033^can_impale{S} { /* That these are for the new combat code */ } 1044^can_impale{S} { /* That these are for the new combat code */ }
1034^can_cut{S} { /* just ignore for now */ } 1045^can_cut{S} { /* just ignore for now */ }
1035^can_dam_armour{S} { } 1046^can_dam_armour{S} { }
1036^weapontype{S} op->weapontype = IVAL; 1047^weapontype{S} op->weapontype = IVAL;
1037^tooltype{S} op->tooltype = IVAL; 1048^tooltype{S} op->tooltype = IVAL;
1038^casting_time{S} op->casting_time = FVAL; 1049^casting_time{S} op->casting_time = (sint16) FVAL;
1039^elevation{S} op->elevation = IVAL; 1050^elevation{S} op->elevation = IVAL;
1040^smoothlevel{S} op->smoothlevel = IVAL; 1051^smoothlevel{S} op->smoothlevel = IVAL;
1041^client_type{S} op->client_type = IVAL; 1052^client_type{S} op->client_type = IVAL;
1042^body_{A} set_body_info(op, yytext); 1053^body_{A} set_body_info(op, yytext);
1043^duration{S} op->duration = IVAL; 1054^duration{S} op->duration = IVAL;
… …
1398 * be reset. 1409 * be reset.
1399 * LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null) 1410 * LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null)
1400 * 1411 *
1401 */ 1412 */
1402 1413
1403int load_object(FILE *fp, object *op, int bufstate, int map_flags) { 1414int load_object(FILE *fp, object_thawer &thawer, object *op, int bufstate, int map_flags) {
1404 int retval; 1415 int retval;
1405 char inbuf[MAX_BUF]; 1416 char inbuf[MAX_BUF];
1406 1417
1407 strcpy(msgbuf, ""); 1418 strcpy(msgbuf, "");
1408 strcpy(lorebuf, ""); 1419 strcpy(lorebuf, "");
… …
1414 } 1425 }
1415 if (bufstate==LO_LINEMODE) { 1426 if (bufstate==LO_LINEMODE) {
1416 YY_BUFFER_STATE yybufstate; 1427 YY_BUFFER_STATE yybufstate;
1417 while (fgets(inbuf, MAX_BUF-3, fp)) { 1428 while (fgets(inbuf, MAX_BUF-3, fp)) {
1418 yybufstate=yy_scan_string(inbuf); 1429 yybufstate=yy_scan_string(inbuf);
1419 retval=lex_load(op, map_flags); 1430 retval=lex_load(op, thawer, map_flags);
1420 yy_delete_buffer(yybufstate); 1431 yy_delete_buffer(yybufstate);
1421 if (retval==LL_NORMAL) return retval; 1432 if (retval==LL_NORMAL) return retval;
1422 } 1433 }
1423 LOG(llevDebug,"Got eof while scanning strings\n"); 1434 LOG(llevDebug,"Got eof while scanning strings\n");
1424 return LL_EOF; 1435 return LL_EOF;
1425 } 1436 }
1426 1437
1427 retval=lex_load(op, map_flags); 1438 retval=lex_load(op, thawer, map_flags);
1428 if (op->current_weapon_script != NULL) 1439 if (op->current_weapon_script != NULL)
1429 { 1440 {
1430 op->current_weapon = find_best_weapon_used_match(op, op->current_weapon_script); 1441 op->current_weapon = find_best_weapon_used_match(op, op->current_weapon_script);
1431 LOG(llevDebug, "CurrentWeapon Loaded !\n"); 1442 LOG(llevDebug, "CurrentWeapon Loaded !\n");
1432 }; 1443 };
… …
1443 * override values and in c_wiz to mutate values. 1454 * override values and in c_wiz to mutate values.
1444 */ 1455 */
1445int set_variable(object *op,char *buf) { 1456int set_variable(object *op,char *buf) {
1446 YY_BUFFER_STATE yybufstate,yycurbuf=YY_CURRENT_BUFFER; 1457 YY_BUFFER_STATE yybufstate,yycurbuf=YY_CURRENT_BUFFER;
1447 int retval; 1458 int retval;
1459 object_thawer thawer;
1448 1460
1449 strcpy(msgbuf, ""); 1461 strcpy(msgbuf, "");
1450 strcpy(lorebuf, ""); 1462 strcpy(lorebuf, "");
1451 yy_push_state(INITIAL); 1463 yy_push_state(INITIAL);
1452 yybufstate=yy_scan_string(buf); 1464 yybufstate=yy_scan_string(buf);
1453 retval=lex_load(op,0); 1465 retval=lex_load(op,thawer,0);
1454 yy_switch_to_buffer(yycurbuf); 1466 yy_switch_to_buffer(yycurbuf);
1455 yy_delete_buffer(yybufstate); 1467 yy_delete_buffer(yybufstate);
1456 yy_pop_state(); 1468 yy_pop_state();
1457 return retval; 1469 return retval;
1458} 1470}
… …
1647 * NEVER touch buf between PREPARE_FASTCAT(buf) and 1659 * NEVER touch buf between PREPARE_FASTCAT(buf) and
1648 * FINISH_FASTCAT(buf) 1660 * FINISH_FASTCAT(buf)
1649 */ 1661 */
1650 static int already_run = 0; 1662 static int already_run = 0;
1651 static int flag_lens[NUM_FLAGS]; 1663 static int flag_lens[NUM_FLAGS];
1652 static char buf2[HUGE_BUF]; 1664 char buf2[4096]; // / was HUFE_BUF, which was hugely incorrect, as is this value, but much less so
1653 static char buf[HUGE_BUF]; 1665 static char buf[128*1024]; // < the assumption is that every object always fits. fixing this bug, however
1654 char* fastbuf; 1666 char* fastbuf; // \ requires a large rewrite of the code, so its left to the next total rewrite.
1655 int tmp; 1667 int tmp;
1656 int i; 1668 int i;
1657#if 0
1658/*Memory polluting code. Should help detect problems, very slow*/
1659 for (i=0;i<HUGE_BUF;i++){
1660 buf[i]='a'+(unsigned short)(i%25);
1661 }
1662#endif
1663 event *etmp; 1669 event *etmp;
1664 event *etmp2; 1670 event *etmp2;
1665 key_value * my_field; 1671 key_value * my_field;
1666 key_value * arch_field; 1672 key_value * arch_field;
1667 1673
… …
1998 get_string_move_type(op->move_slow), 2004 get_string_move_type(op->move_slow),
1999 10); 2005 10);
2000 } 2006 }
2001 2007
2002 if (op->move_slow_penalty != op2->move_slow_penalty) { 2008 if (op->move_slow_penalty != op2->move_slow_penalty) {
2003 FAST_SAVE_LONG(fastbuf,"move_slow_penalty ",op->move_slow_penalty,18); 2009 FAST_SAVE_LONG(fastbuf,"move_slow_penalty ",(long) op->move_slow_penalty,18);
2004 } 2010 }
2005 2011
2006 if (!COMPARE_FLAGS(op,op2)) { 2012 if (!COMPARE_FLAGS(op,op2)) {
2007 for (tmp=0; tmp <= NUM_FLAGS; tmp++) { 2013 for (tmp=0; tmp <= NUM_FLAGS; tmp++) {
2008 if (flag_names[tmp] && (QUERY_FLAG(op, tmp) != QUERY_FLAG(op2, tmp))) { 2014 if (flag_names[tmp] && (QUERY_FLAG(op, tmp) != QUERY_FLAG(op2, tmp))) {
… …
2031 * the only place this is not set is when saving the player. 2037 * the only place this is not set is when saving the player.
2032 * If bit 1 of flag is set, don't remove the object after save. As of now, 2038 * If bit 1 of flag is set, don't remove the object after save. As of now,
2033 * all of the callers are setting this. 2039 * all of the callers are setting this.
2034 */ 2040 */
2035 2041
2036void save_object(FILE *fp,object *op, int flag) { 2042void save_object(FILE *fp,object_freezer &freezer,object *op, int flag) {
2037 archetype *at; 2043 archetype *at;
2038 char *cp; 2044 char *cp;
2039 object *tmp,*old; 2045 object *tmp,*old;
2040 2046
2041 /* Even if the object does have an owner, it would seem that we should 2047 /* Even if the object does have an owner, it would seem that we should
… …
2059 2065
2060 old=NULL; 2066 old=NULL;
2061 2067
2062 if (flag & 2 ) 2068 if (flag & 2 )
2063 for(tmp=op->inv;tmp!=NULL;tmp=tmp->below) 2069 for(tmp=op->inv;tmp!=NULL;tmp=tmp->below)
2064 save_object(fp,tmp,flag); 2070 save_object(fp,freezer,tmp,flag);
2065 2071
2066 /* Slightly different logic because tmp/op will be removed by 2072 /* Slightly different logic because tmp/op will be removed by
2067 * the save_object we call. So we just keep looking at op->inv 2073 * the save_object we call. So we just keep looking at op->inv
2068 * until there is nothing left. In theory, the variable old 2074 * until there is nothing left. In theory, the variable old
2069 * should not be needed, as recursive loops shouldn't happen. 2075 * should not be needed, as recursive loops shouldn't happen.
… …
2071 else while ((tmp=op->inv)!=NULL) { 2077 else while ((tmp=op->inv)!=NULL) {
2072 if(old==tmp) { 2078 if(old==tmp) {
2073 LOG(llevError," Recursive loop in inventory\n"); 2079 LOG(llevError," Recursive loop in inventory\n");
2074 break; 2080 break;
2075 } 2081 }
2076 save_object(fp,tmp,flag); 2082 save_object(fp,freezer,tmp,flag);
2077 old=tmp; 2083 old=tmp;
2078 } 2084 }
2079 2085
2080 if (!(flag&2)) { 2086 if (!(flag&2)) {
2081 remove_ob(op); 2087 remove_ob(op);
2082 free_object (op); 2088 free_object (op);
2083 } 2089 }
2084 2090
2091 freezer.put (fp, op);
2085 fprintf(fp,"end\n"); 2092 fprintf(fp,"end\n");
2086} 2093}
2087 2094
2088void insert_event(object* op, int etype, char *ehook, char *eplug, char *eoptions) 2095void insert_event(object* op, int etype, char *ehook, char *eplug, char *eoptions)
2089{ 2096{

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines