home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / atari / atari800-0.8.6 / devices.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-05-10  |  7.3 KB  |  552 lines
  1.  
  2. #include    <stdio.h>
  3. #include    <stdlib.h>
  4. #include    <string.h>
  5. #include    <ctype.h>
  6.  
  7. #ifdef VMS
  8. #include    <unixio.h>
  9. #include    <file.h>
  10. #else
  11. #include    <fcntl.h>
  12. #ifndef    AMIGA
  13. #include    <unistd.h>
  14. #endif
  15. #endif
  16.  
  17. #define    DO_DIR
  18.  
  19. #ifdef AMIGA
  20. #undef    DO_DIR
  21. #endif
  22.  
  23. #ifdef VMS
  24. #undef    DO_DIR
  25. #endif
  26.  
  27. #ifdef DO_DIR
  28. #include    <dirent.h>
  29. #endif
  30.  
  31. static char *rcsid = "$Id: devices.c,v 1.21 1998/02/21 15:17:44 david Exp $";
  32.  
  33. #define FALSE   0
  34. #define TRUE    1
  35.  
  36. #include "atari.h"
  37. #include "cpu.h"
  38. #include "devices.h"
  39. #include "rt-config.h"
  40.  
  41. #define    ICHIDZ    0x0020
  42. #define    ICDNOZ    0x0021
  43. #define    ICCOMZ    0x0022
  44. #define    ICSTAZ    0x0023
  45. #define    ICBALZ    0x0024
  46. #define    ICBAHZ    0x0025
  47. #define    ICPTLZ    0x0026
  48. #define    ICPTHZ    0x0027
  49. #define    ICBLLZ    0x0028
  50. #define    ICBLHZ    0x0029
  51. #define    ICAX1Z    0x002a
  52. #define    ICAX2Z    0x002b
  53.  
  54. static char *H[5] =
  55. {
  56.     ".",
  57.     atari_h1_dir,
  58.     atari_h2_dir,
  59.     atari_h3_dir,
  60.     atari_h4_dir
  61. };
  62.  
  63. static int devbug = FALSE;
  64.  
  65. static FILE *fp[8] =
  66. {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
  67. static int flag[8];
  68.  
  69. static int fid;
  70. static char filename[64];
  71.  
  72. #ifdef DO_DIR
  73. static DIR *dp = NULL;
  74. #endif
  75.  
  76. char *strtoupper (char *str)
  77. {
  78.   char *ptr;
  79.   for (ptr=str;*ptr;ptr++)
  80.     *ptr = toupper(*ptr);
  81.  
  82.   return str;
  83. }
  84.  
  85. void Device_Initialise(int *argc, char *argv[])
  86. {
  87.     int i;
  88.     int j;
  89.  
  90.     for (i = j = 1; i < *argc; i++) {
  91.         if (strncmp(argv[i], "-H1", 2) == 0)
  92.             H[1] = argv[i] + 2;
  93.         else if (strncmp(argv[i], "-H2", 2) == 0)
  94.             H[2] = argv[i] + 2;
  95.         else if (strncmp(argv[i], "-H3", 2) == 0)
  96.             H[3] = argv[i] + 2;
  97.         else if (strncmp(argv[i], "-H4", 2) == 0)
  98.             H[4] = argv[i] + 2;
  99.         else if (strcmp(argv[i], "-devbug") == 0)
  100.             devbug = TRUE;
  101.         else
  102.             argv[j++] = argv[i];
  103.     }
  104.  
  105.     if (devbug)
  106.         for (i = 0; i < 5; i++)
  107.             printf("H%d: %s\n", i, H[i]);
  108.  
  109.     *argc = j;
  110. }
  111.  
  112. int Device_isvalid(char ch)
  113. {
  114.     int valid;
  115.  
  116.     if (isalnum(ch))
  117.         valid = TRUE;
  118.     else
  119.         switch (ch) {
  120.         case ':':
  121.         case '.':
  122.         case '_':
  123.         case '*':
  124.         case '?':
  125.             valid = TRUE;
  126.             break;
  127.         default:
  128.             valid = FALSE;
  129.             break;
  130.         }
  131.  
  132.     return valid;
  133. }
  134.  
  135. void Device_GetFilename()
  136. {
  137.     int bufadr;
  138.     int offset = 0;
  139.     int devnam = TRUE;
  140.  
  141.     bufadr = (memory[ICBAHZ] << 8) | memory[ICBALZ];
  142.  
  143.     while (Device_isvalid(memory[bufadr])) {
  144.         int byte = memory[bufadr];
  145.  
  146.         if (!devnam) {
  147.             if (isupper(byte))
  148.                 byte = tolower(byte);
  149.  
  150.             filename[offset++] = byte;
  151.         }
  152.         else if (byte == ':')
  153.             devnam = FALSE;
  154.  
  155.         bufadr++;
  156.     }
  157.  
  158.     filename[offset++] = '\0';
  159. }
  160.  
  161. int match(char *pattern, char *filename)
  162. {
  163.     int status = TRUE;
  164.  
  165.     while (status && *filename && *pattern) {
  166.         switch (*pattern) {
  167.         case '?':
  168.             pattern++;
  169.             filename++;
  170.             break;
  171.         case '*':
  172.             if (*filename == pattern[1]) {
  173.                 pattern++;
  174.             }
  175.             else {
  176.                 filename++;
  177.             }
  178.             break;
  179.         default:
  180.             status = (*pattern++ == *filename++);
  181.             break;
  182.         }
  183.     }
  184.     if ((*filename)
  185.         || ((*pattern)
  186.             && (((*pattern != '*') && (*pattern != '?'))
  187.                 || pattern[1]))) {
  188.         status = 0;
  189.     }
  190.     return status;
  191. }
  192.  
  193. void Device_HHOPEN(void)
  194. {
  195.     char fname[128];
  196.     int devnum;
  197.     int temp;
  198.  
  199.     if (devbug)
  200.         printf("HHOPEN\n");
  201.  
  202.     fid = memory[0x2e] >> 4;
  203.  
  204.     if (fp[fid]) {
  205.         fclose(fp[fid]);
  206.         fp[fid] = NULL;
  207.     }
  208. /*
  209.    flag[fid] = (memory[ICDNOZ] == 2) ? TRUE : FALSE;
  210.  */
  211.     Device_GetFilename();
  212. /*
  213.    if (memory[ICDNOZ] == 0)
  214.    sprintf (fname, "./%s", filename);
  215.    else
  216.    sprintf (fname, "%s/%s", h_prefix, filename);
  217.  */
  218.     devnum = memory[ICDNOZ];
  219.     if (devnum > 9) {
  220.         printf("Attempt to access H%d: device\n", devnum);
  221.         exit(1);
  222.     }
  223.     if (devnum >= 5) {
  224.         flag[fid] = TRUE;
  225.         devnum -= 5;
  226.     }
  227.     else {
  228.         flag[fid] = FALSE;
  229.     }
  230.  
  231. #ifdef VMS
  232. /* Assumes H[devnum] is a directory _logical_, not an explicit directory
  233.    specification! */
  234.     sprintf(fname, "%s:%s", H[devnum], filename);
  235. #else
  236.     sprintf(fname, "%s/%s", H[devnum], filename);
  237. #endif
  238.  
  239.     temp = memory[ICAX1Z];
  240.  
  241.     switch (temp) {
  242.     case 4:
  243.         fp[fid] = fopen(fname, "rb");
  244.         if (fp[fid]) {
  245.             regY = 1;
  246.             ClrN;
  247.         }
  248.         else {
  249.             regY = 170;
  250.             SetN;
  251.         }
  252.         break;
  253.     case 6:
  254.     case 7:
  255. #ifdef DO_DIR
  256.         fp[fid] = tmpfile();
  257.         if (fp[fid]) {
  258.             dp = opendir(H[devnum]);
  259.             if (dp) {
  260.                 struct dirent *entry;
  261.  
  262.                 while ((entry = readdir(dp))) {
  263.                     if (match(filename, entry->d_name))
  264.                         fprintf(fp[fid], "%s\n", strtoupper(entry->d_name));
  265.                 }
  266.  
  267.                 closedir(dp);
  268.  
  269.                 regY = 1;
  270.                 ClrN;
  271.  
  272.                 rewind(fp[fid]);
  273.  
  274.                 flag[fid] = TRUE;
  275.             }
  276.             else {
  277.                 regY = 163;
  278.                 SetN;
  279.                 fclose(fp[fid]);
  280.                 fp[fid] = NULL;
  281.             }
  282.         }
  283.         else
  284. #endif
  285.         {
  286.             regY = 163;
  287.             SetN;
  288.         }
  289.         break;
  290.     case 8:
  291.         fp[fid] = fopen(fname, "wb");
  292.         if (fp[fid]) {
  293.             regY = 1;
  294.             ClrN;
  295.         }
  296.         else {
  297.             regY = 170;
  298.             SetN;
  299.         }
  300.         break;
  301.     default:
  302.         regY = 163;
  303.         SetN;
  304.         break;
  305.     }
  306. }
  307.  
  308. void Device_HHCLOS(void)
  309. {
  310.     if (devbug)
  311.         printf("HHCLOS\n");
  312.  
  313.     fid = memory[0x2e] >> 4;
  314.  
  315.     if (fp[fid]) {
  316.         fclose(fp[fid]);
  317.         fp[fid] = NULL;
  318.     }
  319.     regY = 1;
  320.     ClrN;
  321. }
  322.  
  323. void Device_HHREAD(void)
  324. {
  325.     if (devbug)
  326.         printf("HHREAD\n");
  327.  
  328.     fid = memory[0x2e] >> 4;
  329.  
  330.     if (fp[fid]) {
  331.         int ch;
  332.  
  333.         ch = fgetc(fp[fid]);
  334.         if (ch != EOF) {
  335.             if (flag[fid]) {
  336.                 switch (ch) {
  337.                 case '\n':
  338.                     ch = 0x9b;
  339.                     break;
  340.                 default:
  341.                     break;
  342.                 }
  343.             }
  344.             regA = ch;
  345.             regY = 1;
  346.             ClrN;
  347.         }
  348.         else {
  349.             regY = 136;
  350.             SetN;
  351.         }
  352.     }
  353.     else {
  354.         regY = 163;
  355.         SetN;
  356.     }
  357. }
  358.  
  359. void Device_HHWRIT(void)
  360. {
  361.     if (devbug)
  362.         printf("HHWRIT\n");
  363.  
  364.     fid = memory[0x2e] >> 4;
  365.  
  366.     if (fp[fid]) {
  367.         int ch;
  368.  
  369.         ch = regA;
  370.         if (flag[fid]) {
  371.             switch (ch) {
  372.             case 0x9b:
  373.                 ch = 0x0a;
  374.                 break;
  375.             default:
  376.                 break;
  377.             }
  378.         }
  379.         fputc(ch, fp[fid]);
  380.         regY = 1;
  381.         ClrN;
  382.     }
  383.     else {
  384.         regY = 163;
  385.         SetN;
  386.     }
  387. }
  388.  
  389. void Device_HHSTAT(void)
  390. {
  391.     if (devbug)
  392.         printf("HHSTAT\n");
  393.  
  394.     fid = memory[0x2e] >> 4;
  395.  
  396.     regY = 146;
  397.     SetN;
  398. }
  399.  
  400. void Device_HHSPEC(void)
  401. {
  402.     if (devbug)
  403.         printf("HHSPEC\n");
  404.  
  405.     fid = memory[0x2e] >> 4;
  406.  
  407.     switch (memory[ICCOMZ]) {
  408.     case 0x20:
  409.         printf("RENAME Command\n");
  410.         break;
  411.     case 0x21:
  412.         printf("DELETE Command\n");
  413.         break;
  414.     case 0x23:
  415.         printf("LOCK Command\n");
  416.         break;
  417.     case 0x24:
  418.         printf("UNLOCK Command\n");
  419.         break;
  420.     case 0x25:
  421.         printf("NOTE Command\n");
  422.         break;
  423.     case 0x26:
  424.         printf("POINT Command\n");
  425.         break;
  426.     case 0xFE:
  427.         printf("FORMAT Command\n");
  428.         break;
  429.     default:
  430.         printf("UNKNOWN Command\n");
  431.         break;
  432.     }
  433.  
  434.     regY = 146;
  435.     SetN;
  436. }
  437.  
  438. void Device_HHINIT(void)
  439. {
  440.     if (devbug)
  441.         printf("HHINIT\n");
  442. }
  443.  
  444. static int phfd = -1;
  445. void Device_PHCLOS(void);
  446. static char *spool_file = NULL;
  447.  
  448. void Device_PHOPEN(void)
  449. {
  450.     if (devbug)
  451.         printf("PHOPEN\n");
  452.  
  453.     if (phfd != -1)
  454.         Device_PHCLOS();
  455.  
  456.     spool_file = tmpnam(NULL);
  457.     phfd = open(spool_file, O_CREAT | O_TRUNC | O_WRONLY, 0777);
  458.     if (phfd != -1) {
  459.         regY = 1;
  460.         ClrN;
  461.     }
  462.     else {
  463.         regY = 130;
  464.         SetN;
  465.     }
  466. }
  467.  
  468. void Device_PHCLOS(void)
  469. {
  470.     if (devbug)
  471.         printf("PHCLOS\n");
  472.  
  473.     if (phfd != -1) {
  474.         char command[256];
  475.         int status;
  476.  
  477.         close(phfd);
  478.  
  479.         sprintf(command, print_command, spool_file);
  480.         system(command);
  481.  
  482. #ifndef VMS
  483.         status = unlink(spool_file);
  484.         if (status == -1) {
  485.             perror(spool_file);
  486.             exit(1);
  487.         }
  488. #endif
  489.  
  490.         phfd = -1;
  491.     }
  492.     regY = 1;
  493.     ClrN;
  494. }
  495.  
  496. void Device_PHREAD(void)
  497. {
  498.     if (devbug)
  499.         printf("PHREAD\n");
  500.  
  501.     regY = 146;
  502.     SetN;
  503. }
  504.  
  505. void Device_PHWRIT(void)
  506. {
  507.     unsigned char byte;
  508.     int status;
  509.  
  510.     if (devbug)
  511.         printf("PHWRIT\n");
  512.  
  513.     byte = regA;
  514.     if (byte == 0x9b)
  515.         byte = '\n';
  516.  
  517.     status = write(phfd, &byte, 1);
  518.     if (status == 1) {
  519.         regY = 1;
  520.         ClrN;
  521.     }
  522.     else {
  523.         regY = 144;
  524.         SetN;
  525.     }
  526. }
  527.  
  528. void Device_PHSTAT(void)
  529. {
  530.     if (devbug)
  531.         printf("PHSTAT\n");
  532. }
  533.  
  534. void Device_PHSPEC(void)
  535. {
  536.     if (devbug)
  537.         printf("PHSPEC\n");
  538.  
  539.     regY = 1;
  540.     ClrN;
  541. }
  542.  
  543. void Device_PHINIT(void)
  544. {
  545.     if (devbug)
  546.         printf("PHINIT\n");
  547.  
  548.     phfd = -1;
  549.     regY = 1;
  550.     ClrN;
  551. }
  552.