cl.10x_syntax

# Format: <SettingName>: <Settingvalue>
# Setting name must appear at start of line and there must be whitespace after the colon.
# Multiple values can be comma separated or on subsequent lines.
#
# Valid settings for colour rules:
# REGEX()   A regular expression. Colours entire match or first group.
# WORD()	Matches a word (case sensitive)
# WORDI()   Matches a word (case insensitive)
# TEXT()	Match any text in the line (case sensitive)
# TEXTI()	Match any text in the line (case insensitive)

#----------------------------------------------
# settings

Extensions:					.cl

BlockCommentStart:			/*

BlockCommentEnd:			*/

#----------------------------------------------
# colour rules

Language.Comment:
REGEX(//.*)

Language.String:
REGEX(L?"[^"\\]*(?:\\.[^"\\]*)*")
REGEX(L?'[^'\\]*(?:\\.[^'\\]*)*')

Language.Preprocessor:
REGEX(\s*#\s*[a-zA-Z_]+\w*)

Language.Namespace:
REGEX(namespace\s+([a-zA-Z_]+\w*))

Language.Typedef:
REGEX(typedef\s*.*\s+([a-zA-Z_]+\w*))

Language.Number:
REGEX((0[xX][a-zA-Z0-9]+))
REGEX((0[bB][0-9]+))
REGEX([0-9]+[fd]*[uUlLzZfFdD]*)
REGEX([0-9]+\.[0-9]*[fd]*[fFdD]*)
REGEX([0-9]*\.[0-9]+[fd]*[fFdD]*)

Language.Brace:
TEXT({)
TEXT(})

Language.Bracket:
TEXT(()
TEXT())

Language.SquareBracket:
TEXT([)
TEXT(])

Language.SemiColon:
TEXT(;)

Language.Comma:
TEXT(,)

# try and recognise MyClass:: and MyTemplate<MyClass> template args as classes
Language.Class:
REGEX(([a-zA-Z_]+\w*)::)
REGEX(([a-zA-Z_]+\w*)<)
REGEX(<([a-zA-Z_]+\w*)>)
REGEX(<([a-zA-Z_]+\w*)\s*,)

Language.Enum:
REGEX(enum\s+class\s+([a-zA-Z_]+\w*))
REGEX(enum\s+([a-zA-Z_]+\w*))

Language.Keyword:
# OpenCL
WORD(__kernel)
WORD(__constant)
WORD(__global)
WORD(__local)
WORD(__private)
WORD(uint)
WORD(uint2)
WORD(uint4)
WORD(uint8)
WORD(uint16)
WORD(ulong)
WORD(ulong2)
WORD(ulong4)
WORD(ulong8)
WORD(ulong16)
WORD(float2)
WORD(float4)
WORD(float8)
WORD(float16)
WORD(__attribute__)
WORD(packed)
WORD(opencl_unroll_hint)
# C / C++
WORD(alignas)
WORD(alignof)
WORD(and)
WORD(and_eq)
WORD(asm)
WORD(atomic_cancel)
WORD(atomic_commit)
WORD(atomic_noexcept)
WORD(auto)
WORD(bitand)
WORD(bitor)
WORD(bool)
WORD(break)
WORD(case)
WORD(catch)
WORD(char)
WORD(char8_t)
WORD(char16_t)
WORD(char32_t)
WORD(class)
WORD(compl)
WORD(concept)
WORD(const)
WORD(consteval)
WORD(constexpr)
WORD(constinit)
WORD(const_cast)
WORD(continue)
WORD(co_await)
WORD(co_return)
WORD(co_yield)
WORD(decltype)
WORD(default)
WORD(delete)
WORD(do)
WORD(double)
WORD(dynamic_cast)
WORD(else)
WORD(enum)
WORD(explicit)
WORD(export)
WORD(extern)
WORD(false)
WORD(float)
WORD(for)
WORD(friend)
WORD(goto)
WORD(if)
WORD(inline)
WORD(int)
WORD(long)
WORD(mutable)
WORD(namespace)
WORD(new)
WORD(noexcept)
WORD(not)
WORD(not_eq)
WORD(nullptr)
WORD(operator)
WORD(or)
WORD(or_eq)
WORD(private)
WORD(protected)
WORD(public)
WORD(reflexpr)
WORD(register)
WORD(reinterpret_cast)
WORD(requires)
WORD(return)
WORD(short)
WORD(signed)
WORD(sizeof)
WORD(static)
WORD(static_assert)
WORD(static_cast)
WORD(struct)
WORD(switch)
WORD(synchronized)
WORD(template)
WORD(this)
WORD(thread_local)
WORD(throw)
WORD(true)
WORD(try)
WORD(typedef)
WORD(typeid)
WORD(typename)
WORD(union)
WORD(unsigned)
WORD(using)
WORD(virtual)
WORD(void)
WORD(volatile)
WORD(wchar_t)
WORD(while)
WORD(xor)
WORD(xor_eq)

Language.Operator:
TEXT(.)
TEXT(:)
TEXT(-)
TEXT(>)
TEXT(=)
TEXT(+)
TEXT(-)
TEXT(*)
TEXT(/)
TEXT(%)
TEXT(<)
TEXT(>)
TEXT(.)
TEXT(!)
TEXT(|)
TEXT(&)
TEXT(:)
TEXT(~)
TEXT(?)
TEXT(^)

Language.MemberFunction:
REGEX((?:->|\.)([a-zA-Z_]+\w*)\()
REGEX([a-zA-Z_]+\w*::([a-zA-Z_]+\w*)\()

# stop constructor initializers from being interpreted as functions
Language.Variable:
REGEX(^\s*:\s*([a-zA-Z_]+\w*)\(.*\),)
REGEX(^\s*([a-zA-Z_]+\w*)\(.*\),)
REGEX(^\s*,([a-zA-Z_]+\w*)\(.*\))
REGEX(^\s*([a-zA-Z_]+\w*)\(.*\)\s*$)

# treat uppercase functions as preprocessor macros
Language.Preprocessor:
REGEX(\b([A-Z_]+[A-Z0-9_]*)\()

Language.Function:
REGEX(\b([a-zA-Z_]+\w*)\()

Language.Class:
REGEX(::([a-zA-Z_]+\w*))

# treat uppercase variables as preprocessor defines
Language.Preprocessor:
REGEX([^->|\.]\b[A-Z_]+[A-Z0-9_]+\b)

# member variables often start with mp_ or m or are accessed with . or ->
Language.MemberVariable:
REGEX(\b(?:m_|mp_)\w+\b)
REGEX(\b(?:m)[A-Z]\w+\w*\b)
REGEX((?:\.|->)([a-zA-Z_]+\w*))

# treat 'MyClass*', 'MyClass&' and 'MyClass test' as classes
Language.Class:
REGEX(([a-zA-Z_]+\w*)\s*[\*&])
REGEX(([a-zA-Z_]+\w*)\s+(?:[a-zA-Z_]+\w*))

Language.Variable:
REGEX(\b[a-zA-Z_]+\w*\b)