odin-libui

gen.odin (7478B)

---

 package main
 
 import "core:bytes"
 import "core:fmt"
 import "core:io"
 import "core:strings"
 
 
 // generate the odin bindings.
 generate :: proc(wr: io.Writer, p: Parser) {
 	fmt.wprintf(wr, "// GENERATED CODE\n")
 	fmt.wprintf(wr, "package libui\n\n")
 
 	fmt.wprintln(wr, `import libc "core:c"`)
 	fmt.wprintln(wr, import_preamble)
 
 	// To handle the opaque (rawptr) types properly we want to avoid declaring
 	// them with a ^, since that would make them a pointer to a rawptr.
 	// However, we can only know if a type should be opaque if we haven't 
 	// encountered any definition for it (struct, enum, function). Thus as 
 	// quick and dirty hack, this logic will perform a dry run in order to 
 	// resolve opaque types. The second and true run then can omit the 
 	// superfluous caret appropriately.
 
 	dry_run: bytes.Buffer
 	write_everything(bytes.buffer_to_stream(&dry_run), p)
 
 	fmt.wprintln(wr, "// Unresolved symbols; typically opaque widget pointers")
 
 	outer: for type_name in idents {
 		for s in p.struct_defs {
 			if s.name == type_name {
 				continue outer
 			}
 		}
 		for e in p.enum_defs {
 			if e.name == type_name {
 				continue outer
 			}
 		}
 		for f in p.function_defs {
 			if f.name == type_name {
 				continue outer
 			}
 		}
 		opaque_types[type_name] = {}
 		fmt.wprintf(wr, "%s :: rawptr\n", ident(type_name))
 	}
 
 	fmt.wprintln(wr)
 
 	write_everything(wr, p)
 }
 
 write_everything :: proc(wr: io.Writer, p: Parser) {
 	fmt.println("writing edge-cases")
 
 	fmt.wprintln(wr, "// Hardcoded #defines ")
 	fmt.wprintf(wr, "DrawDefaultMiterLimit :: 10.0\n")
 	fmt.wprintln(wr)
 
 	fmt.wprintln(wr, "// Enum definitions")
 
 	/*
 		Enum definitions. 
 	*/
 
 	for enum_def in p.enum_defs {
 		fmt.println("writing", enum_def.name)
 		fmt.wprintf(wr, "%s :: enum {{\n", ident(enum_def.name))
 		for variant in enum_def.variants {
 			fmt.wprintf(wr, "\t%s", ident(variant.name))
 			if n, ok := variant.value.?; ok {
 				fmt.wprintf(wr, " = %d", n)
 			}
 			fmt.wprintf(wr, ",\n")
 		}
 		fmt.wprintf(wr, "}\n\n")
 	}
 
 	/*
 		Struct definitions. 
 	*/
 
 	fmt.wprintln(wr, "// Struct definitions")
 
 	// Explit case for tm (libc time struct)
 	fmt.wprintln(wr, broken_down_time_def)
 
 	for struct_def in p.struct_defs {
 		fmt.println("writing", struct_def.name)
 		fmt.wprintf(wr, "%s :: struct {{\n", ident(struct_def.name))
 		for field in struct_def.fields {
 			fn, fn_ok := field.function.?
 			if fn_ok {
 				fmt.wprintf(wr, "\t%s: %sproc", ident(fn.name), field.is_pointer ? "^" : "")
 				write_procedure_args(wr, fn.args[:])
 				if fn.return_type != "" && !(fn.return_type == "void" && !fn.return_is_pointer) {
 					fmt.wprintf(wr, " -> %s", ident(fn.return_type, fn.return_is_pointer, true))
 				}
 			} else {
 				fmt.wprintf(wr, "\t%s: %s", ident(field.name), ident(field.type, field.is_pointer))
 			}
 			fmt.wprintf(wr, ",\n")
 		}
 		fmt.wprintf(wr, "}\n\n")
 	}
 
 	/*
 		Procedure types are named proc types that are not part of the binding.
 	*/
 
 	fmt.wprintln(wr, "// Procedure types")
 
 	for function_def in p.function_defs {
 		if !function_def.is_type do continue
 		fmt.println("writing", function_def.name)
 		fmt.wprintf(
 			wr,
 			"%s :: %s proc",
 			ident(function_def.name),
 			function_def.is_type ? "#type" : "",
 		)
 		write_procedure_args(wr, function_def.args[:])
 		if function_def.return_type != "" &&
 		   !(function_def.return_type == "void" && !function_def.return_is_pointer) {
 			fmt.wprintf(
 				wr,
 				" -> %s",
 				ident(function_def.return_type, function_def.return_is_pointer, true),
 			)
 		}
 		if !function_def.is_type {
 			fmt.wprintf(wr, " ---")
 		}
 		fmt.wprintf(wr, "\n")
 	}
 
 	fmt.wprintf(wr, "\n")
 
 	/*
 		Procedure definitions. These procs are implemented by the library.
 	*/
 
 	fmt.wprintln(wr, "// Procedure definitions")
 
 	// TODO: maybe check for system installed version of libui.a?
 	// TODO: change to .lib for Windows with "where" clause
 	fmt.wprintln(wr, `@(default_calling_convention = "stdcall", link_prefix = "ui")`)
 	fmt.wprintf(wr, "foreign lib {{\n")
 
 	for function_def in p.function_defs {
 		if function_def.is_type do continue
 		fmt.println("writing", function_def.name)
 		fmt.wprintf(
 			wr,
 			"\t%s :: %s proc",
 			ident(function_def.name),
 			function_def.is_type ? "#type" : "",
 		)
 		write_procedure_args(wr, function_def.args[:])
 		if function_def.return_type != "" &&
 		   !(function_def.return_type == "void" && !function_def.return_is_pointer) {
 			fmt.wprintf(
 				wr,
 				" -> %s",
 				ident(function_def.return_type, function_def.return_is_pointer, true),
 			)
 		}
 		if !function_def.is_type {
 			fmt.wprintf(wr, " ---")
 		}
 		fmt.wprintf(wr, "\n")
 	}
 
 	fmt.wprintf(wr, "}\n")
 }
 
 write_procedure_args :: proc(wr: io.Writer, args: []Function_Argument) {
 	fmt.wprintf(wr, "(")
 	for arg, ii in args {
 		fn, fn_ok := arg.function.?
 		if fn_ok {
 			fmt.wprintf(wr, "%s: %sproc", ident(fn.name), arg.is_pointer ? "^" : "")
 			write_procedure_args(wr, fn.args[:])
 			if fn.return_type != "" && !(fn.return_type == "void" && !fn.return_is_pointer) {
 				fmt.wprintf(wr, " -> %s", ident(fn.return_type, fn.return_is_pointer))
 			}
 		} else {
 			if !(arg.type == "void" && !arg.is_pointer) {
 				fmt.wprintf(
 					wr,
 					"%s: %s",
 					arg.name == "" ? "_" : ident(arg.name),
 					ident(arg.type, arg.is_pointer, true),
 				)
 			}
 		}
 		if ii < len(args) - 1 {
 			fmt.wprintf(wr, ", ")
 		}
 	}
 	fmt.wprintf(wr, ")")
 }
 
 // opaque_types is a map of types that have no known definition. 
 // Such types will be defined as rawptr.
 opaque_types := map[string]struct {}{}
 
 // idents is a map of encoutered identifiers. Compared against
 // known defintions to figure out which types are opaque.
 idents := map[string]struct {}{}
 
 // ident strips off the "ui" prefix and does name replacements.
 //
 // opaque types (void pointers) must not be prefixed with ^ otherwise 
 // they become pointer-to-rawptr which is not correct.
 ident :: proc(text: string, is_pointer := false, is_type := false) -> string {
 	text := text
 
 	b := strings.Builder{}
 	strings.builder_init_none(&b, context.temp_allocator)
 
 	if is_pointer {
 		if _, ok := opaque_types[text]; !ok {
 			strings.write_string(&b, "^")
 		}
 	}
 
 	switch text {
 	case "int":
 		strings.write_string(&b, "libc.int")
 	case "uint32_t":
 		strings.write_string(&b, "libc.uint32_t")
 	case "uint64_t":
 		strings.write_string(&b, "libc.uint64_t")
 	case "uintptr_t":
 		strings.write_string(&b, "libc.uintptr_t")
 	case "size_t":
 		strings.write_string(&b, "libc.size_t")
 	case "void":
 		if is_pointer {
 			strings.builder_reset(&b)
 			strings.write_string(&b, "rawptr")
 		} else {
 			return ""
 		}
 	case "double":
 		strings.write_string(&b, "libc.double")
 	case "char":
 		if is_pointer {
 			strings.builder_reset(&b)
 			strings.write_string(&b, "cstring")
 		} else {
 			strings.write_string(&b, "byte")
 		}
 	case:
 		if is_type && text != "tm" && text != "int" {
 			idents[text] = {}
 		}
 		if strings.has_prefix(text, "ui") {
 			text = text[2:]
 		}
 		strings.write_string(&b, text)
 	}
 
 	return strings.to_string(b)
 }
 
 broken_down_time_def :: `
 // ISO C broken-down time structure.
 tm :: struct {
 	tm_sec: int,
 	tm_min: int,
 	tm_hour: int,
 	tm_mday: int,
 	tm_mon: int,
 	tm_year: int,
 	tm_wday: int,
 	tm_yday: int,
 	tm_isdst: int,
 }
 `
 
 import_preamble :: `
 when ODIN_OS == .Linux {
 	@(extra_linker_flags="-lgtk-3 -lgdk-3 -lz -lharfbuzz -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcairo -lcairo-gobject -lgdk_pixbuf-2.0 -lgio-2.0 -lglib-2.0 -lgobject-2.0")
 	foreign import lib "system:ui"
 } else {
 	foreign import lib "system:ui"
 }
 `