xolatile
/
xighlight
1
1
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Xighlight C source code...
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
34 Commits
1 Branch
946KB
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
xighlight/xighlight.c

455 lines
30KB
Raw Permalink Blame History 

  1. #include <xolatile/xtandard.c>

  2. #include <xolatile/xyntax.c>

  3. 

  4. static void highlight_common (void) {

  5. 	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\"@#$` \t\r\n";

  6. 

  7. 	syntax_define (false, false, "'",                      "'",        '\\', colour_pink, effect_bold);

  8. 	syntax_define (false, false, "\"",                     "\"",       '\\', colour_pink, effect_normal);

  9. 	syntax_define (true,  false, "()[]{}",                 "",         '\0', colour_blue, effect_normal);

  10. 	syntax_define (true,  false, ".,:;<=>+*-/%!&~^?|@#$`", "",         '\0', colour_cyan, effect_normal);

  11. 	syntax_define (true,  true,  "0123456789",             separators, '\0', colour_pink, effect_bold);

  12. }

  13. 

  14. static void highlight_c (void) {

  15. 	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";

  16. 

  17. 	char * keywords [] = {

  18. 		"register",         "volatile",         "auto",             "const",            "static",           "extern",           "if",               "else",

  19. 		"do",               "while",            "for",              "continue",         "switch",           "case",             "default",          "break",

  20. 		"enum",             "union",            "struct",           "typedef",          "goto",             "void",             "return",           "sizeof",

  21. 		"char",             "short",            "int",              "long",             "signed",           "unsigned",         "float",            "double"

  22. 	};

  23. 

  24. 	int word;

  25. 

  26. 	syntax_define (false, false, "/*", "*/", '\0', colour_grey,   effect_bold);

  27. 	syntax_define (false, false, "//", "\n", '\0', colour_grey,   effect_bold);

  28. 	syntax_define (false, false, "#",  "\n", '\\', colour_yellow, effect_italic);

  29. 	syntax_define (false, false, "'",  "'",  '\\', colour_pink,   effect_bold);

  30. 	syntax_define (false, false, "\"", "\"", '\\', colour_pink,   effect_normal);

  31. 

  32. 	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {

  33. 		syntax_define (false, true, keywords [word], separators, '\0', colour_yellow, effect_bold);

  34. 	}

  35. 

  36. 	syntax_define (true, false, "()[]{}",             "", '\0', colour_blue, effect_normal);

  37. 	syntax_define (true, false, ".,:;<=>+*-/%!&~^?|", "", '\0', colour_cyan, effect_normal);

  38. 

  39. 	syntax_define (true, true, "0123456789",                 separators, '\0', colour_pink,  effect_bold);

  40. 	syntax_define (true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', colour_white, effect_normal);

  41. 	syntax_define (true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', colour_white, effect_bold);

  42. 	syntax_define (true, true, "_",                          separators, '\0', colour_white, effect_italic);

  43. }

  44. 

  45. static void highlight_ada (void) {

  46. 	char * separators = ".,:;<=>+-*/&|()\" \t\r\n";

  47. 

  48. 	char * keywords [] = {

  49. 		"abort",            "else",             "new",              "return",           "abs",              "elsif",            "not",              "reverse",

  50. 		"abstract",         "end",              "null",             "accept",           "entry",            "select",           "access",           "of",

  51. 		"separate",         "aliased",          "exit",             "or",               "some",             "all",              "others",           "subtype",

  52. 		"and",              "for",              "out",              "array",            "function",         "at",               "tagged",           "generic",

  53. 		"package",          "task",             "begin",            "goto",             "pragma",           "body",             "private",          "then",

  54. 		"type",             "case",             "in",               "constant",         "until",            "is",               "raise",            "use",

  55. 		"if",               "declare",          "range",            "delay",            "limited",          "record",           "when",             "delta",

  56. 		"loop",             "rem",              "while",            "digits",           "renames",          "with",             "do",               "mod",

  57. 		"requeue",          "xor",              "procedure",        "protected",        "interface",        "synchronized",     "exception",        "overriding",

  58. 		"terminate"

  59. 	};

  60. 

  61. 	int word;

  62. 

  63. 	syntax_define (false, false, "--", "\n", '\0', colour_grey,   effect_bold);

  64. 	syntax_define (false, false, "'",  "'",  '\\', colour_pink,   effect_bold);

  65. 	syntax_define (false, false, "\"", "\"", '\\', colour_pink,   effect_normal);

  66. 

  67. 	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {

  68. 		syntax_define (false, true, keywords [word], separators, '\0', colour_yellow, effect_bold);

  69. 	}

  70. 

  71. 	syntax_define (true, false, "()",             "", '\0', colour_blue, effect_normal);

  72. 	syntax_define (true, false, ".,:;<=>+-*/&|'", "", '\0', colour_cyan, effect_normal);

  73. 

  74. 	syntax_define (true, true, "0123456789",                 separators, '\0', colour_pink,  effect_bold);

  75. 	syntax_define (true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', colour_white, effect_normal);

  76. 	syntax_define (true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', colour_white, effect_bold);

  77. }

  78. 

  79. static void highlight_cpp (void) {

  80. 	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";

  81. 

  82. 	char * keywords [] = {

  83. 		"alignas",          "alignof",          "and",              "and_eq",           "asm",              "atomic_cancel",    "atomic_commit",    "atomic_noexcept",

  84. 		"auto",             "bitand",           "bitor",            "bool",             "break",            "case",             "catch",            "char",

  85. 		"char8_t",          "char16_t",         "char32_t",         "class",            "compl",            "concept",          "const",            "consteval",

  86. 		"constexpr",        "constinit",        "const_cast",       "continue",         "co_await",         "co_return",        "co_yield",         "decltype",

  87. 		"default",          "delete",           "do",               "double",           "dynamic_cast",     "else",             "enum",             "explicit",

  88. 		"export",           "extern",           "false",            "float",            "for",              "friend",           "goto",             "if",

  89. 		"inline",           "int",              "long",             "mutable",          "namespace",        "new",              "noexcept",         "not",

  90. 		"not_eq",           "nullptr",          "operator",         "or",               "or_eq",            "private",          "protected",        "public",

  91. 		"reflexpr",         "register",         "reinterpret_cast", "requires",         "return",           "short",            "signed",           "sizeof",

  92. 		"static",           "static_assert",    "static_cast",      "struct",           "switch",           "synchronized",     "template",         "this",

  93. 		"thread_local",     "throw",            "true",             "try",              "typedef",          "typeid",           "typename",         "union",

  94. 		"unsigned",         "using",            "virtual",          "void",             "volatile",         "wchar_t",          "while",            "xor",

  95. 		"xor_eq",           "final",            "override",         "import",           "module",           "transaction_safe"

  96. 	};

  97. 

  98. 	int word;

  99. 

  100. 	syntax_define (false, false, "/*", "*/", '\0', colour_grey,   effect_bold);

  101. 	syntax_define (false, false, "//", "\n", '\0', colour_grey,   effect_bold);

  102. 	syntax_define (false, false, "#",  "\n", '\\', colour_yellow, effect_italic);

  103. 	syntax_define (false, false, "'",  "'",  '\\', colour_pink,   effect_bold);

  104. 	syntax_define (false, false, "\"", "\"", '\\', colour_pink,   effect_normal);

  105. 

  106. 	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {

  107. 		syntax_define (false, true, keywords [word], separators, '\0', colour_yellow, effect_bold);

  108. 	}

  109. 

  110. 	syntax_define (true, false, "()[]{}",             "", '\0', colour_blue, effect_normal);

  111. 	syntax_define (true, false, ".,:;<=>+*-/%!&~^?|", "", '\0', colour_cyan, effect_normal);

  112. 

  113. 	syntax_define (true, true, "0123456789",                 separators, '\0', colour_pink,  effect_bold);

  114. 	syntax_define (true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', colour_white, effect_normal);

  115. 	syntax_define (true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', colour_white, effect_bold);

  116. 	syntax_define (true, true, "_",                          separators, '\0', colour_white, effect_italic);

  117. }

  118. 

  119. static void highlight_common_assembly (void) {

  120. 	char * separators = ".,+-[]<> \t\r\n";

  121. 

  122. 	char * instructions [] = {

  123. 		"mov",              "movabs",           "movapd",           "movaps",           "movebe",           "movsd",            "movsx",            "movzx",

  124. 		"movsxd",           "movd",             "movq",             "movs",             "movsb",            "movsw",            "movsd",            "movsq",

  125. 		"cmovmp",           "cmovrcxz",         "cmovc",            "cmovnc",           "cmove",            "cmovne",           "cmovz",            "cmovnz",

  126. 		"cmovg",            "cmovng",           "cmovge",           "cmovnge",          "cmovl",            "cmovnl",           "cmovle",           "cmovnle",

  127. 		"cmova",            "cmovna",           "cmovae",           "cmovnae",          "cmovb",            "cmovnb",           "cmovbe",           "cmovnbe",

  128. 		"cmovs",            "cmovns",           "cmovo",            "cmovno",           "cmovp",            "cmovnp",           "cmovpo",           "cmovpe",

  129. 		"cmp",              "cmps",             "cmpsb",            "cmpsw",            "cmpsd",            "cmpsq",            "cmpxchg",          "lea",

  130. 		"monitor",          "cpuid",            "in",               "out",              "syscall",          "sysenter",         "sysret",           "sysexit",

  131. 		"swap",             "bswap",            "pop",              "push",             "call",             "ret",              "enter",            "leave",

  132. 		"and",              "or",               "not",              "neg",              "sal",              "sar",              "shl",              "shr",

  133. 		"inc",              "dec",              "add",              "sub",              "mul",              "div",              "imul",             "idiv",

  134. 		"nop",              "fnop",             "adc",              "sbb",              "aaa",              "aas",              "aam",              "aad",

  135. 		"jmp",              "jrcxz",            "jc",               "jnc",              "je",               "jne",              "jz",               "jnz",

  136. 		"jg",               "jng",              "jge",              "jnge",             "jl",               "jnl",              "jle",              "jnle",

  137. 		"ja",               "jna",              "jae",              "jnae",             "jb",               "jnb",              "jbe",              "jnbe",

  138. 		"js",               "jns",              "jo",               "jno",              "jp",               "jnp",              "jpo",              "jpe",

  139. 		"rep",              "repe",             "repz",             "repne",            "repnz",            "loop",             "loope",            "loopne"

  140. 	};

  141. 

  142. 	char * registers [] = {

  143. 		"rax",              "rcx",              "rdx",              "rbx",              "rsp",              "rbp",              "rsi",              "rdi",

  144. 		"r8",               "r9",               "r10",              "r11",              "r12",              "r13",              "r14",              "r15",

  145. 		"eax",              "ecx",              "edx",              "ebx",              "esp",              "ebp",              "esi",              "edi",

  146. 		"r8d",              "r9d",              "r10d",             "r11d",             "r12d",             "r13d",             "r14d",             "r15d",

  147. 		"ax",               "cx",               "dx",               "bx",               "sp",               "bp",               "si",               "di",

  148. 		"r8w",              "r9w",              "r10w",             "r11w",             "r12w",             "r13w",             "r14w",             "r15w",

  149. 		"al",               "cl",               "dl",               "bl",               "spl",              "bpl",              "sil",              "dil",

  150. 		"r8b",              "r9b",              "r10b",             "r11b",             "r12b",             "r13b",             "r14b",             "r15b",

  151. 		"ah",               "ch",               "dh",               "bh"

  152. 	};

  153. 

  154. 	int word;

  155. 

  156. 	syntax_define (false, false, ";",  "\n", '\0', colour_grey, effect_bold);

  157. 	syntax_define (false, false, "'",  "'",  '\\', colour_pink, effect_bold);

  158. 	syntax_define (false, false, "\"", "\"", '\\', colour_pink, effect_normal);

  159. 

  160. 	for (word = 0; word != (int) (sizeof (instructions) / sizeof (instructions [0])); ++word) {

  161. 		syntax_define (false, true, instructions [word], separators, '\0', colour_yellow, effect_bold);

  162. 	}

  163. 

  164. 	for (word = 0; word != (int) (sizeof (registers) / sizeof (registers [0])); ++word) {

  165. 		syntax_define (false, true, registers [word], separators, '\0', colour_cyan, effect_bold);

  166. 	}

  167. 

  168. 	syntax_define (true, false, "()[]{}",     "", '\0', colour_blue, effect_normal);

  169. 	syntax_define (true, false, ".,+*-/%$<>", "", '\0', colour_cyan, effect_normal);

  170. 

  171. 	syntax_define (true, true, "0123456789",                 separators, '\0', colour_pink,  effect_bold);

  172. 	syntax_define (true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', colour_white, effect_normal);

  173. 	syntax_define (true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', colour_white, effect_bold);

  174. 	syntax_define (true, true, "_",                          separators, '\0', colour_white, effect_italic);

  175. }

  176. 

  177. static void highlight_flat_assembly (void) {

  178. 	char * separators = ".,+-=:;(){}[]%$<> \t\r\n";

  179. 

  180. 	char * instructions [] = {

  181. 		"mov",              "movabs",           "movapd",           "movaps",           "movebe",           "movsd",            "movsx",            "movzx",

  182. 		"movsxd",           "movd",             "movq",             "movs",             "movsb",            "movsw",            "movsd",            "movsq",

  183. 		"cmovmp",           "cmovrcxz",         "cmovc",            "cmovnc",           "cmove",            "cmovne",           "cmovz",            "cmovnz",

  184. 		"cmovg",            "cmovng",           "cmovge",           "cmovnge",          "cmovl",            "cmovnl",           "cmovle",           "cmovnle",

  185. 		"cmova",            "cmovna",           "cmovae",           "cmovnae",          "cmovb",            "cmovnb",           "cmovbe",           "cmovnbe",

  186. 		"cmovs",            "cmovns",           "cmovo",            "cmovno",           "cmovp",            "cmovnp",           "cmovpo",           "cmovpe",

  187. 		"cmp",              "cmps",             "cmpsb",            "cmpsw",            "cmpsd",            "cmpsq",            "cmpxchg",          "lea",

  188. 		"monitor",          "cpuid",            "in",               "out",              "syscall",          "sysenter",         "sysret",           "sysexit",

  189. 		"swap",             "bswap",            "pop",              "push",             "call",             "ret",              "enter",            "leave",

  190. 		"and",              "or",               "not",              "neg",              "sal",              "sar",              "shl",              "shr",

  191. 		"inc",              "dec",              "add",              "sub",              "mul",              "div",              "imul",             "idiv",

  192. 		"nop",              "fnop",             "adc",              "sbb",              "aaa",              "aas",              "aam",              "aad",

  193. 		"jmp",              "jrcxz",            "jc",               "jnc",              "je",               "jne",              "jz",               "jnz",

  194. 		"jg",               "jng",              "jge",              "jnge",             "jl",               "jnl",              "jle",              "jnle",

  195. 		"ja",               "jna",              "jae",              "jnae",             "jb",               "jnb",              "jbe",              "jnbe",

  196. 		"js",               "jns",              "jo",               "jno",              "jp",               "jnp",              "jpo",              "jpe",

  197. 		"rep",              "repe",             "repz",             "repne",            "repnz",            "loop",             "loope",            "loopne"

  198. 	};

  199. 

  200. 	char * registers [] = {

  201. 		"rax",              "rcx",              "rdx",              "rbx",              "rsp",              "rbp",              "rsi",              "rdi",

  202. 		"r8",               "r9",               "r10",              "r11",              "r12",              "r13",              "r14",              "r15",

  203. 		"eax",              "ecx",              "edx",              "ebx",              "esp",              "ebp",              "esi",              "edi",

  204. 		"r8d",              "r9d",              "r10d",             "r11d",             "r12d",             "r13d",             "r14d",             "r15d",

  205. 		"ax",               "cx",               "dx",               "bx",               "sp",               "bp",               "si",               "di",

  206. 		"r8w",              "r9w",              "r10w",             "r11w",             "r12w",             "r13w",             "r14w",             "r15w",

  207. 		"al",               "cl",               "dl",               "bl",               "spl",              "bpl",              "sil",              "dil",

  208. 		"r8b",              "r9b",              "r10b",             "r11b",             "r12b",             "r13b",             "r14b",             "r15b",

  209. 		"ah",               "ch",               "dh",               "bh"

  210. 	};

  211. 

  212. 	char * keywords [] = {

  213. 		"format",           "executable",       "readable",         "writable",         "segment",          "sector",           "entry",            "macro",

  214. 		"db",               "dw",               "dd",               "dq",               "rb",               "rw",               "rd",               "rq"

  215. 	};

  216. 

  217. 	int word;

  218. 

  219. 	syntax_define (false, false, ";",  "\n", '\0', colour_grey, effect_bold);

  220. 	syntax_define (false, false, "'",  "'",  '\\', colour_pink, effect_bold);

  221. 	syntax_define (false, false, "\"", "\"", '\\', colour_pink, effect_normal);

  222. 

  223. 	for (word = 0; word != (int) (sizeof (instructions) / sizeof (instructions [0])); ++word) {

  224. 		syntax_define (false, true, instructions [word], separators, '\0', colour_yellow, effect_bold);

  225. 	}

  226. 

  227. 	for (word = 0; word != (int) (sizeof (registers) / sizeof (registers [0])); ++word) {

  228. 		syntax_define (false, true, registers [word], separators, '\0', colour_cyan, effect_bold);

  229. 	}

  230. 

  231. 	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {

  232. 		syntax_define (false, true, keywords [word], separators, '\0', colour_yellow, effect_italic);

  233. 	}

  234. 

  235. 	syntax_define (true, false, "()[]{}",      "", '\0', colour_blue, effect_normal);

  236. 	syntax_define (true, false, ".,+-=:;%$<>", "", '\0', colour_cyan, effect_normal);

  237. 

  238. 	syntax_define (true, true, "0123456789",                 separators, '\0', colour_pink,  effect_bold);

  239. 	syntax_define (true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', colour_white, effect_normal);

  240. 	syntax_define (true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', colour_white, effect_bold);

  241. 	syntax_define (true, true, "_",                          separators, '\0', colour_white, effect_italic);

  242. }

  243. 

  244. static void highlight_fortran (void) {

  245. 	char * separators = ",:<=>+-*/&()[]\"\' \t\r\n";

  246. 

  247. 	char * keywords [] = {

  248. 		"allocatable",      "allocate",         "associate",        "backspace",        "block",            "call",             "case",             "common",

  249. 		"contains",         "cycle",            "data",             "deallocate",       "d0",               "do",               "else",             "elseif",

  250. 		"end",              "enddo",            "endfile",          "endif",            "entry",            "equivalence",      "exit",             "external",

  251. 		"forall",           "format",           "function",         "goto",             "if",               "implicit",         "inquire",          "intent",

  252. 		"intrinsic",        "module",           "namelist",         "none",             "nullify",          "only",             "open",             "optional",

  253. 		"parameter",        "pointer",          "print",            "private",          "program",          "public",           "read",             "recursive",

  254. 		"return",           "rewind",           "save",             "select",           "sequence",         "stop",             "subroutine",       "target",

  255. 		"then",             "to",               "type",             "use",              "where",            "write"

  256. 	};

  257. 

  258. 	char * constants [] = {

  259. 		".and.",            ".or.",             ".not.",            ".true.",           ".false.",          "in",               "out",              "character",

  260. 		"integer",          "logical",          "real",             "complex",          "dimension",        "modulo",           "len",              "advance"

  261. 	};

  262. 

  263. 	int word;

  264. 

  265. 	syntax_define (false, false, "!",  "\n", '\0', colour_grey,   effect_bold);

  266. 	syntax_define (false, false, "'",  "'",  '\\', colour_pink,   effect_bold);

  267. 	syntax_define (false, false, "\"", "\"", '\\', colour_pink,   effect_normal);

  268. 

  269. 	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {

  270. 		syntax_define (false, true, keywords [word], separators, '\0', colour_yellow, effect_bold);

  271. 	}

  272. 

  273. 	for (word = 0; word != (int) (sizeof (constants) / sizeof (constants [0])); ++word) {

  274. 		syntax_define (false, true, constants [word], separators, '\0', colour_yellow, effect_italic);

  275. 	}

  276. 

  277. 	syntax_define (true, false, "()[]",       "", '\0', colour_blue, effect_normal);

  278. 	syntax_define (true, false, ",:<=>+-*/&", "", '\0', colour_cyan, effect_normal);

  279. 

  280. 	syntax_define (true, true, "0123456789",                 separators, '\0', colour_pink,  effect_bold);

  281. 	syntax_define (true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', colour_white, effect_normal);

  282. 	syntax_define (true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', colour_white, effect_bold);

  283. 	syntax_define (true, true, "_",                          separators, '\0', colour_white, effect_italic);

  284. }

  285. 

  286. static void highlight_shell (void) {

  287. 	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}@#$`'\" \t\r\n";

  288. 

  289. 	char * keywords [] = {

  290. 		"if",               "then",             "else",             "elif",             "fi",               "do",               "done",             "case",

  291. 		"esac",             "while",            "until",            "for",              "function",         "declare",          "let",              "local",

  292. 		"alias",            "shopt",            "export",           "in",               "return",           "echo",             "set",              "alias",

  293. 		"exit",             "source",           "shift",            "cd"

  294. 	};

  295. 

  296. 	int word;

  297. 

  298. 	syntax_define (false, false, "#",   "\n", '\0', colour_grey,   effect_bold);

  299. 	syntax_define (false, false, "'",   "'",  '\\', colour_pink,   effect_bold);

  300. 	syntax_define (false, false, "\"",  "\"", '\\', colour_pink,   effect_normal);

  301. 	syntax_define (false, true,  "$#",  " ",  '\0', colour_pink,   effect_italic);

  302. 	syntax_define (false, false, "$((", "))", '\0', colour_blue,   effect_italic);

  303. 	syntax_define (false, false, "${",  "}",  '\0', colour_yellow, effect_italic);

  304. 	syntax_define (false, false, "$(",  ")",  '\0', colour_cyan,   effect_italic);

  305. 

  306. 	syntax_define (false, true, "&&", " ", '\0', colour_yellow, effect_italic);

  307. 	syntax_define (false, true, "||", " ", '\0', colour_yellow, effect_italic);

  308. 	syntax_define (false, true, ";;", " ", '\0', colour_yellow, effect_italic);

  309. 	syntax_define (false, true, "<<", " ", '\0', colour_yellow, effect_italic);

  310. 	syntax_define (false, true, ">>", " ", '\0', colour_yellow, effect_italic);

  311. 	syntax_define (false, true, "<>", " ", '\0', colour_yellow, effect_italic);

  312. 

  313. 	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {

  314. 		syntax_define (false, true, keywords [word], separators, '\0', colour_yellow, effect_bold);

  315. 	}

  316. 

  317. 	syntax_define (true, false, "()[]{}",                 "", '\0', colour_blue, effect_normal);

  318. 	syntax_define (true, false, ".,:;<=>+*-/%!&~^?|@#$`", "", '\0', colour_cyan, effect_normal);

  319. 

  320. 	syntax_define (true, true, "0123456789",                 separators, '\0', colour_pink,  effect_bold);

  321. 	syntax_define (true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', colour_white, effect_normal);

  322. 	syntax_define (true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', colour_white, effect_bold);

  323. 	syntax_define (true, true, "_",                          separators, '\0', colour_white, effect_italic);

  324. }

  325. 

  326. static void highlight_xofya (void) {

  327. 	char * separators = ".,:;<=>+-*/%!&~^?|(){}'\" \t\r\n";

  328. 

  329. 	char * keywords [] = {

  330. 		"character",        "natural",          "integer",          "logical",          "address",          "pointer",          "union",            "enter",

  331. 		"array",            "iterate",          "enumerate",        "include",          "exclude",          "execute",          "if",               "else",

  332. 		"match",            "for",              "break",            "cycle",            "and",              "or",               "not",              "true",

  333. 		"false",            "nil",              "range",            "then",             "terminate",        "procedure",        "program",          "package"

  334. 	};

  335. 

  336. 	int word;

  337. 

  338. 	syntax_define (false, false, "!",   "\n",  '\0', colour_red,  effect_bold);

  339. 	syntax_define (false, false, "---", "\n",  '\0', colour_grey, effect_bold);

  340. 	syntax_define (false, false, "--!", "!--", '\0', colour_grey, effect_bold);

  341. 	syntax_define (false, false, "@",   "\n",  '\0', colour_red,  effect_italic);

  342. 	syntax_define (false, false, "<!>", "\n",  '\0', colour_red,  effect_normal);

  343. 	syntax_define (false, false, "\"",  "\"",  '\\', colour_pink, effect_normal);

  344. 	syntax_define (false, false, "'",   "'",   '\\', colour_pink, effect_bold);

  345. 

  346. 	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {

  347. 		syntax_define (false, true, keywords [word], separators, '\0', colour_yellow, effect_bold);

  348. 	}

  349. 

  350. 	syntax_define (true, false, "(){}",               "", '\0', colour_blue, effect_normal);

  351. 	syntax_define (true, false, ".,:;<=>+*-/%!&~^?|", "", '\0', colour_cyan, effect_normal);

  352. 

  353. 	syntax_define (true, true, "0123456789",                 separators, '\0', colour_pink,  effect_bold);

  354. 	syntax_define (true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', colour_white, effect_normal);

  355. 	syntax_define (true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', colour_white, effect_bold);

  356. 	syntax_define (true, true, "_",                          separators, '\0', colour_white, effect_italic);

  357. }

  358. 

  359. int main (int argc, char * * argv) {

  360. 	int    offset = 0;

  361. 	int    select = 0;

  362. 	int    length = 0;

  363. 	char * buffer = null;

  364. 

  365. 	if (argc != 1) {

  366. 		if (string_compare (argv [1], "-v") || string_compare (argv [1], "--version")) {

  367. 			echo ("xighlight: Terminal syntax highlighter (version 144)\n");

  368. 			exit (log_success);

  369. 		} else if (string_compare (argv [1], "-l") || string_compare (argv [1], "--license")) {

  370. 			echo ("xighlight: Terminal syntax highlighter (GNU/GPLv3)\n");

  371. 			exit (log_success);

  372. 		} else if (string_compare (argv [1], "-a") || string_compare (argv [1], "--author")) {

  373. 			echo ("xighlight: Terminal syntax highlighter (Ognjen 'xolatile' Milan Robovic)\n");

  374. 			exit (log_success);

  375. 		} else if (string_compare (argv [1], "-h") || string_compare (argv [1], "--help")) {

  376. 			echo ("xighlight: Terminal syntax highlighter:\n");

  377. 			echo ("Example usage:\n");

  378. 			echo ("\t$ cat file.ext | xighlight [flag] -- You need to pass language flag in this case.\n");

  379. 			echo ("\t$ xighlight [flag] < file.ext     -- You need to pass language flag in this case.\n");

  380. 			echo ("\t$ xighlight file.ext              -- Language is automatically detected in this case.\n");

  381. 			echo ("Supported languages:\n");

  382. 			echo ("\t -C --c        -- C syntax\n");

  383. 			echo ("\t -A --ada      -- Ada syntax\n");

  384. 			echo ("\t -P --cpp      -- C++ syntax \n");

  385. 			echo ("\t -S --assembly -- General assembly syntax\n");

  386. 			echo ("\t -T --flat     -- Flat assembly syntax\n");

  387. 			echo ("\t -F --fortran  -- Fortran syntax\n");

  388. 			echo ("\t -H --shell    -- Shell syntax\n");

  389. 			echo ("\t -X --xofya    -- Xofya\n");

  390. 			exit (log_success);

  391. 		} else if (string_compare (argv [1], "-C") || string_compare (argv [1], "--c")) {

  392. 			highlight_c ();

  393. 		} else if (string_compare (argv [1], "-A") || string_compare (argv [1], "--ada")) {

  394. 			highlight_ada ();

  395. 		} else if (string_compare (argv [1], "-P") || string_compare (argv [1], "--cpp")) {

  396. 			highlight_cpp ();

  397. 		} else if (string_compare (argv [1], "-S") || string_compare (argv [1], "--assembly")) {

  398. 			highlight_common_assembly ();

  399. 		} else if (string_compare (argv [1], "-T") || string_compare (argv [1], "--flat")) {

  400. 			highlight_flat_assembly ();

  401. 		} else if (string_compare (argv [1], "-F") || string_compare (argv [1], "--fortran")) {

  402. 			highlight_fortran ();

  403. 		} else if (string_compare (argv [1], "-H") || string_compare (argv [1], "--shell")) {

  404. 			highlight_shell ();

  405. 		} else if (string_compare (argv [1], "-X") || string_compare (argv [1], "--xofya")) {

  406. 			highlight_xofya ();

  407. 		} else {

  408. 			select = file_type   (argv [1]);

  409. 			buffer = file_import (argv [1]);

  410. 		}

  411. 	}

  412. 

  413. 	if (buffer == null) {

  414. 		buffer = record ();

  415. 	}

  416. 

  417. 	if (syntax_active == false) {

  418. 		if ((select == file_type_c_source) || (select == file_type_c_header)) {

  419. 			highlight_c ();

  420. 		} else if ((select == file_type_ada_body) || (select == file_type_ada_specification)) {

  421. 			highlight_ada ();

  422. 		} else if ((select == file_type_cpp_source) || (select == file_type_cpp_header)) {

  423. 			highlight_cpp ();

  424. 		} else if (select == file_type_common_assembly) {

  425. 			highlight_common_assembly ();

  426. 		} else if (select == file_type_flat_assembly) {

  427. 			highlight_flat_assembly ();

  428. 		} else if (select == file_type_fortran_90) {

  429. 			highlight_fortran ();

  430. 		/*} else if (select == file_type_xofya) {

  431. 			highlight_xofya ();*/

  432. 		} else {

  433. 			highlight_common ();

  434. 		}

  435. 	}

  436. 

  437. 	for (offset = 0; buffer [offset] != '\0'; offset += length) {

  438. 		select = syntax_select (& buffer [offset], & length);

  439. 

  440. 		if (select >= syntax_count) {

  441. 			terminal_colour (colour_white, effect_normal);

  442. 		} else {

  443. 			terminal_colour (syntax_colour [select], syntax_effect [select]);

  444. 		}

  445. 

  446. 		out (& buffer [offset], length);

  447. 

  448. 		terminal_cancel ();

  449. 	}

  450. 

  451. 	buffer = deallocate (buffer);

  452. 

  453. 	return (log_success);

  454. }