Programmer 7500/MAX_PROGRAMMERS.iso/PASCAL/ECO30603.ZIP/ECO30603.LZH/ECOLIBNG/SOURCE/ECO_FUNC.DAT

Text File | 1992-06-09 | 57.3 KB | 1,978 lines

!short  Assignaux                                                        ECO_232

   ^Bprocedure assignaux(var f: text; port, params: word);^N

   This command enables you to control the CRT COM port, like
   The DOS MODE command does.

   ^R Control bits: ^N


     byte: 7   6   5    4    3       2      1    0
           ─────────    ──────    ───────   ──────
           baud rate    parity    stopbit   length


           tabel  I:                │       tabel  II:
                                    │
   baud rate:   bit: 7  6  5        │  parity:   bit   4   3
   ─────────────────────────────────┼─────────────────────────────
                                    │
         110         0  0  0        │    none          0   0
         150         0  0  1        │
         300         0  1  0        │     odd          0   1
         600         0  1  1        │
        1200         1  0  0        │    even          1   1
        2400         1  0  1        │
        4800         1  1  0        │
        9600         1  1  1        │


           tabel  iii:              │       tabel  iv:
   stop bits:      bit: 2           │  length:   bit:  1   0
   ─────────────────────────────────┼─────────────────────────────
                                    │
       1  bit           0           │  7 bits          1   0
                                    │
       2 bits           1           │  8 bits          1   1


   ^Rconvert this binary code into a hexadecimal code and use it as in the^N
   ^RFollowing Example:^N

   uses
     eco_232

     ;


   var
     com1: text;

   begin
     assignaux(com1,0,$83);  /this ($83) means com1, 1200 baud, no parity\
     rewrite(com1);          /1 stop bit and 8 data bits                 \
     writeln(com1,'devicedriver by UltiHouse Software / The ECO Group.')
     close(com1);
   end.


!short  Bios_rs232_init(comport: integer; comparm: word);                ECO_asyn

   ^Bprocedure bios_rs232_init(comport: integer; comparm: word);^N

   This function initializes the BIOS comport.

!short  Async_close(drop_dtr: boolean);                                  ECO_asyn

   ^Bprocedure async_close(drop_dtr: boolean);^N

   This function close the asynchronous port directly

!short  Async_clear_errors;                                              ECO_asyn

   ^Bprocedure async_clear_errors;^N

   This function clears any errors that may be currently
   being reported by the asynchronous port buffer.


!short  Async_reset_port()                                               ECO_asyn

   ^Bprocedure async_reset_port()
   ^B  comport      : integer;^N
   ^B  baudrate     : word;^N
   ^B  parity       : char;^N
   ^B  wordsize     : integer;^N
   ^B  stopbits     : integer^N
   ^B);^N

   This function issues a standard reset on the asynchronous
   communications port.


!short  Async_open();                                                    ECO_asyn

   ^Bfunction  async_open(^N
   ^B  comport      : integer;^N
   ^B  baudrate     : word;^N
   ^B  parity       : char;^N
   ^B  wordsize     : integer;^N
   ^B  stopbits     : integer^N
  ^B): boolean;^N

   This function opens the asynchronous communications port to enable
   writing commands to it.


!short  Async_send(c: char);                                             ECO_asyn

   ^Bprocedure async_send(c: char);^N

   This function sends characters to the asynchronous
   communications port to which connection has been set up.


!short  Async_receive(var c: char): boolean;                             ECO_asyn

   ^Bfunction  async_receive(var c: char): boolean;^N

   This function tries to receive characters from the asynchronous
   communications port to which connection has been set up.


!short  Async_receive_with_timeout();                                    ECO_asyn

   ^Bprocedure async_receive_with_timeout();^N

   This function tries to receive characters from the asynchronous
   communications port to which connection has been set up.
   It takes a certain timeout period before it stops trying.

!short  Async_stuff(ch: char);                                           ECO_asyn

   ^Bprocedure async_stuff(ch: char);^N

   This function tries to stuff characters into the asynchronous
   communications port to which connection has been set up, by filling
   the buffer to be used.

!short  Async_find_delay(var one_ms_delay: integer);                     ECO_asyn

   ^Bprocedure async_find_delay(var one_ms_delay: integer);^N


