home *** CD-ROM | disk | FTP | other *** search
/ Beijing Paradise BBS Backup / PARADISE.ISO / software / BBSDOORW / AAEMA95A.ZIP / EM.H < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-10  |  38.1 KB  |  951 lines
  1. /* This file is EM.H */
  2. #define VERSION "10 Oct 1995"
  3. /* also update the date at start of README & README.1ST */
  4. #include <std.h>
  5. #include <setjmp.h>
  6. #include <string.h>
  7. #include <ctype.h>
  8. #include <new.h>
  9. #include <pc.h>
  10. //#include <sys/farptr.h>
  11. #include <dpmi.h>
  12. #include <time.h>
  13. #include <go32.h>
  14. /*-----*/
  15. #define uns unsigned
  16. #define reg register
  17. typedef uns char byte;
  18. #define strsize 1024 /* must be multiple of 8 */
  19. #define lwand(n) ((n+7)/8) /* wand = bit pattern of which chars are magic */
  20. #define lmagic(n) (((((n)&0x00ffffff)*9+7)>>3)+1) /* length of string+1+wand */
  21. #define magicsize lmagic(strsize)
  22. #define LF 10 /* C '\n' == LF, but PC RET key = CR */
  23. #define CR 13
  24. #define esc 27
  25. /*-----*/
  26. #define SEL _go32_info_block.selector_for_linear_memory
  27. inline void _farpokeb(uns short selector, uns long offset, uns char value) {
  28.   asm("movw %0,%%fs" : : "r" (selector));
  29.   asm(".byte 0x64\n" " movb %0,(%1)" : : "r" ((uns char)value), "r" (offset));}
  30. inline void _farpokew(uns short selector, uns long offset, uns short value) {
  31.   asm("movw %0,%%fs" : : "r" (selector));
  32.   asm(".byte 0x64\n" " movw %0,(%1)" : : "r" (value), "r" (offset));}
  33. inline void _farpokel(uns short selector, uns long offset, uns long value) {
  34.   asm("movw %0,%%fs" : : "r" (selector));
  35.   asm(".byte 0x64\n" " movl %0,(%1)" : : "r" (value), "r" (offset));}
  36. inline uns char _farpeekb(uns short selector, uns long offset) {uns char R;
  37.   asm("movw %0,%%fs" : : "r" (selector));
  38.   asm(".byte 0x64\n" " movb (%1),%0" : "=r" ((int)R) : "r" (offset)); return R;}
  39. inline uns short _farpeekw(uns short selector, uns long offset) {uns short R;
  40.   asm("movw %0,%%fs" : : "r" (selector));
  41.   asm(".byte 0x64\n" " movw (%1),%0" : "=r" (R) : "r" (offset)); return R;}
  42. inline uns long _farpeekl(uns short selector, uns long offset) {uns long R;
  43.   asm("movw %0,%%fs" : : "r" (selector));
  44.   asm(".byte 0x64\n" " movl (%1),%0" : "=r" (R) : "r" (offset)); return R;}
  45. /*-----*//* conventional memory:- */
  46. class c_mem {public: _go32_dpmi_seginfo x;
  47. inline c_mem(int nbytes){x.size=nbytes; _go32_dpmi_allocate_dos_memory(&x);};
  48. inline ~c_mem(){_go32_dpmi_free_dos_memory(&x);};};
  49. /* typedef struct { u_long size, pm_offset;
  50.       u_short pm_selector, rm_offset, rm_segment; } _go32_dpmi_seginfo; */
  51. /*-----*/
  52. class c_byte_addr; class c_short_addr;
  53. /*-----*/
  54. class c_byte {public: uns int addr;
  55. inline c_byte_addr&adr();
  56. inline char val(){return _farpeekb(SEL,addr);};
  57. inline void operator=(char c){_farpokeb(SEL,addr,c);};
  58. inline char(){return _farpeekb(SEL,addr);};};
  59. /*-----*/
  60. class c_byte_addr {public: uns int addr;
  61. inline c_byte_addr(uns int Addr=0){addr=Addr;};
  62. inline c_byte_addr(uns short Seg,uns short Offset){addr=Seg*16+Offset;};
  63. inline c_byte_addr(c_mem m){addr=m.x.rm_segment*16+m.x.rm_offset;};
  64. inline c_byte operator*(){return*(c_byte*)this;};
  65. inline c_byte operator[](int i){c_byte x; x.addr=addr+i; return x;};};
  66. /*-----*/
  67. inline c_byte_addr&c_byte::adr(){return*(c_byte_addr*)this;}
  68. /*-----*/
  69. class c_short {public: uns int addr;
  70. inline short(){return _farpeekw(SEL,addr);};
  71. inline short val(){return _farpeekw(SEL,addr);};
  72. inline c_short_addr&adr();
  73. inline uns short operator=(short c){_farpokew(SEL,addr,c); return c;};
  74. inline void operator+=(int c){*this=(*this).val()+c;};
  75. inline void operator&=(int c){*this=(*this).val()&c;};
  76. inline c_byte Char(){return*(c_byte*)this;}
  77. inline c_byte color(){return *c_byte_addr(addr+1);};};
  78. /*-----*/
  79. class c_short_addr {public: uns int addr;
  80. inline c_short_addr(uns int Addr=0){addr=Addr;};
  81. inline c_short_addr(c_mem m){addr=m.x.rm_segment*16+m.x.rm_offset;};
  82. inline c_short_addr(uns short Seg,uns short Offset){addr=Seg*16+Offset;};
  83. inline c_short_addr operator+(int i){c_short_addr x; x.addr=addr+2*i;return x;};
  84. inline c_short_addr operator-(int i){c_short_addr x; x.addr=addr-2*i;return x;};
  85. inline void operator+=(int i){addr+=2*i;};
  86. inline void operator++(){addr+=2;};
  87. inline c_short push(int i){_farpokew(SEL,addr,i); addr+=2;};
  88. inline void operator=(c_short_addr p){addr=p.addr;};
  89. inline int operator-(c_short_addr x){return (addr-x.addr)/2;};
  90. inline int operator>=(c_short_addr p){return addr>=p.addr;};
  91. inline int operator< (c_short_addr p){return addr< p.addr;};
  92. inline c_short operator*(){return*(c_short*)this;};
  93. inline c_short operator[](int i){c_short x; x.addr=addr+2*i; return x;};};
  94. /*-----*/
  95. extern void newcolor(c_short_addr x,int from,int to,char c);
  96. inline c_short_addr&c_short::adr(){return*(c_short_addr*)this;}
  97. inline void c_put(c_short_addr x,short*y,int n){dosmemput(y,n*2,x.addr);};
  98. inline void c_get(short*y,c_short_addr x,int n){dosmemget(x.addr,n*2,y);};
  99. extern void c_put_color(c_short_addr x,char*y,int n,byte color);
  100. /*-----*/
  101. extern void bitpack(char*s,char*t,int n);
  102. extern void showmoan();
  103. extern volatile void MOAN(char *m);
  104. extern char CW[strsize],disp[256]; extern jmp_buf *bad,rep,Exit;
  105. extern void int10(); extern void int16(); extern void int21();
  106. extern void int33();
  107. /*-----*/
  108. #define namebit(name,member,bit) \
  109.   inline int name(){return (member>>bit)&1;}; \
  110.   inline void name(reg int i){if(i) member|=(1<<bit); else member&=~(1<<bit);};
  111. /*-----*/
  112. class buffer; class line; class mark; class gp_cur; class region; class macro;
  113. class keyarray; class parsing; class val; class colreg; class var; class Mouse;
  114. struct call_;
  115. typedef void subr(val,val,val); typedef val func(int,val*);
  116. class Subr{public: subr*f; short n; char*name; short*args;};
  117. class Func{public: func*f; short n; char*name; short*args;};
  118. /*-----*/
  119. inline int bit(char*s,int i) {return (s[i>>3]>>(7-(i&7)))&1;}
  120. /*-----*/
  121. #define _typeend 3
  122. #define _adinf 3
  123. #define _magic 2
  124. #define _string 1
  125. #define _unbound 0
  126. #define _subr -1
  127. #define _macro -2
  128. #define _char -3
  129. #define _keyarray -4
  130. #define _buffer -5
  131. #define _int -6
  132. #define _keyseq -7
  133. #define _rsvword -8
  134. #define _unidfname -9
  135. #define _call -10
  136. #define _bad -11
  137. #define _Subr -12
  138. #define _func -13
  139. #define _Func -14
  140. #define _ref -15
  141. #define _type -16
  142. #define _float -17
  143. #define _label -18
  144. #define _typebeg -18
  145. /* code numbers of types. n>0 (and n==0 if s!=0) == string of n chars */
  146. extern char**keysort;
  147. /*----- a value and what type it is  */
  148. class val{public: int n; /* n == ditto, or +ve = string of n chars */
  149.   union{keyarray*k; subr*f; macro*m; char*s; buffer*b; int i; struct call_*C;
  150.     Subr*S; func*fn; Func*Fn; var*v; float x;};
  151. /* n      2nd field use
  152. >0        char*s         -> a string of n chars
  153.   0  unbound   char*s         if s==0 or 1, nothing, else empty string
  154.  -1  _subr     subr*f         -> a function void ....(val,val,val)
  155.  -2  _macro    macro*m        -> a macro
  156.  -3  _char     int i          the char i. 256-511 mean 'alt/special key i&255'
  157.  -4  _keyarray keyarray*k     -> an array of val's corresponding to key values
  158.  -5  _buffer   buffer*b  -> a buffer
  159.  -6  _int      int i          the integer i
  160.  -7  _keyseq   char*s         -> a keysequence,kept in chars s[1] to s[s[0]-1]
  161.  -8  _rsvword  int i          the i'th reserved_word
  162.  -9  _unidfname     char*s         -> an unidentified word (terminated by '\000')
  163. -10  _call     struct call_*C -> base & args of a function call
  164. -11  _bad char*s         -> a string describing what was wrong
  165. -12  _Subr     Subr*S         -> an entry in the table of subr names & info
  166. -13  _func     func*fn        -> a function val ....(int,val*)
  167. -14  _Func     Func*Fn        -> an enter in the table of func names & info
  168. -15  _ref var*v          a variable
  169. -16  _type     int i          the name of the type i
  170. -17  _float    float x        the float x
  171. -18  _label       (will only occur in var's)
  172. 0x80000000+n   char*s         -> a magic string of n chars */
  173. inline val(val&K){n=K.n; s=K.s;}; /* works, as all 2nd members are 4 bytes */
  174. inline val(){s=0; n=0;}; /* binding key to each allowed type:- */
  175. inline val(buffer*B){b=B; n=_buffer;}
  176. inline val(float X){x=X; n=_float;};
  177. inline val(char C){i=C; n=_char;};
  178. inline val(byte C){i=C; n=_char;};
  179. inline val(char*S,int t){s=S; n=t;};
  180. inline val(char*t){n=strlen(s=t);};
  181. inline val(int I,int t=_int){i=I; n=t;};
  182. inline val(keyarray&K){k=&K; n=_keyarray;};
  183. inline val(macro*M){m=M; n=_macro;};
  184. inline val(struct call_*I){C=I; n=_call;};
  185. /* inline val(subr*F){f=F; n=_subr;}; */
  186. inline val(Subr*B){S=B; n=_Subr;};
  187. /* inline val(func*F){fn=F; n=_func;}; */
  188. inline val(Func*B){Fn=B; n=_Func;};
  189. inline val(var*V){v=V; n=_ref;};
  190. inline int magic(){return (n&0xff000000)==0x80000000;};
  191. inline int magic(int i){return bit(s+(n&0x00ffffff)+1,i);};
  192. inline int bad(){return n==_bad;};
  193.  
  194. inline void operator=(buffer*B){b=B; n=_buffer;};
  195. inline void operator=(byte C){i=C; n=_char;};
  196. inline void operator=(char C){i=C; n=_char;};
  197. inline void operator=(char*t){n=strlen(s=t);};
  198. inline void operator=(int I){i=I; n=_int;};
  199. inline void operator=(keyarray&K){k=&K; n=_keyarray;};
  200. inline void operator=(macro&M){m=&M; n=_macro;};
  201. inline void operator=(struct call_*I){C=I; n=_call;};
  202. inline void operator=(const val&t){s=t.s; n=t.n;};
  203. inline void operator=(subr*F){f=F; n=_subr;};
  204. inline int operator<<(int j){return n!=_rsvword?0:i==j;};
  205. inline int operator==(byte C){return n!=_char?0:i==C;};
  206. inline int operator==(subr*F){return n!=_subr?0:f==F;};
  207. inline int operator==(val&F){return F.n==n?F.s==s:0;};
  208. inline int notstring(){return n<0?1:n>0?0:!s;}
  209. int operator==(char*t);
  210. inline val operator-(){return val(-i,_int);}; /* only use with _int's */
  211. char*moanifbound(val K,int jump=1);
  212. Subr*Subrinfo(); char*Subrname();
  213. Func*Funcinfo(); char*Funcname();
  214. int charval();
  215. int operator>>(char c); /* char in string? */
  216. int checktype(int type); val convto(int type);
  217. val copy();
  218. val&keyseq();
  219. val&operator[](int N);
  220. void del();
  221. void expandkeyseq(char*K,int plain=0); /* expand char* into names of keys */
  222. val getifn(val&T,char*prompt,int type=0,char*start=0);
  223. val operator()(); /* obey the val */
  224. int type();
  225. int typ();
  226. void print(char*Z=(char*)_buffer,int pr=1000);
  227. void subarray();
  228. void unbind();
  229. int known_now();         };
  230. /*-----*/
  231. inline val kf(subr*F){val f; f.f =F; f.n=_subr; return f;};
  232. inline val ff(func*F){val f; f.fn=F; f.n=_func; return f;};
  233. extern char*copyof(char*s,int n=0);
  234. extern char*copyof(const val&s);
  235. extern char*chname(int c);
  236. extern char*keyname(int c,int alt=0);
  237. extern void Obey(val N=val(1,0));
  238. extern int yesno(char*pt); extern int Yesno(char*s);
  239. /*----- standard header for key-functions */
  240. #define KF(name) void name(val N/*=val(1,0)*/,val T1/*=val()*/,val T2/*=val()*/)
  241. #define Kf(name) extern void name(val N=val(1,0),val T1=val(),val T2=val())
  242. /* if N.n!=0, N.i==repeat count, usually */
  243. #define FN(name) val name(int n,val*arg)
  244. #define fN(name) extern FN(name)
  245. /*----- a detached chain of lines */
  246. class Text{public: line *beg,*end;
  247. inline Text(){beg=end=0;};
  248. inline Text(line*b,line*e){beg=b; end=e;}
  249. inline Text(Text&T){beg=T.beg; end=T.end;};
  250. inline operator=(const Text&T){beg=T.beg; end=T.end;};
  251. val asstring();
  252. Text(val&); void read(char*file); Text copy(); void clear(); /*void print();*/};
  253. /*-----*/
  254. extern Text killring[]; extern short nkill;
  255. /*----- row and column on screen */
  256. class gp_cur{public: byte c,r;
  257.   inline gp_cur(byte R=0, byte C=0){c=C; r=R;};
  258.   inline gp_cur(gp_cur &d){c=d.c; r=d.r;};
  259.   inline void operator=(gp_cur&d){c=d.c; r=d.r;};};
  260. /*-----*/
  261. extern gp_cur cursor; /* the cursor */
  262. extern char *Moan,*Display;
  263. /*----- a position in buffer by line & char */
  264. class mark {public: mark *next,*prev; line *r; int c;
  265. inline mark(line*R=0,int C=0){r=R; c=C;};
  266. inline mark(const mark&m){r=m.r; c=m.c;};
  267. inline void operator=(const mark&m){r=m.r; c=m.c;};
  268. byte operator*(); /* char at mark */
  269. /* move mark 1 char *//* if runs off file, leaves this->r==0 :- */
  270. void operator++(); void operator--();
  271. void operator=(char);
  272. void operator+=(char); void operator+=(char*); void operator+=(buffer*);
  273. line* operator/(int);
  274. void operator!();
  275. void bs();
  276. operator char*();
  277. region yank(const Text&K,int copy=1);
  278. void operator>>=(int n);
  279. void operator<<=(int n);
  280. int Up(); int Down(); int Left(); int Right();
  281. int is_white(); int is_alpha(); int is_alnum();
  282. void find_white(int back=0); void skip_white(int back=0,int Eol=0);
  283. void skip_alpha(int back=0); void find_alpha(int back=0,int Eol=0);
  284. void skip_alnum(int back=0); void find_alnum(int back=0,int Eol=0);
  285. int eol(); int eof(); void Skip();
  286. void skipword(int); int isin(region &R);
  287. int operator<(mark&N);   /* are marks in that order? */
  288. inline int operator==(const mark&N){if(r==N.r) if(c==N.c) return 1; return 0;};
  289. inline int operator!=(const mark&N){if(r==N.r) if(c==N.c) return 0; return 1;};
  290. //friend region operator-=(const mark&M,const mark&N);
  291. //friend region operator-(const mark&M,const mark&N);
  292. inline friend void operator^(mark&M,mark&N){M.next=&N; N.prev=&M;};
  293. void push(); void hsup(); void pop();
  294. void skipsentence(int); void skippara(int);
  295. int thisch(char C); int string(val s); /* parsing:- */
  296. val elem(); /* P.elem() : look for an element, move P over text parsed */
  297. val name(); val label(); val number(); val string(); val expr(int prio=0);
  298. val monexpr_upto(int); val Call(); val decl();
  299. char*op(int);};
  300. extern int heremagic(mark A,val T);
  301. extern int here(mark A,val T,int w=0);
  302. /*----- two marks */
  303. class region{public: mark beg,end;
  304. inline region(){beg=mark(0,0); end=mark(0,0);};
  305. inline region(const mark &B,const mark &E){beg=B; end=E;};
  306. inline void operator=(const region&R){beg=R.beg; end=R.end;};
  307. mark Delete(int query=1); mark kill(int query=1); void copykill();
  308. void format();
  309. int huntf(val T,int word=0); int huntb(val T,int word=0);
  310. inline int hunt(val T,int back=0,int w=0){return back?huntb(T,w):huntf(T,w);};
  311. void replace(val Old,val New,int ask=0,int word=0);
  312. region moveto(mark &M); region copyto(mark &M); region repl(Text&k,int copy=1);
  313. void right_order(); void color(int f,int b); void Case(int);
  314. int ok_to_delete(); void expandtabs(); void maketabs(); };
  315. /*----- M-=N == the region defined by the marks M & N */
  316. inline region operator-=(const mark&M,const mark&N){return region(M,N);}
  317. /*----- ditto, make sure that M <= N */
  318. inline region operator-(const mark&M,const mark&N){
  319. region R(M,N); R.right_order(); return R;}
  320. /*----- a line in a buffer */
  321. class line {public:
  322.     line *next; /* -> the next line */
  323.     line *prev; /* -> the previous line */
  324.     int n; /* chars in line */
  325.     char *s; /* the line, physically has (n+15)&~15 bytes */
  326.     char info;
  327.     short sl; /* current screen line number (line_notshown == not on screen) */
  328. namebit(la,info,0); /* if line altered since last displayed */
  329. namebit(no_cr,info,1) /* if no CR before LF at end of this line */
  330. #define line_notshown 0x4000
  331. inline void nullline(){next=prev=0; s=0; n=0; info=0; la(1); sl=line_notshown;};
  332. inline line(){nullline();}; /* empty line */
  333. line(char*s); line(char*s,int n); line(line*L); ~line();
  334. void operator-(); /* remove previous eol */
  335. void operator--(); /* remove next eol */
  336. void operator-(Text&); /* remove next eol, in a Text */
  337. void display(int i); int dispfold(int i); int nparts(int c=-1); int showeol();
  338. friend inline void operator-(reg line &A,reg line &B){A.next=&B; B.prev=&A;};
  339.   /* link lines A and B */
  340. friend line* operator/ (line &L,val t); /* insert line after line L */
  341. friend line* operator/ (val t,line &L); /* insert line before line L */
  342. void operator= (val t);  /* replace text of line */
  343. void operator+=(char c); /* append char to line */
  344. void operator+=(line &M); /* append text of M to line */
  345. void operator= (int n);  /* change line.n */
  346. void operator+=(int n); void operator-=(int n);   /* ditto */
  347. char operator[](int n);  /* nth char in line */
  348. void empty();  /* delete all text in line */
  349. int to_tabexp(int,int=0); int from_tabexp(int,int=0);
  350. int to_scrcolno(int); /* char # to screen col # */
  351. int from_scrcolno(int); /* screen col # to char # */
  352. int blank(); /* if line is blank */
  353. void dotty();  /* check dot.c */
  354. void split_if_long(); void de_trailing_space();
  355. int is_bop(); int is_eop(); int lineno(); void del(); };
  356. /*-----*/
  357. extern line*dustbin; extern void emptydustbin();
  358. extern line *line0,*modeline; /* dummy lines */
  359. inline byte mark::operator*(){return c>=r->n?LF:r->s[c];} /* char at mark */
  360. inline int mark::eol(){return c>=r->n;}
  361. inline int mark::eof(){return r->next?0:c>=r->n;}
  362. inline void mark::operator++(){if(++c>r->n) {c=0; r=r->next;}}
  363. inline void mark::operator--(){if(--c<0) c=(r=r->prev)?r->n:0;}
  364. /*-----*/
  365. class screenline{public:line *l,*nl; int lp,nlp,np,lc,ok,nc; c_short_addr sa;
  366.   buffer*buf;};
  367. /*-----*/
  368. extern screenline Sl[];
  369. /*----- text to be displayed colored */
  370. class colreg {public: int fg,bg; region Reg;
  371. inline init() {fg=bg=0; Reg.beg=mark(0,0); Reg.end=mark(0,0);};
  372. inline colreg() {init();};};
  373. /*** I must keep track of these marks on any text changes */
  374. /*-----*/
  375. class buffer {public:
  376.     buffer *next;   /* next buffer */
  377.     mark start; /* -> top left char on screen */
  378.     int startc; /* backup for start.c */
  379.     int stback;     /* if fold long lines, where in start.r to start */
  380.     mark dot;  /* cursor */   /* start of chain of marks */
  381.     mark olddot;     /* where dot was at start of current mouse operations */
  382.     mark dot1,dot2; /* where dot was before last command */
  383.     byte row1; /* first row of screen used by buffer */
  384.     byte lastrow;   /* last row of screen used by buffer */
  385.     byte nrows;     /* # of rows of text on screen incl. info line */
  386.     byte ncols;     /* # of cols of text on screen */
  387.     int dotcc,dotcc2;  /* screen col # of dot */
  388.     line text; /* completes circle of lines */
  389.     byte truncated,invisible,readonly,changed,oldch,refresh; /* flags */
  390.     byte overlay,tabtype,twod,wrap,Case,longlines,skip_after_word; /* modes */
  391. #define buffer_nmodes 7
  392.     int rmargin,sortcol;
  393.     char *name;     /* file name */ val bound;
  394.     colreg col;
  395. void initbuffer(); inline buffer(){initbuffer();};
  396. buffer(char*F,int rd=1); /* new buffer opened on file F */
  397. ~buffer();
  398. line* operator[](int);   /* ith line in buffer */
  399. void deltext(); buffer*linkin();
  400. void read(); void write(); void clearscreen();
  401. void go_to(); void operator()(int N=0);
  402. inline mark bof(){return mark(text.next,0);};
  403. inline mark eof(){return mark(text.prev,text.prev->n);};
  404. int nmarks(); mark&Mark(int); void display(); void dispfold(int d=0);
  405. void rem1mark(); void up(); void down(); void left(); void right();
  406. void split_window_with(int N);
  407. inline void operator+=(char c){dot+=c;}; /* insert at dot */
  408. inline void operator+=(char*s){dot+=s;}; /* insert at dot */
  409. void redraw_info(); int exists(); void bind(val*f,val T1);  };
  410. /*-----*/
  411. extern buffer *buf0, *bhead, *B; extern int bcount; /* B -> current buffer */
  412. extern line *T;     /* entry point of circle of lines currently being handled */
  413. /*-----*/
  414. #define forallbufs(b) for(b=bhead;b;b=b->next)
  415. #define forallmarks(M) for(M=&B->start;M;M=M->next)
  416. /* buffer has extra final empty line unless last char in file is not LF */
  417. /*-----*/
  418. extern char DIR[];
  419. #define HELPFILE "HELP"
  420. #define BIGHELPFILE "HELP.BIG"
  421. #define DICTFILE "DICT"
  422. extern char helpfile[],bighelpfile[],**infohelp,**infobig;
  423. extern char**Subrhelp(char*name);
  424. /*-----*/
  425. extern char T1w[],T2w[],Filename[]; extern val T1t,T2t,Fn,specialchars;
  426. extern int needswrap;
  427. #define ob_kill 1
  428. #define ob_yank 2
  429. #define ob_other 3
  430. extern int obtype,prevobtype; extern region lastyank;
  431. extern buffer*window[]; extern int nwindows,currentwindow;
  432. extern long _ax,_bx,_cx,_dx,_si,_di,_bp,_es; extern short _flags;
  433. #define _carry (_flags&1)
  434. #define _zeroflag (_flags&0x40)
  435. /*-----*/
  436. #define __SR() /* save the registers */         ({asm("xchgl %eax,__ax"); \
  437.     asm("xchgl %ebx,__bx"); asm("xchgl %ecx,__cx"); asm("xchgl %edx,__dx"); \
  438.     asm("xchgl %esi,__si"); asm("xchgl %edi,__di"); asm("xchgl %ebp,__bp"); })
  439. #define __RR() /* restore the registers */      ({ \
  440.     asm("pushf"); asm("popw __flags"); __SR();})
  441. /*-----*/
  442. #define interrupt(x) asm( \
  443. "xchgl %eax,__ax; xchgl %ebx,__bx; xchgl %ecx,__cx;" \
  444. "xchgl %edx,__dx; xchgl %esi,__si; xchgl %edi,__di; xchgl %ebp,__bp\n" \
  445. "int $0x"#x"; pushf; popw __flags\n" \
  446. "xchgl %eax,__ax; xchgl %ebx,__bx; xchgl %ecx,__cx;" \
  447. "xchgl %edx,__dx; xchgl %esi,__si; xchgl %edi,__di; xchgl %ebp,__bp")
  448. /*-----*/
  449. #define Black 0
  450. #define Blue 1
  451. #define Green 2
  452. #define Cyan 3
  453. #define Red 4
  454. #define Magenta 5
  455. #define Orange 6
  456. #define White 7
  457. /*-----*/
  458. extern byte gp_Mode,gp_Rows,gp_Cols;
  459. extern short gp_Attr,gp_Attr_def; /* on black */
  460. inline uns short sch(byte C,byte A){return C|(A<<8);}
  461. /* #define screen ((uns short*)ScreenPrimary) */
  462. extern c_short_addr screen; /*********/
  463. #define scr(row,col) (screen[(col)+(row)*gp_Cols])
  464. extern int getkey();
  465. extern int get_key(); extern int nextch;
  466. extern byte get__key();
  467. extern int getkey_nowait();
  468. extern int typahead();
  469. extern int inject(int ch);
  470. extern void printch(char c);
  471. extern int beep();
  472. extern int gp_mode(void);
  473. extern void gp_mode(char m);
  474. extern void gp_cursor(gp_cur c);
  475. inline void gp_cursor(int r,int c) {gp_cursor(gp_cur(r,c));}
  476. extern gp_cur gp_cursor(void);
  477. extern void gp_clear(int i=0,int j=0,int J=gp_Cols-1);
  478. /*-----*/
  479. /* the attribute of a displayed character: bc,fc = back- & foreground colors */
  480. /* fc add 8 for bright; */
  481. inline short Attrib(int fc,int bc=Black,int flash=0) {
  482.     return ((fc&15)<<0)|((bc&7)<<4)|((flash&1)<<7);}
  483. /* typedef struct {int fc:3, bright:1, bc:3, blink:1; } gp_Attrib; */
  484. /*-----*/
  485. /*** special keys. Some of these may be different on different PC's ****/
  486. #define alt_0 129
  487. #define alt_1 120
  488. #define alt_2 121
  489. #define alt_3 122
  490. #define alt_4 123
  491. #define alt_5 124
  492. #define alt_6 125
  493. #define alt_7 126
  494. #define alt_8 127
  495. #define alt_9 128
  496. #define alt_A 30
  497. #define alt_B 48
  498. #define alt_C 46
  499. #define alt_D 32
  500. #define alt_E 18
  501. #define alt_F 33
  502. #define alt_G 34
  503. #define alt_H 35
  504. #define alt_I 23
  505. #define alt_J 36
  506. #define alt_K 37
  507. #define alt_L 38
  508. #define alt_M 50
  509. #define alt_N 49
  510. #define alt_O 24
  511. #define alt_P 25
  512. #define alt_Q 16
  513. #define alt_R 19
  514. #define alt_S 31
  515. #define alt_T 20
  516. #define alt_U 22
  517. #define alt_V 47
  518. #define alt_W 17
  519. #define alt_X 45
  520. #define alt_Y 21
  521. #define alt_Z 44
  522. #define alt_apostr 40
  523. #define alt_bksp 14
  524. #define alt_comma 51
  525. #define alt_del 163
  526. #define alt_downarrow 160
  527. #define alt_end 159
  528. #define alt_equals 131
  529. #define alt_esc 1
  530. #define alt_f10 113
  531. #define alt_f11 139
  532. #define alt_f12 140
  533. #define alt_f1 104
  534. #define alt_f2 105
  535. #define alt_f3 106
  536. #define alt_f4 107
  537. #define alt_f5 108
  538. #define alt_f6 109
  539. #define alt_f7 110
  540. #define alt_f8 111
  541. #define alt_f9 112
  542. #define alt_fullstop 5
  543. #define alt_grave 41
  544. #define alt_home 151
  545. #define alt_insert 162
  546. #define alt_leftarrow 155
  547. #define alt_leftsq 26
  548. #define alt_minus 130
  549. #define alt_padminus 74
  550. #define alt_padplus 78
  551. #define alt_padslash 164
  552. #define alt_padstar 55
  553. #define alt_pagedown 161
  554. #define alt_pageup 153
  555. #define alt_ret 28
  556. #define alt_rightarrow 157
  557. #define alt_rightsq 27
  558. #define alt_semicolon 39
  559. #define alt_sharp 43
  560. #define alt_slash 53
  561. #define alt_tab 165
  562. #define alt_uparrow 152
  563. #define ctrl_2 3
  564. #define ctrl_del 147
  565. #define ctrl_downarrow 145
  566. #define ctrl_end 117
  567. #define ctrl_f10 103
  568. #define ctrl_f11 137
  569. #define ctrl_f12 138
  570. #define ctrl_f1 94
  571. #define ctrl_f2 95
  572. #define ctrl_f3 96
  573. #define ctrl_f4 97
  574. #define ctrl_f5 98
  575. #define ctrl_f6 99
  576. #define ctrl_f7 100
  577. #define ctrl_f8 101
  578. #define ctrl_f9 102
  579. #define ctrl_home 119
  580. #define ctrl_insert 146
  581. #define ctrl_leftarrow 115
  582. #define ctrl_pad5 143
  583. #define ctrl_padminus 142
  584. #define ctrl_padplus 144
  585. #define ctrl_padslash 149
  586. #define ctrl_padstar 150
  587. #define ctrl_pagedown 118
  588. #define ctrl_pageup 132
  589. #define ctrl_rightarrow 116
  590. #define ctrl_tab 148
  591. #define ctrl_uparrow 141
  592. #define del_ 83
  593. #define downarrow 80
  594. #define end_ 79
  595. #define f10 68
  596. #define f11 133
  597. #define f12 134
  598. #define f1 59
  599. #define f2 60
  600. #define f3 61
  601. #define f4 62
  602. #define f5 63
  603. #define f6 64
  604. #define f7 65
  605. #define f8 66
  606. #define f9 67
  607. #define home 71
  608. #define ins 82
  609. #define leftarrow 75
  610. #define pad5 76
  611. #define pagedown 81
  612. #define pageup 73
  613. #define rightarrow 77
  614. #define sh_f10 93
  615. #define sh_f11 135
  616. #define sh_f12 136
  617. #define sh_f1 84
  618. #define sh_f2 85
  619. #define sh_f3 86
  620. #define sh_f4 87
  621. #define sh_f5 88
  622. #define sh_f6 89
  623. #define sh_f7 90
  624. #define sh_f8 91
  625. #define sh_f9 92
  626. #define sh_tab 15
  627. #define uparrow 72
  628. #define clickboth 248
  629. #define lbutton 255
  630. #define mbutton 254
  631. #define rbutton 253
  632. #define lbuttond 252
  633. #define mbuttond 251
  634. #define rbuttond 250
  635. #define mousemove 249
  636. /*-----*/
  637. extern char *altnames[256],*altshortnames[256]; extern val keynames[];
  638. extern char* fullfilename(char*full,char*name);
  639. /*-----*/
  640. inline int bytes(char*s){return *(int*)s;}
  641. /*----- to next multiple of 16 */
  642. inline uns int roundup(uns int i) {return ((i)+15)&((uns int)0xfffffff0);}
  643. /*-----*/
  644. /* {
  645. 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0e,0x0f,
  646. 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1e,0x1f,
  647. 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2e,0x2f,
  648. 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3e,0x3f,
  649. 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4e,0x4f,
  650. 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5e,0x5f,
  651. 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6e,0x6f,
  652. 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x7b,0x7c,0x7e,0x7f,
  653. 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8e,0x8f,
  654. 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9e,0x9f,
  655. 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xae,0xaf,
  656. 0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,0xbe,0xbf,
  657. 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xce,0xcf,
  658. 0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xde,0xdf,
  659. 0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xeb,0xec,0xee,0xef,
  660. 0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfe,0xff}; */
  661. /*----- compare n chars from t to s */
  662. int comptext(reg char*s,reg char*t,int n,int nocase=0);
  663. /*-----*/
  664. #define add_to_list(head,item) ((item)->next=(head), (head)=(item))
  665. #define remove_from_list(head,item) ({typeof(item) *I; \
  666.     for(I=&(head);*I;I=&((*I)->next)) if(*I==(item)) {*I=(*I)->next; break;}})
  667. /*-----*/
  668. /*** make fault remarks without mallocking, in case fault was 'out of store' */
  669. /*----- change color of jth char of ith screen line */
  670. extern void recolor(int i,int j,int col);
  671. /*----- display string s on screen line n (displayn = do not clear to eol) */
  672. extern int displayn(val  T,int n,int c,int fc=White,int bc=Black);
  673. extern int displayn(char*s,int n,int c,int fc=White,int bc=Black);
  674. extern void display(val  T,int n,int c,int fc=White,int bc=Black);
  675. extern void display(char*s,int n,int c,int fc=White,int bc=Black);
  676. extern void clearscreen();
  677. extern void getstring(char*pt,int Sl,val &T,int max,int type=0);
  678. /*-----*/
  679. extern char chwidth[256];
  680. extern byte to__upper[256],to__lower[256]; extern char chtype[256];
  681. #define c_alpha 1
  682. #define c_alnum 2
  683. #define c_white 4
  684. /*-----*/
  685. #define to_upper(c) to__upper[(byte)(c)]
  686. #define to_lower(c) to__lower[(byte)(c)]
  687. /*----- x==y ignoring case? */
  688. #define cheq(x,y,Case) (Case?((x)==(y)):to_upper(x)==to_upper(y))
  689. #undef iswhite
  690. #undef isalpha
  691. #undef isalnum
  692. #define iswhite(c) (chtype[(byte)(c)]&c_white)
  693. #define isalpha(c) (chtype[(byte)(c)]&c_alpha)
  694. #define isalnum(c) (chtype[(byte)(c)]&c_alnum)
  695. inline int mark::is_white(){return iswhite(c>=r->n?LF:r->s[c]);}
  696. inline int mark::is_alpha(){return isalpha(c>=r->n?LF:r->s[c]);}
  697. inline int mark::is_alnum(){return isalnum(c>=r->n?LF:r->s[c]);}
  698. /*-----*/
  699. extern region Found;
  700. /*-----*/
  701. typedef struct call_{char n,pr,*name; int type; val arg[1];} call;
  702. extern call*call_n(int n,int type,int pr,char*name,val*a);
  703. /*----- array of n key bindings to look up in */
  704. class keyarray {public:val*a; long n;   void subarray();
  705. inline keyarray(){a=0; n=0;}; val&operator[](int i);
  706. void search(void(*fn)(val&k));
  707. void print(int N=1,int i=1,int deep=1);      };
  708. /*-----*/
  709. extern val key0; extern keyarray keys; /* head of lookup tree of key bindings */
  710. /*----- one statement in a macro. Contains keybinding and numeric arg */
  711. class macstep{public: macstep *next; val f,N,T1,T2; /* like a call of a subr */
  712. inline macstep(val k=val(),val n=val(1,0),val t1=val(),val t2=val()){
  713.     f=k; N=n; next=0; T1=t1; T2=t2; next=0;};
  714. inline void operator=(macstep &m){f=m.f; N=m.N; T1=m.T1; T2=m.T2;}
  715. inline        macstep(macstep &m){f=m.f; N=m.N; T1=m.T1; T2=m.T2;}
  716. void operator()(int n=1); /* obey */
  717. void print(); /* print macstep into buffer text */
  718. void del(); macstep*copy();
  719. inline void clear(){f.n=T1.n=T2.n=0; N=val(1,0); f.s=T1.s=T2.s=0;};
  720. inline ~macstep(){del();}     };
  721. extern macstep laststep,thisstep;
  722. inline macstep*macstep::copy(){return new macstep(f,N,T1.copy(),T2.copy());};
  723. #define setrec(x,y) ({if(!play) thisstep.x=(y);})
  724. #define setrek(x,y) ({if(!play) thisstep.x=val(y);})
  725. #define setref(x,y) ({if(!play) thisstep.x=kf(y);})
  726. /*-----*/ /* offset+=0x80000000 if global */
  727. class var{public: var*next; char*name; long int type,offset;
  728. inline var(char*Name,int Type,int Offset,var*Next=0){
  729.     name=copyof(Name); type=Type; offset=Offset; next=Next;};
  730. inline ~var(){delete name; if(next) delete next;};};
  731. extern var*globvars; extern int nglobvars;
  732. void prvars(var*v);
  733. /*----- macro header */
  734. extern macro *record,*Macro,*macros;
  735. class macro{public: macstep *last,*text; val bound; macro*next; char*name;
  736. int nvars; var*vars;
  737. inline val&f(){return *(val*)&last;};
  738. inline macro(){last=text=0; bound=val(); next=macros; macros=this; name=0;
  739.     nvars=0; vars=0;};
  740. void operator+=(macstep*m);   /* append step to macro */
  741. void operator()(val N=val(1,0),int r=0); /* obey, arg=N, r = recursion depth */
  742. void print();  /* print macro on buffer text */
  743. void tidy();   /* e.g. chain up successive insert-a-character's */
  744. void empty(); ~macro();  };
  745. extern int macdepth; extern char*CMN; extern macstep _lazy;
  746. /*-----*/
  747. class strings{public: char*s; strings*next;
  748. inline strings(char*t,strings*n){s=t; next=n;};};
  749. /*-----*/
  750. class macrinfo{
  751. public: macstep*prevstep; val*stack; int nvars; byte rec; strings*delenda;
  752. inline macrinfo(){prevstep=&_lazy; rec=1; stack=0; nvars=0; delenda=0;};
  753. inline val&operator[](int i){return stack[(i>?0)<?(nvars-1)];};
  754. inline ~macrinfo(){delete stack;};};
  755. extern macrinfo basemi,*mi;
  756. #define play (mi!=&basemi)
  757. /*-----*/
  758. inline byte keysdown(){_ax=0x0200; int16(); return _ax&255;}
  759. /* these 4 pressed:- */
  760. #define k_rshift 1
  761. #define k_lshift 2
  762. #define k_ctrl 4
  763. #define k_alt 8
  764. /* these 4 toggle:- */
  765. #define k_scrlock 16
  766. #define k_numlock 32
  767. #define k_capslock 64
  768. #define k_insert 128
  769. #define k_break 14 /* alt & ctrl & leftshift*/
  770. extern int loseip();
  771. inline int Breakin(){_ax=0x0200; int16(); return (_ax&14)==14?loseip():0;}
  772. /*-----*/
  773. extern subr*keep[]; extern char keyseqc[];
  774. extern val keyseq; /* work space */
  775. extern char rec; /* whether to record this step */
  776. /*-----*/
  777. extern void Insert(int N,byte c);
  778. extern void Replace(int N,int D,val T1,val T2,char *pt,int ask,int word);
  779. extern void search(int N,int D,val T1,char*prompt,int back=0,int word=0);
  780. extern void incrsearch(int N,int D,char*pt,int back=0);
  781. extern void readescno(short c);
  782. extern void readaltno(short c);
  783. extern byte &bufmode(int i,buffer*BB=0);
  784. /*-----*/
  785. extern char**dispmode[];
  786. extern void(*cf[])(int,byte);
  787. extern subr*cff[];
  788. /*-----*/
  789. extern void insert_(int N,byte c);
  790. extern void overlay_(int N,byte c);
  791. extern void nomove_(int N,byte c);
  792. extern void forallkeys(void Subr(val*),int L=1,keyarray&K=keys);
  793. extern void moan_if_no_help(val*f);
  794. extern void prbuffer(buffer*C);
  795. extern void print_subr(val*f);
  796. extern Subr*namedsubr(val name);
  797. extern val*getk(val arg,char*prompt=0);
  798. /*-----*/
  799. extern void translate(buffer*BB);
  800. extern buffer*buf_named(val name);
  801. extern int findbuf_new(val&name,int read=1);
  802. extern buffer*findbuf(val name);
  803. extern region thisword(int N=1);
  804. extern region thispara();
  805. extern void casechange(int N,line*L,int b,int e);
  806. /*-----*/
  807. extern val eosentchars; extern byte ccc; extern char rept;
  808. extern Subr subrname[]; extern Func funcname[];
  809. /*-----*/
  810. Kf(_idle); Kf(accentedletters); Kf(alt0); Kf(alt1); Kf(alt2); Kf(alt3);
  811. Kf(alt4); Kf(alt5); Kf(alt6); Kf(alt7); Kf(alt8); Kf(alt9); Kf(altminus);
  812. Kf(backspace); Kf(beginmacro); Kf(bindkeybuf); Kf(bindkeymacro);
  813. Kf(bindkeysubr); Kf(buffer_); Kf(buffermenu); Kf(calldos); Kf(callsubr);
  814. Kf(capitalize); Kf(casemode); Kf(cbrackets); Kf(cccmode); Kf(cchrstr);
  815. Kf(char_from_menu); Kf(checkhelp); Kf(checkspelling); Kf(copybufmodes);
  816. Kf(copydir); Kf(copykill); Kf(copytext); Kf(cstrchr); Kf(delblanklines);
  817. Kf(delbuf); Kf(delet); Kf(deletewhite); Kf(dis_play); Kf(displayhex);
  818. Kf(emptyappendix); Kf(endmacro); Kf(esc0); Kf(esc1); Kf(esc2); Kf(esc3);
  819. Kf(esc4); Kf(esc5); Kf(esc6); Kf(esc7); Kf(esc8); Kf(esc9); Kf(escminus);
  820. Kf(expandtabs); Kf(finalcr); Kf(findb); Kf(findf); Kf(findwordb); Kf(findwordf);
  821. Kf(finish); Kf(formatinsetregion); Kf(formatpara); Kf(formatregion);
  822. Kf(getappendix); Kf(godown); Kf(godownpart); Kf(goleft); Kf(goright);
  823. Kf(gotobof); Kf(gotobol); Kf(gotocol); Kf(gotodir); Kf(gotoeof); Kf(gotoeol);
  824. Kf(gotoline); Kf(gotonbuf); Kf(goup); Kf(gouppart); Kf(go_to); Kf(help); Kf(If);
  825. Kf(incrfindb); Kf(incrfindf); Kf(insert); Kf(insertfile); Kf(insertspaces);
  826. Kf(kill_to_eol); Kf(killregion); Kf(killsent); Kf(killwordb); Kf(killwordf);
  827. Kf(leaveonewhite); Kf(linefeed); Kf(literalchar); Kf(longlinesmode);
  828. Kf(lwcaseregion); Kf(lwcasewords); Kf(macromenu); Kf(maketabs); Kf(markbof);
  829. Kf(markeof); Kf(menu); Kf(menu2); Kf(mergefile); Kf(modemenu); Kf(mouse_mode);
  830. Kf(mouse_move); Kf(movetext); Kf(namemacro); Kf(newline); Kf(nextwindow);
  831. Kf(nofinalcr); Kf(nomove); Kf(obey); Kf(onewindow); Kf(openfile); Kf(openline);
  832. Kf(overlay); Kf(overlaymode); Kf(page_down); Kf(page_up); Kf(popmark);
  833. Kf(prbindings); Kf(prbuffers); Kf(prevwindow); Kf(prkeynames); Kf(prkeys);
  834. Kf(prmacro); Kf(prmacros); Kf(prsubrnames); Kf(pushmark); Kf(putappendix);
  835. Kf(readmacros); Kf(refresh_display); Kf(remmark); Kf(renamebuffer); Kf(repeat);
  836. Kf(repl); Kf(replask); Kf(replword); Kf(replwordask); Kf(replyank);
  837. Kf(restorebuf); Kf(savebuffer); Kf(setmark); Kf(setolddot); Kf(setrightmargin);
  838. Kf(setsortcol); Kf(showinfo); Kf(showregion); Kf(skipafterwordmode);
  839. Kf(skipparab); Kf(skipparaf); Kf(skipsentb); Kf(skipsentf); Kf(skipwordb);
  840. Kf(skipwordf); Kf(sortlines); Kf(splitwindow); Kf(swopmark); Kf(tabmode);
  841. Kf(tabulate); Kf(times4); Kf(twiddle); Kf(twiddlelines); Kf(twiddlewords);
  842. Kf(twodmode); Kf(unbindkey); Kf(upcaseregion); Kf(upcasewords); Kf(version);
  843. Kf(whoa); Kf(wrapmode); Kf(writebuffer); Kf(yank);
  844. /*-----*/
  845. fN(_allocate); fN(_andthen); fN(_divide); fN(_minus); fN(_neg); fN(_plus);
  846. fN(_eq); fN(_ne); fN(_ge); fN(_le); fN(_gt); fN(_lt);
  847. fN(_same); fN(_times); fN(currentbuffer); fN(keyseq_); fN(_yesno); fN(lastkill);
  848. /*-----*/
  849. extern void start_an_arg();
  850. extern val&getkeyseq(val P);
  851. inline val&getkeyseq(char*P) {return getkeyseq(val(P,strlen(P)));}
  852. /*-----*/
  853. extern byte esc_alt[26];
  854. extern char*getstringhelp[],*rsvword[],**info;
  855. extern Subr*calledsubr;
  856. /*-----*/
  857. extern void out_of_store();
  858. extern void showmoan();
  859. extern int fileexists(char*);
  860. extern Subr*subrmenu(char*s=0,int fromKF=0);
  861. extern byte drive();
  862. extern void getcurrentdir(char c,char*s);
  863. extern void refreshscreen();
  864. extern buffer*buffer_menu(char*prompt);
  865. extern void filefromdirmenu(val&Dir,char*prompt,char*at=0);
  866. extern int attrib(char*file);
  867. extern buffer*get_file(val&T,char*prompt);
  868. extern unsigned long filesize(char*name);
  869. extern void bitpack(char*s,char*t,int n);
  870. extern void bitexp(char*s,char*t,int n);
  871. extern void bitcopy(char*s,char*t,int n);
  872. extern int charfrommenu();
  873. extern void del_every(val f,keyarray&ka);
  874. extern void del_every(val f,val&m);
  875. extern void del_every(val f,macstep*M);
  876. extern void del_every(val f);
  877. extern void wr(char*s);
  878. extern int display_op_uses();
  879. /*-----*/
  880. #define totab(i) (((i)|7)+1) /* next tab position after i */
  881. #define sptotab(i) (7-((i)&7))
  882.     /* how many spaces (not inclusive) from i to next tab position after i */
  883. /*-----*/
  884. extern char*pr(char*B,char*F0,...);
  885. extern char*pa(char*B,char*F0,...);
  886. extern void pf(int f,char*F0,...);
  887. extern void pb(char*F0,...);
  888. extern void ps(char*F0,...);
  889. extern void p_r(char*S,char*F0,...);
  890. extern char*pr_(char*S,char*F0,int*args);
  891. extern char**readtext(char*file);
  892. extern val named(val name);
  893. extern int byteq(char*a,char*b,int n);
  894. extern int check_spelling(char*ws,int wl);
  895. extern int&appendixsize;
  896. extern char*dictname;
  897. extern short*screendump();
  898. extern void screenrestore(short*s);
  899. extern int deletebuffer(buffer*C);
  900. extern void*myalloc(int i);
  901. extern void counterchange(c_short x);
  902. extern int linewhere(mark M);
  903. extern macro*macro_menu();
  904. extern int bottommenu(
  905.   char*prompt,int nrb,char*codes,char**names,int L=8,int defolt=0);
  906. /*-----*//* MOUSE */
  907. #define Regs _go32_dpmi_registers
  908. extern void event(Regs*R);
  909. extern int int86dpmi(int intno);
  910. extern Regs R;
  911. #define Int int86dpmi
  912. /*-----*/
  913. class mousestate {public: int x,y,xe,ye; char visible,mc,bd;
  914.     inline mousestate(){};
  915.     void operator=(Mouse&);};
  916. /*-----*/
  917. class Mouse {public: int x,y,xe,ye,ldx,ldy,mdx,mdy,rdx,rdy;
  918. char nbuttons,buttons,visible,handlerInstalled,mc,bd;
  919. void show();
  920. void hide();
  921. void read();
  922. void move(int Y,int X);
  923. inline Mouse(){};
  924. void setup();
  925. void operator=(mousestate&);
  926. void settrap(uns int,void (*func)(Regs *));
  927. void range(int ye,int xe);
  928. ~Mouse();};
  929. /*-----*/
  930. extern Mouse Jerry; extern int oldmx,oldmy;
  931. #define LB 1
  932. #define MB 4
  933. #define RB 2
  934. /*-----*/
  935. /* extern int debug;
  936. inline void prdeb(char*s) {write(debug,s,strlen(s));}
  937. #define DEBUG debug=open("t$debug",0x0802)
  938. #define GUBED close(debug) */
  939. //#include <stdio.h>
  940. //extern FILE*debug;
  941. //inline void prdeb(char*s) {fprintf(debug,"%s",s);}
  942. //#define DEBUG debug=fopen("t$debug","a")
  943. //#define GUBED fclose(debug)
  944.  
  945. //#define longjmp(x,y) ({DEBUG; fprintf(debug,"line %1d of "__FILE__":\
  946. // longjmp("#x","#y");\n",__LINE__); GUBED; longjmp(x,y);})
  947. //#define setjmp(x) ({DEBUG; int miaow; fprintf(debug,"line %1d of "__FILE__":\
  948. // setjmp("#x"); set up\n",__LINE__);\
  949. // if(miaow=setjmp(x)) fprintf(debug,"line %1d of "__FILE__":\
  950. // setjmp("#x"); jumped to\n",__LINE__); GUBED; miaow;})
  951.