static size_t op_join(Vis *vis, Text *txt, OperatorContext *c) {
size_t pos = text_line_begin(txt, c->range.end), prev_pos;
Mark mark = NULL;
/* if operator and range are both linewise, skip last line break */
if (c->linewise && text_range_is_linewise(txt, &c->range)) {
size_t line_prev = text_line_prev(txt, pos);
size_t line_prev_prev = text_line_prev(txt, line_prev);
if (line_prev_prev >= c->range.start)
pos = line_prev;
}
size_t len = c->arg->s ? strlen(c->arg->s) : 0;
do {
prev_pos = pos;
size_t end = text_line_start(txt, pos);
pos = text_line_prev(txt, end);
if (pos < c->range.start || end <= pos)
break;
text_delete(txt, pos, end - pos);
char prev, next;
if (text_byte_get(txt, pos-1, &prev) && !isspace((unsigned char)prev) &&
text_byte_get(txt, pos, &next) && next != '\r' && next != '\n')
text_insert(txt, pos, c->arg->s, len);
if (!mark)
mark = text_mark_set(txt, pos);
} while (pos != prev_pos);
size_t newpos = text_mark_get(txt, mark);
return newpos != EPOS ? newpos : c->range.start;
}
static size_t op_join(Vis *vis, Text *txt, OperatorContext *c) {
size_t pos = text_line_begin(txt, c->range.end), prev_pos;
Mark mark = NULL;
/* if operator and range are both linewise, skip last line break */
if (c->linewise && text_range_is_linewise(txt, &c->range)) {
size_t line_prev = text_line_prev(txt, pos);
size_t line_prev_prev = text_line_prev(txt, line_prev);
if (line_prev_prev >= c->range.start)
pos = line_prev;
}
do {
prev_pos = pos;
size_t end = text_line_start(txt, pos);
pos = text_char_next(txt, text_line_finish(txt, text_line_prev(txt, end)));
if (pos >= c->range.start && end > pos) {
text_delete(txt, pos, end - pos);
text_insert(txt, pos, " ", 1);
if (!mark)
mark = text_mark_set(txt, pos);
} else {
break;
}
} while (pos != prev_pos);
size_t newpos = text_mark_get(txt, mark);
return newpos != EPOS ? newpos : c->range.start;
}
int main () {
FILE *input;
input = fopen ("input.txt","r");
text_t *text;
text = text_new();
int stringCount, i, format;
char string[L];
fscanf (input, "%i", &stringCount);
for (i = 0; i < stringCount; i++) {
fscanf (input, "%i", &format);
fscanf (input, "%s", string);
text_insert(text, i, string, format);
}
text_delete (text, 3);
printf ("%i\n", text_getCount(text));
text_writeFormat (text, 0);
text_free (text);
fclose (input);
return 0;
}
static void writeFormat_insertTwoSentenceWithFirstAndSecondFormat_CountOnePlaceZeroFormatSecond (void **state) {
text_t *text = text_new();
char sentence1[L], sentence2[L];
strcpy (sentence1, "Zhenya1");
strcpy (sentence2, "Zhenya2");
text_insert (text, 0, sentence1, 1);
text_insert (text, 1, sentence2, 2);
text_t *text1 = text_new();
text1 = text_writeFormat(text, 2);
assert_int_equal (text_getCount(text1), 1);
assert_string_equal (text_getString(text1, 0), sentence2);
assert_int_equal (text_getFormat(text1, 0), 2);
}
static bool cmd_append(Vis *vis, Win *win, Command *cmd, const char *argv[], Cursor *cur, Filerange *range) {
if (!win)
return false;
size_t len = strlen(argv[1]);
bool ret = text_insert(win->file->text, range->end, argv[1], len);
if (ret)
*range = text_range_new(range->end, range->end + len);
return ret;
}
static size_t op_put(Vis *vis, Text *txt, OperatorContext *c) {
size_t pos = c->pos;
bool sel = text_range_size(&c->range) > 0;
bool sel_linewise = sel && text_range_is_linewise(txt, &c->range);
if (sel) {
text_delete_range(txt, &c->range);
pos = c->pos = c->range.start;
}
switch (c->arg->i) {
case VIS_OP_PUT_AFTER:
case VIS_OP_PUT_AFTER_END:
if (c->reg->linewise && !sel_linewise)
pos = text_line_next(txt, pos);
else if (!sel)
pos = text_char_next(txt, pos);
break;
case VIS_OP_PUT_BEFORE:
case VIS_OP_PUT_BEFORE_END:
if (c->reg->linewise)
pos = text_line_begin(txt, pos);
break;
}
size_t len;
const char *data = register_get(vis, c->reg, &len);
for (int i = 0; i < c->count; i++) {
text_insert(txt, pos, data, len);
pos += len;
}
if (c->reg->linewise) {
switch (c->arg->i) {
case VIS_OP_PUT_BEFORE_END:
case VIS_OP_PUT_AFTER_END:
pos = text_line_start(txt, pos);
break;
case VIS_OP_PUT_AFTER:
pos = text_line_start(txt, text_line_next(txt, c->pos));
break;
case VIS_OP_PUT_BEFORE:
pos = text_line_start(txt, c->pos);
break;
}
} else {
switch (c->arg->i) {
case VIS_OP_PUT_AFTER:
case VIS_OP_PUT_BEFORE:
pos = text_char_prev(txt, pos);
break;
}
}
return pos;
}
static bool cmd_change(Vis *vis, Win *win, Command *cmd, const char *argv[], Cursor *cur, Filerange *range) {
if (!win)
return false;
Text *txt = win->file->text;
size_t len = strlen(argv[1]);
bool ret = text_delete(txt, range->start, text_range_size(range)) &&
text_insert(txt, range->start, argv[1], len);
if (ret)
*range = text_range_new(range->start, range->start + len);
return ret;
}
static void vis_args(Vis *vis, int argc, char *argv[]) {
char *cmd = NULL;
bool end_of_options = false;
for (int i = 1; i < argc; i++) {
if (argv[i][0] == '-' && !end_of_options) {
switch (argv[i][1]) {
case '-':
end_of_options = true;
break;
case 'v':
vis_die(vis, "vis %s\n", VERSION);
break;
case '\0':
break;
default:
vis_die(vis, "Unknown command option: %s\n", argv[i]);
break;
}
} else if (argv[i][0] == '+') {
cmd = argv[i] + (argv[i][1] == '/' || argv[i][1] == '?');
} else if (!vis_window_new(vis, argv[i])) {
vis_die(vis, "Can not load `%s': %s\n", argv[i], strerror(errno));
} else if (cmd) {
vis_prompt_cmd(vis, cmd);
cmd = NULL;
}
}
if (!vis->windows && vis->running) {
if (!strcmp(argv[argc-1], "-")) {
if (!vis_window_new(vis, NULL))
vis_die(vis, "Can not create empty buffer\n");
ssize_t len = 0;
char buf[PIPE_BUF];
File *file = vis->win->file;
Text *txt = file->text;
file->is_stdin = true;
while ((len = read(STDIN_FILENO, buf, sizeof buf)) > 0)
text_insert(txt, text_size(txt), buf, len);
if (len == -1)
vis_die(vis, "Can not read from stdin\n");
text_snapshot(txt);
int fd = open("/dev/tty", O_RDONLY);
if (fd == -1)
vis_die(vis, "Can not reopen stdin\n");
dup2(fd, STDIN_FILENO);
close(fd);
} else if (!vis_window_new(vis, NULL)) {
vis_die(vis, "Can not create empty buffer\n");
}
if (cmd)
vis_prompt_cmd(vis, cmd);
}
}
static size_t op_replace(Vis *vis, Text *txt, OperatorContext *c) {
size_t count = 0;
Iterator it = text_iterator_get(txt, c->range.start);
while (it. pos < c->range.end && text_iterator_char_next(&it, NULL))
count++;
op_delete(vis, txt, c);
size_t pos = c->range.start;
for (size_t len = strlen(c->arg->s); count > 0; pos += len, count--)
text_insert(txt, pos, c->arg->s, len);
return pos;
}
static void writeFormat_insertOneSentenceWithFirstFormat_CountZero (void **state) {
text_t *text = text_new();
int place = 0, format = 1;
char sentence[L];
strcpy (sentence, "Zhenya");
text_insert (text, place, sentence, format);
text_t *text1 = text_new();
text1 = text_writeFormat(text,0);
assert_int_equal (text_getCount(text1), 0);
}
static void
do_kill(int len){
if(!kill_roll) text_clear(yank);
kill_roll=2;
if(len < 0){
text_shift(line, len);
len = -len;
text_shift(yank, -yank->off);
} else {
text_shift(yank, yank->buf->c - yank->off);
}
text_insert(yank, line->buf->r + line->off, len);
text_delete(line, len);
}
static void insert_oneSentence_countOnePlaceZeroFormatTwo(void **state)
{
text_t * text = text_new();
int place = 0, format = 2;
char sentence[L];
strcpy (sentence, "Zhenya");
text_insert (text, place, sentence, format);
assert_int_equal (text_getCount(text), 1);
assert_int_equal (text_getFormat(text, place), format);
assert_string_equal (text_getString(text, place), sentence);
text_free(text);
}
static void prompt_hide(Win *win) {
Text *txt = win->file->text;
size_t size = text_size(txt);
/* make sure that file is new line terminated */
char lastchar;
if (size > 1 && text_byte_get(txt, size-1, &lastchar) && lastchar != '\n')
text_insert(txt, size, "\n", 1);
/* remove empty entries */
Filerange line = text_object_line(txt, size);
size_t line_size = text_range_size(&line);
if (line_size <= 2)
text_delete(txt, line.start, line_size);
vis_window_close(win);
}
static void delete_hasOneInertedSentence_CountZero(void **state)
{
text_t * text = text_new();
int place = 0, format = 2;
char sentence[L];
strcpy (sentence, "Zhenya");
text_insert (text, place, sentence, format);
text_delete (text, place);
assert_int_equal(text_getCount(text), 0);
text_free(text);
}
static void writeFormat_insertOneSentenceWithThirdFormat_CountOnePlaceZeroFormatThird (void **state) {
text_t *text = text_new();
int place = 0, format = 3;
char sentence[L];
strcpy (sentence, "Zhenya");
text_insert (text, place, sentence, format);
text_t *text1 = text_new();
text1 = text_writeFormat(text,format);
assert_int_equal (text_getCount(text1), 1);
assert_string_equal (text_getString(text1, place), sentence);
assert_int_equal (text_getFormat(text1, place), format);
}
static size_t op_shift_right(Vis *vis, Text *txt, OperatorContext *c) {
char spaces[9] = " ";
spaces[MIN(vis->tabwidth, LENGTH(spaces) - 1)] = '\0';
const char *tab = vis->expandtab ? spaces : "\t";
size_t tablen = strlen(tab);
size_t pos = text_line_begin(txt, c->range.end), prev_pos;
size_t inserted = 0;
/* if range ends at the begin of a line, skip line break */
if (pos == c->range.end)
pos = text_line_prev(txt, pos);
do {
prev_pos = pos = text_line_begin(txt, pos);
text_insert(txt, pos, tab, tablen);
pos = text_line_prev(txt, pos);
inserted += tablen;
} while (pos >= c->range.start && pos != prev_pos);
return c->pos + inserted;
}
void vis_prompt_show(Vis *vis, const char *title) {
Win *active = vis->win;
Win *prompt = window_new_file(vis, title[0] == ':' ? vis->command_file : vis->search_file,
UI_OPTION_ONELINE);
if (!prompt)
return;
if (vis->mode->visual)
window_selection_save(active);
Text *txt = prompt->file->text;
text_insert(txt, text_size(txt), title, strlen(title));
Cursor *cursor = view_cursors_primary_get(prompt->view);
view_cursors_scroll_to(cursor, text_size(txt));
prompt->parent = active;
prompt->parent_mode = vis->mode;
vis_window_mode_map(prompt, VIS_MODE_NORMAL, true, "<Enter>", &prompt_enter_binding);
vis_window_mode_map(prompt, VIS_MODE_INSERT, true, "<Enter>", &prompt_enter_binding);
vis_window_mode_map(prompt, VIS_MODE_VISUAL, true, "<Enter>", &prompt_enter_binding);
vis_window_mode_map(prompt, VIS_MODE_NORMAL, true, "<Escape>", &prompt_esc_binding);
vis_window_mode_map(prompt, VIS_MODE_INSERT, true, "<Up>", &prompt_up_binding);
vis_window_mode_map(prompt, VIS_MODE_INSERT, true, "<Backspace>", &prompt_backspace_binding);
vis_mode_switch(vis, VIS_MODE_INSERT);
}
static gboolean main_loop (gpointer data)
{
gboolean result;
int i;
/*
* Make sure we turn off the idle handler if the game isn't running. This
* shouldn't happen.
*/
if (!ms_is_running ())
{
g_warning ("main_loop was called while the game wasn't running");
mainIdleHandler = 0;
return FALSE;
}
for (i = 0; i < MAX_INSTRUCTIONS; i++)
{
result = ms_rungame ();
if (!result)
{
text_insert ("\n[End of session]\n");
mainIdleHandler = 0;
ms_flush ();
ms_stop ();
ms_freemem ();
gtk_text_view_scroll_mark_onscreen (
GTK_TEXT_VIEW (Gui.text_view),
gtk_text_buffer_get_insert (Gui.text_buffer));
break;
}
}
return result;
}
static size_t op_case_change(Vis *vis, Text *txt, OperatorContext *c) {
size_t len = text_range_size(&c->range);
char *buf = malloc(len);
if (!buf)
return c->pos;
len = text_bytes_get(txt, c->range.start, len, buf);
size_t rem = len;
for (char *cur = buf; rem > 0; cur++, rem--) {
int ch = (unsigned char)*cur;
if (isascii(ch)) {
if (c->arg->i == VIS_OP_CASE_SWAP)
*cur = islower(ch) ? toupper(ch) : tolower(ch);
else if (c->arg->i == VIS_OP_CASE_UPPER)
*cur = toupper(ch);
else
*cur = tolower(ch);
}
}
text_delete(txt, c->range.start, len);
text_insert(txt, c->range.start, buf, len);
free(buf);
return c->pos;
}
void vis_insert(Vis *vis, size_t pos, const char *data, size_t len) {
text_insert(vis->win->file->text, pos, data, len);
windows_invalidate(vis, pos, pos + len);
}
void editor_insert(Editor *ed, size_t pos, const char *c, size_t len) {
text_insert(ed->win->file->text, pos, c, len);
editor_windows_invalidate(ed, pos, pos + len);
}
static void
history_load(){
text_clear(line);
if(hist[hist_cur] != NULL)
text_insert(line, hist[hist_cur]->r, hist[hist_cur]->c);
}
static void
insert_character(Rune c, void* f, int v){
if(0xd800 <= c && c < 0xdc00) return;
text_insert(line, &c, 1);
}
