
               THE LOST POWERS OF SCRIPSIT

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

   In days of long ago there once did dwell Hidden Figures of strange and wondrous power in the Device of Scripsit. And in those days the people made great harvest and contrived in artful artifice many sentences containing iron brackets and leathern braces, and did so mark some words with underlying lines to make them sound more strongly on the ear. And all was good and words of power were written by all the people.

   But they grew slothful in their weavings of the words, and lost the art thereof. And powers of Rapid Scroll and Continuous Insert grew weak until the people used them not. And so there came then upon the minds of the Scribes of Documentation a cloud of forgetfulness. And these powers too were lost.

   Time out of mind, the people knew not the Lost Powers and used not the Hidden Figures. But the Powers and the Figures slept inside the Device of Scripsit, and waited for the time when men would need them once more. And they would then come forth.
                                                Folk Legend 
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Scripsit is the one of the best selling word processors for any computer. It is almost transparent, nearly bug-free, and easy to use. It is most everyone's first "Shack" word processor (apologies to Mr. Schrayer). The one you recommend to novices; the one your neighbor has; the one you never forget how to use.

If your introduction to Scripsit was the Model 4 version, you got a neatly indexed and completely straightforward booklet, some stickers for your function keys, a summary card, and a disk; all nicely packaged. You also got the result of five years of complaints from users of the Scripsit 1.0, 3.1, and 3.2 documentation.

The early Scripsit documentation was a big step up from the typical author-written documentation of the day: it was literate, and you never found yourself wondering how old the author was. On the other hand, it had no index, its summary card was designed for ants, and essential information was presented on audio-tape. Three hours of audio-tape. The dry, New England voice of "Mr. Scripsit" was a blessing to thousands of secretaries, and the bane of at least as many hackers. But still, it was essentially the same great program that it is today. 

So now that we know why we use it, here are a few things Tandy never told you about Scripsit.


RAPID HORIZONTAL SCROLL

The cursor can be moved very rapidly and very precisely by using the Repeat Command: <@R>. This is good for getting to specific places on the screen without having to set or reset tabs. For example, if you wanted to get to column twenty on the screen you would press <@R> 20 <ENTER>, and <RIGHT-ARROW>, and the cursor would move exactly twenty spaces to the right. The six keystrokes used to get to column twenty hardly seem worth the effort when you can get there just as well by holding down the arrow key until the cursor gets there. However, this technique becomes particularly handy when you've set the screen width for more than 64 columns and you need to put the cursor exactly on column 102. 

Rapid Horizontal Scroll also spans lines, just like regular horizontal scrolling. So, if you wanted to find the 240th character to the right of the cursor you would press <@R> 240 <ENTER>, and <RIGHT-ARROW>. 


RAPID VERTICAL SCROLL

Scripsit scrolls up or down the screen at a leisurely seven lines per second. If you use <@R> <ENTER> <DOWN-ARROW>, your cursor will move about six times faster. Instead of using the default of 255, you can specify how many lines to move. This is most needed when (for example) you want to find quickly the 113th line of a document: Put the cursor at the top of the document, press <@R> 113 <ENTER>, and <DOWN-ARROW>. Your vision will become blurry and your heart will race (with the cursor) down the screen to line number 113, which just happens to be the start of the third default page.

Want to be sure you are on screen line number one-hundred- thirteen? Just use the Cursor Position command: <BREAK>?C. This command and Rapid Vertical Scroll can get you back and forth in a document very nicely. You can also use the Cursor Position command to tell you where you are after you've made a Global Find command.

In using the Rapid Vertical Scroll or the Cursor Position Comand to find page-breaks, be careful to account for command lines, double spacing, and extra lines forced between paragraphs.


CONTINUOUS INSERTION

If you've ever used a word processor that toggles the INSERT Command, you have reason to make bad noises when Scripsit requires an insertion command <@S> for each letter or space insertion. 

Now you can insert a word, phrase, sentence, or short story in the middle of an already typed line, and do it quickly and easily. This technique involves combining the Repeat Command and the Insert Command. Just move the cursor to the point where you wish to begin the insertion, press <@R> <ENTER> <@S> and begin typing whatever you wish to insert. Everything in front of the cursor will be gently pushed ahead as you type. You can type up to 255 characters before the Insert Command expires. You can also interrupt the continuous insert mode at any time by pressing any of the arrow keys or the <ENTER> or <CLEAR> keys. 

This technique does require two more keystrokes than the one mentioned in the Scripsit documentation: <@S> <@X> to insert a blank line, and <CLEAR> to close up afterwards. But somehow it's so much more, well, elegant this way.


