Work with multiple sessions

These functions can help when working with multiple sessions or with multiple buffers. As you open new buffers in a session, you build a stack of buffers. Each session has its own stack of buffers.

Edit multiple sessions in the same way

These functions apply the same command to multiple sessions.

# Apply command to all sessions.
# usage: <all [<command>]
function+all {
db0
while(*) {
e-
}
while(*) {
~0
e+
}
}

# Apply command to the current and next sessions.
# usage: <allnext [<command>]
function+allnext {
db0
while(*) {
~0
e+
}
}

# Apply command to the current and previous sessions.
# usage: <allprev [<command>]
function+allprev {
db0
while(*) {
~0
e-
}
}

Change session

These functions go to the first or last session.

# Go to the first session.
# usage: <first
function+first {
db0
while(*) {
e-
}
ft
if(?) {
f
}
}

# Go to the last session.
# usage: <last
function+last {
db0
while(*) {
e+
}
ft
if(?) {
f
}
}

Search sessions for a regular expression

These functions search for a regular expression in the buffer in the current session (without wrapping) and search the buffer in the next or previous session when they fail to find a match in the buffer in the current session. The function next searches forward. The function prev searches backward. Use the ci command to control whether the searches are case sensitive.

# Find the next match across sessions.
# usage: <next <regular expression>
# This function uses the label z.
function+next {
db0
H-
sg+
sw-
kz
/~0/f
while(?) {
'zX
if(*) {
}
e+
sw+
kz
$X
if(*) {
}
/~0/f
}
}

# Find the previous match across sessions.
# usage: <prev <regular expression>
# This function uses the label z.
function+prev {
db0
H-
sg+
sw-
kz
?~0?f
while(?) {
'zX
if(*) {
}
e-
sw+
kz
1X
if(*) {
}
?~0?f
}
}

Count sessions

This function prints the number of sessions.

# Print the number of sessions.
# usage: sessions
function+sessions {
db0
var lower=1
e-
while(*) {
var lower=$(lower+1)
e-
}
var total=1
e+
while(*) {
var total=$(total+1)
e+
}
p $(total)
[ $(total) != $(lower) ]
while(*) {
var lower=$(lower+1)
e-
[ $(total) != $(lower) ]
}
var lower=clear
var total=clear
}

Quit sessions

This function quits sessions until it reaches a session that contains a buffer with unwritten changes. If a buffer has unwritten changes, you can use the w command to write the changes to a file. Use the function again to quit the current session and continue quitting sessions.

# Quit sessions.
# usage: <q
function+q {
db0
while(*) {
q
}
ft
if(?) {
f
}
bw
}

Change buffer

These functions go to the top or bottom buffer.

# Go to the top buffer.
# usage: <top
function+top {
db0
while(*) {
up
}
ft
if(?) {
f
}
}

# Go to the bottom buffer.
# usage: <bot
function+bot {
db0
while(*) {
down
}
ft
if(?) {
f
}
}

Search buffers for a regular expression

These functions search for a regular expression in the current buffer (without wrapping) and search the history of buffers in the current session when they fail to find a match in the current buffer. The function sdown searches down. The function sup searches up. Use the ci command to control whether the searches are case sensitive.

# Find the next match across buffers.
# usage: <sdown <regular expression>
# This function uses the label z.
function+sdown {
db0
H-
sg+
sw-
kz
/~0/f
while(?) {
'zX
if(*) {
}
down
sw+
kz
$X
if(*) {
}
/~0/f
}
}

# Find the previous match across buffers.
# usage: <sup <regular expression>
# This function uses the label z.
function+sup {
db0
H-
sg+
sw-
kz
?~0?f
while(?) {
'zX
if(*) {
}
up
sw+
kz
1X
if(*) {
}
?~0?f
}
}

Unstack buffers

This function moves each buffer in the stack in the current session to its own session.

# Unstack the buffers.
# usage: <unstack
function+unstack {
db0
while(*) {
M0
}
}