!short  Async_init(                                                      ECO_asyn

   ^Bprocedure async_init(^N
   ^B  async_buffer_max : integer;^N
   ^B  async_obuffer_max: integer;^N
   ^B  async_high_lev1  : integer;^N
   ^B  async_high_lev2  : integer;^N
   ^B  async_low_lev    : integer^N
   ^B);^N

   Set up the asynchronous communications port and initialize it.
   It is not opened until you issue the open command.


!short  Async_carrier_detect: boolean;                                   ECO_asyn

   ^Bfunction  async_carrier_detect: boolean;^N

   Detects whether a carrier is present at the currently set up
   asynchronous communications port.


!short  Async_carrier_drop: boolean;                                     ECO_asyn

   ^Bfunction  async_carrier_drop: boolean;^N

   Force the carrier to drop from the asynchronous communications port

!short  Async_term_ready(ready_status: boolean);                         ECO_asyn

   ^Bprocedure async_term_ready(ready_status: boolean);^N

   Request readiness of asynchronous communications port.


!short  Async_buffer_check: boolean;                                     ECO_asyn

   ^Bfunction  async_buffer_check: boolean;^N

   Check whether buffer of current asynchronous communications port
   is working.

!short  Async_line_error(var error_flags: byte): boolean;                ECO_asyn

   ^Bfunction  async_line_error(var error_flags: byte): boolean;^N

   Retrive errorflags of asynchronous communications port.

!short  Async_ring_detect: boolean;                                      ECO_asyn

   ^Bfunction  async_ring_detect: boolean;^N

   Detect ring signal from current asynchronous communications port.
   (not used frequently enymore.)

!short  Async_send_break;                                                ECO_asyn

   ^Bprocedure async_send_break;^N

   Send the BRK signal to the currently set up asynchronous
   communications port.

!short  Async_send_string(s: string);                                    ECO_asyn

   ^Bprocedure async_send_string(s: string);^N


!short  Async_send_string_with_delays(                                   ECO_asyn

   ^Bprocedure async_send_string_with_delays(^N
   ^B  s         : string;^N
   ^B  char_delay: integer;^N
   ^B  eos_delay : integer^N
   ^B);^N

   Send to the asynchronous communications port a string with
   timed delays.

!short  Async_percentage_used: real;                                     ECO_asyn

   ^Bfunction  async_percentage_used: real;^N

   Buffer check of asynchronous communications port currently
   being used.


!short  Async_purge_buffer;                                              ECO_asyn

   ^Bprocedure async_purge_buffer;^N

   Empty the buffer of the asynchronous communications port
   currently being used.


!short  Async_peek(nchars: integer): char;                               ECO_asyn

   ^Bfunction  async_peek(nchars: integer): char;^N

   Look at buffer from the asynchronous communications port,
   to inspect whats present.

!short  Async_setup_port(                                                ECO_asyn

   ^Bprocedure async_setup_port(^N
   ^B  comport      : integer;^N
   ^B  base_address : integer;^N
   ^B  irq_line     : integer;^N
   ^B  int_numb     : integer^N
   ^B);^N

   Set up the current asynchronous communications port with new data.


!short  Async_release_buffers;                                           ECO_asyn

   ^Bprocedure async_release_buffers;^N

   Purge all buffers from all asynchronous communications ports, by
   throwing all data away.


!short  Async_flush_output_buffer;                                       ECO_asyn

   ^Bprocedure async_flush_output_buffer;^N

   Purge all buffers from all asynchronous communications ports, but not
   by throwing all data away.

!short  Async_drain_output_buffer(max_wait_time: integer);               ECO_asyn

   ^Bprocedure async_drain_output_buffer(max_wait_time: integer);^N

   Read all data from buffer of asynchronous communications port
   at once.


!short  Async_port_address_given(com_port): boolean;                     ECO_asyn

   ^Bfunction  async_port_address_given(com_port): boolean;^N

   Change the address of the current asynchronous communications port.


!short  Async_send_now(c: char);                                         ECO_asyn

   ^Bprocedure async_send_now(c: char);^N

   Directly send a character to the asynchronous communications port.


!short  Async_wait_for_quiet()                                           ECO_asyn

   ^Bfunction  async_wait_for_quiet(^N
   ^B  max_wait: longint;^N
   ^B  wait_time: longint^N
   ^B): boolean;^N

   Wait on the current asynchronous communications port until silence
   is detected.

!short  Send_modem_command(modem_text: string);                          ECO_asyn

   ^Bprocedure send_modem_command(modem_text: string);^N

   Send a modemcommand to the modem on the current
   asynchronous communications port.


!short  Set_params(first_time: boolean): boolean;                        ECO_asyn

   ^Bfunction  set_params(first_time: boolean): boolean;^N

   Mark whether you're initializing for the first time or
   whether you're reassigning.

!short  Initialize_modem;                                                ECO_asyn

   ^Bprocedure initialize_modem;^N

   ATZ command

!short  Pak_tv;                                                          ECO_atv

   ^Bfunction  pak_tv(arc: pathstr; var opt: optiontype): boolean;^N

   The ECO Shell for CFI interface. Makes all knowledge about the
   various archivers completely superfluous.
   The actions to be performed must be send, though.

!short  Atv;                                                             ECO_atv

   ^Bfunction  atv(arcname: pathstr): boolean;^N

   The ECO Shell for CFI interface. Makes all knowledge about the
   various archivers completely superfluous. Can be used as completely
   independent interface for all archives and actions.



!short  Base(x: longint;b: byte): basestr;                               ECO_bcnv

   ^Bfunction  base(x: longint;b: byte): basestr;^N


!short  Basef(x: longint;b, f: byte): basestr;                           ECO_bcnv

   ^Bfunction  basef(x: longint;b, f: byte): basestr;^N


!short  Hex(x: longint): basestr;                                        ECO_bcnv

   ^Bfunction  hex(x: longint): basestr;^N


!short  Hexf(x: longint;f: byte): basestr;                               ECO_bcnv

   ^Bfunction  hexf(x: longint;f: byte): basestr;^N


!short  Dez(x: basestr;s: byte): longint;                                ECO_bcnv

   ^Bfunction  dez(x: basestr;s: byte): longint;^N


!short  Dezh(x: basestr): longint;                                       ECO_bcnv

   ^Bfunction  dezh(x: basestr): longint;^N



!short  Calendaraction;                                                  ECO_cal

   ^Bprocedure calendaraction;^N

   Eternal calendar interface.

!short  Tan(radians: real): real;                                        ECO_calc

   ^Bfunction  tan(radians: real): real;^N


!short  Arcsin(invalue: real): real;                                     ECO_calc

   ^Bfunction  arcsin(invalue: real): real;^N


!short  Arccos(invalue: real): real;                                     ECO_calc

   ^Bfunction  arccos(invalue: real): real;^N


!short  Degreestoradians(degrees: real): real;                           ECO_calc

   ^Bfunction  degreestoradians(degrees: real): real;^N


!short  Radianstodegrees(radians: real): real;                           ECO_calc

   ^Bfunction  radianstodegrees(radians: real): real;^N


!short  Sin_degree(degrees: real): real;                                 ECO_calc

   ^Bfunction  sin_degree(degrees: real): real;^N


!short  Cos_degree(degrees: real): real;                                 ECO_calc

   ^Bfunction  cos_degree(degrees: real): real;^N


!short  Tan_degree(degrees: real): real;                                 ECO_calc

   ^Bfunction  tan_degree(degrees: real): real;^N


!short  Arcsin_degree(degrees: real): real;                              ECO_calc

   ^Bfunction  arcsin_degree(degrees: real): real;^N


!short  Arccos_degree(degrees: real): real;                              ECO_calc

   ^Bfunction  arccos_degree(degrees: real): real;^N


!short  Arctan_degree(degrees: real): real;                              ECO_calc

   ^Bfunction  arctan_degree(degrees: real): real;^N


!short  Degreepartstodegrees()                                           ECO_calc

   ^Bfunction  degreepartstodegrees(degrees, minutes, sECOnds: real): real;^N


!short  Degreepartstoradians()                                           ECO_calc

   ^Bfunction  degreepartstoradians(degrees, minutes, sECOnds: real): real;^N


!short  Degreestodegreeparts();                                          ECO_calc

   ^Bprocedure degreestodegreeparts(^N
   ^B  degreesin: real; var degrees, minutes, sECOnds: real^N
   ^B);^N


!short  Radianstodegreeparts();                                          ECO_calc

   ^Bprocedure radianstodegreeparts(^N
   ^B  radians: real; var degrees, minutes, sECOnds: real^N
   ^B);^N


!short  Sin_degreeparts();                                               ECO_calc

   ^Bfunction  sin_degreeparts(degrees, minutes, sECOnds: real): real;^N


!short  Cos_degreeparts();                                               ECO_calc

   ^Bfunction  cos_degreeparts(degrees, minutes, sECOnds: real): real;^N


!short  Tan_degreeparts();                                               ECO_calc

   ^Bfunction  tan_degreeparts(degrees, minutes, sECOnds: real): real;^N


!short  Arcsin_degreeparts();                                            ECO_calc

   ^Bfunction  arcsin_degreeparts(degrees, minutes, sECOnds: real): real;^N


!short  Arccos_degreeparts();                                            ECO_calc

   ^Bfunction  arccos_degreeparts(degrees, minutes, sECOnds: real): real;^N


!short  Arctan_degreeparts();                                            ECO_calc

   ^Bfunction  arctan_degreeparts(degrees, minutes, sECOnds: real): real;^N


!short  Degreetypetodegrees();                                           ECO_calc

   ^Bfunction  degreetypetodegrees(degreevar: degreetype): real;^N


!short  Degreetypetoradians(degreevar: degreetype): real;                ECO_calc

   ^Bfunction  degreetypetoradians(degreevar: degreetype): real;^N


!short  Degreetypetodegreeparts();                                       ECO_calc

  ^Bprocedure degreetypetodegreeparts(^N
   ^B degreevar: degreetype; var degrees, minutes, sECOnds: real^N
  ^B);^N

!short  Degreestodegreetype();                                           ECO_calc

   ^B procedure degreestodegreetype(degrees: real; var degreevar: degreetype);^N

!short  Radianstodegreetype();                                           ECO_calc

   ^B procedure radianstodegreetype(radians: real; var degreevar: degreetype);^N


!short  Degreepartstodegreetype();                                       ECO_calc

  ^Bprocedure degreepartstodegreetype(^N
   ^B degrees, minutes, sECOnds: real; var degreevar: degreetype^N
  ^B);^N


!short  Sin_degreetype(degreevar: degreetype): real;                     ECO_calc

   ^Bfunction  sin_degreetype(degreevar: degreetype): real;^N


!short  Cos_degreetype(degreevar: degreetype): real;                     ECO_calc

   ^Bfunction  cos_degreetype(degreevar: degreetype): real;^N


!short  Tan_degreetype(degreevar: degreetype): real;                     ECO_calc

   ^Bfunction  tan_degreetype(degreevar: degreetype): real;^N


!short  Arcsin_degreetype(degreevar: degreetype): real;                  ECO_calc

   ^Bfunction  arcsin_degreetype(degreevar: degreetype): real;^N


!short  Arccos_degreetype(degreevar: degreetype): real;                  ECO_calc

   ^Bfunction  arccos_degreetype(degreevar: degreetype): real;^N


!short  Arctan_degreetype(degreevar: degreetype): real;                  ECO_calc

   ^Bfunction  arctan_degreetype(degreevar: degreetype): real;^N


!short  Sinh(invalue: real): real;                                       ECO_calc

   ^Bfunction  sinh(invalue: real): real;^N


!short  Cosh(invalue: real): real;                                       ECO_calc

   ^Bfunction  cosh(invalue: real): real;^N


!short  Tanh(invalue: real): real;                                       ECO_calc

   ^Bfunction  tanh(invalue: real): real;^N


!short  Coth(invalue: real): real;                                       ECO_calc

   ^Bfunction  coth(invalue: real): real;^N


!short  Sech(invalue: real): real;                                       ECO_calc

   ^Bfunction  sech(invalue: real): real;^N


!short  Csch(invalue: real): real;                                       ECO_calc

   ^Bfunction  csch(invalue: real): real;^N


!short  Arcsinh(invalue: real): real;                                    ECO_calc

   ^Bfunction  arcsinh(invalue: real): real;^N


!short  Arccosh(invalue: real): real;                                    ECO_calc

   ^Bfunction  arccosh(invalue: real): real;^N


!short  Arctanh(invalue: real): real;                                    ECO_calc

   ^Bfunction  arctanh(invalue: real): real;^N


!short  Arccoth(invalue: real): real;                                    ECO_calc

   ^Bfunction  arccoth(invalue: real): real;^N


!short  Arcsech(invalue: real): real;                                    ECO_calc

   ^Bfunction  arcsech(invalue: real): real;^N


!short  Arccsch(invalue: real): real;                                    ECO_calc

   ^Bfunction  arccsch(invalue: real): real;^N


!short  Log10(innumber: real): real;                                     ECO_calc

   ^Bfunction  log10(innumber: real): real;^N


!short  Log(base, innumber: real): real;                                 ECO_calc

   ^Bfunction  log(base, innumber: real): real;^N


!short  Power(innumber, exponent: real): real;                           ECO_calc

   ^Bfunction  power(innumber, exponent: real): real;^N


!short  Root(innumber, theroot: real): real;                             ECO_calc

   ^Bfunction  root(innumber, theroot: real): real;^N



!short  Closecfi;                                                        ECO_cfi

   ^Bprocedure closecfi;^N

  Ancestor compression file interface function


!short  Opencfifile(f: str79): boolean;                                  ECO_cfi

   ^Bfunction  opencfifile(f: str79): boolean;^N

  Ancestor compression file interface function

!short  Cfinext: boolean;                                                ECO_cfi

   ^Bfunction  cfinext: boolean;^N

  Ancestor compression file interface function

!short  Dectohex(l: longint; cfityp: byte): str8;                        ECO_cfi

   ^Bfunction  dectohex(l: longint; cfityp: byte): str8;^N

  Ancestor compression file interface function


!short  __crc32(value: byte; crc: longint): longint;                     ECO_crc

   ^Bfunction  __crc32(value: byte; crc: longint): longint;^N

  var
    crc32 : longint;
  begin
    crc32 := $ffffffff;
    crc32 := __crc32(xxxx, crc32);
  end;

!short  __crc16(value: byte; crc: word)   :    word;                     ECO_crc

   ^Bfunction  __crc16(value: byte; crc: word)   :    word;^N

  var
    crc16 : longint;

  begin
    crc16 := $0000;
    crc16 := __crc16(xxxx, crc16);
  end;


!short  Desqviewpresent: boolean;                                        ECO_dsqv

   ^Bfunction  desqviewpresent: boolean;^N

  Checks whether DesqView is present or not

!short  Starttask(x: str2);                                              ECO_dsqv

   ^Bprocedure starttask(x: str2);^N

   Start a DesqView task

!short  Giveupcpu;                                                       ECO_dsqv

   ^Bprocedure giveupcpu;^N

   Give up DesqView CPU time.

!short  Giveupidle;                                                      ECO_dsqv

   ^Bprocedure giveupidle;^N

   Give up time back to DesqView  (when waiting for keypresses, e.g.).

!short  Exittask;                                                        ECO_dsqv

   ^Bprocedure exittask;^N

   Quit a DesqView task.

!short  Initmouse;                                                       ECO_emou

   ^Bprocedure initmouse;^N

   Initialise the Microsoft mouse.

!short  Showmouse;                                                       ECO_emou

   ^Bprocedure showmouse;^N

   Show the Microsoft mouse.

!short  Hidemouse;                                                       ECO_emou

   ^Bprocedure hidemouse;^N

   Hide the Microsoft mouse.

!short  Readmouse;                                                       ECO_emou

   ^Bprocedure readmouse;^N

   Read the position of the Microsoft mouse.

!short  Setmouseposition(x, y: word);                                    ECO_emou

   ^Bprocedure setmouseposition(x, y: word);^N

   Move the Microsoft mouse to certain location.

!short  Setmousepoint(x, y: word);                                       ECO_emou

   ^Bprocedure setmousepoint(x, y: word);^N

   Move the Microsoft mouse graphics cursor.

!short  Mousepress();                                                    ECO_emou

   ^Bfunction  mousepress(button: word;^N
   ^B  var count, lastx, lasty: word^N
   ^B): word;^N

   Checks whether the Microsoft mouse buttons have been pressed.

!short  Mouserelease();                                                  ECO_emou

   ^Bfunction  mouserelease(^N
     button: word;
     var count, lastx, lasty: word
   ): word;

   Checks whether the Microsoft mouse buttons have been released.

!short  Setmousearea(x1, y1, x2, y2: word);                              ECO_emou

   ^Bprocedure setmousearea(x1, y1, x2, y2: word);^N

   Confine the Microsoft mouse to a certain boxlocation.

!short  Setmouseboxarea(var r);                                          ECO_emou

   ^Bprocedure setmouseboxarea(var r);^N


!short  Mousegraphiccursor(shape: integer);                              ECO_emou

   ^Bprocedure mousegraphiccursor(shape: integer);^N

   Create a new shape in the graphics mousecursor.

!short  Setmousegraphiccursor(var mask: masktype);                       ECO_emou

   ^Bprocedure setmousegraphiccursor(var mask: masktype);^N

   Create a new shape in the graphics mousecursor.

!short  Mousetextcursor(select, start, stop: word);                      ECO_emou

   ^Bprocedure mousetextcursor(select, start, stop: word);^N

   Create a new shape in the textmode mousecursor.

!short  Readmickey(var x, y: word);                                      ECO_emou

   ^Bprocedure readmickey(var x, y: word);^N

   Where is the mouse?

!short  Setmouseisr(mask: word; var address);                            ECO_emou

   ^Bprocedure setmouseisr(mask: word; var address);^N

   Create handler

!short  Lightpen(flag: boolean);                                         ECO_emou

   ^Bprocedure lightpen(flag: boolean);^N

   Where is lightpen

!short  Setpixeltomickey(x, y: word);                                    ECO_emou

   ^Bprocedure setpixeltomickey(x, y: word);^N


!short  Hidemousearea(x1, y1, x2, y2: word);                             ECO_emou

   ^Bprocedure hidemousearea(x1, y1, x2, y2: word);^N


!short  Hidemouseboxarea(var r);                                         ECO_emou

   ^Bprocedure hidemouseboxarea(var r);^N


!short  Mousethreshold(threshold: word);                                 ECO_emou

   ^Bprocedure mousethreshold(threshold: word);^N


!short  Swapmouseisr(var mask: word; var address);                       ECO_emou

   ^Bprocedure swapmouseisr(var mask: word; var address);^N


!short  Setmousepage(page: word);                                        ECO_emou

   ^Bprocedure setmousepage(page: word);^N


!short  Getmousepage: word;                                              ECO_emou

   ^Bfunction  getmousepage: word;^N


!short  Mousein(x1, y1, x2, y2: word): boolean;                          ECO_emou

   ^Bfunction  mousein(x1, y1, x2, y2: word): boolean;^N


!short  Mouseinbox(var r): boolean;                                      ECO_emou

   ^Bfunction  mouseinbox(var r): boolean;^N


!short  Mouseclick: boolean;                                             ECO_emou

   ^Bfunction  mouseclick: boolean;^N


!short  Mouseclickin(x1, y1, x2, y2: word): boolean;                     ECO_emou

   ^Bfunction  mouseclickin(x1, y1, x2, y2: word): boolean;^N


!short  Mouseclickinbox(var r): boolean;                                 ECO_emou

   ^Bfunction  mouseclickinbox(var r): boolean;^N


!short  Pushmouse: boolean;                                              ECO_emou

   ^Bfunction  pushmouse: boolean;^N


!short  Popmouse: boolean;                                               ECO_emou

   ^Bfunction  popmouse: boolean;^N


!short  Zapmousestack;                                                   ECO_emou

   ^Bprocedure zapmousestack;^N



!short  Getptr(vector: byte): combufptr;                                 ECO_exe

   ^Bfunction  getptr(vector: byte): combufptr;^N

   Get a pointer to a common dataplace (likely to reside in
   the memory of a hostprogram, that spawns children)

!short  Cseg_t(): word;                                                  ECO_exe

   ^Bfunction  cseg_t(var comseg, compars: word; vector: byte): word;^N

   read info about the common data place.


!short  Chain_t(): word;                                                 ECO_exe

   ^Bfunction  chain_t(prog, cmd: string; vector: byte): word;^N

   Enter data about what program to rechain. (respawn)

!short  Default_t(): word;                                               ECO_exe

   ^Bfunction  default_t(prog: string; vector: byte): word;^N

   What program to default spawn if the normal chain is broken.

!short  __attr(f, b: byte): byte;                                        ECO_ext

   ^Bfunction  __attr(f, b: byte): byte;^N

   Construct a byte from two colours.

!short  __coordmou(var x: word; var y: word);                            ECO_ext

   ^Bprocedure __coordmou(var x: word; var y: word);^N

   PowerTools Mouse functions made easy.

!short  __delay(w: word);                                                ECO_ext

   ^Bprocedure __delay(w: word);^N

   Wait a delay, using the timer instead of the CRT unit.

!short  __delaykey(w: word);                                             ECO_ext

   ^Bprocedure __delaykey(w: word);^N

   Wait a delay, using the timer instead of the CRT unit,
   immediately if a key is pressed.

!short  __fastkey;                                                       ECO_ext

   ^Bprocedure __fastkey;^N

   Set Extended keyboard to FAST response.

!short  __funcmou(): mouseaction;                                        ECO_ext

   ^Bfunction  __funcmou(var b: word; var x: word; var y: word): mouseaction;^N

   PowerTools Mouse Functions made easy.

!short  __isboxmou(x1, y1, x2, y2, cx, cy: word): boolean;               ECO_ext

   ^Bfunction  __isboxmou(x1, y1, x2, y2, cx, cy: word): boolean;^N

   PowerTools Mouse Functions made easy.

!short  __keypressed: boolean;                                           ECO_ext

   ^Bfunction  __keypressed: boolean;^N

   Does not use CRT. Checks BIOS keyboardbuffer change.

!short  __keyword(k: _keys): word;                                       ECO_ext

   ^Bfunction  __keyword(k: _keys): word;^N

   PowerTools Keyboarde Functions made easy.
   Returns key, using __getkey;
   Change keypoller := NIL; to keypoller := @keyprocedure
   if you want a procedure to be called between keypollings.

   Where:
     ^Rkeyprocedure(var reg: registers); far;^N

!short  __main(b: longint; w: word): longint;                            ECO_ext

   ^Bfunction  __main(b: longint; w: word): longint;^N

   Calculates the main.

   ^RExamples:^N
     __main(   0, 8192) =    0
     __main(2182, 8192) = 8192
     __main(8192, 8192) = 8192
     __main(8193, 8192) = 16384


!short  __max(v1, v2: longint): longint;                                 ECO_ext

   ^Bfunction  __max(v1, v2: longint): longint;^N

   Calculates the maximum of two.

   ^RExample:^N
     __max(4, 90) = 90;

!short  __min(v1, v2: longint): longint;                                 ECO_ext

   ^Bfunction  __min(v1, v2: longint): longint;^N

   Calculates the minimum of two.

   ^RExample:^N
     __min(4, 90) = 4;

!short  __power(x, y: integer): longint;                                 ECO_ext

   ^Bfunction  __power(x, y: integer): longint;^N

   Calculates the power of two numbers.

   ^RExamples:^N
     __power(2, 3) = 8;
     __power(3, 4) = 81;
     __power(1, 0) = 1;

!short  __readkey: char;                                                 ECO_ext

   ^Bfunction  __readkey: char;^N

   Read a key from the keyboard.
   Does not use the CRT unit.

!short  __retdow(y, m, d: word): word;                                   ECO_ext

   ^Bfunction  __retdow(y, m, d: word): word;^N

   Returns the day of the week using date Y/M/D

!short  __retkey: word;                                                  ECO_ext

   ^Bfunction  __retkey: word;^N

   Returns key word;


!short  __str(st: string): integer;                                      ECO_ext

   ^Bfunction  __str(st: string): integer;^N

   Evaluate a number in a string

!short  __today: byte;                                                   ECO_ext

   ^Bfunction  __today: byte;^N

   Current day of week.
     0 - sunday,  6 - saturday

!short  __val(st: string): longint;                                      ECO_ext

   ^Bfunction  __val(st: string): longint;^N

     Evaluate string number to longint (larger numbers)

!short  Packetname_:  string;                                            ECO_fido

   ^Bfunction  packetname_:  string;^N


!short  Packetmessage_:  string;                                         ECO_fido

   ^Bfunction  packetmessage_:  string;^N


!short  Packetheader_:  string;                                          ECO_fido

   ^Bfunction  packetheader_:  string;^N


!short  Netmessage_:  string;                                            ECO_fido

   ^Bfunction  netmessage_:  string;^N


!short  Getpath_(var fname: string): boolean;                            ECO_fido

   ^Bfunction  getpath_(var fname: string): boolean;^N


!short  Getnet_(gn: string):  string;                                    ECO_fido

   ^Bfunction  getnet_(gn: string):  string;^N


!short  Getnode_(gn: string):  string;                                   ECO_fido

   ^Bfunction  getnode_(gn: string):  string;^N


!short  Msgdatestamp_:  string;                                          ECO_fido

   ^Bfunction  msgdatestamp_:  string;^N


!short  Lastmsgnum_(_netpath: string): integer;                          ECO_fido

   ^Bfunction  lastmsgnum_(_netpath: string): integer;^N


!short  Hex_ (n: word):  string;                                         ECO_fido

   ^Bfunction  hex_ (n: word):  string;^N


!short  Archivename_:  string;                                           ECO_fido

   ^Bfunction  archivename_:  string;^N


!short  Expandnodenumbers_();                                            ECO_fido

   ^Bprocedure expandnodenumbers_(var list: string; var totalnumber: integer);^N


!short  Convertnetnode_();                                               ECO_fido

   ^Bprocedure convertnetnode_(netnode: string; var net, node: word);^N



!short  __attrfilter(fileattr, filter: byte): boolean;                   ECO_fil

   ^Bfunction  __attrfilter(fileattr, filter: byte): boolean;^N

   Selects whether a file is admissible.
   ^RExamples:^N
        archive + hidden + readonly + sysfile + directory + volumid + only +
     ^B1 finding all normal files^N
       if __attrfilter(
         search.attr,
         archive + readonly
       ) then writeln('Found: ', search.name);
       Files that are found can have: none, arc, r/o or arc + r/o attributes!

     ^B2 finding all system files files^N
       if __attrfilter(
         search.attr,
         hidden + sysfile + only
       ) then writeln('Found: ', search.name);
       Files that are found can have ^Bonly^N hidden + sysfile attributes!

     ^B3 finding all system files files^N
       if __attrfilter(
         search.attr,
         volumid  directory + only + notnone
       ) then writeln('Found: ', search.name);
       Files that are found cannot have ^Bno attributes^N since
       "notnone" is specified.
       Furthermore they can have directory or volumid attributes.
       By error, since DOS normally does not allow it, files
       with both VolumID and Directory attributes are found, too.

!short  __comexebatfilter(s: namestr): boolean;                          ECO_fil

   ^Bfunction  __comexebatfilter(s: namestr): boolean;^N

   Checks whether the file specified  (like "HELLO.EXE")  end
   on either COM, EXE or BAT. Quite handy!

!short  __curdir: string;                                                ECO_fil

   ^Bfunction  __curdir: string;^N

   Returns the current directory, ending in "\".

!short  __delvlfil(drive: char): boolean;                                ECO_fil

   ^Bfunction  __delvlfil(drive: char): boolean;^N

   Delete a VolumeID

!short  __deverr: string;                                                ECO_fil

   ^Bfunction  __deverr: string;^N

   Returns the doserror in a string;

   ^RExample:^N
     if doserror > 0 then begin writeln(__deverror); halt(doserror) end;

!short  __drvparm(drv: char);                                            ECO_fil

   ^Bprocedure __drvparm(drv: char);^N

   Retrieve drive parameters into unit variables.


!short  __erasefiles(s: string);                                         ECO_fil

   ^Bprocedure __erasefiles(s: string);^N

   Erase files with dos wildcards.

!short  __existpath(s: string): boolean;                                 ECO_fil

   ^Bfunction  __existpath(s: string): boolean;^N

   Does a path exist?

!short  __extractext(name: pathstr): str3;                               ECO_fil

   ^Bfunction  __extractext(name: pathstr): str3;^N

   Extract name from pathname C:\...\FILE.EXT
   EXT is returned

!short  __extractname(s: string): string;                                ECO_fil

   ^Bfunction  __extractname(s: string): string;^N

   Extract name from pathname C:\...\FILE.EXT
   FILE is returned

!short  __extractpath(s: string): string;                                ECO_fil

   ^Bfunction  __extractpath(s: string): string;^N

   Extract name from pathname C:\...\FILE.EXT
   C:\...\ is returned

!short  __findfil(f: string; var s: string): boolean;                    ECO_fil

   ^Bfunction  __findfil(f: string; var s: string): boolean;^N

   Finds files with wildcards in f; found file is returned in s.
   If you don't (re-)move s, then the same s is found everytime.


!short  __inparams(s: string): boolean;                                  ECO_fil

   ^Bfunction  __inparams(s: string): boolean;^N

   Quickly check whether a certain parameter is present in the
   commandline.

!short  __packfil(str: string; size: byte): string;                      ECO_fil

   ^Bfunction  __packfil(str: string; size: byte): string;^N

   Display as much info as possible in size spaces. At least 15 positions.
   ("C:\FILENAME.EXT")
   ^RExample:^N
     writeln(__packfil('C:\PROG\PROJ\COMM\FILE1\COMMPROG.PAS', 20));
     writes: "C:FILE1\COMMPROG.PAS"

!short  __parsefil();                                                    ECO_fil

   ^Bprocedure __parsefil(name: filestr; var nam: namestr; var ext: extstr);^N

   filestr = string[12];

!short  __retdfil(drive: char): byte;                                    ECO_fil

   ^Bfunction  __retdfil(drive: char): byte;^N


!short  __reteqfil(drv: char; var errorcode: byte): char;                ECO_fil

   ^Bfunction  __reteqfil(drv: char; var errorcode: byte): char;^N

   Scans ghost drives and finds "brother"-drive.

!short  __searchrec();                                                   ECO_fil

   ^Bfunction  __searchrec(^N
   ^B  src                 : searchrec;^N
   ^B  nm, woord, mainsize :      word;^N
   ^B  takemainsize, extended, ^N
   ^B  ampm, show_attr, ^N
   ^B  wide                :   boolean^N
   ^B): string;^N

   To save space.

!short  __srec2srec(s: searchrec; var s2: searchrecord);                 ECO_fil

   ^Bprocedure __srec2srec(s: searchrec; var s2: searchrecord);^N

   Easy conversion

!short  __seteqfil(drv: char; var errorcode: byte): char;                ECO_fil

   ^Bfunction  __seteqfil(drv: char; var errorcode: byte): char;^N

   Set brother-drive up as ghost.

!short  __sizefil(pt: string): longint;                                  ECO_fil

   ^Bfunction  __sizefil(pt: string): longint;^N

   Return size of a file.

!short  __speedfil;                                                      ECO_fil

   ^Bprocedure __speedfil;^N

   Speeds up drive table of floppy drive.

!short  __strattr(attr: byte): string;                                   ECO_fil

   ^Bfunction  __strattr(attr: byte): string;^N

   Return attributes in a string.

!short  Fos_atcmd_(): boolean;                                           ECO_fos

   ^Bfunction  fos_atcmd_(comport_ : byte;  command_: string): boolean;^N


!short  Fos_avail_(comport_ : byte): boolean;                            ECO_fos

   ^Bfunction  fos_avail_(comport_ : byte): boolean;^N


!short  Fos_cd_(comport_ : byte): boolean;                               ECO_fos

   ^Bfunction  fos_cd_(comport_ : byte): boolean;^N


!short  Fos_checkmodem_(comport_ : byte): boolean;                       ECO_fos

   ^Bfunction  fos_checkmodem_(comport_ : byte): boolean;^N


!short  Fos_empty_comport_ : byte): boolean;                             ECO_fos

   ^Bfunction  fos_empty_(comport_ : byte): boolean;^N


!short  Fos_hangup_(comport_ : byte): boolean;                           ECO_fos

   ^Bfunction  fos_hangup_(comport_ : byte): boolean;^N


!short  Fos_oktosend_(comport_ : byte): boolean;                         ECO_fos

   ^Bfunction  fos_oktosend_(comport_ : byte): boolean;^N


!short  Fos_receive_(comport_ : byte): char;                             ECO_fos

   ^Bfunction  fos_receive_(comport_ : byte): char;^N


!short  Fos_reboot_;                                                     ECO_fos

   ^Bprocedure fos_reboot_;^N


!short  Fos_ansi_(character: char);                                      ECO_fos

   ^Bprocedure fos_ansi_(character: char);^N


!short  Fos_bios_(character: char);                                      ECO_fos

   ^Bprocedure fos_bios_(character: char);^N


!short  Fos_clear_regs_;                                                 ECO_fos

   ^Bprocedure fos_clear_regs_;^N


!short  Fos_close_(comport_ : byte);                                     ECO_fos

   ^Bprocedure fos_close_(comport_ : byte);^N


!short  Fos_dtr_(comport_ : byte;  state: boolean);                      ECO_fos

   ^Bprocedure fos_dtr_(comport_ : byte;  state: boolean);^N


!short  Fos_flow_(comport_ : byte;  state: boolean);                     ECO_fos

   ^Bprocedure fos_flow_(comport_ : byte;  state: boolean);^N


!short  Fos_flush_(comport_ : byte);                                     ECO_fos

   ^Bprocedure fos_flush_(comport_ : byte);^N


!short  Fos_init_(comport_ : byte);                                      ECO_fos

   ^Bprocedure fos_init_(comport_ : byte);^N


!short  Fos_kill_out_(comport_ : byte);                                  ECO_fos

   ^Bprocedure fos_kill_out_(comport_ : byte);^N


!short  Fos_kill_in_(comport_ : byte);                                   ECO_fos

   ^Bprocedure fos_kill_in_(comport_ : byte);^N


!short  Fos_parms_();                                                    ECO_fos

   ^Bprocedure fos_parms_(^N
   ^B  comport_ : byte;^N
   ^B  baud: integer;^N
   ^B  databits: byte;^N
   ^B  parity: char;^N
   ^B  stopbit: byte^N
   ^B);^N


!short  Fos_string_(comport_ : byte;  outstring: string);                ECO_fos

   ^Bprocedure fos_string_(comport_ : byte;  outstring: string);^N


!short  Fos_stringcrlf_();                                               ECO_fos

   ^Bprocedure fos_stringcrlf_(comport_ : byte;  outstring: string);^N


!short  Fos_watchdog_(comport_ : byte;  state: boolean);                 ECO_fos

   ^Bprocedure fos_watchdog_(comport_ : byte;  state: boolean);^N


!short  Fos_write_(comport_ : byte;  character: char);                   ECO_fos

   ^Bprocedure fos_write_(comport_ : byte;  character: char);^N



!short  Restorekbdvectors;                                               ECO_kbd

   ^Bprocedure restorekbdvectors;^N


!short  Readkeyword: word;                                               ECO_kbd

   ^Bfunction  readkeyword: word;^N


!short  Hexw(w: word): string;                                           ECO_kbd

   ^Bfunction  hexw(w: word): string;^N



!short  Mreset(var mouse: resetrec);                                     ECO_mou

   ^Bprocedure mreset(var mouse: resetrec);^N


!short  Mshow;                                                           ECO_mou

   ^Bprocedure mshow;^N


!short  Mhide;                                                           ECO_mou

   ^Bprocedure mhide;^N


!short  Mpos(var mouse: locrec);                                         ECO_mou

   ^Bprocedure mpos(var mouse: locrec);^N


!short  Mmoveto(col, row: integer);                                      ECO_mou

   ^Bprocedure mmoveto(col, row: integer);^N


!short  Mpressed(button: integer; var mouse: locrec);                    ECO_mou

   ^Bprocedure mpressed(button: integer; var mouse: locrec);^N


!short  Mreleased(button: integer; var mouse: locrec);                   ECO_mou

   ^Bprocedure mreleased(button: integer; var mouse: locrec);^N


!short  Mcolrange(min, max: integer);                                    ECO_mou

   ^Bprocedure mcolrange(min, max: integer);^N


!short  Mrowrange(min, max: integer);                                    ECO_mou

   ^Bprocedure mrowrange(min, max: integer);^N


!short  Mgraphcursor();                                                  ECO_mou

   ^Bprocedure mgraphcursor(hhot, vhot: integer; maskseg, maskofs: word);^N


!short  Mtextcursor(ctype, p1, p2: word);                                ECO_mou

   ^Bprocedure mtextcursor(ctype, p1, p2: word);^N


!short  Mmotion(var moved: moverec);                                     ECO_mou

   ^Bprocedure mmotion(var moved: moverec);^N


!short  Minsttask(mask, taskseg, taskofs: word);                         ECO_mou

   ^Bprocedure minsttask(mask, taskseg, taskofs: word);^N


!short  Mlpenon;                                                         ECO_mou

   ^Bprocedure mlpenon;^N


!short  Mlpenoff;                                                        ECO_mou

   ^Bprocedure mlpenoff;^N


!short  Mratio(horiz, vert: integer);                                    ECO_mou

   ^Bprocedure mratio(horiz, vert: integer);^N


!short  Getcolor();                                                      ECO_pal

   ^Bfunction  getcolor(^N
   ^B  x_pos, y_pos, winf, winb, wintype: byte;^N
   ^B  var fore, back: byte;^N
   ^B  msg: string^N
   ^B): byte;^N

   Uses a palette in which you can move around to choose
   the colour. If you specify a default value in fore, back,
   then, when ESCaping, the original is restored.
   The cursor then also jumpes to the right loaction.

!short  __setpopascii(x, y, f1, b1: integer);                            ECO_pasc

   ^Bprocedure __setpopascii(x, y, f1, b1: integer);^N

   Determine data for a popup ASCII table.

!short  __popascii: char;                                                ECO_pasc

   ^Bfunction  __popascii: char;^N

   Return data from a popup ASCII table

!short  __setcalc(x, y, f, b: integer);                                  ECO_pclc

   ^Bprocedure __setcalc(x, y, f, b: integer);^N

   Determine data for a popup Calculator.

!short  __popcalc: real;                                                 ECO_pclc

   ^Bfunction  __popcalc: real;^N

   Return data from a popup Calculator.

!short  Setdefaultnotes;                                                 ECO_play

   ^Bprocedure setdefaultnotes;^N

   Initialise notes for PLAY Command

!short  Play(s: string);                                                 ECO_play

   ^Bprocedure play(s: string);^N

   Plays songs in BASICA style.

  ^Bcall: play(string)^N

        music_string --- the string containing the encoded music to be
                         played.  the format is the same as that of the
                         microsoft basic play statement.  the string
                         must be <= 254 characters in length.

  calls:  sound
          getint  (internal)

  remarks:  the characters accepted by this routine are:

            a - g       musical notes
            # or +      following a - g note, indicates sharp
            -           following a - g note, indicates flat
            <           move down one octave
            >           move up one octave
            .           dot previous note (extend note duration by 3/2)
            mn          normal duration (7/8 of interval between notes)
            ms          staccato duration
            ml          legato duration
            ln          length of note (n=1-64; 1=whole note, 4=quarter note)
            pn          pause length (same n values as ln above)
            tn          tempo, n=notes/minute (n=32-255, default n=120)
            on          octave number (n=0-6, default n=4)
            nn          play note number n (n=0-84)

            the following two commands are ignored by play:

            mf          complete note before continuing
            mb          another process may begin before speaker is
                        finished playing note

  ^Bimportant --- setdefaultnotes must have been called at least once before^N
   ^B             this routine is called.^N


!short  Beep(h, l: word);                                                ECO_play

   ^Bprocedure beep(h, l: word);^N

   Standaard issue beep to speaker.


!short  Screensaver(st: string);                                         ECO_scrn

   ^Bprocedure screensaver(st: string);^N

   Graphical screensaver.


!short  Blockpos(var buffer; size: word; s: string): integer;            ECO_srch

   ^Bfunction  blockpos(var buffer;size: word;s: string): integer;^N

   Search buffer for text

!short  Makeboyertable();                                                ECO_srch

   ^Bprocedure makeboyertable(matchstring: string;var table: boyertable);^N

   Set up a boyer searchtable

!short  Boyermoore();                                                    ECO_srch

   ^Bfunction  boyermoore(^N
   ^B  var bufferaddr;size: word;start: word;var table: boyertable^N
   ^B): word;^N

  Search boyermoore-like in buffer

!short  __app(var st: string; aps: string);                              ECO_str

   ^Bprocedure __app(var st: string; aps: string);^N

   Append string to string;

!short  __backapp(s: string): string;                                    ECO_str

   ^Bfunction  __backapp(s: string): string;^N

   append \ if not existing.

!short  __backrem(s: string): string;                                    ECO_str

   ^Bfunction  __backrem(s: string): string;^N

   remove \ if present.

!short  __comp(s1, s2: string): boolean;                                 ECO_str

   ^Bfunction  __comp(s1, s2: string): boolean;^N

   rough compare two strings; (uppercase, remove white, compare).

!short  __hxdecstr(hexstr: string): longint;                             ECO_str

   ^Bfunction  __hxdecstr(hexstr: string): longint;^N

   get number from hex input.

!short  __lo(s: string): string;                                         ECO_str

   ^Bfunction  __lo(s: string): string;^N

   lowercase a string.

!short  __num(nr: longint): string;                                      ECO_str

   ^Bfunction  __num(nr: longint): string;^N

   represent number textually.

!short  __nw(s: string): string;                                         ECO_str

   ^Bfunction  __nw(s: string): string;^N

   remove all white from string.

!short  __overtype(n: byte;strs, strt: string): string;                  ECO_str

   ^Bfunction  __overtype(n: byte;strs, strt: string): string;^N

   Overtype string with part of another.

!short  __pntstr(n: longint): string;                                    ECO_str

   ^Bfunction  __pntstr(n: longint): string;^N

   Represent a number with points in it:

   ^RExample:^N
     Writeln('Free on C: ', __pntstr(diskfree(0)), ' bytes.');
     writes: Free on C: 31.753.428 bytes.

!short  __rep(n: byte; character: char): string;                         ECO_str

   ^Bfunction  __rep(n: byte; character: char): string;^N

   Replicate a number of characters.

!short  __retdowstr(dayofweek: word; ful: boolean): string;              ECO_str

   ^Bfunction  __retdowstr(dayofweek: word; ful: boolean): string;^N

   Use in combination with __retdow.
   Result: "Monday", "Thursday" etc. when ful = true, else
           "Mon", "Thu" etc.

!short  __todaystr(ful: boolean): string;                                ECO_str

   ^Bfunction  __todaystr(ful: boolean): string;^N

   Today in string notation.
   like __retdowstr.

   Result: "Monday", "Thursday" etc. when ful = true, else
           "Mon", "Thu" etc.

!short  __up(s: string): string;                                         ECO_str

   ^Bfunction  __up(s: string): string;^N

   Uppercase string.

!short  __uprem(s: string): string;                                      ECO_str

   ^Bfunction  __uprem(s: string): string;^N

   Uppercase string, and remove all white.

!short  Copystoa(s: anystr; var a; length_a: integer);                   ECO_str

   ^Bprocedure copystoa(s: anystr; var a; length_a: integer);^N

   Copies string into charcterarray.

!short  Copys2ar(s: anystr; var a; length_a: integer);                   ECO_str

   ^Bprocedure copys2ar(s: anystr; var a; length_a: integer);^N

   Copies string into charcterarray.

!short  Read_ctrls(s: anystr): anystr;                                   ECO_str

   ^Bfunction  read_ctrls(s: anystr): anystr;^N


!short  Write_ctrls(s: anystr): anystr;                                  ECO_str

   ^Bfunction  write_ctrls(s: anystr): anystr;^N


!short  Asciiz_to_str(a: asciiz): string;                                ECO_str

   ^Bfunction  asciiz_to_str(a: asciiz): string;^N


!short  Str_to_asciiz(s: string; var a: asciiz);                         ECO_str

   ^Bprocedure str_to_asciiz(s: string; var a: asciiz);^N



!short  Switch(): integer;                                               ECO_swch

   ^Bfunction  switch(drive: integer; mem: integer; command: string): integer;^N



!short  Starttimer (whichclock: byte);                                   ECO_time

   ^Bprocedure starttimer (whichclock: byte);^N
   starts the internal clock.  resets the clock if it was previously set.


!short  Getlaptime (whichclock: byte): string;                           ECO_time

   ^Bfunction  getlaptime (whichclock: byte): string;^N
   returns a string showing the elapsed time.  the returned string is...
   "xx: xx: xx.xx".  the clock continues to run.


!short  Restarttimer (whichclock: byte);                                 ECO_time

   ^Bprocedure restarttimer (whichclock: byte);^N
   restarts the clock if the stoptimer procedure stopped the clock.
   it does nothing if the clock is still running.


!short  Stoptimer (whichclock: byte): string;                            ECO_time

   ^Bfunction  stoptimer (whichclock: byte): string;^N
   stops the timer without clearing the elapsed time.
   returned string will be one of the following...
   "xx: xx: xx.xx", or "Can't stop clock #0!".



!short  __palget(var origpal: paltype);                                  ECO_vga

   ^Bprocedure __palget(var origpal: paltype);^N


!short  __palfade(origpal: paltype; fadeout: boolean);                   ECO_vga

   ^Bprocedure __palfade(origpal: paltype; fadeout: boolean);^N


!short  __palblack(origpal: paltype);                                    ECO_vga

   ^Bprocedure __palblack(origpal: paltype);^N


!short  __palput(origpal: paltype);                                      ECO_vga

   ^Bprocedure __palput(origpal: paltype);^N



!short  __attrib(x1, y1, x2, y2, f, b: byte);                            ECO_vid

   ^Bprocedure __attrib(x1, y1, x2, y2, f, b: byte);^N


!short  __bandwin(del: boolean; x1, y1, x2, y2, f, b, bt: byte);         ECO_vid

   ^Bprocedure __bandwin(del: boolean; x1, y1, x2, y2, f, b, bt: byte);^N


!short  __barchoice(x, x1, y, f, b, h: byte; st: string): byte;          ECO_vid

   ^Bfunction  __barchoice(x, x1, y, f, b, h: byte; st: string): byte;^N

   ^RUsage:^N
   __barchoise(10, 30, 12, lightblue, black, lightred,
     ' Keep_option    Kill_it!     Next '
   );
   ^RWhere^N you can press <SPACE>, <LEFT?, <RIGHT>, <ESC>, <ENTER> or one of the
   uppercasedm, direct, letterkeys.
   ^RReturns^N
     0 = Esc
     1 = Item 1
     .
     .
     N = Item N

!short  __betwscn(x1, x2, y, f, b: byte; st: string);                    ECO_vid

   ^Bprocedure __betwscn(x1, x2, y, f, b: byte; st: string);^N


!short  __clrscn(x1, y1, x2, y2, f, b: byte; c: char);                   ECO_vid

   ^Bprocedure __clrscn(x1, y1, x2, y2, f, b: byte; c: char);^N


!short  __cls;                                                           ECO_vid

   ^Bprocedure __cls;^N


!short  __copyfil(): byte;                                               ECO_vid

   ^Bfunction  __copyfil(^N
   ^B  x1, x2, y, f, b: byte; fs: longint; src, targ: string^N
   ^B): byte;^N

   Copies a file, with attractive progression bar.

!short  __copyscn(x1, y1, x2, y2, x, y: byte);                           ECO_vid

   ^Bprocedure __copyscn(x1, y1, x2, y2, x, y: byte);^N


!short  __ECO_message;                                                   ECO_vid

   ^Bprocedure __ECO_message;^N


!short  __hbetwscn(x1, x2, y, f, b, h: byte; st: string);                ECO_vid

   ^Bprocedure __hbetwscn(x1, x2, y, f, b, h: byte; st: string);^N

   Like __quikscn;
   ^RUsage:^N
     __hbetwscn(1, 80, _currows div 2, 7, 0, 12, 'Choise: ~F1~: nothing');
     All is colour 7 (lightgray), F1 is lightred.

!short  __hquikscn(x, y, f, b, h: byte; st: string);                     ECO_vid

   ^Bprocedure __hquikscn(x, y, f, b, h: byte; st: string);^N


!short  __nocrt;                                                         ECO_vid

   ^Bprocedure __nocrt;^N


!short  __panelwin();                                                    ECO_vid

   ^Bprocedure __panelwin(del: boolean; x1, y1, x2, y2, f, b, bt: byte);^N

   Like bandwin;

!short  __partscn();                                                     ECO_vid

   ^Bprocedure __partscn(sc: pointer; x1, y1, x2, y2: byte; toscreen: boolean);^N

   Restore part of screen;

!short  __ptd_message;                                                   ECO_vid

   ^Bprocedure __ptd_message;^N


!short  __qvertscn(x1, y1, f, b: byte;  st: string);                     ECO_vid

   ^Bprocedure __qvertscn(x1, y1, f, b: byte;  st: string);^N


!short  __repscn(f, b: byte; st: string);                                ECO_vid

   ^Bprocedure __repscn(f, b: byte; st: string);^N


!short  __resscn(sc: _scnimageptr);                                      ECO_vid

   ^Bprocedure __resscn(sc: _scnimageptr);^N


!short  __savscn(sc: _scnimageptr);                                      ECO_vid

   ^Bprocedure __savscn(sc: _scnimageptr);^N


!short  __setblwin(blink: boolean);                                      ECO_vid

   ^Bprocedure __setblwin(blink: boolean);^N

   Set bit for blinking off or on.
   Works on Hercules, EGA or VGA.
   __BlinkScn works only on ?GA adapters.


!short  Zmodem_receive();                                                ECO_zmod

   ^Bfunction  zmodem_receive(^N
   ^B  path: string; comport: word; baudrate: longint^N
   ^B): boolean;^N


!short  Zmodem_send();                                                   ECO_zmod

   ^Bfunction  zmodem_send(^N
   ^B  pathname: string; lastfile: boolean; comport: word; baudrate: longint^N
   ^B): boolean;^N