Qedit Commands

Introduction

Qedit operates in Line mode or Visual mode, depending upon the type of terminal. The same commands are used in both modes. In Line mode, you do everything with commands. In Visual mode, you do most editing with built-in functions of your terminal, but use commands for some things. Line mode commands work in Visual mode, and Visual mode function keys work in Line mode.

Here we describe the Qedit commands in alphabetic order. For each command, we show both the longest and the shortest name that Qedit can recognize, as in Add [A]. Highlighted terms (e.g., linenum) and jargon words (e.g., "workfile") are defined in the "Glossary". The Visual command is described only briefly in this section: see the chapter "Getting A Quick Start with Full-Screen Editing" for full details.

General Notes

Here are general guidelines that apply to using the Qedit commands.

Abbreviations

Each Qedit command has a name such as List that you can abbreviate to any leading subset. Thus, L means List. Some commands require more than one letter: GARbage, DEStroy, RENumber, SHut, VIsual. You may append option letters to the command: Q, T, or J. Q means "quiet", T means "template", and J means various things, depending on the command.

list all {fully spelled out}

l @ {maximal abbreviation}

lq {list quietly}

listqt {list quietly, with template}

lqjt {list quiet, jumping, with template}

list $ {most recent external file name}

s dec on {Set Decimal command}

sh {Shut command}

Uppercase or Lowercase

You can enter the commands in uppercase or lowercase. These commands are identical:

LIST ALL {uppercase}

list all {lowercase}

Multiple Commands per Line

You can enter several commands on a single line, if you separate them with semicolons. The maximum command line is 256 characters, and & is not supported for continuation. If you want to have an MPE command or a calculator command in the stack, you should enclose it in parentheses. This prevents Qedit from passing the rest of the line as parameters. For example,

List 5;Listspf o ;seleq=[owner=mgr.acct];List 4 {fails}

List 5;(Listspf o ;seleq=[owner=mgr.acct]);List 4 {works}

If the syntax requires semicolons and parentheses, you have to put the problematic command in a command file, a UDC, or set it in a MPE variable and use it in the command list instead.

Any error causes Qedit to flush the remaining commands in the line.

list 505;add *-1 {list line 505; add just before it}

shut;stream job23

When combining Qedit commands, be certain to use the same quote character in all the commands.

Wrong:

/c7/7"DISPLAY";c\.\\

Right:

/c7/7"DISPLAY";c".""

Comments on Command Lines

You may annotate Qedit commands by putting comment text in curly braces at the end of the line:

keep sample,yes {update disc file}

