constructor(cartoStr) {

this.env = null;

/**

this.parser = null;

/**

this.ruleSet = null;

/**

this.cartoStr = "";

/**

this.shaders = null;

if (typeof cartoStr === "string") {

this.cartoStr = cartoStr;

this.env = {

frames: [],

errors: [],

error: function (obj) {

this.errors.push(obj);

}

};

this.parser = this.getParser(this.env);

this.parse(cartoStr);

this.shaders = this.toShaders();

}

}

/**

getParser(env) {

var input, // LeSS input string

i, // current index in `input`

j, // current chunk

temp, // temporarily holds a chunk's state, for backtracking

memo, // temporarily holds `i`, when backtracking

furthest, // furthest index the parser has gone to

chunks, // chunkified input

current, // index of current chunk, in `input`

parser;

var that = this;

// This function is called after all files

// have been imported through `@import`.

var finish = function () {//NOSONAR

//所有文件导入完成之后调用

};

function save() {

temp = chunks[j];

memo = i;

current = i;

}

function restore() {

chunks[j] = temp;

i = memo;

current = i;

}

function sync() {

if (i > current) {

chunks[j] = chunks[j].slice(i - current);

current = i;

}

}

//

// Parse from a token, regexp or string, and move forward if match

//

function $(tok) {

var match, length, c, endIndex;

// Non-terminal

if (tok instanceof Function) {

return tok.call(parser.parsers);

// Terminal

// Either match a single character in the input,

// or match a regexp in the current chunk (chunk[j]).

} else if (typeof(tok) === 'string') {

match = input.charAt(i) === tok ? tok : null;

length = 1;

sync();

} else {

sync();

match = tok.exec(chunks[j]);

if (match) {

length = match[0].length;

} else {

return null;

}

}

// The match is confirmed, add the match length to `i`,

// and consume any extra white-space characters (' ' || '\n')

// which come after that. The reason for this is that LeSS's

// grammar is mostly white-space insensitive.

if (match) {

var mem = i += length;

endIndex = i + chunks[j].length - length;

while (i < endIndex) {

c = input.charCodeAt(i);

if (!(c === 32 || c === 10 || c === 9)) {

break;

}

i++;

}

chunks[j] = chunks[j].slice(length + (i - mem));

current = i;

if (chunks[j].length === 0 && j < chunks.length - 1) {

j++;

}

if (typeof(match) === 'string') {

return match;

} else {

return match.length === 1 ? match[0] : match;

}

}

}

// Same as $(), but don't change the state of the parser,

// just return the match.

function peek(tok) {

if (typeof(tok) === 'string') {

return input.charAt(i) === tok;

} else {

return !!tok.test(chunks[j]);

}

}

// Make an error object from a passed set of properties.

// Accepted properties:

// - `message`: Text of the error message.

// - `filename`: Filename where the error occurred.

// - `index`: Char. index where the error occurred.

function makeError(err) {

var einput;

var defautls = {

index: furthest,

filename: env.filename,

message: 'Parse error.',

line: 0,

column: -1

};

if (defautls) {

for (var prop in defautls) {

if (err[prop] === 0) {err[prop] = defautls[prop];}

}

}

if (err.filename && that.env.inputs && that.env.inputs[err.filename]) {

einput = that.env.inputs[err.filename];

} else {

einput = input;

}

err.line = (einput.slice(0, err.index).match(/\n/g) || '').length + 1;

for (var n = err.index; n >= 0 && einput.charAt(n) !== '\n'; n--) {

err.column++;

}

return new Error([err.filename, err.line, err.column, err.message].join(";"));

}

this.env = env = env || {};

this.env.filename = this.env.filename || null;

this.env.inputs = this.env.inputs || {};

// The Parser

parser = {

// Parse an input string into an abstract syntax tree.

// Throws an error on parse errors.

parse: function (str) {

var root, error = null;

i = j = current = furthest = 0;

chunks = [];

input = str.replace(/\r\n/g, '\n');

if (env.filename) {

that.env.inputs[env.filename] = input;

}

// Split the input into chunks.

chunks = (function (chunks) {

var j = 0,

skip = /(?:@\{[\w-]+\}|[^"'`\{\}\/\(\)\\])+/g,

comment = /\/\*(?:[^*]|\*+[^\/*])*\*+\/|\/\/.*/g,

string = /"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'|`((?:[^`]|\\.)*)`/g,

level = 0,

match,

chunk = chunks[0],

inParam;

for (var i = 0, c, cc; i < input.length;) {

skip.lastIndex = i;

if (match = skip.exec(input)) {

if (match.index === i) {

i += match[0].length;

chunk.push(match[0]);

}

}

c = input.charAt(i);

comment.lastIndex = string.lastIndex = i;

if (match = string.exec(input)) {

if (match.index === i) {

i += match[0].length;

chunk.push(match[0]);

continue;

}

}

if (!inParam && c === '/') {

cc = input.charAt(i + 1);

if (cc === '/' || cc === '*') {

if (match = comment.exec(input)) {

if (match.index === i) {

i += match[0].length;

chunk.push(match[0]);

continue;

}

}

}

}

switch (c) {

case '{'://NOSONAR

if (!inParam) {

level++;

chunk.push(c);

break;

}

case '}'://NOSONAR

if (!inParam) {

level--;

chunk.push(c);

chunks[++j] = chunk = [];

break;

}

case '('://NOSONAR

if (!inParam) {

inParam = true;

chunk.push(c);

break;

}

case ')'://NOSONAR

if (inParam) {

inParam = false;

chunk.push(c);

break;

}

default:

chunk.push(c);

break;

}

i++;

}

if (level !== 0) {

error = {

index: i - 1,

type: 'Parse',

message: (level > 0) ? "missing closing `}`" : "missing opening `{`"

};

}

return chunks.map(function (c) {

return c.join('');

});

})([[]]);

