codegen/codegen/codegen.py

from pathlib import Path
from .utils import load_func_body_from_file
from .datatypes import (
    CDataType,
    CStruct,
    CEnum,
    CEnumVal,
    CFunc,
    CHeader,
    CSource,
    CArg,
    CType,
    CPointer,
    CPointerType,
    CQualifier,
    CInclude,
    CUserType,
    get_datatype_string,
)


def test_str8():
    struct = CStruct(
        name="Str8",
        cargs=[
            CArg(name="size", _type=CType.U64),
            CArg(name="capacity", _type=CType.U64),
            CArg(name="buf", _type=CType.U8, pointer=CPointer(_type=CPointerType.SINGLE)),
        ],
    )

    cenum = CEnum(
        name="OS",
        values=[
            CEnumVal(name="OS_LINUX"),
            CEnumVal(name="OS_WINDOWS"),
            CEnumVal(name="OS_MACOS"),
        ]
    )

    typed_enum = CEnum(
        name="Compiler",
        values=[
            CEnumVal(name="COMPILER_GCC"),
            CEnumVal(name="COMPILER_CLANG"),
            CEnumVal(name="COMPILER_MSVC"),
        ],
        typedef=True,
    )

    main_func = CFunc(
        name="my_custom_func",
        ret_type=CType.I32,
        args=[
            CArg(name="argc", _type=CType.I32),
            CArg(name="argv", _type=CType.CHAR, pointer=CPointer(_type=CPointerType.DOUBLE), qualifier=CQualifier.CONST),
        ],
        body="  return 0;"
    )

    header = CHeader(
        name="str",
        includes=[
            CInclude(header="aliases.h", local=True),
        ],
        types=[struct, cenum, typed_enum],
        funcs=[main_func],
    )

    source = CSource(
        name="str",
        includes=[
            CInclude(header=header, local=True),
            CInclude(header="aliases.h", local=True),
        ],
        types=[],
        internal_funcs=[],
        funcs=[main_func]
    )

    header.save(Path("."))
    source.save(Path("."))


def test_typed_array():
    datatypes = [CType.U8, CType.F32, CType.CHAR]
    types: list[CUserType] = []
    funcs: list[CFunc] = []

    getter_func_body = """\
  if(idx >= arr->size) {
    return 0;
  }

  return arr->data[idx];"""

    setter_func_body = """\
  if(idx >= arr->size) {
    return;
  }

  arr->data[idx] = val;"""

    for _type in datatypes:
        struct = CStruct(
            name=f"Array{str(_type).title()}".strip(),
            cargs=[
                CArg(name="size", _type=CType.U64),
                CArg(name="data", _type=_type, pointer=CPointer(_type=CPointerType.SINGLE)),
            ],
        )
        types.append(struct)

        funcs.append(CFunc(
            name=f"array_{str(_type)}_get",
            ret_type=_type,
            args=[
                CArg(name="arr", _type=struct, pointer=CPointer(_type=CPointerType.SINGLE), qualifier=CQualifier.CONST),
                CArg(name="idx", _type=CType.U64),
            ],
            body=getter_func_body,
        ))

        funcs.append(CFunc(
            name=f"array_{str(_type)}_set",
            ret_type=CType.VOID,
            args=[
                CArg(name="arr", _type=struct, pointer=CPointer(_type=CPointerType.SINGLE)),
                CArg(name="idx", _type=CType.U64),
                CArg(name="val", _type=_type)
            ],
            body=setter_func_body,
        ))

    header = CHeader(
        name="typed_array",
        includes=[
            CInclude(header="aliases.h", local=True)
        ],
        types=types,
        funcs=funcs
    )

    source = CSource(
        name="typed_array",
        includes=[
            CInclude(header="aliases.h", local=True),
            CInclude(header=header, local=True)
        ],
        funcs=funcs
    )

    header.save(Path("."))
    source.save(Path("."))


