#! /usr/bin/env python
#
# sysgen.py - System Generator
#
#
# Copyright (c) 2015, Wind River Systems, Inc.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1) Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2) Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# 3) Neither the name of Wind River Systems nor the names of its contributors
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#

# Arguments:
#   - name of MDEF file
#   - name of directory for output files (optional)

# Generates:
#   - kernel_main.c file
#   - kernel_main.h file (local copy)
#   - kernel_struct.h file (local copy)
#   - zephyr.h file

import os
import sys
import subprocess

# global variables describing system

num_kargs = 0
num_timers = 0
num_prios = 0

task_list = []
event_list = []
mutex_list = []
sema_list = []
fifo_list = []
pipe_list = []
mbx_list = []
map_list = []
pool_list = []

driver_list = []

group_dictionary = {}
group_key_list = []

# global variables used during generation of output files

do_not_edit_warning = \
    "\n\n\n/* THIS FILE IS AUTOGENERATED -- DO NOT MODIFY! */\n\n\n"

copyright = \
    "/*\n" + \
    " * Copyright (c) 2015 Wind River Systems, Inc.\n" + \
    " *\n" + \
    " * Redistribution and use in source and binary forms," + \
    " with or without\n" + \
    " * modification, are permitted provided that the following conditions" + \
    " are met:\n" + \
    " *\n" + \
    " * 1) Redistributions of source code must retain" + \
    " the above copyright notice,\n" + \
    " * this list of conditions and the following disclaimer.\n" + \
    " *\n" + \
    " * 2) Redistributions in binary form must reproduce" + \
    " the above copyright notice,\n" + \
    " * this list of conditions and the following disclaimer" + \
    " in the documentation\n" + \
    " * and/or other materials provided with the distribution.\n" + \
    " *\n" + \
    " * 3) Neither the name of Wind River Systems nor the names" + \
    " of its contributors\n" + \
    " * may be used to endorse or promote products derived" + \
    " from this software without\n" + \
    " * specific prior written permission.\n" + \
    " *\n" + \
    " * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS" + \
    " AND CONTRIBUTORS \"AS IS\"\n" + \
    " * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING," + \
    " BUT NOT LIMITED TO, THE\n" + \
    " * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS" + \
    " FOR A PARTICULAR PURPOSE\n" + \
    " * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER" + \
    " OR CONTRIBUTORS BE\n" + \
    " * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL," + \
    " EXEMPLARY, OR\n" + \
    " * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO," + \
    " PROCUREMENT OF\n" + \
    " * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;" + \
    " OR BUSINESS\n" + \
    " * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY," + \
    " WHETHER IN\n" + \
    " * CONTRACT, STRICT LIABILITY, OR TORT" + \
    " (INCLUDING NEGLIGENCE OR OTHERWISE)\n" + \
    " * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE," + \
    " EVEN IF ADVISED OF THE\n" + \
    " * POSSIBILITY OF SUCH DAMAGE.\n" + \
    " */\n"

output_dir = ""


def get_output_dir():
    """ Handle optional output directory argument """

    global output_dir
    if len(sys.argv) > 2:
        output_dir = sys.argv[2]


def write_file(filename, contents):
    """ Create file using specified name and contents """

    f = open(filename, 'w')    # overwrites file if it already exists
    f.write(contents)
    f.close()


#
# ERROR HANDLING
#


def sysgen_error(msg):
    print("\n*** sysgen error: " + msg + "\n")
    sys.exit(1)


def error_arg_count(line):
    sysgen_error("invalid number of arguments on following line\n" + line)


#
# CREATE INTERNAL REPRESENTATION OF SYSTEM
#


