home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 405.lha / AppleII_Emulators_src / src-2 / file_handler.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-28  |  19.2 KB  |  710 lines
  1. #include <cpu_prog_model.h>
  2. #include <stdio.h>
  3.  
  4. #define FALSE   0
  5. #define TRUE    1
  6.  
  7. #define WORK_DIR  "*>work_dir"
  8.  
  9. #define FOPEN_READ_BIN    "i"
  10. #define FOPEN_WRITE_BIN   "o"
  11. #define FOPEN_UPDATE_BIN  "i+"
  12.  
  13. #     define file_per_sec 15    /* It migt be wrong */
  14.  
  15. static FILE   * int_drive_pointer      = NULL;
  16. static char  ** ext_drive_pointer [35] = {NULL};
  17. static short    current_slot           = 0x60,
  18.                 current_drive          = 1,
  19.                 current_volume         = 0,
  20.                 current_open_mode      = _CLOSE;
  21.  
  22. static struct
  23. {
  24.    short  volume,
  25.           track,
  26.           sector,
  27.           byte;
  28. }  ext_drive_info;
  29.  
  30. typedef struct
  31. {
  32.    short   file_flag;
  33.    char    byte  [256];
  34. }  MEM_SEC;
  35.  
  36. typedef struct
  37. {
  38.    short   file_flag;
  39.    FILE  * file_pointer;
  40.    long    index;
  41. }  FILE_SEC;
  42.  
  43. typedef struct
  44. {
  45.    short  file_flag;
  46. }  NONE_SEC;
  47.  
  48. typedef struct
  49. {
  50.    int  dir_unit;
  51. }  DIR;
  52.  
  53.  
  54. /*  tas bort */
  55. static struct
  56. {
  57.    char   in_use,
  58.           track,
  59.           sector;
  60.    char   file_name [18 + 1];
  61.    long   position;
  62. }  sector_info;
  63. /* tas bort */
  64.  
  65.  
  66. DIR *open_dir( path_name)
  67. char  path_name [];
  68. {
  69.    void  * malloc();
  70.    DIR   * pointer;
  71.  
  72.    pointer  = (DIR *) malloc( sizeof (DIR) );
  73.    pointer->dir_unit = open( path_name, 0);
  74.  
  75.    if (pointer->dir_unit == -1)
  76.       return NULL;
  77.  
  78.    return pointer;
  79. }
  80.  
  81. close_dir( dir_pointer)
  82. DIR  * dir_pointer;
  83. {
  84.    return close (dir_pointer->dir_unit);
  85. }
  86.  
  87.  
  88. int dir_next_file( buffer, dir_pointer)
  89. char   buffer [];
  90. DIR  * dir_pointer;
  91. {
  92.    char  * lsdir(),
  93.          * temp_pointer;
  94.  
  95.    if ((temp_pointer = lsdir( dir_pointer->dir_unit)) == NULL)
  96.       return FALSE;
  97.  
  98.    strcpy( buffer, temp_pointer);
  99.    return TRUE;
  100. }
  101.  
  102. int fsufix( file_name, sufix)
  103. char  file_name [],
  104.       sufix     [];
  105. {
  106.    short  pos;
  107.  
  108.    pos = strlen( file_name) - 1;
  109.    while (file_name [pos] && (file_name [pos] != '.') )
  110.       pos --;
  111.  
  112.    if (!strcmp( file_name + pos + 1, sufix) )
  113.       return TRUE;
  114.  
  115.    return FALSE;
  116. }
  117.  
  118. inc_ts_pointer( ts_pointer, inc)
  119. short  * ts_pointer,
  120.          inc;
  121. {
  122.    short    temp_value;
  123.  
  124.    *ts_pointer  += inc;
  125.    temp_value    = *ts_pointer & 0x00F0;
  126.    *ts_pointer  &= 0xFF0F;
  127.    *ts_pointer  += (temp_value * 0x10);
  128.    while (ext_drive_pointer [*ts_pointer >> 8] [*ts_pointer & 0xFF] != NULL)
  129.    {
  130. printf( "Point over point (inc_ts_pointer)\n");
  131.       *ts_pointer  += 1;
  132.       temp_value    = *ts_pointer & 0x00F0;
  133.       *ts_pointer  &= 0xFF0F;
  134.       *ts_pointer  += (temp_value * 0x10);
  135.    }
  136.  
  137.    if ( (*ts_pointer & 0xFF00) >= 0x2300)
  138.       *ts_pointer = 0x0300;
  139.  
  140.    if ( (*ts_pointer & 0xFF00) == 0x1100)
  141.    {
  142.       printf("Internal error DISK_FULL on ext_disk\n");
  143.       exit( -1);
  144.    }
  145. }
  146.  
  147. mem_sector_malloc( pointer)
  148. void  * pointer;
  149. {
  150.    void  * malloc();
  151.    short   loop;
  152.  
  153.    (MEM_SEC *) pointer = (MEM_SEC *) malloc( sizeof (MEM_SEC) );
  154.    if (pointer == NULL)
  155.    {
  156.       printf("Out of memory\n");
  157.       exit( -1);
  158.    }
  159.  
  160.    ( (MEM_SEC *) pointer)->file_flag = FALSE;
  161.    for (loop = 0;loop < 256;loop ++)
  162.       ( (MEM_SEC *) pointer)->byte [loop] = NULL;
  163.  
  164. }
  165.  
  166. file_sector_malloc( pointer)
  167. void  * pointer;
  168. {
  169.    void  * malloc();
  170.    short   loop;
  171.  
  172.    (FILE_SEC *) pointer = (FILE_SEC *) malloc( sizeof (FILE_SEC) );
  173.    if (pointer == NULL)
  174.    {
  175.       printf("Out of memory\n");
  176.       exit( -1);
  177.    }
  178.  
  179.    ( (FILE_SEC *) pointer)->file_flag = TRUE;
  180. }
  181.  
  182. ext_drive_write( track, sector, byte, value)
  183. char  track,
  184.       sector,
  185.       byte,
  186.       value;
  187. {
  188.    if ( ((NONE_SEC *) ext_drive_pointer [track] [sector])->file_flag = TRUE)
  189.    {
  190.       printf("Can't  write to disk yet.\n");
  191.       exit(-1);
  192.    }
  193.  
  194.    if ( ((NONE_SEC *) ext_drive_pointer [track] [sector])->file_flag = FALSE)
  195.    {
  196. printf("Storing in mem_sector\n");
  197.       ( (MEM_SEC *) ext_drive_pointer [track] [sector])->byte [byte] = value;
  198.    }
  199. }
  200.  
  201. char ext_drive_read( track, sector, byte)
  202. char  track,
  203.       sector,
  204.       byte;
  205. {
  206.    char   value;
  207.  
  208.    if ( ((NONE_SEC *) ext_drive_pointer [track] [sector])->file_flag = TRUE)
  209.    {
  210.       printf("Can't  read from disk yet.\n");
  211.       exit(-1);
  212.    }
  213.  
  214.    if ( ((NONE_SEC *) ext_drive_pointer [track] [sector])->file_flag = FALSE)
  215.    {
  216. printf("Reading in mem_sector\n");
  217.       return ( (MEM_SEC *) ext_drive_pointer [track] [sector])->byte [byte];
  218.    }
  219. }
  220.  
  221. int disk_open( mode, slot, drive, volume)
  222. short  mode,
  223.        slot,
  224.        drive,
  225.        volume;
  226. {
  227.    char  * opening_mode;
  228.  
  229.    switch (mode)
  230.    {
  231.       case _READ:    opening_mode = FOPEN_READ_BIN;    break;
  232.       case _WRITE:   opening_mode = FOPEN_WRITE_BIN;   break;
  233.       case _MODIFY:  opening_mode = FOPEN_UPDATE_BIN;  break;
  234.    }
  235.  
  236.    if (int_drive_pointer != NULL)   /* Some drive is already opened */
  237.    {
  238.       if ( (current_open_mode != mode) || (current_drive != drive) )
  239.       {
  240.          if (current_drive == 0x01)
  241.             fclose( int_drive_pointer);
  242.          else
  243.          {
  244.             short  loop_1;
  245.             short  loop_2;
  246.  
  247.             for (loop_1 = 0;loop_1 < 35;loop_1 ++)
  248.             {
  249.                loop_2 = 0;
  250.  
  251.                while (ext_drive_pointer [loop_1][loop_2])
  252.                   free( ext_drive_pointer [loop_1][loop_2++]);
  253.  
  254. printf("Free %d sectors on track %x\n", loop_2, loop_1);
  255.                free( ext_drive_pointer [loop_1]);
  256.                ext_drive_pointer [loop_1]= NULL;
  257.             }
  258.          }
  259.  
  260.       }
  261.  
  262.       else
  263.          return FALSE;    /* It's this one which is open */
  264.    }
  265.  
  266.    switch (drive)
  267.    {
  268.       case 0x01:
  269.          int_drive_pointer = fopen( "tobbe>apple>apple_disk>boot_disk",
  270.                                                            opening_mode );
  271.          if (int_drive_pointer == NULL)
  272.             return TRUE;
  273.  
  274.          break;
  275.  
  276.       case 0x02:     /* init VTOC */
  277.          if (ext_drive_pointer == NULL)
  278.          {
  279.             DIR   * dir_pointer;
  280.             void  * malloc();
  281.             short   byte_pos,
  282.                     filenum_on_sec,
  283.                     curr_sector,        /* Current sector in VTOC.track  */
  284.                     next_tsl,           /* T/S List for one prog on disk */
  285.                     next_aloc_sec,
  286.                     loop;
  287.             char    name_buffer [30];
  288.  
  289.             for (loop = 0;loop < 35;loop ++)
  290.                ext_drive_pointer [loop][0x00] = NULL;
  291.  
  292.             ext_drive_pointer [0x11] = (char **) malloc( sizeof (char *) * 16);
  293.             if (ext_drive_pointer [0x11] == NULL)
  294.             {
  295.                printf("Out of memory  (ext_drive_pointer [0x11])\n");
  296.                exit( -1);
  297.             }
  298.                                               /* Track  Sector */
  299.             mem_sector_malloc( ext_drive_pointer [0x11] [0x00]);
  300.  
  301.                          /* Track  Sector Byte   Value */
  302.             ext_drive_write( 0x11,  0x00,  0x00,  0x04);   /* dummy          */
  303.             ext_drive_write( 0x11,  0x00,  0x01,  0x11);   /* Next :  Track  */
  304.             ext_drive_write( 0x11,  0x00,  0x02,  0x0F);   /*         Sector */
  305.             ext_drive_write( 0x11,  0x00,  0x03,  0x03);   /* Dos rev        */
  306.             ext_drive_write( 0x11,  0x00,  0x06,  0x00);   /* Volume         */
  307.             ext_drive_write( 0x11,  0x00,  0x27,  0x7A);   /* 122 T/S pairs  */
  308.             ext_drive_write( 0x11,  0x00,  0x30,  0x11);   /* Last allocated */
  309.             ext_drive_write( 0x11,  0x00,  0x31,  0x01);   /* Next T + 0x01  */
  310.             ext_drive_write( 0x11,  0x00,  0x34,  0x23);   /* 35 Tracks/Disk */
  311.             ext_drive_write( 0x11,  0x00,  0x35,  0x10);   /* 16 Sectors / T */
  312.             ext_drive_write( 0x11,  0x00,  0x36,  0x00);   /* 0x0100 & 0xFF  */
  313.             ext_drive_write( 0x11,  0x00,  0x37,  0x01);   /* >> 8;  Bytes/S */
  314.  
  315.             for (byte_pos = 0x0038;byte_pos < 0x00C4;byte_pos += 4)
  316.             {
  317.                ext_drive_write( 0x11, 0x00, byte_pos + 0, 0xFF);
  318.                ext_drive_write( 0x11, 0x00, byte_pos + 1, 0xFF);
  319.                ext_drive_write( 0x11, 0x00, byte_pos + 2, 0x00);
  320.                ext_drive_write( 0x11, 0x00, byte_pos + 3, 0x00);
  321.             }
  322.  
  323.             if ((dir_pointer = open_dir( WORK_DIR)) == NULL)
  324.             {
  325.                printf("Internal error can't open '%s'\n", WORK_DIR);
  326.                exit( -1);
  327.             }
  328.  
  329.             curr_sector = 0x0F;
  330.             mem_sector_malloc( ext_drive_pointer [0x11] [curr_sector]);
  331.  
  332.             ext_drive_write( 0x11, curr_sector, 0x01, 0x11);
  333.             ext_drive_write( 0x11, curr_sector, 0x02, curr_sector - 1);
  334.  
  335.             filenum_on_sec  = 0;
  336.             next_tsl        = 0x1200;
  337.             while (dir_next_file( name_buffer, dir_pointer) )
  338.             {
  339.                short   file_size,
  340.                        number_of_tslist,
  341.                        curr_num_tslist,
  342.                        pos_in_tslist;
  343.                char    temp_path [256];
  344.                long    file_pos;
  345.  
  346.                sprintf( temp_path, "%s>%s", WORK_DIR, name_buffer);
  347.                file_size = fsize( temp_path);
  348.                number_of_tslist = file_size /
  349.                                      ext_drive_read( 0x11, 0x00, 0x27) + 1;
  350.  
  351.                ext_drive_write( 0x11, curr_sector,
  352.                                 file_per_sec * 0x23 + 0x0B, next_tsl >> 8);
  353.                ext_drive_write( 0x11, curr_sector,
  354.                                 file_per_sec * 0x23 + 0x0C, next_tsl & 0xFF);
  355.  
  356.  
  357.                ext_drive_write( 0x11, curr_sector,
  358.                                 file_per_sec * 0x23 + 0x0D, 0x10);
  359.  
  360.                if (fsufix( name_buffer, "TXT") )
  361.                   ext_drive_write( 0x11, curr_sector,
  362.                                 file_per_sec * 0x23 + 0x0D, 0x00);
  363.  
  364.                if (fsufix( name_buffer, "BAS") )
  365.                   ext_drive_write( 0x11, curr_sector,
  366.                                 file_per_sec * 0x23 + 0x0D, 0x02);
  367.  
  368.                if (fsufix( name_buffer, "OBJ") )
  369.                   ext_drive_write( 0x11, curr_sector,
  370.                                 file_per_sec * 0x23 + 0x0D, 0x04);
  371.  
  372.                for (loop = 0;loop < 30;loop ++)
  373.                   ext_drive_write( 0x11, curr_sector,
  374.                                    file_per_sec * 0x23 + 0x0E + loop, ' ');
  375.  
  376.                for (loop = 0;loop < strlen( name_buffer);loop ++)
  377.                   ext_drive_write( 0x11, curr_sector,
  378.                                    file_per_sec * 0x23 + 0x0E + loop,
  379.                                                    name_buffer [loop] );
  380.  
  381.                ext_drive_write( 0x11, curr_sector,
  382.                                 file_per_sec * 0x23 + 0x2C,
  383.                                      (file_size + 1) & 0xFF );
  384.                ext_drive_write( 0x11, curr_sector,
  385.                                 file_per_sec * 0x23 + 0x2D,
  386.                                      (file_size + 1) >>  8 );
  387.  
  388.  
  389.                /* Fix the T/S List for the current file */
  390.                mem_sector_malloc( ext_drive_pointer [next_tsl >>   8]
  391.                                                     [next_tsl & 0xFF]);
  392.                next_aloc_sec = next_tsl;
  393.                inc_ts_pointer( &next_aloc_sec, 1);
  394.  
  395.                file_pos        = 0;
  396.                curr_num_tslist = 1;
  397.                while (curr_num_tslist <= number_of_tslist)
  398.                {
  399.                   FILE   * file_pointer;
  400.  
  401.                   file_sector_malloc( ext_drive_pointer [next_aloc_sec >>   8]
  402.                                                        [next_aloc_sec  & 0xFF]);
  403.  
  404.                   file_pointer = fopen( temp_path, opening_mode);
  405.                   if (file_pointer == NULL)
  406.                   {
  407.                      printf("Can't open file '%s' (open_ext_drive)\n",
  408.                                                                temp_path );
  409.                      exit( -1);
  410.                   }
  411.  
  412.                   pos_in_tslist = 0;
  413.                   while (pos_in_tslist < ext_drive_read( 0x11, 0x00, 0x27) )
  414.                   {
  415.                      ext_drive_write( next_tsl >> 8, next_tsl & 0xFF +
  416.                                                      pos_in_tslist + 0x0C,
  417.                                                      next_aloc_sec >>   8 );
  418.                      ext_drive_write( next_tsl >> 8, next_tsl & 0xFF +
  419.                                                      pos_in_tslist + 0x0D,
  420.                                                      next_aloc_sec & 0xFF );
  421.                      pos_in_tslist += 2;
  422.                      inc_ts_pointer( &next_aloc_sec, 1);
  423.  
  424.  
  425.                      ( (FILE_SEC *) ext_drive_pointer)->file_pointer =
  426.                                                                 file_pointer;
  427.                      ( (FILE_SEC *) ext_drive_pointer)->index = file_pos;
  428.  
  429.                      file_pos += 256;
  430.  
  431.                      file_sector_malloc( ext_drive_pointer [next_aloc_sec >> 8]
  432.                                                        [next_aloc_sec & 0xFF]);
  433.  
  434.                   }
  435.  
  436.                   curr_num_tslist ++;
  437.  
  438.  
  439.  
  440.                next_aloc_sec = next_tsl;
  441.                inc_ts_pointer( &next_aloc_sec, 1);
  442.  
  443.  
  444.  
  445.  
  446.  
  447.  
  448.                /* Fix the T/S List for the current file */
  449.  
  450.                ext_drive_pointer [next_tsl >>   8]
  451.                                  [next_tsl & 0xFF] [0x
  452.  
  453.                number_of_tslist = 1;
  454.                while (number_of_tslist)
  455.                {
  456.                   if (loop > 1)
  457.  
  458.  
  459.                   inc_ts_pointer( &next_tsl,
  460.  
  461. short  **ext_drive_sectors;
  462.  
  463.  
  464. inc_ts_pointer(
  465.    short  alocat_pointer [35][16];
  466.  
  467.  
  468.                file_per_sec ++;
  469.                if (file_per_sec >= 8)
  470.                {
  471.                   curr_sector --;
  472.  
  473.                   inc_ts_pointer( &next_tsl, number_of_tslist);
  474.  
  475.                   ext_drive_pointer [(curr_sector << 8) | 0x01] = 0x11;
  476.                   ext_drive_pointer [(curr_sector << 8) | 0x02] =
  477.                                                               curr_sector - 1;
  478.                   ext_drive_pointer [(curr_sector << 8) | 0x0B] =
  479.                                                               next_tsl >> 8;
  480.                   ext_drive_pointer [(curr_sector << 8) | 0x0C] =
  481.                                                               next_tsl & 0xFF;
  482.  
  483.                   file_per_sec = 0;
  484.                }
  485.  
  486.                if (curr_sector == 0)
  487.                {
  488.                   printf("Internal error To meny Files in ext_dir\n");
  489.                   exit( -1);
  490.                }
  491.  
  492.             }  /* Until end of dir */
  493.  
  494.             if (curr_sector != 0)
  495.             {
  496.                ext_drive_pointer [(curr_sector << 8) | 0x01] = 0x11;
  497.                ext_drive_pointer [(curr_sector << 8) | 0x02] = curr_sector - 1;
  498.             }
  499.  
  500.          }  /* End of   VTOC init  */
  501.          break;
  502.  
  503.       default:
  504.          printf("Can't find the drive %d  (open)\n", drive);
  505.          exit( -1);
  506.  
  507.    }
  508.  
  509.    current_drive     = drive;
  510.    current_open_mode = mode;
  511.    return FALSE;
  512. }
  513.  
  514. disk_seek( track, sector, relative_pos)
  515. short  track,
  516.        sector,
  517.        relative_pos;
  518. {
  519.    long    position;
  520.  
  521.    if (int_drive_pointer == NULL)
  522.    {
  523.       printf("You haven't open the drive yet!\n");
  524.       exit (-1);
  525.    }
  526.  
  527.    switch (current_drive)
  528.    {
  529.       case 0x01:
  530.          position = track * 0x1040 + sector * 0x104 + relative_pos;
  531.          fseek( int_drive_pointer, (long) position, 0);
  532.          break;
  533.  
  534.       case 0x02:
  535.          ext_drive_info.track  = track;
  536.          ext_drive_info.sector = sector;
  537.          ext_drive_info.byte   = relative_pos;
  538.          break;
  539.  
  540.       default:
  541.          printf("Internal error in seek\n");
  542.          exit( -1);
  543.    }
  544.  
  545. }
  546.  
  547. disk_read( buffer, length)
  548. char   buffer [];
  549. short  length;
  550. {
  551.    if (int_drive_pointer == NULL)
  552.    {
  553.       printf("You haven't open the drive yet!\n");
  554.       exit (-1);
  555.    }
  556.  
  557.    switch (current_drive)
  558.    {
  559.       case 0x01:
  560.          fread( buffer, sizeof (char), length, int_drive_pointer);
  561.          break;
  562.  
  563.       case 0x02:
  564.          if (ext_drive_info.track == 0x11)
  565.          {
  566.             buffer [0] = ext_drive_info.volume;
  567.             buffer [1] = ext_drive_info.track;
  568.             buffer [2] = ext_drive_info.sector;
  569.             buffer [3] = 0x55;   /* Dummy */
  570.  
  571.             memcpy( buffer + 4,
  572.                     &ext_drive_pointer [(ext_drive_info.sector << 8) |
  573.                                                     ext_drive_info.byte],
  574.                                                                    length );
  575.             break;
  576.          }
  577.  
  578. printf("track %x   sector %x  byte %x\n", ext_drive_info.track,
  579.                                           ext_drive_info.sector,
  580.                                           ext_drive_info.byte);
  581. break;
  582.          fread( §or_info, sizeof (sector_info), 1, int_drive_pointer);
  583.          if (sector_info.in_use)
  584.          {
  585.             FILE   * file_pointer;
  586.             char     temp_path [256];
  587.  
  588.             sprintf( temp_path, "%s>%s", WORK_DIR, sector_info.file_name);
  589.             file_pointer = fopen( temp_path, "i");
  590.             if (file_pointer == NULL)
  591.             {
  592.                printf("Iternal error in read from file '%s'\n", temp_path);
  593.                exit( -1);
  594.             }
  595.  
  596.             fread( buffer, sizeof (char), length, file_pointer);
  597.             fclose( file_pointer);
  598.          }
  599.  
  600.          else
  601.          {
  602.             short loop;
  603.  
  604.             for (loop = 0;loop < length;loop ++)
  605.                buffer [loop] = '\0';
  606.          }
  607.          break;
  608.  
  609.       default:
  610.          printf("Internal error in read\n");
  611.          exit( -1);
  612.  
  613.  
  614.    }
  615. }
  616.  
  617. disk_write( buffer, length)
  618. char   buffer [];
  619. short  length;
  620. {
  621.    if (int_drive_pointer == NULL)
  622.    {
  623.       printf("You haven't open the drive yet!\n");
  624.       exit (-1);
  625.    }
  626.  
  627.    if (current_drive == 0x01)
  628.       return fwrite( buffer, sizeof (char), length, int_drive_pointer);
  629.  
  630.    if (current_drive == 0x02)
  631.    {
  632.       FILE   * file_pointer;
  633.       char     temp_path [256];
  634.  
  635. printf("Not istall yet\n");
  636. exit(-1);
  637.       fread( §or_info, sizeof (sector_info), 1, int_drive_pointer);
  638.       if (!sector_info.in_use)
  639.       {
  640.          sector_info.in_use = TRUE;
  641.          sprintf( sector_info.file_name, "sector%02x%02x", sector_info.track,
  642.                                                            sector_info.sector);
  643.          sector_info.position = 0;
  644.          disk_open( _WRITE, current_slot, 0x02, current_volume);
  645.          disk_seek( sector_info.track, sector_info.sector,
  646.                                        sector_info.position);
  647.          fwrite( §or_info, sizeof (sector_info), 1, int_drive_pointer);
  648.       }
  649.  
  650.       sprintf( temp_path, "%s>%s", WORK_DIR, sector_info.file_name);
  651.       file_pointer = fopen( temp_path, "o");
  652.       if (file_pointer == NULL)
  653.       {
  654.          printf("Internal error in write, can't read from file '%s'\n",
  655.                                                   sector_info.file_name );
  656.          exit( -1);
  657.       }
  658.  
  659.       fwrite( buffer, sizeof (char), length, file_pointer);
  660.       fclose( file_pointer);
  661.  
  662.       return;
  663.    }
  664.  
  665.    printf("Internal error in write, can't found the drive %d\n",
  666.                                                    current_drive  );
  667.    exit( -1);
  668. }
  669.  
  670. disk_close()
  671. {
  672.    if (int_drive_pointer == NULL)
  673.    {
  674.       printf("You haven't open the drive yet!\n");
  675.       exit (-1);
  676.    }
  677.  
  678. /*
  679. put on waiting
  680.    fclose( int_drive_pointer);
  681.    int_drive_pointer = NULL;
  682. */
  683. }
  684.  
  685. format_ext_drive( slot)
  686. short  slot;
  687. {
  688.    short  track,
  689.           sector;
  690.  
  691.    disk_open( _WRITE, slot, 0x02, 0x00);
  692.    for (track = 0;track < 35;track ++)
  693.    {
  694.       for (sector = 0;sector < 16;sector ++)
  695.       {
  696.          sector_info.in_use       = FALSE;
  697.          sector_info.track        = track;
  698.          sector_info.sector       = sector;
  699.          (*sector_info.file_name) = '\0';
  700.          sector_info.position     = 0;
  701. printf("init\n");
  702. /*         fwrite( §or_info, sizeof (sector_info), 1, int_drive_pointer);*/
  703.       }
  704.    }
  705.  
  706. }
  707.  
  708.  
  709.  
  710.