if (error) {

throw makeError(error);

}

// Sort rules by specificity: this function expects selectors to be

// split already.

//

// Written to be used as a .sort(Function);

// argument.

//

// [1, 0, 0, 467] > [0, 0, 1, 520]

var specificitySort = function (a, b) {

var as = a.specificity;

var bs = b.specificity;

if (as[0] != bs[0]) {return bs[0] - as[0];}

if (as[1] != bs[1]) {return bs[1] - as[1];}

if (as[2] != bs[2]) {return bs[2] - as[2];}

return bs[3] - as[3];

};

// Start with the primary rule.

// The whole syntax tree is held under a Ruleset node,

// with the `root` property set to true, so no `{}` are

// output.

root = new SuperMap.CartoCSS.Tree.Ruleset([], $(this.parsers.primary));

root.root = true;

// Get an array of Ruleset objects, flattened

// and sorted according to specificitySort

root.toList = (function () {

return function (env) {

env.error = function (e) {

if (!env.errors) {env.errors = new Error('');}

if (env.errors.message) {

env.errors.message += '\n' + makeError(e).message;

} else {

env.errors.message = makeError(e).message;

}

};

env.frames = env.frames || [];

// call populates Invalid-caused errors

var definitions = this.flatten([], [], env);

definitions.sort(specificitySort);

return definitions;

};

})();

return root;

},

// Here in, the parsing rules/functions

//

// The basic structure of the syntax tree generated is as follows:

//

// Ruleset -> Rule -> Value -> Expression -> Entity

//

// In general, most rules will try to parse a token with the `$()` function, and if the return

// value is truly, will return a new node, of the relevant type. Sometimes, we need to check

// first, before parsing, that's when we use `peek()`.