CONTINUOUS DELETION

This is a dangerous command because there is no stopping it once it starts. Press <@R> <ENTER> <@D> and <ENTER>. Your words will then crawl back into the cursor, madly word-wrapping themselves into oblivion. This can be disconcerting, especially if you are inclined to panic. Do this too near the end of a file, or in an empty new file, and you may find the place where old hackers go.


ABSOLUTE WIPE-OUT

Like Continuous Deletion, this is one control sequence that you probably do not want to use, and that will get you into trouble if you run across it by accident. It is <@T>. This command will sometimes dump you into DOS, sometimes put you into DEBUG, and sometimes just freeze your keyboard and play games with your screen. Some copies of Scripsit will just give an error message. This seems to be a leftover author's utility; a quick hook into the Scripsit code itself. While you couldn't really call this a bug, neither is it a desirable feature (although assembly programmers may find it useful.) Like other darker powers, this one should be recognized for what it is, and avoided. No other rituals are required.


GLOBAL COMMANDS

There are a number of commands and procedures in the Global Command function that are poorly documented or not mentioned at all in versions 1.x and 3.x. These include:

1. The use of the Global Find Wildcard, which is the question mark. Useful for finding all instances of everything. For example: <@R> <ENTER> <BREAK>F>?m?th<ENTER>, will find every smith, Smith, smyth, and Smyth in your document -- and also every mother, myth, and Samothracian. Other uses might be to find all variations of a control code, a range of dates, or all zip-codes within a Sectional Center Facility.

2. The use of characters peculiar to Global Command procedures, such as the Copy Marker character (^), which you can produce on the command line by pressing <UP-ARROW>; and the first character in Block Markers ([), which you can produce on the command line by pressing <@Q>; and the last character in Block Markers (]), which you can produce on the command line by pressing <@><DOWN-ARROW>. 

3. The fact that all boundary markers (line, paragraph, copy, and page) can be Globally replaced, deleted, found, or counted. In case you've forgotten, the ubiquitous line boundary marker (the square thing you get when you press ENTER) can be produced by entering <@X> . . . even on the command line.

4. The fact that all Global Commands can be combined with the Repeat Command to make multiple changes throughout the document at the same time. This is particularly useful for preparing raw ASCII files for transfer between word processors or for modem transmission.

   (And for you Model 4 users, too . . .)
5. The fact that you CAN get a word count. Begin by Saving the current file. Then: 
   <@R><ENTER> 
   <BREAK><R>(two spaces)>XX<ENTER>
Repeat this procedure until you reach the end of the file. Then return to the beginning and:  
   <@R><ENTER> 
   <BREAK>F>(one space)<ENTER>
Repeat until you reach the end of the document, and keep a tally of how many were found. Then reload your original file. The first series of commands replaces all double blank spaces with strings of Xs. The second series of commands counts the single blank spaces that are left: the ones between words.


BUILDING "MACROS"

Many word processors are very proud of their ability to make Macros. A Macro is a function that makes a large group of predetermined characters appear, or an entire command sequence begin, just by entering one or two keystrokes. 

Scripsit has always been able to do this.

Scripsit's Macros are, of course, the Block Commands. You can use any character on the keyboard as a MACRO key, except the P, H, F, -, or any lower case letter of the alphabet. Naturally, the arrow, <ENTER>, and <CLEAR> keys are also out. That leaves about 58 characters including numbers and symbols, each of which can be used as a block marker -- and each block marker can contain up to the amount of text that can be put in memory. Keeping a library of 58 Macro commands straight is your problem.

Many writers find it useful to put "boilerplate" (frequently used blocks of text) inside block markers, and save that block, or an indexed group of such blocks, to a special file. Then whenever they make a document needing that "boilerplate" text, they chain the special file to the end of their document and use the Insert Block command to put a particular MACRO wherever they want. (Just remember that whenever you use the Load-Chain Command, the default filename for the file you are working on is changed too.) 

Another good use of Scripsit Macros overcomes the complexities of Headers, Footers, and special Print Formats. How many times have you had to dig out the Scripsit manual to figure out how to put centered page numbers at the bottom of each odd-numbered page? What about the format for skipping headers and perforations on continuous letterhead? or keeping the ink off your platen when using a sheet feeder? Why not put each of these headaches in its own special block marker, and then put all the Print Formats in one file, all the Header Formats in another, and the Footers in yet another. Whenever you need one, just chain it onto the current document, use the Insert Block Command to put the Macro of your choice where you want it, and delete the dross. If you need these more than once, you need a set of MACRO files.