Such comments are recognized at the "/" prompt, in usefiles, command files, and UDCs (of course, MPE won't like them!), as well as Visual's home line and Next? prompt and List's More? prompt. In command files and UDCs the {comment} may appear on continuation lines, before or after the "&".

STREAMX Warning

STREAMX is a product from VESOFT that permits you to build flexible job streams. STREAMX contains a complete programming language with loops, prompts, and parameter substitution. A problem arises when trying to enter comments into a Qedit batch job that will be submitted with STREAMX. Qedit uses the {...} pair to delimit comments. STREAMX uses these same characters for expressions.

You cannot change Qedit's comment character, but you can change the {...} characters in STREAMX. The following example changes the STREAMX expression characters from {...} to ~...~:

!job helpfile,user.acct

::setbraces ~~

!comment Purpose: This job stream uses the QLIB tools

!comment Prose and Qhelp to create

!comment a helpfile from a user manual.

!comment

!purge ~product~.help.acct

!setjcw outhelpcomp=1

!run helpcomp.qlib.robelle;parm=3

~product~.doc.acct

yes

~product~.help.acct

!release ~product~.help.acct

!run qedit.pub.robelle

open ~product~.help.acct

list .beginkey (U) {optimizing pointers for speed}

exit

!tell ~hpjobname~,~hpuser~.~hpaccount~;Help created!

!set stdlist=delete

!eoj

Stopping Commands with Control-Y

You can stop most Line mode functions by pressing the Control-Y key. For example, to stop an inadvertent List ALL, use Control-Y. To stop the Add, Modify, or Replace commands, use either Control-Y or two slashes (//).

Implicit Commands

Some commands have no alphabetic name. In Line mode, pressing only Return means display the next line and a backslash (\) means display the previous line, $ means enable Memory Lock and $- means disable Memory Lock. In either mode, ? means Help, any line number means go to that line, a string means display the next line with that string, and "^" means search backwards for a string:

55	find and display line 55 or higher
FIRST	find and display first line
;;;;	display the next 5 lines
\	display the previous line
-5	move current line back 5 lines
"string"	display next line with string
^"string"	display previous line with string
$	turn on memory lock at this line
$-	turn off memory lock

Function Keys

Qedit accepts the eight user function keys of HP terminals as one-keystroke abbreviations for useful functions:

F1	Go into Visual; Update/Getnext if in Visual
F2	Roll the screen up 6 lines; browse
F3	Findup (find previous line with current string)
F4	Find (find next line with current string)
F5	Browse Backward One Page
F6	Browse Forward One Page
F7	Listredo (line) or execute ===> line (Visual)
F8	Exit from Qedit or Exit from Visual to Line mode

^1 through ^8 are another way of invoking the user function keys in Line mode.

Command Files and UDCs

Qedit executes MPE commands, UDCs (see Set UDC), and command files, whether they start with a colon (":") or not. Your UDCs must first be activated in Qedit using the Set UDC command.

MPE Commands

Qedit accepts most MPE commands, including Run commands, User Defined Commands, command files, and Implied Runs, with or without the colon. You only need the ":" if the MPE command is also a valid Qedit command (e.g., :help requests MPE help). Beware of some unobvious Qedit commands composed of abbreviations and options. For example, PRT is interpreted as a Qedit command (Proc with the template option) so you must put a colon in front of it to have Qedit execute it as a User Command. Any MPE command causes Qedit to post to the disc all changes to your current workfile.

Examples

/listf abc.source,2

/list abc.source 5/10;listf abc.source,1

/fcopy from=abc.source;to=

/:showtime

/showjob

/file bobtape;dev=tape

/stream abc12.compile {stream Qedit files, *}

/showcatalog {see Set UDC command}

/:help listf {colon is recommended}

/:help udcname {see set UDC}

/compile * {Set Lang decides compiler}

/cobol abc.source,,lp

/prep $oldpass,abc12.prog;pmap

/run abc12.prog;lib=g

/dbutil {implied Run dbutil.pub.sys}

/segmenter

/display Print this message on the screen.

/pause Press Return when ready to continue:

/tdpdraft * {invoke Scribe on Qedit file}

/reflect dir {Reflection PC command}

/qhelp qlib.help.robelle {get Robelle Help}

Differences from MPE

The Break key will not stop Qedit in the middle of a long :Listf or other command. You may want to use :Break and :Resume to do a long :Listf. Control-Y sometimes stops a :Listf on certain versions of MPE/iX, but generally Control-Y doesn't stop most commands. Control-Y does stop a compile if the compiler has been "fixed" to use our interface routines to read Qedit source files. The Qedit syntax for Prep and Run is more forgiving than in MPE; you can abbreviate the keywords, leave out the commas, and use default parameter values. Qedit adds a number of new commands that MPE forgot -- Reflect, Display, Pause, Activate, Kill.

Unlike Qedit commands, MPE commands cannot normally be shortened, and only one may be entered per command line. You will find MPE commands handy to check files (listf), to check users (showjob), to redirect files (file lp = $stdlist), to compile without leaving Qedit, to :Prep (or :Link on MPE/iX), and to :Run programs:

/listf

/file lp;dev=serialp

/cobol *,,lp

/prep {$oldpass to $newpass by default}

/run {defaults to $oldpass}

Calculator Commands

Any command that begins with an equal sign (=) is treated as a calculator expression. This feature can be used to compute temporary values and do conversions from one number base to another.

=64,O

Result= %000100

QEDITCOUNT JCW

Qedit has a JCW (like a variable) that keeps track of how many lines were processed by the last command: QEDITCOUNT. This JCW is updated after those commands that can print a total: List, Delete, Add-file, Add-move, Add-copy, Append, Change, Divide, Glue, Justify, Keep, Merge, Proc, and Text. The line count is truncated at 32,000.

/deleteq "$page"

29 lines DELETED!

/showjcw qeditcount

QEDITCOUNT = 29

QEDCURWFILE Variable

Qedit updates a variable, QEDCURWFILE, with the name of your current or last workfile. The name in this variable is the same as the name substituted when you use "*" as a parameter in a User Command. This gives you the ability to reference the current workfile easily from within a User Command without having to pass it in as a parameter.

External Program Commands

If you define an external program such as MPEX with the Set Extprog command, you can then send it commands by prefixing them with a percent sign (%). When the external command completes, you return to Qedit.

/set extprog main.pub.vesoft

/%!altfile @.@;squeeze;extents=1

:Activate Command [AC/:A]

Awakens one of the programs that you have held in Qedit. See also Kill.

:ACTIVATE [ progname [,entrypoint] ]

(Defaults: most recently used)

The progname must be the name of a program file that you ran within Qedit, that suspended on exit, and that you held. The default is the program most-recently used. You need not spell out the entire program file; you may shorten the name to any substring. Use Verify Run to see what programs are ready to be activated.

Examples

/run suprtool.pub.robelle

>base xx;get yy;list;xeq {do Suprtool task}

>exit {return to Qedit}

End Run

SUPRTOOL is still alive. Okay to HOLD onto it [no]?yes

/list all... {continue editing}

/ac supr {activate Suprtool}

SUPRTOOL.PUB.ROBELLE

>get zz;list;xeq

>exit

Program Held. Use :Activate/:Run to rerun.

Add Command [A]

Adds lines into the workfile. There are five varieties of Add that cover all the ways you can add lines into a Qedit workfile:

NEW	Add new lines to your workfile from Stdin.
STRING	Add a new line from the command prompt.
COPY	Copy lines from one place to another.
MOVE	Move lines from one place to another.
FILE	Bring lines in from an external file.

Add (Adding New Lines)

Add some new lines from the terminal keyboard. Insert them at a given line number or after it.

ADD [ linenum ]

(Q=no linenums, J=justified, T=template)

(Default: linenum = *)

The linenum parameter specifies where to add new lines and also determines the increment between new lines. If linenum is 9.1, lines will be incremented by 0.1; if 9.01, then 0.01. If linenum already exists, Qedit increments it and begins adding after the existing line. If linenum is 0, Qedit adds new lines before the first existing line in the file. If you don't say which linenum, Add inserts the lines after the current position (*). (See Miscellaneous Points below.)

Examples

/add 5 {add new lines after line 5}

5.1 line a {Qedit prompts with line number}

5.2 line b {you enter line of text and Return}

5.3 // {you enter // or Control-Y to stop}

/aq {add after * line; no prompt}

This is new text

// {end the Add command}

Temporary Workfile: Qeditscr

If you do not have a named workfile Open when you Add, Qedit automatically builds a temporary workfile for you. This file is named Qeditscr (or Qednnnnn if you have Set Work Random On), and it is job temporary, meaning it goes away when you log off the computer. Therefore, you should convert it into a permanent Qedit workfile by doing Shut filename or into a permanent Editor-style file by doing Keep filename.

Making Qeditscr Permanent

Do you access Qedit over a telephone line? Have you ever been disconnected by noise on the line? If so, you probably know that Qeditscr is a job temporary file. When your session is lost, so is your editing work. Of course, if you were editing a named Qedit file that you Opened, you would not lose anything.

Qeditscr can easily be converted into a permanent file so that it will not be lost on :BYE. However, if two people share the same logon group, the Qeditscr file cannot be permanent for both of them! Here are the commands to create a permanent scratch file for yourself:

/:purge qeditscr,temp {purge existing file}

/set work size 3200 {ensure file is big enough}

/open {creates new Qeditscr}

/shut

/:save qeditscr {make permanent}

Another way of using permanent scratch files is to pass a file name for Qedit to edit, or to use Set Work Random On. See the "Running Qedit Under MPE" chapter for more information.

Using the Tab Key

By default, Qedit defines tabs every 10 columns across the line (every 8 for Qedit/UX). You can override these default tab stops using Set Tabs Stop n (every 2 to 15 characters) or Set Tabs 5 10 22 28 ... for completely custom tab stops. When you press the tab key as you Add lines, Qedit correctly inserts spaces in your lines and skip to the correct column on your screen (assuming you are using an HP terminal).

Overflowing Lines or Line Numbers

The Add command continues prompting until you press Control-Y, or you type "//" at the end of a line, or you run out of line numbers. When you exhaust the line numbers possible between two lines, Qedit prints "Error: Already". You can continue by doing a range Renumber on the area where you wish to add more lines. Thus, if your last line added was 4.999, use Renum 4/5 to spread out the lines between 4 and 5.

You can configure Qedit to automatically renumber part of the file so that you do not have to renumber it manually. See the Set Visual Renum option.

Line Wraparound

If you enter a line that is too long, Qedit divides it into several lines. Set Wraparound ON divides lines on "word" boundaries only. Any words that will not fit on the current line are moved to the next line. If only a small number of words are moved to the next line, Qedit prompts you to complete the line. To end the Add when this happens, press Return before typing "//". If you are editing FORTRAN source code, Qedit generates a valid continuation line for you.

Automatically Indenting Lines

AJ for justified is a special option to indent new lines. The linenum you specify must be an existing line. You enter new lines beneath it. Qedit will then indent the new lines by exactly the same number of spaces as the existing line. You can shift the indentation left by typing {'s at the start of a line, or shift it right with }'s. To redefine the { and } characters, use Set Zip.

Modifying a Line During Add

When you know you made a typo, and prefer to fix it now instead of going on, the auto-modify character will help you. Enter the command Set Zip []@{}#, or better yet, put it in your Qeditmgr configuration file. The # character (or other special character of your choice) is called the auto-modify character. It allows you to modify the line you are currently entering. Type "#" at the end of the line, and Qedit redisplays the line for you to modify. When you are done with the Modify, you press Return to continue adding new lines.

Miscellaneous Points to Note

If you have Set Left/Right margins, the new lines added will have spaces to the left and right of the margins. That is, the line you enter will be left-justified within the current margins of the workfile.

The maximum default increment between new lines is 1.0 (or 0.1 for standard COBOL files). You can change this default with Set Increment.

You can ask Qedit to remove nonprinting characters from your input lines using Set Editinput Data ON. If you do not wish to allow the extended Roman-8 characters, use Set Editinput Data ON Extend OFF.

Add (Adding a String as a Line)

Add one new line, with the text coming from a string in the command itself. This is handy when you need some literal text within a User Command or Use file, but don't want to create a temporary file to hold it.

ADD linenum string

(Q=no linenums, J=justified, T=template)

(Default: linenum = *)

The linenum parameter specifies where to insert the new line containing the string.

Examples

/add 5 "new line"

5.1 new line

/add 10.01 "change datasetdata setall"

10.01 change datasetdata setall

Add (Copying Lines within a File)

Add lines by copying duplicates of existing lines.

ADD linenum = rangelist

(Q=no display)

(Defaults: none)

The linenum parameter tells Qedit where to insert the copied lines. The number of decimal places in linenum tells Qedit how finely to number the new lines:

/add 50 = 1/9 {new lines will be 50.1, 50.2, 50.3...}

/add 50.10=1/9 {new lines will be 50.10, 50.11, 50.12...}

The rangelist parameter tells Qedit which lines to copy:

/add 50.1 = 1/9 10/15 {'1/9 10/15' is the rangelist}

Examples

/list 4/8 {how lines look before the copy command}

4 aaaaaaaa

5 bbbbbbbb

6 cccccccc

7 dddddddd

8 eeeeeeee

/add 5 = 7/8 {copy lines 7 and 8 after line 5}

5.1 dddddddd

5.2 eeeeeeee

2 lines COPIED

/list 4/8 {how lines look after the copy command}

4 aaaaaaaa

5 bbbbbbbb

5.1 dddddddd

5.2 eeeeeeee

6 cccccccc

7 dddddddd

8 eeeeeeee

/aq 5 = 5 {duplicate line 5 after itself}

Notes

Add prints each new line, unless you use AQ. When you copy lines, the rangelist must not include the linenum (e.g., /Add 5 = 4/6 is rejected because it would be an infinite loop). Qedit prints "Error: Already". The lines copied are not deleted from the original location. You now have two copies of the lines (and a copy in the Hold0 file, see Add-Move). Add-Copy is like the Copy command of EDIT/3000.

If you have Set Left/Right margins, Qedit prints only the portion of each line within the margins. However, it will actually copy the entire line, including the portion outside of the current margins.

Add (Moving Lines within a File)

Move some lines from one place in the file to another, deleting them from the original position.

ADD linenum < rangelist

(Q=no display)

(Defaults: none)

The linenum tells Qedit where to move the lines. The number of decimal places in linenum determines the line number increment. For example, "/add 5.10<100/200" creates lines 5.10, 5.11, 5.12, etc.

The rangelist tells Qedit which lines to move. Add deletes the original lines after moving them. You still only have one copy of each line.

Examples

/list 4/7 {how lines look before the move}

4 aaaaaaaa

5 bbbbbbbb

6 dddddddd

7 cccccccc

/add 5 < 7 {move line 7 after line 5}

5.1 cccccccc

1 line MOVED

/list 4/7 {how lines look after the move}

4 aaaaaaaa

5 bbbbbbbb

5.1 cccccccc

6 dddddddd

Notes

Control-Y during a move stops the move, but it also changes the move into a copy. The lines being moved in the current range are not deleted.

Add-Move ignores Set LEFT/RIGHT margins; it moves entire lines. However, it only prints the portion of the line within the current margins.

Add-Move is like the Gather command in EDIT/3000.

When you copy or move lines using Add= or Add<, Qedit first puts the lines into a "Hold" file called Hold0. It then counts the lines. If you do not have sufficient line numbers to insert the new lines, Qedit stops and prints "Error: Already". Use Renum to renumber the range of line numbers and then copy the lines from the Hold0 file. See also the Hold command.

/list hold0

/add 55=hold0 {add from Hold file}

Add (Copying Lines Between Files)

Add lines to the workfile from an external file.

ADD linenum = filename [,UNN] [ rangelist ]

(Q=no display)

(Default: entire file)

The linenum tells Qedit where to begin adding the lines from the external file.

The filename tells Qedit which file to copy from. It can be any type of disc file. If any of the lines are too long, they will be truncated with a warning. Use filename,UNN when you are adding from a data file with numeric characters in the last eight columns which are not really sequence numbers.

The rangelist tells Qedit how much of the file to copy. The default is to copy the entire file. If the external file does not have sequence numbers, Qedit assumes that the file is numbered from 1 by the current Set Increment. When you specify a rangelist, Add leaves a copy of the lines from the external file in the Hold0 file, as well as in your workfile.

Examples

/add 500.01 = abc {copy in the file ABC after 500.01}

500.001 abc line-1 {prints each line copied from file}

500.002 abc line-2 {prints new line numbers too}

/aq 5 = xyz 5/10 {copy in lines 5/10 of the file XYZ}

/l template "$page"(up) {list page breaks in a file}

1 $PAGE "xx" {select the template you want}

24 $PAGE "yy"

37 $PAGE "zz"

/add 5=template 24/36 {copy the lines between $pages}

/shut longname.to.type {establishing "previous" file}

/new cust {open another file}

/a 1 = $ 50/60 {$ stands for longname.to.type}

Notes

Add prints each line as it copies it, unless you use AQ. If Qedit finds invalid sequence numbers in a file, it begins assigning "logical" sequence numbers using the last valid sequence number and the current Set Increment.

If you have Set Left/Right margins, Qedit inserts blanks before the left margin in each line. That is, the lines from the external file are left-justified within the current margins of the workfile.

Add from a file is like the Join command in EDIT/3000.

Append Command [AP]

Appends a string to the end of each line in the rangelist.

APPEND "string" [ rangelist ]

(Q=no display)

(Default: rangelist = *)

Append allows you to add a semi-colon (or any other string of characters) to the end of a line (/AP ";" 5/10). Append prints each line that it changes. If the resulting line would be too long, Append goes into Modify on that line.

Examples

/list 25

25 to the end of the line

/append "!"

25 to the end of the line!

/ap ")" 1/4

1 (redo function)

2 (modify function)

3 (append function)

4 (list function)

Backward Command [BA/F5]

Starts "browsing" the current file by displaying one page "backward". You stay in "browse" mode until you enter any command (see List, jumping option).

BACKWARD

(F5 key does the same)

In Line mode, Backward and Forward (or F5/F6) throw you into List-Jumping's browse-mode. Qedit displays a screen of text, where the screen size is either 23 lines or what you specify with Set List LJ, then waits for you by asking "More?". Press Return to see the next screen. Typing a line number moves you to the screen starting at that line, pressing F2-F6 does the appropriate action, and F8 or "//" or Control-Y or typing any command gets you out of browse-mode. At the "More" prompt, the * "current" line is the last line displayed.

Before Command [B]

Repeat any combination of the previous 1,000 command lines, with or without editing.

BEFORE [ start [ / stop ] ]

[ string ]

[ ALL | @ ]

(Default: redo previous line)

(BQ=redo without change)

(BJ=listredo)

The Before command allows you to modify the commands before it executes them. If you don't need to change them, use BQ or :Do. Commands are numbered sequentially, starting with 1 for the first command entered and, by default, the last 1,000 commands are accessible. This numbering sequence applies only to the temporary redo stack, because this stack is discarded when you exit Qedit. The numbering sequence in a persistent redo stack, which is accessible across Qedit invocations, continues between invocations. Use the :Listredo or BJ command to display the previous commands. You can redo a single command, a range of commands, or the most recent command whose name matches a string.

The Before command uses Qedit-style Control characters for modifying the commands. The default mode is to replace characters. To delete use Control-D, and to insert use Control-B. If you prefer HP-style modify (D, R, I, and U), use the :Redo command instead of Before, or do Set Modify HP.

Examples

/listf @.soruce {"source" is not spelled right}

NON-EXISTENT GROUP. (CIERR 908)

/Before {redo most recent command}

listf @.soruce {last command is printed}

our {you enter changes to it}

listf @.source {the edited command is shown}

you press Return}

/listredo -10/ {show last 10 commands}

/before 5 {redo 5th command in stack}

/bef 8/10 {redo 8th through 10th}

/b listf {redo last Listf command}

/b listftemp {redo "listftemp" command}

/b @temp {redo last containing "temp"}

/before –2 {redo command before previous}

/before -5/-2 {redo by relative lines}

Notes

If you wish to change any characters within the line, the modify operators are the regular Control Codes used in Qedit:

Any printing characters replace the ones above.

Control-D plus spaces deletes columns above.

Control-B puts you into "insert before" mode.

Control-A starts appending characters at the end of line.

Control-A, Control-D, plus spaces, deletes from the end.

Control-T ends Insert Mode, allowing movement to a new column.

Control-G recovers the original line.

Control-O specifies "overwrite" mode (needed for spaces).

To save more commands, use a :File command on the file Qedredo before running Qedit:

:file qedredo;disc=5000

:run qedit.pub.robelle

:Beginfile and :Endfile Commands

Qedit allows you to build and fill MPE files in UDCs and usefiles:

:BEGINFILE filename

: data records

:ENDFILE

The :Beginfile command opens a new temporary file with 256-byte records. :File equations are allowed to override the format of the file. Qedit writes all of the data records between the :Beginfile and the :Endfile into this new file. Each data record must have a colon at the start, but the colon is not written to the temporary file. Also note that Qedit removes all leading spaces between the colon and the first character on the line. The :Endfile command closes the file as a temporary file. If the session already has a file with the same name, Endfile asks the user if he wishes to purge the existing file or rename the new one. If you don't want the end-user to go through this dialogue, you should :Purge the existing file before the :Beginfile.

Examples

You can use this file as input to programs, using a :File command and/or the Stdin parameter of Run:

:purge basename,temp

:beginfile basename

:menu

:endfile

:file inname=basename,oldtemp

:run dbutil.pub.sys,create;stdin=*inname

:reset inname

:purge basename,temp

Notes

A useful application of :Beginfile is to create command files in job streams. However, when creating a file with :Beginfile in a job stream, be certain that each data line starts with a colon (:). Otherwise, Qedit thinks that those are Qedit commands and it attempts to execute them.

Change Command [C]

Changes one string or column range to another string in some or all of your lines. There are two basic varieties of Change:

STRINGS	replace one string with another
COLUMNS	replace a column range with a string

Change (Changing Strings)

Replaces one string of characters by another string, the two strings being separated by a single quote character.

CHANGE "string1"string2" [ rangelist ]

(Q=no display, J=verify, T=CobX Tag)

(Default: rangelist = *)

The string1 tells Change what string of characters to find. The default for string1 is the last string used, and you specify this default via the null string (e.g., change ""xxx"). The null string recalls the last string and the window used with it. If the target string1 occurs more than once in a line, Qedit changes every occurrence.

The string2 tells Change what characters to substitute. In this format of the Change command, only three quote characters are used to define the two strings, not four as you would normally expect. Another oddity is that string2 does not become the current string. This is so that you can do another Change or Find command using "" as the target (i.e., the last string), finding and fixing multiple occurrences of the same string (e.g., find "nad"; CH ""and"; F; CH ""and"; ...). The third difference of string2 is that a null string for this parameter actually means "null". change "very"" 100 means remove "very" from line 100.

The rangelist tells Change what lines to search for string1. The default rangelist is the current line only.

If string2 is shorter than string1 (e.g., change "Robert"Bob"), Qedit shortens the line by shifting the rest of the line left. If string2 is longer (e.g., change "Bob"Robert"), Qedit lengthens the line by shifting characters right. If string2 is so much longer that the line would be too long, Qedit sends you into the Modify command to fix the line by hand.

Change prints each line that it updates, unless you use CQ.

Examples

/list 55 {display line with mistake}

55 select lines contaning both of two

/change "contan"contain" {change string in current line}

55 select lines containing both of two

/change "sub"subindex" all {make a global change}

10 subindex = subindex + 1

11 table(subindex) = 0

213 if subindexway = 0 {oops-bad change!}

/cj "cust"Customer" 200/300 {change with user approval}

225 Display Customer {shown for approval}

Change okay (Y,N,or Modify) [No]: yes

/list 9 {display line to review}

9 The test results were very exciting.

/c "very"" {remove word, change to null string}

9 The test results were exciting.

/find "wiith" {search forward for line with error}

99 the string is combined wiith the second string

/c ""with" {change "wiith" to "with"}

99 the string is combined with the second string

Using Alternates to Quote

You may select your own quote character if you find " too much work because it is a shifted key. Among the alternatives are \ : and ' (apostrophe). See the "Glossary" for more on strings and other alternates to quotes.

/c :wiith:with:

/c \wiith\with\

Approving Each Changed Line

Use CJ to give yourself approval over each change before it is updated. With CJ, Qedit displays the line as it would be and asks you for a Yes, No, or Modify answer. Use CJ when you have trouble working out the precise strings to change.

Searching for Two Strings at Once

Because the rangelist can contain a search string, you can actually select lines containing both of two strings:

/c "xxx"filename" all {"xxx" becomes "filename" in ALL}

/c "xxx"filename" "rename" {line must contain "rename" too}

Including a Window

The form of Change command just described requires only three quotes per command, but does not allow all options. You cannot specify a special window - you will always use the default Set Window value. To do a Change with a special window, you must specify four quote characters, two for each string:

CHANGE "string1" (window) "string2" [ rangelist ]

Each string is delimited by two quote characters and the two strings must be separated by a space or a comma. Between the two strings you may insert a window such as (SMART) or (20/30) or (UPSHIFT).

Changing Within a Column Range

If you insert a column window, Qedit changes only the columns within the window. Columns outside the window are untouched:

/change "CUSTREC" (10/39) "CUSTOMER-RECORD"

In this example, "CUSTREC" is expanded to "CUSTOMER-RECORD", but the data at column 40 and beyond is not moved. In addition, the Change must not cause the rest of the window to overflow.

Changing Uppercase and Lowercase

If you specify an upshift window, Qedit ignores the case of letters when matching the target string. It will match words that are spelled with caps or without:

/change "JONES" (upshift) "Fitz-Jones" all

In this example, Change selects lines containing "JONES", "Jones", or even "joneS".

Avoiding Changes to Embedded Words

If you specify a Smart window, Qedit rejects those matches in which the target string is actually in the middle of another word:

/change "FRANK" (smart) "Frank" all

This example selects "FRANK", but reject "FRANKLYN." You can combine Smart and Upshift.

Patterns and Windows

In other commands the window can specify a pattern to match. In the Change command patterns are not allowed, because Change cannot perform pattern changes. However, a string specified in the rangelist portion of the Change command may be a pattern. For example:

/change "CUSTREC" "CUST-REC" "@01@PIC@" (pattern)

{change custrec to cust-rec in all lines that}

{ also contain "01" and "PIC" in that order}

CobX Tags

Cobol tags are short strings stored in columns 73 to 80 of CobX source files. The Cobol tag value is defined using the Set X command. Once enabled, updated lines and added lines are automatically updated with the tag. They can also be modified manually with custom tag values.

In its regular form, the Change command affects only the text area in columns 7 to 72. If you wish to make changes to Cobol tags, use the T suffix. You can think of it as the Tag option. This option operates only on the tag area itself, columns 73 to 80.

/change "CUST" "SUPP" all

{change cust to supp in all lines. }

{ cust must be between columns 7 and 72. }

/changeT "CUST" "SUPP" all

{change cust to supp in all lines. }

{ cust must be between columns 73 and 80. }

To to this, the Tag option temporarily changes the margins to (73/80). Qedit displays a warning every time this option is used. Because the margin values have changed, explicit column range in a Window can only be between 73 and 80.

/changeT "CUST" (50/60) "SUPP" all

Warning: ChangeT: editing the Cobol tag area only (73-80).

Error: Window

/changeT "CUST" (73/80) "SUPP" all

Warning: ChangeT: editing the Cobol tag area only (73-80).

10 SUPP0102

1 line changed

Because the margins have been changed, Qedit displays text in the tag area only except when the Justify option is used. In this case, Qedit prompts for confirmation before making the change. It would be hard to determine if a line needs to be changed based only on the tag value. So, when the Justify option is used, Qedit displays the complete line. The user has the option to accept the changes, reject the changes or manually modify the line. If the user chooses to modify the line, only the tag is displayed.

Change (Changing Columns)

Replace some columns in some lines with a new string of characters. Use Change to insert columns, shift text left, or shift text right.

CHANGE column [/column] [(window)] "string" [rangelist]

(Q=no display, J=verify)

(Default: rangelist = *)

Change replaces the target column range with the string in the lines of the rangelist. You can use this to insert a string at a specified column. You can also use it to replace, expand, or contract specified columns.

If you specify a single column instead of a range, Qedit inserts the string before that column and shifts the rest of the line to the right. You can create new columns by inserting blanks in front of a position (e.g., change 5 " ").

If you specify a range of columns, Qedit replaces that column range with the string. The string may be the same length as the column range, longer, or shorter. If the string is shorter than the column range deleted, the rest of the line shifts left. If longer, the rest of the line shifts right. You can remove columns entirely by changing them to a null string (e.g., change 5/7 "").

Examples

/change 5"|"all {draw vertical line of "|"s in file}

/cq 1/2 "" 10/15 {shift lines 10/15 left 2 spaces}

/cq 1 " " 10/15 {shift lines 10/15 right 3 spaces}

/cq 1(1/8)" " all {shift columns 1/8 right 1 space}

{don't change text beyond column 8}

/change 12/12 :: {delete column 12 in the current line}

Notes

See the discussion of windows under "Changing Strings". Those notes also apply to column changes.

The first column number is usually 1,except for standard COBOL source files, where it is 7 (seven). The last column number depends on the current values for Set Language, Set Length, and Set Right. See the COBOL section in the chapter "Using Qedit with MPE Programming Tools."

Change prints each line modified, unless you use CQ. CJ asks you to verify each change.

Close Command [CL]

Shut the current work file and remove it from the recently accessed file list.

(Default: none)

The Shut command is the normal way to close a workfile. When you Shut a file (or Open another one), Qedit remembers the name of the current workfile in a list of recently accessed files. This allows you to reopen the file using open ?. However, the list is of limited size. If you are not coming back to edit the current file again, use the Close command instead of Shut. This keeps other file names from falling off the bottom of the list.

Examples

/open abc

/open def

/close {close "def" and forget it}

/open * {current file is now "abc"}

Colcopy Command [COL]

Copies one or more columns to a different location on the same line.

COLCOPY source [ /source2 ] destination1 [ /destination2 ] [ rangelist ]

(Q=no display, J=verify, T=CobX Tag)

(Default: rangelist = *)

Colcopy copies text in columns specified by source1 and source2 to the destination columns specified by destination1 and destination2 in the lines of rangelist. Even though Colcopy can modify multiple lines using a rangelist, it really operates on one line at a time. You can not copy columns from one line to another.

Source and destination columns always represent the original location. All changes are based on that assumption.

If source1 only is specified, Qedit copies just that column (length of 1). If destination1 only is specified, the source columns are inserted at that location. If you wish to replace a single column, enter a destination range where destination1 and Destination2 are the same e.g. Colcopy 1 10/10.

/list 1

1 abcdefghijklmnopqrstuvwxyz

/colcopy 1 10 { insert column 1 at column 10 }

1 abcdefghiajklmnopqrstuvwxyz

1 line changed

/colcopy 1/5 10 { insert columns 1/5 at column 10 }

1 abcdefghiabcdejklmnopqrstuvwxyz

1 line changed

If destination1 and destination2 are specified, text in these columns is replaced by the source text. If the source text is narrower or wider, the line is shortened or expanded as needed.

/colcopy 1 10/15 { copy column 1 to columns 10/15 }

1 abcdefghiapqrstuvwxyz

1 line changed

/colcopy 1/5 10/11 { copy columns 1/5 to 10/11. Line expands. }

1 abcdefghiabcdelmnopqrstuvwxyz

1 line changed

/colcopy 1/5 10/20 { copy columns 1/5 to 10/20. Line shortens. }

1 abcdefghiabcdeuvwxyz

1 line changed

Trailing Spaces

Trailing spaces on the line are not significant. This means that a line can expand until a non-space character reaches the current right margin (Set Right). However, trailing spaces from the source text are significant and are copied in the operation. If the line can not be expanded further, Qedit displays a warning message and allows the user to modify it.

/list 2

2 abcd efghiabcdeuvwxyz

/colcopy 1/8 20 { insert columns 1/8 at 20 }

1 abcd efghiabcdeabcd uvwxyz

1 line changed

/Set right 30

/colcopy 1/5 30 { insert columns 1/5 at 30 }

Warning: Source columns could not be inserted. Please modify. (Warning 2)

1 abcd efghiabcdeabcd uvwxyz

1 line modified

Overlapping Columns

When source and destination columns do not overlap, the results are straightforward. If source and destination columns overlap partially or completely, the results might not be as expected. Keep in mind that:

· source and destination columns are always based on the original line

· the destination columns are removed

· the source columns are put in their place

Approving Each Changed Line

Use COLJ to give yourself approval over each change before it is updated. With COLJ, Qedit displays the line as it would be and asks you for a Yes, No, or Modify answer.

CobX Tags

In its regular form, the Colcopy command affects only the text area in columns 7 to 72. If you wish to make changes to Cobol tags, use the T suffix. You can think of it as the Tag option. This option operates only on the tag area itself, columns 73 to 80.

/ColT 73/74 79/80 all { copies content of columns 73 and 74 }

{ into columns 79/80 }

/ColT 73/74 75 all { inserts content of columns 73 and 74 }

{ in column 75. Columns 76-80 are shifted. }

/ColT 23/24 79/80 all

Warning: ColcopyT: editing the Cobol tag area only (73-80).

Error: The Sourcestart column (23) is not between 73 and 80

/ColT 73/74 79/80 10

Warning: ColcopyT: editing the Cobol tag area only (73-80).

10 ME0307ME

1 line changed

Colmove Command [COLM]

Moves one or more columns to a different location on the same line.

COLMOVE source [ /source2 ] destination1 [ /destination2 ] [ rangelist ]

(Q=no display, J=verify, T=CobX Tag)

(Default: rangelist = *)

Colmove moves text in columns specified by source1 and source2 to the destination columns specified by destination1 and destination2 in the lines of rangelist. The source columns are removed from their original location. Even though Colmove can modify multiple lines using a rangelist, it really operates on one line at a time.

You can not move columns from one line to another. Source and destination columns always represent the original location. All changes are based on that assumption.

If source1 only is specified, Qedit moves just that column (length of 1). If destination1 only is specified, the source columns are inserted at that location. If you wish to replace a single column, enter a destination range where destination1 and Destination2 are the same e.g. Colcopy 1 10/10. A move means the original columns are removed and the line is shifted left. Then the source text is inserted at the destination.

/list 1

1 abcdefghijklmnopqrstuvwxyz

/colmove 1 10 { move column 1 to column 10 }

1 bcdefghiajklmnopqrstuvwxyz

1 line changed

/colmove 1/5 10 { move columns 1/5 to column 10 }

1 fghiabcdejklmnopqrstuvwxyz

1 line changed

If destination1 and destination2 are specified, text in these columns is replaced by the source text. If the source text is narrower or wider, the line is shortened or expanded as needed.

/colmove 1 10/15 { move column 1 to columns 10/15 }

1 bcdefghiapqrstuvwxyz

1 line changed

/colmove 1/5 10/11 { move columns 1/5 to 10/11 }

1 fghiabcdelmnopqrstuvwxyz

1 line changed

/colmove 1/5 10/20 { move columns 1/5 to 10/20 }

1 fghiabcdeuvwxyz

1 line changed

Trailing Spaces

/list 2

2 abcd efghiabcdeuvwxyz

/colmove 1/8 20 { move columns 1/8 to 20 }

1 efghiabcdeabcd uvwxyz

1 line changed

Overlapping Columns

· source and destination columns are always based on the original line

· the source columns are removed

· the destination columns are removed

· the source columns are put in their place

Here is an example:

/list 1

1 abcdefghijklmnopqrstuvwxyz

/colm 6/20 15

1 abcdefghijklmnopqrstuvwxyz

1 line changed

Apparently, nothing has changed but, in fact, something did happen to the line. Qedit removed the source columns "fghijklmnopqrst" and tried to insert the original text where column 15 used to be. Column 15 was part of the area that has been removed so Qedit inserts the text where it should have been i.e. between "e" and "u". So, it's putting the original text back where it was.

Moving Passed the Right Margin

Destination columns can exceed the current right margin. In this case, Qedit assumes the columns should be moved to the end of the line. Effectively, the source columns are inserted in the rightmost columns of the line. The destination columns do not have to be a precise value. They just need to be larger than the current right margin. If the right margin is currently set at 80, the following commands yield the same results.

/v right

Set Right 50

/lt2

....+....10...+....20...+....30...+....40...+....5

2 abcdefghijklmnopqrstuvwxyz

/colm 1/5 51

2 fghijklmnopqrstuvwxyz abcde

1 line changed

/colm 1/5 88/90

2 fghijklmnopqrstuvwxyz abcde

1 line changed

Approving Each Changed Line

Use COLMJ to give yourself approval over each change before it is updated. With COLMJ, Qedit displays the line as it would be and asks you for a Yes, No, or Modify answer.

CobX Tags

In its regular form, the Colmove command affects only the text area in columns 7 to 72.If you wish to make changes to Cobol tags, use the T suffix. You can think of it as the Tag option. This option operates only on the tag area itself, columns 73 to 80.

/ColmT 73/74 79/80 all { copies content of columns 73 and 74 }

{ into columns 79/80 }

/ColmT 73/74 75 all { inserts content of columns 73 and 74 }

{ in column 75. Columns 76-80 are shifted. }

/ColmoveT 23/24 79/80 all

Warning: ColcopyT: editing the Cobol tag area only (73-80).

Error: The Sourcestart column (23) is not between 73 and 80

/ColmoveT 73/74 79/80 10

Warning: ColcopyT: editing the Cobol tag area only (73-80).

10 ME0307ME

1 line changed

:Compile Command [CO/:C]

Qedit supports many commands for compiling using MPE V or CM compilers: three for COBOL, two for FORTRAN, SPL, Pascal, and RPG. To select a default CM COBOL compiler, use Set Whichcomp. Qedit provides a generic :Compile command that uses Set Language to determine which compiler to use. Once you have compiled a program, you can also :Prep and :Run it from within Qedit.

The generic :Compile command does not currently apply to NM compilers. Instead, use the regular command files in Pub.Sys, which we adjust to use our special Qcompxl routines (e.g., COB85XL).

Commands for MPE V and CM Compiles

COMPILE files [ ;INFO [=] "string" ]

CO files

COBOL files {see Set Whichcomp}

COBOLI files

COBOLII files

SPL files

RPG files

FORTRAN files {see Set Whichcomp}

FTN files {FORTRAN 77}

Pascal files

The files Parameters

All of the compile commands use the same file parameters:

:COMPILE text, usl, list, master, new

The text file is the file that contains the source code. It may be a Keep file or a Qedit workfile (if the compilers have been properly "fixed"). Compiler fixing is part of the standard Qedit install jobs. But, the "copylib" file for COBOL cannot be a Qedit file; it should be KSAM. If the text file is "*", the currently open workfile is compiled. If none is open, the one just closed is compiled.

The usl file is the file where the compiler deposits the machine code that it generates. This file must be "prepped" into a program file before you can actually :Run. The usl file defaults to $newpass (or $oldpass). You can specify a USL file created via the Segmenter (-buildusl) or by a previous compile (e.g., :save $oldpass after compile).

The list file is where the compiler sends its listing. The default is to print on $stdlist (i.e., your screen). If the list file is "LP", it always refers to Dev=LP. To direct the listing to a device name other than "LP", use a regular File command:

/file sp;dev=serialp

/cobol x,,*sp {compile file x, list to device Serialp}

The master file is a master source file that is merged with the text file by line number at compile time. This parameter is not supported for FORTRAN 77, Pascal, or C.

The new file is an optional output disc file that can be created by merging the master file and the text file.

Examples

/cobol abc.source,,lp {output goes to dev=lp}

/open def.source {open another source file}

/co * {Lang of file selects compiler}

/shut {close current workfile}

/spl * {compile errors to terminal}

/open * {resume editing}

Compiling a Range

You can specify a line range instead of a filename if you like:

/fortran 300/414.5

This option works only with the current workfile, accepts only explicit line numbers (e.g., 1.0, not FIRST), and allows only a single range (e.g., not 5/10,20/30).

Set Whichcomp Command

Qedit has the :COBOLII command to run the COBOLII program and :COBOLI to run the COBOLI program. To use COBOL-85, you need to use Set Whichcomp.

/set whichcomp cobol 85 {run COBOLII,COBOLIIX}

/set whichcomp cobol 74 {run COBOLII for :COBOL}

/set whichcomp cobol 68 {run COBOLI for :COBOL}

Qedit has the :FORTRAN command to compile FORTRAN 66 and :FTN to compile FORTRAN 77. Use Set Whichcomp to make FORTRAN 77 the default for :Compile:

/set whichcomp fortran 77

Interrupting with Control-Y

You can use Control-Y during a long compile to interrupt the compiler. It should print the question "Terminate program [no]?". Answer "YES" to abort the compile, or answer "NO" to continue compiling.

Compile Priority

Normally, the compiler is run in the same priority subqueue as Qedit, but the System Manager can specify a maximum subqueue for compiles that is lower than the programmer's logon priority. In these cases, the compiler is run in the lower subqueue (see the installation chapter). The System Manager can also specify that no on-line compiles at all are to be done in Qedit.

Include Files

The Qedit compiler interface interprets $include commands within Qedit workfiles at compile time. This is the syntax:

$INCLUDE filename or !INCLUDE (filename)

The HP Pascal syntax for $include is okay: $include 'filename' $. For Transact systems, use !Include with the filename in parentheses. For C, use #Include <file>. The Include statement must start at the beginning of the line.

When the Include command is encountered during the compile, the Include file is opened, and the lines are returned to the compiler with their actual sequence numbers. If the file cannot be opened, Qedit returns the include line to the compiler for interpretation. If the file can be opened, the include line is returned as a comment. Include is recognized only in Qedit workfiles, not in Keep files. However, "included" files themselves can be either Qedit files or Keep files. Nesting of includes is supported to ten levels deep.

Note that the SPL compiler interprets lines that start with an exclamation mark as a comment, even !include. The Qedit compiler interface treats this as a valid !include statement, not a comment. To prevent this, use the SPL << >> comment syntax instead.

Compiling to a Disc File

If you direct your compiler error listing to a disc file, you can use Qedit to examine the errors and fix them.

First, add a line to the beginning of your workfile specifying "$control nolist", which means "list only lines with errors":

/add 1.1

1.10 $control nolist

1.11 //

Later, when you want a full listing, change this line to "$control list", or "$control source" for COBOL.

Build a disc file, compile the listing into it, and display it:

/:build list;rec=-132,64,f,ascii;disc=4000,32

/:spl *,,list {compiler listing goes to List}

/lq list {displays compiler listing on your terminal}

On subsequent compiles, you can use the same file and the compiler should erase the previous contents. With this technique, you can do your compile in a job stream and continue editing another file while you are waiting. When the stream job finishes, you can check the results from within Qedit, even if you are remotely located from the batch line printer. Using :Tell, you could have the Job send a message to your Session when it completes.

Trapping Compiler Syntax Errors

Qedit can trap compiler syntax errors and show you each line in your source code for you to correct. See the chapter "Using Qedit with MPE Programming Tools" for full details.

Delete Command [D]

Deletes lines from the workfile.

DELETE [ rangelist ]

(Q=no display, J=verify)

(Default: rangelist = *)

Delete prints each line in rangelist, with an underline character after the line number, as it deletes them, unless you use DQ.

Notes

If you do Delete All, you must answer "Y" to a verifying question before the lines will be deleted. This also applies if you Set Check Delete is ON and you delete more than 5 lines.

If you delete the wrong lines, you can cancel the Delete by striking Control-Y. However, you must use Control-Y before you press Return on the next command line. Qedit responds by printing "Undeleted" or "Canceled". Once you have typed in the next command line and press Return, your chance to recover using Control-Y is gone and the previous Delete command is final. You can still undo the deletion using Undo.

Delete All resets the Set Keep Name (default for Keep command) so that a later Keep command will not wipe out the wrong file by mistake.

Confirm Each Deletion

Use DJ to give yourself approval over each delete before it is carried out. With DJ, Qedit displays the line (even if the Quiet option is used) and asks you for a Yes, No, or Stop answer.

Answer No or Return to keep the line.

Answer Yes to delete the current line. Unlike the basic Delete operation where lines are removed with the next command, lines confirmed in DJ are deleted immediately. They can be recovered with an Undo command.

Answer Stop if you wish to stop the delete process. When you use Stop, lines that have been deleted are not recovered automatically. Use Undo to recover them.

Examples

/delete 5/6 {remove lines 5 and 6 from file}

5 _this is line 5

6 _and this is line 6!

/dq 2 10/49 {delete lines 2 and 10/49}

/delete "."(1/1) {delete lines with "." in column 1}

{Implied rangelist is ALL}

/del "."(1/1 nomatch) {delete lines without "."}

/d "~"(pattern) {delete all blank lines}

/dj 3/66

3 this is line 3

Delete it (Y,N or Stop) [No]:

4 this is line 4

Delete it (Y,N or Stop) [No]:Y

5 this is line 5

Delete it (Y,N or Stop) [No]:n

6 this is line 6

Delete it (Y,N or Stop) [No]:S

1 line Deleted!

Destroy Command [DES/:D]

Purges the current workfile, a named MPE file, a Copylib member, or a spool file, after first verifying with the user.

DESTROY [ filename ]

(Default: current workfile)

The filename parameter can be the name of any file that you have write access to, "$" to refer to the "last" file name mentioned in another command, or "*" to refer to either the current workfile or, if none is currently open, the one just Shut. To purge a Copylib member, put the name in parentheses and do a :File command for "copylib". To purge a native-mode spool file, just refer to the number preceded by a #.

Examples

/destroy crept23.dead

CREPT23.DEAD.GREEN,OLD Qedit File, # of lines=162

Purge file [no]? Oui {that's French for Yes}

/open ctemp

/des *

CTEMP.BOB.GREEN,OLD Qedit file, # of lines=15

Purge file [no]? {Return key means "no"}

File NOT purged

/list datapg2 {check contents of file}

/destroy $ {...then purge it}

/destroy #o1234 {purge an NM spool file}

/file copylib=copylib.pub.develop

/destroy (custrec)

Notes

The MPE :Purge command also purges files, but it does not ask for your approval first. If you abbreviate the Purge command (as in PU), you are sent to the Destroy command instead.

If you are purging an opened file that is "clean" (that is, a file that has not been changed since the last save), Qedit does not ask for approval before purging the file.

:Display Command [DISPLAY]

Prints a message on the terminal - handy for instructions in UDCs. The message is not in quotes and is separated from the command name by a single space. See also Pause.

:DISPLAY [ message ]

(Defaults: blank line)

Examples

/display To get out of Suprtool, type Exit

/display

/run suprtool.pub.robelle

Divide Command [DI]

Divides a line into two or more lines at specified columns. Divide can turn a field-oriented record into a series of lines with one field per line. It can also append a blank line after every line in a file. See also VV in Visual. For the opposite of Divide, see the Glue command.

DIVIDE [ ( columnlist ) ] [ rangelist ]

(Default: columnlist = ], rangelist = *)

The columnlist parameter is one or more valid column numbers in ascending order such as (10 20 30), or it may be a (]) for "after end-of-line" (i.e., append a blank line). All characters from the specified column to end-of-line are moved to a new line after the original line.

The rangelist parameter specifies one or more lines in the file. Each line is split into two or more lines according to the column parameter. The default rangelist is the current line.

The default columnlist is "]", except when the Divide command has no parameters or only a "string" rangelist. Then the current line is split at the "current column". When Divide has no parameters, the current column is "]". Following a successful string match, the current column is the first column of the string position in the line(s).

Examples

/find "abc";divide {move "abc..." to a new line}

/list *+2;divide {move ahead 2 lines, add a blank line}

/divide (20) all {split every line at column 20}

/divide (20 40) @ {split every line at columns 20 and 40}

/divide (10 20 30) {split current line at 3 places}

/divide (]) */*+10 {add blank line after lines */*+10}

/divide (20)"Qedit" {split all "Qedit" lines at column 20}

/divide "Qedit" {split all "Qedit" lines at "Qedit"}

/divide (])"Qedit" {add blank line to all "Qedit" lines}

