snark13/Sprinter-SDCC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: snark13/Sprinter-SDCC:e1450ba7b447aa808a6f80dbc66676d967e0e41d
Branches Tags
snark13/Sprinter-SDCC:main
snark13/Sprinter-SDCC:v0.5-pop-level1 snark13/Sprinter-SDCC:v0.4-pop-roomtest snark13/Sprinter-SDCC:v0.3-libc snark13/Sprinter-SDCC:v0.2-mdview2
...
compare: snark13/Sprinter-SDCC:e5866d6ba4f2d5d12f54e3ac8d53ff9cacd569bc
Branches Tags
snark13/Sprinter-SDCC:main
snark13/Sprinter-SDCC:v0.5-pop-level1 snark13/Sprinter-SDCC:v0.4-pop-roomtest snark13/Sprinter-SDCC:v0.3-libc snark13/Sprinter-SDCC:v0.2-mdview2

4 Commits
e1450ba7b4 ... e5866d6ba4

Author SHA1 Message Date
snark13 e5866d6ba4 mdview2: единая позиция при переключениях F2 (MD↔RAW) и F8 (8bit↔UTF-8) 
Валюта позиции — байт-offset активного буфера:
- line_at_off(off): обратный перевод offset → MD-строка (бинарный поиск
  по seg_off, оффсеты сегментов монотонны);
- map_off(off, from, to): пропорциональный перенос позиции между
  буферами разного размера — один цикл restoring-деления, без
  __mullong/__divulong, точность from/65536;
- raw_pos()/raw_reanchor(off) в RAW-модуле; raw_seed_from через
  reanchor, raw_home стал приватным (только клавиша Home).

F2 RAW→MD: top_line = line_at_off(raw_pos()) — точное позиционирование.
F8 между готовыми наборами: view_pos → map_off → view_reanchor вместо
восстановления сохранённой позиции набора. Ленивая сборка — по-прежнему
с начала (в RAW с raw_reanchor(0) и откатом при неудаче).

Попутно: F8 в RAW-режиме больше не рисует MD-вид поверх RAW —
перерисовка по g_view.

exe 25100 → 25725 (+625). Проверено в MAME.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
 2026-07-04 22:00:24 +03:00
snark13 adf667c087 mdview2: слить inline_scan + scan_join_stream в scan_stream — exe 25616 → 25100 
B2 stage2: общий цикл inline-форматирования/переносов/склейки в одном
scan_stream (mode: NONE / LIST / QUOTE / PLAIN); дублировавшиеся блоки
эмиссии пробела/символа, переноса с усечением и отката стиля — в одном
экземпляре. Старые имена — тонкие обёртки, API inline_scan для
table-модуля не изменился. styles_map умерла: emph_to_attr(ls, ATTR_TEXT)
тождественна ей.

Индексатор 9839 → 9315 Б. Проверено в MAME: переносы заголовков/списков/
цитат, таблицы, inline-маркеры на границе переноса, жёсткие переносы.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
 2026-07-04 21:26:13 +03:00
snark13 ffd179e064 mdview2: оптимизация размера — exe 28215 → 25616 (−2599 Б) 
Раунд 1 (−1411): --max-allocs 100000 в Makefile (−848 кода) + снятие
всех нулевых инициализаторов file-scope переменных (_INITIALIZER
583→24; _DATA теперь зануляется в crt0).

Раунд 2 (−1188, индексатор 11019→9839): дедупликации в mdview2_index.c:
- classify_line: копия HR-проверки → вызов is_hr_raw;
- next_line() поверх row_end() вместо 9 копий «домотать до \n»;
- inline_marker: emph_to_attr(ls, base) вычисляется один раз (at);
- set_{nowrap,blank,code,hscroll}_cur → set_cur_flags(mask): строка
  code-блока делает один idx_put вместо трёх.

Проверено в MAME (README/UTF8TEST: маркеры, списки, цитаты, таблицы,
code-блоки, F8).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
 2026-07-04 21:15:43 +03:00
snark13 961cfb786d toolchain: gsinit зануляет _DATA (C-семантика статиков) + sprinter-cc --max-allocs 
Все четыре crt0 (default/small/minimal/banked): gsinit теперь зануляет
_DATA и _BSS через общий zero_area, затем копирует _INITIALIZER.
Явные `= 0` у глобалов/статиков больше не нужны (они жгли байты
_INITIALIZER в образе). crt0-приватные переменные, записываемые ДО
gsinit (_estex_startup_ix и др.), перенесены из _DATA в _CODE (RAM).

sprinter-cc: новая опция --max-allocs N → SDCC --max-allocs-per-node
(агрессивнее аллокация регистров, меньше/быстрее код ценой времени
компиляции).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
 2026-07-04 21:15:42 +03:00
