#! /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.
#

# Required arguments:
#   - name of VPF file

# Generates:
#   - kernel_main.c file
#   - microkernel_objects.h file
#   - vxmicro.h file

import os
import sys

# input-related variables

num_kargs   = 0
num_timers  = 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 = [ ]

# output-related variables

kernel_main_c_data = ""
vxmicro_h_data = ""
micro_objs_h_data = ""

def get_output_dir():
	if len(sys.argv) > 2:
		return sys.argv[2]
	else:
		return ""

output_dir = get_output_dir()

# Parse VPF file

def vpf_parse():
    global num_kargs
    global num_timers

    # open file for reading
    with open(sys.argv[1], 'r') as infile:

        # read file contents
        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") :
            num_kargs = int(words[1])
            num_timers = int(words[2])
            continue

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

        if (words[0] == "TASKGROUP") :
            if group_dictionary.has_key(words[1]) :
                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") :
            event_list.append( (words[1], words[2]) )
            continue

        if (words[0] == "SEMA") :
            sema_list.append( (words[1], ) )
            continue

        if (words[0] == "MUTEX") :
            mutex_list.append( (words[1], ) )
            continue

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

        if (words[0] == "PIPE") :
            pipe_list.append( (words[1], int(words[2])) )
            continue

        if (words[0] == "MAILBOX") :
            mbx_list.append( (words[1], ) )
            continue

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

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

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

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

        print "UNRECOGNIZED INPUT LINE"
        print words     # display any unrecognized line

# Generate miscellaneous global variables

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

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"

def kernel_main_c_general():
    kernel_main_c_out(
		kernel_main_c_filename_str +
		copyright +
		do_not_edit_warning +
        "\n" +
        "#include <microkernel.h>\n" +
        "#include <k_boot.h>\n" +
        "#include <toolchain.h>\n" +
        "#include <sections.h>\n" +
        "#include <vxmicro.h>")

    kernel_main_c_out("\nconst knode_t K_ThisNode = 0x00010000;")
    kernel_main_c_out("\nchar __noinit _minik_stack[CONFIG_MICROKERNEL_SERVER_STACK_SIZE];")
    kernel_main_c_out("int K_StackSize = CONFIG_MICROKERNEL_SERVER_STACK_SIZE;")

# Generate command packet variables

def kernel_main_c_kargs():

    # command packets

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

    # linked list of free command packets

    kernel_main_c_out("\n" +
        "struct nano_lifo K_ArgsFree = " +
        "{(void *) &K_ArgsBlocks[%d], NULL};" % (num_kargs-1))

# Generate timer system variables

def kernel_main_c_timers():

    # timer descriptors

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

    # linked list of free timers

    kernel_main_c_out("\n" +
        "struct nano_lifo K_TimerFree = " +
        "{(void *) &K_TimerBlocks[%d], NULL};" % (num_timers-1))

# Generate task variables

def kernel_main_c_tasks():
    total_tasks = len(task_list) + 1

    # task global variables

    kernel_main_c_out("int K_TaskCount = %d;" % (total_tasks - 1));

    # task stack areas

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

    # task descriptors (including one for idle task)

    kernel_main_c_out("\n" +
        "struct k_proc K_TaskList[%d] =\n" % (total_tasks) +
        "{")
    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}," % (entry, stack, size))
        ident += 1

    kernel_main_c_out("    {NULL, NULL, 63, 0x00000000, " +
        "0x00000000, 0x00000000,\n" +
        "(taskstartfunction)NULL, NULL, 0, (taskabortfunction)NULL}")
    kernel_main_c_out("};")

    # currently scheduled task (idle task)

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

# Generate task scheduling variables

def kernel_main_c_priorities():
    num_prios = 64
    total_tasks = len(task_list) + 1

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

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

    # active priority queue (idle task's queue)

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

# Generate event variables

def kernel_main_c_events():
    total_events = 4 + len(event_list)

    # event descriptors

    kernel_main_c_out("\n" +
        "struct evstr EVENTS[%d] =\n" % (total_events) +
        "{")
    # pre-defined events
    kernel_main_c_out(
        "    {0, (kevent_handler_t)K_ticker, (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" +
        "    {0, (kevent_handler_t)NULL, (struct k_args *)NULL, 0},"
    )
    # project-specific events
    for event in event_list:
        kernel_main_c_out(
            "    {0, (kevent_handler_t)%s, (struct k_args *)NULL, 0}," %
            (event[1]))
    kernel_main_c_out("};")

    # number of events

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

    # event object identifiers

    kernel_main_c_out("")

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