Notes

After a Divide command, the current line is the last line divided. To not print the lines, use DivideQ.

Divide works within the current Left and Right margins. That is, characters to the right or left of the current margins are not moved.

When working with COBOLX files, the Divide command does not consider the tag (columns 73 to 80) as part of the data. This means that the current tag data is not moved to the new split line. It also means that you cannot divide a line passed column 73.

The QEDITCOUNT JCW is updated with the number of lines divided, rather than the number of lines resulting.

:Do Command [DO]

The :Do command repeats (without changes) any of the previous 1,000 commands.

DO [ start [ / stop ] ]

[ string ]

[ ALL | @ ]

(Default: repeat the previous command)

Commands are numbered sequentially from 1 as entered and the last 1,000 of them are retained. Use the :Listredo command to display the previous commands. You can repeat a single command (do 5), a range of commands (do 5/10) or the most recent command whose name matches a string (do list). If you want to modify the commands before executing them, use :Redo or Before.

Examples

/listredo {or /bj or ,, }

/do {do previous command again}

/do 39 {do command line 39 again}

/do 5/8 {do command lines 5 to 8 again}

/do list {do most recent List command}

/do show {do last starting with "show"}

/do showjob job {do last "showjob job" command}

/do @job {do last containing "job"}

/do -2 {do command before previous}

