mirror of
https://github.com/FreeRTOS/FreeRTOS-Plus-TCP
synced 2025-10-19 02:43:05 +08:00
a4124602cc
This commit brings in the refactoring and restructuring changes from IntegrationTesting1 branch to the main branch. It also includes additional unit tests for 100% coverage. The rationale behind not creating a PR is that the conflicts were too huge to be resolved correctly. Thus, a force push to the main branch is being done.
240 lines
11 KiB
Python
240 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# Prerequisits: Python 3.7 or greater.
|
|
#
|
|
# To run this script, go to the root of the FreeRTOS+TCP directory; that is the
|
|
# directory in which this script is present. And then invoke it with:
|
|
# `python3 your/path/to/GenerateOriginalFiles.py`
|
|
#
|
|
# After running this script, you will have 9 source files in the root directory
|
|
# and two additional folders namely `include` and `portable``.
|
|
|
|
|
|
# Import the shutil library to aid in copying of files and folders to different
|
|
# location.
|
|
import os
|
|
import shutil
|
|
import sys
|
|
|
|
# FreeRTOS Kernel includes. DO NOT change the order in the list.
|
|
FreeRTOS_Kernel_Includes = [ 'FreeRTOS.h',
|
|
'task.h',
|
|
'queue.h',
|
|
'semphr.h',
|
|
'list.h',
|
|
'event_groups.h',
|
|
'timers.h' ]
|
|
|
|
# FreeRTOS+TCP include files. DO NOT change the order in the list.
|
|
FreeRTOS_TCP_Includes = [ 'FreeRTOS_IP.h',
|
|
'FreeRTOSIPConfigDefaults.h',
|
|
'FreeRTOS_IP_Private.h',
|
|
'FreeRTOS_IP_Utils.h',
|
|
'FreeRTOS_IP_Timers.h',
|
|
'FreeRTOS_ARP.h',
|
|
'FreeRTOS_DHCP.h',
|
|
'FreeRTOS_DNS.h',
|
|
'FreeRTOS_DNS_Cache.h',
|
|
'FreeRTOS_DNS_Callback.h',
|
|
'FreeRTOS_DNS_Globals.h',
|
|
'FreeRTOS_DNS_Networking.h',
|
|
'FreeRTOS_DNS_Parser.h',
|
|
'FreeRTOS_ICMP.h',
|
|
'FreeRTOS_Sockets.h',
|
|
'FreeRTOS_Stream_Buffer.h',
|
|
'FreeRTOS_TCP_IP.h',
|
|
'FreeRTOS_TCP_Reception.h',
|
|
'FreeRTOS_TCP_State_Handling.h',
|
|
'FreeRTOS_TCP_Transmission.h',
|
|
'FreeRTOS_TCP_Utils.h',
|
|
'FreeRTOS_TCP_WIN.h',
|
|
'FreeRTOS_UDP_IP.h',
|
|
'FreeRTOS_errno_TCP.h',
|
|
'IPTraceMacroDefaults.h',
|
|
'NetworkInterface.h',
|
|
'NetworkBufferManagement.h' ]
|
|
|
|
# A dictionary to hold the modules to combine and the destination.
|
|
MODULES_DICT = dict()
|
|
|
|
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_ARP.c
|
|
ARP_modules_to_combine = [ 'source/FreeRTOS_ARP.c' ]
|
|
|
|
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_DHCP.c
|
|
DHCP_modules_to_combine = [ 'source/FreeRTOS_DHCP.c' ]
|
|
|
|
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_DNS.c
|
|
DNS_modules_to_combine = [ 'source/FreeRTOS_DNS.c',
|
|
'source/FreeRTOS_DNS_Cache.c',
|
|
'source/FreeRTOS_DNS_Callback.c',
|
|
'source/FreeRTOS_DNS_Networking.c',
|
|
'source/FreeRTOS_DNS_Parser.c' ]
|
|
|
|
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_IP.c
|
|
IP_modules_to_combine = [ 'source/FreeRTOS_ICMP.c',
|
|
'source/FreeRTOS_IP.c',
|
|
'source/FreeRTOS_IP_Timers.c',
|
|
'source/FreeRTOS_IP_Utils.c' ]
|
|
|
|
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_Sockets.c
|
|
Socket_modules_to_combine = [ 'source/FreeRTOS_Sockets.c' ]
|
|
|
|
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_Stream_Buffer.c
|
|
StreamBuffer_modules_to_combine = [ 'source/FreeRTOS_Stream_Buffer.c' ]
|
|
|
|
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_TCP_IP.c
|
|
TCP_modules_to_combine = [ 'source/FreeRTOS_TCP_IP.c',
|
|
'source/FreeRTOS_TCP_Reception.c',
|
|
'source/FreeRTOS_TCP_State_Handling.c',
|
|
'source/FreeRTOS_TCP_Transmission.c',
|
|
'source/FreeRTOS_TCP_Utils.c' ]
|
|
|
|
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_TCP_WIN.c
|
|
TCP_WIN_modules_to_combine = [ 'source/FreeRTOS_TCP_WIN.c',
|
|
'source/FreeRTOS_Tiny_TCP.c' ]
|
|
|
|
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_UDP_IP.c
|
|
UDP_modules_to_combine = [ 'source/FreeRTOS_UDP_IP.c' ]
|
|
|
|
# Add all the modules and the destinations to the dictionary.
|
|
MODULES_DICT['FreeRTOS_ARP.c'] = ARP_modules_to_combine
|
|
MODULES_DICT['FreeRTOS_DHCP.c'] = DHCP_modules_to_combine
|
|
MODULES_DICT['FreeRTOS_DNS.c'] = DNS_modules_to_combine
|
|
MODULES_DICT['FreeRTOS_IP.c'] = IP_modules_to_combine
|
|
MODULES_DICT['FreeRTOS_Sockets.c'] = Socket_modules_to_combine
|
|
MODULES_DICT['FreeRTOS_Stream_Buffer.c'] = StreamBuffer_modules_to_combine
|
|
MODULES_DICT['FreeRTOS_TCP_IP.c'] = TCP_modules_to_combine
|
|
MODULES_DICT['FreeRTOS_TCP_WIN.c'] = TCP_WIN_modules_to_combine
|
|
MODULES_DICT['FreeRTOS_UDP_IP.c'] = UDP_modules_to_combine
|
|
|
|
# Sorting function used to add Kernel includes. This is required as the includes
|
|
# need to adhere to a specific order of inclusion.
|
|
def KernelSortingFunction(element):
|
|
return FreeRTOS_Kernel_Includes.index(element)
|
|
|
|
# Sorting function used to add FreeRTOS+TCP includes. This is required as the includes
|
|
# need to adhere to a specific order of inclusion.
|
|
def TCPSortingFunction(element):
|
|
return FreeRTOS_TCP_Includes.index(element)
|
|
|
|
# Get all the includes in all the modules to combine first. This function does
|
|
# remove the duplicates but does not sort the includes in any specific order.
|
|
def GetIncludeList(ModulesToCombine):
|
|
# This list is used for the FreeRTOS+TCP include files.
|
|
TCP_include_list = list()
|
|
# This list is used for FreeRTOS Kernel include files.
|
|
Kernel_include_list = list()
|
|
# This list is used for standard library include files.
|
|
StdLib_include_list = list()
|
|
|
|
for filename in ModulesToCombine:
|
|
f = open(filename, "r")
|
|
for line in f.readlines():
|
|
if line.lstrip().startswith('#include '):
|
|
if '<' in line:
|
|
#if this is a standard library include
|
|
start_token = '<'
|
|
end_token = '>'
|
|
header = line.split(start_token)[1].split(end_token)[0]
|
|
StdLib_include_list.append(header)
|
|
else:
|
|
start_token = '"'
|
|
end_token = '"'
|
|
header = line.split(start_token)[1]
|
|
|
|
if header in FreeRTOS_TCP_Includes:
|
|
TCP_include_list.append(header)
|
|
elif header in FreeRTOS_Kernel_Includes:
|
|
Kernel_include_list.append(header)
|
|
else:
|
|
print("ERROR: Found " + header + " which is not in any list!")
|
|
f.close()
|
|
return list(set(StdLib_include_list)), list(set(Kernel_include_list)), list(set(TCP_include_list))
|
|
|
|
# Write the includes in a specific order to the destination file.
|
|
def AddIncludesInFile(modules_to_combine, file_descriptor):
|
|
StdLib_include_list_unique, Kernel_include_list_unique, TCP_include_list_unique = GetIncludeList(modules_to_combine)
|
|
|
|
for include in StdLib_include_list_unique:
|
|
file_descriptor.write(f'#include <{include}>\n')
|
|
|
|
# Sort the Kernel includes in a specific order using KernelSortingFunction.
|
|
Kernel_include_list_unique.sort(key=KernelSortingFunction)
|
|
for include in Kernel_include_list_unique:
|
|
file_descriptor.write(f'#include "{include}"\n')
|
|
|
|
# Sort the TCP includes in a specific order using TCPSortingFunction.
|
|
TCP_include_list_unique.sort(key=TCPSortingFunction)
|
|
for include in TCP_include_list_unique:
|
|
file_descriptor.write(f'#include "{include}"\n')
|
|
|
|
# Function to add the copyright notice to the destination file.
|
|
def AddCopyRightNotice(CopyRightNotice, file_descriptor):
|
|
for line in CopyRightNotice:
|
|
file_descriptor.write(f'{line}')
|
|
|
|
# Function to generate the original modules by adding the copyright notice,
|
|
# includes and source to the destination modules.
|
|
def GenerateOriginalModules():
|
|
# Flag to note the first iteration.
|
|
FirstIteration = True
|
|
# Create a list to hold the multi-line copyright notice.
|
|
CopyRightNotice = list()
|
|
|
|
for module in MODULES_DICT:
|
|
# Store the copyright notice for future use.
|
|
if FirstIteration:
|
|
FirstIteration = False
|
|
# Open the first module. All modules have copyright notices in them.
|
|
with open(MODULES_DICT[module][0]) as f:
|
|
for line in f.readlines():
|
|
CopyRightNotice.append(line)
|
|
|
|
if '*/' in line:
|
|
# Found the end of commented copyright notice. Break out
|
|
# of the loop.
|
|
break
|
|
f.close()
|
|
|
|
# Combine modules only if they were split into multiple ones.
|
|
if len(MODULES_DICT[module]) != 1:
|
|
with open(module, 'w') as file_to_write:
|
|
# Add the copyright notice to the destination module.
|
|
AddCopyRightNotice(CopyRightNotice, file_to_write)
|
|
|
|
# Add the include files in the destination module.
|
|
AddIncludesInFile(MODULES_DICT[module], file_to_write)
|
|
|
|
# Add the source from all the modules into the destination
|
|
# module.
|
|
for filename in MODULES_DICT[module]:
|
|
ready_to_write = False
|
|
with open(filename, "r") as f:
|
|
for line in f.readlines():
|
|
if ready_to_write:
|
|
file_to_write.write(f'{line}')
|
|
elif not line.lstrip().startswith('#include') and not line.lstrip().startswith(('*', '/*', '*/')):
|
|
file_to_write.write(f'{line}')
|
|
ready_to_write = True
|
|
f.close()
|
|
file_to_write.close()
|
|
# Some modules are intact and there is no need to combine.
|
|
# Just copy them to the root directory.
|
|
else:
|
|
shutil.copy2(MODULES_DICT[module][0] ,module)
|
|
|
|
# Function to copy the portable and include directories into the root of the
|
|
# folder.
|
|
def CopyIncludeAndPortableDirs():
|
|
# Copy the include directory to the root of the folder.
|
|
shutil.copytree('source/include', 'include')
|
|
# Copy the portable directory to the root of the folder.
|
|
shutil.copytree('source/portable', 'portable')
|
|
|
|
if __name__ == "__main__":
|
|
# Change the working directory to the root of repository.
|
|
os.chdir(os.path.dirname(sys.argv[0]))
|
|
|
|
GenerateOriginalModules()
|
|
CopyIncludeAndPortableDirs()
|