def test_doubly_linked_list():
    def __format_func_body(filename: Path, type_string: str):
        return load_func_body_from_file(filename).format(
            T=type_string,
            Tupper=type_string.upper(),
            Tlower=type_string.lower(),
        )

    datatypes: dict[CDataType, list[CInclude]] = {"Str8": [CInclude(header="str8.h", local=True)]}
    snippets_dir = Path(__file__).parent / "snippets"

    for _type, includes in datatypes.items():
        type_string = get_datatype_string(_type)

        node = CStruct(
            name=f"{type_string}Node",
            cargs=[
                CArg(name="string", _type=type_string, pointer=CPointer(_type=CPointerType.SINGLE)),
                CArg(name="prev", _type=f"{type_string}Node", pointer=CPointer(_type=CPointerType.SINGLE)),
                CArg(name="next", _type=f"{type_string}Node", pointer=CPointer(_type=CPointerType.SINGLE)),
            ],
        )
        
        dl_list = CStruct(
            name=f"{type_string}List",
            cargs=[
                CArg(name="first", _type=node, pointer=CPointer(_type=CPointerType.SINGLE)),
                CArg(name="last", _type=node, pointer=CPointer(_type=CPointerType.SINGLE)),
                CArg(name="total_size", _type=CType.U64),
                CArg(name="node_count", _type=CType.U64),
            ],
        )

        get_func = CFunc(
            name=f"wapp_{type_string.lower()}_list_get",
            ret_type=node,
            args=[
                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST),
                CArg(name="index", _type=CType.U64),
            ],
            body=__format_func_body(snippets_dir / "list_get", type_string),
            pointer=CPointer(CPointerType.SINGLE),
        )

        push_front_func = CFunc(
            name=f"wapp_{type_string.lower()}_list_push_front",
            ret_type=CType.VOID,
            args=[
                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
                CArg(name="node", _type=node, pointer=CPointer(CPointerType.SINGLE)),
            ],
            body=__format_func_body(snippets_dir / "list_push_front", type_string),
        )

        push_back_func = CFunc(
            name=f"wapp_{type_string.lower()}_list_push_back",
            ret_type=CType.VOID,
            args=[
                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
                CArg(name="node", _type=node, pointer=CPointer(CPointerType.SINGLE)),
            ],
            body=__format_func_body(snippets_dir / "list_push_back", type_string),
        )

        insert_func = CFunc(
            name=f"wapp_{type_string.lower()}_list_insert",
            ret_type=CType.VOID,
            args=[
                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
                CArg(name="node", _type=node, pointer=CPointer(CPointerType.SINGLE)),
                CArg(name="index", _type=CType.U64),
            ],
            body=__format_func_body(snippets_dir / "list_insert", type_string),
        )

        pop_front_func = CFunc(
            name=f"wapp_{type_string.lower()}_list_pop_front",
            ret_type=node,
            args=[
                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
            ],
            body=__format_func_body(snippets_dir / "list_pop_front", type_string),
            pointer=CPointer(CPointerType.SINGLE),
        )

        pop_back_func = CFunc(
            name=f"wapp_{type_string.lower()}_list_pop_back",
            ret_type=node,
            args=[
                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
            ],
            body=__format_func_body(snippets_dir / "list_pop_back", type_string),
            pointer=CPointer(CPointerType.SINGLE),
        )

        remove_func = CFunc(
            name=f"wapp_{type_string.lower()}_list_remove",
            ret_type=node,
            args=[
                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
                CArg(name="index", _type=CType.U64),
            ],
            body=__format_func_body(snippets_dir / "list_remove", type_string),
            pointer=CPointer(CPointerType.SINGLE),
        )

        empty_func = CFunc(
            name=f"wapp_{type_string.lower()}_list_empty",
            ret_type=CType.VOID,
            args=[
                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
            ],
            body=__format_func_body(snippets_dir / "list_empty", type_string),
        )

        node_to_list_func = CFunc(
            name=f"{type_string.lower()}_node_to_list",
            ret_type=dl_list,
            args=[
                CArg(name="node", _type=node, pointer=CPointer(CPointerType.SINGLE)),
            ],
            body=__format_func_body(snippets_dir / "node_to_list", type_string),
            qualifiers=[CQualifier.INTERNAL],
        )

        header = CHeader(
            name=f"{type_string.lower()}_list",
            includes=[CInclude(header="aliases.h", local=True)],
            types=[node, dl_list],
            funcs=[
                get_func,
                push_front_func,
                push_back_func,
                insert_func,
                pop_front_func,
                pop_back_func,
                remove_func,
                empty_func,
           ]
        )

        source = CSource(
            name=header.name,
            includes=[CInclude(header="aliases.h", local=True), CInclude(header, local=True), CInclude(header="stddef.h")],
            internal_funcs=[node_to_list_func],
            funcs=header.funcs
        )

        if len(includes) > 0:
            header.includes.extend(includes)
            source.includes.extend(includes)

        header.save(Path("."))
        source.save(Path("."))