/do -7/-5 {do by relative line number}

/do 5/ {do command lines 5 to "last"}

Notes

The :Do command can be abbreviated to ",." as in MPEX, but you cannot use ";" to combine commands on the same line. To stop a :Do All, use Control-Y.

:Editerror Command [EDITERROR]

Pulls up "errors" in source files for the user to correct. :Editerror depends upon a special error-file that is usually generated by the program that detects the errors. See Appendix B for the file format. Some compilers, such as SRN's SPLash! compiler, can generate Qedit error-files. For COBOL, SPL, Pascal, and HP C, Qedit converts compile errors into :Editerror format using the Editerr utility program.

:EDITERROR error-file [VISUAL | NEXT | PREV]

(Default: Line mode)

There are two basic types of :Editerror command: the first command after a compile, and a subsequent command.

/:editerror error-file [VISUAL] {first command}

/:editerror error-file NEXT {subsequent}

Finding the First Error

The first command after a compile would not specify NEXT or PREV and would find the first error in the error-file. Qedit prints the error message, then Opens or Texts the source file containing the error, and positions itself to the line with the error. If the current open file is a Qedit workfile, :Editerror does an automatic Shut command on it. If the current open file is Qeditscr and you did a previous Text and made some changes, :Editerror does an automatic Keep command on it (you will see the question "Purge existing file?"). :Editerror can handle Copylib members if the member name is enclosed in parentheses and followed by the name of the Copylib file (without a space).

