This is the documentation for SET's Editor.
Copyright (C) 1996 Salvador Eduardo Tropea
This documentation may be freely distributed with the editor or the RHIDE package or any part thereof, provided this copyright notice is left intact on all copies.
Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.
Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.
People who helped me develop the editor:
This editor is included in the Robert Höhne's RHIDE as a replacement for the original TVision's editor class.
SET's editor is an editor designed to be used by programmers; the main target of the editor is C and C++ code but Pascal and Clipper are supported too.
The editor was designed to be very similar to the DOS standard editors for C, especially to the Borland's IDE editor. The editor supports a lot of WordStar style commands plus some CUA commands, so if you used any editor that uses these kinds of commands you'll find my editor very familiar. On the other hand if you never used a DOS editor, especially if you use VI on UNIX machines you'll feel lost. You can configure the keyboard but this feature is relative limited. See How to configure the keyboard .
For now I only plan to distribute my editor inside of RHIDE requirements are the requirements of RHIDE.
0B██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ 0F██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ 0B██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ The editor was made by Salvador Eduardo Tropea (SET), with the help of Robert Höhne.
E-Mail: Salvador Eduardo Tropea
Telephone: (+541) 759-0013
Postal Address:
Salvador E. Tropea
Curapaligüe 2124
(1678) Caseros - 3 de Febrero
Prov: Buenos Aires
Argentina
0B██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ 0F██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ 0B██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
Read the conventions topic first to understand my way of indicating keystrokes.
In the description of each command I'll include the internal name used by the editor because this name is needed to configure the keyboard.
I'll use some conventions when talking about the keystrokes needed to trigger some command. So here is what I use:
The key named Ctrl or Control is represented as ^; this key doesn't have any effect used alone inside of the editor so the ^ symbol will be used only in conjuntion with the name of some key indicating that you must press the two keys at the same time; for example: ^A is Ctrl and A at the same time. When I say "at the same time" that means: press Ctrl, hold it, and press the other key; that's the reason to put A after Ctrl.
To indicate a sequence of keystrokes I'll use a - to separate the keys; for example ^K-B is Ctrl and K at the same time, and then press B; of course release ^K first.
To indicate keys pressed at the same time other than ^x I'll use the +; for example: Shift+^Insert is the three keys at the same time!.
I don't think that you are stupid; the editor is written for programmers, but I'll wanted to make that clear to avoid problems ;-).
cmbCharLeft
cmbCharRight
cmbWordLeft
cmbWordRight
cmbLineUp
cmbLineDown
cmbScrollUp
cmbScrollDown
cmbPageUp
cmbPageDown
cmbLineStart
cmbLineEnd
cmbFirstLineInScreen
cmbLastLineInScreen
cmbTextStart
cmbTextEnd
cmbDelChar
cmbBackSpace
cmbDelLine
cmbDelEnd
cmbDelStart
cmbDelWord
cmbDelPrevWord
cmbNewLine
cmbInsMode
A block is a selected portion of the text, you can copy, delete, etc blocks of text. The asociated commands are:
cmbGoBeginBlock
cmbGoEndBlock
cmbStartSelect
cmbEndSelect
cmbHideSelect
cmbMarkLine
cmbMarkWord
cmbCut
cmbCopyBlock
cmbMoveBlock
cmbCopy
cmbClear
cmbPaste
cmbReadBlock
cmbWriteBlock
cmbReplaceSelect
cmbToUpper
cmbToLower
cmbSelLength
There are two block modes, one is the mode that the old editor of RHIDE used this mode is used in CUA programs, and the other is called Persistent Blocks.
In the normal mode each time you select a block and then insert any thing on it (with cmbPaste or typing anything) the selected block is deleted and is replaced by the new text.
In persistent blocks the selection is not replaced and is not loosed when you move the cursor, from here comes the name "Persistent", in this mode you can use cmbMoveBlock and
cmbCopyBlock without using the Clipboard, in adition you can apply indentations to the block (See
Indentation ), search only inside it, etc, that's makes this mode much more powerful than the former. If you really like to replace the selected text by the selection of
the Clipboard, that's the default behaviour of the first mode, you can use the cmbReplaceSelect command to achieve the same in the Persistent Blocks mode.
The described commands for select a block, cmbStartSelect and cmbEndSelect, are good but not so quick, there are another ways to make that.
Using the mouse you only need to point the start place, hold the left button pressed and move the mouse to the end point of your block.
To select a word with the mouse just double click on it.
Using the shift key you only need to move the cursor to the start point, hold Shift pressed and move the cursor to the end point with any of the available See Cursor movement commands.
You can indent or unindent a block of text using various commands, but you must keep in mind that by now the editor is limited in the following: If you are using See Real Tabs to indent your text don't mix the tabs with spaces and if you are using spaces to indent don't mix it with real tabs.
cmbIndentBlkOne
cmbUnIndentBlkOne
cmbIndentBlk
cmbUnIndentBlk
cmbSmartIndent
cmbSmartUnIndent
cmbUnIndentBlkOne unindents deleting one char at the start of the line so if the line is indented with tabs the line will retroced one tab.
cmbIndentBlk acts according to the mode, if you are using See
Real Tabs , the editor will put one tab in each line, if you aren't using tabs the editor will operate the Tab command on the first line and then will use this amount of
indentation in the rest of the block.
cmbUnIndentBlk acts according to the mode too, in See
Real Tabs mode is just like cmbUnIndentBlkOne deleting one tab but if you don't use tabs the editor uses Backspace on the first used column of the first line
of the block and unindents the resulting amount all the block.
cmbSmartIndent and cmbSmartUnIndent indents taking as reference the { } pair where the block is, for example:
{
line1
line2
line3
}
After indenting a block that contains line1 to line3 is:
{
line1
line2
line3
}
The indentation is made with spaces. The editor includes a mode where you can select a rectangular portion of the text and copy, cut, clear, paste, move, etc this region. This tool is very useful for modifications on columns.
Attention! the selected area is based on the X,Y coordinates, for this reason if you insert lines before the bottom of the rectangle the area won't be moved. I don't plan to move the area by now because that takes some CPU and I think that this selection is made just before using it. So don't report that like a bug is that the way that works.
cmbSelRectStart
cmbSelRectEnd
cmbSelRectHide
cmbSelRectCut
cmbSelRectMove
cmbSelRectCopy
cmbSelRectDel
cmbSelRectPaste
This feature is very useful to save some keystrokes, with this feature you can create a lot of shortcuts to make your life easiest.
So now, What's a Pseudo Macro?, It's like a macro but is triggered but two things: one the text behine the cursor and two the ^Space convination.
And What's the result?, the result is customizable, but by default there are some predefined behaviours for example, type in a new window the following two letter: #i and the press ^Space ...
Surprised?, I bet, you got: #include <.h> and the cursor just in the right place to write the name of the header.
Now write the famous stdio word, press End, then Enter twice and now write the following two letters: ma and then ^Space ...
I bet this time you predicted better what will happend so you aren't so surprised ;-), anyways Surprise!, now type pr and the magic keys and .... printf(""); appears, to end the happy history now type Hello world!, that's all; you wrote the hello world program at a very good speed.
Now you know what I mean when I say pseudo-macros.
Is very easy there is a file called pmacros.txt in the same directory where you started the editor, this file contains the definitions for each pseudo macro, you can define up to 32
pseudo macros (Please tell me if that isn't enough I can sacrify some time to make it dinamically expandable).
Important: If you are using RHIDE consult the RHIDE documentation to know where is stored the pmacros.txt file.
The pmacros.txt file is a very good example and is self-explained but I'll include here one example.
Trigger: "i("
Mode: 0,1,0,1,0
"if (@0)\n"
" {@1\n"
"}\n"
"\belse\n"
" {@2\n"
"}"
The Trigger keyword defines the two letter behine the cursor that will trigger the pseudo macro. The Mode keyword indicates the mode that the editor will use when inserting the text. The modes are:
The rest is the code to insert surrounded by ". You can use \b to indicate backspace, \n for newline and \\ to indicate a simple \. If you want to insert a @ you have to type it twice @@, because this character has a special meaning (see below).
After the insertion the cursor is positioned in the place marked with @0, don't forget to signal this point or the cursor will positioned at the beggining of the file, the places marked with @1, @2 and @3 are saved in the markers 7, 8 and 9.
cmbIndentMode
cmbGotoMarkn
cmbPutMarkn
cmbSearchOpPar
cmbSearchClPar
cmbSearchOpCor
cmbSearchClCor
cmbUndo
cmbExpandCode
cmbGotoEditorLine
cmbSetLocalOptions
cmbSetGlobalOptions
cmbExpandAllTabs
cmbCompactBuffer
cmbRecordMacro
cmbStopMacro
cmbPlayMacro
There are three associated files with the keyboard: keybind.cc, keybind.h and keybind.txt.
The keybind.h file contains the scancode number for each key and the number for each command, this file is included in keybind.cc. If your keyboard have a different
assigment you can modify the scancodes in this file, for example: The german keyboards have the following sequence QWERTZ instead of the more common QWERTY, so each time you press ^Z you won't get the
function of ^Z, but ^Y instead. Somebody can live with it, but is fixable. To fix this problem you must correct the scancode of the Z key in keybind.h, of course that this affects to ^Y too. That's
only an example, the most common problem is with the symbols like {, }, [, etc. If you don't know how to find the scancode of a key take this link See
A program to find the scancodes .
The keybind.cc file is a C++ file but you don't need to compile it and link with the editor, you only need to preprocess it (I used this methode to save the time needed to make a parser
;-).
To convert this file into a keybind.txt file use:
cpp keybind.cpp > keybind.txt
Where cpp is the C++ preprocessor. You can use any of the comment systems available in C++ inside the file. I guess that you have cpp, but if not you can use another C++ preprocessor or even Clipper using the /P switch.
There are 7 sections in the file, each section is the keyboard translation under certain situation. The sections are:
cmbCtrlQ.
cmbCtrlK.
cmbCtrlK.
cmbNoCommand to this key, for example is you wish
eliminate the BACKSPACE key and use the ^O instead you must:
a) put BACKSPACE = cmbNoCommand in the NORMAL section.
b) put O = cmbBackSpace in the CONTROL section,
If you only put the b) you'll not eliminate the BACKSPACE key.
II)
If some thing is wrong in the KEYBIND.TXT file the program will inform the error, the line number is for the KEYBIND.TXT and not for KEYBIND.CPP (sorry some day
I'll fix this).
To continue the execution press any key and then enter.
III) You can repeat an assignment, the last win:
BACKSPACE = cmbNoCommand
BACKSPACE = cmbBackSpace
The first is ignored The author of the following program is Robert Höhne:
#include#include #ifdef __GNUC__ #include #define REGS __dpmi_regs #define INTR(nr,r) __dpmi_int(nr,&r) #else #define REGS union REGS #define INTR(nr,r) int86(nr,&r,&r) #endif unsigned short getshiftstate(void) { REGS r; r.h.ah = 0x12; INTR(0x16,r); return r.x.ax; } unsigned short gkey(void) { REGS r; r.h.ah = 0x10; INTR(0x16,r); if (r.h.al == 0xE0 || r.h.al == 0) r.h.al = 0; return r.x.ax; } main() { unsigned short key; do { key = gkey(); fprintf(stdout,"%04X, scan code: %d\n",key,key>>8); } while (1); }
The settings are:
This setting controls if the typed characters are inserted in the buffer or if the typed characters replaces the original ones, see See Insert and Delete for a detailed explanation.
This setting controls what happend when you press ENTER, if this setting is off the cursor goes to the column 1 of a new inserted line. If the mode is on the editor will try to keep the indentation of the code inserting spaces.
This setting controls what happend when you press TAB, if this setting is on the editor will insert an ASCII 9 in this place.
An ASCII 9 is a TAB, that means that the width of this char is enough to move the cursor to the next tabulator column. In the editor the tabulator columns are equidistant and the positions are controled by the Tab Size value.
If this setting is off the editor won't put any ASCII 9 in your text, instead the editor will insert enough spaces to move the cursor to the next tabulator, but if the cursor is positioned on the first character of the line the editor will insert spaces to move this position to the next hole in the line over the line where you are. Confused?, sorry for my english, an example will clarify that:
This is a line over the line where you are
That's the line where the cursor is, at column one.
After pressing TAB you'll get:
This is a line over the line where you are
That's the line where the cursor is, at column one.
Now can ask, why this? Is that useful?, the answer is that's very useful to keep your code indented, experiment using that under a line with if, for, etc.
Another thing controlled by this setting is the behaviour of the Backspace key, when the setting is on the key is just 'delete the character at the left of the cursor' but when the setting is off this key is the 'Unindent' key.
The editor is much more coherent when you choose to use TABs or not use tabs, if you mess the two things you'll get some unexpected things, specially in the indentation of the blocks.
Is better is you ever works in a file without tabs and with this setting of, then you'll get much from the editor.
Now you can say: But I really need tabs because I'm editing a make file! or because I'll send the file using an ultra slow link and I want the compression granted by the tabs. In these cases you can first expand all tabs, then work without real tabs and at the final of your work compact all possible spaces and generate a file with all the tabs that you need see the See Miscellaneous section.
This setting controls the behaviour of the selected area.
See the chapter See Block modes for a detailed explanation.
This mode was designed to be used in joint with the Pseudo Macros (See Pseudo Macros ) and the Real Tabs mode in off to achieve an easy way to indent the code making a better work than the Autoindent mode.
In this mode the spaces inserted after pressing ENTER depends on the first word in the last line, for example, if you have:
if (a==b)_
With the cursor in the '_' position and press ENTER you'll get:
if (a==b)
_
Now you can do two things, 1) press space and write the code that will be executed by the if, or 2) if this a multiline code press { and ENTER, in the last case you'll get:
if (a==b)
{
_
Now type your first line of code, press ENTER, write your next line, press ENTER again and then Backspace:
if (a==b)
{
1st line;
2nd line;
_
Now type } and press ENTER one more time:
if (a==b)
{
1st line;
2nd line;
}
_
As you can see the code is perfectly aligned without a significant work from your part. I tried to make this mode as smart as possible, but needs more work, if you have suggestions contact me.
Another important thing is that this indentation have a personal style, mine style ;-), so may be you don't like it. If that's your case you can do the following things:
I'll try to describe the behaviour of the mode:
Each time you press ENTER the editor inserts a '\r\n' string in your text, after that the editor searchs one line located above the new line that have at least one character inside. This line is taked as reference, the editor analizes this line searching for:
If the line contains } at the start the editor will go to the same column of the } and then will perform a Backspace, is the See Real Tabs mode is off that's an unindent.
If the line starts with a C++ comment the effect is the same as in See Autoindent .
If the line starts with a C comment the editor will try to skip the comment and analize the rest of the line, but if the comment doesn't end on this line the editor will go to the column where the / is.
If the line starts with / the editor goes to this column.
If the line have more ( than ) the editor will go to the column of the first non-blank after the first (.
If the line have more ) than ( the editor will search the line where the number of parenthesis is balanced, then will analize this line, if the whole line still generating an unbalanced situation the editor will go to the first used column in the line that was found at first time. But if this line lets all balanced the editor will take the first word on the line and will use it as reference.
At last, and according to the word founded, the editor will use this word as reference. The editor recognises the following keywords:
Seasick? take a look at: See Do you have more examples? .
Note: Some of these features was added in v0.2.14 of the editor based on a suggestion of
Well here are some examples, I used some strange convention, is like this: if I say 'type a[ENTER]{' is type the a letter, then press ENTER and finally press the { key.
Example 1: (Is similar to the explained before but is to show the convention)
Type:
if (a==1)[ENTER]{[ENTER]a=2;[ENTER]b=3;[ENTER][BACKSPACE]}[ENTER]
You'll get:
if (a==1)
{
a=2;
b=3;
}
[<--- cursor here]
Example 2: A switch/case example
Type:
switch(a)[ENTER]{[ENTER]case 1:[ENTER]a=2;[ENTER]b=3;[ENTER]break;
[ENTER]case 2:[ENTER]b=5;[ENTER]break;[ENTER][BACKSPACE]}[ENTER]
You'll get:
switch(a)
{
case 1:
a=2;
b=3;
break;
case 2:
b=5;
break;
}
[<--- cursor here]
Example 3: A call to a function that takes a lot of parameters
Type:
printf([SPACE]"Num: %d",[ENTER]a[SPACE]);[ENTER]
You'll get:
printf( "Num: %d",
a );
[<--- cursor here]
Example 4: A lot of parethesis
Type:
if[SPACE]([SPACE](a==1)[SPACE]||[ENTER](b==2)[SPACE]||[ENTER]
c[SPACE])[ENTER]
You'll get:
if ( (a==1) ||
(b==2) ||
c )
[<--- cursor here]
Example 5: Comment trying to interfer part 1
Type:
/*-a-*/for[SPACE](x=1;x;--x)[ENTER]
You'll get:
/*-a-*/for (x=1;x;--x)
[<--- cursor here]
Example 6: Comment trying to interfer part 2
Type:
for[SPACE](x=1;x;--x);[SPACE]//-b[ENTER]
You'll get:
for (x=1;x;--x); //-b
[<--- cursor here]
Note: Of course you can full the editor but as you can see is relative smart ;-). This setting enables an strange feature of the editor, when this mode is on the column where the cursor is is highlithed. This feature is very good to check if some part of your code is aligned.
If you like this mode but is very uncomfortable to be used all the time contact me and if I get enough feedback I'll put this thing in a key to be turned on/off quickly.
This setting is similar to the See Column cursor but acts on the row where the cursor is. If you enable the two modes you'll get a cross on the screen showing where the cursor is.
This mode acts showing the pairs of (/), [/] and {/} on the fly. Each time you type one of these symbols the editor will search the matching pair, if the editor finds it and the match is on the screen both will be highlithed, if the match is outside the screen the editor will inform the position on the status line, and if there is no match the editor will inform the situation in the status line too.
That's very usefull when you are typing complex parenthesis expressions or a very nested code. You can use it in joint with the cmbSearchStart, cmbSearchEnd,
cmbSearchOpPar, cmbSearchClPar, cmbSearchOpCor and cmbSearchClCor commands (See
Miscellaneous ).
The editor can make highlight the syntax of your code, the available modes are:
The C/C++ highlight was designed for the GNU C compiler.
The Pascal highlight was designed for the GNU Pascal compiler.
The Clipper highlight was designed for the CA-Clipper 5 compiler.
If you find a bug please contact me, the Undo thing is the most complex one and I know that needs some work on it.
When reporting a bug please don't say me: Some times some strange thing happend ..., try to find a pattern of the problem, what situation triggers the problem, with wich file. Then send me the file and the description.
When sending to me a file UUEncode it to avoid problems related with the e-mail.