An extension of this idea is to develop your own HELP file of useful but little-used Scripsit procedures. After all, your Scripsit system disk is usually a lot closer (and more helpful) than your Scripsit manual. 


EDITING BASIC WITH EARLY SCRIPSIT

Owners of disk version 3.2 and higher enjoy the use of Scripsit as a full-screen BASIC language editor. Owners of earlier disk versions (even if converted from tape) can do the same by following a few simple precautions.

Keep your program lines less than 240 characters long. (Your Rapid Horizontal Scroll works well here.)  It seems that more than 240 characters per line in an ASCII-saved BASIC program may rouse the dreaded "Direct Statement in File."  Before saving your BASIC program, be sure to remove all Scripsit text markers, and make sure there is a line marker at the end of each program line. Then add at least three extra lines to the end of your program. They should have legitimate line numbers, but contain only filler data. This will pad your file so that the last sector of REAL data will not be lost when you load it in BASIC.


REVEALING THE HIDDEN CHARACTERS    (Model 4 users excused)

You can create 10 characters that you probably didn't know Scripsit could produce. These are the right and left braces and brackets, the backslash, the vertical bar, the tilde, the underline, the circumflex, and the plus/minus: {}[]\|^_~. These are produced by using the capital or lower case character Y as a control key and pressing two numbers simultaneously. For example:

Y13 = [     Y14 = \     Y15 = ]     Y16 = ^     Y17 = _    

y13 = {     y14 = |     y15 = }     y16 = ~     y17 =    

When you enter any of these sequences, you also get some garbage along with your new character (an extra "Y" and some numbers). To use your new characters effectively you will have to remember each command (or find it each time by trial and error), and then manually delete the surrounding garbage. . . Or you can do it the easy way and use the Special Character Macro system described below. But first:

Because new functions can be dangerous if not used carefully, it is necessary that you stop here for a machine-language mini-tutorial. When you use any Scripsit command that leaves a text or boundary marker on the screen, the mark that you see there is not really an ASCII character, but is a specially coded symbol that will not print and that performs both screen and printer formatting commands. Your new special characters are not like this at all: they are simply ASCII characters, the same as any letter or number. That is, the End of Block character is not the same as your new right bracket character and they are NOT interchangeable. The same is true of the new backslash, which looks like (but is not the same as) the page boundary marker gotten by pressing <@V>; and of the circumflex, which looks like (but is not the same as) the copy marker gotten by pressing <BREAK> C <ENTER>. This is also true of hyphens produced by Scripsit's automatic hyphenation procedure. The point of this mini-tutorial is that if you don't watch your language, the machine will get you.


USING THE SPECIAL CHARACTERS

This is useful for ALL versions of Scripsit, because three logically mnemonic commands are easier to remember than ten randomly assigned ones.

Starting with an empty file, create the new characters in the following sequence and delete all of the surrounding garbage so that the result looks like this:

[{     }]       \|^_~ 

Then put the new characters in block markers, as follows:

[B> [{ ]
[E> }] ]
[O> \|^_~ ]