def mdef_parse():
    """ Parse MDEF file """

    global num_kargs
    global num_timers
    global num_prios

    # read file contents in a single shot
    with open(sys.argv[1], 'r') as infile:
        data = infile.read()

    # create list of the lines, breaking at line boundaries
    my_list = data.splitlines()

    # process each line
    for line in my_list:
        words = line.split()

        if (len(words) == 0):
            continue    # ignore blank line

        if (words[0][0] == "%"):
            continue    # ignore comment line

        if (words[0] == "CONFIG"):
            if (len(words) != 4):
                error_arg_count(line)
            num_kargs = int(words[1])
            num_timers = int(words[2])
            num_prios = int(words[3])
            continue

        if (words[0] == "TASK"):
            if (len(words) != 6):
                error_arg_count(line)
            task_list.append((words[1], int(words[2]), words[3],
                              int(words[4]), words[5]))
            continue

        if (words[0] == "TASKGROUP"):
            if (len(words) != 2):
                error_arg_count(line)
            if words[1] in group_dictionary:
                continue    # ignore re-definition of a task group
            group_bitmask = 1 << len(group_dictionary)
            group_dictionary[words[1]] = group_bitmask
            group_key_list.append(words[1])
            continue

        if (words[0] == "EVENT"):
            if (len(words) != 3):
                error_arg_count(line)
            event_list.append((words[1], words[2]))
            continue

        if (words[0] == "SEMA"):
            if (len(words) != 2):
                error_arg_count(line)
            sema_list.append((words[1],))
            continue

        if (words[0] == "MUTEX"):
            if (len(words) != 2):
                error_arg_count(line)
            mutex_list.append((words[1],))
            continue

        if (words[0] == "FIFO"):
            if (len(words) != 4):
                error_arg_count(line)
            fifo_list.append((words[1], int(words[2]), int(words[3])))
            continue

        if (words[0] == "PIPE"):
            if (len(words) != 3):
                error_arg_count(line)
            pipe_list.append((words[1], int(words[2])))
            continue

        if (words[0] == "MAILBOX"):
            if (len(words) != 2):
                error_arg_count(line)
            mbx_list.append((words[1],))
            continue

        if (words[0] == "MAP"):
            if (len(words) != 4):
                error_arg_count(line)
            map_list.append((words[1], int(words[2]), int(words[3])))
            continue

        if (words[0] == "POOL"):
            if (len(words) != 5):
                error_arg_count(line)
            pool_list.append((words[1], int(words[2]), int(words[3]),
                              int(words[4])))
            continue

        if (words[0] == "TIMERDRIVER"):
            if (len(words) == 1):
                error_arg_count(line)
            if (num_timers == 0):
                continue    # ignore timer driver for a tickless microkernel
            start_quote = line.find("'")
            end_quote = line.rfind("'")
            driver_list.append(line[start_quote + 1:end_quote])
            continue

        if (words[0] == "USERDRIVER"):
            if (len(words) == 1):
                error_arg_count(line)
            start_quote = line.find("'")
            end_quote = line.rfind("'")
            driver_list.append(line[start_quote + 1:end_quote])
            continue

        sysgen_error("unrecognized keyword %s on following line\n%s" %
                     (words[0], line))


#
# GENERATE kernel_main.c FILE
#


kernel_main_c_data = ""

kernel_main_c_filename_str = \
    "/* kernel_main.c - microkernel mainline and kernel objects */\n\n"


def kernel_main_c_out(string):
    """ Append a string to kernel_main.c """

    global kernel_main_c_data
    kernel_main_c_data += string


def kernel_main_c_header():
    """ Generate initial portion of kernel_main.c """

    kernel_main_c_out(
        kernel_main_c_filename_str +
        copyright +
        do_not_edit_warning +
        "\n" +
        "#include <zephyr.h>\n" +
        "#include <drivers/system_timer.h>\n" +
        "#include <kernel_struct.h>\n" +
        "#include <kernel_main.h>\n" +
        "#include <toolchain.h>\n" +
        "#include <sections.h>\n")


def kernel_main_c_kargs():
    """ Generate command packet variables """

    # command packets

    kernel_main_c_out("\n" +
        "struct k_args _k_server_command_packets[%s] =\n" % (num_kargs) +
        "{\n" +
        "    {NULL, NULL, 0, 0, (K_COMM) UNDEFINED},\n")
    for i in range(1, num_kargs - 1):
        kernel_main_c_out(
            "    {&_k_server_command_packets[%d], " % (i - 1) +
            "NULL, 0, 0, (K_COMM) UNDEFINED},\n")
    kernel_main_c_out(
        "    {&_k_server_command_packets[%d], " % (num_kargs - 2) +
        "NULL, 0, 0, (K_COMM) UNDEFINED}\n" +
        "};\n")

    # linked list of free command packets

    kernel_main_c_out("\n" +
        "struct nano_lifo _k_server_command_packet_free = " +
        "{{NULL, &_k_server_command_packet_free.wait_q.head}, " +
        "(void *) &_k_server_command_packets[%d]};\n" % (num_kargs - 1))


def kernel_main_c_timers():
    """ Generate timer system variables """

    if (num_timers == 0):
        return

    # timer descriptors

    kernel_main_c_out("\n" +
        "struct k_timer _k_timer_blocks[%d] =\n" % (num_timers) +
        "{\n" +
        "    {NULL, NULL, 0, 0, (struct k_args *)0xffffffff},\n")
    for i in range(1, num_timers - 1):
        kernel_main_c_out(
            "    {&_k_timer_blocks[%d], " % (i - 1) +
            "NULL, 0, 0, (struct k_args *)0xffffffff},\n")
    kernel_main_c_out(
        "    {&_k_timer_blocks[%d], " % (num_timers - 2) +
        "NULL, 0, 0, (struct k_args *)0xffffffff}\n" +
        "};\n")

    # linked list of free timers

    kernel_main_c_out("\n" +
        "struct nano_lifo _k_timer_free = " +
        "{{NULL, &_k_timer_free.wait_q.head}, " +
        "(void *) &_k_timer_blocks[%d]};\n" % (num_timers - 1))