# Generate mutex variables

def kernel_main_c_mutexes():
    total_mutexes = len(mutex_list)

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

    # mutex descriptors

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

    # mutex object identifiers

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

# Generate semaphore variables

def kernel_main_c_semas():
    total_semas = len(sema_list)

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

    # semaphore descriptors

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

# Generate FIFO variables

def kernel_main_c_fifos():
    total_fifos = len(fifo_list)

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

    # FIFO buffers

    kernel_main_c_out("")

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

    # FIFO descriptors

    kernel_main_c_out("\n" +
        "struct que_struct K_QueList[%s] =\n" % (total_fifos) +
        "{"
    )
    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}," %
            (buffer, buffer))
    kernel_main_c_out("};")

# Generate pipe variables

def kernel_main_c_pipes():
    total_pipes = len(pipe_list)

    # pipe global variables

    kernel_main_c_out("int K_PipeCount = %d;" % (total_pipes));

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

    # pipe buffers

    kernel_main_c_out("")

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

    # pipe descriptors

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

    # pipe variables [should probably be eliminated]

    kernel_main_c_out("\n" +
        "PFN_CHANNEL_RW  pHS_Channel_Put = (PFN_CHANNEL_RW)NULL;\n" +
        "PFN_CHANNEL_RW  pHS_Channel_PutW = (PFN_CHANNEL_RW)NULL;\n" +
        "PFN_CHANNEL_RWT pHS_Channel_PutWT = (PFN_CHANNEL_RWT)NULL;\n" +
        "PFN_CHANNEL_RW  pHS_Channel_Get = (PFN_CHANNEL_RW)NULL;\n" +
        "PFN_CHANNEL_RW  pHS_Channel_GetW = (PFN_CHANNEL_RW)NULL;\n" +
        "PFN_CHANNEL_RWT pHS_Channel_GetWT = (PFN_CHANNEL_RWT)NULL;\n" +
        "PFN_CHANNEL_RWT pKS_Channel_PutWT = _task_pipe_put;\n" +
        "PFN_CHANNEL_RWT pKS_Channel_GetWT = _task_pipe_get;")

# Generate mailbox variables

def kernel_main_c_mailboxes():
    total_mbxs = len(mbx_list)

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

    # mailbox descriptors

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


# Generate memory map variables

def kernel_main_c_maps():
    total_maps = len(map_list)

    # map global variables

    kernel_main_c_out("int K_MapCount = %d;" % (total_maps));

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

    # memory map buffers

    kernel_main_c_out("")

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

    # memory map descriptors

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


# Generate memory pool variables

