760 lines
19 KiB
Python
Executable File
760 lines
19 KiB
Python
Executable File
#! /usr/bin/env python2
|
|
#
|
|
# sysgen - System Generator
|
|
#
|
|
#
|
|
# Copyright (c) 2015, Wind River Systems, Inc.
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
|
|
# Arguments:
|
|
# - name of MDEF file
|
|
# - name of directory for output files (optional)
|
|
|
|
# Generates:
|
|
# - kernel_main.c file
|
|
# - kernel_main.h file (local copy)
|
|
# - micro_private_types.h file (local copy)
|
|
# - sysgen.h file
|
|
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
import argparse
|
|
|
|
# global variables describing system
|
|
|
|
MIN_HEAP = 64
|
|
heap_pos_in_pool_list = -1
|
|
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 = []
|
|
|
|
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-2017 Wind River Systems, Inc.\n" + \
|
|
" *\n" + \
|
|
" * SPDX-License-Identifier: Apache-2.0\n" + \
|
|
" */\n"
|
|
|
|
output_dir = ""
|
|
input_mdef_file = ""
|
|
|
|
def get_cmdline_args():
|
|
""" Handle optional output directory argument """
|
|
|
|
global input_mdef_file
|
|
global output_dir
|
|
|
|
output_dir_help='output directory for kernel_main.*, sysgen.h, etc'
|
|
input_mdef_file_help='input MDEF file'
|
|
|
|
parser = argparse.ArgumentParser()
|
|
|
|
parser.add_argument('-i', '--input-mdef-file', action='store',
|
|
required=True, help=input_mdef_file_help)
|
|
parser.add_argument('-o', '--output-dir', action='store',
|
|
help=output_dir_help)
|
|
|
|
args = parser.parse_args()
|
|
|
|
input_mdef_file = args.input_mdef_file
|
|
|
|
if (args.output_dir != None):
|
|
output_dir = args.output_dir
|
|
|
|
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
|
|
global MIN_HEAP
|
|
global heap_pos_in_pool_list
|
|
|
|
# read file contents in a single shot
|
|
with open(input_mdef_file, '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 and len(words) > 10:
|
|
error_arg_count(line)
|
|
|
|
p1 = 0
|
|
p2 = 0
|
|
p3 = 0
|
|
|
|
if len(words) >= 7:
|
|
p1 = words[6]
|
|
if len(words) >= 8:
|
|
p2 = words[7]
|
|
if len(words) == 9:
|
|
p3 = words[8]
|
|
|
|
abort = 0
|
|
if len(words) == 10:
|
|
abort = words[9]
|
|
|
|
task_list.append((words[1], int(words[2]), words[3],
|
|
int(words[4]), words[5], p1, p2, p3, abort))
|
|
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 and len(words) > 4:
|
|
error_arg_count(line)
|
|
if len(words) == 2:
|
|
sema_list.append((words[1], 0, 0xffffffff))
|
|
elif len(words) == 3:
|
|
sema_list.append((words[1], int(words[2]), 0xffffffff))
|
|
else:
|
|
sema_list.append((words[1], int(words[2]), int(words[3])))
|
|
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] == "HEAP_SIZE"):
|
|
if (len(words) != 2):
|
|
error_arg_count(line)
|
|
heap_size = int(words[1])
|
|
heap_pos_in_pool_list = len(pool_list)
|
|
pool_list.append(("_HEAP_MEM_POOL", MIN_HEAP, heap_size, 1))
|
|
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 - 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 <sysgen.h>\n" +
|
|
"#include <debug/object_tracing_common.h>\n" +
|
|
"#include <kernel.h>\n" +
|
|
"#include <toolchain.h>\n" +
|
|
"#include <sections.h>\n")
|
|
|
|
|
|
def get_group_bitmask(group_str):
|
|
|
|
# create bitmask of group(s) task belongs to
|
|
group_bitmask = 0
|
|
group_set = group_str[1:len(group_str) - 1] # drop [] surrounding groups
|
|
if (group_set != ""):
|
|
group_list = group_set.split(',')
|
|
for group in group_list:
|
|
group_bitmask |= group_dictionary[group]
|
|
|
|
return group_bitmask
|
|
|
|
def is_float(x):
|
|
try:
|
|
float(x)
|
|
return True
|
|
except ValueError:
|
|
return False
|
|
|
|
def is_int(x):
|
|
try:
|
|
int(x)
|
|
return True
|
|
except ValueError:
|
|
return False
|
|
|
|
def is_number(x):
|
|
return is_float(x) or is_int(x)
|
|
|
|
def kernel_main_c_tasks():
|
|
global num_prios
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
# declare task entry points
|
|
|
|
kernel_main_c_out("\n")
|
|
for task in task_list:
|
|
entry = task[2]
|
|
|
|
if entry == "main":
|
|
# We will re-use existing main_thread
|
|
continue
|
|
|
|
kernel_main_c_out("EXTERN_C void %s(void *, void *, void *);\n" %
|
|
entry)
|
|
|
|
|
|
# thread_init objects
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
for task in task_list:
|
|
name = task[0]
|
|
prio = task[1]
|
|
entry = task[2]
|
|
stack_size = task[3]
|
|
|
|
if entry == "main":
|
|
# We will re-use existing main thread
|
|
continue
|
|
|
|
groups = get_group_bitmask(task[4])
|
|
|
|
params = (task[5], task[6], task[7])
|
|
for param in params:
|
|
if not is_number(param):
|
|
kernel_main_c_out("extern void *%s;\n" % (param));
|
|
|
|
abort = task[8]
|
|
if abort != 0 and abort != 'NULL':
|
|
kernel_main_c_out("EXTERN_C void %s(void);\n" % abort)
|
|
|
|
kernel_main_c_out(
|
|
"_MDEF_THREAD_DEFINE(%s, %u, %s, %s, %s, %s, %s, %d, 0x%x);\n" %
|
|
(name, int(stack_size), entry,
|
|
params[0], params[1], params[2],
|
|
abort, int(prio), int(groups)))
|
|
|
|
|
|
def kernel_main_c_events():
|
|
""" Generate event variables """
|
|
|
|
event_type = 'struct k_alert *'
|
|
|
|
# event descriptors
|
|
|
|
# project-specific events
|
|
for event in event_list:
|
|
|
|
# if there is a handler function, it needs to be declared
|
|
# before setting up the object via DEFINE_EVENT()
|
|
#
|
|
# in other words, no declaration if handler is NULL or 0
|
|
handler = event[1].strip().lower()
|
|
if handler != "null" and handler != "0":
|
|
kernel_main_c_out("extern int %s(%s event);\n" %
|
|
(event[1], event_type))
|
|
|
|
kernel_main_c_out("K_ALERT_DEFINE(_k_event_obj_%s, %s, 1);\n" %
|
|
(event[0], event[1]))
|
|
|
|
def kernel_main_c_mutexes():
|
|
""" Generate mutex variables """
|
|
|
|
total_mutexes = len(mutex_list)
|
|
|
|
if (total_mutexes == 0):
|
|
return
|
|
|
|
# mutex descriptors
|
|
|
|
kernel_main_c_out("\n")
|
|
for mutex in mutex_list:
|
|
name = mutex[0]
|
|
kernel_main_c_out("K_MUTEX_DEFINE(_k_mutex_obj_%s);\n" % (name))
|
|
|
|
|
|
def kernel_main_c_semas():
|
|
""" Generate semaphore variables """
|
|
|
|
total_semas = len(sema_list)
|
|
|
|
if (total_semas == 0):
|
|
return
|
|
|
|
# semaphore descriptors
|
|
|
|
kernel_main_c_out("\n")
|
|
for semaphore in sema_list:
|
|
name = semaphore[0]
|
|
initial_count = semaphore[1]
|
|
limit = semaphore[2]
|
|
kernel_main_c_out("K_SEM_DEFINE(_k_sem_obj_%s, %s, %s);\n" %
|
|
(name, initial_count, limit))
|
|
|
|
|
|
def kernel_main_c_fifos():
|
|
""" Generate FIFO variables """
|
|
|
|
total_fifos = len(fifo_list)
|
|
|
|
if (total_fifos == 0):
|
|
return
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
# message queue objects
|
|
for fifo in fifo_list:
|
|
name = fifo[0]
|
|
depth = fifo[1]
|
|
width = fifo[2]
|
|
kernel_main_c_out("K_MSGQ_DEFINE(_k_fifo_obj_%s, %s, %s, 4);\n" %
|
|
(name, width, depth))
|
|
|
|
|
|
def kernel_main_c_pipes():
|
|
""" Generate pipe variables """
|
|
|
|
total_pipes = len(pipe_list)
|
|
|
|
if (total_pipes == 0):
|
|
return
|
|
|
|
# pipe buffers
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
# pipe objects
|
|
for pipe in pipe_list:
|
|
name = pipe[0]
|
|
size = pipe[1]
|
|
kernel_main_c_out("K_PIPE_DEFINE(_k_pipe_obj_%s, %d, 4);\n" %
|
|
(name, size))
|
|
|
|
|
|
def kernel_main_c_mailboxes():
|
|
""" Generate mailbox variables """
|
|
|
|
total_mbxs = len(mbx_list)
|
|
|
|
if (total_mbxs == 0):
|
|
return
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
# mailbox objects
|
|
for mbx in mbx_list:
|
|
name = mbx[0]
|
|
kernel_main_c_out("K_MBOX_DEFINE(_k_mbox_obj_%s);\n" % (name))
|
|
|
|
|
|
def kernel_main_c_maps():
|
|
""" Generate memory map variables """
|
|
|
|
total_maps = len(map_list)
|
|
|
|
if (total_maps == 0):
|
|
return
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
# memory map objects
|
|
for map in map_list:
|
|
name = map[0]
|
|
blocks = map[1]
|
|
block_size = map[2]
|
|
kernel_main_c_out("K_MEM_SLAB_DEFINE(_k_mem_map_obj_%s, %s, %s, 4);\n" %
|
|
(name, block_size, blocks))
|
|
|
|
|
|
def kernel_main_c_pools():
|
|
""" Generate memory pool variables """
|
|
global heap_pos_in_pool_list
|
|
|
|
total_pools = len(pool_list)
|
|
|
|
# pool global variables
|
|
|
|
kernel_main_c_out("\nint _k_mem_pool_count = %d;\n" % (total_pools))
|
|
|
|
pool_descriptors = ""
|
|
for pool in pool_list:
|
|
kernel_main_c_out("\n")
|
|
min_block_size = pool[1]
|
|
max_block_size = pool[2]
|
|
num_maximal_blocks = pool[3]
|
|
pool_descriptors += "K_MEM_POOL_DEFINE(_k_mem_pool_obj_%s, %d, %d, %d, 4);\n" % \
|
|
(pool[0], min_block_size, max_block_size,
|
|
num_maximal_blocks)
|
|
|
|
if (heap_pos_in_pool_list != -1):
|
|
kernel_main_c_out(
|
|
"\nkmemory_pool_t _heap_mem_pool_ptr = " +
|
|
"&_k_mem_pool_obj__HEAP_MEM_POOL;\n")
|
|
kernel_main_c_out(pool_descriptors)
|
|
|
|
|
|
def kernel_main_c_generate():
|
|
""" Generate kernel_main.c file """
|
|
|
|
global kernel_main_c_data
|
|
|
|
kernel_main_c_header()
|
|
|
|
kernel_main_c_mutexes()
|
|
kernel_main_c_semas()
|
|
kernel_main_c_events()
|
|
kernel_main_c_maps()
|
|
kernel_main_c_fifos()
|
|
kernel_main_c_mailboxes()
|
|
kernel_main_c_tasks()
|
|
kernel_main_c_pipes()
|
|
kernel_main_c_pools()
|
|
|
|
write_file(output_dir + 'kernel_main.c', kernel_main_c_data)
|
|
|
|
|
|
|
|
#
|
|
# GENERATE sysgen.h FILE
|
|
#
|
|
|
|
|
|
sysgen_h_data = ""
|
|
|
|
sysgen_h_filename_str = \
|
|
"/* sysgen.h - system generated kernel definitions */\n\n"
|
|
|
|
sysgen_h_include_guard = "_SYSGEN__H_"
|
|
|
|
sysgen_h_header_include_guard_str = \
|
|
"#ifndef " + sysgen_h_include_guard + "\n" \
|
|
"#define " + sysgen_h_include_guard + "\n\n"
|
|
|
|
|
|
def generate_sysgen_h_header():
|
|
|
|
global sysgen_h_data
|
|
|
|
kernel_api_file = "#include <kernel.h>\n"
|
|
|
|
sysgen_h_data += \
|
|
sysgen_h_filename_str + \
|
|
copyright + \
|
|
do_not_edit_warning + \
|
|
kernel_api_file + \
|
|
sysgen_h_header_include_guard_str + \
|
|
"\n"
|
|
|
|
|
|
def generate_taskgroup_line(taskgroup, group_id):
|
|
|
|
global sysgen_h_data
|
|
sysgen_h_data += \
|
|
"#define " + taskgroup + " 0x%8.8x\n" % group_id
|
|
|
|
|
|
def generate_sysgen_h_taskgroups():
|
|
|
|
global sysgen_h_data
|
|
|
|
for group in group_key_list:
|
|
generate_taskgroup_line(group, group_dictionary[group])
|
|
|
|
sysgen_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_sysgen_h_obj_ids():
|
|
|
|
global sysgen_h_data
|
|
|
|
mutex_struct = 'k_mutex'
|
|
mutex_type = 'struct k_mutex *'
|
|
sem_struct = 'k_sem'
|
|
sem_type = 'struct k_sem *'
|
|
pipe_struct = 'k_pipe'
|
|
pipe_type = 'struct k_pipe *'
|
|
map_struct = 'k_mem_slab'
|
|
map_type = 'struct k_mem_slab *'
|
|
fifo_struct = 'k_msgq'
|
|
fifo_type = 'struct k_msgq *'
|
|
mbox_struct = 'k_mbox'
|
|
mbox_type = 'struct k_mbox *'
|
|
event_type = 'struct k_alert *'
|
|
mem_pool_type = 'struct k_mem_pool'
|
|
# add missing object types
|
|
|
|
# mutex object ids
|
|
|
|
sysgen_h_data += "\n"
|
|
for mutex in mutex_list:
|
|
name = mutex[0]
|
|
sysgen_h_data += \
|
|
"extern struct %s _k_mutex_obj_%s;\n" % (mutex_struct, name)
|
|
sysgen_h_data += \
|
|
"#define %s ((%s)&_k_mutex_obj_%s)\n\n" % (name, mutex_type, name)
|
|
|
|
# semaphore object ids
|
|
|
|
sysgen_h_data += "\n"
|
|
for semaphore in sema_list:
|
|
name = semaphore[0]
|
|
sysgen_h_data += \
|
|
"extern struct %s _k_sem_obj_%s;\n" % (sem_struct, name)
|
|
sysgen_h_data += \
|
|
"#define %s ((%s)&_k_sem_obj_%s)\n\n" % (name, sem_type, name)
|
|
|
|
# fifo (aka message queue) object ids
|
|
|
|
sysgen_h_data += "\n"
|
|
for fifo in fifo_list:
|
|
name = fifo[0]
|
|
sysgen_h_data += \
|
|
"extern struct %s _k_fifo_obj_%s;\n" % (fifo_struct, name)
|
|
sysgen_h_data += \
|
|
"#define %s ((%s)&_k_fifo_obj_%s)\n\n" % (name, fifo_type, name)
|
|
|
|
# mailbox object ids
|
|
|
|
sysgen_h_data += "\n"
|
|
for mbx in mbx_list:
|
|
name = mbx[0]
|
|
sysgen_h_data += \
|
|
"extern struct %s _k_mbox_obj_%s;\n" % (mbox_struct, name)
|
|
sysgen_h_data += \
|
|
"#define %s ((%s)&_k_mbox_obj_%s)\n\n" % (name, mbox_type, name)
|
|
|
|
# pipe object id
|
|
|
|
sysgen_h_data += "\n"
|
|
for pipe in pipe_list:
|
|
name = pipe[0];
|
|
sysgen_h_data += \
|
|
"extern struct %s _k_pipe_obj_%s;\n" % (pipe_struct, name)
|
|
sysgen_h_data += \
|
|
"#define %s ((%s)&_k_pipe_obj_%s)\n\n" % (name, pipe_type, name)
|
|
|
|
# memory map object id
|
|
|
|
sysgen_h_data += "\n"
|
|
for map in map_list:
|
|
name = map[0];
|
|
sysgen_h_data += \
|
|
"extern struct %s _k_mem_map_obj_%s;\n" % (map_struct, name)
|
|
sysgen_h_data += \
|
|
"#define %s ((%s)&_k_mem_map_obj_%s)\n" % (name, map_type, name)
|
|
|
|
# task object id
|
|
|
|
sysgen_h_data += "\n"
|
|
for task in task_list:
|
|
name = task[0];
|
|
prio = task[1]
|
|
entry = task[2]
|
|
stack_size = task[3]
|
|
|
|
if entry == "main":
|
|
# Special case: if the MDEF defines a main() thread,
|
|
# re-purpose the already existing main_thread for it.
|
|
sysgen_h_data += \
|
|
"#define MDEF_MAIN_STACK_SIZE %d\n" % stack_size
|
|
sysgen_h_data += \
|
|
"#define MDEF_MAIN_THREAD_PRIORITY %d\n" % prio
|
|
else:
|
|
sysgen_h_data += \
|
|
"extern char _k_thread_obj_%s[];\n" % (name) + \
|
|
"#define %s ((k_tid_t)_k_thread_obj_%s)\n" % (name, name)
|
|
|
|
# event object ids
|
|
|
|
sysgen_h_data += "\n"
|
|
for event in event_list:
|
|
# no need to expose the irq task events
|
|
if not (event[0].startswith("_TaskIrqEvt")):
|
|
name = event[0];
|
|
sysgen_h_data += \
|
|
"extern struct k_alert _k_event_obj_%s;\n" % (name)
|
|
sysgen_h_data += \
|
|
"#define %s (&_k_event_obj_%s)\n\n" % (name, name)
|
|
|
|
# memory pool object ids
|
|
|
|
for mem_pool in pool_list:
|
|
name = mem_pool[0];
|
|
sysgen_h_data += \
|
|
"extern %s _k_mem_pool_obj_%s;\n" % (mem_pool_type, name)
|
|
sysgen_h_data += \
|
|
"#define %s ((%s *)&_k_mem_pool_obj_%s)\n" % (name, mem_pool_type, name)
|
|
|
|
# all other object ids
|
|
|
|
|
|
sysgen_h_footer_include_guard_str = \
|
|
"\n#endif /* " + sysgen_h_include_guard + " */\n"
|
|
|
|
|
|
def generate_sysgen_h_footer():
|
|
|
|
global sysgen_h_data
|
|
sysgen_h_data += \
|
|
sysgen_h_footer_include_guard_str
|
|
|
|
|
|
def sysgen_h_generate():
|
|
""" Generate sysgen.h file """
|
|
|
|
generate_sysgen_h_header()
|
|
generate_sysgen_h_taskgroups()
|
|
generate_sysgen_h_obj_ids()
|
|
generate_sysgen_h_footer()
|
|
|
|
write_file(output_dir + 'sysgen.h', sysgen_h_data)
|
|
|
|
|
|
#
|
|
# SYSTEM GENERATOR MAINLINE
|
|
#
|
|
|
|
get_cmdline_args()
|
|
mdef_parse()
|
|
kernel_main_c_generate()
|
|
sysgen_h_generate()
|