From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../rust/jsparagus-parser/.cargo-checksum.json | 1 + third_party/rust/jsparagus-parser/Cargo.toml | 40 + .../benches/__finStreamer-proto.js | 977 ++++++++ .../rust/jsparagus-parser/benches/parser.rs | 40 + .../rust/jsparagus-parser/benches/simple.js | 103 + third_party/rust/jsparagus-parser/src/lexer.rs | 2325 ++++++++++++++++++++ third_party/rust/jsparagus-parser/src/lib.rs | 111 + .../rust/jsparagus-parser/src/numeric_value.rs | 160 ++ third_party/rust/jsparagus-parser/src/parser.rs | 262 +++ .../rust/jsparagus-parser/src/queue_stack.rs | 256 +++ third_party/rust/jsparagus-parser/src/simulator.rs | 211 ++ third_party/rust/jsparagus-parser/src/tests.rs | 875 ++++++++ third_party/rust/jsparagus-parser/src/unicode.rs | 41 + .../rust/jsparagus-parser/src/unicode_data.rs | 2117 ++++++++++++++++++ 14 files changed, 7519 insertions(+) create mode 100644 third_party/rust/jsparagus-parser/.cargo-checksum.json create mode 100644 third_party/rust/jsparagus-parser/Cargo.toml create mode 100644 third_party/rust/jsparagus-parser/benches/__finStreamer-proto.js create mode 100644 third_party/rust/jsparagus-parser/benches/parser.rs create mode 100644 third_party/rust/jsparagus-parser/benches/simple.js create mode 100644 third_party/rust/jsparagus-parser/src/lexer.rs create mode 100644 third_party/rust/jsparagus-parser/src/lib.rs create mode 100644 third_party/rust/jsparagus-parser/src/numeric_value.rs create mode 100644 third_party/rust/jsparagus-parser/src/parser.rs create mode 100644 third_party/rust/jsparagus-parser/src/queue_stack.rs create mode 100644 third_party/rust/jsparagus-parser/src/simulator.rs create mode 100644 third_party/rust/jsparagus-parser/src/tests.rs create mode 100644 third_party/rust/jsparagus-parser/src/unicode.rs create mode 100644 third_party/rust/jsparagus-parser/src/unicode_data.rs (limited to 'third_party/rust/jsparagus-parser') diff --git a/third_party/rust/jsparagus-parser/.cargo-checksum.json b/third_party/rust/jsparagus-parser/.cargo-checksum.json new file mode 100644 index 0000000000..f28c683696 --- /dev/null +++ b/third_party/rust/jsparagus-parser/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"9ef3ec903b675e57867f02252811185c0da07362e19561e392df741c21e880e1","benches/__finStreamer-proto.js":"44edc00a99a8904f8c6bb0c42c7ba4f96ad611e61191d2702ecb228ae6d7b35d","benches/parser.rs":"6cb13b135513e86b94e1bbe1470156f182355078c2e34bf8d9deba1c67daf4b9","benches/simple.js":"fbb50c1c49c0b1e3740a79407a834248c1f8ebdb1b72530c0fc6df57d079f252","src/lexer.rs":"fc641c9e320652c7f73bdf78080ba73b84a5afcea0fa88759039290ce659d2e0","src/lib.rs":"12fb80fe5b0429f96540385ebfde861f98750ca629769f1bff47f22ab094e882","src/numeric_value.rs":"f429c50640eb35a53aa5ffdf71de305da30747e568dc10219c54b766372f6eca","src/parser.rs":"d7e69fd548d3149bc2aa4ef8e0e35725c9188dcaab470c899c66ba485445625f","src/queue_stack.rs":"5abbcfd65c655507e0fad545242bbff24db523ae962b5d02aac4e7f1debba293","src/simulator.rs":"fe77deff60bdddff4d2e1e243bc1660603506c515f1c88ffda87d0f9c9b341eb","src/tests.rs":"ad30ed0a762dbbde7562ba9eed1d282abdf4640135f1f9cabaef333b9d6e5fe2","src/unicode.rs":"0e5d77d4d6751c6441982ae3d4a8453233443376441c5c01da5c86a5a5051167","src/unicode_data.rs":"5356c11b9ac59300bb29c164b26efc7b1ce263864e47ce90a68734277be1c392"},"package":null} \ No newline at end of file diff --git a/third_party/rust/jsparagus-parser/Cargo.toml b/third_party/rust/jsparagus-parser/Cargo.toml new file mode 100644 index 0000000000..d1287bf6b9 --- /dev/null +++ b/third_party/rust/jsparagus-parser/Cargo.toml @@ -0,0 +1,40 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2018" +name = "jsparagus-parser" +version = "0.1.0" +authors = ["Jason Orendorff "] +license = "MIT/Apache-2.0" + +[[bench]] +name = "parser" +harness = false + +[dependencies] +arrayvec = "0.7" +bumpalo = "3.4.0" + +[dependencies.jsparagus-ast] +path = "../ast" + +[dependencies.jsparagus-generated-parser] +path = "../generated_parser" + +[dependencies.jsparagus-json-log] +path = "../json-log" + +[dev-dependencies] +criterion = "0.3" + +[features] +logging = ["jsparagus-json-log/logging"] diff --git a/third_party/rust/jsparagus-parser/benches/__finStreamer-proto.js b/third_party/rust/jsparagus-parser/benches/__finStreamer-proto.js new file mode 100644 index 0000000000..1f672edc4c --- /dev/null +++ b/third_party/rust/jsparagus-parser/benches/__finStreamer-proto.js @@ -0,0 +1,977 @@ +/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/ +(function($protobuf) { + var $Reader = $protobuf.Reader, $util = $protobuf.util; + + var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {}); + + $root.quotefeeder = (function() { + + var quotefeeder = {}; + + quotefeeder.QuoteType = (function() { + var valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "NONE"] = 0; + values[valuesById[5] = "ALTSYMBOL"] = 5; + values[valuesById[7] = "HEARTBEAT"] = 7; + values[valuesById[8] = "EQUITY"] = 8; + values[valuesById[9] = "INDEX"] = 9; + values[valuesById[11] = "MUTUALFUND"] = 11; + values[valuesById[12] = "MONEYMARKET"] = 12; + values[valuesById[13] = "OPTION"] = 13; + values[valuesById[14] = "CURRENCY"] = 14; + values[valuesById[15] = "WARRANT"] = 15; + values[valuesById[17] = "BOND"] = 17; + values[valuesById[18] = "FUTURE"] = 18; + values[valuesById[20] = "ETF"] = 20; + values[valuesById[23] = "COMMODITY"] = 23; + values[valuesById[28] = "ECNQUOTE"] = 28; + values[valuesById[41] = "CRYPTOCURRENCY"] = 41; + values[valuesById[42] = "INDICATOR"] = 42; + values[valuesById[1000] = "INDUSTRY"] = 1000; + return values; + })(); + + quotefeeder.MarketHours = (function() { + var valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "PRE_MARKET"] = 0; + values[valuesById[1] = "REGULAR_MARKET"] = 1; + values[valuesById[2] = "POST_MARKET"] = 2; + values[valuesById[3] = "EXTENDED_HOURS_MARKET"] = 3; + return values; + })(); + + quotefeeder.OptionType = (function() { + var valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "CALL"] = 0; + values[valuesById[1] = "PUT"] = 1; + return values; + })(); + + quotefeeder.PricingData = (function() { + + function PricingData(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) + this[ks[i]] = p[ks[i]]; + } + + PricingData.prototype.id = ""; + PricingData.prototype.price = 0; + PricingData.prototype.time = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.currency = ""; + PricingData.prototype.exchange = ""; + PricingData.prototype.quoteType = 0; + PricingData.prototype.marketHours = 0; + PricingData.prototype.changePercent = 0; + PricingData.prototype.dayVolume = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.dayHigh = 0; + PricingData.prototype.dayLow = 0; + PricingData.prototype.change = 0; + PricingData.prototype.shortName = ""; + PricingData.prototype.expireDate = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.openPrice = 0; + PricingData.prototype.previousClose = 0; + PricingData.prototype.strikePrice = 0; + PricingData.prototype.underlyingSymbol = ""; + PricingData.prototype.openInterest = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.optionsType = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.miniOption = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.lastSize = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.bid = 0; + PricingData.prototype.bidSize = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.ask = 0; + PricingData.prototype.askSize = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.priceHint = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.vol_24hr = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.volAllCurrencies = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + PricingData.prototype.fromcurrency = ""; + PricingData.prototype.lastMarket = ""; + PricingData.prototype.circulatingSupply = 0; + PricingData.prototype.marketcap = 0; + + PricingData.decode = function decode(r, l) { + if (!(r instanceof $Reader)) + r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, m = new $root.quotefeeder.PricingData(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.id = r.string(); + break; + case 2: + m.price = r.float(); + break; + case 3: + m.time = r.sint64(); + break; + case 4: + m.currency = r.string(); + break; + case 5: + m.exchange = r.string(); + break; + case 6: + m.quoteType = r.int32(); + break; + case 7: + m.marketHours = r.int32(); + break; + case 8: + m.changePercent = r.float(); + break; + case 9: + m.dayVolume = r.sint64(); + break; + case 10: + m.dayHigh = r.float(); + break; + case 11: + m.dayLow = r.float(); + break; + case 12: + m.change = r.float(); + break; + case 13: + m.shortName = r.string(); + break; + case 14: + m.expireDate = r.sint64(); + break; + case 15: + m.openPrice = r.float(); + break; + case 16: + m.previousClose = r.float(); + break; + case 17: + m.strikePrice = r.float(); + break; + case 18: + m.underlyingSymbol = r.string(); + break; + case 19: + m.openInterest = r.sint64(); + break; + case 20: + m.optionsType = r.sint64(); + break; + case 21: + m.miniOption = r.sint64(); + break; + case 22: + m.lastSize = r.sint64(); + break; + case 23: + m.bid = r.float(); + break; + case 24: + m.bidSize = r.sint64(); + break; + case 25: + m.ask = r.float(); + break; + case 26: + m.askSize = r.sint64(); + break; + case 27: + m.priceHint = r.sint64(); + break; + case 28: + m.vol_24hr = r.sint64(); + break; + case 29: + m.volAllCurrencies = r.sint64(); + break; + case 30: + m.fromcurrency = r.string(); + break; + case 31: + m.lastMarket = r.string(); + break; + case 32: + m.circulatingSupply = r.double(); + break; + case 33: + m.marketcap = r.double(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + + PricingData.fromObject = function fromObject(d) { + if (d instanceof $root.quotefeeder.PricingData) + return d; + var m = new $root.quotefeeder.PricingData(); + if (d.id != null) { + m.id = String(d.id); + } + if (d.price != null) { + m.price = Number(d.price); + } + if (d.time != null) { + if ($util.Long) + (m.time = $util.Long.fromValue(d.time)).unsigned = false; + else if (typeof d.time === "string") + m.time = parseInt(d.time, 10); + else if (typeof d.time === "number") + m.time = d.time; + else if (typeof d.time === "object") + m.time = new $util.LongBits(d.time.low >>> 0, d.time.high >>> 0).toNumber(); + } + if (d.currency != null) { + m.currency = String(d.currency); + } + if (d.exchange != null) { + m.exchange = String(d.exchange); + } + switch (d.quoteType) { + case "NONE": + case 0: + m.quoteType = 0; + break; + case "ALTSYMBOL": + case 5: + m.quoteType = 5; + break; + case "HEARTBEAT": + case 7: + m.quoteType = 7; + break; + case "EQUITY": + case 8: + m.quoteType = 8; + break; + case "INDEX": + case 9: + m.quoteType = 9; + break; + case "MUTUALFUND": + case 11: + m.quoteType = 11; + break; + case "MONEYMARKET": + case 12: + m.quoteType = 12; + break; + case "OPTION": + case 13: + m.quoteType = 13; + break; + case "CURRENCY": + case 14: + m.quoteType = 14; + break; + case "WARRANT": + case 15: + m.quoteType = 15; + break; + case "BOND": + case 17: + m.quoteType = 17; + break; + case "FUTURE": + case 18: + m.quoteType = 18; + break; + case "ETF": + case 20: + m.quoteType = 20; + break; + case "COMMODITY": + case 23: + m.quoteType = 23; + break; + case "ECNQUOTE": + case 28: + m.quoteType = 28; + break; + case "CRYPTOCURRENCY": + case 41: + m.quoteType = 41; + break; + case "INDICATOR": + case 42: + m.quoteType = 42; + break; + case "INDUSTRY": + case 1000: + m.quoteType = 1000; + break; + } + switch (d.marketHours) { + case "PRE_MARKET": + case 0: + m.marketHours = 0; + break; + case "REGULAR_MARKET": + case 1: + m.marketHours = 1; + break; + case "POST_MARKET": + case 2: + m.marketHours = 2; + break; + case "EXTENDED_HOURS_MARKET": + case 3: + m.marketHours = 3; + break; + } + if (d.changePercent != null) { + m.changePercent = Number(d.changePercent); + } + if (d.dayVolume != null) { + if ($util.Long) + (m.dayVolume = $util.Long.fromValue(d.dayVolume)).unsigned = false; + else if (typeof d.dayVolume === "string") + m.dayVolume = parseInt(d.dayVolume, 10); + else if (typeof d.dayVolume === "number") + m.dayVolume = d.dayVolume; + else if (typeof d.dayVolume === "object") + m.dayVolume = new $util.LongBits(d.dayVolume.low >>> 0, d.dayVolume.high >>> 0).toNumber(); + } + if (d.dayHigh != null) { + m.dayHigh = Number(d.dayHigh); + } + if (d.dayLow != null) { + m.dayLow = Number(d.dayLow); + } + if (d.change != null) { + m.change = Number(d.change); + } + if (d.shortName != null) { + m.shortName = String(d.shortName); + } + if (d.expireDate != null) { + if ($util.Long) + (m.expireDate = $util.Long.fromValue(d.expireDate)).unsigned = false; + else if (typeof d.expireDate === "string") + m.expireDate = parseInt(d.expireDate, 10); + else if (typeof d.expireDate === "number") + m.expireDate = d.expireDate; + else if (typeof d.expireDate === "object") + m.expireDate = new $util.LongBits(d.expireDate.low >>> 0, d.expireDate.high >>> 0).toNumber(); + } + if (d.openPrice != null) { + m.openPrice = Number(d.openPrice); + } + if (d.previousClose != null) { + m.previousClose = Number(d.previousClose); + } + if (d.strikePrice != null) { + m.strikePrice = Number(d.strikePrice); + } + if (d.underlyingSymbol != null) { + m.underlyingSymbol = String(d.underlyingSymbol); + } + if (d.openInterest != null) { + if ($util.Long) + (m.openInterest = $util.Long.fromValue(d.openInterest)).unsigned = false; + else if (typeof d.openInterest === "string") + m.openInterest = parseInt(d.openInterest, 10); + else if (typeof d.openInterest === "number") + m.openInterest = d.openInterest; + else if (typeof d.openInterest === "object") + m.openInterest = new $util.LongBits(d.openInterest.low >>> 0, d.openInterest.high >>> 0).toNumber(); + } + if (d.optionsType != null) { + if ($util.Long) + (m.optionsType = $util.Long.fromValue(d.optionsType)).unsigned = false; + else if (typeof d.optionsType === "string") + m.optionsType = parseInt(d.optionsType, 10); + else if (typeof d.optionsType === "number") + m.optionsType = d.optionsType; + else if (typeof d.optionsType === "object") + m.optionsType = new $util.LongBits(d.optionsType.low >>> 0, d.optionsType.high >>> 0).toNumber(); + } + if (d.miniOption != null) { + if ($util.Long) + (m.miniOption = $util.Long.fromValue(d.miniOption)).unsigned = false; + else if (typeof d.miniOption === "string") + m.miniOption = parseInt(d.miniOption, 10); + else if (typeof d.miniOption === "number") + m.miniOption = d.miniOption; + else if (typeof d.miniOption === "object") + m.miniOption = new $util.LongBits(d.miniOption.low >>> 0, d.miniOption.high >>> 0).toNumber(); + } + if (d.lastSize != null) { + if ($util.Long) + (m.lastSize = $util.Long.fromValue(d.lastSize)).unsigned = false; + else if (typeof d.lastSize === "string") + m.lastSize = parseInt(d.lastSize, 10); + else if (typeof d.lastSize === "number") + m.lastSize = d.lastSize; + else if (typeof d.lastSize === "object") + m.lastSize = new $util.LongBits(d.lastSize.low >>> 0, d.lastSize.high >>> 0).toNumber(); + } + if (d.bid != null) { + m.bid = Number(d.bid); + } + if (d.bidSize != null) { + if ($util.Long) + (m.bidSize = $util.Long.fromValue(d.bidSize)).unsigned = false; + else if (typeof d.bidSize === "string") + m.bidSize = parseInt(d.bidSize, 10); + else if (typeof d.bidSize === "number") + m.bidSize = d.bidSize; + else if (typeof d.bidSize === "object") + m.bidSize = new $util.LongBits(d.bidSize.low >>> 0, d.bidSize.high >>> 0).toNumber(); + } + if (d.ask != null) { + m.ask = Number(d.ask); + } + if (d.askSize != null) { + if ($util.Long) + (m.askSize = $util.Long.fromValue(d.askSize)).unsigned = false; + else if (typeof d.askSize === "string") + m.askSize = parseInt(d.askSize, 10); + else if (typeof d.askSize === "number") + m.askSize = d.askSize; + else if (typeof d.askSize === "object") + m.askSize = new $util.LongBits(d.askSize.low >>> 0, d.askSize.high >>> 0).toNumber(); + } + if (d.priceHint != null) { + if ($util.Long) + (m.priceHint = $util.Long.fromValue(d.priceHint)).unsigned = false; + else if (typeof d.priceHint === "string") + m.priceHint = parseInt(d.priceHint, 10); + else if (typeof d.priceHint === "number") + m.priceHint = d.priceHint; + else if (typeof d.priceHint === "object") + m.priceHint = new $util.LongBits(d.priceHint.low >>> 0, d.priceHint.high >>> 0).toNumber(); + } + if (d.vol_24hr != null) { + if ($util.Long) + (m.vol_24hr = $util.Long.fromValue(d.vol_24hr)).unsigned = false; + else if (typeof d.vol_24hr === "string") + m.vol_24hr = parseInt(d.vol_24hr, 10); + else if (typeof d.vol_24hr === "number") + m.vol_24hr = d.vol_24hr; + else if (typeof d.vol_24hr === "object") + m.vol_24hr = new $util.LongBits(d.vol_24hr.low >>> 0, d.vol_24hr.high >>> 0).toNumber(); + } + if (d.volAllCurrencies != null) { + if ($util.Long) + (m.volAllCurrencies = $util.Long.fromValue(d.volAllCurrencies)).unsigned = false; + else if (typeof d.volAllCurrencies === "string") + m.volAllCurrencies = parseInt(d.volAllCurrencies, 10); + else if (typeof d.volAllCurrencies === "number") + m.volAllCurrencies = d.volAllCurrencies; + else if (typeof d.volAllCurrencies === "object") + m.volAllCurrencies = new $util.LongBits(d.volAllCurrencies.low >>> 0, d.volAllCurrencies.high >>> 0).toNumber(); + } + if (d.fromcurrency != null) { + m.fromcurrency = String(d.fromcurrency); + } + if (d.lastMarket != null) { + m.lastMarket = String(d.lastMarket); + } + if (d.circulatingSupply != null) { + m.circulatingSupply = Number(d.circulatingSupply); + } + if (d.marketcap != null) { + m.marketcap = Number(d.marketcap); + } + return m; + }; + + PricingData.toObject = function toObject(m, o) { + if (!o) + o = {}; + var d = {}; + if (o.defaults) { + d.id = ""; + d.price = 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.time = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.time = o.longs === String ? "0" : 0; + d.currency = ""; + d.exchange = ""; + d.quoteType = o.enums === String ? "NONE" : 0; + d.marketHours = o.enums === String ? "PRE_MARKET" : 0; + d.changePercent = 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.dayVolume = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.dayVolume = o.longs === String ? "0" : 0; + d.dayHigh = 0; + d.dayLow = 0; + d.change = 0; + d.shortName = ""; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.expireDate = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.expireDate = o.longs === String ? "0" : 0; + d.openPrice = 0; + d.previousClose = 0; + d.strikePrice = 0; + d.underlyingSymbol = ""; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.openInterest = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.openInterest = o.longs === String ? "0" : 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.optionsType = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.optionsType = o.longs === String ? "0" : 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.miniOption = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.miniOption = o.longs === String ? "0" : 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.lastSize = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.lastSize = o.longs === String ? "0" : 0; + d.bid = 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.bidSize = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.bidSize = o.longs === String ? "0" : 0; + d.ask = 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.askSize = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.askSize = o.longs === String ? "0" : 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.priceHint = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.priceHint = o.longs === String ? "0" : 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.vol_24hr = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.vol_24hr = o.longs === String ? "0" : 0; + if ($util.Long) { + var n = new $util.Long(0, 0, false); + d.volAllCurrencies = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; + } else + d.volAllCurrencies = o.longs === String ? "0" : 0; + d.fromcurrency = ""; + d.lastMarket = ""; + d.circulatingSupply = 0; + d.marketcap = 0; + } + if (m.id != null && m.hasOwnProperty("id")) { + d.id = m.id; + } + if (m.price != null && m.hasOwnProperty("price")) { + d.price = o.json && !isFinite(m.price) ? String(m.price) : m.price; + } + if (m.time != null && m.hasOwnProperty("time")) { + if (typeof m.time === "number") + d.time = o.longs === String ? String(m.time) : m.time; + else + d.time = o.longs === String ? $util.Long.prototype.toString.call(m.time) : o.longs === Number ? new $util.LongBits(m.time.low >>> 0, m.time.high >>> 0).toNumber() : m.time; + } + if (m.currency != null && m.hasOwnProperty("currency")) { + d.currency = m.currency; + } + if (m.exchange != null && m.hasOwnProperty("exchange")) { + d.exchange = m.exchange; + } + if (m.quoteType != null && m.hasOwnProperty("quoteType")) { + d.quoteType = o.enums === String ? $root.quotefeeder.QuoteType[m.quoteType] : m.quoteType; + } + if (m.marketHours != null && m.hasOwnProperty("marketHours")) { + d.marketHours = o.enums === String ? $root.quotefeeder.MarketHours[m.marketHours] : m.marketHours; + } + if (m.changePercent != null && m.hasOwnProperty("changePercent")) { + d.changePercent = o.json && !isFinite(m.changePercent) ? String(m.changePercent) : m.changePercent; + } + if (m.dayVolume != null && m.hasOwnProperty("dayVolume")) { + if (typeof m.dayVolume === "number") + d.dayVolume = o.longs === String ? String(m.dayVolume) : m.dayVolume; + else + d.dayVolume = o.longs === String ? $util.Long.prototype.toString.call(m.dayVolume) : o.longs === Number ? new $util.LongBits(m.dayVolume.low >>> 0, m.dayVolume.high >>> 0).toNumber() : m.dayVolume; + } + if (m.dayHigh != null && m.hasOwnProperty("dayHigh")) { + d.dayHigh = o.json && !isFinite(m.dayHigh) ? String(m.dayHigh) : m.dayHigh; + } + if (m.dayLow != null && m.hasOwnProperty("dayLow")) { + d.dayLow = o.json && !isFinite(m.dayLow) ? String(m.dayLow) : m.dayLow; + } + if (m.change != null && m.hasOwnProperty("change")) { + d.change = o.json && !isFinite(m.change) ? String(m.change) : m.change; + } + if (m.shortName != null && m.hasOwnProperty("shortName")) { + d.shortName = m.shortName; + } + if (m.expireDate != null && m.hasOwnProperty("expireDate")) { + if (typeof m.expireDate === "number") + d.expireDate = o.longs === String ? String(m.expireDate) : m.expireDate; + else + d.expireDate = o.longs === String ? $util.Long.prototype.toString.call(m.expireDate) : o.longs === Number ? new $util.LongBits(m.expireDate.low >>> 0, m.expireDate.high >>> 0).toNumber() : m.expireDate; + } + if (m.openPrice != null && m.hasOwnProperty("openPrice")) { + d.openPrice = o.json && !isFinite(m.openPrice) ? String(m.openPrice) : m.openPrice; + } + if (m.previousClose != null && m.hasOwnProperty("previousClose")) { + d.previousClose = o.json && !isFinite(m.previousClose) ? String(m.previousClose) : m.previousClose; + } + if (m.strikePrice != null && m.hasOwnProperty("strikePrice")) { + d.strikePrice = o.json && !isFinite(m.strikePrice) ? String(m.strikePrice) : m.strikePrice; + } + if (m.underlyingSymbol != null && m.hasOwnProperty("underlyingSymbol")) { + d.underlyingSymbol = m.underlyingSymbol; + } + if (m.openInterest != null && m.hasOwnProperty("openInterest")) { + if (typeof m.openInterest === "number") + d.openInterest = o.longs === String ? String(m.openInterest) : m.openInterest; + else + d.openInterest = o.longs === String ? $util.Long.prototype.toString.call(m.openInterest) : o.longs === Number ? new $util.LongBits(m.openInterest.low >>> 0, m.openInterest.high >>> 0).toNumber() : m.openInterest; + } + if (m.optionsType != null && m.hasOwnProperty("optionsType")) { + if (typeof m.optionsType === "number") + d.optionsType = o.longs === String ? String(m.optionsType) : m.optionsType; + else + d.optionsType = o.longs === String ? $util.Long.prototype.toString.call(m.optionsType) : o.longs === Number ? new $util.LongBits(m.optionsType.low >>> 0, m.optionsType.high >>> 0).toNumber() : m.optionsType; + } + if (m.miniOption != null && m.hasOwnProperty("miniOption")) { + if (typeof m.miniOption === "number") + d.miniOption = o.longs === String ? String(m.miniOption) : m.miniOption; + else + d.miniOption = o.longs === String ? $util.Long.prototype.toString.call(m.miniOption) : o.longs === Number ? new $util.LongBits(m.miniOption.low >>> 0, m.miniOption.high >>> 0).toNumber() : m.miniOption; + } + if (m.lastSize != null && m.hasOwnProperty("lastSize")) { + if (typeof m.lastSize === "number") + d.lastSize = o.longs === String ? String(m.lastSize) : m.lastSize; + else + d.lastSize = o.longs === String ? $util.Long.prototype.toString.call(m.lastSize) : o.longs === Number ? new $util.LongBits(m.lastSize.low >>> 0, m.lastSize.high >>> 0).toNumber() : m.lastSize; + } + if (m.bid != null && m.hasOwnProperty("bid")) { + d.bid = o.json && !isFinite(m.bid) ? String(m.bid) : m.bid; + } + if (m.bidSize != null && m.hasOwnProperty("bidSize")) { + if (typeof m.bidSize === "number") + d.bidSize = o.longs === String ? String(m.bidSize) : m.bidSize; + else + d.bidSize = o.longs === String ? $util.Long.prototype.toString.call(m.bidSize) : o.longs === Number ? new $util.LongBits(m.bidSize.low >>> 0, m.bidSize.high >>> 0).toNumber() : m.bidSize; + } + if (m.ask != null && m.hasOwnProperty("ask")) { + d.ask = o.json && !isFinite(m.ask) ? String(m.ask) : m.ask; + } + if (m.askSize != null && m.hasOwnProperty("askSize")) { + if (typeof m.askSize === "number") + d.askSize = o.longs === String ? String(m.askSize) : m.askSize; + else + d.askSize = o.longs === String ? $util.Long.prototype.toString.call(m.askSize) : o.longs === Number ? new $util.LongBits(m.askSize.low >>> 0, m.askSize.high >>> 0).toNumber() : m.askSize; + } + if (m.priceHint != null && m.hasOwnProperty("priceHint")) { + if (typeof m.priceHint === "number") + d.priceHint = o.longs === String ? String(m.priceHint) : m.priceHint; + else + d.priceHint = o.longs === String ? $util.Long.prototype.toString.call(m.priceHint) : o.longs === Number ? new $util.LongBits(m.priceHint.low >>> 0, m.priceHint.high >>> 0).toNumber() : m.priceHint; + } + if (m.vol_24hr != null && m.hasOwnProperty("vol_24hr")) { + if (typeof m.vol_24hr === "number") + d.vol_24hr = o.longs === String ? String(m.vol_24hr) : m.vol_24hr; + else + d.vol_24hr = o.longs === String ? $util.Long.prototype.toString.call(m.vol_24hr) : o.longs === Number ? new $util.LongBits(m.vol_24hr.low >>> 0, m.vol_24hr.high >>> 0).toNumber() : m.vol_24hr; + } + if (m.volAllCurrencies != null && m.hasOwnProperty("volAllCurrencies")) { + if (typeof m.volAllCurrencies === "number") + d.volAllCurrencies = o.longs === String ? String(m.volAllCurrencies) : m.volAllCurrencies; + else + d.volAllCurrencies = o.longs === String ? $util.Long.prototype.toString.call(m.volAllCurrencies) : o.longs === Number ? new $util.LongBits(m.volAllCurrencies.low >>> 0, m.volAllCurrencies.high >>> 0).toNumber() : m.volAllCurrencies; + } + if (m.fromcurrency != null && m.hasOwnProperty("fromcurrency")) { + d.fromcurrency = m.fromcurrency; + } + if (m.lastMarket != null && m.hasOwnProperty("lastMarket")) { + d.lastMarket = m.lastMarket; + } + if (m.circulatingSupply != null && m.hasOwnProperty("circulatingSupply")) { + d.circulatingSupply = o.json && !isFinite(m.circulatingSupply) ? String(m.circulatingSupply) : m.circulatingSupply; + } + if (m.marketcap != null && m.hasOwnProperty("marketcap")) { + d.marketcap = o.json && !isFinite(m.marketcap) ? String(m.marketcap) : m.marketcap; + } + return d; + }; + + PricingData.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return PricingData; + })(); + + quotefeeder.StaticData = (function() { + + function StaticData(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) + this[ks[i]] = p[ks[i]]; + } + + StaticData.prototype.id = ""; + StaticData.prototype.displayName = ""; + StaticData.prototype.currency = ""; + StaticData.prototype.exchange = ""; + StaticData.prototype.openPrice = 0; + StaticData.prototype.closePrice = 0; + StaticData.prototype.fiftytwoWkMovingAvgPrice = 0; + StaticData.prototype.twohundredDataMovingAvgPrice = 0; + + StaticData.decode = function decode(r, l) { + if (!(r instanceof $Reader)) + r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, m = new $root.quotefeeder.StaticData(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.id = r.string(); + break; + case 2: + m.displayName = r.string(); + break; + case 3: + m.currency = r.string(); + break; + case 4: + m.exchange = r.string(); + break; + case 5: + m.openPrice = r.float(); + break; + case 6: + m.closePrice = r.float(); + break; + case 7: + m.fiftytwoWkMovingAvgPrice = r.float(); + break; + case 8: + m.twohundredDataMovingAvgPrice = r.float(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + + StaticData.fromObject = function fromObject(d) { + if (d instanceof $root.quotefeeder.StaticData) + return d; + var m = new $root.quotefeeder.StaticData(); + if (d.id != null) { + m.id = String(d.id); + } + if (d.displayName != null) { + m.displayName = String(d.displayName); + } + if (d.currency != null) { + m.currency = String(d.currency); + } + if (d.exchange != null) { + m.exchange = String(d.exchange); + } + if (d.openPrice != null) { + m.openPrice = Number(d.openPrice); + } + if (d.closePrice != null) { + m.closePrice = Number(d.closePrice); + } + if (d.fiftytwoWkMovingAvgPrice != null) { + m.fiftytwoWkMovingAvgPrice = Number(d.fiftytwoWkMovingAvgPrice); + } + if (d.twohundredDataMovingAvgPrice != null) { + m.twohundredDataMovingAvgPrice = Number(d.twohundredDataMovingAvgPrice); + } + return m; + }; + + StaticData.toObject = function toObject(m, o) { + if (!o) + o = {}; + var d = {}; + if (o.defaults) { + d.id = ""; + d.displayName = ""; + d.currency = ""; + d.exchange = ""; + d.openPrice = 0; + d.closePrice = 0; + d.fiftytwoWkMovingAvgPrice = 0; + d.twohundredDataMovingAvgPrice = 0; + } + if (m.id != null && m.hasOwnProperty("id")) { + d.id = m.id; + } + if (m.displayName != null && m.hasOwnProperty("displayName")) { + d.displayName = m.displayName; + } + if (m.currency != null && m.hasOwnProperty("currency")) { + d.currency = m.currency; + } + if (m.exchange != null && m.hasOwnProperty("exchange")) { + d.exchange = m.exchange; + } + if (m.openPrice != null && m.hasOwnProperty("openPrice")) { + d.openPrice = o.json && !isFinite(m.openPrice) ? String(m.openPrice) : m.openPrice; + } + if (m.closePrice != null && m.hasOwnProperty("closePrice")) { + d.closePrice = o.json && !isFinite(m.closePrice) ? String(m.closePrice) : m.closePrice; + } + if (m.fiftytwoWkMovingAvgPrice != null && m.hasOwnProperty("fiftytwoWkMovingAvgPrice")) { + d.fiftytwoWkMovingAvgPrice = o.json && !isFinite(m.fiftytwoWkMovingAvgPrice) ? String(m.fiftytwoWkMovingAvgPrice) : m.fiftytwoWkMovingAvgPrice; + } + if (m.twohundredDataMovingAvgPrice != null && m.hasOwnProperty("twohundredDataMovingAvgPrice")) { + d.twohundredDataMovingAvgPrice = o.json && !isFinite(m.twohundredDataMovingAvgPrice) ? String(m.twohundredDataMovingAvgPrice) : m.twohundredDataMovingAvgPrice; + } + return d; + }; + + StaticData.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return StaticData; + })(); + + quotefeeder.PriceUpdate = (function() { + + function PriceUpdate(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) + this[ks[i]] = p[ks[i]]; + } + + PriceUpdate.prototype.pricingData = null; + + PriceUpdate.decode = function decode(r, l) { + if (!(r instanceof $Reader)) + r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, m = new $root.quotefeeder.PriceUpdate(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.pricingData = $root.quotefeeder.PricingData.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + + PriceUpdate.fromObject = function fromObject(d) { + if (d instanceof $root.quotefeeder.PriceUpdate) + return d; + var m = new $root.quotefeeder.PriceUpdate(); + if (d.pricingData != null) { + if (typeof d.pricingData !== "object") + throw TypeError(".quotefeeder.PriceUpdate.pricingData: object expected"); + m.pricingData = $root.quotefeeder.PricingData.fromObject(d.pricingData); + } + return m; + }; + + PriceUpdate.toObject = function toObject(m, o) { + if (!o) + o = {}; + var d = {}; + if (o.defaults) { + d.pricingData = null; + } + if (m.pricingData != null && m.hasOwnProperty("pricingData")) { + d.pricingData = $root.quotefeeder.PricingData.toObject(m.pricingData, o); + } + return d; + }; + + PriceUpdate.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return PriceUpdate; + })(); + + quotefeeder.StaticUpdate = (function() { + + function StaticUpdate(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) + this[ks[i]] = p[ks[i]]; + } + + StaticUpdate.prototype.staticData = null; + + StaticUpdate.decode = function decode(r, l) { + if (!(r instanceof $Reader)) + r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, m = new $root.quotefeeder.StaticUpdate(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.staticData = $root.quotefeeder.StaticData.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + + StaticUpdate.fromObject = function fromObject(d) { + if (d instanceof $root.quotefeeder.StaticUpdate) + return d; + var m = new $root.quotefeeder.StaticUpdate(); + if (d.staticData != null) { + if (typeof d.staticData !== "object") + throw TypeError(".quotefeeder.StaticUpdate.staticData: object expected"); + m.staticData = $root.quotefeeder.StaticData.fromObject(d.staticData); + } + return m; + }; + + StaticUpdate.toObject = function toObject(m, o) { + if (!o) + o = {}; + var d = {}; + if (o.defaults) { + d.staticData = null; + } + if (m.staticData != null && m.hasOwnProperty("staticData")) { + d.staticData = $root.quotefeeder.StaticData.toObject(m.staticData, o); + } + return d; + }; + + StaticUpdate.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return StaticUpdate; + })(); + + return quotefeeder; + })(); + + return $root; +})(protobuf); diff --git a/third_party/rust/jsparagus-parser/benches/parser.rs b/third_party/rust/jsparagus-parser/benches/parser.rs new file mode 100644 index 0000000000..9479a2dbcf --- /dev/null +++ b/third_party/rust/jsparagus-parser/benches/parser.rs @@ -0,0 +1,40 @@ +use criterion::criterion_group; +use criterion::criterion_main; +use criterion::Criterion; +use std::cell::RefCell; +use std::collections::HashMap; +use std::rc::Rc; + +use bumpalo::Bump; +use jsparagus_ast::source_atom_set::SourceAtomSet; +use jsparagus_ast::source_slice_list::SourceSliceList; +use jsparagus_parser::{parse_script, ParseOptions}; + +fn parser_bench(c: &mut Criterion) { + let tests = &["simple", "__finStreamer-proto"]; + let mut programs = HashMap::new(); + + programs.insert("simple", include_str!("./simple.js")); + programs.insert( + "__finStreamer-proto", + include_str!("./__finStreamer-proto.js"), + ); + + c.bench_function_over_inputs( + "parser_bench", + move |b, &name| { + let program = &programs[name]; + b.iter(|| { + let allocator = &Bump::new(); + let options = ParseOptions::new(); + let atoms = Rc::new(RefCell::new(SourceAtomSet::new())); + let slices = Rc::new(RefCell::new(SourceSliceList::new())); + let _ = parse_script(allocator, program, &options, atoms, slices); + }); + }, + tests, + ); +} + +criterion_group!(benches, parser_bench); +criterion_main!(benches); diff --git a/third_party/rust/jsparagus-parser/benches/simple.js b/third_party/rust/jsparagus-parser/benches/simple.js new file mode 100644 index 0000000000..1c2b4c384a --- /dev/null +++ b/third_party/rust/jsparagus-parser/benches/simple.js @@ -0,0 +1,103 @@ +// Artificial testcase with 100 simple Fluent Messages + +var key0 = "Value 0"; +var key1 = "Value 1"; +var key2 = "Value 2"; +var key3 = "Value 3"; +var key4 = "Value 4"; +var key5 = "Value 5"; +var key6 = "Value 6"; +var key7 = "Value 7"; +var key8 = "Value 8"; +var key9 = "Value 9"; +var key10 = "Value 10"; +var key11 = "Value 11"; +var key12 = "Value 12"; +var key13 = "Value 13"; +var key14 = "Value 14"; +var key15 = "Value 15"; +var key16 = "Value 16"; +var key17 = "Value 17"; +var key18 = "Value 18"; +var key19 = "Value 19"; +var key20 = "Value 20"; +var key21 = "Value 21"; +var key22 = "Value 22"; +var key23 = "Value 23"; +var key24 = "Value 24"; +var key25 = "Value 25"; +var key26 = "Value 26"; +var key27 = "Value 27"; +var key28 = "Value 28"; +var key29 = "Value 29"; +var key30 = "Value 30"; +var key31 = "Value 31"; +var key32 = "Value 32"; +var key33 = "Value 33"; +var key34 = "Value 34"; +var key35 = "Value 35"; +var key36 = "Value 36"; +var key37 = "Value 37"; +var key38 = "Value 38"; +var key39 = "Value 39"; +var key40 = "Value 40"; +var key41 = "Value 41"; +var key42 = "Value 42"; +var key43 = "Value 43"; +var key44 = "Value 44"; +var key45 = "Value 45"; +var key46 = "Value 46"; +var key47 = "Value 47"; +var key48 = "Value 48"; +var key49 = "Value 49"; +var key50 = "Value 50"; +var key51 = "Value 51"; +var key52 = "Value 52"; +var key53 = "Value 53"; +var key54 = "Value 54"; +var key55 = "Value 55"; +var key56 = "Value 56"; +var key57 = "Value 57"; +var key58 = "Value 58"; +var key59 = "Value 59"; +var key60 = "Value 60"; +var key61 = "Value 61"; +var key62 = "Value 62"; +var key63 = "Value 63"; +var key64 = "Value 64"; +var key65 = "Value 65"; +var key66 = "Value 66"; +var key67 = "Value 67"; +var key68 = "Value 68"; +var key69 = "Value 69"; +var key70 = "Value 70"; +var key71 = "Value 71"; +var key72 = "Value 72"; +var key73 = "Value 73"; +var key74 = "Value 74"; +var key75 = "Value 75"; +var key76 = "Value 76"; +var key77 = "Value 77"; +var key78 = "Value 78"; +var key79 = "Value 79"; +var key80 = "Value 80"; +var key81 = "Value 81"; +var key82 = "Value 82"; +var key83 = "Value 83"; +var key84 = "Value 84"; +var key85 = "Value 85"; +var key86 = "Value 86"; +var key87 = "Value 87"; +var key88 = "Value 88"; +var key89 = "Value 89"; +var key90 = "Value 90"; +var key91 = "Value 91"; +var key92 = "Value 92"; +var key93 = "Value 93"; +var key94 = "Value 94"; +var key95 = "Value 95"; +var key96 = "Value 96"; +var key97 = "Value 97"; +var key98 = "Value 98"; +var key99 = "Value 99"; + diff --git a/third_party/rust/jsparagus-parser/src/lexer.rs b/third_party/rust/jsparagus-parser/src/lexer.rs new file mode 100644 index 0000000000..109558c5c2 --- /dev/null +++ b/third_party/rust/jsparagus-parser/src/lexer.rs @@ -0,0 +1,2325 @@ +//! JavaScript lexer. + +use crate::numeric_value::{parse_float, parse_int, NumericLiteralBase}; +use crate::parser::Parser; +use crate::unicode::{is_id_continue, is_id_start}; +use ast::arena; +use ast::source_atom_set::{CommonSourceAtomSetIndices, SourceAtomSet}; +use ast::source_slice_list::SourceSliceList; +use ast::SourceLocation; +use bumpalo::{collections::String, Bump}; +use generated_parser::{ParseError, Result, TerminalId, Token, TokenValue}; +use std::cell::RefCell; +use std::convert::TryFrom; +use std::rc::Rc; +use std::str::Chars; + +pub struct Lexer<'alloc> { + allocator: &'alloc Bump, + + /// Next token to be returned. + token: arena::Box<'alloc, Token>, + + /// Length of the input text, in UTF-8 bytes. + source_length: usize, + + /// Iterator over the remaining not-yet-parsed input. + chars: Chars<'alloc>, + + atoms: Rc>>, + + slices: Rc>>, +} + +enum NumericResult { + Int { + base: NumericLiteralBase, + }, + Float, + BigInt { + #[allow(dead_code)] + base: NumericLiteralBase, + }, +} + +impl<'alloc> Lexer<'alloc> { + pub fn new( + allocator: &'alloc Bump, + chars: Chars<'alloc>, + atoms: Rc>>, + slices: Rc>>, + ) -> Lexer<'alloc> { + Self::with_offset(allocator, chars, 0, atoms, slices) + } + + /// Create a lexer for a part of a JS script or module. `offset` is the + /// total length of all previous parts, in bytes; source locations for + /// tokens created by the new lexer start counting from this number. + pub fn with_offset( + allocator: &'alloc Bump, + chars: Chars<'alloc>, + offset: usize, + atoms: Rc>>, + slices: Rc>>, + ) -> Lexer<'alloc> { + let source_length = offset + chars.as_str().len(); + let mut token = arena::alloc(allocator, new_token()); + token.is_on_new_line = true; + Lexer { + allocator, + token, + source_length, + chars, + atoms, + slices, + } + } + + fn is_looking_at(&self, s: &str) -> bool { + self.chars.as_str().starts_with(s) + } + + pub fn offset(&self) -> usize { + self.source_length - self.chars.as_str().len() + } + + fn peek(&self) -> Option { + self.chars.as_str().chars().next() + } + + fn double_peek(&self) -> Option { + let mut chars = self.chars.as_str().chars(); + chars.next(); + chars.next() + } + + fn set_result( + &mut self, + terminal_id: TerminalId, + loc: SourceLocation, + value: TokenValue, + ) -> Result<'alloc, ()> { + self.token.terminal_id = terminal_id; + self.token.loc = loc; + self.token.value = value; + Ok(()) + } + + #[inline] + pub fn next<'parser>( + &mut self, + parser: &Parser<'parser>, + ) -> Result<'alloc, arena::Box<'alloc, Token>> { + let mut next_token = arena::alloc_with(self.allocator, || new_token()); + self.advance_impl(parser)?; + std::mem::swap(&mut self.token, &mut next_token); + Ok(next_token) + } + + fn unexpected_err(&mut self) -> ParseError<'alloc> { + if let Some(ch) = self.peek() { + ParseError::IllegalCharacter(ch) + } else { + ParseError::UnexpectedEnd + } + } +} + +/// Returns an empty token which is meant as a place holder to be mutated later. +fn new_token() -> Token { + Token::basic_token(TerminalId::End, SourceLocation::default()) +} + +// ---------------------------------------------------------------------------- +// 11.1 Unicode Format-Control Characters + +/// U+200C ZERO WIDTH NON-JOINER, abbreviated in the spec as . +/// Specially permitted in identifiers. +const ZWNJ: char = '\u{200c}'; + +/// U+200D ZERO WIDTH JOINER, abbreviated as . +/// Specially permitted in identifiers. +const ZWJ: char = '\u{200d}'; + +/// U+FEFF ZERO WIDTH NO-BREAK SPACE, abbreviated . +/// Considered a whitespace character in JS. +const ZWNBSP: char = '\u{feff}'; + +// ---------------------------------------------------------------------------- +// 11.2 White Space + +/// U+0009 CHARACTER TABULATION, abbreviated . +const TAB: char = '\u{9}'; + +/// U+000B VERTICAL TAB, abbreviated . +const VT: char = '\u{b}'; + +/// U+000C FORM FEED, abbreviated . +const FF: char = '\u{c}'; + +/// U+0020 SPACE, abbreviated . +const SP: char = '\u{20}'; + +/// U+00A0 NON-BREAKING SPACE, abbreviated . +const NBSP: char = '\u{a0}'; + +// ---------------------------------------------------------------------------- +// 11.3 Line Terminators + +/// U+000A LINE FEED, abbreviated in the spec as . +const LF: char = '\u{a}'; + +/// U+000D CARRIAGE RETURN, abbreviated in the spec as . +const CR: char = '\u{d}'; + +/// U+2028 LINE SEPARATOR, abbreviated . +const LS: char = '\u{2028}'; + +/// U+2029 PARAGRAPH SEPARATOR, abbreviated . +const PS: char = '\u{2029}'; + +// ---------------------------------------------------------------------------- +// 11.4 Comments +// +// Comment:: +// MultiLineComment +// SingleLineComment + +impl<'alloc> Lexer<'alloc> { + /// Skip a *MultiLineComment*. + /// + /// ```text + /// MultiLineComment :: + /// `/*` MultiLineCommentChars? `*/` + /// + /// MultiLineCommentChars :: + /// MultiLineNotAsteriskChar MultiLineCommentChars? + /// `*` PostAsteriskCommentChars? + /// + /// PostAsteriskCommentChars :: + /// MultiLineNotForwardSlashOrAsteriskChar MultiLineCommentChars? + /// `*` PostAsteriskCommentChars? + /// + /// MultiLineNotAsteriskChar :: + /// SourceCharacter but not `*` + /// + /// MultiLineNotForwardSlashOrAsteriskChar :: + /// SourceCharacter but not one of `/` or `*` + /// ``` + /// + /// (B.1.3 splits MultiLineComment into two nonterminals: MultiLineComment + /// and SingleLineDelimitedComment. The point of that is to help specify + /// that a SingleLineHTMLCloseComment must occur at the start of a line. We + /// use `is_on_new_line` for that.) + /// + fn skip_multi_line_comment(&mut self, builder: &mut AutoCow<'alloc>) -> Result<'alloc, ()> { + while let Some(ch) = self.chars.next() { + match ch { + '*' if self.peek() == Some('/') => { + self.chars.next(); + *builder = AutoCow::new(&self); + return Ok(()); + } + CR | LF | PS | LS => { + self.token.is_on_new_line = true; + } + _ => {} + } + } + Err(ParseError::UnterminatedMultiLineComment.into()) + } + + /// Skip a *SingleLineComment* and the following *LineTerminatorSequence*, + /// if any. + /// + /// ```text + /// SingleLineComment :: + /// `//` SingleLineCommentChars? + /// + /// SingleLineCommentChars :: + /// SingleLineCommentChar SingleLineCommentChars? + /// + /// SingleLineCommentChar :: + /// SourceCharacter but not LineTerminator + /// ``` + fn skip_single_line_comment(&mut self, builder: &mut AutoCow<'alloc>) { + while let Some(ch) = self.chars.next() { + match ch { + CR | LF | LS | PS => break, + _ => continue, + } + } + *builder = AutoCow::new(&self); + self.token.is_on_new_line = true; + } +} + +// ---------------------------------------------------------------------------- +// 11.6 Names and Keywords + +/// True if `c` is a one-character *IdentifierStart*. +/// +/// ```text +/// IdentifierStart :: +/// UnicodeIDStart +/// `$` +/// `_` +/// `\` UnicodeEscapeSequence +/// +/// UnicodeIDStart :: +/// > any Unicode code point with the Unicode property "ID_Start" +/// ``` +fn is_identifier_start(c: char) -> bool { + // Escaped case is handled separately. + if c.is_ascii() { + c == '$' || c == '_' || c.is_ascii_alphabetic() + } else { + is_id_start(c) + } +} + +/// True if `c` is a one-character *IdentifierPart*. +/// +/// ```text +/// IdentifierPart :: +/// UnicodeIDContinue +/// `$` +/// `\` UnicodeEscapeSequence +/// +/// +/// +/// UnicodeIDContinue :: +/// > any Unicode code point with the Unicode property "ID_Continue" +/// ``` +fn is_identifier_part(c: char) -> bool { + // Escaped case is handled separately. + if c.is_ascii() { + c == '$' || c == '_' || c.is_ascii_alphanumeric() + } else { + is_id_continue(c) || c == ZWNJ || c == ZWJ + } +} + +impl<'alloc> Lexer<'alloc> { + /// Scan the rest of an IdentifierName, having already parsed the initial + /// IdentifierStart and stored it in `builder`. + /// + /// On success, this returns `Ok((has_escapes, str))`, where `has_escapes` + /// is true if the identifier contained any UnicodeEscapeSequences, and + /// `str` is the un-escaped IdentifierName, including the IdentifierStart, + /// on success. + /// + /// ```text + /// IdentifierName :: + /// IdentifierStart + /// IdentifierName IdentifierPart + /// ``` + fn identifier_name_tail( + &mut self, + mut builder: AutoCow<'alloc>, + ) -> Result<'alloc, (bool, &'alloc str)> { + while let Some(ch) = self.peek() { + if !is_identifier_part(ch) { + if ch == '\\' { + self.chars.next(); + builder.force_allocation_without_current_ascii_char(&self); + + let value = self.unicode_escape_sequence_after_backslash()?; + if !is_identifier_part(value) { + return Err(ParseError::InvalidEscapeSequence.into()); + } + + builder.push_different(value); + continue; + } + + break; + } + self.chars.next(); + builder.push_matching(ch); + } + let has_different = builder.has_different(); + Ok((has_different, builder.finish(&self))) + } + + fn identifier_name(&mut self, mut builder: AutoCow<'alloc>) -> Result<'alloc, &'alloc str> { + match self.chars.next() { + None => { + return Err(ParseError::UnexpectedEnd.into()); + } + Some(c) => { + match c { + '$' | '_' | 'a'..='z' | 'A'..='Z' => { + builder.push_matching(c); + } + + '\\' => { + builder.force_allocation_without_current_ascii_char(&self); + + let value = self.unicode_escape_sequence_after_backslash()?; + if !is_identifier_start(value) { + return Err(ParseError::IllegalCharacter(value).into()); + } + builder.push_different(value); + } + + other if is_identifier_start(other) => { + builder.push_matching(other); + } + + other => { + return Err(ParseError::IllegalCharacter(other).into()); + } + } + self.identifier_name_tail(builder) + .map(|(_has_escapes, name)| name) + } + } + } + + /// Finish scanning an *IdentifierName* or keyword, having already scanned + /// the *IdentifierStart* and pushed it to `builder`. + /// + /// `start` is the offset of the *IdentifierStart*. + /// + /// The lexer doesn't know the syntactic context, so it always identifies + /// possible keywords. It's up to the parser to understand that, for + /// example, `TerminalId::If` is not a keyword when it's used as a property + /// or method name. + /// + /// If the source string contains no escape and it matches to possible + /// keywords (including contextual keywords), the result is corresponding + /// `TerminalId`. For example, if the source string is "yield", the result + /// is `TerminalId::Yield`. + /// + /// If the source string contains no escape sequence and also it doesn't + /// match to any possible keywords, the result is `TerminalId::Name`. + /// + /// If the source string contains at least one escape sequence, + /// the result is always `TerminalId::NameWithEscape`, regardless of the + /// StringValue of it. For example, if the source string is "\u{79}ield", + /// the result is `TerminalId::NameWithEscape`, and the StringValue is + /// "yield". + fn identifier_tail(&mut self, start: usize, builder: AutoCow<'alloc>) -> Result<'alloc, ()> { + let (has_different, text) = self.identifier_name_tail(builder)?; + + // https://tc39.es/ecma262/#sec-keywords-and-reserved-words + // + // keywords in the grammar match literal sequences of specific + // SourceCharacter elements. A code point in a keyword cannot be + // expressed by a `\` UnicodeEscapeSequence. + let (id, value) = if has_different { + // Always return `NameWithEscape`. + // + // Error check against reserved word should be handled in the + // consumer. + (TerminalId::NameWithEscape, self.string_to_token_value(text)) + } else { + match &text as &str { + "as" => ( + TerminalId::As, + TokenValue::Atom(CommonSourceAtomSetIndices::as_()), + ), + "async" => { + /* + ( + TerminalId::Async, + TokenValue::Atom(CommonSourceAtomSetIndices::async_()), + ), + */ + return Err(ParseError::NotImplemented( + "async cannot be handled in parser due to multiple lookahead", + ) + .into()); + } + "await" => { + /* + ( + TerminalId::Await, + TokenValue::Atom(CommonSourceAtomSetIndices::await_()), + ), + */ + return Err( + ParseError::NotImplemented("await cannot be handled in parser").into(), + ); + } + "break" => ( + TerminalId::Break, + TokenValue::Atom(CommonSourceAtomSetIndices::break_()), + ), + "case" => ( + TerminalId::Case, + TokenValue::Atom(CommonSourceAtomSetIndices::case()), + ), + "catch" => ( + TerminalId::Catch, + TokenValue::Atom(CommonSourceAtomSetIndices::catch()), + ), + "class" => ( + TerminalId::Class, + TokenValue::Atom(CommonSourceAtomSetIndices::class()), + ), + "const" => ( + TerminalId::Const, + TokenValue::Atom(CommonSourceAtomSetIndices::const_()), + ), + "continue" => ( + TerminalId::Continue, + TokenValue::Atom(CommonSourceAtomSetIndices::continue_()), + ), + "debugger" => ( + TerminalId::Debugger, + TokenValue::Atom(CommonSourceAtomSetIndices::debugger()), + ), + "default" => ( + TerminalId::Default, + TokenValue::Atom(CommonSourceAtomSetIndices::default()), + ), + "delete" => ( + TerminalId::Delete, + TokenValue::Atom(CommonSourceAtomSetIndices::delete()), + ), + "do" => ( + TerminalId::Do, + TokenValue::Atom(CommonSourceAtomSetIndices::do_()), + ), + "else" => ( + TerminalId::Else, + TokenValue::Atom(CommonSourceAtomSetIndices::else_()), + ), + "enum" => ( + TerminalId::Enum, + TokenValue::Atom(CommonSourceAtomSetIndices::enum_()), + ), + "export" => ( + TerminalId::Export, + TokenValue::Atom(CommonSourceAtomSetIndices::export()), + ), + "extends" => ( + TerminalId::Extends, + TokenValue::Atom(CommonSourceAtomSetIndices::extends()), + ), + "finally" => ( + TerminalId::Finally, + TokenValue::Atom(CommonSourceAtomSetIndices::finally()), + ), + "for" => ( + TerminalId::For, + TokenValue::Atom(CommonSourceAtomSetIndices::for_()), + ), + "from" => ( + TerminalId::From, + TokenValue::Atom(CommonSourceAtomSetIndices::from()), + ), + "function" => ( + TerminalId::Function, + TokenValue::Atom(CommonSourceAtomSetIndices::function()), + ), + "get" => ( + TerminalId::Get, + TokenValue::Atom(CommonSourceAtomSetIndices::get()), + ), + "if" => ( + TerminalId::If, + TokenValue::Atom(CommonSourceAtomSetIndices::if_()), + ), + "implements" => ( + TerminalId::Implements, + TokenValue::Atom(CommonSourceAtomSetIndices::implements()), + ), + "import" => ( + TerminalId::Import, + TokenValue::Atom(CommonSourceAtomSetIndices::import()), + ), + "in" => ( + TerminalId::In, + TokenValue::Atom(CommonSourceAtomSetIndices::in_()), + ), + "instanceof" => ( + TerminalId::Instanceof, + TokenValue::Atom(CommonSourceAtomSetIndices::instanceof()), + ), + "interface" => ( + TerminalId::Interface, + TokenValue::Atom(CommonSourceAtomSetIndices::interface()), + ), + "let" => { + /* + ( + TerminalId::Let, + TokenValue::Atom(CommonSourceAtomSetIndices::let_()), + ), + */ + return Err(ParseError::NotImplemented( + "let cannot be handled in parser due to multiple lookahead", + ) + .into()); + } + "new" => ( + TerminalId::New, + TokenValue::Atom(CommonSourceAtomSetIndices::new_()), + ), + "of" => ( + TerminalId::Of, + TokenValue::Atom(CommonSourceAtomSetIndices::of()), + ), + "package" => ( + TerminalId::Package, + TokenValue::Atom(CommonSourceAtomSetIndices::package()), + ), + "private" => ( + TerminalId::Private, + TokenValue::Atom(CommonSourceAtomSetIndices::private()), + ), + "protected" => ( + TerminalId::Protected, + TokenValue::Atom(CommonSourceAtomSetIndices::protected()), + ), + "public" => ( + TerminalId::Public, + TokenValue::Atom(CommonSourceAtomSetIndices::public()), + ), + "return" => ( + TerminalId::Return, + TokenValue::Atom(CommonSourceAtomSetIndices::return_()), + ), + "set" => ( + TerminalId::Set, + TokenValue::Atom(CommonSourceAtomSetIndices::set()), + ), + "static" => ( + TerminalId::Static, + TokenValue::Atom(CommonSourceAtomSetIndices::static_()), + ), + "super" => ( + TerminalId::Super, + TokenValue::Atom(CommonSourceAtomSetIndices::super_()), + ), + "switch" => ( + TerminalId::Switch, + TokenValue::Atom(CommonSourceAtomSetIndices::switch()), + ), + "target" => ( + TerminalId::Target, + TokenValue::Atom(CommonSourceAtomSetIndices::target()), + ), + "this" => ( + TerminalId::This, + TokenValue::Atom(CommonSourceAtomSetIndices::this()), + ), + "throw" => ( + TerminalId::Throw, + TokenValue::Atom(CommonSourceAtomSetIndices::throw()), + ), + "try" => ( + TerminalId::Try, + TokenValue::Atom(CommonSourceAtomSetIndices::try_()), + ), + "typeof" => ( + TerminalId::Typeof, + TokenValue::Atom(CommonSourceAtomSetIndices::typeof_()), + ), + "var" => ( + TerminalId::Var, + TokenValue::Atom(CommonSourceAtomSetIndices::var()), + ), + "void" => ( + TerminalId::Void, + TokenValue::Atom(CommonSourceAtomSetIndices::void()), + ), + "while" => ( + TerminalId::While, + TokenValue::Atom(CommonSourceAtomSetIndices::while_()), + ), + "with" => ( + TerminalId::With, + TokenValue::Atom(CommonSourceAtomSetIndices::with()), + ), + "yield" => { + /* + ( + TerminalId::Yield, + TokenValue::Atom(CommonSourceAtomSetIndices::yield_()), + ), + */ + return Err( + ParseError::NotImplemented("yield cannot be handled in parser").into(), + ); + } + "null" => ( + TerminalId::NullLiteral, + TokenValue::Atom(CommonSourceAtomSetIndices::null()), + ), + "true" => ( + TerminalId::BooleanLiteral, + TokenValue::Atom(CommonSourceAtomSetIndices::true_()), + ), + "false" => ( + TerminalId::BooleanLiteral, + TokenValue::Atom(CommonSourceAtomSetIndices::false_()), + ), + _ => (TerminalId::Name, self.string_to_token_value(text)), + } + }; + + self.set_result(id, SourceLocation::new(start, self.offset()), value) + } + + /// ```text + /// PrivateIdentifier:: + /// `#` IdentifierName + /// ``` + fn private_identifier(&mut self, start: usize, builder: AutoCow<'alloc>) -> Result<'alloc, ()> { + let name = self.identifier_name(builder)?; + let value = self.string_to_token_value(name); + self.set_result( + TerminalId::PrivateIdentifier, + SourceLocation::new(start, self.offset()), + value, + ) + } + + /// ```text + /// UnicodeEscapeSequence:: + /// `u` Hex4Digits + /// `u{` CodePoint `}` + /// ``` + fn unicode_escape_sequence_after_backslash(&mut self) -> Result<'alloc, char> { + match self.chars.next() { + Some('u') => {} + _ => { + return Err(ParseError::InvalidEscapeSequence.into()); + } + } + self.unicode_escape_sequence_after_backslash_and_u() + } + + fn unicode_escape_sequence_after_backslash_and_u(&mut self) -> Result<'alloc, char> { + let value = match self.peek() { + Some('{') => { + self.chars.next(); + + let value = self.code_point()?; + match self.chars.next() { + Some('}') => {} + _ => { + return Err(ParseError::InvalidEscapeSequence.into()); + } + } + value + } + _ => self.hex_4_digits()?, + }; + + Ok(value) + } +} + +impl<'alloc> Lexer<'alloc> { + // ------------------------------------------------------------------------ + // 11.8.3 Numeric Literals + + /// Advance over decimal digits in the input. + /// + /// ```text + /// NumericLiteralSeparator:: + /// `_` + /// + /// DecimalDigits :: + /// DecimalDigit + /// DecimalDigits NumericLiteralSeparator? DecimalDigit + /// + /// DecimalDigit :: one of + /// `0` `1` `2` `3` `4` `5` `6` `7` `8` `9` + /// ``` + fn decimal_digits(&mut self) -> Result<'alloc, ()> { + if let Some('0'..='9') = self.peek() { + self.chars.next(); + } else { + return Err(self.unexpected_err().into()); + } + + self.decimal_digits_after_first_digit()?; + Ok(()) + } + + fn optional_decimal_digits(&mut self) -> Result<'alloc, ()> { + if let Some('0'..='9') = self.peek() { + self.chars.next(); + } else { + return Ok(()); + } + + self.decimal_digits_after_first_digit()?; + Ok(()) + } + + fn decimal_digits_after_first_digit(&mut self) -> Result<'alloc, ()> { + while let Some(next) = self.peek() { + match next { + '_' => { + self.chars.next(); + + if let Some('0'..='9') = self.peek() { + self.chars.next(); + } else { + return Err(self.unexpected_err().into()); + } + } + '0'..='9' => { + self.chars.next(); + } + _ => break, + } + } + Ok(()) + } + + /// Skip an ExponentPart, if present. + /// + /// ```text + /// ExponentPart :: + /// ExponentIndicator SignedInteger + /// + /// ExponentIndicator :: one of + /// `e` `E` + /// + /// SignedInteger :: + /// DecimalDigits + /// `+` DecimalDigits + /// `-` DecimalDigits + /// ``` + fn optional_exponent(&mut self) -> Result<'alloc, bool> { + if let Some('e') | Some('E') = self.peek() { + self.chars.next(); + self.decimal_exponent()?; + return Ok(true); + } + + Ok(false) + } + + fn decimal_exponent(&mut self) -> Result<'alloc, ()> { + if let Some('+') | Some('-') = self.peek() { + self.chars.next(); + } + + self.decimal_digits()?; + + Ok(()) + } + + /// ```text + /// HexDigit :: one of + /// `0` `1` `2` `3` `4` `5` `6` `7` `8` `9` `a` `b` `c` `d` `e` `f` `A` `B` `C` `D` `E` `F` + /// ``` + fn hex_digit(&mut self) -> Result<'alloc, u32> { + match self.chars.next() { + None => Err(ParseError::InvalidEscapeSequence.into()), + Some(c @ '0'..='9') => Ok(c as u32 - '0' as u32), + Some(c @ 'a'..='f') => Ok(10 + (c as u32 - 'a' as u32)), + Some(c @ 'A'..='F') => Ok(10 + (c as u32 - 'A' as u32)), + Some(other) => Err(ParseError::IllegalCharacter(other).into()), + } + } + + fn code_point_to_char(value: u32) -> Result<'alloc, char> { + if 0xd800 <= value && value <= 0xdfff { + Err(ParseError::NotImplemented("unicode escape sequences (surrogates)").into()) + } else { + char::try_from(value).map_err(|_| ParseError::InvalidEscapeSequence.into()) + } + } + + /// ```text + /// Hex4Digits :: + /// HexDigit HexDigit HexDigit HexDigit + /// ``` + fn hex_4_digits(&mut self) -> Result<'alloc, char> { + let mut value = 0; + for _ in 0..4 { + value = (value << 4) | self.hex_digit()?; + } + Self::code_point_to_char(value) + } + + /// ```text + /// CodePoint :: + /// HexDigits but only if MV of HexDigits ≤ 0x10FFFF + /// + /// HexDigits :: + /// HexDigit + /// HexDigits HexDigit + /// ``` + fn code_point(&mut self) -> Result<'alloc, char> { + let mut value = self.hex_digit()?; + + loop { + let next = match self.peek() { + None => { + return Err(ParseError::InvalidEscapeSequence.into()); + } + Some(c @ '0'..='9') => c as u32 - '0' as u32, + Some(c @ 'a'..='f') => 10 + (c as u32 - 'a' as u32), + Some(c @ 'A'..='F') => 10 + (c as u32 - 'A' as u32), + Some(_) => break, + }; + self.chars.next(); + value = (value << 4) | next; + if value > 0x10FFFF { + return Err(ParseError::InvalidEscapeSequence.into()); + } + } + + Self::code_point_to_char(value) + } + + /// Scan a NumericLiteral (defined in 11.8.3, extended by B.1.1) after + /// having already consumed the first character, which was `0`. + /// + /// ```text + /// NumericLiteral :: + /// DecimalLiteral + /// DecimalBigIntegerLiteral + /// NonDecimalIntegerLiteral + /// NonDecimalIntegerLiteral BigIntLiteralSuffix + /// + /// DecimalBigIntegerLiteral :: + /// `0` BigIntLiteralSuffix + /// NonZeroDigit DecimalDigits? BigIntLiteralSuffix + /// + /// NonDecimalIntegerLiteral :: + /// BinaryIntegerLiteral + /// OctalIntegerLiteral + /// HexIntegerLiteral + /// + /// BigIntLiteralSuffix :: + /// `n` + /// ``` + fn numeric_literal_starting_with_zero(&mut self) -> Result<'alloc, NumericResult> { + let mut base = NumericLiteralBase::Decimal; + match self.peek() { + // BinaryIntegerLiteral :: + // `0b` BinaryDigits + // `0B` BinaryDigits + // + // BinaryDigits :: + // BinaryDigit + // BinaryDigits NumericLiteralSeparator? BinaryDigit + // + // BinaryDigit :: one of + // `0` `1` + Some('b') | Some('B') => { + self.chars.next(); + + base = NumericLiteralBase::Binary; + + if let Some('0'..='1') = self.peek() { + self.chars.next(); + } else { + return Err(self.unexpected_err().into()); + } + + while let Some(next) = self.peek() { + match next { + '_' => { + self.chars.next(); + + if let Some('0'..='1') = self.peek() { + self.chars.next(); + } else { + return Err(self.unexpected_err().into()); + } + } + '0'..='1' => { + self.chars.next(); + } + _ => break, + } + } + + if let Some('n') = self.peek() { + self.chars.next(); + self.check_after_numeric_literal()?; + return Ok(NumericResult::BigInt { base }); + } + } + + // OctalIntegerLiteral :: + // `0o` OctalDigits + // `0O` OctalDigits + // + // OctalDigits :: + // OctalDigit + // OctalDigits NumericLiteralSeparator? OctalDigit + // + // OctalDigit :: one of + // `0` `1` `2` `3` `4` `5` `6` `7` + // + Some('o') | Some('O') => { + self.chars.next(); + + base = NumericLiteralBase::Octal; + + if let Some('0'..='7') = self.peek() { + self.chars.next(); + } else { + return Err(self.unexpected_err().into()); + } + + while let Some(next) = self.peek() { + match next { + '_' => { + self.chars.next(); + + if let Some('0'..='7') = self.peek() { + self.chars.next(); + } else { + return Err(self.unexpected_err().into()); + } + } + '0'..='7' => { + self.chars.next(); + } + _ => break, + } + } + + if let Some('n') = self.peek() { + self.chars.next(); + self.check_after_numeric_literal()?; + return Ok(NumericResult::BigInt { base }); + } + } + + // HexIntegerLiteral :: + // `0x` HexDigits + // `0X` HexDigits + // + // HexDigits :: + // HexDigit + // HexDigits NumericLiteralSeparator? HexDigit + // + // HexDigit :: one of + // `0` `1` `2` `3` `4` `5` `6` `7` `8` `9` `a` `b` `c` `d` `e` `f` `A` `B` `C` `D` `E` `F` + Some('x') | Some('X') => { + self.chars.next(); + + base = NumericLiteralBase::Hex; + + if let Some('0'..='9') | Some('a'..='f') | Some('A'..='F') = self.peek() { + self.chars.next(); + } else { + return Err(self.unexpected_err().into()); + } + + while let Some(next) = self.peek() { + match next { + '_' => { + self.chars.next(); + + if let Some('0'..='9') | Some('a'..='f') | Some('A'..='F') = self.peek() + { + self.chars.next(); + } else { + return Err(self.unexpected_err().into()); + } + } + '0'..='9' | 'a'..='f' | 'A'..='F' => { + self.chars.next(); + } + _ => break, + } + } + + if let Some('n') = self.peek() { + self.chars.next(); + self.check_after_numeric_literal()?; + return Ok(NumericResult::BigInt { base }); + } + } + + Some('.') => { + self.chars.next(); + return self.decimal_literal_after_decimal_point_after_digits(); + } + + Some('e') | Some('E') => { + self.chars.next(); + self.decimal_exponent()?; + return Ok(NumericResult::Float); + } + + Some('n') => { + self.chars.next(); + self.check_after_numeric_literal()?; + return Ok(NumericResult::BigInt { base }); + } + + Some('0'..='9') => { + // This is almost always the token `0` in practice. + // + // In nonstrict code, as a legacy feature, other numbers + // starting with `0` are allowed. If /0[0-7]+/ matches, it's a + // LegacyOctalIntegerLiteral; but if we see an `8` or `9` in + // the number, it's decimal. Decimal numbers can have a decimal + // point and/or ExponentPart; octals can't. + // + // Neither is allowed with a BigIntLiteralSuffix `n`. + // + // LegacyOctalIntegerLiteral :: + // `0` OctalDigit + // LegacyOctalIntegerLiteral OctalDigit + // + // NonOctalDecimalIntegerLiteral :: + // `0` NonOctalDigit + // LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + // NonOctalDecimalIntegerLiteral DecimalDigit + // + // LegacyOctalLikeDecimalIntegerLiteral :: + // `0` OctalDigit + // LegacyOctalLikeDecimalIntegerLiteral OctalDigit + // + // NonOctalDigit :: one of + // `8` `9` + // + + // TODO: implement `strict_mode` check + // let strict_mode = true; + // if !strict_mode { + // // TODO: Distinguish between Octal and NonOctalDecimal. + // // TODO: Support NonOctalDecimal followed by a decimal + // // point and/or ExponentPart. + // self.decimal_digits()?; + // } + return Err(ParseError::NotImplemented("LegacyOctalIntegerLiteral").into()); + } + + _ => {} + } + + self.check_after_numeric_literal()?; + Ok(NumericResult::Int { base }) + } + + /// Scan a NumericLiteral (defined in 11.8.3, extended by B.1.1) after + /// having already consumed the first character, which is a decimal digit. + fn decimal_literal_after_first_digit(&mut self) -> Result<'alloc, NumericResult> { + // DecimalLiteral :: + // DecimalIntegerLiteral `.` DecimalDigits? ExponentPart? + // `.` DecimalDigits ExponentPart? + // DecimalIntegerLiteral ExponentPart? + // + // DecimalIntegerLiteral :: + // `0` #see `numeric_literal_starting_with_zero` + // NonZeroDigit + // NonZeroDigit NumericLiteralSeparator? DecimalDigits + // NonOctalDecimalIntegerLiteral #see `numeric_literal_ + // # starting_with_zero` + // + // NonZeroDigit :: one of + // `1` `2` `3` `4` `5` `6` `7` `8` `9` + + self.decimal_digits_after_first_digit()?; + match self.peek() { + Some('.') => { + self.chars.next(); + return self.decimal_literal_after_decimal_point_after_digits(); + } + Some('n') => { + self.chars.next(); + self.check_after_numeric_literal()?; + return Ok(NumericResult::BigInt { + base: NumericLiteralBase::Decimal, + }); + } + _ => {} + } + + let has_exponent = self.optional_exponent()?; + self.check_after_numeric_literal()?; + + let result = if has_exponent { + NumericResult::Float + } else { + NumericResult::Int { + base: NumericLiteralBase::Decimal, + } + }; + + Ok(result) + } + + fn decimal_literal_after_decimal_point(&mut self) -> Result<'alloc, NumericResult> { + // The parts after `.` in + // + // `.` DecimalDigits ExponentPart? + self.decimal_digits()?; + self.optional_exponent()?; + self.check_after_numeric_literal()?; + + Ok(NumericResult::Float) + } + + fn decimal_literal_after_decimal_point_after_digits( + &mut self, + ) -> Result<'alloc, NumericResult> { + // The parts after `.` in + // + // DecimalLiteral :: + // DecimalIntegerLiteral `.` DecimalDigits? ExponentPart? + self.optional_decimal_digits()?; + self.optional_exponent()?; + self.check_after_numeric_literal()?; + + Ok(NumericResult::Float) + } + + fn check_after_numeric_literal(&self) -> Result<'alloc, ()> { + // The SourceCharacter immediately following a + // NumericLiteral must not be an IdentifierStart or + // DecimalDigit. (11.8.3) + if let Some(ch) = self.peek() { + if is_identifier_start(ch) || ch.is_digit(10) { + return Err(ParseError::IllegalCharacter(ch).into()); + } + } + + Ok(()) + } + + // ------------------------------------------------------------------------ + // 11.8.4 String Literals (as extended by B.1.2) + + /// Scan an LineContinuation or EscapeSequence in a string literal, having + /// already consumed the initial backslash character. + /// + /// ```text + /// LineContinuation :: + /// `\` LineTerminatorSequence + /// + /// EscapeSequence :: + /// CharacterEscapeSequence + /// (in strict mode code) `0` [lookahead ∉ DecimalDigit] + /// (in non-strict code) LegacyOctalEscapeSequence + /// HexEscapeSequence + /// UnicodeEscapeSequence + /// + /// CharacterEscapeSequence :: + /// SingleEscapeCharacter + /// NonEscapeCharacter + /// + /// SingleEscapeCharacter :: one of + /// `'` `"` `\` `b` `f` `n` `r` `t` `v` + /// + /// LegacyOctalEscapeSequence :: + /// OctalDigit [lookahead ∉ OctalDigit] + /// ZeroToThree OctalDigit [lookahead ∉ OctalDigit] + /// FourToSeven OctalDigit + /// ZeroToThree OctalDigit OctalDigit + /// + /// ZeroToThree :: one of + /// `0` `1` `2` `3` + /// + /// FourToSeven :: one of + /// `4` `5` `6` `7` + /// ``` + fn escape_sequence(&mut self, text: &mut String<'alloc>) -> Result<'alloc, ()> { + match self.chars.next() { + None => { + return Err(ParseError::UnterminatedString.into()); + } + Some(c) => match c { + LF | LS | PS => { + // LineContinuation. Ignore it. + // + // Don't set is_on_new_line because this LineContinuation + // has no bearing on whether the current string literal was + // the first token on the line where it started. + } + + CR => { + // LineContinuation. Check for the sequence \r\n; otherwise + // ignore it. + if self.peek() == Some(LF) { + self.chars.next(); + } + } + + '\'' | '"' | '\\' => { + text.push(c); + } + + 'b' => { + text.push('\u{8}'); + } + + 'f' => { + text.push(FF); + } + + 'n' => { + text.push(LF); + } + + 'r' => { + text.push(CR); + } + + 't' => { + text.push(TAB); + } + + 'v' => { + text.push(VT); + } + + 'x' => { + // HexEscapeSequence :: + // `x` HexDigit HexDigit + let mut value = self.hex_digit()?; + value = (value << 4) | self.hex_digit()?; + match char::try_from(value) { + Err(_) => { + return Err(ParseError::InvalidEscapeSequence.into()); + } + Ok(c) => { + text.push(c); + } + } + } + + 'u' => { + let c = self.unicode_escape_sequence_after_backslash_and_u()?; + text.push(c); + } + + '0' => { + // In strict mode code and in template literals, the + // relevant production is + // + // EscapeSequence :: + // `0` [lookahead { + return Err(ParseError::NotImplemented( + "legacy octal escape sequence in string", + ) + .into()); + } + Some('8'..='9') => { + return Err(ParseError::NotImplemented( + "digit immediately following \\0 escape sequence", + ) + .into()); + } + _ => {} + } + text.push('\0'); + } + + '1'..='7' => { + return Err(ParseError::NotImplemented( + "legacy octal escape sequence in string", + ) + .into()); + } + + other => { + // "\8" and "\9" are invalid per spec, but SpiderMonkey and + // V8 accept them, and JSC accepts them in non-strict mode. + // "\8" is "8" and "\9" is "9". + text.push(other); + } + }, + } + Ok(()) + } + + /// Scan a string literal, having already consumed the starting quote + /// character `delimiter`. + /// + /// ```text + /// StringLiteral :: + /// `"` DoubleStringCharacters? `"` + /// `'` SingleStringCharacters? `'` + /// + /// DoubleStringCharacters :: + /// DoubleStringCharacter DoubleStringCharacters? + /// + /// SingleStringCharacters :: + /// SingleStringCharacter SingleStringCharacters? + /// + /// DoubleStringCharacter :: + /// SourceCharacter but not one of `"` or `\` or LineTerminator + /// + /// + /// `\` EscapeSequence + /// LineContinuation + /// + /// SingleStringCharacter :: + /// SourceCharacter but not one of `'` or `\` or LineTerminator + /// + /// + /// `\` EscapeSequence + /// LineContinuation + /// ``` + fn string_literal(&mut self, delimiter: char) -> Result<'alloc, ()> { + let offset = self.offset() - 1; + let mut builder = AutoCow::new(&self); + loop { + match self.chars.next() { + None | Some('\r') | Some('\n') => { + return Err(ParseError::UnterminatedString.into()); + } + + Some(c @ '"') | Some(c @ '\'') => { + if c == delimiter { + let value = self.string_to_token_value(builder.finish_without_push(&self)); + return self.set_result( + TerminalId::StringLiteral, + SourceLocation::new(offset, self.offset()), + value, + ); + } else { + builder.push_matching(c); + } + } + + Some('\\') => { + let text = builder.get_mut_string_without_current_ascii_char(&self); + self.escape_sequence(text)?; + } + + Some(other) => { + // NonEscapeCharacter :: + // SourceCharacter but not one of EscapeCharacter or LineTerminator + // + // EscapeCharacter :: + // SingleEscapeCharacter + // DecimalDigit + // `x` + // `u` + builder.push_matching(other); + } + } + } + } + + // ------------------------------------------------------------------------ + // 11.8.5 Regular Expression Literals + + fn regular_expression_backslash_sequence(&mut self) -> Result<'alloc, ()> { + match self.chars.next() { + None | Some(CR) | Some(LF) | Some(LS) | Some(PS) => { + Err(ParseError::UnterminatedRegExp.into()) + } + Some(_) => Ok(()), + } + } + + // See 12.2.8 and 11.8.5 sections. + fn regular_expression_literal(&mut self, builder: &mut AutoCow<'alloc>) -> Result<'alloc, ()> { + let offset = self.offset(); + + loop { + match self.chars.next() { + None | Some(CR) | Some(LF) | Some(LS) | Some(PS) => { + return Err(ParseError::UnterminatedRegExp.into()); + } + Some('/') => { + break; + } + Some('[') => { + // RegularExpressionClass. + loop { + match self.chars.next() { + None | Some(CR) | Some(LF) | Some(LS) | Some(PS) => { + return Err(ParseError::UnterminatedRegExp.into()); + } + Some(']') => { + break; + } + Some('\\') => { + self.regular_expression_backslash_sequence()?; + } + Some(_) => {} + } + } + } + Some('\\') => { + self.regular_expression_backslash_sequence()?; + } + Some(_) => {} + } + } + let mut flag_text = AutoCow::new(&self); + while let Some(ch) = self.peek() { + match ch { + '$' | '_' | 'a'..='z' | 'A'..='Z' | '0'..='9' => { + self.chars.next(); + flag_text.push_matching(ch); + } + _ => break, + } + } + + // 12.2.8.2.1 Assert literal is a RegularExpressionLiteral. + let literal = builder.finish(&self); + + // 12.2.8.2.2 Check that only gimsuy flags are mentioned at most once. + let gimsuy_mask: u32 = ['g', 'i', 'm', 's', 'u', 'y'] + .iter() + .map(|x| 1 << ((*x as u8) - ('a' as u8))) + .sum(); + let mut flag_text_set: u32 = 0; + for ch in flag_text.finish(&self).chars() { + if !ch.is_ascii_lowercase() { + return Err(ParseError::NotImplemented( + "Unexpected flag in regular expression literal", + ) + .into()); + } + let ch_mask = 1 << ((ch as u8) - ('a' as u8)); + if ch_mask & gimsuy_mask == 0 { + return Err(ParseError::NotImplemented( + "Unexpected flag in regular expression literal", + ) + .into()); + } + if flag_text_set & ch_mask != 0 { + return Err(ParseError::NotImplemented( + "Flag is mentioned twice in regular expression literal", + ) + .into()); + } + flag_text_set |= ch_mask; + } + + // TODO: 12.2.8.2.4 and 12.2.8.2.5 Check that the body matches the + // grammar defined in 21.2.1. + + let value = self.slice_to_token_value(literal); + self.set_result( + TerminalId::RegularExpressionLiteral, + SourceLocation::new(offset, self.offset()), + value, + ) + } + + // ------------------------------------------------------------------------ + // 11.8.6 Template Literal Lexical Components + + /// Parse a template literal component token, having already consumed the + /// starting `` ` `` or `}` character. On success, the `id` of the returned + /// `Token` is `subst` (if the token ends with `${`) or `tail` (if the + /// token ends with `` ` ``). + /// + /// ```text + /// NoSubstitutionTemplate :: + /// ``` TemplateCharacters? ``` + /// + /// TemplateHead :: + /// ``` TemplateCharacters? `${` + /// + /// TemplateMiddle :: + /// `}` TemplateCharacters? `${` + /// + /// TemplateTail :: + /// `}` TemplateCharacters? ``` + /// + /// TemplateCharacters :: + /// TemplateCharacter TemplateCharacters? + /// ``` + fn template_part( + &mut self, + start: usize, + subst: TerminalId, + tail: TerminalId, + ) -> Result<'alloc, ()> { + let mut builder = AutoCow::new(&self); + while let Some(ch) = self.chars.next() { + // TemplateCharacter :: + // `$` [lookahead != `{` ] + // `\` EscapeSequence + // `\` NotEscapeSequence + // LineContinuation + // LineTerminatorSequence + // SourceCharacter but not one of ``` or `\` or `$` or LineTerminator + // + // NotEscapeSequence :: + // `0` DecimalDigit + // DecimalDigit but not `0` + // `x` [lookahead but only if MV of |HexDigits| > 0x10FFFF ] + // + // CodePoint :: + // HexDigits [> but only if MV of |HexDigits| ≤ 0x10FFFF ] + if ch == '$' && self.peek() == Some('{') { + self.chars.next(); + let value = self.string_to_token_value(builder.finish_without_push(&self)); + return self.set_result(subst, SourceLocation::new(start, self.offset()), value); + } + if ch == '`' { + let value = self.string_to_token_value(builder.finish_without_push(&self)); + return self.set_result(tail, SourceLocation::new(start, self.offset()), value); + } + // TODO: Support escape sequences. + if ch == '\\' { + let text = builder.get_mut_string_without_current_ascii_char(&self); + self.escape_sequence(text)?; + } else { + builder.push_matching(ch); + } + } + Err(ParseError::UnterminatedString.into()) + } + + fn advance_impl<'parser>(&mut self, parser: &Parser<'parser>) -> Result<'alloc, ()> { + let mut builder = AutoCow::new(&self); + let mut start = self.offset(); + while let Some(c) = self.chars.next() { + match c { + // 11.2 White Space + // + // WhiteSpace :: + // + // + // + // + // + // + // + TAB | + VT | + FF | + SP | + NBSP | + ZWNBSP | + '\u{1680}' | // Ogham space mark (in ) + '\u{2000}' ..= '\u{200a}' | // typesetting spaces (in ) + '\u{202f}' | // Narrow no-break space (in ) + '\u{205f}' | // Medium mathematical space (in ) + '\u{3000}' // Ideographic space (in ) + => { + // TODO - The spec uses to stand for any character + // with category "Space_Separator" (Zs). New Unicode + // standards may add characters to this set. This should therefore be + // implemented using the Unicode database somehow. + builder = AutoCow::new(&self); + start = self.offset(); + continue; + } + + // 11.3 Line Terminators + // + // LineTerminator :: + // + // + // + // + LF | CR | LS | PS => { + self.token.is_on_new_line = true; + builder = AutoCow::new(&self); + start = self.offset(); + continue; + } + + '0' => { + let result = self.numeric_literal_starting_with_zero()?; + return Ok(self.numeric_result_to_advance_result(builder.finish(&self), start, result)?); + } + + '1'..='9' => { + let result = self.decimal_literal_after_first_digit()?; + return Ok(self.numeric_result_to_advance_result(builder.finish(&self), start, result)?); + } + + '"' | '\'' => { + return self.string_literal(c); + } + + '`' => { + return self.template_part(start, TerminalId::TemplateHead, TerminalId::NoSubstitutionTemplate); + } + + '!' => match self.peek() { + Some('=') => { + self.chars.next(); + match self.peek() { + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::StrictNotEqual, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::LaxNotEqual, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + } + } + _ => return self.set_result( + TerminalId::LogicalNot, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + }, + + '%' => match self.peek() { + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::RemainderAssign, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::Remainder, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + }, + + '&' => match self.peek() { + Some('&') => { + self.chars.next(); + match self.peek() { + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::LogicalAndAssign, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::LogicalAnd, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ) + } + } + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::BitwiseAndAssign, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::BitwiseAnd, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + }, + + '*' => match self.peek() { + Some('*') => { + self.chars.next(); + match self.peek() { + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::ExponentiateAssign, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::Exponentiate, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + } + } + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::MultiplyAssign, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::Star, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + }, + + '+' => match self.peek() { + Some('+') => { + self.chars.next(); + return self.set_result( + TerminalId::Increment, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::AddAssign, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::Plus, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + }, + + '-' => match self.peek() { + Some('-') => { + self.chars.next(); + match self.peek() { + Some('>') if self.token.is_on_new_line => { + // B.1.3 SingleLineHTMLCloseComment + // TODO: Limit this to Script (not Module). + self.skip_single_line_comment(&mut builder); + continue; + } + _ => return self.set_result( + TerminalId::Decrement, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + } + } + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::SubtractAssign, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::Minus, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + }, + + '.' => match self.peek() { + Some('.') => { + self.chars.next(); + match self.peek() { + Some('.') => { + self.chars.next(); + return self.set_result( + TerminalId::Ellipsis, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return Err(ParseError::IllegalCharacter('.').into()), + } + } + Some('0'..='9') => { + let result = self.decimal_literal_after_decimal_point()?; + return Ok(self.numeric_result_to_advance_result(builder.finish(&self), start, result)?); + } + _ => return self.set_result( + TerminalId::Dot, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + }, + + '/' => match self.peek() { + Some('/') => { + // SingleLineComment :: `//` SingleLineCommentChars? + self.chars.next(); + self.skip_single_line_comment(&mut builder); + start = self.offset(); + continue; + } + Some('*') => { + self.chars.next(); + self.skip_multi_line_comment(&mut builder)?; + start = self.offset(); + continue; + } + _ => { + if parser.can_accept_terminal(TerminalId::Divide) { + match self.peek() { + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::DivideAssign, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::Divide, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + } + } + return self.regular_expression_literal(&mut builder); + } + }, + + '}' => { + if parser.can_accept_terminal(TerminalId::TemplateMiddle) { + return self.template_part(start, TerminalId::TemplateMiddle, TerminalId::TemplateTail); + } + return self.set_result( + TerminalId::CloseBrace, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + + '<' => match self.peek() { + Some('<') => { + self.chars.next(); + match self.peek() { + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::LeftShiftAssign, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + _ => return self.set_result( + TerminalId::LeftShift, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ), + } + } + Some('=') => { + self.chars.next(); + return self.set_result( + TerminalId::LessThanOrEqualTo, + SourceLocation::new(start, self.offset()), + TokenValue::None, + ); + } + Some('!') if self.is_looking_at("!--") => { + // B.1.3 SingleLineHTMLOpenComment. Note that the above + // `is_looking_at` test peeked ahead at the next three + // characters of input. This lookahead is necessary + // because `x'-----' + /// stack ^ gap queue + /// | + /// top -' + buf: Vec, + /// Length of the stack, self.buf[top - 1] being the last element of the + /// stack. + top: usize, + /// Length of the gap between the stack top and the queue head. + gap: usize, +} + +impl QueueStack { + /// Create a queue and stack with the given number of reserved elements. + pub fn with_capacity(n: usize) -> QueueStack { + QueueStack { + buf: Vec::with_capacity(n), + top: 0, + gap: 0, + } + } + + /// Add an element to the back of the queue. + pub fn enqueue(&mut self, value: T) { + self.buf.push(value); + } + + /// Add an element to the front of the queue. + pub fn push_next(&mut self, value: T) { + self.compact_with_gap(1); + self.gap -= 1; + unsafe { + // Write over the gap without reading nor dropping the old entry. + let ptr = self.buf.as_mut_ptr().add(self.top + self.gap); + ptr.write(value); + } + } + + /// Whether elements can be shifted. + pub fn can_shift(&self) -> bool { + self.gap == 0 && !self.queue_empty() + } + + /// Whether elements can be unshifted. + pub fn can_unshift(&self) -> bool { + self.gap == 0 && !self.stack_empty() + } + + /// Transfer an element from the top of the stack to the front of the queue. + /// + /// The gap must be empty. This does not move the value from one address to + /// another in memory; it just adjusts the boundary between the stack and + /// the queue. + /// + /// # Panics + /// If the stack is empty or there is a gap. + pub fn unshift(&mut self) { + assert!(self.can_unshift()); + self.top -= 1; + } + + /// Transfer an element from the front of the queue to the top of the stack. + /// + /// The gap must be empty. This does not move the value from one address to + /// another in memory; it just adjusts the boundary between the stack and + /// the queue. + /// + /// # Panics + /// If the queue is empty or there is a gap. + #[inline(always)] + pub fn shift(&mut self) { + assert!(self.can_shift()); + self.top += 1; + } + + /// Remove the top element of the stack and return it, or None if the stack + /// is empty. + /// + /// This increases the gap size by 1. + pub fn pop(&mut self) -> Option { + if self.top == 0 { + None + } else { + self.top -= 1; + self.gap += 1; + unsafe { + // Take ownership of the content. + let ptr = self.buf.as_mut_ptr().add(self.top); + Some(ptr.read()) + } + } + } + + /// Set the gap size to `new_gap`, memmove-ing the contents of the queue as + /// needed. + fn compact_with_gap(&mut self, new_gap: usize) { + assert!(new_gap <= (std::isize::MAX as usize)); + assert!(self.gap <= (std::isize::MAX as usize)); + let diff = new_gap as isize - self.gap as isize; + if diff == 0 { + return; + } + // Ensure there is enough capacity. + if diff > 0 { + self.buf.reserve(diff as usize); + } + // Number of elements to be copied. + let count = self.queue_len(); + let new_len = self.top + new_gap + count; + assert!(new_len < self.buf.capacity()); + unsafe { + let src_ptr = self.buf.as_mut_ptr().add(self.top + self.gap); + let dst_ptr = src_ptr.offset(diff); + + // Shift everything down/up to have the expected gap. + ptr::copy(src_ptr, dst_ptr, count); + + // Update the buffer length to newly copied elements. + self.buf.set_len(new_len); + // Update the gap to the new gap value. + self.gap = new_gap; + } + debug_assert_eq!(self.queue_len(), count); + } + + /// Returns a reference to the front element of the queue. + pub fn next(&self) -> Option<&T> { + if self.queue_empty() { + None + } else { + Some(&self.buf[self.top + self.gap]) + } + } + + /// Returns a reference to the top element of the stack. + #[allow(dead_code)] + pub fn top(&self) -> Option<&T> { + if self.top == 0 { + None + } else { + Some(&self.buf[self.top - 1]) + } + } + + /// Returns a mutable reference to the top of the stack. + #[allow(dead_code)] + pub fn top_mut(&mut self) -> Option<&mut T> { + if self.top == 0 { + None + } else { + Some(&mut self.buf[self.top - 1]) + } + } + + /// Number of elements in the stack. + pub fn stack_len(&self) -> usize { + self.top + } + + /// Number of elements in the queue. + pub fn queue_len(&self) -> usize { + self.buf.len() - self.top - self.gap + } + + /// Whether the stack is empty. + pub fn stack_empty(&self) -> bool { + self.top == 0 + } + + /// Whether the queue is empty. + pub fn queue_empty(&self) -> bool { + self.top == self.buf.len() + } + + /// Create a slice which corresponds the stack. + pub fn stack_slice(&self) -> &[T] { + &self.buf[..self.top] + } + + /// Create a slice which corresponds the queue. + #[allow(dead_code)] + pub fn queue_slice(&self) -> &[T] { + &self.buf[self.top + self.gap..] + } +} + +impl Drop for QueueStack { + fn drop(&mut self) { + // QueueStack contains a gap of non-initialized values, before releasing + // the vector, we move all initialized values from the queue into the + // remaining gap. + self.compact_with_gap(0); + } +} diff --git a/third_party/rust/jsparagus-parser/src/simulator.rs b/third_party/rust/jsparagus-parser/src/simulator.rs new file mode 100644 index 0000000000..0e060fd5c1 --- /dev/null +++ b/third_party/rust/jsparagus-parser/src/simulator.rs @@ -0,0 +1,211 @@ +//! Simulates parser execution, for a single token of input, without incurring +//! any side effects. +//! +//! This is basically a copy of the parser.rs source code with calls to +//! generated_parser::reduce, and stack bookkeeping, omitted. + +use crate::parser::Parser; +use arrayvec::ArrayVec; +use ast::SourceLocation; +use generated_parser::{ + noop_actions, ParseError, ParserTrait, Result, StackValue, TermValue, TerminalId, Token, TABLES, +}; + +/// The Simulator is used to check whether we can shift one token, either to +/// check what might be accepted, or to check whether we can End parsing now. +/// This is used by the REPL to verify whether or not we can end the input. +pub struct Simulator<'alloc, 'parser> { + /// Define the top of the immutable stack. + sp: usize, + /// Immutable state stack coming from the forked parser. + state_stack: &'parser [usize], + /// Immuatable term stack coming from the forked parser. + node_stack: &'parser [TermValue>], + /// Mutable state stack used by the simulator on top of the immutable + /// parser's state stack. + /// + /// Uses a fixed-size array as the number of lookahead is bounded to a lower + /// value, panics otherwise. + sim_state_stack: ArrayVec, + /// Mutable term stack used by the simulator on top of the immutable + /// parser's term stack. + /// + /// Uses a fixed-size array as the number of lookahead is bounded to a lower + /// value, panics otherwise. + sim_node_stack: ArrayVec, 4>, + /// Mutable term stack used by the simulator for replaying terms when + /// reducing non-terminals are replaying lookahead terminals. + /// + /// Uses a fixed-size array as the number of lookahead is bounded to a lower + /// value, panics otherwise. + replay_stack: ArrayVec, 4>, +} + +impl<'alloc, 'parser> ParserTrait<'alloc, ()> for Simulator<'alloc, 'parser> { + fn shift(&mut self, tv: TermValue<()>) -> Result<'alloc, bool> { + // Shift the new terminal/nonterminal and its associated value. + let mut state = self.state(); + assert!(state < TABLES.shift_count); + let mut tv = tv; + loop { + let term_index: usize = tv.term.into(); + assert!(term_index < TABLES.shift_width); + let index = state * TABLES.shift_width + term_index; + let goto = TABLES.shift_table[index]; + if goto < 0 { + // Error handling is in charge of shifting an ErrorSymbol from the + // current state. + self.try_error_handling(tv)?; + tv = self.replay_stack.pop().unwrap(); + continue; + } + state = goto as usize; + self.sim_state_stack.push(state); + self.sim_node_stack.push(tv); + // Execute any actions, such as reduce actions. + if state >= TABLES.shift_count { + assert!(state < TABLES.action_count + TABLES.shift_count); + if noop_actions(self, state)? { + return Ok(true); + } + state = self.state(); + } + assert!(state < TABLES.shift_count); + if let Some(tv_temp) = self.replay_stack.pop() { + tv = tv_temp; + } else { + break; + } + } + Ok(false) + } + fn shift_replayed(&mut self, state: usize) { + let tv = self.replay_stack.pop().unwrap(); + self.sim_state_stack.push(state); + self.sim_node_stack.push(tv); + } + fn unshift(&mut self) { + let tv = self.pop(); + self.replay(tv) + } + fn pop(&mut self) -> TermValue<()> { + if let Some(s) = self.sim_node_stack.pop() { + self.sim_state_stack.pop(); + return s; + } + let t = self.node_stack[self.sp - 1].term; + self.sp -= 1; + TermValue { term: t, value: () } + } + fn replay(&mut self, tv: TermValue<()>) { + self.replay_stack.push(tv) + } + fn epsilon(&mut self, state: usize) { + if self.sim_state_stack.is_empty() { + self.sim_state_stack.push(self.state_stack[self.sp]); + self.sim_node_stack.push(TermValue { + term: self.node_stack[self.sp - 1].term, + value: (), + }); + self.sp -= 1; + } + *self.sim_state_stack.last_mut().unwrap() = state; + } + fn top_state(&self) -> usize { + self.state() + } + fn check_not_on_new_line(&mut self, _peek: usize) -> Result<'alloc, bool> { + Ok(true) + } +} + +impl<'alloc, 'parser> Simulator<'alloc, 'parser> { + pub fn new( + state_stack: &'parser [usize], + node_stack: &'parser [TermValue>], + ) -> Simulator<'alloc, 'parser> { + let sp = state_stack.len() - 1; + assert_eq!(state_stack.len(), node_stack.len() + 1); + Simulator { + sp, + state_stack, + node_stack, + sim_state_stack: ArrayVec::new(), + sim_node_stack: ArrayVec::new(), + replay_stack: ArrayVec::new(), + } + } + + fn state(&self) -> usize { + if let Some(res) = self.sim_state_stack.last() { + *res + } else { + self.state_stack[self.sp] + } + } + + pub fn write_token(&mut self, t: TerminalId) -> Result<'alloc, ()> { + // Shift the token with the associated StackValue. + let accept = self.shift(TermValue { + term: t.into(), + value: (), + })?; + // JavaScript grammar accepts empty inputs, therefore we can never + // accept any program before receiving a TerminalId::End. + assert!(!accept); + Ok(()) + } + + pub fn close(&mut self, _position: usize) -> Result<'alloc, ()> { + // Shift the End terminal with the associated StackValue. + let accept = self.shift(TermValue { + term: TerminalId::End.into(), + value: (), + })?; + // Adding a TerminalId::End would either lead to a parse error, or to + // accepting the current input. In which case we return matching node + // value. + assert!(accept); + + // We can either reduce a Script/Module, or a Script/Module followed by + // an terminal. + assert!(self.sp + self.sim_node_stack.len() >= 1); + Ok(()) + } + + // Simulate the action of Parser::try_error_handling. + fn try_error_handling(&mut self, t: TermValue<()>) -> Result<'alloc, bool> { + if t.term.is_terminal() { + let term = t.term.to_terminal(); + let bogus_loc = SourceLocation::new(0, 0); + let token = &Token::basic_token(term, bogus_loc); + + // Error tokens might them-self cause more errors to be reported. + // This happens due to the fact that the ErrorToken can be replayed, + // and while the ErrorToken might be in the lookahead rules, it + // might not be in the shifted terms coming after the reduced + // nonterminal. + if term == TerminalId::ErrorToken { + return Err(Parser::parse_error(token).into()); + } + + // Otherwise, check if the current rule accept an Automatic + // Semi-Colon insertion (ASI). + let state = self.state(); + assert!(state < TABLES.shift_count); + let error_code = TABLES.error_codes[state]; + if let Some(error_code) = error_code { + Parser::recover(token, error_code)?; + self.replay(t); + self.replay(TermValue { + term: TerminalId::ErrorToken.into(), + value: (), + }); + return Ok(false); + } + return Err(Parser::parse_error(token).into()); + } + // On error, don't attempt error handling again. + Err(ParseError::ParserCannotUnpackToken.into()) + } +} diff --git a/third_party/rust/jsparagus-parser/src/tests.rs b/third_party/rust/jsparagus-parser/src/tests.rs new file mode 100644 index 0000000000..7953dd7554 --- /dev/null +++ b/third_party/rust/jsparagus-parser/src/tests.rs @@ -0,0 +1,875 @@ +use std::iter; + +use crate::lexer::Lexer; +use crate::parser::Parser; +use crate::{parse_script, ParseOptions}; +use ast::source_atom_set::SourceAtomSet; +use ast::source_slice_list::SourceSliceList; +use ast::{arena, source_location::SourceLocation, types::*}; +use bumpalo::{self, Bump}; +use generated_parser::{self, AstBuilder, ParseError, Result, TerminalId}; +use std::cell::RefCell; +use std::rc::Rc; + +#[cfg(all(feature = "unstable", test))] +mod benchmarks { + extern crate test; + + use std::fs::File; + use std::io::Read; + use test::Bencher; + + use crate::lexer::Lexer; + use crate::parse_script; + + #[bench] + fn bench_parse_grammar(b: &mut Bencher) { + let mut buffer = fs::read_to_string("../vue.js").expect("reading test file"); + b.iter(|| { + let lexer = Lexer::new(buffer.chars()); + parse_script(lexer).unwrap(); + }); + } +} + +trait IntoChunks<'a> { + type Chunks: Iterator; + fn into_chunks(self) -> Self::Chunks; +} + +impl<'a> IntoChunks<'a> for &'a str { + type Chunks = iter::Once<&'a str>; + fn into_chunks(self) -> Self::Chunks { + iter::once(self) + } +} + +impl<'a> IntoChunks<'a> for &'a Vec<&'a str> { + type Chunks = iter::Cloned>; + fn into_chunks(self) -> Self::Chunks { + self.iter().cloned() + } +} + +// Glue all the chunks together. XXX TODO Once the lexer supports chunks, +// we'll reimplement this to feed the code to the lexer one chunk at a time. +fn chunks_to_string<'a, T: IntoChunks<'a>>(code: T) -> String { + let mut buf = String::new(); + for chunk in code.into_chunks() { + buf.push_str(chunk); + } + buf +} + +fn try_parse<'alloc, 'source, Source>( + allocator: &'alloc Bump, + code: Source, +) -> Result<'alloc, arena::Box<'alloc, Script<'alloc>>> +where + Source: IntoChunks<'source>, +{ + let buf = arena::alloc_str(allocator, &chunks_to_string(code)); + let options = ParseOptions::new(); + let atoms = Rc::new(RefCell::new(SourceAtomSet::new())); + let slices = Rc::new(RefCell::new(SourceSliceList::new())); + parse_script(allocator, &buf, &options, atoms, slices) +} + +fn assert_parses<'alloc, T: IntoChunks<'alloc>>(code: T) { + let allocator = &Bump::new(); + try_parse(allocator, code).unwrap(); +} + +fn assert_error<'alloc, T: IntoChunks<'alloc>>(code: T) { + let allocator = &Bump::new(); + assert!(match try_parse(allocator, code).map_err(|e| *e) { + Err(ParseError::NotImplemented(_)) => panic!("expected error, got NotImplemented"), + Err(_) => true, + Ok(ast) => panic!("assertion failed: SUCCESS error: {:?}", ast), + }); +} + +fn assert_syntax_error<'alloc, T: IntoChunks<'alloc>>(code: T) { + let allocator = &Bump::new(); + assert!(match try_parse(allocator, code).map_err(|e| *e) { + Err(ParseError::SyntaxError(_)) => true, + Err(other) => panic!("unexpected error: {:?}", other), + Ok(ast) => panic!("assertion failed: SUCCESS error: {:?}", ast), + }); +} + +fn assert_not_implemented<'alloc, T: IntoChunks<'alloc>>(code: T) { + let allocator = &Bump::new(); + assert!(match try_parse(allocator, code).map_err(|e| *e) { + Err(ParseError::NotImplemented(_)) => true, + Err(other) => panic!("unexpected error: {:?}", other), + Ok(ast) => panic!("assertion failed: SUCCESS error: {:?}", ast), + }); +} + +fn assert_illegal_character<'alloc, T: IntoChunks<'alloc>>(code: T) { + let allocator = &Bump::new(); + assert!(match try_parse(allocator, code).map_err(|e| *e) { + Err(ParseError::IllegalCharacter(_)) => true, + Err(other) => panic!("unexpected error: {:?}", other), + Ok(ast) => panic!("assertion failed: SUCCESS error: {:?}", ast), + }); +} + +fn assert_error_eq<'alloc, T: IntoChunks<'alloc>>(code: T, expected: ParseError) { + let allocator = &Bump::new(); + let result = try_parse(allocator, code); + assert!(result.is_err()); + assert_eq!(*result.unwrap_err(), expected); +} + +fn assert_incomplete<'alloc, T: IntoChunks<'alloc>>(code: T) { + let allocator = &Bump::new(); + let result = try_parse(allocator, code); + assert!(result.is_err()); + assert_eq!(*result.unwrap_err(), ParseError::UnexpectedEnd); +} + +// Assert that `left` and `right`, when parsed as ES Modules, consist of the +// same sequence of tokens (although possibly at different offsets). +fn assert_same_tokens<'alloc>(left: &str, right: &str) { + let allocator = &Bump::new(); + let left_atoms = Rc::new(RefCell::new(SourceAtomSet::new())); + let left_slices = Rc::new(RefCell::new(SourceSliceList::new())); + let right_atoms = Rc::new(RefCell::new(SourceAtomSet::new())); + let right_slices = Rc::new(RefCell::new(SourceSliceList::new())); + let mut left_lexer = Lexer::new( + allocator, + left.chars(), + left_atoms.clone(), + left_slices.clone(), + ); + let mut right_lexer = Lexer::new( + allocator, + right.chars(), + right_atoms.clone(), + right_slices.clone(), + ); + + let mut left_parser = Parser::new( + AstBuilder::new(allocator, left_atoms, left_slices), + generated_parser::START_STATE_MODULE, + ); + let mut right_parser = Parser::new( + AstBuilder::new(allocator, right_atoms, right_slices), + generated_parser::START_STATE_MODULE, + ); + + loop { + let left_token = left_lexer + .next(&left_parser) + .expect("error parsing left string"); + let right_token = right_lexer + .next(&right_parser) + .expect("error parsing right string"); + assert_eq!( + left_token.terminal_id, right_token.terminal_id, + "at offset {} in {:?} / {} in {:?}", + left_token.loc.start, left, right_token.loc.start, right, + ); + assert_eq!( + left_token.value, right_token.value, + "at offsets {} / {}", + left_token.loc.start, right_token.loc.start + ); + + if left_token.terminal_id == TerminalId::End { + break; + } + left_parser.write_token(left_token).unwrap(); + right_parser.write_token(right_token).unwrap(); + } + left_parser.close(left_lexer.offset()).unwrap(); + right_parser.close(left_lexer.offset()).unwrap(); +} + +fn assert_can_close_after<'alloc, T: IntoChunks<'alloc>>(code: T) { + let allocator = &Bump::new(); + let buf = chunks_to_string(code); + let atoms = Rc::new(RefCell::new(SourceAtomSet::new())); + let slices = Rc::new(RefCell::new(SourceSliceList::new())); + let mut lexer = Lexer::new(allocator, buf.chars(), atoms.clone(), slices.clone()); + let mut parser = Parser::new( + AstBuilder::new(allocator, atoms, slices), + generated_parser::START_STATE_SCRIPT, + ); + loop { + let t = lexer.next(&parser).expect("lexer error"); + if t.terminal_id == TerminalId::End { + break; + } + parser.write_token(t).unwrap(); + } + assert!(parser.can_close()); +} + +fn assert_same_number(code: &str, expected: f64) { + let allocator = &Bump::new(); + let script = try_parse(allocator, code).unwrap().unbox(); + match &script.statements[0] { + Statement::ExpressionStatement(expression) => match &**expression { + Expression::LiteralNumericExpression(num) => { + assert_eq!(num.value, expected, "{}", code); + } + _ => panic!("expected LiteralNumericExpression"), + }, + _ => panic!("expected ExpressionStatement"), + } +} + +#[test] +fn test_asi_at_end() { + assert_parses("3 + 4"); + assert_syntax_error("3 4"); + assert_incomplete("3 +"); + assert_incomplete("{"); + assert_incomplete("{;"); +} + +#[test] +fn test_asi_at_block_end() { + assert_parses("{ doCrimes() }"); + assert_parses("function f() { ok }"); +} + +#[test] +fn test_asi_after_line_terminator() { + assert_parses( + "switch (value) { + case 1: break + case 2: console.log('2'); + }", + ); + assert_syntax_error("switch (value) { case 1: break case 2: console.log('2'); }"); + + // "[T]he presence or absence of single-line comments does not affect the + // process of automatic semicolon insertion[...]." + // + assert_parses("x = 1 // line break here\ny = 2"); + assert_parses("x = 1 // line break here\r\ny = 2"); + assert_parses("x = 1 /* no line break in here */ //\ny = 2"); + assert_parses("x = 1 hello world\nok", "ok"); + assert_same_tokens("/* ignore */ --> also ignore\nok", "ok"); + assert_same_tokens("/* ignore *//**/--> also ignore\nok", "ok"); + assert_same_tokens("x-->y\nz", "x -- > y\nz"); +} + +#[test] +fn test_incomplete_comments() { + assert_error("/*"); + assert_error("/* hello world"); + assert_error("/* hello world *"); + + assert_parses(&vec!["/* hello\n", " world */"]); + assert_parses(&vec!["// oawfeoiawj", "ioawefoawjie"]); + assert_parses(&vec!["// oawfeoiawj", "ioawefoawjie\n ok();"]); + assert_parses(&vec!["// oawfeoiawj", "ioawefoawjie", "jiowaeawojefiw"]); + assert_parses(&vec![ + "// oawfeoiawj", + "ioawefoawjie", + "jiowaeawojefiw\n ok();", + ]); +} + +#[test] +fn test_strings() { + assert_parses("f(\"\",\"\")"); + assert_parses("f(\"\")"); + assert_parses("(\"\")"); + assert_parses("f('','')"); + assert_parses("f('')"); + assert_parses("('')"); +} + +#[test] +fn test_awkward_chunks() { + assert_parses(&vec!["const", "ructor.length = 1;"]); + assert_parses(&vec!["const", " x = 1;"]); + + // Try feeding one character at a time to the parser. + let chars: Vec<&str> = "function f() { ok(); }".split("").collect(); + assert_parses(&chars); + + // XXX TODO + //assertEqual( + // self.parse(&vec!["/xyzzy/", "g;"]), + // ('Script', + // ('ScriptBody', + // ('StatementList 0', + // ('ExpressionStatement', + // ('PrimaryExpression 10', '/xyzzy/g')))))); + + let allocator = &Bump::new(); + let actual = try_parse(allocator, &vec!["x/", "=2;"]).unwrap(); + let atoms = Rc::new(RefCell::new(SourceAtomSet::new())); + let expected = Script { + directives: arena::Vec::new_in(allocator), + statements: bumpalo::vec![ + in allocator; + Statement::ExpressionStatement(arena::alloc( + allocator, + Expression::CompoundAssignmentExpression { + operator: CompoundAssignmentOperator::Div { + loc: SourceLocation::new(1, 3), + }, + binding: SimpleAssignmentTarget::AssignmentTargetIdentifier( + AssignmentTargetIdentifier { + name: Identifier { + value: atoms.borrow_mut().insert("x"), + loc: SourceLocation::new(0, 1), + }, + loc: SourceLocation::new(0, 1), + }, + ), + expression: arena::alloc( + allocator, + Expression::LiteralNumericExpression(NumericLiteral { + value: 2.0, + loc: SourceLocation::new(3, 4), + }), + ), + loc: SourceLocation::new(0, 4), + }, + )) + ], + loc: SourceLocation::new(0, 4), + }; + assert_eq!(format!("{:?}", actual), format!("{:?}", expected)); +} + +#[test] +fn test_can_close() { + let empty: Vec<&str> = vec![]; + assert_can_close_after(&empty); + assert_can_close_after(""); + assert_can_close_after("2 + 2;\n"); + assert_can_close_after("// seems ok\n"); +} + +#[test] +fn test_regex() { + assert_parses("/x/"); + assert_parses("x = /x/"); + assert_parses("x = /x/g"); + + // FIXME: Unexpected flag + // assert_parses("x = /x/wow_flags_can_be_$$anything$$"); + assert_not_implemented("x = /x/wow_flags_can_be_$$anything$$"); + + // TODO: Should the lexer running out of input throw an incomplete error, or a lexer error? + assert_error_eq("/x", ParseError::UnterminatedRegExp); + assert_incomplete("x = //"); // comment + assert_error_eq("x = /*/", ParseError::UnterminatedMultiLineComment); /*/ comment */ + assert_error_eq("x =/= 2", ParseError::UnterminatedRegExp); + assert_parses("x /= 2"); + assert_parses("x = /[]/"); + assert_parses("x = /[^x]/"); + assert_parses("x = /+=351*/"); + assert_parses("x = /^\\s*function (\\w+)/;"); + assert_parses("const regexp = /this is fine: [/] dont @ me/;"); +} + +#[test] +fn test_arrow_parameters() { + assert_error_eq( + "({a:a, ...b, c:c}) => {}", + ParseError::ObjectPatternWithNonFinalRest, + ); + assert_error_eq( + "(a, [...zero, one]) => {}", + ParseError::ArrayPatternWithNonFinalRest, + ); + assert_error_eq( + "(a, {items: [...zero, one]}) => {}", + ParseError::ArrayPatternWithNonFinalRest, + ); +} + +#[test] +fn test_invalid_assignment_targets() { + assert_syntax_error("2 + 2 = x;"); + assert_error_eq("(2 + 2) = x;", ParseError::InvalidAssignmentTarget); + assert_error_eq("++-x;", ParseError::InvalidAssignmentTarget); + assert_error_eq("(x && y)--;", ParseError::InvalidAssignmentTarget); +} + +#[test] +fn test_can_close_with_asi() { + assert_can_close_after("2 + 2\n"); +} + +#[test] +fn test_conditional_keywords() { + // property names + assert_parses("const obj = {if: 3, function: 4};"); + assert_parses("const obj = {true: 1, false: 0, null: NaN};"); + assert_parses("assert(obj.if == 3);"); + assert_parses("assert(obj.true + obj.false + obj.null == NaN);"); + + // method names + assert_parses( + " + class C { + if() {} + function() {} + } + ", + ); + + // FIXME: let (multitoken lookahead): + assert_not_implemented("let a = 1;"); + /* + // let as identifier + assert_parses("var let = [new Date];"); + // let as keyword, then identifier + assert_parses("let v = let;"); + // `let .` -> ExpressionStatement + assert_parses("let.length;"); + // `let [` -> LexicalDeclaration + assert_syntax_error("let[0].getYear();"); + */ + + assert_parses( + " + var of = [1, 2, 3]; + for (of of of) console.log(of); // logs 1, 2, 3 + ", + ); + + // Not implemented: + // assert_parses("var of, let, private, target;"); + + assert_parses("class X { get y() {} }"); + + // Not implemented: + // assert_parses("async: { break async; }"); + + assert_parses("var get = { get get() {}, set get(v) {}, set: 3 };"); + + // Not implemented (requires hack; grammar is not LR(1)): + // assert_parses("for (async of => {};;) {}"); + // assert_parses("for (async of []) {}"); +} + +#[test] +fn test_async_arrows() { + // FIXME: async (multiple lookahead) + assert_not_implemented("const a = async a => 1;"); + /* + assert_parses("let f = async arg => body;"); + assert_parses("f = async (a1, a2) => {};"); + assert_parses("f = async (a1 = b + c, ...a2) => {};"); + + assert_error_eq("f = async (a, b + c) => {};", ParseError::InvalidParameter); + assert_error_eq( + "f = async (...a1, a2) => {};", + ParseError::ArrowParametersWithNonFinalRest, + ); + assert_error_eq("obj.async() => {}", ParseError::ArrowHeadInvalid); + */ + + assert_error_eq("foo(a, b) => {}", ParseError::ArrowHeadInvalid); +} + +#[test] +fn test_binary() { + assert_parses("1 == 2"); + assert_parses("1 != 2"); + assert_parses("1 === 2"); + assert_parses("1 !== 2"); + assert_parses("1 < 2"); + assert_parses("1 <= 2"); + assert_parses("1 > 2"); + assert_parses("1 >= 2"); + assert_parses("1 in 2"); + assert_parses("1 instanceof 2"); + assert_parses("1 << 2"); + assert_parses("1 >> 2"); + assert_parses("1 >>> 2"); + assert_parses("1 + 2"); + assert_parses("1 - 2"); + assert_parses("1 * 2"); + assert_parses("1 / 2"); + assert_parses("1 % 2"); + assert_parses("1 ** 2"); + assert_parses("1 , 2"); + assert_parses("1 || 2"); + assert_parses("1 && 2"); + assert_parses("1 | 2"); + assert_parses("1 ^ 2"); + assert_parses("1 & 2"); +} + +#[test] +fn test_coalesce() { + assert_parses("const f = options.prop ?? 0;"); + assert_syntax_error("if (options.prop ?? 0 || options.prop > 1000) {}"); +} + +#[test] +fn test_no_line_terminator_here() { + // Parse `code` as a Script and compute some function of the resulting AST. + fn parse_then(code: &str, f: F) -> R + where + F: FnOnce(&Script) -> R, + { + let allocator = &Bump::new(); + match try_parse(allocator, code) { + Err(err) => { + panic!("Failed to parse code {:?}: {}", code, err); + } + Ok(script) => f(&*script), + } + } + + // Parse `code` as a Script and return the number of top-level + // StatementListItems. + fn count_items(code: &str) -> usize { + parse_then(code, |script| script.statements.len()) + } + + // Without a newline, labelled `break` in loop. But a line break changes + // the meaning -- then it's a plain `break` statement, followed by + // ExpressionStatement `LOOP;` + assert_eq!(count_items("LOOP: while (true) break LOOP;"), 1); + assert_eq!(count_items("LOOP: while (true) break \n LOOP;"), 2); + + // The same, but for `continue`. + assert_eq!(count_items("LOOP: while (true) continue LOOP;"), 1); + assert_eq!(count_items("LOOP: while (true) continue \n LOOP;"), 2); + + // Parse `code` as a Script, expected to contain a single function + // declaration, and return the number of statements in the function body. + fn count_statements_in_function(code: &str) -> usize { + parse_then(code, |script| { + assert_eq!( + script.statements.len(), + 1, + "expected function declaration, got {:?}", + script + ); + match &script.statements[0] { + Statement::FunctionDeclaration(func) => func.body.statements.len(), + _ => panic!("expected function declaration, got {:?}", script), + } + }) + } + + assert_eq!( + count_statements_in_function("function f() { return x; }"), + 1 + ); + assert_eq!( + count_statements_in_function("function f() { return\n x; }"), + 2 + ); + + assert_parses("x++"); + assert_incomplete("x\n++"); + + assert_parses("throw fit;"); + assert_syntax_error("throw\nfit;"); + + // Alternative ways of spelling LineTerminator + assert_syntax_error("throw//\nfit;"); + assert_syntax_error("throw/*\n*/fit;"); + assert_syntax_error("throw\rfit;"); + assert_syntax_error("throw\r\nfit;"); +} diff --git a/third_party/rust/jsparagus-parser/src/unicode.rs b/third_party/rust/jsparagus-parser/src/unicode.rs new file mode 100644 index 0000000000..16bfc1fe85 --- /dev/null +++ b/third_party/rust/jsparagus-parser/src/unicode.rs @@ -0,0 +1,41 @@ +use crate::unicode_data::{ + char_info, is_id_continue_non_bmp, is_id_start_non_bmp, IS_ID_CONTINUE_TABLE, IS_ID_START_TABLE, +}; + +const UTF16_MAX: char = '\u{ffff}'; + +fn is_id_start_ascii(c: char) -> bool { + IS_ID_START_TABLE[c as usize] +} + +fn is_id_continue_ascii(c: char) -> bool { + IS_ID_CONTINUE_TABLE[c as usize] +} + +fn is_id_start_bmp_non_ascii(c: char) -> bool { + char_info(c).is_id_start() +} + +fn is_id_continue_bmp_non_ascii(c: char) -> bool { + char_info(c).is_id_continue() +} + +pub fn is_id_start(c: char) -> bool { + if c > UTF16_MAX { + return is_id_start_non_bmp(c); + } + if c < '\u{80}' { + return is_id_start_ascii(c); + } + is_id_start_bmp_non_ascii(c) +} + +pub fn is_id_continue(c: char) -> bool { + if c > UTF16_MAX { + return is_id_continue_non_bmp(c); + } + if c < '\u{80}' { + return is_id_continue_ascii(c); + } + is_id_continue_bmp_non_ascii(c) +} diff --git a/third_party/rust/jsparagus-parser/src/unicode_data.rs b/third_party/rust/jsparagus-parser/src/unicode_data.rs new file mode 100644 index 0000000000..7b2acb773b --- /dev/null +++ b/third_party/rust/jsparagus-parser/src/unicode_data.rs @@ -0,0 +1,2117 @@ +// Generated by update_unicode.py DO NOT MODIFY +// Unicode version: 14.0.0 + +const FLAG_ID_START: u8 = 1; +const FLAG_ID_CONTINUE: u8 = 2; + +pub struct CharInfo { + flags: u8, +} + +impl CharInfo { + pub fn is_id_start(&self) -> bool { + self.flags & FLAG_ID_START != 0 + } + + pub fn is_id_continue(&self) -> bool { + self.flags & FLAG_ID_CONTINUE != 0 + } +} + +pub const CHAR_INFO_TABLE: &'static [CharInfo] = &[ + CharInfo { flags: 0 }, + CharInfo { flags: 2 }, + CharInfo { flags: 3 }, +]; + +pub const INDEX1: &'static [u8] = &[ + 0, 0, 0, 1, 2, 3, 2, 4, 0, 0, 5, 6, 7, 8, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 9, 10, 11, 0, 12, 12, 12, 12, 12, 12, 12, 13, 14, 7, 15, 7, + 7, 7, 7, 16, 7, 7, 7, 7, 7, 7, 7, 7, 17, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 18, 7, 7, 19, 20, + 12, 21, 22, 7, 23, 24, 0, 25, 7, 7, 26, 12, 27, 28, 7, 7, 7, 7, 7, 29, 30, 31, 0, 32, 7, 12, + 33, 7, 7, 7, 7, 7, 34, 35, 36, 7, 26, 37, 7, 38, 39, 0, 7, 40, 4, 7, 41, 42, 7, 7, 43, 12, 44, + 12, 45, 7, 7, 46, 12, 47, 48, 2, 49, 50, 51, 52, 53, 54, 48, 55, 56, 50, 51, 57, 58, 59, 60, + 61, 62, 15, 51, 63, 64, 65, 48, 66, 67, 50, 51, 63, 68, 69, 48, 70, 71, 72, 73, 74, 75, 76, 60, + 0, 77, 78, 51, 79, 80, 81, 48, 0, 82, 78, 51, 83, 80, 84, 48, 85, 86, 78, 7, 87, 88, 89, 48, + 90, 91, 92, 7, 93, 94, 95, 60, 96, 2, 7, 7, 97, 98, 1, 0, 0, 99, 7, 100, 101, 102, 103, 0, 0, + 65, 104, 1, 105, 106, 7, 107, 20, 108, 109, 12, 110, 111, 0, 0, 0, 7, 7, 26, 112, 1, 113, 114, + 115, 116, 117, 7, 7, 118, 7, 7, 119, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 120, 121, 7, 7, 120, 7, 7, 122, 123, 8, 7, 7, 7, 123, 7, 7, 7, 124, 125, 126, 7, 0, 7, 7, 7, + 7, 7, 127, 2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 128, 7, 2, 4, 7, 7, 7, 7, 129, 19, 7, 130, 7, 131, 7, 132, 133, + 134, 7, 7, 7, 135, 12, 136, 1, 0, 137, 1, 7, 7, 7, 7, 7, 19, 7, 7, 138, 7, 7, 7, 7, 139, 7, + 140, 141, 141, 60, 7, 142, 143, 7, 7, 144, 7, 145, 25, 0, 0, 7, 146, 7, 7, 7, 147, 12, 148, 1, + 1, 149, 21, 150, 0, 0, 0, 151, 7, 7, 135, 152, 1, 153, 154, 155, 7, 156, 36, 7, 7, 34, 154, 7, + 7, 135, 157, 158, 36, 7, 142, 19, 7, 7, 159, 0, 160, 161, 162, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 12, 12, 12, 12, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 127, 7, 7, 127, 163, 7, + 142, 7, 7, 7, 164, 165, 166, 107, 165, 0, 0, 0, 167, 168, 169, 0, 170, 0, 107, 0, 0, 0, 110, + 171, 168, 172, 173, 174, 175, 176, 0, 7, 7, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 177, 178, 7, 7, 118, 7, 7, 7, 179, 167, 7, 180, 181, 181, 181, 181, 12, 12, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 182, 0, 183, 184, 2, 7, 7, 7, 7, 185, 2, 7, 7, 7, 7, 119, 186, 7, 7, 2, 7, 7, 7, 7, 140, 0, 7, + 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 107, 0, 0, 0, 0, 7, 7, 142, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 107, 7, 187, 0, 7, 7, 188, 189, 7, 190, 7, 7, 7, 7, 7, 126, 0, 191, 192, + 7, 7, 7, 7, 7, 193, 7, 7, 7, 4, 194, 0, 192, 195, 7, 196, 0, 7, 7, 7, 197, 198, 7, 7, 135, 199, + 1, 12, 200, 36, 7, 201, 7, 202, 154, 7, 107, 45, 7, 7, 203, 204, 1, 205, 206, 7, 7, 207, 208, + 209, 1, 7, 210, 7, 7, 7, 211, 212, 213, 26, 214, 215, 216, 181, 7, 7, 119, 145, 7, 7, 7, 7, 7, + 7, 7, 217, 1, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 197, 7, 218, 7, 7, 144, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 142, 7, 7, 7, 7, 7, 7, 145, 0, 0, 180, 219, 51, 220, + 221, 7, 7, 7, 7, 7, 7, 10, 0, 222, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 142, 0, 7, 7, 7, 7, 192, 7, 7, 223, 0, 0, 144, 12, 0, 12, 224, 225, 0, 0, 226, 7, 7, 7, 7, + 7, 7, 7, 107, 0, 1, 2, 3, 2, 4, 227, 7, 7, 7, 7, 140, 228, 229, 0, 0, +]; + +pub const INDEX2: &'static [u8] = &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 2, 2, 0, 0, 2, 2, 2, 2, 0, 2, + 0, 0, 0, 0, 0, 0, 2, 1, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 1, 1, 1, 1, 0, 0, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, + 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, + 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, + 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, + 1, 1, 1, 1, 1, 2, 2, 1, 1, 0, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 0, 0, 2, + 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, + 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, + 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, + 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, + 2, 0, 2, 0, 0, 0, 2, 2, 2, 2, 0, 0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 2, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 1, 0, + 0, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 0, 1, 0, 1, 1, + 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 2, 2, 2, 0, 0, 1, 2, 1, 1, + 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, + 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 2, 2, 0, 2, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 2, 2, + 2, 0, 2, 2, 2, 2, 0, 0, 0, 2, 2, 0, 2, 0, 2, 2, 0, 0, 0, 2, 2, 0, 0, 0, 2, 2, 2, 0, 0, 0, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, + 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 1, 2, 1, 1, + 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 2, 2, 2, 0, 0, 2, 0, 0, + 2, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 0, 1, 2, 1, 1, + 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 2, 1, 1, + 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 0, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, + 2, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, + 2, 2, 2, 2, 2, 0, 2, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 2, 2, 2, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, + 1, 2, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, + 2, 2, 2, 2, 2, 2, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 0, 0, + 2, 0, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 2, 2, + 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, + 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 0, 0, 0, 2, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, + 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, 2, 2, + 2, 2, 2, 2, 1, 2, 2, 1, 1, 1, 2, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 2, 0, 2, 0, 2, + 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 0, 0, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, + 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, + 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, + 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 1, + 1, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, + 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 0, + 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, + 0, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 1, 1, 2, 2, 2, 2, 2, + 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, + 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, + 2, 2, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 2, 2, 2, 2, 2, 2, 0, 0, 0, 2, 0, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 2, 1, 1, 1, 2, 2, 1, 2, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 1, + 2, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, + 0, 0, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 0, + 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 2, 1, 2, + 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, + 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 0, 0, 0, +]; + +const SHIFT: usize = 4; + +pub fn char_info(c: char) -> &'static CharInfo { + let code = c as usize; + let index = INDEX1[code >> SHIFT] as usize; + let index = INDEX2[(index << SHIFT) + (code & ((1 << SHIFT) - 1))] as usize; + + &CHAR_INFO_TABLE[index] +} + +pub const IS_ID_START_TABLE: &'static [bool] = &[ + false, false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, false, false, false, false, + true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, + true, true, true, true, true, true, true, true, true, true, false, false, false, false, false, + false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, + true, true, true, true, true, true, true, true, true, true, true, true, false, false, false, + false, false, +]; + +pub const IS_ID_CONTINUE_TABLE: &'static [bool] = &[ + false, false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, true, true, true, true, true, + true, true, true, true, true, false, false, false, false, false, false, false, true, true, + true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, + true, true, true, true, true, true, true, true, false, false, false, false, true, false, true, + true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, + true, true, true, true, true, true, true, true, true, false, false, false, false, false, +]; + +pub fn is_id_start_non_bmp(c: char) -> bool { + if c >= '\u{10000}' && c <= '\u{1000B}' { + return true; + } + if c >= '\u{1000D}' && c <= '\u{10026}' { + return true; + } + if c >= '\u{10028}' && c <= '\u{1003A}' { + return true; + } + if c >= '\u{1003C}' && c <= '\u{1003D}' { + return true; + } + if c >= '\u{1003F}' && c <= '\u{1004D}' { + return true; + } + if c >= '\u{10050}' && c <= '\u{1005D}' { + return true; + } + if c >= '\u{10080}' && c <= '\u{100FA}' { + return true; + } + if c >= '\u{10140}' && c <= '\u{10174}' { + return true; + } + if c >= '\u{10280}' && c <= '\u{1029C}' { + return true; + } + if c >= '\u{102A0}' && c <= '\u{102D0}' { + return true; + } + if c >= '\u{10300}' && c <= '\u{1031F}' { + return true; + } + if c >= '\u{1032D}' && c <= '\u{1034A}' { + return true; + } + if c >= '\u{10350}' && c <= '\u{10375}' { + return true; + } + if c >= '\u{10380}' && c <= '\u{1039D}' { + return true; + } + if c >= '\u{103A0}' && c <= '\u{103C3}' { + return true; + } + if c >= '\u{103C8}' && c <= '\u{103CF}' { + return true; + } + if c >= '\u{103D1}' && c <= '\u{103D5}' { + return true; + } + if c >= '\u{10400}' && c <= '\u{1049D}' { + return true; + } + if c >= '\u{104B0}' && c <= '\u{104D3}' { + return true; + } + if c >= '\u{104D8}' && c <= '\u{104FB}' { + return true; + } + if c >= '\u{10500}' && c <= '\u{10527}' { + return true; + } + if c >= '\u{10530}' && c <= '\u{10563}' { + return true; + } + if c >= '\u{10570}' && c <= '\u{1057A}' { + return true; + } + if c >= '\u{1057C}' && c <= '\u{1058A}' { + return true; + } + if c >= '\u{1058C}' && c <= '\u{10592}' { + return true; + } + if c >= '\u{10594}' && c <= '\u{10595}' { + return true; + } + if c >= '\u{10597}' && c <= '\u{105A1}' { + return true; + } + if c >= '\u{105A3}' && c <= '\u{105B1}' { + return true; + } + if c >= '\u{105B3}' && c <= '\u{105B9}' { + return true; + } + if c >= '\u{105BB}' && c <= '\u{105BC}' { + return true; + } + if c >= '\u{10600}' && c <= '\u{10736}' { + return true; + } + if c >= '\u{10740}' && c <= '\u{10755}' { + return true; + } + if c >= '\u{10760}' && c <= '\u{10767}' { + return true; + } + if c >= '\u{10780}' && c <= '\u{10785}' { + return true; + } + if c >= '\u{10787}' && c <= '\u{107B0}' { + return true; + } + if c >= '\u{107B2}' && c <= '\u{107BA}' { + return true; + } + if c >= '\u{10800}' && c <= '\u{10805}' { + return true; + } + if c >= '\u{10808}' && c <= '\u{10808}' { + return true; + } + if c >= '\u{1080A}' && c <= '\u{10835}' { + return true; + } + if c >= '\u{10837}' && c <= '\u{10838}' { + return true; + } + if c >= '\u{1083C}' && c <= '\u{1083C}' { + return true; + } + if c >= '\u{1083F}' && c <= '\u{10855}' { + return true; + } + if c >= '\u{10860}' && c <= '\u{10876}' { + return true; + } + if c >= '\u{10880}' && c <= '\u{1089E}' { + return true; + } + if c >= '\u{108E0}' && c <= '\u{108F2}' { + return true; + } + if c >= '\u{108F4}' && c <= '\u{108F5}' { + return true; + } + if c >= '\u{10900}' && c <= '\u{10915}' { + return true; + } + if c >= '\u{10920}' && c <= '\u{10939}' { + return true; + } + if c >= '\u{10980}' && c <= '\u{109B7}' { + return true; + } + if c >= '\u{109BE}' && c <= '\u{109BF}' { + return true; + } + if c >= '\u{10A00}' && c <= '\u{10A00}' { + return true; + } + if c >= '\u{10A10}' && c <= '\u{10A13}' { + return true; + } + if c >= '\u{10A15}' && c <= '\u{10A17}' { + return true; + } + if c >= '\u{10A19}' && c <= '\u{10A35}' { + return true; + } + if c >= '\u{10A60}' && c <= '\u{10A7C}' { + return true; + } + if c >= '\u{10A80}' && c <= '\u{10A9C}' { + return true; + } + if c >= '\u{10AC0}' && c <= '\u{10AC7}' { + return true; + } + if c >= '\u{10AC9}' && c <= '\u{10AE4}' { + return true; + } + if c >= '\u{10B00}' && c <= '\u{10B35}' { + return true; + } + if c >= '\u{10B40}' && c <= '\u{10B55}' { + return true; + } + if c >= '\u{10B60}' && c <= '\u{10B72}' { + return true; + } + if c >= '\u{10B80}' && c <= '\u{10B91}' { + return true; + } + if c >= '\u{10C00}' && c <= '\u{10C48}' { + return true; + } + if c >= '\u{10C80}' && c <= '\u{10CB2}' { + return true; + } + if c >= '\u{10CC0}' && c <= '\u{10CF2}' { + return true; + } + if c >= '\u{10D00}' && c <= '\u{10D23}' { + return true; + } + if c >= '\u{10E80}' && c <= '\u{10EA9}' { + return true; + } + if c >= '\u{10EB0}' && c <= '\u{10EB1}' { + return true; + } + if c >= '\u{10F00}' && c <= '\u{10F1C}' { + return true; + } + if c >= '\u{10F27}' && c <= '\u{10F27}' { + return true; + } + if c >= '\u{10F30}' && c <= '\u{10F45}' { + return true; + } + if c >= '\u{10F70}' && c <= '\u{10F81}' { + return true; + } + if c >= '\u{10FB0}' && c <= '\u{10FC4}' { + return true; + } + if c >= '\u{10FE0}' && c <= '\u{10FF6}' { + return true; + } + if c >= '\u{11003}' && c <= '\u{11037}' { + return true; + } + if c >= '\u{11071}' && c <= '\u{11072}' { + return true; + } + if c >= '\u{11075}' && c <= '\u{11075}' { + return true; + } + if c >= '\u{11083}' && c <= '\u{110AF}' { + return true; + } + if c >= '\u{110D0}' && c <= '\u{110E8}' { + return true; + } + if c >= '\u{11103}' && c <= '\u{11126}' { + return true; + } + if c >= '\u{11144}' && c <= '\u{11144}' { + return true; + } + if c >= '\u{11147}' && c <= '\u{11147}' { + return true; + } + if c >= '\u{11150}' && c <= '\u{11172}' { + return true; + } + if c >= '\u{11176}' && c <= '\u{11176}' { + return true; + } + if c >= '\u{11183}' && c <= '\u{111B2}' { + return true; + } + if c >= '\u{111C1}' && c <= '\u{111C4}' { + return true; + } + if c >= '\u{111DA}' && c <= '\u{111DA}' { + return true; + } + if c >= '\u{111DC}' && c <= '\u{111DC}' { + return true; + } + if c >= '\u{11200}' && c <= '\u{11211}' { + return true; + } + if c >= '\u{11213}' && c <= '\u{1122B}' { + return true; + } + if c >= '\u{11280}' && c <= '\u{11286}' { + return true; + } + if c >= '\u{11288}' && c <= '\u{11288}' { + return true; + } + if c >= '\u{1128A}' && c <= '\u{1128D}' { + return true; + } + if c >= '\u{1128F}' && c <= '\u{1129D}' { + return true; + } + if c >= '\u{1129F}' && c <= '\u{112A8}' { + return true; + } + if c >= '\u{112B0}' && c <= '\u{112DE}' { + return true; + } + if c >= '\u{11305}' && c <= '\u{1130C}' { + return true; + } + if c >= '\u{1130F}' && c <= '\u{11310}' { + return true; + } + if c >= '\u{11313}' && c <= '\u{11328}' { + return true; + } + if c >= '\u{1132A}' && c <= '\u{11330}' { + return true; + } + if c >= '\u{11332}' && c <= '\u{11333}' { + return true; + } + if c >= '\u{11335}' && c <= '\u{11339}' { + return true; + } + if c >= '\u{1133D}' && c <= '\u{1133D}' { + return true; + } + if c >= '\u{11350}' && c <= '\u{11350}' { + return true; + } + if c >= '\u{1135D}' && c <= '\u{11361}' { + return true; + } + if c >= '\u{11400}' && c <= '\u{11434}' { + return true; + } + if c >= '\u{11447}' && c <= '\u{1144A}' { + return true; + } + if c >= '\u{1145F}' && c <= '\u{11461}' { + return true; + } + if c >= '\u{11480}' && c <= '\u{114AF}' { + return true; + } + if c >= '\u{114C4}' && c <= '\u{114C5}' { + return true; + } + if c >= '\u{114C7}' && c <= '\u{114C7}' { + return true; + } + if c >= '\u{11580}' && c <= '\u{115AE}' { + return true; + } + if c >= '\u{115D8}' && c <= '\u{115DB}' { + return true; + } + if c >= '\u{11600}' && c <= '\u{1162F}' { + return true; + } + if c >= '\u{11644}' && c <= '\u{11644}' { + return true; + } + if c >= '\u{11680}' && c <= '\u{116AA}' { + return true; + } + if c >= '\u{116B8}' && c <= '\u{116B8}' { + return true; + } + if c >= '\u{11700}' && c <= '\u{1171A}' { + return true; + } + if c >= '\u{11740}' && c <= '\u{11746}' { + return true; + } + if c >= '\u{11800}' && c <= '\u{1182B}' { + return true; + } + if c >= '\u{118A0}' && c <= '\u{118DF}' { + return true; + } + if c >= '\u{118FF}' && c <= '\u{11906}' { + return true; + } + if c >= '\u{11909}' && c <= '\u{11909}' { + return true; + } + if c >= '\u{1190C}' && c <= '\u{11913}' { + return true; + } + if c >= '\u{11915}' && c <= '\u{11916}' { + return true; + } + if c >= '\u{11918}' && c <= '\u{1192F}' { + return true; + } + if c >= '\u{1193F}' && c <= '\u{1193F}' { + return true; + } + if c >= '\u{11941}' && c <= '\u{11941}' { + return true; + } + if c >= '\u{119A0}' && c <= '\u{119A7}' { + return true; + } + if c >= '\u{119AA}' && c <= '\u{119D0}' { + return true; + } + if c >= '\u{119E1}' && c <= '\u{119E1}' { + return true; + } + if c >= '\u{119E3}' && c <= '\u{119E3}' { + return true; + } + if c >= '\u{11A00}' && c <= '\u{11A00}' { + return true; + } + if c >= '\u{11A0B}' && c <= '\u{11A32}' { + return true; + } + if c >= '\u{11A3A}' && c <= '\u{11A3A}' { + return true; + } + if c >= '\u{11A50}' && c <= '\u{11A50}' { + return true; + } + if c >= '\u{11A5C}' && c <= '\u{11A89}' { + return true; + } + if c >= '\u{11A9D}' && c <= '\u{11A9D}' { + return true; + } + if c >= '\u{11AB0}' && c <= '\u{11AF8}' { + return true; + } + if c >= '\u{11C00}' && c <= '\u{11C08}' { + return true; + } + if c >= '\u{11C0A}' && c <= '\u{11C2E}' { + return true; + } + if c >= '\u{11C40}' && c <= '\u{11C40}' { + return true; + } + if c >= '\u{11C72}' && c <= '\u{11C8F}' { + return true; + } + if c >= '\u{11D00}' && c <= '\u{11D06}' { + return true; + } + if c >= '\u{11D08}' && c <= '\u{11D09}' { + return true; + } + if c >= '\u{11D0B}' && c <= '\u{11D30}' { + return true; + } + if c >= '\u{11D46}' && c <= '\u{11D46}' { + return true; + } + if c >= '\u{11D60}' && c <= '\u{11D65}' { + return true; + } + if c >= '\u{11D67}' && c <= '\u{11D68}' { + return true; + } + if c >= '\u{11D6A}' && c <= '\u{11D89}' { + return true; + } + if c >= '\u{11D98}' && c <= '\u{11D98}' { + return true; + } + if c >= '\u{11EE0}' && c <= '\u{11EF2}' { + return true; + } + if c >= '\u{11FB0}' && c <= '\u{11FB0}' { + return true; + } + if c >= '\u{12000}' && c <= '\u{12399}' { + return true; + } + if c >= '\u{12400}' && c <= '\u{1246E}' { + return true; + } + if c >= '\u{12480}' && c <= '\u{12543}' { + return true; + } + if c >= '\u{12F90}' && c <= '\u{12FF0}' { + return true; + } + if c >= '\u{13000}' && c <= '\u{1342E}' { + return true; + } + if c >= '\u{14400}' && c <= '\u{14646}' { + return true; + } + if c >= '\u{16800}' && c <= '\u{16A38}' { + return true; + } + if c >= '\u{16A40}' && c <= '\u{16A5E}' { + return true; + } + if c >= '\u{16A70}' && c <= '\u{16ABE}' { + return true; + } + if c >= '\u{16AD0}' && c <= '\u{16AED}' { + return true; + } + if c >= '\u{16B00}' && c <= '\u{16B2F}' { + return true; + } + if c >= '\u{16B40}' && c <= '\u{16B43}' { + return true; + } + if c >= '\u{16B63}' && c <= '\u{16B77}' { + return true; + } + if c >= '\u{16B7D}' && c <= '\u{16B8F}' { + return true; + } + if c >= '\u{16E40}' && c <= '\u{16E7F}' { + return true; + } + if c >= '\u{16F00}' && c <= '\u{16F4A}' { + return true; + } + if c >= '\u{16F50}' && c <= '\u{16F50}' { + return true; + } + if c >= '\u{16F93}' && c <= '\u{16F9F}' { + return true; + } + if c >= '\u{16FE0}' && c <= '\u{16FE1}' { + return true; + } + if c >= '\u{16FE3}' && c <= '\u{16FE3}' { + return true; + } + if c >= '\u{17000}' && c <= '\u{187F7}' { + return true; + } + if c >= '\u{18800}' && c <= '\u{18CD5}' { + return true; + } + if c >= '\u{18D00}' && c <= '\u{18D08}' { + return true; + } + if c >= '\u{1AFF0}' && c <= '\u{1AFF3}' { + return true; + } + if c >= '\u{1AFF5}' && c <= '\u{1AFFB}' { + return true; + } + if c >= '\u{1AFFD}' && c <= '\u{1AFFE}' { + return true; + } + if c >= '\u{1B000}' && c <= '\u{1B122}' { + return true; + } + if c >= '\u{1B150}' && c <= '\u{1B152}' { + return true; + } + if c >= '\u{1B164}' && c <= '\u{1B167}' { + return true; + } + if c >= '\u{1B170}' && c <= '\u{1B2FB}' { + return true; + } + if c >= '\u{1BC00}' && c <= '\u{1BC6A}' { + return true; + } + if c >= '\u{1BC70}' && c <= '\u{1BC7C}' { + return true; + } + if c >= '\u{1BC80}' && c <= '\u{1BC88}' { + return true; + } + if c >= '\u{1BC90}' && c <= '\u{1BC99}' { + return true; + } + if c >= '\u{1D400}' && c <= '\u{1D454}' { + return true; + } + if c >= '\u{1D456}' && c <= '\u{1D49C}' { + return true; + } + if c >= '\u{1D49E}' && c <= '\u{1D49F}' { + return true; + } + if c >= '\u{1D4A2}' && c <= '\u{1D4A2}' { + return true; + } + if c >= '\u{1D4A5}' && c <= '\u{1D4A6}' { + return true; + } + if c >= '\u{1D4A9}' && c <= '\u{1D4AC}' { + return true; + } + if c >= '\u{1D4AE}' && c <= '\u{1D4B9}' { + return true; + } + if c >= '\u{1D4BB}' && c <= '\u{1D4BB}' { + return true; + } + if c >= '\u{1D4BD}' && c <= '\u{1D4C3}' { + return true; + } + if c >= '\u{1D4C5}' && c <= '\u{1D505}' { + return true; + } + if c >= '\u{1D507}' && c <= '\u{1D50A}' { + return true; + } + if c >= '\u{1D50D}' && c <= '\u{1D514}' { + return true; + } + if c >= '\u{1D516}' && c <= '\u{1D51C}' { + return true; + } + if c >= '\u{1D51E}' && c <= '\u{1D539}' { + return true; + } + if c >= '\u{1D53B}' && c <= '\u{1D53E}' { + return true; + } + if c >= '\u{1D540}' && c <= '\u{1D544}' { + return true; + } + if c >= '\u{1D546}' && c <= '\u{1D546}' { + return true; + } + if c >= '\u{1D54A}' && c <= '\u{1D550}' { + return true; + } + if c >= '\u{1D552}' && c <= '\u{1D6A5}' { + return true; + } + if c >= '\u{1D6A8}' && c <= '\u{1D6C0}' { + return true; + } + if c >= '\u{1D6C2}' && c <= '\u{1D6DA}' { + return true; + } + if c >= '\u{1D6DC}' && c <= '\u{1D6FA}' { + return true; + } + if c >= '\u{1D6FC}' && c <= '\u{1D714}' { + return true; + } + if c >= '\u{1D716}' && c <= '\u{1D734}' { + return true; + } + if c >= '\u{1D736}' && c <= '\u{1D74E}' { + return true; + } + if c >= '\u{1D750}' && c <= '\u{1D76E}' { + return true; + } + if c >= '\u{1D770}' && c <= '\u{1D788}' { + return true; + } + if c >= '\u{1D78A}' && c <= '\u{1D7A8}' { + return true; + } + if c >= '\u{1D7AA}' && c <= '\u{1D7C2}' { + return true; + } + if c >= '\u{1D7C4}' && c <= '\u{1D7CB}' { + return true; + } + if c >= '\u{1DF00}' && c <= '\u{1DF1E}' { + return true; + } + if c >= '\u{1E100}' && c <= '\u{1E12C}' { + return true; + } + if c >= '\u{1E137}' && c <= '\u{1E13D}' { + return true; + } + if c >= '\u{1E14E}' && c <= '\u{1E14E}' { + return true; + } + if c >= '\u{1E290}' && c <= '\u{1E2AD}' { + return true; + } + if c >= '\u{1E2C0}' && c <= '\u{1E2EB}' { + return true; + } + if c >= '\u{1E7E0}' && c <= '\u{1E7E6}' { + return true; + } + if c >= '\u{1E7E8}' && c <= '\u{1E7EB}' { + return true; + } + if c >= '\u{1E7ED}' && c <= '\u{1E7EE}' { + return true; + } + if c >= '\u{1E7F0}' && c <= '\u{1E7FE}' { + return true; + } + if c >= '\u{1E800}' && c <= '\u{1E8C4}' { + return true; + } + if c >= '\u{1E900}' && c <= '\u{1E943}' { + return true; + } + if c >= '\u{1E94B}' && c <= '\u{1E94B}' { + return true; + } + if c >= '\u{1EE00}' && c <= '\u{1EE03}' { + return true; + } + if c >= '\u{1EE05}' && c <= '\u{1EE1F}' { + return true; + } + if c >= '\u{1EE21}' && c <= '\u{1EE22}' { + return true; + } + if c >= '\u{1EE24}' && c <= '\u{1EE24}' { + return true; + } + if c >= '\u{1EE27}' && c <= '\u{1EE27}' { + return true; + } + if c >= '\u{1EE29}' && c <= '\u{1EE32}' { + return true; + } + if c >= '\u{1EE34}' && c <= '\u{1EE37}' { + return true; + } + if c >= '\u{1EE39}' && c <= '\u{1EE39}' { + return true; + } + if c >= '\u{1EE3B}' && c <= '\u{1EE3B}' { + return true; + } + if c >= '\u{1EE42}' && c <= '\u{1EE42}' { + return true; + } + if c >= '\u{1EE47}' && c <= '\u{1EE47}' { + return true; + } + if c >= '\u{1EE49}' && c <= '\u{1EE49}' { + return true; + } + if c >= '\u{1EE4B}' && c <= '\u{1EE4B}' { + return true; + } + if c >= '\u{1EE4D}' && c <= '\u{1EE4F}' { + return true; + } + if c >= '\u{1EE51}' && c <= '\u{1EE52}' { + return true; + } + if c >= '\u{1EE54}' && c <= '\u{1EE54}' { + return true; + } + if c >= '\u{1EE57}' && c <= '\u{1EE57}' { + return true; + } + if c >= '\u{1EE59}' && c <= '\u{1EE59}' { + return true; + } + if c >= '\u{1EE5B}' && c <= '\u{1EE5B}' { + return true; + } + if c >= '\u{1EE5D}' && c <= '\u{1EE5D}' { + return true; + } + if c >= '\u{1EE5F}' && c <= '\u{1EE5F}' { + return true; + } + if c >= '\u{1EE61}' && c <= '\u{1EE62}' { + return true; + } + if c >= '\u{1EE64}' && c <= '\u{1EE64}' { + return true; + } + if c >= '\u{1EE67}' && c <= '\u{1EE6A}' { + return true; + } + if c >= '\u{1EE6C}' && c <= '\u{1EE72}' { + return true; + } + if c >= '\u{1EE74}' && c <= '\u{1EE77}' { + return true; + } + if c >= '\u{1EE79}' && c <= '\u{1EE7C}' { + return true; + } + if c >= '\u{1EE7E}' && c <= '\u{1EE7E}' { + return true; + } + if c >= '\u{1EE80}' && c <= '\u{1EE89}' { + return true; + } + if c >= '\u{1EE8B}' && c <= '\u{1EE9B}' { + return true; + } + if c >= '\u{1EEA1}' && c <= '\u{1EEA3}' { + return true; + } + if c >= '\u{1EEA5}' && c <= '\u{1EEA9}' { + return true; + } + if c >= '\u{1EEAB}' && c <= '\u{1EEBB}' { + return true; + } + if c >= '\u{20000}' && c <= '\u{2A6DF}' { + return true; + } + if c >= '\u{2A700}' && c <= '\u{2B738}' { + return true; + } + if c >= '\u{2B740}' && c <= '\u{2B81D}' { + return true; + } + if c >= '\u{2B820}' && c <= '\u{2CEA1}' { + return true; + } + if c >= '\u{2CEB0}' && c <= '\u{2EBE0}' { + return true; + } + if c >= '\u{2F800}' && c <= '\u{2FA1D}' { + return true; + } + if c >= '\u{30000}' && c <= '\u{3134A}' { + return true; + } + false +} + +pub fn is_id_continue_non_bmp(c: char) -> bool { + if c >= '\u{10000}' && c <= '\u{1000B}' { + return true; + } + if c >= '\u{1000D}' && c <= '\u{10026}' { + return true; + } + if c >= '\u{10028}' && c <= '\u{1003A}' { + return true; + } + if c >= '\u{1003C}' && c <= '\u{1003D}' { + return true; + } + if c >= '\u{1003F}' && c <= '\u{1004D}' { + return true; + } + if c >= '\u{10050}' && c <= '\u{1005D}' { + return true; + } + if c >= '\u{10080}' && c <= '\u{100FA}' { + return true; + } + if c >= '\u{10140}' && c <= '\u{10174}' { + return true; + } + if c >= '\u{101FD}' && c <= '\u{101FD}' { + return true; + } + if c >= '\u{10280}' && c <= '\u{1029C}' { + return true; + } + if c >= '\u{102A0}' && c <= '\u{102D0}' { + return true; + } + if c >= '\u{102E0}' && c <= '\u{102E0}' { + return true; + } + if c >= '\u{10300}' && c <= '\u{1031F}' { + return true; + } + if c >= '\u{1032D}' && c <= '\u{1034A}' { + return true; + } + if c >= '\u{10350}' && c <= '\u{1037A}' { + return true; + } + if c >= '\u{10380}' && c <= '\u{1039D}' { + return true; + } + if c >= '\u{103A0}' && c <= '\u{103C3}' { + return true; + } + if c >= '\u{103C8}' && c <= '\u{103CF}' { + return true; + } + if c >= '\u{103D1}' && c <= '\u{103D5}' { + return true; + } + if c >= '\u{10400}' && c <= '\u{1049D}' { + return true; + } + if c >= '\u{104A0}' && c <= '\u{104A9}' { + return true; + } + if c >= '\u{104B0}' && c <= '\u{104D3}' { + return true; + } + if c >= '\u{104D8}' && c <= '\u{104FB}' { + return true; + } + if c >= '\u{10500}' && c <= '\u{10527}' { + return true; + } + if c >= '\u{10530}' && c <= '\u{10563}' { + return true; + } + if c >= '\u{10570}' && c <= '\u{1057A}' { + return true; + } + if c >= '\u{1057C}' && c <= '\u{1058A}' { + return true; + } + if c >= '\u{1058C}' && c <= '\u{10592}' { + return true; + } + if c >= '\u{10594}' && c <= '\u{10595}' { + return true; + } + if c >= '\u{10597}' && c <= '\u{105A1}' { + return true; + } + if c >= '\u{105A3}' && c <= '\u{105B1}' { + return true; + } + if c >= '\u{105B3}' && c <= '\u{105B9}' { + return true; + } + if c >= '\u{105BB}' && c <= '\u{105BC}' { + return true; + } + if c >= '\u{10600}' && c <= '\u{10736}' { + return true; + } + if c >= '\u{10740}' && c <= '\u{10755}' { + return true; + } + if c >= '\u{10760}' && c <= '\u{10767}' { + return true; + } + if c >= '\u{10780}' && c <= '\u{10785}' { + return true; + } + if c >= '\u{10787}' && c <= '\u{107B0}' { + return true; + } + if c >= '\u{107B2}' && c <= '\u{107BA}' { + return true; + } + if c >= '\u{10800}' && c <= '\u{10805}' { + return true; + } + if c >= '\u{10808}' && c <= '\u{10808}' { + return true; + } + if c >= '\u{1080A}' && c <= '\u{10835}' { + return true; + } + if c >= '\u{10837}' && c <= '\u{10838}' { + return true; + } + if c >= '\u{1083C}' && c <= '\u{1083C}' { + return true; + } + if c >= '\u{1083F}' && c <= '\u{10855}' { + return true; + } + if c >= '\u{10860}' && c <= '\u{10876}' { + return true; + } + if c >= '\u{10880}' && c <= '\u{1089E}' { + return true; + } + if c >= '\u{108E0}' && c <= '\u{108F2}' { + return true; + } + if c >= '\u{108F4}' && c <= '\u{108F5}' { + return true; + } + if c >= '\u{10900}' && c <= '\u{10915}' { + return true; + } + if c >= '\u{10920}' && c <= '\u{10939}' { + return true; + } + if c >= '\u{10980}' && c <= '\u{109B7}' { + return true; + } + if c >= '\u{109BE}' && c <= '\u{109BF}' { + return true; + } + if c >= '\u{10A00}' && c <= '\u{10A03}' { + return true; + } + if c >= '\u{10A05}' && c <= '\u{10A06}' { + return true; + } + if c >= '\u{10A0C}' && c <= '\u{10A13}' { + return true; + } + if c >= '\u{10A15}' && c <= '\u{10A17}' { + return true; + } + if c >= '\u{10A19}' && c <= '\u{10A35}' { + return true; + } + if c >= '\u{10A38}' && c <= '\u{10A3A}' { + return true; + } + if c >= '\u{10A3F}' && c <= '\u{10A3F}' { + return true; + } + if c >= '\u{10A60}' && c <= '\u{10A7C}' { + return true; + } + if c >= '\u{10A80}' && c <= '\u{10A9C}' { + return true; + } + if c >= '\u{10AC0}' && c <= '\u{10AC7}' { + return true; + } + if c >= '\u{10AC9}' && c <= '\u{10AE6}' { + return true; + } + if c >= '\u{10B00}' && c <= '\u{10B35}' { + return true; + } + if c >= '\u{10B40}' && c <= '\u{10B55}' { + return true; + } + if c >= '\u{10B60}' && c <= '\u{10B72}' { + return true; + } + if c >= '\u{10B80}' && c <= '\u{10B91}' { + return true; + } + if c >= '\u{10C00}' && c <= '\u{10C48}' { + return true; + } + if c >= '\u{10C80}' && c <= '\u{10CB2}' { + return true; + } + if c >= '\u{10CC0}' && c <= '\u{10CF2}' { + return true; + } + if c >= '\u{10D00}' && c <= '\u{10D27}' { + return true; + } + if c >= '\u{10D30}' && c <= '\u{10D39}' { + return true; + } + if c >= '\u{10E80}' && c <= '\u{10EA9}' { + return true; + } + if c >= '\u{10EAB}' && c <= '\u{10EAC}' { + return true; + } + if c >= '\u{10EB0}' && c <= '\u{10EB1}' { + return true; + } + if c >= '\u{10F00}' && c <= '\u{10F1C}' { + return true; + } + if c >= '\u{10F27}' && c <= '\u{10F27}' { + return true; + } + if c >= '\u{10F30}' && c <= '\u{10F50}' { + return true; + } + if c >= '\u{10F70}' && c <= '\u{10F85}' { + return true; + } + if c >= '\u{10FB0}' && c <= '\u{10FC4}' { + return true; + } + if c >= '\u{10FE0}' && c <= '\u{10FF6}' { + return true; + } + if c >= '\u{11000}' && c <= '\u{11046}' { + return true; + } + if c >= '\u{11066}' && c <= '\u{11075}' { + return true; + } + if c >= '\u{1107F}' && c <= '\u{110BA}' { + return true; + } + if c >= '\u{110C2}' && c <= '\u{110C2}' { + return true; + } + if c >= '\u{110D0}' && c <= '\u{110E8}' { + return true; + } + if c >= '\u{110F0}' && c <= '\u{110F9}' { + return true; + } + if c >= '\u{11100}' && c <= '\u{11134}' { + return true; + } + if c >= '\u{11136}' && c <= '\u{1113F}' { + return true; + } + if c >= '\u{11144}' && c <= '\u{11147}' { + return true; + } + if c >= '\u{11150}' && c <= '\u{11173}' { + return true; + } + if c >= '\u{11176}' && c <= '\u{11176}' { + return true; + } + if c >= '\u{11180}' && c <= '\u{111C4}' { + return true; + } + if c >= '\u{111C9}' && c <= '\u{111CC}' { + return true; + } + if c >= '\u{111CE}' && c <= '\u{111DA}' { + return true; + } + if c >= '\u{111DC}' && c <= '\u{111DC}' { + return true; + } + if c >= '\u{11200}' && c <= '\u{11211}' { + return true; + } + if c >= '\u{11213}' && c <= '\u{11237}' { + return true; + } + if c >= '\u{1123E}' && c <= '\u{1123E}' { + return true; + } + if c >= '\u{11280}' && c <= '\u{11286}' { + return true; + } + if c >= '\u{11288}' && c <= '\u{11288}' { + return true; + } + if c >= '\u{1128A}' && c <= '\u{1128D}' { + return true; + } + if c >= '\u{1128F}' && c <= '\u{1129D}' { + return true; + } + if c >= '\u{1129F}' && c <= '\u{112A8}' { + return true; + } + if c >= '\u{112B0}' && c <= '\u{112EA}' { + return true; + } + if c >= '\u{112F0}' && c <= '\u{112F9}' { + return true; + } + if c >= '\u{11300}' && c <= '\u{11303}' { + return true; + } + if c >= '\u{11305}' && c <= '\u{1130C}' { + return true; + } + if c >= '\u{1130F}' && c <= '\u{11310}' { + return true; + } + if c >= '\u{11313}' && c <= '\u{11328}' { + return true; + } + if c >= '\u{1132A}' && c <= '\u{11330}' { + return true; + } + if c >= '\u{11332}' && c <= '\u{11333}' { + return true; + } + if c >= '\u{11335}' && c <= '\u{11339}' { + return true; + } + if c >= '\u{1133B}' && c <= '\u{11344}' { + return true; + } + if c >= '\u{11347}' && c <= '\u{11348}' { + return true; + } + if c >= '\u{1134B}' && c <= '\u{1134D}' { + return true; + } + if c >= '\u{11350}' && c <= '\u{11350}' { + return true; + } + if c >= '\u{11357}' && c <= '\u{11357}' { + return true; + } + if c >= '\u{1135D}' && c <= '\u{11363}' { + return true; + } + if c >= '\u{11366}' && c <= '\u{1136C}' { + return true; + } + if c >= '\u{11370}' && c <= '\u{11374}' { + return true; + } + if c >= '\u{11400}' && c <= '\u{1144A}' { + return true; + } + if c >= '\u{11450}' && c <= '\u{11459}' { + return true; + } + if c >= '\u{1145E}' && c <= '\u{11461}' { + return true; + } + if c >= '\u{11480}' && c <= '\u{114C5}' { + return true; + } + if c >= '\u{114C7}' && c <= '\u{114C7}' { + return true; + } + if c >= '\u{114D0}' && c <= '\u{114D9}' { + return true; + } + if c >= '\u{11580}' && c <= '\u{115B5}' { + return true; + } + if c >= '\u{115B8}' && c <= '\u{115C0}' { + return true; + } + if c >= '\u{115D8}' && c <= '\u{115DD}' { + return true; + } + if c >= '\u{11600}' && c <= '\u{11640}' { + return true; + } + if c >= '\u{11644}' && c <= '\u{11644}' { + return true; + } + if c >= '\u{11650}' && c <= '\u{11659}' { + return true; + } + if c >= '\u{11680}' && c <= '\u{116B8}' { + return true; + } + if c >= '\u{116C0}' && c <= '\u{116C9}' { + return true; + } + if c >= '\u{11700}' && c <= '\u{1171A}' { + return true; + } + if c >= '\u{1171D}' && c <= '\u{1172B}' { + return true; + } + if c >= '\u{11730}' && c <= '\u{11739}' { + return true; + } + if c >= '\u{11740}' && c <= '\u{11746}' { + return true; + } + if c >= '\u{11800}' && c <= '\u{1183A}' { + return true; + } + if c >= '\u{118A0}' && c <= '\u{118E9}' { + return true; + } + if c >= '\u{118FF}' && c <= '\u{11906}' { + return true; + } + if c >= '\u{11909}' && c <= '\u{11909}' { + return true; + } + if c >= '\u{1190C}' && c <= '\u{11913}' { + return true; + } + if c >= '\u{11915}' && c <= '\u{11916}' { + return true; + } + if c >= '\u{11918}' && c <= '\u{11935}' { + return true; + } + if c >= '\u{11937}' && c <= '\u{11938}' { + return true; + } + if c >= '\u{1193B}' && c <= '\u{11943}' { + return true; + } + if c >= '\u{11950}' && c <= '\u{11959}' { + return true; + } + if c >= '\u{119A0}' && c <= '\u{119A7}' { + return true; + } + if c >= '\u{119AA}' && c <= '\u{119D7}' { + return true; + } + if c >= '\u{119DA}' && c <= '\u{119E1}' { + return true; + } + if c >= '\u{119E3}' && c <= '\u{119E4}' { + return true; + } + if c >= '\u{11A00}' && c <= '\u{11A3E}' { + return true; + } + if c >= '\u{11A47}' && c <= '\u{11A47}' { + return true; + } + if c >= '\u{11A50}' && c <= '\u{11A99}' { + return true; + } + if c >= '\u{11A9D}' && c <= '\u{11A9D}' { + return true; + } + if c >= '\u{11AB0}' && c <= '\u{11AF8}' { + return true; + } + if c >= '\u{11C00}' && c <= '\u{11C08}' { + return true; + } + if c >= '\u{11C0A}' && c <= '\u{11C36}' { + return true; + } + if c >= '\u{11C38}' && c <= '\u{11C40}' { + return true; + } + if c >= '\u{11C50}' && c <= '\u{11C59}' { + return true; + } + if c >= '\u{11C72}' && c <= '\u{11C8F}' { + return true; + } + if c >= '\u{11C92}' && c <= '\u{11CA7}' { + return true; + } + if c >= '\u{11CA9}' && c <= '\u{11CB6}' { + return true; + } + if c >= '\u{11D00}' && c <= '\u{11D06}' { + return true; + } + if c >= '\u{11D08}' && c <= '\u{11D09}' { + return true; + } + if c >= '\u{11D0B}' && c <= '\u{11D36}' { + return true; + } + if c >= '\u{11D3A}' && c <= '\u{11D3A}' { + return true; + } + if c >= '\u{11D3C}' && c <= '\u{11D3D}' { + return true; + } + if c >= '\u{11D3F}' && c <= '\u{11D47}' { + return true; + } + if c >= '\u{11D50}' && c <= '\u{11D59}' { + return true; + } + if c >= '\u{11D60}' && c <= '\u{11D65}' { + return true; + } + if c >= '\u{11D67}' && c <= '\u{11D68}' { + return true; + } + if c >= '\u{11D6A}' && c <= '\u{11D8E}' { + return true; + } + if c >= '\u{11D90}' && c <= '\u{11D91}' { + return true; + } + if c >= '\u{11D93}' && c <= '\u{11D98}' { + return true; + } + if c >= '\u{11DA0}' && c <= '\u{11DA9}' { + return true; + } + if c >= '\u{11EE0}' && c <= '\u{11EF6}' { + return true; + } + if c >= '\u{11FB0}' && c <= '\u{11FB0}' { + return true; + } + if c >= '\u{12000}' && c <= '\u{12399}' { + return true; + } + if c >= '\u{12400}' && c <= '\u{1246E}' { + return true; + } + if c >= '\u{12480}' && c <= '\u{12543}' { + return true; + } + if c >= '\u{12F90}' && c <= '\u{12FF0}' { + return true; + } + if c >= '\u{13000}' && c <= '\u{1342E}' { + return true; + } + if c >= '\u{14400}' && c <= '\u{14646}' { + return true; + } + if c >= '\u{16800}' && c <= '\u{16A38}' { + return true; + } + if c >= '\u{16A40}' && c <= '\u{16A5E}' { + return true; + } + if c >= '\u{16A60}' && c <= '\u{16A69}' { + return true; + } + if c >= '\u{16A70}' && c <= '\u{16ABE}' { + return true; + } + if c >= '\u{16AC0}' && c <= '\u{16AC9}' { + return true; + } + if c >= '\u{16AD0}' && c <= '\u{16AED}' { + return true; + } + if c >= '\u{16AF0}' && c <= '\u{16AF4}' { + return true; + } + if c >= '\u{16B00}' && c <= '\u{16B36}' { + return true; + } + if c >= '\u{16B40}' && c <= '\u{16B43}' { + return true; + } + if c >= '\u{16B50}' && c <= '\u{16B59}' { + return true; + } + if c >= '\u{16B63}' && c <= '\u{16B77}' { + return true; + } + if c >= '\u{16B7D}' && c <= '\u{16B8F}' { + return true; + } + if c >= '\u{16E40}' && c <= '\u{16E7F}' { + return true; + } + if c >= '\u{16F00}' && c <= '\u{16F4A}' { + return true; + } + if c >= '\u{16F4F}' && c <= '\u{16F87}' { + return true; + } + if c >= '\u{16F8F}' && c <= '\u{16F9F}' { + return true; + } + if c >= '\u{16FE0}' && c <= '\u{16FE1}' { + return true; + } + if c >= '\u{16FE3}' && c <= '\u{16FE4}' { + return true; + } + if c >= '\u{16FF0}' && c <= '\u{16FF1}' { + return true; + } + if c >= '\u{17000}' && c <= '\u{187F7}' { + return true; + } + if c >= '\u{18800}' && c <= '\u{18CD5}' { + return true; + } + if c >= '\u{18D00}' && c <= '\u{18D08}' { + return true; + } + if c >= '\u{1AFF0}' && c <= '\u{1AFF3}' { + return true; + } + if c >= '\u{1AFF5}' && c <= '\u{1AFFB}' { + return true; + } + if c >= '\u{1AFFD}' && c <= '\u{1AFFE}' { + return true; + } + if c >= '\u{1B000}' && c <= '\u{1B122}' { + return true; + } + if c >= '\u{1B150}' && c <= '\u{1B152}' { + return true; + } + if c >= '\u{1B164}' && c <= '\u{1B167}' { + return true; + } + if c >= '\u{1B170}' && c <= '\u{1B2FB}' { + return true; + } + if c >= '\u{1BC00}' && c <= '\u{1BC6A}' { + return true; + } + if c >= '\u{1BC70}' && c <= '\u{1BC7C}' { + return true; + } + if c >= '\u{1BC80}' && c <= '\u{1BC88}' { + return true; + } + if c >= '\u{1BC90}' && c <= '\u{1BC99}' { + return true; + } + if c >= '\u{1BC9D}' && c <= '\u{1BC9E}' { + return true; + } + if c >= '\u{1CF00}' && c <= '\u{1CF2D}' { + return true; + } + if c >= '\u{1CF30}' && c <= '\u{1CF46}' { + return true; + } + if c >= '\u{1D165}' && c <= '\u{1D169}' { + return true; + } + if c >= '\u{1D16D}' && c <= '\u{1D172}' { + return true; + } + if c >= '\u{1D17B}' && c <= '\u{1D182}' { + return true; + } + if c >= '\u{1D185}' && c <= '\u{1D18B}' { + return true; + } + if c >= '\u{1D1AA}' && c <= '\u{1D1AD}' { + return true; + } + if c >= '\u{1D242}' && c <= '\u{1D244}' { + return true; + } + if c >= '\u{1D400}' && c <= '\u{1D454}' { + return true; + } + if c >= '\u{1D456}' && c <= '\u{1D49C}' { + return true; + } + if c >= '\u{1D49E}' && c <= '\u{1D49F}' { + return true; + } + if c >= '\u{1D4A2}' && c <= '\u{1D4A2}' { + return true; + } + if c >= '\u{1D4A5}' && c <= '\u{1D4A6}' { + return true; + } + if c >= '\u{1D4A9}' && c <= '\u{1D4AC}' { + return true; + } + if c >= '\u{1D4AE}' && c <= '\u{1D4B9}' { + return true; + } + if c >= '\u{1D4BB}' && c <= '\u{1D4BB}' { + return true; + } + if c >= '\u{1D4BD}' && c <= '\u{1D4C3}' { + return true; + } + if c >= '\u{1D4C5}' && c <= '\u{1D505}' { + return true; + } + if c >= '\u{1D507}' && c <= '\u{1D50A}' { + return true; + } + if c >= '\u{1D50D}' && c <= '\u{1D514}' { + return true; + } + if c >= '\u{1D516}' && c <= '\u{1D51C}' { + return true; + } + if c >= '\u{1D51E}' && c <= '\u{1D539}' { + return true; + } + if c >= '\u{1D53B}' && c <= '\u{1D53E}' { + return true; + } + if c >= '\u{1D540}' && c <= '\u{1D544}' { + return true; + } + if c >= '\u{1D546}' && c <= '\u{1D546}' { + return true; + } + if c >= '\u{1D54A}' && c <= '\u{1D550}' { + return true; + } + if c >= '\u{1D552}' && c <= '\u{1D6A5}' { + return true; + } + if c >= '\u{1D6A8}' && c <= '\u{1D6C0}' { + return true; + } + if c >= '\u{1D6C2}' && c <= '\u{1D6DA}' { + return true; + } + if c >= '\u{1D6DC}' && c <= '\u{1D6FA}' { + return true; + } + if c >= '\u{1D6FC}' && c <= '\u{1D714}' { + return true; + } + if c >= '\u{1D716}' && c <= '\u{1D734}' { + return true; + } + if c >= '\u{1D736}' && c <= '\u{1D74E}' { + return true; + } + if c >= '\u{1D750}' && c <= '\u{1D76E}' { + return true; + } + if c >= '\u{1D770}' && c <= '\u{1D788}' { + return true; + } + if c >= '\u{1D78A}' && c <= '\u{1D7A8}' { + return true; + } + if c >= '\u{1D7AA}' && c <= '\u{1D7C2}' { + return true; + } + if c >= '\u{1D7C4}' && c <= '\u{1D7CB}' { + return true; + } + if c >= '\u{1D7CE}' && c <= '\u{1D7FF}' { + return true; + } + if c >= '\u{1DA00}' && c <= '\u{1DA36}' { + return true; + } + if c >= '\u{1DA3B}' && c <= '\u{1DA6C}' { + return true; + } + if c >= '\u{1DA75}' && c <= '\u{1DA75}' { + return true; + } + if c >= '\u{1DA84}' && c <= '\u{1DA84}' { + return true; + } + if c >= '\u{1DA9B}' && c <= '\u{1DA9F}' { + return true; + } + if c >= '\u{1DAA1}' && c <= '\u{1DAAF}' { + return true; + } + if c >= '\u{1DF00}' && c <= '\u{1DF1E}' { + return true; + } + if c >= '\u{1E000}' && c <= '\u{1E006}' { + return true; + } + if c >= '\u{1E008}' && c <= '\u{1E018}' { + return true; + } + if c >= '\u{1E01B}' && c <= '\u{1E021}' { + return true; + } + if c >= '\u{1E023}' && c <= '\u{1E024}' { + return true; + } + if c >= '\u{1E026}' && c <= '\u{1E02A}' { + return true; + } + if c >= '\u{1E100}' && c <= '\u{1E12C}' { + return true; + } + if c >= '\u{1E130}' && c <= '\u{1E13D}' { + return true; + } + if c >= '\u{1E140}' && c <= '\u{1E149}' { + return true; + } + if c >= '\u{1E14E}' && c <= '\u{1E14E}' { + return true; + } + if c >= '\u{1E290}' && c <= '\u{1E2AE}' { + return true; + } + if c >= '\u{1E2C0}' && c <= '\u{1E2F9}' { + return true; + } + if c >= '\u{1E7E0}' && c <= '\u{1E7E6}' { + return true; + } + if c >= '\u{1E7E8}' && c <= '\u{1E7EB}' { + return true; + } + if c >= '\u{1E7ED}' && c <= '\u{1E7EE}' { + return true; + } + if c >= '\u{1E7F0}' && c <= '\u{1E7FE}' { + return true; + } + if c >= '\u{1E800}' && c <= '\u{1E8C4}' { + return true; + } + if c >= '\u{1E8D0}' && c <= '\u{1E8D6}' { + return true; + } + if c >= '\u{1E900}' && c <= '\u{1E94B}' { + return true; + } + if c >= '\u{1E950}' && c <= '\u{1E959}' { + return true; + } + if c >= '\u{1EE00}' && c <= '\u{1EE03}' { + return true; + } + if c >= '\u{1EE05}' && c <= '\u{1EE1F}' { + return true; + } + if c >= '\u{1EE21}' && c <= '\u{1EE22}' { + return true; + } + if c >= '\u{1EE24}' && c <= '\u{1EE24}' { + return true; + } + if c >= '\u{1EE27}' && c <= '\u{1EE27}' { + return true; + } + if c >= '\u{1EE29}' && c <= '\u{1EE32}' { + return true; + } + if c >= '\u{1EE34}' && c <= '\u{1EE37}' { + return true; + } + if c >= '\u{1EE39}' && c <= '\u{1EE39}' { + return true; + } + if c >= '\u{1EE3B}' && c <= '\u{1EE3B}' { + return true; + } + if c >= '\u{1EE42}' && c <= '\u{1EE42}' { + return true; + } + if c >= '\u{1EE47}' && c <= '\u{1EE47}' { + return true; + } + if c >= '\u{1EE49}' && c <= '\u{1EE49}' { + return true; + } + if c >= '\u{1EE4B}' && c <= '\u{1EE4B}' { + return true; + } + if c >= '\u{1EE4D}' && c <= '\u{1EE4F}' { + return true; + } + if c >= '\u{1EE51}' && c <= '\u{1EE52}' { + return true; + } + if c >= '\u{1EE54}' && c <= '\u{1EE54}' { + return true; + } + if c >= '\u{1EE57}' && c <= '\u{1EE57}' { + return true; + } + if c >= '\u{1EE59}' && c <= '\u{1EE59}' { + return true; + } + if c >= '\u{1EE5B}' && c <= '\u{1EE5B}' { + return true; + } + if c >= '\u{1EE5D}' && c <= '\u{1EE5D}' { + return true; + } + if c >= '\u{1EE5F}' && c <= '\u{1EE5F}' { + return true; + } + if c >= '\u{1EE61}' && c <= '\u{1EE62}' { + return true; + } + if c >= '\u{1EE64}' && c <= '\u{1EE64}' { + return true; + } + if c >= '\u{1EE67}' && c <= '\u{1EE6A}' { + return true; + } + if c >= '\u{1EE6C}' && c <= '\u{1EE72}' { + return true; + } + if c >= '\u{1EE74}' && c <= '\u{1EE77}' { + return true; + } + if c >= '\u{1EE79}' && c <= '\u{1EE7C}' { + return true; + } + if c >= '\u{1EE7E}' && c <= '\u{1EE7E}' { + return true; + } + if c >= '\u{1EE80}' && c <= '\u{1EE89}' { + return true; + } + if c >= '\u{1EE8B}' && c <= '\u{1EE9B}' { + return true; + } + if c >= '\u{1EEA1}' && c <= '\u{1EEA3}' { + return true; + } + if c >= '\u{1EEA5}' && c <= '\u{1EEA9}' { + return true; + } + if c >= '\u{1EEAB}' && c <= '\u{1EEBB}' { + return true; + } + if c >= '\u{1FBF0}' && c <= '\u{1FBF9}' { + return true; + } + if c >= '\u{20000}' && c <= '\u{2A6DF}' { + return true; + } + if c >= '\u{2A700}' && c <= '\u{2B738}' { + return true; + } + if c >= '\u{2B740}' && c <= '\u{2B81D}' { + return true; + } + if c >= '\u{2B820}' && c <= '\u{2CEA1}' { + return true; + } + if c >= '\u{2CEB0}' && c <= '\u{2EBE0}' { + return true; + } + if c >= '\u{2F800}' && c <= '\u{2FA1D}' { + return true; + } + if c >= '\u{30000}' && c <= '\u{3134A}' { + return true; + } + if c >= '\u{E0100}' && c <= '\u{E01EF}' { + return true; + } + false +} -- cgit v1.2.3