TAVERN - Tertiary Acme Verbalisation, Epistle and Recall Nucleus.

For those unable to decode the title, TAVERN is a quite powerful prog for verbalising, sending epistles and recalling the same. It has categorised information storage, a powerful multi-line character-based communications module, built-in job status features, VDU control facilities, a line-based communicator, Inter-Process Communication Facility handling via the Programmable Software Interrupt system, an automatic reply system with scratch pad, an accounting file, etc etc... in all, a right abortion.

Access to TAVERN is on an Id basis; each user has either one or two Ids, which uniquely identify him/her/it both to TAVERN and to the other users. This two-Id system was decided on as the best way to distinguish between a "CASUAL" and a "REGULAR" user - the former is a person/object who just wishes to access the "OPEN" section of TAVERN, the latter a user of the "CLOSED" section. These sections are explained below. A casual user can have any old rubbish as an OPEN Id; CLOSED Ids are stored along with other junk in the info file. One important part of this other junk is a Password for each CLOSED Id. Further reference to the OPEN Id will be as "OPENID"; a Closed Id is called simply an ID.

Given an OPENID, a Casual user can access the Closed section by using the ID "ANON"; the Password to this is null (i.e. type <CR>) which allows a limited set of the Closed commands. Also, a number of OPEN-section commands aren't allowed without an ID - naturally, these are the naughty ones. A Casual user, who has obtained an ID of "ANON" is still considered to be a Casual user despite having a Regular ID, and cannot access those OPEN-section commands which require a Regular ID.

The Closed section contains the Info, Recall and Message system. All other functions are considered to be Open-section. Open-commands can be typed to the Closed-command processor, but not vice-versa (nor, for that matter, the other way round). Some Open-commands cause a return to the Open mode if they parse correctly: in this case, standard Closed-EXIT functions are performed.

Commands are divided into 6 categories: INIT, SET, ACTION, MODE, CLOSED and TEXT. They are generally defined by where they can be typed; the first four are collectively called Open commands, and have a similar form - that of switches, although the initial slash may often be omitted (or put in - suit yerself). There are 6 ways of typing commands to TAVERN (though they don't necessarily correspond to the 6 command types):

1) As switches in SWITCH.INI addressed to TAVERN (surprised?);

2) On the RUN-command line as switches prefixed with a "-";

3) To the Open prompt "/", omitting the first "/" if you so desire;

4) In Chat mode, with "/" as the first character on a line;

5) To the Closed prompt "*";

6) In a text input frame.

All the commands can be uniquely abbreviated; many have single-character forms for brevity.

INIT commands.

Surprisingly enough, these commands are legal only at initialisation, and set up a user profile. They may be typed only in modes 1 or 2 (SWITCH.INI or RUN-command) and give an error message otherwise.

/ID:id

Searches the ID table for this ID or a valid abbreviation, then checks the full ID as an OPENID. Asks for the corresponding password, and if everything is OK, sets up both ID and OPENID. Grants appropriate privileges. ANON is not a valid argument. Putting this in SWITCH.INI is the easiest way of getting into TAVERN.

/OPENID:id or /O:id

Checks the OPENID for legality (see below) and if OK sets it up as an OPENID in the table for you. Grants no privs.

If no /ID or /OPENID is done, TAVERN prompts for the OPENID with "Id:" to which an OPENID must be typed before proceeding. Both Ids are up to 12 SIXBIT chars, except ":", "/", comma or dot. The first character must be non-numeric. When specifying an Id as a tag for another user, a unique abbreviation suffices. So, to specify ID="FRED" and OPENID="KING#FRED", a possible command string could be:

.RU TAVERN-/ID:FR/O:KING FRED/....

/ENTRY:type

Sets verbosity of entry. "type" is one of SILENT, LOUD, QUIET or NORMAL. Currently, NORMAL=QUIET; this produces a short message to other users when making contact. LOUD produces a one-line short SYSTAT saying who, job, PPN etc. SILENT gives no message for a sneaky entry. Casual users may set /ENTRY, but it has no effect - they are always /ENTRY:LOUD.

SET commands.

