odin-libui

parse.odin (8869B)

---

 package main
 
 import "core:bytes"
 import "core:fmt"
 import "core:strconv"
 import "core:strings"
 import "core:unicode"
 
 Struct :: struct {
 	name:   string,
 	fields: [dynamic]Struct_Field,
 }
 
 Struct_Field :: struct {
 	type:       string,
 	name:       string,
 	is_pointer: bool,
 	// Because we don't do generic expression parsing we must explicitly 
 	// allow for function pointers.
 	function:   Maybe(Function),
 }
 
 Function :: struct {
 	name:              string,
 	return_type:       string,
 	return_is_pointer: bool,
 	is_type:           bool,
 	args:              [dynamic]Function_Argument,
 }
 
 Function_Argument :: struct {
 	type:       string,
 	name:       string,
 	is_pointer: bool,
 	function:   Maybe(Function),
 }
 
 Enum :: struct {
 	name:     string,
 	type:     string,
 	variants: [dynamic]Enum_Variant,
 }
 
 Enum_Variant :: struct {
 	name:  string,
 	value: Maybe(uint),
 }
 
 Parser :: struct {
 	data:          []byte,
 	offset:        int,
 	line:          int,
 	column:        int,
 	enum_defs:     [dynamic]Enum,
 	struct_defs:   [dynamic]Struct,
 	function_defs: [dynamic]Function,
 }
 
 Parser_Proc :: #type proc(_: ^Parser)
 
 parser_parse_struct :: proc(p: ^Parser) {
 	struct_def: Struct
 	parser_consume(p, "struct")
 	parser_skip_space(p)
 	struct_def.name = parser_consume_identifier(p)
 	parser_skip_space(p)
 	if !parser_check(p, "{") do return // not all structs have bodies
 	parser_consume(p, "{")
 	for {
 		parser_skip_space(p)
 		if parser_check(p, "};") {
 			break
 		}
 		append(&struct_def.fields, parser_parse_struct_field(p))
 	}
 	parser_consume(p, "};")
 	append(&p.struct_defs, struct_def)
 }
 
 parser_check :: proc(p: ^Parser, text: string) -> bool {
 	return parser_peek(p, len(text)) == text
 }
 
 parser_consume :: proc(p: ^Parser, text: string) {
 	got := p.data[p.offset:p.offset + len(text)]
 	if !bytes.equal(got, transmute([]u8)text) {
 		panic(
 			fmt.tprintf(
 				"expected %q, got %q (offset=%d) (line=%d, col=%d) (context=%q)",
 				text,
 				got,
 				p.offset,
 				p.line + 1,
 				p.column,
 				p.data[p.offset - 10:p.offset + 10],
 			),
 		)
 	}
 	parser_skip_n(p, len(text))
 }
 
 parser_consume_identifier :: proc(p: ^Parser) -> string {
 	parser_skip_text(p, "const ")
 	parser_skip_text(p, "struct ")
 	start := p.offset
 	for {
 		if !is_ident(p.data[p.offset]) {
 			return cast(string)p.data[start:p.offset]
 		}
 		if !parser_advance(p) {
 			break
 		}
 	}
 	panic("EOF before identifier")
 }
 
 is_ident :: proc(b: byte) -> bool {
 	r := rune(b)
 	return unicode.is_letter(r) || unicode.is_digit(r) || b == '_'
 }
 
 parser_skip_space :: proc(p: ^Parser) -> bool {
 	start := p.offset
 	for {
 		if p.data[p.offset] == '/' {
 			parser_skip_comment(p)
 		}
 		if !unicode.is_space(rune(p.data[p.offset])) {
 			return p.offset != start
 		}
 		if !parser_advance(p) {
 			break
 		}
 	}
 	return false
 }
 
 parser_parse_struct_field :: proc(p: ^Parser) -> (field: Struct_Field) {
 	ident := parser_consume_identifier(p)
 	parser_skip_space(p)
 	if parser_check(p, "*") {
 		parser_consume(p, "*")
 		field.is_pointer = true
 	}
 	parser_skip_space(p)
 	if !parser_check(p, "(") {
 		field.name = parser_consume_identifier(p)
 	} else {
 		field.function = parser_parse_function_pointer(p)
 	}
 	parser_consume(p, ";")
 	// Special case to ensure that the return type is appropriately labeled. 
 	if field.function == nil {
 		field.type = ident
 	} else {
 		if f, ok := &field.function.?; ok {
 			f.return_type = ident
 		}
 	}
 	return
 }
 
 parser_parse_function_pointer :: proc(p: ^Parser) -> (f: Function) {
 	f.return_type = parser_consume_identifier(p)
 	parser_skip_space(p)
 	parser_consume(p, "(")
 	parser_skip_space(p)
 	parser_consume(p, "*")
 	parser_skip_space(p)
 	f.name = parser_consume_identifier(p)
 	parser_consume(p, ")")
 	parser_skip_space(p)
 	f.args = parser_parse_function_arguments(p)
 	return
 }
 
 parser_parse_function :: proc(p: ^Parser) {
 	f: Function
 	parser_consume(p, "_UI_EXTERN")
 	parser_skip_space(p)
 	f.return_type = parser_consume_identifier(p)
 	parser_skip_space(p)
 	if parser_check(p, "*") {
 		f.return_is_pointer = true
 		parser_consume(p, "*")
 	}
 	parser_skip_space(p)
 	f.name = parser_consume_identifier(p)
 	f.args = parser_parse_function_arguments(p)
 	parser_skip_space(p)
 	parser_consume(p, ";")
 	append(&p.function_defs, f)
 	return
 }
 
 parser_parse_function_arguments :: proc(p: ^Parser) -> (args: [dynamic]Function_Argument) {
 	parser_consume(p, "(")
 	for {
 		arg: Function_Argument
 		if parser_check(p, ")") {
 			break
 		}
 		parser_skip_space(p)
 		arg.type = parser_consume_identifier(p)
 		parser_skip_space(p)
 		if parser_check(p, "*") {
 			arg.is_pointer = true
 			parser_consume(p, "*")
 		}
 		parser_skip_space(p)
 		if parser_check(p, "(") {
 			fn := parser_parse_function_pointer(p)
 			fn.return_type = arg.type
 			arg.type = ""
 			arg.function = fn
 		} else {
 			arg.name = parser_consume_identifier(p)
 		}
 
 		if parser_check(p, ",") {
 			parser_consume(p, ",")
 		}
 		parser_skip_space(p)
 		append(&args, arg)
 	}
 	parser_consume(p, ")")
 	return
 }
 
 parser_skip_n :: proc(p: ^Parser, n: int = 1) {
 	for ii in 0 ..< n {
 		if !parser_advance(p) do return
 	}
 }
 
 parser_skip_text :: proc(p: ^Parser, text: string) {
 	if parser_check(p, text) {
 		parser_consume(p, text)
 	}
 }
 
 // TODO: might need to handle multiline preprocessor things
 parser_skip_preproccessor_stuff :: proc(p: ^Parser) -> bool {
 	if !parser_check(p, "#") {
 		return false
 	}
 	parser_skip_until(p, "\n")
 	return true
 }
 
 parser_parse_enum :: proc(p: ^Parser) {
 	enum_def: Enum
 	parser_consume(p, "_UI_ENUM")
 	parser_consume(p, "(")
 	enum_def.name = parser_consume_identifier(p)
 	parser_consume(p, ")")
 	parser_skip_space(p)
 	parser_consume(p, "{")
 	for {
 		variant: Enum_Variant
 		parser_skip_space(p)
 		if parser_check(p, "};") {
 			break
 		}
 		append(&enum_def.variants, parser_parse_enum_variant(p))
 	}
 	parser_consume(p, "};")
 	append(&p.enum_defs, enum_def)
 }
 
 parser_skip_comment :: proc(p: ^Parser) -> bool {
 	line_comment := parser_check(p, "//")
 	inline_comment := parser_check(p, "/*")
 
 	if line_comment {
 		parser_skip_until(p, "\n")
 		return true
 	}
 
 	if inline_comment {
 		parser_skip_until(p, "*/")
 		return true
 	}
 
 	return false
 }
 
 parser_skip_until :: proc(p: ^Parser, text: string) {
 	for {
 		if parser_check(p, text) {
 			defer parser_consume(p, text)
 			return
 		}
 		if !parser_advance(p) do return
 	}
 }
 
 parser_advance :: proc(p: ^Parser) -> bool {
 	if p.offset > len(p.data) - 1 {
 		return false
 	}
 	if p.data[p.offset] == '\n' {
 		p.line += 1
 		p.column = 0
 	}
 	p.column += 1
 	p.offset += 1
 	return p.offset < len(p.data)
 }
 
 parser_peek :: proc(p: ^Parser, n: int) -> string {
 	end := p.offset + n
 	if end > len(p.data) - 1 do return ""
 	return cast(string)p.data[p.offset:end]
 }
 
 bitwise_operators :: [?]string{"<<", ">>"}
 
 parser_parse_enum_variant :: proc(p: ^Parser) -> (variant: Enum_Variant) {
 	variant.name = parser_consume_identifier(p)
 	parser_skip_space(p)
 	if parser_check(p, "=") {
 		parser_consume(p, "=")
 		parser_skip_space(p)
 		n_1 := parser_parse_int(p)
 		parser_skip_space(p)
 		// Because some enums use bitshifting we have to account for that,
 		// but because we aren't doing proper expresion parsing it's total
 		// jank.
 		for op in bitwise_operators {
 			if !parser_check(p, op) do continue
 			parser_consume(p, op)
 			parser_skip_space(p)
 			n_2 := parser_parse_int(p)
 			switch op {
 			case "<<":
 				n_1 = n_1 << n_2
 			case ">>":
 				n_1 = n_1 << n_2
 			}
 		}
 		variant.value = n_1
 	}
 	parser_consume(p, ",")
 	return
 }
 
 parser_parse_int :: proc(p: ^Parser) -> uint {
 	start := p.offset
 	index: int
 	for unicode.is_digit(rune(p.data[p.offset + index])) {
 		index += 1
 	}
 	n, n_ok := strconv.parse_uint(cast(string)p.data[p.offset:p.offset + index])
 	if !n_ok {
 		panic("not a number")
 	}
 	parser_skip_n(p, index)
 	return n
 }
 
 // We are only handling typedef'd function pointers. 
 parser_parse_typedef :: proc(p: ^Parser) {
 	parser_consume(p, "typedef")
 	parser_skip_space(p)
 	if parser_check(p, "struct") {
 		parser_skip_until(p, ";")
 		return
 	}
 	function := parser_parse_function_pointer(p)
 	function.is_type = true
 	parser_skip_until(p, ";")
 	append(&p.function_defs, function)
 }
 
 keywords :: [?]string{"_UI_ENUM", "_UI_EXTERN", "typedef", "struct"}
 
 parser_parse :: proc(p: ^Parser, by: []byte) {
 	p.data = by
 
 	for p.offset < len(p.data) - 1 {
 		skipped_space := parser_skip_space(p)
 		skipped_comment := parser_skip_comment(p)
 		skipped_preprocessor := parser_skip_preproccessor_stuff(p)
 
 		start := p.offset
 
 
 		defer if !(skipped_space || skipped_comment || skipped_preprocessor) {
 			end := p.offset
 
 			if start == end {
 				parser_skip_n(p, 1)
 			}
 		}
 
 		for keyword in keywords {
 			if !parser_check(p, keyword) {
 				continue
 			}
 			switch keyword {
 			case "struct":
 				parser_parse_struct(p)
 			case "_UI_ENUM":
 				parser_parse_enum(p)
 			case "_UI_EXTERN":
 				parser_parse_function(p)
 			case "typedef":
 				parser_parse_typedef(p)
 			}
 		}
 	}
 }