home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume4 / tvx / part07 < prev    next >
Internet Message Format  |  1986-11-30  |  55KB
  1. From: talcott!seismo!gatech!unmvax!wampler (Bruce Wampler)
  2. Subject: tvx: 7 of 10
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 4, Issue 21
  7. Submitted by: gatech!unmvax!wampler (Bruce Wampler)
  8.  
  9. #--------CUT---------CUT---------CUT---------CUT--------#
  10. #########################################################
  11. #  TVX: File 7 of 10                                    #
  12. #                                                       #
  13. # This is a shell archive file.  To extract files:      #
  14. #                                                       #
  15. #    1)    Make a directory (like tvx) for the files.      #
  16. #    2) Write a file, such as "filen.shar", containing  #
  17. #       this archive file into the directory.           #
  18. #    3) Type "sh file.shar".  Do not use csh.           #
  19. #                                                       #
  20. #########################################################
  21. #
  22. #
  23. echo Extracting tvx_io.c:
  24. sed 's/^X//' >tvx_io.c <<\SHAR_EOF
  25. X/* ------------------------ tvx_io.c ---------------------------- */
  26. X#include "tvx_defs.ic"
  27. X#include "tvx_glbl.ic"
  28. X
  29. X#define SWITCH '-'
  30. X#define FILESEP '.'
  31. X
  32. X#ifdef MSDOS
  33. X#define TEMPEXT ".$$1"        /* name of temporary file */
  34. X#define BACKEXT ".BAK"        /* name of backup file */
  35. X#endif
  36. X
  37. X#ifdef OSCPM
  38. X#define TEMPEXT ".$$1"        /* name of temporary file */
  39. X#define BACKEXT ".BAK"        /* name of backup file */
  40. X#endif
  41. X
  42. X#ifdef GEMDOS
  43. X#define TEMPEXT ".Z1X"        /* name of temporary file */
  44. X#define BACKEXT ".BAK"        /* name of backup file */
  45. X#endif
  46. X
  47. X#ifdef UNIX
  48. X#define BACKEXT ".B"        /* name of backup file */
  49. X#endif
  50. X
  51. X    FILE *fopen();
  52. X
  53. X/* local globals (used by tv terminal driver section) */
  54. X
  55. X    static int linptr; /* common "linot" */
  56. X    static char linout[242];
  57. X
  58. X    static char stemp[FNAMESIZE+1];
  59. X
  60. X/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  61. X
  62. X    FILE IO section
  63. X
  64. X   File handling algorithm:
  65. X
  66. X    The original name specified on command line is called orig_file.
  67. X    It will remain untouched throughout the editing session.  At the
  68. X    very end (normal exit), it will be renamed to the ".BAK" name.
  69. X
  70. X    source_file is the current name of the file with source.  It will
  71. X    orignally be the same as orig_file, but may change to a generated
  72. X    scratch name depending on the operating system.  source_file is
  73. X    always the lastest fully written version of the file (like after
  74. X    file beginning, for example). 
  75. X
  76. X    work_file is the output file.  On normal exit, this is the
  77. X    file renamed to dest_file.  On buffer beginning, it will be
  78. X    moved to source_file, possibly after renameing.
  79. X    
  80. X    dest_file is the ultimate destination file.  This name is not
  81. X    actually used until the final rename on normal exit.  It is
  82. X    checked to be sure it is a valid name to be opened, however.
  83. X
  84. X   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  85. X
  86. X/* =============================>>> ABORT <<<============================= */
  87. X  abort()
  88. X  {    /* abort - close files, abort operation */
  89. X
  90. X    char rply[4];
  91. X
  92. X    tvclr();
  93. X    ask("Abort, are you sure? ",rply,1);
  94. X    if (clower(rply[0]) != 'y')
  95. X      {
  96. X    verify(1);
  97. X    return;
  98. X      }
  99. X    abort2();
  100. X  }
  101. X
  102. X/* =============================>>> ABORT2 <<<============================= */
  103. X  abort2()
  104. X  {
  105. X    clobak();
  106. X    tvclr();
  107. X
  108. X    if (!newfil)
  109. X    fclose(infile);
  110. X    if (!rdonly)
  111. X    fclose(outfile);
  112. X
  113. X    if (strcmp(orig_file,source_file) != 0)
  114. X      {
  115. X    prompt("File begin used, intermediate edits in: ");
  116. X    remark(source_file);
  117. X      }
  118. X    unlink(work_file);        /* delete the work file */
  119. X
  120. X    reset();
  121. X    quit();
  122. X  }
  123. X
  124. X/* =============================>>> FBEG   <<<============================= */
  125. X  int fbeg()
  126. X  { /* fbeg - go back to file top */
  127. X 
  128. X    SLOW int fbegv;
  129. X 
  130. X    if (rdonly)
  131. X      {
  132. X    tverrb("Can't: R/O");    /* can't do this for read only access */
  133. X    return (FALSE);
  134. X      }
  135. X
  136. X    for (wtpage(1) ; rdpage() ; wtpage(1) )    /* write out rest */
  137. X    ;
  138. X
  139. X    if ((! newfil))
  140. X      {
  141. X    fclose(infile);            /* close source_file */
  142. X      }
  143. X    if (usecz)
  144. X    fputc(ENDFILE,outfile);
  145. X
  146. X    fclose(outfile);            /* close work_file */
  147. X
  148. X/* files closed now, re-open */ 
  149. X 
  150. X    newfil = FALSE;        /* not a new file any more */
  151. X
  152. X    strcpy(source_file,work_file);    /* new source file */
  153. X    temp_name(work_file,FALSE);        /* make a new temporary name */
  154. X
  155. X    if (!(infile = fopen(source_file,FILEREAD)))
  156. X    goto l900;
  157. X    else
  158. X    ineof = FALSE;
  159. X
  160. X    unlink(work_file);            /* get rid of previous copies */
  161. X
  162. X    if (!(outfile = fopen(work_file,FILEWRITE)))
  163. X      {
  164. X    goto l900;
  165. X      }
  166. X 
  167. X    fbegv=rdpage();        /* read in new buffer */
  168. X    newscr();
  169. X    return (fbegv);
  170. X
  171. Xl900: tverrb("Error re-opening");
  172. X    return (FALSE);
  173. X  }
  174. X 
  175. X/* =============================>>> FILE_EXIT <<<============================= */
  176. X  file_exit()
  177. X  { /* close the input and output files, rename */
  178. X 
  179. X    SLOW int i;
  180. X
  181. X    if (!newfil)        /* don't close input if new file */
  182. X      {
  183. X    fclose(infile);
  184. X      }
  185. X
  186. X    while (!rdonly && !*dest_file)
  187. X      {
  188. X    remark("No name for output file has been specified.");
  189. X    prompt("Enter new name for output file: ");
  190. X    reply(dest_file,FNAMESIZE);
  191. X      }
  192. X
  193. X    if (!rdonly)    /* don't close output if read only access */
  194. X      {
  195. X    if (usecz)
  196. X        fputc(ENDFILE,outfile);
  197. X    set_mode(outfile);        /* set output mode if can */
  198. X    fclose(outfile);
  199. X
  200. X    /*    orig_file has the name to be renamed to .bak
  201. X    work_file has the file name we want to be dest_name
  202. X    */
  203. X    if (strcmp(orig_file,dest_file) == 0)    /* make backup version */
  204. X      {
  205. X        strcpy(stemp,orig_file);
  206. X#ifndef COMMA_BAK
  207. X        if ((i = rindx(stemp,FILESEP)) > 0)    /* see if extenstion */
  208. X        scopy(BACKEXT,0,stemp,i);        /* make .bak */
  209. X        else
  210. X          {
  211. X        scopy(BACKEXT,0,stemp,strlen(stemp));    /* just add on */
  212. X          }
  213. X#else
  214. X        i = rindx(orig_file,'/')+1;
  215. X        scopy(".,",0,stemp,i);
  216. X        scopy(orig_file,i,stemp,strlen(stemp));
  217. X#endif
  218. X
  219. X        unlink(stemp);            /* delete previous generation */
  220. X        ren_file(orig_file,stemp);        /* rename the file */
  221. X        if (!makebackup)            /* don't want to keep old one */
  222. X        unlink(stemp);    /* delete it if don't want backup file */
  223. X      }
  224. X
  225. X    if (strcmp(orig_file,source_file) != 0)    /* delete intermediate file */
  226. X        unlink(source_file);
  227. X
  228. X
  229. X    while (infile = fopen(dest_file,FILEREAD))    /* output exists? */
  230. X      {
  231. X        fclose(infile);
  232. X        prompt("Output file "); prompt(dest_file);
  233. X        prompt(" already exists.  Overwrite it? (y/n) ");
  234. X        ureply(stemp,1);
  235. X        if (*stemp == 'Y')
  236. X          {
  237. X        unlink(dest_file);
  238. X        break;
  239. X          }
  240. X        prompt("Enter new name for output file: ");
  241. X        reply(dest_file,FNAMESIZE);
  242. X      }
  243. X
  244. X    ren_file(work_file,dest_file);        /* finally, rename last file */
  245. X      }
  246. X
  247. X  }
  248. X
  249. X/* =============================>>> FOPENX  <<<============================= */
  250. X  fopenx(argc,argv)
  251. X  int argc;
  252. X  char *argv[];
  253. X  {  /* open the input file
  254. X    This routine picks up file name from the user, creates a backup
  255. X    version in some appropriate manner, and opens the file for input
  256. X    and output. */
  257. X 
  258. X    SLOW int iswval, iswbeg, argnum, set_ttymode;
  259. X    SLOW char ch, tmpc;
  260. X    char rply[4];
  261. X 
  262. X    usebak = logdef;        /* if useing backup log file */
  263. X
  264. X    ttymode = FALSE;        /* not in tty mode, so io ok */
  265. X    ttynext = 1000;        /* force read */
  266. X
  267. X    if (argc <= 1)
  268. X      {
  269. X    remark("Usage: tvx filename [-b -i -l -o=f -r -s -t -w -# {-z -c=f}]");
  270. X#ifdef FULLHELP
  271. X    remark("");
  272. X    starthelp();        /* print start help message */
  273. X    prompt(" Options: "); remark(VERSION);
  274. X    remark("  -[no]b : backup file   -[no]i : autoindent");
  275. X    remark("  -[no]l : make command log file");
  276. X    remark("  -o=outputfile          -r : read only");
  277. X    remark("  -s : big save buff     -[no]w : word processing mode");
  278. X    remark("  -t : tty edit mode     -# : set virtual window lines to #");
  279. X#ifdef MSDOS
  280. X    remark("  -[no]z : use control-z for end of file");
  281. X#endif
  282. X#ifdef CONFIGFILE
  283. X#ifdef MSDOS
  284. X    remark("  -c=configfile        -c : use /bin/config.tvx");
  285. X#endif
  286. X#ifdef GEMDOS
  287. X    remark("  -c=configfile        -c : use /bin/config.tvx");
  288. X#endif
  289. X#ifdef OSCPM
  290. X    remark("  -c=configfile        -c : use A:config.tvx");
  291. X#endif
  292. X#endif
  293. X#ifdef UNIX
  294. X    remark("  {options not available for unix}");
  295. X#endif
  296. X#endif
  297. X    remark("");
  298. X    reset();
  299. X    quit();
  300. X      }
  301. X
  302. X    newfil=                /* assume opening an old file */
  303. X    rdonly = FALSE;            /* assume not read only */
  304. X    makebackup = MAKE_BACKUP;        /* default value for make a backup */
  305. X    blimit = BUFFLIMIT;
  306. X 
  307. X    for (argnum = 1 ; argnum < argc ; ++argnum)
  308. X      {
  309. X    strcpy(stemp,argv[argnum]);    /* pick up the file name or switch */
  310. XREDO:
  311. X    if (stemp[0] == SWITCH)        /* switch in form "/R filename" only */
  312. X      {
  313. X        iswbeg=1;        /* start at 1 */
  314. X        iswval = TRUE;
  315. X        if (clower(stemp[1]) == 'n' && clower(stemp[2]) == 'o')
  316. X          {
  317. X        iswval = FALSE ; iswbeg = 3 ;
  318. X          }
  319. X
  320. X        ch = clower(stemp[iswbeg]);        /* get the char */
  321. X        if (ch == 'r')        /* read only access */
  322. X        rdonly=iswval;
  323. X        else if (ch == 'i')        /* auto indent */
  324. X        autoin = iswval;
  325. X        else if (ch == 'w')        /* word processing mode */
  326. X          {
  327. X        if (iswval)
  328. X            wraplm = 70;
  329. X        else
  330. X            wraplm = 0;
  331. X          }
  332. X        else if (ch == 'l')        /* log file */
  333. X        usebak = iswval;
  334. X        else if (ch == 'b')
  335. X        makebackup = iswval;    /* make a backup file */
  336. X        else if (ch == 'z')
  337. X        usecz = iswval;
  338. X        else if (ch == 'o' && (stemp[iswbeg+1] == '=' ||
  339. X          stemp[iswbeg+1] == ':'))    /* specifying output */
  340. X          {
  341. X        if (!iswval)        /* wrong order! */
  342. X          {
  343. X            remark("Bad -O= switch");
  344. X            quit();
  345. X          }
  346. X        scopy(stemp,iswbeg+2,dest_file,0);  /* remember name */
  347. X          }
  348. X#ifdef CONFIGFILE
  349. X        else if (stemp[iswbeg] == 'c' && stemp[iswbeg+1] == 0) /* default cfg */
  350. X          {
  351. X        strcpy(stemp,cfgname);
  352. X          goto REDO;
  353. X          }
  354. X        else if (stemp[iswbeg] == 'c' && (stemp[iswbeg+1] == '=' ||
  355. X          stemp[iswbeg+1] == ':'))    /* specifying config */
  356. X          {
  357. X        expand_name(&stemp[iswbeg+2]);
  358. X        if ((bkuin = fopen(&stemp[iswbeg+2],FILEREAD))==0)
  359. X          {
  360. X            remark("Can't open configuration file.");
  361. X            continue;
  362. X          }
  363. X        rdcfg(lexsym,LEXVALUES+1);
  364. X        rdcfg(synofr,20);
  365. X        rdcfg(synoto,20);
  366. X        rdcfg(funchar,50);
  367. X        rdcfg(funcmd,50);
  368. X        rdcfg(&funkey,1);
  369. X        rdcfg(&tmpc,1); autoin = (int) tmpc;
  370. X        rdcfg(&tmpc,1); ddline = (int) tmpc;
  371. X        rdcfg(&tmpc,1); dscrl = (int) tmpc;
  372. X        rdcfg(&tmpc,1); dxcase = (int) tmpc;
  373. X        rdcfg(&tmpc,1); wraplm = (int) tmpc;
  374. X        rdcfg(&tmpc,1); use_wild = (int) tmpc;
  375. X        rdcfg(&tmpc,1); usebak = (int) tmpc;
  376. X        logdef = usebak;
  377. X        rdcfg(&tmpc,1); cut_mode = (int) tmpc;
  378. X#ifdef MSDOS
  379. X        rdcfg(&tmpc,1); usecz = (int) tmpc;
  380. X#endif
  381. X#ifdef GEMDOS
  382. X        rdcfg(&tmpc,1); usecz = (int) tmpc;
  383. X#endif
  384. X        fclose(bkuin);
  385. X          }
  386. X#endif
  387. X        else if (ch == 's')    /* big save buffer */
  388. X          {
  389. X        if (!iswval)
  390. X            blimit=BUFFLIMIT;
  391. X        else
  392. X            blimit=BUFFLIMIT*3;
  393. X          }
  394. X#ifndef VTERM
  395. X        else if (ch == 't')    /* tty mode */
  396. X        set_ttymode = iswval;    /* make a backup file */
  397. X#endif
  398. X        else if (ch >= '0' && ch <= '9')    /* making a virtual window */
  399. X          {
  400. X        tvlins = atoi(&stemp[iswbeg]);    /* get virtual screen size */
  401. X        if (tvlins < 3 || tvlins > tvhardlines)    /* invalid window */
  402. X          {
  403. X            remark("Invalid window size");
  404. X            tvlins = tvhardlines;
  405. X          }
  406. X        else
  407. X          {
  408. X            ddline = (tvlins / 2) + 1;    /* fix home line */
  409. X            setdscrl();
  410. X          }
  411. X          }
  412. X        else                /* illegal switch */
  413. X          {
  414. X        prompt("Unknown switch -"); ttwt(ch);
  415. X        prompt(": Ignore and continue? (y/n) ");
  416. X        ureply(rply,1);
  417. X        if (*rply != 'Y')
  418. X          {
  419. X            reset();  quit();
  420. X          }
  421. X          }
  422. X      }
  423. X    else            /* must have a file name */
  424. X      {
  425. X        strcpy(orig_file,stemp);
  426. X      }
  427. X      }        /* end for */
  428. X 
  429. X/*    now open file properly - make copies to all 4 names */
  430. X
  431. XGETNAME:
  432. X    while (!*orig_file)
  433. X      {
  434. X        ask("Edit file? ",orig_file,FNAMESIZE);
  435. X      }
  436. X
  437. X    expand_name(orig_file);        /* expand on unix */
  438. X
  439. X    if (!(infile = fopen(orig_file,FILEREAD)))    /* can open? */
  440. X      {
  441. X        prompt("Create file "); prompt(orig_file);
  442. X        prompt("? (y/n) ");
  443. X        ureply(rply,1);
  444. X        if (*rply != 'Y')
  445. X          {
  446. X        *orig_file = 0; goto GETNAME;
  447. X          }
  448. X        if (*dest_file)
  449. X        remark("New file, -o= switch ignored");
  450. X        *dest_file = 0;
  451. X        newfil = TRUE;        /* a new file */
  452. X        rdonly = FALSE;
  453. X      }
  454. X
  455. X/* orig_file now has the name of the source file, and it might be open */
  456. X
  457. X    ineof = FALSE;
  458. X    strcpy(source_file,orig_file);    /* copy to other names */
  459. X    strcpy(work_file,orig_file);
  460. X    if (!*dest_file)        /* no -o specified */
  461. X        strcpy(dest_file,orig_file);
  462. X
  463. X
  464. X    if (!newfil)            /* not new file */
  465. X      {
  466. X        fclose(infile);        /* close orig file */
  467. X        if (!(infile = fopen(source_file,FILEREAD)))    /* re-open */
  468. X          {
  469. X        remark("Internal editor error, aborting");
  470. X        exit(100);
  471. X          }
  472. X        get_mode(infile);        /* get mode of original file */
  473. X      }
  474. X    else
  475. X      {
  476. X        *orig_file = *source_file = 0; 
  477. X      }
  478. X
  479. X/* now see if we can make an output file */
  480. X    
  481. X    if (!rdonly)
  482. X      {
  483. X        temp_name(work_file,TRUE);    /* make into a temporary name 1st time */
  484. X        if ((outfile = fopen(work_file,FILEREAD)))
  485. X          {
  486. X        /* this code is needed when the temp_name might not be
  487. X           unique - which happens when you push (^O) and try to
  488. X           edit a file with the same main name but perhaps a different
  489. X           extension - the temp file will be the same, and the child
  490. X           version of tvx will then delete the temprorary file created
  491. X           by the parent.  This can happen again if fbeg, but let's
  492. X           assume the 'y' applies forever.
  493. X        */
  494. X        fclose(outfile);    /* close up the file */
  495. X        prompt("Work file already exists: ");
  496. X        remark(work_file);
  497. X        prompt("Erase it and continue with editing? (y/n) ");
  498. X        ureply(rply,1);
  499. X        if (*rply != 'Y')
  500. X          {
  501. X            reset();
  502. X            exit(100);        /* abnormal exit */
  503. X          }
  504. X          }
  505. X
  506. X        unlink(work_file);    /* get rid if already there */
  507. X
  508. X        if (!(outfile = fopen(work_file,FILEWRITE)))
  509. X          {
  510. X        prompt("Unable to create output work file: ");
  511. X        remark(work_file);
  512. X        if (!newfil)
  513. X          {
  514. X            prompt("Continue in read only mode? (y/n) ");
  515. X            ureply(rply,1);
  516. X            if (*rply != 'Y')
  517. X              {
  518. X            fclose(infile);
  519. X            reset();
  520. X            exit(100);        /* abnormal exit */
  521. X              }
  522. X          }
  523. X        *dest_file = *work_file = 0;
  524. X        rdonly = TRUE;
  525. X          }
  526. X      }
  527. X    else
  528. X      {
  529. X        *dest_file = *work_file = 0;
  530. X      }
  531. X
  532. X    ttymode = force_tty ? TRUE : set_ttymode;    /* now safe to set ttymode */
  533. X  }
  534. X
  535. X/* =============================>>> setdscrl <<<============================= */
  536. X  setdscrl()
  537. X  {    /* compute a new value for dscrl */
  538. X
  539. X    if (dscrl == 0)
  540. X    return;            /* if already 0, don't change */
  541. X    dscrl = tvlins / 3;
  542. X    if ((ddline + dscrl) >= tvlins)    /* looks ugly if hits last line */
  543. X    dscrl--;
  544. X    if (dscrl < 0)        /* don't allow this */
  545. X    dscrl = 0;
  546. X  }
  547. X
  548. X#ifdef CONFIGFILE
  549. X/* =============================>>> RDCFG <<<============================= */
  550. X  rdcfg(toset,cnt)
  551. X  char *toset;
  552. X  int cnt;
  553. X    {    /* read cnt vals from bkuin */
  554. X
  555. X    FAST int i,val;
  556. X
  557. X    for (i = 0 ; i < cnt ; ++i)
  558. X      {
  559. X    if ((val = fgetc(bkuin)) == EOF)
  560. X     {
  561. X        remark("Invalid configuration file, aborting");
  562. X        fclose(bkuin);
  563. X        quit();
  564. X     }
  565. X    *toset++ = val;    /* replace with new commands */
  566. X      }
  567. X  }
  568. X#endif
  569. X
  570. X/* =============================>>> ADDFIL <<<============================= */
  571. X  int addfil(rw)
  572. X  int rw;
  573. X  {  /* addfil - add contents of external file to save buffer
  574. X    positive means read into buffer, negative means write save buffer */
  575. X
  576. X    SLOW int chr;
  577. X    SLOW int limit;
  578. X
  579. X    SLOW BUFFINDEX fromch;
  580. X    SLOW int i;
  581. X    SLOW FILE *f;
  582. X
  583. X    if (rw >= 0)    /* read a file */
  584. X      {
  585. X    if (!gbgcol(nxtchr))    /* gc first */
  586. X      {
  587. X        newscr();
  588. X        tverrb("No save room");
  589. X        return (FALSE);
  590. X      }
  591. X
  592. X    tvclr();
  593. X#ifdef LASL
  594. X    ask("Read external filename: ",stemp,FNAMESIZE);
  595. X#else
  596. X    ask("Yank filename: ",stemp,FNAMESIZE);
  597. X#endif
  598. X
  599. X    expand_name(stemp);            /* expand on some systems */
  600. X
  601. X    if (!(f = fopen(stemp,FILEREAD)) || !*stemp)
  602. X      {
  603. X        newscr();
  604. X#ifdef LASL
  605. X        tverrb(" Unable to open external file ");
  606. X#else
  607. X        tverrb(" Unable to open yank file ");
  608. X#endif
  609. X        return (FALSE);
  610. X     }
  611. X
  612. X    savlin=0 ; savlen=0 ; nxtsav =mxbuff ;    /* clear out save buffer */
  613. X
  614. X    limit = max(nxtchr,mxbuff/2) + ALMOSTOUT;
  615. X    do
  616. X      {
  617. X        if ((chr = getchr(f)) < 0)
  618. X          {
  619. X        newscr();
  620. X        fclose(f);
  621. X        return (TRUE);
  622. X          }
  623. X        if (chr == NEWLINE)
  624. X          {
  625. X#ifdef FILELF
  626. X        getchr(f);
  627. X#endif
  628. X        chr=ENDLINE;
  629. X        ++savlin;
  630. X          }
  631. X        *(buff+nxtsav--) = chr;
  632. X        if (nxtsav <= limit)
  633. X          {
  634. X        newscr();
  635. X        tverrb("File only partly read");
  636. X        break;
  637. X          }
  638. X      }
  639. X    while (1);
  640. X    fclose(f);
  641. X    return (TRUE);
  642. X      }
  643. X
  644. X    /* --------------- to here, then writing from save buffer --------------*/
  645. X
  646. X
  647. X    if (nxtsav==mxbuff)        /* nothing to save */
  648. X      {
  649. X     tverrb("Save buffer empty!");
  650. X    return (TRUE);
  651. X      }
  652. X
  653. X    tvclr();
  654. X    ask("Write to external filename: ",stemp,FNAMESIZE);
  655. X
  656. X    expand_name(stemp);            /* expand on some systems */
  657. X
  658. X    if (!(f = fopen(stemp,FILEWRITE)) || !*stemp)
  659. X      {
  660. X    newscr();
  661. X    tverrb(" Unable to open external file ");
  662. X    return (FALSE);
  663. X      }
  664. X
  665. X    
  666. X/*   # move down line to make space for new */
  667. X    fromch = mxbuff;        /* where taking saved stuff from */
  668. X    for (i = 0 ; i < savlin ; ++i)
  669. X      {
  670. X    for ( ; ; )        /* scan save buffer */
  671. X      {
  672. X         if ((chr = *(buff+fromch--)) == ENDLINE)
  673. X          {
  674. X        fputc(NEWLINE,f);
  675. X#ifdef FILELF
  676. X        fputc(LF,f);
  677. X#endif
  678. X        break;
  679. X          }
  680. X        else
  681. X        fputc(chr,f);
  682. X      }
  683. X      }
  684. X
  685. X    if (usecz)
  686. X    fputc(ENDFILE,f);
  687. X    fclose(f);
  688. X    newscr();
  689. X    return (TRUE);
  690. X
  691. X  }
  692. X
  693. X/*=============================>>> SCOPY  <<<================================*/
  694. X  scopy(old,oldbeg,new,newbeg)
  695. X  char old[], new[];
  696. X  int oldbeg,newbeg;
  697. X  {
  698. X    while (old[oldbeg])
  699. X    new[newbeg++]=old[oldbeg++];
  700. X    new[newbeg] = 0;
  701. X  }
  702. X
  703. X/* **************************************************************************
  704. X
  705. X    Following code is for non-unix systems
  706. X
  707. X **************************************************************************** */
  708. X#ifndef UNIX
  709. X/* =============================>>> get_mode <<<============================= */
  710. X  get_mode(f)
  711. X  FILE *f;
  712. X  {        /* gets access mode of open file f */
  713. X  }
  714. X
  715. X/* =============================>>> set_mode <<<============================= */
  716. X  set_mode(f)
  717. X  FILE *f;
  718. X  {        /* sets access mode of open file f */
  719. X  }
  720. X
  721. X/* ==========================>>> expand_name <<<============================ */
  722. X  expand_name(n)
  723. X  char *n;
  724. X  {        /* expands unix file names */
  725. X  }
  726. X
  727. X/* =============================>>> ren_file <<<=========================== */
  728. X  ren_file(old,new)
  729. X  char *old, *new;
  730. X  {
  731. X#ifndef GEMDOS
  732. X    if (rename(old,new) != 0)
  733. X      {
  734. X    prompt(old) ; prompt(" not renamed to "); remark(new);
  735. X      }
  736. X#endif
  737. X#ifdef GEMDOS
  738. X    gemdos(0x56,0,old,new);    /* can't find C version */
  739. X#endif
  740. X  }
  741. X
  742. X/* =============================>>> temp_name <<<=========================== */
  743. X  temp_name(n,first)
  744. X  char *n;
  745. X  int first;
  746. X  {
  747. X    /* generates a temporary name from n.  Depending on value of
  748. X       first, it will either add a 1 or 2 to name */
  749. X
  750. X    SLOW int i;
  751. X
  752. X    if (first)
  753. X      {
  754. X    if ((i = rindx(n,FILESEP)) > 0)    /* see if extenstion */
  755. X        scopy(TEMPEXT,0,n,i);        /* make .bak */
  756. X    else
  757. X      {
  758. X        scopy(TEMPEXT,0,n,strlen(n));    /* just add on */
  759. X      }
  760. X      }
  761. X    else
  762. X      {
  763. X    i = strlen(n);
  764. X    if (n[i-1] == '1')
  765. X        n[i-1] = '2';
  766. X    else
  767. X        n[i-1] = '1';
  768. X      }
  769. X  }
  770. X#endif
  771. X
  772. X/* **************************************************************************
  773. X
  774. X    This section is for the version supporting command logfile
  775. X    backup.  The code necessary for this version is included here,
  776. X    and may be compiled by defining VB to be a blank.
  777. X
  778. X **************************************************************************** */
  779. X 
  780. X/* =============================>>> OPNBAK <<<============================= */
  781. X  opnbak()
  782. X  { 
  783. X    /* opnbak - open the backup log file
  784. X       if VB defined as ' ', then backup version created */
  785. X 
  786. X#ifdef VB
  787. X 
  788. X    if (! usebak)
  789. X      {
  790. X    bakflg = FALSE;
  791. X    return;
  792. X      }
  793. X
  794. X    bkuout = fopen(BACKUPNAME,FILEWRITE);
  795. X    bakpos = 1;
  796. X#endif
  797. X 
  798. X  }
  799. X 
  800. X/* =============================>>> PUTBAK <<<============================= */
  801. X  putbak(chr)
  802. X  char chr;
  803. X  { /* putbak - put a character into the backup file */
  804. X 
  805. X#ifdef VB
  806. X    static char copy;
  807. X
  808. X    if (! usebak)
  809. X    return;
  810. X    copy=chr;
  811. X    if (copy < 32 || copy == '@' || copy==delkey)
  812. X      {
  813. X    fputc('@',bkuout);
  814. X    bakcrlf();
  815. X    if (copy < 32)
  816. X        copy += '@';
  817. X    else if (copy==delkey)
  818. X        copy = '?';     /* let @? be rubout */
  819. X      }
  820. X    fputc(copy,bkuout);
  821. X    bakcrlf();
  822. X#endif
  823. X  }
  824. X 
  825. X#ifdef VB
  826. X/* =============================>>> BAKCRLF <<<============================= */
  827. X  bakcrlf()
  828. X  {    /* conditionally put a cr/lf to backup file */
  829. X
  830. X    if (++bakpos > 63)
  831. X      {
  832. X    fputc(NEWLINE,bkuout);
  833. X#ifdef FILELF
  834. X    fputc(LF,bkuout);
  835. X#endif
  836. X    bakpos = 1;
  837. X      }
  838. X  }
  839. X#endif
  840. X
  841. X/* =============================>>> CLOBAK <<<============================= */
  842. X  clobak()
  843. X  {
  844. X
  845. X#ifdef VB
  846. X    if (! usebak)
  847. X    return;
  848. X    fputc(NEWLINE,bkuout);
  849. X#ifdef FILELF
  850. X    fputc(LF,bkuout);
  851. X#endif
  852. X    if (usecz)
  853. X    fputc(ENDFILE,bkuout);
  854. X
  855. X    fclose(bkuout);
  856. X#endif
  857. X  }
  858. X 
  859. X/* =============================>>> GETBAK <<<============================= */
  860. X  getbak(chr)
  861. X  char *chr;
  862. X  {  /* get one char from back up file if there */
  863. X
  864. X#ifdef VB
  865. X    SLOW int ich;
  866. X
  867. Xl10:
  868. X    if ((ich = getchr(bkuin)) < 0 || ich == ENDFILE)
  869. X      {
  870. Xl15:    fclose(bkuin);
  871. X    *chr=0;            /* harmless character */
  872. X    bakflg=FALSE;
  873. X    verify();
  874. X    return;
  875. X      }
  876. X    if (ich == NEWLINE)
  877. X    goto l10;
  878. X#ifdef FILELF
  879. X    if (ich == LF)
  880. X    goto l10;
  881. X#endif
  882. X    *chr=ich;
  883. X    if (ich=='@')
  884. X      {
  885. Xl20:    if ((ich = getchr(bkuin)) < 0 || ich == ENDFILE)
  886. X      {
  887. X        goto l15;
  888. X      }
  889. X    if (ich == NEWLINE)
  890. X        goto l20;
  891. X#ifdef FILELF
  892. X    if (ich == LF)
  893. X        goto l20;
  894. X#endif
  895. X    *chr=ich;
  896. X    if (ich == '?')
  897. X        *chr=delkey;
  898. X    else if (*chr != '@')
  899. X        *chr= ich - '@';
  900. X      }
  901. X#endif
  902. X  }
  903. X 
  904. X/* =============================>>> OPNATF <<<============================= */
  905. X  opnatf()
  906. X  { /* open an indirect command file */
  907. X 
  908. X#ifdef VB
  909. X
  910. X    tvclr();
  911. X 
  912. X    ask("Name of command file: ",stemp,FNAMESIZE);
  913. X        /* read in the file name from the terminal */
  914. X
  915. X    expand_name(stemp);
  916. X
  917. X    if (!*stemp)
  918. X      {
  919. X    verify();
  920. X    return;
  921. X      }
  922. X
  923. X    if (!(bkuin = fopen(stemp,FILEREAD)))
  924. X      {
  925. X    verify();
  926. X    tverrb("Bad @ name");
  927. X    return;
  928. X      }
  929. X    bakflg=TRUE;
  930. X    newscr();
  931. X#endif
  932. X  }
  933. X
  934. X/* **************************************************************************
  935. X
  936. X    This section contains code to write and read buffers of data
  937. X
  938. X **************************************************************************** */
  939. X
  940. X/* =============================>>> RDPAGE <<<============================= */
  941. X  int rdpage()
  942. X  { /* rdpage - read in file up to buffer limit
  943. X       only place text read from edited file */
  944. X 
  945. X    SLOW int chr;
  946. X    SLOW int l,newlns;
  947. X#ifdef GETSIO
  948. X    char inbuff[256];
  949. X    FAST char *bp;    /* ptr to inbuff */
  950. X    SLOW int do_read;    /* flag if need to read */
  951. X
  952. X    do_read = TRUE;    /* need to do read first time */
  953. X#endif
  954. X 
  955. X    if (newfil)        /* can't read in when a new file */
  956. X      {
  957. X    return (FALSE);
  958. X      }
  959. X    if (nxtlin > mxline || nxtchr > mxbuff-130)    /* error check */
  960. X      {
  961. X    tverrb("Lines filled ");
  962. X    return (FALSE);
  963. X      }
  964. X 
  965. X    newlns=0;            /* begin at the beginning */
  966. X
  967. X    while (mxline-nxtlin > LINELIMIT  && nxtsav-nxtchr > blimit && !ineof)
  968. X      {             /* read in while have room */
  969. X#ifdef GETSIO
  970. X    if (do_read)
  971. X      {
  972. X        if (fgets(inbuff,255,infile) == NULL)
  973. X          {
  974. X        ineof = TRUE;
  975. X        break;
  976. X          }
  977. X        do_read = FALSE;    /* a line has been read */
  978. X        bp = inbuff;    /* point to beginning of buffer */
  979. X      }
  980. X    chr = *bp++;        /* "read" the character */
  981. X#else
  982. X    if ((chr = fgetc(infile)) == EOF)
  983. X      {
  984. X        ineof = TRUE;
  985. X        break;
  986. X      }
  987. X#endif
  988. X
  989. X    if (chr == ENDFILE && usecz)
  990. X      {
  991. X        ineof = TRUE;
  992. X        break;
  993. X      }
  994. X#ifdef FILELF
  995. X    if (chr == LF)
  996. X        continue;
  997. X#endif
  998. X    *(buff+nxtchr) = BEGLINE;
  999. X    *(lines+nxtlin) = nxtchr++;
  1000. X    ++newlns ;
  1001. X        
  1002. X    while (chr != NEWLINE)        /* store a line */
  1003. X      {
  1004. X        *(buff+nxtchr++) = chr;
  1005. X#ifdef GETSIO
  1006. X        chr = *bp++;        /* "read" the character */
  1007. X#else
  1008. X        if ((chr = fgetc(infile)) == EOF)
  1009. X          {
  1010. X        ineof = TRUE;
  1011. X        break;
  1012. X          }
  1013. X#endif
  1014. X        if (chr == ENDFILE && usecz)
  1015. X          {
  1016. X        ineof = TRUE;
  1017. X        break;
  1018. X          }
  1019. X      }    /* end of while != NEWLINE */
  1020. X#ifdef GETSIO
  1021. X    do_read = TRUE;
  1022. X#endif
  1023. X
  1024. X    *(buff+nxtchr++) = ENDLINE;
  1025. X    ++nxtlin;
  1026. X      }
  1027. X
  1028. X    if (nxtlin > 1)        /* we really read something */
  1029. X      {
  1030. X    curlin=1;        /* point to top of char */
  1031. X    curchr = *(lines+1)+1;    /* point to first character */
  1032. X      }
  1033. X    return (newlns > 0) ;
  1034. X  }
  1035. X
  1036. X/* =============================>>> WTPAGE <<<============================= */
  1037. X  wtpage(whow)
  1038. X  int whow;
  1039. X  { /* wtpage - write out contents of text buffer, and clear line list */
  1040. X 
  1041. X    FAST int i;
  1042. X    FAST char *chrp;
  1043. X    SLOW char *lim;
  1044. X    SLOW int wlimit;
  1045. X#ifdef GETSIO
  1046. X    char outbuff[256];
  1047. X    FAST char *bp;    /* ptr to outbuff */
  1048. X    SLOW int buff_len;
  1049. X#endif
  1050. X 
  1051. X    if (whow < 0)        /* allow writing partial buffer */
  1052. X    wlimit = curlin - 1;
  1053. X    else
  1054. X    wlimit = nxtlin -1;
  1055. X
  1056. X    if (nxtlin <= 1 || rdonly)
  1057. X      {
  1058. X    tverr("Empty buffer");
  1059. X    goto zapb;
  1060. X      }
  1061. X
  1062. X    if (whow < 0)
  1063. X    tverr("Writing partial buffer");
  1064. X    else
  1065. X    tverr("Writing buffer");
  1066. X 
  1067. X    tvhdln();
  1068. X 
  1069. X    for (i = 1 ; i <= wlimit ; ++i)
  1070. X      {
  1071. X    chrp = buff + (*(lines+i)+1);    /* ptr to first char of line */
  1072. X#ifdef GETSIO
  1073. X    bp = outbuff;            /* pt to buffer */
  1074. X    buff_len = 0;
  1075. X    while (*chrp != ENDLINE && buff_len < 253)
  1076. X      {
  1077. X        *bp++ = *chrp++;        /* copy character */
  1078. X      }
  1079. X    *bp++ = NEWLINE;
  1080. X#ifdef FILELF
  1081. X    *bp++ = LF;
  1082. X#endif
  1083. X    *bp = 0;            /* end of string */
  1084. X    fputs(outbuff,outfile);        /* and write all at once */
  1085. X#else
  1086. X    while (*chrp != ENDLINE)
  1087. X      {
  1088. X        fputc(*chrp++, outfile);
  1089. X      }
  1090. X    fputc(NEWLINE,outfile);
  1091. X#ifdef FILELF
  1092. X    fputc(LF,outfile);
  1093. X#endif
  1094. X
  1095. X#endif
  1096. X      }
  1097. X
  1098. Xzapb:
  1099. X
  1100. X    if (whow < 0)
  1101. X      {
  1102. X    killin(-(curlin-1));    /* kill to top of buffer */
  1103. X    if (!gbgcol(nxtchr))    /* gc first */
  1104. X      {
  1105. X        newscr();
  1106. X        tverrb("Warning: no extra room created");
  1107. X        return (FALSE);
  1108. X      }
  1109. X    return (TRUE);
  1110. X      }
  1111. X    else
  1112. X      {
  1113. X    lim = buff + nxtsav;
  1114. X    for (chrp=buff ; chrp < lim ; *chrp++ = GARBAGE)
  1115. X        ;
  1116. X    tvdlin =            /* start on first line again */
  1117. X    nxtlin =            /* reset to initial state */
  1118. X    nxtchr = 1;
  1119. X    curchr =
  1120. X    curlin=0;
  1121. X    return (TRUE);
  1122. X      }
  1123. X  }
  1124. X
  1125. X/* **************************************************************************
  1126. X
  1127. X    This section contains misc. stuff likely to be operating system dependent
  1128. X
  1129. X **************************************************************************** */
  1130. X
  1131. X/* ===========================>>> OPSYSTEM <<<============================== */
  1132. X  opsystem()
  1133. X  {
  1134. X#ifdef MSDOS            /* !!! cii-86 dependent */
  1135. X
  1136. X    char rp[80];
  1137. X
  1138. XMS_AGAIN:
  1139. X    tvclr();
  1140. X    ask("DOS command (any key to resume edit when done): ",rp,79);
  1141. X    remark("");
  1142. X    if (system(rp) != 0)
  1143. X      {
  1144. X        tvxy(1,1);
  1145. X    ask("Sorry, but couldn't find COMMAND.COM.",rp,1);
  1146. X      }
  1147. X    else
  1148. X      {
  1149. X    tvxy(1,1);
  1150. X    ask("",rp,1);
  1151. X    if (*rp == '!')
  1152. X       goto MS_AGAIN;
  1153. X      }
  1154. X    verify(1);
  1155. X#endif
  1156. X#ifdef UNIX
  1157. X    unix_sys();
  1158. X#endif
  1159. X#ifdef GEMDOS
  1160. X    return;
  1161. X#endif
  1162. X  }
  1163. X
  1164. X#ifndef UNIX
  1165. X/* ===========================>>> TTINIT <<<============================== */
  1166. X  ttinit()
  1167. X  { /*  this routine could be used to set up keyboard input, perhaps
  1168. X    turning on non-echoed input */
  1169. X    return;
  1170. X  }
  1171. X
  1172. X/* ===========================>>> TTCLOS <<<============================== */
  1173. X  ttclos()
  1174. X  {  /* this routine could undo anything ttinit() did */
  1175. X    return;
  1176. X  }
  1177. X#endif
  1178. X
  1179. X#ifndef VTERM
  1180. X/* ===========================>>> TTRD <<<============================== */
  1181. X  ttrd()
  1182. X  { /* this routine is called to read one unechoed char from the keyboard */
  1183. X
  1184. X  static int tc, i;
  1185. X  static char chr;
  1186. X
  1187. XRDTOP:
  1188. X    if (ttymode)
  1189. X    tc = rdtty();        /* get a char from the tty */
  1190. X    else
  1191. X      {
  1192. X
  1193. X#ifdef OSCPM
  1194. X    while (!(tc = bdos(6,-1)))        /* cp/m implementation */
  1195. X    ;
  1196. X#endif
  1197. X#ifdef MSDOS
  1198. X    tc = bdos(7,-1);        /* ms-dos implementation  (!!! cii-86) */
  1199. X#endif
  1200. X#ifdef GEMDOS
  1201. X    tc = gemdos(7);        /* GEMDOS application */
  1202. X#endif
  1203. X#ifdef UNIX
  1204. X    tc = ttrd_unix();
  1205. X#endif
  1206. X       }
  1207. X
  1208. X    chr = tc & 0377;
  1209. X
  1210. X    if (chr == funkey)            /* function key */
  1211. X      {
  1212. X    if (ttymode)
  1213. X      {
  1214. X        tc = rdtty();        /* get a char from the tty */
  1215. X      }
  1216. X    else
  1217. X      {
  1218. X#ifdef OSCPM
  1219. X    while (!(tc = bdos(6,-1)))        /* cp/m implementation */
  1220. X        ;
  1221. X#endif
  1222. X#ifdef MSDOS
  1223. X    tc = bdos(7,-1);        /* ms-dos implementation */
  1224. X#endif
  1225. X#ifdef GEMDOS
  1226. X    tc = gemdos(7);        /* GEMDOS application */
  1227. X#endif
  1228. X#ifdef UNIX
  1229. X    tc = ttrd_unix();
  1230. X#endif
  1231. X      }
  1232. X    chr = tc & 0377;
  1233. X    for (i = 0 ; i < 50 && funchar[i] ; ++i)
  1234. X      {
  1235. X        if (chr == funchar[i])
  1236. X          {
  1237. X        tc = funcmd[i] & 0377;
  1238. X        return (tc);
  1239. X          }
  1240. X      }
  1241. X    goto RDTOP;            /* ignore invalid function keys */
  1242. X      }
  1243. X    tc = chr & 0377;
  1244. X    return (tc);
  1245. X
  1246. X  }
  1247. X#endif
  1248. X
  1249. X#ifndef UNIX
  1250. X/* ===========================>>> TTWT <<<============================== */
  1251. X  ttwt(chr)
  1252. X  char chr;
  1253. X  { /*  this routine is called to write one char to the keyboard
  1254. X    It also interprets print direction */
  1255. X
  1256. X    if (ttymode)
  1257. X    return;
  1258. X    dispch(chr);    /* cp/m, ms-dos version */
  1259. X    if (useprint)
  1260. X    printc(chr);
  1261. X  }
  1262. X#endif
  1263. X
  1264. X#ifdef MSDOS
  1265. X#define DEFGETCHR
  1266. X#endif
  1267. X
  1268. X#ifdef OSCPM
  1269. X#define DEFGETCHR
  1270. X#endif
  1271. X
  1272. X#ifdef GEMDOS
  1273. X#define DEFGETCHR
  1274. X#endif
  1275. X
  1276. X#ifdef DEFGETCHR
  1277. X/* ===========================>>> GETCHR <<<============================== */
  1278. X  getchr(filnum)
  1279. X  FILE *filnum;
  1280. X  {  /* get a character from filnum */
  1281. X
  1282. X#define EOFBYTE 26
  1283. X
  1284. X    FAST int ichr;
  1285. X
  1286. X    if (((ichr = fgetc(filnum)) == EOFBYTE))
  1287. X      {
  1288. X    if (usecz)
  1289. X        return (EOF);
  1290. X      }
  1291. X
  1292. X    return (ichr);
  1293. X  }
  1294. X#endif
  1295. X
  1296. X/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1297. X
  1298. X    TVX TERMINAL DRIVER  for various terminals
  1299. X
  1300. X   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  1301. X 
  1302. X
  1303. X/* =============================>>> TRMINI <<<============================= */
  1304. X  trmini()
  1305. X  {  /* initialize term if necessary */
  1306. X
  1307. X    sendcs(cinit);
  1308. X    tvclr();
  1309. X  }
  1310. X
  1311. X/* =============================>>> reset <<<============================= */
  1312. X  reset()
  1313. X  {
  1314. X    sendcs(cendit);
  1315. X    ttclos();
  1316. X  }
  1317. X
  1318. X/* =============================>>> ttyverify <<<============================= */
  1319. X  ttyverify(knt)
  1320. X  int knt;
  1321. X  {
  1322. X    SLOW BUFFINDEX oldline, oldchr, limit;        /* current position */
  1323. X
  1324. X    oldline = curlin; oldchr = curchr;    /* remember where we were */
  1325. X
  1326. X    ttymode = FALSE;            /* enable output stuff */
  1327. X
  1328. X    if (knt < 0)            /* type some above */
  1329. X      {
  1330. X    curchr = 0;
  1331. X    curlin = curlin + knt ;        /* back n lines */
  1332. X    if (curlin < 1)
  1333. X       curlin = 1;
  1334. X    while (curlin < oldline)    /* write out the lines */
  1335. X        ttyline(curlin++);    /* write line, no cursor */
  1336. X      }
  1337. X    else
  1338. X      {
  1339. X    ttyline(curlin);        /* type current line */
  1340. X    curchr = 0;            /* this turns off cursor */
  1341. X    limit = oldline + knt - 1;
  1342. X    if (limit >= nxtlin)
  1343. X        limit = nxtlin - 1;
  1344. X    while (++curlin <= limit)
  1345. X        ttyline(curlin);
  1346. X      }
  1347. X    curchr = oldchr;
  1348. X    curlin = oldline;
  1349. X    ttymode = TRUE;
  1350. X  }
  1351. X
  1352. X/* =============================>>> ttyline <<<============================= */
  1353. X  ttyline(linenr,cursor)
  1354. X  BUFFINDEX linenr;
  1355. X  {
  1356. X    SLOW BUFFINDEX chrc;
  1357. X    SLOW int outlen;
  1358. X    
  1359. X    chrc = *(lines+linenr)+1;    /* point to first character in line */
  1360. X    outlen = 0;            /* nothing out yet */
  1361. X    for ( ; ; )
  1362. X      {
  1363. X    if (chrc == curchr)    /* at cursor */
  1364. X      {
  1365. X        outlen += 2;
  1366. X        if (outlen > 78)    /* line wrap */
  1367. X          {
  1368. X        remark("");
  1369. X        ttwt('_');
  1370. X        outlen = 3;
  1371. X          }
  1372. X        ttwt('/'); ttwt('\\');
  1373. X      }
  1374. X        if (*(buff+chrc) == ENDLINE)    /* done */
  1375. X        break;
  1376. X    outlen += ttywtch(*(buff+chrc));    /* watch for line wrap */
  1377. X    if (outlen > 78)
  1378. X      {
  1379. X        remark("");
  1380. X        ttwt('_');
  1381. X        outlen = 1;
  1382. X      }
  1383. X    ++chrc;            /* next character */
  1384. X      }
  1385. X    remark("");
  1386. X  }
  1387. X  
  1388. X/* =============================>>> ttywtch <<<============================= */
  1389. X  ttywtch(chr)
  1390. X  char chr;
  1391. X  {
  1392. X    if (chr >= ' ')        /* regular character */
  1393. X      {
  1394. X    ttwt(chr);
  1395. X    return 1;
  1396. X      }
  1397. X    else            /* control character */
  1398. X      {
  1399. X    ttwt('^');
  1400. X    ttwt(chr+'@');
  1401. X    return 2;
  1402. X      }
  1403. X  }
  1404. X  
  1405. X/* =============================>>> rdtty <<<============================= */
  1406. X  rdtty(knt)
  1407. X  int knt;
  1408. X  {        /* fake rdtt for ttymode - only called when in ttymode */
  1409. X
  1410. X#define RDBUFFSIZE 81
  1411. X    static char rdtbuf[RDBUFFSIZE];
  1412. X
  1413. XRDTOP:
  1414. X    ttymode = FALSE;            /* take out of ttymode for echo */
  1415. X    if (ttynext >= RDBUFFSIZE)        /* need to read a line */
  1416. X      {
  1417. X    if (ins_mode)            /* different prompts for modes */
  1418. X        prompt("+");
  1419. X    else
  1420. X        prompt("tvx>");
  1421. X    reply(rdtbuf,80);        /* read a line */
  1422. X    ttynext = 0;            /* reset pointer */
  1423. X      }
  1424. X    ttymode = TRUE;            /* no echo again */
  1425. X    if (rdtbuf[ttynext] == 0)        /* end of buffer */
  1426. X      {
  1427. X    ttynext = 1000;
  1428. X    if (ins_mode)
  1429. X        return (CR);        /* return a carriage return for ins */
  1430. X    else
  1431. X        goto RDTOP;            /* read another line */
  1432. X      }
  1433. X    else
  1434. X      {
  1435. X    return (rdtbuf[ttynext++]);    /* return character */
  1436. X      }
  1437. X  }
  1438. X
  1439. X/* =============================>>> TVPLIN <<<============================= */
  1440. X  tvplin(chrptr)
  1441. X  BUFFINDEX chrptr;
  1442. X  { /* tvplin - put line beginning at chrptr
  1443. X        will only type what will fit on screen (using xout) */
  1444. X 
  1445. X    SLOW char tmp;
  1446. X    SLOW int linlen, origx;
  1447. X    SLOW BUFFINDEX i;
  1448. X 
  1449. X#ifdef ULBD
  1450. X    SLOW int ul, bd, useul, usebd;
  1451. X
  1452. X    ul = bd = useul = usebd = FALSE;
  1453. X#endif
  1454. X
  1455. X    last_col_out = linptr = 0;
  1456. X    origx = xoutcm;            /* save x so can get true linelen */
  1457. X    for (i=chrptr; *(buff+i)!=ENDLINE && xoutcm <= 240; ++i)
  1458. X      {
  1459. X#ifdef NO_EXTEND_CHAR
  1460. X    if ((*(buff+i) < ' ' && *(buff+i) >= 0) || (*(buff+i) & 0x80) )
  1461. X        /* control character? */
  1462. X#else
  1463. X    if (*(buff+i)<' ' && *(buff+i) >= 0)    /* control character? */
  1464. X#endif
  1465. X      {
  1466. X        if (*(buff+i) == TAB)
  1467. X          {
  1468. X        if (tabspc > 0)
  1469. X          {
  1470. X            do 
  1471. X              {
  1472. X            linout[linptr++] = ' ';    /* replace with blanks */
  1473. X            ++xoutcm;
  1474. X              }
  1475. X            while ( ((xoutcm-1) % tabspc) != 0);
  1476. X          }
  1477. X        else
  1478. X          {
  1479. X            linout[linptr++] = '^';
  1480. X            linout[linptr++] = 'I';
  1481. X            xoutcm += 2;
  1482. X          }
  1483. X        continue;
  1484. X          }
  1485. X        else        /*  other control character */
  1486. X          {
  1487. X        linout[linptr++] = (*(buff+i) & 0x80) ? '~' : '^';
  1488. X        ++xoutcm;
  1489. X        if (xoutcm==tvcols && *(buff+i) != ENDLINE)
  1490. X            continue;
  1491. X
  1492. X/*  #$$$    ascii machines!!!! */
  1493. X        tmp = *(buff+i);
  1494. X        if ((tmp &= 0x7f) < ' ')    /* ok to mix extended, ctrl */
  1495. X            tmp += '@';
  1496. X        linout[linptr++]=tmp;
  1497. X
  1498. X#ifdef ULBD
  1499. X        if ( *(buff+i)==TOGUNDERLINE && cundlb[0] != 0)
  1500. X          {
  1501. X            if (ul)
  1502. X              {
  1503. X            strcopy(cundle,0,linout,&linptr);
  1504. X            ul = FALSE;
  1505. X              }
  1506. X            else
  1507. X              {
  1508. X            strcopy(cundlb,0,linout,&linptr);
  1509. X            useul = TRUE;
  1510. X            ul = TRUE;
  1511. X              }
  1512. X          }
  1513. X        if (*(buff+i) == TOGBOLD && cboldb[0] != 0)
  1514. X          {
  1515. X            if (bd)
  1516. X              {
  1517. X            strcopy(cbolde,0,linout,&linptr);
  1518. X            bd = FALSE;
  1519. X              }
  1520. X            else
  1521. X              {
  1522. X            strcopy(cboldb,0,linout,&linptr);
  1523. X            usebd = TRUE;
  1524. X            bd = TRUE;
  1525. X              }
  1526. X          }
  1527. X#endif          
  1528. X          }
  1529. X      } /*# end if control character */
  1530. X    else 
  1531. X      {
  1532. X        linout[linptr++] = *(buff+i);
  1533. X      }
  1534. X    ++xoutcm;
  1535. X      }
  1536. X
  1537. X    if (*(buff+chrptr-1)==BEGLINE)        /* write whole line */
  1538. X      {
  1539. X    last_col_out = linlen = min(tvcols,linptr-leftmg+1);
  1540. X    if (linlen > 0)
  1541. X      {
  1542. X        tvlout(&linout[leftmg-1],linlen);
  1543. X      }
  1544. X      }
  1545. X    else
  1546. X      {
  1547. X    linlen = min(tvcols-origx+1,linptr);
  1548. X    last_col_out = linlen + origx - 1;
  1549. X    if (linlen > 0)
  1550. X        tvlout(linout,linlen);
  1551. X      }
  1552. X#ifdef ULBD
  1553. X    if (useul)
  1554. X    sendcs(cundle);
  1555. X    if (usebd)
  1556. X    sendcs(cbolde);
  1557. X#endif
  1558. X    
  1559. X  }
  1560. X 
  1561. X/* =============================>>> TVLOUT <<<============================= */
  1562. X  tvlout(chrbuf,lenbuf)
  1563. X  char chrbuf[];
  1564. X  int lenbuf;
  1565. X  {  /* tvlout - intercepts tvcout calls to use line I/O */
  1566. X 
  1567. X    if (!(echof && !bakflg))
  1568. X    return;
  1569. X    ttwtln(chrbuf,lenbuf);    /* write out whole line */
  1570. X  }
  1571. X 
  1572. X/* =============================>>> TVTYPE <<<============================= */
  1573. X  tvtype(ibeg,icnt)
  1574. X  int ibeg,icnt;
  1575. X  { /* tytype - type icnt lines starting at lines[ibeg]
  1576. X        no cr/lf on the last line */
  1577. X 
  1578. X    FAST int i,lim;
  1579. X    SLOW BUFFINDEX start;
  1580. X 
  1581. X    if (!echof)
  1582. X    return;
  1583. X    xoutcm=tvx;
  1584. X    lim = ibeg+icnt-1;
  1585. X
  1586. X    for (i = ibeg ; i<=lim && i<nxtlin ; ++i)
  1587. X      {
  1588. X    start = (*(lines+i))+1;
  1589. X    tvplin(start);    /* type out a line */
  1590. X    xoutcm=1;
  1591. X    if (celin[0] && last_col_out < tvcols)
  1592. X        tvelin();    /* erase rest of line */
  1593. X    if ( i != lim )
  1594. X      {
  1595. X        tvcout(CR);
  1596. X#ifdef USELF
  1597. X        tvcout(LF);
  1598. X#endif
  1599. X      }
  1600. X      }
  1601. X#ifdef SCR_BUF
  1602. X    ttflush();
  1603. X#endif
  1604. X  }
  1605. X
  1606. X/* =============================>>> SCRPRINT <<<============================= */
  1607. X  scrprint()
  1608. X  {    /* print screen on printer */
  1609. X
  1610. X#ifndef UNIX
  1611. X 
  1612. X   SLOW beg, cnt;
  1613. X
  1614. X    tvclr();        /* clear screen first */
  1615. X    finddl(&beg, &cnt);
  1616. X    useprint = TRUE;    /* enable printing */
  1617. X    tvtype(beg,cnt);    /* and display/print */
  1618. X    printc(CR);        /* force closing cr/lf */
  1619. X#ifdef USELF
  1620. X    printc(LF);
  1621. X#endif
  1622. X    useprint = FALSE;
  1623. X#endif
  1624. X    verify(1);        /* reset screen */
  1625. X  }
  1626. X 
  1627. X/* =============================>>> VERIFY <<<============================= */
  1628. X  verify(knt)
  1629. X  int knt;
  1630. X  { /* verify - rewrite the screen or type current line with cursor */
  1631. X
  1632. X    SLOW int xf;
  1633. X 
  1634. X    if (ttymode)
  1635. X    ttyverify(knt);
  1636. X    else
  1637. X      {
  1638. X    newscr();
  1639. X    xf = findx();
  1640. X    tvxy(xf,tvy);    /* reset cursor to current position */
  1641. X      }
  1642. X#ifdef SCR_BUF
  1643. X    ttflush();
  1644. X#endif
  1645. X  }
  1646. X
  1647. X/* =============================>>> CSRCMD <<<============================= */
  1648. X  csrcmd()
  1649. X  {
  1650. X    ins_mode = FALSE;        /* let world know in command mode */
  1651. X    sendcs(ccsrcm);
  1652. X#ifdef SCR_BUF
  1653. X    ttflush();
  1654. X#endif
  1655. X  }
  1656. X
  1657. X/* =============================>>> CSRINS <<<============================= */
  1658. X  csrins()
  1659. X  {
  1660. X    SLOW int oldx,oldy,oldxot;
  1661. X
  1662. X    ins_mode = TRUE;        /* in insert mode */
  1663. X    sendcs(ccsrin);
  1664. X
  1665. X    if (tvdlin != tvhardlines)
  1666. X      {
  1667. X        oldx = tvx; oldy = tvy; oldxot = xoutcm;
  1668. X    tvmsg("### Insert Mode ###",FALSE);
  1669. X    tvxy(oldx,oldy);
  1670. X    xoutcm = oldxot;
  1671. X      }
  1672. X#ifdef SCR_BUF
  1673. X    ttflush();
  1674. X#endif
  1675. X  }
  1676. X  
  1677. X/* **************************************************************************
  1678. X
  1679. X   tv screen primitives follow
  1680. X
  1681. X*************************************************************************** */
  1682. X 
  1683. X/* =============================>>> TVBOTB <<<============================= */
  1684. X  tvbotb(n)
  1685. X  int n;
  1686. X  {  /* tvbotb - make n blank lines at the bottom of the screen */
  1687. X 
  1688. X    FAST int i,j;
  1689. X 
  1690. X/*  All versions  control sequences */
  1691. X 
  1692. X    if (n >= tvlins)
  1693. X      {
  1694. X    tvclr();
  1695. X      }
  1696. X    else 
  1697. X      {
  1698. X    tvxy(1,tvhardlines);    /* go to real last line */
  1699. X    for (i = 1 ; i <= n ; ++i)    /* and write n blank lines */
  1700. X      {
  1701. X        sendcs(cbotb);
  1702. X        if (dsp_mem)
  1703. X        tvelin();    /* might scroll non-blank line */
  1704. X      }
  1705. X    j=tvlins-n+1;    /* home to virtual last line */
  1706. X    tvxy(1,j);    /* position at first new blank line */
  1707. X      }
  1708. X#ifdef SCR_BUF
  1709. X    ttflush();
  1710. X#endif
  1711. X  }
  1712. X 
  1713. X/* =============================>>> TVCLR  <<<============================= */
  1714. X  tvclr()
  1715. X  {  /* tvclr - clear the entire screen and home */
  1716. X 
  1717. X    if (cclears[0])
  1718. X    sendcs(cclears);
  1719. X    else
  1720. X      {
  1721. X    tvxy(1,1);
  1722. X    tvescr();
  1723. X      }
  1724. X#ifdef SCR_BUF
  1725. X    ttflush();
  1726. X#endif
  1727. X  }
  1728. X 
  1729. X/* =============================>>> TVCOUT <<<============================= */
  1730. X  tvcout(chr)
  1731. X  char chr;
  1732. X  {  /* tvcout - send one character to the terminal */
  1733. X 
  1734. X    if (echof && !bakflg)
  1735. X    ttwt(chr);
  1736. X  }
  1737. X 
  1738. X/* =============================>>> TVELIN <<<============================= */
  1739. X  tvelin()
  1740. X  {  /* tvelin - erase the rest of the current line */
  1741. X 
  1742. X    sendcs(celin);
  1743. X  }
  1744. X 
  1745. X/* =============================>>> TVESCR <<<============================= */
  1746. X  tvescr()
  1747. X  {  /* tvescr - erase from current cursor position to end of screen */
  1748. X 
  1749. X    SLOW int oldx,oldy;
  1750. X    FAST int i;
  1751. X
  1752. X    if (cescr[0])
  1753. X    sendcs(cescr);
  1754. X    else
  1755. X      {
  1756. X    oldx = tvx ; oldy = tvy ;
  1757. X    tvelin();
  1758. X    for (i = oldy+1 ; i <= tvhardlines ; ++i)
  1759. X      {
  1760. X        tvxy(1,i);
  1761. X        tvelin();
  1762. X      }
  1763. X    tvxy(oldx,oldy);
  1764. X      }
  1765. X  }
  1766. X 
  1767. X/* =============================>>> TVINSL <<<============================= */
  1768. X  tvinsl()
  1769. X  {  /* tvinsl - insert line, handle virtual screen size */
  1770. X 
  1771. X    SLOW int oldx,oldy;
  1772. X    FAST int i;
  1773. X
  1774. X    oldx = tvx ; oldy = tvy ;
  1775. X    sendcs(ciline);
  1776. X    if (tvlins != tvhardlines)
  1777. X      {
  1778. X    tvxy(1,tvlins+1);    /* kill scrolled down line */
  1779. X    tvelin();
  1780. X    tvxy(oldx,oldy);
  1781. X      }
  1782. X  }
  1783. X 
  1784. X/* =============================>>> TVTOPB <<<============================= */
  1785. X  tvtopb(n)
  1786. X  int n;
  1787. X  {  /* tvtopb - create n blank lines at the top of the screen */
  1788. X 
  1789. X    FAST int i;
  1790. X
  1791. X    if (! ctopb[0])
  1792. X    return;
  1793. X    tvxy(1,1);        /* home first */
  1794. X    if ( n >= tvlins)
  1795. X    tvescr();    /* simply erase the screen */
  1796. X    else
  1797. X      {
  1798. X    for (i = 1 ; i <= n ; ++i)
  1799. X      {
  1800. X        sendcs(ctopb);
  1801. X        if (dsp_mem)        /* non blank line might be scrolled */
  1802. X        tvelin();
  1803. X      }
  1804. X    if (tvlins != tvhardlines)
  1805. X      {
  1806. X        tvxy(1,tvlins+1);    /* kill scrolled down line */
  1807. X        tvelin();
  1808. X        tvxy(1,1);
  1809. X      }
  1810. X      }
  1811. X  }
  1812. X 
  1813. X/* =============================>>> TVXY   <<<============================= */
  1814. X  tvxy(ix,iy)
  1815. X  int ix,iy;
  1816. X  {  /* tvxy - position cursor at position x,y 
  1817. X        x=0 is left most column
  1818. X        y=0 is top most line    */
  1819. X 
  1820. X#ifdef TERMCAP            /* TERMCAP different */
  1821. X
  1822. X    tvx=ix;
  1823. X    tvy=iy;
  1824. X    tcapxy(ix,iy);        /* call termcap version of xy */
  1825. X
  1826. X#else                /* generic version of tvxy */
  1827. X
  1828. X    SLOW int x,y, coord1, coord2;
  1829. X    FAST int i;
  1830. X    SLOW char chrrep[4];
  1831. X 
  1832. X    x = min(ix+addx,tvcols+addx);    /* column is addx */
  1833. X    y = iy+addy;            /* same for row */
  1834. X    tvx = ix;
  1835. X    tvy = iy;
  1836. X
  1837. X    sendcs(cxybeg);        /* opening control sequence */
  1838. X    if (cxy1st == 'l')
  1839. X      {
  1840. X    coord1 = y ; coord2 = x;
  1841. X      }
  1842. X    else
  1843. X      {
  1844. X    coord1 = x ; coord2 = y;
  1845. X      }
  1846. X
  1847. X    if (cxychr)
  1848. X      {
  1849. X    itoa(coord1,chrrep);
  1850. X    sendcs(chrrep);
  1851. X      }
  1852. X    else
  1853. X    tvcout(coord1);
  1854. X
  1855. X    sendcs(cxymid);        /* middle control sequence */
  1856. X
  1857. X    if (cxychr)
  1858. X      {
  1859. X    itoa(coord2,chrrep);
  1860. X    sendcs(chrrep);
  1861. X      }
  1862. X    else
  1863. X    tvcout(coord2);
  1864. X
  1865. X    sendcs(cxyend);        /* send terminating sequence */
  1866. X
  1867. X#endif                /* end of gerneric version */
  1868. X  }
  1869. X
  1870. X/* =============================>>> SENDCS <<<============================= */
  1871. X  sendcs(cs)
  1872. X  char cs[];
  1873. X  {    /* send a control sequencs to terminal */
  1874. X
  1875. X    FAST int i;
  1876. X
  1877. X#ifndef UNIX
  1878. X
  1879. X    for (i = 0 ; cs[i] ; ++i)
  1880. X    tvcout(cs[i]);
  1881. X#else                /* unix version */
  1882. X
  1883. X#ifdef TERMCAP            /* termcap uses special output */
  1884. X    tcapcs(cs);            /* send control string to termcap */
  1885. X#else
  1886. X    i = strlen(cs);
  1887. X    tvlout(cs,i);
  1888. X#endif                /* terminal specific unix version */
  1889. X
  1890. X#endif                /* end of unix version */
  1891. X  
  1892. X  }
  1893. X
  1894. X/* =============================>>> GKBD   <<<============================= */
  1895. X  gkbd(chr)
  1896. X  char *chr;
  1897. X  {  /* gkbd - get one character from the keyboard */
  1898. X 
  1899. X#ifdef VB
  1900. X    if (!bakflg)
  1901. X      {
  1902. X#endif
  1903. X    do 
  1904. X      {
  1905. X        *chr = ttrd();    /* read only if non-backup version */
  1906. X      }
  1907. X    while (*chr == 0);    /* ignore EOS character */
  1908. X#ifdef VB
  1909. X      }
  1910. X    else
  1911. X    getbak(chr);
  1912. X    putbak(*chr);    /* save to backup file */
  1913. X#endif
  1914. X  }
  1915. X
  1916. X#ifndef UNIX
  1917. X/* =============================>>> TTWTLN <<<============================= */
  1918. X  ttwtln(chrbuf,len)
  1919. X  char chrbuf[];
  1920. X  int len;
  1921. X  {  /*  write one line to terminal, generic version, unix uses its own */
  1922. X 
  1923. X    FAST int i;
  1924. X
  1925. X#ifndef GEMDOS
  1926. X    for (i = 0 ; i < len ; i++)
  1927. X    ttwt(chrbuf[i]);
  1928. X#else
  1929. X    char oldc;
  1930. X    oldc = chrbuf[len];        /* I'm not sure just who calls ttwtln */
  1931. X    chrbuf[len] = 0;        /* so be safe, be sure 0 terminated */
  1932. X    gemdos(9,chrbuf);        /* gemdos write line to terminal */
  1933. X    chrbuf[len] = oldc;        /* restore, just in case */
  1934. X#endif
  1935. X  } 
  1936. X#endif
  1937. X
  1938. X#ifdef OSCPM
  1939. X/* ===========================>>> DISPCH <<<============================== */
  1940. X  dispch(chr)
  1941. X  char chr;
  1942. X  {
  1943. X
  1944. X    bdos(2,chr);    /* cp/m, ms-dos version */
  1945. X  }
  1946. X/* =============================>>> USER_1 <<<============================= */
  1947. X  user_1(knt)
  1948. X  int knt;
  1949. X  {
  1950. X    return (TRUE);
  1951. X  }
  1952. X
  1953. X/* =============================>>> USER_2 <<<============================= */
  1954. X  user_2(knt)
  1955. X  int knt;
  1956. X  {
  1957. X    return (TRUE);
  1958. X  }
  1959. X#endif
  1960. X
  1961. X#ifdef MSDOS
  1962. X#ifndef IBMPC
  1963. X/* ===========================>>> DISPCH <<<============================== */
  1964. X  dispch(chr)
  1965. X  char chr;
  1966. X  {
  1967. X
  1968. X    bdos(2,chr);    /* cp/m, ms-dos version */
  1969. X  }
  1970. X#endif
  1971. X/* =============================>>> USER_1 <<<============================= */
  1972. X  user_1(knt)
  1973. X  int knt;
  1974. X  {
  1975. X    return (TRUE);
  1976. X  }
  1977. X
  1978. X/* =============================>>> USER_2 <<<============================= */
  1979. X  user_2(knt)
  1980. X  int knt;
  1981. X  {
  1982. X    return (TRUE);
  1983. X  }
  1984. X#endif
  1985. X
  1986. X#ifdef GEMDOS
  1987. X/* ===========================>>> DISPCH <<<============================== */
  1988. X  dispch(chr)
  1989. X  char chr;
  1990. X  {
  1991. X
  1992. X    gemdos(2,chr);    /* cp/m, ms-dos version */
  1993. X  }
  1994. X
  1995. X/* =============================>>> USER_1 <<<============================= */
  1996. X  user_1(knt)
  1997. X  int knt;
  1998. X  {
  1999. X    /* toggle screen res */
  2000. X
  2001. X    if (tvhardlines > 25)    /* already in 50 line mode */
  2002. X      {
  2003. X    if (rez25())        /* make sure not color */
  2004. X      {
  2005. X        tvhardlines = tvlins = 25;
  2006. X        ddline = 13;
  2007. X      }
  2008. X      }
  2009. X    else            /* in 25 line mode */
  2010. X      {
  2011. X    if (rez50())        /* make sure not color */
  2012. X      {
  2013. X        tvhardlines = tvlins = 50;
  2014. X        ddline = 26;
  2015. X      }
  2016. X      }
  2017. X
  2018. X    setdscrl();            /* reset scroll region */
  2019. X    tvidefs();            /* reset defaults */
  2020. X    verify(1);
  2021. X    return (TRUE);
  2022. X  }
  2023. X
  2024. X/* =============================>>> USER_2 <<<============================= */
  2025. X  user_2(knt)
  2026. X  int knt;
  2027. X  {
  2028. X    return (TRUE);
  2029. X  }
  2030. X#endif
  2031. X/* ------------------------ tvx_io.c ---------------------------- */
  2032. SHAR_EOF
  2033. echo Extracting tvx_lib.c:
  2034. sed 's/^X//' >tvx_lib.c <<\SHAR_EOF
  2035. X/* ------------------------ tvx_lib.c ---------------------------- */
  2036. X#include "tvx_defs.ic"
  2037. X#include "tvx_glbl.ic"
  2038. X
  2039. X#ifdef COMPILESTANDARD
  2040. X#define STANDARD    /* the set of standard functions TVX use */
  2041. X#endif
  2042. X
  2043. X#define LOCAL static    /* make locals to this module */
  2044. X
  2045. X/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  2046. X
  2047. X/* following are some non-standard routines required by TVX */
  2048. X
  2049. X/* =============================>>> STCOPY <<<============================= */
  2050. X  stcopy(from, i, to, j)
  2051. X  char from[],to[];
  2052. X  BUFFINDEX i,*j;
  2053. X  { /* ## stcopy string, increment j */
  2054. X
  2055. X    BUFFINDEX k1, k2;
  2056. X 
  2057. X    k2 = *j;
  2058. X    for (k1 = i; from[k1] ; )
  2059. X      {
  2060. X    to[k2++] = from[k1++];
  2061. X      }
  2062. X    to[k2] = 0;
  2063. X    *j = k2;
  2064. X  }
  2065. X
  2066. X/* =============================>>> STRCOPY <<<============================= */
  2067. X  strcopy(from, i, to, j)
  2068. X  char from[],to[];
  2069. X  int i,*j;
  2070. X  { /* ## stcopy string, increment j */
  2071. X
  2072. X    FAST int k1, k2;
  2073. X 
  2074. X    k2 = *j;
  2075. X    for (k1 = i; from[k1] ; )
  2076. X      {
  2077. X    to[k2++] = from[k1++];
  2078. X      }
  2079. X    to[k2] = 0;
  2080. X    *j = k2;
  2081. X  }
  2082. X
  2083. X#ifndef GEMDOS
  2084. X/* =============================>>> MIN <<<============================= */
  2085. X  min(v1,v2)
  2086. X  int v1,v2;
  2087. X  {
  2088. X    return (v1 > v2 ? v2 : v1);
  2089. X  }
  2090. X
  2091. X/* =============================>>> MAX <<<============================= */
  2092. X  max(v1,v2)
  2093. X  int v1,v2;
  2094. X  {
  2095. X    return (v1 > v2 ? v1 : v2);
  2096. X  }
  2097. X#endif
  2098. X
  2099. X/*=============================>>> CLOWER  <<<================================*/
  2100. X  char clower(ch)
  2101. X  char ch;
  2102. X  {
  2103. X    return ((ch >='A' && ch<='Z') ? ch + ' ' : ch);
  2104. X  }
  2105. X
  2106. X/*=============================>>> CUPPER  <<<================================*/
  2107. X  char cupper(ch)
  2108. X  char ch;
  2109. X  {
  2110. X    return ((ch >= 'a' && ch <= 'z') ? ch - ' ' : ch);
  2111. X  }
  2112. X
  2113. X/* =========================>>> LOWER  <<<==============================*/
  2114. X  lower(str)
  2115. X  char str[];
  2116. X  {
  2117. X    FAST int i;
  2118. X
  2119. X    for (i=0 ; str[i] ; ++i)
  2120. X    str[i]=clower(str[i]);
  2121. X
  2122. X  }
  2123. X
  2124. X/* ===========================>>> PRINTC <<<============================== */
  2125. X  printc(chr)
  2126. X  char chr;
  2127. X  { /* send one character to the printer */
  2128. X
  2129. X#ifdef MSDOS
  2130. X    bdos(5,chr);    /* cp/m, ms-dos version */
  2131. X#endif
  2132. X#ifdef OSCPM
  2133. X    bdos(5,chr);    /* cp/m, ms-dos version */
  2134. X#endif
  2135. X#ifdef GEMDOS
  2136. X    gemdos(5,chr);    /* gemdos version */
  2137. X#endif
  2138. X  }
  2139. X
  2140. X/*=============================>>> PROMPT <<<================================*/
  2141. X  prompt(msg)
  2142. X  char msg[];
  2143. X  {
  2144. X    SLOW int i;
  2145. X    i = strlen(msg);
  2146. X    ttwtln(msg,i);
  2147. X#ifdef SCR_BUF
  2148. X    ttflush();
  2149. X#endif
  2150. X  }
  2151. X
  2152. X/*=============================>>> QUIT <<<================================*/
  2153. X  quit()
  2154. X  {
  2155. X   exit(0);
  2156. X  }
  2157. X
  2158. X/*=============================>>> RINDX  <<<================================*/
  2159. X  rindx(str, c)
  2160. X  char c, str[];
  2161. X  {  /* rindx - find last occurrence character  c  in string  str */
  2162. X
  2163. X    FAST int i,j;
  2164. X 
  2165. X    j = -1;
  2166. X    for (i = 0 ; str[i] != 0; i++)
  2167. X        if (str[i] == c)
  2168. X            j = i;
  2169. X    return (j);
  2170. X  }
  2171. X
  2172. X/*=============================>>> REMARK <<<================================*/
  2173. X  remark(msg)
  2174. X  char msg[];
  2175. X  {
  2176. X    prompt(msg);
  2177. X    ttwt(CR);
  2178. X#ifdef USELF
  2179. X    ttwt(LF);
  2180. X#endif
  2181. X#ifdef SCR_BUF
  2182. X    ttflush();
  2183. X#endif
  2184. X  }
  2185. X
  2186. X/*=============================>>> UPPER  <<<================================*/
  2187. X  upper(str)
  2188. X  char str[];
  2189. X  {
  2190. X    static int i;
  2191. X
  2192. X    for (i=0 ; str[i] ; ++i)
  2193. X    str[i]=cupper(str[i]);
  2194. X  }
  2195. X
  2196. X/*=============================>>> WTINT  <<<================================*/
  2197. X  wtint(intg)
  2198. X  int intg;
  2199. X  {
  2200. X    char chrep[10];
  2201. X    itoa(intg,chrep);
  2202. X    prompt(chrep);
  2203. X  }
  2204. X
  2205. X/*=============================>>> LREPLY <<<================================*/
  2206. X  lreply(msg,maxc)
  2207. X  char msg[];
  2208. X  int maxc;
  2209. X  {
  2210. X    reply(msg,maxc);
  2211. X    lower(msg);
  2212. X  }
  2213. X
  2214. X/*=============================>>> UREPLY <<<================================*/
  2215. X  ureply(msg,maxc)
  2216. X  char msg[];
  2217. X  int maxc;
  2218. X  {
  2219. X    reply(msg,maxc);
  2220. X    upper(msg);
  2221. X  }
  2222. X
  2223. X/*=============================>>> REPLY <<<================================*/
  2224. X  reply(msg,maxc)
  2225. X  char msg[];
  2226. X  int maxc;
  2227. X  {
  2228. X#define CBS 8        /* Backspace */
  2229. X#define CDL1 21        /* ^U */
  2230. X#define CDL2 24        /* ^X */
  2231. X#define CABORT 3    /* ^C */
  2232. X#define CRET 13        /* cr */
  2233. X#define CESCAPE    27    /* ESC to allow any char to be entered */
  2234. X#define BKSPC 8
  2235. X
  2236. X    static char ch, rp;
  2237. X    static int i;
  2238. X    SLOW int oldtty;
  2239. X
  2240. X    oldtty = ttymode;
  2241. X    ttymode = FALSE;        /* change to regular mode */
  2242. X
  2243. X    for (i = 0 ; i < maxc ; )    /* i -> next char */
  2244. X      {
  2245. X    ch = ttrd_();        /* read the character */
  2246. X    if (ch == CESCAPE)    /* literal next */
  2247. X      {
  2248. X        ch = ttrd_();
  2249. X        goto ESC_CONT;
  2250. X       }
  2251. X    if (ch == CBS)        /* back space */
  2252. X      {
  2253. X        if (i > 0)        /* must be something to delete */
  2254. X          {
  2255. X        --i;        /* wipe out char */
  2256. X        ttwt(BKSPC); ttwt(' '); ttwt(BKSPC);
  2257. X        if (msg[i] < ' ')    /* double echo ^ chrs */
  2258. X          {
  2259. X            ttwt(BKSPC); ttwt(' '); ttwt(BKSPC);
  2260. X          }
  2261. X          }
  2262. X#ifdef SCR_BUF
  2263. X        ttflush();
  2264. X#endif
  2265. X      }
  2266. X#ifdef USE_WIPE
  2267. X    else if (ch == CDL1 || ch == CDL2)    /* wipe whole line */
  2268. X      {
  2269. X        i = 0;        /* set for loop ++ */
  2270. X        remark("#");
  2271. X        prompt("Re-enter? ");
  2272. X      }
  2273. X#endif
  2274. X    else if (ch == CABORT && !ins_mode)
  2275. X      {
  2276. X        remark("^C");
  2277. X        prompt("Exit to operating system - are you sure? (y/n) ");
  2278. X        rp = ttrd_();
  2279. X        if (rp == 'y' || rp =='Y')
  2280. X         {
  2281. X        remark("y");
  2282. X        reset();            /* need to reset things */
  2283. X        exit(0);
  2284. X         }
  2285. X        remark("n");
  2286. X        msg[i] = 0;
  2287. X        prompt("Re-enter? "); prompt(msg);        /* re-echo */
  2288. X      }
  2289. X    else if (ch == CRET)        /* ret, so done */
  2290. X      {
  2291. X        remark("");
  2292. X        msg[i] = 0;
  2293. X        ttymode = oldtty;
  2294. X        return;
  2295. X      }
  2296. X    else
  2297. X      {
  2298. XESC_CONT:
  2299. X        msg[i++] = ch;
  2300. X        msg[i] = 0;            /* always 0 terminate */
  2301. X        if (ch < ' ')
  2302. X          {
  2303. X        ch += '@';
  2304. X        ttwt('^');
  2305. X          }
  2306. X        ttwt(ch);            /* echo char */
  2307. X#ifdef SCR_BUF
  2308. X        ttflush();
  2309. X#endif
  2310. X      }
  2311. X      } /* end for */
  2312. X
  2313. X    ttymode = oldtty;
  2314. X    remark("");
  2315. X  }
  2316. X
  2317. X/* ============================>>> TTRD_   <<<================================ */
  2318. X  ttrd_()
  2319. X  {
  2320. X    SLOW char tc;
  2321. X#ifdef RD_FROM_CONSOLE_DIRECTLY
  2322. X#ifdef OSCPM
  2323. X    while (!(tc = bdos(6,-1)))        /* cp/m implementation */
  2324. X    ;
  2325. X#endif
  2326. X#ifdef MSDOS
  2327. X    tc = bdos(7,-1);        /* ms-dos implementation */
  2328. X#endif
  2329. X#ifdef GEMDOS
  2330. X    tc = gemdos(7);        /* ms-dos implementation */
  2331. X#endif
  2332. X#ifdef UNIX
  2333. X    tc = ttrd();
  2334. X#endif
  2335. X#else
  2336. X    gkbd(&tc);            /* this should work */
  2337. X#endif
  2338. X
  2339. X    return (tc & 0377);
  2340. X
  2341. X  }
  2342. X
  2343. X/*=============================>>> RDINT <<<================================*/
  2344. X  rdint(val)
  2345. X  int *val;
  2346. X  {
  2347. X    char chrrep[12];
  2348. X    reply(chrrep,11);
  2349. X    *val = atoi(chrrep);
  2350. X    return;
  2351. X  }
  2352. X
  2353. X/* =============================>>> ITOA   <<<============================= */
  2354. X  itoa(intg, str)
  2355. X  int intg;
  2356. X  char str[];
  2357. X  {  /* itoa - convert integer  int  to char string in  str */
  2358. X 
  2359. X    FAST int i;
  2360. X    int d, intval, j;
  2361. X    char k;
  2362. X    static char digits[] = "0123456789";
  2363. X 
  2364. X    intval = intg >= 0 ? intg : (-intg);
  2365. X    str[0] = 0;
  2366. X    i = 0;
  2367. X    do
  2368. X      {                /* generate digits */
  2369. X        i++;
  2370. X        d = intval % 10;    /* mod 10 */
  2371. X        str[i] = digits[d];
  2372. X        intval = intval / 10;
  2373. X      }
  2374. X    while (intval != 0);
  2375. X    if (intg < 0)
  2376. X      {                /* then sign */
  2377. X        str[++i] = '-';
  2378. X      }
  2379. X    for (j = 0 ; j < i ; j++ )
  2380. X      {                /* then reverse */
  2381. X        k = str[i];
  2382. X        str[i--] = str[j];
  2383. X        str[j] = k;
  2384. X      }
  2385. X  }
  2386. X
  2387. X/* ------------------------------------------------------------------------- */
  2388. X#ifdef STANDARD
  2389. X
  2390. X/* ============================>>> ATOI   <<<================================ */
  2391. X  atoi(in)
  2392. X  char in[];
  2393. X  {  /* atoi - convert string : Ascii machines! */
  2394. X 
  2395. X    FAST int i;
  2396. X    int d, val, neg;
  2397. X    
  2398. X    for (i=0 ; in[i] == ' ' || in[i] == '\t' ; i++)
  2399. X        ;
  2400. X    if (in[i] == '-')        /* look for negative */
  2401. X      {
  2402. X    i++;
  2403. X    neg=1;
  2404. X      }
  2405. X    else
  2406. X    neg=0;
  2407. X    for (val = 0; in[i] ; i++)
  2408. X      {
  2409. X    if (in[i]<'0' || in[i]>'9')
  2410. X        break;
  2411. X    d = in[i]-'0';
  2412. X        val = 10 * val + d;
  2413. X      }
  2414. X    if (neg)
  2415. X    val = (-val);
  2416. X    return (val);
  2417. X  }
  2418. X#endif
  2419. X/* ------------------------ tvx_lib.c ---------------------------- */
  2420. SHAR_EOF
  2421. echo ALL DONE!
  2422. exit 0
  2423.  
  2424.