May be typed anywhere except in a text frame. Have no effect on the basic mode, and perform no action except their set function. Divided into two categories: argument and no-argument.

/AUTOREPLY:arg or /A:arg

Sets up an automatic reply feature invoked upon receiving an epistle (in /M mode). The arg is one of: NONE - disable autoreply (default); SINGLE - autoreply after each epistle; USER - autoreply after all messages from any one user; JSINGLE - as SINGLE, and also enable the jog feature; JUSER - as USER with jog. The jog feature is a fixed block of short strings cleared at startup and after each autoreply; TEXT commands manipulate input/output of jogs, and TAVERN prompts with "Jog?" upon encountering a received jog-break and also at the end of each message. You may then type in a memory-jog as if you had a scratch pad by your side. Use of the TEXT commands return successive jogs on a FIFO basis.

/MSGLVL:arg

Sets up the usual message level. Arg is PREFIX, LINE or BOTH.

/TTTYPE:arg

Does the equivalent of a series of cursor-control commands to set up the terminal type. Current args are TTY, NLAB and VISTAR. Others on request.

/ADD:arg,arg,arg,...

Adds the specified args to the /TRACK output.

/SUB:arg,arg,arg,...

Removes the specfied args from the /TRACK output. Possible args: TIME, JOB, TTY, PPN, USERNAME, PROGRAM, CORE, STATECODES and PRIVS. Also ALL. Initially JOB, USERNAME, and PRIVS are Off, others On.

/COMPARE:arg,arg,arg...

Sets the items compared during a /TRACK. Initially TTY, PROG, CORE, STAT and PRIV; omitting the argument resets this.

/TIME:n

Sets time between passes during a /TRACK, in ms. Initially 3 secs.

/IRUBOUT:arg

Sets the string for rubouts typed in during a text frame and /C. Defaults to "__".

/ORUBOUT:arg

Sets the string for rubouts output during /C only. Defaults to "__".

/CNTLU:arg:

Sets the string for a control-U during a text frame. Defaults to "XXX".

/CNTLR:arg

Sets the control-R string for a text frame. Defaults to 0+CRLF. The first word is the delete string for the characters "^R", the second word is the string to return to the start of the line. Args to the cursor controllers are either "N", "N1+N2" or "A,B,C,..." where N is an octal representation of an ASCII string, up to 5 chars, shifted right one binary place; N is output as such. N1 and N2 are in the same form as N; N1+N2 (concatenated) is output as such, but N2 is also regarded as a distinct string in ^R (see above) and also IRUBOUT, where N2 is output by itself at the beginning of a line to remove the blob generated by some VDUs. A,B,C etc are octal characters, up to 9 of 'em. The 6th to 9th are treated as N2 in the string representation. Eg: for a VDU with ^H as a backspace and also a blob, /IRUB:10,40,10,0,0,10,40,10 does the job. Be careful with the ^R string, because it gets typed in odd places during a text frame.

/LOUD and /NOLOUD (default)

Makes all NORMAL/QUIET LOUD if set.

/ALLGENERALS and /NEWGENERALS (default)

If /ALL, all general messages in the info file are typed. /NEW types only those not yet seen. ANON users have /ALL set by default.

/L or /LEAVE and /D or /DELETE (default)

If /D, epistles are automatically flagged for deletion upon exit from Closed mode. /L gives a Y or N option; ANON is /L by default.

/NAMES (default) and /N or /NONAMES

