CommandElecFermiFillings() : Command("elec-fermi-fillings")
{
format = "<mixInterval> <kT> [<alpha>=0.5]";
comments =
"Fermi-Dirac fillings at a temperature <kT> (in Hartrees).\n"
" If <mixInterval> is zero, use the auxilliary hamiltonian method (recommended).\n"
" Else, mix fermi functions every <mixInterval> iterations with mixing fraction <alpha>.";
require("lcao-params");
forbid("fix-electron-density");
forbid("fix-electron-potential");
}
CommandElecInitialHaux() : Command("elec-initial-Haux")
{
format = "<filename>";
comments = "Read the auxilliary hamiltonian for direct fillings (default: set to subspace hamiltonian)\n";
forbid("initial-state");
}
CommandFluidInitialState() : Command("fluid-initial-state")
{
format = "<filename>";
comments = "Read initial state of a fluid (compatible with *.fluidState from dump End State)";
forbid("initial-state");
}
static void
set_color_select(struct video *v, u_char byte)
{
if(byte != v->data.cga.color_select)
{
v->vga.regs[VGA_ATTR_REGS+0x11] = byte & 15;
if(byte & 0x20)
{
/* Cyan, Magenta & White. */
v->vga.regs[VGA_ATTR_REGS+0] = 0x00;
v->vga.regs[VGA_ATTR_REGS+1] = 0x03;
v->vga.regs[VGA_ATTR_REGS+2] = 0x05;
v->vga.regs[VGA_ATTR_REGS+3] = 0x07;
}
else
{
/* Green, Red & Yellow. */
v->vga.regs[VGA_ATTR_REGS+0] = 0x00;
v->vga.regs[VGA_ATTR_REGS+1] = 0x02;
v->vga.regs[VGA_ATTR_REGS+2] = 0x04;
v->vga.regs[VGA_ATTR_REGS+3] = 0x0e;
}
/* Need to do background intensity bit as well. */
v->data.cga.color_select = byte;
if(v->in_view)
{
forbid();
video_module.vga_load_regs(&v->vga);
permit();
}
}
}
/* Suspend the current task immediately, note that this *may not* be
called from an interrupt handler. */
void
suspend_current_task(void)
{
forbid();
suspend_task(current_task);
schedule();
permit();
}
CommandElecInitialCharge() : Command("elec-initial-charge")
{
format = "<QNet> | <QupNet> <QdnNet>";
comments =
"Initialize a system with <QNet> excess unpolarized electrons\n"
"or with <QupNet> and <QdnNet> excess electrons in each spin channel.\n"
"Both versions are valid irrespective of whether system is spin-polarized.";
forbid("target-mu");
}
CommandElecInitialFillings() : Command("elec-initial-fillings")
{
format = "read <filename> [<nBandsOld>]";
comments =
"Initial electronic fillings are read from <filename> instead of computed automatically (default).\n"
"+ <nBandsOld> specifies the number of bands in the file being read, if different from current nBands.\n"
" Extra new bands are filled with 0s, fillings of extra old bands are accumulated into other bands.\n"
" Default: 0 => fillings file has same number of bands as this run.";
forbid("initial-state");
}
CommandPhonon() : Command("phonon", "phonon")
{
format = "<key1> <args1...> <key2> <args2...> ...";
comments =
"Control phonon calculation and output. The possible <key>'s and their\n"
"corresponding arguments are:\n"
"\n+ supercell <N0> <N1> <N2>\n\n"
" Supercell for frozen phonon perturbation. Each entry must divide\n"
" the corresponding value in kpoint-folding. The k-point mesh must\n"
" be uniform and centered on Gamma.\n"
"\n+ dr <dr>\n\n"
" Amplitude (in bohrs) of frozen phonon perturbation (default 0.01).\n"
"\n+ T <T>\n\n"
" Temperature (in Kelvins) used for vibrational free energy estimation (default 298).\n"
"\n+ Fcut <Fcut>\n\n"
" Fillings threshold to include in supercell calculation (default 1e-8).\n"
" The unit cell calculation may have extra bands for which matrix elements\n"
" are desired; this flag ensures that those extra bands do not affect the\n"
" performance or memory requirements of the supercell calculations.";
forbid("fix-electron-density");
forbid("fix-electron-potential");
}
static inline void
map_cga_buffer(struct video *v, bool phys_buf)
{
int i;
DB(("map_cga_buffer: v=%p phys_buf=%#d\n", v, phys_buf));
forbid();
for(i = 0; i < 4; i++)
{
kernel->set_pte(v->task->page_dir, CGA_VIDEO_MEM + (i * PAGE_SIZE),
(phys_buf ? (CGA_VIDEO_MEM + (i * PAGE_SIZE))
: TO_PHYSICAL(v->data.cga.video_buffer[i])) | PTE_USER
| PTE_READ_WRITE | PTE_PRESENT);
}
permit();
}
CommandTargetMu() : Command("target-mu")
{
format = "<mu> [<Cinitial>=1.0] [<dnMix>=0.7]";
comments =
"Fixed chemical potential <mu> (instead of fixed charge)\n"
"When using elec-fermi-fillings with non-zero mixInterval (deprecated),\n"
"the following parameters control the convergence:\n"
"+ Cinitial: Initial capacitance, affects only first few mixing steps\n"
"+ dnMix: Scale the ideal step in n by this factor";
hasDefault = false;
require("fluid-cation");
require("fluid-anion");
require("elec-fermi-fillings");
forbid("elec-initial-charge");
}
void check_config_hpp(file const& f)
{
static std::string const loose ("# *include *[<\"]config.hpp[>\"]");
static std::string const strict ("\\n(#include \"config.hpp\")\\n");
static std::string const indent ("\\n(# include \"config.hpp\")\\n");
if
( f.is_of_phylum(e_log)
|| f.phyloanalyze("^test_coding_rules_test.sh$")
|| f.phyloanalyze("^GNUmakefile$")
|| f.phyloanalyze("^pchfile(_.*)?\\.hpp$")
)
{
return;
}
else if(f.is_of_phylum(e_header) && f.phyloanalyze("^pchlist(_.*)?\\.hpp$"))
{
require(f, loose , "must include 'config.hpp'.");
require(f, indent, "lacks line '# include \"config.hpp\"'.");
boost::smatch match;
static boost::regex const first_include("(# *include[^\\n]*)");
boost::regex_search(f.data(), match, first_include);
if("# include \"config.hpp\"" != match[1])
{
complain(f, "must include 'config.hpp' first.");
}
}
else if(f.is_of_phylum(e_header) && !f.phyloanalyze("^config(_.*)?\\.hpp$"))
{
require(f, loose , "must include 'config.hpp'.");
require(f, strict, "lacks line '#include \"config.hpp\"'.");
boost::smatch match;
static boost::regex const first_include("(# *include[^\\n]*)");
boost::regex_search(f.data(), match, first_include);
if("#include \"config.hpp\"" != match[1])
{
complain(f, "must include 'config.hpp' first.");
}
}
else
{
forbid(f, loose, "must not include 'config.hpp'.");
}
}
/* Allocate memory from the heap. */
void *
malloc(size_t size)
{
void *result;
int log, block, blocks, i, lastblocks, start;
struct list *next;
forbid();
if ((!initialized && !initialize())
|| (size == 0))
{
permit();
return NULL;
}
if (size < sizeof (struct list))
size = sizeof (struct list);
/* Determine the allocation policy based on the request size. */
if (size <= BLOCKSIZE / 2) {
/* Small allocation to receive a fragment of a block. Determine
the logarithm to base two of the fragment size. */
--size;
for (log = 1; (size >>= 1) != 0; ++log)
;
/* Look in the fragment lists for a free fragment of the
desired size. */
if ((next = _fraghead[log].next) != 0) {
/* There are free fragments of this size. Pop a fragment
out of the fragment list and return it. Update the block's
nfree and first counters. */
result = next;
next->prev->next = next->next;
if (next->next)
next->next->prev = next->prev;
block = BLOCK(result);
if (--_heapinfo[block].busy.info.frag.nfree)
_heapinfo[block].busy.info.frag.first
= (unsigned int) ((char *) next->next - (char *) NULL)
% BLOCKSIZE >> log;
} else {
vmain()
{
register int c, cnt, i;
char esave[TUBECOLS];
char *oglobp;
char d;
line *addr;
int ind, nlput;
int shouldpo = 0;
int onumber, olist, (*OPline)(), (*OPutchar)();
vch_mac = VC_NOTINMAC;
/*
* If we started as a vi command (on the command line)
* then go process initial commands (recover, next or tag).
*/
if (initev) {
oglobp = globp;
globp = initev;
hadcnt = cnt = 0;
i = tchng;
addr = dot;
goto doinit;
}
/*
* NB:
*
* The current line is always in the line buffer linebuf,
* and the cursor at the position cursor. You should do
* a vsave() before moving off the line to make sure the disk
* copy is updated if it has changed, and a getDOT() to get
* the line back if you mung linebuf. The motion
* routines in ex_vwind.c handle most of this.
*/
for (;;) {
/*
* Decode a visual command.
* First sync the temp file if there has been a reasonable
* amount of change. Clear state for decoding of next
* command.
*/
TSYNC();
vglobp = 0;
vreg = 0;
hold = 0;
seenprompt = 1;
wcursor = 0;
Xhadcnt = hadcnt = 0;
Xcnt = cnt = 1;
splitw = 0;
if (i = holdupd) {
if (state == VISUAL)
ignore(peekkey());
holdupd = 0;
/*
if (LINE(0) < ZERO) {
vclear();
vcnt = 0;
i = 3;
}
*/
if (state != VISUAL) {
vcnt = 0;
vsave();
vrepaint(cursor);
} else if (i == 3)
vredraw(WTOP);
else
vsync(WTOP);
vfixcurs();
}
/*
* Gobble up counts and named buffer specifications.
*/
for (;;) {
looptop:
#ifdef MDEBUG
if (trace)
fprintf(trace, "pc=%c",peekkey());
#endif
if (isdigit(peekkey()) && peekkey() != '0') {
hadcnt = 1;
cnt = vgetcnt();
forbid (cnt <= 0);
}
if (peekkey() != '"')
break;
ignore(getkey()), c = getkey();
/*
* Buffer names be letters or digits.
* But not '0' as that is the source of
* an 'empty' named buffer spec in the routine
* kshift (see ex_temp.c).
*/
forbid (c == '0' || !isalpha(c) && !isdigit(c));
vreg = c;
}
reread:
/*
* Come to reread from below after some macro expansions.
* The call to map allows use of function key pads
* by performing a terminal dependent mapping of inputs.
*/
#ifdef MDEBUG
if (trace)
fprintf(trace,"pcb=%c,",peekkey());
#endif
op = getkey();
maphopcnt = 0;
do {
/*
* Keep mapping the char as long as it changes.
* This allows for double mappings, e.g., q to #,
* #1 to something else.
*/
c = op;
op = map(c,arrows);
#ifdef MDEBUG
if (trace)
fprintf(trace,"pca=%c,",c);
#endif
/*
* Maybe the mapped to char is a count. If so, we have
* to go back to the "for" to interpret it. Likewise
* for a buffer name.
*/
if ((isdigit(c) && c!='0') || c == '"') {
ungetkey(c);
goto looptop;
}
if (!value(REMAP)) {
c = op;
break;
}
if (++maphopcnt > 256)
error("Infinite macro loop");
} while (c != op);
/*
* Begin to build an image of this command for possible
* later repeat in the buffer workcmd. It will be copied
* to lastcmd by the routine setLAST
* if/when completely specified.
*/
lastcp = workcmd;
if (!vglobp)
*lastcp++ = c;
/*
* First level command decode.
*/
switch (c) {
/*
* ^L Clear screen e.g. after transmission error.
*/
/*
* ^R Retype screen, getting rid of @ lines.
* If in open, equivalent to ^L.
* On terminals where the right arrow key sends
* ^L we make ^R act like ^L, since there is no
* way to get ^L. These terminals (adm31, tvi)
* are intelligent so ^R is useless. Soroc
* will probably foul this up, but nobody has
* one of them.
*/
case CTRL(l):
case CTRL(r):
if (c == CTRL(l) || (KR && *KR==CTRL(l))) {
vclear();
vdirty(0, vcnt);
}
if (state != VISUAL) {
/*
* Get a clean line, throw away the
* memory of what is displayed now,
* and move back onto the current line.
*/
vclean();
vcnt = 0;
vmoveto(dot, cursor, 0);
continue;
}
vredraw(WTOP);
/*
* Weird glitch -- when we enter visual
* in a very small window we may end up with
* no lines on the screen because the line
* at the top is too long. This forces the screen
* to be expanded to make room for it (after
* we have printed @'s ick showing we goofed).
*/
if (vcnt == 0)
vrepaint(cursor);
vfixcurs();
continue;
/*
* $ Escape just cancels the current command
* with a little feedback.
*/
case ESCAPE:
beep();
continue;
/*
* @ Macros. Bring in the macro and put it
* in vmacbuf, point vglobp there and punt.
*/
case '@':
c = getesc();
if (c == 0)
continue;
if (c == '@')
c = lastmac;
if (isupper(c))
c = tolower(c);
forbid(!islower(c));
lastmac = c;
vsave();
CATCH
char tmpbuf[BUFSIZ];
regbuf(c,tmpbuf,sizeof(vmacbuf));
macpush(tmpbuf, 1);
ONERR
lastmac = 0;
splitw = 0;
getDOT();
vrepaint(cursor);
continue;
ENDCATCH
vmacp = vmacbuf;
goto reread;
/*
* . Repeat the last (modifying) open/visual command.
*/
case '.':
/*
* Check that there was a last command, and
* take its count and named buffer unless they
* were given anew. Special case if last command
* referenced a numeric named buffer -- increment
* the number and go to a named buffer again.
* This allows a sequence like "1pu.u.u...
* to successively look for stuff in the kill chain
* much as one does in EMACS with C-Y and M-Y.
*/
forbid (lastcmd[0] == 0);
if (hadcnt)
lastcnt = cnt;
if (vreg)
lastreg = vreg;
else if (isdigit(lastreg) && lastreg < '9')
lastreg++;
vreg = lastreg;
cnt = lastcnt;
hadcnt = lasthad;
vglobp = lastcmd;
goto reread;
/*
* ^U Scroll up. A count sticks around for
* future scrolls as the scroll amount.
* Attempt to hold the indentation from the
* top of the screen (in logical lines).
*
* BUG: A ^U near the bottom of the screen
* on a dumb terminal (which can't roll back)
* causes the screen to be cleared and then
* redrawn almost as it was. In this case
* one should simply move the cursor.
*/
case CTRL(u):
if (hadcnt)
vSCROLL = cnt;
cnt = vSCROLL;
if (state == VISUAL)
ind = vcline, cnt += ind;
else
ind = 0;
vmoving = 0;
vup(cnt, ind, 1);
vnline(NOSTR);
continue;
/*
* ^D Scroll down. Like scroll up.
*/
case CTRL(d):
#ifdef TRACE
if (trace)
fprintf(trace, "before vdown in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
#endif
if (hadcnt)
vSCROLL = cnt;
cnt = vSCROLL;
if (state == VISUAL)
ind = vcnt - vcline - 1, cnt += ind;
else
ind = 0;
vmoving = 0;
vdown(cnt, ind, 1);
#ifdef TRACE
if (trace)
fprintf(trace, "before vnline in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
#endif
vnline(NOSTR);
#ifdef TRACE
if (trace)
fprintf(trace, "after vnline in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
#endif
continue;
/*
* ^E Glitch the screen down (one) line.
* Cursor left on same line in file.
*/
case CTRL(e):
if (state != VISUAL)
continue;
if (!hadcnt)
cnt = 1;
/* Bottom line of file already on screen */
forbid(lineDOL()-lineDOT() <= vcnt-1-vcline);
ind = vcnt - vcline - 1 + cnt;
vdown(ind, ind, 1);
vnline(cursor);
continue;
/*
* ^Y Like ^E but up
*/
case CTRL(y):
if (state != VISUAL)
continue;
if (!hadcnt)
cnt = 1;
forbid(lineDOT()-1<=vcline); /* line 1 already there */
ind = vcline + cnt;
vup(ind, ind, 1);
vnline(cursor);
continue;
/*
* m Mark position in mark register given
* by following letter. Return is
* accomplished via ' or `; former
* to beginning of line where mark
* was set, latter to column where marked.
*/
case 'm':
/*
* Getesc is generally used when a character
* is read as a latter part of a command
* to allow one to hit rubout/escape to cancel
* what you have typed so far. These characters
* are mapped to 0 by the subroutine.
*/
c = getesc();
if (c == 0)
continue;
/*
* Markreg checks that argument is a letter
* and also maps ' and ` to the end of the range
* to allow '' or `` to reference the previous
* context mark.
*/
c = markreg(c);
forbid (c == 0);
vsave();
names[c - 'a'] = (*dot &~ 01);
ncols[c - 'a'] = cursor;
anymarks = 1;
continue;
/*
* ^F Window forwards, with 2 lines of continuity.
* Count repeats.
*/
case CTRL(f):
vsave();
if (vcnt > 2) {
addr = dot + (vcnt - vcline) - 2 + (cnt-1)*basWLINES;
forbid(addr > dol);
dot = addr;
vcnt = vcline = 0;
}
vzop(0, 0, '+');
continue;
/*
* ^B Window backwards, with 2 lines of continuity.
* Inverse of ^F.
*/
case CTRL(b):
vsave();
if (one + vcline != dot && vcnt > 2) {
addr = dot - vcline - 2 + (cnt-1)*basWLINES;
forbid (addr <= zero);
dot = addr;
vcnt = vcline = 0;
}
vzop(0, 0, '^');
continue;
/*
* z Screen adjustment, taking a following character:
* z<CR> current line to top
* z<NL> like z<CR>
* z- current line to bottom
* also z+, z^ like ^F and ^B.
* A preceding count is line to use rather
* than current line. A count between z and
* specifier character changes the screen size
* for the redraw.
*
*/
case 'z':
if (state == VISUAL) {
i = vgetcnt();
if (i > 0)
vsetsiz(i);
c = getesc();
if (c == 0)
continue;
}
vsave();
vzop(hadcnt, cnt, c);
continue;
/*
* Y Yank lines, abbreviation for y_ or yy.
* Yanked lines can be put later if no
* changes intervene, or can be put in named
* buffers and put anytime in this session.
*/
case 'Y':
ungetkey('_');
c = 'y';
break;
/*
* J Join lines, 2 by default. Count is number
* of lines to join (no join operator sorry.)
*/
case 'J':
forbid (dot == dol);
if (cnt == 1)
cnt = 2;
if (cnt > (i = dol - dot + 1))
cnt = i;
vsave();
vmacchng(1);
setLAST();
cursor = strend(linebuf);
vremote(cnt, join, 0);
notenam = "join";
vmoving = 0;
killU();
vreplace(vcline, cnt, 1);
if (!*cursor && cursor > linebuf)
cursor--;
if (notecnt == 2)
notecnt = 0;
vrepaint(cursor);
continue;
/*
* S Substitute text for whole lines, abbrev for c_.
* Count is number of lines to change.
*/
case 'S':
ungetkey('_');
c = 'c';
break;
/*
* O Create a new line above current and accept new
* input text, to an escape, there.
* A count specifies, for dumb terminals when
* slowopen is not set, the number of physical
* line space to open on the screen.
*
* o Like O, but opens lines below.
*/
case 'O':
case 'o':
vmacchng(1);
voOpen(c, cnt);
continue;
/*
* C Change text to end of line, short for c$.
*/
case 'C':
if (*cursor) {
ungetkey('$'), c = 'c';
break;
}
goto appnd;
/*
* ~ Switch case of letter under cursor
*/
case '~':
{
char mbuf[4];
setLAST();
mbuf[0] = 'r';
mbuf[1] = *cursor;
mbuf[2] = cursor[1]==0 ? 0 : ' ';
mbuf[3] = 0;
if (isalpha(mbuf[1]))
mbuf[1] ^= ' '; /* toggle the case */
macpush(mbuf, 1);
}
continue;
/*
* A Append at end of line, short for $a.
*/
case 'A':
operate('$', 1);
appnd:
c = 'a';
/* fall into ... */
/*
* a Appends text after cursor. Text can continue
* through arbitrary number of lines.
*/
case 'a':
if (*cursor) {
if (state == HARDOPEN)
putchar(*cursor);
cursor++;
}
goto insrt;
/*
* I Insert at beginning of whitespace of line,
* short for ^i.
*/
case 'I':
operate('^', 1);
c = 'i';
/* fall into ... */
/*
* R Replace characters, one for one, by input
* (logically), like repeated r commands.
*
* BUG: This is like the typeover mode of many other
* editors, and is only rarely useful. Its
* implementation is a hack in a low level
* routine and it doesn't work very well, e.g.
* you can't move around within a R, etc.
*/
case 'R':
/* fall into... */
/*
* i Insert text to an escape in the buffer.
* Text is arbitrary. This command reminds of
* the i command in bare teco.
*/
case 'i':
insrt:
/*
* Common code for all the insertion commands.
* Save for redo, position cursor, prepare for append
* at command and in visual undo. Note that nothing
* is doomed, unless R when all is, and save the
* current line in a the undo temporary buffer.
*/
vmacchng(1);
setLAST();
vcursat(cursor);
prepapp();
vnoapp();
doomed = c == 'R' ? 10000 : 0;
if(FIXUNDO)
vundkind = VCHNG;
vmoving = 0;
CP(vutmp, linebuf);
/*
* If this is a repeated command, then suppress
* fake insert mode on dumb terminals which looks
* ridiculous and wastes lots of time even at 9600B.
*/
if (vglobp)
hold = HOLDQIK;
vappend(c, cnt, 0);
continue;
/*
* ^? An attention, normally a ^?, just beeps.
* If you are a vi command within ex, then
* two ATTN's will drop you back to command mode.
*/
case ATTN:
beep();
if (initev || peekkey() != ATTN)
continue;
/* fall into... */
/*
* ^\ A quit always gets command mode.
*/
case QUIT:
/*
* Have to be careful if we were called
* g/xxx/vi
* since a return will just start up again.
* So we simulate an interrupt.
*/
if (inglobal)
onintr();
/* fall into... */
#ifdef notdef
/*
* q Quit back to command mode, unless called as
* vi on command line in which case dont do it
*/
case 'q': /* quit */
if (initev) {
vsave();
CATCH
error("Q gets ex command mode, :q leaves vi");
ENDCATCH
splitw = 0;
getDOT();
vrepaint(cursor);
continue;
}
#endif
/* fall into... */
/*
* Q Is like q, but always gets to command mode
* even if command line invocation was as vi.
*/
case 'Q':
vsave();
/*
* If we are in the middle of a macro, throw away
* the rest and fix up undo.
* This code copied from getbr().
*/
if (vmacp) {
vmacp = 0;
if (inopen == -1) /* don't screw up undo for esc esc */
vundkind = VMANY;
inopen = 1; /* restore old setting now that macro done */
}
return;
/*
* ZZ Like :x
*/
case 'Z':
forbid(getkey() != 'Z');
oglobp = globp;
globp = "x";
vclrech(0);
goto gogo;
/*
* P Put back text before cursor or before current
* line. If text was whole lines goes back
* as whole lines. If part of a single line
* or parts of whole lines splits up current
* line to form many new lines.
* May specify a named buffer, or the delete
* saving buffers 1-9.
*
* p Like P but after rather than before.
*/
case 'P':
case 'p':
vmoving = 0;
#ifdef notdef
forbid (!vreg && value(UNDOMACRO) && inopen < 0);
#endif
/*
* If previous delete was partial line, use an
* append or insert to put it back so as to
* use insert mode on intelligent terminals.
*/
if (!vreg && DEL[0]) {
forbid ((DEL[0] & (QUOTE|TRIM)) == OVERBUF);
vglobp = DEL;
ungetkey(c == 'p' ? 'a' : 'i');
goto reread;
}
/*
* If a register wasn't specified, then make
* sure there is something to put back.
*/
forbid (!vreg && unddol == dol);
/*
* If we just did a macro the whole buffer is in
* the undo save area. We don't want to put THAT.
*/
forbid (vundkind == VMANY && undkind==UNDALL);
vsave();
vmacchng(1);
setLAST();
i = 0;
if (vreg && partreg(vreg) || !vreg && pkill[0]) {
/*
* Restoring multiple lines which were partial
* lines; will leave cursor in middle
* of line after shoving restored text in to
* split the current line.
*/
i++;
if (c == 'p' && *cursor)
cursor++;
} else {
/*
* In whole line case, have to back up dot
* for P; also want to clear cursor so
* cursor will eventually be positioned
* at the beginning of the first put line.
*/
cursor = 0;
if (c == 'P') {
dot--, vcline--;
c = 'p';
}
}
killU();
/*
* The call to putreg can potentially
* bomb since there may be nothing in a named buffer.
* We thus put a catch in here. If we didn't and
* there was an error we would end up in command mode.
*/
addr = dol; /* old dol */
CATCH
vremote(1, vreg ? putreg : put, vreg);
ONERR
if (vreg == -1) {
splitw = 0;
if (op == 'P')
dot++, vcline++;
goto pfixup;
}
ENDCATCH
splitw = 0;
nlput = dol - addr + 1;
if (!i) {
/*
* Increment undap1, undap2 to make up
* for their incorrect initialization in the
* routine vremote before calling put/putreg.
*/
if (FIXUNDO)
undap1++, undap2++;
vcline++;
nlput--;
/*
* After a put want current line first line,
* and dot was made the last line put in code
* run so far. This is why we increment vcline
* above and decrease dot here.
*/
dot -= nlput - 1;
}
#ifdef TRACE
if (trace)
fprintf(trace, "vreplace(%d, %d, %d), undap1=%d, undap2=%d, dot=%d\n", vcline, i, nlput, lineno(undap1), lineno(undap2), lineno(dot));
#endif
vreplace(vcline, i, nlput);
if (state != VISUAL) {
/*
* Special case in open mode.
* Force action on the screen when a single
* line is put even if it is identical to
* the current line, e.g. on YP; otherwise
* you can't tell anything happened.
*/
vjumpto(dot, cursor, '.');
continue;
}
pfixup:
vrepaint(cursor);
vfixcurs();
continue;
/*
* ^^ Return to previous file.
* Like a :e #, and thus can be used after a
* "No Write" diagnostic.
*/
case CTRL(^):
forbid (hadcnt);
vsave();
ckaw();
oglobp = globp;
if (value(AUTOWRITE))
globp = "e! #";
else
globp = "e #";
goto gogo;
/*
* ^] Takes word after cursor as tag, and then does
* tag command. Read ``go right to''.
*/
case CTRL(]):
grabtag();
oglobp = globp;
globp = "tag";
goto gogo;
/*
* & Like :&
*/
case '&':
oglobp = globp;
globp = "&";
goto gogo;
/*
* ^G Bring up a status line at the bottom of
* the screen, like a :file command.
*
* BUG: Was ^S but doesn't work in cbreak mode
*/
case CTRL(g):
oglobp = globp;
globp = "file";
gogo:
addr = dot;
vsave();
goto doinit;
#ifdef SIGTSTP
/*
* ^Z: suspend editor session and temporarily return
* to shell. Only works with Berkeley/IIASA process
* control in kernel.
*/
case CTRL(z):
forbid(dosusp == 0 || !ldisc);
vsave();
oglobp = globp;
globp = "stop";
goto gogo;
#endif
/*
* : Read a command from the echo area and
* execute it in command mode.
*/
case ':':
forbid (hadcnt);
vsave();
i = tchng;
addr = dot;
if (readecho(c)) {
esave[0] = 0;
goto fixup;
}
getDOT();
/*
* Use the visual undo buffer to store the global
* string for command mode, since it is idle right now.
*/
oglobp = globp; strcpy(vutmp, genbuf+1); globp = vutmp;
doinit:
esave[0] = 0;
fixech();
/*
* Have to finagle around not to lose last
* character after this command (when run from ex
* command mode). This is clumsy.
*/
d = peekc; ungetchar(0);
if (shouldpo) {
/*
* So after a "Hit return..." ":", we do
* another "Hit return..." the next time
*/
pofix();
shouldpo = 0;
}
CATCH
/*
* Save old values of options so we can
* notice when they change; switch into
* cooked mode so we are interruptible.
*/
onumber = value(NUMBER);
olist = value(LIST);
OPline = Pline;
OPutchar = Putchar;
#ifndef CBREAK
vcook();
#endif
commands(1, 1);
if (dot == zero && dol > zero)
dot = one;
#ifndef CBREAK
vraw();
#endif
ONERR
#ifndef CBREAK
vraw();
#endif
copy(esave, vtube[WECHO], TUBECOLS);
ENDCATCH
fixol();
Pline = OPline;
Putchar = OPutchar;
ungetchar(d);
globp = oglobp;
/*
* If we ended up with no lines in the buffer, make
* a line, and don't consider the buffer changed.
*/
if (dot == zero) {
fixzero();
sync();
}
splitw = 0;
/*
* Special case: did list/number options change?
*/
if (onumber != value(NUMBER))
setnumb(value(NUMBER));
if (olist != value(LIST))
setlist(value(LIST));
fixup:
/*
* If a change occurred, other than
* a write which clears changes, then
* we should allow an undo even if .
* didn't move.
*
* BUG: You can make this wrong by
* tricking around with multiple commands
* on one line of : escape, and including
* a write command there, but its not
* worth worrying about.
*/
if (FIXUNDO && tchng && tchng != i)
vundkind = VMANY, cursor = 0;
/*
* If we are about to do another :, hold off
* updating of screen.
*/
if (vcnt < 0 && Peekkey == ':') {
getDOT();
shouldpo = 1;
continue;
}
shouldpo = 0;
/*
* In the case where the file being edited is
* new; e.g. if the initial state hasn't been
* saved yet, then do so now.
*/
if (unddol == truedol) {
vundkind = VNONE;
Vlines = lineDOL();
if (!inglobal)
savevis();
addr = zero;
vcnt = 0;
if (esave[0] == 0)
copy(esave, vtube[WECHO], TUBECOLS);
}
/*
* If the current line moved reset the cursor position.
*/
if (dot != addr) {
vmoving = 0;
cursor = 0;
}
/*
* If current line is not on screen or if we are
* in open mode and . moved, then redraw.
*/
i = vcline + (dot - addr);
if (i < 0 || i >= vcnt && i >= -vcnt || state != VISUAL && dot != addr) {
if (state == CRTOPEN)
vup1();
if (vcnt > 0)
vcnt = 0;
vjumpto(dot, (char *) 0, '.');
} else {
/*
* Current line IS on screen.
* If we did a [Hit return...] then
* restore vcnt and clear screen if in visual
*/
vcline = i;
if (vcnt < 0) {
vcnt = -vcnt;
if (state == VISUAL)
vclear();
else if (state == CRTOPEN) {
vcnt = 0;
}
}
/*
* Limit max value of vcnt based on $
*/
i = vcline + lineDOL() - lineDOT() + 1;
if (i < vcnt)
vcnt = i;
/*
* Dirty and repaint.
*/
vdirty(0, LINES);
vrepaint(cursor);
}
/*
* If in visual, put back the echo area
* if it was clobberred.
*/
if (state == VISUAL) {
int sdc = destcol, sdl = destline;
splitw++;
vigoto(WECHO, 0);
for (i = 0; i < TUBECOLS - 1; i++) {
if (esave[i] == 0)
break;
vputchar(esave[i]);
}
splitw = 0;
vgoto(sdl, sdc);
}
continue;
/*
* u undo the last changing command.
*/
case 'u':
vundo(1);
continue;
/*
* U restore current line to initial state.
*/
case 'U':
vUndo();
continue;
fonfon:
beep();
vmacp = 0;
inopen = 1; /* might have been -1 */
continue;
}
/*
* Rest of commands are decoded by the operate
* routine.
*/
operate(c, cnt);
}
}
void
operate(int c, int cnt)
{
register int i;
void (*moveop)(), (*deleteop)();
void (*opf)();
bool subop = 0;
char *oglobp, *ocurs;
register line *addr;
static char lastFKND, lastFCHR;
char d;
moveop = vmove, deleteop = vdelete;
wcursor = cursor;
wdot = NOLINE;
notecnt = 0;
dir = 1;
switch (c) {
/*
* d delete operator.
*/
case 'd':
moveop = vdelete;
deleteop = beep;
break;
/*
* s substitute characters, like c\040, i.e. change space.
*/
case 's':
ungetkey(' ');
subop++;
/* fall into ... */
/*
* c Change operator.
*/
case 'c':
if ((c == 'c' && workcmd[0] == 'C') || workcmd[0] == 'S')
subop++;
moveop = vchange;
deleteop = beep;
break;
/*
* ! Filter through a UNIX command.
*/
case '!':
moveop = vfilter;
deleteop = beep;
break;
/*
* y Yank operator. Place specified text so that it
* can be put back with p/P. Also yanks to named buffers.
*/
case 'y':
moveop = vyankit;
deleteop = beep;
break;
/*
* = Reformat operator (for LISP).
*/
#ifdef LISP
case '=':
forbid(!value(LISP));
/* fall into ... */
#endif
/*
* > Right shift operator.
* < Left shift operator.
*/
case '<':
case '>':
moveop = vshftop;
deleteop = beep;
break;
/*
* r Replace character under cursor with single following
* character.
*/
case 'r':
vrep(cnt);
return;
default:
goto nocount;
}
/*
* Had an operator, so accept another count.
* Multiply counts together.
*/
if (isdigit(peekkey()) && peekkey() != '0') {
cnt *= vgetcnt();
Xcnt = cnt;
forbid (cnt <= 0);
}
/*
* Get next character, mapping it and saving as
* part of command for repeat.
*/
c = map(getesc());
if (c == 0)
return;
if (!subop)
*lastcp++ = c;
nocount:
opf = moveop;
switch (c) {
/*
* b Back up a word.
* B Back up a word, liberal definition.
*/
case 'b':
case 'B':
dir = -1;
/* fall into ... */
/*
* w Forward a word.
* W Forward a word, liberal definition.
*/
case 'W':
case 'w':
wdkind = c & ' ';
if (edge()) {
forbid (opf == vmove);
wcursor = dir == -1 ? linebuf : strend(linebuf);
} else
while (cnt > 0 && !edge())
word(opf, cnt), cnt--;
vmoving = 0;
break;
/*
* E to end of following blank/nonblank word
*/
case 'E':
wdkind = 0;
goto ein;
/*
* e To end of following word.
*/
case 'e':
wdkind = 1;
ein:
if (edge()) {
forbid(opf == vmove);
wcursor = dir == -1 ? linebuf : strend(linebuf);
} else {
while (cnt > 1 && !edge()) {
word(opf, cnt);
cnt--;
}
eend(opf, cnt);
}
vmoving = 0;
break;
/*
* ( Back an s-expression.
*/
case '(':
dir = -1;
/* fall into... */
/*
* ) Forward an s-expression.
*/
case ')':
forbid(lfind(0, cnt, opf, (line *) 0) < 0);
if (wdot)
markpr(wdot);
break;
/*
* { Back an s-expression, but don't stop on atoms.
* In text mode, a paragraph. For C, a balanced set
* of {}'s.
*/
case '{':
dir = -1;
/* fall into... */
/*
* } Forward an s-expression, but don't stop on atoms.
* In text mode, back paragraph. For C, back a balanced
* set of {}'s.
*/
case '}':
forbid(lfind(1, cnt, opf, (line *) 0) < 0);
if (wdot)
markpr(wdot);
break;
/*
* % To matching () or {}. If not at ( or { scan for
* first such after cursor on this line.
*/
case '%':
vsave();
i = lmatchp((line *) 0);
getDOT();
forbid(!i);
if (opf != vmove)
if (dir > 0)
wcursor++;
else
cursor++;
else
if (wdot)
markpr(wdot);
break;
/*
* [ Back to beginning of defun, i.e. an ( in column 1.
* For text, back to a section macro.
* For C, back to a { in column 1 (~~ beg of function.)
*/
case '[':
dir = -1;
/* fall into ... */
/*
* ] Forward to next defun, i.e. a ( in column 1.
* For text, forward section.
* For C, forward to a } in column 1 (if delete or such)
* or if a move to a { in column 1.
*/
case ']':
if (!vglobp)
forbid(getkey() != c);
if (Xhadcnt)
vsetsiz(Xcnt);
vsave();
i = lbrack(c, opf);
getDOT();
forbid(!i);
if (wdot)
markpr(wdot);
if (ex_ospeed > B300)
hold |= HOLDWIG;
break;
/*
* , Invert last find with f F t or T, like inverse
* of ;.
*/
case ',':
forbid (lastFKND == 0);
c = isupper((int)lastFKND) ? tolower((int)lastFKND) : toupper((int)lastFKND);
ungetkey(lastFCHR);
if (vglobp == 0)
vglobp = "";
subop++;
goto nocount;
/*
* 0 To beginning of real line.
*/
case '0':
wcursor = linebuf;
vmoving = 0;
break;
/*
* ; Repeat last find with f F t or T.
*/
case ';':
forbid (lastFKND == 0);
c = lastFKND;
ungetkey(lastFCHR);
subop++;
goto nocount;
/*
* F Find single character before cursor in current line.
* T Like F, but stops before character.
*/
case 'F': /* inverted find */
case 'T':
dir = -1;
/* fall into ... */
/*
* f Find single character following cursor in current line.
* t Like f, but stope before character.
*/
case 'f': /* find */
case 't':
i = getesc();
if (i == 0)
return;
if (!subop)
*lastcp++ = i;
if (vglobp == 0)
lastFKND = c, lastFCHR = i;
for (; cnt > 0; cnt--)
forbid (find(i) == 0);
switch (c) {
case 'T':
wcursor++;
break;
case 't':
wcursor--;
case 'f':
fixup:
if (moveop != vmove)
wcursor++;
break;
}
vmoving = 0;
break;
/*
* | Find specified print column in current line.
*/
case '|':
if (Pline == numbline)
cnt += 8;
vmovcol = cnt;
vmoving = 1;
wcursor = vfindcol(cnt);
break;
/*
* ^ To beginning of non-white space on line.
*/
case '^':
wcursor = vskipwh(linebuf);
vmoving = 0;
break;
/*
* $ To end of line.
*/
case '$':
if (cnt > 1) {
if (opf == vmove) {
wcursor = 0;
vmoving = 1;
vmovcol = 20000;
cnt--;
} else
wcursor = linebuf;
wdot = dot + cnt;
break;
}
if (linebuf[0]) {
wcursor = strend(linebuf) - 1;
goto fixup;
}
wcursor = linebuf;
vmoving = 0;
break;
/*
* h Back a character.
* ^H Back a character.
*/
case 'h':
case CTRL('h'):
dir = -1;
/* fall into ... */
/*
* space Forward a character.
*/
case ' ':
forbid (margin() || (opf == vmove && edge()));
while (cnt > 0 && !margin())
wcursor += dir, cnt--;
if ((margin() && opf == vmove) || wcursor < linebuf)
wcursor -= dir;
vmoving = 0;
break;
/*
* D Delete to end of line, short for d$.
*/
case 'D':
cnt = INF;
goto deleteit;
/*
* X Delete character before cursor.
*/
case 'X':
dir = -1;
/* fall into ... */
deleteit:
/*
* x Delete character at cursor, leaving cursor where it is.
*/
case 'x':
if (margin())
goto errlab;
while (cnt > 0 && !margin())
wcursor += dir, cnt--;
opf = deleteop;
vmoving = 0;
break;
default:
/*
* Stuttered operators are equivalent to the operator on
* a line, thus turn dd into d_.
*/
if (opf == vmove || c != workcmd[0]) {
errlab:
beep();
return;
}
/* fall into ... */
/*
* _ Target for a line or group of lines.
* Stuttering is more convenient; this is mostly
* for aesthetics.
*/
case '_':
wdot = dot + cnt - 1;
vmoving = 0;
wcursor = 0;
break;
/*
* H To first, home line on screen.
* Count is for count'th line rather than first.
*/
case 'H':
wdot = (dot - vcline) + cnt - 1;
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = 0;
break;
/*
* - Backwards lines, to first non-white character.
*/
case '-':
wdot = dot - cnt;
vmoving = 0;
wcursor = 0;
break;
/*
* ^P To previous line same column. Ridiculous on the
* console of the VAX since it puts console in LSI mode.
*/
case CTRL('p'):
wdot = dot - cnt;
if (vmoving == 0)
vmoving = 1, vmovcol = column(cursor);
wcursor = 0;
break;
/*
* L To last line on screen, or count'th line from the
* bottom.
*/
case 'L':
wdot = dot + vcnt - vcline - cnt;
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = 0;
break;
/*
* M To the middle of the screen.
*/
case 'M':
wdot = dot + ((vcnt + 1) / 2) - vcline - 1;
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = 0;
break;
/*
* + Forward line, to first non-white.
*
* CR Convenient synonym for +.
*/
case '+':
case CR:
wdot = dot + cnt;
vmoving = 0;
wcursor = 0;
break;
/*
* ^N To next line, same column if possible.
*
* LF Linefeed is a convenient synonym for ^N.
*/
case CTRL('n'):
case NL:
wdot = dot + cnt;
if (vmoving == 0)
vmoving = 1, vmovcol = column(cursor);
wcursor = 0;
break;
/*
* n Search to next match of current pattern.
*/
case 'n':
vglobp = vscandir;
c = *vglobp++;
goto nocount;
/*
* N Like n but in reverse direction.
*/
case 'N':
vglobp = vscandir[0] == '/' ? "?" : "/";
c = *vglobp++;
goto nocount;
/*
* ' Return to line specified by following mark,
* first white position on line.
*
* ` Return to marked line at remembered column.
*/
case '\'':
case '`':
d = c;
c = getesc();
if (c == 0)
return;
c = markreg(c);
forbid (c == 0);
wdot = getmark(c);
forbid (wdot == NOLINE);
if (Xhadcnt)
vsetsiz(Xcnt);
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = d == '`' ? ncols[c - 'a'] : 0;
if (wcursor) {
vsave();
ex_getline(*wdot);
if (wcursor > strend(linebuf))
wcursor = 0;
getDOT();
}
if (ex_ospeed > B300)
hold |= HOLDWIG;
break;
/*
* G Goto count'th line, or last line if no count
* given.
*/
case 'G':
if (!Xhadcnt)
cnt = lineDOL();
wdot = zero + cnt;
forbid (wdot < one || wdot > dol);
if (opf == vmove)
markit(wdot);
vmoving = 0;
wcursor = 0;
break;
/*
* / Scan forward for following re.
* ? Scan backward for following re.
*/
case '/':
case '?':
if (Xhadcnt)
vsetsiz(Xcnt);
vsave();
ocurs = cursor;
wcursor = 0;
if (readecho(c))
return;
if (!vglobp)
vscandir[0] = genbuf[0];
oglobp = globp; CP(vutmp, genbuf); globp = vutmp;
d = peekc; ungetchar(0); fixech();
CATCH
#ifdef V6
/*
* Lose typeahead (ick).
*/
vcook();
#endif
addr = address();
#ifdef V6
vraw();
#endif
ONERR
#ifdef V6
vraw();
#endif
globp = oglobp;
ungetchar(d);
splitw = 0;
vclean();
vjumpto(dot, ocurs, 0);
return;
ENDCATCH
if (globp == 0)
globp = "";
else if (peekc)
--globp;
ungetchar(d);
c = 0;
if (*globp == 'z')
globp++, c = '\n';
if (any(*globp, "^+-."))
c = *globp++;
i = 0;
while (isdigit((int)*globp))
i = i * 10 + *globp++ - '0';
if (*globp)
c = *globp++;
globp = oglobp;
splitw = 0;
vmoving = 0;
if (i != 0)
vsetsiz(i);
if (opf == vmove) {
if (state == ONEOPEN || state == HARDOPEN)
outline = destline = WBOT;
markit(addr);
if (loc1 > linebuf && *loc1 == 0)
loc1--;
if (c)
vjumpto(addr, loc1, c);
else {
vmoving = 0;
if (loc1) {
vmoving++;
vmovcol = column(loc1);
}
getDOT();
if (state == CRTOPEN && addr != dot)
vup1();
vupdown(addr - dot, NOSTR);
}
return;
}
lastcp[-1] = 'n';
getDOT();
wdot = addr;
break;
}
/*
* Apply.
*/
if (vreg && wdot == 0)
wdot = dot;
(*opf)(c);
wdot = NOLINE;
}
/*
* Do a z operation.
* Code here is rather long, and very uninteresting.
*/
void
vzop(int hadcnt, int cnt, register int c)
{
register line *addr;
if (state != VISUAL) {
/*
* Z from open; always like a z=.
* This code is a mess and should be cleaned up.
*/
vmoveitup(1, 1);
vgoto(outline, 0);
ostop(normf);
setoutt();
addr2 = dot;
vclear();
destline = WECHO;
zop2(Xhadcnt ? Xcnt : value(WINDOW) - 1, '=');
if (state == CRTOPEN)
putnl();
putNFL();
termreset();
Outchar = vputchar;
ignore(ostart());
vcnt = 0;
outline = destline = 0;
vjumpto(dot, cursor, 0);
return;
}
if (hadcnt) {
addr = zero + cnt;
if (addr < one)
addr = one;
if (addr > dol)
addr = dol;
markit(addr);
} else
switch (c) {
case '+':
addr = dot + vcnt - vcline;
break;
case '^':
addr = dot - vcline - 1;
forbid (addr < one);
c = '-';
break;
default:
addr = dot;
break;
}
switch (c) {
case '.':
case '-':
break;
case '^':
forbid (addr <= one);
break;
case '+':
forbid (addr >= dol);
/* fall into ... */
case CR:
case NL:
c = CR;
break;
default:
beep();
return;
}
vmoving = 0;
vjumpto(addr, NOSTR, c);
}