parsers: {

// The `primary` rule is the *entry* and *exit* point of the parser.

// The rules here can appear at any level of the parse tree.

//

// The recursive nature of the grammar is an interplay between the `block`

// rule, which represents `{ ... }`, the `ruleset` rule, and this `primary` rule,

// as represented by this simplified grammar:

//

// primary → (ruleset | rule)+

// ruleset → selector+ block

// block → '{' primary '}'

//

// Only at one point is the primary rule not called from the

// block rule: at the root level.

primary: function () {

var node, root = [];

while ((node = $(this.rule) || $(this.ruleset) ||

$(this.comment)) ||

$(/^[\s\n]+/) || (node = $(this.invalid))) {

if (node) {root.push(node);}

}

return root;

},

invalid: function () {

var chunk = $(/^[^;\n]*[;\n]/);

// To fail gracefully, match everything until a semicolon or linebreak.

if (chunk) {

return new SuperMap.CartoCSS.Tree.Invalid(chunk, memo);

}

},

// We create a Comment node for CSS comments `/* */`,

// but keep the LeSS comments `//` silent, by just skipping

// over them.

comment: function () {

var comment;

if (input.charAt(i) !== '/') {return;}

if (input.charAt(i + 1) === '/') {

return new SuperMap.CartoCSS.Tree.Comment($(/^\/\/.*/), true);

} else if (comment = $(/^\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/)) {

return new SuperMap.CartoCSS.Tree.Comment(comment);

}

},

// Entities are tokens which can be found inside an Expression

entities: {

// A string, which supports escaping " and ' "milky way" 'he\'s the one!'

quoted: function () {

if (input.charAt(i) !== '"' && input.charAt(i) !== "'") {return;}

var str = $(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/);

if (str) {

return new SuperMap.CartoCSS.Tree.Quoted(str[1] || str[2]);

}

},

// A reference to a Mapnik field, like [NAME]

// Behind the scenes, this has the same representation, but Carto

// needs to be careful to warn when unsupported operations are used.

field: function () {

var l = '[', r = ']';

if (!$(l)) {return;}

var field_name = $(/(^[^\]]+)/);

if (!$(r)) {return;}

if (field_name) {return new SuperMap.CartoCSS.Tree.Field(field_name[1]);}

},

// This is a comparison operator

comparison: function () {

var str = $(/^=~|=|!=|<=|>=|<|>/);

if (str) {

return str;

}

},

// A catch-all word, such as: hard-light

// These can start with either a letter or a dash (-),

// and then contain numbers, underscores, and letters.

keyword: function () {

var k = $(/^[A-Za-z\u4e00-\u9fa5-]+[A-Za-z-0-9\u4e00-\u9fa5_]*/);

if (k) {

return new SuperMap.CartoCSS.Tree.Keyword(k);

}

},

// A function call like rgb(255, 0, 255)

// The arguments are parsed with the `entities.arguments` parser.

call: function () {

var name, args;

if (!(name = /^([\w\-]+|%)\(/.exec(chunks[j]))) {return;}

name = name[1];

if (name === 'url') {

// url() is handled by the url parser instead

return null;

} else {

i += name.length;

}

var l = '(', r = ')';

$(l); // Parse the '(' and consume whitespace.

args = $(this.entities['arguments']);

if (!$(r)) {return;}

if (name) {

return new SuperMap.CartoCSS.Tree.Call(name, args, i);

}

},

// Arguments are comma-separated expressions

'arguments': function () {

var args = [], arg;

while (arg = $(this.expression)) {

args.push(arg);

var q = ',';

if (!$(q)) {

break;

}

}

return args;

},

literal: function () {

return $(this.entities.dimension) ||

$(this.entities.keywordcolor) ||

$(this.entities.hexcolor) ||

$(this.entities.quoted);

},

// Parse url() tokens

//

// We use a specific rule for urls, because they don't really behave like

// standard function calls. The difference is that the argument doesn't have

// to be enclosed within a string, so it can't be parsed as an Expression.

url: function () {

var value;

if (input.charAt(i) !== 'u' || !$(/^url\(/)) {return;}

value = $(this.entities.quoted) || $(this.entities.variable) ||

$(/^[\-\w%@$\/.&=:;#+?~]+/) || '';

var r = ')';

if (!$(r)) {

return new SuperMap.CartoCSS.Tree.Invalid(value, memo, 'Missing closing ) in URL.');

} else {

return new SuperMap.CartoCSS.Tree.URL((typeof value.value !== 'undefined' ||

value instanceof SuperMap.CartoCSS.Tree.Variable) ?

value : new SuperMap.CartoCSS.Tree.Quoted(value));

}

},

// A Variable entity, such as `@fink`, in

//

// width: @fink + 2px

//

// We use a different parser for variable definitions,

// see `parsers.variable`.

variable: function () {

var name, index = i;

if (input.charAt(i) === '@' && (name = $(/^@[\w-]+/))) {

return new SuperMap.CartoCSS.Tree.Variable(name, index, env.filename);

}

},

hexcolor: function () {

var rgb;

if (input.charAt(i) === '#' && (rgb = $(/^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})/))) {

return new SuperMap.CartoCSS.Tree.Color(rgb[1]);

}

},

keywordcolor: function () {

var rgb = chunks[j].match(/^[a-z]+/);

if (rgb && rgb[0] in SuperMap.CartoCSS.Tree.Reference.data.colors) {

return new SuperMap.CartoCSS.Tree.Color(SuperMap.CartoCSS.Tree.Reference.data.colors[$(/^[a-z]+/)]);

}

},

// A Dimension, that is, a number and a unit. The only

// unit that has an effect is %

dimension: function () {

var c = input.charCodeAt(i);

if ((c > 57 || c < 45) || c === 47) {return;}

var value = $(/^(-?\d*\.?\d+(?:[eE][-+]?\d+)?)(\%|\w+)?/);

if (value) {

return new SuperMap.CartoCSS.Tree.Dimension(value[1], value[2], memo);

}

}

},

// The variable part of a variable definition.

// Used in the `rule` parser. Like @fink:

variable: function () {

var name;

if (input.charAt(i) === '@' && (name = $(/^(@[\w-]+)\s*:/))) {

return name[1];

}

},

// Entities are the smallest recognized token,

// and can be found inside a rule's value.

entity: function () {

var property1 = $(this.entities.call) || $(this.entities.literal);

var property2 = $(this.entities.field) || $(this.entities.variable);

var property3 = $(this.entities.url) || $(this.entities.keyword);

return property1 || property2 || property3;

},

// A Rule terminator. Note that we use `peek()` to check for '}',

// because the `block` rule will be expecting it, but we still need to make sure

// it's there, if ';' was ommitted.

end: function () {

var q = ';';

return $(q) || peek('}');

},

// Elements are the building blocks for Selectors. They consist of

// an element name, such as a tag a class, or `*`.

//增加对中文的支持，[\u4e00-\u9fa5]

element: function () {

var e = $(/^(?:[.#][\w\u4e00-\u9fa5\-]+|\*|Map)/);

if (e) {return new SuperMap.CartoCSS.Tree.Element(e);}

},

// Attachments allow adding multiple lines, polygons etc. to an

// object. There can only be one attachment per selector.

attachment: function () {

var s = $(/^::([\w\-]+(?:\/[\w\-]+)*)/);

if (s) {return s[1];}

},

// Selectors are made out of one or more Elements, see above.

selector: function () {

var a, attachment,

e, elements = [],

f, filters = new SuperMap.CartoCSS.Tree.Filterset(),

z, zooms = [],

segments = 0, conditions = 0;

while (

(e = $(this.element)) ||

(z = $(this.zoom)) ||

(f = $(this.filter)) ||

(a = $(this.attachment))

) {

segments++;

if (e) {

elements.push(e);

} else if (z) {

zooms.push(z);

conditions++;

} else if (f) {

var err = filters.add(f);

if (err) {

throw makeError({

message: err,

index: i - 1

});

}

conditions++;

} else if (attachment) {

throw makeError({

message: 'Encountered second attachment name.',

index: i - 1

});

} else {

attachment = a;

}

var c = input.charAt(i);

if (c === '{' || c === '}' || c === ';' || c === ',') {

break;

}

}

if (segments) {

return new SuperMap.CartoCSS.Tree.Selector(filters, zooms, elements, attachment, conditions, memo);

}

},

filter: function () {

save();

var key, op, val, l = '[', r = ']';

if (!$(l)) {return;}

if (key = $(/^[a-zA-Z0-9\-_]+/) ||

$(this.entities.quoted) ||

$(this.entities.variable) ||

$(this.entities.keyword) ||

$(this.entities.field)) {

if (key instanceof SuperMap.CartoCSS.Tree.Quoted) {

key = new SuperMap.CartoCSS.Tree.Field(key.toString());

}

if ((op = $(this.entities.comparison)) &&

(val = $(this.entities.quoted) ||

$(this.entities.variable) ||

$(this.entities.dimension) ||

$(this.entities.keyword) ||

$(this.entities.field))) {

if (!$(r)) {

throw makeError({

message: 'Missing closing ] of filter.',

index: memo - 1

});

}

if (!key.is) {key = new SuperMap.CartoCSS.Tree.Field(key);}

return new SuperMap.CartoCSS.Tree.Filter(key, op, val, memo, env.filename);

}

}

},

zoom: function () {

save();

var op, val, r = ']';

if ($(/^\[\s*zoom/g) &&

(op = $(this.entities.comparison)) &&

(val = $(this.entities.variable) || $(this.entities.dimension)) && $(r)) {

return new SuperMap.CartoCSS.Tree.Zoom(op, val, memo);

} else {

// backtrack

restore();

}

},

// The `block` rule is used by `ruleset`

// It's a wrapper around the `primary` rule, with added `{}`.

block: function () {

var content, l = '{', r = '}';

if ($(l) && (content = $(this.primary)) && $(r)) {

return content;

}

},

// div, .class, body > p {...}

ruleset: function () {

var selectors = [], s, rules, q = ',';

save();

while (s = $(this.selector)) {

selectors.push(s);

while ($(this.comment)) {//NOSONAR

}

if (!$(q)) {

break;

}

while ($(this.comment)) {//NOSONAR

}

}

if (s) {

while ($(this.comment)) {//NOSONAR

}

}

if (selectors.length > 0 && (rules = $(this.block))) {

if (selectors.length === 1 &&

selectors[0].elements.length &&

selectors[0].elements[0].value === 'Map') {

var rs = new SuperMap.CartoCSS.Tree.Ruleset(selectors, rules);

rs.isMap = true;

return rs;

}

return new SuperMap.CartoCSS.Tree.Ruleset(selectors, rules);

} else {

// Backtrack

restore();

}

},

rule: function () {

var name, value, c = input.charAt(i);

save();