If set, the OPENIDs of new typists (or even one-finger wonders - we don't discriminate against them) on your Chat line are typed.

ACTION commands.

These are mid-way between SET and MODE commands, in that, although they cause TAVERN to perform a function, they don't change the mode, and TAVERN continues prompting the same (if it was in the first place). Note that any MODE or ACTION request removes an earlier request in the command string, and TAVERN determines it's new MODE or ACTION at the end of the command.

/WHAT:id or /W:id

Performs a one-line stats of the Id if it exists. If the arg is omitted, a headed /W is done for all current users.

/GENSTS or /G

General status of TAVERN.

/JOB:n or /J:n

Stats on job n. Format is /ADD:ALL/SUB:TIME. If arg is omitted, all jobs done.

/TTY:n or /T:n

Stats on TTYn. Format as /JOB.

/KILL:id

Kills the specified user (exit only at present) (priv'ed to /ID'ed users).

/BANISH:id

Does /KILL, but also places the killed user's PPN as the first entry in the bad PPN table so he/she/it don't try it again till TAVERN's reloaded.

/OPTION:opname

Not really an ACTION command, but closer than any other type. Gets and does SWITCH.INI option "opname". Compatible and non-destructive but not nestable.

/SEND:arg:message or /S:arg:message

Sends a message via IPCF. Message is rest of line (40 chars limit), arg is an OPENID, a job number or null (i.e. /S::mess) for the last job or Id.

MODE commands.

These set the basic mode; any previous mode is terminated, and the return from the mode (if any) is to the "/" prompt. MODE commands can be typed anywhere except in a text frame, and are executed at the end of a command string; any MODE command removes earlier MODE and ACTION settings.

/EXIT or /E

Returns to monitor, after performing miscellaneous TAVERN functions. No return.

/HELP or /H

Types this crap, then returns to "/".

/TRACK:job

Tracks the specified job. Time, output and comparisons are set by /TIME, /ADD, /SUB and /COMPARE. Continues track until a character (preferably a space) is input, then returns to "/".

/CHAT:id or /C:id or /C

If no Id is specified, connects you to the public Chat-line, and enters Chat mode. If an Id is given, then:

1) If the user with that Id isn't chatting, or is chatting on the public line, find another line which is free, and connect to it;

2) If the other user is chatting on a non-public line (note that non-public and private aren't the same thing), check whether it's a private line or not - if not, connect to it, else error;

3) Enter Chat mode. In this mode, typing "/" as the first character on a line will allow you to type in an Open-command. If a MODE is set, Chat mode is terminated, otherwise it is continued.

Please note that:

1) Echo gets switched on and off during typing, so if the system is loaded, echo may seem slow;

2) You can't input when someone else is typing;

3) There is no full-buffer check;

4) Checking for dead jobs only occurs at odd intervals;

5)There is a variable time limit between wake-ups, and a 15 second grace;

6) Only rubout has any effect on cursor positioning;

7) There is optimisation for fast typists.

/PCHAT:id or /P:id

Must have an Id. Sets up either a private or a pending-private line to that user: pending-private lines become private as soon as another user does a /PCHAT to that line, and can be made non-private using /BREAKIN. A pending-private line does not become private until 2 /PCHATs are done, and hence more than 2 users can use a private line by a /PCHAT,/CHAT,/CHAT.../PCHAT sequence.

/BREAKIN:id (priv)

Makes the specified line non-private, then does a /C:id.

/MESSAGE:spec or /M:spec or /MESSAGE or /M

Enters CLOSED mode. If no ID is set up, asks for one+password; outputs either to the file specified (default is DSK:HHMMSS.TVN[,]) or to TTY if no spec. Reads the info file into core, then scans through outputting relevant stuff, doing autoreplies, jogs etc etc. Types "*" and waits for a CLOSED command.

/SMESSAGE:spec or /SMESSAGE

As /M, but also types on TTY who else has epistles. Exactly the same as /M for ANON.

/AMESSAGE:spec or /AMESSAGE

As /M, but also asks for a new password after verifying the old one. Not for ANON.

CLOSED commands.

These are typed to the prompt "*", and are verbform. Open-commands may also be typed to "*", as switchform. MODE commands perform a "*EXIT" before altering the mode. Sections of the CLOSED-commands can be delimited as shown, or by breaks (CR, ALT etc) in which case TAVERN prompts for the other portions of the command. Spaces are often significant.

*SEND id,id,id,...:message

Sends an epistle to all the IDs given, consisting of the text "message". If ":message" is omitted, a text frame is initiated. IDs are not checked for repitition, so if the urge takes you, then you can send the same message to one user up to 36 times.

*DSEND spec id,id,id...

As *SEND, but the message comes from the file set up by spec.

*GENERAL message

Sends a general message. *GEN by itself initiates a text frame.