If you specify VISUAL on the first command, Qedit assumes that you wish to correct the errors in Visual mode. Qedit does not throw you into Visual mode, but if you enter (or re-enter) Visual at this point, Qedit will display the error message at the top of the screen where the error occurred. If you do not specify Visual, Qedit assumes that you want to correct the errors in Line mode. Normally, the first command would be included in the UDC that does your compile.

Subsequent Errors

Subsequent commands retrieve the "next" (or "previous") error in the same error-file.

If you used the Visual option on your first command, Qedit allows you to use the F4 and F3 keys in Visual to find the Next or Previous error. Visual mode does the necessary :Editerror commands for you automatically.

If you do any string searches in fixing your errors, you will lose the ability to use F4 and F3 for Next and Previous Error. This often happens when you must search backward in your file for the definition of a data item. If the current string value does not equal "$error", the F4 and F3 keys do not pull up the next and previous errors to be fixed. You can now reactivate error-fixing by searching for "$error" explicitly.

You do not need to go through all the errors before recompiling. If you go past the last error to be fixed, Qedit prints a warning that says so. The same occurs if you try to go backwards beyond the first error to be fixed. Qedit does not turn off error-fixing just because you reach the end -- you can still go back to the previous error by pressing F3.

Resetting :Editerror Mode

