Reviewed-on: StarOpenSource/core#1 Rewrote CORE and improved the startup process and startup time significantly. The documentation has been beefed up too and is now much better. Existing projects may need major refactoring however. Co-authored-by: JeremyStarTM <jeremystartm@staropensource.de> Co-committed-by: JeremyStarTM <jeremystartm@staropensource.de>
217 lines
8.6 KiB
GDScript
217 lines
8.6 KiB
GDScript
######################################
|
|
# THE CORE FRAMEWORK #
|
|
# MADE BY THE STAROPENSOURCE PROJECT #
|
|
# AND CONTRIBUTERS (THANK YOU!) #
|
|
# #
|
|
# COPYRIGHT 2023 THE STAROPENSOURCE #
|
|
# PROJECT AND CONTRIBUTERS #
|
|
# #
|
|
# LICENSED UNDER THE GNU GENERAL #
|
|
# PUBLIC LICENSE VERSION 3 (ONLY) #
|
|
######################################
|
|
extends Node
|
|
|
|
## ## # ##### ##### ####
|
|
## # # # # # # #
|
|
## # # # # # # ####
|
|
## # ## # # # #
|
|
## # # ##### # ####
|
|
## The preprocessor is *very* undocumented at this point
|
|
## in time as it is a little bit complicated. We may document
|
|
## it in the future, but for now you have to read the source.
|
|
##
|
|
## - JeremyStarTM
|
|
|
|
# CORE modules
|
|
var core: Node = null
|
|
var logger: Node = null
|
|
|
|
# Enables/disables preprocessor functionality
|
|
@export var enabled = true
|
|
# Do not enable unless you exactly know what you are doing!
|
|
# It will spam your log chock full of useless garbage!
|
|
@export var diagnostic = false
|
|
|
|
# Checks if logger is null
|
|
func initialize() -> void:
|
|
if core.protection_mode: return
|
|
if logger == null:
|
|
return
|
|
logger.diag("CORE/preprocessor.gd","Preprocessor is ready.",false)
|
|
|
|
# Parses <nl> tags
|
|
func _newline(msg:String,prefix:String,pre_msg:String,post_msg:String,exclusion_filter:Array) -> String:
|
|
if core.protection_mode: return ""
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing newline tags",false)
|
|
var prefix_space = prefix
|
|
for exclusion in exclusion_filter:
|
|
prefix_space = prefix_space.replace(exclusion,"")
|
|
prefix_space = " ".repeat(prefix_space.length())
|
|
var msg_proc = prefix + pre_msg + msg.replace("<nl>",post_msg + "\n" + prefix_space + pre_msg) + post_msg
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsed newline tags. Transformed \"" + msg + "\" into \"" + msg_proc + "\"",false)
|
|
return msg_proc
|
|
|
|
# Parses <lo> and </lo> tags
|
|
func _case_lower(msg:String) -> String:
|
|
if core.protection_mode: return ""
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing lowercase tags",false)
|
|
var msg_proc = msg
|
|
while true:
|
|
var index_one = msg_proc.find("<lo>")
|
|
var index_two = msg_proc.find("</lo>")
|
|
if index_one != -1:
|
|
if index_two != -1:
|
|
index_two = index_two + 5 - index_one
|
|
var index_proc = msg_proc.substr(index_one,index_two)
|
|
msg_proc = msg_proc.replace(index_proc,index_proc.replace("<lo>","").replace("</lo>","").to_lower())
|
|
else:
|
|
core.exception("Preprocessor","Failed parsing lowercase tags in message \"" + msg + "\" (missing end tag?)")
|
|
msg_proc = msg
|
|
break
|
|
else:
|
|
break
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsed lowercase tags. Transformed \"" + msg + "\" into \"" + msg_proc + "\"",false)
|
|
return msg_proc
|
|
|
|
# Parses <up> and </up> tags
|
|
func _case_upper(msg:String) -> String:
|
|
if core.protection_mode: return ""
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing uppercase tags",false)
|
|
var msg_proc = msg
|
|
while true:
|
|
var index_one = msg_proc.find("<up>")
|
|
var index_two = msg_proc.find("</up>")
|
|
if index_one != -1:
|
|
if index_two != -1:
|
|
index_two = index_two + 5 - index_one
|
|
var index_proc = msg_proc.substr(index_one,index_two)
|
|
msg_proc = msg_proc.replace(index_proc,index_proc.replace("<up>","").replace("</up>","").to_upper())
|
|
else:
|
|
core.exception("Preprocessor","Failed parsing uppercase tags in message \"" + msg + "\" (missing end tag?)")
|
|
msg_proc = msg
|
|
break
|
|
else:
|
|
break
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsed uppercase tags. Transformed \"" + msg + "\" into \"" + msg_proc + "\"",false)
|
|
return msg_proc
|
|
|
|
# Parses <ca> and </ca> tags
|
|
func _case_camelcase(msg:String) -> String:
|
|
if core.protection_mode: return ""
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing camelcase tags",false)
|
|
var msg_proc = msg
|
|
while true:
|
|
var index_one = msg_proc.find("<ca>")
|
|
var index_two = msg_proc.find("</ca>")
|
|
if index_one != -1:
|
|
if index_two != -1:
|
|
index_two = index_two + 5 - index_one
|
|
var index_proc = msg_proc.substr(index_one,index_two)
|
|
msg_proc = msg_proc.replace(index_proc,index_proc.replace("<ca>","").replace("</ca>","").to_camel_case())
|
|
else:
|
|
core.exception("Preprocessor","Failed parsing camelcase tags in message \"" + msg + "\" (missing end tag?)")
|
|
msg_proc = msg
|
|
break
|
|
else:
|
|
break
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsed camelcase tags. Transformed \"" + msg + "\" into \"" + msg_proc + "\"",false)
|
|
return msg_proc
|
|
|
|
# Parses <pa> and </pa> tags
|
|
func _case_pascalcase(msg:String) -> String:
|
|
if core.protection_mode: return ""
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing pascalcase tags",false)
|
|
var msg_proc = msg
|
|
while true:
|
|
var index_one = msg_proc.find("<pa>")
|
|
var index_two = msg_proc.find("</pa>")
|
|
if index_one != -1:
|
|
if index_two != -1:
|
|
index_two = index_two + 5 - index_one
|
|
var index_proc = msg_proc.substr(index_one,index_two)
|
|
msg_proc = msg_proc.replace(index_proc,index_proc.replace("<pa>","").replace("</pa>","").to_pascal_case())
|
|
else:
|
|
core.exception("Preprocessor","Failed parsing pascalcase tags in message \"" + msg + "\" (missing end tag?)")
|
|
msg_proc = msg
|
|
break
|
|
else:
|
|
break
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsed pascalcase tags. Transformed \"" + msg + "\" into \"" + msg_proc + "\"",false)
|
|
return msg_proc
|
|
|
|
# Parses <sn> and </sn> tags
|
|
func _case_snakecase(msg:String) -> String:
|
|
if core.protection_mode: return ""
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing snakecase tags",false)
|
|
var msg_proc = msg
|
|
while true:
|
|
var index_one = msg_proc.find("<sn>")
|
|
var index_two = msg_proc.find("</sn>")
|
|
if index_one != -1:
|
|
if index_two != -1:
|
|
index_two = index_two + 5 - index_one
|
|
var index_proc = msg_proc.substr(index_one,index_two)
|
|
msg_proc = msg_proc.replace(index_proc,index_proc.replace("<sn>","").replace("</sn>","").to_snake_case())
|
|
else:
|
|
core.exception("Preprocessor","Failed parsing snakecase tags in message \"" + msg + "\" (missing end tag?)")
|
|
msg_proc = msg
|
|
break
|
|
else:
|
|
break
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsed snakecase tags. Transformed \"" + msg + "\" into \"" + msg_proc + "\"",false)
|
|
return msg_proc
|
|
|
|
# Function calls to everything *case-related
|
|
func _case(msg:String) -> String:
|
|
if core.protection_mode: return ""
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing casing tags",false)
|
|
var msg_proc = _case_lower(msg)
|
|
msg_proc = _case_upper(msg_proc)
|
|
msg_proc = _case_camelcase(msg_proc)
|
|
msg_proc = _case_pascalcase(msg_proc)
|
|
msg_proc = _case_snakecase(msg_proc)
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsed casing tags. Transformed \"" + msg + "\" into \"" + msg_proc + "\"",false)
|
|
return msg_proc
|
|
|
|
# Replaces all escapes
|
|
func _escapes(msg:String) -> String:
|
|
if core.protection_mode: return ""
|
|
if diagnostic:logger.diag("CORE/preprocessor.gd","Parsing escape tags",false)
|
|
var msg_proc = msg.replace("<esc_nl>","<nl>")
|
|
msg_proc = msg_proc.replace("<esc_up>","<up>")
|
|
msg_proc = msg_proc.replace("<esc_lo>","<lo>")
|
|
msg_proc = msg_proc.replace("<esc_ca>","<ca>")
|
|
msg_proc = msg_proc.replace("<esc_pa>","<pa>")
|
|
msg_proc = msg_proc.replace("<esc_sn>","<sn>")
|
|
msg_proc = msg_proc.replace("</esc_up>","</up>")
|
|
msg_proc = msg_proc.replace("</esc_lo>","</lo>")
|
|
msg_proc = msg_proc.replace("</esc_ca>","</ca>")
|
|
msg_proc = msg_proc.replace("</esc_pa>","</pa>")
|
|
msg_proc = msg_proc.replace("</esc_sn>","</sn>")
|
|
msg_proc = msg_proc.replace("<esc_np>","<np>")
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsed escape tags. Transformed \"" + msg + "\" into \"" + msg_proc + "\"",false)
|
|
return msg_proc
|
|
|
|
# Checks for <np> tag and if found stops processing
|
|
func _noprocess(msg:String) -> bool:
|
|
if core.protection_mode: return true
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Checking for noprocess tag", false)
|
|
if msg.contains("<np>"):
|
|
return true
|
|
return false
|
|
|
|
# Executes all preprocessing functions and returns their combined work
|
|
func process(msg:String,prefix:String = "",pre_msg:String = "",post_msg:String = "",exclusion_filter:Array = []) -> String:
|
|
if core.protection_mode: return ""
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Call to process() recieved",false)
|
|
if !enabled:
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing failed: Preprocessor is disabled",false)
|
|
return msg
|
|
if _noprocess(msg):
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing stopped: noprocess tag detected", false)
|
|
return msg
|
|
var msg_proc = _case(msg)
|
|
msg_proc = _newline(msg_proc,prefix,pre_msg,post_msg,exclusion_filter)
|
|
msg_proc = _escapes(msg_proc)
|
|
if diagnostic: logger.diag("CORE/preprocessor.gd","Parsing complete", false)
|
|
return msg_proc
|