def kernel_main_c_tasks():
    """ Generate task variables """

    global num_prios

    total_tasks = len(task_list) + 1

    # task global variables

    kernel_main_c_out("\nint _k_task_count = %d;\n" % (total_tasks - 1))

    # task stack areas

    kernel_main_c_out("\n")
    for task in task_list:
        kernel_main_c_out("char __noinit __stack __%s_stack[%d];\n" %
                          (task[0], task[3]))

    kernel_main_c_out("extern char main_task_stack[CONFIG_MAIN_STACK_SIZE];\n")

    # declare task entry points

    kernel_main_c_out("\n")
    for task in task_list:
        kernel_main_c_out("extern void %s(void);\n" % task[2])

    # task descriptors (including one for idle task)

    kernel_main_c_out("\n" +
        "struct k_proc _k_task_list[%d] =\n" % (total_tasks) +
        "{\n")
    ident = 0x00010000
    for task in task_list:
        prio = task[1]
        entry = task[2]
        size = task[3]

        stack = "__" + task[0] + "_stack"

        # create bitmask of group(s) task belongs to
        group_bitmask = 0
        group_set = task[4][1:len(task[4]) - 1]   # drop [] surrounding groups
        if (group_set != ""):
            group_list = group_set.split(',')
            for group in group_list:
                group_bitmask |= group_dictionary[group]

        # invert bitmask to convert SYS indication to non-SYS indication
        #
        # NOTE: There actually is no SYS group; instead, there is a non-SYS
        # group that all tasks belong to unless they specify the 'SYS' name.
        # This approach allows the kernel to easily suspend all non-SYS tasks
        # during debugging, while minimizing the number of task entries that
        # have to explicitly indicate their SYS/non-SYS status.
        group_bitmask ^= group_dictionary['SYS']

        kernel_main_c_out(
            "    {NULL, NULL, %d, %#010x, " % (prio, ident) +
            "0x00000001, %#010x,\n" % (group_bitmask) +
            "%s, %s, %d, (taskabortfunction)NULL},\n" % (entry, stack, size))
        ident += 1

    kernel_main_c_out("    {NULL, NULL, %d, 0x00000000, " % (num_prios - 1) +
        "0x00000000, 0x00000000,\n" +
        "(taskstartfunction)NULL, main_task_stack, CONFIG_MAIN_STACK_SIZE, " +
        "(taskabortfunction)NULL}\n")
    kernel_main_c_out("};\n")

    # currently scheduled task (idle task)

    kernel_main_c_out("\n" +
        "struct k_proc * _k_current_task = &_k_task_list[%d];\n" %
        (total_tasks - 1))


