home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast2.iso / fortran / fv121s.zip / FAT3.DOC < prev    next >
Text File  |  1988-06-04  |  29KB  |  1,053 lines
  1.         APR 1988                FAT-VIDEO 1.21  GETMON          Page V-32
  2.  
  3.  
  4.         GETMON(NRS,NCS,NRE,NCE,SEG) - Copy a screen window to memory at SEG.
  5.  
  6.         Usage:
  7.  
  8.           call getmon(nrs,ncs,nre,nce,seg)
  9.  
  10.           integer*2 nrs,ncs
  11.           integer*2 nre,nce
  12.           integer*2 seg or integer*4 seg
  13.  
  14.           inputs: nrs,ncs,nre,nce,seg
  15.  
  16.           returns: none
  17.  
  18.           MS-Fortran 4.0 Large Model
  19.  
  20.         Description:
  21.  
  22.            This subroutine stores the window section defined by nrs,ncs
  23.         and nre,nce on the screen into the buffer starting at seg.  It is
  24.         up to the calling program to allocate storage via ALLMEM().
  25.  
  26.            This routine stores the monochrome buffers character and
  27.         attribute bytes for the window defined, to memory at SEG.
  28.  
  29.            This routine reads directly from the monochrome video buffer,
  30.         and may cause software incompatabilities.
  31.  
  32.            This function does not clear the window after saving it, but
  33.         once saved you may do anything to the window area, and restore
  34.         the saved window contents using PUTMON().
  35.  
  36.         See also getvid(), putvid(),getcga(),putcga().
  37.  
  38.         nrs = first row of window
  39.         ncs = first col of window
  40.         nre = last row of window
  41.         nce = last col of window
  42.         seg = segment of allocated memory, as output from ALLMEM().
  43.  
  44.         Note: To calcualte the number of paragraphs to request from ALLMEM()
  45.               calculate the following:
  46.  
  47.                 Npar= (((nr*nc)*2)+15)/16  ; nr=nre-nrs+1, nc=nce=ncs+1
  48.  
  49.         Example:
  50.                 Npar=  (((11*41)*2)+15)/16
  51.                 call ALLMEM(Npar,SEG,MaxPar)
  52.                 if(SEG.eq.7 .or. SEG.eq.8)Go To 1000 ;Error !
  53.                 call GETMON(0,0,10,40,SEG)
  54.  
  55.         See Wopen(),Wclose().
  56.         Restrictions: 80 column mode only !
  57.  
  58.         Int none
  59.  
  60.         Mono, EGA
  61.        APR 1988                FAT-VIDEO 1.21  PUTMON          Page V-33
  62.  
  63.  
  64.         PUTMON(NRS,NCS,NRE,NCE,SEG) - Copy a window in memory at SEG to
  65.                                       the screen.
  66.         Usage:
  67.  
  68.           call putmon(nrs,ncs,nre,nce,seg)
  69.  
  70.           integer*2 nrs,ncs
  71.           integer*2 nre,nce
  72.           integer*2 seg or integer*4 seg
  73.  
  74.           inputs: nrs,ncs,nre,nce,seg
  75.  
  76.           returns: none
  77.  
  78.           MS-Fortran 4.0 Large Model
  79.  
  80.         Description:
  81.  
  82.            This subroutine restores the window section defined by nrs,ncs
  83.         and nre,nce onto the screen.  It is up to the calling program to
  84.         free storage via FREMEM().
  85.  
  86.            This routine restores the monochrome buffers character and
  87.         attribute bytes for the window defined.
  88.  
  89.            This routine writes directly to the mono video memory buffer.
  90.  
  91.         See also getvid(), putvid(),getcga(),putcga().
  92.  
  93.         nrs = first row of window
  94.         ncs = first col of window
  95.         nre = last row of window
  96.         nce = last col of window
  97.         Seg = segment address used in GETMON()
  98.  
  99.         Example:
  100.                 call PUTMON(0,0,10,40,seg)
  101.                 call FREMEM(Seg,Ier)
  102.                 if(Ier.ne.0)Go To 1000   ; Error !
  103.  
  104.         See Wopen(),Wclose().
  105.         Restrictions: 80 column mode only !
  106.  
  107.         Int none
  108.  
  109.         Mono, EGA
  110.        APR 1988                FAT-VIDEO 1.21  CLS             Page V-34
  111.  
  112.  
  113.         CLS() - Clear the Screen.
  114.  
  115.         Usage:
  116.  
  117.           call cls()
  118.  
  119.           MS-Fortran 4.0 Large Model
  120.  
  121.         Description:
  122.  
  123.            This subroutine scrolls the entire window up, effectively
  124.         clearing the screen.
  125.  
  126.            This function determines the active page, gets the attribute
  127.         byte at the cursor, and then scrolls the window, filling the
  128.         blank lines with the color defined by the attribute bytes
  129.         background color.
  130.  
  131.         See also scwup(), scwdn().
  132.  
  133.         Int 10h, fx-0Fh, 08h, 06h
  134.  
  135.         CGA,Mono
  136.  
  137.         APR 1988                FAT-VIDEO 1.21  RDKBD           Page V-35
  138.  
  139.  
  140.         RDKBD(SCAN,KEY) - Read the keyboard.
  141.  
  142.         Usage:
  143.  
  144.           call rdkbd(SCAN,KEY)
  145.  
  146.           integer*2 scan,key
  147.  
  148.           inputs: none
  149.  
  150.           returns: scan,key
  151.  
  152.           MS-Fortran 4.0 Large Model
  153.  
  154.         Description:
  155.  
  156.            This subroutine returns the ascii code from the keyboard and
  157.         its scan code. This function doesn't echo the character read from
  158.         the keyboard.
  159.  
  160.            If key is returned as zero then a special key was hit such as
  161.         the function keys(F1,F2,..) or the cursor keys, or a combination
  162.         of shift,ctrl,alt and a function key. The value
  163.         of the special key is returned in the scan variable.
  164.  
  165.            If a normal key is struck then key returns the ascii code.
  166.         Once read by rdkbd() a character is removed from the keyboard
  167.         buffer. This function cannot be interrupted by a ctrl-c keypress.
  168.         See chinp() to allow ctrl-c interrupts during a keyboard read.
  169.  
  170.         See also chinp(), kbdst(), kbdfl().
  171.  
  172.         scan = scan code if ascii, key code if special key
  173.         key= ascii code or 0 for special key code
  174.  
  175.  
  176.         Int 16, fx-00h
  177.  
  178.         CGA, Mono, EGA
  179.        APR 1988                FAT-VIDEO 1.21  KBDST           Page V-36
  180.  
  181.  
  182.         KBDST(SCAN,ACHAR) - Get the keyboard status.
  183.  
  184.         Usage:
  185.  
  186.           call kbdst(SCAN,ACHAR)
  187.  
  188.           integer*2 scan,key
  189.  
  190.           inputs: none
  191.  
  192.           returns: scan,key
  193.  
  194.           MS-Fortran 4.0 Large Model
  195.  
  196.         Description:
  197.  
  198.            This subroutine reports whether a character is is ready at
  199.         the keyboard.  If there are no characters ready then scan and
  200.         key are zero.  If an ascii character is ready, it is returned in
  201.         key.   If a special key is present, then key is zero and scan
  202.         contains the key code.
  203.  
  204.            This function does not remove characters from the keyboard
  205.         buffer though, as rdkbd() does.
  206.  
  207.            The keyboard buffer may be cleared by calling this function,
  208.         and if a character is ready, reading it with rdkbd(), and
  209.         doing this until no characters are found.
  210.  
  211.         See also rdkbd(), kbdfl(), chinp().
  212.  
  213.         scan = scan code if ascii, key code if special key
  214.         key= ascii code or 0 for special key code
  215.  
  216.         Int 16h, fx- 02h
  217.  
  218.         CGA, Mono, EGA
  219.        APR 1988                FAT-VIDEO 1.21  KBDFL           Page V-37
  220.  
  221.  
  222.         KBDFL(FLAGS) - Get the keyboard flags.
  223.  
  224.         Usage:
  225.  
  226.           call kbdfl(Flags)
  227.  
  228.           integer*2 Flags
  229.  
  230.           inputs: none
  231.  
  232.           returns: flags
  233.  
  234.           MS-Fortran 4.0 Large Model
  235.  
  236.         Description:
  237.  
  238.            This subroutine returns the keyboard flags byte.  The flags
  239.         indicate which special keys are pressed, such as left-shift,
  240.         right-shift, insert, scroll lock, num lock, and ctrl.
  241.  
  242.            This is not a generally useful function from Fortran,
  243.         especially with the other keyboard reads available, since
  244.         they can read any key combination. There are some uses for this,
  245.         if you are clever.
  246.  
  247.         See also rdkbd(), kbdst(), chinp().
  248.  
  249.         Flag = the low byte of flag has each bit set as defined below.
  250.  
  251.           Bit Set       Meaning         Dec Value
  252.                 7       Insert on       128
  253.                 6       Caps on         64
  254.                 5       Num Lock on     32
  255.                 4       Scroll Lock on  16
  256.                 3       Alt key down     8
  257.                 2       Ctrl key down    4
  258.                 1       Left-Shift down  2
  259.                 0       Right-Shift down 1
  260.  
  261.  
  262.         Int 16h, fx-02
  263.  
  264.         CGA, Mono, EGA
  265.        APR 1988                FAT-VIDEO 1.21  CHINP           Page V-38
  266.  
  267.  
  268.  
  269.         CHINP(KEY) - Get character from keyboard, no echo.
  270.  
  271.         Usage:
  272.  
  273.           call chinp(key)
  274.  
  275.           integer*2 key
  276.  
  277.           inputs: none
  278.  
  279.           returns: key
  280.  
  281.           MS-Fortran 4.0 Large Model Dos2.0
  282.  
  283.         Description:
  284.  
  285.           This program reads a character from the keyboard.  This input is
  286.         unfiltered and waits for a keypress.  This function doesn't echo
  287.         the keypress to the screen.
  288.  
  289.           To read extended key codes, call this routine twice. The first
  290.         call returns zero to indicate a special extended code key, such as
  291.         F1-F10.  A ctrl-c keypress during this function will terminate
  292.         a program. Use rdkbd() to prevent ctrl-c interrupts during a
  293.         keyboard read operation.
  294.  
  295.         See also rdkbd(), kbdst(), kbdfl().
  296.  
  297.         KEY = 0 Extended char code, call again for key id
  298.         KEY > 0 ascii character, use char(key) to reference.
  299.  
  300.         Int 21, fx-08h.
  301.        APR 1988                FAT-VIDEO 1.21  ALLMEM          Page V-39
  302.  
  303.  
  304.         ALLMEM(NPAR,SEG,MAXPAR) - Allocate Memory, Dynamically.
  305.  
  306.         Usage:
  307.  
  308.           call allmem(NPAR,SEG,MAXPAR)
  309.  
  310.           integer*2 npar,seg,maxpar
  311.                 or
  312.           integer*4 npar,seg,maxpar
  313.  
  314.           inputs: npar
  315.  
  316.           returns: seg,maxpar
  317.  
  318.           MS-Fortran 4.0 Large Model Dos2.0
  319.  
  320.         Description:
  321.  
  322.           This program attempts to allocate memory dynamically.  If
  323.         successful it returns the paragraph segment in SEG.  If
  324.         unsuccessful it returns the maximum available paragraphs in
  325.         MAXSEG, and the error code in SEG.  Inputting 640k for NPAR
  326.         returns available memory in MAXPAR if you want xbytes request
  327.         (xbytes+15)/16 paragraphs.
  328.  
  329.         NPAR-   No. of paragraphs to allocate.
  330.         SEG-    Segment address of allocated memory, or error code.
  331.         MAXPAR- Maximum available memory, or actual allocated.
  332.  
  333.         See also fremem().
  334.  
  335.         Error Codes:
  336.                 SEG values if allocation failed.
  337.                 7 = memory blocks destroyed
  338.                 8 = insufficient memory
  339.  
  340.         Warning:
  341.                 SEG should be checked after each allocation.
  342.  
  343.         Int 21h, fx-48h
  344.  
  345.         CGA, Mono, EGA
  346.  
  347.            This only works with the first 640k.  It does not work with
  348.         extended, expanded, or any other memory additions, just the first
  349.         640k !!!
  350.  
  351.  
  352.         APR 1988                FAT-VIDEO 1.21  FREMEM          Page V-40
  353.  
  354.  
  355.         FREMEM(SEG,IER) - Free Memory.
  356.  
  357.         Usage:
  358.  
  359.           call fremem(SEG,IER)
  360.  
  361.           integer*2 seg,ier  or integer*4 seg,ier
  362.  
  363.           inputs: seg
  364.  
  365.           returns: ier
  366.  
  367.           MS-Fortran 4.0 Large Model Dos2.0
  368.  
  369.         Description:
  370.  
  371.           This program frees memory previously allocated.  Normally
  372.         you should only free memory allocated via allmem().  On input, SEG
  373.         is the paragraph segment to free.  On return, IER is set to 0 if
  374.         memory was deallocated, otherwise IER is set to an error code, as
  375.         below.
  376.  
  377.         SEG-    Segment address returned by allmem().
  378.         IER-    Error code, as below
  379.  
  380.         See also allmem().
  381.  
  382.         Error Code:
  383.                 IER values
  384.                   0 = no error
  385.                   7 = memory control blocks destroyed
  386.                   9 = bad segment id(not allocated?)
  387.  
  388.         Warning:
  389.                 IER should be checked after every call
  390.                 to fremem().
  391.  
  392.         Note:   DOS will free up any dynamically allocated memory when a
  393.                 program terminates.
  394.        APR 1988                FAT-VIDEO 1.21  SETNUL          Page V-41
  395.  
  396.  
  397.         SETNUL(STRING)   Null Terminate a String.
  398.  
  399.         Usage:
  400.  
  401.           call setnul(string)
  402.  
  403.           character*255 string
  404.  
  405.           inputs: string
  406.  
  407.           returns: string
  408.  
  409.           MS-Fortran 4.0 Large Model
  410.  
  411.         Description:
  412.  
  413.            This function replaces the '`' character with a 0 byte, the
  414.         null terminator. This forms a c-string which is also equivalent
  415.         to appending the char(0) to a string. The following are all identical
  416.         strings as far as the video and window library are concerned.
  417.  
  418.         string = 'text'C                Used MS-Fortran only.
  419.                 or
  420.         string = 'text'//char(0)        Used by many compilers.
  421.                 or
  422.         string = 'text`'                Can be used by any compiler.
  423.         call setnul(string)
  424.  
  425.            The video library functions can use the string defined as
  426.         string = 'text`', it is treated as a null terminated string.  The
  427.         '`' character is considered equivalent to char(0).
  428.  
  429.         The above string does not have to be passed to setnul() in order
  430.         to be usable by the video library.  The setnul() function is provided
  431.         to assist you in forming true null terminated strings should you
  432.         need to.  The maximum string length, including the null terminator,
  433.         is 255 bytes or anything less.
  434.  
  435.         CGA, Mono, EGA
  436.        APR 1988                FAT-VIDEO 1.21  REVAB           Page V-42
  437.  
  438.  
  439.         REVAB(ATTR,RATTR) - Reverse foreground and background in attribute.
  440.  
  441.         Usage:
  442.  
  443.           call revab(attr,rattr)
  444.  
  445.           integer*2  attr,rattr
  446.  
  447.           inputs: attr
  448.  
  449.           returns: rattr
  450.  
  451.           MS-Fortran Large Model
  452.  
  453.         Description:
  454.  
  455.            This function takes the input attribute and reverses the
  456.         foreground and background colors.  It does not alter the
  457.         blink or intensity bits.
  458.  
  459.         attr  = input attribute
  460.         rattr = output attribute with reverse colors
  461.  
  462.         See also setab(), getab().
  463.  
  464.        APR 1988                FAT-VIDEO 1.21  SETBC           Page V-43
  465.  
  466.  
  467.         SETBC(COLOR) - Set CGA border color in text modes.
  468.  
  469.         Usage:
  470.  
  471.           call setbc(color)
  472.  
  473.           integer*2  color
  474.  
  475.           inputs: color
  476.  
  477.           returns: none
  478.  
  479.           MS-Fortran Large Model
  480.  
  481.         Description:
  482.  
  483.            This function sets the border color in text mode on the
  484.         CGA adapter.  Do not use with the EGA or mono adapter.
  485.  
  486.            See setpal() to set border colors in graphics mode.
  487.  
  488.         color = 0-15
  489.  
  490.                 Colors
  491.                 ------
  492.         0 Black         8  Gray
  493.         1 Blue          9  Light Blue
  494.         2 Green         10 Light Green
  495.         3 Cyan          11 Light Cyan
  496.         4 Red           12 Pink
  497.         5 Magenta       13 Light Magenta
  498.         6 Brown         14 Yellow
  499.         7 White         15 Bright White
  500.  
  501.         See also setab(), getab(), setpal().
  502.  
  503.         CGA Only !
  504.        APR 1988                FAT-VIDEO 1.21  BVEF            Page V-44
  505.  
  506. +
  507.         BVEF(Flag) - Get the BIOS video equipment flag.
  508.  
  509.         Usage:
  510.  
  511.           call bvef(bflag)
  512.  
  513.           integer*2  bflag
  514.  
  515.           inputs: none
  516.  
  517.           returns: bflag
  518.  
  519.           MS-Fortran Large Model
  520.  
  521.         Description:
  522.  
  523.            This function returns the BIOS video equipment flag.
  524.  
  525.         See also getadp().
  526.  
  527.  
  528.  
  529.         EGAF(Flag) - Get the EGA status flag.
  530.  
  531.         Usage:
  532.  
  533.           call egaf(bflag)
  534.  
  535.           integer*2  egaf
  536.  
  537.           inputs: none
  538.  
  539.           returns: egaf
  540.  
  541.           MS-Fortran Large Model
  542.  
  543.         Description:
  544.  
  545.            This function returns the EGA status flag.
  546.  
  547.         See also getadp().
  548.  
  549.  
  550.        APR 1988                FAT-VIDEO 1.21  CGACOF          Page V-45
  551.  
  552.  
  553.         CGACOF() - Turn off cursor on CGA adapter.
  554.  
  555.         Usage:
  556.  
  557.           call cgacof()
  558.  
  559.           inputs: none
  560.  
  561.           returns: none
  562.  
  563.           MS-Fortran Large Model
  564.  
  565.         Description:
  566.  
  567.            This function turns the cursor off on the CGA adapter.
  568.  
  569.         See also cgacon(), moncof(), moncon().
  570.  
  571.  
  572.  
  573.         CGACON() - Turn on cursor on CGA adapter.
  574.  
  575.         Usage:
  576.  
  577.           call cgacon()
  578.  
  579.           inputs: none
  580.  
  581.           returns: none
  582.  
  583.           MS-Fortran Large Model
  584.  
  585.         Description:
  586.  
  587.            This function turns the CGA cursor on.
  588.  
  589.         See also cgacof(), moncof(), moncon().
  590.  
  591.        APR 1988                FAT-VIDEO 1.21  MONCOF          Page V-46
  592.  
  593.  
  594.         MONCOF() - Turn off cursor on monochrome display.
  595.  
  596.         Usage:
  597.  
  598.           call moncof()
  599.  
  600.           inputs: none
  601.  
  602.           returns: none
  603.  
  604.           MS-Fortran Large Model
  605.  
  606.         Description:
  607.  
  608.            This function turns the mono display cursor off.
  609.  
  610.         See also cgacof(), cgacon(), moncon().
  611.  
  612.  
  613.  
  614.         MONCON() - Turn on cursor on monochrome display.
  615.  
  616.         Usage:
  617.  
  618.           call moncon()
  619.  
  620.           inputs: none
  621.  
  622.           returns: none
  623.  
  624.           MS-Fortran Large Model
  625.  
  626.         Description:
  627.  
  628.            This function turns the mono display cursor on.
  629.  
  630.         See also cgacof(), cgacon(), moncof().
  631.  
  632.  
  633.        APR 1988                FAT-VIDEO 1.21  COMLIN          Page V-47
  634.  
  635.  
  636.         COMLIN(TAIL) - gets the user typed command line tail. DOS 2.0.
  637.  
  638.         Usage:
  639.  
  640.           call comlin(tail)
  641.  
  642.           character*127 tail
  643.  
  644.           inputs: none
  645.  
  646.           returns: tail
  647.  
  648.           MS-Fortran Large Model - DOS 3.0
  649.  
  650.         Description:
  651.  
  652.            This function returns the command line tail used to invoke
  653.         the currently active program.
  654.  
  655.         tail - character string containing the command tail from the
  656.                MS-DOS command line.
  657.  
  658.  
  659.  
  660.         GETDOS(MAJOR,MINOR) - returns does version .
  661.  
  662.         Usage:
  663.  
  664.           call getdos(major,minor)
  665.  
  666.           integer*2 major,minor
  667.  
  668.           inputs: none
  669.  
  670.           returns: major,minor
  671.  
  672.           MS-Fortran Large Model
  673.  
  674.         Description:
  675.  
  676.            This function returns the DOS version number. For DOS 3.20
  677.         major=3 and minor = 20.
  678.  
  679.        APR 1988                FAT-VIDEO 1.21  GETTIM          Page V-48
  680.  
  681.  
  682.         GETTIM(HR,MIN,SEC,HSEC)- returns DOS time.
  683.  
  684.         Usage:
  685.  
  686.           call gettim(hr,min,sec,hsec)
  687.  
  688.           integer*2 hr,min,sec,hsec
  689.  
  690.           inputs: none
  691.  
  692.           returns: hr,min,sec,hsec
  693.  
  694.           MS-Fortran Large Model
  695.  
  696.         Description:
  697.  
  698.            This function returns the time as DOS maintains it.
  699.  
  700.         HR= 0-23 , MIN=0-59, SEC=0-59, HSEC= 0-99
  701.  
  702.  
  703.  
  704.         CLRKBD() - clears the keyboard type ahead buffer.
  705.  
  706.         Usage:  call clrkbd()
  707.  
  708.           inputs: none ;   returns: none
  709.  
  710.         BEEP() - Beeps the speaker
  711.  
  712.         Usage:  call beep()
  713.  
  714.           inputs: none ;   returns: none
  715.  
  716.         CurOff() - Turns the cursor off using the video BIOS.
  717.  
  718.         Usage:  call CurOff()
  719.  
  720.           inputs: none ;   returns: none
  721.  
  722.         CurOn()  - Turns the cursor in using the video BIOS.
  723.  
  724.         Usage:  call CurOn()
  725.  
  726.           inputs: none ;   returns: none
  727.  
  728.        APR 1988                FAT-VIDEO 1.21  GETML          Page V-49
  729.  
  730.  
  731.         GETML(NBYTES,SEG,OFF) - Allocate memory dynamically in Lahey
  732.                Fortran. This memory comes from the Lahey Heap.
  733.  
  734.         Usage:
  735.  
  736.           call getml(nbytes,seg,off)
  737.  
  738.           integer*4 nbytes,seg,off
  739.  
  740.           inputs:  nbytes
  741.  
  742.           returns: seg,off
  743.  
  744.           For Lahey Compiler Only !
  745.  
  746.         Description:
  747.  
  748.            This function allocates memory dynamically in Lahey-Fortran
  749.         and returns the segment and offset of the allocated memory. This
  750.         memory is allocated from the Lahey Heap. That is Lahey allocates
  751.         available DOS memory at startup. Any memory not required for
  752.         code and data is available as Heap memory. See the Lahey WOPEN().
  753.         source code for an example.
  754.  
  755.         Error Checking:
  756.                 If Seg = 0 and Off = 0 memory not allocated.
  757.  
  758.         RLSML(NBYTES,SEG,OFF) - Free memory dynamically in Lahey
  759.                Fortran. This memory is returned to the Lahey Heap.
  760.  
  761.         Usage:
  762.  
  763.           call rlsml(nbytes,seg,off)
  764.  
  765.           integer*4 nbytes,seg,off
  766.  
  767.           inputs:  nbytes,seg,off
  768.  
  769.           returns: seg,off
  770.  
  771.           For Lahey Compiler Only !
  772.  
  773.         Description:
  774.  
  775.            This function retruns dynamically allocated memory to the Lahey
  776.         Heap. The GETML() routine must have been used to allocate the
  777.         memory prior to a call to free Heap memory. See the Lahey Wclose()
  778.         routine for an example of this function.
  779.  
  780.         Error checking:
  781.  
  782.           On return: Seg = 0 safe return.
  783.                          <>0 error return, memory not freed, or bad input.
  784.        APR 1988                FAT-VIDEO 1.21  PEEKL          Page V-50
  785.  
  786.  
  787.  
  788.         PEEKL - Get a Long word value from memory.
  789.  
  790.         integer*2 OFF,SEG
  791.         integer*4 VALUE
  792.         call PEEKL(OFF,SEG,VALUE)
  793.  
  794.         call with:
  795.         OFF - offset value from start of segment, <=64k
  796.         SEG - segment value of long word location, <=64k
  797.  
  798.         returns:
  799.         VALUE - the long word value is returned in this argument.
  800.  
  801.         example:
  802.           call PEEKL(INT2(0),INT2(#0800),VALUE)
  803.           This call returns long word stored at SEG= Hex 0800, OFF=0.
  804.  
  805.         Notes: An integer*2 is signed and may range from -32k to +32k.
  806.             If the segment or offset values exceed this amount you should
  807.             declare the segment and offset as integer*4.
  808.           i.e.
  809.             integer*4 SEG,OFF
  810.             integer*4 VALUE
  811.             SEG = #B800  <--- .gt. 32k
  812.             OFF = 0
  813.             call PEEKL(INT2(OFF),INT2(SEG),VALUE)
  814.  
  815.  
  816.         POKEL - Store a long word value in memory.
  817.  
  818.         integer*2 OFF,SEG
  819.         integer*4 VALUE
  820.         call POKEL(OFF,SEG,VALUE)
  821.  
  822.         call with:
  823.         OFF - offset value from start of segment, <=64k
  824.         SEG - segment value of long word location, <=64k
  825.         VALUE - the long word value to store.
  826.  
  827.         returns: nothing
  828.  
  829.  
  830.         example: VALUE = 128
  831.            call POKEL(Int2(0),Int2(#0800),VALUE)
  832.           This call stores the value 128 at SEG=Hex 0800, OFF = 0.
  833.  
  834.         Notes: An integer*2 is signed and may be range from -32k to +32k.
  835.             If the segment or offset values exceed this amount you should
  836.             declare the segment and offset as integer*4.
  837.           i.e.
  838.             integer*4 SEG,OFF
  839.             integer*4 VALUE
  840.             SEG = #B800  <--- .gt. 32k
  841.             OFF = 0
  842.             call POKEL(INT2(OFF),INT2(SEG),VALUE)
  843.        APR 1988                FAT-VIDEO 1.21  WRTS          Page V-51
  844.  
  845.  
  846.  
  847.         WRTS(STRING)
  848.          Write a null terminated string to screen using the BIOS.
  849.  
  850.         character*n string
  851.         string= 'Hello`' or string='Hello'//char(0)
  852.         call wrts(string)
  853.  
  854.         input: string
  855.         returns: nothing
  856.  
  857.         Description:
  858.  
  859.            This function writes a null terminated string to the video
  860.         screen. The routine works in video modes 3 & 7. This is a text
  861.         mode function only. The function writes to screen using the
  862.         BIOS, for hardware compatibility.
  863.  
  864.  
  865.  
  866.         WRTSP(STRINg,ROW,COL,PAGE)
  867.  
  868.           Write a null terminated string to screen at the position given,
  869.         using the BIOS, for compatibility.
  870.  
  871.         integer*2 row,col,page
  872.         character*n string
  873.         page=0
  874.         row=2
  875.         col=3
  876.         string= 'Hello`' or string='Hello'//char(0)
  877.         call wrts(string,row,col,page)
  878.  
  879.         input: string,row,col,page
  880.         returns: nothing
  881.  
  882.         Description:
  883.  
  884.            This function writes a null terminated string to the video
  885.         screen at the lcoation specified. The routine works in video
  886.         modes 3 & 7. This is a text mode function only. The function
  887.         writes to screen using the BIOS, for hardware compatibility.
  888.  
  889.         Row = Row starting position of 1st character, 0-24
  890.         Col = Col starting position of 1st character, 0-79
  891.        APR 1988                FAT-VIDEO 1.21  CPUT            Page V-52
  892.  
  893.  
  894.  
  895.         CPUT(STRING)
  896.  
  897.            Write a null terminated string to the screen, by writing
  898.         directly to video ram.
  899.  
  900.         character*n string
  901.         string= 'Hello`' or string='Hello'//char(0)
  902.         call cput(string)
  903.  
  904.         inputs: string
  905.         returns: none
  906.  
  907.         Description:
  908.  
  909.            This founction writs a null terminated string to the screen
  910.         by writing directly to video ram. The routine works in either
  911.         mode 7 or mode 3. This is a text mode function only. The direct
  912.         video ram writing produces very fast output. This routine writes
  913.         one byte per screen character, and is twice as fast as CPUTA, and
  914.        CPUTAP.
  915.  
  916.         CPUTA(ATTR,STRING)
  917.  
  918.            Write a null terminated string to the screen using the attribute
  919.         given, by writing directly to video ram.
  920.  
  921.         integer*2   attr
  922.         character*n string
  923.         attr = 7
  924.         string= 'Hello`' or string='Hello'//char(0)
  925.         call cput(attr,string)
  926.  
  927.         inputs: string,attr
  928.         returns: none
  929.  
  930.         Description:
  931.  
  932.            This function writes a null terminated string to the screen
  933.         using the attribute given, by writing directly to video ram.
  934.         The routine works in either mode 7 or mode 3. This is a text
  935.         mode function only. The direct video ram writing produces very
  936.         fast output. This routine is slower than CPUT, and CPUTP.
  937.  
  938.  
  939.        APR 1988                FAT-VIDEO 1.21  CPUTP          Page V-53
  940.  
  941.  
  942.  
  943.         CPUTP(STRING,ROW,COL)
  944.  
  945.            Write a null terminated string to the screen at the position
  946.         specified, by writing directly to video ram.
  947.  
  948.         integer*2   row,col
  949.         character*n string
  950.         row=2
  951.         col=2
  952.         string= 'Hello`' or string='Hello'//char(0)
  953.         call cputp(string,row,col)
  954.  
  955.         inputs: string,row,col
  956.         returns: none
  957.  
  958.         Description:
  959.  
  960.            This founction writes a null terminated string to the screen
  961.         at the position specified by writing directly to video ram.
  962.         The routine works in either mode 7 or mode 3. This is a text
  963.         mode function only. The direct video ram writing produces very
  964.         fast output. This routine is faster than CPUTA, and CPUTAP.
  965.  
  966.         Row = Row starting position of 1st character, 0-24
  967.         Col = Col starting position of 1st character, 0-79
  968.  
  969.  
  970.         CPUTAP(ATTR,STRING,ROW,COL)
  971.  
  972.            Write a null terminated string to the screen using the attribute
  973.         and location given, by writing directly to video ram.
  974.  
  975.         integer*2   attr,row,col
  976.         character*n string
  977.         attr = 7
  978.         row=2
  979.         col=7
  980.         string= 'Hello`' or string='Hello'//char(0)
  981.         call cput(attr,string)
  982.  
  983.         inputs: string,attr,row,col
  984.         returns: none
  985.  
  986.         Description:
  987.  
  988.            This function writes a null terminated string to the screen
  989.         using the attribute and location given, by writing directly to
  990.         vide ram. The routine works in either mode 7 or mode 3. This is a
  991.         text mode function only. The direct video ram writing produces very
  992.         fast output. This routine is slower than CPUT, and CPUTP.
  993.  
  994.         Row = Row starting position of 1st character, 0-24
  995.         Col = Col starting position of 1st character, 0-79
  996.  
  997.        APR 1988                FAT-VIDEO 1.21  CPUTAC          Page V-54
  998.  
  999.  
  1000.  
  1001.         CPUTAC(ATTR,VALUE)
  1002.  
  1003.            Write a character to the video screen using the attribute given,
  1004.         by writing directly to video ram.
  1005.  
  1006.         integer*2   attr
  1007.         integer*2   value
  1008.         attr = 7
  1009.         value= 65
  1010.         call cputac(attr,value)
  1011.  
  1012.         inputs: attr,value
  1013.         returns: none
  1014.  
  1015.         Description:
  1016.  
  1017.            This founction writes a character to the screen using the attribute
  1018.         given, by writing directly to video ram.
  1019.         The routine works in either mode 7 or mode 3. This is a text
  1020.         mode function only. The direct video ram writing produces very
  1021.         fast output. This routine is slower than CPUTC.
  1022.  
  1023.         ATTR = valid attribute byte.
  1024.         VALUE= ASCII value of character, or extended value of character.
  1025.  
  1026.  
  1027.         CPUTC(VALUE)
  1028.  
  1029.            Write a character to the video screen by writing directly to video
  1030.         ram, for fast screen output. This routine uses the current screen
  1031.         attribute.
  1032.  
  1033.         integer*2   value
  1034.         value= 65
  1035.         call cputc(value)
  1036.  
  1037.         inputs: attr,value
  1038.         returns: none
  1039.  
  1040.         Description:
  1041.  
  1042.            This founction writes a character to the screen, by writing directly
  1043.         to video ram, and uses the current screen attribute.
  1044.           The routine works in either mode 7 or mode 3. This is a text
  1045.         mode function only. The direct video ram writing produces very
  1046.         fast output. This routine is faster than CPUTAC.
  1047.  
  1048.         VALUE = ASCII value of character to write, or extended key value.
  1049.  
  1050.  
  1051.  
  1053.