home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume7 / indexor / part02 < prev    next >
Encoding:
Text File  |  1989-07-23  |  32.1 KB  |  1,410 lines
  1. Newsgroups: comp.sources.misc
  2. organization: Univ. of Pittsburgh, Comp & Info Sys
  3. subject: v07i101: Index insertor for Scribe, TeX/LaTeX, *roff, etc. part 02/02
  4. From: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  5. Reply-To: jbw@unix.cis.pittsburgh.edu (Jingbai  Wang)
  6.  
  7. Posting-number: Volume 7, Issue 101
  8. Submitted-by: jbw@unix.cis.pittsburgh.edu (Jingbai  Wang)
  9. Archive-name: indexor/part02
  10.  
  11. [[See part 1 for unpacking instructions.  ++bsa]]
  12. #! /bin/sh
  13. # This file was wrapped with "dummyshar".  "sh" this file to extract.
  14. # Contents:  indexor.c-2
  15. echo extracting 'indexor.c-2'
  16. if test -f 'indexor.c-2' -a -z "$1"; then echo Not overwriting 'indexor.c-2'; else
  17. sed 's/^X//' << \EOF > 'indexor.c-2'
  18. X
  19. X}
  20. X
  21. Xcursor_right()
  22. X{
  23. X
  24. Xif (cursor_mark>=buffer_length-1) {next_page(); return;}
  25. X   ++cursor_mark; cursor_position();
  26. X   if (marker==1) printf("%c",buffer[cursor_mark]);
  27. X   GOTOXY(chr[cursor_mark].x,chr[cursor_mark].y);
  28. X
  29. X}
  30. X
  31. Xcursor_left()
  32. X{
  33. X  if (cursor_mark<=cursor_last) {cursor_mark=cursor_last; cursor_position();BELL; return;}
  34. X  NORMAL; cursor_position();printf("%c",buffer[cursor_mark]);
  35. X  --cursor_mark;
  36. X  if (marker==1) REVERSE;
  37. X  GOTOXY(chr[cursor_mark].x,chr[cursor_mark].y);
  38. X
  39. X
  40. X}
  41. X
  42. Xcursor_down()
  43. X{
  44. Xint i,the_stop;
  45. Xchar check;
  46. Xthe_stop=cursor_mark;
  47. X
  48. Xcursor_position();
  49. Xfor (i=cursor_mark;i<buffer_length;i++)
  50. X {if (i>=buffer_length-2) {next_page();return;}
  51. X  if (buffer[i]==10) {cursor_mark=i+1;
  52. X     cursor_position();goto check;}
  53. X }
  54. X
  55. Xcheck:
  56. X  if (marker)
  57. X   { GOTOXY(chr[the_stop].x,chr[the_stop].y);
  58. X     for (i=the_stop;i<=cursor_mark;i++)
  59. X      printf("%c",buffer[i]);
  60. X     cursor_position();
  61. X   }
  62. X}
  63. X
  64. Xcursor_up()
  65. X{
  66. Xchar check;
  67. Xint i,the_stop;
  68. Xif (cursor_mark<=cursor_last) {cursor_mark=cursor_last;cursor_position(); BELL; return;}
  69. X
  70. Xcursor_position();the_stop=cursor_mark;
  71. Xfor (i=cursor_mark;i>=cursor_last;i--)
  72. X {
  73. X  if (buffer[i]==10) {cursor_mark=i-1;
  74. X  GOTOXY(chr[cursor_mark].x,chr[cursor_mark].y);
  75. X  goto check;}
  76. X }
  77. X cursor_mark=cursor_last; cursor_position(); BELL;
  78. X
  79. Xcheck:
  80. X  if (marker)
  81. X   {
  82. X    NORMAL; GOTOXY(chr[cursor_mark+1].x,chr[cursor_mark+1].y);
  83. X    for (i=cursor_mark+1;i<=the_stop;i++)
  84. X       printf("%c",buffer[i]);
  85. X    REVERSE;
  86. X    GOTOXY(chr[cursor_mark].x,chr[cursor_mark].y);
  87. X   }
  88. X
  89. X}
  90. X
  91. X
  92. X
  93. X
  94. X
  95. X
  96. Xmark_word()
  97. X{
  98. Xif (marker==0) mark_begin(); word_skip();return;
  99. X}
  100. X
  101. Xpass_marked()
  102. X{
  103. Xint i;
  104. Xif (marker==0) { word_skip();return;}
  105. XGOTOXY(chr[cursor_last].x,chr[cursor_last].y);
  106. Xmarker=0; NORMAL;
  107. X phrase_str[0]= 0;
  108. X for (i=cursor_last;i<=cursor_mark;i++)
  109. X     printf("%c",buffer[i]);
  110. X
  111. Xcursor_mark=cursor_last;
  112. Xcursor_position();
  113. X}
  114. X
  115. X
  116. Xword_skip()
  117. X{
  118. Xint i, the_stop;
  119. Xchar check;
  120. X
  121. Xthe_stop=cursor_mark;
  122. Xif (cursor_mark>=buffer_length-1) {next_page(); return;}
  123. X
  124. Xcursor_right();
  125. Xfor (i=cursor_mark; i<buffer_length;i++)
  126. X {
  127. X
  128. X  switch(buffer[i])
  129. X   {case '!':
  130. X    case ',':
  131. X    case '"':
  132. X    case '\'':
  133. X    case '`':
  134. X    case '(':
  135. X    case ')':
  136. X    case '[':
  137. X    case ']':
  138. X    case '/':
  139. X    case '+':
  140. X    case '=':
  141. X    case '?':
  142. X    case '<':
  143. X    case '>':
  144. X    case '{':
  145. X    case '}':
  146. X    case '*':
  147. X    case '^':
  148. X    case '&':
  149. X    case '#':
  150. X    case ':':
  151. X    case ';':
  152. X    case '|':
  153. X    case  9:
  154. X    case 10:
  155. X    case 13:
  156. X    case '~':
  157. X    case '@':
  158. X    case '\\':
  159. X    case 32:
  160. X    case '.': if (word_mark) {word_mark=0;cursor_mark=i-1;
  161. X                 cursor_position();
  162. X                 goto check;}
  163. X          else break;
  164. X    default:   word_mark=1;
  165. X
  166. X   }
  167. X  }
  168. X
  169. Xcheck:
  170. X  if(marker)
  171. X   { GOTOXY(chr[the_stop].x,chr[the_stop].y);
  172. X     for (i=the_stop;i<=cursor_mark;i++)
  173. X    printf("%c",buffer[i]);
  174. X    cursor_position();
  175. X   }
  176. X
  177. X}
  178. X
  179. X
  180. X
  181. Xword_back()
  182. X{
  183. Xint i, the_stop;
  184. Xchar check;
  185. Xthe_stop=cursor_mark;
  186. Xcursor_left();
  187. Xfor (i=cursor_mark; i>=0;i--)
  188. X { if (i<=cursor_last) {cursor_mark=cursor_last;
  189. X            cursor_position();BELL;goto check;}
  190. X
  191. X  switch(buffer[i])
  192. X   {case '!':
  193. X    case ',':
  194. X    case '"':
  195. X    case '\'':
  196. X    case '`':
  197. X    case '(':
  198. X    case ')':
  199. X    case '[':
  200. X    case ']':
  201. X    case '/':
  202. X    case '+':
  203. X    case '=':
  204. X    case '?':
  205. X    case '<':
  206. X    case '>':
  207. X    case '{':
  208. X    case '}':
  209. X    case '*':
  210. X    case '^':
  211. X    case '&':
  212. X    case '#':
  213. X    case ':':
  214. X    case ';':
  215. X    case '|':
  216. X    case  9:
  217. X    case 10:
  218. X    case 13:
  219. X    case '~':
  220. X    case '@':
  221. X    case '\\':
  222. X    case 32:
  223. X    case '.':
  224. X         if (word_mark) {word_mark=0; cursor_mark=i; cursor_position();
  225. X        goto check;
  226. X          }
  227. X          else  break;
  228. X    default:   word_mark=1;
  229. X
  230. X    }
  231. X  }
  232. X
  233. Xcheck:
  234. X  if (marker)
  235. X   {GOTOXY(chr[cursor_mark+1].x,chr[cursor_mark+1].y);
  236. X    NORMAL;
  237. X     for (i=cursor_mark+1;i<=the_stop;i++)
  238. X     printf("%c",buffer[i]);
  239. X
  240. X    REVERSE;
  241. X    cursor_position();
  242. X   }
  243. X}
  244. X
  245. X
  246. Xnext_page()
  247. X{
  248. Xint i, length, pre_row, ch_count;
  249. X
  250. XNORMAL;
  251. XCLS_UP();
  252. XGOTOXY(1,1);  pre_row=0; ch_count=0;
  253. X
  254. Xif (end_outfile) {BELL; return;}
  255. X
  256. X
  257. Xif (marker){
  258. X if ((strlen(phrase_str)+strlen(&buffer[phrase_on]))<510)
  259. X  strcat(phrase_str, &buffer[phrase_on]);
  260. X else marker=0;
  261. X}
  262. X
  263. Xfor (i=buffer_line[lines-2];i<buffer_length;i++)
  264. X {
  265. X if ((marker==1) && (i>=phrase_on)) {REVERSE;}
  266. X   printf("%c", buffer[i]);
  267. X }
  268. X
  269. Xfor (i=cursor_last;i<buffer_length;i++)
  270. X  {   fprintf(outfile,"%c",buffer[i]);
  271. X  if (buffer[i]==10)
  272. X     {
  273. X      if (next_flag==1) {
  274. X             fprintf(outfile, "%s\n", next_str);
  275. X             next_str[0]=0; next_flag=0;
  276. X             }
  277. X     }
  278. X
  279. X  }
  280. X
  281. X
  282. Xcursor_last=0;
  283. Xphrase_on=0;
  284. Xcursor_mark=0;
  285. Xbuffer_length=0;
  286. XNORMAL;
  287. X
  288. Xif (end_infile) {end_outfile=1;
  289. X         GOTOXY(17, 70); BOLD;printf("[EOF]"); BELL; return;}
  290. X
  291. Xend_infile=read_in();
  292. Xif (marker) {REVERSE; printf("%c",buffer[0]);cursor_position();}
  293. X}
  294. X
  295. X
  296. Xcontrol(inchar)
  297. Xchar inchar;
  298. X{
  299. Xchar ch;
  300. X
  301. X
  302. X switch(inchar)
  303. X     {
  304. X       case EXT:
  305. X#if unix|VMS
  306. X             /* mainframe  environment  */
  307. X               if (getch()!=EXT1) {BELL;break;}
  308. X               ch=getch();
  309. X#else
  310. X             /* DOS environment              */ 
  311. X
  312. X             ch=getch();
  313. X#endif            
  314. X
  315. X             switch(ch)
  316. X              { 
  317. X               case L_ARROW: cursor_left(); 
  318. X                   break;
  319. X               case R_ARROW: cursor_right();
  320. X                   break;
  321. X               case D_ARROW: cursor_down();
  322. X                   break;
  323. X           case U_ARROW: cursor_up();
  324. X                   break;
  325. X               default: BELL;
  326. X              }
  327. X
  328. X          break;
  329. X       case 13: if (marker==0) {mark_begin(); break;}
  330. X                if (marker==1) 
  331. X                 {mark_end(); index_now();}
  332. X                 break;     
  333. X       case 9:  word_skip(); break;
  334. X       case 'b':
  335. X       case 'B':
  336. X       case 8:
  337. X       case 127:
  338. X                word_back(); break;
  339. X       case 32: next_page(); break;
  340. X       case 'n':
  341. X       case 'N': if (marker==1) 
  342. X                {mark_end();index_next_line();} 
  343. X                 else BELL; break;    
  344. X       case 'p':
  345. X       case 'P': pass_marked(); break;
  346. X       case 'f':
  347. X       case 'F': finish_up(); return(1); break;
  348. X       case 'a':
  349. X       case 'A': if (marker==1) mark_end(); see_also();break;
  350. X       case 's':
  351. X       case 'S': if (marker==1) mark_end();index_secondary();break;
  352. X       case 'i':
  353. X       case 'I': if (marker==1) mark_end();index_entry();break;
  354. X       case 'g':
  355. X       case 'G': if (marker==1) mark_end();
  356. X          else warning("No current marked, will take the previous one");
  357. X         glossary();
  358. X           break;
  359. X       case 'W':
  360. X       case 'w': mark_word(); break;
  361. X       case '@': set_up(); break;
  362. X       case  6 : str_search(); break;
  363. X       case  3 : all_done(); break;
  364. X#if unix
  365. X       case  4 : all_done(); break;
  366. X#endif
  367. X       default: BELL;
  368. X   }
  369. X
  370. X
  371. X}
  372. X
  373. X
  374. X
  375. X
  376. Xmain(argc, argv)
  377. Xint argc;
  378. Xchar *argv[];
  379. X{
  380. Xint in_file,out_file, status;
  381. Xint i,j;
  382. Xchar infile_name[30], outfile_name[30];
  383. Xchar out_ok=1;
  384. Xchar ch, quit;
  385. Xchar getch();
  386. X
  387. X#if     VMS
  388. X$DESCRIPTOR(terminal,"TT");
  389. X
  390. X        status = SYS$ASSIGN(&terminal, &iochan, 0, 0);
  391. X        if (status != SS$_NORMAL) exit(status);
  392. X
  393. Xsystem("set broadcast=none");
  394. X
  395. X#endif
  396. X
  397. X
  398. XNORMAL;
  399. XCLS;
  400. X 
  401. Xswitch(argc)
  402. X  {
  403. X    case 1: in_file=1; out_file=1; break;
  404. X    case 2: in_file=0; out_file=1; strcpy(infile_name,argv[1]); break;
  405. X    default: in_file=0;out_file=0;
  406. X           strcpy(infile_name,argv[1]); 
  407. X           strcpy(outfile_name,argv[2]); break;
  408. X  }
  409. X
  410. X if (in_file) 
  411. X   {GOTOXY(5,15);
  412. X   printf(" Input file (file to be indexed) >");
  413. X   scanf("%s",infile_name);
  414. X   fflush(stdin);
  415. X   }
  416. X
  417. X   if ((infile=fopen(infile_name,"r"))==NULL)
  418. X     {GOTOXY(20,20); BLINK;
  419. X       printf("Can't find the input file");
  420. X       NORMAL; goto quit;
  421. X     }
  422. X
  423. Xwhile (out_ok)
  424. X
  425. X {
  426. X  if (out_file) 
  427. X    {GOTOXY(6,15); ERASE;
  428. X    printf(" Output file (indexed file) >");
  429. X    fscanf(stdin, "%s",outfile_name);
  430. X    fflush(stdin);
  431. X    }
  432. X
  433. X
  434. X    out_ok=0; 
  435. X   if ((outfile=fopen(outfile_name,"r"))!=NULL)
  436. X     { out_ok=1;
  437. X       GOTOXY(7,16); ERASE;
  438. X       out_file=1;
  439. X      fflush(stdin);
  440. X      printf("File %s already exits, overwrite ? [N]", outfile_name);
  441. X      ch=getch();
  442. X      ch=getch();
  443. X        if ((ch=='y')||(ch=='Y')) out_ok=0;
  444. X        fclose(outfile);
  445. X
  446. X     }
  447. X
  448. X    if (out_ok==0)
  449. X       {
  450. X    outfile=fopen(outfile_name,"w");
  451. X       }
  452. X }
  453. X
  454. X
  455. X
  456. XNORMAL;
  457. XCLS;
  458. X
  459. Xhelp_menu();
  460. Xend_infile=read_in();
  461. X
  462. X while (1)
  463. X  {
  464. X   control(getch());
  465. X   if (exit_flag) goto quit;
  466. X  }
  467. X
  468. Xquit:
  469. XGOTOXY(25, 1);
  470. Xprintf("\n\t>>> Thank you for using INDEX MAKER >>>\n");
  471. Xprintf("\t>>> by Jingbai Wang, August 1988 >>>\n");
  472. X
  473. X
  474. X
  475. X}
  476. X
  477. Xwarning(warn_str)
  478. Xchar *warn_str;
  479. X{
  480. Xchar i;
  481. X
  482. XSAVE_CURSOR;
  483. XGOTOXY(24,5); REVERSE; BLINK;
  484. Xprintf("%s", warn_str); BELL; BELL;
  485. Xfor (i=1;i<10000;i++) ;
  486. XGOTOXY(24,1); RESTORE_CURSOR; NORMAL;
  487. X}
  488. X
  489. Xvoid  clr_show()
  490. X{
  491. Xint i;
  492. Xfor (i=13;i<17;i++)
  493. X  {NORMAL; GOTOXY(i,1);ERASE;}
  494. X}
  495. X
  496. X
  497. Xindex_now()
  498. X{ int i;
  499. Xfprintf(outfile, "%s%s%s%s",the_index,the_delimiter1,phrase_str,the_delimiter2);
  500. XSAVE_CURSOR;
  501. Xclr_show(); out_check();
  502. XGOTOXY(13,1);
  503. XBOLD;
  504. Xprintf("%s%s%s%s",the_index,the_delimiter1,out_str,the_delimiter2);
  505. XNORMAL; RESTORE_CURSOR;
  506. X}
  507. X
  508. Xindex_next_line()
  509. X{
  510. Xint i;
  511. X
  512. Xnext_flag=1;
  513. Xstrcat(next_str, the_index);
  514. Xstrcat(next_str, the_delimiter1);
  515. X    if ((strlen(next_str)+strlen(phrase_str))<510) 
  516. X        strcat(next_str, phrase_str);
  517. Xstrcat(next_str, the_delimiter2);
  518. XSAVE_CURSOR;
  519. Xclr_show(); out_check();
  520. XGOTOXY(13,1);
  521. XBOLD;
  522. Xprintf("%s%s%s%s}", the_index,the_delimiter1,out_str,the_delimiter2);
  523. XNORMAL; RESTORE_CURSOR;
  524. X
  525. X}
  526. X
  527. Xsee_also()
  528. X{
  529. XSAVE_CURSOR;BELL;
  530. XGOTOXY(24,2); BLINK; REVERSE;
  531. Xprintf("  Primary=");  NORMAL;printf("[%s]",save_str);
  532. Xget_line();
  533. Xif (memcmp(command_line,"",1)==0) strcpy(command_line, save_str);
  534. X else strcpy(save_str, command_line);
  535. Xfprintf(outfile, "%s%s%s%s%s%s,\n %s%s%s%s%s",the_seealso,the_delimiter1,
  536. Xthe_primary,the2_delimiter1,command_line, the2_delimiter2,the_second,
  537. Xthe2_delimiter1,phrase_str,the2_delimiter2, the_delimiter2);
  538. XGOTOXY(24,1);ERASE;
  539. Xclr_show();  out_check();
  540. XGOTOXY(13,1);
  541. XBOLD;
  542. Xprintf("%s%s%s%s%s%s,\n %s%s%s%s%s",the_seealso,the_delimiter1,
  543. Xthe_primary,the2_delimiter1,command_line, the2_delimiter2,the_second,
  544. Xthe2_delimiter1,out_str,the2_delimiter2, the_delimiter2);
  545. XNORMAL; RESTORE_CURSOR;
  546. X
  547. X}
  548. X
  549. Xindex_entry()
  550. X{
  551. Xchar entry[20], number[30];
  552. Xstrcpy(save_str, phrase_str);
  553. X
  554. Xstrcpy(number, ",\nNumber=<");
  555. XSAVE_CURSOR;BELL;
  556. XGOTOXY(24,2); BLINK; REVERSE;
  557. Xprintf("  Entry=");  NORMAL;printf("[%s]",phrase_str);
  558. Xget_line();
  559. Xif (memcmp(command_line,"",1)==0) strcpy(entry, phrase_str);
  560. X else strcpy(entry, command_line);
  561. XGOTOXY(24,1);ERASE;
  562. XGOTOXY(24,2); BLINK; REVERSE;
  563. Xprintf("  Number=");  NORMAL;
  564. Xget_line();
  565. Xif (memcmp(command_line,"",1)==0) number[0]=0;
  566. X else  {strcat(number, command_line); strcat(number, ">");}
  567. X
  568. X
  569. Xfprintf(outfile, "%s%s%s%s%s%s,\n %s%s%s%s%s%s",the_indexentry,the_delimiter1,
  570. Xthe_key,the2_delimiter1,phrase_str, the2_delimiter2,the_entry,
  571. Xthe2_delimiter1,entry,the2_delimiter2,  number, the_delimiter2);
  572. XGOTOXY(24,1);ERASE;
  573. Xclr_show();  out_check();
  574. XGOTOXY(13,1);
  575. XBOLD;
  576. Xprintf("%s%s%s%s%s%s,\n %s%s%s%s%s%s",the_indexentry,the_delimiter1,
  577. Xthe_key,the2_delimiter1,out_str, the2_delimiter2,the_entry,
  578. Xthe2_delimiter1,entry,the2_delimiter2, number, the_delimiter2);
  579. XNORMAL; RESTORE_CURSOR;
  580. X
  581. X}
  582. X
  583. Xindex_secondary()
  584. X{
  585. XSAVE_CURSOR;BELL;
  586. XGOTOXY(24,2); BLINK; REVERSE;
  587. Xprintf("  Primary=");  NORMAL;printf("[%s]",save_str);
  588. Xget_line();
  589. Xif (memcmp(command_line,"",1)==0) strcpy(command_line, save_str);
  590. X else strcpy(save_str, command_line);
  591. Xfprintf(outfile, "%s%s%s%s%s%s,\n %s%s%s%s%s",the_indexsecond,the_delimiter1,
  592. Xthe_primary,the2_delimiter1,command_line, the2_delimiter2,the_second,
  593. Xthe2_delimiter1,phrase_str,the2_delimiter2, the_delimiter2);
  594. XGOTOXY(24,1);ERASE;
  595. Xclr_show();  out_check();
  596. XGOTOXY(13,1);
  597. XBOLD;
  598. Xprintf("%s%s%s%s%s%s,\n %s%s%s%s%s",the_indexsecond,the_delimiter1,
  599. Xthe_primary,the2_delimiter1,command_line, the2_delimiter2,the_second,
  600. Xthe2_delimiter1,out_str,the2_delimiter2, the_delimiter2);
  601. XNORMAL; RESTORE_CURSOR;
  602. X
  603. X}
  604. X
  605. Xglossary()
  606. X{
  607. XSAVE_CURSOR;
  608. XGOTOXY(24,2); BLINK; REVERSE;
  609. Xprintf("  Description:");  NORMAL;
  610. Xget_line();
  611. Xfprintf(outfile, "%s%s%s%s%s%s,\n %s%s%s%s%s",the_gloss,the_delimiter1,
  612. Xg_primary,the2_delimiter1,phrase_str, the2_delimiter2,g_second,
  613. Xthe2_delimiter1,command_line,the2_delimiter2, the_delimiter2);
  614. XGOTOXY(24,1);ERASE;
  615. Xclr_show();  out_check();
  616. XGOTOXY(13,1);
  617. XBOLD;
  618. Xprintf("%s%s%s%s%s%s,\n %s%s%s%s%s",the_gloss,the_delimiter1,
  619. Xg_primary,the2_delimiter1,command_line, the2_delimiter2,g_second,
  620. Xthe2_delimiter1,out_str,the2_delimiter2, the_delimiter2);
  621. XNORMAL; RESTORE_CURSOR;
  622. X
  623. X}
  624. X
  625. X
  626. Xfinish_up()
  627. X{ char ch;
  628. X  int i;
  629. X
  630. Xif(end_infile && end_outfile) {all_done(); exit();}
  631. X
  632. X
  633. Xif (marker) {mark_end(); index_now(); }
  634. X
  635. Xfor (i=cursor_last;i<buffer_length;i++)
  636. X  {
  637. X  if (buffer[i]==13)
  638. X     { 
  639. X      if (next_flag==1) {
  640. X             fprintf(outfile, "%s\n\n", next_str);
  641. X             next_str[0]=0; next_flag=0;
  642. X             }
  643. X     }
  644. X  else fprintf(outfile,"%c",buffer[i]);
  645. X  }
  646. X
  647. X
  648. X
  649. Xif (end_infile==1) {all_done(); return;}
  650. XGOTOXY(24,35); BLINK; printf("Working ... \n");
  651. X
  652. X    while (fscanf(infile,"%c",&ch)!=EOF)
  653. X      {
  654. X    if (ch==13);
  655. X    else fprintf(outfile, "%c", ch);
  656. X      }
  657. X  all_done();NORMAL;
  658. X}
  659. X
  660. X
  661. Xall_done()
  662. X{
  663. Xfclose(infile); fclose(outfile); exit_flag=1;
  664. X#if VMS
  665. Xsystem("set broadcast=all");
  666. X#endif
  667. X}
  668. X
  669. X
  670. XCLS_UP()
  671. X{ char i;
  672. X
  673. Xfor(i=1;i<12;i++)
  674. X  {GOTOXY(i,1); ERASE;}
  675. X
  676. X}
  677. X
  678. Xhelp_menu()
  679. X{
  680. XGOTOXY(12, 1);
  681. XREVERSE; printf("                                ");
  682. Xprintf(" Inserting                                 ");
  683. X
  684. XGOTOXY(17,1);
  685. Xprintf(" ===== ^H delete ======================== ^F Search string ===============");
  686. XNORMAL;
  687. XGOTOXY(18,3); BOLD; printf("SPACE BAR"); NORMAL; printf(" -- next page");
  688. XGOTOXY(19,3); BOLD; printf("<RETURN> 1"); NORMAL; printf(" -- set mark");
  689. XGOTOXY(20,3); BOLD; printf("<RETURN> 2"); NORMAL; printf(" -- end mark & index");
  690. XGOTOXY(21,3); BOLD; printf("<TAB>"); NORMAL; printf(" -- forward a word");
  691. XGOTOXY(22,40); BOLD; printf("G"); NORMAL; printf(" -- end mark & glossary");
  692. XGOTOXY(22,3); BOLD; printf("W"); NORMAL; printf(" -- mark word");
  693. XGOTOXY(21,40); BOLD; printf("B"); NORMAL; printf(" -- backward a word");
  694. XGOTOXY(20,40); BOLD; printf("N"); NORMAL; printf(" -- end mark & index in next line");
  695. XGOTOXY(19,40); BOLD; printf("P"); NORMAL; printf(" -- abandon the marked/skip a word ");
  696. XGOTOXY(18,40); BOLD; printf("F"); NORMAL; printf(" -- finish     \
  697. X        ^F--string search");
  698. XGOTOXY(23,40); BOLD; printf("S"); NORMAL; printf(" -- IndexSecondary");
  699. XGOTOXY(23,17); BOLD; printf("I"); NORMAL; printf(" -- IndexEntry");
  700. XGOTOXY(23,3); BOLD; printf("A"); NORMAL; printf(" -- SeeAlso");
  701. XGOTOXY(23,65); BOLD; printf("@"); NORMAL; printf(" -- set up");
  702. X}
  703. X
  704. X
  705. Xset_up()
  706. X{
  707. Xint the_row, i;
  708. Xint ch_count;
  709. Xchar ch, string[81];
  710. X
  711. Xch_count=0;
  712. XSAVE_CURSOR;
  713. XNORMAL; REVERSE;
  714. XGOTOXY(12,1);
  715. Xprintf("                            Set-up Menu                  <TAB> to quit      ");
  716. XNORMAL;
  717. Xfor (i=13;i<24;i++)
  718. X  {GOTOXY(i,1);ERASE;}
  719. X
  720. XGOTOXY(13,3);printf("[%s]:",the_index);
  721. XGOTOXY(14,3);printf("[%s]:",the_indexentry);
  722. XGOTOXY(15,3);printf("[%s]:",the_indexsecond);
  723. XGOTOXY(16,3);printf("[%s]:",the_seealso);
  724. XGOTOXY(17,3);printf("[%s]:",the_primary);
  725. XGOTOXY(18,3);printf("[%s]:",the_second);
  726. XGOTOXY(19,3);printf("[%s]:",the_gloss);
  727. XGOTOXY(20,3);printf("Gloss k1 [%s]:",g_primary);
  728. XGOTOXY(21,3);printf("Gloss k2 [%s]:",g_second);
  729. XGOTOXY(22,3);printf("left delimiter 1 [%s]:",the_delimiter1);
  730. XGOTOXY(22,40);printf("right delimiter 1 [%s]:",the_delimiter2);
  731. XGOTOXY(23,3);printf("left delimiter 2 [%s]:",the2_delimiter1);
  732. XGOTOXY(23,40);printf("right delimiter 2 [%s]:",the2_delimiter2);
  733. X
  734. Xthe_row=13;
  735. Xset_up_in(the_row);
  736. X
  737. X     while(1)
  738. X      { ch=getch();
  739. X     switch(ch)
  740. X     {
  741. X      case EXT:
  742. X#if unix | VMS
  743. X
  744. X         /* VAX */
  745. X         ch=getch(); if (ch!=EXT1) {BELL;break;}
  746. X         ch=getch();
  747. X#else
  748. X               /* DOS                 */
  749. X          ch=getch(); 
  750. X#endif        
  751. X         switch(ch)
  752. X         {
  753. X          case L_ARROW:
  754. X          case U_ARROW:
  755. X               set_up_out(the_row); ch_count=0;string[0]=0;
  756. X               --the_row; if (the_row<13) the_row=25;
  757. X               set_up_in(the_row); break;
  758. X          case R_ARROW:
  759. X          case D_ARROW:
  760. X  down:                        set_up_out(the_row);ch_count=0;string[0]=0;
  761. X               ++the_row; if (the_row>25) the_row=13;
  762. X               set_up_in(the_row); break;
  763. X         default: BELL;
  764. X         } break;
  765. X       case  3 : all_done(); break;
  766. X#if unix
  767. X       case  4 : all_done(); break;
  768. X#endif
  769. X      case 1:
  770. X      case 2:
  771. X      case 5:
  772. X      case 6:
  773. X      case 7:
  774. X      case 10:
  775. X      case 11:
  776. X      case 12:
  777. X      case 14:
  778. X      case 15:
  779. X      case 16:
  780. X      case 19:
  781. X      case 20:
  782. X      case 21:
  783. X      case 22:
  784. X      case 23:
  785. X      case 24:
  786. X      case 25:
  787. X      case 26:BELL;break;
  788. X          case 8:
  789. X          case 127:
  790. X              if (ch_count>0){
  791. X                  CURSOR_LEFT; ERASE;
  792. X                  string[--ch_count]=0;
  793. X                  }  break;
  794. X
  795. X      case 13: if (ch_count>0)
  796. X          { string[ch_count]=0;
  797. X           set_up_save(the_row, string);
  798. X           } goto down;break;
  799. X      case 9: NORMAL;for (i=12;i<24;i++)
  800. X           {GOTOXY(i,1);ERASE;}
  801. X           help_menu();RESTORE_CURSOR;
  802. X           return;
  803. X      default: printf("%c",ch);string[ch_count++]=ch;
  804. X
  805. X     }
  806. X
  807. X      }
  808. X
  809. X
  810. X}
  811. X
  812. X
  813. X
  814. X
  815. X
  816. Xset_up_in( the_row)
  817. Xint the_row;
  818. X{ REVERSE;
  819. X      switch(the_row)
  820. X    {
  821. X     case 13:
  822. XGOTOXY(13,3);printf("[%s]:",the_index);break;
  823. Xcase 14:
  824. XGOTOXY(14,3);printf("[%s]:",the_indexentry);break;
  825. Xcase 15:
  826. XGOTOXY(15,3);printf("[%s]:",the_indexsecond);break;
  827. Xcase 16:
  828. XGOTOXY(16,3);printf("[%s]:",the_seealso);break;
  829. Xcase 17:
  830. XGOTOXY(17,3);printf("[%s]:",the_primary); break;
  831. Xcase 18:
  832. XGOTOXY(18,3);printf("[%s]:",the_second);  break;
  833. Xcase 19:
  834. XGOTOXY(19,3);printf("[%s]:",the_gloss);  break;
  835. Xcase 20:
  836. XGOTOXY(20,3);printf("Gloss k1 [%s]:",g_primary);break;
  837. Xcase 21:
  838. XGOTOXY(21,3);printf("Gloss k2 [%s]:",g_second); break;
  839. Xcase 22:
  840. XGOTOXY(22,3);printf("left delimiter 1 [%s]:",the_delimiter1);break;
  841. Xcase 23:
  842. XGOTOXY(22,40);printf("right delimiter 1 [%s]:",the_delimiter2);break;
  843. Xcase 24:
  844. XGOTOXY(23,3);printf("left delimiter 2 [%s]:",the2_delimiter1); break;
  845. Xcase 25:
  846. XGOTOXY(23,40);printf("right delimiter 2 [%s]:",the2_delimiter2);break;
  847. X
  848. X    }
  849. X
  850. X}
  851. X
  852. X
  853. Xset_up_save(the_row, string)
  854. Xint the_row;
  855. Xchar *string;
  856. X{
  857. X      switch(the_row)
  858. X    {
  859. X     case 13:strcpy(the_index,string);break;
  860. X     case 14:strcpy(the_indexentry,string);break;
  861. X     case 15:strcpy(the_indexsecond,string);break;
  862. X     case 16:strcpy(the_seealso,string);break;
  863. X     case 17:strcpy(the_primary,string);break;
  864. X     case 18:strcpy(the_second,string);break;
  865. X     case 19:strcpy(the_gloss,string);break;
  866. X     case 20:strcpy(g_primary,string);break;
  867. X     case 21:strcpy(g_second,string);break;
  868. X     case 22:strcpy(the_delimiter1,string);break;
  869. X     case 23:strcpy(the_delimiter2,string);break;
  870. X     case 24:strcpy(the2_delimiter1,string);break;
  871. X     case 25:strcpy(the2_delimiter2,string);break;
  872. X
  873. X    }
  874. X
  875. X}
  876. X
  877. X
  878. X
  879. Xset_up_out(the_row)
  880. Xint the_row;
  881. X{  NORMAL;
  882. X      switch(the_row)
  883. X    {
  884. X     case 13:GOTOXY(13,1);ERASE;
  885. XGOTOXY(13,3); printf("[%s]:",the_index);break;
  886. Xcase 14:GOTOXY(14,1);ERASE;
  887. XGOTOXY(14,3);printf("[%s]:",the_indexentry);break;
  888. Xcase 15:GOTOXY(15,1);ERASE;
  889. XGOTOXY(15,3);printf("[%s]:",the_indexsecond);break;
  890. Xcase 16:GOTOXY(16,1);ERASE;
  891. XGOTOXY(16,3);printf("[%s]:",the_seealso);break;
  892. Xcase 17:GOTOXY(17,1);ERASE;
  893. XGOTOXY(17,3);printf("[%s]:",the_primary); break;
  894. Xcase 18:GOTOXY(18,1);ERASE;
  895. XGOTOXY(18,3);printf("[%s]:",the_second);  break;
  896. Xcase 19:GOTOXY(19,1);ERASE;
  897. XGOTOXY(19,3);printf("[%s]:",the_gloss);  break;
  898. Xcase 20:GOTOXY(20,1);ERASE;
  899. XGOTOXY(20,3);printf("Gloss k1 [%s]:",g_primary);break;
  900. Xcase 21:GOTOXY(21,1);ERASE;
  901. XGOTOXY(21,3);printf("Gloss k2 [%s]:",g_second); break;
  902. Xcase 22:GOTOXY(22,3);printf("                                 ");
  903. XGOTOXY(22,3);printf("left delimiter 1 [%s]:",the_delimiter1);break;
  904. Xcase 23:GOTOXY(22,40);ERASE;
  905. XGOTOXY(22,40);printf("right delimiter 1 [%s]:",the_delimiter2);break;
  906. Xcase 24:GOTOXY(23,3);printf("                               ");
  907. XGOTOXY(23,3);printf("left delimiter 2 [%s]:",the2_delimiter1); break;
  908. Xcase 25:GOTOXY(23,40);ERASE;
  909. XGOTOXY(23,40);printf("right delimiter 2 [%s]:",the2_delimiter2);break;
  910. X
  911. X    }
  912. X
  913. X}
  914. X
  915. Xout_check()
  916. X{int i, rows, length, trunc;
  917. Xrows=1;  trunc=256;
  918. X
  919. Xstrcpy(out_str,phrase_str);
  920. Xlength=strlen(out_str);
  921. X
  922. Xfor (i=0;i<length; i++)
  923. X {
  924. X  if (out_str[i]==10) ++rows;
  925. X  if (rows==2) {trunc=i-4;break;}
  926. X }
  927. X
  928. X
  929. Xif (length>trunc) {out_str[trunc]='.';out_str[trunc+1]='.';out_str[trunc+2]='.';
  930. Xout_str[trunc+3]=0;}
  931. X}
  932. X
  933. X
  934. X
  935. Xget_line()
  936. X{
  937. Xchar ch;
  938. Xint ch_count;
  939. X
  940. Xch_count=0;
  941. X
  942. Xcommand_line[0]=0;
  943. X
  944. X     while(1)
  945. X      { ch=getch();
  946. X         switch(ch)
  947. X          {
  948. X          case 3: all_done(); break;
  949. X#if unix
  950. X          case 4: all_done(); break;
  951. X#endif       
  952. X          case 0:
  953. X      case 1:
  954. X      case 2:
  955. X
  956. X      case 5:
  957. X      case 6: 
  958. X      case 7:
  959. X      case 10:
  960. X      case 11:
  961. X      case 12:
  962. X      case 14:
  963. X      case 15:
  964. X      case 16:
  965. X      case 19:
  966. X      case 20:
  967. X      case 21:
  968. X      case 22:
  969. X      case 23:
  970. X      case 24:
  971. X      case 25:
  972. X      case 26: BELL;break;
  973. X          case 8:
  974. X          case 127:
  975. X              if (ch_count>0){
  976. X                  CURSOR_LEFT; ERASE;
  977. X                  command_line[--ch_count]=0;
  978. X                  }  break;
  979. X      case 13: if (ch_count>0)
  980. X             command_line[ch_count]=0;
  981. X             return;
  982. X      default: printf("%c",ch);command_line[ch_count++]=ch;
  983. X
  984. X     }
  985. X    }
  986. X
  987. X}
  988. X
  989. X
  990. Xstr_search()
  991. X{
  992. Xchar *ptr;
  993. X#if unix
  994. Xchar *memchr();
  995. X#endif
  996. Xint same_page= -1;
  997. Xvoid  this_page();
  998. Xint cursor_here=0,i;
  999. Xcommand_line[0]=0;
  1000. XSAVE_CURSOR;
  1001. X
  1002. XGOTOXY(24,2); REVERSE;
  1003. Xprintf("String:"); NORMAL; printf(" ");
  1004. Xif (the_phrase[0]>0) printf("[%s]", the_phrase);
  1005. Xget_line();
  1006. X
  1007. Xif (command_line[0]>0) strcpy(the_phrase, command_line);
  1008. X  else if (the_phrase[0]==0)  {GOTOXY(24,2); ERASE; RESTORE_CURSOR; 
  1009. X        return;}
  1010. X
  1011. Xptr=buffer;
  1012. Xif (same_page<0)
  1013. X  while ( cursor_here<cursor_mark) {cursor_here++; ptr++;}  
  1014. X
  1015. Xwhile (1){
  1016. X
  1017. Xwhile ((ptr=memchr(ptr, the_phrase[0], buffer_length))!=NULL)
  1018. X    {
  1019. X    if( memcmp(ptr, the_phrase, strlen(the_phrase))==0)
  1020. X      { GOTOXY(24,2); ERASE;
  1021. X       this_page(same_page*cursor_here); return;}
  1022. X    else {ptr++;}       
  1023. X    }
  1024. X
  1025. X   /* Writing the buffer into the output file */
  1026. X
  1027. Xfor (i=cursor_last;i<buffer_length;i++)
  1028. X  {   fprintf(outfile,"%c",buffer[i]);
  1029. X  if ((same_page<0) && (buffer[i]==10))
  1030. X     {
  1031. X      if (next_flag) {
  1032. X             fprintf(outfile, "%s\n", next_str);
  1033. X             next_str[0]=0; next_flag=0;
  1034. X             }
  1035. X     }
  1036. X
  1037. X  }
  1038. X
  1039. X
  1040. Xif (same_page<0)
  1041. X{
  1042. X marker=0;
  1043. Xcursor_last=0;
  1044. Xphrase_on=0;
  1045. Xcursor_mark=0;
  1046. Xbuffer_length=0;
  1047. Xnext_flag=0;
  1048. Xsame_page=1;
  1049. X}
  1050. X
  1051. X
  1052. Xif (end_infile) { end_outfile=1;
  1053. X         GOTOXY(17, 70); BOLD;printf("[EOF]"); BELL;
  1054. XGOTOXY(24, 2); printf("String not found"); 
  1055. Xall_done();
  1056. X exit();}
  1057. X
  1058. Xend_infile=read_in_only(); cursor_here=0; ptr=buffer;
  1059. X }
  1060. X
  1061. X}
  1062. X
  1063. X
  1064. Xint read_in_only()
  1065. X{
  1066. Xint i, quit_s;
  1067. Xchar quit;
  1068. Xchar string[81];
  1069. X
  1070. X
  1071. Xbuffer_length=0;
  1072. Xbuffer[0]=0;
  1073. Xstring[0]=0;
  1074. X           quit_s=0;
  1075. X
  1076. Xfor (i=1;i<=8;i++)
  1077. X  { if( fgets(string,80,infile)==NULL)
  1078. X        {fclose(infile); quit_s=1; goto quit;}
  1079. X           strcat(buffer,string);
  1080. X  }
  1081. X
  1082. Xquit:
  1083. Xbuffer_length=strlen(buffer);
  1084. X
  1085. Xreturn(quit_s);
  1086. X}
  1087. X
  1088. X
  1089. Xvoid this_page(cursor_here)
  1090. Xint cursor_here;
  1091. X{
  1092. Xint i, cursor_there, the_cursor;
  1093. X
  1094. Xif (cursor_here<0) cursor_there= (-1)*cursor_here;
  1095. X   else cursor_there=0;
  1096. X
  1097. Xfor (i=cursor_there;i<buffer_length;i++)
  1098. X if(memcmp(&buffer[i], the_phrase, strlen(the_phrase))==0) 
  1099. X  {the_cursor=i; break;}
  1100. X
  1101. Xif (cursor_here<0) {
  1102. X     if (marker) 
  1103. X      {REVERSE; cursor_mark=cursor_last; cursor_position(); marker=0;
  1104. X       for (i=cursor_last; i<=the_cursor; i++)
  1105. X        {
  1106. X        printf("%c", buffer[i]);
  1107. X        }
  1108. X       NORMAL;
  1109. X      }
  1110. X     cursor_mark= the_cursor;
  1111. X     cursor_position();
  1112. X      }
  1113. X    else 
  1114. X   {
  1115. X   position();
  1116. X   NORMAL; CLS_UP(); NORMAL; 
  1117. X   GOTOXY(3,1);
  1118. X   for (i=0;i<buffer_length;i++)
  1119. X     printf("%c", buffer[i]);
  1120. X   cursor_mark=the_cursor;
  1121. X   cursor_position();
  1122. X   }
  1123. X
  1124. Xreturn;
  1125. X}
  1126. X
  1127. X
  1128. X
  1129. X/* for ultrix define V7 = 1 */
  1130. X
  1131. X/*
  1132. X * The functions in this file negotiate with the operating system for
  1133. X * characters, and write characters in a barely buffered fashion on the display.
  1134. X * All operating systems.
  1135. X */
  1136. X
  1137. X
  1138. X#if   MSDOS & TURBO
  1139. X#include <conio.h>
  1140. X#endif
  1141. X
  1142. X#if     AMIGA
  1143. X#define NEW 1006L
  1144. X#define AMG_MAXBUF      1024L
  1145. Xstatic long terminal;
  1146. Xstatic char     scrn_tmp[AMG_MAXBUF+1];
  1147. Xstatic long     scrn_tmp_p = 0;
  1148. X#endif
  1149. X
  1150. X#if     CPM
  1151. X#include        <bdos.h>
  1152. X#endif
  1153. X
  1154. X#if     MSDOS & (LATTICE | MSC | TURBO | AZTEC | MWC86)
  1155. Xunion REGS rg;          /* cpu register for use of DOS calls */
  1156. Xint nxtchar = -1;       /* character held from type ahead    */
  1157. X#endif
  1158. X
  1159. X#if RAINBOW
  1160. X#include "rainbow.h"
  1161. X#endif
  1162. X
  1163. X#if     USG                     /* System V */
  1164. X#include        <signal.h>
  1165. X#include        <termio.h>
  1166. X#include        <fcntl.h>
  1167. Xint kbdflgs;                    /* saved keyboard fd flags      */
  1168. Xint kbdpoll;                    /* in O_NDELAY mode                     */
  1169. Xint kbdqp;                      /* there is a char in kbdq      */
  1170. Xchar kbdq;                      /* char we've already read      */
  1171. Xstruct  termio  otermio;        /* original terminal characteristics */
  1172. Xstruct  termio  ntermio;        /* charactoristics to use inside */
  1173. X#endif
  1174. X
  1175. X#if V7 | BSD
  1176. X/*
  1177. X#undef  CTRL
  1178. X*/
  1179. X#include        <sgtty.h>        /* for stty/gtty functions */
  1180. X#include        <signal.h>
  1181. Xstruct  sgttyb  ostate;          /* saved tty state */
  1182. Xstruct  sgttyb  nstate;          /* values for editor mode */
  1183. Xstruct tchars   otchars;        /* Saved terminal special character set */
  1184. Xstruct tchars   ntchars = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  1185. X                                /* A lot of nothing */
  1186. X#if BSD
  1187. X#include <sys/ioctl.h>          /* to get at the typeahead */
  1188. Xextern  int rtfrmshell();       /* return from suspended shell */
  1189. X#define         TBUFSIZ         128
  1190. Xchar tobuf[TBUFSIZ];            /* terminal output buffer */
  1191. X#endif
  1192. X#endif
  1193. X
  1194. X/*
  1195. X * This function is called once to set up the terminal device streams.
  1196. X */
  1197. Xttopen()
  1198. X{
  1199. X
  1200. X#if     AMIGA
  1201. X        char oline[NSTRING];
  1202. X#if     AZTEC
  1203. X        extern  Enable_Abort;   /* Turn off ctrl-C interrupt */
  1204. X
  1205. X        Enable_Abort = 0;       /* for the Manx compiler */
  1206. X#endif
  1207. X        strcpy(oline, "RAW:0/0/640/200/");
  1208. X        strcat(oline, PROGNAME);
  1209. X        strcat(oline, " ");
  1210. X        strcat(oline, VERSION);
  1211. X        strcat(oline, "/Amiga");
  1212. X        terminal = Open(oline, NEW);
  1213. X#endif
  1214. X#if     CPM
  1215. X#endif
  1216. X
  1217. X#if     MSDOS & (HP150 == 0) & LATTICE
  1218. X        /* kill the ctrl-break interupt */
  1219. X        rg.h.ah = 0x33;                 /* control-break check dos call */
  1220. X        rg.h.al = 1;            /* set the current state */
  1221. X        rg.h.dl = 0;            /* set it OFF */
  1222. X        intdos(&rg, &rg);       /* go for it! */
  1223. X#endif
  1224. X
  1225. X#if     USG
  1226. X        ioctl(0, TCGETA, &otermio);     /* save old settings */
  1227. X        ntermio.c_iflag = 0;            /* setup new settings */
  1228. X        ntermio.c_oflag = 0;
  1229. X        ntermio.c_cflag = otermio.c_cflag;
  1230. X        ntermio.c_lflag = 0;
  1231. X        ntermio.c_line = otermio.c_line;
  1232. X        ntermio.c_cc[VMIN] = 1;
  1233. X        ntermio.c_cc[VTIME] = 0;
  1234. X        ioctl(0, TCSETA, &ntermio);     /* and activate them */
  1235. X        kbdflgs = fcntl( 0, F_GETFL, 0 );
  1236. X        kbdpoll = FALSE;
  1237. X#endif
  1238. X
  1239. X#if     V7 | BSD
  1240. Xif (tt_status==tt_open) return;
  1241. X        gtty(0, &ostate);                       /* save old state */
  1242. X        gtty(0, &nstate);                       /* get base of new state */
  1243. X        nstate.sg_flags |= RAW;
  1244. X        nstate.sg_flags &= ~(ECHO|CRMOD);       /* no echo for now... */
  1245. X        stty(0, &nstate);                       /* set mode */
  1246. X        ioctl(0, TIOCGETC, &otchars);           /* Save old characters */
  1247. X        ioctl(0, TIOCSETC, &ntchars);           /* Place new character into K */
  1248. Xtt_status=tt_open;
  1249. X#if     BSD
  1250. X        /* provide a smaller terminal output buffer so that
  1251. X           the type ahead detection works better (more often) */
  1252. X        setbuffer(stdout, &tobuf[0], TBUFSIZ);
  1253. X/*---        signal(SIGTSTP,SIG_DFL);         set signals so that we can
  1254. X        signal(SIGCONT,rtfrmshell);      suspend & restart emacs */
  1255. X#endif
  1256. X#endif
  1257. X        /* on all screens we are not sure of the initial position
  1258. X           of the cursor                                        */
  1259. X/*---   ttrow = 999;
  1260. X        ttcol = 999; */
  1261. X
  1262. X}
  1263. X
  1264. X/*
  1265. X * This function gets called just before we go back home to the command
  1266. X * interpreter. 
  1267. X * Another no-operation on CPM.
  1268. X */
  1269. Xttclose()
  1270. X{
  1271. X
  1272. X#if     AMIGA
  1273. X#if     LATTICE
  1274. X        amg_flush();
  1275. X        Close(terminal);
  1276. X#endif
  1277. X#if     AZTEC
  1278. X        amg_flush();
  1279. X        Enable_Abort = 1;       /* Fix for Manx */
  1280. X        Close(terminal);
  1281. X#endif
  1282. X#endif
  1283. X#if     CPM
  1284. X#endif
  1285. X#if     MSDOS & (HP150 == 0) & LATTICE
  1286. X        /* restore the ctrl-break interupt */
  1287. X        rg.h.ah = 0x33;                 /* control-break check dos call */
  1288. X        rg.h.al = 1;            /* set the current state */
  1289. X        rg.h.dl = 1;            /* set it ON */
  1290. X        intdos(&rg, &rg);       /* go for it! */
  1291. X#endif
  1292. X
  1293. X#if     USG
  1294. X        ioctl(0, TCSETA, &otermio);     /* restore terminal settings */
  1295. X        fcntl(0, F_SETFL, kbdflgs);
  1296. X#endif
  1297. X
  1298. X#if     V7 | BSD
  1299. Xif (tt_status==tt_close) return;
  1300. X        stty(0, &ostate);
  1301. X        ioctl(0, TIOCSETC, &otchars);   /* Place old character into K */
  1302. Xtt_status=tt_close;
  1303. X#endif
  1304. X
  1305. X
  1306. X}
  1307. X
  1308. X#if     AMIGA
  1309. Xamg_flush()
  1310. X{
  1311. X        if(scrn_tmp_p)
  1312. X                Write(terminal,scrn_tmp,scrn_tmp_p);
  1313. X        scrn_tmp_p = 0;
  1314. X}
  1315. X#endif
  1316. X
  1317. X/*
  1318. X * Flush terminal buffer. Does real work where the terminal output is buffered
  1319. X * up. A no-operation on systems where byte at a time terminal I/O is done.
  1320. X */
  1321. Xttflush()
  1322. X{
  1323. X#if     AMIGA
  1324. X        amg_flush();
  1325. X#endif
  1326. X
  1327. X#if     CPM
  1328. X#endif
  1329. X
  1330. X#if     MSDOS
  1331. X#endif
  1332. X
  1333. X#if     V7 | USG | BSD
  1334. X        fflush(stdout);
  1335. X#endif
  1336. X}
  1337. X
  1338. X/*
  1339. X * Read a character from the terminal, performing no editing and doing no echo
  1340. X * at all.
  1341. X */
  1342. Xttgetc()
  1343. X{
  1344. X#if     AMIGA
  1345. X        char ch;
  1346. X        amg_flush();
  1347. X        Read(terminal, &ch, 1L);
  1348. X        return(255 & (int)ch);
  1349. X#endif
  1350. X#if     CPM
  1351. X        return (biosb(BCONIN, 0, 0));
  1352. X#endif
  1353. X
  1354. X#if RAINBOW
  1355. X        int Ch;
  1356. X
  1357. X        while ((Ch = Read_Keyboard()) < 0);
  1358. X
  1359. X        if ((Ch & Function_Key) == 0)
  1360. X                if (!((Ch & 0xFF) == 015 || (Ch & 0xFF) == 0177))
  1361. X                        Ch &= 0xFF;
  1362. X
  1363. X        return Ch;
  1364. X#endif
  1365. X
  1366. X#if     MSDOS & MWC86
  1367. X        return (getcnb());
  1368. X#endif
  1369. X
  1370. X#if     MSDOS & (LATTICE | MSC | TURBO | AZTEC)
  1371. X        int c;          /* character read */
  1372. X
  1373. X        /* if a char already is ready, return it */
  1374. X        if (nxtchar >= 0) {
  1375. X                c = nxtchar;
  1376. X                nxtchar = -1;
  1377. X                return(c);
  1378. X        }
  1379. X
  1380. X        /* call the dos to get a char */
  1381. X        rg.h.ah = 7;            /* dos Direct Console Input call */
  1382. X        intdos(&rg, &rg);
  1383. X        c = rg.h.al;            /* grab the char */
  1384. X        return(c & 255);
  1385. X#endif
  1386. X
  1387. X#if     V7 | BSD
  1388. X        return(127 & fgetc(stdin));
  1389. X#endif
  1390. X
  1391. X#if     USG
  1392. X        if( kbdqp )
  1393. X                kbdqp = FALSE;
  1394. X        else
  1395. X        {
  1396. X                if( kbdpoll && fcntl( 0, F_SETFL, kbdflgs ) < 0 )
  1397. X                        return FALSE;
  1398. X                kbdpoll = FALSE;
  1399. X                while (read(0, &kbdq, 1) != 1)
  1400. X                        ;
  1401. X        }
  1402. X        return ( kbdq & 127 );
  1403. X#endif
  1404. X}
  1405. EOF
  1406. chars=`wc -c < 'indexor.c-2'`
  1407. if test $chars !=    30576; then echo 'indexor.c-2' is $chars characters, should be    30576 characters!; fi
  1408. fi
  1409. exit 0
  1410.