def kernel_main_c_priorities():
    """ Generate task scheduling variables """

    global num_prios

    total_tasks = len(task_list) + 1

    # priority queue descriptors (lowest priority queue contains idle task)

    kernel_main_c_out("\n" +
        "struct k_tqhd _k_task_priority_list[%d] =\n" % (num_prios) +
        "{\n")
    for i in range(1, num_prios):
        kernel_main_c_out(
            "    {NULL, (struct k_proc *)&_k_task_priority_list[%d]},\n" %
            (i - 1))
    kernel_main_c_out(
        "    {&_k_task_list[%d], &_k_task_list[%d]}\n" %
        (total_tasks - 1, total_tasks - 1) +
        "};\n")

    # active priority queue (idle task's queue)

    kernel_main_c_out("\n" +
        "struct k_tqhd * K_Prio = &_k_task_priority_list[%d];\n" %
        (num_prios - 1))

    # priority queue bit map (indicates which priority queues are non-empty;
    # initially only the idle task's queue has a runnable task)

    num_bit_maps = ((num_prios + 31) // 32)

    kernel_main_c_out("\n" +
        "uint32_t _k_task_priority_bitmap[%d] = {" % (num_bit_maps))
    for i in range(1, num_bit_maps):
        kernel_main_c_out("0, ")
    kernel_main_c_out("(1u << %d)};\n" % ((num_prios - 1) & 0x1f))


def kernel_main_c_events():
    """ Generate event variables """

    total_events = 4 + len(event_list)

    # event descriptors

    kernel_main_c_out("\n" +
        "struct evstr _k_event_list[%d] =\n" % (total_events) +
        "{\n")
    # pre-defined events
    if (num_timers > 0):
        kernel_main_c_out(
            "    {0, (kevent_handler_t)_k_ticker, " +
            "(struct k_args *)NULL, 0},\n")
    else:
        kernel_main_c_out(
            "    {0, (kevent_handler_t)NULL, (struct k_args *)NULL, 0},\n")
    kernel_main_c_out(
        "    {0, (kevent_handler_t)NULL, (struct k_args *)NULL, 0},\n" +
        "    {0, (kevent_handler_t)NULL, (struct k_args *)NULL, 0},\n" +
        "    {0, (kevent_handler_t)NULL, (struct k_args *)NULL, 0},\n"
    )
    # project-specific events
    for event in event_list:
        kernel_main_c_out(
            "    {0, (kevent_handler_t)%s, (struct k_args *)NULL, 0},\n" %
            (event[1]))
    kernel_main_c_out("};\n")

    # number of events

    kernel_main_c_out("\n" +
        "const int _k_num_events = %d;\n" % (total_events))

    # event object identifiers (for project-defined events only)

    if (len(event_list) > 0):
        kernel_main_c_out("\n")

        for event_name in event_list:
            kernel_main_c_out(
                "const kevent_t %s_objId = %s;\n" %
                (event_name[0], event_name[0]))


def kernel_main_c_mutexes():
    """ Generate mutex variables """

    total_mutexes = len(mutex_list)

    if (total_mutexes == 0):
        kernel_main_c_out("\nstruct mutex_struct * _k_mutex_list = NULL;\n")
        return

    # mutex descriptors

    kernel_main_c_out("\n" +
        "struct mutex_struct _k_mutex_list[%s] =\n" % (total_mutexes) +
        "{\n")
    for mutex in mutex_list:
        kernel_main_c_out("    {ANYTASK, 64, 64, 0, NULL, 0, 0},\n")
    kernel_main_c_out("};\n")
    kernel_main_c_out("\n")

    # mutex object identifiers

    for mutex in mutex_list:
        name = mutex[0]
        kernel_main_c_out("const kmutex_t %s_objId = %s;\n" % (name, name))


def kernel_main_c_semas():
    """ Generate semaphore variables """

    total_semas = len(sema_list)

    if (total_semas == 0):
        kernel_main_c_out("\nstruct sem_struct * _k_sem_list = NULL;\n")
        return

    # semaphore descriptors

    kernel_main_c_out("\n" +
        "struct sem_struct _k_sem_list[%s] =\n" % (total_semas) +
        "{\n")
    for semaphore in sema_list:
        kernel_main_c_out("    {NULL, 0, 0},\n")
    kernel_main_c_out("};\n")


def kernel_main_c_fifos():
    """ Generate FIFO variables """

    total_fifos = len(fifo_list)

    if (total_fifos == 0):
        kernel_main_c_out("\nstruct que_struct * _k_fifo_list = NULL;\n")
        return

    # FIFO buffers

    kernel_main_c_out("\n")

    for fifo in fifo_list:
        kernel_main_c_out(
            "char __noinit __%s_buffer[%d];\n" % (fifo[0], fifo[1] * fifo[2]))

    # FIFO descriptors

    kernel_main_c_out("\n" +
        "struct que_struct _k_fifo_list[%s] =\n" % (total_fifos) +
        "{\n"
    )
    for fifo in fifo_list:
        depth = fifo[1]
        width = fifo[2]
        buffer = "__" + fifo[0] + "_buffer"
        kernel_main_c_out(
            "    {%d, %d, %s, %s + (%d * %d),\n" %
            (depth, width, buffer, buffer, depth, width) +
            "%s, %s, NULL, 0, 0, 0},\n" %
            (buffer, buffer))
    kernel_main_c_out("};\n")


def kernel_main_c_pipes():
    """ Generate pipe variables """

    total_pipes = len(pipe_list)

    # pipe global variables

    kernel_main_c_out("\nint _k_pipe_count = %d;\n" % (total_pipes))

    if (total_pipes == 0):
        kernel_main_c_out("\nstruct pipe_struct * _k_pipe_list = NULL;\n")
        return

    # pipe buffers

    kernel_main_c_out("\n")

    for pipe in pipe_list:
        kernel_main_c_out(
            "char __noinit __%s_buffer[%d];\n" % (pipe[0], pipe[1]))

    # pipe descriptors

    kernel_main_c_out("\n" +
        "struct pipe_struct _k_pipe_list[%d] =\n" % (total_pipes) +
        "{\n")
    for pipe in pipe_list:
        size = pipe[1]
        buffer = "__" + pipe[0] + "_buffer"
        kernel_main_c_out("    {%d, %s},\n" % (size, buffer))
    kernel_main_c_out("};\n")


def kernel_main_c_mailboxes():
    """ Generate mailbox variables """

    total_mbxs = len(mbx_list)

    if (total_mbxs == 0):
        kernel_main_c_out("\nstruct mbx_struct * _k_mbox_list = NULL;\n")
        return

    # mailbox descriptors

    kernel_main_c_out("\n" +
        "struct mbx_struct _k_mbox_list[%d] =\n" % (total_mbxs) +
        "{\n")
    for mbx in mbx_list:
        kernel_main_c_out("    {NULL, NULL, 0},\n")
    kernel_main_c_out("};\n")


def kernel_main_c_maps():
    """ Generate memory map variables """

    total_maps = len(map_list)

    # map global variables

    kernel_main_c_out("\nint _k_mem_map_count = %d;\n" % (total_maps))

    if (total_maps == 0):
        kernel_main_c_out("\nstruct map_struct * _k_mem_map_list = NULL;\n")
        return

    # memory map buffers

    kernel_main_c_out("\n")

    for map in map_list:
        blocks = map[1]
        block_size = map[2]
        kernel_main_c_out("char __noinit __MAP_%s_buffer[%d];\n" %
                    (map[0], blocks * block_size))

    # memory map descriptors

    kernel_main_c_out(
        "\nstruct map_struct _k_mem_map_list[%d] =\n{\n" % (total_maps))
    for map in map_list:
        blocks = map[1]
        block_size = map[2]
        kernel_main_c_out("    { %d, %d, __MAP_%s_buffer },\n" %
                    (blocks, block_size, map[0]))
    kernel_main_c_out("};\n")


def kernel_main_c_pools():
    """ Generate memory pool variables """

    total_pools = len(pool_list)

    # pool global variables

    kernel_main_c_out("\nint _k_mem_pool_count = %d;\n" % (total_pools))

    if (total_pools == 0):
        kernel_main_c_out("\nstruct pool_struct * _k_mem_pool_list = NULL;\n")
        return

    # start accumulating memory pool descriptor info

    pool_descriptors = "\nstruct pool_struct _k_mem_pool_list[%d] =\n{\n" % \
                        (total_pools)
    ident = 0x00010000

    for pool in pool_list:

        kernel_main_c_out("\n")

        # create local variables relating to current pool

        min_block_size = pool[1]
        max_block_size = pool[2]
        num_maximal_blocks = pool[3]
        total_memory = max_block_size * num_maximal_blocks
        buffer = "__" + pool[0] + "_buffer"
        frag_table = "fragtab_%#010x" % ident

        # determine block sizes used by pool (including actual minimum size)

        frag_size_list = [max_block_size]
        while (ident != 0):    # loop forever
            min_block_size_actual = frag_size_list[len(frag_size_list) - 1]
            min_block_size_proposed = min_block_size_actual / 4
            if (min_block_size_proposed < min_block_size):
                break
            frag_size_list.append(min_block_size_proposed)
        frag_levels = len(frag_size_list)

        # determine size of block status arrays
        # - largest size gets special handling
        # - remainder of algorithm is a complete mystery ...

        block_status_sizes = [(num_maximal_blocks + 3) / 4]
        block_status_size_to_use = num_maximal_blocks
        for index in range(1, frag_levels):
            block_status_sizes.append(block_status_size_to_use)
            block_status_size_to_use *= 4

        # generate block status areas

        for index in range(0, frag_levels):
            kernel_main_c_out(
                "struct block_stat blockstatus_%#010x_%d[%d];\n" %
                (ident, index, block_status_sizes[index]))

        # generate memory pool fragmentation descriptor

        kernel_main_c_out("\nstruct pool_block %s[%d] =\n{\n" %
                        (frag_table, frag_levels))
        for index in range(0, frag_levels):
            kernel_main_c_out("    { %d, %d, blockstatus_%#010x_%d},\n" %
                (frag_size_list[index], block_status_sizes[index],
                 ident, index))
        kernel_main_c_out("};\n")

        # generate memory pool buffer

        kernel_main_c_out("\nchar __noinit %s[%d];\n" % (buffer, total_memory))

        # append memory pool descriptor info

        pool_descriptors += "    {%d, %d, 2, %d, %d, %d, NULL, %s, %s},\n" % \
            (max_block_size, min_block_size_actual, total_memory,
            num_maximal_blocks, frag_levels, frag_table, buffer)

        ident += 1

    # generate memory pool descriptor info

    pool_descriptors += "};\n"
    kernel_main_c_out(pool_descriptors)


def kernel_main_c_kernel_services():
    """ Generate kernel services function table """

    # initialize table with info for all possible kernel services

    func_table = [
"/*  0 */ _k_nop,",                               # required
"/*  1 */ _k_movedata_request,",                  # required
"/*  2 */ (kernelfunc) NULL,",                    # unused
"/*  3 */ (kernelfunc) NULL,",                    # unused
"/*  4 */ _k_offload_to_fiber,",                  # required
"/*  5 */ _k_workload_get,",                      # required
"/*  6 */ _k_sem_signal,",                        # depends on semaphores
"/*  7 */ _k_sem_group_signal,",                  # depends on semaphores
"/*  8 */ _k_sem_reset,",                         # depends on semaphores
"/*  9 */ _k_sem_group_reset,",                   # depends on semaphores
"/* 10 */ _k_sem_wait_request,",                  # depends on semaphores
"/* 11 */ _k_sem_wait_reply,",                    # depends on semaphores
"/* 12 */ _k_sem_wait_reply,",                    # depends on semaphores and
                                                  #  timers
"/* 13 */ _k_sem_group_wait_any,",                # depends on semaphores
"/* 14 */ _k_sem_group_wait_request,",            # depends on semaphores
"/* 15 */ _k_sem_group_ready,",                   # depends on semaphores
"/* 16 */ _k_sem_group_wait_cancel,",             # depends on semaphores
"/* 17 */ _k_sem_group_wait_accept,",             # depends on semaphores
"/* 18 */ _k_sem_group_wait,",                    # depends on semaphores
"/* 19 */ _k_sem_group_wait_timeout,",            # depends on semaphores
                                                  #  (but not timers)
"/* 20 */ _k_sem_inquiry,",                       # depends on semaphores
"/* 21 */ _k_mutex_lock_request,",                # depends on mutexes
"/* 22 */ _k_mutex_lock_reply,",                  # depends on mutexes
"/* 23 */ _k_mutex_lock_reply,",                  # depends on mutexes and
                                                  #  timers
"/* 24 */ _k_mutex_unlock,",                      # depends on mutexes
"/* 25 */ _k_fifo_enque_request,",                # depends on FIFOs
"/* 26 */ _k_fifo_enque_reply,",                  # depends on FIFOs
"/* 27 */ _k_fifo_enque_reply,",                  # depends on FIFOs and timers
"/* 28 */ _k_fifo_deque_request,",                # depends on FIFOs
"/* 29 */ _k_fifo_deque_reply,",                  # depends on FIFOs
"/* 30 */ _k_fifo_deque_reply,",                  # depends on FIFOs and timers
"/* 31 */ _k_fifo_ioctl,",                        # depends on FIFOs
"/* 32 */ _k_mbox_send_request,",                 # depends on mailboxes
"/* 33 */ _k_mbox_send_reply,",                   # depends on mailboxes and
                                                  #  timers
"/* 34 */ _k_mbox_send_ack,",                     # depends on mailboxes
"/* 35 */ _k_mbox_send_data,",                    # depends on mailboxes
"/* 36 */ _k_mbox_receive_request,",              # depends on mailboxes
"/* 37 */ _k_mbox_receive_reply,",                # depends on mailboxes and
                                                  #  timers
"/* 38 */ _k_mbox_receive_ack,",                  # depends on mailboxes
"/* 39 */ _k_mbox_receive_data,",                 # depends on mailboxes
"/* 40 */ _k_time_elapse,",                       # depends on timers
"/* 41 */ _k_task_sleep,",                        # depends on timers
"/* 42 */ _k_task_wakeup,",                       # depends on timers
"/* 43 */ _k_task_op,",                           # required
"/* 44 */ _k_task_group_op,",                     # required
"/* 45 */ _k_task_priority_set,",                 # required
"/* 46 */ _k_task_yield,",                        # required
"/* 47 */ _k_mem_map_alloc,",                     # depends on memory maps
"/* 48 */ _k_mem_map_dealloc,",                   # depends on memory maps
"/* 49 */ _k_timer_alloc,",                       # depends on timers
"/* 50 */ _k_timer_dealloc,",                     # depends on timers
"/* 51 */ _k_timer_start,",                       # depends on timers
"/* 52 */ _k_timer_stop,",                        # depends on timers
"/* 53 */ _k_mem_map_alloc_timeout,",             # depends on memory maps and
                                                  #  timers
"/* 54 */ (kernelfunc) NULL,",                    # unused
"/* 55 */ (kernelfunc) NULL,",                    # unused
"/* 56 */ (kernelfunc) NULL,",                    # unused
"/* 57 */ (kernelfunc) NULL,",                    # unused
"/* 58 */ _k_event_test,",                        # required
"/* 59 */ _k_event_handler_set,",                 # required
"/* 60 */ _k_event_signal,",                      # required
"/* 61 */ _k_mem_pool_block_get,",                # depends on memory pools
"/* 62 */ _k_mem_pool_block_release,",            # depends on memory pools
"/* 63 */ _k_block_waiters_get,",                 # depends on memory pools
"/* 64 */ _k_mem_pool_block_get_timeout_handle,",  # depends on memory pools
                                                   #  and timers
"/* 65 */ _k_defrag,",                            # depends on memory pools
"/* 66 */ (kernelfunc) NULL,",                    # unused
"/* 67 */ (kernelfunc) NULL,",                    # unused
"/* 68 */ (kernelfunc) NULL,",                    # unused
"/* 69 */ (kernelfunc) NULL,",                    # unused
"/* 70 */ (kernelfunc) NULL,",                    # unused
"/* 71 */ (kernelfunc) NULL,",                    # unused
"/* 72 */ K_ChSendReq,",                          # depends on pipes
"/* 73 */ K_ChSendTmo,",                          # depends on pipes and timers
"/* 74 */ K_ChSendRpl,",                          # depends on pipes
"/* 75 */ K_ChSendAck,",                          # depends on pipes
"/* 76 */ K_ChRecvReq,",                          # depends on pipes
"/* 77 */ K_ChRecvTmo,",                          # depends on pipes and timers
"/* 78 */ K_ChRecvRpl,",                          # depends on pipes
"/* 79 */ K_ChRecvAck,",                          # depends on pipes
"/* 80 */ K_ChMovedAck,",                         # depends on pipes
"/* 81 */ _k_event_test_timeout"                  # depends on timers
    ]

    # eliminate table entries for kernel services that project doesn't utilize
    # (note: some entries can be eliminated for more than one reason)

    if (len(sema_list) == 0):
        func_table[6] = "/*  6 */ (kernelfunc) NULL,"
        func_table[7] = "/*  7 */ (kernelfunc) NULL,"
        func_table[8] = "/*  8 */ (kernelfunc) NULL,"
        func_table[9] = "/*  9 */ (kernelfunc) NULL,"
        func_table[10] = "/* 10 */ (kernelfunc) NULL,"
        func_table[11] = "/* 11 */ (kernelfunc) NULL,"
        func_table[12] = "/* 12 */ (kernelfunc) NULL,"
        func_table[13] = "/* 13 */ (kernelfunc) NULL,"
        func_table[14] = "/* 14 */ (kernelfunc) NULL,"
        func_table[15] = "/* 15 */ (kernelfunc) NULL,"
        func_table[16] = "/* 16 */ (kernelfunc) NULL,"
        func_table[17] = "/* 17 */ (kernelfunc) NULL,"
        func_table[18] = "/* 18 */ (kernelfunc) NULL,"
        func_table[19] = "/* 19 */ (kernelfunc) NULL,"
        func_table[20] = "/* 20 */ (kernelfunc) NULL,"

    if (len(mutex_list) == 0):
        func_table[21] = "/* 21 */ (kernelfunc) NULL,"
        func_table[22] = "/* 22 */ (kernelfunc) NULL,"
        func_table[23] = "/* 23 */ (kernelfunc) NULL,"
        func_table[24] = "/* 24 */ (kernelfunc) NULL,"

    if (len(fifo_list) == 0):
        func_table[25] = "/* 25 */ (kernelfunc) NULL,"
        func_table[26] = "/* 26 */ (kernelfunc) NULL,"
        func_table[27] = "/* 27 */ (kernelfunc) NULL,"
        func_table[28] = "/* 28 */ (kernelfunc) NULL,"
        func_table[29] = "/* 29 */ (kernelfunc) NULL,"
        func_table[30] = "/* 30 */ (kernelfunc) NULL,"
        func_table[31] = "/* 31 */ (kernelfunc) NULL,"

    if (len(mbx_list) == 0):
        func_table[32] = "/* 32 */ (kernelfunc) NULL,"
        func_table[33] = "/* 33 */ (kernelfunc) NULL,"
        func_table[34] = "/* 34 */ (kernelfunc) NULL,"
        func_table[35] = "/* 35 */ (kernelfunc) NULL,"
        func_table[36] = "/* 36 */ (kernelfunc) NULL,"
        func_table[37] = "/* 37 */ (kernelfunc) NULL,"
        func_table[38] = "/* 38 */ (kernelfunc) NULL,"
        func_table[39] = "/* 39 */ (kernelfunc) NULL,"

    if (len(map_list) == 0):
        func_table[47] = "/* 47 */ (kernelfunc) NULL,"
        func_table[48] = "/* 48 */ (kernelfunc) NULL,"
        func_table[53] = "/* 53 */ (kernelfunc) NULL,"

    if (len(pool_list) == 0):
        func_table[61] = "/* 61 */ (kernelfunc) NULL,"
        func_table[62] = "/* 62 */ (kernelfunc) NULL,"
        func_table[63] = "/* 63 */ (kernelfunc) NULL,"
        func_table[64] = "/* 64 */ (kernelfunc) NULL,"
        func_table[65] = "/* 65 */ (kernelfunc) NULL,"

    if (len(pipe_list) == 0):
        func_table[72] = "/* 72 */ (kernelfunc) NULL,"
        func_table[73] = "/* 73 */ (kernelfunc) NULL,"
        func_table[74] = "/* 74 */ (kernelfunc) NULL,"
        func_table[75] = "/* 75 */ (kernelfunc) NULL,"
        func_table[76] = "/* 76 */ (kernelfunc) NULL,"
        func_table[77] = "/* 77 */ (kernelfunc) NULL,"
        func_table[78] = "/* 78 */ (kernelfunc) NULL,"
        func_table[79] = "/* 79 */ (kernelfunc) NULL,"
        func_table[80] = "/* 80 */ (kernelfunc) NULL,"

    if (num_timers == 0):
        func_table[12] = "/* 12 */ (kernelfunc) NULL,"
        func_table[23] = "/* 23 */ (kernelfunc) NULL,"
        func_table[27] = "/* 27 */ (kernelfunc) NULL,"
        func_table[30] = "/* 30 */ (kernelfunc) NULL,"
        func_table[33] = "/* 33 */ (kernelfunc) NULL,"
        func_table[37] = "/* 37 */ (kernelfunc) NULL,"
        func_table[40] = "/* 40 */ (kernelfunc) NULL,"
        func_table[41] = "/* 41 */ (kernelfunc) NULL,"
        func_table[42] = "/* 42 */ (kernelfunc) NULL,"
        func_table[49] = "/* 49 */ (kernelfunc) NULL,"
        func_table[50] = "/* 50 */ (kernelfunc) NULL,"
        func_table[51] = "/* 51 */ (kernelfunc) NULL,"
        func_table[52] = "/* 52 */ (kernelfunc) NULL,"
        func_table[53] = "/* 53 */ (kernelfunc) NULL,"
        func_table[64] = "/* 64 */ (kernelfunc) NULL,"
        func_table[73] = "/* 73 */ (kernelfunc) NULL,"
        func_table[77] = "/* 77 */ (kernelfunc) NULL,"
        func_table[81] = "/* 81 */ (kernelfunc) NULL,"

    # generate function table

    kernel_main_c_out("\n" +
        "const kernelfunc _k_server_dispatch_table[82] =\n" +
        "{\n")
    for func in func_table:
        kernel_main_c_out("    " + func + "\n")
    kernel_main_c_out("};\n")


def kernel_main_c_driver_init():
    """ Generate driver initialization routine """

    kernel_main_c_out("\n" +
        "void _k_init_drivers(void)\n" +
        "{\n")
    for driver_call in driver_list:
        kernel_main_c_out("    " + driver_call + ";\n")
    kernel_main_c_out("}\n")


def kernel_main_c_node_init():
    """ Generate node initialization routine """

    kernel_main_c_out("\n" +
        "void _k_init_node(void)\n{\n")
    if (len(pipe_list) > 0):
        kernel_main_c_out("    _k_pipe_init();\n")
    if (len(map_list) > 0):
        kernel_main_c_out("    _k_mem_map_init();\n")
    if (len(pool_list) > 0):
        kernel_main_c_out("    _k_mem_pool_init();\n")
    kernel_main_c_out("}\n")


def kernel_main_c_main():
    """ Generate main() routine """

    kernel_main_c_out("\n" +
        "void main(void)\n" +
        "{\n" +
        "    _k_kernel_init();\n" +
        "    task_group_start(EXE);\n" +
        "    _k_kernel_idle();\n" +
        "}\n")


def kernel_main_c_generate():
    """ Generate kernel_main.c file """

    global kernel_main_c_data

    kernel_main_c_header()
    kernel_main_c_kargs()
    kernel_main_c_timers()
    kernel_main_c_tasks()
    kernel_main_c_priorities()
    kernel_main_c_events()
    kernel_main_c_mutexes()
    kernel_main_c_semas()
    kernel_main_c_fifos()
    kernel_main_c_pipes()
    kernel_main_c_mailboxes()
    kernel_main_c_maps()
    kernel_main_c_pools()
    kernel_main_c_kernel_services()
    kernel_main_c_driver_init()
    kernel_main_c_node_init()
    kernel_main_c_main()

    write_file(output_dir + 'kernel_main.c', kernel_main_c_data)


#
# GENERATE kernel_main.h FILE
#


def kernel_main_h_generate():
    """ Generate kernel_main.h file """

    global output_dir

    subprocess.check_call([
        "cp",
        "-f",
        os.environ["ZEPHYR_BASE"] +
        "/kernel/microkernel/include/kernel_main.h",
        output_dir])


#
# GENERATE kernel_struct.h FILE
#


def kernel_struct_h_generate():
    """ Generate kernel_struct.h file """

    global output_dir

    subprocess.check_call([
        "cp",
        "-f",
        os.environ["ZEPHYR_BASE"] +
        "/kernel/microkernel/include/kernel_struct.h",
        output_dir])


#
# GENERATE zephyr.h FILE
#


zephyr_h_data = ""

zephyr_h_filename_str = \
    "/* zephyr.h - microkernel master header file */\n\n"

zephyr_h_include_guard = "_ZEPHYR__H_"

zephyr_h_header_include_guard_str = \
    "#ifndef " + zephyr_h_include_guard + "\n" \
    "#define " + zephyr_h_include_guard + "\n\n"


def generate_zephyr_h_header():

    global zephyr_h_data
    zephyr_h_data += \
        zephyr_h_filename_str + \
        copyright + \
        do_not_edit_warning + \
        zephyr_h_header_include_guard_str + \
        "#include <microkernel.h>\n" + \
        "\n"


def generate_taskgroup_line(taskgroup, group_id):

    global zephyr_h_data
    zephyr_h_data += \
        "#define " + taskgroup + " 0x%8.8x\n" % group_id


def generate_zephyr_h_taskgroups():

    global zephyr_h_data

    for group in group_key_list:
        generate_taskgroup_line(group, group_dictionary[group])

    zephyr_h_data += "\n"


def generate_obj_id_line(name, obj_id):

    return "#define " + name + " 0x0001%4.4x\n" % obj_id


def generate_obj_id_lines(obj_types):

    data = ""
    for obj_type in obj_types:
        for obj in obj_type[0]:
            data += generate_obj_id_line(str(obj[0]), obj_type[1])
            obj_type[1] += 1
        if obj_type[1] > 0:
            data += "\n"

    return data


def generate_zephyr_h_obj_ids():

    global zephyr_h_data

    base_event = 4  # no need to generate ids for the 4 pre-defined events
    event_id = base_event
    for event in event_list:
        zephyr_h_data += "#define %s %u\n" % (str(event[0]), event_id)
        event_id += 1
    if event_id > base_event:
        zephyr_h_data += "\n"

    obj_types = [
        [task_list, 0],
        [mutex_list, 0],
        [sema_list, 0],
        [fifo_list, 0],
        [pipe_list, 0],
        [mbx_list, 0],
        [map_list, 0],
        [pool_list, 0],
    ]
    zephyr_h_data += generate_obj_id_lines(obj_types)


zephyr_h_footer_include_guard_str = \
    "\n#endif /* " + zephyr_h_include_guard + " */\n"


def generate_zephyr_h_footer():

    global zephyr_h_data
    zephyr_h_data += \
        zephyr_h_footer_include_guard_str


def zephyr_h_generate():
    """ Generate zephyr.h file """

    generate_zephyr_h_header()
    generate_zephyr_h_taskgroups()
    generate_zephyr_h_obj_ids()
    generate_zephyr_h_footer()

    write_file(output_dir + 'zephyr.h', zephyr_h_data)


#
# SYSTEM GENERATOR MAINLINE
#


mdef_parse()
get_output_dir()
kernel_main_c_generate()
kernel_main_h_generate()
kernel_struct_h_generate()
zephyr_h_generate()