home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_200 / 225_01 / deff4.c < prev    next >
Text File  |  1987-06-09  |  25KB  |  705 lines
  1. /*-----------------------------------------------------------------*/
  2. /*  FILE:          DEFF4.C
  3.     ----
  4.     COMPILER:      BDS C  V 1.50
  5.     --------
  6.     WRITTEN:       22/10/85
  7.     -------
  8.     REVISED:       16/11/86
  9.     -------
  10.     VERSION:       1.4
  11.     -------
  12.     ADDED FCTs:    B_TEST
  13.     ----------                                                     */
  14.  
  15. /*  This file contains the following functions -                   */
  16. /*                                                                 */
  17. /*       SET_BIT        PUT_ERROR           UP_STR                 */
  18. /*       LOWER_STR      ENTAB               PLIST                  */
  19. /*       LIST_STATUS    LISTS               LISTD                  */
  20. /*       MAKE_FCB       PEC_CLEAR           HAZ_CLEAR              */
  21. /*       BRIGHT         NORMAL              LINE(S)                */
  22. /*       PRINT_U        GO_TO               OUT_CHAR               */
  23. /*       ISNUM          INKEY               PRT_HEX                */
  24. /*       VIDEO_CHAR     B_TEST                                     */
  25. /*-----------------------------------------------------------------*/
  26. /*            BIOS Functions
  27.               --------------
  28.  
  29.          W_BOOT         CONST               CONIN
  30.          CONOUT         LIST_C              SELDSK
  31.          SET_TRK        SET_SEC             SET_DMA
  32.          READ_SEC       WRITE_SEC           LISTST                 */
  33. /*-----------------------------------------------------------------*/
  34. /*                                                                 */
  35. /*  all of which are described in the file DEFF4.TXT.              */
  36. /*                                                                 */
  37. /*  WRITTEN:  14th July, 1986                                      */
  38. /*  -------                                                        */
  39. /*  BIOS functions added September 27, 1986                        */
  40. /*  Copyright 1986 by Cogar Computer Services Pty. Ltd.            */
  41. /*  All rights reserved.                                           */
  42. /*-----------------------------------------------------------------*/
  43. #include <pec.h>    /* Required for these functions            */
  44. /*=================================================================*/
  45. /*  LIBRARY FUNCTION:   B_TEST
  46.  
  47.     Will test the nominated bit in a byte and return TRUE if it
  48.     is set ( = 1) or FALSE if it is not set.   Note that "bit"
  49.     must be one of "B_ZERO" to "B_SEVEN" as per pec.h              */
  50. /*-----------------------------------------------------------------*/
  51.  
  52. char b_test(byte, bit)
  53. int bit;
  54. char byte;
  55. {
  56.     int set_bit;
  57.  
  58.     if(bit == 0)
  59.         set_bit = 0x1;
  60.     else if(bit == 1)
  61.         set_bit = 0x2;
  62.     else if(bit == 2)
  63.         set_bit = 0x4;
  64.     else if(bit == 3)
  65.         set_bit = 0x8;
  66.     else if(bit == 4)
  67.         set_bit = 0x10;
  68.     else if(bit == 5)
  69.         set_bit = 0x20;
  70.     else if(bit == 6)
  71.         set_bit = 0x40;
  72.     else if(bit == 7)
  73.         set_bit = 0x80;
  74.  
  75.     if((byte & set_bit) > 0)
  76.         return(1);
  77.     else return(0);
  78. }
  79. /*-----------------------------------------------------------------*/
  80. /*  SUBROUTINE  ==>  set_bit                                       */
  81. /*  Will set the nominated BYTE in the file control block          */
  82. /*  Choices are -                                                  */
  83. /*                 R/O       Read only                             */
  84. /*                 R/W       Read/Write (re-sets the bit)          */
  85. /*                 SYS       System file                           */
  86. /*                 DIR       Directory (re-sets SYS bit)           */
  87. /*                 ARC       Archive bit                           */
  88. /*                 CPY       Copy (re-sets Archive bit)            */
  89. /*-----------------------------------------------------------------*/
  90.  
  91. void set_bit(fcb_buf,str)
  92. char fcb_buf[36], str[3];
  93. {
  94.     up_str(str);    /* convert to upper case */
  95.  
  96.     if(strcmp(str,"R/O") == 0)
  97.         fcb_buf[9] = fcb_buf[9] | 0x80;
  98.     else if(strcmp(str,"R/W") == 0)
  99.         fcb_buf[9] = fcb_buf[9] & 0x7f;
  100.     else if(strcmp(str,"SYS") == 0)
  101.         fcb_buf[10] = fcb_buf[10] | 0x80;
  102.     else if(strcmp(str,"DIR") == 0)
  103.         fcb_buf[10] = fcb_buf[10] & 0x7f;
  104.     else if(strcmp(str,"ARC") == 0)
  105.         fcb_buf[11] = fcb_buf[11] | 0x80;
  106.     else if(strcmp(str,"CPY") == 0)
  107.         fcb_buf[11] = fcb_buf[11] & 0x7f;
  108.     else put_error(str);
  109.  
  110.     if(set_attributes(fcb_buf) == -1)
  111.         printf("\nUnable to find the nominated file.\n");
  112. }
  113. /*-----------------------------------------------------------------*/
  114. /*  SUBROUTINE  ==>  put_error                                     */
  115. /*  Used with set_bit                                              */
  116. /*-----------------------------------------------------------------*/
  117.  
  118. void put_error(string)
  119. char *string;
  120. {
  121. printf("\n\nThe mode  %s is unknown...terminating programme.", string);
  122. exit();
  123. }
  124. /*-----------------------------------------------------------------*/
  125. /*  LIBRARY FILE  ==  up_str                                       */
  126. /*  Will convert a string to UPPER case ASCII                      */
  127. /*-----------------------------------------------------------------*/
  128.  
  129. void up_str(s)
  130. char *s;
  131. {
  132.     short i;
  133.     i = 0;
  134.  
  135.     while(s[i])
  136.     {
  137.         s[i] = toupper(s[i]);
  138.         i++;
  139.     }
  140.     s[i] = '\0';
  141. }
  142. /*-----------------------------------------------------------------*/
  143. /*  LIBRARY FILE  ==  lower_str                                    */
  144. /*  Will convert a NULL-terminated string to ASCII lower case      */
  145. /*-----------------------------------------------------------------*/
  146.  
  147. void lower_str(s)
  148. char *s;
  149. {
  150.     short i;
  151.     i = 0;
  152.  
  153.     while(s[i])
  154.     {
  155.         s[i] = tolower(s[i]);
  156.         i++;
  157.     }
  158.     s[i] = '\0';
  159. }
  160. /*-----------------------------------------------------------------*/
  161. /*  LIBRARY FILE  ==>  ENTAB                                       */
  162. /*  Will compensate for TAB characters on those printers which     */
  163. /*  don't recognise the ASCII tab.   Can be altered for different  */
  164. /*  tab sizes, as needed.                                          */
  165. /*-----------------------------------------------------------------*/
  166.  
  167. char entab(position, size)
  168. short position, size;
  169. {
  170.     short tab_count;
  171.  
  172.     for(tab_count = 0; tab_count <= size - position%size; tab_count++)
  173.         listc(SPACE);
  174.     tab_count--;    /* Must go back one                        */
  175.  
  176.     position = position + tab_count;
  177.     return(position);
  178. }
  179. /*-----------------------------------------------------------------*/
  180. /*  LIBRARY FILE  ==>  plist                                       */
  181. /*  Will list one character to the line printer using the actual   */
  182. /*  I/O port addresses.                                            */
  183. /*  Presently configured for GODBOUT INTERFACER II board but can   */
  184. /*  be modified for any "Centronics" connection provided the       */
  185. /*  ports and the strobe signals are known.                        */
  186. /*  NOTE:  The strobe signals used are those for the Itoh 8510     */
  187. /*  ----   printer.                                                */
  188. /*                                                                 */
  189. /*  Written for BDS C but should be portable to other C's.         */
  190. /*  Copyright 1986 by Cogar Computer Services Pty. Ltd.            */
  191. /*-----------------------------------------------------------------*/
  192. /*      INTERFACER II EQUATES                                      */
  193. /*-----------------------------------------------------------------*/
  194. #define BASE_PORT 0x0c8            /* Interfacer II printer ports     */
  195. #define HAND_SHAKE BASE_PORT + 1    /* Handshaking port        */
  196. #define LIST_PORT HAND_SHAKE + 1    /* Printer data port       */
  197. /*-----------------------------------------------------------------*/
  198. /*      ITOH 8510 PRINTER EQUATES                                  */
  199. /*-----------------------------------------------------------------*/
  200. #define OFF_STROBE 0x0ff    /* To turn all strobes off         */
  201. #define IN_DATA    0x0bf       /* Active, data input signal       */
  202. #define BUSY_INPUT 0x07f    /* Active, input busy signal       */
  203. #define BUSY       0x080    /* Printer busy signal             */
  204. #define DELAY      100        /* 1 millisecond delay ?           */
  205. #define LOOPS      1000            /* To do BUSY test                 */
  206. /*-----------------------------------------------------------------*/
  207.  
  208. void plist(c)
  209. int c;                /* The character to list           */
  210. {
  211.     short i;        /* Delay counter                   */
  212.  
  213.     if(list_status() != TRUE)  /* Test the printer status      */
  214.     {
  215.         printf("\nPrinter must be turned off.");
  216.         exit();
  217.     }
  218.     else outp(LIST_PORT,c);  /* OK, so print character         */
  219.     outp(HAND_SHAKE,IN_DATA); /* Tell printer we've sent it    */
  220.     outp(HAND_SHAKE,OFF_STROBE); /* Sequence finished          */
  221. /*-----------------------------------------------------------------*/
  222. /*  We now have to wait 1 millisec until the printer can accept    */
  223. /*  more data.   I don't know how to get a 1 millisec delay in     */
  224. /*  BDS C, as the smallest allowable delay is 1/30 = 33.3 millisec */
  225. /*  for a 6 mHz clock, if we use the "sleep" function.   So what   */
  226. /*  I have done is just to use an empty loop until I got the delay */
  227. /*  approximately right for this printer.                          */
  228. /*-----------------------------------------------------------------*/
  229.     for(i = 0; i < DELAY; i++)
  230.         ;            /* Empty loop              */
  231.  
  232. }
  233. /*-----------------------------------------------------------------*/
  234.  
  235. char list_status()
  236. {
  237.     short i, n;
  238.     i = n = 0;        /* Has to be changed if successful */
  239.     while(i < LOOPS && n != 1)
  240.     {
  241.     outp(HAND_SHAKE, BUSY_INPUT); /* Ask what the status is    */
  242.     outp(HAND_SHAKE, OFF_STROBE); /* End of enquiry            */
  243.     if(inp(LIST_PORT) != 0)         /* Then printer is busy    */
  244.          i++;                /* So do it again          */
  245.     else n = 1;            /* Not busy, so tell us    */
  246.     }
  247.     return(n);
  248. }
  249. /*-----------------------------------------------------------------*/
  250. /*---------------END OF PLIST--------------------------------------*/
  251. /*-----------------------------------------------------------------*/
  252. /*  LIBRARY FILE  ==>  LISTS                                       */
  253. /*  Will transmit a null-terminated string to the line printer.    */
  254. /*  Uses function ==>  listc  -  from DEFF3                        */
  255. /*-----------------------------------------------------------------*/
  256. void lists(str) /* To list a null-terminated string                */
  257. char *str;
  258. {
  259.     char c;
  260.  
  261.     while(c = *str++)
  262.         listc(c);
  263. }
  264. /*-----------------------------------------------------------------*/
  265. /*  LIBRARY FILE  ==>  LISTD                                       */
  266. /*  The listing (printer) equivalent of print_dec in DEFF3.        */
  267. /*  Will print out a decimal number in the listing.                */
  268. /*-----------------------------------------------------------------*/
  269. void listd(count)    /* To list a decimal number                */
  270. short count;
  271. {
  272.     short i;        /* Counter                         */
  273.  
  274.     if(count < 0)
  275.     {
  276.         listc('-');    /* For negative number             */
  277.         count = -count; /* Make number positive            */
  278.     }
  279.  
  280.     i = 0;        /* Starting condition                      */
  281.     if((i = count/10) != 0)
  282.         listd(i);    /* Recursive call                  */
  283.     listc(count % 10 + '0'); /* Make the digit printable       */
  284. }
  285. /*-----------------------------------------------------------------*/
  286. /*  SUBROUTINE  ==>  make_fcb                                      */
  287. /*  Needs to know -                                                */
  288. /*                   where to look for the name                    */
  289. /*                   where name is to go  (fcb)                    */
  290. /*-----------------------------------------------------------------*/
  291.  
  292. void make_fcb(name,fcb)
  293. char  name[15], fcb[36];
  294. {
  295.     char c;
  296.     short i, j, count;
  297.  
  298. /*-----------------------------------------------------------------*/
  299. /*  Note this routine DOESN'T set the drive name in the file       */
  300. /*  control block.   You must do that separately.                  */
  301. /*-----------------------------------------------------------------*/
  302.     if(name[2] == ':')
  303.         i = 2;    /* Then skip over drive name               */
  304.     else i = 0;    /* Or there is no drive name               */
  305.  
  306.     count = 0;
  307.  
  308.     for (j = 1; j < 9; j++) /* Do the "name" part              */
  309.     {
  310.         if((c = name[i]) != '.')
  311.         {
  312.             fcb[j] = c;
  313.             i++;
  314.         }
  315.         else if((c = name[i]) == '.')
  316.         {
  317.             fcb[j] = SPACE;
  318.         }
  319.     }
  320.     if (name[i] == '.')
  321.         i++;        /* Skip over the period            */
  322.  
  323.     for (j =9; j < 12; j++)   /* Now do the "type" part        */
  324.     {
  325.     if (isalnum(name[i]) == TRUE)    /* A character             */
  326.         {
  327.             fcb[j] = name[i];
  328.             i++;
  329.         }
  330.     else fcb[j] = SPACE;
  331.     }
  332. }
  333. /*-----------------------------------------------------------------*/
  334. /*  UTILITY:       pec_clear                                       */
  335. /*  Will clear the screen of any terminal without using any of     */
  336. /*  the special terminal functions.                                */
  337. /*-----------------------------------------------------------------*/
  338.  
  339. void pec_clear()
  340. {
  341.     short i;
  342.  
  343.     for(i = 0; i < 25; i++)
  344.         putchar('\n');
  345. }
  346. /*-----------------------------------------------------------------*/
  347. /*            TERMINAL FUNCTIONS                                   */
  348. /*            ------------------                                   */
  349. /*  For use with Hazeltine Esprit terminal                         */
  350. /*  Use with LEAD-IN as set by switches.   Change this setting if  */
  351. /*  different in your case.                                        */
  352. /*-----------------------------------------------------------------*/
  353. #define    LEAD_IN 0x07e   /* Tilde selected by switches              */
  354. #define    BRIGHT  0x01f   /* Needs to have foreground switch set     */
  355. #define    DIM    0x019
  356. #define    CLEAR    0x01c
  357. /*-----------------------------------------------------------------*/
  358.  
  359. void haz_clear()
  360. {
  361.     putchar(LEAD_IN);
  362.     putchar(CLEAR);
  363. }
  364. /*-----------------------------------------------------------------*/
  365.  
  366. void bright()
  367. {
  368.     putchar(LEAD_IN);
  369.     putchar(BRIGHT);
  370. }
  371. /*-----------------------------------------------------------------*/
  372.  
  373. void normal()
  374. {
  375.     putchar(LEAD_IN);
  376.     putchar(DIM);
  377. }
  378. /*-----------------------------------------------------------------*/
  379. /*            LINE                                                 */
  380. /*  Spaces down one line on the console display                    */
  381. /*-----------------------------------------------------------------*/
  382.  
  383. void line()
  384. {
  385.     putchar(CR);
  386.     putchar(LF);
  387. }
  388. /*-----------------------------------------------------------------*/
  389. /*            LINES                                                */
  390. /*  Spaces down the number of lines nominated by the user          */
  391. /*-----------------------------------------------------------------*/
  392.  
  393. void lines(number)
  394. unsigned number;
  395. {
  396.     unsigned i;            /* The counter             */
  397.  
  398.     putchar(CR);
  399.     for(i = 0; i < number; i++)
  400.         putchar(LF);
  401. }
  402. /*-----------------------------------------------------------------*/
  403. /*            PRINT_U                                              */
  404. /*  Print an unsigned decimal number to the console                */
  405. /*-----------------------------------------------------------------*/
  406.  
  407. void print_u(n)
  408. unsigned n;
  409. {
  410.     unsigned i;
  411.  
  412.     i = 0;
  413.     if((i = n/10) != 0)
  414.         print_u(i);
  415.     putchar(n % 10 + '0');
  416. }
  417. /*-----------------------------------------------------------------*/
  418. /*            GO_TO                                                */
  419. /*  Direct cursor addressing function where -                      */
  420. /*                                                                 */
  421. /*       x    is the column number (0 to 79)                       */
  422. /*       y    is the row number (0 to 23)                          */
  423. /*******************************************************************/
  424. #define    LEAD_IN 0x7e    /* Tilde for Hazeltine terminal            */
  425. #define    CUR_ADR 0x11    /* Direct cursor address signal            */
  426.  
  427. void go_to(column, row)
  428. int column, row;
  429. {
  430.     out_char(LEAD_IN);
  431.     out_char(CUR_ADR);
  432.     out_char(column);
  433.     out_char(row);
  434. }
  435. /*******************************************************************/
  436. /*            OUT_CHAR                                             */
  437. /*  Send the nominated character to the console but limit size to  */
  438. /*  7 bits.                                                        */
  439. /*******************************************************************/
  440. void out_char(c)
  441. int c;
  442. {
  443.     bios(4, c & 0x7f);
  444. }
  445. /*******************************************************************/
  446. /*  LIBRARY FUNCTION  ==>  ISNUM                                   */
  447. /*  ----------------                                               */
  448. /*                                                                 */
  449. /*  Returns TRUE (1) if a character is numeric (0....9) and        */
  450. /*  FALSE (0) if the character isn't numeric.                      */
  451. /*******************************************************************/
  452.  
  453. char isnum(c)
  454. int c;
  455. {
  456.     if(c >= '0' && c <= '9')
  457.         return(1);
  458.     else return(0);
  459. }
  460. /*******************************************************************/
  461. /*  LIBRARY FUNCTION  ==>  INKEY                                   */
  462. /*  ----------------                                               */
  463. /*  Duplicates the Microsoft Basic "inkey" function which tests    */
  464. /*  the keyboard for input, and returns TRUE/FALSE depending on    */
  465. /*  whether a key has been pressed or not.                         */
  466. /*                                                                 */
  467. /*  Requires:      DEFF3 to get BDOS functions                     */
  468. /*  --------                                                       */
  469. /*  Written to run under BDS C.                                    */
  470. /*  Copyright 1986 by Cogar Computer Services Pty. Ltd.            */
  471. /*******************************************************************/
  472.  
  473. char inkey()
  474. {
  475.     char IN;
  476.     IN = 0xff;    /* Required to initiate DIRECTC function   */
  477.  
  478.  
  479.     if(directc(IN) == 0)
  480.         return(0);    /* No key pressed                  */
  481.     else return(1);         /* Char waiting at keyboard        */
  482. }
  483. /*******************************************************************/
  484. /*            PRT_HEX
  485.  
  486.     This routine will print the character in hexadecimal format
  487.     with a leading zero when the number is less than 16 = 0x10     */
  488. /*******************************************************************/
  489.  
  490. void prt_hex(number)
  491. char number;
  492. {
  493.     if (number < 16)
  494.     {
  495.         putchar('0');
  496.         printf("%x", number);
  497.     }
  498.     else printf("%x", number);
  499. }
  500. /*******************************************************************/
  501. /*            BIOS FUNCTIONS UNDER BDS C
  502.  
  503. This file provides some of the CPM 2.2 BIOS functions which are
  504. available under BDS C.   It uses either the
  505.  
  506.      bios(n, c)              for one-byte quantities
  507.  
  508. or   biosh(n, bc, de)        for two-byte quantities
  509.  
  510. Copyright 1986 - Cogar Computer Services Pty. Ltd.
  511.  
  512. */
  513. /*******************************************************************/
  514. /*            W_BOOT                                               */
  515. /*                                                                 */
  516. /*  Performs a warm boot.   Doesn't return.                        */
  517. /*******************************************************************/
  518.  
  519. void w_boot()
  520. {
  521.     bios(1, 0);
  522. }
  523. /*******************************************************************/
  524. /*            CONST                                                */
  525. /*                                                                 */
  526. /*  Returns the CONSOLE STATUS -
  527.  
  528.                    0         if no character waiting
  529.                    0xff      if character waiting at console
  530. */
  531. /*******************************************************************/
  532.  
  533. char const()
  534. {
  535.     return(bios(2, 0));
  536. }
  537. /*******************************************************************/
  538. /*            CONIN
  539.  
  540.   Returns the next character from the console.   Under CP/M 2.2 the
  541.   parity bit (= bit 7) should be set to zero when the character is
  542.   read in.
  543. */
  544. /*******************************************************************/
  545.  
  546. char conin()
  547. {
  548.     return(bios(3, 0));
  549. }
  550. /*******************************************************************/
  551. /*            CONOUT
  552.  
  553.   Outputs the nominated ASCII character to the console.            */
  554. /*******************************************************************/
  555.  
  556. void conout(c)
  557. char c;
  558. {
  559.     bios(4, c);
  560. }
  561. /*******************************************************************/
  562. /*            LIST_C
  563.  
  564.   Outputs the nominated character to the list device, normally the
  565.   line printer.                                                    */
  566. /*******************************************************************/
  567.  
  568. void list_c(c)
  569. char c;
  570. {
  571.     bios(5, c);
  572. }
  573. /*******************************************************************/
  574. /*            SELDSK
  575.  
  576.   Selects the nominated disk as the logical disk for all I/O.
  577.   Note the disks are numbered -
  578.  
  579.          A    0
  580.          B    1
  581.          C    2
  582.          D    3                                                    */
  583. /*******************************************************************/
  584.  
  585. int seldsk(drive)
  586. char drive;
  587. {
  588.     char c;
  589.  
  590.     c = toupper(drive) - 65; /* Convert A = 0; B = 1;...C = 3  */
  591.  
  592.     return(biosh(9, c, 0));
  593. }
  594. /*******************************************************************/
  595. /*            SET_TRK
  596.  
  597.   Will set the read/write head of the disk drive nominated by
  598.   SELDSK to the track nominated here.   Note this is the
  599.   absolute track number.   Acceptable values are
  600.  
  601.               0 to 65,535 (0xffff)
  602. */
  603. /*******************************************************************/
  604.  
  605. void set_trk(track_no)
  606. unsigned track_no;
  607. {
  608.     bios(10, track_no);
  609. }
  610. /*******************************************************************/
  611. /*            SET_SEC
  612.  
  613.   Will set the nominated sector number (within the previously
  614.   nominated track?) for later read/write.   Acceptable values are
  615.  
  616.               0 to 255 */
  617. /*******************************************************************/
  618.  
  619. void set_sec(sector_no)
  620. int sector_no;
  621. {
  622.        bios(11, sector_no);
  623. }
  624. /*******************************************************************/
  625. /*            SET_DMA
  626.  
  627.   Sets the DMA buffer address to the nominated pointer address.    */
  628. /*******************************************************************/
  629.  
  630. void set_dma(buffer)
  631. char *buffer;
  632. {
  633.     bios(12, buffer);
  634. }
  635. /*******************************************************************/
  636. /*            READ_SEC
  637.  
  638.   Reads the 128-byte sector nominated by previous SETTRK and SETSEC
  639.   calls into the buffer defined by SET_DMA.   Returns 0 in the read
  640.   was successful, otherwise returns 1 for an (unspecified) error.  */
  641. /*******************************************************************/
  642.  
  643. char read_sec()
  644. {
  645.     return(bios(13, 0));
  646. }
  647. /*******************************************************************/
  648. /*            WRITE_SEC
  649.  
  650.   Writes the 128-byte buffer denoted by SET_DMA to the track and
  651.   sector defined by SETTRK and SETSEC.   Returns 0 if the write was
  652.   successful, otherwise returns 1 for an (unspecified) write error.*/
  653. /*******************************************************************/
  654.  
  655. char write_sec()
  656. {
  657.     return(bios(14, 0));
  658. }
  659. /*******************************************************************/
  660. /*            LISTST
  661.  
  662.   Checks the status of the list device (the line printer) and then
  663.   returns
  664.  
  665.               0xff      if the printer is ready to accept a character
  666.   or,          0         if the printer is busy (or off line?).    */
  667. /*******************************************************************/
  668.  
  669. char listst()
  670. {
  671.     return(bios(15, 0));
  672. }
  673. /*******************************************************************/
  674. /*  LIBRARY FILE  ==>  VIDEO_CHAR
  675.  
  676.     This will print one character to the console in the mode
  677.     nominated by the user.   The available modes are -
  678.  
  679.          B  -  Bright
  680.          N  -  Normal
  681.  
  682.     Note: As written uses the "Bright" and "Normal" functions which
  683.     ----  are specific to Hazeltine terminals.   These need to be
  684.           rewritten for other terminals.
  685.  
  686.     Copyright 1986 - Cogar Computer Services Pty. Ltd.             */
  687. /*-----------------------------------------------------------------*/
  688.  
  689. void video_char(ch, attr)
  690. char ch, attr;
  691. {
  692.     if(toupper(attr) == 'B')
  693.         bright();
  694.     else normal();
  695.  
  696.     putchar(ch);
  697.  
  698.     if(toupper(attr) == 'B')
  699.         normal();
  700.     else bright();
  701. }
  702. /*-----------------------------------------------------------------*/
  703. SEC
  704.  
  705.   Reads the 128-byte sector nominated by previous SETTRK and SET