Method finish

crates/c/src/lib.rs:320–582

(&mut self, resolve: &Resolve, id: WorldId, files: &mut Files)

    }

    fn finish(&mut self, resolve: &Resolve, id: WorldId, files: &mut Files) -> Result<()> {
        let linking_symbol = component_type_object::linking_symbol(&self.world);
        self.c_include("<stdlib.h>");
        let snake = self.world.to_snake_case();
        uwriteln!(
            self.src.c_adapters,
            "\n// Ensure that the *_component_type.o object is linked in"
        );
        uwrite!(
            self.src.c_adapters,
            "
               extern void {linking_symbol}(void);
               __attribute__((used))
               void {linking_symbol}_public_use_in_this_compilation_unit(void) {{
                   {linking_symbol}();
               }}
           ",
        );

        self.print_intrinsics();

        if self.needs_string {
            self.c_include("<string.h>");
            let (strlen, size) = match self.opts.string_encoding {
                StringEncoding::UTF8 => (format!("strlen(s)"), 1),
                StringEncoding::UTF16 => {
                    self.h_include("<uchar.h>");
                    uwrite!(
                        self.src.h_helpers,
                        "
                            // Returns the length of the UTF-16 string `s` in code units
                            size_t {snake}_string_len(const char16_t* s);
                        ",
                    );
                    uwrite!(
                        self.src.c_helpers,
                        "
                            size_t {snake}_string_len(const char16_t* s) {{
                                char16_t* c = (char16_t*)s;
                                for (; *c; ++c);
                                return c-s;
                            }}
                        ",
                    );
                    (format!("{snake}_string_len(s)"), 2)
                }
                StringEncoding::CompactUTF16 => unimplemented!(),
            };
            let ty = self.char_type();
            let c_string_ty = match self.opts.string_encoding {
                StringEncoding::UTF8 => "char",
                StringEncoding::UTF16 => "char16_t",
                StringEncoding::CompactUTF16 => panic!("Compact UTF16 unsupported"),
            };
            uwrite!(
                self.src.h_helpers,
                "
                   // Sets the string `ret` to reference the input string `s` without copying it