buffer *alloc_buffer(const buffer * const cur_b) {
buffer *b;
if (b = calloc(1, sizeof(buffer))) {
new_list(&b->line_desc_pool_list);
new_list(&b->line_desc_list);
new_list(&b->char_pool_list);
b->cur_macro = alloc_char_stream(0);
b->opt.tab_size = 8;
b->opt.insert =
b->opt.tabs =
b->opt.shift_tabs =
b->opt.automatch =
b->opt.do_undo =
b->opt.auto_prefs = 1;
b->opt.utf8auto = io_utf8;
b->attr_len = -1;
if (cur_b) {
b->opt.cur_clip = cur_b->opt.cur_clip;
b->opt.tab_size = cur_b->opt.tab_size;
b->opt.tabs = cur_b->opt.tabs;
b->opt.del_tabs = cur_b->opt.del_tabs;
b->opt.shift_tabs = cur_b->opt.shift_tabs;
b->opt.automatch = cur_b->opt.automatch;
b->opt.right_margin = cur_b->opt.right_margin;
b->opt.free_form = cur_b->opt.free_form;
b->opt.hex_code = cur_b->opt.hex_code;
b->opt.word_wrap = cur_b->opt.word_wrap;
b->opt.auto_indent = cur_b->opt.auto_indent;
b->opt.preserve_cr = cur_b->opt.preserve_cr;
b->opt.do_undo = cur_b->opt.do_undo;
b->opt.auto_prefs = cur_b->opt.auto_prefs;
b->opt.no_file_req = cur_b->opt.no_file_req;
b->opt.case_search = cur_b->opt.case_search;
b->opt.binary = cur_b->opt.binary;
b->opt.utf8auto = cur_b->opt.utf8auto;
b->opt.visual_bell = cur_b->opt.visual_bell;
}
/* This leaves out onlyopt.read_only and opt.search_back, which are
implicitly set to 0 by the calloc(). */
return b;
}
return NULL;
}
int save_prefs(buffer * const b, const char * const name) {
if (!b || !name) return ERROR;
assert_buffer(b);
char_stream *cs = alloc_char_stream(PREF_FILE_SIZE_GUESS);
if (cs) {
/* We create a macro by recording an action for each kind of flag. */
if (!saving_defaults && b->syn) record_action(cs, SYNTAX_A, -1, (const char *)b->syn->name, verbose_macros);
record_action(cs, TABSIZE_A, b->opt.tab_size, NULL, verbose_macros);
/* Skip cur_clip */
record_action(cs, RIGHTMARGIN_A, b->opt.right_margin, NULL, verbose_macros);
record_action(cs, FREEFORM_A, b->opt.free_form, NULL, verbose_macros);
record_action(cs, HEXCODE_A, b->opt.hex_code, NULL, verbose_macros);
record_action(cs, WORDWRAP_A, b->opt.word_wrap, NULL, verbose_macros);
record_action(cs, AUTOINDENT_A, b->opt.auto_indent, NULL, verbose_macros);
record_action(cs, PRESERVECR_A, b->opt.preserve_cr, NULL, verbose_macros);
record_action(cs, INSERT_A, b->opt.insert, NULL, verbose_macros);
record_action(cs, DOUNDO_A, b->opt.do_undo, NULL, verbose_macros);
record_action(cs, AUTOPREFS_A, b->opt.auto_prefs, NULL, verbose_macros);
record_action(cs, NOFILEREQ_A, b->opt.no_file_req, NULL, verbose_macros);
/* Skip read_only */
/* Skip search_back */
record_action(cs, CASESEARCH_A, b->opt.case_search, NULL, verbose_macros);
record_action(cs, TABS_A, b->opt.tabs, NULL, verbose_macros);
record_action(cs, DELTABS_A, b->opt.del_tabs, NULL, verbose_macros);
record_action(cs, SHIFTTABS_A, b->opt.shift_tabs, NULL, verbose_macros);
record_action(cs, AUTOMATCHBRACKET_A, b->opt.automatch, NULL, verbose_macros);
record_action(cs, BINARY_A, b->opt.binary, NULL, verbose_macros);
record_action(cs, UTF8AUTO_A, b->opt.utf8auto, NULL, verbose_macros);
record_action(cs, VISUALBELL_A, b->opt.visual_bell, NULL, verbose_macros);
if (saving_defaults) {
/* We only save the global flags that differ from their defaults. */
/* Make sure these are in sync with the defaults near the top of ne.c. */
#ifndef ALTPAGING
if (req_order) record_action(cs, REQUESTORDER_A, req_order, NULL, verbose_macros);
#else
if (!req_order) record_action(cs, REQUESTORDER_A, req_order, NULL, verbose_macros);
#endif
if (fast_gui) record_action(cs, FASTGUI_A, fast_gui, NULL, verbose_macros);
if (!status_bar) record_action(cs, STATUSBAR_A, status_bar, NULL, verbose_macros);
if (!verbose_macros) record_action(cs, VERBOSEMACROS_A, verbose_macros, NULL, verbose_macros);
saving_defaults = false;
}
const int error = save_stream(cs, name, b->is_CRLF, false);
free_char_stream(cs);
return error;
}
return OUT_OF_MEMORY;
}
char_stream *reset_stream(char_stream * const cs) {
if (!cs) return alloc_char_stream(0);
assert_char_stream(cs);
cs->len = 0;
if (cs->size > 2 * CHAR_STREAM_SIZE_INC) {
cs->size = 0;
free(cs->stream);
cs->stream = NULL;
}
return cs;
}
char_stream *realloc_char_stream(char_stream * const cs, const int64_t size) {
if (!cs) return alloc_char_stream(size);
assert_char_stream(cs);
if (!size) {
free(cs->stream);
cs->stream = NULL;
cs->len = cs->size = 0;
return cs;
}
if (cs->stream = realloc(cs->stream, size * sizeof *cs->stream)) {
cs->size = size;
if (cs->len > size) cs->len = size;
return cs;
}
return NULL;
}
