1 #include "vterm_internal.h" 2 3 #include <stdio.h> 4 #include <string.h> 5 6 #define strneq(a,b,n) (strncmp(a,b,n)==0) 7 8 #include "utf8.h" 9 10 #if defined(DEBUG) && DEBUG > 1 11 # define DEBUG_GLYPH_COMBINE 12 #endif 13 14 #define MOUSE_WANT_CLICK 0x01 15 #define MOUSE_WANT_DRAG 0x02 16 #define MOUSE_WANT_MOVE 0x04 17 18 /* Some convenient wrappers to make callback functions easier */ 19 putglyph(VTermState * state,const uint32_t chars[],int width,VTermPos pos)20 static void putglyph(VTermState *state, const uint32_t chars[], int width, VTermPos pos) 21 { 22 VTermGlyphInfo info = { 23 .chars = chars, 24 .width = width, 25 .protected_cell = state->protected_cell, 26 .dwl = state->lineinfo[pos.row].doublewidth, 27 .dhl = state->lineinfo[pos.row].doubleheight, 28 }; 29 30 if(state->callbacks && state->callbacks->putglyph) 31 if((*state->callbacks->putglyph)(&info, pos, state->cbdata)) 32 return; 33 34 fprintf(stderr, "libvterm: Unhandled putglyph U+%04x at (%d,%d)\n", chars[0], pos.col, pos.row); 35 } 36 updatecursor(VTermState * state,VTermPos * oldpos,int cancel_phantom)37 static void updatecursor(VTermState *state, VTermPos *oldpos, int cancel_phantom) 38 { 39 if(state->pos.col == oldpos->col && state->pos.row == oldpos->row) 40 return; 41 42 if(cancel_phantom) 43 state->at_phantom = 0; 44 45 if(state->callbacks && state->callbacks->movecursor) 46 if((*state->callbacks->movecursor)(state->pos, *oldpos, state->mode.cursor_visible, state->cbdata)) 47 return; 48 } 49 erase(VTermState * state,VTermRect rect,int selective)50 static void erase(VTermState *state, VTermRect rect, int selective) 51 { 52 if(state->callbacks && state->callbacks->erase) 53 if((*state->callbacks->erase)(rect, selective, state->cbdata)) 54 return; 55 } 56 vterm_state_new(VTerm * vt)57 static VTermState *vterm_state_new(VTerm *vt) 58 { 59 VTermState *state = vterm_allocator_malloc(vt, sizeof(VTermState)); 60 61 state->vt = vt; 62 63 state->rows = vt->rows; 64 state->cols = vt->cols; 65 66 vterm_state_newpen(state); 67 68 state->bold_is_highbright = 0; 69 70 return state; 71 } 72 vterm_state_free(VTermState * state)73 INTERNAL void vterm_state_free(VTermState *state) 74 { 75 vterm_allocator_free(state->vt, state->tabstops); 76 vterm_allocator_free(state->vt, state->lineinfo); 77 vterm_allocator_free(state->vt, state->combine_chars); 78 vterm_allocator_free(state->vt, state); 79 } 80 scroll(VTermState * state,VTermRect rect,int downward,int rightward)81 static void scroll(VTermState *state, VTermRect rect, int downward, int rightward) 82 { 83 if(!downward && !rightward) 84 return; 85 86 // Update lineinfo if full line 87 if(rect.start_col == 0 && rect.end_col == state->cols && rightward == 0) { 88 int height = rect.end_row - rect.start_row - abs(downward); 89 90 if(downward > 0) 91 memmove(state->lineinfo + rect.start_row, 92 state->lineinfo + rect.start_row + downward, 93 height * sizeof(state->lineinfo[0])); 94 else 95 memmove(state->lineinfo + rect.start_row - downward, 96 state->lineinfo + rect.start_row, 97 height * sizeof(state->lineinfo[0])); 98 } 99 100 if(state->callbacks && state->callbacks->scrollrect) 101 if((*state->callbacks->scrollrect)(rect, downward, rightward, state->cbdata)) 102 return; 103 104 if(state->callbacks) 105 vterm_scroll_rect(rect, downward, rightward, 106 state->callbacks->moverect, state->callbacks->erase, state->cbdata); 107 } 108 linefeed(VTermState * state)109 static void linefeed(VTermState *state) 110 { 111 if(state->pos.row == SCROLLREGION_BOTTOM(state) - 1) { 112 VTermRect rect = { 113 .start_row = state->scrollregion_top, 114 .end_row = SCROLLREGION_BOTTOM(state), 115 .start_col = SCROLLREGION_LEFT(state), 116 .end_col = SCROLLREGION_RIGHT(state), 117 }; 118 119 scroll(state, rect, 1, 0); 120 } 121 else if(state->pos.row < state->rows-1) 122 state->pos.row++; 123 } 124 grow_combine_buffer(VTermState * state)125 static void grow_combine_buffer(VTermState *state) 126 { 127 size_t new_size = state->combine_chars_size * 2; 128 uint32_t *new_chars = vterm_allocator_malloc(state->vt, new_size * sizeof(new_chars[0])); 129 130 memcpy(new_chars, state->combine_chars, state->combine_chars_size * sizeof(new_chars[0])); 131 132 vterm_allocator_free(state->vt, state->combine_chars); 133 134 state->combine_chars = new_chars; 135 state->combine_chars_size = new_size; 136 } 137 set_col_tabstop(VTermState * state,int col)138 static void set_col_tabstop(VTermState *state, int col) 139 { 140 unsigned char mask = 1 << (col & 7); 141 state->tabstops[col >> 3] |= mask; 142 } 143 clear_col_tabstop(VTermState * state,int col)144 static void clear_col_tabstop(VTermState *state, int col) 145 { 146 unsigned char mask = 1 << (col & 7); 147 state->tabstops[col >> 3] &= ~mask; 148 } 149 is_col_tabstop(VTermState * state,int col)150 static int is_col_tabstop(VTermState *state, int col) 151 { 152 unsigned char mask = 1 << (col & 7); 153 return state->tabstops[col >> 3] & mask; 154 } 155 tab(VTermState * state,int count,int direction)156 static void tab(VTermState *state, int count, int direction) 157 { 158 while(count--) 159 while(state->pos.col >= 0 && state->pos.col < THISROWWIDTH(state)-1) { 160 state->pos.col += direction; 161 162 if(is_col_tabstop(state, state->pos.col)) 163 break; 164 } 165 } 166 167 #define NO_FORCE 0 168 #define FORCE 1 169 170 #define DWL_OFF 0 171 #define DWL_ON 1 172 173 #define DHL_OFF 0 174 #define DHL_TOP 1 175 #define DHL_BOTTOM 2 176 set_lineinfo(VTermState * state,int row,int force,int dwl,int dhl)177 static void set_lineinfo(VTermState *state, int row, int force, int dwl, int dhl) 178 { 179 VTermLineInfo info = state->lineinfo[row]; 180 181 if(dwl == DWL_OFF) 182 info.doublewidth = DWL_OFF; 183 else if(dwl == DWL_ON) 184 info.doublewidth = DWL_ON; 185 // else -1 to ignore 186 187 if(dhl == DHL_OFF) 188 info.doubleheight = DHL_OFF; 189 else if(dhl == DHL_TOP) 190 info.doubleheight = DHL_TOP; 191 else if(dhl == DHL_BOTTOM) 192 info.doubleheight = DHL_BOTTOM; 193 194 if((state->callbacks && 195 state->callbacks->setlineinfo && 196 (*state->callbacks->setlineinfo)(row, &info, state->lineinfo + row, state->cbdata)) 197 || force) 198 state->lineinfo[row] = info; 199 } 200 on_text(const char bytes[],size_t len,void * user)201 static int on_text(const char bytes[], size_t len, void *user) 202 { 203 VTermState *state = user; 204 205 VTermPos oldpos = state->pos; 206 207 // We'll have at most len codepoints 208 uint32_t codepoints[len]; 209 int npoints = 0; 210 size_t eaten = 0; 211 212 VTermEncodingInstance *encoding = 213 state->gsingle_set ? &state->encoding[state->gsingle_set] : 214 !(bytes[eaten] & 0x80) ? &state->encoding[state->gl_set] : 215 state->vt->mode.utf8 ? &state->encoding_utf8 : 216 &state->encoding[state->gr_set]; 217 218 (*encoding->enc->decode)(encoding->enc, encoding->data, 219 codepoints, &npoints, state->gsingle_set ? 1 : len, 220 bytes, &eaten, len); 221 222 if(state->gsingle_set && npoints) 223 state->gsingle_set = 0; 224 225 int i = 0; 226 227 /* This is a combining char. that needs to be merged with the previous 228 * glyph output */ 229 if(vterm_unicode_is_combining(codepoints[i])) { 230 /* See if the cursor has moved since */ 231 if(state->pos.row == state->combine_pos.row && state->pos.col == state->combine_pos.col + state->combine_width) { 232 #ifdef DEBUG_GLYPH_COMBINE 233 int printpos; 234 printf("DEBUG: COMBINING SPLIT GLYPH of chars {"); 235 for(printpos = 0; state->combine_chars[printpos]; printpos++) 236 printf("U+%04x ", state->combine_chars[printpos]); 237 printf("} + {"); 238 #endif 239 240 /* Find where we need to append these combining chars */ 241 int saved_i = 0; 242 while(state->combine_chars[saved_i]) 243 saved_i++; 244 245 /* Add extra ones */ 246 while(i < npoints && vterm_unicode_is_combining(codepoints[i])) { 247 if(saved_i >= state->combine_chars_size) 248 grow_combine_buffer(state); 249 state->combine_chars[saved_i++] = codepoints[i++]; 250 } 251 if(saved_i >= state->combine_chars_size) 252 grow_combine_buffer(state); 253 state->combine_chars[saved_i] = 0; 254 255 #ifdef DEBUG_GLYPH_COMBINE 256 for(; state->combine_chars[printpos]; printpos++) 257 printf("U+%04x ", state->combine_chars[printpos]); 258 printf("}\n"); 259 #endif 260 261 /* Now render it */ 262 putglyph(state, state->combine_chars, state->combine_width, state->combine_pos); 263 } 264 else { 265 fprintf(stderr, "libvterm: TODO: Skip over split char+combining\n"); 266 } 267 } 268 269 for(; i < npoints; i++) { 270 // Try to find combining characters following this 271 int glyph_starts = i; 272 int glyph_ends; 273 for(glyph_ends = i + 1; glyph_ends < npoints; glyph_ends++) 274 if(!vterm_unicode_is_combining(codepoints[glyph_ends])) 275 break; 276 277 int width = 0; 278 279 uint32_t chars[glyph_ends - glyph_starts + 1]; 280 281 for( ; i < glyph_ends; i++) { 282 chars[i - glyph_starts] = codepoints[i]; 283 width += vterm_unicode_width(codepoints[i]); 284 } 285 286 chars[glyph_ends - glyph_starts] = 0; 287 i--; 288 289 #ifdef DEBUG_GLYPH_COMBINE 290 int printpos; 291 printf("DEBUG: COMBINED GLYPH of %d chars {", glyph_ends - glyph_starts); 292 for(printpos = 0; printpos < glyph_ends - glyph_starts; printpos++) 293 printf("U+%04x ", chars[printpos]); 294 printf("}, onscreen width %d\n", width); 295 #endif 296 297 if(state->at_phantom || state->pos.col + width > THISROWWIDTH(state)) { 298 linefeed(state); 299 state->pos.col = 0; 300 state->at_phantom = 0; 301 } 302 303 if(state->mode.insert) { 304 /* TODO: This will be a little inefficient for large bodies of text, as 305 * it'll have to 'ICH' effectively before every glyph. We should scan 306 * ahead and ICH as many times as required 307 */ 308 VTermRect rect = { 309 .start_row = state->pos.row, 310 .end_row = state->pos.row + 1, 311 .start_col = state->pos.col, 312 .end_col = THISROWWIDTH(state), 313 }; 314 scroll(state, rect, 0, -1); 315 } 316 317 putglyph(state, chars, width, state->pos); 318 319 if(i == npoints - 1) { 320 /* End of the buffer. Save the chars in case we have to combine with 321 * more on the next call */ 322 int save_i; 323 for(save_i = 0; chars[save_i]; save_i++) { 324 if(save_i >= state->combine_chars_size) 325 grow_combine_buffer(state); 326 state->combine_chars[save_i] = chars[save_i]; 327 } 328 if(save_i >= state->combine_chars_size) 329 grow_combine_buffer(state); 330 state->combine_chars[save_i] = 0; 331 state->combine_width = width; 332 state->combine_pos = state->pos; 333 } 334 335 if(state->pos.col + width >= THISROWWIDTH(state)) { 336 if(state->mode.autowrap) 337 state->at_phantom = 1; 338 } 339 else { 340 state->pos.col += width; 341 } 342 } 343 344 updatecursor(state, &oldpos, 0); 345 346 return eaten; 347 } 348 on_control(unsigned char control,void * user)349 static int on_control(unsigned char control, void *user) 350 { 351 VTermState *state = user; 352 353 VTermPos oldpos = state->pos; 354 355 switch(control) { 356 case 0x07: // BEL - ECMA-48 8.3.3 357 if(state->callbacks && state->callbacks->bell) 358 (*state->callbacks->bell)(state->cbdata); 359 break; 360 361 case 0x08: // BS - ECMA-48 8.3.5 362 if(state->pos.col > 0) 363 state->pos.col--; 364 break; 365 366 case 0x09: // HT - ECMA-48 8.3.60 367 tab(state, 1, +1); 368 break; 369 370 case 0x0a: // LF - ECMA-48 8.3.74 371 case 0x0b: // VT 372 case 0x0c: // FF 373 linefeed(state); 374 if(state->mode.newline) 375 state->pos.col = 0; 376 break; 377 378 case 0x0d: // CR - ECMA-48 8.3.15 379 state->pos.col = 0; 380 break; 381 382 case 0x0e: // LS1 - ECMA-48 8.3.76 383 state->gl_set = 1; 384 break; 385 386 case 0x0f: // LS0 - ECMA-48 8.3.75 387 state->gl_set = 0; 388 break; 389 390 case 0x84: // IND - DEPRECATED but implemented for completeness 391 linefeed(state); 392 break; 393 394 case 0x85: // NEL - ECMA-48 8.3.86 395 linefeed(state); 396 state->pos.col = 0; 397 break; 398 399 case 0x88: // HTS - ECMA-48 8.3.62 400 set_col_tabstop(state, state->pos.col); 401 break; 402 403 case 0x8d: // RI - ECMA-48 8.3.104 404 if(state->pos.row == state->scrollregion_top) { 405 VTermRect rect = { 406 .start_row = state->scrollregion_top, 407 .end_row = SCROLLREGION_BOTTOM(state), 408 .start_col = SCROLLREGION_LEFT(state), 409 .end_col = SCROLLREGION_RIGHT(state), 410 }; 411 412 scroll(state, rect, -1, 0); 413 } 414 else if(state->pos.row > 0) 415 state->pos.row--; 416 break; 417 418 case 0x8e: // SS2 - ECMA-48 8.3.141 419 state->gsingle_set = 2; 420 break; 421 422 case 0x8f: // SS3 - ECMA-48 8.3.142 423 state->gsingle_set = 3; 424 break; 425 426 default: 427 return 0; 428 } 429 430 updatecursor(state, &oldpos, 1); 431 432 return 1; 433 } 434 output_mouse(VTermState * state,int code,int pressed,int modifiers,int col,int row)435 static void output_mouse(VTermState *state, int code, int pressed, int modifiers, int col, int row) 436 { 437 modifiers <<= 2; 438 439 switch(state->mouse_protocol) { 440 case MOUSE_X10: 441 if(col + 0x21 > 0xff) 442 col = 0xff - 0x21; 443 if(row + 0x21 > 0xff) 444 row = 0xff - 0x21; 445 446 if(!pressed) 447 code = 3; 448 449 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%c%c%c", 450 (code | modifiers) + 0x20, col + 0x21, row + 0x21); 451 break; 452 453 case MOUSE_UTF8: 454 { 455 char utf8[18]; size_t len = 0; 456 457 if(!pressed) 458 code = 3; 459 460 len += fill_utf8((code | modifiers) + 0x20, utf8 + len); 461 len += fill_utf8(col + 0x21, utf8 + len); 462 len += fill_utf8(row + 0x21, utf8 + len); 463 utf8[len] = 0; 464 465 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%s", utf8); 466 } 467 break; 468 469 case MOUSE_SGR: 470 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "<%d;%d;%d%c", 471 code | modifiers, col + 1, row + 1, pressed ? 'M' : 'm'); 472 break; 473 474 case MOUSE_RXVT: 475 if(!pressed) 476 code = 3; 477 478 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%d;%d;%dM", 479 code | modifiers, col + 1, row + 1); 480 break; 481 } 482 } 483 mousefunc(int col,int row,int button,int pressed,int modifiers,void * data)484 static void mousefunc(int col, int row, int button, int pressed, int modifiers, void *data) 485 { 486 VTermState *state = data; 487 488 int old_col = state->mouse_col; 489 int old_row = state->mouse_row; 490 int old_buttons = state->mouse_buttons; 491 492 state->mouse_col = col; 493 state->mouse_row = row; 494 495 if(button > 0 && button <= 3) { 496 if(pressed) 497 state->mouse_buttons |= (1 << (button-1)); 498 else 499 state->mouse_buttons &= ~(1 << (button-1)); 500 } 501 502 modifiers &= 0x7; 503 504 505 /* Most of the time we don't get button releases from 4/5 */ 506 if(state->mouse_buttons != old_buttons || button >= 4) { 507 if(button < 4) { 508 output_mouse(state, button-1, pressed, modifiers, col, row); 509 } 510 else if(button < 6) { 511 output_mouse(state, button-4 + 0x40, pressed, modifiers, col, row); 512 } 513 } 514 else if(col != old_col || row != old_row) { 515 if((state->mouse_flags & MOUSE_WANT_DRAG && state->mouse_buttons) || 516 (state->mouse_flags & MOUSE_WANT_MOVE)) { 517 int button = state->mouse_buttons & 0x01 ? 1 : 518 state->mouse_buttons & 0x02 ? 2 : 519 state->mouse_buttons & 0x04 ? 3 : 4; 520 output_mouse(state, button-1 + 0x20, 1, modifiers, col, row); 521 } 522 } 523 } 524 settermprop_bool(VTermState * state,VTermProp prop,int v)525 static int settermprop_bool(VTermState *state, VTermProp prop, int v) 526 { 527 VTermValue val = { .boolean = v }; 528 return vterm_state_set_termprop(state, prop, &val); 529 } 530 settermprop_int(VTermState * state,VTermProp prop,int v)531 static int settermprop_int(VTermState *state, VTermProp prop, int v) 532 { 533 VTermValue val = { .number = v }; 534 return vterm_state_set_termprop(state, prop, &val); 535 } 536 settermprop_string(VTermState * state,VTermProp prop,const char * str,size_t len)537 static int settermprop_string(VTermState *state, VTermProp prop, const char *str, size_t len) 538 { 539 char strvalue[len+1]; 540 strncpy(strvalue, str, len); 541 strvalue[len] = 0; 542 543 VTermValue val = { .string = strvalue }; 544 return vterm_state_set_termprop(state, prop, &val); 545 } 546 savecursor(VTermState * state,int save)547 static void savecursor(VTermState *state, int save) 548 { 549 if(save) { 550 state->saved.pos = state->pos; 551 state->saved.mode.cursor_visible = state->mode.cursor_visible; 552 state->saved.mode.cursor_blink = state->mode.cursor_blink; 553 state->saved.mode.cursor_shape = state->mode.cursor_shape; 554 555 vterm_state_savepen(state, 1); 556 } 557 else { 558 VTermPos oldpos = state->pos; 559 560 state->pos = state->saved.pos; 561 562 settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, state->saved.mode.cursor_visible); 563 settermprop_bool(state, VTERM_PROP_CURSORBLINK, state->saved.mode.cursor_blink); 564 settermprop_int (state, VTERM_PROP_CURSORSHAPE, state->saved.mode.cursor_shape); 565 566 vterm_state_savepen(state, 0); 567 568 updatecursor(state, &oldpos, 1); 569 } 570 } 571 on_escape(const char * bytes,size_t len,void * user)572 static int on_escape(const char *bytes, size_t len, void *user) 573 { 574 VTermState *state = user; 575 576 /* Easier to decode this from the first byte, even though the final 577 * byte terminates it 578 */ 579 switch(bytes[0]) { 580 case ' ': 581 if(len != 2) 582 return 0; 583 584 switch(bytes[1]) { 585 case 'F': // S7C1T 586 state->vt->mode.ctrl8bit = 0; 587 break; 588 589 case 'G': // S8C1T 590 state->vt->mode.ctrl8bit = 1; 591 break; 592 593 default: 594 return 0; 595 } 596 return 2; 597 598 case '#': 599 if(len != 2) 600 return 0; 601 602 switch(bytes[1]) { 603 case '3': // DECDHL top 604 if(state->mode.leftrightmargin) 605 break; 606 set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_TOP); 607 break; 608 609 case '4': // DECDHL bottom 610 if(state->mode.leftrightmargin) 611 break; 612 set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_BOTTOM); 613 break; 614 615 case '5': // DECSWL 616 if(state->mode.leftrightmargin) 617 break; 618 set_lineinfo(state, state->pos.row, NO_FORCE, DWL_OFF, DHL_OFF); 619 break; 620 621 case '6': // DECDWL 622 if(state->mode.leftrightmargin) 623 break; 624 set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_OFF); 625 break; 626 627 case '8': // DECALN 628 { 629 VTermPos pos; 630 uint32_t E[] = { 'E', 0 }; 631 for(pos.row = 0; pos.row < state->rows; pos.row++) 632 for(pos.col = 0; pos.col < ROWWIDTH(state, pos.row); pos.col++) 633 putglyph(state, E, 1, pos); 634 break; 635 } 636 637 default: 638 return 0; 639 } 640 return 2; 641 642 case '(': case ')': case '*': case '+': // SCS 643 if(len != 2) 644 return 0; 645 646 { 647 int setnum = bytes[0] - 0x28; 648 VTermEncoding *newenc = vterm_lookup_encoding(ENC_SINGLE_94, bytes[1]); 649 650 if(newenc) { 651 state->encoding[setnum].enc = newenc; 652 653 if(newenc->init) 654 (*newenc->init)(newenc, state->encoding[setnum].data); 655 } 656 } 657 658 return 2; 659 660 case '7': // DECSC 661 savecursor(state, 1); 662 return 1; 663 664 case '8': // DECRC 665 savecursor(state, 0); 666 return 1; 667 668 case '<': // Ignored by VT100. Used in VT52 mode to switch up to VT100 669 return 1; 670 671 case '=': // DECKPAM 672 state->mode.keypad = 1; 673 return 1; 674 675 case '>': // DECKPNM 676 state->mode.keypad = 0; 677 return 1; 678 679 case 'c': // RIS - ECMA-48 8.3.105 680 { 681 VTermPos oldpos = state->pos; 682 vterm_state_reset(state, 1); 683 if(state->callbacks && state->callbacks->movecursor) 684 (*state->callbacks->movecursor)(state->pos, oldpos, state->mode.cursor_visible, state->cbdata); 685 return 1; 686 } 687 688 case 'n': // LS2 - ECMA-48 8.3.78 689 state->gl_set = 2; 690 return 1; 691 692 case 'o': // LS3 - ECMA-48 8.3.80 693 state->gl_set = 3; 694 return 1; 695 696 case '~': // LS1R - ECMA-48 8.3.77 697 state->gr_set = 1; 698 return 1; 699 700 case '}': // LS2R - ECMA-48 8.3.79 701 state->gr_set = 2; 702 return 1; 703 704 case '|': // LS3R - ECMA-48 8.3.81 705 state->gr_set = 3; 706 return 1; 707 708 default: 709 return 0; 710 } 711 } 712 set_mode(VTermState * state,int num,int val)713 static void set_mode(VTermState *state, int num, int val) 714 { 715 switch(num) { 716 case 4: // IRM - ECMA-48 7.2.10 717 state->mode.insert = val; 718 break; 719 720 case 20: // LNM - ANSI X3.4-1977 721 state->mode.newline = val; 722 break; 723 724 default: 725 fprintf(stderr, "libvterm: Unknown mode %d\n", num); 726 return; 727 } 728 } 729 set_dec_mode(VTermState * state,int num,int val)730 static void set_dec_mode(VTermState *state, int num, int val) 731 { 732 switch(num) { 733 case 1: 734 state->mode.cursor = val; 735 break; 736 737 case 5: // DECSCNM - screen mode 738 settermprop_bool(state, VTERM_PROP_REVERSE, val); 739 break; 740 741 case 6: // DECOM - origin mode 742 { 743 VTermPos oldpos = state->pos; 744 state->mode.origin = val; 745 state->pos.row = state->mode.origin ? state->scrollregion_top : 0; 746 state->pos.col = state->mode.origin ? SCROLLREGION_LEFT(state) : 0; 747 updatecursor(state, &oldpos, 1); 748 } 749 break; 750 751 case 7: 752 state->mode.autowrap = val; 753 break; 754 755 case 12: 756 settermprop_bool(state, VTERM_PROP_CURSORBLINK, val); 757 break; 758 759 case 25: 760 settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, val); 761 break; 762 763 case 69: // DECVSSM - vertical split screen mode 764 // DECLRMM - left/right margin mode 765 state->mode.leftrightmargin = val; 766 if(val) { 767 // Setting DECVSSM must clear doublewidth/doubleheight state of every line 768 for(int row = 0; row < state->rows; row++) 769 set_lineinfo(state, row, FORCE, DWL_OFF, DHL_OFF); 770 } 771 772 break; 773 774 case 1000: 775 case 1002: 776 case 1003: 777 if(val) { 778 state->mouse_col = 0; 779 state->mouse_row = 0; 780 state->mouse_buttons = 0; 781 782 state->mouse_flags = MOUSE_WANT_CLICK; 783 state->mouse_protocol = MOUSE_X10; 784 785 if(num == 1002) 786 state->mouse_flags |= MOUSE_WANT_DRAG; 787 if(num == 1003) 788 state->mouse_flags |= MOUSE_WANT_MOVE; 789 } 790 else { 791 state->mouse_flags = 0; 792 } 793 794 if(state->callbacks && state->callbacks->setmousefunc) 795 (*state->callbacks->setmousefunc)(val ? mousefunc : NULL, state, state->cbdata); 796 797 break; 798 799 case 1005: 800 state->mouse_protocol = val ? MOUSE_UTF8 : MOUSE_X10; 801 break; 802 803 case 1006: 804 state->mouse_protocol = val ? MOUSE_SGR : MOUSE_X10; 805 break; 806 807 case 1015: 808 state->mouse_protocol = val ? MOUSE_RXVT : MOUSE_X10; 809 break; 810 811 case 1047: 812 settermprop_bool(state, VTERM_PROP_ALTSCREEN, val); 813 break; 814 815 case 1048: 816 savecursor(state, val); 817 break; 818 819 case 1049: 820 settermprop_bool(state, VTERM_PROP_ALTSCREEN, val); 821 savecursor(state, val); 822 break; 823 824 default: 825 fprintf(stderr, "libvterm: Unknown DEC mode %d\n", num); 826 return; 827 } 828 } 829 request_dec_mode(VTermState * state,int num)830 static void request_dec_mode(VTermState *state, int num) 831 { 832 int reply; 833 834 switch(num) { 835 case 1: 836 reply = state->mode.cursor; 837 break; 838 839 case 5: 840 reply = state->mode.screen; 841 break; 842 843 case 6: 844 reply = state->mode.origin; 845 break; 846 847 case 7: 848 reply = state->mode.autowrap; 849 break; 850 851 case 12: 852 reply = state->mode.cursor_blink; 853 break; 854 855 case 25: 856 reply = state->mode.cursor_visible; 857 break; 858 859 case 69: 860 reply = state->mode.leftrightmargin; 861 break; 862 863 case 1000: 864 reply = state->mouse_flags == MOUSE_WANT_CLICK; 865 break; 866 867 case 1002: 868 reply = state->mouse_flags == (MOUSE_WANT_CLICK|MOUSE_WANT_DRAG); 869 break; 870 871 case 1003: 872 reply = state->mouse_flags == (MOUSE_WANT_CLICK|MOUSE_WANT_MOVE); 873 break; 874 875 case 1005: 876 reply = state->mouse_protocol == MOUSE_UTF8; 877 break; 878 879 case 1006: 880 reply = state->mouse_protocol == MOUSE_SGR; 881 break; 882 883 case 1015: 884 reply = state->mouse_protocol == MOUSE_RXVT; 885 break; 886 887 case 1047: 888 reply = state->mode.alt_screen; 889 break; 890 891 default: 892 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?%d;%d$y", num, 0); 893 return; 894 } 895 896 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?%d;%d$y", num, reply ? 1 : 2); 897 } 898 on_csi(const char * leader,const long args[],int argcount,const char * intermed,char command,void * user)899 static int on_csi(const char *leader, const long args[], int argcount, const char *intermed, char command, void *user) 900 { 901 VTermState *state = user; 902 int leader_byte = 0; 903 int intermed_byte = 0; 904 905 if(leader && leader[0]) { 906 if(leader[1]) // longer than 1 char 907 return 0; 908 909 switch(leader[0]) { 910 case '?': 911 case '>': 912 leader_byte = leader[0]; 913 break; 914 default: 915 return 0; 916 } 917 } 918 919 if(intermed && intermed[0]) { 920 if(intermed[1]) // longer than 1 char 921 return 0; 922 923 switch(intermed[0]) { 924 case ' ': 925 case '"': 926 case '$': 927 case '\'': 928 intermed_byte = intermed[0]; 929 break; 930 default: 931 return 0; 932 } 933 } 934 935 VTermPos oldpos = state->pos; 936 937 // Some temporaries for later code 938 int count, val; 939 int row, col; 940 VTermRect rect; 941 int selective; 942 943 #define LBOUND(v,min) if((v) < (min)) (v) = (min) 944 #define UBOUND(v,max) if((v) > (max)) (v) = (max) 945 946 #define LEADER(l,b) ((l << 8) | b) 947 #define INTERMED(i,b) ((i << 16) | b) 948 949 switch(intermed_byte << 16 | leader_byte << 8 | command) { 950 case 0x40: // ICH - ECMA-48 8.3.64 951 count = CSI_ARG_COUNT(args[0]); 952 953 rect.start_row = state->pos.row; 954 rect.end_row = state->pos.row + 1; 955 rect.start_col = state->pos.col; 956 if(state->mode.leftrightmargin) 957 rect.end_col = SCROLLREGION_RIGHT(state); 958 else 959 rect.end_col = THISROWWIDTH(state); 960 961 scroll(state, rect, 0, -count); 962 963 break; 964 965 case 0x41: // CUU - ECMA-48 8.3.22 966 count = CSI_ARG_COUNT(args[0]); 967 state->pos.row -= count; 968 state->at_phantom = 0; 969 break; 970 971 case 0x42: // CUD - ECMA-48 8.3.19 972 count = CSI_ARG_COUNT(args[0]); 973 state->pos.row += count; 974 state->at_phantom = 0; 975 break; 976 977 case 0x43: // CUF - ECMA-48 8.3.20 978 count = CSI_ARG_COUNT(args[0]); 979 state->pos.col += count; 980 state->at_phantom = 0; 981 break; 982 983 case 0x44: // CUB - ECMA-48 8.3.18 984 count = CSI_ARG_COUNT(args[0]); 985 state->pos.col -= count; 986 state->at_phantom = 0; 987 break; 988 989 case 0x45: // CNL - ECMA-48 8.3.12 990 count = CSI_ARG_COUNT(args[0]); 991 state->pos.col = 0; 992 state->pos.row += count; 993 state->at_phantom = 0; 994 break; 995 996 case 0x46: // CPL - ECMA-48 8.3.13 997 count = CSI_ARG_COUNT(args[0]); 998 state->pos.col = 0; 999 state->pos.row -= count; 1000 state->at_phantom = 0; 1001 break; 1002 1003 case 0x47: // CHA - ECMA-48 8.3.9 1004 val = CSI_ARG_OR(args[0], 1); 1005 state->pos.col = val-1; 1006 state->at_phantom = 0; 1007 break; 1008 1009 case 0x48: // CUP - ECMA-48 8.3.21 1010 row = CSI_ARG_OR(args[0], 1); 1011 col = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? 1 : CSI_ARG(args[1]); 1012 // zero-based 1013 state->pos.row = row-1; 1014 state->pos.col = col-1; 1015 if(state->mode.origin) { 1016 state->pos.row += state->scrollregion_top; 1017 state->pos.col += SCROLLREGION_LEFT(state); 1018 } 1019 state->at_phantom = 0; 1020 break; 1021 1022 case 0x49: // CHT - ECMA-48 8.3.10 1023 count = CSI_ARG_COUNT(args[0]); 1024 tab(state, count, +1); 1025 break; 1026 1027 case 0x4a: // ED - ECMA-48 8.3.39 1028 case LEADER('?', 0x4a): // DECSED - Selective Erase in Display 1029 selective = (leader_byte == '?'); 1030 switch(CSI_ARG(args[0])) { 1031 case CSI_ARG_MISSING: 1032 case 0: 1033 rect.start_row = state->pos.row; rect.end_row = state->pos.row + 1; 1034 rect.start_col = state->pos.col; rect.end_col = state->cols; 1035 if(rect.end_col > rect.start_col) 1036 erase(state, rect, selective); 1037 1038 rect.start_row = state->pos.row + 1; rect.end_row = state->rows; 1039 rect.start_col = 0; 1040 for(int row = rect.start_row; row < rect.end_row; row++) 1041 set_lineinfo(state, row, FORCE, DWL_OFF, DHL_OFF); 1042 if(rect.end_row > rect.start_row) 1043 erase(state, rect, selective); 1044 break; 1045 1046 case 1: 1047 rect.start_row = 0; rect.end_row = state->pos.row; 1048 rect.start_col = 0; rect.end_col = state->cols; 1049 for(int row = rect.start_row; row < rect.end_row; row++) 1050 set_lineinfo(state, row, FORCE, DWL_OFF, DHL_OFF); 1051 if(rect.end_col > rect.start_col) 1052 erase(state, rect, selective); 1053 1054 rect.start_row = state->pos.row; rect.end_row = state->pos.row + 1; 1055 rect.end_col = state->pos.col + 1; 1056 if(rect.end_row > rect.start_row) 1057 erase(state, rect, selective); 1058 break; 1059 1060 case 2: 1061 rect.start_row = 0; rect.end_row = state->rows; 1062 rect.start_col = 0; rect.end_col = state->cols; 1063 for(int row = rect.start_row; row < rect.end_row; row++) 1064 set_lineinfo(state, row, FORCE, DWL_OFF, DHL_OFF); 1065 erase(state, rect, selective); 1066 break; 1067 } 1068 break; 1069 1070 case 0x4b: // EL - ECMA-48 8.3.41 1071 case LEADER('?', 0x4b): // DECSEL - Selective Erase in Line 1072 selective = (leader_byte == '?'); 1073 rect.start_row = state->pos.row; 1074 rect.end_row = state->pos.row + 1; 1075 1076 switch(CSI_ARG(args[0])) { 1077 case CSI_ARG_MISSING: 1078 case 0: 1079 rect.start_col = state->pos.col; rect.end_col = THISROWWIDTH(state); break; 1080 case 1: 1081 rect.start_col = 0; rect.end_col = state->pos.col + 1; break; 1082 case 2: 1083 rect.start_col = 0; rect.end_col = THISROWWIDTH(state); break; 1084 default: 1085 return 0; 1086 } 1087 1088 if(rect.end_col > rect.start_col) 1089 erase(state, rect, selective); 1090 1091 break; 1092 1093 case 0x4c: // IL - ECMA-48 8.3.67 1094 count = CSI_ARG_COUNT(args[0]); 1095 1096 rect.start_row = state->pos.row; 1097 rect.end_row = SCROLLREGION_BOTTOM(state); 1098 rect.start_col = SCROLLREGION_LEFT(state); 1099 rect.end_col = SCROLLREGION_RIGHT(state); 1100 1101 scroll(state, rect, -count, 0); 1102 1103 break; 1104 1105 case 0x4d: // DL - ECMA-48 8.3.32 1106 count = CSI_ARG_COUNT(args[0]); 1107 1108 rect.start_row = state->pos.row; 1109 rect.end_row = SCROLLREGION_BOTTOM(state); 1110 rect.start_col = SCROLLREGION_LEFT(state); 1111 rect.end_col = SCROLLREGION_RIGHT(state); 1112 1113 scroll(state, rect, count, 0); 1114 1115 break; 1116 1117 case 0x50: // DCH - ECMA-48 8.3.26 1118 count = CSI_ARG_COUNT(args[0]); 1119 1120 rect.start_row = state->pos.row; 1121 rect.end_row = state->pos.row + 1; 1122 rect.start_col = state->pos.col; 1123 if(state->mode.leftrightmargin) 1124 rect.end_col = SCROLLREGION_RIGHT(state); 1125 else 1126 rect.end_col = THISROWWIDTH(state); 1127 1128 scroll(state, rect, 0, count); 1129 1130 break; 1131 1132 case 0x53: // SU - ECMA-48 8.3.147 1133 count = CSI_ARG_COUNT(args[0]); 1134 1135 rect.start_row = state->scrollregion_top; 1136 rect.end_row = SCROLLREGION_BOTTOM(state); 1137 rect.start_col = SCROLLREGION_LEFT(state); 1138 rect.end_col = SCROLLREGION_RIGHT(state); 1139 1140 scroll(state, rect, count, 0); 1141 1142 break; 1143 1144 case 0x54: // SD - ECMA-48 8.3.113 1145 count = CSI_ARG_COUNT(args[0]); 1146 1147 rect.start_row = state->scrollregion_top; 1148 rect.end_row = SCROLLREGION_BOTTOM(state); 1149 rect.start_col = SCROLLREGION_LEFT(state); 1150 rect.end_col = SCROLLREGION_RIGHT(state); 1151 1152 scroll(state, rect, -count, 0); 1153 1154 break; 1155 1156 case 0x58: // ECH - ECMA-48 8.3.38 1157 count = CSI_ARG_COUNT(args[0]); 1158 1159 rect.start_row = state->pos.row; 1160 rect.end_row = state->pos.row + 1; 1161 rect.start_col = state->pos.col; 1162 rect.end_col = state->pos.col + count; 1163 UBOUND(rect.end_col, THISROWWIDTH(state)); 1164 1165 erase(state, rect, 0); 1166 break; 1167 1168 case 0x5a: // CBT - ECMA-48 8.3.7 1169 count = CSI_ARG_COUNT(args[0]); 1170 tab(state, count, -1); 1171 break; 1172 1173 case 0x60: // HPA - ECMA-48 8.3.57 1174 col = CSI_ARG_OR(args[0], 1); 1175 state->pos.col = col-1; 1176 state->at_phantom = 0; 1177 break; 1178 1179 case 0x61: // HPR - ECMA-48 8.3.59 1180 count = CSI_ARG_COUNT(args[0]); 1181 state->pos.col += count; 1182 state->at_phantom = 0; 1183 break; 1184 1185 case 0x63: // DA - ECMA-48 8.3.24 1186 val = CSI_ARG_OR(args[0], 0); 1187 if(val == 0) 1188 // DEC VT100 response 1189 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?1;2c"); 1190 break; 1191 1192 case LEADER('>', 0x63): // DEC secondary Device Attributes 1193 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, ">%d;%d;%dc", 0, 100, 0); 1194 break; 1195 1196 case 0x64: // VPA - ECMA-48 8.3.158 1197 row = CSI_ARG_OR(args[0], 1); 1198 state->pos.row = row-1; 1199 if(state->mode.origin) 1200 state->pos.row += state->scrollregion_top; 1201 state->at_phantom = 0; 1202 break; 1203 1204 case 0x65: // VPR - ECMA-48 8.3.160 1205 count = CSI_ARG_COUNT(args[0]); 1206 state->pos.row += count; 1207 state->at_phantom = 0; 1208 break; 1209 1210 case 0x66: // HVP - ECMA-48 8.3.63 1211 row = CSI_ARG_OR(args[0], 1); 1212 col = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? 1 : CSI_ARG(args[1]); 1213 // zero-based 1214 state->pos.row = row-1; 1215 state->pos.col = col-1; 1216 if(state->mode.origin) { 1217 state->pos.row += state->scrollregion_top; 1218 state->pos.col += SCROLLREGION_LEFT(state); 1219 } 1220 state->at_phantom = 0; 1221 break; 1222 1223 case 0x67: // TBC - ECMA-48 8.3.154 1224 val = CSI_ARG_OR(args[0], 0); 1225 1226 switch(val) { 1227 case 0: 1228 clear_col_tabstop(state, state->pos.col); 1229 break; 1230 case 3: 1231 case 5: 1232 for(col = 0; col < state->cols; col++) 1233 clear_col_tabstop(state, col); 1234 break; 1235 case 1: 1236 case 2: 1237 case 4: 1238 break; 1239 /* TODO: 1, 2 and 4 aren't meaningful yet without line tab stops */ 1240 default: 1241 return 0; 1242 } 1243 break; 1244 1245 case 0x68: // SM - ECMA-48 8.3.125 1246 if(!CSI_ARG_IS_MISSING(args[0])) 1247 set_mode(state, CSI_ARG(args[0]), 1); 1248 break; 1249 1250 case LEADER('?', 0x68): // DEC private mode set 1251 if(!CSI_ARG_IS_MISSING(args[0])) 1252 set_dec_mode(state, CSI_ARG(args[0]), 1); 1253 break; 1254 1255 case 0x6a: // HPB - ECMA-48 8.3.58 1256 count = CSI_ARG_COUNT(args[0]); 1257 state->pos.col -= count; 1258 state->at_phantom = 0; 1259 break; 1260 1261 case 0x6b: // VPB - ECMA-48 8.3.159 1262 count = CSI_ARG_COUNT(args[0]); 1263 state->pos.row -= count; 1264 state->at_phantom = 0; 1265 break; 1266 1267 case 0x6c: // RM - ECMA-48 8.3.106 1268 if(!CSI_ARG_IS_MISSING(args[0])) 1269 set_mode(state, CSI_ARG(args[0]), 0); 1270 break; 1271 1272 case LEADER('?', 0x6c): // DEC private mode reset 1273 if(!CSI_ARG_IS_MISSING(args[0])) 1274 set_dec_mode(state, CSI_ARG(args[0]), 0); 1275 break; 1276 1277 case 0x6d: // SGR - ECMA-48 8.3.117 1278 vterm_state_setpen(state, args, argcount); 1279 break; 1280 1281 case 0x6e: // DSR - ECMA-48 8.3.35 1282 case LEADER('?', 0x6e): // DECDSR 1283 val = CSI_ARG_OR(args[0], 0); 1284 1285 { 1286 char *qmark = (leader_byte == '?') ? "?" : ""; 1287 1288 switch(val) { 1289 case 0: case 1: case 2: case 3: case 4: 1290 // ignore - these are replies 1291 break; 1292 case 5: 1293 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%s0n", qmark); 1294 break; 1295 case 6: // CPR - cursor position report 1296 vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%s%d;%dR", qmark, state->pos.row + 1, state->pos.col + 1); 1297 break; 1298 } 1299 } 1300 break; 1301 1302 1303 case LEADER('!', 0x70): // DECSTR - DEC soft terminal reset 1304 vterm_state_reset(state, 0); 1305 break; 1306 1307 case LEADER('?', INTERMED('$', 0x70)): 1308 request_dec_mode(state, CSI_ARG(args[0])); 1309 break; 1310 1311 case INTERMED(' ', 0x71): // DECSCUSR - DEC set cursor shape 1312 val = CSI_ARG_OR(args[0], 1); 1313 1314 switch(val) { 1315 case 0: case 1: 1316 settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1); 1317 settermprop_int (state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BLOCK); 1318 break; 1319 case 2: 1320 settermprop_bool(state, VTERM_PROP_CURSORBLINK, 0); 1321 settermprop_int (state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BLOCK); 1322 break; 1323 case 3: 1324 settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1); 1325 settermprop_int (state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_UNDERLINE); 1326 break; 1327 case 4: 1328 settermprop_bool(state, VTERM_PROP_CURSORBLINK, 0); 1329 settermprop_int (state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_UNDERLINE); 1330 break; 1331 case 5: 1332 settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1); 1333 settermprop_int (state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BAR_LEFT); 1334 break; 1335 case 6: 1336 settermprop_bool(state, VTERM_PROP_CURSORBLINK, 0); 1337 settermprop_int (state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BAR_LEFT); 1338 break; 1339 } 1340 1341 break; 1342 1343 case INTERMED('"', 0x71): // DECSCA - DEC select character protection attribute 1344 val = CSI_ARG_OR(args[0], 0); 1345 1346 switch(val) { 1347 case 0: case 2: 1348 state->protected_cell = 0; 1349 break; 1350 case 1: 1351 state->protected_cell = 1; 1352 break; 1353 } 1354 1355 break; 1356 1357 case 0x72: // DECSTBM - DEC custom 1358 state->scrollregion_top = CSI_ARG_OR(args[0], 1) - 1; 1359 state->scrollregion_bottom = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]); 1360 LBOUND(state->scrollregion_top, -1); 1361 UBOUND(state->scrollregion_top, state->rows); 1362 LBOUND(state->scrollregion_bottom, -1); 1363 if(state->scrollregion_top == 0 && state->scrollregion_bottom == state->rows) 1364 state->scrollregion_bottom = -1; 1365 else 1366 UBOUND(state->scrollregion_bottom, state->rows); 1367 1368 break; 1369 1370 case 0x73: // DECSLRM - DEC custom 1371 // Always allow setting these margins, just they won't take effect without DECVSSM 1372 state->scrollregion_left = CSI_ARG_OR(args[0], 1) - 1; 1373 state->scrollregion_right = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]); 1374 LBOUND(state->scrollregion_left, -1); 1375 UBOUND(state->scrollregion_left, state->cols); 1376 LBOUND(state->scrollregion_right, -1); 1377 if(state->scrollregion_left == 0 && state->scrollregion_right == state->cols) 1378 state->scrollregion_right = -1; 1379 else 1380 UBOUND(state->scrollregion_right, state->cols); 1381 1382 break; 1383 1384 case INTERMED('\'', 0x7D): // DECIC 1385 count = CSI_ARG_COUNT(args[0]); 1386 1387 rect.start_row = state->scrollregion_top; 1388 rect.end_row = SCROLLREGION_BOTTOM(state); 1389 rect.start_col = state->pos.col; 1390 rect.end_col = SCROLLREGION_RIGHT(state); 1391 1392 scroll(state, rect, 0, -count); 1393 1394 break; 1395 1396 case INTERMED('\'', 0x7E): // DECDC 1397 count = CSI_ARG_COUNT(args[0]); 1398 1399 rect.start_row = state->scrollregion_top; 1400 rect.end_row = SCROLLREGION_BOTTOM(state); 1401 rect.start_col = state->pos.col; 1402 rect.end_col = SCROLLREGION_RIGHT(state); 1403 1404 scroll(state, rect, 0, count); 1405 1406 break; 1407 1408 default: 1409 return 0; 1410 } 1411 1412 if(state->mode.origin) { 1413 LBOUND(state->pos.row, state->scrollregion_top); 1414 UBOUND(state->pos.row, state->scrollregion_bottom-1); 1415 LBOUND(state->pos.col, SCROLLREGION_LEFT(state)); 1416 UBOUND(state->pos.col, SCROLLREGION_RIGHT(state)-1); 1417 } 1418 else { 1419 LBOUND(state->pos.row, 0); 1420 UBOUND(state->pos.row, state->rows-1); 1421 LBOUND(state->pos.col, 0); 1422 UBOUND(state->pos.col, THISROWWIDTH(state)-1); 1423 } 1424 1425 updatecursor(state, &oldpos, 1); 1426 1427 return 1; 1428 } 1429 on_osc(const char * command,size_t cmdlen,void * user)1430 static int on_osc(const char *command, size_t cmdlen, void *user) 1431 { 1432 VTermState *state = user; 1433 1434 if(cmdlen < 2) 1435 return 0; 1436 1437 if(strneq(command, "0;", 2)) { 1438 settermprop_string(state, VTERM_PROP_ICONNAME, command + 2, cmdlen - 2); 1439 settermprop_string(state, VTERM_PROP_TITLE, command + 2, cmdlen - 2); 1440 return 1; 1441 } 1442 else if(strneq(command, "1;", 2)) { 1443 settermprop_string(state, VTERM_PROP_ICONNAME, command + 2, cmdlen - 2); 1444 return 1; 1445 } 1446 else if(strneq(command, "2;", 2)) { 1447 settermprop_string(state, VTERM_PROP_TITLE, command + 2, cmdlen - 2); 1448 return 1; 1449 } 1450 1451 return 0; 1452 } 1453 request_status_string(VTermState * state,const char * command,size_t cmdlen)1454 static void request_status_string(VTermState *state, const char *command, size_t cmdlen) 1455 { 1456 if(cmdlen == 1) 1457 switch(command[0]) { 1458 case 'm': // Query SGR 1459 { 1460 long args[20]; 1461 int argc = vterm_state_getpen(state, args, sizeof(args)/sizeof(args[0])); 1462 vterm_push_output_sprintf_ctrl(state->vt, C1_DCS, "1$r"); 1463 for(int argi = 0; argi < argc; argi++) 1464 vterm_push_output_sprintf(state->vt, 1465 argi == argc - 1 ? "%d" : 1466 CSI_ARG_HAS_MORE(args[argi]) ? "%d:" : 1467 "%d;", 1468 CSI_ARG(args[argi])); 1469 vterm_push_output_sprintf(state->vt, "m"); 1470 vterm_push_output_sprintf_ctrl(state->vt, C1_ST, ""); 1471 } 1472 return; 1473 case 'r': // Query DECSTBM 1474 vterm_push_output_sprintf_dcs(state->vt, "1$r%d;%dr", state->scrollregion_top+1, SCROLLREGION_BOTTOM(state)); 1475 return; 1476 case 's': // Query DECSLRM 1477 vterm_push_output_sprintf_dcs(state->vt, "1$r%d;%ds", SCROLLREGION_LEFT(state)+1, SCROLLREGION_RIGHT(state)); 1478 return; 1479 } 1480 1481 if(cmdlen == 2) { 1482 if(strneq(command, " q", 2)) { 1483 int reply; 1484 switch(state->mode.cursor_shape) { 1485 case VTERM_PROP_CURSORSHAPE_BLOCK: reply = 2; break; 1486 case VTERM_PROP_CURSORSHAPE_UNDERLINE: reply = 4; break; 1487 case VTERM_PROP_CURSORSHAPE_BAR_LEFT: reply = 6; break; 1488 } 1489 if(state->mode.cursor_blink) 1490 reply--; 1491 vterm_push_output_sprintf_dcs(state->vt, "1$r%d q", reply); 1492 return; 1493 } 1494 else if(strneq(command, "\"q", 2)) { 1495 vterm_push_output_sprintf_dcs(state->vt, "1$r%d\"q", state->protected_cell ? 1 : 2); 1496 return; 1497 } 1498 } 1499 1500 vterm_push_output_sprintf_dcs(state->vt, "0$r%.s", (int)cmdlen, command); 1501 } 1502 on_dcs(const char * command,size_t cmdlen,void * user)1503 static int on_dcs(const char *command, size_t cmdlen, void *user) 1504 { 1505 VTermState *state = user; 1506 1507 if(cmdlen >= 2 && strneq(command, "$q", 2)) { 1508 request_status_string(state, command+2, cmdlen-2); 1509 return 1; 1510 } 1511 1512 return 0; 1513 } 1514 on_resize(int rows,int cols,void * user)1515 static int on_resize(int rows, int cols, void *user) 1516 { 1517 VTermState *state = user; 1518 VTermPos oldpos = state->pos; 1519 1520 if(cols != state->cols) { 1521 unsigned char *newtabstops = vterm_allocator_malloc(state->vt, (cols + 7) / 8); 1522 1523 /* TODO: This can all be done much more efficiently bytewise */ 1524 int col; 1525 for(col = 0; col < state->cols && col < cols; col++) { 1526 unsigned char mask = 1 << (col & 7); 1527 if(state->tabstops[col >> 3] & mask) 1528 newtabstops[col >> 3] |= mask; 1529 else 1530 newtabstops[col >> 3] &= ~mask; 1531 } 1532 1533 for( ; col < cols; col++) { 1534 unsigned char mask = 1 << (col & 7); 1535 if(col % 8 == 0) 1536 newtabstops[col >> 3] |= mask; 1537 else 1538 newtabstops[col >> 3] &= ~mask; 1539 } 1540 1541 vterm_allocator_free(state->vt, state->tabstops); 1542 state->tabstops = newtabstops; 1543 } 1544 1545 if(rows != state->rows) { 1546 VTermLineInfo *newlineinfo = vterm_allocator_malloc(state->vt, rows * sizeof(VTermLineInfo)); 1547 1548 int row; 1549 for(row = 0; row < state->rows && row < rows; row++) { 1550 newlineinfo[row] = state->lineinfo[row]; 1551 } 1552 1553 for( ; row < rows; row++) { 1554 newlineinfo[row] = (VTermLineInfo){ 1555 .doublewidth = 0, 1556 }; 1557 } 1558 1559 vterm_allocator_free(state->vt, state->lineinfo); 1560 state->lineinfo = newlineinfo; 1561 } 1562 1563 state->rows = rows; 1564 state->cols = cols; 1565 1566 VTermPos delta = { 0, 0 }; 1567 1568 if(state->callbacks && state->callbacks->resize) 1569 (*state->callbacks->resize)(rows, cols, &delta, state->cbdata); 1570 1571 if(state->at_phantom && state->pos.col < cols-1) { 1572 state->at_phantom = 0; 1573 state->pos.col++; 1574 } 1575 1576 state->pos.row += delta.row; 1577 state->pos.col += delta.col; 1578 1579 if(state->pos.row >= rows) 1580 state->pos.row = rows - 1; 1581 if(state->pos.col >= cols) 1582 state->pos.col = cols - 1; 1583 1584 updatecursor(state, &oldpos, 1); 1585 1586 return 1; 1587 } 1588 1589 static const VTermParserCallbacks parser_callbacks = { 1590 .text = on_text, 1591 .control = on_control, 1592 .escape = on_escape, 1593 .csi = on_csi, 1594 .osc = on_osc, 1595 .dcs = on_dcs, 1596 .resize = on_resize, 1597 }; 1598 vterm_obtain_state(VTerm * vt)1599 VTermState *vterm_obtain_state(VTerm *vt) 1600 { 1601 if(vt->state) 1602 return vt->state; 1603 1604 VTermState *state = vterm_state_new(vt); 1605 vt->state = state; 1606 1607 state->combine_chars_size = 16; 1608 state->combine_chars = vterm_allocator_malloc(state->vt, state->combine_chars_size * sizeof(state->combine_chars[0])); 1609 1610 state->tabstops = vterm_allocator_malloc(state->vt, (state->cols + 7) / 8); 1611 1612 state->lineinfo = vterm_allocator_malloc(state->vt, state->rows * sizeof(VTermLineInfo)); 1613 1614 state->encoding_utf8.enc = vterm_lookup_encoding(ENC_UTF8, 'u'); 1615 if(*state->encoding_utf8.enc->init) 1616 (*state->encoding_utf8.enc->init)(state->encoding_utf8.enc, state->encoding_utf8.data); 1617 1618 vterm_set_parser_callbacks(vt, &parser_callbacks, state); 1619 1620 return state; 1621 } 1622 vterm_state_reset(VTermState * state,int hard)1623 void vterm_state_reset(VTermState *state, int hard) 1624 { 1625 state->scrollregion_top = 0; 1626 state->scrollregion_bottom = -1; 1627 state->scrollregion_left = 0; 1628 state->scrollregion_right = -1; 1629 1630 state->mode.keypad = 0; 1631 state->mode.cursor = 0; 1632 state->mode.autowrap = 1; 1633 state->mode.insert = 0; 1634 state->mode.newline = 0; 1635 state->mode.alt_screen = 0; 1636 state->mode.origin = 0; 1637 state->mode.leftrightmargin = 0; 1638 1639 state->vt->mode.ctrl8bit = 0; 1640 1641 for(int col = 0; col < state->cols; col++) 1642 if(col % 8 == 0) 1643 set_col_tabstop(state, col); 1644 else 1645 clear_col_tabstop(state, col); 1646 1647 for(int row = 0; row < state->rows; row++) 1648 set_lineinfo(state, row, FORCE, DWL_OFF, DHL_OFF); 1649 1650 if(state->callbacks && state->callbacks->initpen) 1651 (*state->callbacks->initpen)(state->cbdata); 1652 1653 vterm_state_resetpen(state); 1654 1655 VTermEncoding *default_enc = state->vt->mode.utf8 ? 1656 vterm_lookup_encoding(ENC_UTF8, 'u') : 1657 vterm_lookup_encoding(ENC_SINGLE_94, 'B'); 1658 1659 for(int i = 0; i < 4; i++) { 1660 state->encoding[i].enc = default_enc; 1661 if(default_enc->init) 1662 (*default_enc->init)(default_enc, state->encoding[i].data); 1663 } 1664 1665 state->gl_set = 0; 1666 state->gr_set = 1; 1667 state->gsingle_set = 0; 1668 1669 state->protected_cell = 0; 1670 1671 // Initialise the props 1672 settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, 1); 1673 settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1); 1674 settermprop_int (state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BLOCK); 1675 1676 if(hard) { 1677 state->pos.row = 0; 1678 state->pos.col = 0; 1679 state->at_phantom = 0; 1680 1681 VTermRect rect = { 0, state->rows, 0, state->cols }; 1682 erase(state, rect, 0); 1683 } 1684 } 1685 vterm_state_get_cursorpos(const VTermState * state,VTermPos * cursorpos)1686 void vterm_state_get_cursorpos(const VTermState *state, VTermPos *cursorpos) 1687 { 1688 *cursorpos = state->pos; 1689 } 1690 vterm_state_set_callbacks(VTermState * state,const VTermStateCallbacks * callbacks,void * user)1691 void vterm_state_set_callbacks(VTermState *state, const VTermStateCallbacks *callbacks, void *user) 1692 { 1693 if(callbacks) { 1694 state->callbacks = callbacks; 1695 state->cbdata = user; 1696 1697 if(state->callbacks && state->callbacks->initpen) 1698 (*state->callbacks->initpen)(state->cbdata); 1699 } 1700 else { 1701 state->callbacks = NULL; 1702 state->cbdata = NULL; 1703 } 1704 } 1705 vterm_state_set_termprop(VTermState * state,VTermProp prop,VTermValue * val)1706 int vterm_state_set_termprop(VTermState *state, VTermProp prop, VTermValue *val) 1707 { 1708 /* Only store the new value of the property if usercode said it was happy. 1709 * This is especially important for altscreen switching */ 1710 if(state->callbacks && state->callbacks->settermprop) 1711 if(!(*state->callbacks->settermprop)(prop, val, state->cbdata)) 1712 return 0; 1713 1714 switch(prop) { 1715 case VTERM_PROP_TITLE: 1716 case VTERM_PROP_ICONNAME: 1717 // we don't store these, just transparently pass through 1718 return 1; 1719 case VTERM_PROP_CURSORVISIBLE: 1720 state->mode.cursor_visible = val->boolean; 1721 return 1; 1722 case VTERM_PROP_CURSORBLINK: 1723 state->mode.cursor_blink = val->boolean; 1724 return 1; 1725 case VTERM_PROP_CURSORSHAPE: 1726 state->mode.cursor_shape = val->number; 1727 return 1; 1728 case VTERM_PROP_REVERSE: 1729 state->mode.screen = val->boolean; 1730 return 1; 1731 case VTERM_PROP_ALTSCREEN: 1732 state->mode.alt_screen = val->boolean; 1733 if(state->mode.alt_screen) { 1734 VTermRect rect = { 1735 .start_row = 0, 1736 .start_col = 0, 1737 .end_row = state->rows, 1738 .end_col = state->cols, 1739 }; 1740 erase(state, rect, 0); 1741 } 1742 return 1; 1743 } 1744 1745 return 0; 1746 } 1747 vterm_state_get_lineinfo(const VTermState * state,int row)1748 const VTermLineInfo *vterm_state_get_lineinfo(const VTermState *state, int row) 1749 { 1750 return state->lineinfo + row; 1751 } 1752