Once you do the :Editerror command you are in a special mode where the F4 and F3 keys pull up errors. This mode stays enabled until one of the following resets it:

· another :Editerror operation

· :Editerror without any parameters

· any explicit Text, Open, Keep, Shut or New command

· using the F8 key to exit from Visual back to Line mode

Line Mode Tip

If you use Line mode to correct your errors, you will need a UDC to retrieve the next and previous error. For example, if the error file is called cerrors:

nexterror

option nolist

editerror cerrors next

*****

Screen Format

In most programming languages, it makes more sense to see the lines above the point of error, rather than after. The error line becomes the current line in :Editerror and the default Visual display is zero lines above the current line and 19 lines after. You can of course override this with Set Vis Above and Set Vis Below. If your Above value is 0, :Editerror changes the screen format so that there are 9 lines above and 9 fewer lines below (with a minimum of 9). Naturally, :Editerror saves the original values and resets them when you end error-fixing mode.

UDCs

See the UDCs called COBERR and EDERR in the file Udc.Catalog.Robelle for examples of how to use the Editerror command effectively.

:Escape Command [ESCAPE]

The :Escape command causes control to leave all User Commands (regardless of nesting levels) and return to the Qedit prompt. The :Escape command is valid only in User Commands (UDCs and command files). It returns an error if executed from the Qedit prompt or in a Use file.

