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.
Here are general guidelines that apply to using the Qedit
commands.
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}
You can enter the commands in
uppercase or lowercase. These commands are identical:
LIST ALL {uppercase}
list all {lowercase}
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".""
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 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
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 (//).
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
|
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.
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.
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}
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}
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.
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
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.
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
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.
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 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 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 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.
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 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.
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)
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.
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
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.
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
|
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.
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.
Shut the current work file and
remove it from the recently accessed file list.
CLose
(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"}
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
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 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. }
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 the source and destination columns can
only be between 73 and 80.
/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
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.
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
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 moved in the operation.
/list 2
2 abcd efghiabcdeuvwxyz
/colmove 1/8 20 { move columns 1/8 to 20 }
1 efghiabcdeabcd uvwxyz
1 line changed
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 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
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 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. }
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 the source and destination columns can
only be between 73 and 80.
/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
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.
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:
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.
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!
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.
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
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.
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.
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.
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
See also the
:Return command.
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.
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.
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.
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.
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.
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}
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.
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.
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.
translates to
/Add 1=hold.mygroup.myacct
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:
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.
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:
Robelle Solutions Technology Inc.
Tools for HP3000
Output lines:
Robelle Solutions Technology
Inc.
Tools for
HP3000
Centering Lines
Justify Center adjusts each rangelist line so that it is centered
between the left edge and the right edge. For example:
/justify center margin 50 rangelist
Input lines:
Robelle Solutions Technology Inc.
Tools for HP3000
Output lines:
Robelle Solutions Technology
Inc.
Tools for HP3000
Left Justifying
Lines
Justify Left removes leading
spaces from each rangelist line,
until the left-most nonblank character is at the left edge. This will left-justify
the lines. Use for this option to recover from an inadvertent Center or Right
option. For example:
Input lines:
Robelle Solutions Technology
Inc.
Tools for HP3000
Output lines:
Robelle Solutions Technology Inc.
Tools for HP3000
Filling Words into
Tidy Paragraphs
Justify Format adjusts the
processed lines so that the words fill the space between the left edge and the
right edge, but allows the right edge to be ragged:
/justify format margin 50 rangelist
Input lines:
The Format keyword performs a
function which is equivalent to
Format mode in TDP/3000. Uneven lines
are converted into lines of about
the same length.
Output lines:
The Format keyword performs a
function which is
equivalent to Format mode in
TDP/3000. Uneven
lines are converted into lines of about
the same
length.
Making Both Edges
Even
Justify Both is similar to
Justify Format, except that both the left and right edges of the text are even.
This is accomplished by inserting blanks between words. For example:
/justify both margin 50 rangelist
Input lines:
The Both keyword performs a
function which is equivalent to
Format;Just ON in TDP/3000. Uneven lines
are converted into lines of
exactly the same length.
Output lines:
The Both keyword performs
a function which
is
equivalent to Format;Just ON in TDP/3000. Uneven
lines are converted into lines of
exactly the same
length.
Null Option
Justify Null is included as an option to serve as a
default. If Both were the default option, most of your file would be quickly
formatted if you accidentally typed "J 5" instead of "LJ
5".
Configuring the Justify
Command
The five options (Right,
Center, Left, Format, and Both) and the four keywords (Margin, Two, Indent, and
Withindent), configure the Justify command. The hierarchy of configuration
values is as follows:
Startup default
(the "default default")
overridden by
SET Justify (the
configured default)
overridden by
Keywords in Justify
command
You set your own defaults for
the Justify option and keyword values using Set Justify. Once
you find the setting you like, you may want to put them in your Qeditmgr
configuration file so you won't have to do the Set Justify command every time
you run Qedit. For example:
/set justify null margin 50 two on
causes
/justify both 5
to be interpreted as
/justify both margin 50 two on 5
but you can override your own defaults, as in
/justify both margin 60 10/20
which merges with your Set Justify values to produce
/justify both margin 60 two on 10/20
Configuring the
Right Edge
The Margin keyword specifies
the right-most column for processed lines. This column is needed for the Right,
Center, Format and Both options. The value you specify is relative to any Set
Left margin that is effective at the time of the Justify command.
Determining the
Left Edge
For the Both and Format
options, the left margin is determined by looking at the first and second lines
of each "paragraph". If the first and second line are indented, the
entire paragraph will be indented. Of course, this indentation is relative to
any Set Left.
/justify both margin 50 linenum
Input lines:
The Both keyword performs a
function which is equivalent to
Format;Just ON in TDP/3000. Uneven lines
are converted into lines of
exactly the same length.
Output lines:
The Both keyword performs a function which is
equivalent to Format;Just ON
in TDP/3000.
Uneven lines are
converted into lines of
exactly the same length.
Two Spaces at End
of Sentence
Normally,
when Qedit adjusts text with Format and Both, it inserts one space between each
symbol, regardless of the number of spaces between symbols in the input text.
If the Two keyword is ON, Justify maintains two blanks after the end of a
sentence (i.e., after a . ? or !, or one of those three followed by a quote
mark or a right parenthesis and a space). The default for this keyword is OFF.
Justify does not insert two spaces if the input only
contains one; it merely maintains two spaces if they are there already (this
means you don't have to worry about getting two spaces in a name like Calvin C.
Cook).
/justify format two on margin
70 99.5/
Formatting a List
of Points
The Indent keyword is a special capability for
handling lists of numbered points (1., 2., 3., ...). It assumes that your text
is indented and that the numbers for each point appear to the left of that indentation.
The Indent parameter specifies the number of spaces at the start of each line
that will not contain text to format. Justify leaves anything to the left of
this border "as is". In fact, the existence of text to the left of
the border acts as an "end-of-point" indicator, eliminating the need
for a blank line between points to stop the justification. Indent is relative
to any Set Left.
The end of each point in a list is effectively an end of
paragraph. Here is a sample of what happens when you attempt to format a list
of points without the Indent keyword:
/justify both margin 50 rangelist
Input lines:
1.
Text which occurs in
a list of points should also
be formatted into even lines.
2.
Any text to the left of column 5
causes a
"justification break".
Output lines:
1.
Text which occurs in a list of
points should
also be formatted
into even lines. 2. Any
text to the
left of column
5 causes a
"justification break".
All of the points have been run together into a single
point. You can avoid this result by inserting a blank line at each point, or by
doing Justify on each point individually, or by using the Indent keyword:
/justify both margin 50 indent 4 rangelist
Input lines:
1.
Text which occurs in
a list of points should also
be formatted into even lines.
2.
Any text to the left of column 5
causes a
"justification break".
Output lines:
1.
Text which occurs in a list of
points should
also be formatted into even lines.
2.
Any text to
the left of column 5 causes a
"justification break".
Activating
Indentation
Withindent activates an Indent
value that you have previously configured with Set Justify Indent. Withindent
allows you to settle on a single indentation for all "lists of
points" without having to respecify that value on every Justify command.
You merely specify Withindent when you format a list of points:
/set justify indent 4 {configure potential indentation}
/justify format 5 {this is not a list of points}
/just f with 9
{this is a list of points}
Justification
Breaks and Formatting Commands
Justify
has options to define characters that start and/or stop justification when
found in column one. These options make it much easier to justify text in files
which contain embedded commands and special characters for a format program
(e.g., Prose, TDP, etc.). The specific characters are defined using the Start
and Stop options:
/set justify stop ".+"
start "` "
This command says that any line with "." or
"+" in column one stops text justification and that line is not
changed. Any line with "`" or " " (space) in column one
ends justification of the previous paragraph and signals a new paragraph (i.e.,
that line is formatted as part of the next paragraph).
It's important to note that a "string" rangelist has precedence over Start and
Stop characters. In other words, the latter options are ignored.
Here is an example which justifies some text from a
Robelle document that consists of both text and embedded Prose formatting
directives. Note that lines beginning with "." and "+" are
not altered, and the line beginning with "`" properly appears as a
new paragraph.
/justify start "` " stop
".+" margin 50 format all
Input lines:
.for([ T S:40 // l55 / "-" pn:1 "-" /]
+
[ S T:40 // l55 / "-" pn:1 "-" /])
.par(f` p5 s1 u3).com Define ` as Start of Paragraph
.ent `|1Welcome to Compare|
.beginkey compare
Welcome to version 2.2 of Compare -- a
file comparison program for text files.
`Compare answers the question,
"How different are these two text
files?"
Compare will tell you whether lines
have been added, or whether a block of
lines is now different.
Output lines:
.for([ T S:40 // l55 / "-" pn:1 "-" /]
+
[ S T:40 // l55 / "-" pn:1 "-" /])
.par(f` p5 s1 u3).com Define ` as Start of Paragraph
.ent `|1Welcome to Compare|
.beginkey compare
Welcome to version 2.2 of Compare -- a file
comparison program for text files.
`Compare answers the question,
"How different are
these two text files?" Compare
will tell you
whether lines have been added, or
whether a block
of lines is now different.
Creates a standard disc file
and writes the workfile into it, including any user labels copied by the Text
command. Can also update or create a "member" in a COBOL Copylib.
Keep is the reverse of Text, which copies a standard disc file into a workfile
that you can edit. Use Text when you need to duplicate a file. You should not
need Keep very often - especially if you retain your files in Qedit format. In
that case you would use New or Open to start editing the Qedit workfile, and
Shut to stop editing.
KEEP [filename][,options] [ rangelist
]
(Q=no linenums)
(Defaults: rangelist=ALL, filename=last)
Keep Options
Qedit allows several options on the Keep command. Note
that the comma preceding the option name is mandatory, and that spaces are not
allowed before the comma or the option name.
|
Keep filename,TEMP
|
temporary instead of permanent file
|
|
Keep filename,UNN
|
unnumbered (same as KQ)
|
|
Keep filename,YES
|
go ahead and purge old file
|
|
Keep filename,NO
|
never purge an old file
|
|
Keep filename,XEQ
|
assign xeq access
|
|
Keep filename,NOLABELS
|
discard user labels
|
|
Keep filename,RELEASED
|
:Release security
|
|
Keep filename,IFDIRTY
|
only if changes made
|
Keep creates a new disc file named filename. You can combine several options on the same Keep command.
The default filename is the name and
domain (temporary vs. permanent) of the last Text or full Keep (i.e., it does
not count if you use a rangelist or
have reduced the margins with Set Left or Set Right). If filename already exists, Qedit will ask you to verify that it is
okay to purge it unless you specify the ,YES or ,NO option.
Usually the file will have sequence numbers in each line
(this is called numbered), but you can omit the sequence numbers with KQ, or by
specifying the ,UNN option.
Keep transfers rangelist
lines from the workfile to filename.
The default rangelist is ALL.
Warning: Qedit writes only the data within the current left and right margins,
so reset the margins first if you want the entire line (e.g., Set Left; Set
Right).
To save the current workfile lines as a COBOL Copylib
member, put the member name in parentheses, optionally followed by the file
name (default is "copylib" for which you usually have a :File
command). If the member already exists, you will be asked if you want to purge
the old copy. If the member does not exist, it will be created.
Examples
/text menu.schema {make a copy of existing schema file}
QEDITSCR
/find "FUNCTION-CODE"
14 FUNCTION-CODE, X8;
/change "X8"X10"
14 FUNCTION-CODE, X10;
/keep menu.new {create a new schema file}
... {do some more
changes}
/keep {save again with same name...}
MENU.NEW.DEV,OLD 80B FA # of records =
127
Purge existing file [No]? yes {you must authorize purge!}
/s left 1;s right 50 {define margins as first 50 columns}
/kq nov99.datafile {unnumbered with 50-byte records}
/k notes,UNN,TEMP,YES {unnumbered,
temporary, purge old file}
/keep ,yes {keep to last text, purging old}
/file copylib=copylib.pub.develop
/text (custrec)
/visual
/keep {updates member}
/keep (custrec2) {creates new member}
/keepq (custrec) copylib2.test.develop
Absolute File Name
If you are on a version of
MPE/iX 5.0 which supports the Chdir command and the creation of new files in
the POSIX namespace, you may find yourself doing the following: Text file xxx,
Chdir to another directory to add from some other files, then Keep to update
your original file. Keep defaults to the "absolute" name (e.g.,
xxx.src.util or /user/dev/lib/src/xxx). This means you can change to other
directories after a Text, but still easily Keep the file back under its
original name. In the past, Keep would default to the "relative" name
of the Text file (e.g., xxx), saving the file in your current working
directory.
Keep Only When
Changes Were Made
Keep,Ifdirty only does the
Keep operation if the workfile has been modified since the last Text or Keep.
This can be useful in job streams that do Changes: by not Keeping files where
no string changes occurred, you reduce the number of files that appear on the
partial backup. To see whether your workfile is clean or dirty, do Verify Open.
Resetting File Commands
The Keep command pays
attention to any :File commands that you have active. If you specify a
file-close disposition like Temp or Save, and then try to text and keep the
file with Qedit, the purge of the existing file cannot be carried out and Qedit
will print an error message (Fclose Err: Duplicate). Qedit observes the :File
equation even if you do not specify an asterisk before the file name. To avoid
this confusion, :Reset the :File equation before texting or keeping the file.
/purge sj
/file
sj;rec=-80,16,f,ascii;disc=200;nocctl;save
/showjob *sj
/t sj
Qeditscr
27 lines in file
/k
SJ.JIM.TECHSUP,OLD 80B FA # of
records=27
Purge existing file [no]? y
Existing file apparently purged,
but still cannot save new file.
Fclose Err: Duplicate
SJ.JIM.TECHSUP,NEW 80B FA # of
records=27
DUPLICATE PERMANENT FILE NAME (FSERR 100)
/reset sj
/k
SJ.JIM.TECHSUP,OLD 80B FA # of
records=27
Purge existing file [no]? y
27 lines saved
File Modification
Timestamp
When you use the Text command
on a file, Qedit stores the file's modification timestamp in the workfile. If
you try to Keep the file, Qedit compares the stored timestamp with the file's
current timestamp. If they are different, it means the original file has
changed since you first opened it. Qedit will alert you to the difference by
displaying a message similar to the following:
Warning: Original file has been
modified since the initial
Text or last Keep
The file timestamp can change for a number of reasons.
Here are few examples:
·
Someone else might have been working on that
same file with Qedit and saved their changes before you did.
·
The file could have been restored.
·
Maybe you used the file to test a program which
modified the file in some way.
Because the timestamp message is just a warning, Qedit
continues its processing. It then asks for Keep confirmation. If you answer
"Yes", the file will be purged and you might lose someone else's changes.
Qedit will also store the new modification timestamp.
If you answer "No", you should compare the
contents of the file with your workfile and decide if it is safe to Keep your
changes. This is one way to compare the files:
·
Keep the workfile under a different name
·
Use our Compare bonus program to display the
differences between the original file and the new version you just created
·
Look at the report and separate the lines that
you changed from the ones you did not touch
·
If needed, apply changes to your copy so you are
not missing anything important
By default, timestamp checking on Keep is enabled. If you
want to change this setting, use the Set Keep Checktimestamp command.
If you want to erase the saved timestamp, you can use the
Set Keep Name command.
Notes
You do not need to Keep your Qedit workfile before
compiling. Only use Keep when you need a file as input to software that does
not read Qedit files. For example, you would Keep an IMAGE schema before
compiling it (although you can convert DBSCHEMA to read Qedit files; see the
chapter on installation at the end of this manual).
When you Text a file and Keep it again, Qedit attempts to
duplicate the original file. The form of the Keep file depends upon the current
language and Set options, especially Set Keep and Set Extentsize. To see what
the Keep file will look like, use Verify Keep.
Keep will retain the security
of your existing file (including the :Release state and the ACDs) if you answer
Yes to the "Purge old?" question. ACDs (Access Control Definitions)
are a form of security that allows you to say exactly which users can do what
to a file. Keep does not retain the ACDs on MPE V or when purging a remote
file.
Kills any or all of the
programs that are currently held.
:KILL [ @ | progfile [,entrypoint] ]
(Defaults: most
recently used)
When you save a son process (such as SPOOK) after
returning to Qedit, you can awaken it later. The process, and its resources, will
not be released until you Exit from Qedit, even if you never use it. To
terminate a son process at any time, you can use the :Kill command. You can
either kill all of your sons, one specified by name, or the most-recently used
one (this is the default). See also Run and Activate.
Examples
/COMMENT Assume that suprtool is
already held.
/run suprtool.pub.robelle {activate Suprtool}
Warning: Held program activated!
>get zz;list;xeq
>exit
Program Held. Use :Activate/:Run to rerun.
/kill
Terminate: SUPRTOOL.PUB.ROBELLE
Prints lines of the current
workfile, an external file, a spool file, or a Copylib member, either on your
screen or to a printer file.
LIST [$option...] [ rangelist ]
(Default: rangelist = *)
LIST [$option...] filename[,UNN]
[ rangelist ]
(Default: rangelist = ALL)
(Q=no linenums,
T=template, J=jumping)
If you do not specify a filename, List displays lines of the
current workfile. If you do specify a filename,
List displays lines from that file without Shutting your current workfile. You
can refer to the "previous" file by a shorthand method, a
"$".
If you specify a single line
number as a rangelist and that line does not exist in the current file, Qedit's
action depends on the Set List Nearest setting. If the option is Off, the
default, Qedit displays a No Line warning. If the option is On, Qedit displays
the nearest line. For example, if lines 100 to 120 are missing from a file,
here is what would happen:
/List 100
Warning: No Line
/Set List Nearest On
/List 100
121 This is line #121.
If you are trying to do something similar on an external
file, Qedit does not display anything.
Specify filename,UNN
when listing a data file which has numeric characters in the last 8 column
positions and they are not valid sequence numbers.
When you list lines of your current workfile, Qedit shows
only the columns within the current left and right margins, and the default rangelist is the current line (e.g.,
List = List *). When you List an external filename,
margins are ignored and the default rangelist
is ALL.
Examples
/list 5 {display line 5 only}
/listq 5/ {List-Quiet from 5 to Last}
/list "customer" {all lines containing
"customer"}
/list -5/+5 {display current vicinity}
/l r23gl.src {display entire source file}
/l r23gl.job ]-10/ {print last 11 lines of job file}
/l $ "$page"(1/5) {"$page" in column 1 of previous
file}
/set left 55;set right 132 {set margins in wide file}
/listt all {show template above columns}
/list "bob" (upshift)
{"bob","BOB","Bob",etc.}
/list "@UPD@MAST@" (pat) {strings UPD and MAST both in line}
{pattern matching}
$-Options
You can configure permanent options for the List command
using Set List; you can also select temporary
options within a specific List command. The temporary options are preceded
by a dollar sign.
LIST [ $option ... ] [ filename[,UNN]
] [ rangelist ]
The temporary $-options come after the command name and
before the external filename and rangelist.
Here are the $-options accepted in the List command:
|
[$lp | $lpa | $lpb | $record ]
|
Overrides default output to
$stdlist. $lp, $lpa and $lpb send output to a file with the same name as the
option. $Record sends output to LPCRT=$stdlist via Record mode.
|
|
[$DEVice filename]
|
The $device option sends
output to the specified file name. If the file name is not equated to a
particular device, the output is sent to that file name. If the file name is
redirected with a file equation (file filename;dev=printer),
then the output is sent to that device.
|
|
[$HEX | $OCTAL | $DECIMAL]
|
Numeric dump
|
|
$CHAR
|
Remove garbage; combines
with Hex/Octal/Dec
|
|
$PCL code
|
LaserJet fonts and orientation
|
|
$DUPLEX
|
Double-sided printing on
certain LaserJets
|
|
$EVEN | $ODD
|
Outputs even or odd number
of pages
|
|
[$COLUMNS (range, ...)]
|
Lists only certain columns
The $columns option allows you to list only the contents of certain columns.
You can specify up to four column ranges. The ranges have to be enclosed in
parentheses and can be separated by commas or spaces.
A range must have a start column and, optionally, an end column. If only a
start column is specified, the end column is assumed to be the same. In this
case, Qedit lists only one column. For example
/List
$columns (5) {lists only the contents of column 5}
/List $columns (5/10) {lists the contents of columns 5 to 10}
/List $columns (5 20/30) {lists column 5 and 20 to 30}
Column numbers must be valid for the Language of the file. For most files,
the first column is 1. For COBOL-type files, the first column is 7. Column
numbers must also be within the current left and right margins. The column
numbers do not have to be entered in a particular order. For example, the
column numbers in the first range can be greater than the column numbers in
the second range. The text appears in range order (i.e., range1, range2,
range3 and range4). The same column can be included in multiple column
ranges. The total number of columns listed cannot exceed the absolute line
length maximum (8,172 characters).
Although a template Listing is allowed with $columns, the output might not be
very helpful. For example,
/LT
$column (15/20)
+....2
1 O
2 pp
3 QQQ
4 rrrr
List $include is supported with $columns, but included files are treated as
if they are the same type as the main file. For example, if you include a
COBOL file within a Data file, the COBOL file will start at column one.
You can specify a rangelist (e.g., a search string with $columns). Qedit
first searches for the string, which can appear anywhere on the line, then
applies the $columns specification.
|
|
$DOUBLE
|
Double space the listing (or $DBL)
|
|
$SHIFT
|
Shift the listing four spaces to the right
|
|
[$RIGHTBY spaces]
|
Shift the listing to the
right by the number of spaces
The $rightby option works like the $shift option. It allows you to shift the
printed output to the right. The $shift option shifts the output by four
spaces. The $rightby option allows you to specify the number of spaces by
which the output is shifted. This number can be between 1 and 30.
/List
$shift LP {shifts output by four spaces}
/List $rightby 4 LP {also shifts output by four spaces}
/List $rightby 20 LP {shifts output by 20 spaces}
|
|
$INCLUDE
|
List/search $include files as well
|
|
$USE
|
List/search usefiles as well
|
|
$COPY
|
List/search COBOL Copylib files as well
|
|
$PAGE [ ON|OFF ]
|
Override Set List Page option
|
|
$LINES count
|
Override Set List Lines (per page)
|
|
$PRE | $POST
|
Override pre- or
post-spacing (default)
|
|
$SKIP | $NOSKIP
|
Override skip (default) or
noskip on perf
|
Here is an example that uses three of the $-options:
/list $lpa $double $shift all
This command would list all of
the current file to the LPA with double spacing, and the listing would be
shifted four spaces to the right. The file LPA defaults to Dev=LPA, but you can
use :file lpa;dev=serialp to redirect it.
When listing an external file, the $-options must come
before the file name:
/list $hex $char filename {hex-char dump of file}
Include Files
Normally, Qedit only searches
the current file for a string. If you specify the $include keyword, however,
Qedit will also search the $include files for the string.
/list $include
"global_variable"
The lines that specify Include
files must begin with either "$", "#", "!", or
".". In SPL programs, an exclamation point indicates that the rest of
the line should be treated as a comment. So, if a line starts with an
exclamation point followed by the word Include, Qedit also assumes this to be a
comment and not an actual Include statement.
The $include command must be spelled out in full, and it
can be indented from the prefix character ($, #, etc.). The prefix character
can be in any column as long as it is preceded by spaces only. Even though
Qedit allows prefix indentation, other programs such as compilers might require
prefixes to be in specific columns e.g. column 1.
So, as far as Qedit is concerned, the following examples
are valid Include source lines:
$include 'globals.source'
$include constant.srcinc
$ include headers
#include <strings.h>
#include "parser/bnf.c"
!
include somefile
.include chapter1.book
You cannot combine the $use and $include options.
Usefiles
The $use option is very
similar to the $include option. If you specify the $use keyword, Qedit will
also search any usefiles for a string. Usefiles are commonly used in PowerHouse
source code, Qedit and Suprtool command files, and jobs streams that run Qedit
and Suprtool.
The lines that contain the "use" directive must
have the word "use" as the first word in the line. Leading blanks are
allowed. Everything after the word "use" is assumed to be a file
name.
You cannot combine the $use and $include options.
COBOL Copylib
The $copy option is very
similar to the $include and $use options. This option works with files of
Language COBOL, COBX or COBFREE. It does not have any effect on files with
other languages.
If you specify the $copy keyword, Qedit scans all the
lines in the rangelist for the word Copy anywhere in columns 8 to 72
(columns 1 to 256 for COBFREE files). Qedit assumes the next word on the line
is the member name. It then looks for an In or Of clause. If
there is one, Qedit uses the next word as the library name. If there is no In and
Of
clauses, the library name defaults to Copylib.
Qedit will also search any COBOL Copylib files for a
string.
/list $copy 9/10 {list all Copylib members found}
{in lines 9 through
10}
/list $copy "CUSTREC" {list all lines containing the string}
{also scans Copylib
members}
You cannot combine $copy with $use and $include options.
$Device Option
The new $device option is very
similar to the $lp, $lpa, and $lpb keywords.
The above command opens a file called Printer and sends
the list output to it. To redirect the output from the List command to a printer,
you must specify a file equation to a valid device.
:file printer;dev=laser
/list $device printer
If both the $device and $lp keywords are used, the $device
takes precedence.
Configuring
Printers
By using :File commands in
your Qeditmgr file, you can define LP, LPA and LPB as three different printers
on your system. The default device class is LP, if no file equation is
specified.
:file lp;dev=lp
:file lpa;dev=serialp
:file lpb;dev=33
Merging Options
The $-options in the List command are merged with the Set
List options, except that Set List Record ON applies only to the file LP, not
LPA and LPB. The $-options can be combined wherever they make sense; they can
be used with Jumping, Quiet and Template, and can work on the current workfile
or an external file. $-Options may be shortened (e.g., $h = $hex).
Interrupting a
Listing
Press the Control-S key to
"pause" the listing for review. Then, press Control-Q to resume the
listing. On newer HP terminals, the Stop key pauses a listing until you press
Stop again. To stop the List command, press the Control-Y key.
Listing External Files
With the List command, you can look at any file on a
system to which you have read access security.
Qedit studies the file and determines whether it has
sequence numbers or not. If you ask for a rangelist
of lines, Qedit implicitly numbers a file without numbers. It starts at
line 1.0 and adds the current Set Increment value. If the file has sequence
numbers, Qedit uses them, unless it finds illegal numbers or numbers out of sequence. It then prints the following message:
Error: line
number out of sequence (001200) - renumbering the rest
The string in parentheses is the
incorrect line number. You should make sure it contains numeric digits only and
that it is greater than the number on the previous line. To check this
information, you should text the file using the Unnumbered option.
After reporting the information,
Qedit then assigns new numbers to the lines, starting with the last valid
number and adding the current increment.
Qedit uses this shorthand
character to refer to the most recent external file name: "$". For
example,
/list abc.source
"$page"(1/5)
/list $ 500/600
Because Qedit uses "LP" as a reserved keyword in
this command, you must use a :File command if you want to list an external file
named LP.
/:file xyzzy = lp
/list xyzzy
Listing Temp Files
Normally the List command looks for either a temporary
file or a permanent file with the specified name. To list only a temporary
file, append the Temp keyword to the file name:
You can append more than one keyword to the file name:
Listing Output
Spool Files (NM)
On MPE XL 2.1 and later, spool
files are now regular files that can be listed in Qedit. To make this easier,
Qedit converts the spool file numeric format (i.e., #o1234) into an MPE file
name for you. You can omit the "o" if you like.
/showout
/list #o1234
/lqj #456
Pre- Versus
Post-Spacing and Skip-on-Perf
If you Text a spool file into
Qedit and then reprint it using LQ, you may find that the file has switched
from pre-spacing to post-spacing or from noskip-on-perforation to skip-on-perf.
These are the defaults, and the information to override them is sometimes
hidden in the spool file where Qedit cannot find it. Similar problems may occur
when editing CCTL disc files.
List has the $pre, $post, $skip and $noskip options to
deal with these problems.
/listq $pre $lp all {pre-spacing on LP}
/listq $noskip $rec all {on attached printer}
/listq $pre all {on $stdlist}
A program selects these
printer options by using a carriage control code. The codes can be specified in
two ways: either through the Fwrite intrinsic, or the Fcontrol intrinsic (in
this case they do not show up when Qedit Freads the spool file). Here are the
four CCTL codes:
|
|
Char
|
Dec
|
Octal
|
Hex
|
|
Post-spacing
|
" "
|
64
|
%100
|
$40
|
|
Pre-spacing
|
"A"
|
65
|
%101
|
$41
|
|
Skip-on-perf
|
"B"
|
66
|
%102
|
$42
|
|
Noskip-on-perf
|
"C"
|
67
|
%103
|
$43
|
Listing Copylib
Members
To display a member of your
Copylib file, you just put the member name in parentheses. You don't need to
mention the name of the Copylib itself if you have a :File command for
"copylib". Otherwise just put the file name after the member name.
For example,
/file copylib=copylib.pub.develop
/list (custrec)
/list (custrec) copylib.test.develop
To list the member names in the Copylib, instead of the
members themselves, specify a pattern instead of an actual member name.
/list (b@) {names starting with "b"}
/list (@) {all the names}
Quiet Listing and
CCTL
LQ means list without showing
the line numbers. When you use LQ to list a file that has CCTL (carriage
control), Qedit uses the first column of each line as carriage control. Thus,
Qedit can reproduce application reports which were redirected from LP to Disc
(using :file list = xxx, new; cctl
;dev = disc) with exactly the same spacing and paging that was used originally.
Workfiles may also have CCTL (see Set Keep and Verify Keep).
Template Listing
The LT command prints a column-number template
before the first line of the listing.
/lqt 5
....+....10...+....20...+....30...+....40...+....50..
training of Qedit users is so easy that you will
Remember that the first column number in a standard COBOL
source file is column 7, not column 1. For a COBFREE file, the first column is
1. In addition, if you have done Set Left and Set Right to define margins for
your file, the template starts with the Left margin column and ends with the
Right margin column.
/set left 20;set right 41
/lqt 5
20...+....30...+....40
it users is so easy th
Browsing or
"List-Jumping"
When you add "J" to
"List" it means list-jumping. This lists the lines specified, but
stops every 23 lines (this pause is handy at 19.2K baud). Browse quickly
throughout a file, viewing as much or as little of each section as you like.
The default rangelist for ListJ is
*/Last, and ListJ linenum means start
jumping at linenum. You can go into
Browse mode quickly from Line mode by using the function keys. Press F6 to
start browsing at the current line, press F5 to browse starting back a page,
and press F2 to roll the screen forward a few lines before starting to browse.
At the end of each screen, ListJ prompts you for
"what to do next?" and waits for your reply. If the user presses
Return or F6, or types "yes", Qedit displays the next screen. If the
user presses F8 or Control-Y, or types "no", Qedit stops the listing.
If the user types a line number, a string, or a relative line count (e.g., -50,
+5), or presses F2, F3, F4, or F5, Qedit moves to a new location within the
file. When you enter any command, Qedit stops the listing, returns to Command
mode, and executes the command. When you are on an HP terminal, ListJ enhances
and erases the line with the "what to do next?" prompt.
You can combine ListJ with the $include option to browse
through the specified files as well as their $include files. You can combine
with ListJ with "Q" to display the lines without sequence numbers.
Also, you can combine "ListJ" with "T" to print a column
template at the top of each screen. In fact, you can combine all three options
into "ListJQT" to List-Jump without line numbers, but with a column
template.
The screensize can be changed from 23 lines to another number with Set
List LJ nn (where nn is some number of lines from 5 to
100). If you put the command Set List QJ On in your Qeditmgr file, you can
avoid seeing sequence numbers when you browse.
When List-Jumping reaches the last line of your file, it
prints "End! Are you DONE? [yes]" and waits for your answer.
"Yes" ends the listing, and "No" starts listing again from
the beginning. Set List Endstop On disables this question; List-Jumping just
prints the last line of the file and ends the LJ command.
Controlling Printer
Listings
When you put "$lp"
(or "$lpa" or "$lpb") in a List command, Qedit opens a file
named "LP" (or "LPA" or "LPB") with the device
Class "LP." The lines that would have been printed on the terminal
are written to the printer file instead. At the end of the command, Qedit
closes the file, which releases it for printing.
The default Qedit listing to the printer is a raw dump of
your lines, with or without line numbers. It has no page breaks, no headings,
no title, and no page numbers. However, you can override this default with the
Set List command.
Listing to Attached
Printer
To
list to a printer that is attached to your terminal, use List $record. If you
want all listings to $lp to go to the attached printer, do Set List Record On
and then List $lp. Qedit will use Record mode on your terminal or PC to print
on the attached printer. This option opens a file named LPCRT instead of LP.
If you have a LaserJet
connected to your PC and are using Reflection, you will want to Set Printer-Passthru-Conv
No in Reflection. Otherwise you will find that some characters are printing
oddly, such as the square block printing as a plus-minus sign. If you are using
Reflection for Windows, the above option may be called "Disable Printer
Translation" or "Use Host Character Set." As well, you have to
select "Bypass Windows Printing" and disable "Auto Form
Feed."
You can combine this option
with other listing options such as $PCL or $duplex. You cannot interrupt Record
mode with Control-Y, but you can do a soft Reset. This unlocks the keyboard and
causes the rest of the output to appear on the screen. You can then stop it
with Control-Y.
LP Listings with
Headings
To have Qedit do a page break
every 60 lines and put a heading with a page number on each page, do List $page
On $lp (or $record, $lpa, $lpb). To configure "paging" as the
default, do Set List Page On. Two lines at the top of each page are used as a
heading. The first line contains the page number, the file name (or the last
Text file name in the case of Qeditscr), and the time of the listing, and the
second line is blank.
In this mode, Qedit also looks
for $title, $page, #pragma page, and #pragma title commands in your file and
uses them to create page breaks. The optional string parameter of these
commands replaces the date and time in the page heading (e.g., $page
"Monthly Staff Review"). A $page or $title command without a string
clears the title area of the heading. The only exception to this processing is
an LQ of a CCTL file; in this case, the carriage control in column one of the
file determines the format of the printer listing, and $page commands are
ignored.
To vary the number of lines
per page, do List $lines nn, or use
Set List Lines nn for a permanent
override, where nn is a value between
1 and 256. (Assumes Set List Page On.).
/set list page on lines 59
To print the heading only on the first page, use $lines 0.
This causes continuous printing with no page ejects.
/list $lp $lines 0 all {ignores $page too}
To perform continuous printing
with no automatic page ejects but skip to a new page on $Page directives, use
$lines 999.
/list $lp
$lines 999 all {skips to a new page
on $page only}
To drop the file name from the
page heading, do Set List Name Off. (Assumes Set List Page On.)
/set list page on name off
To
drop the page numbers from each page, do Set List Num Off. (Assumes Set List
Page On.)
/set list page on name off num off
To drop the title from the
heading, do Set List Title Off. (Assumes Set List Page On.)
/set list page on title off
To drop the two-line heading from each page while still
doing page breaks, use Set List to disable the three components of the heading:
/set list page on name off num off
title off
Getting an Even or
Odd Number of Pages
There
are times when the number of printed pages is important. For example, you could
have a printer that is always loaded with pre-printed forms that come in pairs
(e.g., Page 1 of 2 and Page 2 of 2) or the paper is folded in certain ways so
that a report is easier to tear up and insert into a binder. In both examples,
sending a report with an odd number of pages would cause the next output to be
on a wrong page.
To prevent this from happening, you can now use the $even
or $odd options on the List command and ask Qedit to "round up" the
number of pages. The $even option ensures that the output has an even number of
pages. Similarly, the $odd option ensures there is an odd number of pages by
sending an extra page eject sequence before closing the output file.
These even and odd options are mutually exclusive (i.e.,
they cannot be both enabled at the same time). If you try use them both on the
same command, Qedit uses the last one in the sequence. For example, you can
type
/List $even $odd $lpa myfile
Qedit does not see this as an error and uses the $odd
option, ignoring $even.
These options only make sense if you are sending the list
to a printer, either attached or spooled. They have no effect when listing the
file to the screen. For this reason, you have to specify a destination printer
using $lp, $lpa, $lpb, $record or $device.
You can also use one of these options as the default by
using the Set List command. Specifying a $-option on the List command overrides
the Set value. There is currently no way to completely ignore the Set options.
If you want both options to be disabled, you have to issue
/Set List Even Off Odd Off
prior to the List
command.
Double-Spaced
Listings
When listing to LP, you can
force the result to be double spaced with List $double. This feature can be
combined with most of the other features of List, including LT, LQ, and Set
List Page On. To make all printer listings double spaced, do Set List Dbl On.
LQ on a CCTL file disables the Double option because the CCTL codes in the file
control the spacing on the listing.
LaserJet Listings
Qedit has two special options for HP LaserJets:
$duplex and $PCL. Duplex means double-sided printing, and PCL means Printer
Command Language, which is used to select fonts, spacing, and orientation.
$Duplex for Two-Sided Printing. Some LaserJets can print on both
sides of the paper; use List $duplex to enable this option.
PCL = Printer Command Language. All LaserJets have several sizes of
character fonts and can print in either landscape or portrait orientation. To
help you take advantage of these features, Qedit has a number of PCL codes that
can do all the work for you. PCL stands for Printer Command Language, which is
the HP standard for printers. To specify a LaserJet option for a single
listing, use List $PCL; to configure all listings, use Set List PCL. To disable
the special PCL option, use PCL 0. Get a quick on-line listing of the PCL
options with
Changing Fonts and
Orientation
Landscape-Tiny: PCL
1. To list to the LaserJet in the tiny font that prints across the paper
sideways (i.e., 16.67 pitch, landscape), use PCL 1. The number of columns is
automatically increased; you do not need to do any special Rec= on your :File
command.
/:file lp;dev=serialp
/list $lp $pcl 1 all
Landscape-Regular:
PCL 2. To list with the regular Courier font in landscape orientation, use
PCL 2. Again, there is no need to specify Rec=.
The Standard: PCL
3. The normal default for LaserJet output is portrait orientation (across
the narrow side) with the Courier font. However, once you insert a font
cartridge into your LaserJet, it may select one of the cartridge fonts as the
default instead of Courier. PCL 3 allows you to select the standard Courier
font, even if another font cartridge is installed.
Portrait-Tiny: PCL
4. Some LaserJets provide the tiny "Line printer" font in
portrait orientation as well as landscape orientation. PCL 4 selects this
option.
A4 Special: PCL 5. To print 80 columns, instead of 77, across A4
paper using the standard Courier typeface, try PCL 5. This tightens the spacing
between characters.
Legal-Landscape-Tiny:
PCL 6. To print tiny letters in landscape orientation on legal-size paper,
use PCL 6.
You can combine PCL 1, 2, 3, 4, 5, and 6 with Page On and
Off, with Lines 0, with LQ, with $DBL, with $record, and with $duplex.
Two-Column Listings
If your LaserJet supports
"Line printer" font in landscape orientation, you can print listings
across the page with two columns of text side by side.
/list
$lp $pcl 10 all {two-column
listing format}
/lq $rec $pcl 10 1/200
If you have a legal-size paper tray, you can use PCL 11 to
print two wide columns of 110 characters each on a single piece of paper.
A4-Size Paper
Most of the PCL options, with
the exception of PCL 5, were designed and tested with North American
letter-size paper. PCL 5 is especially for A4 paper; it reduces the horizontal
spacing between characters so that 80 columns of Courier output can fit on a
single line. In addition, if you add 2000 to a PCL code, Qedit adjusts the
number of rows and columns for that option to match A4 paper. For example, to
print two-up landscape on A4 paper, use PCL 2010 instead of PCL 10.
In general, selecting A4 paper gives you more space along
the long dimension of the paper and less space along the short dimension. If
you are happy with the way letter-size rows and columns work on A4 paper,
simply do not add 2000 to the PCL code. If for some reason you want more
columns than provided by Qedit (perhaps you are using a PCL-compatible system
printer with wider paper), you can override the size by using a :File command
with the Rec= parameter, as in :file lp;dev=syslp;rec=-220.
Summary of Qedit
PCL Codes
|
PCL
|
L/P
|
Font
|
A4 Rows
|
A4 Columns
|
Letter Rows
|
Letter Columns
|
Notes
|
|
1
|
L
|
lp
|
58
|
188
|
60
|
175
|
|
|
2
|
L
|
courier
|
43
|
110
|
45
|
100
|
|
|
3
|
P
|
courier
|
64
|
77
|
60
|
80
|
"standard"
|
|
4
|
P
|
lp
|
85
|
128
|
80
|
132
|
|
|
5
|
P
|
courier
|
64
|
80
|
60
|
80
|
A4-squeeze
|
|
6
|
L
|
lp
|
60
|
223
|
60
|
223
|
legal-size*
|
|
10
|
L
|
lp
|
58
|
95
|
60
|
87
|
two columns
|
|
11
|
L
|
lp
|
60
|
110
|
60
|
110
|
2-up legal*
|
L/P mean landscape or portrait orientation.
* Note: PCL 6 and 11 were designed to print on North
American legal-size paper and will select that size. However, you can see what
happens with A4 paper by using 2006 and 2011. Some people have found this
useful.
Roman-8 vs. ASCII
The PCL option requests a
Roman-8 character set, but some combination font cartridges only supply the
ASCII character set (half as many characters means twice as many fonts in a
single cartridge). If you ask for landscape Line printer and get landscape
Courier instead, your Line printer font probably has the ASCII character set instead
of the Roman-8 character set. To request an ASCII font, add 1,000 to the PCL
code. For example, if you have a Super Cartridge (55 fonts in one!), use PCL
1001, 1004, 1006, 1010 and 1011. To select both ASCII and A4 paper, add 3000.
Multiple Copies
To
produce multiple copies of a listing to a spooled printer, use a :File command.
For example, use these commands to produce three copies:
/:file lp;dev=lp,,3
/list $lp all
The :File command remains in effect until you enter
another :File command or :Reset LP or :BYE.
Redirecting Output
to Disc
You can also use :File
commands to direct output to a disc file:
/:file lpb = discfile, old; dev =
disc
/:build discfile; rec=-80,16,f,ascii
/list $lpb 100/200
The :Listredo command displays
any of the previous 1,000 commands.
LISTREDO [ start [ / stop ] ] [;ABS]
[;OUT=file]
[
string ] [;REL]
[ ALL | @ ] [;UNN]
(Default: display previous 20
commands)
(BJ, F7 and ,, are
short for Listredo)
Commands are numbered sequentially from 1 as entered and
the last 1,000 are retained. You can display a single command, a range of
commands, all 1,000, or all the commands whose name matches the string. You can
print the commands with ABSolute line numbers (the default), RELative line
numbers (-5/-4), or UNNumbered. You can write the commands to your terminal or
OUT to a temporary file. If you want to redo any of these commands, see :Do,
:Redo, and Before.
Notes
Examples
/listredo 5
/listredo 5/10
/listredo help {print all Help commands}
/bj {historical shorthand!}
/listredo -10 {print last ten commands}
/listredo ALL {print entire redo stack}
/listredo purge {print all Purge commands}
/listredo purge xx {print all "purge xx"
commands}
/listredo @purge {print all with "purge"
anywhere}
/listredo @;rel {print all, relative numbers}
/listredo 1/10;out=*lp {dump commands to printer}
/listredo @;unn;out=save {write
commands to a file}
Notes
The :Listredo command can be abbreviated to ",,"
as in MPEX, or to BJ, or can be invoked by the F7 function key. Using F7 to
invoke Listredo only works in Line mode, not Visual mode. You cannot use
";" to combine commands on the same line.
Displays the complete Undo
change log of commands that modified text, starting with the most recent and
working backward.
LISTUNDO
Listundo shows the complete
Undo change log, including each command, the number of lines updated, deleted,
added, or renumbered by that command, and the text lines. Text for deleted
lines is preceded by an underscore ("_") as in the Delete command,
and the "before" value of lines that were updated has a Greater Than
">".
Commands are printed in reverse order, with the most
recent command first. This is the command that would undone by the next Undo
command. To stop the Listundo report, use Control-Y.
Examples
Sorts a range of lines.
LSORT range [ KEYS keylist ]
LSORT string range [ KEYS keylist ]
(Q=no display)
(Default: by entire
line)
The simplest Lsort command just specifies a range of lines
to be sorted and no other parameters. This means to use the entire line as the
key and sort the lines into ascending order, printing them once sorted.
To stop Lsort from printing the sorted lines, use LsortQ.
Parameters
To sort by some other key fields in the lines (from one to
four are supported) or to sort the lines in Descending Order, you need to
specify the KEYS keylist parameters.
The keylist consists of one to four
keys separated by spaces or commas, with a key consisting of either a column
range or a starting column and length:
column , length [DESC]
column / column [DESC]
Ascending Order is assumed by default, but you may specify
DESC to sort this key in Descending Order.
Examples
/lsort all {sort entire file}
/lsortq all {sort without printing}
/lsort 10/33 {sort some lines only}
/lsort 30/last keys 10,5 {col 10 through 14}
/lsort zz keys 10/20 {col 10 through 20}
/lsort 20/last keys 1,10 20,5,desc {two keys}
Merges an external file into
the current workfile by line number. Use Merge to apply source-code
"changes-files" containing new and revised text, that are distributed
by some application vendors.
MERGE filename [ (rangelist) ]
(Q=no display,
J=Justified)
(Default: rangelist: ALL)
MergeQ suppresses printing of the merged lines.
The optional rangelist
specifies a subset of the external file to merge into the current file.
Examples
/text master.src {start with the master file}
/merge changes {update changed lines, add new}
Notes
To make your own "merge file", create a file
that contains edits to be applied to your current workfile. Mark the lines of
text that will replace existing lines in your workfile, with the corresponding
line numbers. Give new line numbers to any completely new lines of text to be
added to your workfile. To delete lines in your workfile, use the $edit Void
command of the MPE compilers in the merge file. $Edit Void removes the line
number specified in the command and, optionally, lines up to and including a
Void= line number. Warning: the
Void= parameter cannot accept a
decimal point so, for example, you must enter Qedit line 60.1 as 60100. To
delete from line 55 to 60.1, you would use the following:
Justified
The default is to replace existing lines with the
corresponding line from the external file. The Justified option appends the corresponding
line from the external file. Text is appended immediately after the last
non-blank character if Set Work Trailingspaces is disabled. If Trailinspaces is enabled, text is appended
immediately after the last significant trailing space. If the resulting merged
line is too long for the current length, the merged line is truncated. Let's
say the current workfile contains:
and the external file contains:
A MergeJ would result in:
If the maximum length was 5, the
resulting file would be:
/mergej
myfile
1
11111
Warning: Result line will be too long. Truncating merged text.
2
22222
Warning: Result line will be too long. Truncating merged text.
3
33333
Warning: Result line will be too long. Truncating merged text.
3 lines
merged
/l all
1
abc11
2
def22
3
ghj33
Editing characters within
lines using either Control codes (default Set Mod Robelle), D-I-R-U edits (Set
Mod HP), or Control codes with visible feedback (Set Mod Qzmod).
MODIFY rangelist
(Q=no linenum,
T=template)
(Default: rangelist = *)
By default, Modify displays the first line and puts the
cursor under the first column. You enter an "edit-line" to specify a
changes. You use spaces to move the cursor under the word you want to change,
then type new characters to replace those in the columns above. For example:
/modify 5
5 Over 2000 computers use
Suprtool. {prints line}
750 {you edit it}
5 Over 2750 computers use
Suprtool. {prints new line}
<Return>
{end Modify}
Each time you press Return, Modify applies your changes to
the line and prints the new result. This cycle continues until you enter only a
Return (no more edits).
You use nonprinting Control codes for editing, such as
Control-D to delete. For visual feedback, do Set Mod Qzmod, which puts your
cursor right on top of the line and responds to each Control code by revising
the image on the screen (i.e., Control-D actually makes the character disappear
from the screen). If you would prefer to use MPE-style edits (D-I-R-U) instead
of Control Codes, do Set Mod HP to reconfigure Modify.
To force the line number onto a separate line, use Set Mod
Prompt OFF.
Examples
/modify 5/ {modify from line 5 until ^Y or end}
/find "corelate";m {find
spelling error and modify line}
/mod "q_flag" {modify all lines with
"q_flag"}
Getting into Modify
Mode
There are other commands that
invoke Modify mode in Qedit:
·
Change, when a line overflows or you use CJ.
·
Add, when you use the auto modify character from Set Zip.
·
Before, so that you can revise and redo a
previous command.
·
Redo, also enables you to revise and redo a
previous command.
Edit Functions of
Modify
Here are the edit functions of Modify and their Control
codes, which may be changed with the Set Modify command.
|
Function
|
Key
|
Purpose
|
|
Overwrite
|
Control-O
|
Replace characters (default).
|
|
Delete
|
Control-D
|
Delete characters.
|
|
Before
|
Control-B
|
Insert characters before a column.
|
|
Append
|
Control-A
|
Add characters to end of the line.
|
|
Divide
|
Control-V
|
Divide line in two at this column.
|
|
Goof
|
Control-G
|
Restart Modify with original line.
|
|
Terminate
|
Control-T
|
End this edit so you can do another.
|
|
Lengthen
|
Control-L
|
Same as Append (Control-A).
|
|
Insert
|
Control-^
|
Same as Before (Control-B).
|
Advanced
You create Control codes by
holding down the Control key while pressing the other key. Most Control codes
are invisible and do not move the cursor. In the user manual, the symbol (^) as
a prefix stands for the Control key (^-D for Control-D).
Some functions combine two of the Control codes: pressing
^-T then ^-V in the first column of a line splices
two lines together (and deletes the second line if it's emptied). Actions
not restricted to column 1 may be performed at any point on the line.
|
Function
|
Key
|
Col.
|
Purpose
|
|
Splice
|
^T ^V
|
1
|
Fills current line from next line.
|
|
Insert Line
|
^A ^V
|
1
|
Adds a blank line before
current one.
|
|
Insert Line
|
^A ^V
|
|
Adds a blank line after
current line.
|
|
Delete Last
|
^A ^D
|
|
Spaces remove characters at end of line.
|
|
Replace End
|
^A ^O
|
|
Replaces from end of line (overwrites).
|
|
Delete Line
|
^T ^D
|
1
|
Deletes current line.
|
Overwriting
Characters
To overwrite characters in a line, type the new characters
underneath the ones to be replaced. There is no need to type a control
character; "overwrite" is the default edit function. Once you are in
Overwrite mode, you can also use the Space bar to erase the columns that you
move through. If you have not yet typed any characters, the Space bar just
moves your column position to the right one place. You can get into Overwrite
mode at any time while in modify by pressing Control-O. Terminate overwrite
mode and go into space- transparency mode by typing Control-T.
Start Over Editing
a Line
To correct a Modify mistake,
enter the Goof control code (Control-G) and press Return. Qedit restores the
line to its original contents and restarts the Modify cycle. Control-G does not
undo Splits and Splices.
Doing Several Edits
in One Line
You can do more than one edit operation in one edit-line
if each edit is clearly separated from the preceding and following ones. When
the edits are at different ends of the line, you must Terminate the first
function so that you can move the cursor right to the next column. The
Terminate control code (Control-T) provides this capability.
The following illustrates where to place your control
codes (^ stands for the Control key), even though they will not appear on your
screen. The first example capitalizes the "r" in "return",
then replaces "in error" with "by mistake", which requires
inserting the letters "ke." The second example inserts the word
"Goof" and a space at the start of the line, and deletes the last two
words at the end of the sentence, adding a final period.
/m 13
13 a return. If you do this in
error, {displays line}
R by mistake {^codes are: }
<spaces> R<^T, spaces> by
mista<^B>ke<Return>
13 a Return. If you do this by
mistake, {redisplays}
/m+1
14 control code restores the
line for you. {displays line}
Goof
. {^codes are: }
<^B>Goof <^T, spaces> .<^D, Return>
14 Goof control code restores
the line. {redisplays}
Deleting Characters
To delete characters from the
line, starting with the current column position, enter the Delete control code
(Control-D). Then space to the right the number of columns to be deleted. Any
remaining characters in the line are left-shifted to fill in the deleted
columns.
In all cases, the columns deleted are those immediately
above the cursor, regardless of what other functions have been performed
previously on the same line. The Delete function is stopped by the first nonblank
character, either Return, a printing character to switch back into Overwrite
function, or another control code.
Erasing the Line
To erase from the current column to the end of the line,
enter the Delete control code, followed by a Return. If you do this by mistake,
the Goof control code restores the line for you.
Inserting
Characters
To insert characters in the
line before the current column position, enter the Before control code
(Control-B). Then type the characters to be inserted. The existing characters
starting in the insert column are right-shifted to make room for the new
characters.
On the operator's console of certain HP e3000 models,
the Control-B character puts the terminal into
"maintenance" mode. In these cases, use Control-^ instead. If you do
press Control-B on the console accidentally, type "CO" on a Series
800 or 900. On a Micro3000, type "RUN".
Adding Characters
to the End of a Line
To add characters to the end
of the line after the last nonblank character in the line, enter the Append
control code (Control-A). Then type the characters to be added. This function
is independent of the current column position.
Dividing a Line
into Two Lines
The Divide control code
(Control-V) splits the current line into two lines at the current column
position. If a line number is available, Qedit moves all characters from the
current column to the end of the line to a new line that is added after the
current line. The Goof function recalls the original contents of the line, but
does not delete the new line (neither does Control-Y). See also Divide command.
Splicing Two Lines
Together
To splice two lines together,
you must be on the first column of the first line you wish to splice. Type
Control-T, then Control-V, and quick as a wink, all the characters from the
second line are appended to the end of your current one. Qedit moves only as
many characters as will fit. If all the characters are moved, the second line,
now empty, is deleted. See also the Glue command.
Editing Lines with
More Than 80 Columns
To modify long lines (i.e., more than 80 columns), use Set
Left and Set Right to define a slice through the lines.
/set left 55
/mqt * {quiet, with template}
+....60...+....70...+....80...+....90...+....100..+....
ubsequent Sales Follow-up - Completion
Ratio Report
Or use Set Modify Qzmodify, it handles long lines without
the need to set margins.
Qzmodify: WYSIWYG
You may want to try Set Modify
Qzmodify to replace the normal Qedit modify with a "visual" modify
(What You See Is What You Get). Qzmodify uses the same Control codes, plus many
extensions, but Qzmodify does single-character reads. This allows it to respond
immediately and visually to each keystroke, but means that the performance is
unacceptable over NS, packet-switching LANs, and the DTC. Once in Qzmodify,
type Control-Q for a list of commands.
How to Edit in
Qzmodify
In Qzmodify, "what you see is what you get". The
cursor rests on the same line as the text you are editing. If you press any printable
key (ASCII code 32 or greater), that key either replaces the character the
cursor was on, or (if Insert mode is on) inserts the key before that character,
moving the rest of line to the right by one character.
When you initially enter Qzmodify you are in Transparent
mode--here, a blank simply causes the cursor to move one space to the right.
Pressing any other printable character immediately terminates Transparent mode
and puts you in Overwrite mode, so the character replaces the one the cursor is
on. The three basic modes are:
|
Mode
|
To enter
|
To exit
|
|
transparent
|
^T
|
any printable char, ^B, ^O, or ^X
|
|
overwrite
|
^O
|
^T, ^B, or ^X
|
|
insert
|
^B or ^^
|
^T, ^O, or ^X
|
Qzmodify will not allow you to create a line longer than a
maximum specified by the calling program, nor can you accidentally
"lose" characters off the right edge when using Insert mode ...
Qzmodify beeps when you try to do something illegal. To edit Roman-8
characters, use Set Editinput Extend ON.
Editing Commands
Qzmodify has an extensive set
of commands, all of which are invoked via control characters. In this
documentation, the symbol ^ means that the following character is a control
character (e.g., ^G is control-G). Control characters may be entered as lowercase
or uppercase letters (i.e: ^g and ^G are identical).
|
Char Mnemonic
|
Description
|
|
^A append
|
Go to end-of-line. Moves the cursor to just after the last
character on the line. If the line is already at the maximum length, the
cursor is placed at the last character.
|
|
^B before
|
Turn on Insert mode. Turns off Overwrite mode. If you
enter a character while in Insert mode, it will be put Before the character
the cursor is on, and the rest of the line will move one to the right.
|
|
^^ before
|
Control up-arrow...synonym of ^B. Use ^^ instead of ^B if
you are on a system console!
|
|
^C case
|
Change case of current character. If the current character
is a lowercase letter, it will be changed to an uppercase letter and vice
versa.
|
|
^D delete
|
Delete character. Pressing ^D will cause the character
under the cursor to be deleted, and the rest of the line to be moved one
space to the left.
|
|
^L^D delete end
|
If the cursor is just past the last character in the line,
(i.e., you just did a ^L or ^A), then the ^D will delete the last character
of the line.
|
|
^E erase
|
Erase to end of line. This will erase all of the text from
the cursor to the end of the line.
|
|
^F<c> find
|
Find next occurrence of character <c>. The cursor
will be moved to the next occurrence of the character <c> to the right
of the cursor. If <c> is not found, you will hear a beep.
|
|
^F<n><c>
|
Find nth occurrence of <c> where 1<=n<=8.
|
|
^G goof
|
Undo all current modifications. Restores the line of text
to its original form. Note: ^V, ^K, ^T^D, and ^T^V cannot be undone.
|
|
^H backspace
|
Move back one character (nondestructive).
|
|
^I tab
|
Skip ahead to the next tab stop.
|
|
^J justify
|
Deletes blanks from the cursor to the first nonblank (does
not delete that character).
|
|
^K add
|
Requests Qedit to add a line after the current line. The
current line will then be redisplayed for editing and you will get to edit
the new line.
|
|
^L lengthen
|
Go to end-of-line...synonym of ^A. Use ^L instead of ^A if
you are on a Type Ahead Engine (TAE).
|
|
^M return
|
Marks the end of editing a line. Returns the modified line
to Qedit. Note that ^M is the same as Return.
|
|
^O overwrite
|
Initiates Overwrite mode and turns off Insert mode (^B).
In Overwrite mode, if you enter a character, it will replace the one on the
screen.
|
|
^P<#><dir>
|
Moves up or down some number of lines of text. For
example, ^P3- moves back three lines.
|
|
^Q query
|
Displays list of Qzmodify functions.
|
|
^S<c> scan
|
Find previous occurrence of <c>. The cursor will be
moved to the first occurrence of <c> to the left of the current cursor
position. If <c> is not found, you will hear a beep.
|
|
^S<n><c>
|
Find nth occurrence of <c> where 1<=n<=8.
|
|
^T Transparent
|
Terminates Insert mode and Overwrite mode. After ^T, if
you type blanks, the cursor simply moves right one space without affecting
the text. Transparent mode is always turned off automatically whenever a
nonblank printable character is entered, then Overwrite mode is turned on.
|
|
^T^D delete
|
If done at column one, this deletes the entire line.
|
|
^T^V splice
|
If done at column one, this will join the next line to the
end of the current line and display the spliced line for editing. If not a
column one, then is the same as ^V.
|
|
^U jUmpback
|
Move back to the previous tab stop. This is the opposite
to ^I. As an aid to remembering them, ^I is the same as pressing the tab key,
and ^U is just to the left of ^I on the keyboard.
|
|
^V split
|
Split the current line (at the cursor) into two lines and
modify both of them. Note that ^Y restores the text if you decide not to make
the change, but you have to manually remove the second split-off line.
|
|
^X eXamine
|
Examine (redisplay) the current line.
|
|
^Y abort
|
Terminates modify without
changing the current line.
|
|
^W Wordproc
|
Shifts into "word-processor" mode. In
word-processor mode, the next control character is used to select a function.
The functions are:
|
|
^W^C
|
Compress multiple blank spaces to single blank spaces.
|
|
^W^D
|
Delete Word. Deletes from the cursor to the next blank,
and then any following blanks up to (but not including) the next nonblank.
|
|
^W^H
|
Toggles a flag that remembers if you have an HP 110 (or an
HP 2640). The flag is needed because the HP 110 knows only a subset of the
"standard" HP 26xx escape sequences, and some of them incorrectly!
|
|
^W^L
|
Draws a ruled "line"; similar to the ListT
command.
|
|
^W^N
|
Toggles Numbered mode. A line-number prefix will be
displayed in front of a line of text only if both of the following are true:-
line numbers have been requested (either via a Modify command from Qedit or
via ^W^N);- the line number was passed to Qzmodify by Qedit (i.e., you did an
Modify command, not an ModifyQ command)
|
|
^W<c>^D
|
Delete all characters from the cursor up to, but not
including, character <c>. Note: <c> must be a printable ASCII
character (character code > 31). If the cursor is currently on the same
<c>, it is deleted immediately before looking for the first <c>.
If <c> is not found, nothing is deleted.
|
|
^W^P<c>
|
Put the character into the text. This is useful when you
want to put a control character into the text. All nonprintable characters
will be displayed as periods (.), so they will take up one space on the line.
|
|
^W^S^D
|
Downshift all letters from the cursor to end-of-line.
|
|
^W^S^U
|
Upshift all letters from the cursor to end-of-line.
|
|
^W^S^T
|
Reverse the case (e.g., "a" becomes
"A" and "A" becomes "a") of all letters from
the cursor to end-of-line.
|
|
^W^T
|
Toggles the Type Ahead Engine (if you have one) through
three states: disabled, enabled, ignored.
|
|
^W^V
|
Prints the version ID of Qzmodify.
|
|
^W?
|
Display the ASCII character code for the character that
the cursor is on.
|
|
^W$<hh>
|
Replace the character at the current column position with
the ASCII character whose hexadecimal value is <hh>.
|
Symbols Used in
Qzmodify Command List
<c> is any single character. Qzmodify will search
for this character. If <c> is ^W, the search will be for the next word
(words are anything delimited by blanks) instead of for a single character.
<#> is zero or more digits. For example, ^P12+ would
mean move forward 12 lines. ^P3- would move back three lines.
<n> is one of: ^A, ^B, ..., ^H and is interpreted as
the number 1, 2, ..., 8 respectively.
<dir> is a "-" to move "back",
or a "+" to move "forward".
<hh> is any pair of hexadecimal digits.
Note: When modifying a line longer than 79 characters,
some commands (e.g.: ^D, ^B, ^E) will not update any line of the screen display
other than the one you are on. Whenever you want to see an accurate display of
your text line, press ^X to refresh the display. This limitation could be
fixed, but only at the cost of slowing down response time while editing these
longer lines.
Note: You cannot use the special keys on an HP terminal
(e.g.: cursor keys, insert char, delete char, clear) because they are designed
to either send no characters to the computer when they are pressed or two
characters ... and both of these choices cause difficult problems on an HP
e3000 without a Type Ahead Engine. Thus, these keys should not be used. If you
use them by accident, a ^X will refresh the display of the line you are editing.
Qzmodify with a
Type Ahead Engine
The Type Ahead Engine (TAE)
from Telamon can be in one of three states from the Qzmodify viewpoint:
disabled, enabled, or ignored. Each is defined below.
Ignored. Qzmodify
will not do anything to either encourage the use, or discourage the use, of the
TAE. This is usually the initial state (see below).
Enabled. Qzmodify
will place the TAE in single-character mode at entry, and restore it to Line
mode at exit. This means that the HP3000 won't lose typed ahead input anymore,
and that the special keys (e.g., cursor keys) will work nicely.
Disabled. Qzmodify
will disable typeahead (by sending ^A^V to the TAE) at entry, and enable it at
exit. In this mode, the TAE is effectively taken out of the "circuit".
With Qedit, you configure TAE-treatment as part of the Set
Modify Qzmodify command:
Set Mod Qzmodify {ignore the TAE}
Set Mod Qzmod TAEOFF {TAE exists,
disable it}
Set Mod Qzmod TAE {TAE exists, enable it}
When the TAE is present and enabled, you can use these
extra commands:
|
^W^T
|
Toggles the Type Ahead Engine through three states:
disabled, enabled, ignored.
|
|
leftarrow
|
The HP26xx left-arrow key will move the cursor 1 space to
the left.
|
|
rightarrow
|
The HP26xx right-arrow key will move the cursor 1 space to
the right.
|
|
up arrow
|
Move up to the prior line of text, leaving cursor in the
same column. The terminal screen is scrolled DOWN, so the line you were just
editing is moved down 1.
|
|
down arrow
|
Move down to the next line of text, leaving cursor in the
same column. The terminal screen is scrolled UP, so the line you were just
editing is moved up 1.
|
|
delete char
|
Deletes the character under the cursor (like ^D).
|
|
insert char
|
Turns on Insert mode (like ^B).
|
|
insert line
|
Asks Qedit to add a new line after the current line.
|
|
delete line
|
Asks Qedit to delete the current line.
|
|
^leftarrow
|
Moves cursor LEFT to the blank just after the nearest
"word" on the left of the cursor. Valid only if a Type Ahead Engine
is present and enabled. Only available on HP264x terminals.
|
|
^rightarrow
|
Moves cursor RIGHT until it reaches the start of the next
"word" (will not move past current end of text.) Valid only if a
Type Ahead Engine is present and enabled. Only available on HP264x terminals.
|
Hpmodify: No
Control Characters
Set Modify Hpmodify replaces
Qedit's standard Modify in all places with MPE-style editing (D for delete, I
for insert, R for replace, U for undo, > for append, >D for delete at
end, >R for replace at end, and D> for clear). We suggest Hpmodify when
using Qedit over finicky datacomm networks, since it does not require any
Control codes.
Hpmodify Keys -
Reference
|
Directive
|
Effect
|
|
i
|
INSERT. If text follows the i, this text is inserted in
the current line, starting at the position of the i.
|
|
r
|
REPLACE. If text follows the r, this text replaces the
same number of characters in the current line, beginning at the position of
the r.
|
|
d
|
DELETE. Deletes a character from the current line for each
d specified in the edit line. Note that "d d" does not specify a
range as it does in MPE V but simply deletes one character above each d.
Multiple d's may be followed by an Insert or Replace operation.
|
|
d>
|
DELETE. Deletes to the end of the current line from the
position specified by d>. May be followed by an Insert or Replace
operation.
|
|
>
|
APPEND. If text follows the
>, this text is appended to the end of the current line. If a > without
text is positioned beyond the end of the current line, then a simple
replacement is performed instead.
|
|
>d
|
DELETE. Deletes from the end of the current line,
right-to-left. Multiple d's and Insert and Replace strings may be specified
after > .
|
|
>r
|
REPLACE. Replaces characters at the end of the command
line. The last (rightmost) character of the replacement string is at the end
of the line.
|
|
c
|
CHANGE. Changes all
occurrences of one string to another in the current line starting at the c.
The search string and replace string must be properly delimited. A proper
delimiter is a nonalphabetic character (such as ' " or /) The
substitution is specified as cdelim
search-string delim [replace-string
[delim]]. Omitting the replace-string causes occurrences of search-string to be deleted, with no
substitution.
|
|
u
|
UNDO. A single u in column
one cancels the most recent edit of the current line. Using the Undo command
twice in a row cancels all edits for the current line and re-establishes the
original, unedited line. If u is placed anywhere other than column one of the
current line, then a simple replacement is performed. Undo makes sense only
if you have a line on which you have performed some editing that can be
"undone."
|
|
other
|
Simple replacement. Any other character (not i, r, d,
d>, >, >d, >r, c, or u) will be put into the current line at the
position above where it is placed, replacing any existing character. Simple
replacement also occurs for the editing characters i, r, c, or > if they
are not followed by text; or if > appears at or beyond the current end of
line.
|
Hpmodify Examples
|
Edit
|
Action
|
|
u
|
First occurrence undoes the previous edits. The u must be
in column one.
|
|
u
|
Second occurrence undoes all edits on the current line.
The u must be in column one.
|
|
rxyz
|
Replaces the current text with xyz starting at the
position of r.
|
|
xyz
|
Replaces the current text with xyz starting at the
position of x.
|
|
ixyz
|
Inserts xyz into the current line, starting at the
position of the i.
|
|
ddd
|
Deletes three characters, one above each d.
|
|
d xyz
|
Deletes a single character above the d, skips one space,
then replaces the current text with xyz starting at the position of x.
|
|
ddixy
|
Deletes two characters, then inserts xyz in the current line
starting at the position of the i.
|
|
d d
|
Deletes one character above the first d, skips two spaces
and deletes a second character above the second d. It does not delete a range
of characters, making it unlike the MPE V version of Redo.
|
|
d d>xyz
|
Deletes a single character above the first d, skips two
spaces and deletes to the end of the line beginning at the second d, and then
places xyz at the end of line.
|
|
>xyz
|
Appends xyz to the end of the current line.
|
|
>ddxyz
|
Deletes the last two characters from the end of the
current line and then places xyz at the end of the line.
|
|
>rxyz
|
Replaces the last three characters in the current line
with xyz.
|
|
>ixyz
|
Appends xyz to the end of the line. In this case, the i
command is superfluous, because > accomplishes the same result. Using
>xyz would be sufficient.
|
|
c/ab/def
|
Changes all occurrences of ab to def, starting at c.
|
|
c"ab"
|
Deletes all occurrences of "ab" starting at c.
|
|
cxyz
|
Replace the current text with cxyz, starting at c. Because
delimiters have not been specified (as they were in the previous two
examples), this is a simple replacement with the four characters.
|
Creates a new, empty Qedit
workfile and opens it. This can be either an unnamed extra scratch file or a
named workfile. The advantages of a workfile are that you can instantly Open
and Shut it, and that it compresses your data. You can use Text to make a copy
of a Qedit file when you wish to protect the work you have done.
NEW filename [,language [ (size) ]
NEW
(Default: extra
scratch, 3200 lines)
Qedit shuts the current file and builds filename, which it then opens for
editing. If you leave out filename,
Qedit creates a new extra scratch file and assigns it a number (1,2,3..) so
that you can recognize it in Verify Open and Open ?. Up to eight extra scratch
files are allowed (see also the TextJ command). You can convert a scratch file
into a named workfile at any time by Opening it and doing Shut filename. You cannot Exit without
discarding or saving any edits you have done in an extra scratch file.
The language defaults
to the current Set Lang value, but can be overridden. This is useful for
forcing creation of a Jumbo workfile in Qedit/MPE by doing "new
abc,data."
If you want to force creating
a Wide-Jumbo format, you should set the Length to a value larger than 1,000
before issuing the New command.
/Set Length 2500
/New newwork
These commands create a new permanent workfile called
Newwork. If you want to create a new scratch file, enter the New command by
itself.
The optional size
specifies the number of lines you expect to add to the file. The minimum size is 200 lines, the default is 3200
(see Set Work for increasing or decreasing the default size), and the maximum
is either 65,535 or 99,999,999.
Examples
/new {create an extra scratch
file}
/new memos {create an empty file named
Memos}
/set lang job {define file as 80-column
records}
/add
/new forbig,data (100000) {Jumbo workfile}
/new frankie(500) {build Frankie for 500 lines}
/aq 1=johnny {memos was shut automatically}
Building Workfiles
with Text
You can also create new workfiles
while doing a Text command.
/text johnny {copy Johnny file into
Qeditscr}
/shut frankie {save Qeditscr as Frankie
file}
or...
/t frankie=johnny {build Frankie file ...}
{and copy Johnny
into it}
The advantage of this method over New is that Qedit
ensures that the size of the new
workfile is always large enough for the external file, plus room for expansion.
When you create the workfile with New, you may not build it large enough to
hold a file that you Text into it later.
Instantly opens or reopens a
Qedit file for editing or browsing, as opposed to the Text command which
creates a copy of a file for editing.
OPEN filename[,BROWSE|DEFER|NODEFER]
*
*-n
?
(Default: edit
primary scratch file)
Qedit shuts the current workfile and opens filename. The filename must exist (see New and Text) and must be a Qedit workfile
or scratch file. You cannot Open a Keep file - you must first Text it into a
scratch file.
Open filename,Browse opens a workfile for browsing in Qedit. You can use
the List command, including List-Jumping, Hold, Visual mode HH and ZZ, and any
other functions of Qedit which do not
modify the file. Open-Browse protects you from making unplanned changes to
a file.
If you try to Keep the file with its original name i.e.
you enter a Keep without a filename, you will get an error.
/Open workfile,browse
/Verify Keep
Set Keep Name txtfile
/K
File opened with Browse, please specify
a Keep file name
You can still force a Keep by specifying an explicit
filename as in:
/Open workfile,browse
/Keep txtfile
TXTFILE.DATA.ACCT,OLD 80B FA # of
records=16
Purge existing file [no]? y
Open filename,Defer
opens the workfile without write access, but acquires write access later if you
attempt to modify the file. Set Open Defer On makes Defer the default and Open filename,Nodefer overrides that command.
It is important to remember that certain workfile attributes
and settings are normally saved when the file is opened with write access. Some
of these settings are the ZZ marker, the current line marker (*), and a new
default Keep name modified with Set Keep Name. If you open a workfile in Browse
mode, these settings are not updated unless the file is re-opened with write
access.
To reopen the file most recently accessed, do open *;
for the file before that do open *-1, then open *-2, and so. To select from
a list of recently accessed files, do open ?.
Examples
/open mail {want to edit Mail}
/c "stop"start" @
/open * {reopen previous file}
/list all
/open ? {select a recent file}
/visual
/open *-1 {select file before last}
/list "function"
/open *-2 {select file before that}
/hold 400/500
/open {edit scratch file}
Notes
Since you must Open a file before editing, any command
that requires an Open file prompts you for the filename if none is Open.
If you attempt to Open a file which is not a Qedit
workfile, you see a message similar to the following:
/open qpart2
QPART2 Error: you can only Open Qedit
workfiles (code=111)
You need to Text this file, not Open it.
The Open Stack
Qedit maintains an Open-Stack
of the ten most recently Opened files. One of these is always reserved for the
primary scratch file. You can have up to eight extra scratch files (see TextJ
and New), which take priority over named workfiles in the Open-Stack. To reopen
one of these files, do an open ? command. Open ? prints the list and prompts
for a relative file number, starting with zero for the most recent (same as
Open *).
Open *-n allows
you to open one of the recently accessed files directly. Open
*-2 opens the third file in the list, since zero is the first.
When you open any file it moves to the top of the list and
the other files are pushed down one position. The Close command shuts the
current workfile and removes it from the list of recently accessed files. This
is useful to stop desired file names from dropping off the bottom of the list.
If the file is a scratch file, you are prompted to Discard Changes.
Set Open Defer On
If you use Set Open Defer On,
the Open command does not acquire write access to a workfile until you make a
change to it. The workfile is opened with read access by default, unless Qedit
knows you are going to be writing to it (as when Text or Add force an Open). If
you only browse through the file, the Last-Mod date does not change. This
includes full-screen mode viewing. However, if you make any changes to the file
or use Set Left/Right/Length /Lang, Qedit reopens the workfile with write
access.
It is important to remember that certain workfile
attributes and settings are normally saved when the file is opened with write
access. Some of these settings are the ZZ marker, the current line marker (*),
and a new default Keep name modified with Set Keep Name. If you explicitly open
a workfile in Browse mode or use Set Open Defer On, these settings are not
updated permanently unless the file is re-opened with write access.
You can override the current Set Open Defer value by doing
Open filename,Defer or Open filename,Nodefer.
There are a few error conditions that may occur if you attempt
to modify a file because now someone else can edit the file while you have it
open. For example, you cannot obtain write access if someone else already has
write access to the file. In Visual mode, you may see the error "Unable to
reopen file with write access. Concurrent usage/backup?".
If "Error: EXCLUSIVE
VIOLATION: FILE BEING ACCESSED" appears when you try to open a file, it
means that either someone is editing the file or it is being backed up.
If you are working in Visual mode, someone can delete the
lines you want to edit after Qedit has displayed them on your screen. If this
happens, Qedit does not update your screen and displays this error message:
"File has changed since page last displayed. Another user?"
Crash Recovery
Qedit ensures the validity of
workfiles after a system crash or program :Abort. It checks to see whether the
file was properly closed the last time. If the file was in the midst of
Renumber, Qedit completes the renumber. If the file was in the middle of a
Text, Qedit clears the file so you can do the Text over again. In all other
cases, Qedit prints a RECOVERY warning and searches through the file to
eliminate any duplicate lines. After a RECOVERY, examine the area of lines that
you were last editing. A few lines may be missing or out-of-date, but that is
all. If a workfile is ever damaged, use the Serial option of QCOPY to recover
the file.
File Modification
Timestamp
When you use the Text or Keep
commands on a file, Qedit stores the file's modification timestamp in the
workfile. If you Shut the workfile to do something else, the next time you Open
it, Qedit will compare the stored value with the file's current timestamp. If
they are different, it means that the original file has changed either since
you last worked on it or since the last time you saved your changes. Qedit will
alert you to the difference by displaying a message similar to the following:
Warning: Original
file has been modified since the
initial Text or last
Keep !
The file timestamp can change for a number of reasons.
Here are few examples:
·
Someone else might have been working on that
same file with Qedit and saved their changes before you did.
·
The file could have been restored.
·
Maybe you used the file to test a program which
modified the file in some way.
Because the timestamp message is just a warning, Qedit
continues its processing. However, if you want to be sure you are not missing
important data, you should compare the contents of the file with your workfile
and decide if it is safe to continue editing your copy.
This is one way to compare the files:
·
Use Verify Keep and write down the default Keep
name
·
Keep the workfile under a different name
·
Use our Compare bonus program to display the
differences between the original file and the new version you just created
·
Look at the report and separate the lines that
you changed from the ones you did not touch
·
If needed, apply changes to your copy so that
you do not miss anything important
It is important to remember that certain Qedit commands
will shut and open workfiles on your behalf. The timestamp warning might appear
when you do not expect it.
By default, timestamp checking on Open is disabled. If you
want to change this setting, you can use the Set Open Checktimestamp command.
The Pause command has two
uses: to suspend Qedit for a specified number of seconds, or to print a prompt
message on the screen and wait for the user to press Return. If the parameter
is numeric, Pause does a timed wait. If the parameter is not numeric, it is
used as the prompt message and a wait for user Return is done instead. The
Pause command is handy in usefiles to provide time for the user to read the
screen before continuing.
:PAUSE [ seconds | message ]
(Defaults: read
without a prompt)
The message is
not in quotes and is separated from the command name by a single space.
Examples
/pause 5 {wait for 5 seconds}
/display To get out of Suprtool, type
Exit
/pause Press Return when ready to try
Suprtool.
/run suprtool.pub.robelle
Converts the object code in a
USL file into a "program file". USL files are produced by compilers.
Program files are what you execute in the :Run command.
:PREP [ uslfile
] [ ,progfile ] [ ; ]
[
STACK words ]
[
MAXDATA words ]
[
DLSIZE words ]
[
RL rlfile ]
[
CAP caplist ]
[
PMAP ]
[
QMAP ]
[
LP ] {map to printer}
[
PATCH words ]
[
ZERODB ]
[
FPMAP ]
[
NOFPMAP ]
[
YES ]
[
NO ]
[
NOSYM ]
[
CHECKSUM]
(Defaults: uslfile = $oldpass,
progfile = $newpass;
see Set MAXDATA for
default;
see Set RL for rlfile)
The parameters to :Prep are the same as in MPE. Keyword
parameters can, of course, occur in any order. In Qedit, all parameters
including file names are optional. Most of the parameters may be shortened to a
single letter.
|
uslfile
|
USL file produced by the compiler (default = $oldpass).
|
|
progfile
|
PROG file produced by the :Prep (default = $newpass).
|
|
STACK
|
specifies starting dynamic stack (seldom
needed).
|
|
MAXDATA
|
specifies largest stack size
(MPE expands).
|
|
CAP
|
specifies capabilities
(example: CAP IA BA PH MR).
|
|
PMAP
|
causes a procedure map to be
printed.
|
|
QMAP
|
causes the PMAP to be
reorganized into a more readable report; procedures are put into alphabetical
order and a segment-size histogram is added. QMAP;LP directs the QMAP to the
line printer (QMAPLIST). The program Qmap.Pub.Robelle must be on the system.
|
|
LP
|
causes the PMAP or QMAP to appear on the printer.
|
|
PATCH
|
reserves a specified number of words at the end of each
code segment for patches.
|
|
ZERODB
|
sets uninitialized global stack locations to zero.
|
|
FPMAP
|
writes a copy of the PMAP into the program file for
debugging.
|
|
NOFPMAP
|
does not write a copy of the PMAP into the program file
for debugging.
|
|
YES
|
purge any existing program without asking permission.
|
|
NO
|
do not purge any existing program file.
|
|
NOSYM
|
does not write the symbol table into the program file.
|
|
CHECKSUM
|
writes checksum information to the program file.
|
Examples
/open src {open source file}
/modify ... {make some changes}
/cobol * {compile it, with code to $newpass}
/prep {prep $oldpass,$newpass}
/run {run $oldpass and see if it still
works!}
/prep ,pf {prep $oldpass into the file pf}
/prep;c mr lp {prep with cap=mr and send pmap to printer}
Notes
If the program file already exists and it has CODE of
"PROG", Qedit asks whether you want to purge it. If you answer NO,
Qedit cancels the :Prep. After the :Prep, Qedit saves the program file, even if
a nonfatal error occurs.
To send the QMAP to a disc file, use these commands:
/purge discfile
/build discfile;rec=-80,16,f,ascii
/file qmaplist=discfile,old;dev=disc
/prep uslfile,progfile;qmap {do not use LP}
/list discfile
Calls an external subroutine
and passes it lines to examine, update, delete, or split. Qedit has two
built-in routines to downshift and upshift lines, DOWN and UP.
PROC [name] [ S|P|G|PP|PG ]
[ rangelist ]
[ DOWN | UP
]
(Q=reset workspace)
(Defaults: previous
proc)
Except when name is one of the built-in routines
(DOWN, UP), name must be a procedure
in an SL file to be dynamically loaded and then called. If you omit name, PRoc calls the most recent
procedure name (at startup this is
DOWN). The procedure is only actually "loaded" the first time you
mention it. Qedit keeps the procedure loaded as long as it can. Since DOWN and
UP are part of Qedit, they need not be loaded from an SL, nor can they be
unloaded. Use Verify Proc to list the current procedures.
Maximum
Set Limits Proc n determines the maximum number of
procedures which Qedit will keep loaded for you at a time. The default is four.
When you exceed the limit, Qedit unloads the one least-recently used. Normally,
Qedit unloads procedures when needed to make room for new routines that you
have asked to load. However, if you are using an Interface routine also, Qedit
does not unload any of your procedures. That is because Qedit allows you to
combine interface routines and Proc routines in the same routine and install
both with a single Loadproc. The Qedit display will show that the Proc is gone,
and you will no longer be able to call it, but it will not be unloaded. You
will not be able to purge it from the SL unless you Exit from Qedit.
Proc passes each line of the rangelist to the procedure and updates the line upon return. If you
omit rangelist, Proc passes a dummy
line with all blanks and line number of " ? " instead; this allows
you to call procedures without having a workfile Open.
For DOWN and UP, the default rangelist is the current line (*); PQ shifts quietly (i.e., without
printing the lines); and PJ shifts with user verification (i.e., PJ prints each
shifted line and asks you to approve it).
The library search options for the Proc command are as
follows:
|
PROC procname S
|
Sl.Pub.Sys only
|
|
PROC procname P
|
logon Sl.Pub then Sl.Pub.Sys
|
|
PROC procname G
|
logon group, then Sl.Pub, then Sl.Pub.Sys
|
|
PROC procname PP
|
Sl.Pub in Qedit program account
|
|
PROC procname PG
|
SL in Qedit program account and group
|
Built-In PROCs to
Shift Up or Down
The Up and Down Procedures put Roman-8 characters into uppercase
or lowercase if Set Editinput Extend is On. Otherwise, they only operate on A-Z
and a-z.
The first time that you use Down or Up after running
Qedit, they ask you to configure them. There are 4 options: 1 means to shift
every alpha character in the lines, 2 means to skip over characters enclosed in
double quotes ("), 3 means to skip over characters enclosed in single
quotes ('), and 4 means to skip over characters enclosed in either double
quotes or single quotes. If Down (or Up) finds a line with unmatched quotes, it
prints a warning and stops (unless the lines are part of a COBOL program, in
which case unmatched quotes are okay).
/open qedit.doc {open document file}
/list 415.1 {display a line}
415.1 You will need to Purge the
old file.
/proc down 415.1 {try it lowercase}
Set Shift DOWN? 1(@) 2(") 3(') 4(" or ') [0]:2
415.1 you will need to purge the
old file.
/proc up 415.1 {try it uppercase}
Set Shift UP? 1(@) 2(") 3(') 4(" or ') [0]:2
415.1 YOU WILL NEED TO PURGE THE
OLD FILE.
/proc down {lowercase is better}
/proc 410/415 {downshift some more lines}
/pq 420/1002 {many more! quietly}
/pj up 1003 {upshift with approval}
1003
>GET D-LINE (Okay?) yes
If you always configure the shifting routines to the same
option (e.g., skip strings with double quotes), you can use Set Shift to define
the configuration:
User-Written PROCs
Besides the two built-in PROCedures UP and DOWN, you can
invoke any number of user-written PROCedures from SL files (four of these can
be loaded at one time).
The QLIB contributed library
contains two PROCedures: FINDJUNK to remove nonprinting characters from lines,
and NEATER to align COBOL fields to specific columns. The easiest way to use
them is to copy SL.QLIB into your logon account and/or group:
/:run fcopy.pub.sys
>from=sl.qlib.robelle;to=sl;new
>exit
/open memos {open document with junk in it}
/proc findjunk,g,first/10 {cleanup start of current file}
/proc 1/50 {cleanup some more
lines}
/p findjunkq,g,51/last {cleanup the rest quietly}
/:qhelp qlib.help.robelle,contr,findj {check manual}
/open cobsrc {open a cobol source file}
/p neater40,g,12.3/14 {adjust some data division}
/:qhelp qlib.help.robelle,contr,neater
/p findjunk 2.1/2.4 {remove some phone junk too!}
For detailed instructions on coding user procedures,
consult the index.
Prints a message on $stdlist.
Q [ "string" ]
(Default: print a
blank line)
The string of up
to 80 characters is printed on $stdlist.
Use the Q command to print prompts from usefiles. This
works especially well when you use a file quietly.
Q can be used to include comments in batch mode. Use
:COMMENT in usefiles for a nonprinting comment line.
Examples
Below is a usefile for compiling and preparing a large SPL
program. The program reports to the user as it progresses. Because these
commands may take a long time to complete, the last line is a Q command to wake
us up by ringing the Bell.
Q "This usefile compiles/preps
Suprtool."
Q "First we Shut your Open
workfile, if any."
shut
:COMMENT Purge any existing USL
file. Will build new one.
:purge suprtool.usl
:COMMENT Use Segment Stdin= commands to
init new USL file.
:run segdvr.pub.sys;stdin=toolseg.job
:COMMENT Save new USL file.
:save suprtool.usl
:COMMENT Drop security; we need access
from many accounts.
:release suprtool.usl
:COMMENT Compile all source modules
into USL file.
Q "USL file initialized for
Suprtool."
:spl commag1.suprtool,suprtool.usl
:spl commhr1.suprtool,suprtool.usl
:spl commsz1.suprtool,suprtool.usl
:spl main1.suprtool, suprtool.usl
:spl open1.suprtool, suprtool.usl
:spl sort1.suprtool, suprtool.usl
:spl util1.suprtool, suprtool.usl
Q "All Suprtool source modules
compiled."
:COMMENT Nested usefile to do the Prep
command.
use prep.suprtool
:COMMENT Finally, use Q command to ring
Bell on user terminal.
Q "Suprtool :prep is Done!
<Control-G> ..."
When you execute a command
file (or a UDC) from within Qedit, you can also include Qedit commands in the
command file by preceding the Qedit commands with a slash (for example,/find "text").
/command line
(Defaults: none)
Qedit allows you to include
Qedit command lines within UDCs and command files. You can check the result of
the /Qedit command by testing CIERROR:
setjcw CIERROR = 0
continue
/open abc.source
/find "def"
if CIERROR=0 then
/delete *
else
if CIERROR=860 then
display Invalid syntax in Qedit command!
else
if CIERROR=900 then
display End of file - string not found!
else
if CIERROR=907 then
display Non-existent file!
endif
endif
endif
endif
As this example shows, the
/Qedit command returns one of three CIERROR values:
860 = Illegal
Keyword
907 = Non-Existent
File
900 = End Of File
(returned by Find and Findup)
Note that these CIERROR values are only set when the
commands are being executed from a User Command, not from $stdin or a usefile.
INSIDEQEDIT JCW
You can test whether your
command file is being executed by Qedit by having it check the INSIDEQEDIT job
control word, so as to only execute /Qedit commands while inside Qedit.
Invokes the QHELP subsystem on
a specified help file. QHELP is a part of QLIB, the Robelle contributed
library. The helpfile must have been
processed by HELPCOMP.QLIB. The keyword parameters
must be separated by commas, since blanks are allowed in a single keyword.
:QHELP helpfile [,keyword,...]
(Defaults: no keyword = start at top)
Examples
/qhelp qlib.help.robelle
/qhelp suprtool.help.robelle,commands,base
Enables you to modify and
repeat any of the previous 1,000 command lines.
REDO [ start
[ / stop ] ]
[
string ]
[
ALL | @ ]
(Default: redo the
previous command)
The :Redo command allows you to modify the commands before
it executes them. If you don't need to change them, use the :Do command.
Commands are numbered sequentially from 1 as entered and the last 1,000 are
retained. Use the :Listredo 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 :Redo command uses MPE-style commands (D, I, R, U and
>) to modify a line. The following are some common commands. A complete list
of commands appears at the end of this section. The default mode is to replace
characters. To delete, type DDDD under the characters to be removed. To insert,
type I under the insertion spot, then the new characters. To undo your changes,
type U. To append to the end of the line, use >xxx. To delete from the end
of the line, use >DD. To replace at the end of the line, use >Rxxx. And
to erase the rest of the line, use D>. See below for a complete list of
edits.
Examples
/listf @.soruce {"source" is not spelled right}
NON-EXISTENT GROUP. (CIERR 908)
/redo {redo most recent command}
listf @.soruce {last command is printed}
our {you enter changes to
it}
listf @.source {edited command is shown}
{you press Return}
/listredo all
/redo 5 {redo 5th command in stack}
/redo {redo previous command}
/redo -2 {redo command before previous}
/redo 8/10 {redo 8th through 10th}
/redo -10/ {redo -10 through last}
/redo purge {redo last Purge command}
/redo purge temp {redo last "purge temp"}
/redo @temp {redo last containing
"temp"}
Notes
The :Redo command can be abbreviated to "," as
in MPEX, but you cannot use ";" to combine commands on the same line.
You can, however, stop a Redo ALL using the Control-Y key. To save more
commands, use a :File command on the file Qedredo before running Qedit:
:file qedredo;disc=5000
:run qedit.pub.robelle
Editing in :Redo
:Redo uses the same edits as the MPE/iX :Redo command,
except that control characters in lines are printed as dots "." so
that you can see them. Use Set Modify Hpmodify to select these MPE-style edits
for all commands. If you prefer the Qedit-style edits, use Set Modify Robelle
to select Qedit editing for all commands, including :Redo. If you prefer
Qzmodify, use Set Modify Qzmodify to select Qzmodify editing for all commands.
Persistent Redo
Redo commands can be saved in a permanent file and can
therefore be used from another session. You can use the Set Redo command to
specify a file name to save your redo commands. Please see the Set Redo command
for details.
Executes
a Reflection command on your PC. Qedit checks whether the command succeeds or
fails. A failure is treated like the failure of an MPE command. :Reflect allows
you to control a PC from within your HP e3000 UDCs or batch job (send and
receive files, backup your PC, execute PC programs, etc.).
:REFLECT reflection command
(Defaults: none)
Examples
/reflect type mreport.crt
/reflect shell lotus
Version of
Reflection
The :Reflect command depends on Reflection's ability to
accept commands using an escape sequence, and to be able to pass back a status
code indicating whether the command succeeded. These features are implemented
in the following versions of Reflection:
·
Reflection 1 for DOS version 1.40 or later
·
Reflection 3/7 for DOS version 1.55 or later
·
All versions of Reflection for Windows
·
All versions of Reflection for Macintosh
Batch PC Control
You can use the :Reflect
command in a batch job, but you must do a :File equation to specify the PC that
you wish to control. The file name is Qedcrt and you must redirect it to a
hard-wired PC port. If you wish to switch to another PC, use Set Vis Stop and
another :File command. Here is an example:
!job pcbackup,user.acct
!file qedcrt;dev=29
!run qedit.pub.robelle
reflect dir
continue
reflect dri {oops}
Your Reflection command failed.
10 = ERROR-CODE from the Reflection PC.
UNKNOWN COMMAND NAME. (CIERR 975)
file backup = backup.wade
continue
reflect backup c:\*.* /S {need Reflection PLUS option}
set vis stop {prepare to access 2nd PC}
file qedcrt;dev=58 {define second PC}
file backup=backup.rockey
continue
reflect backup c:\*.* /S {add /C for full backup}
exit
!eoj
Debugging PC Errors
The examples above show PC functions with and without
error control. If you want the job to continue, even if the :Reflect command
fails, put a :Continue in front of each :Reflect command. The error CIERROR 975
will be returned if the :Reflect command fails for any reason.
Remember, in order to get :Reflect to work in batch:
·
The PC must be turned on.
·
Reflection must be running.
·
The Reflection baud rate must be the same as in
the MPE configuration.
·
The PC must not be logged on to the HP e3000.
·
For the Backup command to work, Reflection must
be a Plus version.
If the :Reflect command fails,
Qedit will display the Reflection error-code. If you have a version of
Reflection that is capable of passing back the error-code, Qedit will also put
the error-code in a JCW named QEDPCERROR. For an explanation of Reflection
error-codes, refer to the Reflection Command Language reference manual.
Using Line Mode
Some Reflection command files
work fine when executed from the Alt-Y command line, but fail (possibly leaving
your terminal in a locked state) when invoked with Qedit's :Reflect command.
The reason is that Qedit's :Reflect command sends an
escape code to Reflection to invoke the command. Then Qedit waits for
Reflection to send back a status code to indicate when the command is finished.
While Qedit is waiting for the result code from Reflection, it isn't capable of
executing other Qedit commands -- it's already executing a Qedit command! The
only thing that Qedit is capable of doing while it's waiting is to execute any
MPE commands that Reflection might send to the HP e3000. The reason MPE
commands must be accepted is that Reflection sends a :Run command for PCLINK
whenever a file transfer is requested.
As long as the command or command file doesn't attempt to transmit any data to the HP e3000,
:Reflect will probably work the same way as Alt-Y.
For example, here is a Reflection command file that works
from Alt-Y, but not from :Reflect.
; BYE
; This command file gets me out of
Qedit, logs me off
; the HP e3000 and exits from
Reflection back to DOS.
;
transmit "exit^M"
wait 0:01:00 for "^Q"
transmit "yes^M"
wait 0:01:00 for "^Q"
transmit "bye^M"
wait 0:01:00 for "CONNECT"
wait 0:00:05
hardexit
Also see the chapter "Qedit Issues and
Solutions" for more information.
Renumbers a range of lines or
the entire workfile.
RENUM [ firstline ] [ maxincr]
[ startline / stopline ] [ maxincr ]
(Default: entire file
from 1.0 by current increment)
If you specify a range of lines (e.g., 101/102), Qedit
spreads out the line numbers in that range to allow as much space as possible
between each line. The numbers of the startline
and stopline are not changed.
If you do not specify a range, Qedit renumbers the entire
file, starting at 1.0 or from the optional startline
value.
If you specify a maxincr
value, Renum will attempt to renumber with that increment. If it must use a
smaller value, it will print a warning. If you do not specify a maxincr value, Renum attempts to use the
current Set Increment value which defaults to 1.0 (except for standard COBOL
which is 0.1).
Examples
/ren {assign new numbers to all lines}
/list 10/11 {show current line numbers}
10 The Renumber command
10.2 has two basic modes:
10.21 1. renumber an entire file
10.211 2. spread out a range of lines
11 to make room for new lines.
/add 10.21 {attempt to add a line}
Out
of line numbers. Suggest Renumber.
/ren 10/11 {spread out line range evenly}
/list 10/11 {check new lines numbers}
10 The Renumber command
10.2 has two basic modes:
10.4 1. renumber an entire file
10.6 2. spread out a range of lines
11 to make room for new lines.
/add 10.4 {now you can add some lines}
10.5 (usually from 1.0 by
1.0).
10.51 //
Notes
If you keep adding new lines
at the same spot in a file, Qedit will assign incremental line numbers such as
3.01, 3.011, but it cannot add a line between 3.011 and 3.012. The smallest
increment between lines is 0.001. When you run out of line numbers, Qedit warns
you. You can Renumber a range of lines or the entire file to get around this
problem.
Replaces lines with new text,
either from Stdinx or from the Hold file.
REPLACE [ $HOLD ] rangelist
(Q=no printing,
T=template, J=justified)
(Default: rangelist = *)
Replace $hold looks for new
lines of text in the Hold file (see the Hold command) and uses each to replace
one of the lines of the rangelist.
Replace without $hold prints each line of rangelist,
then waits for you to type a new line at the keyboard. Pressing Return only erases the line! Replacej indents the new line
the same number of columns as the original line. $Hold can be abbreviated to
$h.
Examples
/rq $hold 50/70 {replace from the Hold file}
/rq $h 50/70 {replace from the Hold file}
/rep 5 {replace line 5 only}
5 LINE 5 {prints existing contents}
5 NEW LINE 5 {prompts you with linenum}
Column Editing with
$Hold
You can use the $hold option
of the Replace command to do extensive column editing:
/lt @
....+....10...+....20...+....30...+....40...
1 *****************
2 * Page One
*
3 *****************
4 *****************
5 * Page Two
*
6 *****************
/holdq 4/6 {hold the second page of text}
/deleteq 4/6 {now delete those lines}
/set left 20 {set your left margin to starting column}
/repq $hold 1/3 {overlay from the Hold
file}
/set left 1 {don't forget to reset left margin}
/lt @
....+....10...+....20...+....30...+....40...
1 ***************** *****************
2 * Page One
* * Page Two
*
3 ***************** *****************
You can copy columns of text from one position in a line
to another by setting margins with the Set Left and Set Right commands, holding
the columns of text that you want to copy, setting new margins, and replacing
the new column range with the text in the Hold file. Here is a command file
that works on MPE V and MPE/iX which does all this for you:
COPYCOL.CMD.SYS
parm fromcol,tocol,length,rangelist
/set right
/set left
setjcw right := !fromcol + !length
setjcw right := right - 1
/set right !right
/set left !fromcol
/holdq !rangelist
setjcw right := !tocol + !length
setjcw right = right - 1
/set left
/set right !right
/set left !tocol
/replaceq $hold !rangelist
/set right
/set left
For example, to copy text from columns 1/5 to column 30 in
all lines, you would enter:
Return
is valid only in a UDC or command file; it exits at once, but returns a
successful status rather than an error. Control returns to whatever invoked the
User Command, which may be Qedit or may be another UDC or command file. Use
:Return within an If or Else clause to get out. It can not be used at the Qedit
prompt or in a Use file.
:RETURN
(Default: none)
Examples
if cierror = 999 then
return
endif
See also the :Escape command.
Executes a program without
leaving Qedit; returns to Qedit when done.
:RUN [ progfile
] [ ,entrypoint ] [ ; ]
[
STACK words ]
[
MAXDATA words ]
[
DLSIZE words ]
[
LIB [G|P|S] ]
[
PARM value ]
[
DE
