alecAbstraction Layer for Escape Codes |
| git clone git://git.dimitrijedobrota.com/alec.git |
| Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING | |
| commit | d0bd51c29c05b227b28d71c59c6caf7f9742df8d |
| parent | 9dc03661ab1baccce726bd37b704d7ae34a4caa5 |
| author | Dimitrije Dobrota <mail@dimitrijedobrota.com> |
| date | Tue, 27 Feb 2024 22:58:45 +0000 |
Code generation works!!! * devide document into 3 sections with %%, same as with flex and bison ~ first section is copied over, as is, before the generated code ~ second section contains the rules for generating ~ third section is copied over, as is, after the generated code * Configure cmake to generate alec.hpp
Diffstat:| M | CMakeLists.txt | | | +- |
| M | src/CMakeLists.txt | | | ++++++++++++++++++---- |
| D | src/alec.hpp | | | --------------------------------------------------------------------------------- |
| A | src/alec.rules.hpp | | | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| M | src/lexer.l | | | +++++++++++++++++------ |
| M | src/parser.y | | | +++++++++++++++++++++++++++++++++------------ |
| D | src/rules | | | --------------------------------------------------------------------------------- |
7 files changed, 394 insertions(+), 580 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -3,7 +3,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
project(
Alec
VERSION 0.0.10
VERSION 0.0.11
DESCRIPTION "Abstraction Layer for Escape Codes"
HOMEPAGE_URL https://git.dimitrijedobrota.com/alec.git
LANGUAGES C CXX
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -17,19 +17,33 @@ ADD_FLEX_BISON_DEPENDENCY(LEXER PARSER)
add_executable(generator "${LEXER_OUT}" "${PARSER_OUT}")
target_include_directories(generator PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
set(GENERATE_OUT "${CMAKE_BINARY_DIR}/bin")
set_target_properties(generator PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION ${PROJECT_VERSION_MAJOR}
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
RUNTIME_OUTPUT_DIRECTORY "${GENERATE_OUT}"
)
set(RULES_NAME "alec.rules.hpp")
set(RULES_FILE "${CMAKE_BINARY_DIR}/${RULES_NAME}")
configure_file(alec.rules.hpp ${RULES_FILE} COPYONLY)
add_custom_command(
OUTPUT ${GENERATE_OUT}/alec.hpp
COMMAND generator ${RULES_FILE} > ${GENERATE_OUT}/alec.hpp
DEPENDS generator ${RULES_NAME}
COMMENT "Generating include file"
)
add_library(alec INTERFACE)
target_include_directories(alec INTERFACE .)
add_library(alec INTERFACE ${GENERATE_OUT}/alec.hpp)
target_include_directories(alec INTERFACE ${GENERATE_OUT})
set_target_properties(alec PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION ${PROJECT_VERSION_MAJOR}
PUBLIC_HEADER alec.hpp
PUBLIC_HEADER ${GENERATE_OUT}/alec.hpp
)
install(TARGETS alec
diff --git a/src/alec.hpp b/src/alec.hpp
@@ -1,374 +0,0 @@
#ifndef ALEC_ALEC_H
#define ALEC_ALEC_H
#include <algorithm>
#include <array>
#include <assert.h>
#include <cstdint>
#include <string>
#include <type_traits>
namespace ALEC {
enum CTRL {
BELL = 0x07,
BS = 0x08,
HT = 0x09,
LF = 0x0A,
VT = 0x0B,
FF = 0x0C,
CR = 0x0D,
ESC = 0x1B,
DEL = 0x7F,
};
enum class COLOR {
BLACK = 0,
RED = 1,
GREEN = 2,
YELLOW = 3,
BLUE = 4,
MAGENTA = 5,
CYAN = 6,
WHITE = 7,
DEFAULT = 9,
};
enum class DECOR {
RESET = 0,
BOLD = 1,
DIM = 2,
ITALIC = 3,
UNDERLINE = 4,
BLINK = 5,
INVERSE = 7,
HIDE = 8,
STRIKE = 9,
};
enum class MOTION {
END = 0,
BEGIN = 1,
WHOLE = 2,
};
namespace details {
template <std::size_t N> struct string_literal {
consteval string_literal(const char (&str)[N]) { std::copy_n(str, N, value); }
consteval std::size_t size() const { return N; }
char value[N];
};
struct helper {
template <typename T> static consteval std::size_t size(T val);
template <typename T> static constexpr char *append(char *ptr, T val);
template <std::size_t N> static constexpr std::size_t size(string_literal<N> val) { return val.size(); }
static constexpr std::size_t size(char val) { return 1; }
static constexpr std::size_t size(int val) {
std::size_t len = 1;
while (val /= 10)
len++;
return len;
}
template <std::size_t N> static constexpr char *append(char *ptr, string_literal<N> val) {
std::copy_n(val.value, N, ptr);
return ptr + N;
}
static constexpr char *append(char *ptr, char val) {
*ptr++ = val;
return ptr;
}
static constexpr char *append(char *ptr, int val) {
char *tmp = ptr += size(val);
do {
*--tmp = '0' + (val % 10);
} while (val /= 10);
return ptr;
}
static const std::string make(auto... args) {
std::size_t len = (helper::size(args) + ... + 2);
std::string res(len, 'a');
res[0] = CTRL::ESC, res[1] = '[';
auto map = [ptr = res.data() + 2](auto const &s) mutable { ptr = helper::append(ptr, s); };
(map(args), ...);
res[len] = 0;
return res;
}
};
template <auto... Args> struct escape_t {
static constexpr const auto value = []() {
constexpr std::size_t len = (helper::size(Args) + ... + 2);
std::array<char, len + 1> arr{CTRL::ESC, '[', 0};
auto map = [ptr = arr.data() + 2](auto const &s) mutable { ptr = helper::append(ptr, s); };
(map(Args), ...);
arr[len] = 0;
return arr;
}();
};
template <auto... Strs> static constexpr auto escape = escape_t<Strs...>::value.data();
template <details::string_literal... Strs> static constexpr auto escape_literal = escape<Strs...>;
} // namespace details
// Tamplate parameter constraints
template <int n>
concept limit_256_v = n >= 0 && n < 256;
template <int n>
concept limit_pos_v = n >= 0;
static inline bool limit_pos(int n) { return n >= 0; };
static inline bool limit_256(int n) { return n >= 0 && n < 256; };
/* Template compile-time variables */
// Move cursor up/down/frwd/back
template <int n>
requires limit_pos_v<n>
static constexpr auto cursor_up_v = details::escape<n, 'A'>;
template <int n>
requires limit_pos_v<n>
static constexpr auto cursor_down_v = details::escape<n, 'B'>;
template <int n>
requires limit_pos_v<n>
static constexpr auto cursor_frwd_v = details::escape<n, 'C'>;
template <int n>
requires limit_pos_v<n>
static constexpr auto cursor_back_v = details::escape<n, 'D'>;
// Move cursor to the next/prev line
template <int n>
requires limit_pos_v<n>
static constexpr auto cursor_line_next_v = details::escape<n, 'E'>;
template <int n>
requires limit_pos_v<n>
static constexpr auto cursor_line_prev_v = details::escape<n, 'F'>;
// Set cursor to specific column
template <int n>
requires limit_pos_v<n>
static constexpr auto cursor_column_v = details::escape<n, 'G'>;
// Erase functions
template <MOTION m> static constexpr auto erase_display_v = details::escape<(int)m, 'J'>;
template <MOTION m> static constexpr auto erase_line_v = details::escape<(int)m, 'K'>;
// Scroll up/down
template <int n>
requires limit_pos_v<n>
static constexpr auto scroll_up_v = details::escape<n, 'S'>;
template <int n>
requires limit_pos_v<n>
static constexpr auto scroll_down_v = details::escape<n, 'T'>;
// Set cursor to a specific position
template <int n, int m>
requires limit_pos_v<n> && limit_pos_v<m>
static constexpr auto cursor_position_v = details::escape<n, ';', m, 'H'>;
// color
template <auto... val> static const char *foreground_v;
template <auto... val> static const char *background_v;
// palet colors
template <COLOR color> static constexpr auto foreground_v<color> = details::escape<(int)color + 30, 'm'>;
template <COLOR color> static constexpr auto background_v<color> = details::escape<(int)color + 40, 'm'>;
// 256-color palette
template <int idx>
requires limit_256_v<idx>
static constexpr auto foreground_v<idx> = details::escape<38, ';', 5, ';', idx, 'm'>;
template <int idx>
requires limit_256_v<idx>
static constexpr auto background_v<idx> = details::escape<48, ';', 5, ';', idx, 'm'>;
// RGB colors
template <int R, int G, int B>
requires limit_256_v<R> && limit_256_v<G> && limit_256_v<B>
static constexpr auto foreground_v<R, G, B> =
details::escape<38, ';', 5, ';', R, ';', G, ';', B, 'm'>;
template <int R, int G, int B>
requires limit_256_v<R> && limit_256_v<G> && limit_256_v<B>
static constexpr auto background_v<R, G, B> =
details::escape<48, ';', 5, ';', R, ';', G, ';', B, 'm'>;
// Set/reset text decorators
template <DECOR decor> static constexpr auto decor_set_v = details::escape<(int)decor, 'm'>;
template <DECOR decor> static constexpr auto decor_reset_v = details::escape<(int)decor + 20, 'm'>;
// Save/load cursor position;
static constexpr auto cursor_save_v = details::escape<'s'>;
static constexpr auto cursor_load_v = details::escape<'u'>;
// Set screen modes
template <int n>
requires limit_pos_v<n>
static constexpr auto screen_mode_set_v = details::escape<'=', n, 'h'>;
template <int n>
requires limit_pos_v<n>
static constexpr auto screen_mode_reset_v = details::escape<'=', n, 'l'>;
// Private screen modes supported by most terminals
// Save/load screen
static constexpr auto screen_show_v = details::escape_literal<"?47h">;
static constexpr auto screen_hide_v = details::escape_literal<"?47l">;
// Show/hide cursor
static constexpr auto cursor_show_v = details::escape_literal<"?25h">;
static constexpr auto cursor_hide_v = details::escape_literal<"?25l">;
// Show/hide alternate buffer
static constexpr auto abuf_show_v = details::escape_literal<"?1049h">;
static constexpr auto abuf_hide_v = details::escape_literal<"?1049l">;
/* Run-time functions */
// Move cursor up/down/frwd/back
static constexpr auto cursor_up(int n) {
assert(limit_pos(n));
return details::helper::make(n, 'A');
}
static constexpr auto cursor_down(int n) {
assert(limit_pos(n));
return details::helper::make(n, 'B');
}
static constexpr auto cursor_frwd(int n) {
assert(limit_pos(n));
return details::helper::make(n, 'C');
}
static constexpr auto cursor_back(int n) {
assert(limit_pos(n));
return details::helper::make(n, 'D');
}
// Move cursor to the next/prev line
static constexpr auto cursor_line_next(int n) {
assert(limit_pos(n));
return details::helper::make(n, 'E');
}
static constexpr auto cursor_line_prev(int n) {
assert(limit_pos(n));
return details::helper::make(n, 'F');
}
// Set cursor to specific column
static constexpr auto cursor_column(int n) {
assert(limit_pos(n));
return details::helper::make(n, 'G');
}
// Erase functions
static constexpr auto erase_display(MOTION m) { return details::helper::make((int)m, 'J'); }
static constexpr auto erase_line(MOTION m) { return details::helper::make((int)m, 'K'); }
// Scroll up/down
static constexpr auto scroll_up(int n) {
assert(limit_pos(n));
return details::helper::make(n, 'S');
}
static constexpr auto scroll_down(int n) {
assert(limit_pos(n));
return details::helper::make(n, 'T');
}
// Set cursor to a specific position
static constexpr auto cursor_position(int n, int m) {
assert(limit_pos(n));
assert(limit_pos(m));
return details::helper::make(n, ';', m, 'H');
}
// color
// palet colors
static constexpr auto foreground(COLOR color) { return details::helper::make((int)color + 30, 'm'); }
static constexpr auto background(COLOR color) { return details::helper::make((int)color + 40, 'm'); }
// 256-color palette
static constexpr auto foreground(int idx) {
assert(limit_256(idx));
return details::helper::make(38, ';', 5, ';', idx, 'm');
}
static constexpr auto background(int idx) {
assert(limit_256(idx));
return details::helper::make(48, ';', 5, ';', idx, 'm');
}
// RGB colors
static constexpr auto foreground(int R, int G, int B) {
assert(limit_256(R));
assert(limit_256(G));
assert(limit_256(B));
return details::helper::make(38, ';', 5, ';', R, ';', G, ';', B, 'm');
}
static constexpr auto background(int R, int G, int B) {
assert(limit_256(R));
assert(limit_256(G));
assert(limit_256(B));
return details::helper::make(48, ';', 5, ';', R, ';', G, ';', B, 'm');
}
// Set/reset text decorators
static constexpr auto decor_set(DECOR decor) { return details::helper::make((int)decor, 'm'); }
static constexpr auto decor_reset(DECOR decor) { return details::helper::make((int)decor + 20, 'm'); }
// Save/load cursor position;
static constexpr auto cursor_save() { return cursor_save_v; }
static constexpr auto cursor_load() { return cursor_load_v; }
// Set screen modes
static constexpr auto screen_mode_set(int n) {
assert(limit_pos(n));
return details::helper::make('=', n, 'h');
}
static constexpr auto screen_mode_reset(int n) {
assert(limit_pos(n));
return details::helper::make('=', n, 'l');
}
// Private screen modes supported by most terminals
// Save/load screen
static constexpr auto screen_show() { return screen_show_v; }
static constexpr auto screen_hide() { return screen_hide_v; }
// Show/hide cursor
static constexpr auto cursor_show() { return cursor_show_v; }
static constexpr auto cursor_hide() { return cursor_hide_v; }
// Show/hide alternate buffer
static constexpr auto abuf_show() { return abuf_show_v; }
static constexpr auto abuf_hide() { return abuf_hide_v; }
// Keyboard string TODO
} // namespace ALEC
#endif
diff --git a/src/alec.rules.hpp b/src/alec.rules.hpp
@@ -0,0 +1,325 @@
#ifndef ALEC_ALEC_H
#define ALEC_ALEC_H
#include <algorithm>
#include <array>
#include <assert.h>
#include <cstdint>
#include <string>
#include <type_traits>
namespace ALEC {
enum CTRL {
BELL = 0x07,
BS = 0x08,
HT = 0x09,
LF = 0x0A,
VT = 0x0B,
FF = 0x0C,
CR = 0x0D,
ESC = 0x1B,
DEL = 0x7F,
};
enum class COLOR {
BLACK = 0,
RED = 1,
GREEN = 2,
YELLOW = 3,
BLUE = 4,
MAGENTA = 5,
CYAN = 6,
WHITE = 7,
DEFAULT = 9,
};
enum class DECOR {
RESET = 0,
BOLD = 1,
DIM = 2,
ITALIC = 3,
UNDERLINE = 4,
BLINK = 5,
INVERSE = 7,
HIDE = 8,
STRIKE = 9,
};
enum class MOTION {
END = 0,
BEGIN = 1,
WHOLE = 2,
};
namespace details {
template <std::size_t N> struct string_literal {
consteval string_literal(const char (&str)[N]) { std::copy_n(str, N, value); }
consteval std::size_t size() const { return N; }
char value[N];
};
struct helper {
template <typename T> static consteval std::size_t size(T val);
template <typename T> static constexpr char *append(char *ptr, T val);
template <std::size_t N> static constexpr std::size_t size(string_literal<N> val) { return val.size(); }
static constexpr std::size_t size(char val) { return 1; }
static constexpr std::size_t size(int val) {
std::size_t len = 1;
while (val /= 10)
len++;
return len;
}
template <std::size_t N> static constexpr char *append(char *ptr, string_literal<N> val) {
std::copy_n(val.value, N, ptr);
return ptr + N;
}
static constexpr char *append(char *ptr, char val) {
*ptr++ = val;
return ptr;
}
static constexpr char *append(char *ptr, int val) {
char *tmp = ptr += size(val);
do {
*--tmp = '0' + (val % 10);
} while (val /= 10);
return ptr;
}
static const std::string make(auto... args) {
std::size_t len = (helper::size(args) + ... + 2);
std::string res(len, 'a');
res[0] = CTRL::ESC, res[1] = '[';
auto map = [ptr = res.data() + 2](auto const &s) mutable { ptr = helper::append(ptr, s); };
(map(args), ...);
res[len] = 0;
return res;
}
};
template <auto... Args> struct escape_t {
static constexpr const auto value = []() {
constexpr std::size_t len = (helper::size(Args) + ... + 2);
std::array<char, len + 1> arr{CTRL::ESC, '[', 0};
auto map = [ptr = arr.data() + 2](auto const &s) mutable { ptr = helper::append(ptr, s); };
(map(Args), ...);
arr[len] = 0;
return arr;
}();
};
template <auto... Strs> static constexpr auto escape = escape_t<Strs...>::value.data();
template <details::string_literal... Strs> static constexpr auto escape_literal = escape<Strs...>;
} // namespace details
// Tamplate parameter constraints
template <int n>
concept limit_256_v = n >= 0 && n < 256;
template <int n>
concept limit_pos_v = n >= 0;
static inline bool limit_pos(int n) { return n >= 0; };
static inline bool limit_256(int n) { return n >= 0 && n < 256; };
%%
// Move cursor up/down/frwd/back
cursor_up
int n
limit_pos
n, 'A'
cursor_down
int n
limit_pos
n, 'B'
cursor_frwd
int n
limit_pos
n, 'C'
cursor_back
int n
limit_pos
n, 'D'
// Move cursor to the next/prev line
cursor_line_next
int n
limit_pos
n, 'E'
cursor_line_prev
int n
limit_pos
n, 'F'
// Set cursor to specific column
cursor_column
int n
limit_pos
n, 'G'
// Erase functions
erase_display
MOTION m
|
(int)m, 'J'
erase_line
MOTION m
|
(int)m, 'K'
// Scroll up/down
scroll_up
int n
limit_pos
n, 'S'
scroll_down
int n
limit_pos
n, 'T'
// Set cursor to a specific position
cursor_position
int n, int m
limit_pos
n, ';', m, 'H'
// color
// palet colors
foreground
COLOR color
|
(int)color + 30, 'm'
background
COLOR color
|
(int)color + 40, 'm'
// 256-color palette
foreground
int idx
limit_256
38, ';', 5, ';', idx, 'm'
background
int idx
limit_256
48, ';', 5, ';', idx, 'm'
// RGB colors
foreground
int R, int G, int B
limit_256
38, ';', 5, ';', R, ';', G, ';', B, 'm'
background
int R, int G, int B
limit_256
48, ';', 5, ';', R, ';', G, ';', B, 'm'
// Set/reset text decorators
decor_set
DECOR decor
|
(int)decor, 'm'
decor_reset
DECOR decor
|
(int)decor + 20, 'm'
// Save/load cursor position;
cursor_save
|
|
's'
cursor_load
|
|
'u'
// Set screen modes
screen_mode_set
int n
limit_pos
'=', n, 'h'
screen_mode_reset
int n
limit_pos
'=', n, 'l'
// Private screen modes supported by most terminals
// Save/load screen
screen_show
|
|
"?47h"
screen_hide
|
|
"?47l"
// Show/hide cursor
cursor_show
|
|
"?25h"
cursor_hide
|
|
"?25l"
// Show/hide alternate buffer
abuf_show
|
|
"?1049h"
abuf_hide
|
|
"?1049l"
%%
// Keyboard string TODO
} // namespace ALEC
#endif
diff --git a/src/lexer.l b/src/lexer.l
@@ -8,22 +8,33 @@
LINE_END (\n|\r|\r\n)
%x GEN
%x LAST
%%
{LINE_END} { return EOL; }
^[\t ]*{LINE_END} { return EOL; }
^[\t ]*\|*[\t ]*{LINE_END} { return EOL; }
^[\t ]*"//".* { yylval.n = strdup(yytext); return COMMENT; }
"%%"{LINE_END} { BEGIN GEN; return SWITCH; }
.*{LINE_END} { yylval.n = strdup(yytext); return BEFORE; }
<GEN>{LINE_END} { return EOL; }
<GEN>^[\t ]*{LINE_END} { return EOL; }
<GEN>^[\t ]*\|*[\t ]*{LINE_END} { return EOL; }
<GEN>^[\t ]*"//".* { yylval.n = strdup(yytext); return COMMENT; }
, { return COMMA; }
<GEN>, { return COMMA; }
[^,\n]* {
<GEN>[^,\n]* {
char *p = yytext + strlen(yytext) - 1;
while(isspace(*p)) *p-- = '\0';
while(*yytext && isspace(*yytext)) yytext++;
yylval.n = strdup(yytext); return LITERAL;
}
<GEN>"%%"{LINE_END} { BEGIN LAST; return SWITCH; }
<LAST>.*{LINE_END} { yylval.n = strdup(yytext); return AFTER; }
%%
diff --git a/src/parser.y b/src/parser.y
@@ -7,7 +7,9 @@
void yyrestart(FILE *);
int yylex_destroy(void);
struct list *records;
struct list *records = NULL;
struct list *before = NULL;
struct list *after = NULL;
%}
%union {
@@ -16,8 +18,8 @@
char *n;
}
%token <n> LITERAL COMMENT
%token EOL COMMA
%token <n> LITERAL COMMENT BEFORE AFTER
%token EOL COMMA SWITCH
%type <r> record
%type <l> list
@@ -27,15 +29,23 @@
%%
document: %empty
| EOL document
| record document { records = list_new((char *)$1, records); }
| COMMENT document {
records = list_new((char *)record_new(
$1, NULL, NULL, NULL
), records);
}
;
document: before SWITCH mid SWITCH after
before: %empty
| BEFORE before { before = list_new($1, before); }
after: %empty
| AFTER after { after = list_new($1, after); }
mid: %empty
| EOL mid
| record mid { records = list_new((char *)$1, records); }
| COMMENT mid {
records = list_new((char *)record_new(
$1, NULL, NULL, NULL
), records);
}
;
record: name list list list { $$ = record_new($1, $2, $3, $4); }
;
@@ -73,6 +83,12 @@ int main(const int argc, char *argv[]) {
fclose(f);
}
// print before section
for(struct list *p = before; p; p = p->next) {
printf("%s", p->data);
}
struct list *dupes = record_dupes(records);
record_print_dupes(dupes);
@@ -88,6 +104,11 @@ int main(const int argc, char *argv[]) {
record_print_function(r);
}
// print after section
for(struct list *p = after; p; p = p->next) {
printf("%s", p->data);
}
list_free(records, record_free);
list_free(dupes, 0);
diff --git a/src/rules b/src/rules
@@ -1,183 +0,0 @@
// Move cursor up/down/frwd/back
cursor_up
int n
limit_pos
n, 'A'
cursor_down
int n
limit_pos
n, 'B'
cursor_frwd
int n
limit_pos
n, 'C'
cursor_back
int n
limit_pos
n, 'D'
// Move cursor to the next/prev line
cursor_line_next
int n
limit_pos
n, 'E'
cursor_line_prev
int n
limit_pos
n, 'F'
// Set cursor to specific column
cursor_column
int n
limit_pos
n, 'G'
// Erase functions
erase_display
MOTION m
|
(int)m, 'J'
erase_line
MOTION m
|
(int)m, 'K'
// Scroll up/down
scroll_up
int n
limit_pos
n, 'S'
scroll_down
int n
limit_pos
n, 'T'
// Set cursor to a specific position
cursor_position
int n, int m
limit_pos
n, ';', m, 'H'
// color
// palet colors
foreground
COLOR color
|
(int)color + 30, 'm'
background
COLOR color
|
(int)color + 40, 'm'
// 256-color palette
foreground
int idx
limit_256
38, ';', 5, ';', idx, 'm'
background
int idx
limit_256
48, ';', 5, ';', idx, 'm'
// RGB colors
foreground
int R, int G, int B
limit_256
38, ';', 5, ';', R, ';', G, ';', B, 'm'
background
int R, int G, int B
limit_256
48, ';', 5, ';', R, ';', G, ';', B, 'm'
// Set/reset text decorators
decor_set
DECOR decor
|
(int)decor, 'm'
decor_reset
DECOR decor
|
(int)decor + 20, 'm'
// Save/load cursor position;
cursor_save
|
|
's'
cursor_load
|
|
'u'
// Set screen modes
screen_mode_set
int n
limit_pos
'=', n, 'h'
screen_mode_reset
int n
limit_pos
'=', n, 'l'
// Private screen modes supported by most terminals
// Save/load screen
screen_show
|
|
"?47h"
screen_hide
|
|
"?47l"
// Show/hide cursor
cursor_show
|
|
"?25h"
cursor_hide
|
|
"?25l"
// Show/hide alternate buffer
abuf_show
|
|
"?1049h"
abuf_hide
|
|
"?1049l"