#include <eepp/ui/doc/languages/ring.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>

namespace EE { namespace UI { namespace Doc { namespace Language {

SyntaxDefinition& addRing() {

	return SyntaxDefinitionManager::instance()->add(

		{ "Ring",
		  { "%.ring$", "%.rh$", "%.rform$" },
		  {
			  { { "#.*" }, "comment" },
			  { { "//.*" }, "comment" },
			  { { "/%*", "%*/" }, "comment" },
			  { { "\"", "\"", "\\" }, "string" },
			  { { "'", "'", "\\" }, "string" },
			  { { "`", "`", "\\" }, "string" },
			  { { "-?%d+[%d%.]*f?" }, "number" },
			  { { "-?0x%x+" }, "number" },
			  { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" },
			  { { "[%a_][%w_]*%f[(]" }, "function" },
			  { { "([Dd][Ee][Ff])(%s+)([%a_][%w_]*)" },
				{ "normal", "keyword", "normal", "function" } },
			  { { "([Ff][Uu][Nn][Cc])(%s+)([%a_][%w_]*)" },
				{ "normal", "keyword", "normal", "function" } },
			  { { "([Cc][Ll][Aa][Ss][Ss])(%s+)([%a_][%w_]*)" },
				{ "normal", "keyword", "normal", "function" } },
			  { { "[%a_][%w_]*" }, "symbol" },
			  { { "%?" }, "keyword" },
			  { { ":[%a_][%w_]*" }, "literal" },

		  },
		  {
			  { "int", "type" },
			  { "BREAK", "keyword" },
			  { "new", "keyword" },
			  { "IF", "keyword" },
			  { "Override", "type" },
			  { "End", "keyword" },
			  { "endfor", "keyword" },
			  { "Catch", "keyword" },
			  { "loop", "keyword" },
			  { "OTHER", "keyword" },
			  { "CASE", "keyword" },
			  { "long", "type" },
			  { "foreach", "keyword" },
			  { "LOAD", "keyword" },
			  { "String", "type" },
			  { "give", "keyword" },
			  { "STEP", "keyword" },
			  { "Give", "keyword" },
			  { "FALSE", "literal" },
			  { "end", "keyword" },
			  { "Loadsyntax", "keyword" },
			  { "short", "type" },
			  { "while", "keyword" },
			  { "bye", "keyword" },
			  { "endclass", "keyword" },
			  { "FOREACH", "keyword" },
			  { "VOID", "type" },
			  { "OBJECT", "type" },
			  { "break", "keyword" },
			  { "Object", "type" },
			  { "ENDCLASS", "keyword" },
			  { "BUT", "keyword" },
			  { "IMPORT", "keyword" },
			  { "Other", "keyword" },
			  { "changeringkeyword", "keyword" },
			  { "Enablehashcomments", "keyword" },
			  { "False", "literal" },
			  { "WHILE", "keyword" },
			  { "abstract", "type" },
			  { "ELSEIF", "keyword" },
			  { "CATCH", "keyword" },
			  { "Int", "type" },
			  { "Nl", "keyword" },
			  { "BOOLEAN", "type" },
			  { "SIGNED", "type" },
			  { "Break", "keyword" },
			  { "class", "keyword" },
			  { "void", "type" },
			  { "DOUBLE", "type" },
			  { "byte", "type" },
			  { "Changeringkeyword", "keyword" },
			  { "boolean", "type" },
			  { "Step", "keyword" },
			  { "ENDWHILE", "keyword" },
			  { "DO", "keyword" },
			  { "LOOP", "keyword" },
			  { "AGAIN", "keyword" },
			  { "other", "keyword" },
			  { "Return", "keyword" },
			  { "float", "type" },
			  { "see", "function" },
			  { "loadsyntax", "keyword" },
			  { "do", "keyword" },
			  { "to", "keyword" },
			  { "Abstract", "type" },
			  { "default", "keyword" },
			  { "but", "keyword" },
			  { "char", "type" },
			  { "BYTE", "type" },
			  { "Call", "keyword" },
			  { "Next", "keyword" },
			  { "get", "keyword" },
			  { "call", "keyword" },
			  { "from", "keyword" },
			  { "Static", "type" },
			  { "else", "keyword" },
			  { "next", "keyword" },
			  { "For", "keyword" },
			  { "Loop", "keyword" },
			  { "Foreach", "keyword" },
			  { "FUNC", "keyword" },
			  { "SEE", "function" },
			  { "ENDFUNCTION", "keyword" },
			  { "string", "type" },
			  { "Endfor", "keyword" },
			  { "DEFAULT", "keyword" },
			  { "Number", "type" },
			  { "Char", "type" },
			  { "elseif", "keyword" },
			  { "in", "keyword" },
			  { "NUMBER", "type" },
			  { "Float", "type" },
			  { "private", "keyword" },
			  { "signed", "type" },
			  { "DEF", "keyword" },
			  { "switch", "keyword" },
			  { "OVERRIDE", "type" },
			  { "Get", "keyword" },
			  { "LOADSYNTAX", "keyword" },
			  { "Exit", "keyword" },
			  { "import", "keyword" },
			  { "try", "keyword" },
			  { "Unsigned", "type" },
			  { "See", "function" },
			  { "In", "keyword" },
			  { "Short", "type" },
			  { "endtry", "keyword" },
			  { "LIST", "type" },
			  { "FLOAT", "type" },
			  { "DISABLEHASHCOMMENTS", "keyword" },
			  { "list", "type" },
			  { "Try", "keyword" },
			  { "catch", "keyword" },
			  { "LONG", "type" },
			  { "Endpackage", "keyword" },
			  { "EXIT", "keyword" },
			  { "SHORT", "type" },
			  { "done", "keyword" },
			  { "Done", "keyword" },
			  { "again", "keyword" },
			  { "on", "keyword" },
			  { "nl", "keyword" },
			  { "CLASS", "keyword" },
			  { "Disablehashcomments", "keyword" },
			  { "Long", "type" },
			  { "ENDSWITCH", "keyword" },
			  { "TRY", "keyword" },
			  { "Do", "keyword" },
			  { "for", "keyword" },
			  { "FROM", "keyword" },
			  { "Package", "keyword" },
			  { "OFF", "keyword" },
			  { "DONE", "keyword" },
			  { "RETURN", "keyword" },
			  { "IN", "keyword" },
			  { "null", "literal" },
			  { "PRINT", "function" },
			  { "CHANGERINGKEYWORD", "keyword" },
			  { "func", "keyword" },
			  { "INT", "type" },
			  { "NEXT", "keyword" },
			  { "disablehashcomments", "keyword" },
			  { "If", "keyword" },
			  { "CHAR", "type" },
			  { "Bye", "keyword" },
			  { "enablehashcomments", "keyword" },
			  { "endfunc", "keyword" },
			  { "STRING", "type" },
			  { "exit", "keyword" },
			  { "Endswitch", "keyword" },
			  { "ENDTRY", "keyword" },
			  { "Off", "keyword" },
			  { "On", "keyword" },
			  { "CALL", "keyword" },
			  { "ENDPACKAGE", "keyword" },
			  { "Else", "keyword" },
			  { "END", "keyword" },
			  { "Byte", "type" },
			  { "Elseif", "keyword" },
			  { "Default", "keyword" },
			  { "Changeringoperator", "keyword" },
			  { "static", "type" },
			  { "Endfunc", "keyword" },
			  { "CONTINUE", "keyword" },
			  { "off", "keyword" },
			  { "def", "keyword" },
			  { "true", "literal" },
			  { "Void", "type" },
			  { "endfunction", "keyword" },
			  { "Signed", "type" },
			  { "ENDFUNC", "keyword" },
			  { "PROTECTED", "type" },
			  { "Endtry", "keyword" },
			  { "Class", "keyword" },
			  { "case", "keyword" },
			  { "protected", "type" },
			  { "ON", "keyword" },
			  { "Switch", "keyword" },
			  { "STATIC", "type" },
			  { "Func", "keyword" },
			  { "PACKAGE", "keyword" },
			  { "continue", "keyword" },
			  { "While", "keyword" },
			  { "Put", "function" },
			  { "True", "literal" },
			  { "Print", "function" },
			  { "CHANGERINGOPERATOR", "keyword" },
			  { "Continue", "keyword" },
			  { "Endwhile", "keyword" },
			  { "BYE", "keyword" },
			  { "SWITCH", "keyword" },
			  { "load", "keyword" },
			  { "Endclass", "keyword" },
			  { "object", "type" },
			  { "false", "literal" },
			  { "Public", "type" },
			  { "GIVE", "keyword" },
			  { "ok", "keyword" },
			  { "ENDFOR", "keyword" },
			  { "Private", "keyword" },
			  { "endwhile", "keyword" },
			  { "print", "function" },
			  { "GET", "keyword" },
			  { "List", "type" },
			  { "TRUE", "literal" },
			  { "NL", "keyword" },
			  { "Import", "keyword" },
			  { "if", "keyword" },
			  { "TO", "keyword" },
			  { "ELSE", "keyword" },
			  { "NEW", "keyword" },
			  { "step", "keyword" },
			  { "public", "type" },
			  { "unsigned", "type" },
			  { "New", "keyword" },
			  { "number", "type" },
			  { "Case", "keyword" },
			  { "changeringoperator", "keyword" },
			  { "put", "function" },
			  { "PRIVATE", "keyword" },
			  { "double", "type" },
			  { "Load", "keyword" },
			  { "PUBLIC", "type" },
			  { "return", "keyword" },
			  { "NULL", "literal" },
			  { "But", "keyword" },
			  { "PUT", "function" },
			  { "Double", "type" },
			  { "Ok", "keyword" },
			  { "Null", "literal" },
			  { "endpackage", "keyword" },
			  { "From", "keyword" },
			  { "ABSTRACT", "type" },
			  { "ENABLEHASHCOMMENTS", "keyword" },
			  { "FOR", "keyword" },
			  { "Boolean", "type" },
			  { "OK", "keyword" },
			  { "package", "keyword" },
			  { "override", "type" },
			  { "Protected", "type" },
			  { "To", "keyword" },
			  { "Again", "keyword" },
			  { "Def", "keyword" },
			  { "UNSIGNED", "type" },
			  { "Endfunction", "keyword" },
			  { "endswitch", "keyword" },

		  },
		  "//",
		  {}

		} ).setBlockComment( { "/*", "*/" } );
}

}}}} // namespace EE::UI::Doc::Language
