#define CODEGEN_C #include <stdio.h> #include <stdlib.h> #include <time.h> #include "gen.h" #include "codegen.h" #include "cflags.h" #include "questnames.h" #include "events.h" #include "config.h" #include "exits.h" static FILE *obj_file = NULL; static FILE *mob_file = NULL; static FILE *loc_file = NULL; static FILE *zon_file = NULL; static FILE *proto_file = NULL; static Boolean has_zone_header = False; static Boolean is_first = True; /************************************************************************** ** PROTOTYPE FUNCTIONS **************************************************************************/ void gen_statements(stmt_list_record *the_stmt, FILE *the_file, hashTable *the_hash); void gen_stmt(stmt_record *the_stmt, FILE *the_file, hashTable *the_hash, Boolean print_semicolon); /************************************************************************** ** UTILITY FUNCTIONS **************************************************************************/ void compile_panic(char *str, char *fn, int linenr) { printf("\nPanic: %s (File: %s, Line: %d)\n",str,fn,linenr); exit(2); } FILE *safe_open(char *the_filename,char *the_directory,char *mode) { char temp_filename[255]; FILE *thefp; sprintf(temp_filename,"%s/%s",the_directory,the_filename); if ((thefp = fopen(temp_filename,mode)) == NULL) { printf("Could not open targetfile %s.\n",temp_filename); } return thefp; } /************************************************************************* ** ** get_cflag - ** ** Parameters: filename - the filename string to open ** ** ret - ** *************************************************************************/ int get_cflag(int the_flag) { int TokenTable[] = {T_INROOM, T_INCONTAINER, T_CARRIEDBY, T_WORNBY, T_WIELDEDBY, T_BOTHBY, T_LAST}; int CflagTable[] = {IN_ROOM, IN_CONTAINER, CARRIED_BY, WORN_BY, WIELDED_BY, BOTH_BY, T_LAST}; int i; for (i=0; TokenTable[i] != T_LAST; i++) { if (TokenTable[i] == the_flag) return CflagTable[i]; } return -1; } /************************************************************************* ** ** get_quest - ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ int get_quest(char *the_quest) { int i = 0; fflush(stdout); for (i = 0; Quests[i] != TABLE_END; i++) { if (!strcasecmp(the_quest, Quests[i])) return i; } return -1; } /************************************************************************** ** ** convert_item - ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** **************************************************************************/ char *convert_item(hashTable *the_hash, char *the_item, char *thezone, char *the_type) { char *nextchar; char *tmp_char; int num_amper = 0; char holder[(MAXNAMLEN*2)+5]; Boolean has_carrot = False; nextchar = the_item; while (*nextchar != '\0') { if (*nextchar == '@') { num_amper++; } if (*nextchar == '^') has_carrot = True; nextchar++; } if (has_carrot) { nextchar = the_item; while (*nextchar != '^') { nextchar++; } tmp_char = nextchar+1; while (*tmp_char != '\0') { *nextchar = *tmp_char; nextchar++; tmp_char++; } *nextchar = '\0'; the_type = "obj"; } if (num_amper == 0) { sprintf(holder, "%s@%s@%s", the_type, thezone, the_item); strcpy(the_item, holder); } else if (num_amper == 1) { char tempstr[120]; char *nameptr = tempstr; char *zoneptr; strcpy(tempstr,the_item); zoneptr = index(tempstr,'@'); if (zoneptr == NULL) panicError("Cannot convert location properly, no ampersand found\n"); *zoneptr = '\0'; zoneptr++; sprintf(holder, "%s@%s@%s", the_type, zoneptr, nameptr); strcpy(the_item, holder); } lowercase(the_item); return the_item; } /************************************************************************** ** MUDCODE GENERATION FUNCTIONS *************************************************************************/ /************************************************************************** ** ** gen_zon_header ** ** Parameters: thezone - zone to create a header file for. ** *************************************************************************/ void gen_zon_header(zone_record *thezone) { char upzonename[FILENAMESIZE]; char filename[MAXNAMLEN]; time_t t = time(0); if (zon_file == NULL) { sprintf(filename, "%s.h", thezone->zonefile); if ((zon_file = safe_open(filename, request_char_value("GLOBALS_DIR"),"w")) == NULL) { printf("Warning: could not open code file %s\n",filename); return; } strcpy(upzonename,thezone->zonefile); (void)uppercase(upzonename); fprintf(zon_file, "/***********************************************************************\n" " ** ZONE: %s\n" " ** Automatically created header file. Do not change things here, it will\n" " ** go away. The Original code can be found in %s.area\n" " ** last update: %s" " **********************************************************************/\n" "#ifndef ZON_%s_H_\n" "#define ZON_%s_H_\n" "\n\n", thezone->zonefile, thezone->zonefile, ctime(&t),upzonename,upzonename); } } /************************************************************************** ** ** gen_loc_mudcode ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_loc_header(zone_record *thezone) { char filename[MAXNAMLEN]; time_t t = time(0); if (loc_file == NULL) { sprintf(filename, "%s.c", thezone->zonefile); if ((loc_file = safe_open(filename, request_char_value("LOCATIONS_DIR"),"w")) == NULL) { printf("Warning: could not open code file %s\n",filename); return; } fprintf(loc_file, "/***********************************************************************\n" " ** ZONE: %s\n" " ** Automatically created code file. Do not change things here, it will\n" " ** go away. The Original code can be found in %s.area\n" " ** last update: %s" " **********************************************************************/\n" "\n\n", thezone->zonefile, thezone->zonefile, ctime(&t)); if (has_zone_header) fprintf(loc_file,"#include \"../Globals/%s.h\"\n\n",thezone->zonefile); } } /************************************************************************** ** ** gen_obj_mudcode ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_obj_header(zone_record *thezone) { char filename[MAXNAMLEN]; time_t t = time(0); if (obj_file == NULL) { sprintf(filename, "%s.c", thezone->zonefile); if ((obj_file = safe_open(filename, request_char_value("OBJECTS_DIR"), "w")) == NULL) { printf("Warning: could not open code file %s\n",filename); return; } fprintf(obj_file, "/***********************************************************************\n" " ** ZONE: %s\n" " ** Automatically created code file. Do not change things here, it will\n" " ** go away. The Original code can be found in %s.area\n" " ** last update: %s" " **********************************************************************/\n" "\n\n", thezone->zonefile, thezone->zonefile, ctime(&t)); if (has_zone_header) fprintf(obj_file,"#include \"../Globals/%s.h\"\n\n",thezone->zonefile); } } /************************************************************************** ** ** gen_mob_mudcode ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_mob_header(zone_record *thezone) { char filename[MAXNAMLEN]; time_t t = time(0); if (mob_file == NULL) { sprintf(filename, "%s.c", thezone->zonefile); if ((mob_file = safe_open(filename, request_char_value("NPC_DIR"), "w")) == NULL) { printf("Warning: Could not open codefile: %s\n",filename); return; } fprintf(mob_file, "/***********************************************************************\n" " ** ZONE: %s\n" " ** Automatically created code file. Do not change things here, it will\n" " ** go away. The Original code can be found in %s.area\n" " ** last update: %s" " **********************************************************************/\n" "\n\n", thezone->zonefile, thezone->zonefile, ctime(&t)); if (has_zone_header) fprintf(mob_file,"#include \"../Globals/%s.h\"\n\n",thezone->zonefile); } } /************************************************************************** ** ** xgen_identifiers ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void xgen_identifiers(stmt_list_record *the_stmt, FILE *the_file) { stmt_list_record *tmp_stmt; var_decl *tmp_var; const_decl *tmp_const; tmp_stmt = the_stmt; /* Marty: had to add the tmp_stmt here, dunno anything about * this part though :/ */ while (tmp_stmt != NULL && ((tmp_stmt->the_statement->stmt_type == STMT_VAR_DECL) || (tmp_stmt->the_statement->stmt_type == STMT_CONST_DECL))) { if (tmp_stmt->the_statement->stmt_type == STMT_VAR_DECL) { tmp_var = tmp_stmt->the_statement->stmt.var_d; while (tmp_var != NULL) { if (tmp_var->var_type == T_STR) { fprintf(the_file, " char %s[%d];\n", tmp_var->var_name, tmp_var->str_len); } else if (tmp_var->var_type == T_BOOL) { fprintf(the_file, " Boolean %s;\n", tmp_var->var_name); } else if (tmp_var->var_type == T_NUMBER) { fprintf(the_file, " int %s;\n", tmp_var->var_name); } else printf("blah\n"); tmp_var = tmp_var->more_var; } } else if (tmp_stmt->the_statement->stmt_type == STMT_CONST_DECL) { tmp_const = tmp_stmt->the_statement->stmt.const_d; if (tmp_const->const_type == T_STR) { fprintf(the_file, " const char %s = \"%s\";\n", tmp_const->const_name, tmp_const->assign); } else if (tmp_const->const_type == T_NUMBER) { fprintf(the_file, " const int %s = %s;\n", tmp_const->const_name, tmp_const->assign); } else printf("blah2\n"); } tmp_stmt = tmp_stmt->more_statements; } } /************************************************************************** ** ** gen_identifiers ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_identifiers(trap_record *the_trap, FILE *the_file) { trap_record *tmp_trap; tmp_trap = the_trap; while (tmp_trap != NULL) { xgen_identifiers(tmp_trap->the_statements, the_file); tmp_trap = tmp_trap->more_traps; } } /************************************************************************** ** ** gen_assignmt ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_assignmt(assignmt *the_stmt, FILE *the_file, hashTable *the_hash) { arith_number *tmp_num; arith_string *tmp_arith_str; string_record *tmp_str; if (the_stmt->the_stmt->stmt_type == STMT_ARITH_NUM) { fprintf(the_file, "\t%s = ", the_stmt->var_name); tmp_num = the_stmt->the_stmt->stmt.arith_num_d; while (tmp_num != NULL) { fprintf(the_file, "%s", tmp_num->arith_str); if (tmp_num->numberfunct != NULL) gen_stmt(tmp_num->numberfunct, the_file, the_hash, False); tmp_num = tmp_num->next_number; } fprintf(the_file, ";\n"); return; } else if (the_stmt->the_stmt->stmt_type == STMT_ARITH_STR) { tmp_arith_str = the_stmt->the_stmt->stmt.arith_str_d; fprintf(the_file, "\t%s[0] = '\\0';\n", the_stmt->var_name); while (tmp_arith_str != NULL) { fprintf(the_file, "\tstrcat(%s, ", the_stmt->var_name); if (tmp_arith_str->stringfunct1 != NULL) gen_stmt(tmp_arith_str->stringfunct1, the_file, the_hash, False); else { tmp_str = tmp_arith_str->string1; while (tmp_str != NULL) { fprintf(the_file, "\"%s\"", tmp_str->the_string); if (tmp_str->nextstr != NULL) fprintf(the_file, "\n"); tmp_str = tmp_str->nextstr; } } fprintf(the_file, ");\n"); if (tmp_arith_str->string2 != NULL) tmp_arith_str = tmp_arith_str->string2->stmt.arith_str_d; else tmp_arith_str = NULL; } } else { printf("ERROR!!!!! Unexpected assignment after =!!!\n"); return; } } /************************************************************************** ** ** gen_ident ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_ident(ident_decl *the_stmt, FILE *the_file, hashTable *the_hash) { int i; Boolean has_amper = False; char holder[TOKENSTRLEN]; /* see if it has an amperstand, meaning it would be an identifier of type <TYPE>_<ZONE>_<ITEMNAME> */ for (i=0; i < strlen(the_stmt->the_ident); i++) { if (the_stmt->the_ident[i] == '@') has_amper = True; } /* if it has an amperstand, convert it to proper form */ if (has_amper) { for (i=0; i < strlen(the_stmt->the_ident); i++) { if (the_stmt->the_ident[i] == '@') holder[i] = '_'; else holder[i] = toupper(the_stmt->the_ident[i]); } holder[i] = '\0'; /* Add a + max_players when we're dealing with a mobile id */ if (strncmp(the_stmt->the_ident,"mob",3) == 0) fprintf(the_file, "(%s + max_players)", holder); else fprintf(the_file, "%s", holder); } /* else just display it */ else { lowercase(the_stmt->the_ident); fprintf(the_file, "%s", the_stmt->the_ident); } } /************************************************************************** ** ** gen_bool_exp ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_bool_exp(bool_stmt *the_stmt, FILE *the_file, hashTable *the_hash) { bool_stmt *tmp_bool; tmp_bool = the_stmt; while (tmp_bool != NULL) { fprintf(the_file, "%s", tmp_bool->bool_string); if (tmp_bool->the_stmt != NULL) gen_stmt(tmp_bool->the_stmt, the_file, the_hash, False); tmp_bool = tmp_bool->next_bool; } return; } /************************************************************************** ** ** gen_mud_defined ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_mud_defined(mudfunct_decl *the_stmt, FILE *the_file, hashTable *the_hash, Boolean print_semicolon) { thecode_record *template; /* reads the template for the code */ string_record *tmp_str; /* used to read all strings in the linked list */ mudfunct_param *param; param_record *param_finder; Boolean has_amper = False; char holder[TOKENSTRLEN]; int i; template = the_stmt->the_funct->the_code; fprintf(the_file, "\t"); /* follow the template, printing out the appropriate code for each block */ while (template->next_code != NULL) { /* print out the raw code from the template */ tmp_str = template->code_str; while (tmp_str->nextstr != NULL) { fprintf(the_file, "%s\n", tmp_str->the_string); tmp_str = tmp_str->nextstr; } fprintf(the_file, "%s", tmp_str->the_string); /* print out the user entered parameters */ if (template->param_type != -1) { param_finder = the_stmt->the_funct->parameters; param = the_stmt->parameters; while (!((param_finder->param_type == template->param_type) && (param_finder->param_num == template->param_num))) { param_finder = param_finder->next_param; param = param->more_param; if ((param_finder == NULL) || (param == NULL)) { printf("Error in compiler code found! Statement not generated correctly\n" "because parameter not found. Please inform Slate or Marty about\n" "this.\n"); return; } } /* if the parameter is a function, print that out */ if (param->funct_param != NULL) { gen_stmt(param->funct_param, the_file, the_hash, False); } /* else it is a string or an identifier */ else { /* see if it has an amperstand, meaning it would be an identifier of type <TYPE>_<ZONE>_<ITEMNAME> */ for (i=0; i < strlen(param->the_param->the_string); i++) { if (param->the_param->the_string[i] == '@') has_amper = True; } /* if it has an amperstand, convert it to proper form */ if (has_amper) { for (i=0; i < strlen(param->the_param->the_string); i++) { if (param->the_param->the_string[i] == '@') holder[i] = '_'; else holder[i] = toupper(param->the_param->the_string[i]); } fprintf(the_file, "%s", holder); } /* else just display it */ else { tmp_str = param->the_param; while (tmp_str->nextstr != NULL) { if (param->has_quotes) fprintf(the_file, "\""); fprintf(the_file, "%s", tmp_str->the_string); if (param->has_quotes) fprintf(the_file, "\"\n"); else fprintf(the_file, "\n"); tmp_str = tmp_str->nextstr; } if (param->has_quotes) fprintf(the_file, "\""); fprintf(the_file, "%s", tmp_str->the_string); if (param->has_quotes) fprintf(the_file, "\""); } } } template = template->next_code; } tmp_str = template->code_str; while (tmp_str->nextstr != NULL) { fprintf(the_file, "%s\n", tmp_str->the_string); tmp_str = tmp_str->nextstr; } fprintf(the_file, "%s", tmp_str->the_string); if (print_semicolon) fprintf(the_file, ";\n"); } /************************************************************************** ** ** gen_raw ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_raw(raw_decl *the_stmt, FILE *the_file) { string_record *tmp_str; tmp_str = the_stmt->the_code; while (tmp_str != NULL) { fprintf(the_file, "\t%s\n", tmp_str->the_string); tmp_str = tmp_str->nextstr; } /*fprintf(the_file,"\tbreak;\n");*/ } /************************************************************************** ** ** gen_block ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_block(block_decl *the_stmt, FILE *the_file, hashTable *the_hash) { fprintf(the_file, "\t{\n"); gen_statements(the_stmt->block_statements, the_file, the_hash); fprintf(the_file, "\t}\n"); return; } /************************************************************************** ** ** gen_if ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_if(if_decl *the_stmt, FILE *the_file, hashTable *the_hash) { fprintf(the_file, "\tif ("); gen_bool_exp(the_stmt->bool_exp, the_file, the_hash); fprintf(the_file, ")"); fprintf(the_file, "\n\t{\n"); gen_statements(the_stmt->if_statements, the_file, the_hash); fprintf(the_file, "\t}\n"); if (the_stmt->else_statements != NULL) { fprintf(the_file, "\telse\n\t{\n"); gen_statements(the_stmt->else_statements, the_file, the_hash); fprintf(the_file, "\t}\n"); } return; } /************************************************************************** ** ** gen_repeat ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_repeat(while_decl *the_stmt, FILE *the_file, hashTable *the_hash) { fprintf(the_file, "\tdo\n\t{\n"); gen_statements(the_stmt->while_statements, the_file, the_hash); fprintf(the_file, "\t}\n\twhile ("); gen_bool_exp(the_stmt->bool_exp, the_file, the_hash); fprintf(the_file, ");\n"); return; } /************************************************************************** ** ** gen_while ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_while(while_decl *the_stmt, FILE *the_file, hashTable *the_hash) { fprintf(the_file, "\twhile ("); gen_bool_exp(the_stmt->bool_exp, the_file, the_hash); fprintf(the_file, ")\n\t{\n"); gen_statements(the_stmt->while_statements, the_file, the_hash); fprintf(the_file, "\t}\n"); return; } /************************************************************************** ** ** gen_for ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_for(for_decl *the_stmt, FILE *the_file, hashTable *the_hash) { fprintf(the_file, "\t{\n" "\tint gti;\n" "\tfor(gti = %d; gti <= %d; gti++)\n" "\t{\n", the_stmt->from, the_stmt->to); gen_statements(the_stmt->for_statements, the_file, the_hash); fprintf(the_file, "\t}\n" "\t}\n"); } /************************************************************************** ** ** gen_stmt ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_stmt(stmt_record *the_stmt, FILE *the_file, hashTable *the_hash, Boolean print_semicolon) { switch(the_stmt->stmt_type) { case STMT_VAR_DECL: case STMT_CONST_DECL: break; case STMT_FOR_LOOP: gen_for(the_stmt->stmt.for_d, the_file, the_hash); break; case STMT_WHILE_LOOP: gen_while(the_stmt->stmt.while_d, the_file, the_hash); break; case STMT_REPEAT_UNTIL: gen_repeat(the_stmt->stmt.while_d, the_file, the_hash); break; case STMT_IF_THEN: gen_if(the_stmt->stmt.if_d, the_file, the_hash); break; case STMT_BLOCK: gen_block(the_stmt->stmt.block_d, the_file, the_hash); break; case STMT_RAW_CODE: gen_raw(the_stmt->stmt.raw_d, the_file); break; case STMT_MUD_DEFINED: gen_mud_defined(the_stmt->stmt.mudfunct_d, the_file, the_hash, print_semicolon); break; case STMT_ARITH_STR: case STMT_ARITH_NUM: break; case STMT_IDENT: gen_ident(the_stmt->stmt.ident_d, the_file, the_hash); break; case STMT_ASSIGNMT: gen_assignmt(the_stmt->stmt.assignmt_d, the_file, the_hash); break; default: printf("Unexpected function found!\n"); break; } } /************************************************************************** ** ** gen_statements ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_statements(stmt_list_record *the_stmt, FILE *the_file, hashTable *the_hash) { stmt_list_record *tmp_stmt; tmp_stmt = the_stmt; if (is_first) is_first = False; else xgen_identifiers(the_stmt, the_file); while (tmp_stmt != NULL) { if (tmp_stmt->the_statement == NULL) printf("ERROR, found empty statement structure.\n"); gen_stmt(tmp_stmt->the_statement, the_file, the_hash, True); tmp_stmt = tmp_stmt->more_statements; } } /************************************************************************** ** ** gen_mudcode ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void gen_mudcode(trap_record *the_trap, FILE *data_file, char *type, zone_record *thezone, char *itemname, FILE *the_file, hashTable *the_hash) { char the_item[(MAXNAMLEN*2)+5]; char *lower_item; trap_record *tmp_trap; trap_desc *tmp_verbs; Boolean preceed_else = False; Boolean needs_if = True; sprintf(the_item, "%s_%s_%s", type, thezone->zonefile, itemname); lower_item = xlowercase(the_item, (MAXNAMLEN*2)+5); fprintf(data_file, " { %s, %s},\n", uppercase(the_item), lower_item); fprintf(the_file, "EVENT_HANDLER(%s)\n" "{\n", lower_item); fprintf(proto_file,"EVENT_HANDLER(%s);\n",lower_item); tmp_trap = the_trap; gen_identifiers(tmp_trap, the_file); xfree(lower_item,REC_CHAR); while (tmp_trap != NULL) { tmp_verbs = tmp_trap->trap_verb; while (tmp_verbs != NULL) { if (needs_if) fprintf(the_file," %s if (",preceed_else ? "else" : ""); fprintf(the_file, "%s(%s) ", needs_if? "" : "||\n ", find_event_check(tmp_verbs->trap_verb)); preceed_else = True; needs_if = False; tmp_verbs = tmp_verbs->next_desc; } fprintf(the_file,")\n {\n"); if (tmp_trap->the_statements == NULL) { if (tmp_trap->trap_verb->trap_location != '\0') { /* We are dealing with an external definition */ char extern_funcname[120]; char *extern_item; char *extern_zone; extern_item = tmp_trap->trap_verb->trap_location; extern_zone = index(extern_item,'@'); if (extern_zone == NULL) extern_zone = thezone->zonefile; else { *extern_zone = '\0'; extern_zone++; } /* Now we know where the original trap is, so we add a function * call to the code. */ sprintf(extern_funcname,"%s_%s_%s",type,extern_zone,extern_item); fprintf(the_file,"\t /* Trap uses external event in %s@%s */\n" "\t %s(event);\n", extern_item,extern_zone,lowercase(extern_funcname)); } else printf("Warning: trap %s defined for %s@%s, but no code found.\n", find_event_name(tmp_trap->trap_verb->trap_verb),itemname, thezone->zonename); } else { is_first = True; gen_statements(tmp_trap->the_statements, the_file, the_hash); } tmp_trap = tmp_trap->more_traps; needs_if = True; fprintf(the_file," }\n"); } fprintf(the_file,"}\n\n"); } /************************************************************************** ** GENERATION FUNCTIONS *************************************************************************/ /************************************************************************** ** ** print_loc ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ void print_loc(hashTable *the_hash, char *the_dir, zone_record *thezone, FILE *data_file) { hashRecord *this_hash; if (the_dir != NULL) { if (*the_dir == '#') { fprintf(data_file, " %d", atoi(the_dir+1)); } else { this_hash = findHashRecord(convert_item(the_hash, the_dir, thezone->zonefile, "loc"), the_hash); if (this_hash == NULL) { printf("Error looking up %s\n", convert_item(the_hash, the_dir, thezone->zonefile, "loc")); panicError("Code generation failed due to a lookup error.\n"); } if (this_hash->idnumber >= 0) fprintf(data_file, " %ld ", this_hash->idnumber + DOOR); else fprintf(data_file, " %ld ", this_hash->idnumber); } } else fprintf(data_file, " 0 "); } /************************************************************************** ** ** gen_zone_include ** ** Creates the zone header file ***************************************************************************/ int gen_zone_include(hashTable *the_hash, zone_record *thezone) { if (thezone->code != NULL) { if (zon_file == NULL) { gen_zon_header(thezone); } gen_statements(thezone->code,zon_file,the_hash); fprintf(zon_file,"#endif\n"); if (zon_file) fclose(zon_file); has_zone_header = True; zon_file = NULL; } return 1; } /************************************************************************** ** ** gen_locations ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ int gen_locations(hashTable *the_hash, zone_record *thezone, FILE *def_file, FILE *data_file, FILE *code_incl, FILE *code_tabl, FILE *zones_data, int zonenum) { location_record *tmp_loc; location_record *find_last; char hash_str[(MAXNAMLEN*2)+5]; hashRecord *this_hash; long last_num; Boolean first = True; Boolean first_line = True; Boolean needs_include = True; string_record *tmp_str; tmp_loc = thezone->location_data; fprintf(def_file,"/* ZONE: %s\n */\n",thezone->zonefile); /* loop through getting the last location number */ find_last = tmp_loc; while (find_last != NULL) { sprintf(hash_str, "loc@%s@%s", thezone->zonefile, find_last->name); lowercase(hash_str); this_hash = findHashRecord(hash_str, the_hash); if (this_hash == NULL) { printf("Error looking up %s\n",hash_str); panicError("Code generation failed due to a lookup error.\n"); exit(2); } last_num = this_hash->idnumber; find_last = find_last->next_loc; } /* loop through all locations, writing data */ while (tmp_loc != NULL) { /* get this hash record */ sprintf(hash_str, "loc@%s@%s", thezone->zonefile, tmp_loc->name); lowercase(hash_str); this_hash = findHashRecord(hash_str, the_hash); if (this_hash == NULL) { printf("Error looking up %s\n",hash_str); panicError("Code generation failed due to a lookup error.\n"); } /* write locmin and locmax info to the define file */ if (first) { fprintf(zones_data, "%s %ld\n", thezone->zonefile, -(this_hash->idnumber)-1); strcpy(hash_str, thezone->zonefile); uppercase(hash_str); fprintf(def_file, "#define LOCMIN_%s %ld\n", hash_str, (this_hash->idnumber+1)); fprintf(def_file, "#define LOCMAX_%s %ld\n", hash_str, last_num); first = False; } /* write this info to the define file */ sprintf(hash_str, "loc_%s_%s", thezone->zonefile, tmp_loc->name); uppercase(hash_str); fprintf(def_file, "#define %s %ld\n", hash_str, this_hash->idnumber); /* write the location data to the data file */ fprintf(data_file, "%ld %d", this_hash->idnumber, zonenum); print_loc(the_hash, tmp_loc->north, thezone, data_file); print_loc(the_hash, tmp_loc->east, thezone, data_file); print_loc(the_hash, tmp_loc->south, thezone, data_file); print_loc(the_hash, tmp_loc->west, thezone, data_file); print_loc(the_hash, tmp_loc->up, thezone, data_file); print_loc(the_hash, tmp_loc->down, thezone, data_file); print_loc(the_hash, tmp_loc->northeast, thezone, data_file); print_loc(the_hash, tmp_loc->northwest, thezone, data_file); print_loc(the_hash, tmp_loc->southeast, thezone, data_file); print_loc(the_hash, tmp_loc->southwest, thezone, data_file); fprintf(data_file, "\n0x%08lx:0x%08lx:0x%08lx\n" "%s^\n", tmp_loc->lflags.b1, tmp_loc->lflags.b2, tmp_loc->lflags.b3, tmp_loc->title); tmp_str = tmp_loc->desc; first_line = True; while (tmp_str != NULL && strlen(tmp_str->the_string) == 0) tmp_str = tmp_str->nextstr; while (tmp_str != NULL) { if (tmp_str->the_string[0] == '\n' && first_line) fprintf(data_file, "%s\n", tmp_str->the_string+1); else fprintf(data_file, "%s\n", tmp_str->the_string); tmp_str = tmp_str->nextstr; first_line = False; } fprintf(data_file, "^\n"); if (tmp_loc->loc_code != NULL) { if (loc_file == NULL) { if (needs_include) { fprintf(code_incl, "#include \"%s.c\"\n", thezone->zonefile); needs_include = False; } gen_loc_header(thezone); } gen_mudcode(tmp_loc->loc_code, code_tabl, "loc", thezone, tmp_loc->name, loc_file, the_hash); } /* get new location */ tmp_loc = tmp_loc->next_loc; } if (loc_file) fclose(loc_file); loc_file = NULL; return 1; } /************************************************************************** ** ** gen_objects ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone data stored in it or ** attached to it ** *************************************************************************/ int gen_objects(hashTable *the_hash, zone_record *thezone, FILE *def_file, FILE *data_file, FILE *code_incl, FILE *code_tabl, int zonenum) { object_record *tmp_obj; hashRecord *this_hash; char hash_str[(MAXNAMLEN*2)+5]; string_record *tmp_str; int i; char *type; Boolean needs_include = True; tmp_obj = thezone->object_data; fprintf(def_file,"/* ZONE: %s\n */\n",thezone->zonefile); while (tmp_obj != NULL) { /* get the hash record */ sprintf(hash_str, "obj@%s@%s", thezone->zonefile, tmp_obj->oname); lowercase(hash_str); this_hash = findHashRecord(hash_str, the_hash); if (this_hash == NULL) { printf("Error looking up %s\n",hash_str); panicError("Code generation failed due to a lookup error.\n"); } /* write this data to the define file */ sprintf(hash_str, "obj_%s_%s", thezone->zonefile, tmp_obj->oname); uppercase(hash_str); fprintf(def_file, "#define %s %ld\n", hash_str, this_hash->idnumber); /* write this data to the data file */ fprintf(data_file, "%s %s %d %ld %ld ", (tmp_obj->name == NULL) ? tmp_obj->oname : tmp_obj->name, (tmp_obj->altname == NULL) ? "<null>" : tmp_obj->altname, zonenum, this_hash->idnumber, this_hash->idnumber); if (tmp_obj->linked != NULL) { this_hash = findHashRecord(convert_item(the_hash, tmp_obj->linked, thezone->zonefile, "obj"), the_hash); fprintf(data_file, "%ld ", this_hash->idnumber); } else fprintf(data_file, "-1 "); fprintf(data_file, "%d %d ", tmp_obj->vis, get_cflag(tmp_obj->location->loc_type)); if (tmp_obj->location->loc_type == T_INROOM) type = "loc"; else if (tmp_obj->location->loc_type == T_INCONTAINER) type = "obj"; else type = "mob"; this_hash = findHashRecord(convert_item(the_hash, tmp_obj->location->the_loc, thezone->zonefile, type), the_hash); if (this_hash == NULL) { printf("Error looking up %s\n",convert_item(the_hash, tmp_obj->location->the_loc, thezone->zonefile, type)); panicError("Code generation failed due to a lookup error.\n"); } fprintf(data_file, "%ld ", this_hash->idnumber); fprintf(data_file, "%d %d %d %d %d %d %d\n" "0x%08lx:0x%08lx:0x%08lx", tmp_obj->state, tmp_obj->damage, tmp_obj->armor, tmp_obj->maxstate, tmp_obj->basevalue, tmp_obj->size, tmp_obj->weight, tmp_obj->oflags.b1, tmp_obj->oflags.b2, tmp_obj->oflags.b3); for (i=0; i<4; i++) { tmp_str = tmp_obj->desc[i]; while (tmp_str != NULL && strlen(tmp_str->the_string) == 0) tmp_str = tmp_str->nextstr; if (tmp_str == NULL) fprintf(data_file, "\n"); while (tmp_str != NULL) { fprintf(data_file, "\n"); fprintf(data_file, "%s", tmp_str->the_string); tmp_str = tmp_str->nextstr; } fprintf(data_file, "^"); } fprintf(data_file, "\n"); tmp_str = tmp_obj->examine; while (tmp_str != NULL && strlen(tmp_str->the_string) == 0) tmp_str = tmp_str->nextstr; while (tmp_str != NULL) { fprintf(data_file, "%s\n", tmp_str->the_string); tmp_str = tmp_str->nextstr; } fprintf(data_file, "^\n\n"); if (tmp_obj->obj_code != NULL) { if (obj_file == NULL) { if (needs_include) { fprintf(code_incl, "#include \"%s.c\"\n", thezone->zonefile); needs_include = False; } gen_obj_header(thezone); } gen_mudcode(tmp_obj->obj_code, code_tabl, "obj", thezone, tmp_obj->oname, obj_file, the_hash); } /* go to next object */ tmp_obj = tmp_obj->next_obj; } if (obj_file) fclose(obj_file); obj_file = NULL; return 1; } /************************************************************************** ** ** gen_mobiles ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all ** *************************************************************************/ int gen_mobiles(hashTable *the_hash, zone_record *thezone, FILE *def_file, FILE *data_file, FILE *code_incl, FILE *code_tabl, int zonenum) { mobile_record *tmp_mob; hashRecord *this_hash; char hash_str[(MAXNAMLEN*2)+5]; string_record *tmp_str; Boolean needs_include = True; tmp_mob = thezone->mobile_data; fprintf(def_file,"/* ZONE: %s\n */\n",thezone->zonefile); while (tmp_mob != NULL) { /* get this hash record */ sprintf(hash_str, "mob@%s@%s", thezone->zonefile, tmp_mob->mname); lowercase(hash_str); this_hash = findHashRecord(hash_str, the_hash); if (this_hash == NULL) { printf("Error looking up %s\n",hash_str); panicError("Code generation failed due to a lookup error.\n"); } /* write this info to the define file */ sprintf(hash_str, "mob_%s_%s", thezone->zonefile, tmp_mob->mname); uppercase(hash_str); fprintf(def_file, "#define %s %ld\n", hash_str, this_hash->idnumber); tmp_mob->mname[0] = toupper(tmp_mob->mname[0]); /* record mobile data in datafile */ fprintf(data_file, "%s^\n" "%ld %ld %d ", (tmp_mob->name == NULL) ? tmp_mob->mname : tmp_mob->name, this_hash->idnumber, this_hash->idnumber, zonenum); tmp_mob->mname[0] = tolower(tmp_mob->mname[0]); this_hash = findHashRecord(convert_item(the_hash, tmp_mob->location->the_loc, thezone->zonefile, "loc"), the_hash); fprintf(data_file, "%ld ", this_hash->idnumber); fprintf(data_file, "%d %d %d %d %d %d %d\n" "0x%08lx:0x%08lx:0x%08lx 0x%08lx:0x%08lx:0x%08lx\n" "0x%08lx:0x%08lx\n", tmp_mob->strength, tmp_mob->damage, tmp_mob->aggr, tmp_mob->armor, tmp_mob->speed, tmp_mob->vis, tmp_mob->wimpy, tmp_mob->sflags.b1, tmp_mob->sflags.b2, tmp_mob->sflags.b3, tmp_mob->pflags.b1, tmp_mob->pflags.b2, tmp_mob->pflags.b3, tmp_mob->mflags.h, tmp_mob->mflags.l); tmp_str = tmp_mob->desc; while (tmp_str != NULL && strlen(tmp_str->the_string) == 0) tmp_str = tmp_str->nextstr; while (tmp_str != NULL) { fprintf(data_file, "%s%s", tmp_str->the_string, tmp_str->nextstr == NULL ? "" : "\n"); tmp_str = tmp_str->nextstr; } fprintf(data_file, "^\n"); tmp_str = tmp_mob->examine; while (tmp_str != NULL) { fprintf(data_file, "%s\n", tmp_str->the_string); tmp_str = tmp_str->nextstr; } fprintf(data_file, "^\n\n"); if (tmp_mob->mob_code != NULL) { if (mob_file == NULL) { if (needs_include) { fprintf(code_incl, "#include \"%s.c\"\n", thezone->zonefile); needs_include = False; } gen_mob_header(thezone); } gen_mudcode(tmp_mob->mob_code, code_tabl, "mob", thezone, tmp_mob->mname, mob_file, the_hash); } /* get the next mobile record */ tmp_mob = tmp_mob->next_mob; } if (mob_file != NULL) { fclose(mob_file); mob_file = NULL; } return 1; } /************************************************************************** ** MAIN CODE GENERATION FUNCTION *************************************************************************/ /************************************************************************* ** ** gen_code ** ** Parameters: filename - the filename string to open ** ** ret - returns a zone record with all zone datd to it ** *************************************************************************/ int gen_code(hashTable *the_hash, zone_record *thezone) { FILE *loc_def = NULL; /* locations.h define file */ FILE *obj_def = NULL; /* objects.h define file */ FILE *mob_def = NULL; /* mobiles.h define file */ FILE *zones_data = NULL; /* zones data file */ FILE *loc_data = NULL; /* locations data file */ FILE *obj_data = NULL; /* locations data file */ FILE *mob_data = NULL; /* locations data file */ FILE *quest_data = NULL; /* quest data file */ FILE *author_data = NULL; /* gets data about the author */ FILE *mob_code_incl = NULL; /* mobile include file */ FILE *obj_code_incl = NULL; /* object include file */ FILE *loc_code_incl = NULL; /* location include file */ FILE *mob_code_tabl = NULL; /* Mobile function table file */ FILE *obj_code_tabl = NULL; /* Object function table file */ FILE *loc_code_tabl = NULL; /* Locations function table file */ char *INCLUDE_DIR = request_char_value("INCLUDE_DIR"); char *NPC_DIR = request_char_value("NPC_DIR"); char *OBJECTS_DIR = request_char_value("OBJECTS_DIR"); char *LOCATIONS_DIR= request_char_value("LOCATIONS_DIR"); char *DATABASE_DIR = request_char_value("DATA_DIR"); int zone_num = 0; int the_quest; time_t t = time(0); zone_record *tmp_zone; /* used to loop through zone records */ /* open all the files for writing to */ if ((loc_def = safe_open("locations.h", INCLUDE_DIR, "w")) == NULL) { printf("Error opening locations.h for write. " "Terminating code generation.\n"); return -1; } if ((obj_def = safe_open("objects.h", INCLUDE_DIR, "w")) == NULL) { printf("Error opening objects.h for write. " "Terminating code generation.\n"); return -1; } if ((mob_def = safe_open("mobiles.h", INCLUDE_DIR, "w")) == NULL) { printf("Error opening mobiles.h for write. " "Terminating code generation.\n"); return -1; } if ((zones_data = safe_open("zones", DATABASE_DIR, "w")) == NULL) { printf("Error opening data file zones for write. \n" "Terminating code generation.\n"); return -1; } if ((loc_data = safe_open("locations", DATABASE_DIR, "w")) == NULL) { printf("Error opening data file locations for write. \n" "Terminating code generation.\n"); return -1; } if ((obj_data = safe_open("objects", DATABASE_DIR, "w")) == NULL) { printf("Error opening data file locations for write. \n" "Terminating code generation.\n"); return -1; } if ((mob_data = safe_open("mobiles", DATABASE_DIR, "w")) == NULL) { printf("Error opening data file locations for write. \n" "Terminating code generation.\n"); return -1; } if ((quest_data = safe_open("zonetab.h",INCLUDE_DIR, "w")) == NULL) { printf("Error opening data file zonetab.h for write. \n" "Terminating code generation.\n"); return -1; } if ((author_data = safe_open("authors.h",INCLUDE_DIR, "w")) == NULL) { printf("Error opening data file zonetab.h for write. \n" "Terminating code generation.\n"); return -1; } if ((mob_code_incl = safe_open("includemobs.h", NPC_DIR, "w")) == NULL) { printf("Error opening data file includemobs.h for write. \n" "Terminating code generation.\n"); return -1; } if ((loc_code_incl = safe_open("includerooms.h", LOCATIONS_DIR, "w")) == NULL) { printf("Error opening data file includerooms.h for write. \n" "Terminating code generation.\n"); return -1; } if ((obj_code_incl = safe_open("includeobjects.h",OBJECTS_DIR, "w")) == NULL) { printf("Error opening data file includeobjects.h for write. \n" "Terminating code generation.\n"); return -1; } if ((mob_code_tabl = safe_open("mobtable.h", NPC_DIR, "w")) == NULL) { printf("Error opening data file mobtable.h for write. \n" "Terminating code generation.\n"); return -1; } if ((loc_code_tabl = safe_open("loctable.h", LOCATIONS_DIR, "w")) == NULL) { printf("Error opening data file loctable.h for write. \n" "Terminating code generation.\n"); return -1; } if ((obj_code_tabl = safe_open("objtable.h",OBJECTS_DIR, "w")) == NULL) { printf("Error opening data file objtable.h for write. \n" "Terminating code generation.\n"); return -1; } if ((proto_file = safe_open("prototypes.h",INCLUDE_DIR,"w")) == NULL) { printf("Error opening include file prototypes.h for write.\n" "Terminating code generation.\n"); return -1; } tmp_zone = thezone; /* put the header at the top of the mobiles.h file */ fprintf(mob_def, "" "/*****************************************************************" "*********\n" " ** MOBILES INCLUDE - Automatically created by gen.\n" " ** DO NOT make any changes here, as they will go away !!!\n" " ** last update: %s" " *****************************************************************" "***********/\n" "#ifndef _MOBILES_H_\n" "#define _MOBILES_H_\n\n", ctime(&t)); /* put the header at the top of the objects.h file */ fprintf(obj_def, "" "/*****************************************************************" "*********\n" " ** OBJECTS INCLUDE - Automatically created by gen.\n" " ** DO NOT make any changes here, as they will go away !!!\n" " ** last update: %s\n" " *****************************************************************" "***********/\n" "#ifndef _OBJECTS_H_\n" "#define _OBJECTS_H_\n\n", ctime(&t)); /* put the header at the top of the locations.h file */ fprintf(loc_def, "/*****************************************************************" "*********\n" " ** LOCATIONS INCLUDE - Automatically created by gen.\n" " ** DO NOT make any changes here, as they will go away !!!\n" " ** last update: %s\n" " *****************************************************************" "***********/\n" "#ifndef _LOCATIONS_H_\n" "#define _LOCATIONS_H_\n\n", ctime(&t)); fprintf(mob_data, "%d\n", cur_mob); fprintf(obj_data, "%d\n", cur_obj); fprintf(loc_data, "%d\n", -(cur_loc)-1); /* print header at head of authors.h file */ fprintf(author_data, "" "/** AUTOMATIC CREATED AUTHORS TABLE - " "Do not edit this file, it will go away!\n **/\n" "#ifndef AUTHORS_H\n" "#define AUTHORS_H\n\n" "const char *authortab[] = {\n"); /* print header at head of zonetab.h file */ fprintf(quest_data, "" "/** AUTOMATIC CREATED ZONE TABLE - " "Do not edit this file, it will go away!\n **/\n" "#ifndef ZONE_TAB_H\n" "#define ZONE_TAB_H\n\n" "#include \"quests.h\"\n" "const int zonetab[] = {\n"); /* print header at head of mudcode include files */ fprintf(obj_code_incl, "#ifndef _OBJ_INCLUDE_OBJECTS_H_\n" "#define _OBJ_INCLUDE_OBJECTS_H_\n\n"); fprintf(mob_code_incl, "#ifndef _MOB_INCLUDE_MOBS_H_\n" "#define _MOB_INCLUDE_MOBS_H_\n\n"); fprintf(loc_code_incl, "#ifndef _LOC_INCLUDE_ROOMS_H_\n" "#define _LOC_INCLUDE_ROOMS_H_\n\n"); /* print header at head of mudcode table files */ fprintf(obj_code_tabl, "/** AUTOMATIC CREATED OBJECT TABLE - " "Do not edit this file, it will go away.\n **/\n" "#ifndef OBJ_TABLE_H\n" "#define OBJ_TABLE_H\n\n" "MAPPING(obj_table) =\n" "{\n"); fprintf(mob_code_tabl, "/** AUTOMATIC CREATED MOBILE TABLE - " "Do not edit this file, it will go away.\n **/\n" "#ifndef MOB_TABLE_H\n" "#define MOB_TABLE_H\n\n" "MAPPING(mob_table) =\n" "{\n"); fprintf(loc_code_tabl, "/** AUTOMATIC CREATED LOCATION TABLE - " "Do not edit this file, it will go away.\n **/\n" "#ifndef LOC_TABLE_H\n" "#define LOC_TABLE_H\n\n" "MAPPING(loc_table) =\n" "{\n"); fprintf(proto_file,"/** AUTOMATIC CREATED PROTOTYPES FILE - Do not edit, it will go away.\n **/\n" "#ifndef EVENT_PROTOTYPES_H\n" "#define EVENT_PROTOTYPES_H\n\n"); /* print header at top of zones file */ fprintf(zones_data, "%d\n", num_zones); while (tmp_zone != NULL) { printf("\r Creating information for zone %-20.20s",tmp_zone->zonename); fflush(stdout); /* write quest info */ if (tmp_zone->quest != NULL) { if ((the_quest = get_quest(tmp_zone->quest)) == -1) printf("Warning - Quest %s not recognized in %s zone, " "leaving it out.\n", tmp_zone->quest, tmp_zone->zonefile); else fprintf(quest_data, "\t%d,\t%d,\n", zone_num, the_quest); } /* write author info */ if (tmp_zone->author == NULL) fprintf(author_data, "\t\"Unknown\",\n"); else fprintf(author_data, "\t\"%s\",\n", tmp_zone->author); /* generate location/object/mobile info */ if ((gen_zone_include(the_hash,tmp_zone) == -1) || (gen_locations(the_hash, tmp_zone, loc_def, loc_data, loc_code_incl, loc_code_tabl, zones_data, zone_num) == -1) || (gen_objects(the_hash, tmp_zone, obj_def, obj_data, obj_code_incl, obj_code_tabl, zone_num) == -1) || (gen_mobiles(the_hash, tmp_zone, mob_def, mob_data, mob_code_incl, mob_code_tabl, zone_num) == -1)) { printf("Unexpected error in code generation. " "Terminating generate\n"); return -1; } tmp_zone = tmp_zone->next_zone; zone_num++; has_zone_header = False; } fprintf(loc_def, "\n#endif\n"); fprintf(mob_def, "\n#endif\n"); fprintf(obj_def, "\n#endif\n"); fprintf(quest_data, "\t-1,\t-1\n" "};\n\n" "#endif\n"); fprintf(author_data, "\tTABLE_END\n" "};\n\n" "#endif\n"); fprintf(obj_code_incl, "\n#endif\n"); fprintf(mob_code_incl, "\n#endif\n"); fprintf(loc_code_incl, "\n#endif\n"); fprintf(proto_file,"\n#endif\n"); fprintf(obj_code_tabl, " { -1, NULL }\n" "};\n\n" "#endif\n"); fprintf(mob_code_tabl, " { -1, NULL }\n" "};\n\n" "#endif\n"); fprintf(loc_code_tabl, " { -1, NULL }\n" "};\n\n" "#endif\n"); fclose(zones_data); fclose(loc_def); fclose(loc_data); fclose(obj_def); fclose(obj_data); fclose(mob_def); fclose(mob_data); fclose(quest_data); fclose(author_data); fclose(loc_code_incl); fclose(mob_code_incl); fclose(obj_code_incl); fclose(loc_code_tabl); fclose(mob_code_tabl); fclose(obj_code_tabl); fclose(proto_file); return 1; }