mp_syntax.mpsl

   1 /*
   2
   3     Minimum Profit 5.x
   4     A Programmer's Text Editor
   5
   6     Syntax highlight definitions.
   7
   8     Copyright (C) 1991-2009 Angel Ortega <angel@triptico.com>
   9
  10     This program is free software; you can redistribute it and/or
  11     modify it under the terms of the GNU General Public License
  12     as published by the Free Software Foundation; either version 2
  13     of the License, or (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program; if not, write to the Free Software
  22     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23
  24     http://www.triptico.com
  25
  26 */
  27
  28 /** editor actions **/
  29
  30 mp.actions['help']      =       sub (d) {
  31         local w, h, r;
  32
  33         /* get the special word regex separator for help (if any) */
  34         r = d.syntax.help_word_regex;
  35
  36         /* if there is a word at the cursor position,
  37            try searching for help */
  38         if ((w = mp.get_word(d, r)) != NULL)
  39                 h = mp.help(d, w);
  40
  41         if (h == NULL)
  42                 mp.alert(sprintf(L("No help for '%s'."), w));
  43         else {
  44                 local d;
  45
  46                 d = mp.new(sprintf(L("<help on '%s'>"), w), h);
  47                 d.read_only = 1;
  48         }
  49 };
  50
  51 mp.actions['section_list'] = sub (d) {
  52         local l = mp.section_list(d);
  53
  54         if (l == NULL)
  55                 mp.alert(L("No detection for sections for this mode."));
  56         else {
  57                 if (size(l) == 0)
  58                         mp.alert(L("No sections were found in this document."));
  59                 else {
  60                         local r = mp.form( [
  61                         {
  62                                 'label' => L("Section list"),
  63                                 'type'  => 'list',
  64                                 'list'  => map(sub (e) { e[0]; }, l),
  65                                 'value' => 0
  66                         }
  67                         ]);
  68
  69                         if (r != NULL) {
  70                                 mp.set_y(d, l[r[0]][1]);
  71                                 mp.set_x(d, 0);
  72                         }
  73                 }
  74         }
  75 };
  76
  77 /** default key bindings **/
  78
  79 mp.keycodes['f1']       =       "help";
  80 mp.keycodes['ctrl-d']   =       "section_list";
  81
  82 /** action descriptions **/
  83
  84 mp.actdesc['help']              = LL("Help on word over cursor");
  85 mp.actdesc['section_list']      = LL("Section list...");
  86
  87 /* data */
  88
  89 mp.syntax = {};
  90
  91 /** syntax definitions **/
  92
  93 sub mp.syn_token_list(l) { '/\b(' ~ join("|", l) ~ ')\b/'; }
  94
  95 mp.syntax.c = {
  96         'id'            =>      'c',
  97         'name'          =>      'C / C++',
  98         'filenames'     =>      [ '/\.c$/', '/\.h$/', '/\.l$/', '/\.y$/', '/\.d$/',
  99                                 '/\.cpp$/', '/\.hpp$/', '/\.c++$/', '/\.xpm$/' ],
 100         'help'          =>      [ "man 2 %s", "man 3 %s" ],
 101         'defs'          =>      [
 102                 'word1',        [
 103                                 mp.syn_token_list( [
 104                                 "for", "while", "if", "switch", "case", "do",
 105                                 "else", "break", "continue", "return",
 106                                 "default", "goto", "main", "fopen", "fclose",
 107                                 "fgets", "fgetc", "fputs", "fputc", "fprintf",
 108                                 "putc", "printf", "sprintf", "strcpy", "strcat",
 109                                 "strcmp", "strncmp", "strtok", "stricmp", "strchr",
 110                                 "strrchr", "strlen", "memcmp", "memcpy", "malloc",
 111                                 "free", "strncpy", "strncat", "snprintf", "strstr",
 112                                 "memset", "memcpy", "va_start", "va_end", "vsprintf",
 113                                 "vsnprintf", "atoi", "qsort", "bsearch", "getenv",
 114                                 "fscanf", "popen", "pclose", "realloc", "fread",
 115                                 "fwrite", "fseek", '\{', '\}', "putchar", "fflush",
 116                                 "wcscmp", "swprintf", "wmemcpy", "swscanf", "sscanf",
 117                                 "wcslen", "wmemset", "wcscpy", "wcsncpy", "wcscoll",
 118                                 "mbstowcs", "wcstombs", "wprintf", "wcschr",
 119                                 "wcsrchr", "wcsstr", "strdup", "wctomb", "mbtowc",
 120                                 "mbrtowc", "wcrtomb", "open", "close", "read",
 121                                 "write", "pipe", "fork", "dup", "dup2", "wait",
 122                                 "execl", "execlp", "execle", "execv", "execvp"
 123                                 ])
 124                 ],
 125                 'word2',        [
 126                                 mp.syn_token_list( [
 127                                 "char", "int", "long", "struct", "union", "const",
 128                                 "void", "unsigned", "signed", "auto", "volatile",
 129                                 "enum", "typedef", "float", "double", "extern",
 130                                 "register", "short", "sizeof", "static", "far",
 131                                 "near", "defined", "va_list", "size_t", "wchar_t",
 132                                 "iconv_t" ]),
 133                                 '/[-=<>:\?\+\*\/\!\%&\|]+/'
 134                 ],
 135                 'quotes',       [
 136                         /* from http://ad.hominem.org/log/2005/05/quoted_strings.php */
 137                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 138                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",         /* single-quoted strings */
 139                         "/\b-?[0-9]+\b/",                       /* numbers */
 140                         "/\b0x[0-9a-f]+\b/i",                   /* hex numbers */
 141                         "/\b[0-9[:upper:]_]+\b/"                /* all-caps words */
 142                 ],
 143                 'comments',     [
 144                         [ '|/\*|', '|\*/|' ],                   /* C-like */
 145                         '|//.*$|m',                             /* C++ */
 146                         '/^\s*#[a-z]+/m'                        /* CPP directives */
 147                 ],
 148                 'documentation',        [
 149                         [ "|/\*\*\n|", '|\*/|' ],               /* mp_doccer */
 150                         '/^/\*\*.*\*\*/$/m'                     /* section mark */
 151                 ]
 152         ],
 153         'section'       =>      [ '/(^\/\*\*.*\*\*\/$|^#pragma mark|^\w.*\)$)/' ]
 154 };
 155
 156 mp.syntax.rc = {
 157         'id'            =>      'rc',
 158         'name'          =>      'Resource file',
 159         'filenames'     =>      [ '/\.rc$/' ],
 160         'defs'          =>      [
 161                 'word1',        [ ],
 162                 'word2',        [ ],
 163                 'quotes',       [
 164                         /* from http://ad.hominem.org/log/2005/05/quoted_strings.php */
 165                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 166                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",         /* single-quoted strings */
 167                         "/\b-?[0-9]+\b/",                       /* numbers */
 168                         "/\b0x[0-9a-f]+\b/i",                   /* hex numbers */
 169                         "/\b[0-9[:upper:]_]+\b/"                /* all-caps words */
 170                 ],
 171                 'comments',     [
 172                         [ '|/\*|', '|\*/|' ],                   /* C-like */
 173                         '|//.*$|m',                             /* C++ */
 174                         '/^\s*#[a-z]+/m'                        /* CPP directives */
 175                 ]
 176         ]
 177 };
 178
 179 mp.syntax.perl = {
 180         'id'            =>      'perl',
 181         'name'          =>      'Perl',
 182         'filenames'     =>      [ '/\.pl$/i', '/\.pm$/' ],
 183         'help'          =>      [ 'perldoc -f %s', 'perldoc %s' ],
 184         'help_word_regex' =>    '/[A-Z_][A-Z0-9_:]*/i',
 185         'defs'  =>      [
 186                 'word1',        [
 187                                 mp.syn_token_list( [
 188                                 "for", "if", "next", "last", "else", "elsif",
 189                                 "unless", "while", "shift", "unshift", "push",
 190                                 "pop", "delete", "new", "bless", "return",
 191                                 "foreach", "keys", "values", "sort", "grep",
 192                                 "tr", "length", "system", "exec", "fork", "map",
 193                                 "print", "write", "open", "close", "chop",
 194                                 "chomp", "exit", "sleep", "split", "join",
 195                                 "sub", "printf", "sprintf", "s", "glob",
 196                                 "scalar", "my", "local", "undef", "defined",
 197                                 "use", "package", "require", "ref", "can", "isa",
 198                                 "qw", "qq", "eq", "ne", "or", "exists",
 199                                 "and", "not", "import", "our", "caller" ]),
 200                                 '/->/'
 201                 ],
 202                 'word2',        [
 203                                 '/[:\?\+\*\/\!\$@\%&\|~\.]+/',
 204                                 '/[\$@%]\w+/'
 205                 ],
 206                 'quotes',       [
 207                         /* from http://ad.hominem.org/log/2005/05/quoted_strings.php */
 208                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 209                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",         /* single-quoted strings */
 210                         "/\b-?[0-9]+\b/",                       /* numbers */
 211                         "/\b0x[0-9a-f]+\b/i",                   /* hex numbers */
 212                         "/\b[0-9[:upper:]_]+\b/",               /* all-caps words */
 213                         [ "/q\(/", "/\)/" ],                    /* quote */
 214                         [ "/qw\(/", "/\)/" ],                   /* quote word */
 215                         '/\w+\s*=>/',                           /* barewords as hash keys 1 */
 216                         '/\{\s*-?\w+\s*\}/',                    /* barewords as hash keys 2 */
 217                         [ "/`/", "/`/" ],                       /* backticks */
 218                         [ "/<<[\"']?EOF.*$/m", "/^EOF$/m" ]     /* 'document here' */
 219                 ],
 220                 /* color all => as word2 */
 221                 'word2',        [ '/=>/' ],
 222                 /* color curly brackets as word */
 223                 'word',         [ '/[{}]/' ],
 224                 'comments',     [
 225                         "/#.*$/m"                               /* Comments */
 226                 ],
 227                 'documentation',        [
 228                         "/__END__\n.*$/",                       /* __END__ */
 229                         '/^## .*$/m',                           /* section mark */
 230                         [ "/^=(head[1-4]|over|item|back|pod|begin|end|for)/m",
 231                                 "/^=cut$/m" ]                   /* POD */
 232                 ]
 233         ],
 234         'detect'        =>      sub (d) {
 235                 /* take the first line */
 236                 local f = d.txt.lines[0];
 237
 238                 /* is it a 'she-bang' for Perl? */
 239                 return regex('/^#!\s*/usr/bin/(env )?perl/', f);
 240         },
 241         'section'       =>      [ '/(^sub \w+|^package|^## )/' ]
 242 };
 243
 244
 245 mp.syntax.mpsl = {
 246         'id'            =>      'mpsl',
 247         'name'          =>      'MPSL',
 248         'filenames'     =>      [ '/\.mpsl$/' ],
 249         'defs'          =>      [
 250                 'word1',        [
 251                                 mp.syn_token_list( [
 252                                         'if', 'else', 'while', 'foreach',
 253                                         'sub', 'break', 'return', 'eq', 'ne' ]),
 254                                 mp.syn_token_list( keys(MPSL.CORE) ),
 255                                 '/[\{\}]/'
 256                 ],
 257                 'word2',        [
 258                                 "/(NULL|local)/",
 259                                 '/[-=<>:\?\+\*\/\!\%&\|]+/'
 260                 ],
 261                 'quotes',       [
 262                         /* from http://ad.hominem.org/log/2005/05/quoted_strings.php */
 263                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 264                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",         /* single-quoted strings */
 265                         "/\b-?[0-9]+\b/",                       /* numbers */
 266                         "/\b0x[0-9a-f]+\b/i",                   /* hex numbers */
 267                         "/\b[0-9[:upper:]_]+\b/"                /* all-caps words */
 268                 ],
 269                 'comments',     [
 270                         [ '|/\*|', '|\*/|' ]                    /* C-like */
 271                 ],
 272                 'documentation',        [
 273                         [ "|/\*\*\n|", '|\*/|' ],               /* mp_doccer */
 274                         '/^/\*\*.*\*\*/$/m'                     /* section mark */
 275                 ]
 276         ],
 277         'section'       =>      [ '/(^sub \w+|^\/\*\*.*\*\*\/$)/' ]
 278 };
 279
 280 mp.syntax.sh = {
 281         'id'            =>      'sh',
 282         'name'          =>      'Shell script',
 283         'filenames'     =>      [ '/\.sh$/', '/makefile/i' ],
 284         'defs'          =>      [
 285                 'word1',        [
 286                                 mp.syn_token_list( [
 287                                 "if", "then", "else", "elif",
 288                                 "fi", "case", "do", "done", "esac",
 289                                 "for", "until", "while", "break",
 290                                 "in", "source", "alias", "cd",
 291                                 "continue", "echo", "eval", "exec",
 292                                 "exit", "export", "kill", "logout",
 293                                 "printf", "pwd", "read", "return",
 294                                 "shift", "test", "trap", "ulimit",
 295                                 "umask", "unset", "wait", "cp", "rm" ]),
 296                                 '/[\{\}]/'
 297
 298                 ],
 299                 'word2',        [
 300                                 '/\b(local|let|set)\b/',
 301                                 '/[-=<>:\?\+\*\!\%&\|]+/',
 302                                 '/\$\w+/',
 303                                 '/\$\{\w+\}/',
 304                                 "/\b[0-9[:upper:]_]+\b/"        /* all-caps words */
 305                 ],
 306                 'quotes',       [
 307                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 308                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",         /* single-quoted strings */
 309                         "/\b-?[0-9]+\b/",                       /* numbers */
 310                         "/\b0x[0-9a-f]+\b/i",                   /* hex numbers */
 311                         "/\([A-Za-z0-9_]+\)/",                  /* parens */
 312                         [ "/`/", "/`/" ],                       /* backticks */
 313                         [ "/<<[\"']?EOF[\"']?;$/m", "/^EOF$/m" ]        /* 'document here' */
 314                 ],
 315                 'comments',     [ "/#.*$/m" ]
 316         ],
 317         'detect'        =>      sub (d) {
 318                 /* take the first line */
 319                 local f = d.txt.lines[0];
 320
 321                 /* is it a 'she-bang' for usual shells? */
 322                 return regex('/^#!\s*/bin/(sh|bash|csh|dash|ksh)/', f) ||
 323                        regex('/^#!\s*/usr/bin/make -f/', f);
 324         },
 325         'section'       =>      [ '/(^\w+\(\))/', '/^[A-Za-z0-9_\.-]+:/' ]
 326 };
 327
 328
 329 mp.syntax.html = {
 330         'id'            =>      'html',
 331         'name'          =>      'HTML',
 332         'filenames'     =>      [ '/\.html$/', '/\.htm$/' ],
 333         'defs'          =>      [
 334                 'word1',        [
 335                                 "/<[\/]?[ \t]*(" ~
 336                                 join("|", [
 337                                 "a", "abbr", "acronym", "address",
 338                                 "area", "b", "base", "bdo", "big",
 339                                 "blockquote", "body", "br", "button",
 340                                 "caption", "center", "cite", "code", "col",
 341                                 "colgroup", "dd", "del", "dfn", "div",
 342                                 "dl", "dt", "em", "fieldset", "form",
 343                                 "h1", "h2", "h3", "h4", "h5", "h6",
 344                                 "head", "hr", "html", "i", "img",
 345                                 "input", "ins", "kbd", "label", "legend",
 346                                 "li", "link", "map", "meta", "noscript",
 347                                 "object", "ol", "optgroup", "option",
 348                                 "p", "param", "pre", "q", "samp",
 349                                 "script", "select", "small", "span",
 350                                 "strong", "style", "sub", "sup", "table",
 351                                 "tbody", "td", "textarea", "tfoot", "th",
 352                                 "thead", "title", "tr", "tt", "ul",
 353                                 "var" ] ) ~
 354                                 ")[^<>]*>/i"
 355                 ],
 356                 'word2',        [
 357                                 mp.syn_token_list( [
 358                                  "!DOCTYPE", "class", "type",
 359                                 "cellspacing", "cellpadding",
 360                                 "href", "align", "valign", "name", "lang",
 361                                 "value", "action", "width", "height",
 362                                 "content", "http-equiv", "src", "alt",
 363                                 "bgcolor", "text", "link", "vlink", "alink",
 364                                 "media" ])
 365                 ],
 366                 'quotes',       [
 367                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 368                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/"          /* single-quoted strings */
 369                 ],
 370                 'comments',     [
 371                                 [ '/<!--/', '/-->/' ]
 372                 ]
 373         ],
 374         'section'       =>      [ '/<\s*h[0-9]\s*>/' ]
 375 };
 376
 377
 378 mp.syntax.conf = {
 379         'id'            =>      'conf',
 380         'name'          =>      'Config file',
 381         'filenames'     =>      [ '/\.conf$/', '/\.cfg$/', '/^.*\/?\.[0-9a-z_-]+rc$/' ],
 382         'defs'          =>      [
 383                 'word1',        [ '/^\[.+\]$/m' ],
 384                 'word2',        [ "/^[^:=\n]+[:=]/m" ],
 385                 'quotes',       [
 386                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 387                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",         /* single-quoted strings */
 388                         "/\b-?[0-9]+\b/",                       /* numbers */
 389                         "/\b0x[0-9a-f]+\b/i"                    /* hex numbers */
 390                 ],
 391                 'comments',     [ "/#.*$/m" ]
 392         ]
 393 };
 394
 395
 396 mp.syntax.php = {
 397         'id'            =>      'php',
 398         'name'          =>      'PHP',
 399         'filenames'     =>      [ '/\.php[345]?$/', '/\.inc$/' ],
 400         'defs'          =>      [
 401                 'word1',        [
 402                                 mp.syn_token_list( [
 403                                 "and", "array", "as",
 404                                 "bool", "boolean", "break", "case", "class",
 405                                 "const", "continue", "declare", "default",
 406                                 "die", "do", "double", "echo", "else", "elseif",
 407                                 "empty", "enddeclare", "endfor", "endforeach",
 408                                 "endif", "endswitch", "endwhile", "eval",
 409                                 "exit", "extends", "__FILE__", "float", "for",
 410                                 "foreach", "function", "cfunction", "global",
 411                                 "if", "include", "include_once", "int",
 412                                 "integer", "isset", "__LINE__", "list", "new",
 413                                 "object", "old_function", "or", "print", "real",
 414                                 "require", "require_once", "return",
 415                                 "static", "string", "switch", "unset", "use",
 416                                 "var", "while", "xor", 'true', 'false' ]
 417                                 )
 418                 ],
 419                 'word2',        [ '/\$\w+/', '/[-=<>:\?\+\*\!\%&\|]+/' ],
 420                 'quotes',       [
 421                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 422                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",         /* single-quoted strings */
 423                         "/\b-?[0-9]+\b/",                       /* numbers */
 424                         "/\b0x[0-9a-f]+\b/i",                   /* hex numbers */
 425                         "/\b[0-9[:upper:]_]+\b/",               /* all-caps words */
 426                         [ "/`/", "/`/" ]                        /* backticks */
 427                 ],
 428                 'comments',     [
 429                         [ '|/\*|', '|\*/|' ],                   /* C-like */
 430                         '|//.*$|m'                              /* C++ */
 431                 ]
 432         ]
 433 };
 434
 435 mp.syntax.python = {
 436         'id'            =>      'python',
 437         'name'          =>      'Python',
 438         'filenames'     =>      [ '/\.py$/' ],
 439         'defs'          =>      [
 440                 'word1',        [
 441                         mp.syn_token_list( [
 442                                 "and", "assert", "break", "class", "continue",
 443                                 "def", "del", "elif", "else", "except", "exec",
 444                                 "finally", "for", "from", "if", "import", "in",
 445                                 "is", "lambda", "not", "or", "pass", "print",
 446                                 "raise", "return", "try", "while", "yield"
 447                                 ]
 448                         )
 449                 ],
 450                 'word2',        [ '/global/', '/\$\w+/', '/[-=<>:\?\+\*\!\%&\|{}]+/' ],
 451                 'quotes',       [
 452                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 453                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",         /* single-quoted strings */
 454                         "/\b-?[0-9]+\b/",                       /* numbers */
 455                         "/\b0x[0-9a-f]+\b/i",                   /* hex numbers */
 456                         "/\b[0-9[:upper:]_]+\b/",               /* all-caps words */
 457                         [ "/`/", "/`/" ]                        /* backticks */
 458                 ],
 459                 'comments',             [ "/#.*$/m" ],
 460                 'documentation',        [ [ '/""".+[^"]$/m', '/"""$/m' ] ]
 461         ],
 462         'detect'        =>      sub (d) {
 463                 /* take the first line */
 464                 local f = d.txt.lines[0];
 465
 466                 /* is it a 'she-bang'? */
 467                 return regex('/^#!\s*/usr/bin/(env )?python/', f);
 468         },
 469         'section'       =>      [ '/^[ \t]*def/' ]
 470 };
 471
 472 mp.syntax.ruby = {
 473         'id'            =>      'ruby',
 474         'name'          =>      'Ruby',
 475         'filenames'     =>      [ '/\.rb$/' ],
 476         'defs'          =>      [
 477                 'word1',        [
 478                         mp.syn_token_list( [
 479                                 "BEGIN", "END", "alias", "and", "begin",
 480                                 "break", "case", "class", "def", "defined",
 481                                 "do", "else", "elsif", "end", "ensure",
 482                                 "false", "for", "if", "in", "module", "next",
 483                                 "nil", "not", "or", "redo", "rescue", "retry",
 484                                 "return", "self", "super", "then", "true",
 485                                 "undef", "unless", "until", "when", "while",
 486                                 "yield", "require", "include" ]
 487                         )
 488                 ],
 489                 'word2',        [ '/[-=<>:\?\+\*\!\%&\|{}]+/', '/=(begin|end)/' ],
 490                 'quotes',       [
 491                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 492                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",         /* single-quoted strings */
 493                         "/\b-?[0-9]+\b/",                       /* numbers */
 494                         "/\b0x[0-9a-f]+\b/i",                   /* hex numbers */
 495                         "/\b[0-9[:upper:]_]+\b/",               /* all-caps words */
 496                         [ "/`/", "/`/" ]                        /* backticks */
 497                 ],
 498                 'comments',     [ "/#.*$/m" ]
 499         ],
 500         'detect'        =>      sub (d) {
 501                 /* take the first line */
 502                 local f = d.txt.lines[0];
 503
 504                 /* is it a 'she-bang'? */
 505                 return regex('/^#!\s*/usr/bin/(env )?ruby/', f);
 506         }
 507 };
 508
 509 mp.syntax.diff = {
 510         'id'            =>      'diff',
 511         'name'          =>      'diff',
 512         'filenames'     =>      [ '/\.diff$/', '/\.patch$/' ],
 513         'defs'          =>      [
 514                 'word1',        [ '/^\+.+$/m' ],
 515                 'word2',        [ '/^\-.+$/m' ],
 516                 'quotes',       [ '/^@@.+@@$/m' ]
 517         ],
 518         'section'       =>      [ '/^--- ' ]
 519 };
 520
 521 mp.syntax.commit_msg = {
 522         'id'            =>      'commit_msg',
 523         'name'          =>      'VCS commit message',
 524         'filenames'     =>      [ '/sv[kn]-commit.*\./' ],
 525         'defs'          =>      [
 526                 'word1',        [ '/^AM? .+$/m' ],
 527                 'word2',        [ '/^D .+$/m' ],
 528                 'quotes',       [ '/^M .+$/m' ],
 529                 'comments',     [ '/^=== .+$/m', '/^--.+$/m' ]
 530         ]
 531 };
 532
 533 mp.syntax.po = {
 534         'id'            =>      'po',
 535         'name'          =>      'Gettext file',
 536         'filenames'     =>      [ '/\.po$/' ],
 537         'defs'          =>      [
 538                 'word1',        [ '/^msgid/m' ],
 539                 'word2',        [ '/^msgstr/m' ],
 540                 'comments',     [ "/#.*$/m" ],
 541                 'quotes',       [
 542                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/"      /* double-quoted strings */
 543                 ]
 544         ]
 545 };
 546
 547 mp.syntax.xml = {
 548         'id'            =>      'xml',
 549         'name'          =>      'XML / XGML',
 550         'filenames'     =>      [ '/\.xml$/', '/\.sgml$/' ],
 551         'defs'          =>      [
 552                 'word1',        [ '/<[^>]+>/' ],
 553                 'word2',        [ '/<\?[^\?]+\?>/' ],
 554                 'quotes',       [
 555                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",     /* double-quoted strings */
 556                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/"          /* single-quoted strings */
 557                 ],
 558                 'comments',     [
 559                                 [ '/<!--/', '/-->/' ]
 560                 ]
 561         ],
 562         'detect'        =>      sub (d) {
 563                 /* take the first line */
 564                 local f = d.txt.lines[0];
 565
 566                 return regex('/<\?xml/', f);
 567         }
 568 };
 569
 570 mp.syntax.make_output = {
 571         'id'            =>      'make_output',
 572         'name'          =>      'Make output',
 573         'defs'          =>      [
 574                 'word1',        [ "/^.*warning:.*$/m" ],
 575                 'word2',        [ "/^.*error:.*$/m" ]
 576         ]
 577 };
 578
 579 mp.syntax.euphoria = {
 580         'id'            =>      'euphoria',
 581         'name'          =>      'euphoria',
 582         'filenames'     =>      [ '/\.e$/', '/\.eu$/', '/\.ew$/', '/\.ed$/',
 583                                 '/\.ex$/', '/\.exw$/', '/\.exu$/' ],
 584         'defs'          =>      [
 585                 'word1',        [
 586                         mp.syn_token_list( [
 587                                 "as", "and", "break", "by", "case", "constant", "continue", "do", "end",
 588                                 "else", "elsif", "elsifdef",
 589                                 "exit", "entry", "enum", "export", "for", "function", "global", "include",
 590                                 "if", "ifdef", "label",
 591                                 "not", "or", "procedure", "return", "retry", "switch", "then", "type",
 592                                 "to", "while", "with", "without", "xor"
 593                         ] )
 594                 ],
 595                 'word2',        [
 596                         mp.syn_token_list( [
 597                                 "atom", "integer", "sequence", "object"
 598                         ] )
 599                 ],
 600                 'quotes',       [
 601                         "/\"([^\"\\\\\n]*(\\\\.[^\"\\\\\n]*)*)\"/",    /* double-quoted strings */
 602                         "/'([^'\\\\\n]*(\\\\.[^'\\\\\n]*)*)'/",        /* single-quoted strings */
 603                         "/\b-?#[0-9A-F]+\b/",                /* hex numbers */
 604                         "/\b-?[0-9]+\b/",                /* numbers */
 605                         "/\b[0-9[:upper:]_]+\b/"            /* all-caps words */
 606                 ],
 607                 'comments',             [ "/--.*$/m" ]
 608         ],
 609         'section'       =>      [ '/^[ \t]*(global|export)*[ \t]*(function|procedure)/' ]
 610 };
 611
 612
 613 /** code **/
 614
 615 sub mp.detect_syntax(doc)
 616 /* tries to detect the syntax of a document */
 617 {
 618         doc.syntax = NULL;
 619
 620         /* loops the syntax highlight definitions */
 621         foreach (n, keys(mp.syntax)) {
 622                 local s = mp.syntax[n];
 623
 624                 /* test the extensions */
 625                 foreach (ext, s.filenames) {
 626                         if (regex(ext, doc.name)) {
 627                                 doc.syntax = s;
 628                                 return;
 629                         }
 630                 }
 631         }
 632
 633         /* not by extension? try the 'detect' subroutine */
 634         foreach (n, keys(mp.syntax)) {
 635                 local s = mp.syntax[n];
 636
 637                 if (is_exec(s.detect) && s.detect(doc)) {
 638                         doc.syntax = s;
 639                         return;
 640                 }
 641         }
 642 }
 643
 644
 645 sub mp.help(doc, word)
 646 {
 647         local h;
 648
 649         foreach (c, doc.syntax.help) {
 650                 local f;
 651
 652                 /* format the command */
 653                 c = sprintf(c, word);
 654
 655                 /* pipe from it */
 656                 if ((f = popen(c, "r")) != NULL) {
 657                         local l;
 658                         h = [];
 659
 660                         while ((l = read(f)) != NULL)
 661                                 push(h, mp.chomp(l));
 662
 663                         /* fails? */
 664                         if (pclose(f) != 0)
 665                                 h = NULL;
 666                 }
 667
 668                 /* is there already help? don't look for more */
 669                 if (h != NULL)
 670                         break;
 671         }
 672
 673         return h;
 674 }
 675
 676
 677 /**
 678  * mp.section_list - Returns the list of sections of a document.
 679  * @doc: the document
 680  *
 681  * Applies the `section' array of regular expressions of the
 682  * document's syntax definition and returns it as an array of
 683  * line and line number pairs.
 684  *
 685  * If the document has no syntax highlight definition, or it has
 686  * one without a `section' definition, NULL is returned. Otherwise,
 687  * an array of line, line number pairs is returned (it can be
 688  * an empty list if the document has no recognizable sections).
 689  */
 690 sub mp.section_list(doc)
 691 {
 692         local r;
 693
 694         if (doc.syntax.section) {
 695                 local n, l;
 696
 697                 r = [];
 698
 699                 while ((l = doc.txt.lines[n]) != NULL) {
 700                         foreach (ex, doc.syntax.section) {
 701                                 if (regex(ex, l)) {
 702                                         push(r, [ l, n ]);
 703                                         break;
 704                                 }
 705                         }
 706
 707                         n++;
 708                 }
 709         }
 710
 711         return r;
 712 }