carbon/lib/customModes/nimrod.js

const CodeMirror = require('codemirror')


CodeMirror.defineMode("nimrod", function(conf, parserConf) {
  var ERRORCLASS = 'error';

  function wordRegexp(words) {
    return new RegExp("^((" + words.join(")|(") + "))\\b");
  }

  var operators = new RegExp("\\=\\+\\-\\*\\/\\<\\>\\@\\$\\~\\&\\%\\|\\!\\?\\^\\:\\\\");
  var identifiers = new RegExp("^[_A-Za-z][_A-Za-z0-9]*");

  var commonkeywords = ['addr', 'asm', 'atomic',
                        'bind', 'block', 'break', 'case', 'cast',
                        'const', 'continue', 'converter',
                        'discard', 'distinct', 'do',
                        'elif', 'else', 'end', 'enum', 'except', 'export',
                        'finally', 'for', 'from',
                        'generic',
                        'if', 'import', 'include', 'interface', 'iterator',
                        'lambda', 'let',
                        'macro', 'method', 'mixin', 'nil',
                        'object', 'out',
                        'proc', 'ptr',
                        'raise', 'ref', 'return',
                        'shared', 'static',
                        'template', 'try', 'tuple', 'type',
                        'using',
                        'var',
                        'when', 'while', 'with', 'without',
                        'yield',

                        // keyword operators
                        'shl', 'shr', 'and', 'or', 'xor', 'not',
                        'div', 'mod', 'is', 'isnot', 'in', 'as', 'of'];

  var commonBuiltins = ["int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16",
                        "uint32", "uint64", "float", "float32", "float64", "bool", "char",
                        "string", "cstring", "pointer", "range", "array", "openarray",
                        "seq", "set", "Byte", "Natural", "Positive", "TObject", "PObject",
                        "Conversion", "TResult", "TAddress", "BiggestInt", "BiggestFloat",
                        "cchar", "cschar", "cshort", "cint", "csize", "cuchar", "cushort",
                        "clong", "clonglong", "cfloat", "cdouble", "clongdouble", "cuint",
                        "culong", "culonglong", "cchar", "cstringArray", "TEndian", "PFloat32",
                        "PFloat64", "PInt64", "PInt32", "TGC_Strategy", "TFile", "TFileMode",
                        "TFileHandle", "isMainModule", "CompileDate", "CompileTime", "NimrodVersion",
                        "NimrodMajor", "NimrodMinor", "NimrodPatch", "cpuEndian", "hostOS", "hostCPU",
                        "inf", "neginf", "nan", "QuitSuccess", "QuitFailure", "dbgLineHook", "stdin",
                        "stdout", "stderr", "defined", "new", "high", "low", "sizeof", "succ", "pred",
                        "inc", "dec", "newSeq", "len", "incl", "excl", "card", "ord", "chr", "ze",
                        "ze64", "toU8", "toU16", "toU32", "abs", "min", "max", "add", "repr", "contains",
                        "toFloat", "toBiggestFloat", "toInt", "toBiggestInt", "addQuitProc", "copy",
                        "setLen", "newString", "zeroMem", "copyMem", "moveMem", "equalMem", "alloc",
                        "alloc0", "realloc", "dealloc", "setLen", "assert", "swap", "getRefcount",
                        "getCurrentException", "Msg", "getOccupiedMem", "getFreeMem", "getTotalMem",
                        "isNil", "seqToPtr", "find", "pop", "GC_disable", "GC_enable", "GC_fullCollect",
                        "GC_setStrategy", "GC_enableMarkAnd", "Sweep", "GC_disableMarkAnd", "Sweep",
                        "GC_getStatistics", "GC_ref", "GC_ref", "GC_ref", "GC_unref", "GC_unref",
                        "GC_unref", "quit", "OpenFile", "OpenFile", "CloseFile", "EndOfFile",
                        "readChar", "FlushFile", "readFile", "write", "readLine", "writeln",
                        "writeln", "getFileSize", "ReadBytes", "ReadChars", "readBuffer",
                        "writeBytes", "writeChars", "writeBuffer", "setFilePos", "getFilePos",
                        "fileHandle", "countdown", "countup", "items", "lines",
                        "true", "false",

                        // exceptions
                        "E_Base", "EAsynch", "ESynch", "ESystem", "EIO", "EOS", "ERessourceExhausted",
                        "EArithmetic", "EDivByZero", "EOverflow", "EAccessViolation", "EAssertionFailed",
                        "EControlC", "EInvalidValue", "EOutOfMemory", "EInvalidIndex", "EInvalidField",
                        "EOutOfRange", "EStackOverflow", "ENoExceptionToReraise", "EInvalidObjectAssignment",
                        "EInvalidObject", "EInvalidLibrary", "EInvalidKey", "EInvalidObjectConversion",
                        "EFloatingPoint", "EFloatInvalidOp", "EFloatDivByZero", "EFloatOverflow",
                        "EFloatInexact", "EDeadThrea"];

  if(parserConf.extra_keywords != undefined)
    commonkeywords = commonkeywords.concat(parserConf.extra_keywords);

  if(parserConf.extra_builtins != undefined)
    commonBuiltins = commonBuiltins.concat(parserConf.extra_builtins);

  var keywords = wordRegexp(commonkeywords);
  var builtins = wordRegexp(commonBuiltins);

  var indentInfo = null;

  var stringPrefixes = new RegExp("^(('{3}|\"{3}|['\"]))", "i");

  // tokenizers
  function tokenBase(stream, state) {
    // Handle scope changes
    if (stream.sol()) {
      var scopeOffset = state.scopes[0].offset;
      if (stream.eatSpace()) {
        var lineOffset = stream.indentation();
        if (lineOffset > scopeOffset) {
          indentInfo = 'indent';
        } else if (lineOffset < scopeOffset) {
          indentInfo = 'dedent';
        }
        return null;
      } else {
        if (scopeOffset > 0) {
          dedent(stream, state);
        }
      }
    }

    if (stream.eatSpace())
      return null;

    var ch = stream.peek();

    // Handle Comments
    if (ch === '#') {
      stream.skipToEnd();
      return 'comment';
    }

    // Handle Number Literals
    if (stream.match(/^[0-9\.]/, false)) {
      var floatLiteral = false;
      // Floats
      if (stream.match(/^\d*\.\d+(e[\+\-]?\d+)?/i)) { floatLiteral = true; }
      if (stream.match(/^\d+\.\d*/)) { floatLiteral = true; }
      if (stream.match(/^\.\d+/)) { floatLiteral = true; }
      if (floatLiteral) {
          // Float literals may be "imaginary"
          stream.eat(/J/i);
          return 'number';
      }
      // Integers
      var intLiteral = false;
      // Hex
      if (stream.match(/^0x[0-9a-f]+/i)) { intLiteral = true; }
      // Binary
      if (stream.match(/^0b[01]+/i)) { intLiteral = true; }
      // Octal
      if (stream.match(/^0o[0-7]+/i)) { intLiteral = true; }
      // Decimal
      if (stream.match(/^[1-9]\d*(e[\+\-]?\d+)?/)) {
        // Decimal literals may be "imaginary"
        stream.eat(/J/i);
        // TODO - Can you have imaginary longs?
        intLiteral = true;
      }
      // Zero by itself with no other piece of number.
      if (stream.match(/^0(?![\dx])/i)) { intLiteral = true; }
      if (intLiteral) {
        // Integer literals may be "long"
        stream.eat(/L/i);
        return 'number';
      }
    }

    // Handle Strings
    if (stream.match(stringPrefixes)) {
      state.tokenize = tokenStringFactory(stream.current());
      return state.tokenize(stream, state);
    }

    if (stream.match(operators))
      return 'operator';

    if (stream.match(keywords))
      return 'keyword';

    if (stream.match(builtins))
      return 'builtin';

    if (stream.match(identifiers)) {
      if (state.lastToken != null &&
          state.lastToken.match(/proc|iterator|macro|template|class|converter/)) {
        return 'def';
      }

      return 'variable';
    }

    // Handle non-detected items
    stream.next();
    return ERRORCLASS;
  }

  function tokenStringFactory(delimiter) {
    var singleline = delimiter.length == 1;
    var OUTCLASS = 'string';

    function tokenString(stream, state) {
      while (!stream.eol()) {
        stream.eatWhile(/[^'"\\]/);
        if (stream.eat('\\')) {
          stream.next();
          if (singleline && stream.eol()) {
              return OUTCLASS;
          }
        } else if (stream.match(delimiter)) {
          state.tokenize = tokenBase;
          return OUTCLASS;
        } else {
          stream.eat(/['"]/);
        }
      }
      if (singleline) {
        if (parserConf.singleLineStringErrors) {
          return ERRORCLASS;
        } else {
          state.tokenize = tokenBase;
        }
      }
      return OUTCLASS;
    }

    tokenString.isString = true;
    return tokenString;
  }

  function indent(stream, state, type) {
    type = type || 'nim';
    var indentUnit = 0;
    if (type === 'nim') {
      if (state.scopes[0].type !== 'nim') {
        state.scopes[0].offset = stream.indentation();
        return;
      }
      for (var i = 0; i < state.scopes.length; ++i) {
        if (state.scopes[i].type === 'nim') {
          indentUnit = state.scopes[i].offset + conf.indentUnit;
          break;
        }
      }
    } else {
      indentUnit = stream.column() + stream.current().length;
    }

    state.scopes.unshift({
      offset: indentUnit,
      type: type
    });
  }

  function dedent(stream, state, type) {
      type = type || 'nim';
      if (state.scopes.length == 1) return;
      if (state.scopes[0].type === 'nim') {
          var _indent = stream.indentation();
          var _indent_index = -1;
          for (var i = 0; i < state.scopes.length; ++i) {
              if (_indent === state.scopes[i].offset) {
                  _indent_index = i;
                  break;
              }
          }
          if (_indent_index === -1) {
              return true;
          }
          while (state.scopes[0].offset !== _indent) {
              state.scopes.shift();
          }
          return false;
      } else {
          if (type === 'nim') {
              state.scopes[0].offset = stream.indentation();
              return false;
          } else {
              if (state.scopes[0].type != type) {
                  return true;
              }
              state.scopes.shift();
              return false;
          }
      }
  }

  function tokenLexer(stream, state) {
    indentInfo = null;
    var style = state.tokenize(stream, state);
    var current = stream.current();

    // Handle '.' connected identifiers
    if (current === '.') {
      style = stream.match(identifiers, false) ? null : ERRORCLASS;
      if (style === null && state.lastStyle === 'meta') {
        // Apply 'meta' style to '.' connected identifiers when
        // appropriate.
        style = 'meta';
      }
      return style;
    }

    if ((style === 'variable' || style === 'builtin')
        && state.lastStyle === 'meta') {
      style = 'meta';
    }

    // Handle scope changes.
    if (current.match(/return|break|continue|raise/) ||
        (current === 'discard' && stream.eol()))
      state.dedent += 1;

    if (current === 'lambda' || current === 'proc')
      state.lambda = true;

    var delimiter_index = '[({'.indexOf(current);

    if (delimiter_index !== -1) {
      indent(stream, state, '])}'.slice(delimiter_index, delimiter_index+1));
    }
    else if(stream.eol() && current.match(/\=|\:|import|include|type|const|var|let/)) {
      indent(stream, state);
    }

    if (indentInfo === 'dedent') {
      if (dedent(stream, state)) {
        return ERRORCLASS;
      }
    }

    delimiter_index = '])}'.indexOf(current);
    if (delimiter_index !== -1) {
      if (dedent(stream, state, current)) {
        return ERRORCLASS;
      }
    }

    if (state.dedent > 0 && stream.eol() && state.scopes[0].type == 'nim') {
      if (state.scopes.length > 1) state.scopes.shift();
      state.dedent -= 1;
    }

    return style;
  }

  var external = {
    startState: function(basecolumn) {
      return {
        tokenize: tokenBase,
        scopes: [{offset:basecolumn || 0, type:'nim'}],
        lastStyle: null,
        lastToken: null,
        lambda: false,
        dedent: 0
      };
    },

    token: function(stream, state) {
      var style = tokenLexer(stream, state);

      state.lastStyle = style;

      var current = stream.current();
      if (current && style)
        state.lastToken = current;

      if (stream.eol() && state.lambda)
        state.lambda = false;

      return style;
    },

    indent: function(state) {
      if (state.tokenize != tokenBase)
        return state.tokenize.isString ? CodeMirror.Pass : 0;

      return state.scopes[0].offset;
    },

    lineComment: "#",
    fold: "indent"
  };

  return external;
});

CodeMirror.defineMIME("text/x-nimrod", "nimrod");