:ESCAPE

(Default: none)

Examples

if cierror = 999 then

escape

endif

Exit Command [E/F8]

Exit from Qedit and return to the operating system.

EXIT [string]

The current workfile is closed and Qedit terminates. The F8 user key is the same as Exit.

To close the current workfile without exiting, use Shut. Remember: you do not need to Exit in order to do :COBOL, :Prep or :Run, but you do need to Exit in order to do :BYE.

When you Exit, Qedit checks whether you have any unsaved edits in any of your Extra scratch files. If so, you are prompted to Discard? them, or stay in Qedit to save them. If your primary Qeditscr file is temporary and named "Qeditscr", Qedit warns you that you forgot to save your changes, but does not purge the file. You can re-enter Qedit, Open it and resume work or save your edits.

Examples

:hello bob.green {log on to the computer}

:run qedit.pub.robelle

/open qedit.doc {open file to work on}

/modify 2482.5/ {do some editing...}

/:prose * {use a UDC to format a document}

/exit {ready to quit for the day!}

:bye {disconnect from computer}

Notes

To avoid accidental Exit as a result of pressing F8 one time too many, you can run Qedit with Parm=64. This forces user approval of Exit.

The only situation where Qedit does not terminate on an Exit is when you invoke Qedit from another user program (e.g., from SPOOK, MPEX, or SELECT). In this case, Qedit "suspends" so that the father process can quickly "activate" Qedit again. When you reactivate Qedit you can resume editing with Open *. If the father does not want to hold onto Qedit, he should get rid of it with the KILL intrinsic. If the father process is like HPDesk and does not notice that Qedit remains suspended, you should :Run Qedit with Parm=32 or do Set Suspend Off to force Qedit to terminate on Exit instead of suspending.

The string parameter is only allowed when Qedit is running as a server. The string is a message sent to the Qedit for Windows client. The client receives the exit notification, displays the message and disconnects immediately. If no string is specified, a default message is displayed.

Find Command [F/F4]

Finds the next line in the workfile that contains a string. Use Findup if you want to search for the previous line. Find always finds a single line that matches a string. Use the List command if you want to find many lines that match a string.

FIND [string] [linenum]

FIND [string range] [linenum]

(Q=no display)

(Default: string = recent; linenum = *+1)

Find defaults string to be "same as last string" and linenum to be "starting from the next line". This saves having to repeatedly type the string and linenum. Once you have defined your string and starting position, just enter "F" to find the next line.

Find does not start searching at the beginning of your file. Find will start searching for the string at the line after the current line, unless you specify a linenum to start the search. If you want to search from the beginning of your file, use Find string FIRST.

The F4 user key does the same function as Find with no parameters.

Examples

/find "exit" first {find first line with "exit"}

45 this command will cause an exit from the

(28)^

/f {find next line with "exit"}

90 after you exit from a module, the program

(11)^

/f {continue finding lines...}

...

/f {...until you reach end of file}

Warning: No Line {prints error and rewinds}

Error: End of File

/f {next Find wraps around!}

Warning: Rewind to FIRST

45 this command will cause an exit from the

(28)^

/fq"$page"(1/5);m {find next $page and modify it}

/fq;c""exit" {find next string and change it}

/fq;c""" {find next string and remove it}

/f "start"/"end" [ {find string range and set ZZ}

Lines 5/11 saved in ZZ

Notes

The Q option lets you find the line without printing it. Use FQ if you intend to Modify the line after you find it.

Find prints an error when the search reaches the LAST line without locating the string. Then, if you enter another Find without a line number, the search starts from the FIRST line in the file, after printing a warning.

See the /Qedit command for a command file that uses the Find command and checks the value of CIERROR to see if the string was found. The Find command only sets the CIERROR JCW when it is executed from a User Command. It does not set the JCW when executed from $stdin or from a usefile.

To find/see all occurrences of a string in a file, use the List command.

When a string range is used and a corresponding block is found, the start and end line numbers are stored in the ZZ marker.

Findup Command [FINDU/F3]

Finds the previous line in the workfile that contains a string. Findup can be shortened to ^. Use Find if you want to search for the next line.

FINDUP [string] [linenum]

(Q=no display)

(Default: string = recent; linenum = *-1)

Findup defaults string to be "same as last string" and linenum to be "starting from the previous line". This saves having to repeatedly type the string and linenum. Once you have defined your string and starting position, all you need to enter is "^" or "FINDU" to find the next string.

The F3 user key does the same function as Findup without parameters.

Examples

/findup "exit" last {find last line with "exit"}

90 after you exit from a module, the program

(11)^

/findup find previous line with "exit"

45 this command will cause an exit from the

(28)^

/^ {continue finding lines...}

...

/^ {...until you reach start of file}

Warning: No Line {prints error and rewinds}

Error: Beginning of File

/findup {next Findup wraps around!}

Warning: Rewind to LAST

90 after you exit from a module, the program

(11)^

/findupq;mod {find string and modify it}

/findupq;c""exit" {find string and change it}

/findupq;c""" {find string and remove it}

Notes

Refer to the notes under the Find command.

Form Command [FORM]

Displays information about a self-describing file created by programs such as Suprtool. These programs store information about the record layout such as field names, data types, length.

FORM [ $lp | $lpa | $lpb ] [ filename ]

(Default: filename = current Text file)

If filename is omitted and a workfile is currently active, Qedit uses the name of the Text file (see Verify Keep). An external filename can be specified.

If the file is not self-describing, Qedit displays the following message:

Error: File is not self-describing.

Self-describing files on MPE have a special filecode, SD. The data description information is stored in the file userlabels. For example, a self-describing file would look like this:

ACCOUNT= GL GROUP= DATA

FILENAME CODE ------------LOGICAL RECORD----------- ----SPACE----

SIZE TYP EOF LIMIT R/B SECTORS #X MX

X1DSBEDR SD 302B FA 3500 3500 13 320 1 1

The Form output looks like this:

Self-describing information for X1DSBEDR.DATA.GL

File: X1DSBEDR.DATA.GL (SD Version B.00.00)

Entry: Offset

CHAR-FIELD X5 1 <<Sort# 1 >>

INT-FIELD I1 6

DBL-FIELD I2 8

PACKED-FIELD P12 12

PACKED*-FIELD P12 18

QUAD-FIELD I4 24

ID-FIELD I1 32

LOGICAL-FIELD K1 34

DBLLOG-FIELD K2 36

ZONED-FIELD Z5 40

Limit: 3500 EOF: 3500 Entry Length: 44 Blocking: 64

LP listing

Overrides default output to $stdlist. $lp, $lpa and $lpb send output to a file with the same name as the option.

Forward Command [FO/F6]

Starts "browsing" the current file by displaying the next page "forward". You stay in "browse" mode until you enter any command (see List, jumping option).

FORWARD

(F6 key does the same)

In Line mode, Backward and Forward (or F5/F6) throw you into List-Jumping's Browse mode. Qedit displays a screen of text, where the screen size is either 23 lines or what you specify with Set List LJ, then waits for you by asking "More?". Press Return to see the next screen, typing a line number moves you to the screen starting at that line, pressing F2-F6 does the appropriate action, and F8 or "//" or Control-Y or typing any command gets you out of browse mode. At the "More" prompt, the * "current" line is the last line displayed.

Garbage Command [GAR]

Finds and recovers wasted space in the current workfile.

GARBAGE

(Q = no summary)

If you keep adding lines to a workfile and editing them, eventually you will get an "Error: Full" message in Line mode or "File nearly full!" in Visual mode, and be unable to add more lines. One method of continuing at this point is to use the Garbage command.

/garbage

/gar {minimal command name}

Garbage combines partially full blocks to squeeze out free blocks, but it also searches the workfile for any blocks that have been "lost" (i.e., are no longer on the "free list" or the "text list"). Garbage does not release extents, nor does it reduce the EOF. It does not make your file any smaller, it just allows you to continue editing by finding usable space within the file.

Garbage prints a summary of how much space it recovered and how much is available in the file. The summary report can be suppressed using GarbageQ.

5 blocks squeezed out, 2 found, 55 used,

10 on free list, 9 for expansion.

In this example, Garbage reports that 5 blocks were retrieved via squeezing, 2 lost blocks were found, 55 blocks are currently used to hold text, 10 empty blocks are held on a "deleted-block" list (the free list), and 9 blocks are available if the EOF is expanded toward the LIMIT.

Expanding Your File

If you need still more space, you should build a bigger file using the Text command. Text creates a workfile with room to add more lines.

/open crept23

/add

5.11 this is a new line

Error: Full

/shut {close the file that is too small}

/text * {text Crept23 into larger Qeditscr}

/shut * {rename as new Crept23, purge old}

/open * {open new big file and edit...}

/add

5.11 this is a new line

Compressing Your File