*DGENERAL spec

As *GENERAL, but message comes from the file "spec".

*EXIT/sw

Exits from CLOSED mode. /sw may be omitted, in which case all received epistles which are flagged for deletion are deleted, any general messages over their expiry date are deleted, any KILLed info is deleted; the remaining text is written back to the info file. This is done when a */command is performed which alters the mode, e.g. */CHAT. Switches are: /LEAVE - any epistles or general messages are left undeleted; /QUIT - leave file in it's original state (including password if /AMESS was done); /EXIT - exit to monitor rather than to "/". Note that /LEAVE does not preserve KILLed info - /QUIT must be used.

*CATALOG class

Does a listing of all info of the specified class, which may be null to catalog all classes. "class" can be abbreviated in all commands.

*QUERY title-start

Does a listing of all info items with titles beginning "title-start", which may be null: this types available info classes.

*KILL class title

Flags the specified info item for deletion. This can only be done when you are the author of the info. A full title spec is needed.

*TYPE class title-start

Types the specified infos, if they exist and you are PERMITted to access them.

*DTYPE spec class title-start

As *TYPE, but out to file "spec".

*OUTPUT spec class title-start

As *DTYPE, except waffle about author etc is omitted. For easy updating. Note that this command still types multi-info, so if too few characters are specified as the title-start, more than one info may be output.

*INFO class title

Enters info as a text frame, and then does a *PERMIT ALL on it.

*XINFO class title

As *INFO, but does *FORBID ALL instead.

*DINFO spec class title

As *INFO, but the text comes from the file instead of a text frame.

*DXINFO spec class title

Do i really need to say?

*FORBID id,id,id,...:class title

Forbids the users specified access to that info. ALL is a valid ID here. If ":class title" is omitted, the last info accessed by any INFO-style, TYPE-style or FORBID/PERMIT command is assumed. Legal only if it's your info.

*PERMIT id,id,id,...:class title

As *FORBID, but the users are permitted access.

*USERS

Types list of CLOSED Ids. Illegal when ANON.

An info title can be any characters except breaks, up to 39 of 'em. Some commands accept an abbreviated title; any info title is considered a match to this if the first chars of the title match those of the abbreviated title. Other commands require the full title. A special info class PRIVILEGED exists which no ANON user can access despite settings of FORBID/PERMIT.

TEXT commands.

TEXT mode is initiated during CLOSED mode either in response to a command or as an autoreply. TEXT commands are simply control characters, and also rubout. Most are standard. the usual ones are sort of a conglomerate of TOPS-10, TOPS-20 and TECO with a bit of DDT thrown in for good measure. All non-control chars are taken as text to be input to the frame; those control chars with no defined function are generally treated as text, but may not be at some future time. (like as soon as i can figger out how else to use 'em)

RUBOUT

Inputting a rubout causes the following: If the cursor is as the start of a line, the second half of the IRUBOUT string is typed, removing a possible blob; else, the entire IRUBOUT string is typed and a character is removed from the frame. The exception is when the IRUBOUT string is "__", in which case the character being deleted is echoed.

Control-A

Causes the frame to abort; returns to "*" or else continues if the frame was initialised as an autoreply. Jogs are not cleared.

Control-Z

Terminates input of the frame, and flags a jog.

Control-U

Deletes the current input line, and types the CNTLU string, or "XXX" if it's null.

Control-R

Types the CNTLR string, or CRLF if null, then retypes the current input line.

Control-W

Performs a series of rubouts, until either the beginning of the line is reached, or a space would be deleted, i.e. deletes the last word. Note that if the IRUBOUT string is "__", then that is typed.

ALTMODE

If jog isn't enabled, an error message results; else the next jog that was input in response to "Jog?" is typed, and ^P is simulated.

Control-P

If this isn't the first jog that's been input, flag a jog. Perform a MIC TYPE of "About " and carry on inputting.

If any bugs decide to crawl from under their stones, then please inform CONTROLLER of this if possible, else tell one of the authors. (However, in this case, beware the magnitude of derision and scorn that this will probably entail)

             Many thanks.

         [End of TAVERN.HLP]