CORE/preprocessor.gd

######################################
#         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