Plato - lang/compiler/lexer/string.js

(function(sc) {
  "use strict";

require("./lexer");

var Token = sc.lang.compiler.Token;
  var Lexer = sc.lang.compiler.Lexer;

Lexer.addLexMethod("String", function(source, index) {
    return new StringLexer(source, index).scan();
  });

function StringLexer(source, index) {
    this.source = source;
    this.index = index;
  }

StringLexer.prototype.scan = function() {
    return this.scanSymbolLiteral() ||
      this.scanQuotedSymbolLiteral() ||
      this.scanStringLiteral() ||
      this.scanCharLiteral();
  };

StringLexer.prototype.match = function(re) {
    return re.exec(this.source.slice(this.index));
  };

StringLexer.prototype.scanCharLiteral = function() {
    var source = this.source;
    var index  = this.index;

if (source.charAt(index) !== "$") {
      return;
    }

var value = source.charAt(index + 1) || "";

return makeStringToken(Token.CharLiteral, value, 1);
  };

StringLexer.prototype.scanSymbolLiteral = function() {
    var items = this.match(/^\\([a-zA-Z_]\w*|\d+)?/);

if (!items) {
      return;
    }

var value = items[1] || "";

return makeStringToken(Token.SymbolLiteral, value, 1);
  };

StringLexer.prototype.scanQuotedSymbolLiteral = function() {
    var source = this.source;
    var index  = this.index;

if (source.charAt(index) !== "'") {
      return;
    }

return makeErrorToken("'" + value);
  };

StringLexer.prototype.scanStringLiteral = function() {
    var source = this.source;
    var index  = this.index;

if (source.charAt(index) !== '"') {
      return;
    }

return makeErrorToken('"' + value, line);
  };

function makeStringToken(type, value, pad, line) {
    return {
      type: type,
      value: value,
      length: value.length + pad,
      line: line|0
    };
  }

function makeErrorToken(value, line) {
    return {
      error: true,
      value: value,
      length: value.length,
      line: line|0
    };
  }
})(sc);

lang/compiler/lexer/string.js

Maintainability

Lines of code

Difficulty

Estimated Errors

Function weight

By Complexity

By SLOC