home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / unix / volume13 / bpatch2 < prev    next >
Encoding:
Text File  |  1988-09-11  |  52.4 KB  |  2,250 lines
  1. Subject:  v13i074:  Binary patch program, ported to 80286 etc.
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: rupley!local@ARIZONA.EDU
  7. Posting-number: Volume 13, Issue 74
  8. Archive-name: bpatch2
  9.  
  10. Neat code and program.  Dump or edit files (binary or acsii), displayed by
  11. 256-byte records in side-by-side hex and ascii formats.  Various other
  12. features (eg, toggled swap within byte pairs).  I spent some time tonight
  13. getting bpatch to work well on a Vax (at least one particular Vax) running
  14. BSD4.3 with NFS.  The macros in ctype.h gave some problems.  The code
  15. attached here compiles both on Microport SysV and BSD4.3, without change,
  16. if the proper Makefile is used.  The program appears to work equally in
  17. the two environments.  I expect that there should be little problem in
  18. adjusting for other flavors of BSD or SysV.
  19.  
  20. There are two Makefiles now, for bsd and Sysv.  Small changes in README
  21. and the man pages.
  22.  
  23. John Rupley
  24.     uucp: ..{ihnp4 | hao!noao}!arizona!rupley!local
  25.     internet: rupley!local@megaron.arizona.edu
  26.     telex: 9103508679(JARJAR)
  27.     (H) 30 Calle Belleza, Tucson AZ  85716 - (602) 325-4533
  28.     (O) Dept. Biochemistry, Univ. Arizona, Tucson AZ 85721 - (602) 621-3929
  29.  
  30. ************************cut here******************************************
  31. # To unbundle, sh this file
  32. echo unbundling README 1>&2
  33. cat >README <<'AlBeRtEiNsTeIn'
  34.  
  35. BPATCH.C
  36. Original code written by Garry M. Johnson and Steven Lisk.
  37.  
  38. Neat code and program.  Dump or edit files (binary or acsii), displayed
  39. by 256-byte records in side-by-side hex and ascii formats.  Various
  40. other features (eg, toggled swap within byte pairs).
  41.  
  42. Here converted to 80286 (Microport sysV/AT). More details in bpatch.c, 
  43. under Change History.  Some of the changes also serve to fix code that 
  44. appeared to be broken even for a 32-bit environment.
  45.  
  46. Makefile.sys5 is set for Microport SysV/AT.2.2.  The code should compile 
  47. under standard SysV environments.
  48.  
  49. The man pages are changed only slightly from the original distribution.
  50.  
  51. The code compiles on a Vax running BSD4.3, with Makefile.bsd, of 
  52. course.  Testing was with an AT compatible logged in as a terminal, 
  53. with setenv TERM vt100.  There may be curses/terminal problems for 
  54. other environments.  A terminal which was an adm3a equivalent was ok.
  55.  
  56. Beware of using the shell escape feature!
  57.  
  58. Like the previous authors, I would appreciate learning of further 
  59. changes and improvements in the code:
  60.  
  61. John Rupley
  62.  uucp: ..{ihnp4 | hao!noao}!arizona!rupley!local
  63.  internet: rupley!local@megaron.arizona.edu
  64.  telex: 9103508679(JARJAR)
  65.  (H) 30 Calle Belleza, Tucson AZ 85716 - (602) 325-4533
  66.  (O) Dept. Biochemistry, Univ. Arizona, Tucson AZ 85721 - (602) 621-3929
  67.  
  68. +++++++++++++++++++++original distribution README+++++++++++++++++++++++
  69. >Herewith find BPATCH - a marvelously utile utility.  While not of
  70. >my original creation, I have been given permission to place in the
  71. >public domain.  I have made substantial modifications to the original
  72. >source given to me.  Specifically I cleaned it up a bit and made it
  73. >work with SVR2 curses.  Personally, I think it's pretty neat.
  74. >
  75. >OK - for those of you who may scream by now "WHAT THE HELL IS IT ALREADY?"
  76. >I respond that it is a binary file editor and dump utility!  That's 
  77. >right!  You can dump your file in the nicely laid out side-by-side
  78. >hex and ascii format or you can actually EDIT it at your terminal!
  79. >Yes, I have seen the BED editor that came across the network.
  80. >Unfortunately, it converted the entire file before and after editing.
  81. >Bpatch, on the other hand, works with one 256 byte page at a time.
  82. >It is marvelously useful for looking at things like raw disk UNIFY
  83. >databases and even raw disks!  While the man page may not be absolutely
  84. >up to date, the online help is.  Try the question mark (?) command.
  85. >
  86. >As always, I would love to hear about bugs/changes/enhancements/requests.
  87. >    Steven List @ Benetics Corporation, Mt. View, CA
  88. >    Just part of the stock at "Uncle Bene's Farm"
  89. >    {cdp,engfocus,idi,oliveb,opusys,plx,pyramid,tolerant}!bene!luke!itkin
  90. >
  91. >Addition by the moderator:
  92. >I have added code, surrounded by #ifdef MOD_HAX, that gets bpatch
  93. >(barely?) working on my 4.2 system.  I would be very interested in
  94. >publishing a set of diffs that's less of a hack.  Oh yeah:  I also
  95. >wrote the Makefile.
  96. >    /Rich $alz
  97. +++++++++++++++++++++end of original distribution README++++++++++++++++++++
  98. AlBeRtEiNsTeIn
  99. echo unbundling Makefile.bsd 1>&2
  100. cat >Makefile.bsd <<'AlBeRtEiNsTeIn'
  101. # This may have to change on your system.
  102. # You may have to fiddle with various combinations of curses, termcap,
  103. # terminfo, etc.  Good luck!
  104. LIBS    = -lcurses -ltermcap
  105. #LIBS    = -ltermlib
  106. #LIBS    = -lterminfo
  107. #for sysV
  108. #LIBS    = -lcurses
  109.  
  110. # However you need getopt.
  111. #GETOPT    = -lgetopt
  112. #not for sysV! (nor for some BSD)
  113. #GETOPT    =
  114.  
  115. # If you're running on a 4.[23] system, you probably want this.
  116. WORK    = -DMOD_HAX
  117. #sysV
  118. #WORK    =
  119.  
  120. #BSD or thereabouts
  121. CFLAGS    = -O $(WORK)
  122. #Microport sysV/AT, large model, for sdb debugger
  123. #CFLAGS    = -g -Ml
  124.  
  125. bpatch:        bpatch.o
  126.     $(CC) -o bpatch $(CFLAGS) bpatch.o $(GETOPT) $(LIBS)
  127.  
  128. install:
  129.     @echo Use cp to put things where you want them
  130. AlBeRtEiNsTeIn
  131. echo unbundling Makefile.sys5 1>&2
  132. cat >Makefile.sys5 <<'AlBeRtEiNsTeIn'
  133. # This may have to change on your system.
  134. # You may have to fiddle with various combinations of curses, termcap,
  135. # terminfo, etc.  Good luck!
  136. #LIBS    = -lcurses -ltermcap
  137. #LIBS    = -ltermlib
  138. #LIBS    = -lterminfo
  139. #for sysV
  140. LIBS    = -lcurses
  141.  
  142. # However you need getopt.
  143. #GETOPT    = -lgetopt
  144. #not for sysV! (nor for some BSD)
  145. #GETOPT    =
  146.  
  147. # If you're running on a 4.[23] system, you probably want this.
  148. #WORK    = -DMOD_HAX
  149. #sysV
  150. WORK    =
  151.  
  152. #BSD or thereabouts
  153. #CFLAGS    = -O $(WORK)
  154. #Microport sysV/AT, large model, for sdb debugger
  155. CFLAGS    = -g -Ml
  156.  
  157. bpatch:        bpatch.o
  158.     $(CC) -o bpatch $(CFLAGS) bpatch.o $(GETOPT) $(LIBS)
  159.  
  160. install:
  161.     @echo Use cp to put things where you want them
  162. AlBeRtEiNsTeIn
  163. echo unbundling bpatch.1 1>&2
  164. cat >bpatch.1 <<'AlBeRtEiNsTeIn'
  165. .TH "bpatch" "1" "Benetics Local"
  166. .UC 4
  167. \" .if t .nr LL 7i
  168. \" .if t .nr IN .8i
  169. \" .if n .nr LL 70
  170. \" .if n .nr IN 8
  171. \" .fi
  172. \" .ad b
  173. .SH NAME
  174. bpatch - binary patch and dump file utility
  175. .SH SYNOPSIS
  176. bpatch [ -b blksize ] [ -d ] [ -D pagecnt ] [ -e ] [ -p ] [ -r reclen ] [ -s ] [ -x ] file...
  177. .SH DESCRIPTION
  178. \fIBpatch\fR allows the viewing and/or modification of files, independent of
  179. file type (text, executable, data file, and so forth).  \fIBpatch\fR
  180. allows the data to either be examined at the terminal, dumped to a print
  181. device or file, or edited in the general manner of \fIvi(1)\fR.  The
  182. data in the file is dumped or displayed in \fIpages\fR of 256 bytes.
  183. .SS Options
  184. .IP "-b blksize" 12
  185. The \fI-b\fR option specifies the blocksize of the data file.  This is used
  186. primarily with tapes, and is allowed only with one of the dump (\fI-d\fR
  187. or \fI-D\fR) options.  When this option is specified, the file is opened
  188. in readonly mode.
  189. .IP "-d" 12
  190. The \fI-d\fR option indicates that a dump (no terminal manipulation) is
  191. to be performed.  The entire file will be dumped to standard output.  No
  192. editing of the data is allowed and the file is opened in readonly mode.
  193. <DEL> interrupts a continuous display, producing a pause after the
  194. current record is displayed; at this point, a second <DEL> exits and
  195. and other character begins display of the next file.
  196. .IP "-D pagecnt" 12
  197. The \fI-D\fR option is similar to the \fI-d\fR option, with the
  198. following exception: the pagecnt argument limits the dump to the
  199. specified number of \fIpages\fR.
  200. .IP "-e" 12
  201. The \fI-e\fR option indicates that the file contains EBCDIC data and
  202. should be converted in the character portion of the dump.
  203. .IP "-p" 12
  204. Used with one of the \fIdump\fR options, this option causes the program
  205. to pause between \fIpages\fR.  The program will then wait for the user
  206. to press either the \fIreturn\fR key to continue, or the \fIDEL\fR (or
  207. \fIrubout\fR) key to stop the dump.
  208. .IP "-r reclen" 12
  209. The \fI-r\fR option indicates the record length of the data within the
  210. dump.  When specified, this option causes \fIbpatch\fR to place a colon
  211. (:) between the last byte of one record and the first byte of the next.
  212. .IP "-s" 12
  213. This option turns on the byte swap option.  It may be toggled dynamically
  214. during execution (see \fI-x\fP under Commands below).
  215. .IP "-x" 12
  216. This option specifies the suppression of pages that contain only NUL
  217. characters.  The result is that only the page header (name and page
  218. number) will appear for such a page.  This option may only be used with
  219. one of the dump options.
  220. .SS Arguments
  221. .IP file 12
  222. Any number of files may be specified.
  223. .SS Commands
  224. All commands are valid only in the non-dump, interactive mode.  Commands
  225. may be entered in either upper or lower case.  Commands of the form '^x'
  226. indicate that the control character \fIx\fR is to be entered.
  227. .P
  228. All commands that request movement within a file or between files cannot
  229. be executed if any changes have been made.  To proceed in this case, the
  230. user must either enter the \fIw\fR command, the \fIu\fR command, or the
  231. \fIr\fR command.
  232. .P
  233. Requesting a next or previous file when there is no such will cause the
  234. issuance of an error message.
  235. .P
  236. Note that certain commands allow/require either some text or numeric
  237. value.  In those cases, the user should type in characters and end the
  238. string with either a <cr> or <DEL>.
  239. .IP ? 6
  240. Display the help screen.  The help screen will remain until the user
  241. either redraws the screen (see \fI^r\fR) or changes pages or files.
  242. .IP ! 6
  243. Execute the following command in the shell.
  244. .IP backslash 6
  245. Display the previous page.
  246. .IP <cr> 6
  247. Display the next page.
  248. .IP DEL 6
  249. Quit the program if no changes have been made.
  250. .IP / 6
  251. This command initiates an ASCII search.  The text entered on the command
  252. line will be used as a search string, and the file will be searched
  253. starting with the current page.  When the string is found, the page
  254. containing the string will be displayed.  If the string is not found, an
  255. apapropriate message will be displayed.
  256. .IP ^f 6
  257. Open a named file whose name will be entered on the command line and
  258. followed either by <cr> or DEL.
  259. .IP ^n 6
  260. Open the next file and display the first page.
  261. .IP ^p 6
  262. Open the previous file and display the first page.
  263. .IP ^q 6
  264. Quit without writing current changes.
  265. .IP ^r 6
  266. Redraw the screen.
  267. .IP NNN 6
  268. Entering a numeric value requests that the specified page be displayed.
  269. .IP -x 6
  270. Toggle the command line option represented by \fIx\fR:
  271. .RS 12
  272. .IP a 6
  273. Toggle display to ascii (assume data is ascii).
  274. .IP e 6
  275. Toggle display to dbcdic (assume data is ebcdic).
  276. .IP s 6
  277. Toggle byte swap.
  278. .RE
  279. .IP a 6
  280. Edit the ASCII display.  End edits by pressing the DEL key.  All other
  281. characters will be treated as valid input.  Cursor movement keys (arrows
  282. and home) allow movement within the edit window.  Nonprinting
  283. characters are displayed as dot (.) in this window.
  284. .IP f 6
  285. Display the first page in the current file.
  286. .IP g 6
  287. Display the page containing the byte address typed in following the command.
  288. .IP h 6
  289. Edit the HEXADECIMAL display.  End edits by pressing DEL key.  Cursor
  290. movement keys (arrows and home) allow movement within the edit window.
  291. Two keystrokes are required to modify a byte, and both must be valid
  292. hexadecimal values (0-9 and a-f).  To cancel a change after typing one
  293. character, press DEL.
  294. .IP l 6
  295. Display the last page in the current file.
  296. .IP q 6
  297. Quit the file.  A warning will be issued if any changes have been made
  298. but not written out.
  299. .IP r 6
  300. Reread the current page.
  301. .IP u 6
  302. Undo all changes to the current page.
  303. .IP w 6
  304. Write out the current page.
  305. .SH "SEE ALSO"
  306. od(1)
  307. AlBeRtEiNsTeIn
  308. echo unbundling bpatch.c 1>&2
  309. cat >bpatch.c <<'AlBeRtEiNsTeIn'
  310. /*T bpatch - A binary file patch/dump utility */
  311. /*S Introduction */
  312. /*F bpatch ***********************************************************
  313. * bpatch
  314. * by Garry M Johnson - 09/17/84
  315. * (C) Copyright 1984, 1985
  316. *
  317. * Change History:
  318. *
  319. * 11/29/87 - PORT TO 80286 SYSTEM (MICROPORT SYSV/AT, 2.2)
  320. * 
  321. * -> sorted out nonportable int -ne char *  and int -ne long (ever-
  322. * annoying problems for the 286); the changes should not have broken 
  323. * the code for 32-bit int -eq char *  machines; indeed, some of the 
  324. * changes fix apparently broken code
  325. * -> calls to outstr() now pass only a string address; where values are to 
  326. * be displayed, they are entered into the string with a prior 
  327. * sprintf(); 
  328. * -> calls to errmsg() handled as for outstr(), except there is a second 
  329. * parameter, "sleep_time", to specify the length of a sleep after message 
  330. * display; this is *not* implemented; call of sleep dumps core -- signal 
  331. * handling problem??
  332. * -> after "windowed" is set, forced all exit()'s into passing first 
  333. * through reset() and likewise everywhere follow reset() with immediate 
  334. * exit()
  335. * -> in the segment following "not interactive - keep dumping ...",
  336. * repaired broken code that controlled flow for the -d and -D options;
  337. * allow DEL interrupt of continuous dump of long file, in order to 
  338. * quit or go to next file
  339. * -> in reset(), ioctl'd terminal to be as at entry
  340. * -> in arrow(), added vi-like cursor control
  341. * -> cleaned up code for formats where specification did not agree with
  342. * declared type for variable; same for function parameter lists; checked 
  343. * casts and conversions to/from long; miscellaneous general cleanup 
  344. * of the code
  345. * -> cleaned up the display, but lots left to be done
  346. * 
  347. * 
  348. * REMAINING MINOR BUGS AND INFELICITIES AND WISH LIST --
  349. * 
  350. * -> spawn a properly working interactive shell; probably just need 
  351. * a fork and a full reset() under "!" option
  352. * -> easy repeat of string search to find next occurrence; highlight 
  353. * string positions in the display; put edit cursor at start of string
  354. * -> in debug mode, allow backspace over command entered, to cancel it
  355. * -> errmsg() display not nice, if have several messages output in
  356. * sequence; no pause in errmsg() (sleep not working?)
  357. * -> column under pointer not always erased (local clrtoeol problem ??)
  358. * -> irregular passing of pointers to record and related arrays
  359. * -> most of the external vars should be local to main()
  360. * -> signal handling?
  361. * -> file closing?
  362. * 
  363. * COMMENTS --
  364. * 
  365. * -> thanks to Steven List and Garry Johnson for a very useful program;
  366. * it's a nice way for one who is lazy to avoid a lot of compilation 
  367. * when what is wanted is a small change in data; the code is easy to 
  368. * read -- again compliments to the authors;
  369. * -> these modifications are hacks of the previous authors' code; the 
  370. * modified program has not been hardened, although I tried to check 
  371. * its operation under limit conditions; please be careful in using it
  372. * -> like the authors, I would appreciate receiving a copy of any 
  373. * improvements
  374. * 
  375. * John Rupley, Dept. Biochemistry, Univ. Arizona, Tucson, AZ 85721
  376. * {ihnp4 | hao!noao}!arizona!rupley!local or rupley!local@megaron.arizona.edu
  377. *
  378. ******************************************************************************
  379. *
  380. *  03/05/86 - added further terminal independence
  381. *          added use of ioctl (see main and mstdin)
  382. *          added -D versus -d command line option
  383. *          added use of standard getopt
  384. *          cleaned up code, eliminated function "ikf"
  385. *          added original versions of ezlib functions, such as
  386. *        icc, setterm, cm, mstdin, erase, length, move
  387. *          added ^R, ^Q, ^N, and ^P commands
  388. *          added ^F, !, and ^X (-X) commands
  389. *              changed name to "bpatch"
  390. *              added direct address command (g)
  391. *          added ASCII search capability
  392. *  07/07/86 - converted to use curses
  393. *          modified direct addressing to use suffixes
  394. *          updated HELP function
  395. *
  396. *   Steven List @ Benetics Corporation, Mt. View, CA
  397. *   {cdp,engfocus,idi,oliveb,plx,tolerant}!bene!luke!itkin
  398. *********************************************************************/
  399. /*E*/
  400. /*S includes, globals, and defines */
  401. /*Page Eject*/
  402. #include    <curses.h>
  403. #include <fcntl.h>
  404. #include <signal.h>
  405. #include <ctype.h>
  406. #include <sys/types.h>
  407. #include <sys/stat.h>
  408.  
  409. static int pbrk = 0;
  410. struct stat sb;
  411.  
  412. void icc ();
  413. void copyrec ();
  414. void schwapp ();
  415.  
  416. /* added declarations, mostly for cleanliness */
  417. extern long lseek();
  418. extern long atol();
  419. extern char *strncpy();
  420. extern void exit();
  421. extern unsigned sleep();    /* signal problems ??? if sleep called */
  422. extern void perror();
  423.  
  424. /* set up for calls to outstr and errmsg, etc, */
  425. /* by use of sprintf to fill outbuf */
  426. char outbuf[512];
  427.  
  428.     /* ------------------------------------------------------------ */
  429.     /* Some defines added by the moderator to get it work on 4.2     */
  430.     /* ------------------------------------------------------------ */
  431. #ifdef    MOD_HAX
  432.     /* Fifos?  We ain't got no steenkin' fifos. */
  433. /*    #define S_IFIFO        123450    */
  434.     /* "Spelling differences." */
  435. #define beep()        fprintf (stderr, "\007")
  436. /*    #define cbreak()    crmode()    */
  437.     /* Our curses doesn't translate keypad keys to single characters.    */
  438. #define keypad(a, b)        /*    null    */    /* orig defines */
  439. #define KEY_UP        '\0'    /*    '^'    */    /* by MOD_HAX    */
  440. #define KEY_DOWN    '\0'    /*    'v'    */    /* not portable    */
  441. #define KEY_LEFT    '\0'    /*    '<'    */
  442. #define KEY_RIGHT    '\0'    /*    '>'    */
  443. #define KEY_HOME    '\0'    /*    '@'    */
  444. #endif    /* MOD_HAX */
  445.  
  446. /* vi-like cursor control = vi keys, as control characters */
  447. /* this is a hack, and I hope does not interfere with keypad() */
  448. #define VI_UP        ('K' - 0x40)
  449. #define VI_DOWN        ('J' - 0x40)
  450. #define VI_LEFT        ('H' - 0x40)
  451. #define VI_RIGHT    ('L' - 0x40)
  452. #define VI_HOME        ('G' - 0x40)
  453.  
  454. #define SLEEP_TIME    (unsigned )0    /* a small pause after errmsg */
  455.                     /* does not work -- signals?? */
  456.     /* ------------------------------------------------------------ */
  457.     /* Some convenient defines                     */
  458.     /* ------------------------------------------------------------ */
  459.  
  460. #define DEL '\177'
  461. #define HEX 1
  462. #define ALPHA 0
  463.  
  464.     /* ------------------------------------------------------------ */
  465.     /* general purpose identification and control variables         */
  466.     /* ------------------------------------------------------------ */
  467.  
  468. char    filename[64];        /* current file being examined        */
  469. char    record[16][16];        /* record (page) buffer            */
  470. char    unch_rec[16][16];    /* record before any changes        */
  471. int     zp;            /* current input character        */
  472.  
  473. int        block = 0;    /* block size if -b in command        */
  474. int        block_spec;    /* true if file is block special    */
  475. int        bytes = 0;    /* number of bytes from last read    */
  476. int        char_spec;    /* true if file is char special        */
  477. int        debug = 0;    /* true if debug is turned on        */
  478. int        dir_spec;    /* true if file is directory        */
  479. int        dump = 0;    /* nonzero if dump instead of change    */
  480. int        Dump = 0;    /* store of value with -D option    */
  481. int        ebcdic = 0;    /* true if -e option            */
  482. int        fifo_spec;    /* true if file is fifo            */
  483. int        honly = 0;    /* true if dump is to be hex only    */
  484. int        mod = 0;    /* true if record has been modified    */
  485. int        pause_opt = 0;    /* true if -p option            */
  486. int        rawfile = 0;    /* true if file is c/b/p        */
  487. int        reclen = 0;    /* record length, if -r            */
  488. int        recno = 0;    /* current record (page) number        */
  489. int        stay = 0;    /* true if no position change         */
  490. int        swab_opt = 0;    /* true if byte swapping is on        */
  491. int        windowed = 0;    /* true if windowing - not dump        */
  492.  
  493. long    position = 0;        /* byte address in file            */
  494.  
  495. WINDOW *hexwin = NULL;
  496. WINDOW *alphawin = NULL;
  497. WINDOW *errwin = NULL;
  498.  
  499. #ifdef    MOD_HAX
  500. #else    /* use original code... */
  501.     /* plus some more for restoring terminal function */
  502.     struct termio asis, aswas;
  503. #endif    /* MOD_HAX */
  504.  
  505. /*S main - control all the work from here */
  506. /*H main *************************************************************
  507. *
  508. *                 main
  509. *
  510. *    set up the globals, initilize the state, and process the file
  511. *
  512. *********************************************************************/
  513. /*E*/
  514. main (argc, argv)
  515. int argc;
  516. char *argv[];
  517. {
  518.     extern WINDOW *subwin ();
  519.     extern WINDOW *newwin ();
  520.  
  521.     register char    *cp;        /* general purpose char ptr    */
  522.     extern   char    *gets ();    /* get string from stdin    */
  523.           char    m = '\017';    /* mask for hex edit        */
  524.           char    response[512];    /* general purpose buffer    */
  525.           int     z;        /* character read in        */
  526.      
  527.     int        breakp ();    /* signal trapping function    */
  528.     int        c;        /* current screen column    */
  529.     int        change = 0;    /* true if cmd line option toggled */
  530.     int        fid;        /* file descriptor         */
  531.     int        firstfile;    /* arg # of first file in cmd line */
  532.     int        h;        /* temp for hex edit        */
  533.     int        i;        /* general purpose loop index    */
  534.     int        j;        /* general purpose loop index    */
  535.     int        r;        /* current screen row        */
  536.     int        hexc;        /* current cursor column in hexwin */
  537.  
  538.     long    byteaddr;        /* planned byte address for 'G'    */
  539.     long    size;            /* file size in bytes        */
  540.     long    status;            /* EOF if at end of file or error */
  541.  
  542.     extern int optind;        /* getopt index into argv    */
  543.     extern char *optarg;        /* getopt pointer to opt arg    */
  544.  
  545.     extern long getnum ();
  546.     extern char *instr ();        /* get a string from the cmd line */
  547.     extern int reset ();        /* exit function - reset terminal */
  548.  
  549.     /* ------------------------------------------------------------ */
  550.     /* set up signal handling                     */
  551.     /* ------------------------------------------------------------ */
  552.  
  553.     if (!dump) signal (SIGINT, breakp);
  554.  
  555.     signal (SIGTERM, reset);
  556.  
  557.     /* ------------------------------------------------------------ */
  558.     /* process command line arguments                 */
  559.     /* ------------------------------------------------------------ */
  560.  
  561.     while ((i = getopt (argc, argv, "r:dD:b:pxXse")) != EOF)
  562.     {
  563.         switch (i)
  564.         {
  565.             case    'b':    /* blocking            */
  566.                 block = atoi (optarg);
  567.                 if (block < 1 || block > 10240)
  568.                 {
  569.                     fprintf (stderr,
  570.                         "invalid block size: %d\n", block);
  571.                     exit (1);
  572.                 }
  573.                 break;
  574.             case    'd':    /* straight dump - no limit    */
  575.                 dump = -1;
  576.                 break;
  577.             case    'D':    /* dump - page count spec    */
  578.                 dump = atoi (optarg);
  579.                 Dump = dump;
  580.                 break;
  581.             case    'e':    /* file is ebcdic        */
  582.                 ebcdic = 1;
  583.                 break;
  584.             case    'p':    /* pause between pages - dump    */
  585.                 pause_opt = 1;
  586.                 break;
  587.             case    'r':    /* record length for dump    */
  588.                 reclen = atoi (optarg);
  589.                 break;
  590.             case    's':    /* byte swapping required    */
  591.                 swab_opt = 1;
  592.                 break;
  593.             case    'x':    /* hex dump only        */
  594.                 honly = 1;
  595.                 break;
  596.             case    'X':
  597.                 debug = 1;
  598.                 break;
  599.             default:    /* uhoh                */
  600.                 fprintf (stderr,
  601. "usage: bpatch [ -b blocksz ] [ -d<ump> ] [ -D pagecnt ] [ -e<bcdic> ]\n");
  602.                 fprintf (stderr,
  603. "           [ -p<ause> ] [ -r reclen ] [ -s<wap bytes> ] [ -x<only> ]\n");
  604.                 exit (1);
  605.         }
  606.     }
  607.  
  608.     /* ------------------------------------------------------------ */
  609.     /* check for valid combinations of options             */
  610.     /* ------------------------------------------------------------ */
  611.  
  612.     if ((honly || block || reclen || pause_opt ) && !dump)
  613.     {
  614.         fprintf (stderr, "-x|-b|-r|-p requires -d or -D\n");
  615.         exit (2);
  616.     }
  617.  
  618.     /* ------------------------------------------------------------ */
  619.     /* At least one file name must be specified on the cmd line     */
  620.     /* ------------------------------------------------------------ */
  621.  
  622.     if (optind == argc)
  623.     {
  624.         fprintf (stderr, "no file name(s) specified\n");
  625.         exit (2);
  626.     }
  627.  
  628.     /* ------------------------------------------------------------ */
  629.     /* set up the screen, if this is an interactive session         */
  630.     /* ------------------------------------------------------------ */
  631.  
  632.     if (!dump)
  633.     {
  634.         windowed = 1;
  635.         initscr ();
  636.         nonl ();
  637.         noecho ();
  638.         cbreak ();
  639.         keypad (stdscr, TRUE);
  640.         hexwin = subwin (stdscr, 16, 48, 4, 4);
  641.         keypad (hexwin, TRUE);
  642.         alphawin = subwin (stdscr, 16, 16, 4, 57);
  643.         keypad (alphawin, TRUE);
  644.         errwin = subwin (stdscr, 1, 80, 23, 0);
  645.  
  646. #ifdef    MOD_HAX
  647.         /* This is not exactly what the original code does,
  648.            but it's good enough.  -r$ */
  649.         raw();
  650. #else    /* use original code... */
  651.         ioctl (0, TCGETA, &asis);
  652.         aswas = asis;    /* save termio stuff for later restore */
  653.         asis.c_cc[VINTR] = '\0';
  654.         asis.c_iflag &= ~IXON;
  655.         asis.c_iflag &= ~IXOFF;
  656.         asis.c_iflag &= ~IXANY;
  657.         ioctl (0, TCSETA, &asis);
  658. #endif    /* MOD_HAX */
  659.     }
  660.  
  661.     /* ------------------------------------------------------------ */
  662.     /* save the first file's index for backing up later         */
  663.     /* ------------------------------------------------------------ */
  664.  
  665.     firstfile = optind;
  666.  
  667.     /* ------------------------------------------------------------ */
  668.     /* open the first file                          */
  669.     /* ------------------------------------------------------------ */
  670.  
  671.     for (fid = -1; fid < 0 && optind < argc;)
  672.     {
  673.         fid = ckfile (argv[optind], &size);
  674.         if (fid < 0) optind++;
  675.     }
  676.     if (fid < 0)
  677.     {
  678.         fprintf (stderr, "could not handle the file list\n");
  679.         reset (0);
  680.         exit (2);
  681.     }
  682.  
  683.     strncpy (filename, argv[optind], sizeof filename);
  684.  
  685.     if (block != 0)
  686.     {
  687.         size = -1;
  688.     }
  689.  
  690.     recno = 0;
  691.     stay = 0;
  692.     mod = 0;
  693.     status = 0;
  694.  
  695.     /* ------------------------------------------------------------ */
  696.     /* Until the user exits...                     */
  697.     /* ------------------------------------------------------------ */
  698.  
  699.     if (!dump) clear ();
  700.  
  701.     while (status != EOF)
  702.     {
  703.     /* ------------------------------------------------------------ */
  704.     /* change of location - read and display             */
  705.     /* ------------------------------------------------------------ */
  706.         if (stay == 0)
  707.         {
  708.             position = lseek (fid, ((long )recno) * 256, 0);
  709.  
  710.             if ((bytes = bread (fid, record, 256, block)) < 0)
  711.             {
  712.                 sprintf(outbuf, "error on reading file %s", filename);
  713.                 errmsg (outbuf, SLEEP_TIME);
  714.                 status = EOF;
  715.                 continue;
  716.             }
  717.             if (bytes > 0)
  718.             {
  719.                 if (swab_opt) schwapp (record, 256);
  720.  
  721.                 copyrec (record, unch_rec, sizeof record);
  722.  
  723.                 if (!dump) clear ();
  724.                 show (bytes, record, filename, size, recno,
  725.                         position, m,reclen, dump, ebcdic, swab_opt,
  726.                         block, honly);
  727.             }
  728.             mod = 0;
  729.         }
  730.     /* ------------------------------------------------------------ */
  731.     /* not interactive - keep dumping or open next file         */
  732.     /* ------------------------------------------------------------ */
  733.         /* major changes in control of flow */
  734.         /* first records of multiple-files now dump */
  735.         /* core is not dumped at end of filelist */
  736.         /* can break with DEL into a long dump */
  737.         if (dump)
  738.         {
  739.             if (dump > 0) dump--;
  740.             if ((dump < 0 && bytes == 0) || dump == 0)
  741.             {
  742.                 if (Dump) dump = Dump;
  743.                 if (optind == argc) status = EOF;
  744.                 else
  745.                 {
  746.                     close (fid);
  747.                     fid = -1;
  748.                     for (optind++; fid < 0 && optind < argc;)
  749.                     {
  750.                         fid = ckfile (argv[optind], &size);
  751.                         if (fid < 0) optind++;
  752.                     }
  753.                     if (fid < 0)
  754.                     {
  755.                         status = EOF;
  756.                         continue;
  757.                     }
  758.  
  759.                     strncpy (filename, argv[optind], sizeof filename);
  760.  
  761.                     if (block != 0)
  762.                     {
  763.                         size = -1;
  764.                     }
  765.                     recno = 0;
  766.                     stay = 0;
  767.                     status = lseek (fid, (long)0, 0);
  768.                 }
  769.             }
  770.             else
  771.             {
  772.                 ++recno;
  773.             }
  774.     /* ------------------------------------------------------------ */
  775.     /* if pause, beep and wait                     */
  776.     /* ------------------------------------------------------------ */
  777.             /* settings to bypass show() */
  778.             /* and go to read of next file */
  779.             /* if type DEL during file display */
  780.             if (status != EOF && (pause_opt || pbrk))
  781.             {
  782.                 if (pbrk)
  783.                 {
  784.                     bytes = 0;
  785.                     dump = -1;
  786.                     stay = 1;
  787.                 }
  788.                 pbrk = 0;
  789.                 fprintf (stderr, "\007");
  790.                 gets (response);
  791.  
  792.                 if (pbrk) status = EOF;
  793.             }
  794.  
  795.             continue;
  796.         }
  797.     /* ------------------------------------------------------------ */
  798.     /* if we got here, this is an interactive session         */
  799.     /* ------------------------------------------------------------ */
  800.         stay = 0;
  801.     /* ------------------------------------------------------------ */
  802.     /* get the user's command                     */
  803.     /* ------------------------------------------------------------ */
  804.         response[0] = EOF;
  805.         mvaddstr (22, 0, "> ");
  806.         clrtoeol ();
  807.         refresh ();
  808.         zp = getch ();
  809.  
  810.         if (debug && !dump)
  811.         {
  812.             /* cheap cleanup of errwin */
  813.             errmsg ("", SLEEP_TIME);
  814.             if (isascii (zp) && isprint (zp))
  815.             {
  816.                 sprintf (outbuf, "command entered is %c", (char )zp);
  817.                 errmsg (outbuf, 0);
  818.             }
  819.             else
  820.             {
  821.                 sprintf (outbuf, "command entered is ^%c (%#x)", (char )zp + '@', zp);
  822.                 errmsg (outbuf, 0);
  823.             }
  824.             getch ();
  825.         }
  826.  
  827.         /* assume normal ascii character sequence        */
  828.         if ((zp >= 'a') && (zp <= 'z'))
  829.             zp = zp - 0x20;
  830.     /* ------------------------------------------------------------ */
  831.     /* here we go - what does the user want?             */
  832.     /* ------------------------------------------------------------ */
  833.         refresh ();
  834.         errmsg ("", SLEEP_TIME);
  835.         switch (zp)
  836.         { 
  837.             case    '!':    /* shell escape    */
  838.                 echo ();
  839.                 move (23,0);
  840.                 clrtoeol ();
  841.                 addstr ("shell command: ");
  842.                 refresh ();
  843.                 getstr (response);
  844.                 clear ();
  845.                 nl ();
  846.                 system (response);
  847.                 noecho ();
  848.                 nonl ();
  849.                 move (23,0);
  850.                 standout ();
  851.                 addstr (" <Press any key> ");
  852.                 standend ();
  853.                 clrtoeol ();
  854.                 refresh ();
  855.                 getch ();
  856.                 break;
  857.  
  858.             case    '?':    /* HELP    */
  859.                 clear ();
  860.                 dbg_msg ("Help");
  861.                 dohelp ();
  862.                 break;
  863.  
  864.             case    '/':    /* search for a string */
  865.                 stay = 1;
  866.                 if (mod)
  867.                 {
  868.                     errmsg ("No write since last change", SLEEP_TIME);
  869.                 }
  870.                 else search (fid);
  871.                 break;
  872.  
  873.             case '-':    /* toggle options */
  874.                 zp = getch ();
  875.                 stay = 1;
  876.                 change = 0;
  877.                 switch (zp)
  878.                 {
  879.                     case 'a': /* ascii */
  880.                         if (ebcdic)
  881.                         {
  882.                             dbg_msg ("toggle to ascii");
  883.                             change = 1;
  884.                         }
  885.                         ebcdic = 0;
  886.                         break;
  887.  
  888.                     case 'e': /* ebcdic */
  889.                         if (ebcdic == 0)
  890.                         {
  891.                             dbg_msg ("toggle to ebcdic");
  892.                             change = 1;
  893.                         }
  894.                         ebcdic = 1;
  895.                         break;
  896.  
  897.                     case 's': /* swab */
  898.                         dbg_msg ("toggle byte swap");
  899.                         change = 1;
  900.                         schwapp (record, 256);
  901.                         swab_opt = !swab_opt;
  902.                         break;
  903.                 }
  904.                 if (change)
  905.                 {
  906.                     clear ();
  907.                     show (bytes, record, filename, size,
  908.                             recno, position, m,reclen, dump,
  909.                             ebcdic, swab_opt, block, honly);
  910.                 }
  911.  
  912.                 break;
  913.  
  914.             case '\022':    /* redraw screen (^R) */
  915.                 clear ();
  916.                 show (bytes, record, filename, size, recno,
  917.                       position, m, reclen, dump, ebcdic,
  918.                       swab_opt, block, honly);
  919.                 stay = 1;
  920.                 break;
  921.             
  922.             case    '\030':    /* toggle debug (^X) */
  923.                 debug = !debug;
  924.                 stay = 1;
  925.                 break;
  926.  
  927.             case    '\006':    /* new file (^F) */
  928.                 close (fid);
  929.                 fid = ckfile (cp = instr (), &size);
  930.                 if (fid < 0)
  931.                 {
  932.                     fid = ckfile (filename, &size);
  933.                 }
  934.                 else
  935.                 {
  936.                     strncpy (filename, cp, sizeof filename);
  937.                     stay = 0;
  938.                     recno = 0;
  939.                 }
  940.                 break;
  941.  
  942.             case    '\016':    /* next file (^N) */
  943.                 if (mod)
  944.                 {
  945.                     errmsg ("No write since last change", SLEEP_TIME);
  946.                     stay = 1;
  947.                 }
  948.                 else if (optind == (argc - 1))
  949.                 {
  950.                     errmsg ("No more files", SLEEP_TIME);
  951.                     stay = 1;
  952.                 }
  953.                 else
  954.                 {
  955.                     close (fid);
  956.                     for (fid = -1, optind++; fid < 0 && optind < argc;)
  957.                     {
  958.                         fid = ckfile (argv[optind], &size);
  959.                         if (fid < 0) optind++;
  960.                     }
  961.                     if (fid < 0)
  962.                     {
  963.                         errmsg ("could not handle the file list", SLEEP_TIME);
  964.                         reset (0);
  965.                         exit (0);
  966.                     }
  967.                     strncpy (filename, argv[optind], sizeof filename);
  968.                     stay = 0;
  969.                     recno = 0;
  970.                 }
  971.                 break;
  972.  
  973.             case    '\020':    /* prev file (^P) */
  974.                 if (mod)
  975.                 {
  976.                     errmsg ("No write since last change", SLEEP_TIME);
  977.                     stay = 1;
  978.                 }
  979.                 else if (optind == firstfile)
  980.                 {
  981.                     errmsg ("No previous file", SLEEP_TIME);
  982.                     stay = 1;
  983.                 }
  984.                 else
  985.                 {
  986.                     close (fid);
  987.                     for (fid = -1, optind--; fid < 0 && optind >= firstfile;)
  988.                     {
  989.                         fid = ckfile (argv[optind], &size);
  990.                         if (fid < 0) optind--;
  991.                     }
  992.                     if (fid < 0)
  993.                     {
  994.                         errmsg ("could not handle the file list", SLEEP_TIME);
  995.                         reset (0);
  996.                         exit (0);
  997.                     }
  998.                     strncpy (filename, argv[optind], sizeof filename);
  999.                     stay = 0;
  1000.                     recno = 0;
  1001.                 }
  1002.                 break;
  1003.  
  1004.             case    '\021':    /* quit absolutely (^Q)    */
  1005.                 status = EOF;
  1006.                 break;
  1007.  
  1008.             case DEL:    /* quit with check */
  1009.             case 'Q':     /* quit */
  1010.                 if (mod)
  1011.                 {
  1012.                     errmsg ("No write since last change!", SLEEP_TIME);
  1013.                     stay = 1;
  1014.                 }
  1015.                 else
  1016.                 {
  1017.                     status = EOF;
  1018.                 }
  1019.                 break;
  1020.  
  1021.             case '\\':     /* back up 1 record */
  1022.                 if (mod)
  1023.                 {
  1024.                     errmsg ("No write since last change", SLEEP_TIME);
  1025.                     stay = 1;
  1026.                 }
  1027.                 else
  1028.                 {
  1029.                     if (recno > 0)
  1030.                     {
  1031.                         --recno;
  1032.                         stay = 0;
  1033.  
  1034.                         status = lseek (fid, ((long )recno) * 256, 0);
  1035.                         if (status < 0)
  1036.                         {
  1037.                             move (22, 0);
  1038.                             clrtoeol ();
  1039.                             perror (filename);
  1040.                             errmsg ("error positioning in file", SLEEP_TIME);
  1041.                             beep ();
  1042.                             ++recno;
  1043.                             stay = 1;
  1044.                         }
  1045.                     }
  1046.                     else
  1047.                     {
  1048.                         errmsg ("No previous records", SLEEP_TIME);
  1049.                         beep ();
  1050.                         stay = 1;
  1051.                     }
  1052.                 }
  1053.                 break; 
  1054.  
  1055.             case 'F':     /* go to first record */
  1056.                 if (mod)
  1057.                 {
  1058.                     errmsg ("No write since last change", SLEEP_TIME);
  1059.                     stay = 1;
  1060.                 }
  1061.                 else
  1062.                 {
  1063.                     status = lseek (fid, (long)0, 0);
  1064.                     recno = 0;
  1065.                 }
  1066.                 break;
  1067.  
  1068.             case 'L':     /* go to last record */
  1069.                 if (mod)
  1070.                 {
  1071.                     errmsg ("No write since last change", SLEEP_TIME);
  1072.                     stay = 1;
  1073.                 }
  1074.                 else
  1075.                 {
  1076.                     position = lseek (fid, (long)0, 2);
  1077.                     recno = position / 256;
  1078.                     j = position % 256;
  1079.                     if (j == 0) --recno;
  1080.                     status = lseek (fid, ((long )recno)*256, 0);
  1081.                 }
  1082.                 break;
  1083.  
  1084.             case 'U':    /* undo changes    */
  1085.                 stay = 1;
  1086.                 mod = 0;
  1087.                 copyrec (unch_rec, record, sizeof record);
  1088.                 clear ();
  1089.                 show (bytes, record, filename, size, recno,
  1090.                         position, m,reclen, dump, ebcdic, swab_opt,
  1091.                         block, honly);
  1092.                 break;
  1093.  
  1094.             case 'R':     /* re-read record */
  1095.                 status = lseek (fid, ((long )recno)*256, 0);
  1096.                 break;
  1097.  
  1098.             case '0':     /* go to some address */
  1099.             case '1':
  1100.             case '2':
  1101.             case '3':
  1102.             case '4':
  1103.             case '5':
  1104.             case '6':
  1105.             case '7':
  1106.             case '8':
  1107.             case '9':
  1108.                 if (mod)
  1109.                 {
  1110.                     errmsg ("No write since last change", SLEEP_TIME);
  1111.                     stay = 1;
  1112.                 }
  1113.                 else
  1114.                 {
  1115.                     byteaddr = getnum (zp, FALSE);
  1116.                     stay = 1;
  1117.                     sprintf (outbuf, "Position to byte %ld", byteaddr);
  1118.                     errmsg (outbuf, 0);
  1119.                     if (!rawfile && byteaddr > size)
  1120.                     {
  1121.                         errmsg ("Address outside file", SLEEP_TIME);
  1122.                         beep ();
  1123.                     }
  1124.                     else if ((int )(byteaddr / 256) != recno)
  1125.                     {
  1126.                         recno = byteaddr / 256;
  1127.                         status = lseek (fid, ((long )recno)*256, 0);
  1128.                         stay = 0;
  1129.                     }
  1130.                 }
  1131.                 break;
  1132.  
  1133.             case 'A':     /* alpha modify */
  1134.                 stay = 1;
  1135.                 r = c = 0;
  1136.                 dbg_msg ("edit ascii");
  1137.                 if (bytes == 0) break;
  1138.                 touchwin (stdscr);
  1139.                 refresh ();
  1140.                 wmove (alphawin, r, c);
  1141.                 touchwin (alphawin);
  1142.                 wrefresh (alphawin);
  1143.  
  1144.                 while ((z = wgetch (alphawin)) != DEL)
  1145.                 {
  1146.                     if (!arrow (z, &r, &c))
  1147.                     {
  1148.                         if (isascii (z))
  1149.                         {
  1150.                             if (isprint (z)) waddch (alphawin, z);
  1151.                             else        waddch (alphawin, '.');
  1152.  
  1153.                             if (ebcdic) icc (&z, 1,"AE");
  1154.  
  1155.                             record[r][c] = z;
  1156.                             mod = 1;
  1157.  
  1158.                             hexc = c * 3;
  1159.                             wmove (hexwin, r, hexc);
  1160.                             if (record[r][c] < '\0')
  1161.                             {
  1162.                                 wprintw (hexwin, "%x%x", (record[r][c] >> 4) & m, record[r][c] & m);
  1163.                             }
  1164.                             else
  1165.                             {
  1166.                                 wprintw (hexwin, "%02x", record[r][c]);
  1167.                             }
  1168.                             wrefresh (hexwin);
  1169.  
  1170.                         }
  1171.                         else
  1172.                         {
  1173.                             beep ();
  1174.                         }
  1175.  
  1176.                         if (c == 15)
  1177.                         {
  1178.                             if (r == 15) beep ();
  1179.                             else
  1180.                             {
  1181.                                 c = 0;
  1182.                                 ++r;
  1183.                             }
  1184.                         }
  1185.                         else
  1186.                         {
  1187.                             c++;
  1188.                         }
  1189.                     }
  1190.                     if (r * 16 + c >= bytes)
  1191.                     {
  1192.                         beep ();
  1193.                         r = (bytes - 1) / 16;
  1194.                         c = (bytes - 1) % 16;
  1195.                     }
  1196.  
  1197.                     wmove (alphawin, r, c);
  1198.                     wrefresh (alphawin);
  1199.                 }
  1200.  
  1201.                 break;
  1202.  
  1203.             case 'H':     /* hex modify */
  1204.                 dbg_msg ("edit hex");
  1205.                 stay = 1;
  1206.                 r = c = hexc = 0;
  1207.                 if (bytes == 0) break;
  1208.                 touchwin (stdscr);
  1209.                 refresh ();
  1210.                 wmove (hexwin, r, hexc);
  1211.                 touchwin (hexwin);
  1212.                 wrefresh (hexwin);
  1213.  
  1214.                 while ((z = wgetch (hexwin)) != DEL)
  1215.                 {
  1216.                     if (!arrow (z, &r, &c))
  1217.                     {
  1218.                         hexc = c * 3;
  1219.                         if ((z >= 'a') && (z <= 'z'))
  1220.                             z = z - 0x20;
  1221.                         if (!(((z >= '0') && (z <= '9')) || ((z >= 'A') && (z <= 'F'))))
  1222.                         {
  1223.                             beep ();
  1224.                         }
  1225.                         else
  1226.                         {
  1227.                             if (z >= 'A')
  1228.                                 waddch (hexwin, tolower (z));
  1229.                             else
  1230.                                 waddch (hexwin, z);
  1231.                             wrefresh (hexwin);
  1232.  
  1233.                             if (z > '9') z -= 7;
  1234.  
  1235.                             h = (z & m) << 4;
  1236.  
  1237.                             while (2)
  1238.                             {
  1239.                                 z = EOF;
  1240.                                 z = getch ();
  1241.                                 if (z == EOF)
  1242.                                 {
  1243.                                     pbrk = 0;
  1244.                                     h = -1;
  1245.                                     break;
  1246.                                 }
  1247.                                 if ((z >= 'a') && (z <= 'z'))
  1248.                                     z = z - 0x20;
  1249.                                 if (!(((z >= '0') && (z <= '9')) || ((z >= 'A') && (z <= 'F'))))
  1250.                                 {
  1251.                                     beep ();
  1252.                                 }
  1253.                                 else
  1254.                                 {
  1255.                                     if (z >= 'A')
  1256.                                          waddch (hexwin, tolower (z));
  1257.                                      else
  1258.                                          waddch (hexwin, z);
  1259.                                     wrefresh (hexwin);
  1260.                                     if (z > '9') z -= 7;
  1261.  
  1262.                                     h |= z & m;
  1263.                                     break;
  1264.                                 }
  1265.                             }
  1266.  
  1267.                             if (h < 0)
  1268.                             {
  1269.                                 wmove (hexwin, r, hexc);
  1270.                                 if (record[r][c] < '\0')
  1271.                                 {
  1272.                                     wprintw (hexwin, "%x%x",
  1273.                                         (record[r][c] >> 4) & m,
  1274.                                         record[r][c] & m);
  1275.                                 }
  1276.                                 else
  1277.                                 {
  1278.                                     wprintw (hexwin, "%02x", record[r][c]);
  1279.                                 }
  1280.                                 wrefresh (hexwin);
  1281.                                 break;
  1282.                             }
  1283.  
  1284.                             record[r][c] = z = h;
  1285.                             mod = 1;
  1286.  
  1287.                             if (ebcdic) icc (&z, 1,"EA");
  1288.  
  1289.                             wmove (alphawin, r, c);
  1290.                             if (isascii (z) && isprint (z))
  1291.                                 waddch (alphawin, z);
  1292.                             else waddch (alphawin, '.');
  1293.                             wrefresh (alphawin);
  1294.  
  1295.                             if (c == 15)
  1296.                             {
  1297.                                 if (r == 15) beep ();
  1298.                                 else
  1299.                                 {
  1300.                                     c = 0;
  1301.                                     ++r;
  1302.                                 }
  1303.                             }
  1304.                             else
  1305.                             {
  1306.                                 c++;
  1307.                             }
  1308.                         }
  1309.                     }
  1310.  
  1311.                     if (r * 16 + c >= bytes)
  1312.                     {
  1313.                         beep ();
  1314.                         r = (bytes - 1) / 16;
  1315.                         c = (bytes - 1) % 16;
  1316.                     }
  1317.  
  1318.                     hexc = c * 3;
  1319.                     wmove (hexwin, r, hexc);
  1320.                     wrefresh (hexwin);
  1321.                 }
  1322.                 break;
  1323.  
  1324.             case 'W':     /* write record */
  1325.                 stay = 1;
  1326.                 status = lseek (fid, position, 0);
  1327.                 if (status != position)
  1328.                 {
  1329.                     move (22, 0);
  1330.                     clrtoeol ();
  1331.                     perror (filename);
  1332.                     errmsg ("error positioning in file", SLEEP_TIME);
  1333.                     beep ();
  1334.                 }
  1335.                 if (swab_opt) schwapp (record, 256);
  1336.                 if (write (fid, record, bytes) != bytes)
  1337.                 {
  1338.                     errmsg ("error writing to file", SLEEP_TIME);
  1339.                     reset (0);
  1340.                     exit (0);
  1341.                 }
  1342.                 if (swab_opt) schwapp (record, 256);
  1343.                 mod = 0;
  1344.                 errmsg ("Record written", SLEEP_TIME);
  1345.                 break;
  1346.  
  1347.             case    '\n':    /* newline - next page    */
  1348.             case    '\r':
  1349.                 if (mod)
  1350.                 {
  1351.                     errmsg ("No write since last change", SLEEP_TIME);
  1352.                     stay = 1;
  1353.                 }
  1354.                 else
  1355.                 {
  1356.                     ++recno;
  1357.                     if (!rawfile && (((long )recno) * 256) >= size)
  1358.                     {
  1359.                         recno--;
  1360.                         beep ();
  1361.                         errmsg ("No more records in file", SLEEP_TIME);
  1362.                         stay = 1;
  1363.                     }
  1364.                     else stay = 0;
  1365.                 }
  1366.                 break;
  1367.  
  1368.             default:
  1369.                 if (isascii (zp) && isprint (zp))
  1370.                 {
  1371.                     sprintf (outbuf, "Unknown command: %d", zp);
  1372.                     errmsg (outbuf, 0);
  1373.                 }
  1374.                 else
  1375.                 {
  1376.                     sprintf (outbuf, "Unknown command: %d", zp + '@');
  1377.                     errmsg (outbuf, 0);
  1378.                 }
  1379.                 beep ();
  1380.                 stay = 1;
  1381.                 break;
  1382.         }     /* end switch zp */
  1383.         refresh ();
  1384.     }
  1385.  
  1386.     reset (0);
  1387.     if (fid > 0) return (close (fid));
  1388.     else return (0);
  1389. }
  1390. /*S show - display a record on the terminal */
  1391. /*H show */
  1392. /*E*/
  1393. /*checked typing of parameters as declared in fucntion */
  1394. /* versus declarations at call */
  1395. show (bytes, record, filename, size, recno, position,
  1396.       m,reclen, dump, ebcdic, swab_opt, block, honly)
  1397. int bytes;
  1398. char record[16][16];
  1399. char *filename;
  1400. long size;
  1401. int recno;
  1402. long position;
  1403. char m;
  1404. int reclen;
  1405. int dump;
  1406. int ebcdic;
  1407. int swab_opt;
  1408. int block;
  1409. int honly;
  1410. {
  1411.     int        i;
  1412.     int        j;
  1413.     char    s;
  1414.     char    temp[16];
  1415.     char    *look = NULL;
  1416.  
  1417.     int        row = 0;
  1418.     int        col = 0;
  1419.  
  1420.     if (dump)
  1421.         printf ("\n\n");
  1422.     if (!dump)
  1423.         move (0, 0);
  1424.     sprintf (outbuf, "FILE: %s ", filename);
  1425.     outstr (outbuf);
  1426.     if (block_spec) outstr ("(block special)");
  1427.     else if (char_spec) outstr ("(character special)");
  1428.     else if (fifo_spec) outstr ("(fifo (named pipe))");
  1429.     else if (dir_spec)
  1430.     {
  1431.         sprintf (outbuf, "(directory - %ld)", size);
  1432.         outstr (outbuf);
  1433.     }
  1434.     else 
  1435.     {
  1436.         sprintf (outbuf, "(%ld)", size);
  1437.         outstr (outbuf);
  1438.     }
  1439.     if (ebcdic) outstr (" - EBCDIC");
  1440.     else outstr (" - ASCII");
  1441.     if (swab_opt) outstr (" - SWAP");
  1442.     if (block) 
  1443.     {
  1444.         sprintf (outbuf, " - BLOCK (%d)", block);
  1445.         outstr (outbuf);
  1446.     }
  1447.     if (reclen) 
  1448.     {
  1449.         sprintf (outbuf, " - RECORD (%d)", reclen);
  1450.         outstr (outbuf);
  1451.     }
  1452.     if (!dump)
  1453.     {
  1454.         clrtoeol ();
  1455.         move (1,0);
  1456.         printw ("PAGE: %d (%ld)", recno, position);
  1457.         clrtoeol ();
  1458.         row = 2;
  1459.     }
  1460.     else
  1461.     {
  1462.         printf ("\nPAGE: %d (%ld)\n", recno, position);
  1463.     }
  1464.  
  1465.     if (honly)
  1466.     {
  1467.         look = (char *) record;
  1468.         for (j=0;j<256;++j)
  1469.         {
  1470.             if (*look++ != '\0')
  1471.             {
  1472.                 look = NULL;
  1473.                 break;
  1474.             }
  1475.         }
  1476.     }
  1477.  
  1478.     if (!dump) move (row, col);
  1479.  
  1480.     outstr ("    x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf");
  1481.     outstr ("    0123456789abcdef");
  1482.  
  1483.     if (!dump)
  1484.     {
  1485.         row += 2;
  1486.         move (row, col);
  1487.     }
  1488.     else
  1489.     {
  1490.         printf ("\n\n");
  1491.     }
  1492.     for (i=0; i<=bytes/16; ++i)
  1493.     {
  1494.         if (honly && look != NULL)
  1495.         {
  1496.             i = 16;
  1497.             continue;
  1498.         }
  1499.          if (i*16+1 > bytes)
  1500.          {
  1501.             if (!dump) move (++row, 0);
  1502.              continue;
  1503.          }
  1504.  
  1505.         sprintf (outbuf, "%02x: ", i);
  1506.         outstr (outbuf);
  1507.  
  1508.         for (j=0; j<16; ++j)
  1509.         {
  1510.             if (i*16+j < bytes)
  1511.             {
  1512.                 if (record[i][j] < '\0')
  1513.                 {
  1514.                     sprintf (outbuf, "%x%x ",
  1515.                         (record[i][j] >> 4) & m, record[i][j] & m);
  1516.                     outstr (outbuf);
  1517.                 }
  1518.                 else
  1519.                 {
  1520.                     sprintf (outbuf, "%02x ", record[i][j]);
  1521.                     outstr (outbuf);
  1522.                 }
  1523.                 s = ' ';
  1524.                 if (reclen > 0 && (position+i*16+j+1)%reclen == 0)
  1525.                     s = ':';
  1526.                 if (block > 0 && (position+i*16+j+1)%block == 0)
  1527.                 {
  1528.                     if (s == ' ')
  1529.                         s = '/';
  1530.                     else
  1531.                         s = '%';
  1532.                 }
  1533.                 if (s != ' ')
  1534.                 {
  1535.                     sprintf (outbuf, "\b%c", s);
  1536.                     outstr (outbuf);
  1537.                 }
  1538.             }
  1539.             else
  1540.             {
  1541.                 outstr ("   "); /* set at 3 spaces */
  1542.             }
  1543.         }
  1544.  
  1545.         outstr ("     ");    /* set at tab + 1 space */
  1546.  
  1547.         copyrec (record[i], temp, 16);
  1548.  
  1549.         if (ebcdic) icc (temp, 16, "EA");
  1550.  
  1551.         for (j = 0; j < 16 && i*16+j < bytes; ++j)
  1552.         {
  1553.             if (temp[j] < ' ') outch ('.');
  1554.             else
  1555.             {
  1556.                 sprintf (outbuf, "%c", temp[j]);
  1557.                 outstr (outbuf);
  1558.             }
  1559.         }
  1560.  
  1561.         if (!dump)
  1562.         {
  1563.             move (++row, col);
  1564.         }
  1565.         else
  1566.         {
  1567.             printf ("\n");
  1568.         }
  1569.     }
  1570.  
  1571.     /* moved debug output so it would display + other related changes */
  1572.     if (!dump) clrtobot ();
  1573.     if (debug && !dump)
  1574.     {
  1575.         getyx (stdscr, row, col);
  1576.         move (23,0);
  1577.         printw ("show: %d|%ld|%s|%ld|%d|%ld|%#x|%d|%d|%d|%d|%d|%d",
  1578.             bytes, record, filename, size, recno, position,
  1579.             m, reclen, dump, ebcdic, swab_opt, block, honly);
  1580.         move (row, col);
  1581.     }
  1582.     if (!dump) 
  1583.     {
  1584.         touchwin (stdscr);
  1585.         refresh ();
  1586.     }
  1587.     
  1588.     return;
  1589. }
  1590. /*S breakp - set pbrk on interrupt */
  1591. /*H breakp */
  1592. /*E*/
  1593. int breakp (i)
  1594. int i;
  1595. {
  1596.     int s;
  1597.     extern int pbrk;
  1598.     s = (int) signal (SIGINT, breakp);
  1599.     pbrk = i;
  1600. }
  1601. /*S bread - buffered read */
  1602. /*H bread */
  1603. /*E*/
  1604. int bread (fid, record, want, block)
  1605. int fid, want, block;
  1606. char *record;
  1607. {
  1608.     int i, j, k;
  1609.     int what, bytes, orig;
  1610.     static char buffer[10240];
  1611.     static int left, xarrow;
  1612.     static int flag = 1;
  1613.  
  1614.     if (flag)
  1615.     {
  1616.         left = 0;
  1617.         xarrow = 0;
  1618.         flag = 0;
  1619.     }
  1620.  
  1621.     if (block == 0)
  1622.         return (read (fid, record, want));
  1623.  
  1624.     if (block & 1) ++block;
  1625.  
  1626.     orig = what = want;
  1627.     while (1)
  1628.     {
  1629.         if (left < want)
  1630.         {
  1631.             if (left)
  1632.             {
  1633.                 copyrec (&buffer[xarrow], record, left);
  1634.                 record += left;
  1635.                 want -= left;
  1636.             }
  1637.  
  1638.             xarrow = 0;
  1639.             left = 0;
  1640.  
  1641.             if ((bytes = read (fid, buffer, block)) < 0)
  1642.             {
  1643.                 what = bytes;
  1644.                 break;
  1645.             }
  1646.  
  1647.             if (bytes == 0)
  1648.             {
  1649.                 what = orig - want;
  1650.                 break;
  1651.             }
  1652.  
  1653.             left = bytes;
  1654.         }
  1655.         else
  1656.         {
  1657.             copyrec (&buffer[xarrow], record, want);
  1658.             xarrow += want;
  1659.             left -= want;
  1660.             break;
  1661.         }
  1662.     }
  1663.  
  1664.     return (what);
  1665. }
  1666. /*S schwapp - swap bytes in place */
  1667. /*H schwapp */
  1668. /*E*/
  1669. void
  1670. schwapp (ptr, nch)
  1671. register char *ptr;
  1672. register int nch;
  1673. {
  1674.     register int i;
  1675.     register char c;
  1676.     register char *ptra = ptr + 1;
  1677.  
  1678.     if (nch & 1) --nch;
  1679.  
  1680.     for (i = 0; i < nch; i += 2, ptr += 2, ptra += 2)
  1681.     {
  1682.         c = *ptr;
  1683.         *ptr = *ptra;
  1684.         *ptra = c;
  1685.     }
  1686.     return;
  1687. }
  1688. /*S copyrec - transfer bytes from f to t for nbytes bytes */
  1689. /*H copyrec */
  1690. /*E*/
  1691. void
  1692. copyrec (f, t, nbytes)
  1693. register char *f;
  1694. register char *t;
  1695. register int nbytes;
  1696. {
  1697.     register int i;
  1698.  
  1699.     for (i = 0; i < nbytes; i++, f++, t++) *t = *f;
  1700.  
  1701.     return;
  1702. }
  1703. /*S ebcdic codes corresponding to ascii - translation table */
  1704. /*Page Eject*/
  1705. char xebcdic_codes[] = {
  1706. 0, 0x1, 0x2, 0x3, 0x37, 0x2d, 0x2e, 0x2f, 0x16,
  1707. 0x5, 0x25, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11,
  1708. 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f,
  1709. 0x27, 0x1c, 0x1d, 0x1e, 0x1f, 0x40, 0x5a, 0x7f, 0x7b,
  1710. 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b,
  1711. 0x60, 0x4b, 0x61, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5,
  1712. 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e,
  1713. 0x6f, 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
  1714. 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
  1715. 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8,
  1716. 0xe9, 0xad, 0xe0, 0xbd, 0x9a, 0x6d, 0x79, 0x81, 0x82,
  1717. 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92,
  1718. 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0xa2, 0xa3,
  1719. 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x4f, 0xd0,
  1720. 0x5f, 0x7 };
  1721. /*S icc - internal code conversion */
  1722. /*H icc */
  1723. /*E*/
  1724. void
  1725. icc (buf, nch, type)
  1726. register char *buf;
  1727. register int nch;
  1728. char *type;
  1729. {
  1730.     register int i;
  1731.     register int j;
  1732.  
  1733.     if (!strcmp (type, "AE"))
  1734.     {
  1735.         for (i = 0; i < nch; i++, buf++)
  1736.         {
  1737.             *buf = xebcdic_codes[*buf];
  1738.         }
  1739.     }
  1740.     else if (!strcmp (type, "EA"))
  1741.     {
  1742.         for (i = 0; i < nch; i++, buf++)
  1743.         {
  1744.             for (j = 0; j < 128; j++)
  1745.             {
  1746.                 if (*buf == xebcdic_codes[j])
  1747.                 {
  1748.                     *buf = j;
  1749.                     break;
  1750.                 }
  1751.             }
  1752.         }
  1753.     }
  1754.  
  1755.     return;
  1756. }
  1757. /*S ckfile - check on existence, accessibility, and type of file */
  1758. /*H ckfile */
  1759. /*E*/
  1760. ckfile (filename, sizep)
  1761. char    *filename;
  1762. long    *sizep;
  1763. {
  1764.     register int fid = 0;
  1765.  
  1766.     if (access (filename, 0) < 0)
  1767.     {
  1768.         sprintf (outbuf, "file not found (%s)", filename);
  1769.         errmsg (outbuf, SLEEP_TIME);
  1770.         fid = -1;
  1771.     }
  1772.  
  1773.     if (block || pause_opt || dump)
  1774.     {
  1775.         fid = open (filename, O_RDONLY, 0);
  1776.     }
  1777.     else
  1778.     {
  1779.         fid = open (filename, O_RDWR, 0);
  1780.     }
  1781.  
  1782.     if (fid < 0)
  1783.     {
  1784.         sprintf (outbuf, "error opening file %s", filename);
  1785.         errmsg (outbuf, SLEEP_TIME);
  1786.         perror (filename);
  1787.         fid = -1;
  1788.     }
  1789.     else
  1790.     {
  1791.         sprintf (outbuf, "File %s opened successfully ", filename);
  1792.         errmsg (outbuf, 0);
  1793.         if (fstat (fid, &sb) == -1)
  1794.         {
  1795.             fprintf (stderr, "Can't stat\n");
  1796.             perror (filename);
  1797.             fid = -1;
  1798.         }
  1799.         else
  1800.         {
  1801.             block_spec = (sb.st_mode & S_IFMT) == S_IFBLK;
  1802.             char_spec = (sb.st_mode & S_IFMT) == S_IFCHR;
  1803.             fifo_spec = (sb.st_mode & S_IFMT) == S_IFIFO;
  1804.             dir_spec = (sb.st_mode & S_IFMT) == S_IFDIR;
  1805.             rawfile = block_spec || char_spec || fifo_spec;
  1806.  
  1807.             if (rawfile) *sizep = -1;
  1808.             else
  1809.             {
  1810.                 if (sb.st_size == 0)
  1811.                 {
  1812.                     fprintf (stderr,
  1813.                         "file %s is empty (zero bytes)\n",
  1814.                         filename);
  1815.                     fid = -1;
  1816.                 }
  1817.                 *sizep = sb.st_size;
  1818.             }
  1819.         }
  1820.     }
  1821.  
  1822.     return fid;
  1823. }
  1824. /*S dohelp - display help text */
  1825. /*H dohelp */
  1826. /*E*/
  1827. dohelp ()
  1828. {
  1829.     static char *helptxt[] = {
  1830.     "?    - display this help text",    "h   - edit hexadecimal portion",
  1831.     "!    - execute command in the shell",    "a   - edit ascii portion",
  1832.     "q,DEL - quit the program",        "DEL - exit edit->command mode",
  1833.     "^q   - quit without writing changes",    NULL,
  1834.     "-x   - toggle command line option",    "f   - display first page of file",
  1835.     "       ({a|e}->{e|a}, s->!s)",        "l   - display last page of file",
  1836.     "<cr> - display next page",        NULL,
  1837.     "\\    - display previous page",    "nnn - direct addressing",
  1838.     "/    - search for ASCII string",     NULL,
  1839.     "^f   - select named file",        "r   - reread the current page",
  1840.     "^n   - select next file",        "u   - undo all changes to page",
  1841.     "^p   - select previous file",        "w   - write out changed page",
  1842.     "^r   - redraw the screen",        NULL,
  1843.     "^x   - turn on debug",            NULL,
  1844.     "----------------------------------------------------------------", NULL,
  1845.     "direct addressing: nnnS, where nnn = some number, and", NULL,
  1846.     "            S = type suffix", "b = block (512)",
  1847.     NULL, "k = kilobyte (1024)",
  1848.     NULL, "l = long word (4)",
  1849.     NULL, "p = page (256)",
  1850.     NULL, "w = word (2)",
  1851.     NULL, "<cr> = byte",
  1852.     };
  1853.  
  1854.     static int nmsg = sizeof helptxt / sizeof (char *);
  1855.     register int row = 0;
  1856.     register int i;
  1857.  
  1858.     register WINDOW *helpwin;
  1859.     extern WINDOW *newwin ();
  1860.  
  1861.     helpwin = newwin (LINES, COLS, 0, 0);
  1862.     wclear (helpwin);
  1863.  
  1864.     wrefresh (helpwin);
  1865.  
  1866.     wmove (helpwin, 0, 1);
  1867.     waddstr (helpwin,
  1868. "---------------------------------- HELP ----------------------------------");
  1869.  
  1870.     for (row = 1, i = 0; i < nmsg; i+=2)
  1871.     {
  1872.         if (helptxt[i])
  1873.         {
  1874.             wmove (helpwin, row, 1);
  1875.             waddstr (helpwin, helptxt[i]);
  1876.         }
  1877.         if (i+1 <= nmsg && helptxt[i+1])
  1878.         {
  1879.             wmove (helpwin, row, 41);
  1880.             waddstr (helpwin, helptxt[i+1]);
  1881.         }
  1882.         row++;
  1883.     }
  1884.  
  1885.     wmove (helpwin, 23, 0);
  1886.     wstandout (helpwin);
  1887.     waddstr (helpwin, " <Press any key> ");
  1888.     wstandend (helpwin);
  1889.     wclrtoeol (helpwin);
  1890.     wrefresh (helpwin);
  1891.     wgetch (helpwin);
  1892.     /*
  1893.     wclear (helpwin);
  1894.     wmove (helpwin, 0, 0);
  1895.     wrefresh (helpwin);
  1896.     */
  1897.     delwin (helpwin);
  1898.  
  1899.     return;
  1900. }
  1901. /*S reset - reset terminal to original state */
  1902. /*H reset */
  1903. /*E*/
  1904. reset (sig)
  1905. int sig;
  1906. {
  1907.     if (windowed)
  1908.     {
  1909.         move (23, 0);
  1910.         refresh ();
  1911. #ifndef MOD_HAX
  1912.         ioctl (0, TCSETA, &aswas);
  1913. #endif
  1914.         endwin ();
  1915.     }
  1916.     fprintf (stderr, "\n");
  1917.     if (sig)
  1918.     {
  1919.         fprintf (stderr, "killed with signal %d\n", sig);
  1920.         exit (sig);
  1921.     }
  1922.     return (0);
  1923. }
  1924. /*S arrow - determine if current character is a cursor control key */
  1925. /*H arrow */
  1926. /*E*/
  1927. arrow (k, r, c)
  1928. register int k;
  1929. register int *r;
  1930. register int *c;
  1931. {
  1932.     register ret = 1;
  1933.  
  1934.     /* watch out for conflict of VI_* amd KEY_* definitions */
  1935.     if (k == KEY_UP || k == VI_UP)
  1936.     {
  1937.         if (*r == 0) beep ();
  1938.         else (*r)--;
  1939.     }
  1940.     else if (k == KEY_DOWN || k == VI_DOWN)
  1941.     {
  1942.         if (*r == 15) beep ();
  1943.         else (*r)++;
  1944.     }
  1945.     else if (k == KEY_LEFT || k == VI_LEFT)
  1946.     {
  1947.         if (*c == 0)
  1948.         {
  1949.             if (*r == 0) beep ();
  1950.             else
  1951.             {
  1952.                 *c = 15;
  1953.                 (*r)--;
  1954.             }
  1955.         }
  1956.         else (*c)--;
  1957.     }
  1958.     else if (k == KEY_RIGHT || k == VI_RIGHT)
  1959.     {
  1960.         if (*c == 15)
  1961.         {
  1962.             if (*r == 15) beep ();
  1963.             else
  1964.             {
  1965.                 *c = 0;
  1966.                 (*r)++;
  1967.             }
  1968.         }
  1969.         else (*c)++;
  1970.     }
  1971.     else if (k == KEY_HOME || k == VI_HOME)
  1972.     {
  1973.         *r = *c = 0;
  1974.     }
  1975.     else
  1976.     {
  1977.         ret = 0;
  1978.     }
  1979.  
  1980.     return ret;
  1981. }
  1982. /*S dbg_msg - print a debug message */
  1983. /*H dbg_msg */
  1984. /*E*/
  1985. dbg_msg (msg)
  1986. register char *msg;
  1987. {
  1988.     if (debug && !dump)
  1989.     {
  1990.         errmsg (msg, SLEEP_TIME);
  1991.     }
  1992.  
  1993.     return;
  1994. }
  1995. /*S instr - get a character string from the terminal */
  1996. /*H instr */
  1997. /*E*/
  1998. char *
  1999. instr ()
  2000. {
  2001.     static char buf[512];
  2002.  
  2003.     register int c;
  2004.     register char *p = buf;
  2005.     register int col = 0;
  2006.  
  2007.     move (22, 0);
  2008.     clrtoeol ();
  2009.     refresh ();
  2010.  
  2011.     while ((c = getch ()) != '\r')
  2012.     {
  2013.         if (isascii (c) && isprint (c))
  2014.         {
  2015.             move (22, col);
  2016.             addch (c);
  2017.             *p++ = c;
  2018.             col++;
  2019.         }
  2020.         else if (c == '\b')
  2021.         {
  2022.             p--;
  2023.             col--;
  2024.             move (22, col);
  2025.             addch (' ');
  2026.             move (22, col);
  2027.         }
  2028.         refresh ();
  2029.     }
  2030.  
  2031.     refresh ();
  2032.  
  2033.     *p = '\0';
  2034.  
  2035.     return buf;
  2036. }
  2037. /*S getnum - retrieve a number from the terminal */
  2038. /*H getnum */
  2039. /*E*/
  2040. long
  2041. getnum (frst_char, hex)
  2042. register int frst_char;
  2043. register int hex;
  2044. {
  2045.     static char buf[64];
  2046.  
  2047.     register int c;
  2048.     register char *p = buf;
  2049.     register int col = 0;
  2050.  
  2051.     register long retval = 0;
  2052.  
  2053.     move (22, 0);
  2054.     clrtoeol ();
  2055.     if (frst_char)
  2056.     {
  2057.         addch (frst_char);
  2058.         *p++ = frst_char;
  2059.         col++;
  2060.         refresh ();
  2061.     }
  2062.  
  2063.     while ((c = getch()) != '\r')
  2064.     {
  2065.         if (isascii (c))
  2066.         {
  2067.             if ((hex && isxdigit (c)) || isdigit (c))
  2068.             {
  2069.                 move (22, col);
  2070.                 addch (c);
  2071.                 *p++ = c;
  2072.                 col++;
  2073.             }
  2074.             else if (c == '\b')
  2075.             {
  2076.                 p--;
  2077.                 col--;
  2078.                 move (22, col);
  2079.                 addch (' ');
  2080.                 move (22, col);
  2081.             }
  2082.             else
  2083.             {
  2084.                 break;    /* some character typing the value */
  2085.             }
  2086.             refresh ();
  2087.         }
  2088.     }
  2089.  
  2090.     *p = '\0';
  2091.  
  2092.     retval = atol (buf);
  2093.  
  2094.     mvprintw (22, 0, "%ld", retval);
  2095.     switch (c)
  2096.     {
  2097.         case    'b':    /* block - 512 bytes            */
  2098.             retval *= 512;
  2099.             break;
  2100.         case    'k':    /* 1024 bytes                */
  2101.             retval *= 1024;
  2102.             break;
  2103.         case    'l':    /* long word - 4 bytes            */
  2104.             retval *= 4;
  2105.             break;
  2106.         case    'p':    /* page - 256 bytes            */
  2107.             retval *= 256;
  2108.             break;
  2109.         case    'w':    /* word - 2 bytes            */
  2110.             retval *= 2;
  2111.             break;
  2112.         case    '\r':    /* just clear it for display        */
  2113.             c = '\0';
  2114.             break;
  2115.     }
  2116.  
  2117.     printw ("%c -> %ld byte offset", c, retval);
  2118.     clrtoeol ();
  2119.  
  2120.     refresh ();
  2121.  
  2122.     return retval;
  2123. }
  2124. /*S search - look for an ascii string in the file */
  2125. /*H search */
  2126. /*E*/
  2127. search (fid)
  2128. register int fid;
  2129. {
  2130.     long    curpos = position;
  2131.     long    currec = recno;
  2132.  
  2133.     char    lrecord[sizeof record + 1];
  2134.  
  2135.     register int i;
  2136.     register int matched = 0;
  2137.     register int srch_len;
  2138.  
  2139.     register char *cp = instr ();
  2140.     register char *rp;
  2141.  
  2142.     int row, col;
  2143.  
  2144.     srch_len = strlen (cp);
  2145.     copyrec (record, lrecord, sizeof record);
  2146.     lrecord[256] = '\0';
  2147.  
  2148.     pbrk = 0;
  2149.  
  2150.     wmove (errwin, 0, 0);
  2151.     wstandout (errwin);
  2152.     wmove (errwin, 0, 40);
  2153.     wstandend (errwin);
  2154.     wmove (errwin, 0, 1);
  2155.     waddstr (errwin, "..searching record ");
  2156.     getyx (errwin, row, col);
  2157.  
  2158.     do
  2159.     {
  2160.         mvwprintw (errwin, row, col, "%ld", currec);
  2161.         touchwin (errwin);
  2162.         wrefresh (errwin);
  2163.  
  2164.         for (i = 0, rp = lrecord, matched = 0;
  2165.              !matched && i < 256;
  2166.              rp++, i++)
  2167.         {
  2168.             if (*cp == *rp && !strncmp (cp, rp, srch_len))
  2169.             {
  2170.                 matched = 1;
  2171.                 break;
  2172.             }
  2173.         }
  2174.  
  2175.         if (!matched)
  2176.         {
  2177.             bytes = bread (fid, lrecord, 256, block);
  2178.             currec++;
  2179.             lrecord[256] = '\0';
  2180.         }
  2181.     }    while (!pbrk && bytes && !matched);
  2182.  
  2183.     if (matched)
  2184.     {
  2185.         recno = currec;
  2186.         stay = 0;
  2187.         copyrec (record, unch_rec, sizeof record);
  2188.         werase (errwin);
  2189.         touchwin (errwin);
  2190.         wrefresh (errwin);
  2191.     }
  2192.     else
  2193.     {
  2194.         sprintf (outbuf, "String %s not found", cp);
  2195.         errmsg (outbuf, SLEEP_TIME);
  2196.         stay = 1;
  2197.     }
  2198.  
  2199.     return;
  2200. }
  2201. /* simplified call to errmsg(), by using sprintf to load format */
  2202. /* sleep_time is not implemented and awaits cleaning up of the signals (?) */
  2203. errmsg (fmt, sleep_time)
  2204. unsigned sleep_time;
  2205. char *fmt;
  2206. {
  2207.     int y, x;
  2208.  
  2209.     if (windowed)
  2210.     {
  2211.         getyx (stdscr, y, x);
  2212.         wmove (errwin, 0, 0);
  2213.         wstandout (errwin);
  2214.         wprintw (errwin, fmt);
  2215.         wstandend (errwin);
  2216.         wclrtoeol (errwin);
  2217.         touchwin (errwin);
  2218.         wrefresh (errwin);
  2219.         move (y, x);
  2220.     }
  2221.     else
  2222.     {
  2223.         fprintf (stderr, fmt);
  2224.         fprintf (stderr, "\n");
  2225.     }
  2226.     /* signal problem ?? if sleep called
  2227.     if (sleep_time)
  2228.         sleep (sleep_time);
  2229.     */
  2230.     return;
  2231. }
  2232. /* simplified call to outstr(), by using sprintf to load format */
  2233. outstr (fmt)
  2234. char *fmt;
  2235. {
  2236.     if (dump) printf (fmt);
  2237.     else printw (fmt);
  2238.  
  2239.     return;
  2240. }
  2241. outch (ch)
  2242. register char ch;
  2243. {
  2244.     if (dump) putchar (ch);
  2245.     else addch (ch);
  2246.  
  2247.     return;
  2248. }
  2249. AlBeRtEiNsTeIn
  2250.