home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / files / util / misc / rsys / src / rsysinitdata.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-21  |  24.3 KB  |  1,025 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *    RSysInitData.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    int ChooseNewFile ( char *oldfile , char *header );
  12. *    ValidMemoryNode *CheckNode ( ULONG memoryptr );
  13. *    void BuildAllDataEntries ( void );
  14. *    void BuildHardwareList ( void );
  15. *    void BuildHelpList ( void );
  16. *    void BuildLibOffsetList ( void );
  17. *    void BuildValidAddressList ( void );
  18. *    void FreeAmigaGuideContextMemory ( void );
  19. *    void FreeHardwareData ( void );
  20. *    void FreeLibOffData ( void );
  21. *    void FreeValidAddressList ( void );
  22. *    void SaveConfig ( void );
  23. *
  24. *      --- Lokale  Routinen ---
  25. *
  26. *    static int AllocLineBuffer ( void );
  27. *    static int MarkAddress ( ULONG start , ULONG length , char type , char *comment );
  28. *    static int ReadCompanies ( BPTR hfile );
  29. *    static int ReadContextFile ( UBYTE *filename );
  30. *    static int ReadHardwareData ( BPTR hfile );
  31. *    static int ReadLibOff ( BPTR lofile );
  32. *    static int SplitFunction ( char *data , FUNCTION *func , LIBRARY *lib );
  33. *    static STRPTR CheckHardwareEntry ( STRPTR buffer , int *type );
  34. *    static STRPTR CheckLibOffEntry ( STRPTR buffer , int *type );
  35. *    static UBYTE *myFGets ( BPTR file , STRPTR buffer , long size );
  36. *    static void FreeLineBuffer ( void );
  37. *
  38. * Bemerkungen:
  39. *    Enthält die Routinen zur Initialisierung der externen Daten.
  40. *
  41. * Erstellungsdatum:
  42. *    20-Jul-93    Rolf Böhme
  43. *
  44. * Änderungen:
  45. *    20-Jul-93    Rolf Böhme    Erstellung
  46. *
  47. ***************************************************************************
  48. */
  49.  
  50. #include "RSys.h"
  51. /*#include "I.c"*/
  52.  
  53. static struct Remember *HWKey = NULL;
  54. static struct Remember *LOKey = NULL;
  55. static struct Remember *VMKey = NULL;
  56. static struct Remember *ContextKey = NULL;
  57.  
  58. char **company_str;
  59.  
  60. struct Manufacturer *manu;
  61.  
  62. static char *datatype[]=
  63. {
  64.    "END", "MANUFACTURER", "PRODUCT", "TYPE", "NAME", "COMPANY", "UNKNOWN"
  65. };
  66.  
  67. static char *libofftype[]=
  68. {
  69.    "END", "LIBNAME", "TYP", "BASE", "FUNCTION"
  70. };
  71.  
  72. UBYTE *context[MONITOR + 1];
  73.  
  74. int   hardwarecnt = 0;
  75.  
  76. struct List Libraries;
  77. struct List ValidMemoryList;
  78.  
  79. static UBYTE *filebuffer;
  80. #define MAXLINE 256
  81.  
  82. static int
  83. AllocLineBuffer(void)
  84. {
  85.    if(filebuffer = MyAllocVec((MAXLINE+1) * sizeof(UBYTE), MEMF_CLEAR, NO_KILL))
  86.       return TRUE;
  87.  
  88.    ErrorHandle("No file buffer for reading", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  89.  
  90.    return FALSE;
  91. }
  92.  
  93. static void
  94. FreeLineBuffer(void)
  95. {
  96.    MyFreeVec(filebuffer);
  97.  
  98.    return;
  99. }
  100.  
  101. int
  102. ChooseNewFile(char *oldfile, char *header)
  103. {
  104.    char dir[MAXFULLNAME], file[MAXFULLNAME];
  105. /*
  106.    char *dir = NULL,
  107.         *file = NULL;
  108. */
  109.    int   ok = TRUE;
  110.  
  111.    if (!SysWnd) return ok;
  112.  
  113. /*
  114.    if ((dir = MyAllocVec(MAXFULLNAME, MEMF_CLEAR, NO_KILL)) &&
  115.        (file = MyAllocVec(MAXFULLNAME, MEMF_CLEAR, NO_KILL)))
  116.    {
  117. */
  118.       strncpy(file, (char *)FilePart((STRPTR) oldfile), MAXFULLNAME);
  119.       strncpy(dir, oldfile, (int)((ULONG) PathPart((STRPTR) oldfile) - (ULONG) oldfile));
  120.  
  121.       if (GetFile(SysWnd, dir, file, "#?", header, "Load"))
  122.          strncpy(oldfile, _fullpath, MAXFULLNAME);
  123.       else ok = FALSE;
  124. /*
  125.    }
  126.    else
  127.    {
  128.       ok = FALSE;
  129.       ErrorHandle(oldfile, MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  130.    }
  131.  
  132.    MyFreeVec(file);
  133.    MyFreeVec(dir);
  134. */
  135.  
  136.    return ok;
  137. }
  138.  
  139.  
  140. void
  141. FreeHardwareData(void)
  142. {
  143.    FreeRemember(HWKEY, TRUE);
  144.    return;
  145. }
  146.  
  147. static UBYTE *
  148. myFGets(BPTR file, STRPTR buffer, long size)
  149. {
  150.    UBYTE *retval = (UBYTE *) NULL;
  151.    char *nlpos;
  152.  
  153.    retval = FGets(file, buffer, size);
  154.  
  155.    if (retval && (nlpos = strchr((char *)retval, '\n'))) *nlpos = STRINGEND;
  156.  
  157.    while (retval && strchr(";#\f\t\0", (int)(*retval)))
  158.    {
  159.       retval = FGets(file, buffer, size);
  160.  
  161.       if (retval && (nlpos = strchr((char *)retval, '\n'))) *nlpos = STRINGEND;
  162.    }
  163.  
  164.    return retval;
  165. }
  166.  
  167. static int
  168. ReadCompanies(BPTR hfile)
  169. {
  170.    UBYTE *check;
  171.    int   count,
  172.          loop = 0;
  173.  
  174.    check = myFGets(hfile, filebuffer, MAXLINE);
  175.    if (check)
  176.    {
  177.       count = atoi((char *)check);
  178.  
  179.       if (count == 0)
  180.          return FALSE;
  181.  
  182.       if (company_str = (char **)ALLOCHW(count * sizeof(char *)))
  183.       {
  184.          check = myFGets(hfile, filebuffer, MAXLINE);
  185.  
  186.          while ((loop < count) && check)
  187.          {
  188.             if (*check)
  189.             {
  190.                company_str[loop] = ALLOCHW(strlen((char *)check) + 1);
  191.  
  192.                if (!company_str[loop]) return FALSE;
  193.  
  194.                strcpy(company_str[loop++], (char *)check);
  195.             }
  196.  
  197.             if (loop < count) check = myFGets(hfile, filebuffer, MAXLINE);
  198.          }
  199.  
  200.          if ((loop < count) || (check == NULL)) return FALSE;
  201.  
  202.          return TRUE;
  203.       }
  204.    }
  205.  
  206.    return FALSE;
  207. }
  208.  
  209. static STRPTR
  210. CheckHardwareEntry(STRPTR buffer, int *type)
  211. {
  212.    char *eqpos = NULL;
  213.    int   i;
  214.  
  215.    *type = END;
  216.  
  217.    if (!strcmp((char *)buffer, datatype[END]))
  218.       return (STRPTR) eqpos;
  219.  
  220.    *type = UNKNOWN;
  221.  
  222.    for (i = MANU_NR; i < UNKNOWN; i++)
  223.       if (!strncmp((char *)buffer, datatype[i], strlen(datatype[i])))
  224.       {
  225.          eqpos = strchr((char *)buffer, '\=');
  226.  
  227.          eqpos++;
  228.  
  229.          while (*eqpos == ' ')
  230.             eqpos++;
  231.  
  232.          *type = i;
  233.  
  234.          return (STRPTR) eqpos;
  235.       }
  236.  
  237.    return (STRPTR) eqpos;
  238. }
  239.  
  240. static int
  241. ReadHardwareData(BPTR hfile)
  242. {
  243.    UBYTE *check,
  244.          *data;
  245.    int   count = 0,
  246.          loop = 0;
  247.    int   type,
  248.          err;
  249.  
  250.    check = myFGets(hfile, filebuffer, MAXLINE);
  251.    if (check)
  252.    {
  253.       count = atoi((char *)check);
  254.  
  255.       hardwarecnt = count;
  256.  
  257.       if (count == 0)
  258.          return FALSE;
  259.  
  260.       if (manu = ALLOCHW((count + 1) * sizeof(struct Manufacturer)))
  261.       {
  262.          err = FALSE;
  263.  
  264.          check = myFGets(hfile, filebuffer, MAXLINE);
  265.  
  266.          while (loop < count && check && !err)
  267.          {
  268.             data = CheckHardwareEntry(check, &type);
  269.  
  270.             switch (type)
  271.             {
  272.                case MANU_NR:
  273.                   manu[loop].manu_nr = (WORD) atoi((char *)data);
  274.                   break;
  275.  
  276.                case PROD_NR:
  277.                   manu[loop].prod_nr = (WORD) atoi((char *)data);
  278.                   break;
  279.  
  280.                case TYPE_NR:
  281.                   manu[loop].type_nr = (WORD) atoi((char *)data);
  282.                   break;
  283.  
  284.                case COMPANY:
  285.                   manu[loop].company = atoi((char *)data);
  286.                   break;
  287.  
  288.                case NAME_STR:
  289.                   manu[loop].name = ALLOCHW(strlen((char *)data)+1);
  290.  
  291.                   if (manu[loop].name)
  292.                      strcpy(manu[loop].name, (char *)data);
  293.                   else
  294.                   {
  295.                      ErrorHandle((char *)data, MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  296.                      err = TRUE;
  297.                   }
  298.                   break;
  299.  
  300.                case END:
  301.                   loop++;
  302.                   break;
  303.  
  304.                default:
  305.                   ErrorHandle((char *)check, DATA_ENTRY_ERR, TYPE_FAIL, NO_KILL);
  306.                   break;
  307.             }
  308.  
  309.             if (!err) check = myFGets(hfile, filebuffer, MAXLINE);
  310.          }
  311.  
  312.          if (err || loop < count) return FALSE;
  313.  
  314.          return TRUE;
  315.       }
  316.       else
  317.       {
  318.          ErrorHandle((char *)RSysFiles.Hardware, MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  319.          return FALSE;
  320.       }
  321.    }
  322.  
  323.    return FALSE;
  324. }
  325.  
  326. void
  327. BuildHardwareList(void)
  328. {
  329.    int   ok;
  330.    BPTR  hfile;
  331.  
  332.    DPOS;
  333.    if (!ChooseNewFile((char *)RSysFiles.Hardware, "Select new Hardware data file..."))
  334.       return;
  335.  
  336.    DPOS;
  337.    if (Flags.dummy1) FreeHardwareData();
  338.  
  339.    DPOS;
  340.    Flags.dummy1 = 0;
  341.  
  342.    DPOS;
  343.    if (!exist((char *)RSysFiles.Hardware)) return;
  344.  
  345.    DPOS;
  346.    if(!AllocLineBuffer()) return;
  347.  
  348.    DPOS;
  349.    if (hfile = Open(RSysFiles.Hardware, MODE_OLDFILE))
  350.    {
  351.       PrintInfo("Read hardware datas...", SPEAK, NULL);
  352.  
  353.    DPOS;
  354.       ok = ReadCompanies(hfile);
  355.       if (ok)
  356.       {
  357.    DPOS;
  358.          ok = ReadHardwareData(hfile);
  359.  
  360.          if (ok) Flags.dummy1 = 1;
  361.          else
  362.             ErrorHandle((char *)RSysFiles.Hardware, FILE_ERR, READ_FAIL, NO_KILL);
  363.       }
  364.       else ErrorHandle((char *)RSysFiles.Hardware, FILE_ERR, READ_FAIL, NO_KILL);
  365.  
  366.    DPOS;
  367.       Close(hfile);
  368.  
  369.    DPOS;
  370.       if (Flags.dummy1) PrintInfo("Hardware Datas updated", SPEAK, SEC);
  371.  
  372.    }
  373.    else ErrorHandle((char *)RSysFiles.Hardware, FILE_ERR, OPEN_FAIL, NO_KILL);
  374.  
  375.    DPOS;
  376.    FreeLineBuffer();
  377.  
  378.    DPOS;
  379.    PrintStatistics();
  380.  
  381.    return;
  382. }
  383.  
  384. void
  385. FreeLibOffData(void)
  386. {
  387.    FreeRemember(LOKEY, TRUE);
  388.  
  389.    return;
  390. }
  391.  
  392. static STRPTR
  393. CheckLibOffEntry(STRPTR buffer, int *type)
  394. {
  395.    char *eqpos = NULL;
  396.    int   i;
  397.  
  398.    *type = LO_END;
  399.  
  400.    if (!strcmp((char *)buffer, libofftype[LO_END]))
  401.       return (STRPTR) eqpos;
  402.  
  403.    *type = LO_UNKNOWN;
  404.  
  405.    for (i = LO_LIBNAME; i <= LO_FUNCTION; i++)
  406.       if (!strncmp((char *)buffer, libofftype[i], strlen(libofftype[i])))
  407.       {
  408.          eqpos = strchr((char *)buffer, '\=');
  409.  
  410.          eqpos++;
  411.  
  412.          while (*eqpos == ' ')
  413.             eqpos++;
  414.  
  415.          *type = i;
  416.  
  417.          return (STRPTR) eqpos;
  418.       }
  419.  
  420.    return (STRPTR) eqpos;
  421. }
  422.  
  423. static int
  424. SplitFunction(char *data, FUNCTION * func, LIBRARY * lib)
  425. {
  426.    char  f[BUFSIZE],
  427.          b[5],
  428.         *dptr = data;
  429.    int   fc = 0,
  430.          bc = 0,
  431.          dc = 0,
  432.          public,
  433.          ok = TRUE;
  434.  
  435.    while ((fc < BUFSIZE - 1) && (((f[fc++] = *(dptr++))) != ',')) ;
  436.    f[fc - 1] = STRINGEND;
  437.  
  438.    while ((bc < 5) && ((b[bc++] = (char)(*(dptr++))) != ',')) ;
  439.    b[bc - 1] = STRINGEND;
  440.  
  441.    public = atoi(dptr);
  442.  
  443.    if (!(func->f_name = ALLOCLO(strlen(f) + 1)))
  444.       ok = FALSE;
  445.    else
  446.    {
  447.       strcpy(func->f_name, f);
  448.       func->f_bias = atoi(b);
  449.       func->f_public = (char)((public == 1) ? 1 : 0);
  450.  
  451.       AddTail(&(lib->l_functions), &(func->f_node));
  452.    }
  453.  
  454.    return ok;
  455. }
  456.  
  457. static int
  458. ReadLibOff(BPTR lofile)
  459. {
  460.    UBYTE *check,
  461.          *data;
  462.    int   ok = TRUE;
  463.    FUNCTION *func = NULL;
  464.    LIBRARY *lib = NULL;
  465.    int   type;
  466.  
  467.    check = myFGets(lofile, filebuffer, MAXLINE);
  468.    while (check && ok != FALSE)
  469.    {
  470.       data = CheckLibOffEntry(check, &type);
  471.  
  472.       switch (type)
  473.       {
  474.          case LO_END:
  475.             AddTail(&Libraries, &(lib->l_node));
  476.             break;
  477.  
  478.          case LO_LIBNAME:
  479.             lib = ALLOCLO(sizeof(LIBRARY));
  480.  
  481.             if (!lib)
  482.                ok = FALSE;
  483.             else
  484.             {
  485.                NewList(&(lib->l_functions));
  486.  
  487.                lib->l_name = ALLOCLO(strlen((char *)data) + 1);
  488.  
  489.                if (!lib->l_name)
  490.                   ok = FALSE;
  491.                else
  492.                {
  493.                   strcpy((char *)lib->l_name, (char *)data);
  494.                   lib->l_node.ln_Name = (char *)lib->l_name;
  495.                }
  496.             }
  497.             break;
  498.  
  499.          case LO_TYP:
  500.             lib->l_typ = (*data == 'L') ? 1 : 0;
  501.             break;
  502.  
  503.          case LO_BASE:
  504.             lib->l_base = ALLOCLO(strlen((char *)data) + 1);
  505.  
  506.             if (!lib->l_base)
  507.                ok = FALSE;
  508.             else
  509.                strcpy(lib->l_base, (char *)data);
  510.             break;
  511.  
  512.          case LO_FUNCTION:
  513.             func = ALLOCLO(sizeof(LIBRARY));
  514.  
  515.             if (func)
  516.                ok = SplitFunction((char *)data, func, lib);
  517.             else
  518.                ok = FALSE;
  519.             break;
  520.  
  521.          default:
  522.             ErrorHandle((char *)check, DATA_ENTRY_ERR, TYPE_FAIL, NO_KILL);
  523.             break;
  524.       }
  525.  
  526.       if (ok == TRUE) check = myFGets(lofile, filebuffer, MAXLINE);
  527.       else
  528.          ErrorHandle((char *)RSysFiles.LibOffsets, FILE_ERR, READ_FAIL, NO_KILL);
  529.    }
  530.  
  531.    return ok;
  532. }
  533.  
  534. void
  535. BuildLibOffsetList(void)
  536. {
  537.    int   ok;
  538.    BPTR  lofile;
  539.  
  540.    if (!ChooseNewFile((char *)RSysFiles.LibOffsets, "Select new Library offsets file..."))
  541.       return;
  542.  
  543.    if (Flags.dummy2) FreeLibOffData();
  544.  
  545.    NewList(&Libraries);
  546.  
  547.    Flags.dummy2 = 0;
  548.  
  549.    if(!exist((char *)RSysFiles.LibOffsets)) return;
  550.  
  551.    if(!AllocLineBuffer()) return;
  552.  
  553.    if (lofile = Open(RSysFiles.LibOffsets, MODE_OLDFILE))
  554.    {
  555.       PrintInfo("Read library offsets...", SPEAK, NULL);
  556.  
  557.       ok = ReadLibOff(lofile);
  558.       if (ok == TRUE)
  559.       {
  560.          Flags.dummy2 = 1;
  561.          PrintInfo("Library offsets updated", SPEAK, SEC);
  562.       }
  563.       else ErrorHandle((char *)RSysFiles.LibOffsets, FILE_ERR, READ_FAIL, NO_KILL);
  564.  
  565.       Close(lofile);
  566.    }
  567.    else ErrorHandle((char *)RSysFiles.LibOffsets, FILE_ERR, OPEN_FAIL, NO_KILL);
  568.  
  569.    FreeLineBuffer();
  570.  
  571.    PrintStatistics();
  572.  
  573.    return;
  574. }
  575.  
  576. void
  577. FreeAmigaGuideContextMemory(void)
  578. {
  579.    FreeRemember((struct Remember **) & ContextKey, TRUE);
  580.  
  581.    return;
  582. }
  583.  
  584. static int
  585. ReadContextFile(UBYTE * filename)
  586. {
  587.    BPTR  file;
  588.    UBYTE *check;
  589.    int   i = 0,
  590.          noerror = TRUE,
  591.          retval = TRUE;
  592.  
  593.    if (exist((char *)filename))
  594.    {
  595.       if (file = Open(filename, MODE_OLDFILE))
  596.       {
  597.          check = myFGets(file, filebuffer, MAXLINE);
  598.  
  599.          while ((i < MAXENTRY) && check && noerror)
  600.          {
  601.             if (context[i] = AllocRemember((struct Remember **) & ContextKey,
  602.                                            strlen((char *)check) + 1,
  603.                                            MEMF_CLEAR | MEMF_PUBLIC))
  604.             {
  605.                strcpy((char *)(context[i++]), (char *)check);
  606.  
  607.                check = myFGets(file, filebuffer, MAXLINE);
  608.             }
  609.             else noerror = FALSE;
  610.          }
  611.  
  612.          Close(file);
  613.  
  614.          if (!noerror)
  615.          {
  616.             ErrorHandle("AGuide nodes", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  617.             retval = FALSE;
  618.          }
  619.  
  620.          if (!check && (i < MAXENTRY))
  621.          {
  622.             ErrorHandle((char *)filename, DATA_ENTRY_ERR, SIZE_FAIL, NO_KILL);
  623.             retval = FALSE;
  624.          }
  625.  
  626.          context[MAXENTRY] = (UBYTE *) NULL;
  627.  
  628.          return retval;
  629.       }
  630.       else ErrorHandle((char *)filename, FILE_ERR, OPEN_FAIL, NO_KILL);
  631.    }
  632.  
  633.    return FALSE;
  634. }
  635.  
  636. void
  637. BuildHelpList(void)
  638. {
  639.    if (Flags.helpmode) return;
  640.  
  641.    if (!ChooseNewFile((char *)RSysFiles.Guide, "Select AGuide documentation...") ||
  642.        !ChooseNewFile((char *)RSysFiles.GuideContext, "Select new Context nodes file..."))
  643.       return;
  644.  
  645.    if (Flags.dummy3) FreeAmigaGuideContextMemory();
  646.  
  647.    Flags.dummy3 = 0;
  648.  
  649.    if(!AllocLineBuffer()) return;
  650.  
  651.    PrintInfo("Read context nodes...", SPEAK, NULL);
  652.  
  653.    if (!exist((char *)RSysFiles.GuideContext) || !ReadContextFile(RSysFiles.GuideContext))
  654.    {
  655.       if (SysWnd) OffMenu(SysWnd, FULLMENUNUM(0, 1, 0));
  656.  
  657.       Flags.nohelp = 1;
  658.    }
  659.    else
  660.    {
  661.       if (SysWnd) OnMenu(SysWnd, FULLMENUNUM(0, 1, 0));
  662.       Flags.dummy3 = 1;
  663.  
  664.       PrintInfo("Context nodes updated", SPEAK, SEC);
  665.    }
  666.  
  667.    FreeLineBuffer();
  668.  
  669.    PrintStatistics();
  670.  
  671.    return;
  672. }
  673.  
  674. void
  675. SaveConfig(void)
  676. {
  677.    register struct DiskObject *dop;
  678.    char **NewToolTypes,
  679.        **OldToolTypes;
  680.    char *ToolTypes[]=
  681.    {
  682.       /* 00 */ "DONOTWAIT",
  683.  
  684.       /* 01 */ "CX_HOTKEY=",
  685.       /* 02 */ "CX_CRYPT=",
  686.       /* 03 */ "CX_FINDFILE=",
  687.       /* 04 */ "CX_FORMAT=",
  688.       /* 05 */ "CX_HUNKLIST=",
  689.       /* 06 */ "CX_CRC=",
  690.       /* 07 */ "CX_SAVEWINDOW=",
  691.       /* 08 */ "CX_FILEREQUEST=",
  692.  
  693.       /* 09 */ "NOFASTMODE",
  694.       /* 10 */ "NOSORT",
  695.       /* 11 */ "WORKINGBAR",
  696.       /* 12 */ "AUTOFRONT",
  697.       /* 13 */ "MOUSEWINDOW",
  698.       /* 14 */ "TOPAZFONT",
  699.       /* 15 */ "NOSAVEASKING",
  700.       /* 16 */ "NOAPPICON",
  701.  
  702.       /* 17 */ "BACKPATTERNCOL=",
  703.       /* 18 */ "BACKGROUNDCOL=",
  704.       /* 19 */ "BACKPATTERN=",
  705.       /* 20 */ "DETAILPEN=",
  706.       /* 21 */ "BLOCKPEN=",
  707.       /* 22 */ "MENUPEN=",
  708.  
  709.       /* 23 */ "HARDWAREDATA=",
  710.       /* 24 */ "LIBOFFDATA=",
  711.       /* 25 */ "AGUIDEDOC=",
  712.       /* 26 */ "AGUIDECONTEXT=",
  713.       /* 27 */ "ACTIONFILE=",
  714.       /* 28 */ "OUTWINDOW=",
  715.       /* 29 */ "LISTHEIGHT=",
  716.  
  717.       /* 30 */ "TEXTFORMATTER",
  718.       /* 31 */ "ICONX=",
  719.       /* 32 */ "ICONY=",
  720.       /* 33 */ NULL,
  721.    };
  722.    int   i;
  723.    struct Remember *ToolTypeKey = NULL;
  724.  
  725.    if (dop = GetProgramIcon())
  726.    {
  727.       PrintInfo("Write Info file...", SPEAK, NULL);
  728.  
  729.       NewToolTypes = (char **)AllocRemember(&ToolTypeKey, 35 * sizeof(char *), MEMF_CLEAR | MEMF_PUBLIC);
  730.  
  731.       if (NewToolTypes)
  732.       {
  733.          for (i = 0; i < 33; i++)
  734.          {
  735.             NewToolTypes[i] = AllocRemember(&ToolTypeKey, 60, MEMF_CLEAR | MEMF_PUBLIC);
  736.             if (!NewToolTypes[i])
  737.             {
  738.                FreeDiskObject(dop);
  739.                FreeRemember(&ToolTypeKey, TRUE);
  740.                ErrorHandle("AllocRemember()", MEMORY_ERR, ALLOC_FAIL, KILL);
  741.             }
  742.          }
  743.  
  744.          strcpy(NewToolTypes[0], ToolTypes[0]);
  745.  
  746.          for (i = 1; i < 9; i++)
  747.             sprintf(NewToolTypes[i], "%s%s", ToolTypes[i], hotkey[i - 1]);
  748.  
  749. #define NEXT 9
  750.  
  751.          if (!Flags.fastmode)
  752.             strcpy(NewToolTypes[NEXT + 0], ToolTypes[NEXT + 0]);
  753.          else
  754.             sprintf(NewToolTypes[NEXT + 0], "(%s)", ToolTypes[NEXT + 0]);
  755.  
  756.          if (!Flags.sortmode)
  757.             strcpy(NewToolTypes[NEXT + 1], ToolTypes[NEXT + 1]);
  758.          else
  759.             sprintf(NewToolTypes[NEXT + 1], "(%s)", ToolTypes[NEXT + 1]);
  760.  
  761.          if (Flags.workingbar)
  762.             strcpy(NewToolTypes[NEXT + 2], ToolTypes[NEXT + 2]);
  763.          else
  764.             sprintf(NewToolTypes[NEXT + 2], "(%s)", ToolTypes[NEXT + 2]);
  765.  
  766.          if (Flags.autofront)
  767.             strcpy(NewToolTypes[NEXT + 3], ToolTypes[NEXT + 3]);
  768.          else
  769.             sprintf(NewToolTypes[NEXT + 3], "(%s)", ToolTypes[NEXT + 3]);
  770.  
  771.          if (Flags.mousewindow)
  772.             strcpy(NewToolTypes[NEXT + 4], ToolTypes[NEXT + 4]);
  773.          else
  774.             sprintf(NewToolTypes[NEXT + 4], "(%s)", ToolTypes[NEXT + 4]);
  775.  
  776.          if (Flags.sysfont)
  777.             strcpy(NewToolTypes[NEXT + 5], ToolTypes[NEXT + 5]);
  778.          else
  779.             sprintf(NewToolTypes[NEXT + 5], "(%s)", ToolTypes[NEXT + 5]);
  780.  
  781.          if (!Flags.saveasking)
  782.             strcpy(NewToolTypes[NEXT + 6], ToolTypes[NEXT + 6]);
  783.          else
  784.             sprintf(NewToolTypes[NEXT + 6], "(%s)", ToolTypes[NEXT + 6]);
  785.  
  786.          if (!Flags.appicon)
  787.             strcpy(NewToolTypes[NEXT + 7], ToolTypes[NEXT + 7]);
  788.          else
  789.             sprintf(NewToolTypes[NEXT + 7], "(%s)", ToolTypes[NEXT + 7]);
  790.  
  791.          if (bpc)
  792.             sprintf(NewToolTypes[NEXT + 8], "%s%ld", ToolTypes[NEXT + 8], bpc);
  793.          else
  794.             sprintf(NewToolTypes[NEXT + 8], "(%s)", ToolTypes[NEXT + 8]);
  795.  
  796.          if (bgc)
  797.             sprintf(NewToolTypes[NEXT + 9], "%s%ld", ToolTypes[NEXT + 9], bgc);
  798.          else
  799.             sprintf(NewToolTypes[NEXT + 9], "(%s)", ToolTypes[NEXT + 9]);
  800.  
  801.          if (bpp)
  802.             sprintf(NewToolTypes[NEXT + 10], "%s%08lx", ToolTypes[NEXT + 10], bpp);
  803.          else
  804.             sprintf(NewToolTypes[NEXT + 10], "(%s)", ToolTypes[NEXT + 10]);
  805.  
  806.          if (winddetail)
  807.             sprintf(NewToolTypes[NEXT + 11], "%s%ld", ToolTypes[NEXT + 11], winddetail);
  808.          else
  809.             sprintf(NewToolTypes[NEXT + 11], "(%s)", ToolTypes[NEXT + 11]);
  810.  
  811.          if (windblock)
  812.             sprintf(NewToolTypes[NEXT + 12], "%s%ld", ToolTypes[NEXT + 12], windblock);
  813.          else
  814.             sprintf(NewToolTypes[NEXT + 12], "(%s)", ToolTypes[NEXT + 12]);
  815.  
  816.          if (menudetail)
  817.             sprintf(NewToolTypes[NEXT + 13], "%s%ld", ToolTypes[NEXT + 13], menudetail);
  818.          else
  819.             sprintf(NewToolTypes[NEXT + 13], "(%s)", ToolTypes[NEXT + 13]);
  820.  
  821.          sprintf(NewToolTypes[NEXT + 14], "%s%s", ToolTypes[NEXT + 14], RSysFiles.Hardware);
  822.          sprintf(NewToolTypes[NEXT + 15], "%s%s", ToolTypes[NEXT + 15], RSysFiles.LibOffsets);
  823.          sprintf(NewToolTypes[NEXT + 16], "%s%s", ToolTypes[NEXT + 16], RSysFiles.Guide);
  824.          sprintf(NewToolTypes[NEXT + 17], "%s%s", ToolTypes[NEXT + 17], RSysFiles.GuideContext);
  825.          sprintf(NewToolTypes[NEXT + 18], "%s%s", ToolTypes[NEXT + 18], RSysFiles.ActionFile);
  826.          sprintf(NewToolTypes[NEXT + 19], "%s%s", ToolTypes[NEXT + 19], autocon);
  827.  
  828.          sprintf(NewToolTypes[NEXT + 20], "%s%ld", ToolTypes[NEXT + 20], newlvh);
  829.  
  830.          if (!Flags.textformat)
  831.             strcpy(NewToolTypes[NEXT + 21], ToolTypes[NEXT + 21]);
  832.          else
  833.             sprintf(NewToolTypes[NEXT + 21], "(%s)", ToolTypes[NEXT + 21]);
  834.  
  835.          if(iconx != NO_ICON_POSITION)
  836.             sprintf(NewToolTypes[NEXT + 22], "%s%ld", ToolTypes[NEXT + 22], iconx);
  837.          else
  838.             sprintf(NewToolTypes[NEXT + 22], "(%s)", ToolTypes[NEXT + 22]);
  839.  
  840.          if(icony != NO_ICON_POSITION)
  841.             sprintf(NewToolTypes[NEXT + 23], "%s%ld", ToolTypes[NEXT + 23], icony);
  842.          else
  843.             sprintf(NewToolTypes[NEXT + 23], "(%s)", ToolTypes[NEXT + 23]);
  844.  
  845.          NewToolTypes[NEXT + 24] = NULL;
  846.  
  847.          OldToolTypes = dop->do_ToolTypes;
  848.  
  849.          dop->do_ToolTypes = NewToolTypes;
  850.  
  851.          if (!PutDiskObject((STRPTR) RSysName, dop)) 
  852.             ErrorHandle(RSysName, FILE_ERR, WRITE_FAIL, NO_KILL);
  853.          else
  854.          {
  855.             dop->do_ToolTypes = OldToolTypes;
  856.  
  857.             FreeRemember(&ToolTypeKey, TRUE);
  858.  
  859.             PrintInfo("Info file written...", SPEAK, SEC);
  860.          }
  861.       }
  862.       else
  863.       {
  864.          FreeDiskObject(dop);
  865.          FreeRemember(&ToolTypeKey, TRUE);
  866.          ErrorHandle("AllocRemember()", MEMORY_ERR, ALLOC_FAIL, KILL);
  867.       }
  868.  
  869.       FreeDiskObject(dop);
  870.    }
  871.  
  872.    PrintStatistics();
  873.  
  874.    return;
  875. }
  876.  
  877. void
  878. FreeValidAddressList(void)
  879. {
  880.    FreeRemember(VMKEY, TRUE);
  881.    return;
  882. }
  883.  
  884. ValidMemoryNode *
  885. CheckNode(ULONG memoryptr)
  886. {
  887.    struct Node *node;
  888.    ValidMemoryNode *vmnode;
  889.  
  890.    for (node = ValidMemoryList.lh_Head; node->ln_Succ; node = node->ln_Succ)
  891.    {
  892.       vmnode = (ValidMemoryNode *) node;
  893.       if (vmnode->vm_startaddress <= memoryptr && memoryptr <= vmnode->vm_endaddress)
  894.          return vmnode;
  895.    }
  896.  
  897.    return NULL;
  898. }
  899.  
  900. static int
  901. MarkAddress(ULONG start, ULONG length, char type, char *comment)
  902. {
  903.    ValidMemoryNode *VMNode;
  904.  
  905.    if (VMNode = ALLOCVM(sizeof(ValidMemoryNode)))
  906.    {
  907.       VMNode->vm_node.ln_Type = NT_USER;
  908.       VMNode->vm_node.ln_Pri = 0;
  909.  
  910.       VMNode->vm_startaddress = start;
  911.       VMNode->vm_endaddress = start + length;
  912.       VMNode->vm_type = type;
  913.  
  914.       strncpy(VMNode->vm_comment, comment, BUFSIZE);
  915.  
  916.       AddTail(&ValidMemoryList, &(VMNode->vm_node));
  917.  
  918.       return TRUE;
  919.    }
  920.    else ErrorHandle("ValidMemoryNode", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  921.  
  922.    return FALSE;
  923. }
  924.  
  925. void
  926. BuildValidAddressList(void)
  927. {
  928.    struct MemHeader *mem;
  929.    int   ok;
  930.  
  931.    NewList(&ValidMemoryList);
  932.  
  933.    /*
  934.     * Special case the first page of CHIP RAM
  935.     */
  936.    ok = MarkAddress(0, 0x1000, (char)NULL, "First page CHIP-RAM");
  937.  
  938.    /*
  939.     * Map in the free memory
  940.     */
  941.    Forbid();
  942.  
  943.    mem = (struct MemHeader *) SysBase->MemList.lh_Head;
  944.    while (mem->mh_Node.ln_Succ && ok)
  945.    {
  946.       ok = MarkAddress((ULONG) (mem->mh_Lower),
  947.                        (ULONG) (mem->mh_Upper) - (ULONG) (mem->mh_Lower),
  948.                        ((MEMF_CHIP & TypeOfMem(mem->mh_Lower)) ?
  949.                         (char)(VALID) : (char)(CACHEABLE | VALID)),
  950.                        "Memory list entry");
  951.  
  952.       mem = ok ? (struct MemHeader *) (mem->mh_Node.ln_Succ) : NULL;
  953.    }
  954.  
  955.    Permit();
  956.  
  957.    /*
  958.     * Map in the autoconfig boards
  959.     */
  960.    if (ok && (ExpansionBase = (struct ExpansionBase *)OpenLibrary((STRPTR) "expansion.library", 0)))
  961.    {
  962.       struct ConfigDev *cd = NULL;
  963.  
  964.       while ((cd = FindConfigDev(cd, (long)(-1L), (long)(-1L))) != NULL && ok)
  965.       {
  966.          /* Skip memory boards... */
  967.          if (!(cd->cd_Rom.er_Type & ERTF_MEMLIST))
  968.             ok = MarkAddress((ULONG) (cd->cd_BoardAddr),
  969.                              cd->cd_BoardSize,
  970.                              (char)VALID, "Expansion memory");
  971.       }
  972.       CloseLibrary((struct Library *)ExpansionBase);
  973.    }
  974.  
  975.    /*
  976.     * Now for the control areas...
  977.     */
  978.    if (ok) ok = MarkAddress(0x00BC0000, 0x00040000, (char)VALID, "Control area 1");
  979.    if (ok) ok = MarkAddress(0x00D80000, 0x00080000, (char)VALID, "Control area 2");
  980.  
  981.    /*
  982.     * and the ROM...
  983.     */
  984.    if (ok) ok = MarkAddress(0x00F80000, 0x00080000,
  985.                     (char)(CACHEABLE | WRITEPROTECT), "ROM-address");
  986.  
  987.    /*
  988.     * If the credit card resource, make the addresses valid...
  989.     */
  990.    if (ok && OpenResource((STRPTR) "card.resource"))
  991.       ok = MarkAddress(0x00600000, 0x00440002, (char)VALID, "Card resource range");
  992.  
  993.    /*
  994.     * If CD-based Amiga (CDTV, A570, etc.)
  995.     */
  996.    if (ok && FindResident((STRPTR)"cdstrap"))
  997.    {
  998.      ok = MarkAddress(0x00E00000,0x00080000,(char)VALID, "CDTV-RAM");
  999.      if(ok) ok = MarkAddress(0x00B80000,0x00040000,(char)VALID, "CDTV-RAM");
  1000.    }
  1001.  
  1002.    /*
  1003.     * Check for ReKick/ZKick/KickIt
  1004.     */
  1005.    if (ok && ((((ULONG) (SysBase->LibNode.lib_Node.ln_Name)) >> 16) == 0x20))
  1006.       ok = MarkAddress((ULONG)0x00200000, (ULONG)0x00080000,
  1007.                        (char)(VALID | CACHEABLE | WRITEPROTECT),
  1008.                        "KickMem-range for ZKick");
  1009.  
  1010.    Flags.dummy4 = (ok ? 1 : 0);
  1011.  
  1012.    return;
  1013. }
  1014.  
  1015. void
  1016. BuildAllDataEntries(void)
  1017. {
  1018.    BuildActionList();
  1019.    BuildHelpList();
  1020.    BuildHardwareList();
  1021.    BuildLibOffsetList();
  1022.  
  1023.    return;
  1024. }
  1025.