Minor fixes and improvements in Odin, Lobster, OpenSCAD and SQL synta…

…x language definitions. Added YueScript syntax highlighting.
SpartanJ · Feb 23, 2025 · a7c389a · a7c389a
1 parent 173f976
commit a7c389a
Show file tree

Hide file tree

Showing 10 changed files with 270 additions and 119 deletions.
diff --git a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp
@@ -205,8 +205,7 @@ namespace EE { namespace UI { namespace Doc { namespace Language {
 		buf += "{ " + join( pattern.patterns ) + ", " + join( pattern.typesNames, true, true ) +
 			   str( pattern.syntax, ", ", "", false );
 		if ( pattern.isRegEx )
-			buf += ", "
-				   ", true";
+			buf += ", \"\", true";
 		buf += " },\n";
 	}
 	buf += "\n},\n";

diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/lobster.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/lobster.cpp
@@ -5,7 +5,7 @@ namespace EE { namespace UI { namespace Doc { namespace Language {
 
 void addLobster() {
 
-	auto& sd = SyntaxDefinitionManager::instance()->add(
+	SyntaxDefinitionManager::instance()->add(
 
 		{ "Lobster",
 		  { "%.lobster$" },
@@ -14,40 +14,49 @@ void addLobster() {
 			  { { "/%*", "%*/" }, "comment" },
 			  { { "(struct%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } },
 			  { { "(class%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } },
-			  { { "import%s+from" }, "keyword" },
+			  { { "[%w_]+%s*%f[{]" }, "keyword2" },
 			  { { "\"", "\"", "\\" }, "string" },
 			  { { "'", "'", "\\" }, "string" },
 			  { { "\"\"\"", "\"\"\"" }, "string" },
 			  { { "0x%x+" }, "number" },
 			  { { "%d+[%d%.eE]*f?" }, "number" },
 			  { { "%.?%d+f?" }, "number" },
-			  { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" },
+			  { { "[%+%-=/%*%^%%<>!~|&%?]" }, "operator" },
 			  { { "[%a_][%w_]*%f[(]" }, "function" },
 			  { { "[%a_][%w_]*" }, "symbol" },
 			  { { "%s+" }, "normal" },
 			  { { "%w+%f[%s]" }, "normal" },
 
 		  },
 		  {
-			  { "int", "keyword2" },	  { "and", "operator" },	   { "private", "keyword" },
-			  { "default", "keyword" },	  { "switch", "keyword" },	   { "pakfile", "keyword" },
-			  { "return", "keyword" },	  { "var", "keyword" },		   { "import", "keyword" },
-			  { "namespace", "keyword" }, { "void", "keyword2" },	   { "any", "keyword2" },
-			  { "typeof", "keyword" },	  { "enum_flags", "keyword" }, { "for", "keyword" },
-			  { "while", "keyword" },	  { "def", "keyword" },		   { "else", "keyword" },
-			  { "enum", "keyword" },	  { "nil", "literal" },		   { "not", "operator" },
-			  { "float", "keyword2" },	  { "is", "keyword" },		   { "fn", "keyword" },
-			  { "string", "keyword2" },	  { "or", "operator" },		   { "case", "keyword" },
-			  { "if", "keyword" },		  { "resource", "keyword" },   { "let", "keyword" },
-			  { "program", "keyword" },
+			  { "int", "keyword2" },		{ "and", "keyword" },
+			  { "private", "keyword" },		{ "default", "keyword" },
+			  { "abstract", "keyword" },	{ "static_frame", "keyword" },
+			  { "switch", "keyword" },		{ "guard", "keyword" },
+			  { "pakfile", "keyword" },		{ "attribute", "keyword" },
+			  { "return", "keyword" },		{ "var", "keyword" },
+			  { "import", "keyword" },		{ "class", "keyword" },
+			  { "namespace", "keyword" },	{ "void", "keyword2" },
+			  { "static", "keyword" },		{ "any", "keyword2" },
+			  { "typeof", "keyword" },		{ "enum_flags", "keyword" },
+			  { "super", "keyword" },		{ "member", "keyword" },
+			  { "for", "keyword" },			{ "while", "keyword" },
+			  { "from", "keyword" },		{ "member_frame", "keyword" },
+			  { "def", "keyword" },			{ "else", "keyword" },
+			  { "constructor", "keyword" }, { "enum", "keyword" },
+			  { "operator", "keyword" },	{ "nil", "literal" },
+			  { "not", "keyword" },			{ "float", "keyword2" },
+			  { "struct", "keyword" },		{ "is", "keyword" },
+			  { "fn", "keyword" },			{ "string", "keyword2" },
+			  { "or", "keyword" },			{ "case", "keyword" },
+			  { "if", "keyword" },			{ "resource", "keyword" },
+			  { "let", "keyword" },			{ "program", "keyword" },
 
 		  },
 		  "//",
 		  {}
 
 		} );
-
-	sd.setFoldRangeType( FoldRangeType::Indentation );
 }
 
 }}}} // namespace EE::UI::Doc::Language
diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.cpp
@@ -5,7 +5,7 @@ namespace EE { namespace UI { namespace Doc { namespace Language {
 
 void addOdin() {
 
-	auto& sd = SyntaxDefinitionManager::instance()->add(
+	SyntaxDefinitionManager::instance()->add(
 
 		{ "Odin",
 		  { "%.odin$" },
@@ -20,138 +20,149 @@ void addOdin() {
 			  { { "0[dz][%d_]+" }, "number" },
 			  { { "0x[%da-fA-F_]+" }, "number" },
 			  { { "-?%d+[%d%._e]*i?" }, "number" },
-			  { { "([%a_][%w_]+)(%s+::%s+)(proc%s*)%f[(]" },
-				{ "normal", "function", "operator", "keyword" } },
-			  { { "([%a_][%w_]+)(%s+::%s+)%f[(]" }, { "normal", "function", "operator" } },
-			  { { "([%a_][%w_]+)(%s+::%s+)(struct%s*)%f[{]" },
-				{ "normal", "keyword2", "operator", "keyword" } },
-			  { { "([%a_][%w_]+)(%s+::%s+)(enum%s*)(%w+%s*)%f[{]" },
-				{ "normal", "keyword2", "operator", "keyword", "keyword2" } },
 			  { { "[<>~=+-*/]=" }, "operator" },
-			  { { "[%+%-=/%*%^%%<>!~|&:]" }, "operator" },
+			  { { "%.%." }, "operator" },
+			  { { "[%+%-=/%*%^%%<>!~|&:%?]" }, "operator" },
 			  { { "%$[%a_][%w_]*" }, "operator" },
 			  { { "[%a_][%w_]*%f[(]" }, "function" },
 			  { { "[#@][%a_][%w_]*" }, "keyword2" },
 			  { { "[#@]%b()" }, "keyword2" },
 			  { { "[%a_][%w_]*" }, "symbol" },
+			  { { "%s+" }, "normal" },
+			  { { "%w+%f[%s]" }, "normal" },
 
 		  },
 		  {
-			  { "typeid", "keyword2" },
-			  { "i64be", "keyword2" },
-			  { "conj", "keyword2" },
+			  { "int", "keyword2" },
 			  { "i32le", "keyword2" },
-			  { "rawptr", "keyword2" },
-			  { "real", "keyword2" },
-			  { "typeid_of", "keyword2" },
-			  { "type_info_of", "keyword2" },
+			  { "bit_set", "keyword" },
+			  { "len", "keyword2" },
+			  { "not_in", "keyword" },
+			  { "f16be", "keyword2" },
+			  { "uintptr", "keyword2" },
 			  { "offset_of", "keyword2" },
-			  { "i64le", "keyword2" },
-			  { "align_of", "keyword2" },
-			  { "f32", "keyword2" },
 			  { "min", "keyword2" },
-			  { "u64", "keyword2" },
+			  { "i64be", "keyword2" },
+			  { "size_of", "keyword2" },
+			  { "i64le", "keyword2" },
+			  { "any", "keyword2" },
+			  { "i64", "keyword2" },
 			  { "cap", "keyword2" },
+			  { "or_return", "keyword" },
+			  { "for", "keyword" },
+			  { "u64", "keyword2" },
+			  { "jmag", "keyword2" },
+			  { "context", "keyword" },
+			  { "f64", "keyword2" },
+			  { "swizzle", "keyword2" },
+			  { "enum", "keyword" },
+			  { "u16be", "keyword2" },
+			  { "when", "keyword" },
+			  { "break", "keyword" },
+			  { "f64be", "keyword2" },
+			  { "f64le", "keyword2" },
+			  { "type_info_base", "keyword2" },
 			  { "cstring", "keyword2" },
-			  { "len", "keyword2" },
-			  { "byte", "keyword2" },
-			  { "transmute", "keyword2" },
-			  { "proc", "keyword" },
-			  { "any", "keyword2" },
+			  { "u32be", "keyword2" },
+			  { "b64", "keyword2" },
+			  { "i32be", "keyword2" },
 			  { "clamp", "keyword2" },
-			  { "auto_cast", "keyword2" },
-			  { "uintptr", "keyword2" },
 			  { "u16le", "keyword2" },
-			  { "complex", "keyword2" },
-			  { "const", "keyword" },
-			  { "union", "keyword" },
-			  { "u32", "keyword2" },
-			  { "opaque", "keyword" },
-			  { "type_info_base", "keyword2" },
+			  { "i16be", "keyword2" },
+			  { "b16", "keyword2" },
+			  { "dynamic", "keyword" },
+			  { "or_continue", "keyword" },
+			  { "map", "keyword" },
+			  { "b32", "keyword2" },
+			  { "transmute", "keyword2" },
+			  { "byte", "keyword2" },
+			  { "type_of", "keyword2" },
 			  { "defer", "keyword" },
-			  { "max", "keyword2" },
-			  { "do", "keyword" },
-			  { "for", "keyword" },
-			  { "macro", "keyword" },
-			  { "package", "keyword" },
-			  { "bit_set", "keyword" },
-			  { "switch", "keyword" },
-			  { "no_inline", "keyword" },
-			  { "quaternion256", "keyword2" },
-			  { "if", "keyword" },
+			  { "quaternion", "keyword2" },
+			  { "assert", "keyword2" },
+			  { "true", "literal" },
+			  { "soa_unzip", "keyword2" },
+			  { "f16le", "keyword2" },
+			  { "kmag", "keyword2" },
+			  { "real", "keyword2" },
+			  { "offset_of_selector", "keyword2" },
+			  { "f32le", "keyword2" },
 			  { "case", "keyword" },
-			  { "foreign", "keyword" },
-			  { "not_in", "keyword" },
-			  { "inline", "keyword" },
-			  { "import", "keyword" },
-			  { "u8", "keyword2" },
-			  { "nil", "literal" },
-			  { "i16", "keyword2" },
-			  { "swizzle", "keyword2" },
-			  { "u16", "keyword2" },
-			  { "false", "literal" },
-			  { "f16", "keyword2" },
+			  { "cast", "keyword2" },
 			  { "distinct", "keyword" },
-			  { "rune", "keyword2" },
-			  { "i16le", "keyword2" },
-			  { "b64", "keyword2" },
-			  { "i128le", "keyword2" },
+			  { "do", "keyword" },
 			  { "quaternion128", "keyword2" },
-			  { "u16be", "keyword2" },
-			  { "i32be", "keyword2" },
+			  { "continue", "keyword" },
+			  { "asm", "keyword" },
+			  { "i128be", "keyword2" },
+			  { "i16", "keyword2" },
+			  { "quaternion256", "keyword2" },
+			  { "expand_values", "keyword2" },
+			  { "bool", "keyword2" },
+			  { "u64le", "keyword2" },
+			  { "i16le", "keyword2" },
+			  { "i8", "keyword2" },
+			  { "u32", "keyword2" },
+			  { "or_else", "keyword" },
+			  { "union", "keyword" },
+			  { "rawptr", "keyword2" },
 			  { "u128be", "keyword2" },
-			  { "i16be", "keyword2" },
-			  { "u32be", "keyword2" },
-			  { "complex64", "keyword2" },
+			  { "complex", "keyword2" },
+			  { "i128le", "keyword2" },
 			  { "b8", "keyword2" },
-			  { "b32", "keyword2" },
-			  { "i32", "keyword2" },
-			  { "assert", "keyword2" },
-			  { "complex128", "keyword2" },
-			  { "complex32", "keyword2" },
-			  { "return", "keyword" },
-			  { "u128", "keyword2" },
+			  { "conj", "keyword2" },
+			  { "false", "literal" },
 			  { "b128", "keyword2" },
-			  { "i128be", "keyword2" },
-			  { "i8", "keyword2" },
-			  { "int", "keyword2" },
-			  { "i64", "keyword2" },
-			  { "bool", "keyword2" },
-			  { "imag", "keyword2" },
+			  { "type_info_of", "keyword2" },
+			  { "else", "keyword" },
+			  { "foreign", "keyword" },
+			  { "u128le", "keyword2" },
+			  { "typeid_of", "keyword2" },
+			  { "align_of", "keyword2" },
 			  { "u64be", "keyword2" },
-			  { "true", "literal" },
-			  { "context", "keyword" },
-			  { "dynamic", "keyword" },
+			  { "auto_cast", "keyword2" },
+			  { "struct", "keyword" },
+			  { "quaternion64", "keyword2" },
+			  { "soa_zip", "keyword2" },
 			  { "string", "keyword2" },
-			  { "i128", "keyword2" },
-			  { "when", "keyword" },
-			  { "u32le", "keyword2" },
-			  { "size_of", "keyword2" },
-			  { "u64le", "keyword2" },
-			  { "type_of", "keyword2" },
+			  { "complex32", "keyword2" },
+			  { "if", "keyword" },
+			  { "raw_data", "keyword2" },
+			  { "in", "keyword" },
+			  { "f32", "keyword2" },
+			  { "i32", "keyword2" },
+			  { "switch", "keyword" },
 			  { "using", "keyword" },
-			  { "map", "keyword" },
+			  { "offset_of_by_string", "keyword2" },
+			  { "typeid", "keyword2" },
+			  { "offset_of_member", "keyword2" },
+			  { "return", "keyword" },
+			  { "f16", "keyword2" },
+			  { "u8", "keyword2" },
+			  { "import", "keyword" },
+			  { "max", "keyword2" },
+			  { "imag", "keyword2" },
+			  { "proc", "keyword" },
+			  { "complex128", "keyword2" },
 			  { "uint", "keyword2" },
-			  { "struct", "keyword" },
-			  { "cast", "keyword2" },
-			  { "enum", "keyword" },
+			  { "or_break", "keyword" },
+			  { "complex64", "keyword2" },
+			  { "i128", "keyword2" },
 			  { "abs", "keyword2" },
-			  { "f64", "keyword2" },
-			  { "u128le", "keyword2" },
-			  { "continue", "keyword" },
+			  { "package", "keyword" },
+			  { "nil", "literal" },
+			  { "rune", "keyword2" },
+			  { "u128", "keyword2" },
 			  { "fallthrough", "keyword" },
-			  { "in", "keyword" },
-			  { "break", "keyword" },
-			  { "else", "keyword" },
-			  { "or_break", "keyword" },
-			  { "or_continue", "keyword" },
+			  { "f32be", "keyword2" },
+			  { "u16", "keyword2" },
+			  { "u32le", "keyword2" },
+
 		  },
 		  "//",
 		  {}
 
 		} );
-
-	sd.setFoldRangeType( FoldRangeType::Braces ).setFoldBraces( { { '{', '}' } } );
 }
 
 }}}} // namespace EE::UI::Doc::Language
diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.hpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.hpp
@@ -5,6 +5,6 @@ namespace EE { namespace UI { namespace Doc { namespace Language {
 
 extern void addOdin();
 
-}}}}
+}}}} // namespace EE::UI::Doc::Language
 
 #endif
diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/openscad.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/openscad.cpp
@@ -65,6 +65,7 @@ void addOpenSCAD() {
 			  { "hull", "keyword" },
 			  { "is_bool", "function" },
 			  { "version_num", "function" },
+			  { "parent_module", "function" },
 			  { "scale", "keyword" },
 			  { "atan2", "keyword" },
 			  { "intersection", "keyword" },

diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/sql.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/sql.cpp
@@ -352,6 +352,7 @@ void addSQL() {
 			  { "UUID", "keyword2" },
 			  { "at", "keyword" },
 			  { "HAVING", "keyword" },
+			  { "ADD", "keyword" },
 			  { "from", "keyword" },
 			  { "insert", "keyword" },
 			  { "table", "keyword" },
-Original file line number
+Diff line change
@@ Expand Up @@
     extern void addOdin();
-    }}}}
+    }}}} // namespace EE::UI::Doc::Language
     #endif