home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / ECO30603.ZIP / ECO30603.LZH / ECOLIBNG / SOURCE / ECO_CONC.DAT < prev    next >
Encoding:
Text File  |  1992-09-26  |  27.1 KB  |  819 lines
  1. !short unit eco_lib;
  2.  
  3.   This is The ECO Library II -- Concise Edition
  4.  
  5.   It contains all functions freqently used by DOS - OS/2 programmers.
  6.   It is not depending on any other units that SYSTEM.TPU from
  7.   TurboPascal V6.0 or higher.
  8.   In crossplatform development, you should therefore have not much
  9.   troubles locating the cumbersome parts, and convert them to
  10.   the standards requested by those environments.
  11.   
  12.   The code has been written thus, that conversion to C(++) is very
  13.   easy. In fact, almost all little warnings and errors now
  14.   pertain to the field of string conversion (str[0] manipulation).
  15.   This should be solved easily.
  16.  
  17.  
  18.  
  19. !short   STANDARD constants
  20.  
  21.  
  22.   none = $00; only = $40; notnone = $80;
  23.  
  24.   _period      = $342E;  _colon       = $273A;  _c_2= $0300;
  25.   _slash       = $352F;  _padslash    = $E02F;  _c_6= $071E;
  26.                                                 _c_minus = $0C1F;
  27.   _left        = $4BE0;  _padleft     = $4B00;
  28.   _cleft       = $73E0;  _cpadleft    = $7300;
  29.   _right       = $4DE0;  _padright    = $4D00;
  30.   _cright      = $74E0;  _cpadright   = $7400;
  31.   _up          = $48E0;  _padup       = $4800;
  32.   _down        = $50E0;  _paddown     = $5000;
  33.   _pgup        = $49E0;  _padpgup     = $4900;
  34.   _pgdn        = $51E0;  _padpgdn     = $5100;
  35.   _home        = $47E0;  _padhome     = $4700;
  36.   _chome       = $7700;  _end         = $4FE0;
  37.   _padend      = $4F00;  _cend        = $7500;
  38.   _ins         = $52E0;  _padins      = $5200;
  39.   _del         = $53E0;  _paddel      = $5300;
  40.   _spaddel     = $532E;  _backspace   = $0E08;
  41.   _minus       = $0C2D;  _padminus    = $4A2D;
  42.   _plus        = $0D2B;  _padplus     = $4E2B;
  43.   _star        = $092A;  _padstar     = $372A;
  44.   _enter       = $1C0D;  _newline     = $1C0A;
  45.   _padenter    = $E00D;
  46.  
  47.   _tab         = $0F09;  _s_tab       = $0F00;
  48.   _esc         = $011B;  _space       = $3920;
  49.  
  50.   _a    = $1E61;  _b     = $3062;  _s_a  = $1E41;  _s_b   = $3042;
  51.   _c    = $2E63;  _d     = $2064;  _s_c  = $2E43;  _s_d   = $2044;
  52.   _e    = $1265;  _f     = $2166;  _s_e  = $1245;  _s_f   = $2146;
  53.   _g    = $2267;  _h     = $2368;  _s_g  = $2247;  _s_h   = $2348;
  54.   _i    = $1769;  _j     = $246A;  _s_i  = $1749;  _s_j   = $244A;
  55.   _k    = $256B;  _l     = $266C;  _s_k  = $254B;  _s_l   = $264C;
  56.   _m    = $326D;  _n     = $316E;  _s_m  = $324D;  _s_n   = $314E;
  57.   _o    = $186F;  _p     = $1970;  _s_o  = $184F;  _s_p   = $1950;
  58.   _q    = $1071;  _r     = $1372;  _s_q  = $1051;  _s_r   = $1352;
  59.   _s    = $1F73;  _t     = $1474;  _s_s  = $1F53;  _s_t   = $1454;
  60.   _u    = $1675;  _v     = $2F76;  _s_u  = $1655;  _s_v   = $2F56;
  61.   _w    = $1177;  _x     = $2D78;  _s_w  = $1157;  _s_x   = $2D58;
  62.   _y    = $1579;  _z     = $2C7A;  _s_y  = $1559;  _s_z   = $2C5A;
  63.  
  64.   _c_a  = $1E01;  _c_b   = $3002;  _a_a  = $1E00;  _a_b   = $3000;
  65.   _c_c  = $2E03;  _c_d   = $2004;  _a_c  = $2E00;  _a_d   = $2000;
  66.   _c_e  = $1205;  _c_f   = $2106;  _a_e  = $1200;  _a_f   = $2100;
  67.   _c_g  = $2207;  _c_h   = $2308;  _a_g  = $2200;  _a_h   = $2300;
  68.   _c_i  = $1709;  _c_j   = $240A;  _a_i  = $1700;  _a_j   = $2400;
  69.   _c_k  = $250B;  _c_l   = $260C;  _a_k  = $2500;  _a_l   = $2600;
  70.   _c_m  = $320D;  _c_n   = $310E;  _a_m  = $3200;  _a_n   = $3100;
  71.   _c_o  = $180F;  _c_p   = $1910;  _a_o  = $1800;  _a_p   = $1900;
  72.   _c_q  = $1011;  _c_r   = $1312;  _a_q  = $1000;  _a_r   = $1300;
  73.   _c_s  = $1F13;  _c_t   = $1414;  _a_s  = $1F00;  _a_t   = $1400;
  74.   _c_u  = $1615;  _c_v   = $2F16;  _a_u  = $1600;  _a_v   = $2F00;
  75.   _c_w  = $1117;  _c_x   = $2D18;  _a_w  = $1100;  _a_x   = $2D00;
  76.   _c_y  = $1519;  _c_z   = $2C1A;  _a_y  = $1500;  _a_z   = $2C00;
  77.  
  78.   _f1   = $3B00;  _f2    = $3C00;  _f3   = $3D00;  _f4    = $3E00;
  79.   _f5   = $3F00;  _f6    = $4000;  _f7   = $4100;  _f8    = $4200;
  80.   _f9   = $4300;  _f10   = $4400;
  81.  
  82.   _s_f1 = $5400;  _s_f2  = $5500;  _s_f3 = $5600;  _s_f4  = $5700;
  83.   _s_f5 = $5800;  _s_f6  = $5900;  _s_f7 = $5A00;  _s_f8  = $5B00;
  84.   _s_f9 = $5C00;  _s_f10 = $5D00;
  85.  
  86.   _c_f1 = $5E00;  _c_f2  = $5F00;  _c_f3 = $6000;  _c_f4  = $6100;
  87.   _c_f5 = $6200;  _c_f6  = $6300;  _c_f7 = $6400;  _c_f8  = $6500;
  88.   _c_f9 = $6600;  _c_f10 = $6700;
  89.  
  90.   _a_f1 = $6800;  _a_f2  = $6900;  _a_f3 = $6A00;  _a_f4  = $6B00;
  91.   _a_f5 = $6C00;  _a_f6  = $6D00;  _a_f7 = $6E00;  _a_f8  = $6F00;
  92.   _a_f9 = $7000;  _a_f10 = $7100;
  93.  
  94.  
  95. !short   STRING constants
  96.  
  97.   _left_just_str       = 0;
  98.   _right_just_str      = 1;
  99.   _center_str          = 2;
  100.  
  101.   _rem_white_str       = $0001;
  102.   _rem_lead_white_str  = $0002;
  103.   _rem_trail_white_str = $0004;
  104.   _reduce_white_str    = $0008;
  105.   _save_quoted_str     = $0010;
  106.   _to_upcase_str       = $0020;
  107.   _to_lowcase_str      = $0040;
  108.   _discard_str         = $0080;
  109.  
  110.   _usa_dt_str          = 0;
  111.   _euro_dt_str         = 1;
  112.   _year_dt_str         = 2;
  113.   _mont_dt_str         = 3;
  114.   _form_dt_str         = 4;
  115.  
  116.   _12hour_str          = $0001;
  117.   _inc_sec_str         = $0002;
  118.   _inc_tic_str         = $0004;
  119.   _inc_ampm_str        = $0008;
  120.   _standard_str        = $0009;
  121.   _complete_str        = $0006;
  122.   _dos_dir_str         = $0011;
  123.  
  124.   _ampm_str            : array[0..1] of string[3] = (' AM',' PM');
  125.   _ap_str              : string[2] = 'ap';
  126.  
  127.   _fmt_buflen_str      = 256;
  128.  
  129.   _strmonths  : array[1..12] of string[9] = (
  130.     'January', 'February', 'March', 'April', 'May', 'June', 'July',
  131.     'August', 'September', 'October', 'November',  'December'
  132.   );
  133.  
  134.   _strdays    : array[0..6] of string[9] = (
  135.     'Sunday', 'Monday', 'Tuesday', 'Wednesday',
  136.     'Thursday', 'Friday', 'Saturday'
  137.   );
  138.  
  139.   _strusach   : char = '/';
  140.   _streuroch  : char = '-';
  141.   _strmoneych : char = 'f';
  142.  
  143.   fk_ctrl_mark: char = '^';
  144.   nonblock    : char = '-';
  145.   block       : char = 'X';
  146.   maxstr_     =        255;
  147.  
  148.   logfilename : string[12] = 'ECOPURGE.LOG';         { 22 Aug 69  14:50.11 }
  149.   programname : string[40] =     'ECOPURGE';
  150.   purge : byte =   7;
  151.   lines : word = 512;
  152.  
  153.  
  154. !short   DOS constants
  155.  
  156.   (* flags bit masks *)
  157.  
  158.   fcarry     = $0001;
  159.   fparity    = $0004;
  160.   fauxiliary = $0010;
  161.   fzero      = $0040;
  162.   fsign      = $0080;
  163.   foverflow  = $0800;
  164.  
  165.   (* file mode magic numbers *)
  166.  
  167.   fmclosed = $d7b0;
  168.   fminput  = $d7b1;
  169.   fmoutput = $d7b2;
  170.   fminout  = $d7b3;
  171.  
  172.   (* file attribute constants *)
  173.  
  174.   readonly  = $01;
  175.   hidden    = $02;
  176.   sysfile   = $04;
  177.   volumeid  = $08;
  178.   directory = $10;
  179.   archive   = $20;
  180.   anyfile   = $3f;
  181.  
  182.   _keep_mode  = -1;        { do not change file mode in fopen }
  183.   _readonly   = $00;       {     share mode dos 3++ and above }
  184.   _denyall    = $10;
  185.   _writeonly  = $01;
  186.   _denywrite  = $20;
  187.   _readwrite  = $02;
  188.   _denyread   = $30;
  189.   _denynone   = $40;
  190.  
  191.   lockregion   = 00;
  192.   unlockregion = 01;
  193.  
  194.  
  195.  
  196. !short   CHAR constants 
  197.  
  198.   nullchar = $00;
  199.   colon    = ':';
  200.   period   = '.';
  201.   separ    = 'ยท';
  202.   space    = ' ';
  203.   zero     = '0';
  204.  
  205.  
  206. !short   SCREEN constants 
  207.  
  208.   fcol: byte = 7;
  209.   bcol: byte = 0;
  210.   bt_double    = 15;     bt_single    =   0;
  211.   black        = 00;     blue         = 01;
  212.   green        = 02;     cyan         = 03;
  213.   red          = 04;     magenta      = 05;
  214.   brown        = 06;     lightgray    = 07;
  215.   darkgray     = 08;     lightblue    = 09;
  216.   lightgreen   = 10;     lightcyan    = 11;
  217.   lightred     = 12;     lightmagenta = 13;
  218.   yellow       = 14;     white        = 15;
  219.   blink        = 128;
  220.  
  221.   _unknown     = $7f;
  222.   _absent      = 0;                 { no adapter installed           }
  223.   _mono        = 1;                 { monochrome type adapter        }
  224.   _color       = 2;                 { color type adapter             }
  225.  
  226.   _biosseg     = $0040;             { segment of bios/dos communica- }
  227.  
  228.  
  229.  
  230. !short   TYPES used in the unit
  231.  
  232. type
  233.   stream = file;
  234.   textbuf = array [0..127] of char;
  235.   textrec = record
  236.     handle    : word;
  237.     mode      : word;
  238.     bufsize   : word;
  239.     private   : word;
  240.     bufpos    : word;
  241.     bufend    : word;
  242.     bufptr    : ^textbuf;
  243.     openfunc  : pointer;
  244.     inoutfunc : pointer;
  245.     flushfunc : pointer;
  246.     closefunc : pointer;
  247.     userdata  : array [1..16] of byte;
  248.     name      : array [0..79] of char;
  249.     buffer    : textbuf;
  250.   end;
  251.   comstr  = string[127];        { command line string }
  252.   pathstr = string[79];         { full file path string }
  253.   dirstr  = string[67];         { drive and directory string }
  254.   namestr = string[8];          { file name string }
  255.   extstr  = string[4];          { file extension string }
  256.   filestr = string[12];         { file name + extension string }
  257.   registers = record case integer of
  258.     0 : (ax,bx,cx,dx,bp,si,di,ds,es,flags : word);
  259.     1 : (al,ah,bl,bh,cl,ch,dl,dh : byte);
  260.   end;
  261.   searchrec = record
  262.     fill : array [1..21] of byte;
  263.     attr : byte;
  264.     time : longint;
  265.     size : longint;
  266.     name : string[12];
  267.   end;
  268.   datetime = record
  269.     year,month,day,hour,min,sec : word;
  270.   end;
  271.  
  272.   _memorychar = array[1..65534] of char;
  273.   _vectoraddr = record _ofs : word; _seg : word end;
  274.   str3        =              string[3];
  275.   str8        =              string[8];
  276.   str9        =              string[9];
  277.   str32       =             string[32];
  278.   anystr      =                 string;
  279.   asciiz      =  array[0..255] of char;
  280.   asciizptr   =                ^asciiz;
  281.   ar1024      = array[1..1024] of char;
  282.  
  283.  
  284.   daterecord = record
  285.     year      : word;
  286.     month     : word;
  287.     date      : word;
  288.     dayofweek : word
  289.   end;
  290.  
  291.   timerecord = record
  292.     hour      : word;
  293.     minute    : word;
  294.     second    : word;
  295.     hundredth : word
  296.   end;
  297.  
  298.   clockrecord = record
  299.     clockstartdate : daterecord;
  300.     clockstarttime : timerecord;
  301.     elapsedtime    : timerecord;
  302.     clockisrunning : boolean;
  303.   end;
  304.  
  305.   _scnpos = record _ch : char; _attr : byte end;
  306.   _scnimage    = array[1..4000] of _scnpos;
  307.   _scnimageptr = ^_scnimage;
  308.   str80 = string[80];
  309.   _monitortype = (
  310.     _nomonitor,
  311.     _monomonitor,      { monochrome monitor             }
  312.     _colormonitor,     { color monitor (composite also) }
  313.     _enhancedmonitor,  { ega rnhanced color monitor     }
  314.     _anmonomonitor,    { ps/2 analog monochrome monitor }
  315.     _ancolormonitor    { ps/2 analog color monitor      }
  316.   );
  317.  
  318.  
  319. !Short   VARIABLES used
  320. var
  321.   exitcode       :    word;
  322.   doserror       : integer;
  323.   _dosdrv        : integer;
  324.   _dosdrvchar    :    char;
  325.   _doscurpath    : pathstr;
  326.   _dosdiscfree,
  327.   _dosdiscsize   : longint;
  328.  
  329.   lastkey        :    char;
  330.   lastscan       :    byte;
  331.  
  332.   logheader      : array[1..11] of string[62];
  333.   error,
  334.   yr, mo, da     : word;
  335.   i              : byte;
  336.  
  337.   _hidemouse     : byte;
  338.   baseofscreen,
  339.   vseg, vofs,
  340.   rows, cols, 
  341.   _curcolumns,                      { number of screen columns       }
  342.   _currows       : word;            { number of screen rows          }
  343.  
  344.   _scnloc         : _scnimageptr;    { screen adapter memory location }
  345.   _curmonitor     : _monitortype;    { monitor attached to _curdevice }
  346.   _curmode        : byte;            { current video display mode     }
  347.   _curdevice      : byte;            { _mono or _color device         }
  348.   _maxdisplaypage : byte;            { maximum display page number    }
  349.   _curdisplaypage : byte;            { current video display page     }
  350.   _curactivepage  : byte;            { current video active page      }
  351.   _monoadapter    : byte;            { monochrome adapter             }
  352.   _coloradapter   : byte;            { color/graphics adapter         }
  353.   _egaadapter     : byte;            { ega adapter                    }
  354.   _hercadapter    : byte;            { hercules mono graphics card    }
  355.   _vgaadapter     : byte;            { ps/2 video graphics array      }
  356.   _mcgaadapter    : byte;            { ps/2 model 30 adapter          }
  357.   _scrolltab      : word;            { spaces to skip for tab scroll  }
  358.   _tabincr        : word;            { tab increment for _txbufscn    }
  359.   _bufindent      : word;            { left margin for _txbufscn      }
  360.  
  361.   {scnstate_        : scnstat_;    }  { bios video save information    }
  362.   {availcolormodes_ : videomodes_; }  { modes available on color device}
  363.   {availmonomodes_  : videomodes_; }  { modes available on mono device }
  364.   {availcolorrows_  : legalrows_;  }  { rows available on color device }
  365.   {availmonorows_   : legalrows_;  }  { rows available on mono device  }
  366.   {dualdisplay_     : boolean;     }  { two adapters present           }
  367.   egamonitor_       : _monitortype;  { monitor attached: ega          }
  368.   analogmonitor_    : _monitortype;  { monitor attached: vga/mcga     }
  369.   egamemory_        : word;          { 64, 128, 192, or 256 (k)       }
  370.   maxscanline_      : byte;          { current character set size     }
  371.  
  372.   scn1, scn2, 
  373.   scn3, scn4        : _scnimageptr;
  374.  
  375.  
  376. !short 
  377.  
  378.  
  379.  
  380.  
  381. !short   BASE STRING functions
  382.  
  383. { BASE STRING FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  384.   function __leftstr(source : string;   num : word): string;
  385.   function __rightstr(source : string; chpos : word): string;
  386.   function __substr(source : string;   chpos, num: word): string;
  387.   function __midstr(source,target : string; chpos: word): string;
  388.   function __fillstr(
  389.     fillch : char; target : string;
  390.     chpos,num : word
  391.   ): string;
  392.   function __xlatestr(source,table,trans : string) : string;
  393.   function __juststr(
  394.     source : string;  fillch : char;
  395.     fieldsize : word;
  396.     justcode : word
  397.   ): string;
  398.   function __cvtstr(source : string; cvtcode : word) : string;
  399.   function __entabstr(source : string; incr : byte) : string;
  400.   function __detabstr(
  401.     source : string; incr : byte;
  402.     var remstr : string
  403.   ): string;
  404.   function __toradstr(
  405.     intvalue : longint;
  406.     size,radix,width: word
  407.   ): string;
  408.   function __todecstr(intvalue: longint; size: word) : string;
  409.   function __tohexstr(intvalue: longint; size: word) : string;
  410.   function __ptr2str(thisptr: pointer): string;
  411.   function __formstr(mask : string; x : real) : string;
  412.   procedure __initfstr(var fmtfil : text);
  413.   function __retbfstr(var fmtfil : text) : string;
  414.   function __dirstr(srec : searchrec) : string;
  415.   function locase(ch : char) : char;
  416.  
  417.  
  418.  
  419.  
  420.  
  421. !short   SECONDARY STRING functions
  422.  
  423. { SECONDARY STRING FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  424.   procedure __app(var st: string; aps: string);
  425.   function  __backapp(s: string) : string;
  426.   function  __backrem(s: string) : string;
  427.  
  428.   function  __comp(s1, s2: string): boolean;
  429.   function  __overtype(n:byte;strs,strt:string):string;
  430.   function  __rep(n: byte; character: char): string;
  431.   function  __nw(s: string): string;
  432.  
  433.   function  __pntstr(n: longint): string;
  434.   function  __up(s: string): string;
  435.   function  __lo(s: string): string;
  436.   function  __uprem(s: string): string;
  437.  
  438.   function  __hexdecstr(hexstr: string): longint;
  439.   function  __str(st: string): integer;
  440.   function  __num(nr: longint): string;
  441.   function  __val(st: string): longint;
  442.  
  443.   function  __byte2str(b: byte): str8;
  444.   function  __str2byte(s: str8): byte;
  445.   function  __longint2str(l: longint): str32;
  446.   function  __str2longint(s: str32): longint;
  447.  
  448.   procedure __str2obj(s: anystr; var a; length_a: integer);
  449.   procedure __str2arr(s: anystr; var a; length_a: integer);
  450.   function  __readctrls(s: anystr): anystr;
  451.   function  __writectrls(s: anystr): anystr;
  452.   function  __az2str(a: asciiz): string;
  453.   procedure __str2az(s: string; var a : asciiz);
  454.  
  455.   procedure __clr1024(var a: ar1024);
  456.   procedure __app1024(var app: ar1024; s: string);
  457.   function  __len1024(var a: ar1024) : word;
  458.   procedure __del1024(var a: ar1024; b, l: word);
  459.   procedure __ins1024(var a: ar1024; b : word; s: string);
  460.   procedure __write1024(var a: ar1024);
  461.  
  462.  
  463.  
  464.  
  465. !short   PRIMARY DATA CONVERSION functions
  466.  
  467.  
  468. { PRIMARY DATA CONVERSION FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  469.   function  __main(b: longint; w: word): longint;
  470.   function  __max(v1, v2: longint): longint;
  471.   function  __min(v1, v2: longint): longint;
  472.   function  __power(x,y: integer): longint;
  473.  
  474.  
  475.  
  476.   function __2longsup(hiword,loword : word): longint;
  477.   inline($58 { pop ax } /$5A); { pop dx          }
  478.  
  479.   function __hiwrdsup(intvalue : longint) : word;
  480.   inline($58 { pop ax } /$58); { pop ax }
  481.  
  482.     function __lowrdsup(intvalue : longint) : word;
  483.   inline($58 { pop ax } /$5A); { pop dx }
  484.  
  485.   function  __2wordsup(hibyte,lobyte : byte) : word;
  486.   inline($58 { pop ax } /$5A { pop dx } /$8A/$E2); { mov ah,dl }
  487.  
  488.   function __2bytesup(hinybble,lonybble : byte) : byte;
  489.   inline(
  490.     $5B/      { pop bx     }  $58/          { pop ax     }
  491.     $32/$E4/  { xor ah,ah  }  $b1/$04/      { mov cl,4   }
  492.     $d3/$E0/  { shl ax,cl  }  $80/$e3/$0f/  { and bl,0fh }
  493.     $0A/$C3   { or  al,bl  }
  494.   );
  495.  
  496.   function  __hinybsup(bytevalue : byte) : byte;
  497.   inline(
  498.     $58 { pop ax } /$32/$E4  { xor ah,ah }
  499.     /$B1/$04 { mov cl,4 } /$D3/$E8 { shr ax,cl }
  500.   );
  501.  
  502.     function __lonybsup(bytevalue : byte) : byte;
  503.   inline($58 { pop ax } /$25/$0F/$00); { and ax,000fh }
  504.   
  505.   procedure __fcallsup(procptr : pointer; var reg : registers);
  506.   inline(
  507.     $8B/$DC/ { mov  bx,sp } $83/$C3/$04/  { add  bx,4 }
  508.     $36/$FF/$1F/ { call dword ptr ss:[bx] } $83/$C4/$04 { add  sp,4 }
  509.   );
  510.  
  511.   procedure __ncallsup(procptr : pointer; var reg : registers);
  512.   inline(
  513.     $8B/$DC { mov  bx,sp } /$83/$C3/$04 { add  bx,4 }
  514.     /$36/$FF/$17 { call word ptr ss:[bx] } /$83/$C4/$04 { add  sp,4 }
  515.   );
  516.  
  517.     function  __caddrsup : pointer;
  518.     inline(
  519.     $8B/$46/$02 { mov ax,[bp + 2] } /$2D/$03/$00 { sub ax,3 }
  520.     /$8B/$56/$04 { mov dx,[bp + 4] }
  521.   );
  522.  
  523.   procedure __iptrsup (var p : pointer; n : longint);
  524.   procedure __dptrsup (var p : pointer; n : longint);
  525.   function  __nptrsup (thisptr : pointer) : pointer;
  526.   function  __ptr2lsup(thisptr : pointer) : longint;
  527.   procedure __fillwsup(var target; count : longint; fillword : word);
  528.   procedure __fillbsup(var target; count : longint; fillbyte : byte);
  529.   procedure __repmsup (var target,source; count : longint; sourcesize : word);
  530.   function  __alphasup(ch : char) : boolean;
  531.  
  532.  
  533.  
  534.  
  535. !short   IMPORTANT DOS functions
  536.  
  537. { IMPORTANT DOS FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  538.  
  539.   procedure getdate(var year,month,day,dayofweek : word);
  540.   procedure setdate(year,month,day : word);
  541.   procedure gettime(var hour,minute,second,sec100 : word);
  542.   procedure settime(hour,minute,second,sec100 : word);
  543.  
  544.   function  diskfree(drive : byte) : longint;
  545.   function  disksize(drive : byte) : longint;
  546.  
  547.   procedure getfattr(var f;var attr : word);
  548.   procedure setfattr(var f;attr : word);
  549.   procedure getftime(var f;var time : longint);
  550.   procedure setftime(var f;time : longint);
  551.  
  552.   procedure findfirst(path : pathstr;attr : word;var f : searchrec);
  553.   procedure findnext(var f : searchrec);
  554.  
  555.   function  fexpand(path : pathstr) : pathstr;
  556.   procedure fsplit(
  557.     path : pathstr;var dir : dirstr;
  558.     var name : namestr;var ext : extstr
  559.   );
  560.  
  561.   function  __existfil(pathname : pathstr) : boolean;
  562.   procedure __erasefil(filename : pathstr; var errorcode : word);
  563.   procedure intr(intno : byte; var regs : registers);
  564.   procedure swapvectors;
  565.   function  envcount : integer;
  566.   function  envstr(index : integer) : string;
  567.   function  getenv(envvar : string) : string;
  568.   function  __dosinkey(var extendedcode : byte) : char;
  569.   function  __retkey: word;
  570.   function  __exinkey(useextended: boolean; var scancode: byte): char;
  571.   function  __exrdykey(
  572.     useextended : boolean;
  573.     var nextch : char;
  574.     var scancode : byte
  575.   ) : boolean;
  576.   procedure __flushkey;
  577.  
  578.  
  579.   { LOCK FUNCTIONS }
  580.   function fopen(var fv : stream; fn : pathstr; mode : integer) : integer;
  581.   function fclose(var fv : stream) : integer;
  582.   function shareloaded : boolean;
  583.   function filelock(
  584.     handle :    word;
  585.     action :    byte;
  586.     start,    
  587.     bytes  : longint;
  588.     var ax : integer
  589.   ): boolean;
  590.  
  591.  
  592.  
  593. !short   DATE functions
  594.  
  595. { DATE FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  596.   function  __dt2ststr(year, month, day, datefmt : word): string;
  597.   function  __datestr(var year,month,day: word): string;
  598.   function  __timestr(var hours,minutes,seconds,tics: word): string;
  599.   procedure __st2dtstr(st: string; var year, month, day: word; datefmt: word);
  600.   function  __time2str(hours, mins, secs, tics, format: word): string;
  601.   function  __2timestr(timestr: string; var hours,mins,secs,tics:word): boolean;
  602.  
  603.   function  __retdowstr(dayofweek: word; ful: boolean): string;
  604.   function  __todaystr(ful: boolean): string;
  605.   procedure __jl2dtutl(julian: longint; var year, month, day, weekday: word);
  606.   function  __dt2jlutl(year, month, day : word) : longint;
  607.   function  __daysutl(yr1, mn1, day1 : word; yr2, mn2, day2 : word) : longint;
  608.   function  __retdow(y, m, d: word): word;
  609.   function  __today: byte;
  610.  
  611.   function  __curdate: string;
  612.   function  __curdate2longint: longint;
  613.   function  __longint2date(l: longint): string;
  614.   function  __date2longint(d: string): longint; {     'xx NNN yy  HH:MM.ss' }
  615.                                                 { eg. '22 Aug 69  14:50.11' }
  616.   procedure __longint2datetime(d : longint; var dt : datetime);
  617.   function  format_date(dt : datetime; format : byte): string;
  618.   function  __formatdate(d : longint; format : byte): string;
  619.  
  620.   function  __dbdate: string;
  621.   function  __radate: string;
  622.  
  623.   procedure unpacktime(p : longint;var t : datetime);
  624.   procedure packtime(var t : datetime;var p : longint);
  625.  
  626.  
  627.  
  628.  
  629. !short   TIMER functions
  630.  
  631. { IMPORTANT TIMER FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  632.   procedure starttimer(whichclock : byte);
  633.   function  getlaptime(whichclock : byte) : string;
  634.   procedure restarttimer(whichclock : byte);
  635.   function  stoptimer(whichclock : byte) : string;
  636.  
  637.  
  638.  
  639.  
  640. !short   FILE functions
  641.  
  642. { IMPORTANT FILE FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  643.   function  __attrfilter(fileattr, filter: byte): boolean;
  644.   function  __bak(s: string): string;
  645.   function  __comexebatcmdfilter(s: namestr): boolean;
  646.   function  __curdir: string;
  647.   function  __deverr: string;
  648.   procedure __drvparm(drv: char);
  649.   procedure __erasefiles(s: string);
  650.   function  __existpath(s: string): boolean;
  651.   function  __extractext(name: pathstr): str3;
  652.   function  __extractname(s : string): string;
  653.   function  __extractpath(s : string): string;
  654.   function  __findfil(f: string; var s: string): boolean;
  655.   function  __inparams(s: string; var i: word): boolean;
  656.   function  __packfil(str: string; size: byte): string;
  657.   procedure __parsefil(name: filestr; var nam: namestr; var ext: extstr);
  658.   function  __searchrec(
  659.     src                  : searchrec;
  660.     nm, woord, mainsize  :      word;
  661.     takemainsize, extended,
  662.     ampm, show_attr,
  663.     wide                 :   boolean
  664.   ): string;
  665.   function  __sizefil(pt: string): longint;
  666.   function  __strattr(attr: byte; full: boolean): string;
  667.   procedure __uniquefil(               { i.s.o. __tempfil, an unique textfile }
  668.     var pathname: string; var tmpfile: text; var errorcode: word
  669.   );
  670.   function  __copyfil(x1,x2,y,f,b: byte; fs: longint; src, targ: string): byte;
  671.  
  672.  
  673.  
  674. !short   LOG functions
  675.  
  676. { XXXXXXXXXX LOG FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  677.  
  678.  
  679.   procedure __loginit;
  680.   procedure __logapp(s: string);
  681.   procedure __filapp(fil, s : string);
  682.  
  683.   procedure __setpurge(b: byte);
  684.   procedure __logpurge;
  685.  
  686.   function  __recent(s: string): boolean;
  687.  
  688.  
  689.  
  690. !short   FAST SCREEN functions
  691.  
  692. { XXXXXXXXXXXX FAST SCREEN FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  693.  
  694.  
  695.   function  at(f, b: byte): byte;
  696.   procedure __scn(col, row, attr: byte; st: str80);
  697.   procedure __vid(col, row:       byte; st: str80);
  698.   procedure changeattr(col,row,attr: byte; number: word);
  699.   function  get_video_mode: byte;
  700.  
  701.   { extended functions, just like in eco_vid, but for small use }
  702.   procedure __attrib(x1, y1, x2, y2, f, b: byte);
  703.   procedure __bandwin(del: boolean; x1,y1,x2,y2,f,b,bt: byte);
  704.   procedure __betwscn(x1, x2, y, f, b: byte; st: string);
  705.   procedure __boxscn(x1,y1,x2,y2,boxtype,fore,back : byte);
  706.   procedure __clrscn(x1, y1, x2, y2, f, b: byte; c: char);
  707.   procedure __cls;
  708.   procedure __copyscn(x1, y1, x2, y2, x, y: byte);
  709.  
  710.   function __retdvscn(
  711.     var dvmode    : byte;
  712.     var dvcols    : word;
  713.     var dvrows    : word;
  714.     var dbactpage : byte;
  715.     var dvdispage : byte
  716.   ): byte;
  717.  
  718.   procedure __vert(x, y, f, b: byte; s: string);
  719.   procedure __write(col, row, f, b: byte; st: str80);
  720.  
  721.   procedure __resscn(sc: _scnimageptr);
  722.   procedure __savscn(sc: _scnimageptr);
  723.   function  __barchoice(x,x1,y,f,b,h : byte; st: string): byte;
  724.  
  725.  
  726.  
  727.  
  728. !short   CRT functions
  729.  
  730. { XXXXXXXXXXXX CRT FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  731.   procedure standardio;
  732.  
  733.  
  734.  
  735.  
  736.  
  737. !short   TEXT functions
  738.  
  739. { XXXXXXXXXXXX TEXT FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  740.  
  741. type
  742.   strptr = ^string;
  743.   textnodeptr = ^textnode;
  744.   textnode = record
  745.     next,prev :textnodeptr; {line may not be made longer}
  746.     line :strptr;   {allocation is length+1}
  747.   end;
  748.   textbuffer = record
  749.     first,last :textnodeptr;
  750.   end;
  751.  
  752.   {-
  753.     Note: Don't mess around inside the data structures defined above.
  754.     Use the procedures to access them instead.  This unit should be
  755.     written object orientated.  Some procedures don't use all their
  756.     parameters at the moment.  This is intentional and will be useful
  757.     if the structures are enhanced.
  758.   -}
  759.  
  760.   {- initialise an empty buffer -}
  761.   procedure newbuffer(var t :textbuffer);
  762.   
  763.   {- return true if the buffer is empty -}
  764.   function emptybuffer(var t :textbuffer) :boolean;
  765.   
  766.   {- return a pointer to the first line of a buffer -}
  767.   function firstline(var t :textbuffer) :textnodeptr;
  768.   
  769.   {- return a pointer to the last line of a buffer -}
  770.   function lastline(var t :textbuffer) :textnodeptr;
  771.   
  772.   {- return the next line in a buffer -}
  773.   function nextline(var t :textbuffer;  pos :textnodeptr) :textnodeptr;
  774.   
  775.   {- return the previous line in a buffer -}
  776.   function prevline(var t :textbuffer;  pos :textnodeptr) :textnodeptr;
  777.   
  778.   {- add a line to the end of a buffer -}
  779.   procedure addtoend(var t :textbuffer;  line :string);
  780.   
  781.   {- insert a line before another line -}
  782.   procedure addinsert(var t :textbuffer;  pos :textnodeptr;  line :string);
  783.   
  784.   {- delete a line and return the next line or nil if it was the last line -}
  785.   function deleteline(var t :textbuffer;  var pos :textnodeptr) :textnodeptr;
  786.   
  787.   {- delete a buffer -}
  788.   procedure deletebuffer(var t :textbuffer);
  789.   
  790.   {- retrieve the text value from a line -}
  791.   function gettextline(var t: textbuffer;  pos :textnodeptr) :string;
  792.   
  793.   {- assign a new string to a line of text -}
  794.   procedure modifytextline(var t: textbuffer;  pos :textnodeptr;  line :string);
  795.   
  796.   {- word wrap the buffer -}
  797.   procedure wrapbuffer(var t :textbuffer;  margin :byte);
  798.   
  799.   {- create a new buffer with maximum length (255) lines -}
  800.   procedure unwrapbuffer(var t,w :textbuffer);
  801.   
  802.   {- count the number of lines in a buffer -}
  803.   function bufferlength(var t :textbuffer) :word;
  804.   
  805.   
  806.   
  807.   
  808. !short   CRC FUNCTIONS  
  809.   
  810. { XXXXXXXXXXXX CRC FUNCTIONS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX }
  811.   function __crc32(value: byte; crc: longint) : longint;
  812.   function __crc16(value: byte; crc: word)    :    word;
  813.  
  814.  
  815.  
  816.  
  817.  
  818.  
  819.