home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-387-Vol-3of3.iso / d / d-linux.zip / dm-dist / syntax_check.c < prev    next >
C/C++ Source or Header  |  1991-03-01  |  18KB  |  776 lines
  1. /**************************************************************************
  2. *  file: SYNTAX_CHECKER.c , Check syntax of all files     Part of DIKUMUD *
  3. *  Usage: QUICK AND DIRTY!!                                               *
  4. *  Copyright (C) 1990, 1991 - see 'license.doc' for complete information. *
  5. ***************************************************************************/
  6.  
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <ctype.h>
  10. #include <time.h>
  11.  
  12. #include "structs.h"
  13. #include "utils.h"
  14. #include "db.h"
  15. #include "comm.h"
  16. #include "handler.h"
  17. #include "limits.h"
  18.  
  19. /**************************************************************************
  20. *  declarations of most of the 'global' variables                         *
  21. ************************************************************************ */
  22.  
  23. struct room_data *world;              /* dyn alloc'ed array of rooms     */
  24. int top_of_world = 0;                 /* ref to the top element of world */
  25. struct obj_data  *object_list = 0;    /* the global linked list of obj's */
  26. struct char_data *character_list = 0; /* global l-list of chars          */
  27.  
  28. struct zone_data *zone_table;         /* table of reset data             */
  29. int top_of_zone_table = 0;
  30. struct message_list fight_messages[MAX_MESSAGES]; /* fighting messages   */
  31. struct player_index_element *player_table = 0; /* index to player file   */
  32. int top_of_p_table = 0;               /* ref to top of table             */
  33. int top_of_p_file = 0;
  34.  
  35. FILE *mob_f,                          /* file containing mob prototypes  */
  36.      *obj_f,                          /* obj prototypes                  */
  37.      *wld_f,                          /* World file                      */
  38.      *zon_f;
  39.  
  40. struct index_data *mob_index;         /* index table for mobile file     */
  41. struct index_data *obj_index;         /* index table for object file     */
  42. struct index_data *wld_index;
  43.  
  44. struct help_index_element *help_index = 0;
  45.  
  46. int top_of_mobt = 0;                  /* top of mobile index table       */
  47. int top_of_objt = 0;                  /* top of object index table       */
  48. int top_of_wldt = 0;
  49.  
  50. struct time_data time_info;        /* the infomation about the time   */
  51. struct weather_data weather_info;    /* the infomation about the weather */
  52.  
  53.  
  54.  
  55.  
  56. /* local procedures */
  57. void boot_zones(void);
  58. void setup_dir(FILE *fl, int room, int dir);
  59. void allocate_room(int new_top);
  60. void boot_world(void);
  61. struct index_data *generate_indices(FILE *fl, int *top);
  62. void build_player_index(void);
  63. void char_to_store(struct char_data *ch, struct char_file_u *st);
  64. void store_to_char(struct char_file_u *st, struct char_data *ch);
  65. int is_empty(int zone_nr);
  66. void reset_zone(int zone);
  67. int file_to_string(char *name, char *buf);
  68. void renum_world(void);
  69. void renum_zone_table(void);
  70. void reset_time(void);
  71. void clear_char(struct char_data *ch);
  72.  
  73.  
  74. /*************************************************************************
  75. *  routines for booting the system                                       *
  76. *********************************************************************** */
  77.  
  78.  
  79. void assume(int faktisk, int antal, int place, char *errmsg)
  80. {
  81.     if (antal != faktisk) {
  82.         printf("Error has occured at #%d.\n\r", place);
  83.         printf("Message is : %s\n\r", errmsg);
  84.         printf("Actual number read is %d\n\r", faktisk);
  85.         exit();
  86.     }
  87. }
  88.  
  89.  
  90. /* generate index table for object, monster or world file*/
  91. struct index_data *generate_indices(FILE *fl, int *top)
  92. {
  93.     int i = 0, antal;
  94.     struct index_data *index;
  95.     long pos;
  96.     char buf[82];
  97.  
  98.     rewind(fl);
  99.  
  100.     for (;;)
  101.     {
  102.         if (fgets(buf, 81, fl))
  103.         {
  104.             if (*buf == '#')
  105.             {
  106.                 /* allocate new cell */
  107.                 
  108.                 if (!i)                         /* first cell */
  109.                     CREATE(index, struct index_data, 1);
  110.                 else
  111.                     if (!(index = 
  112.                         (struct index_data*) realloc(index, 
  113.                         (i + 1) * sizeof(struct index_data))))
  114.                     {
  115.                         printf("load indices");
  116.                         exit();
  117.                      }
  118.                 antal = sscanf(buf, "#%d", &index[i].virtual);
  119.                 assume(antal, 1, index[i].virtual, "Next string with E/A/$");
  120.  
  121.                 index[i].pos = ftell(fl);
  122.                 index[i].number = index[i].virtual;
  123.                 index[i].func = 0;
  124.                 i++;
  125.             }
  126.             else 
  127.                 if (*buf == '$')    /* EOF */
  128.                     break;
  129.         }
  130.         else
  131.         {
  132.             printf("Error when generating index, based upon #xxxx numbers.\n\r");
  133.             printf("   Probably error at end of file.\n\r");
  134.  
  135.             exit();
  136.         }
  137.     }
  138.     index[i-1].number = -1;
  139.     *top = i - 1;
  140.     return(index);
  141. }
  142.  
  143. int exist_index(struct index_data *index_list, int top, int num)
  144. {
  145.     int i, found;
  146.  
  147.     found = FALSE;
  148.  
  149.     for(i=0; (i<=top) && !(found); i++)
  150.         if (index_list[i].number == num)
  151.             found = TRUE;
  152.  
  153.     if (!found) {
  154.         printf("Reference to non-existent number #%d\n\r", num);
  155.     }
  156.  
  157.     return (found);
  158. }
  159.  
  160.  
  161. /* check the rooms */
  162. void check_world(FILE *fl)
  163. {
  164.     int room_nr = 0, zone = 0, dir_nr, virtual_nr, flag, tmp, old_virtual;
  165.     char *temp, chk[50];
  166.     struct extra_descr_data *new_descr;
  167.  
  168.     int antal;
  169.     char *temp2;
  170.  
  171.     world = 0;
  172.     character_list = 0;
  173.     object_list = 0;
  174.  
  175.     rewind(fl);
  176.  
  177.     old_virtual = -1;
  178.  
  179.  
  180.     do
  181.     {
  182.         antal = fscanf(fl, " #%d\n", &virtual_nr);
  183.         assume(antal,1, virtual_nr, "Reading #xxx");
  184.  
  185.         if (old_virtual > virtual_nr)
  186.             assume(0,1,virtual_nr, "Error - #'s not in order.");
  187.         old_virtual = virtual_nr;
  188.  
  189.         temp = fread_string(fl);
  190.         if (flag = (*temp != '$'))    /* a new record to be read */
  191.         {
  192.             temp2 = fread_string(fl);
  193.  
  194.             antal = fscanf(fl, " %d ", &tmp);
  195.             assume(antal,1, virtual_nr, "In room basic 3 numbers");
  196.  
  197.             antal = fscanf(fl, " %d ", &tmp);
  198.             assume(antal,1, virtual_nr, "In room basic 3 numbers");
  199.  
  200.             antal = fscanf(fl, " %d ", &tmp);
  201.             assume(antal,1, virtual_nr, "In room basic 3 numbers");
  202.  
  203.             for (;;)
  204.             {
  205.                 antal = fscanf(fl, " %s \n", chk);
  206.                 assume(antal,1, virtual_nr, "Reading D/E/S string");
  207.  
  208.                 if (*chk == 'D')  /* direction field */
  209.                     setup_dir(fl, virtual_nr, atoi(chk + 1));
  210.                 else if (*chk == 'E')  /* extra description field */
  211.                 {
  212.                     temp2 = fread_string(fl); /* Description */
  213.                     temp2 = fread_string(fl); /* Keywords    */
  214.                 }
  215.                 else if (*chk == 'S')    /* end of current room */
  216.                     break;
  217.                 else
  218.                     assume(FALSE, 0, virtual_nr, "MISSING D/E or S");
  219.             }
  220.                         
  221.         }
  222.     }
  223.     while (flag);
  224. }
  225.  
  226.  
  227.  
  228.  
  229. /* read direction data */
  230. void setup_dir(FILE *fl, int room, int dir)
  231. {
  232.     int tmp, antal;
  233.     char *temp;
  234.  
  235.     temp = fread_string(fl);
  236.     temp = fread_string(fl);
  237.  
  238.     antal = fscanf(fl, " %d ", &tmp);
  239.     assume(antal,1, room, "One of three Direction data");
  240.     antal = fscanf(fl, " %d ", &tmp);
  241.     assume(antal,1, room, "One of three Direction data");
  242.     antal = fscanf(fl, " %d ", &tmp);
  243.     assume(antal,1, room, "One of three Direction data");
  244.     exist_index(wld_index, top_of_wldt, tmp);
  245.  
  246. }
  247.  
  248.  
  249. #define NEW_ZONE_SYSTEM xxx
  250.  
  251. /* load the zone table and command tables */
  252. void check_zones(FILE *fl)
  253. {
  254.     int line_no;
  255.     int antal, tmp1, tmp2, tmp3, tmp4;
  256.     int zon = 0, cmd_no = 0, ch, expand;
  257.     char *check, buf[81];
  258.     char cmd_type;
  259.  
  260.     rewind(fl);
  261.     line_no=1;
  262.  
  263.     for (;;)
  264.     {
  265.         antal = fscanf(fl, " #%*d\n");
  266.         assume(antal, 0, line_no++, "Zone number not found");
  267.  
  268.         check = fread_string(fl);
  269.         line_no++;
  270.  
  271.         if (*check == '$')
  272.             break;        /* end of file */
  273.  
  274.         /* alloc a new zone */
  275.  
  276. #ifdef NEW_ZONE_SYSTEM
  277.         antal = fscanf(fl, " %d ", &zon);
  278.         assume(antal, 1, line_no, "Zone Room < number not found");
  279. #endif
  280.  
  281.         antal = fscanf(fl, " %d ", &zon);
  282.         assume(antal, 1, line_no, "Life Span");
  283.  
  284.         antal = fscanf(fl, " %d ", &zon);
  285.         assume(antal, 1, line_no++, "Reset Mode");
  286.  
  287.  
  288.         /* read the command table */
  289.  
  290.         cmd_no = 0;
  291.  
  292.         for (expand = 1;;)
  293.         {
  294.  
  295.             fscanf(fl, " "); /* skip blanks */
  296.             antal = fscanf(fl, "%c", &cmd_type);
  297.             assume(antal, 1, line_no, "Command type M/*/O/G/E/S missing");
  298.             
  299.             if (cmd_type == 'S')
  300.                 break;
  301.  
  302.             if (cmd_type == '*')
  303.             {
  304.                 expand = 0;
  305.                 fgets(buf, 80, fl); /* skip command */
  306.                 line_no++;
  307.                 continue;
  308.             }
  309.  
  310.             antal = fscanf(fl, " %d %d %d", &tmp1, &tmp2, &tmp3);
  311.             assume(antal, 3, line_no, "Three values after command missing");
  312.  
  313.  
  314.             if (cmd_type == 'M' || cmd_type == 'O' ||
  315.                 cmd_type == 'D' || cmd_type == 'P') {
  316.                 antal = fscanf(fl, " %d", &tmp4);
  317.                 assume(antal, 1, line_no, "Fourth value after command missing");
  318.             }
  319.  
  320.             switch (cmd_type) {
  321.                 case 'M' :
  322.                     exist_index(mob_index, top_of_mobt, tmp2);
  323.                     exist_index(wld_index, top_of_wldt, tmp4);
  324.                     break;
  325.                 case 'O' :
  326.                     exist_index(obj_index, top_of_objt, tmp2);
  327.                     exist_index(wld_index, top_of_wldt, tmp4);
  328.                     break;
  329.                 case 'G' :
  330.                     exist_index(obj_index, top_of_objt, tmp2);
  331.                     break;
  332.                 case 'E' :
  333.                     exist_index(obj_index, top_of_objt, tmp2);
  334.                     break;
  335.                 case 'P' :
  336.                     exist_index(obj_index, top_of_objt, tmp2);
  337.                     exist_index(obj_index, top_of_objt, tmp4);
  338.                     break;
  339.                 case 'D' :
  340.                     exist_index(wld_index, top_of_wldt, tmp2);
  341.                     break;
  342.                 case 'R' :
  343.                     exist_index(wld_index, top_of_wldt, tmp2);
  344.                     exist_index(obj_index, top_of_objt, tmp3);
  345.                     break;
  346.                 case '*' :
  347.                     break;
  348.                 deafult  :
  349.                     printf("Illegal command type");
  350.                     exit();
  351.                     break;
  352.             }
  353.                     
  354.  
  355.             fgets(buf, 80, fl);    /* read comment */
  356.             line_no++;
  357.         }
  358.     }
  359. }
  360.  
  361.  
  362.  
  363.  
  364.  
  365. /*************************************************************************
  366. *  procedures for resetting, both play-time and boot-time          *
  367. *********************************************************************** */
  368.  
  369.  
  370. /* read a mobile from MOB_FILE */
  371. void check_mobile(FILE *fl)
  372. {
  373.     int virtual_nr, old_virtual, antal, flag;
  374.     char *temp;
  375.     char bogst;
  376.  
  377.     int i, skill_nr;
  378.     long tmp, tmp2, tmp3;
  379.     struct char_data *mob;
  380.     char chk[10];
  381.  
  382.  
  383.     old_virtual = -1;
  384.  
  385.     rewind(fl);
  386.  
  387.     do {
  388.         antal = fscanf(fl, " #%d\n", &virtual_nr);
  389.         assume(antal,1, virtual_nr, "Reading #xxx");
  390.  
  391.         if (old_virtual > virtual_nr)
  392.             assume(0,1,virtual_nr, "Error - #'s not in order.");
  393.  
  394.         old_virtual = virtual_nr;
  395.  
  396.         temp = fread_string(fl);  /* Namelist */
  397.         if (flag = (*temp != '$')) {    /* a new record to be read */
  398.  
  399.             /***** String data *** */
  400.             /* Name already read mob->player.name = fread_string(fl); */
  401.             temp = fread_string(fl);  /* short description  */
  402.             temp = fread_string(fl);  /*long_description    */
  403.             temp = fread_string(fl);  /* player.description */
  404.  
  405.             /* *** Numeric data *** */
  406.  
  407.             antal = fscanf(fl, "%d ", &tmp);
  408.             assume(antal, 1, virtual_nr, "ACT error");
  409.  
  410.             antal = fscanf(fl, " %d ", &tmp);
  411.             assume(antal, 1, virtual_nr, "affected_by error");
  412.  
  413.             antal = fscanf(fl, " %d ", &tmp);
  414.             assume(antal, 1, virtual_nr, "Monster Alignment Error");
  415.  
  416.             antal = fscanf(fl, " %c \n", &bogst);
  417.             assume(antal, 1, virtual_nr, "Simple/Detailed error");
  418.  
  419.             if (bogst!='S')
  420.                 printf("%c %d\n", bogst, bogst);
  421.  
  422.             if (bogst == 'S') {
  423.                 /* The new easy monsters */
  424.  
  425.                 antal = fscanf(fl, " %D ", &tmp);
  426.                 assume(antal, 1, virtual_nr, "Level error");
  427.         
  428.                 antal = fscanf(fl, " %D ", &tmp);
  429.                 assume(antal, 1, virtual_nr, "THAC0 error");
  430.         
  431.                 antal = fscanf(fl, " %D ", &tmp);
  432.                 assume(antal, 1, virtual_nr, "AC error");
  433.  
  434.                 antal = fscanf(fl, " %Dd%D+%D ", &tmp, &tmp2, &tmp3);
  435.                 assume(antal, 3, virtual_nr, "Hitpoints");
  436.  
  437.                 antal = fscanf(fl, " %Dd%D+%D \n", &tmp, &tmp2, &tmp3);
  438.                 assume(antal, 3, virtual_nr, "Damage error");
  439.  
  440.                 antal = fscanf(fl, " %D ", &tmp);
  441.                 assume(antal, 1, virtual_nr, "GOLD error");
  442.  
  443.                 antal = fscanf(fl, " %D \n", &tmp);
  444.                 assume(antal, 1, virtual_nr, "XP error");
  445.  
  446.                 antal = fscanf(fl, " %D ", &tmp);
  447.                 assume(antal, 1, virtual_nr, "POSITION error");
  448.  
  449.                 antal = fscanf(fl, " %D ", &tmp);
  450.                 assume(antal, 1, virtual_nr, "DEFAULT POS error");
  451.  
  452.                 antal = fscanf(fl, " %D \n", &tmp);
  453.                 assume(antal, 1, virtual_nr, "SEXY error");
  454.  
  455.         } else {  /* The old monsters are down below here */
  456.  
  457.             printf("Detailed monsters can't be syntax-checked (yet).\n\r");
  458.             assume(0,1,virtual_nr, "DETAIL ERROR");
  459.  
  460.             exit();
  461.             /*   ***************************
  462.             fscanf(fl, " %D ", &tmp);
  463.             mob->abilities.str = tmp;
  464.  
  465.             fscanf(fl, " %D ", &tmp);
  466.             mob->abilities.intel = tmp; 
  467.  
  468.             fscanf(fl, " %D ", &tmp);
  469.             mob->abilities.wis = tmp;
  470.  
  471.             fscanf(fl, " %D ", &tmp);
  472.             mob->abilities.dex = tmp;
  473.  
  474.             fscanf(fl, " %D \n", &tmp);
  475.             mob->abilities.con = tmp;
  476.  
  477.             fscanf(fl, " %D ", &tmp);
  478.             fscanf(fl, " %D ", &tmp2);
  479.  
  480.             mob->points.max_hit = 0;
  481.             mob->points.hit = mob->points.max_hit;
  482.  
  483.             fscanf(fl, " %D ", &tmp);
  484.             mob->points.armor = tmp;
  485.  
  486.             fscanf(fl, " %D ", &tmp);
  487.             mob->points.mana = tmp;
  488.             mob->points.max_mana = tmp;
  489.  
  490.             fscanf(fl, " %D ", &tmp);
  491.             mob->points.move = tmp;        
  492.             mob->points.max_move = tmp;
  493.  
  494.             fscanf(fl, " %D ", &tmp);
  495.             mob->points.gold = tmp;
  496.  
  497.             fscanf(fl, " %D \n", &tmp);
  498.             GET_EXP(mob) = tmp;
  499.  
  500.             fscanf(fl, " %D ", &tmp);
  501.             mob->specials.position = tmp;
  502.  
  503.             fscanf(fl, " %D ", &tmp);
  504.             mob->specials.default_pos = tmp;
  505.  
  506.             fscanf(fl, " %D ", &tmp);
  507.             mob->player.sex = tmp;
  508.  
  509.             fscanf(fl, " %D ", &tmp);
  510.             mob->player.class = tmp;
  511.  
  512.             fscanf(fl, " %D ", &tmp);
  513.             GET_LEVEL(mob) = tmp;
  514.  
  515.             fscanf(fl, " %D ", &tmp);
  516.             mob->player.birth.hours = time_info.hours;
  517.             mob->player.birth.day    = time_info.day;
  518.             mob->player.birth.month = time_info.month;
  519.             mob->player.birth.year  = time_info.year - tmp;
  520.  
  521.             fscanf(fl, " %D ", &tmp);
  522.             mob->player.weight = tmp;
  523.  
  524.             fscanf(fl, " %D \n", &tmp);
  525.             mob->player.height = tmp;
  526.  
  527.             for (i = 0; i < 3; i++)
  528.             {
  529.                 fscanf(fl, " %D ", &tmp);
  530.                 GET_COND(mob, i) = tmp;
  531.             }
  532.             fscanf(fl, " \n ");
  533.  
  534.             for (i = 0; i < 5; i++)
  535.             {
  536.                 fscanf(fl, " %D ", &tmp);
  537.                 mob->specials.apply_saving_throw[i] = tmp;
  538.             }
  539.  
  540.             fscanf(fl, " \n ");
  541.             mob->points.damroll = 0;
  542.             mob->specials.damnodice = 1;
  543.             mob->specials.damsizedice = 6;
  544.  
  545.             mob->points.hitroll = 0;
  546.             ************************************* */
  547.         }
  548.  
  549.         }
  550.     }
  551.     while (flag);
  552.  
  553. }
  554.  
  555.  
  556. /* read an object from OBJ_FILE */
  557. void check_objects(FILE *fl)
  558. {
  559.     int virtual_nr, old_virtual, antal, flag;
  560.     char *temp;
  561.  
  562.     struct obj_data *obj;
  563.     int tmp, i;
  564.     char chk[256];
  565.     struct extra_descr_data *new_descr;
  566.  
  567.     old_virtual = -1;
  568.  
  569.     rewind(fl);
  570.  
  571.     antal = fscanf(fl, " %s \n", chk);
  572.     assume(antal, 1, virtual_nr, "First #xxx number");
  573.  
  574.     do {
  575.         antal = sscanf(chk, " #%d\n", &virtual_nr);
  576.         assume(antal,1, virtual_nr, "Reading #xxx");
  577.  
  578.         if (old_virtual > virtual_nr)
  579.             assume(0,1,virtual_nr, "Error - #'s not in order.");
  580.  
  581.         old_virtual = virtual_nr;
  582.  
  583.         temp = fread_string(fl);  /* Namelist */
  584.         if (flag = (*temp != '$')) {    /* a new record to be read */
  585.  
  586.             /* *** string data *** */
  587.  
  588.             /* temp = fread_string(fl);  name has been read above */
  589.             temp = fread_string(fl); /* short */
  590.             temp = fread_string(fl); /* descr */
  591.             temp = fread_string(fl); /* action */
  592.  
  593.             /* *** numeric data *** */
  594.  
  595.             antal = fscanf(fl, " %d ", &tmp);
  596.             assume(antal, 1, virtual_nr, "Error reading type flag");
  597.  
  598.             antal = fscanf(fl, " %d ", &tmp);
  599.             assume(antal, 1, virtual_nr, "Extra Flag");
  600.  
  601.             antal = fscanf(fl, " %d ", &tmp);
  602.             assume(antal, 1, virtual_nr, "wear_flags");
  603.  
  604.             antal = fscanf(fl, " %d ", &tmp);
  605.             assume(antal, 1, virtual_nr, "value[0]");
  606.  
  607.             antal = fscanf(fl, " %d ", &tmp);
  608.             assume(antal, 1, virtual_nr, "value[1]");
  609.  
  610.             antal = fscanf(fl, " %d ", &tmp);
  611.             assume(antal, 1, virtual_nr, "value[2]");
  612.  
  613.             antal = fscanf(fl, " %d ", &tmp);
  614.             assume(antal, 1, virtual_nr, "value[3]");
  615.  
  616.             antal = fscanf(fl, " %d ", &tmp);
  617.             assume(antal, 1, virtual_nr, "Weight");
  618.  
  619.             antal = fscanf(fl, " %d \n", &tmp);
  620.             assume(antal, 1, virtual_nr, "Cost");
  621.  
  622.             antal = fscanf(fl, " %d \n", &tmp);
  623.             assume(antal, 1, virtual_nr, "Cost Per Day");
  624.  
  625.             /* *** extra descriptions *** */
  626.  
  627.             while (fscanf(fl, " %s \n", chk), *chk == 'E')
  628.             {
  629.  
  630.                 temp = fread_string(fl);
  631.                 temp = fread_string(fl);
  632.             }
  633.  
  634.             for( i = 0 ; (i < MAX_OBJ_AFFECT) && (*chk == 'A') ; i++)
  635.             {
  636.                 antal = fscanf(fl, " %d ", &tmp);
  637.                 assume(antal, 1, virtual_nr, "affected location");
  638.  
  639.                 antal = fscanf(fl, " %d \n", &tmp);
  640.                 assume(antal, 1, virtual_nr, "Modifier");
  641.  
  642.                 antal = fscanf(fl, " %s \n", chk);
  643.         assume(antal, 1, virtual_nr, "Next string with E/A/$");
  644.  
  645.             }
  646.         }
  647.     }
  648.     while (flag);
  649. }
  650.  
  651.  
  652.  
  653.  
  654. /************************************************************************
  655. *  procs of a (more or less) general utility nature            *
  656. ********************************************************************** */
  657.  
  658.  
  659. /* read and allocate space for a '~'-terminated string from a given file */
  660. char *fread_string(FILE *fl)
  661. {
  662.     static char buf[MAX_STRING_LENGTH], tmp[100];
  663.     char *rslt;
  664.     register char *point;
  665.     int flag;
  666.  
  667.     bzero(buf, MAX_STRING_LENGTH);
  668.  
  669.     do
  670.     {
  671.         if (!fgets(tmp, MAX_STRING_LENGTH, fl))
  672.         {
  673.             printf("fread_str");
  674.             exit();
  675.         }
  676.  
  677.         if (strlen(tmp) + strlen(buf) > MAX_STRING_LENGTH)
  678.         {
  679.             printf("fread_string: string too large (db.c, fread_string)");
  680.             exit();
  681.         }
  682.         else
  683.             strcat(buf, tmp);
  684.  
  685.         for (point = buf + strlen(buf) - 2; point >= buf && isspace(*point);
  686.             point--);        
  687.         if (flag = (*point == '~'))
  688.             if (*(buf + strlen(buf) - 3) == '\n')
  689.             {
  690.                 *(buf + strlen(buf) - 2) = '\r';
  691.                 *(buf + strlen(buf) - 1) = '\0';
  692.             }
  693.             else
  694.                 *(buf + strlen(buf) -2) = '\0';
  695.         else
  696.         {
  697.             *(buf + strlen(buf) + 1) = '\0';
  698.             *(buf + strlen(buf)) = '\r';
  699.         }
  700.     }
  701.     while (!flag);
  702.  
  703.     return(buf);
  704. }
  705.  
  706.  
  707. int main(int argc, char *argv[])
  708. {
  709.  
  710.     char name[256];
  711.  
  712.   if (argc != 2) {
  713.         printf("Usage : syntax_check <BaseFileName>\n\r");
  714.         exit(0);
  715.     }
  716.  
  717.     strcpy(name, argv[1]);
  718.     strcat(name, ".wld");
  719.  
  720.     if (!(wld_f = fopen(name, "r")))
  721.     {
  722.         printf("Could not open world file.\n\r");
  723.         exit();
  724.     }
  725.     strcpy(name, argv[1]);
  726.     strcat(name, ".mob");
  727.     if (!(mob_f = fopen(name, "r")))
  728.     {
  729.         printf("Could not open mobile file.\n\r");
  730.         exit();
  731.     }
  732.     strcpy(name, argv[1]);
  733.     strcat(name, ".obj");
  734.     if (!(obj_f = fopen(name, "r")))
  735.     {
  736.         printf("Could not open object file.\n\r");
  737.         exit();
  738.     }
  739.     strcpy(name, argv[1]);
  740.     strcat(name, ".zon");
  741.     if (!(zon_f = fopen(name, "r")))
  742.     {
  743.         printf("Could not open zone file.\n\r");
  744.         exit();
  745.     }
  746.  
  747.     
  748.     printf("Generating world file indexes.\n\r");
  749.     wld_index = generate_indices(wld_f, &top_of_wldt);
  750.  
  751.     printf("Generating mobile file indexes.\n\r");
  752.     mob_index = generate_indices(mob_f, &top_of_mobt);
  753.  
  754.     printf("Generating object file indexes.\n\r");
  755.     obj_index = generate_indices(obj_f, &top_of_objt);
  756.  
  757.     printf("Checking World File\n\r");
  758.     check_world(wld_f);
  759.  
  760.     printf("Checking Mobile File (only simple mobiles).\n\r");
  761.     check_mobile(mob_f);
  762.  
  763.     printf("Checking Object File.\n\r");
  764.     check_objects(obj_f);
  765.  
  766.     printf("Checking Zone File .\n\r");
  767.     check_zones(zon_f);
  768.  
  769.   printf("\n\r\nCheck successfully completed without any obvious errors.\n\r");
  770.  
  771.     fclose(zon_f);
  772.     fclose(wld_f);
  773.     fclose(mob_f);
  774.     fclose(obj_f);
  775. }
  776.