11 changed files with 389 additions and 287 deletions
Expand all files Collapse all files
bin/sprinter-cc
+6
View File
@@ -34,6 +34,9 @@
# --bank N=FILE.c compile FILE.c as bank N; repeatable; pulls crt0_banked
# automatically and adds -Wl-b_BANKN=0x{N}C000
# --mkexe FLAG extra mkexe flag (repeatable; e.g. --mkexe -p --mkexe 0)
# --max-allocs N SDCC --max-allocs-per-node (default: SDCC's 3000).
# Higher values give smaller/faster code at the cost of
# compile time; 10000..100000 is a reasonable range.
# --debug enable runtime diagnostics — defines DEBUG_RT for both
# sdcc (-DDEBUG_RT) and the crt0 assembly (prepended
# `DEBUG_RT = 1`). Exposes runtime introspection symbols
@@ -82,6 +85,7 @@ SOURCES=()
LD_EXTRA=()
MKEXE_EXTRA=()
BANK_SPECS=() # entries like "1=engine.c"
MAX_ALLOCS="" # if set, passed to sdcc as --max-allocs-per-node
# ------- Parse args ----------------------------------------------------------
usage() {
@@ -105,6 +109,7 @@ while [[ $# -gt 0 ]]; do
-Wl) LD_EXTRA+=("$2"); shift 2;;
--bank) BANK_SPECS+=("$2"); shift 2;;
--mkexe) MKEXE_EXTRA+=("$2"); shift 2;;
--max-allocs) MAX_ALLOCS="$2"; shift 2;;
--debug) DEBUG_RT=1; shift;;
-v) VERBOSE=1; shift;;
-h|--help) usage 0;;
@@ -272,6 +277,7 @@ run "$SDASZ80" -o "$HEAP_TOP_REL" "$HEAP_TOP_SRC"
USER_RELS=()
CC_FLAGS=(-mz80 --no-std-crt0 --std-c99 --opt-code-size -I "$INC_DIR" "${USER_INCS[@]}")
[[ $DEBUG_RT -eq 1 ]] && CC_FLAGS+=(-DDEBUG_RT)
[[ -n "$MAX_ALLOCS" ]] && CC_FLAGS+=(--max-allocs-per-node "$MAX_ALLOCS")
for src in "${SOURCES[@]}"; do
rel="$WORK/$(basename "$src" .c).rel"
run "$SDCC" "${CC_FLAGS[@]}" -c -o "$rel" "$src"
examples/mdview2/Makefile
+3
View File
@@ -10,6 +10,9 @@ PROJ_ROOT := $(abspath $(CURDIR)/../..)
EXAMPLE := mdview2
EXTRA_SRCS := mdview2_raw.c mdview2_help.c mdview2_table.c mdview2_enc.c mdview2_md.c mdview2_status.c mdview2_index.c
MEMORY := small
# --max-allocs 100000: агрессивнее аллокация регистров SDCC — минус ~850 байт
# кода на всём приложении (замер 2026-07-04) ценой более долгой компиляции.
EXTRA_FLAGS := --max-allocs 100000
include $(PROJ_ROOT)/app.mk
examples/mdview2/mdview2.c
+104 -44
View File
@@ -101,15 +101,15 @@ static const uint8_t md_pallete[16 * 4] = {
/* MAX_CACHE_LINE_LEN — в mdview2.h (буфер ячеек g_cells живёт в mdview2_index.c). */
#define MAX_CACHE_CONTENT_PAGES 40u /* кап контента на набор: 40 * 16 КБ = 640 КБ (80 на оба набора) */
static uint8_t cache_dir_blk = 0;
static uint8_t cache_dir_pages = 0;
static uint8_t cache_dir_phys[MAX_CACHE_DIR_PAGES] = {0};
static uint8_t cache_dir_blk;
static uint8_t cache_dir_pages;
static uint8_t cache_dir_phys[MAX_CACHE_DIR_PAGES];
static uint8_t cache_content_blk[MAX_CACHE_CONTENT_PAGES] = {0}; /* id блока на каждую выделенную страницу */
static uint8_t cache_content_phys[MAX_CACHE_CONTENT_PAGES] = {0};
static uint8_t cache_content_n_pages = 0; /* сколько страниц уже выделено */
static uint8_t cache_cur_page_idx = 0; /* индекс текущей страницы записи в cache_content_phys */
static uint16_t cache_cur_off = 0; /* текущее смещение записи в этой странице */
static uint8_t cache_content_blk[MAX_CACHE_CONTENT_PAGES]; /* id блока на каждую выделенную страницу */
static uint8_t cache_content_phys[MAX_CACHE_CONTENT_PAGES];
static uint8_t cache_content_n_pages; /* сколько страниц уже выделено */
static uint8_t cache_cur_page_idx; /* индекс текущей страницы записи в cache_content_phys */
static uint16_t cache_cur_off; /* текущее смещение записи в этой странице */
/* Доступ к директории рендер-кэша — тот же приём, что у idx_get/idx_put. */
void cache_dir_get(uint16_t idx, cache_rec_t *r)
@@ -175,41 +175,41 @@ void cache_commit(uint8_t page, uint16_t off, const void *buf, uint16_t len)
/* emph_to_attr определена ниже (рядом с inline-логикой), нужна в inline_scan. */
/* emph_to_attr — в mdview2_index.c. */
uint16_t n_lines = 0; /* extern: всего строк в индексе текущего набора */
uint16_t max_lines = 0; /* extern: ёмкость индекса: index_pages * 2048 */
uint16_t top_line = 0; /* extern: верхняя видимая строка */
uint32_t file_size = 0; /* extern: размер активного буфера документа */
static uint8_t file_blk = 0;
static uint8_t file_pages = 0;
static uint8_t file_phys[MAX_PAGES] = {0};
uint8_t index_blk = 0; /* extern: дескриптор EMM-блока индекса */
uint8_t index_pages = 0; /* */
uint8_t index_phys[MAX_INDEX_PAGES] = {0}; /* extern: физ. страницы индекса */
uint8_t index_truncated = 0; /* выставляется при исчерпании ёмкости индекса */
uint8_t g_file_clamped = 0; /* extern: файл >256 КБ обрезан до MAX_FILE при загрузке */
uint16_t n_lines; /* extern: всего строк в индексе текущего набора */
uint16_t max_lines; /* extern: ёмкость индекса: index_pages * 2048 */
uint16_t top_line; /* extern: верхняя видимая строка */
uint32_t file_size; /* extern: размер активного буфера документа */
static uint8_t file_blk;
static uint8_t file_pages;
static uint8_t file_phys[MAX_PAGES];
uint8_t index_blk; /* extern: дескриптор EMM-блока индекса */
uint8_t index_pages; /* */
uint8_t index_phys[MAX_INDEX_PAGES]; /* extern: физ. страницы индекса */
uint8_t index_truncated; /* выставляется при исчерпании ёмкости индекса */
uint8_t g_file_clamped; /* extern: файл >256 КБ обрезан до MAX_FILE при загрузке */
/* cur_seg_off/cur_rec (near-состояние индексатора) — в mdview2_index.c. */
uint8_t cur_page = 0xFF; /* extern: 0xFF = в W3 ещё не показана ни одна страница (extern: кодек инвалидирует) */
uint8_t viewport_x = 0; /* extern: горизонтальный сдвиг для nowrap-строк */
char filename[64] = {0}; /* extern: статус-бар */
uint8_t viewport_x; /* extern: горизонтальный сдвиг для nowrap-строк */
char filename[64]; /* extern: статус-бар */
/* Прогрессивная загрузка: рисуем первый экран и пускаем скролл, пока
* index_lines() ещё досканирует файл (кооперативно, без прерываний). */
uint8_t g_view = VIEW_MD; /* extern: активный режим просмотра (существует даже когда доступен только MD режим) */
#if WITH_RAW
uint8_t g_ready = 0; /* extern: 1 когда первичный документ построен — F2 (RAW) рабочий */
uint8_t g_ready; /* extern: 1 когда первичный документ построен — F2 (RAW) рабочий */
static uint8_t g_raw_last = VIEW_RAW_WRAP; /* последний под-режим RAW (возврат по F2) */
#endif
uint8_t g_loading = 0; /* extern: 1 во время index_lines() */
static uint8_t g_first_drawn = 0; /* первый экран уже нарисован */
uint8_t g_f8_enabled = 0; /* extern: можно ли сейчас переключать кодировку */
static uint8_t g_utf_failed = 0; /* UTF-8 набор не удалось построить (нет EMM) — пропускаем UTF-8 в цикле F8 */
uint8_t g_abort = 0; /* extern: F10/Esc во время загрузки → прервать индексацию */
static uint16_t g_last_prog = 0; /* n_lines на последнем обновлении статуса */
uint8_t g_loading; /* extern: 1 во время index_lines() */
static uint8_t g_first_drawn; /* первый экран уже нарисован */
uint8_t g_f8_enabled; /* extern: можно ли сейчас переключать кодировку */
static uint8_t g_utf_failed; /* UTF-8 набор не удалось построить (нет EMM) — пропускаем UTF-8 в цикле F8 */
uint8_t g_abort; /* extern: F10/Esc во время загрузки → прервать индексацию */
static uint16_t g_last_prog; /* n_lines на последнем обновлении статуса */
/* Кодировки (ENC_*) и g_encoding — в mdview2.h / mdview2_enc.c. */
const uint8_t *g_remap = 0; /* extern: активная таблица ремапа (CP1251/KOI8), 0 = без ремапа (CP866)*/
uint8_t g_scratch_phys = 0; /* extern: EMM-страница под ремап-буфер строки для win_rest */
const uint8_t *g_remap; /* extern: активная таблица ремапа (CP1251/KOI8), 0 = без ремапа (CP866)*/
uint8_t g_scratch_phys; /* extern: EMM-страница под ремап-буфер строки для win_rest */
/* UTF-8 набор (utf_blk/utf_pages/utf_phys/utf_size/utf_avail, конвертер и его
* состояние) — в mdview2_enc.c; разделяемые символы и API — в mdview2.h.
@@ -218,10 +218,10 @@ uint8_t g_scratch_phys = 0; /* extern: EMM-страни
/* Снимок исходного (8-битного) файлового буфера — набор DOC_8BIT читает его
* как есть, набор DOC_UTF8 читает utf_phys. */
static uint8_t orig_file_blk = 0;
uint8_t orig_file_pages = 0; /* extern: читает кодек (utf_alloc) */
uint32_t orig_file_size = 0; /* extern: читает кодек (utf_convert_more) */
uint8_t orig_file_phys[MAX_PAGES] = {0}; /* extern: читает кодек (cv_read) */
static uint8_t orig_file_blk;
uint8_t orig_file_pages; /* extern: читает кодек (utf_alloc) */
uint32_t orig_file_size; /* extern: читает кодек (utf_convert_more) */
uint8_t orig_file_phys[MAX_PAGES]; /* extern: читает кодек (cv_read) */
/* ----------------- Два сосуществующих набора индекс/кэш -----------------
* DOC_8BIT — исходные байты (CP866/CP1251/KOI8R, различаются ремапом на
@@ -250,9 +250,9 @@ typedef struct {
#define DOC_8BIT 0
#define DOC_UTF8 1
static docset_t g_doc[2] = {{0}, {0}}; /* ОБЯЗАТЕЛЬНО инициализировать: built=0 для обоих
* (SDCC z80 не обнуляет неинициализированные статики
* надёжно — см. memory/sdcc_static_storage_gotcha) */
static docset_t g_doc[2]; /* built=0 для обоих: _DATA зануляется в crt0 gsinit
* (с 2026-07-04), явный {0}-инициализатор больше
* не нужен — он стоил ~260 байт _INITIALIZER */
static uint8_t g_active_doc = DOC_8BIT; /* какой набор сейчас в живых глобалах */
static uint8_t g_disp_doc = DOC_8BIT; /* какой набор показан пользователю */
@@ -826,6 +826,43 @@ static int build_doc(uint8_t slot, uint8_t enc, uint8_t visible)
return 0;
}
/* Пропорциональный перенос байт-позиции между буферами разного размера
* (8bit ↔ UTF-8 при F8): off * to / from БЕЗ __mullong/__divulong. Один
* цикл restoring-деления: бит k дроби off/from (сравнение с from/2^k)
* сразу добавляет to/2^k в результат — сумма to/2^k по установленным
* битам и есть off*to/from. Точность from/65536 (≤4 байта на максимальном
* файле); ляжет на границу строки через line_at_off / raw_reanchor. */
static uint32_t map_off(uint32_t off, uint32_t from, uint32_t to)
{
if (from == to || from == 0) return off;
uint32_t res = 0;
for (uint8_t i = 0; i < 16; i++) {
from >>= 1;
to >>= 1;
if (off >= from) { off -= from; res += to; }
}
return res;
}
/* Байт-позиция текущего вида (верх экрана) — единая «валюта» для переноса
* позиции между видами/наборами. */
static uint32_t view_pos(void)
{
#if WITH_RAW
if (g_view != VIEW_MD) return raw_pos();
#endif
return seg_off(top_line);
}
/* Поставить текущий вид на байт-позицию off (после doc_switch). */
static void view_reanchor(uint32_t off)
{
#if WITH_RAW
if (g_view != VIEW_MD) { raw_reanchor(off); return; }
#endif
top_line = line_at_off(off);
}
/* Переключает кодировку на `next` (вызывается из главного цикла по F8).
* 8-бит↔8-бит внутри одного набора — мгновенный ремап; переход в другой набор
* — мгновенный doc_switch, если он построен, иначе ЛЕНИВАЯ сборка по месту
@@ -842,14 +879,23 @@ static void switch_encoding(uint8_t next)
set_encoding(next);
g_doc[target].enc = next;
} else if (g_doc[target].built) { /* набор готов — мгновенный свап */
doc_switch(target);
/* Позицию переносим пропорцией байтов (буферы наборов разного
* размера), а не из сохранённой в g_doc копии — иначе каждый набор
* скачет по своей старой позиции. */
uint32_t old_off = view_pos();
uint32_t old_size = file_size;
doc_switch(target);
g_disp_doc = target;
set_encoding(next);
set_encoding(next);
g_doc[target].enc = next;
view_reanchor(map_off(old_off, old_size, file_size));
} else { /* строим набор лениво */
doc_save_live(g_active_doc); /* сохранить текущий (позиция и т.п.) */
#if WITH_RAW
g_ready = 0;
uint32_t raw_save = raw_pos();
if (g_view != VIEW_MD)
raw_reanchor(0); /* прогрессивный показ нового буфера — с начала */
g_ready = 0;
render_menu(); /* идёт индексация — прячем F2 */
#endif
spinner_show(1);
@@ -861,9 +907,13 @@ static void switch_encoding(uint8_t next)
render_menu();
#endif
if (rc < 0) { /* нет EMM — откат на текущий набор */
if (target == DOC_UTF8)
if (target == DOC_UTF8)
g_utf_failed = 1;
doc_load_live(g_active_doc);
#if WITH_RAW
if (g_view != VIEW_MD)
raw_reanchor(raw_save); /* буфер прежний — вернуть позицию RAW */
#endif
return;
}
g_disp_doc = target; /* build_doc уже выставил active/enc */
@@ -1036,6 +1086,7 @@ int main(int argc, char **argv)
} else {
g_raw_last = g_view; /* запомнить под-режим RAW */
g_view = VIEW_MD;
top_line = line_at_off(raw_pos()); /* позиция из RAW */
clamp_top();
render_full_status(); render_menu();
draw_viewport_from_cache();
@@ -1050,9 +1101,18 @@ int main(int argc, char **argv)
if (next == ENC_UTF8 && g_utf_failed)
next = ENC_CP866; /* UTF-8 недоступен */
switch_encoding(next);
if (g_abort)
if (g_abort)
exit(0); /* Esc/F10 во время ленивой досборки */
render_full_status(); /* перерисовка — в MD-режиме */
/* Перерисовка — по текущему виду (switch_encoding сам не рисует). */
#if WITH_RAW
if (g_view != VIEW_MD) {
status_encoding();
render_raw_status();
raw_draw();
continue;
}
#endif
render_full_status();
draw_viewport_from_cache();
continue;
}
examples/mdview2/mdview2.h
+4 -2
View File
@@ -139,12 +139,14 @@ void win_rest(uint8_t row, uint8_t col, uint8_t h, uint8_t w, uint8_t page,
void fill_row(uint8_t y, uint8_t attr);
uint8_t pct16(uint16_t num, uint16_t den); /* num*100/den (0..100), 16-бит, без __divulong */
uint32_t seg_off(uint16_t idx); /* offset исходника для логической строки idx */
uint16_t line_at_off(uint32_t off); /* обратно: последняя строка с seg_off <= off */
/* ================================================================== *
* API модуля RAW (mdview2_raw.c).
* ================================================================== */
void raw_seed_from(uint16_t md_top_line); /* вход в RAW: позиция по top_line */
void raw_home(void); /* сброс в начало (смена буфера при F8 в/из UTF-8) */
void raw_seed_from(uint16_t md_top_line); /* вход в RAW: позиция по top_line */
uint32_t raw_pos(void); /* текущий байт-offset верха экрана RAW */
void raw_reanchor(uint32_t off); /* поставить RAW на строку с байтом off */
void raw_draw(void); /* перерисовать область документа в RAW */
uint8_t raw_pct(void); /* % прокрутки по байтам (для render_raw_status_numbers) */
uint8_t raw_key(uint8_t scan); /* навигация RAW; 1 = обработано */
examples/mdview2/mdview2_enc.c
+10 -10
View File
@@ -23,16 +23,16 @@
/* ---- Состояние кодировки/UTF (владелец — этот модуль) ------------- */
uint8_t g_encoding = ENC_CP866; /* активная кодировка */
uint8_t utf_blk = 0;
uint8_t utf_pages = 0;
uint8_t utf_phys[MAX_PAGES] = {0};
uint32_t utf_size = 0;
uint8_t utf_avail = 0; /* 1 = страницы UTF-8 выделены */
uint8_t g_utf_building = 0; /* 1 пока конвертация не дошла до конца исходника */
uint8_t utf_blk;
uint8_t utf_pages;
uint8_t utf_phys[MAX_PAGES];
uint32_t utf_size;
uint8_t utf_avail; /* 1 = страницы UTF-8 выделены */
uint8_t g_utf_building; /* 1 пока конвертация не дошла до конца исходника */
/* Приватное состояние конвертера (наружу не торчит — сброс через
* utf_conv_reset(), чтение оригинала через cv_read). */
static uint32_t utf_src = 0; /* позиция чтения ОРИГИНАЛА (utf-8) */
static uint32_t utf_src; /* позиция чтения ОРИГИНАЛА (utf-8) */
static uint8_t cv_page = 0xFF; /* orig-страница в W3 для cv_read (своя от cur_page) */
/* Таблицы ремапа СТАРШИХ байтов [128-255] в CP866. Индексируются (ch-0x80):
@@ -180,9 +180,9 @@ static const uint8_t utf_cyr_to_866[96] = {
/* Поток вывода конвертера: пишем в utf_phys чанками по странице, буфер в
* near-памяти, флаш через один bank_write (не побайтовый swap W3). */
static uint8_t conv_buf[256];
static uint16_t conv_n = 0; /* байт в буфере, ещё не сброшено */
static uint8_t conv_page = 0; /* индекс текущей страницы в utf_phys */
static uint16_t conv_off = 0; /* уже сброшенное смещение в этой странице */
static uint16_t conv_n; /* байт в буфере, ещё не сброшено */
static uint8_t conv_page; /* индекс текущей страницы в utf_phys */
static uint16_t conv_off; /* уже сброшенное смещение в этой странице */
static void conv_flush(void)
{
examples/mdview2/mdview2_index.c
+116 -157
View File
@@ -9,17 +9,25 @@
* позиции чтения. Разделяемые символы и API — в mdview2.h.
*
* Приватно (не торчит в .h): idx_rec_t, cur_rec/cur_seg_off, буфер ячеек
* g_cells, styles_map, idx_get/idx_put и все классификаторы/сканеры.
* g_cells, idx_get/idx_put и все классификаторы/сканеры.
*/
#include <stdint.h>
#include <string.h>
#include <conio.h> /* COLOR()/COLOR_* для ATTR_* в styles_map */
#include <conio.h> /* COLOR()/COLOR_* для ATTR_* в сканерах */
#include <sprinter.h>
#include <sprinter_mem.h> /* bank_read/bank_write (idx_get/idx_put) */
#include "mdview2.h"
static uint8_t emph_to_attr(uint8_t emph, uint8_t base_attr); /* forward (нужна в inline-сканере) */
static uint8_t is_hr_raw(uint32_t p); /* forward (нужна в classify_line) */
/* Начало следующей физической строки (байт после '\n', либо file_size). */
static uint32_t next_line(uint32_t p)
{
p = row_end(p);
return (p < file_size) ? p + 1 : p;
}
typedef struct idx_rec_s {
uint32_t off; /* смещение первого байта исходного текста для сегмента */
@@ -31,7 +39,7 @@ typedef struct idx_rec_s {
#define INDEX_REC_SIZE 8u
static uint32_t cur_seg_off = 0; /* смещение последнего emit_seg (кэш в near-памяти) */
static uint32_t cur_seg_off; /* смещение последнего emit_seg (кэш в near-памяти) */
static idx_rec_t cur_rec; /* near-копия последней записанной idx-записи */
/* Для проверки границ выделения считаем пробел/таб/конец строки/0 пробельными. */
@@ -90,12 +98,23 @@ uint32_t seg_off(uint16_t idx)
return r.off;
}
/* Установка флагов всегда идёт в последний emit_seg (n_lines-1).
/* Последняя строка индекса с исходным offset <= off — обратный перевод
* байт-позиции в MD-строку (позиционирование при F2/F8). Оффсеты сегментов
* монотонны, поэтому бинарный поиск (~15 bank-чтений). */
uint16_t line_at_off(uint32_t off)
{
uint16_t lo = 0, hi = n_lines;
while (lo < hi) {
uint16_t mid = (uint16_t)((lo + hi) >> 1);
if (seg_off(mid) <= off) lo = (uint16_t)(mid + 1);
else hi = mid;
}
return (lo > 0) ? (uint16_t)(lo - 1) : 0;
}
/* Установка флагов (маска IF_*) всегда идёт в последний emit_seg (n_lines-1).
* Используется near-копия cur_rec, чтобы не делать обратное чтение из банка. */
static void set_nowrap_cur(void) { cur_rec.flags |= IF_NOWRAP; idx_put((uint16_t)(n_lines - 1), &cur_rec); }
static void set_blank_cur(void) { cur_rec.flags |= IF_BLANK; idx_put((uint16_t)(n_lines - 1), &cur_rec); }
static void set_code_cur(void) { cur_rec.flags |= IF_CODE; idx_put((uint16_t)(n_lines - 1), &cur_rec); }
static void set_hscroll_cur(void){ cur_rec.flags |= IF_HSCROLL; idx_put((uint16_t)(n_lines - 1), &cur_rec); }
static void set_cur_flags(uint8_t f) { cur_rec.flags |= f; idx_put((uint16_t)(n_lines - 1), &cur_rec); }
/* ==================================================================
* Индексация строк
@@ -103,12 +122,6 @@ static void set_hscroll_cur(void){ cur_rec.flags |= IF_HSCROLL; idx_put((uint16_
/* INIT_STYLE_* — в mdview2.h (общие с модулем таблиц). */
/* Таблица сопоставления init-style -> атрибут.
* Порядок должен совпадать с INIT_STYLE_* / EM_* ниже. */
static const uint8_t styles_map[] = {
ATTR_TEXT, ATTR_TEXT_BOLD, ATTR_TEXT_ITALIC, ATTR_TEXT_UNDERSORE, ATTR_TEXT_CODE, ATTR_TEXT_STRIKE
};
/* Тип строки, который возвращает classify_line(). */
#define LK_PLAIN 0
#define LK_H1 1
@@ -157,22 +170,7 @@ static uint8_t classify_line(uint32_t p_start, uint32_t *out_content)
/* Горизонтальный разделитель.
* Проверяется до списков, чтобы `- - -` не стало маркером списка. */
if (c0 == '-' || c0 == '*' || c0 == '_') {
char marker = 0;
uint8_t count = 0;
uint8_t ok = 1;
uint32_t p = p_start;
while (p < file_size) {
char ch = fb(p++);
if (ch == '\n' || ch == '\r') break;
if (ch == ' ' || ch == '\t') continue;
if (ch != '-' && ch != '*' && ch != '_') { ok = 0; break; }
if (marker == 0) marker = ch;
else if (ch != marker) { ok = 0; break; }
count++;
}
if (ok && count >= 3) return LK_HR;
}
if (is_hr_raw(p_start)) return LK_HR;
/* Для списков/цитат дополнительно допускаем ведущие пробелы
* (базовая поддержка вложенности). */
@@ -237,15 +235,15 @@ static uint8_t marker_visible_col(uint8_t kind, uint32_t p_start, uint32_t conte
* g_ncells_at_space — снимок длины на последнем пробеле для усечения буфера
* при переносе строки (отбрасываем уехавшее за границу слово). */
static uint8_t g_cells[MAX_CACHE_LINE_LEN * 2];
uint8_t g_ncells = 0; /* ячеек в текущем сегменте (общий с таблицами) */
static uint8_t g_ncells_at_space = 0; /* снимок g_ncells на последнем пробеле (для усечения при переносе) */
static uint8_t g_skip_flush = 0; /* следующий emit_seg пропустит lag-флаш (pending уже зафлашен вручную, напр. перед таблицей) */
uint8_t g_ncells; /* ячеек в текущем сегменте (общий с таблицами) */
static uint8_t g_ncells_at_space; /* снимок g_ncells на последнем пробеле (для усечения при переносе) */
static uint8_t g_skip_flush; /* следующий emit_seg пропустит lag-флаш (pending уже зафлашен вручную, напр. перед таблицей) */
/* Обрыв индексации: причина (0 / TRUNC_CONTENT / TRUNC_LINES) и строка, на
* которой упёрлись. Выставляются ОДИН раз (первая причина побеждает); по ним
* index_lines() в конце пишет строку-сообщение (IF_TRUNC_MSG, рисуется вживую). */
static uint8_t g_trunc_cause = 0;
static uint16_t g_trunc_line = 0;
static uint8_t g_trunc_cause;
static uint16_t g_trunc_line;
/* Пишет одну (char,attr)-ячейку в g_cells, молча игнорируя переполнение
* MAX_CACHE_LINE_LEN. Оставлена ФУНКЦИЕЙ намеренно: инлайн в сильно
@@ -383,17 +381,18 @@ static uint8_t is_table_raw(uint32_t p)
* маркер обработан (вызывающий делает continue), 0 — символ обычный (пробел/
* текст), его кладёт сам вызывающий (и проверяет перенос). Меняет
* *pq/*pls/*pseg/*pprev. attr берётся как emph_to_attr(line_style, base) —
* для join base=ATTR_TEXT, что тождественно styles_map[line_style]. */
* для join base=ATTR_TEXT (атрибут «обычного» текста). */
static uint8_t inline_marker(uint32_t *pq, uint32_t bound, uint8_t *pls,
uint8_t *pseg, char *pprev, uint8_t base)
{
uint32_t q = *pq;
uint8_t ls = *pls;
char ch = fb(q);
uint8_t at = emph_to_attr(ls, base); /* атрибут литералов текущего стиля */
if (ls != INIT_STYLE_CODE && ch == '\\' && (q + 1) < bound && is_escapable(fb(q + 1))) {
char nb = fb(q + 1);
gc_put(nb, emph_to_attr(ls, base));
gc_put(nb, at);
*pseg += 1; *pq = q + 2; *pprev = nb; return 1;
}
if (ls != INIT_STYLE_CODE && ch == '[' && (q + 2) < bound && fb(q + 2) == ']') {
@@ -403,7 +402,7 @@ static uint8_t inline_marker(uint32_t *pq, uint32_t bound, uint8_t *pls,
if (ch == '`') {
if (ls == INIT_STYLE_PLAIN) { *pls = INIT_STYLE_CODE; *pq = q + 1; return 1; }
if (ls == INIT_STYLE_CODE) { *pls = INIT_STYLE_PLAIN; *pq = q + 1; return 1; }
gc_put('`', emph_to_attr(ls, base)); *pseg += 1; *pq = q + 1; *pprev = '`'; return 1;
gc_put('`', at); *pseg += 1; *pq = q + 1; *pprev = '`'; return 1;
}
if (ch == '*' && (q + 1) < bound && fb(q + 1) == '*') {
char nx = ((q + 2) < bound) ? fb(q + 2) : '\n';
@@ -411,7 +410,7 @@ static uint8_t inline_marker(uint32_t *pq, uint32_t bound, uint8_t *pls,
if (ls == INIT_STYLE_PLAIN && ws_or_eol(*pprev)) { *pls = INIT_STYLE_BOLD; *pq = q + 2; return 1; }
if (ls == INIT_STYLE_BOLD && ws_or_eol_or_delim(nx)) { *pls = INIT_STYLE_PLAIN; *pq = q + 2; return 1; }
}
gc_put('*', emph_to_attr(ls, base)); gc_put('*', emph_to_attr(ls, base));
gc_put('*', at); gc_put('*', at);
*pseg += 2; *pq = q + 2; *pprev = '*'; return 1;
}
if (ch == '~' && (q + 1) < bound && fb(q + 1) == '~') {
@@ -420,7 +419,7 @@ static uint8_t inline_marker(uint32_t *pq, uint32_t bound, uint8_t *pls,
if (ls == INIT_STYLE_PLAIN && ws_or_eol(*pprev)) { *pls = INIT_STYLE_STRIKE; *pq = q + 2; return 1; }
if (ls == INIT_STYLE_STRIKE && ws_or_eol_or_delim(nx)) { *pls = INIT_STYLE_PLAIN; *pq = q + 2; return 1; }
}
gc_put('~', emph_to_attr(ls, base)); gc_put('~', emph_to_attr(ls, base));
gc_put('~', at); gc_put('~', at);
*pseg += 2; *pq = q + 2; *pprev = '~'; return 1;
}
if (ch == '*' || ch == '_') {
@@ -430,99 +429,57 @@ static uint8_t inline_marker(uint32_t *pq, uint32_t bound, uint8_t *pls,
if (ls == INIT_STYLE_PLAIN && ws_or_eol(*pprev)) { *pls = ns; *pq = q + 1; return 1; }
if (ls != INIT_STYLE_PLAIN && ws_or_eol_or_delim(nx)) { *pls = INIT_STYLE_PLAIN; *pq = q + 1; return 1; }
}
gc_put(ch, emph_to_attr(ls, base)); *pseg += 1; *pq = q + 1; *pprev = ch; return 1;
gc_put(ch, at); *pseg += 1; *pq = q + 1; *pprev = ch; return 1;
}
if (ch == '\t') {
uint8_t old_sc = *pseg;
uint8_t tgt_full = (uint8_t)((old_sc & (uint8_t)~(TAB_STOP - 1)) + TAB_STOP);
uint8_t tgt = tgt_full; if (tgt > SCREEN_W) tgt = SCREEN_W;
gc_fill(' ', emph_to_attr(ls, base), (uint8_t)(tgt_full - old_sc));
gc_fill(' ', at, (uint8_t)(tgt_full - old_sc));
*pseg = tgt; *pq = q + 1; *pprev = ' '; return 1;
}
return 0; /* пробел или обычный символ — обрабатывает вызывающий */
}
/* Общий сканер inline-форматирования и переносов.
* Идёт от q до q_end, учитывает стартовую колонку col и при необходимости
* эмитит continuation-сегменты. Возвращает итоговый line_style. */
uint8_t inline_scan(uint32_t q, uint32_t q_end, uint8_t col,
uint8_t ckind, uint8_t line_style, uint8_t base_attr,
uint8_t nowrap)
{
uint32_t last_space = 0xFFFFFFFFu;
uint8_t last_space_style = line_style; /* снимок line_style на момент last_space */
char prev_ch = ' ';
uint8_t seg_col = col;
/* base — атрибут «обычного» текста сегмента. Для заголовка первый сегмент
* имеет title-attr, а continuation-сегменты render рисует как PLAIN
* (ATTR_TEXT, kind=LK_PLAIN при cont) — переключаем base после 1-го переноса. */
uint8_t base = base_attr;
while (q < q_end && n_lines < max_lines) {
char ch = fb(q);
if (ch == '\n') {
/* Жёсткий перенос (уже проверен снаружи) или конец потока. */
q++;
emit_seg(q, line_style, ckind, (ckind == CK_LIST || ckind == CK_QUOTE) ? 1 : 0);
base = ATTR_TEXT;
last_space = 0xFFFFFFFFu; prev_ch = ' '; seg_col = col;
continue;
}
/* Inline-маркеры (\X [x] ` ** ~~ * _ \t) — общий разбор. */
if (inline_marker(&q, q_end, &line_style, &seg_col, &prev_ch, base)) continue;
if (ch == ' ') {
gc_put(' ', emph_to_attr(line_style, base));
last_space = q + 1;
last_space_style = line_style;
g_ncells_at_space = g_ncells;
seg_col++; q++; prev_ch = ' ';
} else {
gc_put(ch, emph_to_attr(line_style, base));
seg_col++; q++; prev_ch = ch;
}
if (!nowrap && seg_col >= SCREEN_W) {
uint8_t use_ls = (uint8_t)(last_space != 0xFFFFFFFFu && last_space > cur_seg_off);
uint32_t wrap_at = use_ls ? last_space : q;
if (wrap_at >= q_end || wrap_at == cur_seg_off) break;
uint8_t wrap_style = use_ls ? last_space_style : line_style;
if (use_ls) g_ncells = g_ncells_at_space;
emit_seg(wrap_at, wrap_style, ckind, 1);
base = ATTR_TEXT; /* continuation заголовка → PLAIN */
seg_col = col; last_space = 0xFFFFFFFFu; prev_ch = ' '; q = wrap_at;
line_style = wrap_style;
}
}
return line_style;
}
#define JOIN_MODE_NONE 0u
#define JOIN_MODE_LIST 1u
#define JOIN_MODE_QUOTE 2u
#define JOIN_MODE_PLAIN 3u
/* Общий потоковый сканер для index_lines().
* Убирает дублирование между ветками list/quote/plain:
* - mode задаёт правила обработки перевода строки,
* - остальная inline-логика (emphasis/таб/перенос) едина.
* Возвращает позицию q, на которой сканер остановился, и обновляет стиль. */
static uint32_t scan_join_stream(uint32_t q, uint32_t para_start, uint8_t col,
uint8_t ckind, uint8_t *io_line_style, uint8_t mode)
/* ================== Единый сканер сегмента ================================
* Общий цикл inline-форматирования, переносов и (в join-режимах) склейки
* физических строк — бывшие inline_scan + scan_join_stream. mode:
* JOIN_MODE_NONE — сканировать РОВНО [q, bound) без склейки; '\n' в
* диапазоне не ожидается (вызывающие дают строку/ячейку до EOL);
* активны base_attr (title-attr заголовка) и nowrap (замер таблиц);
* ckind всегда CK_OTHER (continuation-префикс не эмитится).
* JOIN_MODE_LIST/QUOTE/PLAIN — правила '\n'-склейки; bound == file_size,
* base_attr == ATTR_TEXT (emph_to_attr(ls, ATTR_TEXT) тождественно
* бывшему styles_map[ls]), nowrap == 0.
* Возвращает позицию останова; итоговый стиль — через *io_line_style. */
static uint32_t scan_stream(uint32_t q, uint32_t bound, uint32_t para_start,
uint8_t col, uint8_t ckind, uint8_t *io_line_style,
uint8_t base_attr, uint8_t nowrap, uint8_t mode)
{
uint32_t last_space = 0xFFFFFFFFu;
uint8_t last_space_style = *io_line_style; /* снимок line_style на момент last_space */
char prev_ch = ' ';
uint8_t seg_col = col;
uint8_t line_style = *io_line_style;
/* base — атрибут «обычного» текста сегмента. Для заголовка первый сегмент
* имеет title-attr, а continuation-сегменты render рисует как PLAIN —
* переключаем base после 1-го переноса (в join-режимах base == ATTR_TEXT
* и присваивание ничего не меняет). */
uint8_t base = base_attr;
while (q < file_size && n_lines < max_lines) {
while (q < bound && n_lines < max_lines) {
char ch = fb(q);
uint8_t soft_break = 0;
if (ch == '\n') {
uint32_t next = q + 1;
if (next >= file_size) break;
if (mode == JOIN_MODE_NONE) break; /* NONE: '\n' в [q,bound) не ожидается */
if (next >= bound) break;
if (mode == JOIN_MODE_LIST) {
if (is_line_blank(next)) break;
@@ -538,7 +495,7 @@ static uint32_t scan_join_stream(uint32_t q, uint32_t para_start, uint8_t col,
break;
}
}
while (next < file_size) {
while (next < bound) {
char ws = fb(next);
if (ws == ' ' || ws == '\t') next++;
else break;
@@ -556,8 +513,7 @@ static uint32_t scan_join_stream(uint32_t q, uint32_t para_start, uint8_t col,
if (next_kind != LK_QUOTE) break;
{
uint32_t next_line_end = next_content;
while (next_line_end < file_size && fb(next_line_end) != '\n') next_line_end++;
uint32_t next_line_end = row_end(next_content);
{
uint8_t empty_quote = 1;
@@ -622,7 +578,7 @@ static uint32_t scan_join_stream(uint32_t q, uint32_t para_start, uint8_t col,
q++;
/* как render: пропускаем ведущие пробелы/табы строки-продолжения,
* склейка даёт РОВНО один пробел (иначе merge эмитит отступ как лишние ячейки) */
while (q < file_size && (fb(q) == ' ' || fb(q) == '\t')) q++;
while (q < bound && (fb(q) == ' ' || fb(q) == '\t')) q++;
soft_break = 1;
ch = ' ';
}
@@ -631,39 +587,39 @@ static uint32_t scan_join_stream(uint32_t q, uint32_t para_start, uint8_t col,
/* Inline-маркеры (\X [x] ` ** ~~ * _ \t) — общий разбор; при
* soft_break ch==' ' (синтетический пробел склейки) — маркеры
* пропускаем, его кладёт ветка пробела ниже. */
if (!soft_break && inline_marker(&q, file_size, &line_style, &seg_col, &prev_ch, ATTR_TEXT))
if (!soft_break && inline_marker(&q, bound, &line_style, &seg_col, &prev_ch, base))
continue;
if (ch == ' ') {
gc_put(' ', styles_map[line_style]);
gc_put(' ', emph_to_attr(line_style, base));
if (soft_break) {
last_space = q;
last_space_style = line_style;
seg_col++;
last_space = q; /* синтетический пробел склейки */
} else {
last_space = q + 1;
last_space_style = line_style;
seg_col++;
q++;
}
g_ncells_at_space = g_ncells; /* снимок для усечения */
last_space_style = line_style;
g_ncells_at_space = g_ncells; /* снимок для усечения */
seg_col++;
prev_ch = ' ';
} else {
gc_put(ch, styles_map[line_style]);
gc_put(ch, emph_to_attr(line_style, base));
seg_col++;
q++; /* soft_break здесь всегда 0 (ch!=' ') */
q++; /* soft_break здесь всегда 0 (ch != ' ') */
prev_ch = ch;
}
if (seg_col >= SCREEN_W) {
if (!nowrap && seg_col >= SCREEN_W) {
uint8_t use_ls = (uint8_t)(last_space != 0xFFFFFFFFu && last_space > cur_seg_off);
uint32_t wrap_at = use_ls ? last_space : q;
if (wrap_at >= file_size || wrap_at == cur_seg_off) break;
if (wrap_at >= bound || wrap_at == cur_seg_off) break;
uint8_t wrap_style = use_ls ? last_space_style : line_style;
if (use_ls) g_ncells = g_ncells_at_space; /* усечь до пробела */
emit_seg(wrap_at, wrap_style, ckind, 1);
base = ATTR_TEXT; /* continuation заголовка → PLAIN (в join base и так ATTR_TEXT) */
/* Префикс continuation-сегмента: список и отступленный абзац (#4) —
* col пробелов выравнивания; цитата — отступ + маркер 0xB3 + пробел.
* Для обычного абзаца без отступа col==0 → префикса нет. */
* Для обычного абзаца без отступа col==0 → префикса нет; CK_OTHER
* (заголовки/таблицы, NONE-режим) — префикса нет. */
if (ckind == CK_LIST || ckind == CK_PLAIN) {
gc_fill(' ', ATTR_TEXT, col);
} else if (ckind == CK_QUOTE) {
@@ -692,6 +648,25 @@ static uint32_t scan_join_stream(uint32_t q, uint32_t para_start, uint8_t col,
return q;
}
/* Тонкая обёртка прежнего API: скан ровно [q, q_end) без склейки строк.
* Вызывается для заголовков и ячеек таблиц (всегда CK_OTHER, col=0). */
uint8_t inline_scan(uint32_t q, uint32_t q_end, uint8_t col,
uint8_t ckind, uint8_t line_style, uint8_t base_attr,
uint8_t nowrap)
{
(void)scan_stream(q, q_end, q, col, ckind, &line_style, base_attr, nowrap,
JOIN_MODE_NONE);
return line_style;
}
/* Потоковый сканер для index_lines(): mode задаёт правила '\n'-склейки. */
static uint32_t scan_join_stream(uint32_t q, uint32_t para_start, uint8_t col,
uint8_t ckind, uint8_t *io_line_style, uint8_t mode)
{
return scan_stream(q, file_size, para_start, col, ckind, io_line_style,
ATTR_TEXT, 0, mode);
}
/* Отрисовка таблиц (row_end/table_*) — в модуле mdview2_table.c. */
/* Строит индекс сегментов рендера по загруженному файлу. */
@@ -722,12 +697,11 @@ void index_lines(void)
/* Пустая строка — разделитель параграфов.
* В индекс добавляем не более одной пустой экранной строки подряд. */
if (is_line_blank(p)) {
while (p < file_size && fb(p) != '\n') p++;
if (p < file_size) p++;
p = next_line(p);
/* Серия пустых строк схлопывается в одну визуальную строку. */
if (n_lines == 0 || !(cur_rec.flags & IF_BLANK)) {
emit_seg(p, INIT_STYLE_PLAIN, CK_PLAIN, 0);
set_blank_cur();
set_cur_flags(IF_BLANK);
}
continue;
}
@@ -736,16 +710,13 @@ void index_lines(void)
if (is_fence_raw(p)) {
in_block = !in_block;
emit_seg(p, INIT_STYLE_PLAIN, CK_OTHER, 0);
set_nowrap_cur();
while (p < file_size && fb(p) != '\n') p++;
if (p < file_size) p++;
set_cur_flags(IF_NOWRAP);
p = next_line(p);
continue;
}
if (in_block) {
emit_seg(p, INIT_STYLE_PLAIN, CK_OTHER, 0);
set_nowrap_cur();
set_code_cur();
set_hscroll_cur(); /* код скроллится целым блоком */
set_cur_flags(IF_NOWRAP | IF_CODE | IF_HSCROLL); /* код скроллится целым блоком */
{
uint8_t ccx = 0;
uint32_t pp = p;
@@ -763,18 +734,16 @@ void index_lines(void)
pp++;
}
}
while (p < file_size && fb(p) != '\n') p++;
if (p < file_size) p++;
p = next_line(p);
continue;
}
/* ---- горизонтальный разделитель ---- */
if (is_hr_raw(p)) {
emit_seg(p, INIT_STYLE_PLAIN, CK_OTHER, 0);
set_nowrap_cur();
set_cur_flags(IF_NOWRAP);
gc_fill(0xC4, ATTR_HR, SCREEN_W);
while (p < file_size && fb(p) != '\n') p++;
if (p < file_size) p++;
p = next_line(p);
continue;
}
@@ -814,21 +783,21 @@ void index_lines(void)
/* Проход 2: верхняя рамка → строки/разделитель → нижняя рамка. */
emit_seg(p, INIT_STYLE_PLAIN, CK_OTHER, 0);
set_nowrap_cur(); set_hscroll_cur();
set_cur_flags(IF_NOWRAP | IF_HSCROLL);
table_border(widths, ncols, TBL_TL, TBL_TM, TBL_TR);
r = p;
while (r < tbl_end) {
uint32_t le = row_end(r);
emit_seg(r, INIT_STYLE_PLAIN, CK_OTHER, 0);
set_nowrap_cur(); set_hscroll_cur();
set_cur_flags(IF_NOWRAP | IF_HSCROLL);
if (table_is_sep_row(r, le)) table_border(widths, ncols, TBL_ML, TBL_MM, TBL_MR);
else table_data_row(r, le, widths, ncols);
r = (le < file_size) ? le + 1 : le;
}
emit_seg(tbl_end, INIT_STYLE_PLAIN, CK_OTHER, 0);
set_nowrap_cur(); set_hscroll_cur();
set_cur_flags(IF_NOWRAP | IF_HSCROLL);
table_border(widths, ncols, TBL_BL, TBL_BM, TBL_BR);
p = tbl_end;
@@ -849,11 +818,9 @@ void index_lines(void)
default: hbase = ATTR_TEXT_TITLE4; break;
}
emit_seg(p, INIT_STYLE_PLAIN, CK_OTHER, 0);
uint32_t line_end = content_off;
while (line_end < file_size && fb(line_end) != '\n') line_end++;
uint32_t line_end = row_end(content_off);
(void)inline_scan(content_off, line_end, 0, CK_OTHER, INIT_STYLE_PLAIN, hbase, 0);
while (p < file_size && fb(p) != '\n') p++;
if (p < file_size) p++;
p = next_line(p);
continue;
}
@@ -882,10 +849,7 @@ void index_lines(void)
q = scan_join_stream(q, p, col, CK_LIST, &line_style, JOIN_MODE_LIST);
/* Переходим к началу следующей физической строки после пункта. */
if (q < file_size) {
while (q < file_size && fb(q) != '\n') q++;
if (q < file_size) q++;
}
q = next_line(q);
/* Одна пустая строка между соседними маркерами списка подавляется.
* Две и более пустых строки оставляют видимый разделитель. */
@@ -893,8 +857,7 @@ void index_lines(void)
uint32_t t = q;
uint8_t blanks = 0;
while (t < file_size && is_line_blank(t)) {
while (t < file_size && fb(t) != '\n') t++;
if (t < file_size) t++;
t = next_line(t);
blanks++;
// if (blanks >= 2) break;
}
@@ -934,9 +897,7 @@ void index_lines(void)
}
q = scan_join_stream(q, p, col, CK_QUOTE, &line_style, JOIN_MODE_QUOTE);
while (q < file_size && fb(q) != '\n') q++;
if (q < file_size) q++;
p = q;
p = next_line(q);
continue;
}
@@ -962,9 +923,7 @@ void index_lines(void)
/* q стоит на завершающем newline параграфа.
* Переходим на следующую строку, чтобы внешняя петля её
* корректно переклассифицировала. */
while (q < file_size && fb(q) != '\n') q++;
if (q < file_size) q++;
p = q;
p = next_line(q);
}
}
}
examples/mdview2/mdview2_raw.c
+18 -8
View File
@@ -19,8 +19,8 @@
#if WITH_RAW /* весь модуль — опционален (mdview_conf.h); при 0 пустой объектник */
static uint32_t raw_top = 0; /* байт-offset верхней строки экрана */
static uint16_t raw_hpan = 0; /* гориз. сдвиг (только HSCROLL) */
static uint32_t raw_top; /* байт-offset верхней строки экрана */
static uint16_t raw_hpan; /* гориз. сдвиг (только HSCROLL) */
/* ---- примитивы навигации по физическим строкам / переносам -------- */
@@ -173,17 +173,27 @@ uint8_t calc_raw_pct(void)
/* ---- посев позиции / пересев при смене активного буфера ----------- */
void raw_seed_from(uint16_t md_top_line)
uint32_t raw_pos(void)
{
uint32_t off = seg_off(md_top_line);
if (off > file_size) off = 0;
return raw_top;
}
/* Поставить RAW на начало строки, содержащей байт off (позиционирование
* при F2 MD→RAW и F8-переносе позиции между наборами). */
void raw_reanchor(uint32_t off)
{
if (off > file_size) off = file_size;
raw_top = raw_line_start(off);
raw_hpan = 0;
}
/* Сброс в начало — при смене активного буфера (F8 в/из UTF-8: размеры/offset'ы
* разные, старый raw_top невалиден). Без percent-математики. */
void raw_home(void)
void raw_seed_from(uint16_t md_top_line)
{
raw_reanchor(seg_off(md_top_line));
}
/* Сброс в начало (клавиша Home). */
static void raw_home(void)
{
raw_top = 0;
raw_hpan = 0;
runtime/crt0.s
+31 -15
View File
@@ -27,6 +27,8 @@
.globl s__INITIALIZER
.globl l__INITIALIZER
.globl s__INITIALIZED
.globl s__DATA
.globl l__DATA
.globl s__BSS
.globl l__BSS
@@ -300,10 +302,13 @@ gpn_skip:
;; =========================================================================
;; Runtime data (HOME's _DATA / _BSS)
;; =========================================================================
.area _DATA
.area _CODE
;; Written BEFORE gsinit runs (gsinit zeroes _DATA), so these live in
;; _CODE — RAM on the Sprinter, always mapped.
_estex_startup_ix::
.ds 2
.area _DATA
_argc::
.ds 2
_argv::
@@ -326,32 +331,43 @@ progname_buf:
.ds 128 ; ESTEX APPINFO app_path target
;; =========================================================================
;; gsinit — copy _INITIALIZER -> _INITIALIZED, then zero _BSS.
;; gsinit — zero _DATA + _BSS, then copy _INITIALIZER -> _INITIALIZED.
;; _DATA is zeroed because C guarantees zero-valued statics — this lets
;; code drop explicit `= 0` initializers that burn _INITIALIZER bytes.
;; =========================================================================
.area _GSINIT
gsinit::
ld bc, #l__INITIALIZER
.area _CODE
;; zero_area — fill BC bytes at HL with 0 (BC may be zero).
zero_area:
ld a, b
or a, c
jr Z, gsinit_bss
ld de, #s__INITIALIZED
ld hl, #s__INITIALIZER
ldir
gsinit_bss:
ld bc, #l__BSS
ld a, b
or a, c
jr Z, gsinit_done
ld hl, #s__BSS
ret Z
ld (hl), #0
dec bc
ld a, b
or a, c
jr Z, gsinit_done
ret Z
ld d, h
ld e, l
inc de
ldir
ret
.area _GSINIT
gsinit::
ld hl, #s__DATA
ld bc, #l__DATA
call zero_area
ld hl, #s__BSS
ld bc, #l__BSS
call zero_area
ld bc, #l__INITIALIZER
ld a, b
or a, c
jr Z, gsinit_done
ld de, #s__INITIALIZED
ld hl, #s__INITIALIZER
ldir
gsinit_done:
.area _GSFINAL
runtime/crt0_banked.s
+32 -15
View File
@@ -35,6 +35,8 @@
.globl s__INITIALIZER
.globl l__INITIALIZER
.globl s__INITIALIZED
.globl s__DATA
.globl l__DATA
.globl s__BSS
.globl l__BSS
@@ -398,7 +400,9 @@ gpn_skip:
;; =========================================================================
;; Runtime data
;; =========================================================================
.area _DATA
.area _CODE
;; Written BEFORE gsinit runs (gsinit zeroes _DATA), so these live in
;; _CODE — RAM on the Sprinter, always mapped.
_estex_startup_ix::
.ds 2
_estex_file_handle::
@@ -407,6 +411,8 @@ _estex_block_id::
.ds 1
_bank_block_id::
.ds 1
.area _DATA
_argc::
.ds 2
_argv::
@@ -427,32 +433,43 @@ _w2_self_allocated::
.endif
;; =========================================================================
;; gsinit — same as crt0.s (copy INITIALIZER, zero BSS)
;; gsinit — same as crt0.s (zero _DATA + _BSS, copy INITIALIZER)
;; =========================================================================
.area _GSINIT
gsinit::
ld bc, #l__INITIALIZER
.area _CODE
;; zero_area — fill BC bytes at HL with 0 (BC may be zero).
zero_area:
ld a, b
or a, c
jr Z, gsinit_bss
ld de, #s__INITIALIZED
ld hl, #s__INITIALIZER
ldir
gsinit_bss:
ld bc, #l__BSS
ld a, b
or a, c
jr Z, gsinit_done
ld hl, #s__BSS
ret Z
ld (hl), #0
dec bc
ld a, b
or a, c
jr Z, gsinit_done
ret Z
ld d, h
ld e, l
inc de
ldir
ret
.area _GSINIT
gsinit::
;; --- Zero _DATA + _BSS (C guarantees zero-valued statics) ---
ld hl, #s__DATA
ld bc, #l__DATA
call zero_area
ld hl, #s__BSS
ld bc, #l__BSS
call zero_area
;; --- Copy _INITIALIZER -> _INITIALIZED if non-empty ---
ld bc, #l__INITIALIZER
ld a, b
or a, c
jr Z, gsinit_done
ld de, #s__INITIALIZED
ld hl, #s__INITIALIZER
ldir
gsinit_done:
.area _GSFINAL
runtime/crt0_minimal.s
+30 -17
View File
@@ -20,6 +20,8 @@
.globl s__INITIALIZER
.globl l__INITIALIZER
.globl s__INITIALIZED
.globl s__DATA
.globl l__DATA
.globl s__BSS
.globl l__BSS
@@ -70,40 +72,51 @@ _start::
;; =========================================================================
;; Runtime data
;; =========================================================================
.area _DATA
.area _CODE
;; Written BEFORE gsinit runs (gsinit zeroes _DATA), so these live in
;; _CODE — RAM on the Sprinter, always mapped.
_estex_startup_ix::
.ds 2
;; =========================================================================
;; gsinit — copy _INITIALIZER -> _INITIALIZED, then zero _BSS.
;; gsinit — zero _DATA + _BSS, then copy _INITIALIZER -> _INITIALIZED.
;; SDCC appends per-unit init code between this label and the ret in _GSFINAL.
;; =========================================================================
.area _GSINIT
gsinit::
;; --- Copy _INITIALIZER -> _INITIALIZED if non-empty ---
ld bc, #l__INITIALIZER
.area _CODE
;; zero_area — fill BC bytes at HL with 0 (BC may be zero).
zero_area:
ld a, b
or a, c
jr Z, gsinit_bss
ld de, #s__INITIALIZED
ld hl, #s__INITIALIZER
ldir
gsinit_bss:
;; --- Zero _BSS if non-empty ---
ld bc, #l__BSS
ld a, b
or a, c
jr Z, gsinit_done
ld hl, #s__BSS
ret Z
ld (hl), #0
dec bc
ld a, b
or a, c
jr Z, gsinit_done
ret Z
ld d, h
ld e, l
inc de
ldir
ret
.area _GSINIT
gsinit::
;; --- Zero _DATA + _BSS (C guarantees zero-valued statics) ---
ld hl, #s__DATA
ld bc, #l__DATA
call zero_area
ld hl, #s__BSS
ld bc, #l__BSS
call zero_area
;; --- Copy _INITIALIZER -> _INITIALIZED if non-empty ---
ld bc, #l__INITIALIZER
ld a, b
or a, c
jr Z, gsinit_done
ld de, #s__INITIALIZED
ld hl, #s__INITIALIZER
ldir
gsinit_done:
.area _GSFINAL
runtime/crt0_small.s
+35 -19
View File
@@ -38,6 +38,8 @@
.globl s__INITIALIZER
.globl l__INITIALIZER
.globl s__INITIALIZED
.globl s__DATA
.globl l__DATA
.globl s__BSS
.globl l__BSS
@@ -119,11 +121,11 @@ w2_join:
ld sp, #0xBFFE
.ifdef DEBUG_RT
;; Save the self-alloc flag across gsinit (which clobbers BC/DE/HL and
;; zeroes BSS). SP is in W2 now, push is safe.
;; zeroes _DATA/_BSS). SP is in W2 now, push is safe.
push af
.endif
;; ----- Step 5: save IX prefix in its canonical W2 slot. -------------
;; ----- Step 5: save IX prefix in its canonical slot (_CODE, W1). ----
ld (_estex_startup_ix), ix
;; ----- Step 6: standard gsinit + argv flow (identical to crt0.s). --
@@ -336,10 +338,13 @@ gpn_skip:
;; Runtime data — same layout as crt0.s. Lives in DATA/BSS which the
;; linker places in W2 (--data-loc 0x8000).
;; =========================================================================
.area _DATA
.area _CODE
;; _estex_startup_ix is written BEFORE gsinit runs (gsinit zeroes _DATA),
;; so it lives in _CODE — RAM on the Sprinter, always mapped.
_estex_startup_ix::
.ds 2
.area _DATA
_argc::
.ds 2
_argv::
@@ -362,33 +367,44 @@ _w2_self_allocated::
.endif
;; =========================================================================
;; gsinit — copy _INITIALIZER -> _INITIALIZED, then zero _BSS. Identical
;; to crt0.s; runs AFTER W2 is mapped so writes to _INITIALIZED/_BSS land.
;; gsinit — zero _DATA + _BSS, then copy _INITIALIZER -> _INITIALIZED.
;; Identical to crt0.s; runs AFTER W2 is mapped so the writes land.
;; _DATA is zeroed because C guarantees zero-valued statics — initializing
;; `static uint8_t x;` here lets code drop explicit `= 0` initializers
;; that would otherwise burn _INITIALIZER bytes in the EXE image.
;; =========================================================================
.area _GSINIT
gsinit::
ld bc, #l__INITIALIZER
.area _CODE
;; zero_area — fill BC bytes at HL with 0 (BC may be zero).
zero_area:
ld a, b
or a, c
jr Z, gsinit_bss
ld de, #s__INITIALIZED
ld hl, #s__INITIALIZER
ldir
gsinit_bss:
ld bc, #l__BSS
ld a, b
or a, c
jr Z, gsinit_done
ld hl, #s__BSS
ret Z
ld (hl), #0
dec bc
ld a, b
or a, c
jr Z, gsinit_done
ret Z
ld d, h
ld e, l
inc de
ldir
ret
.area _GSINIT
gsinit::
ld hl, #s__DATA
ld bc, #l__DATA
call zero_area
ld hl, #s__BSS
ld bc, #l__BSS
call zero_area
ld bc, #l__INITIALIZER
ld a, b
or a, c
jr Z, gsinit_done
ld de, #s__INITIALIZED
ld hl, #s__INITIALIZER
ldir
gsinit_done:
.area _GSFINAL