home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archimedes / aramis.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  7KB  |  433 lines
  1. /* -> c.ckamis
  2.  */
  3.  
  4. #include "ckcdeb.h"
  5.  
  6. #ifdef ANSI
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <limits.h>
  11. #include "ckatio.h"
  12. #include "ckafio.h"
  13. #include <assert.h>
  14. #include "ckamis.h"
  15. #include "ckuusr.h"
  16. #endif
  17.  
  18. #ifdef ARTHUR
  19. #include "arthur.h"
  20. #include "plib.h"
  21. #include "tty.h"
  22. #endif
  23.  
  24. #ifdef PANOS
  25. #include "time.h"
  26. #endif
  27.  
  28. extern char *CWDCMD;
  29. extern int RawFrig;
  30.  
  31. static reg_set rs;
  32. static error *ret_val;
  33.  
  34. void
  35. gettimeofday(time_now, time_zone)
  36. timeval *time_now;
  37. int *time_zone;
  38. {
  39.       XBinaryTime(time_now);
  40.       *time_zone = 0;
  41. }
  42.  
  43. unsigned int timerdiff(ts, tf)
  44. timeval ts, tf;
  45. {
  46. /*
  47.  * Returns difference(in centi-seconds) between 2 time
  48.  * stamp records.  NB uses simplified double-precision
  49.  * algorithm: ts is start time; tf is finishing time,
  50.  * assumed greater than ts.
  51.  */
  52. #ifdef ANSI
  53. #define MAX_U_INT UINT_MAX
  54. #else
  55. #define MAX_U_INT (unsigned int) 0xFFFFFFFF
  56. #endif
  57.   unsigned int diff;
  58.  
  59. #ifdef ANSI  
  60.   if( (tf.high = ts.high) != 0 )
  61. #else
  62.   if(tf.high = ts.high)
  63. #endif
  64.     diff =(tf.low - ts.low);  /* in centi-seconds */
  65.   else if((tf.high > ts.high + 1) || (tf.low > ts.low))
  66.     diff = MAX_U_INT; /* vast difference */
  67.   else
  68.     diff =(tf.low +(MAX_U_INT - ts.low) + 1);
  69.   return diff;
  70. }
  71.  
  72. static timeval epoch;
  73.  
  74. void
  75. rtimer()
  76. { int timezone;
  77.   gettimeofday(&epoch, &timezone);
  78. }
  79.  
  80. unsigned int
  81. gtimer()
  82. { timeval now; int timezone;
  83.   gettimeofday(&now, &timezone);
  84.   return (timerdiff(now, epoch) / 100);
  85. }
  86.  
  87. void
  88. sleep(secs) int secs; {
  89.   msleep(secs * 1000);
  90. }
  91.  
  92. void
  93. eraseleft() {
  94.   XSWriteByte(RawFrig, 127);
  95. }
  96.  
  97. void
  98. beep() {
  99.   XSWriteByte(RawFrig, 7);
  100. }
  101.  
  102. /***************************************/
  103. /*    C H D I R  --  Change directory  */
  104. /***************************************/
  105. int
  106. chdir(dirnam) char *dirnam; {
  107. char cmdstr [512];
  108. char *prefix, *suffix;
  109.   char *cp;
  110.   prefix = CWDCMD; suffix = dirnam;
  111.   for (cp = cmdstr; *prefix != '\0'; *cp++ = *prefix++) ;
  112. #ifdef ANSI
  113.   while ( (*cp++ = *suffix++) != '\0' ) ;
  114. #else
  115.   while (*cp++ = *suffix++) ;
  116. #endif
  117.   system(cmdstr);
  118.   return(0);
  119. }
  120.  
  121. void
  122. setbaud(speed) int speed; {
  123. int fx;
  124.  
  125.   switch (speed) {
  126.   case 75: fx = 1; break;
  127.   case 150: fx = 2; break;
  128.   case 300: fx = 3; break;
  129.   case 1200: fx = 4; break;
  130.   case 2400: fx = 5; break;
  131.   case 4800: fx = 6; break;
  132.   case 9600: fx = 7; break;
  133.   case 19200: fx = 8; break;
  134.   default:
  135.     fx = 7; break;
  136.   }
  137.  
  138.   rs.r[0] = 7;
  139.   rs.r[1] = fx;
  140.   ret_val = osbyte( &rs );
  141.  
  142.   rs.r[0] = 8;
  143.   rs.r[1] = fx;
  144.   ret_val = osbyte( &rs );
  145.  
  146. }
  147.  
  148. int
  149. baudint(newx) int newx; {
  150.   switch (newx&7) {
  151.   case 0: return(75);
  152.   case 1: return(150);
  153.   case 2: return(300);
  154.   case 3: return(1200);
  155.   case 4: return(2400);
  156.   case 5: return(4800);
  157.   case 6: return(9600);
  158.   case 7: return(19200);
  159.   default:  return(-1);
  160.   }
  161.  
  162. }
  163.  
  164.  
  165. int
  166. dfbaudr () {
  167. int fx7code, fx8code;
  168.  
  169.  
  170.     /* Read baud rate from CMOS ram, can't read directly using fx7 */
  171.  
  172.     rs.r[0] = 161;
  173.     rs.r[1] = 15;
  174.     rs.r[2] = 0x0;
  175.     ret_val = osbyte( &rs );
  176.  
  177.     fx7code = fx8code = (rs.r[2] >> 2) & 0x7;
  178.  
  179.     if (fx7code != fx8code) {
  180.        printf("Warning - split baud rates not supported - %d:%d\n\
  181.   Please set speed <nnn> immediately\n",
  182.        baudint(fx7code), baudint(fx8code));
  183.     } else {
  184.       setbaud(baudint(fx7code));
  185.     }
  186.   
  187.   return(baudint(fx7code));
  188.  
  189. }
  190.  
  191. void
  192. DirtyFlush(buffer) int buffer; {
  193.  
  194.     rs.r[0] = 21;
  195.     rs.r[1] = buffer;
  196.     ret_val = osbyte( &rs );
  197.  
  198. }
  199.  
  200. void
  201. fx(a,x,y) int a,x,y; {
  202.  
  203.     rs.r[0] = a; 
  204.     rs.r[1] = x;
  205.     rs.r[2] = y;
  206.     ret_val = osbyte( &rs );
  207.  
  208. }
  209.  
  210. static char escape_char;
  211.  
  212. void
  213. initrs() {
  214.  
  215.   /* This should be in ttvt in ckptio - should also be undone afterwards */
  216.   fx(204,0,0);
  217.   fx(2,2,0);
  218.   fx(3,0,0);
  219.   fx(181,1,0);
  220.   fx(202,48,0);
  221.   fx(118,0,0);
  222.  
  223.   rs.r[0] = 220;
  224.   rs.r[1] = 0;
  225.   rs.r[2] = 255;
  226.   ret_val = osbyte( &rs );
  227.   escape_char = rs.r[1];
  228. } 
  229.  
  230. void
  231. termrs() {
  232.   
  233.   rs.r[0] = 220;
  234.   rs.r[1] = escape_char;
  235.   rs.r[2] = 0;
  236.   ret_val = osbyte( &rs );
  237.  
  238. }
  239.  
  240. int
  241. testbf(buff, val) int buff; int *val; {
  242. #define keybf      0
  243. #define rs423inbf  1
  244. #define rs423outbf 2
  245.  
  246. int ch;
  247.  
  248.     switch( buff )
  249.     {
  250.         case keybf:
  251. #ifndef ARTHUR
  252.             rs.r[0] = 145;
  253.             rs.r[1] = buff;
  254.             ch = rs.r[2] = 0xff00;
  255.  
  256.             ret_val = osbyte( &rs );
  257.  
  258.             if ( ch != rs.r[2] )
  259.             { /* not empty */
  260.                  *val = rs.r[2] & 0xff;
  261.                  return 1;
  262.             }
  263.             return 0;
  264. #endif
  265.             ch = kbremove(buff);
  266.             if( ch == 0 )
  267.                 return 0;
  268.  
  269.             *val = ch & 0xff;
  270.             return 1;
  271.             break;
  272.         case rs423inbf:
  273.         case rs423outbf:
  274.             if( (ch = rsremove(buff)) == 0 )
  275.                 return 0;
  276.  
  277.             *val = ch & 0xff;
  278.             return 1;
  279.             break;
  280.         default:
  281.             fatal("Bad buff number\n");
  282.     }
  283.  
  284.     return 0;
  285.  
  286. }
  287.  
  288. int
  289. putinbf(buff, val) int buff, val; {
  290.  
  291.   rs.r[0] = 153;
  292.   rs.r[1] = buff;
  293.   rs.r[2] = val;
  294.   ret_val = osbyte( &rs );
  295.  
  296.   return(1);
  297.  
  298.  
  299. }
  300.  
  301. int nrsbuf() { /* returns number of chars in RS423 input buffer */
  302.     return rscount( 0, 1 );
  303. }
  304.  
  305. void
  306. get_posn(x,y) int *x,*y; { /* returns Beeb text cursor coords */
  307.   
  308.   rs.r[0] = 134;
  309.   rs.r[1] = 0;
  310.   rs.r[2] = 0;
  311.  
  312.   ret_val = osbyte( &rs );
  313.   *x = rs.r[1];
  314.   *y = rs.r[2];
  315.  
  316. }
  317.  
  318. error *mosbyte3r(int r0, int r1, int r2)
  319. {       rs.r[0] = r0;
  320.         rs.r[1] = r1;
  321.         rs.r[2] = r2;
  322.         return (osbyte(&rs));
  323. }
  324.  
  325. void mosbyte3(int r0, int r1, int r2) { mosbyte3r(r0, r1, r2); }
  326.  
  327.  
  328. #define MAXNAMLEN 255
  329. static char dirname[MAXNAMLEN];
  330. static char cmdbuf[MAXNAMLEN+4];
  331.  
  332.  
  333. int
  334. getcwd()
  335. {
  336. osgbpb_block ctl_blk;
  337. error *ret;
  338. char buf[16];
  339. int len;
  340.  
  341.  
  342.         ctl_blk.action = 6;
  343.         ctl_blk.file_handle = NULL; 
  344.         ctl_blk.data_addr = buf;
  345.  
  346.         if( (ret = osgbpb( &ctl_blk )) != NULL )
  347.         {
  348.                 printf("%s (%d)\n",ret->errmess,ret->errnum);
  349.                 return( NULL );
  350.         }
  351.  
  352.         /* Format is:
  353.            <null byte><length byte><dir name><privilege byte>
  354.          */
  355.         len = buf[1];
  356.         buf[len+2] = '\0';
  357.  
  358.         if( (len == 1) && (buf[2] == '$') )
  359.         {
  360.             dirname[0] = '$';
  361.             dirname[1] = '\0';
  362.             return 1;
  363.         }
  364.         else
  365.         {
  366.             system("dir ^");
  367.             if( getcwd() == 1 )
  368.             {
  369.                 buf[1] = '.'; 
  370.                 strcat( dirname, buf+1 );
  371.                 return 1;
  372.             }
  373.             else 
  374.                 return NULL;
  375.         }
  376.                  
  377.         /* Should never get here! */
  378.         return 0;
  379.  
  380. }
  381.  
  382.  
  383. char *
  384. pwd()
  385. {
  386.  
  387.     if( getcwd() != 1 )
  388.         return NULL;
  389.  
  390.     strcpy(cmdbuf,"dir ");
  391.     strcat(cmdbuf, dirname );
  392.     system(cmdbuf);
  393.  
  394.     return dirname;
  395.  
  396. }
  397.  
  398. static char disc[] = ":x";
  399.  
  400. void
  401. du(char * s )
  402. {
  403. reg_set rs;                                                                 
  404. error *err;
  405. FILE *fp;
  406.  
  407.     if( (fp=fopen(s,"w")) == NULL )
  408.         return;
  409.  
  410.     if( (err=swix( 0x040242, &rs )) != NULL )
  411.     {
  412.         fprintf(fp,"ADFS_Drives error %s (%d)\n",err->errmess,err->errnum);
  413.         return ;
  414.     }
  415.  
  416.     disc[1] = rs.r[0] + '0';
  417.  
  418.     rs.r[0] = (int)disc;
  419.  
  420.     if( (err=swix( 0x040243, &rs )) != NULL )
  421.     {
  422.         fprintf(fp,"ADFS_FreeSpace error %s (%d)\n",err->errmess,err->errnum);
  423.         return;
  424.     }
  425.  
  426.     fprintf(fp,"Bytes free &%.8X = %ld\n",rs.r[0],rs.r[0]);
  427.  
  428.     fclose( fp );
  429.  
  430.     return;
  431. }
  432.  
  433.