def kernel_main_c_pools():
    total_pools = len(pool_list)

    # pool global variables

    kernel_main_c_out("\nint K_PoolCount = %d;" % (total_pools));

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

    # start accumulating memory pool descriptor info

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

    for pool in pool_list:

        kernel_main_c_out("")

        # 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];" %
                (ident, index, block_status_sizes[index]))

        # generate memory pool fragmentation descriptor

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

        # generate memory pool buffer

        kernel_main_c_out("char __noinit %s[%d];" % (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 += "};"
    kernel_main_c_out(pool_descriptors)


# Generate kernel services function table

def kernel_main_c_kernel_services():

    # initialize table with info for all possible kernel services

    func_table = [
"/*  0 */ K_nop,",                  # required
"/*  1 */ K_mvdreq,",               # required
"/*  2 */ (kernelfunc) NULL,",      # unused
"/*  3 */ (kernelfunc) NULL,",      # unused
"/*  4 */ K_offload,",              # required
"/*  5 */ K_workload,",             # required
"/*  6 */ K_signals,",              # depends on semaphores
"/*  7 */ K_signalm,",              # depends on semaphores
"/*  8 */ K_resets,",               # depends on semaphores
"/*  9 */ K_resetm,",               # depends on semaphores
"/* 10 */ K_waitsreq,",             # depends on semaphores
"/* 11 */ K_waitsrpl,",             # depends on semaphores
"/* 12 */ K_waitsrpl,",             # depends on semaphores and timers
"/* 13 */ K_waitmany,",             # depends on semaphores
"/* 14 */ K_waitmreq,",             # depends on semaphores
"/* 15 */ K_waitmrdy,",             # depends on semaphores
"/* 16 */ K_waitmcan,",             # depends on semaphores
"/* 17 */ K_waitmacc,",             # depends on semaphores
"/* 18 */ K_waitmend,",             # depends on semaphores
"/* 19 */ K_waitmtmo,",             # depends on semaphores and timers
"/* 20 */ K_inqsema,",              # depends on semaphores
"/* 21 */ K_lockreq,",              # depends on mutexes
"/* 22 */ K_lockrpl,",              # depends on mutexes
"/* 23 */ K_lockrpl,",              # depends on mutexes and timers
"/* 24 */ K_unlock,",               # depends on mutexes
"/* 25 */ K_enqreq,",               # depends on FIFOs
"/* 26 */ K_enqrpl,",               # depends on FIFOs
"/* 27 */ K_enqrpl,",               # depends on FIFOs and timers
"/* 28 */ K_deqreq,",               # depends on FIFOs
"/* 29 */ K_deqrpl,",               # depends on FIFOs
"/* 30 */ K_deqrpl,",               # depends on FIFOs and timers
"/* 31 */ K_queue,",                # depends on FIFOs
"/* 32 */ K_sendreq,",              # depends on mailboxes
"/* 33 */ K_sendrpl,",              # depends on mailboxes and timers
"/* 34 */ K_sendack,",              # depends on mailboxes
"/* 35 */ K_senddata,",             # depends on mailboxes
"/* 36 */ K_recvreq,",              # depends on mailboxes
"/* 37 */ K_recvrpl,",              # depends on mailboxes and timers
"/* 38 */ K_recvack,",              # depends on mailboxes
"/* 39 */ K_recvdata,",             # depends on mailboxes
"/* 40 */ K_elapse,",               # required
"/* 41 */ K_sleep,",                # depends on timers
"/* 42 */ K_wakeup,",               # depends on timers
"/* 43 */ K_taskop,",               # required
"/* 44 */ K_groupop,",              # required
"/* 45 */ K_set_prio,",             # required
"/* 46 */ K_yield,",                # required
"/* 47 */ K_alloc,",                # depends on memory maps
"/* 48 */ K_dealloc,",              # depends on memory maps
"/* 49 */ K_alloc_timer,",          # depends on timers
"/* 50 */ K_dealloc_timer,",        # depends on timers
"/* 51 */ K_start_timer,",          # depends on timers
"/* 52 */ K_stop_timer,",           # depends on timers
"/* 53 */ K_alloctmo,",             # 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_set_handler,",    # required
"/* 60 */ K_event_signal,",         # required
"/* 61 */ K_GetBlock,",             # depends on memory pools
"/* 62 */ K_RelBlock,",             # depends on memory pools
"/* 63 */ K_GetBlock_Waiters,",     # depends on memory pools
"/* 64 */ K_gtbltmo,",              # depends on memory pools
"/* 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
"/* 74 */ K_ChSendRpl,",            # depends on pipes
"/* 75 */ K_ChSendAck,",            # depends on pipes
"/* 76 */ K_ChRecvReq,",            # depends on pipes
"/* 77 */ K_ChRecvTmo,",            # depends on pipes
"/* 78 */ K_ChRecvRpl,",            # depends on pipes
"/* 79 */ K_ChRecvAck,",            # depends on pipes
"/* 80 */ K_ChMovedAck,",           # depends on pipes
"/* 81 */ K_eventtesttmo"           # required
    ]

    # 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[19] = "/* 19 */ (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[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,"

    # generate function table

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

# Generate driver initialization routine

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

# Generate node initialization routine

def kernel_main_c_node_init():
    kernel_main_c_out("\n" +
        "void init_node(void)\n{")
    if (len(pipe_list) > 0) :
        kernel_main_c_out("    InitPipe();")
    if (len(map_list) > 0) :
        kernel_main_c_out("    InitMap();")
    if (len(pool_list) > 0) :
        kernel_main_c_out("    InitPools();")
    kernel_main_c_out("}")

# Generate main() routine

def kernel_main_c_main():
    kernel_main_c_out("\n" +
        "void main(void)\n" +
        "{\n" +
        "    kernel_init();\n" +
        "    task_group_start(EXE);\n" +
        "    kernel_idle();\n" +
        "}")

# Append a string to kernel_main.c

def kernel_main_c_out(string):
    global kernel_main_c_data

    kernel_main_c_data += string + "\n"

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

# Generate kernel_main.c file

def kernel_main_c_generate():
    global kernel_main_c_data

    # create file contents
    kernel_main_c_general()
    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 microkernel_objects.h file

micro_objs_h_filename_str = \
	"/* microkernel_objects.h - microkernel objects */\n\n"

micro_objs_h_include_guard = "_MICROKERNEL_OBJECTS__H_"

micro_objs_h_header_include_guard_str = \
	"#ifndef " + micro_objs_h_include_guard + "\n" \
	"#define " + micro_objs_h_include_guard + "\n\n"

def generate_micro_objs_h_header():

	global micro_objs_h_data
	micro_objs_h_data += \
		micro_objs_h_filename_str + \
		copyright + \
		do_not_edit_warning + \
		micro_objs_h_header_include_guard_str

micro_objs_h_footer_include_guard_str = \
	"\n#endif /* " + micro_objs_h_include_guard + " */\n"

def generate_micro_objs_h_footer():

	global micro_objs_h_data
	micro_objs_h_data += \
		micro_objs_h_footer_include_guard_str

def generate_taskgroup_line(taskgroup, group_id):

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

def generate_micro_objs_h_taskgroups():

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

def generate_micro_objs_h_nodes():

	global micro_objs_h_data
	micro_objs_h_data += \
		"\n#define NODE1 0x00010000\n\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_micro_objs_h_obj_ids():

	global micro_objs_h_data

	obj_types = [
		[task_list,  0],
		[mutex_list, 0],
		[sema_list,  0],
		[fifo_list,  0],
		[pipe_list,  0],
		[mbx_list,   0],
		[pool_list,  0],
	]

	micro_objs_h_data += generate_obj_id_lines(obj_types)

def generate_micro_objs_h_misc():

	global micro_objs_h_data
	micro_objs_h_data += "\n" + \
		"#define TICKFREQ 1000\n" + \
		"#define DATALEN 32768\n" + \
		"#define CEILING_PRIO 5\n" + \
		"#define KERNEL_PRIO 0\n" + \
		"#define DRIVER_PRIO 1\n" + \
		"#define TICKTIME 1000\n"

def micro_objs_h_generate():

	generate_micro_objs_h_header()
	generate_micro_objs_h_taskgroups()
	generate_micro_objs_h_nodes()
	generate_micro_objs_h_obj_ids()
	generate_micro_objs_h_misc() # XXX - remove when ready
	generate_micro_objs_h_footer()

	write_file(output_dir + 'microkernel_objects.h', micro_objs_h_data)

vxmicro_h_filename_str = \
	"/* vxmicro.h - microkernel master header file */\n\n"

vxmicro_h_include_guard = "_VXMICRO__H_"

vxmicro_h_header_include_guard_str = \
	"#ifndef " + vxmicro_h_include_guard + "\n" \
	"#define " + vxmicro_h_include_guard + "\n\n"

def generate_vxmicro_h_header():

	global vxmicro_h_data
	vxmicro_h_data += \
		vxmicro_h_filename_str + \
		copyright + \
		do_not_edit_warning + \
		vxmicro_h_header_include_guard_str + \
		"#include <microkernel.h>\n" + \
		"#include <microkernel_objects.h>\n"

def generate_vxmicro_h_misc():

	global vxmicro_h_data
	vxmicro_h_data += "\n" + \
		"extern const int K_max_eventnr;\n" + \
		"extern struct evstr EVENTS[];\n\n"

def generate_vxmicro_h_obj_ids():

	global vxmicro_h_data

	base_event = 4 # events start at 4
	event_id = base_event
	for event in event_list:
		vxmicro_h_data += "#define %s %u\n" % (str(event[0]), event_id)
		event_id += 1
	if event_id > base_event:
		vxmicro_h_data += "\n"

	obj_types = [
		[map_list, 0],
	]
	vxmicro_h_data += generate_obj_id_lines(obj_types)

vxmicro_h_footer_include_guard_str = \
	"\n#endif /* " + vxmicro_h_include_guard + " */\n"

def generate_vxmicro_h_task_entry_points():

	global vxmicro_h_data
	for task in task_list:
		vxmicro_h_data += "extern void %s(void);\n" % task[2]

def generate_vxmicro_h_footer():

	global vxmicro_h_data
	vxmicro_h_data += \
		vxmicro_h_footer_include_guard_str

# Generate vxmicro.h file

def vxmicro_h_generate():

	generate_vxmicro_h_header()
	generate_vxmicro_h_misc()
	generate_vxmicro_h_obj_ids()
	generate_vxmicro_h_task_entry_points()
	generate_vxmicro_h_footer()

	write_file(output_dir + 'vxmicro.h', vxmicro_h_data)

# System generator mainline

vpf_parse()
kernel_main_c_generate()
vxmicro_h_generate()
micro_objs_h_generate()