Next, save this small file of new characters to your system disk, perhaps using the filename "FIGURE."  Now, whenever you want to put a phrase in brackets or braces you can easily do so. Just chain the file FIGURE onto the document you are working on (<BREAK>L,C FIGURE), and then use the INSERT BLOCK command to put the beginning [B> and ending [E> brackets or braces right where you want them. You can use a block containing all the other characters more easily than you can remember which control code makes a tilde.

What are all these goodies good for? Probably not your shopping list. Often, their use depends more on your writing style than on any real need for them. After all, your notes to the milkman don't require diacritical markings. . . unless he forgot the butter AGAIN. If your parenthetical asides need bracing (and every issue [big {especially!} or small] has them), then you're all set. If you write like Vonnegut they make nice paragraph separators.

                ~~~~~~~~~~~~~~~~~~~~~~~~~~~  

A FULL-SCREEN EDITOR FOR C

Now that you have brackets and braces available in Scripsit, you also have a full-screen editor for C language programs. Users of versions 3.2 and earlier should follow the procedures mentioned for editing BASIC programs. (And while you're at it, make another block marker which contains five blank spaces to use for uniform indentation of program loops, recursions, and comments.)


THE UNDERLINE

The underline character is useful in making printed forms; and, with some effort, it can actually be used to underline things. In either case you will need to add a string of underline characters to your FIGURE file. The easiest way to do this is to get in the CAPs mode, hold down the letter Y, and repeatedly and simultaneously hit the numbers 1 and 7, say about seventy times. Then go back to the start of the line and press <@R><ENTER>, and then <BREAK> D>7 <ENTER>. All the numeral 7's should have disappeared. Delete the 1's and the Y and all you have left is a continuous string of underline characters. (Model 4 users should not sneer.) You can put a Block Marker around this line and add it to your FIGURE file, so that it looks like this:

[B> [{ ]
[E> }] ]
[O>\|^_~]
[L>_______________________________________________________]

Now, whenever you wish to put a string of underline characters in a printed form, just chain FIGURE to the end of the document you are using and insert the block of underline characters wherever you want.

You can underline words in much the same way. But first you must set your printer to produce a carriage return without a linefeed. You will have to change the DIP switches inside some machines. Some Radio Shack printers come set this way, and those of you who have them use the LPC/CMD to overcome this "feature." If you are one of these pioneers, just this once don't LPC, see?

Now that your printer is set, begin the document with a format line that includes a command to give you SINGLE-spaced text: LS=2. Then, put boundary markers at the beginning and end of the screen line that contains the word(s) you want to underline. Immediately before this line, insert a format line that includes a command to suppress linefeeds: LS=1. Immediately after the line to be underlined, put in another format line which returns the linefeeds: LS=2. Then insert your block of underline characters, with another boundary marker at the end, and erase the portions you don't need. On the screen it should look something like this:
 >LS=1
 Every other word in this sentence is underlined.
 >LS=2
      _____      __      ________    __________

and on the page it should look like this:

Every OTHER word IN this SENTENCE is UNDERLINED.

You may have to experiment to find out what works for you. But hey, that's hackin'!


ROMANCING THE LANGUAGE

The tilde(~) and circumflex(^), along with the stress mark (') and the cedilla (,) are useful if you are writing in any of the Romance languages, and can be produced the same way you underline words: by suppressing a linefeed and over-printing a line containing only the carefully placed accent mark. Model 4 users also get to have an grave accent (`), which now becomes the only advantage of Model 4 Scripsit over Models 1 and 3. 


CONVERTING THE LANGUAGE

When converting Scripsit files to work with other word processors, all of Scripsit's non-ASCII characters (its boundary and copy markers) must be removed or replaced. Many word processing programs use ASCII backslashes, bars, or circumflexes where Scripsit uses its tokenized line, paragraph, and page markers. You can replace all of the Scripsit boundary markers with whatever the other program requires by using the Repeat and Global Change commands. Unless you have a Model 4 version, you will then have to examine each replacement and remove extraneous Y's and numbers. Of course, almost all word processors provide a conversion program specifically for Scripsit files, but some things just need to be said. Besides, some of us have unusual needs.


INVISIBLE CHARACTERS ()

This strange little fellow will show up on your screen, but probably cannot be printed. It won't even appear on the paper as a space. If you find a use for it, let me know. If you want to actually print the plus/minus character on paper, you can do it by simply underlining a plus sign (or plusing an underline character.) You can also use this procedure to make new characters of your own device:   /\|  ><^  |^_


PRINTER DIFFERENCES

If you have a daisy wheel or thimble printer you can use the new Scripsit characters to print the copyright, trademark, registration, dagger, swirl, degree, and paragraph marks, depending on your wheel or thimble. If your dot matrix printer has different fonts, it may find new forms for your new characters. 


EXPANDING THE BUFFER

When you type a document in Scripsit you fill up a buffer. When you reach the end of the buffer, that's it. No More Room. Even if you have only a few more words to go, Scripsit won't let you write them. 

But wait! You CAN expand the buffer, or at least expand the room inside the buffer. First clear the blanks at the end of the file: <@D> <@F> <CLEAR>. Then reset the screen to the maximum width possible: <BREAK> W=132. Now you probably have a little more room. Scripsit uses one extra character of memory for each screen line, so the fewer screen lines, the more room for your text. This sometimes works for the Disk Full error message, too. However, remember that Scripsit files are most fragile, most easily lost, when they are very long or when your disk is crammed full. Even on a tape-based system, long files ask more of the system than short ones. So, even if Tandy documentation doesn't say so: Short is good.


FINDING NEW POWERS AND FIGURES

Please drop me a note if you find any undocumented techniques I've not discussed here. I'd also be interested in hearing from you if you've found this article of use.

Eric Bagai                                    March, 1987
P.O.Box 9747
North Hollywod CA 91609
                                                                                                                                                                                                                                                                                           