vtgl

util.c (13869B)

---

 /* See LICENSE for copyright details */
 
 /* NOTE: avoids braindead standards committee UB when n is negative or shift is > 31 */
 function u32
 safe_left_shift(u32 n, u32 shift)
 {
 	u64 result = (u64)n << (shift & 63);
 	return result & 0xFFFFFFFF;
 }
 
 function u32
 round_down_power_of_2(u32 a)
 {
 	u32 result = 0x80000000UL >> clz_u32(a);
 	return result;
 }
 
 function v2
 sub_v2(v2 a, v2 b)
 {
 	v2 result;
 	result.x = a.x - b.x;
 	result.y = a.y - b.y;
 	return result;
 }
 
 function f32
 length_v2(v2 a)
 {
 	f32 result = a.x * a.x + a.y * a.y;
 	return result;
 }
 
 function b32
 equal_iv2(iv2 a, iv2 b)
 {
 	b32 result = a.x == b.x && a.y == b.y;
 	return result;
 }
 
 function b32
 equal_uv2(uv2 a, uv2 b)
 {
 	b32 result = a.x == b.x && a.y == b.y;
 	return result;
 }
 
 function v2
 v2_from_iv2(iv2 a)
 {
 	v2 result = {.x = a.x, .y = a.y};
 	return result;
 }
 
 function b32
 is_valid_range(Range r)
 {
 	b32 result = !equal_iv2(r.end, INVALID_RANGE_END);
 	return result;
 }
 
 function b32
 equal_range(Range a, Range b)
 {
 	b32 result = equal_iv2(a.start, b.start) && equal_iv2(a.end, b.end);
 	return result;
 }
 
 function b32
 point_in_rect(v2 point, Rect rect)
 {
 	v2 max = {.x = rect.pos.x + rect.size.w, .y = rect.pos.y + rect.size.h};
 	b32 result = BETWEEN(point.x, rect.pos.x, max.x) && BETWEEN(point.y, rect.pos.y, max.y);
 	return result;
 }
 
 function Range
 normalize_range(Range r)
 {
 	Range result;
 	if (!is_valid_range(r) || r.start.y < r.end.y) {
 		result = r;
 	} else if (r.end.y < r.start.y) {
 		result = (Range){.start = r.end, .end = r.start};
 	} else {
 		result.start.y = result.end.y = r.start.y;
 		result.start.x = MIN(r.start.x, r.end.x);
 		result.end.x   = MAX(r.start.x, r.end.x);
 	}
 	return result;
 }
 
 function void
 mem_copy(void *restrict dest, void *restrict src, iz len)
 {
 	ASSERT(len >= 0);
 	u8 *s = src, *d = dest;
 	for (; len; len--) *d++ = *s++;
 }
 
 #define zero_struct(s) mem_clear(s, 0, sizeof(typeof(*s)))
 function void *
 mem_clear(void *p_, u8 c, iz len)
 {
 	u8 *p = p_;
 	while (len) p[--len] = c;
 	return p;
 }
 
 /* NOTE(rnp): based on nullprogram's lock-free, concurrent,
  * generic queue in 32 bits */
 function WorkQueueWork *
 work_queue_push(WorkQueue *q)
 {
 	WorkQueueWork *result = 0;
 	static_assert(ISPOWEROFTWO(countof(q->items)), "queue capacity must be power of two");
 	u64 val  = atomic_load(&q->queue);
 	u64 mask = countof(q->items) - 1;
 	u32 widx =  val        & mask;
 	u32 ridx = (val >> 32) & mask;
 	u32 next = (widx + 1)  & mask;
 
 	/* NOTE(rnp): prevent an overflow into the tail on commit */
 	if (val & 0x80000000ULL)
 		atomic_and(&q->queue, ~0x80000000ULL);
 
 	if (next != ridx) {
 		result = q->items + widx;
 		zero_struct(result);
 	}
 
 	return result;
 }
 
 function void
 work_queue_push_commit(WorkQueue *q)
 {
 	atomic_fetch_add(&q->queue, 1);
 }
 
 function WorkQueueWork *
 work_queue_pop(WorkQueue *q)
 {
 	WorkQueueWork *result = 0;
 	static_assert(ISPOWEROFTWO(countof(q->items)), "queue capacity must be power of two");
 	u64 val  = atomic_load(&q->queue);
 	u64 mask = countof(q->items) - 1;
 	u32 widx =  val        & mask;
 	u32 ridx = (val >> 32) & mask;
 
 	if (ridx != widx)
 		result = q->items + ridx;
 
 	return result;
 }
 
 function void
 work_queue_pop_commit(WorkQueue *q)
 {
 	atomic_fetch_add(&q->queue, 0x100000000ULL);
 }
 
 function b32
 work_queue_empty(WorkQueue *q)
 {
 	static_assert(ISPOWEROFTWO(countof(q->items)), "queue capacity must be power of two");
 	u64 r    = atomic_load(&q->queue);
 	u32 mask = countof(q->items) - 1;
 	u32 head =  r        & mask;
 	u32 tail = (r >> 32) & mask;
 	return head == tail;
 }
 
 function b32
 work_queue_insert(WorkQueue *q, WorkQueueWorkKind kind, void *ctx)
 {
 	WorkQueueWork *work = work_queue_push(q);
 	b32 result = 0;
 	/* NOTE(rnp): if we ever fill this up we need to resize the queue */
 	if (work) {
 		work->kind    = kind;
 		work->generic = ctx;
 		work_queue_push_commit(q);
 	}
 	return result;
 }
 
 #define push_struct(a, t) alloc(a, t, 1)
 #define alloc(a, t, n)  (t *)alloc_(a, sizeof(t), _Alignof(t), n)
 function void *
 alloc_(Arena *a, iz len, iz align, iz count)
 {
 	iz padding   = -(uintptr_t)a->beg & (align - 1);
 	iz available = a->end - a->beg - padding;
 	if (available <= 0 || available / len < count) {
 		ASSERT(0);
 	}
 
 	void *p  = a->beg + padding;
 	a->beg  += padding + count * len;
 	return mem_clear(p, 0, count * len);
 }
 
 function Arena
 arena_from_memory_block(OSMemoryBlock memory)
 {
 	Arena result;
 	result.beg = memory.memory;
 	result.end = memory.memory + memory.size;
 	return result;
 }
 
 function OSMemoryBlock
 memory_block_from_arena(Arena *a, iz requested_size)
 {
 	OSMemoryBlock result;
 	result.memory = alloc_(a, requested_size, 64, 1);
 	result.size   = requested_size;
 	return result;
 }
 
 function Arena
 sub_arena(Arena *a, iz size)
 {
 	Arena result = {0};
 	result.beg   = alloc_(a, size, 64, 1);
 	result.end   = result.beg + size;
 	return result;
 }
 
 function TempArena
 begin_temp_arena(Arena *a)
 {
 	TempArena result;
 	result.arena   = a;
 	result.old_beg = a->beg;
 	return result;
 }
 
 function void
 end_temp_arena(TempArena ta)
 {
 	Arena *a = ta.arena;
 	ASSERT(a->beg >= ta.old_beg);
 	a->beg = ta.old_beg;
 }
 
 /* NOTE: This performs wrapping of the ring buffer as needed; since a line could be in
  * progress this must also adjust the start and end of the current line */
 function void
 commit_to_rb(TermView *tv, iz len)
 {
 	ASSERT(ABS(len) <= tv->log.capacity);
 
 	tv->log.write_index += len;
 	tv->log.filled      += len;
 
 	CLAMP(tv->log.filled, 0, tv->log.capacity);
 	if (tv->log.write_index >= tv->log.capacity) {
 		tv->log.write_index -= tv->log.capacity;
 
 		iz line = tv->lines.count;
 		tv->lines.data[line].start -= tv->log.capacity;
 		tv->lines.data[line].end   -= tv->log.capacity;
 	}
 
 	ASSERT(tv->log.filled >= 0);
 	ASSERT(tv->log.write_index >= 0 && tv->log.write_index < tv->log.capacity);
 }
 
 function LineBuffer
 line_buffer_alloc(Arena *a, u8 *start_position, CellStyle state, iz capacity)
 {
 	LineBuffer result = {0};
 	result.capacity = capacity;
 	result.data     = alloc(a, Line, capacity);
 	result.data[0].start = start_position;
 	result.data[0].end   = start_position;
 	result.data[0].cursor_state = state;
 	return result;
 }
 
 function s8
 s8alloc(Arena *a, iz len)
 {
 	return (s8){.len = len, .data = alloc(a, u8, len)};
 }
 
 function s8
 c_str_to_s8(char *s)
 {
 	s8 result = {.data = (u8 *)s};
 	if (s) {
 		char *end = s;
 		while (*end) end++;
 		result.len = end - s;
 	}
 	return result;
 }
 
 function b32
 s8_equal(s8 a, s8 b)
 {
 	b32 result = a.len == b.len;
 	for (iz i = 0; result && i < a.len; i++)
 		result = a.data[i] == b.data[i];
 	return result;
 }
 
 function b32
 s8_prefix_of(s8 s, s8 match)
 {
 	b32 result = 0;
 	if (s.len <= match.len) {
 		s8 head = {.data = match.data, .len = s.len};
 		result  = s8_equal(s, head);
 	}
 	return result;
 }
 
 function s8
 s8_chop_at(s8 raw, u8 delim)
 {
 	iz i;
 	for (i = 0; i < raw.len; i++) {
 		if (raw.data[i] == delim)
 			break;
 	}
 	s8 result = {.len = i, .data = raw.data};
 	return result;
 }
 
 function void
 s8_parse_i32_accum(struct conversion_result *result, s8 raw)
 {
 	result->status = CR_SUCCESS;
 
 	iz  i     = 0;
 	i32 scale = 1;
 	if (raw.len && raw.data[0] == '-') {
 		scale = -1;
 		i     = 1;
 	}
 
 	for (; i < raw.len; i++) {
 		i32 digit = (i32)raw.data[i] - '0';
 		if (BETWEEN(digit, 0, 9)) {
 			if (result->i > (I32_MAX - digit) / 10) {
 				result->status = CR_OUT_OF_RANGE;
 				result->i      = I32_MAX;
 			} else {
 				result->i = 10 * result->i + digit;
 			}
 		} else {
 			break;
 		}
 	}
 
 	if (i == 0 || (i == 1 && raw.data[0] == '-'))
 		result->status = CR_FAILURE;
 
 	result->unparsed  = (s8){.len = raw.len - i, .data = raw.data + i};
 	result->i        *= scale;
 }
 
 function struct conversion_result
 s8_parse_i32(s8 raw)
 {
 	struct conversion_result result = {0};
 	s8_parse_i32_accum(&result, raw);
 	return result;
 }
 
 function struct conversion_result
 s8_parse_i32_until(s8 raw, u8 delim)
 {
 	s8 chopped = s8_chop_at(raw, delim);
 	struct conversion_result result = s8_parse_i32(chopped);
 	result.unparsed = (s8){.data = raw.data + chopped.len, .len = raw.len - chopped.len};
 	return result;
 }
 
 function Stream
 arena_stream(Arena a)
 {
 	Stream result   = {0};
 	result.capacity = a.end - a.beg;
 	result.data     = a.beg;
 	return result;
 }
 
 function void
 stream_reset(Stream *s, iz index)
 {
 	s->errors = index < 0 || index > s->capacity;
 	if (!s->errors) s->count = index;
 }
 
 function void
 stream_commit(Stream *s, iz count)
 {
 	s->errors |= !BETWEEN(s->count + count, 0, s->capacity);
 	if (!s->errors)
 		s->count += count;
 }
 
 function Stream
 stream_alloc(Arena *a, i32 capacity)
 {
 	Stream result   = {0};
 	result.capacity = capacity;
 	result.data     = alloc(a, u8, capacity);
 	return result;
 }
 
 function s8
 stream_to_s8(Stream *s)
 {
 	s8 result = {.len = s->count, .data = s->data};
 	return result;
 }
 
 function void
 stream_push_byte(Stream *s, u8 cp)
 {
 	s->errors |= !(s->capacity - s->count);
 	if (!s->errors)
 		s->data[s->count++] = cp;
 }
 
 function void
 stream_push_s8(Stream *s, s8 str)
 {
 	s->errors |= (s->capacity - s->count) < str.len;
 	if (!s->errors) {
 		mem_copy(s->data + s->count, str.data, str.len);
 		s->count += str.len;
 	}
 }
 
 /* NOTE: how can he get away with not using a library for this */
 function void
 stream_push_s8_left_padded(Stream *s, s8 str, u32 width)
 {
 	for (u32 i = str.len; i < width; i++)
 		stream_push_byte(s, ' ');
 	stream_push_s8(s, str);
 }
 
 function void
 stream_push_s8s(Stream *s, u32 count, s8 *strs)
 {
 	while (count) { stream_push_s8(s, *strs++); count--; }
 }
 
 function void
 stream_push_hex_u64(Stream *s, u64 n)
 {
 	if (!s->errors) {
 		static u8 hex[16] = {"0123456789abcdef"};
 		u8  buf[16];
 		u8 *end = buf + sizeof(buf);
 		u8 *beg = end;
 		while (n) {
 			*--beg = hex[n & 0x0F];
 			n >>= 4;
 		}
 		while (end - beg < 2)
 			*--beg = '0';
 		stream_push_s8(s, (s8){.len = end - beg, .data = beg});
 	}
 }
 
 function void
 stream_push_u64_padded(Stream *s, u64 n, u32 width)
 {
 	if (!s->errors) {
 		u8 tmp[64];
 		u8 *end = tmp + sizeof(tmp);
 		u8 *beg = end;
 		do { *--beg = '0' + (n % 10); } while (n /= 10);
 
 		s8 str = {.len = end - beg, .data = beg};
 		for (u32 i = str.len; i < width; i++)
 			stream_push_byte(s, ' ');
 		stream_push_s8(s, str);
 	}
 }
 
 function void
 stream_push_u64(Stream *s, u64 n)
 {
 	stream_push_u64_padded(s, n, 0);
 }
 
 function void
 stream_push_i64(Stream *s, i64 n)
 {
 	s->errors |= n == I64_MIN;
 	if (!s->errors) {
 		if (n < 0) {
 			stream_push_byte(s, '-');
 			n = -n;
 		}
 		stream_push_u64_padded(s, n, 0);
 	}
 }
 
 function void
 stream_push_iv2(Stream *s, iv2 v)
 {
 	stream_push_byte(s, '{');
 	stream_push_i64(s, v.x);
 	stream_push_byte(s, ',');
 	stream_push_i64(s, v.y);
 	stream_push_byte(s, '}');
 }
 
 function void
 stream_push_f64(Stream *s, f64 f, i64 prec)
 {
 	if (f < 0) {
 		stream_push_byte(s, '-');
 		f *= -1;
 	}
 
 	/* NOTE: round last digit */
 	f += 0.5f / prec;
 
 	if (f >= (f64)(-1UL >> 1)) {
 		stream_push_s8(s, s8("inf"));
 	} else {
 		u64 integral = f;
 		u64 fraction = (f - integral) * prec;
 		stream_push_u64(s, integral);
 		stream_push_byte(s, '.');
 		for (u64 i = prec / 10; i > 1; i /= 10) {
 			if (i > fraction)
 				stream_push_byte(s, '0');
 		}
 		stream_push_u64(s, fraction);
 	}
 }
 
 function void
 selection_clear(Selection *s)
 {
 	s->range.end = INVALID_RANGE_END;
 	s->state     = SS_NONE;
 }
 
 function SelectionIterator
 selection_iterator(Range s, Row *rows, u32 term_width)
 {
 	SelectionIterator result;
 	result.rows       = rows;
 	result.cursor     = (iv2){.x = -1, .y = -1};
 	result.next       = s.start;
 	result.end        = s.end;
 	result.term_width = term_width;
 	return result;
 }
 
 function Cell *
 selection_next(SelectionIterator *s)
 {
 	Cell *result = 0;
 
 	if (!equal_iv2(s->cursor, s->end)) {
 		s->cursor = s->next;
 		result    = s->rows[s->next.y] + s->next.x++;
 		if (s->next.x == s->term_width) {
 			s->next.x = 0;
 			s->next.y++;
 		}
 	}
 
 	return result;
 }
 
 function s8
 envp_lookup(s8 name, char **e)
 {
 	ASSERT(name.data[name.len - 1] == '=');
 
 	s8 s, result = {0};
 	for (; *e; e++) {
 		s = c_str_to_s8(*e);
 		if (s8_prefix_of(name, s))
 			break;
 	}
 
 	if (*e) {
 		result = s;
 		result.len  -= name.len;
 		result.data += name.len;
 	}
 
 	return result;
 }
 
 function c8 **
 construct_c_str_array(Arena *a, SLLVariableVector vars)
 {
 	c8 **result = alloc(a, c8 *, vars.count + 1);
 
 	VariableLink *chain = vars.next;
 	for (u32 i = 0; i < vars.count; i++) {
 		ASSERT(chain->var->type == VT_S8);
 		result[i] = (c8 *)chain->var->s8.data;
 		chain     = chain->next;
 	}
 
 	return result;
 }
 
 function b32
 any_mouse_down(TerminalInput *input)
 {
 	b32 result = input->keys[MOUSE_LEFT].ended_down   ||
 	             input->keys[MOUSE_RIGHT].ended_down  ||
 	             input->keys[MOUSE_MIDDLE].ended_down;
 	return result;
 }
 
 function b32
 all_mouse_up(TerminalInput *input)
 {
 	b32 result = !input->keys[MOUSE_LEFT].ended_down   &&
 	             !input->keys[MOUSE_RIGHT].ended_down  &&
 	             !input->keys[MOUSE_MIDDLE].ended_down;
 	return result;
 }
 
 function void
 button_action(ButtonState *button, b32 pressed)
 {
 	if (pressed != button->ended_down)
 		button->transitions++;
 	button->ended_down = pressed;
 }
 
 function b32
 pressed_last_frame(ButtonState *button)
 {
 	b32 result = (button->transitions > 1) || (button->ended_down && button->transitions == 1);
 	return result;
 }
 
 function s8
 utf8_encode(u32 cp)
 {
 	static u8 buf[4];
 	s8 result = {.data = buf};
 	if (cp <= 0x7F) {
 		result.len = 1;
 		buf[0] = cp & 0x7F;
 	} else if (cp <= 0x7FF) {
 		result.len = 2;
 		buf[0] = ((cp >>  6) & 0x1F) | 0xC0;
 		buf[1] = ((cp >>  0) & 0x3F) | 0x80;
 	} else if (cp <= 0xFFFF) {
 		result.len = 3;
 		buf[0] = ((cp >> 12) & 0x0F) | 0xE0;
 		buf[1] = ((cp >>  6) & 0x3F) | 0x80;
 		buf[2] = ((cp >>  0) & 0x3F) | 0x80;
 	} else if (cp <= 0x10FFFF) {
 		result.len = 4;
 		buf[0] = ((cp >> 18) & 0x07) | 0xF0;
 		buf[1] = ((cp >> 12) & 0x3F) | 0x80;
 		buf[2] = ((cp >>  6) & 0x3F) | 0x80;
 		buf[3] = ((cp >>  0) & 0x3F) | 0x80;
 	} else {
 		buf[0] = '?';
 		result.len = 1;
 	}
 	return result;
 }
 
 #include "extern/utf8_decode.c"