1 #include "vterm_internal.h" 2 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <stdarg.h> 6 #include <string.h> 7 8 /***************** 9 * API functions * 10 *****************/ 11 12 static void *default_malloc(size_t size, void *allocdata) 13 { 14 void *ptr = malloc(size); 15 if(ptr) 16 memset(ptr, 0, size); 17 return ptr; 18 } 19 20 static void default_free(void *ptr, void *allocdata) 21 { 22 free(ptr); 23 } 24 25 static VTermAllocatorFunctions default_allocator = { 26 .malloc = &default_malloc, 27 .free = &default_free, 28 }; 29 30 VTerm *vterm_new(int rows, int cols) 31 { 32 return vterm_new_with_allocator(rows, cols, &default_allocator, NULL); 33 } 34 35 VTerm *vterm_new_with_allocator(int rows, int cols, VTermAllocatorFunctions *funcs, void *allocdata) 36 { 37 /* Need to bootstrap using the allocator function directly */ 38 VTerm *vt = (*funcs->malloc)(sizeof(VTerm), allocdata); 39 40 vt->allocator = funcs; 41 vt->allocdata = allocdata; 42 43 vt->rows = rows; 44 vt->cols = cols; 45 46 vt->parser_state = NORMAL; 47 48 vt->strbuffer_len = 64; 49 vt->strbuffer_cur = 0; 50 vt->strbuffer = vterm_allocator_malloc(vt, vt->strbuffer_len); 51 52 vt->outbuffer_len = 64; 53 vt->outbuffer_cur = 0; 54 vt->outbuffer = vterm_allocator_malloc(vt, vt->outbuffer_len); 55 56 return vt; 57 } 58 59 void vterm_free(VTerm *vt) 60 { 61 if(vt->screen) 62 vterm_screen_free(vt->screen); 63 64 if(vt->state) 65 vterm_state_free(vt->state); 66 67 vterm_allocator_free(vt, vt->strbuffer); 68 vterm_allocator_free(vt, vt->outbuffer); 69 70 vterm_allocator_free(vt, vt); 71 } 72 73 void *vterm_allocator_malloc(VTerm *vt, size_t size) 74 { 75 return (*vt->allocator->malloc)(size, vt->allocdata); 76 } 77 78 void vterm_allocator_free(VTerm *vt, void *ptr) 79 { 80 (*vt->allocator->free)(ptr, vt->allocdata); 81 } 82 83 void vterm_get_size(const VTerm *vt, int *rowsp, int *colsp) 84 { 85 if(rowsp) 86 *rowsp = vt->rows; 87 if(colsp) 88 *colsp = vt->cols; 89 } 90 91 void vterm_set_size(VTerm *vt, int rows, int cols) 92 { 93 vt->rows = rows; 94 vt->cols = cols; 95 96 if(vt->parser_callbacks && vt->parser_callbacks->resize) 97 (*vt->parser_callbacks->resize)(rows, cols, vt->cbdata); 98 } 99 100 void vterm_set_parser_callbacks(VTerm *vt, const VTermParserCallbacks *callbacks, void *user) 101 { 102 vt->parser_callbacks = callbacks; 103 vt->cbdata = user; 104 } 105 106 void vterm_parser_set_utf8(VTerm *vt, int is_utf8) 107 { 108 vt->mode.utf8 = is_utf8; 109 } 110 111 void vterm_push_output_bytes(VTerm *vt, const char *bytes, size_t len) 112 { 113 if(len > vt->outbuffer_len - vt->outbuffer_cur) { 114 fprintf(stderr, "vterm_push_output(): buffer overflow; truncating output\n"); 115 len = vt->outbuffer_len - vt->outbuffer_cur; 116 } 117 118 memcpy(vt->outbuffer + vt->outbuffer_cur, bytes, len); 119 vt->outbuffer_cur += len; 120 } 121 122 void vterm_push_output_vsprintf(VTerm *vt, const char *format, va_list args) 123 { 124 int written = vsnprintf(vt->outbuffer + vt->outbuffer_cur, 125 vt->outbuffer_len - vt->outbuffer_cur, 126 format, args); 127 vt->outbuffer_cur += written; 128 } 129 130 void vterm_push_output_sprintf(VTerm *vt, const char *format, ...) 131 { 132 va_list args; 133 va_start(args, format); 134 vterm_push_output_vsprintf(vt, format, args); 135 va_end(args); 136 } 137 138 void vterm_push_output_sprintf_ctrl(VTerm *vt, unsigned char ctrl, const char *fmt, ...) 139 { 140 if(ctrl >= 0x80 && !vt->mode.ctrl8bit) 141 vterm_push_output_sprintf(vt, "\e%c", ctrl - 0x40); 142 else 143 vterm_push_output_sprintf(vt, "%c", ctrl); 144 145 va_list args; 146 va_start(args, fmt); 147 vterm_push_output_vsprintf(vt, fmt, args); 148 va_end(args); 149 } 150 151 void vterm_push_output_sprintf_dcs(VTerm *vt, const char *fmt, ...) 152 { 153 if(!vt->mode.ctrl8bit) 154 vterm_push_output_sprintf(vt, "\e%c", C1_DCS - 0x40); 155 else 156 vterm_push_output_sprintf(vt, "%c", C1_DCS); 157 158 va_list args; 159 va_start(args, fmt); 160 vterm_push_output_vsprintf(vt, fmt, args); 161 va_end(args); 162 163 vterm_push_output_sprintf_ctrl(vt, C1_ST, ""); 164 } 165 166 size_t vterm_output_bufferlen(VTerm *vt) 167 { 168 return vterm_output_get_buffer_current(vt); 169 } 170 171 size_t vterm_output_get_buffer_size(const VTerm *vt) 172 { 173 return vt->outbuffer_len; 174 } 175 176 size_t vterm_output_get_buffer_current(const VTerm *vt) 177 { 178 return vt->outbuffer_cur; 179 } 180 181 size_t vterm_output_get_buffer_remaining(const VTerm *vt) 182 { 183 return vt->outbuffer_len - vt->outbuffer_cur; 184 } 185 186 size_t vterm_output_bufferread(VTerm *vt, char *buffer, size_t len) 187 { 188 if(len > vt->outbuffer_cur) 189 len = vt->outbuffer_cur; 190 191 memcpy(buffer, vt->outbuffer, len); 192 193 if(len < vt->outbuffer_cur) 194 memmove(vt->outbuffer, vt->outbuffer + len, vt->outbuffer_cur - len); 195 196 vt->outbuffer_cur -= len; 197 198 return len; 199 } 200 201 VTermValueType vterm_get_attr_type(VTermAttr attr) 202 { 203 switch(attr) { 204 case VTERM_ATTR_BOLD: return VTERM_VALUETYPE_BOOL; 205 case VTERM_ATTR_UNDERLINE: return VTERM_VALUETYPE_INT; 206 case VTERM_ATTR_ITALIC: return VTERM_VALUETYPE_BOOL; 207 case VTERM_ATTR_BLINK: return VTERM_VALUETYPE_BOOL; 208 case VTERM_ATTR_REVERSE: return VTERM_VALUETYPE_BOOL; 209 case VTERM_ATTR_STRIKE: return VTERM_VALUETYPE_BOOL; 210 case VTERM_ATTR_FONT: return VTERM_VALUETYPE_INT; 211 case VTERM_ATTR_FOREGROUND: return VTERM_VALUETYPE_COLOR; 212 case VTERM_ATTR_BACKGROUND: return VTERM_VALUETYPE_COLOR; 213 } 214 return 0; /* UNREACHABLE */ 215 } 216 217 VTermValueType vterm_get_prop_type(VTermProp prop) 218 { 219 switch(prop) { 220 case VTERM_PROP_CURSORVISIBLE: return VTERM_VALUETYPE_BOOL; 221 case VTERM_PROP_CURSORBLINK: return VTERM_VALUETYPE_BOOL; 222 case VTERM_PROP_ALTSCREEN: return VTERM_VALUETYPE_BOOL; 223 case VTERM_PROP_TITLE: return VTERM_VALUETYPE_STRING; 224 case VTERM_PROP_ICONNAME: return VTERM_VALUETYPE_STRING; 225 case VTERM_PROP_REVERSE: return VTERM_VALUETYPE_BOOL; 226 case VTERM_PROP_CURSORSHAPE: return VTERM_VALUETYPE_INT; 227 } 228 return 0; /* UNREACHABLE */ 229 } 230 231 void vterm_scroll_rect(VTermRect rect, 232 int downward, 233 int rightward, 234 int (*moverect)(VTermRect src, VTermRect dest, void *user), 235 int (*eraserect)(VTermRect rect, int selective, void *user), 236 void *user) 237 { 238 VTermRect src; 239 VTermRect dest; 240 241 if(abs(downward) >= rect.end_row - rect.start_row || 242 abs(rightward) >= rect.end_col - rect.start_col) { 243 /* Scroll more than area; just erase the lot */ 244 (*eraserect)(rect, 0, user); 245 return; 246 } 247 248 if(rightward >= 0) { 249 /* rect: [XXX................] 250 * src: [----------------] 251 * dest: [----------------] 252 */ 253 dest.start_col = rect.start_col; 254 dest.end_col = rect.end_col - rightward; 255 src.start_col = rect.start_col + rightward; 256 src.end_col = rect.end_col; 257 } 258 else { 259 /* rect: [................XXX] 260 * src: [----------------] 261 * dest: [----------------] 262 */ 263 int leftward = -rightward; 264 dest.start_col = rect.start_col + leftward; 265 dest.end_col = rect.end_col; 266 src.start_col = rect.start_col; 267 src.end_col = rect.end_col - leftward; 268 } 269 270 if(downward >= 0) { 271 dest.start_row = rect.start_row; 272 dest.end_row = rect.end_row - downward; 273 src.start_row = rect.start_row + downward; 274 src.end_row = rect.end_row; 275 } 276 else { 277 int upward = -downward; 278 dest.start_row = rect.start_row + upward; 279 dest.end_row = rect.end_row; 280 src.start_row = rect.start_row; 281 src.end_row = rect.end_row - upward; 282 } 283 284 if(moverect) 285 (*moverect)(dest, src, user); 286 287 if(downward > 0) 288 rect.start_row = rect.end_row - downward; 289 else if(downward < 0) 290 rect.end_row = rect.start_row - downward; 291 292 if(rightward > 0) 293 rect.start_col = rect.end_col - rightward; 294 else if(rightward < 0) 295 rect.end_col = rect.start_col - rightward; 296 297 (*eraserect)(rect, 0, user); 298 } 299 300 void vterm_copy_cells(VTermRect dest, 301 VTermRect src, 302 void (*copycell)(VTermPos dest, VTermPos src, void *user), 303 void *user) 304 { 305 int downward = src.start_row - dest.start_row; 306 int rightward = src.start_col - dest.start_col; 307 308 int init_row, test_row, init_col, test_col; 309 int inc_row, inc_col; 310 311 if(downward < 0) { 312 init_row = dest.end_row - 1; 313 test_row = dest.start_row - 1; 314 inc_row = -1; 315 } 316 else /* downward >= 0 */ { 317 init_row = dest.start_row; 318 test_row = dest.end_row; 319 inc_row = +1; 320 } 321 322 if(rightward < 0) { 323 init_col = dest.end_col - 1; 324 test_col = dest.start_col - 1; 325 inc_col = -1; 326 } 327 else /* rightward >= 0 */ { 328 init_col = dest.start_col; 329 test_col = dest.end_col; 330 inc_col = +1; 331 } 332 333 VTermPos pos; 334 for(pos.row = init_row; pos.row != test_row; pos.row += inc_row) 335 for(pos.col = init_col; pos.col != test_col; pos.col += inc_col) { 336 VTermPos srcpos = { pos.row + downward, pos.col + rightward }; 337 (*copycell)(pos, srcpos, user); 338 } 339 } 340