If you want to compress your file into minimal disc space because you are through editing it, use Garbage to minimize the number of blocks, then use New to build a new smaller file, deriving the number of lines from a Verify Open of the old file, and copy the old file into the new with Text:

/open crept99

/garbage {minimize number of blocks}

/verify open {find out number of lines in file}

/shut saveold {rename file as Saveold}

/new crept99 (2900) {build new, smaller file}

/text saveold {copy old file into new}

Glue Command [G]

Joins a line with one or more following lines, either concatenated or at specified tab positions. Use Glue to turn a list of fields into a single record-oriented line. See also GG in Visual mode. For the opposite of Glue, see the Divide command.

GLUE [ ( columnlist ) ] [ rangelist ]

(Defaults: columnlist = ], rangelist = */*+n)

The columnlist is a list of ascending column numbers in parentheses such as (10 20 30), or ( ] ) for "after the end-of-line", which is the default.

The rangelist specifies which lines to combine. The default rangelist is the current line plus n. When you specify a range of lines, Glue joins the lines in "pairs".

Examples

/glue {joins *+1 to *}

/gluej {joins *+1 to * with space between}

/glue;glue {join *+1 and *+2 to *}

/glue (10) all {joins lines in "pairs" at column 10}

/glue (10 20 30) {joins 4 lines into 1 record}

/glue "string" {glue "string" lines to lines that follow}

Notes

If there are not enough lines at the end of a rangelist to fill in each column of the list, Glue does not go beyond the rangelist. If there is not enough room to move all of the characters into the line, as many characters as will fit are moved, the following line is not deleted, and Qedit prints an "overflow" warning.

After a Glue command, the current line is the line last spliced together. To suppress printing of the spliced lines, use GlueQ.

If you don't specify a list of column fields, Glue removes leading spaces from the following lines before moving them. To insert a single space between them, use GlueJ instead. If you do specify columnar fields, Glue treats spaces as valid data and moves them intact. If you specify more than one field, some nonblank data may be overwritten if the columns are too close together or the lines to be glued are too long. You can always use Undo to cancel a Glue command.

The QEDITCOUNT JCW is updated with the number of lines resulting, rather than the original number of lines that were affected.

If Left or Right margins have been Set, only the text within the margins is copied and the following lines are not deleted.

When editing COBOLX files, the tag area (columns 73 to 80) is not considered part of the data. This means that the tag string on the next line is not moved to the new line. It also means you cannot glue to columns passed 73.

Help Command [H/?]

Gives instructions on the use of Qedit. Everything in the Qedit User Manual is also in the Help command. "?" means the same as Help.

HELP [ command [ ,keyword ] ]

[ TERMS [ ,word] ]

[ INTRO ]

[ NEWS ]

(Default: browse through the entire help file)

(Q = Quick Reference Guide "Quick Help")

The parameters have the following meaning:

command explains command; lists subsidiary keywords to select.

command,keyword finds keyword under command.

command,@ prints everything about the command.

TERMS [,word] explains word (see "Glossary").

INTRO explains how to apply Qedit to typical problems.

NEWS shows any new features in Qedit.

Examples

/h text {explain the Text command and show sub-keywords}

/h text,@ {tell all about Text. Comma is required}

If Help cannot find your specified topic in the Qedit help file, it prints a warning and search the system help file. To get system help directly, put a colon in front of Help (i.e., /:help).

Quick Help - HQ

HQ looks for entries under the keyword Quick in the helpfile. Quick contains the text from the Qedit Quick Reference Guide, offering the experienced user a review of command syntax.

/hq visual {full-screen options}

/hq shortcuts {quick list of shortcuts}

Notes

The help file must be on the system for the Help command to work. If the file is missing, Qedit still works fine, but you cannot get any on-line help. The default file name is Qedit.Help.Robelle, but if you move Qedit to another account you should move the help file to that account as well. Within the Help command, use "+" to see what levels exist "beneath" you and "?" for "help on Help". The help file is organized into levels: to go back to the previous level, press Return instead of entering a keyword. Press F8 to exit the QHELP subsystem completely and return to Qedit. Use the Prev Page (or Page Up) key on your terminal to review help already printed.

Hold Command [HO]

Lets you explicitly write lines to the Hold file.

HOLD [ filename ] [ rangelist ]

(Default: hold current line)

(Q=hold without display)

(J=append, without erasing)

You can refer to the current contents of the Hold file by the actual file name, "hold", in any of the commands that access external files (Add-File, List, Use).

Examples

/hold 50/60 {erase Hold, hold lines}

/holdj 100/198 {append more lines to Hold}

/ho "direct" {hold lines with string}

/open abc.src

/add 33=hold {adds held lines to abc.src}

/holdq qedhint.help.robelle

/list hold

Implicit Hold

When using the Add command to move or copy lines within a file, Qedit overwrites a file named Hold0 with a copy of the lines. It counts the lines and tries to select a line number increment that will accommodate the number of lines being added to your workfile. So, if the command fails or if you wish to copy the same lines again, you can refer to the Hold0 file. Adding from an external file also holds the lines if you specify a rangelist for the file, and if the file is not the Hold file itself.

/add 55=hold0

/list hold0 {the Hold file is temporary}

Notes

You can save the current Hold file using the MPE Save command:

/save hold

/rename hold,newname

On MPE/iX, the Hold files are created with variable-length records and a limit of 250,000 lines. On MPE V, the Hold files are created with variable-length records and space for 3 megabytes of data.

Every time you use "hold" or "hold0" by themselves as a file name in any command, Qedit replaces the word with the fully-qualified file name of the appropriate Hold file.

/Add 1=hold

translates to

/Add 1=hold.mygroup.myacct

:If, :Endif, :Else, :Elseif Commands

In command files, UDCs, usefiles, and even from the /-prompt, use If, Endif, Else and Elseif commands to create conditional logic. See also the While command, the /Qedit command and the INSIDEQEDIT JCW.

:IF expression [THEN]

:ELSEIF expression [THEN]

:ELSE

:ENDIF

Examples

Here is a sample command file to show a specific session or all sessions on the system. The parameter is the session number, which the If tests for zero default value in deciding whether to show one or all sessions:

PARM sessnum=0

setjcw jsnum=!sessnum

if jsnum=0 then

showjob job=@s

else

showjob #s!sessnum

endif

To invoke this command, put it in a file named "SS", then type the file name, optionally followed by a session number:

/ss

/ss 456

Although :If commands may be nested up to 30 levels deep, :Elseif provides an alternative, effectively giving you a "case" command. Any number of Elseifs may follow an If, but only one Else may follow an If or Elseif. The "Then" keyword is optional in Elseif, and in If as well.

Justify Command [J]

With Justify, you can do text formatting: center lines, right-justify lines, left-justify lines, and fill text into margins.

JUSTIFY [option] [keyword ...] [rangelist]

(Q=no display)

(Default option: Null or Set Justify)

When the Justify command is processing the range of lines you specified, if you decide not to continue, press Control-Y to stop the formatting.

Options Specify Which Function

Justify Right	right-justify each line
Justify Center	center each line
Justify Centre	Canadian spelling!
Justify Left	remove leading spaces
Justify Format	fill lines, ragged right margin
Justify Both	fill lines, straight right margin
Justify Null	default - no changes - safety

Keyword Parameters of Justify

MARGIN column	right edge, relative to left
TWO [ ON\|OFF ]	maintain 2 spaces after . ? and !
INDENT spaces	indentation for list of points
WITHINDENT	activate configured indentation
STOP "chars"	break justification when found
START "chars"	start new paragraph

You may shorten options and keywords to the leading letters.

Rangelist Specifies Which Lines

For the Format and Both options, the rangelist specifies some lines to format. Warning: if you type a single line number (e.g., just both 5), Qedit begins formatting lines from that line number to the end of the paragraph. Qedit sees blank lines as end-of-paragraph markers, so if you justify format all you end up with smooth and even chunks of text, set off by blank lines. This is one of the few places in Qedit where a single line number implies a range of lines.

For the Left, Right and Center options, a single line rangelist means a single line. But, you can specify a "string" rangelist to center or justify only lines containing a string. Specifying a "string" rangelist with the Format or Both options is equivalent to specifying a single line number i.e. formatting starts with the line which has the string to the end of the paragraph.

Verification Before Formatting

If Set Check Justify is ON, Justify Format and Both require user verification before formatting more than 5 lines. This should eliminate inadvertent formatting of entire source programs!

You can also use the Undo command to undo the effects of the Justify command.

Left and Right Edges for Justify

Justify works within borders called the left and right edge. The left edge is usually column 1, or column seven 7 in standard COBOL. The right edge is usually the highest column number allowed in the file (e.g., 80 for JOB files). However, if you use Set Left and Set Right to create margins for your file, Justify operates within those limits. Set Left will be the left edge and Set Right will be the right edge. You can also use the Margin keyword to establish the right edge for Justify, but remember that this edge is relative to any Set Left value.

Examples

/justify center 5/6 {center lines 5 through 6}

/j right 5/6 {right-justify lines 5 through 6}

/j left 5/6 {left-justify lines 5 through 6}

/j format 5/50 {format lines 5/50 into margins}

/j f 5/6 {splice lines 5 and 6 into one line}

/j both 5 {format a paragraph, even right edge,}

{ from line 5 to the next blank line}

Right Justifying Lines

Justify Right shifts each line of rangelist to the right until the last nonblank character is at the right edge. For example:

/justify right margin 50 rangelist

Input lines: