279 lines
9 KiB
C
279 lines
9 KiB
C
/*
|
|
* ML/Ocaml language mode for QEmacs.
|
|
*
|
|
* Copyright (c) 2000-2020 Charlie Gordon.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "qe.h"
|
|
|
|
/*---------------- ML/Ocaml coloring ----------------*/
|
|
|
|
static char const ocaml_keywords[] = {
|
|
"|_|and|as|asr|assert|begin|class|constraint|do|done|downto"
|
|
"|else|end|exception|external|false|for|fun|function|functor"
|
|
"|if|ignore|in|include|incr|inherit|initializer"
|
|
"|land|lazy|let|lnot|loop|lor|lsl|lsr|lxor"
|
|
"|match|method|mod|module|mutable|new|not|object|of|open|or"
|
|
"|parser|prec|private|raise|rec|ref|self|sig|struct"
|
|
"|then|to|true|try|type|val|value|virtual|when|while|with"
|
|
"|"
|
|
};
|
|
|
|
static char const ocaml_types[] = {
|
|
"|array|bool|char|exn|float|format|format4||int|int32|int64"
|
|
"|lazy_t|list|nativeint|option|string|unit"
|
|
"|"
|
|
};
|
|
|
|
enum {
|
|
IN_OCAML_COMMENT = 0x01,
|
|
IN_OCAML_COMMENT_MASK = 0x0F,
|
|
IN_OCAML_STRING = 0x10,
|
|
};
|
|
|
|
enum {
|
|
OCAML_STYLE_TEXT = QE_STYLE_DEFAULT,
|
|
OCAML_STYLE_PREPROCESS = QE_STYLE_PREPROCESS,
|
|
OCAML_STYLE_COMMENT = QE_STYLE_COMMENT,
|
|
OCAML_STYLE_STRING = QE_STYLE_STRING,
|
|
OCAML_STYLE_STRING1 = QE_STYLE_STRING,
|
|
OCAML_STYLE_NUMBER = QE_STYLE_NUMBER,
|
|
OCAML_STYLE_KEYWORD = QE_STYLE_KEYWORD,
|
|
OCAML_STYLE_TYPE = QE_STYLE_TYPE,
|
|
OCAML_STYLE_IDENTIFIER = QE_STYLE_DEFAULT,
|
|
OCAML_STYLE_FUNCTION = QE_STYLE_FUNCTION,
|
|
};
|
|
|
|
static void ocaml_colorize_line(QEColorizeContext *cp,
|
|
unsigned int *str, int n, ModeDef *syn)
|
|
{
|
|
char keyword[16];
|
|
int i = 0, start = i, c, k, style, len;
|
|
int colstate = cp->colorize_state;
|
|
|
|
if (colstate & IN_OCAML_COMMENT_MASK)
|
|
goto parse_comment;
|
|
|
|
if (colstate & IN_OCAML_STRING)
|
|
goto parse_string;
|
|
|
|
if (str[i] == '#') {
|
|
/* Handle shbang script heading ^#!.+
|
|
* and preprocessor # line directives
|
|
*/
|
|
i = n;
|
|
SET_COLOR(str, start, i, OCAML_STYLE_PREPROCESS);
|
|
}
|
|
|
|
while (i < n) {
|
|
start = i;
|
|
style = OCAML_STYLE_TEXT;
|
|
c = str[i++];
|
|
switch (c) {
|
|
case '(':
|
|
/* check for comment */
|
|
if (str[i] != '*')
|
|
break;
|
|
|
|
/* regular comment (recursive?) */
|
|
colstate = IN_OCAML_COMMENT;
|
|
i++;
|
|
parse_comment:
|
|
style = OCAML_STYLE_COMMENT;
|
|
for (; i < n; i++) {
|
|
/* OCaml comments do nest */
|
|
if (str[i] == '(' && str[i + 1] == '*') {
|
|
i += 2;
|
|
colstate++;
|
|
} else
|
|
if (str[i] == '*' && str[i + 1] == ')') {
|
|
i += 2;
|
|
if (--colstate == 0)
|
|
break;
|
|
}
|
|
}
|
|
SET_COLOR(str, start, i, style);
|
|
continue;
|
|
case '\"':
|
|
colstate = IN_OCAML_STRING;
|
|
parse_string:
|
|
/* parse string */
|
|
style = OCAML_STYLE_STRING;
|
|
while (i < n) {
|
|
c = str[i++];
|
|
if (c == '\\' && i < n)
|
|
i++;
|
|
else
|
|
if (c == '\"') {
|
|
colstate = 0;
|
|
break;
|
|
}
|
|
}
|
|
SET_COLOR(str, start, i, style);
|
|
continue;
|
|
case '\'':
|
|
/* parse type atom or char const */
|
|
if ((i + 1 < n && str[i] != '\\' && str[i + 1] == '\'')
|
|
|| (i + 2 < n && str[i] == '\\' && str[i + 2] == '\'')
|
|
|| (str[i] == '\\' && str[i + 1] == 'x' &&
|
|
qe_isxdigit(str[i + 2]) && qe_isxdigit(str[i + 3]) &&
|
|
str[i + 4] == '\'')
|
|
|| (str[i] == '\\' && qe_isdigit(str[i + 1]) &&
|
|
qe_isdigit(str[i + 2]) && qe_isdigit(str[i + 3]) &&
|
|
str[i + 4] == '\'')) {
|
|
style = OCAML_STYLE_STRING1;
|
|
while (str[i++] != '\'')
|
|
continue;
|
|
} else
|
|
if (qe_isalpha_(str[i])) {
|
|
while (i < n && (qe_isalnum_(str[i]) || str[i] == '\''))
|
|
i++;
|
|
style = OCAML_STYLE_TYPE;
|
|
}
|
|
SET_COLOR(str, start, i, style);
|
|
continue;
|
|
default:
|
|
break;
|
|
}
|
|
/* parse numbers */
|
|
if (qe_isdigit(c)) {
|
|
style = OCAML_STYLE_NUMBER;
|
|
if (c == '0' && qe_tolower(str[i]) == 'o'
|
|
&& qe_isoctdigit(str[i + 1])) {
|
|
/* octal int: 0[oO][0-7][0-7_]*[lLn]? */
|
|
for (i += 1; qe_isoctdigit_(str[i]); i++)
|
|
continue;
|
|
if (qe_findchar("lLn", str[i]))
|
|
i++;
|
|
} else
|
|
if (c == '0' && qe_tolower(str[i]) == 'x'
|
|
&& qe_isxdigit(str[i + 1])) {
|
|
/* hex int: 0[xX][0-9a-fA-F][0-9a-zA-Z_]*[lLn]? */
|
|
for (i += 1; qe_isxdigit(str[i]); i++)
|
|
continue;
|
|
if (qe_findchar("lLn", str[i]))
|
|
i++;
|
|
} else
|
|
if (c == '0' && qe_tolower(str[i]) == 'b'
|
|
&& qe_isbindigit(str[i + 1])) {
|
|
/* binary int: 0[bB][01][01_]*[lLn]? */
|
|
for (i += 1; qe_isbindigit_(str[i]); i++)
|
|
continue;
|
|
if (qe_findchar("lLn", str[i]))
|
|
i++;
|
|
} else {
|
|
/* decimal integer: [0-9][0-9_]*[lLn]? */
|
|
for (; qe_isdigit_(str[i]); i++)
|
|
continue;
|
|
if (qe_findchar("lLn", str[i])) {
|
|
i++;
|
|
} else {
|
|
/* float:
|
|
* [0-9][0-9_]*(.[0-9_]*])?([eE][-+]?[0-9][0-9_]*)? */
|
|
if (str[i] == '.') {
|
|
for (i += 1; qe_isdigit_(str[i]); i++)
|
|
continue;
|
|
}
|
|
if (qe_tolower(str[i]) == 'e') {
|
|
int k = i + 1;
|
|
if (str[k] == '+' || str[k] == '-')
|
|
k++;
|
|
if (qe_isdigit(str[k])) {
|
|
for (i = k + 1; qe_isdigit_(str[i]); i++)
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SET_COLOR(str, start, i, style);
|
|
continue;
|
|
}
|
|
/* parse identifiers and keywords */
|
|
if (qe_isalpha_(c)) {
|
|
len = 0;
|
|
keyword[len++] = c;
|
|
for (; qe_isalnum_(str[i]) || str[i] == '\''; i++) {
|
|
if (len < countof(keyword) - 1)
|
|
keyword[len++] = str[i];
|
|
}
|
|
keyword[len] = '\0';
|
|
if (strfind(syn->types, keyword)) {
|
|
style = OCAML_STYLE_TYPE;
|
|
} else
|
|
if (strfind(syn->keywords, keyword)) {
|
|
style = OCAML_STYLE_KEYWORD;
|
|
} else {
|
|
style = OCAML_STYLE_IDENTIFIER;
|
|
k = i;
|
|
if (qe_isblank(str[k]))
|
|
k++;
|
|
if (str[k] == '(' && str[k + 1] != '*')
|
|
style = OCAML_STYLE_FUNCTION;
|
|
}
|
|
SET_COLOR(str, start, i, style);
|
|
continue;
|
|
}
|
|
}
|
|
cp->colorize_state = colstate;
|
|
}
|
|
|
|
static ModeDef ocaml_mode = {
|
|
.name = "Ocaml",
|
|
.extensions = "ml|mli|mll|mly",
|
|
.shell_handlers = "ocaml",
|
|
.keywords = ocaml_keywords,
|
|
.types = ocaml_types,
|
|
.colorize_func = ocaml_colorize_line,
|
|
};
|
|
|
|
/*---------------- Eff language coloring ----------------*/
|
|
|
|
static char const eff_keywords[] = {
|
|
// eff-keywords
|
|
"and|as|begin|check|do|done|downto|else|end|effect|external|finally|for|"
|
|
"fun|function|handle|handler|if|in|match|let|new|of|operation|rec|val|"
|
|
"while|to|type|then|with|"
|
|
// eff-constants
|
|
"asr|false|mod|land|lor|lsl|lsr|lxor|or|true|"
|
|
// other
|
|
"ref|try|raise|"
|
|
// directives
|
|
"help|reset|quit|use|"
|
|
};
|
|
|
|
static char const eff_types[] = {
|
|
"empty|bool|float|double|int|exception|string|map|range|unit|"
|
|
};
|
|
|
|
static ModeDef eff_mode = {
|
|
.name = "Eff",
|
|
.extensions = "eff",
|
|
.shell_handlers = "eff",
|
|
.keywords = eff_keywords,
|
|
.types = eff_types,
|
|
.colorize_func = ocaml_colorize_line,
|
|
};
|
|
|
|
static int ocaml_init(void)
|
|
{
|
|
qe_register_mode(&ocaml_mode, MODEF_SYNTAX);
|
|
qe_register_mode(&eff_mode, MODEF_SYNTAX);
|
|
|
|
return 0;
|
|
}
|
|
|
|
qe_module_init(ocaml_init);
|