mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Backed out 3 changesets (bug 1505343) for build bustages in testBinASTReader.cpp CLOSED TREE 

Backed out changeset 4ac13d1f0d7c (bug 1505343)
Backed out changeset b2456f6d11c4 (bug 1505343)
Backed out changeset c1e2b7779d6a (bug 1505343)

--HG--
rename : js/src/frontend/BinAST-macros.h => js/src/frontend/BinSource-macros.h
rename : js/src/frontend/BinAST.webidl_ => js/src/frontend/BinSource.webidl_
rename : js/src/frontend/BinAST.yaml => js/src/frontend/BinSource.yaml
rename : js/src/frontend/BinASTRuntimeSupport.cpp => js/src/frontend/BinSourceRuntimeSupport.cpp
rename : js/src/frontend/BinASTRuntimeSupport.h => js/src/frontend/BinSourceRuntimeSupport.h
rename : js/src/frontend/BinASTToken.cpp => js/src/frontend/BinToken.cpp
rename : js/src/frontend/BinASTToken.h => js/src/frontend/BinToken.h
rename : js/src/frontend/BinASTTokenReaderBase.cpp => js/src/frontend/BinTokenReaderBase.cpp
rename : js/src/frontend/BinASTTokenReaderBase.h => js/src/frontend/BinTokenReaderBase.h
rename : js/src/frontend/BinASTTokenReaderMultipart.cpp => js/src/frontend/BinTokenReaderMultipart.cpp
rename : js/src/frontend/BinASTTokenReaderMultipart.h => js/src/frontend/BinTokenReaderMultipart.h
rename : js/src/frontend/binast/Cargo.toml => js/src/frontend/binsource/Cargo.toml
rename : js/src/frontend/binast/README.md => js/src/frontend/binsource/README.md
rename : js/src/frontend/binast/build.sh => js/src/frontend/binsource/build.sh
rename : js/src/frontend/binast/moz.build => js/src/frontend/binsource/moz.build
rename : js/src/frontend/binast/src/main.rs => js/src/frontend/binsource/src/main.rs
rename : js/src/frontend/binast/src/refgraph.rs => js/src/frontend/binsource/src/refgraph.rs
This commit is contained in:
Noemi Erli 2019-03-13 05:26:34 +02:00
Родитель 6532cbeb1f
Коммит d2f8c37768
33 изменённых файлов: 1348 добавлений и 1362 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
Cargo.toml
Просмотреть файл

@ -9,7 +9,7 @@ members = [
"js/src/rust",
"js/src/wasm/cranelift",
"js/rust",
"js/src/frontend/binast", # Code generator.
"js/src/frontend/binsource", # Code generator.
"testing/geckodriver",
"toolkit/crashreporter/rust",
"toolkit/library/gtest/rust",

2
js/src/frontend/BinASTEnum.h
Просмотреть файл

@ -7,7 +7,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// To generate this file, see the documentation in
// js/src/frontend/binast/README.md.
// js/src/frontend/binsource/README.md.
#ifndef frontend_BinASTEnum_h
#define frontend_BinASTEnum_h

1342
js/src/frontend/BinASTParser.cpp
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

361
js/src/frontend/BinASTParser.h
Просмотреть файл

@ -7,7 +7,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// To generate this file, see the documentation in
// js/src/frontend/binast/README.md.
// js/src/frontend/binsource/README.md.
#ifndef frontend_BinASTParser_h
#define frontend_BinASTParser_h
@ -16,8 +16,8 @@
#include "frontend/BCEParserHandle.h"
#include "frontend/BinASTParserPerTokenizer.h"
#include "frontend/BinASTToken.h"
#include "frontend/BinASTTokenReaderMultipart.h"
#include "frontend/BinToken.h"
#include "frontend/BinTokenReaderMultipart.h"
#include "frontend/FullParseHandler.h"
#include "frontend/ParseContext.h"
#include "frontend/ParseNode.h"
@ -38,7 +38,7 @@ class BinASTParser : public BinASTParserPerTokenizer<Tok> {
using Tokenizer = Tok;
using BinASTFields = typename Tokenizer::BinASTFields;
using BinFields = typename Tokenizer::BinFields;
using AutoList = typename Tokenizer::AutoList;
using AutoTaggedTuple = typename Tokenizer::AutoTaggedTuple;
using Chars = typename Tokenizer::Chars;
@ -135,44 +135,42 @@ class BinASTParser : public BinASTParserPerTokenizer<Tok> {
JS::Result<ParseNode*> parseSpreadElementOrExpression();
JS::Result<ParseNode*> parseStatement();
JS::Result<Ok> parseSumAssertedMaybePositionalParameterName(
const size_t start, const BinASTKind kind, const BinASTFields& fields,
const size_t start, const BinKind kind, const BinFields& fields,
AssertedScopeKind scopeKind,
MutableHandle<GCVector<JSAtom*>> positionalParams);
JS::Result<ParseNode*> parseSumAssignmentTarget(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
JS::Result<ParseNode*> parseSumBinding(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseSumBinding(const size_t start, const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseSumExpression(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseSumExpressionOrSuper(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseSumForInOfBindingOrAssignmentTarget(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseSumObjectProperty(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseSumParameter(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
JS::Result<ParseNode*> parseSumProgram(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseSumProgram(const size_t start, const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseSumPropertyName(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseSumSimpleAssignmentTarget(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseSumSpreadElementOrExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseSumStatement(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseSumVariableDeclarationOrExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
// ----- Interfaces (by lexicographical order)
// `ParseNode*` may never be nullptr
@ -204,229 +202,252 @@ class BinASTParser : public BinASTParserPerTokenizer<Tok> {
JS::Result<ParseNode*> parseSwitchDefault();
JS::Result<ParseNode*> parseVariableDeclarator();
JS::Result<ParseNode*> parseInterfaceArrayAssignmentTarget(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceArrayBinding(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceArrayExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceArrayExpression(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<Ok> parseInterfaceAssertedBlockScope(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<Ok> parseInterfaceAssertedBoundName(const size_t start,
const BinASTKind kind,
const BinASTFields& fields,
const BinKind kind,
const BinFields& fields,
AssertedScopeKind scopeKind);
JS::Result<Ok> parseInterfaceAssertedBoundNamesScope(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<Ok> parseInterfaceAssertedBoundNamesScope(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<Ok> parseInterfaceAssertedDeclaredName(
const size_t start, const BinASTKind kind, const BinASTFields& fields,
const size_t start, const BinKind kind, const BinFields& fields,
AssertedScopeKind scopeKind);
JS::Result<Ok> parseInterfaceAssertedParameterScope(
const size_t start, const BinASTKind kind, const BinASTFields& fields,
const size_t start, const BinKind kind, const BinFields& fields,
MutableHandle<GCVector<JSAtom*>> positionalParams);
JS::Result<Ok> parseInterfaceAssertedPositionalParameterName(
const size_t start, const BinASTKind kind, const BinASTFields& fields,
const size_t start, const BinKind kind, const BinFields& fields,
AssertedScopeKind scopeKind,
MutableHandle<GCVector<JSAtom*>> positionalParams);
JS::Result<Ok> parseInterfaceAssertedScriptGlobalScope(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<Ok> parseInterfaceAssertedVarScope(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceAssignmentExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceAssignmentTargetIdentifier(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceAwaitExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceAwaitExpression(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceBinaryExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceBindingIdentifier(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceBindingWithInitializer(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceBlock(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceBreakStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceCallExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceBreakStatement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceCallExpression(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<LexicalScopeNode*> parseInterfaceCatchClause(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceClassDeclaration(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceClassExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceClassExpression(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceCompoundAssignmentExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceComputedMemberAssignmentTarget(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceComputedMemberExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceComputedPropertyName(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceConditionalExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceContinueStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceDataProperty(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceDebuggerStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceDirective(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceDoWhileStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceEagerArrowExpressionWithExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceEagerArrowExpressionWithFunctionBody(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceEagerFunctionDeclaration(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceEagerFunctionExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceEagerGetter(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceEagerMethod(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceEagerSetter(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceEmptyStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceEmptyStatement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceExpressionStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceForInOfBinding(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceForInStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceForOfStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceForInOfBinding(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceForInStatement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceForOfStatement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceForStatement(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
JS::Result<ListNode*> parseInterfaceFormalParameters(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ListNode*> parseInterfaceFormalParameters(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<Ok> parseInterfaceFunctionExpressionContents(
const size_t start, const BinASTKind kind, const BinASTFields& fields,
const size_t start, const BinKind kind, const BinFields& fields,
uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut);
JS::Result<Ok> parseInterfaceFunctionOrMethodContents(
const size_t start, const BinASTKind kind, const BinASTFields& fields,
const size_t start, const BinKind kind, const BinFields& fields,
uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut);
JS::Result<Ok> parseInterfaceGetterContents(
const size_t start, const BinASTKind kind, const BinASTFields& fields,
const size_t start, const BinKind kind, const BinFields& fields,
uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut);
JS::Result<ParseNode*> parseInterfaceIdentifierExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceIfStatement(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLabelledStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLazyArrowExpressionWithExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLazyArrowExpressionWithFunctionBody(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLazyFunctionDeclaration(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLazyFunctionExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLazyGetter(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLazyMethod(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLazySetter(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLiteralBooleanExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLiteralInfinityExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLiteralNullExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLiteralNumericExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLiteralPropertyName(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLiteralRegExpExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceLiteralStringExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceModule(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceNewExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceNewExpression(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceNewTargetExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceObjectAssignmentTarget(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceObjectBinding(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceObjectBinding(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceObjectExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceReturnStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceReturnStatement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceScript(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<Ok> parseInterfaceSetterContents(
const size_t start, const BinASTKind kind, const BinASTFields& fields,
const size_t start, const BinKind kind, const BinFields& fields,
uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut);
JS::Result<ParseNode*> parseInterfaceShorthandProperty(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceSpreadElement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceSpreadElement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceStaticMemberAssignmentTarget(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceStaticMemberExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceSuper(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<CaseClause*> parseInterfaceSwitchCase(const size_t start,
const BinASTKind kind,
const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceSwitchDefault(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceSwitchStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceSwitchDefault(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceSwitchStatement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceSwitchStatementWithDefault(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceTemplateExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceThisExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceThrowStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceThisExpression(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceThrowStatement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceTryCatchStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceTryFinallyStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceUnaryExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceUnaryExpression(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceUpdateExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceVariableDeclaration(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceVariableDeclarator(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceWhileStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceWithStatement(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
JS::Result<ParseNode*> parseInterfaceYieldExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceWhileStatement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceWithStatement(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceYieldExpression(const size_t start,
const BinKind kind,
const BinFields& fields);
JS::Result<ParseNode*> parseInterfaceYieldStarExpression(
const size_t start, const BinASTKind kind, const BinASTFields& fields);
const size_t start, const BinKind kind, const BinFields& fields);
// ----- String enums (by lexicographical order)
JS::Result<typename BinASTParser<Tok>::AssertedDeclaredKind>
@ -466,7 +487,7 @@ class BinASTParser : public BinASTParserPerTokenizer<Tok> {
JS::Result<ParseNode*> parseOptionalVariableDeclarationOrExpression();
};
extern template class BinASTParser<BinASTTokenReaderMultipart>;
extern template class BinASTParser<BinTokenReaderMultipart>;
} // namespace frontend
} // namespace js

75
js/src/frontend/BinASTParserPerTokenizer.cpp
Просмотреть файл

@ -14,9 +14,9 @@
#include "mozilla/ScopeExit.h"
#include "mozilla/Vector.h"
#include "frontend/BinAST-macros.h"
#include "frontend/BinASTParser.h"
#include "frontend/BinASTTokenReaderMultipart.h"
#include "frontend/BinSource-macros.h"
#include "frontend/BinTokenReaderMultipart.h"
#include "frontend/FullParseHandler.h"
#include "frontend/ParseNode.h"
#include "frontend/Parser.h"
@ -118,8 +118,7 @@ JS::Result<ParseNode*> BinASTParserPerTokenizer<Tok>::parseAux(
tokenizer_.emplace(cx_, this, start, length);
BinASTParseContext globalpc(cx_, this, globalsc,
/* newDirectives = */ nullptr);
BinParseContext globalpc(cx_, this, globalsc, /* newDirectives = */ nullptr);
if (!globalpc.init()) {
return cx_->alreadyReportedError();
}
@ -180,7 +179,7 @@ JS::Result<FunctionNode*> BinASTParserPerTokenizer<Tok>::parseLazyFunction(
// Push a new ParseContext. It will be used to parse `scope`, the arguments,
// the function.
BinASTParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
BINJS_TRY(funpc.init());
pc_->functionScope().useAsVarScope(pc_);
MOZ_ASSERT(pc_->isFunctionBox());
@ -197,9 +196,9 @@ JS::Result<FunctionNode*> BinASTParserPerTokenizer<Tok>::parseLazyFunction(
NewLexicalScopeData(cx_, lexicalScope, alloc_, pc_));
BINJS_TRY_DECL(body, handler_.newLexicalScope(*lexicalScopeData, tmpBody));
auto binASTKind = isExpr ? BinASTKind::LazyFunctionExpression
: BinASTKind::LazyFunctionDeclaration;
return buildFunction(firstOffset, binASTKind, nullptr, params, body);
auto binKind = isExpr ? BinKind::LazyFunctionExpression
: BinKind::LazyFunctionDeclaration;
return buildFunction(firstOffset, binKind, nullptr, params, body);
}
template <typename Tok>
@ -275,29 +274,29 @@ JS::Result<FunctionBox*> BinASTParserPerTokenizer<Tok>::buildFunctionBox(
return funbox;
}
FunctionSyntaxKind BinASTKindToFunctionSyntaxKind(const BinASTKind kind) {
FunctionSyntaxKind BinKindToFunctionSyntaxKind(const BinKind kind) {
// FIXME: this doesn't cover FunctionSyntaxKind::ClassConstructor and
// FunctionSyntaxKind::DerivedClassConstructor.
switch (kind) {
case BinASTKind::EagerFunctionDeclaration:
case BinASTKind::LazyFunctionDeclaration:
case BinKind::EagerFunctionDeclaration:
case BinKind::LazyFunctionDeclaration:
return FunctionSyntaxKind::Statement;
case BinASTKind::EagerFunctionExpression:
case BinASTKind::LazyFunctionExpression:
case BinKind::EagerFunctionExpression:
case BinKind::LazyFunctionExpression:
return FunctionSyntaxKind::Expression;
case BinASTKind::EagerArrowExpressionWithFunctionBody:
case BinASTKind::LazyArrowExpressionWithFunctionBody:
case BinASTKind::EagerArrowExpressionWithExpression:
case BinASTKind::LazyArrowExpressionWithExpression:
case BinKind::EagerArrowExpressionWithFunctionBody:
case BinKind::LazyArrowExpressionWithFunctionBody:
case BinKind::EagerArrowExpressionWithExpression:
case BinKind::LazyArrowExpressionWithExpression:
return FunctionSyntaxKind::Arrow;
case BinASTKind::EagerMethod:
case BinASTKind::LazyMethod:
case BinKind::EagerMethod:
case BinKind::LazyMethod:
return FunctionSyntaxKind::Method;
case BinASTKind::EagerGetter:
case BinASTKind::LazyGetter:
case BinKind::EagerGetter:
case BinKind::LazyGetter:
return FunctionSyntaxKind::Getter;
case BinASTKind::EagerSetter:
case BinASTKind::LazySetter:
case BinKind::EagerSetter:
case BinKind::LazySetter:
return FunctionSyntaxKind::Setter;
default:
MOZ_CRASH("Invalid/ kind");
@ -306,10 +305,10 @@ FunctionSyntaxKind BinASTKindToFunctionSyntaxKind(const BinASTKind kind) {
template <typename Tok>
JS::Result<FunctionNode*> BinASTParserPerTokenizer<Tok>::makeEmptyFunctionNode(
const size_t start, const BinASTKind kind, FunctionBox* funbox) {
const size_t start, const BinKind kind, FunctionBox* funbox) {
// LazyScript compilation requires basically none of the fields filled out.
TokenPos pos = tokenizer_->pos(start);
FunctionSyntaxKind syntaxKind = BinASTKindToFunctionSyntaxKind(kind);
FunctionSyntaxKind syntaxKind = BinKindToFunctionSyntaxKind(kind);
BINJS_TRY_DECL(result, handler_.newFunction(syntaxKind, pos));
@ -320,8 +319,8 @@ JS::Result<FunctionNode*> BinASTParserPerTokenizer<Tok>::makeEmptyFunctionNode(
template <typename Tok>
JS::Result<FunctionNode*> BinASTParserPerTokenizer<Tok>::buildFunction(
const size_t start, const BinASTKind kind, ParseNode* name,
ListNode* params, ParseNode* body) {
const size_t start, const BinKind kind, ParseNode* name, ListNode* params,
ParseNode* body) {
FunctionBox* funbox = pc_->functionBox();
// Set the argument count for building argument packets. Function.length is
@ -683,22 +682,22 @@ BinASTParserPerTokenizer<Tok>::raiseMissingDirectEvalInAssertedScope() {
template <typename Tok>
mozilla::GenericErrorResult<JS::Error&>
BinASTParserPerTokenizer<Tok>::raiseInvalidKind(const char* superKind,
const BinASTKind kind) {
const BinKind kind) {
Sprinter out(cx_);
BINJS_TRY(out.init());
BINJS_TRY(out.printf("In %s, invalid kind %s", superKind,
describeBinASTKind(kind)));
BINJS_TRY(
out.printf("In %s, invalid kind %s", superKind, describeBinKind(kind)));
return raiseError(out.string());
}
template <typename Tok>
mozilla::GenericErrorResult<JS::Error&>
BinASTParserPerTokenizer<Tok>::raiseInvalidVariant(const char* kind,
const BinASTVariant value) {
const BinVariant value) {
Sprinter out(cx_);
BINJS_TRY(out.init());
BINJS_TRY(out.printf("In %s, invalid variant '%s'", kind,
describeBinASTVariant(value)));
describeBinVariant(value)));
return raiseError(out.string());
}
@ -706,11 +705,11 @@ BinASTParserPerTokenizer<Tok>::raiseInvalidVariant(const char* kind,
template <typename Tok>
mozilla::GenericErrorResult<JS::Error&>
BinASTParserPerTokenizer<Tok>::raiseMissingField(const char* kind,
const BinASTField field) {
const BinField field) {
Sprinter out(cx_);
BINJS_TRY(out.init());
BINJS_TRY(out.printf("In %s, missing field '%s'", kind,
describeBinASTField(field)));
BINJS_TRY(
out.printf("In %s, missing field '%s'", kind, describeBinField(field)));
return raiseError(out.string());
}
@ -733,11 +732,11 @@ BinASTParserPerTokenizer<Tok>::raiseOOM() {
template <typename Tok>
mozilla::GenericErrorResult<JS::Error&>
BinASTParserPerTokenizer<Tok>::raiseError(BinASTKind kind,
BinASTParserPerTokenizer<Tok>::raiseError(BinKind kind,
const char* description) {
Sprinter out(cx_);
BINJS_TRY(out.init());
BINJS_TRY(out.printf("In %s, %s", describeBinASTKind(kind), description));
BINJS_TRY(out.printf("In %s, %s", describeBinKind(kind), description));
return tokenizer_->raiseError(out.string());
}
@ -806,7 +805,7 @@ BinASTParserPerTokenizer<Tok>::asFinalParser() const {
// Force class instantiation.
// This ensures that the symbols are built, without having to export all our
// code (and its baggage of #include and macros) in the header.
template class BinASTParserPerTokenizer<BinASTTokenReaderMultipart>;
template class BinASTParserPerTokenizer<BinTokenReaderMultipart>;
} // namespace frontend
} // namespace js

31
js/src/frontend/BinASTParserPerTokenizer.h
Просмотреть файл

@ -19,8 +19,8 @@
#include "frontend/BCEParserHandle.h"
#include "frontend/BinASTEnum.h"
#include "frontend/BinASTParserBase.h"
#include "frontend/BinASTToken.h"
#include "frontend/BinASTTokenReaderMultipart.h"
#include "frontend/BinToken.h"
#include "frontend/BinTokenReaderMultipart.h"
#include "frontend/FullParseHandler.h"
#include "frontend/ParseContext.h"
#include "frontend/ParseNode.h"
@ -54,7 +54,7 @@ class BinASTParserPerTokenizer : public BinASTParserBase,
using AutoList = typename Tokenizer::AutoList;
using AutoTaggedTuple = typename Tokenizer::AutoTaggedTuple;
using BinASTFields = typename Tokenizer::BinASTFields;
using BinFields = typename Tokenizer::BinFields;
using Chars = typename Tokenizer::Chars;
public:
@ -106,18 +106,18 @@ class BinASTParserPerTokenizer : public BinASTParserBase,
MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&>
raiseMissingDirectEvalInAssertedScope();
MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseInvalidKind(
const char* superKind, const BinASTKind kind);
const char* superKind, const BinKind kind);
MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseInvalidVariant(
const char* kind, const BinASTVariant value);
const char* kind, const BinVariant value);
MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseMissingField(
const char* kind, const BinASTField field);
const char* kind, const BinField field);
MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseEmpty(
const char* description);
MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseOOM();
MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseError(
const char* description);
MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseError(
BinASTKind kind, const char* description);
BinKind kind, const char* description);
// Ensure that this parser will never be used again.
void poison();
@ -136,13 +136,12 @@ class BinASTParserPerTokenizer : public BinASTParserBase,
// Build a function object for a function-producing production. Called AFTER
// creating the scope.
JS::Result<FunctionNode*> makeEmptyFunctionNode(const size_t start,
const BinASTKind kind,
const BinKind kind,
FunctionBox* funbox);
JS::Result<FunctionNode*> buildFunction(const size_t start,
const BinASTKind kind,
ParseNode* name, ListNode* params,
ParseNode* body);
const BinKind kind, ParseNode* name,
ListNode* params, ParseNode* body);
JS::Result<FunctionBox*> buildFunctionBox(GeneratorKind generatorKind,
FunctionAsyncKind functionAsyncKind,
FunctionSyntaxKind syntax,
@ -285,7 +284,7 @@ class BinASTParserPerTokenizer : public BinASTParserBase,
mozilla::Maybe<Tokenizer> tokenizer_;
VariableDeclarationKind variableDeclarationKind_;
friend class BinASTParseContext;
friend class BinParseContext;
friend class AutoVariableDeclarationKind;
// Helper class: Restore field `variableDeclarationKind` upon leaving a scope.
@ -315,18 +314,18 @@ class BinASTParserPerTokenizer : public BinASTParserBase,
inline const FinalParser* asFinalParser() const;
};
class BinASTParseContext : public ParseContext {
class BinParseContext : public ParseContext {
public:
template <typename Tok>
BinASTParseContext(JSContext* cx, BinASTParserPerTokenizer<Tok>* parser,
SharedContext* sc, Directives* newDirectives)
BinParseContext(JSContext* cx, BinASTParserPerTokenizer<Tok>* parser,
SharedContext* sc, Directives* newDirectives)
: ParseContext(cx, parser->pc_, sc, *parser, parser->usedNames_,
newDirectives, /* isFull = */ true) {}
};
void TraceBinASTParser(JSTracer* trc, JS::AutoGCRooter* parser);
extern template class BinASTParserPerTokenizer<BinASTTokenReaderMultipart>;
extern template class BinASTParserPerTokenizer<BinTokenReaderMultipart>;
} // namespace frontend
} // namespace js

155
js/src/frontend/BinASTToken.cpp
Просмотреть файл

@ -1,155 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "frontend/BinASTToken.h"
#include "mozilla/Maybe.h"
#include <sys/types.h>
#include "frontend/BinASTRuntimeSupport.h"
#include "frontend/TokenStream.h"
#include "js/Result.h"
#include "vm/JSContext.h"
namespace js {
namespace frontend {
const BinaryASTSupport::CharSlice BINASTKIND_DESCRIPTIONS[] = {
#define WITH_VARIANT(_, SPEC_NAME) \
BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1),
FOR_EACH_BIN_KIND(WITH_VARIANT)
#undef WITH_VARIANT
};
const BinaryASTSupport::CharSlice BINASTFIELD_DESCRIPTIONS[] = {
#define WITH_VARIANT(_, SPEC_NAME) \
BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1),
FOR_EACH_BIN_FIELD(WITH_VARIANT)
#undef WITH_VARIANT
};
const BinaryASTSupport::CharSlice BINASTVARIANT_DESCRIPTIONS[] = {
#define WITH_VARIANT(_, SPEC_NAME) \
BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1),
FOR_EACH_BIN_VARIANT(WITH_VARIANT)
#undef WITH_VARIANT
};
const BinaryASTSupport::CharSlice& getBinASTKind(const BinASTKind& variant) {
return BINASTKIND_DESCRIPTIONS[static_cast<size_t>(variant)];
}
const BinaryASTSupport::CharSlice& getBinASTVariant(
const BinASTVariant& variant) {
return BINASTVARIANT_DESCRIPTIONS[static_cast<size_t>(variant)];
}
const BinaryASTSupport::CharSlice& getBinASTField(const BinASTField& variant) {
return BINASTFIELD_DESCRIPTIONS[static_cast<size_t>(variant)];
}
const char* describeBinASTKind(const BinASTKind& variant) {
return getBinASTKind(variant).begin();
}
const char* describeBinASTField(const BinASTField& variant) {
return getBinASTField(variant).begin();
}
const char* describeBinASTVariant(const BinASTVariant& variant) {
return getBinASTVariant(variant).begin();
}
} // namespace frontend
BinaryASTSupport::BinaryASTSupport()
: binASTKindMap_(frontend::BINASTKIND_LIMIT),
binASTFieldMap_(frontend::BINASTFIELD_LIMIT),
binASTVariantMap_(frontend::BINASTVARIANT_LIMIT) {}
/**
* It is expected that all bin tables are initialized on the main thread, and
* that any helper threads will find the read-only tables properly initialized,
* so that they can do their accesses safely without taking any locks.
*/
bool BinaryASTSupport::ensureBinTablesInitialized(JSContext* cx) {
return ensureBinASTKindsInitialized(cx) &&
ensureBinASTVariantsInitialized(cx);
}
bool BinaryASTSupport::ensureBinASTKindsInitialized(JSContext* cx) {
MOZ_ASSERT(!cx->helperThread());
if (binASTKindMap_.empty()) {
for (size_t i = 0; i < frontend::BINASTKIND_LIMIT; ++i) {
const BinASTKind variant = static_cast<BinASTKind>(i);
const CharSlice& key = getBinASTKind(variant);
auto ptr = binASTKindMap_.lookupForAdd(key);
MOZ_ASSERT(!ptr);
if (!binASTKindMap_.add(ptr, key, variant)) {
ReportOutOfMemory(cx);
return false;
}
}
}
return true;
}
bool BinaryASTSupport::ensureBinASTVariantsInitialized(JSContext* cx) {
MOZ_ASSERT(!cx->helperThread());
if (binASTVariantMap_.empty()) {
for (size_t i = 0; i < frontend::BINASTVARIANT_LIMIT; ++i) {
const BinASTVariant variant = static_cast<BinASTVariant>(i);
const CharSlice& key = getBinASTVariant(variant);
auto ptr = binASTVariantMap_.lookupForAdd(key);
MOZ_ASSERT(!ptr);
if (!binASTVariantMap_.add(ptr, key, variant)) {
ReportOutOfMemory(cx);
return false;
}
}
}
return true;
}
JS::Result<const js::frontend::BinASTKind*> BinaryASTSupport::binASTKind(
JSContext* cx, const CharSlice key) {
MOZ_ASSERT_IF(cx->helperThread(), !binASTKindMap_.empty());
if (!cx->helperThread()) {
// Initialize Lazily if on main thread.
if (!ensureBinASTKindsInitialized(cx)) {
return cx->alreadyReportedError();
}
}
auto ptr = binASTKindMap_.readonlyThreadsafeLookup(key);
if (!ptr) {
return nullptr;
}
return &ptr->value();
}
JS::Result<const js::frontend::BinASTVariant*> BinaryASTSupport::binASTVariant(
JSContext* cx, const CharSlice key) {
MOZ_ASSERT_IF(cx->helperThread(), !binASTVariantMap_.empty());
if (!cx->helperThread()) {
// Initialize lazily if on main thread.
if (!ensureBinASTVariantsInitialized(cx)) {
return cx->alreadyReportedError();
}
}
auto ptr = binASTVariantMap_.readonlyThreadsafeLookup(key);
if (!ptr) {
return nullptr;
}
return &ptr->value();
}
} // namespace js

6
js/src/frontend/BinAST-macros.h → js/src/frontend/BinSource-macros.h
Просмотреть файл

@ -4,8 +4,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef frontend_BinAST_macros_h
#define frontend_BinAST_macros_h
#ifndef frontend_BinSource_macros_h
#define frontend_BinSource_macros_h
#include "vm/JSContext.h"
@ -59,4 +59,4 @@
if (_##VAR.isErr()) return ::mozilla::Err(_##VAR.unwrapErr()); \
auto VAR = _##VAR.unwrap();
#endif // frontend_BinAST_macros_h
#endif // frontend_BinSource_macros_h

0
js/src/frontend/BinAST.webidl_ → js/src/frontend/BinSource.webidl_
Просмотреть файл

50
js/src/frontend/BinAST.yaml → js/src/frontend/BinSource.yaml
Просмотреть файл

@ -27,7 +27,7 @@ cpp:
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// To generate this file, see the documentation in
// js/src/frontend/binast/README.md.
// js/src/frontend/binsource/README.md.
#include "frontend/BinASTParser.h"
@ -38,8 +38,8 @@ cpp:
#include "mozilla/PodOperations.h"
#include "mozilla/Vector.h"
#include "frontend/BinAST-macros.h"
#include "frontend/BinASTTokenReaderMultipart.h"
#include "frontend/BinSource-macros.h"
#include "frontend/BinTokenReaderMultipart.h"
#include "frontend/FullParseHandler.h"
#include "frontend/ParseNode.h"
#include "frontend/Parser.h"
@ -64,7 +64,7 @@ cpp:
// Force class instantiation.
// This ensures that the symbols are built, without having to export all our
// code (and its baggage of #include and macros) in the header.
template class BinASTParser<BinASTTokenReaderMultipart>;
template class BinASTParser<BinTokenReaderMultipart>;
} // namespace frontend
} // namespace js
@ -80,7 +80,7 @@ hpp:
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// To generate this file, see the documentation in
// js/src/frontend/binast/README.md.
// js/src/frontend/binsource/README.md.
#ifndef frontend_BinASTParser_h
#define frontend_BinASTParser_h
@ -89,8 +89,8 @@ hpp:
#include "frontend/BCEParserHandle.h"
#include "frontend/BinASTParserPerTokenizer.h"
#include "frontend/BinASTToken.h"
#include "frontend/BinASTTokenReaderMultipart.h"
#include "frontend/BinToken.h"
#include "frontend/BinTokenReaderMultipart.h"
#include "frontend/FullParseHandler.h"
#include "frontend/ParseContext.h"
#include "frontend/ParseNode.h"
@ -111,7 +111,7 @@ hpp:
using Tokenizer = Tok;
using BinASTFields = typename Tokenizer::BinASTFields;
using BinFields = typename Tokenizer::BinFields;
using AutoList = typename Tokenizer::AutoList;
using AutoTaggedTuple = typename Tokenizer::AutoTaggedTuple;
using Chars = typename Tokenizer::Chars;
@ -193,7 +193,7 @@ hpp:
footer: |
};
extern template class BinASTParser<BinASTTokenReaderMultipart>;
extern template class BinASTParser<BinTokenReaderMultipart>;
} // namespace frontend
} // namespace js
@ -209,7 +209,7 @@ hpp:
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// To generate this file, see the documentation in
// js/src/frontend/binast/README.md.
// js/src/frontend/binsource/README.md.
#ifndef frontend_BinASTEnum_h
#define frontend_BinASTEnum_h
@ -224,7 +224,7 @@ hpp:
#endif // frontend_BinASTEnum_h
# Rules for generating BinASTToken.h
# Rules for generating BinToken.h
tokens:
kind:
doc: |
@ -287,10 +287,10 @@ hpp:
// To generate this file, see the documentation in
// js/src/frontend/binast/README.md.
// js/src/frontend/binsource/README.md.
#ifndef frontend_BinASTToken_h
#define frontend_BinASTToken_h
#ifndef frontend_BinToken_h
#define frontend_BinToken_h
#include <stddef.h>
@ -299,9 +299,9 @@ hpp:
*
* In the Binary AST world, an AST is composed of nodes, where a node is
* defined by:
* - a Kind (see `BinASTKind`);
* - a Kind (see `BinKind`);
* - a list of fields, where each field is:
* - a Name (see `BinASTField`);
* - a Name (see `BinField`);
* - a Value, which may be either a node or a primitive value.
*
* The mapping between Kind and list of fields is determined entirely by
@ -325,24 +325,24 @@ hpp:
footer: |
/**
* Return a string describing a `BinASTKind`.
* Return a string describing a `BinKind`.
*/
const char* describeBinASTKind(const BinASTKind& kind);
const char* describeBinKind(const BinKind& kind);
/**
* Return a string describing a `BinASTField`.
* Return a string describing a `BinField`.
*/
const char* describeBinASTField(const BinASTField& kind);
const char* describeBinField(const BinField& kind);
/**
* Return a string describing a `BinASTVariant`.
* Return a string describing a `BinVariant`.
*/
const char* describeBinASTVariant(const BinASTVariant& kind);
const char* describeBinVariant(const BinVariant& kind);
} // namespace frontend
} // namespace js
#endif // frontend_BinASTToken_h
#endif // frontend_BinToken_h
Arguments:
init: |
@ -921,7 +921,7 @@ EagerFunctionExpression:
// Push a new ParseContext. It will be used to parse `scope`, the arguments,
// the function.
BinASTParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
BINJS_TRY(funpc.init());
pc_->functionScope().useAsVarScope(pc_);
MOZ_ASSERT(pc_->isFunctionBox());
@ -1615,7 +1615,7 @@ VariableDeclarator:
if (!init) {
// Here, `init` is required.
return raiseMissingField("VariableDeclarator (with non-trivial pattern)",
BinASTField::Init);
BinField::Init);
}
MOZ_CRASH("Unimplemented: AssertedScope check for BindingPattern variable declaration");

14
js/src/frontend/BinASTRuntimeSupport.cpp → js/src/frontend/BinSourceRuntimeSupport.cpp
Просмотреть файл

@ -4,7 +4,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "frontend/BinASTRuntimeSupport.h"
#include "frontend/BinSourceRuntimeSupport.h"
#include "gc/Tracer.h"
#include "js/Vector.h"
@ -15,18 +15,18 @@ namespace frontend {
/* static */
BinASTSourceMetadata* BinASTSourceMetadata::Create(
const Vector<BinASTKind>& binASTKinds, uint32_t numStrings) {
uint32_t numBinASTKinds = binASTKinds.length();
const Vector<BinKind>& binKinds, uint32_t numStrings) {
uint32_t numBinKinds = binKinds.length();
BinASTSourceMetadata* data = static_cast<BinASTSourceMetadata*>(
js_malloc(BinASTSourceMetadata::totalSize(numBinASTKinds, numStrings)));
js_malloc(BinASTSourceMetadata::totalSize(numBinKinds, numStrings)));
if (!data) {
return nullptr;
}
new (data) BinASTSourceMetadata(numBinASTKinds, numStrings);
memcpy(data->binASTKindBase(), binASTKinds.begin(),
binASTKinds.length() * sizeof(BinASTKind));
new (data) BinASTSourceMetadata(numBinKinds, numStrings);
memcpy(data->binKindBase(), binKinds.begin(),
binKinds.length() * sizeof(BinKind));
return data;
}

69
js/src/frontend/BinASTRuntimeSupport.h → js/src/frontend/BinSourceRuntimeSupport.h
Просмотреть файл

@ -4,12 +4,12 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef frontend_BinASTSupport_h
#define frontend_BinASTSupport_h
#ifndef frontend_BinSourceSupport_h
#define frontend_BinSourceSupport_h
#include "mozilla/HashFunctions.h"
#include "frontend/BinASTToken.h"
#include "frontend/BinToken.h"
#include "gc/DeletePolicy.h"
#include "js/AllocPolicy.h"
@ -24,9 +24,9 @@ class ScriptSource;
// Support for parsing JS Binary ASTs.
struct BinaryASTSupport {
using BinASTVariant = js::frontend::BinASTVariant;
using BinASTField = js::frontend::BinASTField;
using BinASTKind = js::frontend::BinASTKind;
using BinVariant = js::frontend::BinVariant;
using BinField = js::frontend::BinField;
using BinKind = js::frontend::BinKind;
// A structure designed to perform fast char* + length lookup
// without copies.
@ -64,29 +64,29 @@ struct BinaryASTSupport {
BinaryASTSupport();
JS::Result<const BinASTVariant*> binASTVariant(JSContext*, const CharSlice);
JS::Result<const BinASTKind*> binASTKind(JSContext*, const CharSlice);
JS::Result<const BinVariant*> binVariant(JSContext*, const CharSlice);
JS::Result<const BinKind*> binKind(JSContext*, const CharSlice);
bool ensureBinTablesInitialized(JSContext*);
private:
bool ensureBinASTKindsInitialized(JSContext*);
bool ensureBinASTVariantsInitialized(JSContext*);
bool ensureBinKindsInitialized(JSContext*);
bool ensureBinVariantsInitialized(JSContext*);
private:
// A HashMap that can be queried without copies from a CharSlice key.
// Initialized on first call. Keys are CharSlices into static strings.
using BinASTKindMap = js::HashMap<const CharSlice, BinASTKind, CharSlice,
using BinKindMap =
js::HashMap<const CharSlice, BinKind, CharSlice, js::SystemAllocPolicy>;
BinKindMap binKindMap_;
using BinFieldMap =
js::HashMap<const CharSlice, BinField, CharSlice, js::SystemAllocPolicy>;
BinFieldMap binFieldMap_;
using BinVariantMap = js::HashMap<const CharSlice, BinVariant, CharSlice,
js::SystemAllocPolicy>;
BinASTKindMap binASTKindMap_;
using BinASTFieldMap = js::HashMap<const CharSlice, BinASTField, CharSlice,
js::SystemAllocPolicy>;
BinASTFieldMap binASTFieldMap_;
using BinASTVariantMap = js::HashMap<const CharSlice, BinASTVariant,
CharSlice, js::SystemAllocPolicy>;
BinASTVariantMap binASTVariantMap_;
BinVariantMap binVariantMap_;
};
namespace frontend {
@ -95,7 +95,7 @@ class BinASTSourceMetadata {
using CharSlice = BinaryASTSupport::CharSlice;
const uint32_t numStrings_;
const uint32_t numBinASTKinds_;
const uint32_t numBinKinds_;
// The data lives inline in the allocation, after this class.
inline JSAtom** atomsBase() {
@ -106,33 +106,32 @@ class BinASTSourceMetadata {
reinterpret_cast<uintptr_t>(atomsBase()) +
numStrings_ * sizeof(JSAtom*));
}
inline BinASTKind* binASTKindBase() {
return reinterpret_cast<BinASTKind*>(
reinterpret_cast<uintptr_t>(sliceBase()) +
numStrings_ * sizeof(CharSlice));
inline BinKind* binKindBase() {
return reinterpret_cast<BinKind*>(reinterpret_cast<uintptr_t>(sliceBase()) +
numStrings_ * sizeof(CharSlice));
}
static inline size_t totalSize(uint32_t numBinASTKinds, uint32_t numStrings) {
static inline size_t totalSize(uint32_t numBinKinds, uint32_t numStrings) {
return sizeof(BinASTSourceMetadata) + numStrings * sizeof(JSAtom*) +
numStrings * sizeof(CharSlice) + numBinASTKinds * sizeof(BinASTKind);
numStrings * sizeof(CharSlice) + numBinKinds * sizeof(BinKind);
}
BinASTSourceMetadata(uint32_t numBinASTKinds, uint32_t numStrings)
: numStrings_(numStrings), numBinASTKinds_(numBinASTKinds) {}
BinASTSourceMetadata(uint32_t numBinKinds, uint32_t numStrings)
: numStrings_(numStrings), numBinKinds_(numBinKinds) {}
friend class js::ScriptSource;
public:
static BinASTSourceMetadata* Create(const Vector<BinASTKind>& binASTKinds,
static BinASTSourceMetadata* Create(const Vector<BinKind>& binKinds,
uint32_t numStrings);
inline uint32_t numBinASTKinds() { return numBinASTKinds_; }
inline uint32_t numBinKinds() { return numBinKinds_; }
inline uint32_t numStrings() { return numStrings_; }
inline BinASTKind& getBinASTKind(uint32_t index) {
MOZ_ASSERT(index < numBinASTKinds_);
return binASTKindBase()[index];
inline BinKind& getBinKind(uint32_t index) {
MOZ_ASSERT(index < numBinKinds_);
return binKindBase()[index];
}
inline CharSlice& getSlice(uint32_t index) {
@ -156,4 +155,4 @@ typedef UniquePtr<frontend::BinASTSourceMetadata,
} // namespace js
#endif // frontend_BinASTSupport_h
#endif // frontend_BinSourceSupport_h

153
js/src/frontend/BinToken.cpp Normal file
Просмотреть файл

@ -0,0 +1,153 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "frontend/BinToken.h"
#include "mozilla/Maybe.h"
#include <sys/types.h>
#include "frontend/BinSourceRuntimeSupport.h"
#include "frontend/TokenStream.h"
#include "js/Result.h"
#include "vm/JSContext.h"
namespace js {
namespace frontend {
const BinaryASTSupport::CharSlice BINKIND_DESCRIPTIONS[] = {
#define WITH_VARIANT(_, SPEC_NAME) \
BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1),
FOR_EACH_BIN_KIND(WITH_VARIANT)
#undef WITH_VARIANT
};
const BinaryASTSupport::CharSlice BINFIELD_DESCRIPTIONS[] = {
#define WITH_VARIANT(_, SPEC_NAME) \
BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1),
FOR_EACH_BIN_FIELD(WITH_VARIANT)
#undef WITH_VARIANT
};
const BinaryASTSupport::CharSlice BINVARIANT_DESCRIPTIONS[] = {
#define WITH_VARIANT(_, SPEC_NAME) \
BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1),
FOR_EACH_BIN_VARIANT(WITH_VARIANT)
#undef WITH_VARIANT
};
const BinaryASTSupport::CharSlice& getBinKind(const BinKind& variant) {
return BINKIND_DESCRIPTIONS[static_cast<size_t>(variant)];
}
const BinaryASTSupport::CharSlice& getBinVariant(const BinVariant& variant) {
return BINVARIANT_DESCRIPTIONS[static_cast<size_t>(variant)];
}
const BinaryASTSupport::CharSlice& getBinField(const BinField& variant) {
return BINFIELD_DESCRIPTIONS[static_cast<size_t>(variant)];
}
const char* describeBinKind(const BinKind& variant) {
return getBinKind(variant).begin();
}
const char* describeBinField(const BinField& variant) {
return getBinField(variant).begin();
}
const char* describeBinVariant(const BinVariant& variant) {
return getBinVariant(variant).begin();
}
} // namespace frontend
BinaryASTSupport::BinaryASTSupport()
: binKindMap_(frontend::BINKIND_LIMIT),
binFieldMap_(frontend::BINFIELD_LIMIT),
binVariantMap_(frontend::BINVARIANT_LIMIT) {}
/**
* It is expected that all bin tables are initialized on the main thread, and
* that any helper threads will find the read-only tables properly initialized,
* so that they can do their accesses safely without taking any locks.
*/
bool BinaryASTSupport::ensureBinTablesInitialized(JSContext* cx) {
return ensureBinKindsInitialized(cx) && ensureBinVariantsInitialized(cx);
}
bool BinaryASTSupport::ensureBinKindsInitialized(JSContext* cx) {
MOZ_ASSERT(!cx->helperThread());
if (binKindMap_.empty()) {
for (size_t i = 0; i < frontend::BINKIND_LIMIT; ++i) {
const BinKind variant = static_cast<BinKind>(i);
const CharSlice& key = getBinKind(variant);
auto ptr = binKindMap_.lookupForAdd(key);
MOZ_ASSERT(!ptr);
if (!binKindMap_.add(ptr, key, variant)) {
ReportOutOfMemory(cx);
return false;
}
}
}
return true;
}
bool BinaryASTSupport::ensureBinVariantsInitialized(JSContext* cx) {
MOZ_ASSERT(!cx->helperThread());
if (binVariantMap_.empty()) {
for (size_t i = 0; i < frontend::BINVARIANT_LIMIT; ++i) {
const BinVariant variant = static_cast<BinVariant>(i);
const CharSlice& key = getBinVariant(variant);
auto ptr = binVariantMap_.lookupForAdd(key);
MOZ_ASSERT(!ptr);
if (!binVariantMap_.add(ptr, key, variant)) {
ReportOutOfMemory(cx);
return false;
}
}
}
return true;
}
JS::Result<const js::frontend::BinKind*> BinaryASTSupport::binKind(
JSContext* cx, const CharSlice key) {
MOZ_ASSERT_IF(cx->helperThread(), !binKindMap_.empty());
if (!cx->helperThread()) {
// Initialize Lazily if on main thread.
if (!ensureBinKindsInitialized(cx)) {
return cx->alreadyReportedError();
}
}
auto ptr = binKindMap_.readonlyThreadsafeLookup(key);
if (!ptr) {
return nullptr;
}
return &ptr->value();
}
JS::Result<const js::frontend::BinVariant*> BinaryASTSupport::binVariant(
JSContext* cx, const CharSlice key) {
MOZ_ASSERT_IF(cx->helperThread(), !binVariantMap_.empty());
if (!cx->helperThread()) {
// Initialize lazily if on main thread.
if (!ensureBinVariantsInitialized(cx)) {
return cx->alreadyReportedError();
}
}
auto ptr = binVariantMap_.readonlyThreadsafeLookup(key);
if (!ptr) {
return nullptr;
}
return &ptr->value();
}
} // namespace js

42
js/src/frontend/BinASTToken.h → js/src/frontend/BinToken.h
Просмотреть файл

@ -7,10 +7,10 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// To generate this file, see the documentation in
// js/src/frontend/binast/README.md.
// js/src/frontend/binsource/README.md.
#ifndef frontend_BinASTToken_h
#define frontend_BinASTToken_h
#ifndef frontend_BinToken_h
#define frontend_BinToken_h
#include <stddef.h>
@ -19,9 +19,9 @@
*
* In the Binary AST world, an AST is composed of nodes, where a node is
* defined by:
* - a Kind (see `BinASTKind`);
* - a Kind (see `BinKind`);
* - a list of fields, where each field is:
* - a Name (see `BinASTField`);
* - a Name (see `BinField`);
* - a Value, which may be either a node or a primitive value.
*
* The mapping between Kind and list of fields is determined entirely by
@ -185,14 +185,14 @@ namespace frontend {
F(YieldExpression, "YieldExpression") \
F(YieldStarExpression, "YieldStarExpression")
enum class BinASTKind {
enum class BinKind {
#define EMIT_ENUM(name, _) name,
FOR_EACH_BIN_KIND(EMIT_ENUM)
#undef EMIT_ENUM
};
// The number of distinct values of BinASTKind.
const size_t BINASTKIND_LIMIT = 120;
// The number of distinct values of BinKind.
const size_t BINKIND_LIMIT = 120;
/**
* The different fields of Binary AST nodes, as per the specifications of
@ -278,14 +278,14 @@ const size_t BINASTKIND_LIMIT = 120;
F(Update, "update") \
F(Value, "value")
enum class BinASTField {
enum class BinField {
#define EMIT_ENUM(name, _) name,
FOR_EACH_BIN_FIELD(EMIT_ENUM)
#undef EMIT_ENUM
};
// The number of distinct values of BinASTField.
const size_t BINASTFIELD_LIMIT = 69;
// The number of distinct values of BinField.
const size_t BINFIELD_LIMIT = 69;
/**
* The different variants of Binary AST string enums, as per
@ -354,31 +354,31 @@ const size_t BINASTFIELD_LIMIT = 69;
F(VariableDeclarationKindConst, "const") \
F(VariableDeclarationKindLet, "let")
enum class BinASTVariant {
enum class BinVariant {
#define EMIT_ENUM(name, _) name,
FOR_EACH_BIN_VARIANT(EMIT_ENUM)
#undef EMIT_ENUM
};
// The number of distinct values of BinASTVariant.
const size_t BINASTVARIANT_LIMIT = 49;
// The number of distinct values of BinVariant.
const size_t BINVARIANT_LIMIT = 49;
/**
* Return a string describing a `BinASTKind`.
* Return a string describing a `BinKind`.
*/
const char* describeBinASTKind(const BinASTKind& kind);
const char* describeBinKind(const BinKind& kind);
/**
* Return a string describing a `BinASTField`.
* Return a string describing a `BinField`.
*/
const char* describeBinASTField(const BinASTField& kind);
const char* describeBinField(const BinField& kind);
/**
* Return a string describing a `BinASTVariant`.
* Return a string describing a `BinVariant`.
*/
const char* describeBinASTVariant(const BinASTVariant& kind);
const char* describeBinVariant(const BinVariant& kind);
} // namespace frontend
} // namespace js
#endif // frontend_BinASTToken_h
#endif // frontend_BinToken_h

38
js/src/frontend/BinASTTokenReaderBase.cpp → js/src/frontend/BinTokenReaderBase.cpp
Просмотреть файл

@ -4,9 +4,9 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "frontend/BinASTTokenReaderBase.h"
#include "frontend/BinTokenReaderBase.h"
#include "frontend/BinAST-macros.h"
#include "frontend/BinSource-macros.h"
#include "js/Result.h"
namespace js {
@ -19,44 +19,44 @@ using ErrorResult = mozilla::GenericErrorResult<T>;
// to represent a `null` number.
const uint64_t NULL_FLOAT_REPRESENTATION = 0x7FF0000000000001;
void BinASTTokenReaderBase::updateLatestKnownGood() {
void BinTokenReaderBase::updateLatestKnownGood() {
MOZ_ASSERT(current_ >= start_);
const size_t update = current_ - start_;
MOZ_ASSERT(update >= latestKnownGoodPos_);
latestKnownGoodPos_ = update;
}
ErrorResult<JS::Error&> BinASTTokenReaderBase::raiseError(
ErrorResult<JS::Error&> BinTokenReaderBase::raiseError(
const char* description) {
MOZ_ASSERT(!hasRaisedError());
errorReporter_->errorNoOffset(JSMSG_BINAST, description);
return cx_->alreadyReportedError();
}
ErrorResult<JS::Error&> BinASTTokenReaderBase::raiseOOM() {
ErrorResult<JS::Error&> BinTokenReaderBase::raiseOOM() {
ReportOutOfMemory(cx_);
return cx_->alreadyReportedError();
}
ErrorResult<JS::Error&> BinASTTokenReaderBase::raiseInvalidNumberOfFields(
const BinASTKind kind, const uint32_t expected, const uint32_t got) {
ErrorResult<JS::Error&> BinTokenReaderBase::raiseInvalidNumberOfFields(
const BinKind kind, const uint32_t expected, const uint32_t got) {
Sprinter out(cx_);
BINJS_TRY(out.init());
BINJS_TRY(out.printf("In %s, invalid number of fields: expected %u, got %u",
describeBinASTKind(kind), expected, got));
describeBinKind(kind), expected, got));
return raiseError(out.string());
}
ErrorResult<JS::Error&> BinASTTokenReaderBase::raiseInvalidField(
const char* kind, const BinASTField field) {
ErrorResult<JS::Error&> BinTokenReaderBase::raiseInvalidField(
const char* kind, const BinField field) {
Sprinter out(cx_);
BINJS_TRY(out.init());
BINJS_TRY(out.printf("In %s, invalid field '%s'", kind,
describeBinASTField(field)));
BINJS_TRY(
out.printf("In %s, invalid field '%s'", kind, describeBinField(field)));
return raiseError(out.string());
}
bool BinASTTokenReaderBase::hasRaisedError() const {
bool BinTokenReaderBase::hasRaisedError() const {
if (cx_->helperThread()) {
// When performing off-main-thread parsing, we don't set a pending
// exception but instead add a pending compile error.
@ -66,11 +66,11 @@ bool BinASTTokenReaderBase::hasRaisedError() const {
return cx_->isExceptionPending();
}
size_t BinASTTokenReaderBase::offset() const { return current_ - start_; }
size_t BinTokenReaderBase::offset() const { return current_ - start_; }
TokenPos BinASTTokenReaderBase::pos() { return pos(offset()); }
TokenPos BinTokenReaderBase::pos() { return pos(offset()); }
TokenPos BinASTTokenReaderBase::pos(size_t start) {
TokenPos BinTokenReaderBase::pos(size_t start) {
TokenPos pos;
pos.begin = start;
pos.end = current_ - start_;
@ -78,12 +78,12 @@ TokenPos BinASTTokenReaderBase::pos(size_t start) {
return pos;
}
void BinASTTokenReaderBase::seek(size_t offset) {
void BinTokenReaderBase::seek(size_t offset) {
MOZ_ASSERT(start_ + offset >= start_ && start_ + offset < stop_);
current_ = start_ + offset;
}
JS::Result<Ok> BinASTTokenReaderBase::readBuf(uint8_t* bytes, uint32_t len) {
JS::Result<Ok> BinTokenReaderBase::readBuf(uint8_t* bytes, uint32_t len) {
MOZ_ASSERT(!hasRaisedError());
MOZ_ASSERT(len > 0);
@ -98,7 +98,7 @@ JS::Result<Ok> BinASTTokenReaderBase::readBuf(uint8_t* bytes, uint32_t len) {
return Ok();
}
JS::Result<uint8_t> BinASTTokenReaderBase::readByte() {
JS::Result<uint8_t> BinTokenReaderBase::readByte() {
uint8_t byte;
MOZ_TRY(readBuf(&byte, 1));
return byte;

26
js/src/frontend/BinASTTokenReaderBase.h → js/src/frontend/BinTokenReaderBase.h
Просмотреть файл

@ -4,10 +4,10 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef frontend_BinASTTokenReaderBase_h
#define frontend_BinASTTokenReaderBase_h
#ifndef frontend_BinTokenReaderBase_h
#define frontend_BinTokenReaderBase_h
#include "frontend/BinASTToken.h"
#include "frontend/BinToken.h"
#include "frontend/ErrorReporter.h"
#include "frontend/TokenStream.h"
@ -20,7 +20,7 @@ namespace frontend {
// A constant used by tokenizers to represent a null float.
extern const uint64_t NULL_FLOAT_REPRESENTATION;
class MOZ_STACK_CLASS BinASTTokenReaderBase {
class MOZ_STACK_CLASS BinTokenReaderBase {
public:
template <typename T>
using ErrorResult = mozilla::GenericErrorResult<T>;
@ -67,13 +67,13 @@ class MOZ_STACK_CLASS BinASTTokenReaderBase {
MOZ_MUST_USE ErrorResult<JS::Error&> raiseError(const char* description);
MOZ_MUST_USE ErrorResult<JS::Error&> raiseOOM();
MOZ_MUST_USE ErrorResult<JS::Error&> raiseInvalidNumberOfFields(
const BinASTKind kind, const uint32_t expected, const uint32_t got);
MOZ_MUST_USE ErrorResult<JS::Error&> raiseInvalidField(
const char* kind, const BinASTField field);
const BinKind kind, const uint32_t expected, const uint32_t got);
MOZ_MUST_USE ErrorResult<JS::Error&> raiseInvalidField(const char* kind,
const BinField field);
protected:
BinASTTokenReaderBase(JSContext* cx, ErrorReporter* er, const uint8_t* start,
const size_t length)
BinTokenReaderBase(JSContext* cx, ErrorReporter* er, const uint8_t* start,
const size_t length)
: cx_(cx),
errorReporter_(er),
poisoned_(false),
@ -172,12 +172,12 @@ class MOZ_STACK_CLASS BinASTTokenReaderBase {
size_t latestKnownGoodPos_;
private:
BinASTTokenReaderBase(const BinASTTokenReaderBase&) = delete;
BinASTTokenReaderBase(BinASTTokenReaderBase&&) = delete;
BinASTTokenReaderBase& operator=(BinASTTokenReaderBase&) = delete;
BinTokenReaderBase(const BinTokenReaderBase&) = delete;
BinTokenReaderBase(BinTokenReaderBase&&) = delete;
BinTokenReaderBase& operator=(BinTokenReaderBase&) = delete;
};
} // namespace frontend
} // namespace js
#endif // frontend_BinASTTokenReaderBase_h
#endif // frontend_BinTokenReaderBase_h

106
js/src/frontend/BinASTTokenReaderMultipart.cpp → js/src/frontend/BinTokenReaderMultipart.cpp
Просмотреть файл

@ -4,7 +4,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "frontend/BinASTTokenReaderMultipart.h"
#include "frontend/BinTokenReaderMultipart.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/Casting.h"
@ -14,8 +14,8 @@
#include <utility>
#include "frontend/BinAST-macros.h"
#include "frontend/BinASTRuntimeSupport.h"
#include "frontend/BinSource-macros.h"
#include "frontend/BinSourceRuntimeSupport.h"
#include "frontend/BytecodeCompiler.h" // IsIdentifier
#include "js/Result.h"
@ -40,34 +40,34 @@ const char COMPRESSION_IDENTITY[] = "identity;";
// single file.
const uint32_t MAX_NUMBER_OF_STRINGS = 32768;
using AutoList = BinASTTokenReaderMultipart::AutoList;
using AutoTaggedTuple = BinASTTokenReaderMultipart::AutoTaggedTuple;
using AutoList = BinTokenReaderMultipart::AutoList;
using AutoTaggedTuple = BinTokenReaderMultipart::AutoTaggedTuple;
using CharSlice = BinaryASTSupport::CharSlice;
using Chars = BinASTTokenReaderMultipart::Chars;
using Chars = BinTokenReaderMultipart::Chars;
BinASTTokenReaderMultipart::BinASTTokenReaderMultipart(JSContext* cx,
ErrorReporter* er,
const uint8_t* start,
const size_t length)
: BinASTTokenReaderBase(cx, er, start, length),
BinTokenReaderMultipart::BinTokenReaderMultipart(JSContext* cx,
ErrorReporter* er,
const uint8_t* start,
const size_t length)
: BinTokenReaderBase(cx, er, start, length),
metadata_(nullptr),
posBeforeTree_(nullptr) {
MOZ_ASSERT(er);
}
BinASTTokenReaderMultipart::~BinASTTokenReaderMultipart() {
BinTokenReaderMultipart::~BinTokenReaderMultipart() {
if (metadata_ && metadataOwned_ == MetadataOwnership::Owned) {
UniqueBinASTSourceMetadataPtr ptr(metadata_);
}
}
BinASTSourceMetadata* BinASTTokenReaderMultipart::takeMetadata() {
BinASTSourceMetadata* BinTokenReaderMultipart::takeMetadata() {
MOZ_ASSERT(metadataOwned_ == MetadataOwnership::Owned);
metadataOwned_ = MetadataOwnership::Unowned;
return metadata_;
}
JS::Result<Ok> BinASTTokenReaderMultipart::initFromScriptSource(
JS::Result<Ok> BinTokenReaderMultipart::initFromScriptSource(
ScriptSource* scriptSource) {
metadata_ = scriptSource->binASTSourceMetadata();
metadataOwned_ = MetadataOwnership::Unowned;
@ -75,7 +75,7 @@ JS::Result<Ok> BinASTTokenReaderMultipart::initFromScriptSource(
return Ok();
}
JS::Result<Ok> BinASTTokenReaderMultipart::readHeader() {
JS::Result<Ok> BinTokenReaderMultipart::readHeader() {
// Check that we don't call this function twice.
MOZ_ASSERT(!posBeforeTree_);
@ -103,13 +103,13 @@ JS::Result<Ok> BinASTTokenReaderMultipart::readHeader() {
}
BINJS_MOZ_TRY_DECL(grammarNumberOfEntries, readInternalUint32());
if (grammarNumberOfEntries > BINASTKIND_LIMIT) { // Sanity check.
if (grammarNumberOfEntries > BINKIND_LIMIT) { // Sanity check.
return raiseError("Invalid number of entries in grammar table");
}
// This table maps BinASTKind index -> BinASTKind.
// This table maps BinKind index -> BinKind.
// Initialize and populate.
Vector<BinASTKind> grammarTable_(cx_);
Vector<BinKind> grammarTable_(cx_);
if (!grammarTable_.reserve(grammarNumberOfEntries)) {
return raiseOOM();
}
@ -125,7 +125,7 @@ JS::Result<Ok> BinASTTokenReaderMultipart::readHeader() {
CharSlice name((const char*)current_, byteLen);
current_ += byteLen;
BINJS_MOZ_TRY_DECL(kind, cx_->runtime()->binast().binASTKind(cx_, name));
BINJS_MOZ_TRY_DECL(kind, cx_->runtime()->binast().binKind(cx_, name));
if (!kind) {
return raiseError("Invalid entry in grammar table");
}
@ -215,13 +215,13 @@ JS::Result<Ok> BinASTTokenReaderMultipart::readHeader() {
return Ok();
}
void BinASTTokenReaderMultipart::traceMetadata(JSTracer* trc) {
void BinTokenReaderMultipart::traceMetadata(JSTracer* trc) {
if (metadata_) {
metadata_->trace(trc);
}
}
JS::Result<bool> BinASTTokenReaderMultipart::readBool() {
JS::Result<bool> BinTokenReaderMultipart::readBool() {
updateLatestKnownGood();
BINJS_MOZ_TRY_DECL(byte, readByte());
@ -241,7 +241,7 @@ JS::Result<bool> BinASTTokenReaderMultipart::readBool() {
//
// NULL_FLOAT_REPRESENTATION (signaling NaN) => null
// anything other 64 bit sequence => IEEE-764 64-bit floating point number
JS::Result<double> BinASTTokenReaderMultipart::readDouble() {
JS::Result<double> BinTokenReaderMultipart::readDouble() {
updateLatestKnownGood();
uint8_t bytes[8];
@ -262,7 +262,7 @@ JS::Result<double> BinASTTokenReaderMultipart::readDouble() {
}
// A single atom is represented as an index into the table of strings.
JS::Result<JSAtom*> BinASTTokenReaderMultipart::readMaybeAtom() {
JS::Result<JSAtom*> BinTokenReaderMultipart::readMaybeAtom() {
updateLatestKnownGood();
BINJS_MOZ_TRY_DECL(index, readInternalUint32());
@ -272,7 +272,7 @@ JS::Result<JSAtom*> BinASTTokenReaderMultipart::readMaybeAtom() {
return metadata_->getAtom(index);
}
JS::Result<JSAtom*> BinASTTokenReaderMultipart::readAtom() {
JS::Result<JSAtom*> BinTokenReaderMultipart::readAtom() {
BINJS_MOZ_TRY_DECL(maybe, readMaybeAtom());
if (!maybe) {
@ -282,7 +282,7 @@ JS::Result<JSAtom*> BinASTTokenReaderMultipart::readAtom() {
return maybe;
}
JS::Result<JSAtom*> BinASTTokenReaderMultipart::readMaybeIdentifierName() {
JS::Result<JSAtom*> BinTokenReaderMultipart::readMaybeIdentifierName() {
BINJS_MOZ_TRY_DECL(result, readMaybeAtom());
if (result) {
if (!IsIdentifier(result)) {
@ -292,7 +292,7 @@ JS::Result<JSAtom*> BinASTTokenReaderMultipart::readMaybeIdentifierName() {
return result;
}
JS::Result<JSAtom*> BinASTTokenReaderMultipart::readIdentifierName() {
JS::Result<JSAtom*> BinTokenReaderMultipart::readIdentifierName() {
BINJS_MOZ_TRY_DECL(result, readMaybeAtom());
if (!IsIdentifier(result)) {
return raiseError("Invalid identifier");
@ -300,15 +300,15 @@ JS::Result<JSAtom*> BinASTTokenReaderMultipart::readIdentifierName() {
return result;
}
JS::Result<JSAtom*> BinASTTokenReaderMultipart::readMaybePropertyKey() {
JS::Result<JSAtom*> BinTokenReaderMultipart::readMaybePropertyKey() {
return readMaybeAtom();
}
JS::Result<JSAtom*> BinASTTokenReaderMultipart::readPropertyKey() {
JS::Result<JSAtom*> BinTokenReaderMultipart::readPropertyKey() {
return readAtom();
}
JS::Result<Ok> BinASTTokenReaderMultipart::readChars(Chars& out) {
JS::Result<Ok> BinTokenReaderMultipart::readChars(Chars& out) {
updateLatestKnownGood();
BINJS_MOZ_TRY_DECL(index, readInternalUint32());
@ -320,7 +320,7 @@ JS::Result<Ok> BinASTTokenReaderMultipart::readChars(Chars& out) {
return Ok();
}
JS::Result<BinASTVariant> BinASTTokenReaderMultipart::readVariant() {
JS::Result<BinVariant> BinTokenReaderMultipart::readVariant() {
updateLatestKnownGood();
BINJS_MOZ_TRY_DECL(index, readInternalUint32());
@ -340,8 +340,7 @@ JS::Result<BinASTVariant> BinASTTokenReaderMultipart::readVariant() {
// ill-formed variant, so we don't run the risk of feching an ill-variant
// more than once.
Chars slice = metadata_->getSlice(index); // We have checked `index` above.
BINJS_MOZ_TRY_DECL(variant,
cx_->runtime()->binast().binASTVariant(cx_, slice));
BINJS_MOZ_TRY_DECL(variant, cx_->runtime()->binast().binVariant(cx_, slice));
if (!variant) {
return raiseError("Invalid string enum variant");
@ -354,8 +353,8 @@ JS::Result<BinASTVariant> BinASTTokenReaderMultipart::readVariant() {
return *variant;
}
JS::Result<BinASTTokenReaderBase::SkippableSubTree>
BinASTTokenReaderMultipart::readSkippableSubTree() {
JS::Result<BinTokenReaderBase::SkippableSubTree>
BinTokenReaderMultipart::readSkippableSubTree() {
updateLatestKnownGood();
BINJS_MOZ_TRY_DECL(byteLen, readInternalUint32());
@ -367,21 +366,20 @@ BinASTTokenReaderMultipart::readSkippableSubTree() {
current_ += byteLen;
return BinASTTokenReaderBase::SkippableSubTree(start, byteLen);
return BinTokenReaderBase::SkippableSubTree(start, byteLen);
}
// Tagged tuples:
// - uint32_t index in table [grammar];
// - content (specified by the higher-level grammar);
JS::Result<Ok> BinASTTokenReaderMultipart::enterTaggedTuple(
BinASTKind& tag, BinASTTokenReaderMultipart::BinASTFields&,
AutoTaggedTuple& guard) {
JS::Result<Ok> BinTokenReaderMultipart::enterTaggedTuple(
BinKind& tag, BinTokenReaderMultipart::BinFields&, AutoTaggedTuple& guard) {
BINJS_MOZ_TRY_DECL(index, readInternalUint32());
if (index >= metadata_->numBinASTKinds()) {
if (index >= metadata_->numBinKinds()) {
return raiseError("Invalid index to grammar table");
}
tag = metadata_->getBinASTKind(index);
tag = metadata_->getBinKind(index);
// Enter the body.
guard.init();
@ -395,8 +393,8 @@ JS::Result<Ok> BinASTTokenReaderMultipart::enterTaggedTuple(
//
// The total byte length of `number of items` + `contents` must be `byte
// length`.
JS::Result<Ok> BinASTTokenReaderMultipart::enterList(uint32_t& items,
AutoList& guard) {
JS::Result<Ok> BinTokenReaderMultipart::enterList(uint32_t& items,
AutoList& guard) {
guard.init();
MOZ_TRY_VAR(items, readInternalUint32());
@ -404,20 +402,19 @@ JS::Result<Ok> BinASTTokenReaderMultipart::enterList(uint32_t& items,
return Ok();
}
void BinASTTokenReaderMultipart::AutoBase::init() { initialized_ = true; }
void BinTokenReaderMultipart::AutoBase::init() { initialized_ = true; }
BinASTTokenReaderMultipart::AutoBase::AutoBase(
BinASTTokenReaderMultipart& reader)
BinTokenReaderMultipart::AutoBase::AutoBase(BinTokenReaderMultipart& reader)
: initialized_(false), reader_(reader) {}
BinASTTokenReaderMultipart::AutoBase::~AutoBase() {
BinTokenReaderMultipart::AutoBase::~AutoBase() {
// By now, the `AutoBase` must have been deinitialized by calling `done()`.
// The only case in which we can accept not calling `done()` is if we have
// bailed out because of an error.
MOZ_ASSERT_IF(initialized_, reader_.hasRaisedError());
}
JS::Result<Ok> BinASTTokenReaderMultipart::AutoBase::checkPosition(
JS::Result<Ok> BinTokenReaderMultipart::AutoBase::checkPosition(
const uint8_t* expectedEnd) {
if (reader_.current_ != expectedEnd) {
return reader_.raiseError(
@ -427,13 +424,12 @@ JS::Result<Ok> BinASTTokenReaderMultipart::AutoBase::checkPosition(
return Ok();
}
BinASTTokenReaderMultipart::AutoList::AutoList(
BinASTTokenReaderMultipart& reader)
BinTokenReaderMultipart::AutoList::AutoList(BinTokenReaderMultipart& reader)
: AutoBase(reader) {}
void BinASTTokenReaderMultipart::AutoList::init() { AutoBase::init(); }
void BinTokenReaderMultipart::AutoList::init() { AutoBase::init(); }
JS::Result<Ok> BinASTTokenReaderMultipart::AutoList::done() {
JS::Result<Ok> BinTokenReaderMultipart::AutoList::done() {
MOZ_ASSERT(initialized_);
initialized_ = false;
if (reader_.hasRaisedError()) {
@ -449,7 +445,7 @@ JS::Result<Ok> BinASTTokenReaderMultipart::AutoList::done() {
// Encoded as variable length number.
MOZ_MUST_USE JS::Result<uint32_t>
BinASTTokenReaderMultipart::readInternalUint32() {
BinTokenReaderMultipart::readInternalUint32() {
uint32_t result = 0;
uint32_t shift = 0;
while (true) {
@ -475,11 +471,11 @@ BinASTTokenReaderMultipart::readInternalUint32() {
}
}
BinASTTokenReaderMultipart::AutoTaggedTuple::AutoTaggedTuple(
BinASTTokenReaderMultipart& reader)
BinTokenReaderMultipart::AutoTaggedTuple::AutoTaggedTuple(
BinTokenReaderMultipart& reader)
: AutoBase(reader) {}
JS::Result<Ok> BinASTTokenReaderMultipart::AutoTaggedTuple::done() {
JS::Result<Ok> BinTokenReaderMultipart::AutoTaggedTuple::done() {
MOZ_ASSERT(initialized_);
initialized_ = false;
if (reader_.hasRaisedError()) {

72
js/src/frontend/BinASTTokenReaderMultipart.h → js/src/frontend/BinTokenReaderMultipart.h
Просмотреть файл

@ -4,14 +4,14 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef frontend_BinASTTokenReaderMultipart_h
#define frontend_BinASTTokenReaderMultipart_h
#ifndef frontend_BinTokenReaderMultipart_h
#define frontend_BinTokenReaderMultipart_h
#include "mozilla/Maybe.h"
#include "frontend/BinASTRuntimeSupport.h"
#include "frontend/BinASTToken.h"
#include "frontend/BinASTTokenReaderBase.h"
#include "frontend/BinSourceRuntimeSupport.h"
#include "frontend/BinToken.h"
#include "frontend/BinTokenReaderBase.h"
#include "js/Result.h"
@ -30,19 +30,18 @@ namespace frontend {
* - the reader does not support error recovery;
* - the reader does not support lookahead or pushback.
*/
class MOZ_STACK_CLASS BinASTTokenReaderMultipart
: public BinASTTokenReaderBase {
class MOZ_STACK_CLASS BinTokenReaderMultipart : public BinTokenReaderBase {
public:
class AutoList;
class AutoTaggedTuple;
using CharSlice = BinaryASTSupport::CharSlice;
// This implementation of `BinASTFields` is effectively `void`, as the format
// This implementation of `BinFields` is effectively `void`, as the format
// does not embed field information.
class BinASTFields {
class BinFields {
public:
explicit BinASTFields(JSContext*) {}
explicit BinFields(JSContext*) {}
};
using Chars = CharSlice;
@ -52,18 +51,18 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart
*
* Does NOT copy the buffer.
*/
BinASTTokenReaderMultipart(JSContext* cx, ErrorReporter* er,
const uint8_t* start, const size_t length);
BinTokenReaderMultipart(JSContext* cx, ErrorReporter* er,
const uint8_t* start, const size_t length);
/**
* Construct a token reader.
*
* Does NOT copy the buffer.
*/
BinASTTokenReaderMultipart(JSContext* cx, ErrorReporter* er,
const Vector<uint8_t>& chars);
BinTokenReaderMultipart(JSContext* cx, ErrorReporter* er,
const Vector<uint8_t>& chars);
~BinASTTokenReaderMultipart();
~BinTokenReaderMultipart();
/**
* Read the header of the file.
@ -118,10 +117,10 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart
MOZ_MUST_USE JS::Result<Ok> readChars(Chars&);
/**
* Read a single `BinASTVariant | null` value.
* Read a single `BinVariant | null` value.
*/
MOZ_MUST_USE JS::Result<mozilla::Maybe<BinASTVariant>> readMaybeVariant();
MOZ_MUST_USE JS::Result<BinASTVariant> readVariant();
MOZ_MUST_USE JS::Result<mozilla::Maybe<BinVariant>> readMaybeVariant();
MOZ_MUST_USE JS::Result<BinVariant> readVariant();
/**
* Read over a single `[Skippable]` subtree value.
@ -171,7 +170,7 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart
* @return out If the header of the tuple is invalid.
*/
MOZ_MUST_USE JS::Result<Ok> enterTaggedTuple(
BinASTKind& tag, BinASTTokenReaderMultipart::BinASTFields& fields,
BinKind& tag, BinTokenReaderMultipart::BinFields& fields,
AutoTaggedTuple& guard);
/**
@ -188,10 +187,9 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart
MOZ_MUST_USE JS::Result<uint32_t> readInternalUint32();
private:
// A mapping string index => BinASTVariant as extracted from the [STRINGS]
// A mapping string index => BinVariant as extracted from the [STRINGS]
// section of the file. Populated lazily.
js::HashMap<uint32_t, BinASTVariant, DefaultHasher<uint32_t>,
SystemAllocPolicy>
js::HashMap<uint32_t, BinVariant, DefaultHasher<uint32_t>, SystemAllocPolicy>
variantsTable_;
enum class MetadataOwnership { Owned, Unowned };
@ -200,9 +198,9 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart
const uint8_t* posBeforeTree_;
BinASTTokenReaderMultipart(const BinASTTokenReaderMultipart&) = delete;
BinASTTokenReaderMultipart(BinASTTokenReaderMultipart&&) = delete;
BinASTTokenReaderMultipart& operator=(BinASTTokenReaderMultipart&) = delete;
BinTokenReaderMultipart(const BinTokenReaderMultipart&) = delete;
BinTokenReaderMultipart(BinTokenReaderMultipart&&) = delete;
BinTokenReaderMultipart& operator=(BinTokenReaderMultipart&) = delete;
public:
void traceMetadata(JSTracer* trc);
@ -226,38 +224,38 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart
// Base class used by other Auto* classes.
class MOZ_STACK_CLASS AutoBase {
protected:
explicit AutoBase(BinASTTokenReaderMultipart& reader);
explicit AutoBase(BinTokenReaderMultipart& reader);
~AutoBase();
// Raise an error if we are not in the expected position.
MOZ_MUST_USE JS::Result<Ok> checkPosition(const uint8_t* expectedPosition);
friend BinASTTokenReaderMultipart;
friend BinTokenReaderMultipart;
void init();
// Set to `true` if `init()` has been called. Reset to `false` once
// all conditions have been checked.
bool initialized_;
BinASTTokenReaderMultipart& reader_;
BinTokenReaderMultipart& reader_;
};
// Guard class used to ensure that `enterList` is used properly.
class MOZ_STACK_CLASS AutoList : public AutoBase {
public:
explicit AutoList(BinASTTokenReaderMultipart& reader);
explicit AutoList(BinTokenReaderMultipart& reader);
// Check that we have properly read to the end of the list.
MOZ_MUST_USE JS::Result<Ok> done();
protected:
friend BinASTTokenReaderMultipart;
friend BinTokenReaderMultipart;
void init();
};
// Guard class used to ensure that `enterTaggedTuple` is used properly.
class MOZ_STACK_CLASS AutoTaggedTuple : public AutoBase {
public:
explicit AutoTaggedTuple(BinASTTokenReaderMultipart& reader);
explicit AutoTaggedTuple(BinTokenReaderMultipart& reader);
// Check that we have properly read to the end of the tuple.
MOZ_MUST_USE JS::Result<Ok> done();
@ -280,15 +278,15 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart
}
template <size_t N>
static JS::Result<Ok, JS::Error&> checkFields(
const BinASTKind kind, const BinASTFields& actual,
const BinASTField (&expected)[N]) {
static JS::Result<Ok, JS::Error&> checkFields(const BinKind kind,
const BinFields& actual,
const BinField (&expected)[N]) {
// Not implemented in this tokenizer.
return Ok();
}
static JS::Result<Ok, JS::Error&> checkFields0(const BinASTKind kind,
const BinASTFields& actual) {
static JS::Result<Ok, JS::Error&> checkFields0(const BinKind kind,
const BinFields& actual) {
// Not implemented in this tokenizer.
return Ok();
}
@ -297,4 +295,4 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart
} // namespace frontend
} // namespace js
#endif // frontend_BinASTTokenReaderMultipart_h
#endif // frontend_BinTokenReaderMultipart_h

6
js/src/frontend/BytecodeCompiler.cpp
Просмотреть файл

@ -766,8 +766,8 @@ JSScript* frontend::CompileGlobalBinASTScript(
GlobalSharedContext globalsc(cx, ScopeKind::Global, directives,
options.extraWarningsOption);
frontend::BinASTParser<BinASTTokenReaderMultipart> parser(
cx, alloc, usedNames, options, sourceObj);
frontend::BinASTParser<BinTokenReaderMultipart> parser(cx, alloc, usedNames,
options, sourceObj);
// Metadata stores internal pointers, so we must use the same buffer every
// time, including for lazy parses
@ -1057,7 +1057,7 @@ bool frontend::CompileLazyBinASTFunction(JSContext* cx,
script->setHasBeenCloned();
}
frontend::BinASTParser<BinASTTokenReaderMultipart> parser(
frontend::BinASTParser<BinTokenReaderMultipart> parser(
cx, cx->tempLifoAlloc(), usedNames, options, sourceObj, lazy);
auto parsed =

2
js/src/frontend/BytecodeCompiler.h
Просмотреть файл

@ -60,7 +60,7 @@
* ParseContext.h: class ParseContext: Extremely complex class that serves a lot
* of purposes, but it's a single class - essentially no derived classes - so
* it's a little easier to comprehend all at once. (SourceParseContext and
* BinASTParseContext do derive from ParseContext, but they do nothing except
* BinParseContext do derive from ParseContext, but they do nothing except
* adjust the constructor's arguments).
* Note it uses a thing called Nestable, which implements a stack of objects:
* you can push (and pop) instances to a stack (linked list) as you parse

16
js/src/frontend/binast/README.md
Просмотреть файл

@ -1,16 +0,0 @@
A parser generator used to generate the following files:
- js/src/frontend/BinASTParser.h
- js/src/frontend/BinASTParser.cpp
- js/src/frontent/BinASTToken.h
from the following files:
- js/src/frontend/BinAST.webidl_ (specifications of BinAST)
- js/src/frontend/BinAST.yaml (parser generator driver)
To use it:
```sh
$ cd $(topsrcdir)/js/src/frontend/binast
% ./build.sh
```

2
js/src/frontend/binast/Cargo.toml → js/src/frontend/binsource/Cargo.toml
Просмотреть файл

@ -14,5 +14,5 @@ yaml-rust = "^0.4.2"
webidl = "^0.8"
[[bin]]
name = "binast"
name = "binsource"
path = "src/main.rs"

16
js/src/frontend/binsource/README.md Normal file
Просмотреть файл

@ -0,0 +1,16 @@
A parser generator used to generate the following files:
- js/src/frontend/BinSource-auto.h
- js/src/frontend/BinSource-auto.cpp
- js/src/frontent/BinToken.h
from the following files:
- js/src/frontend/BinSource.webidl_ (specifications of BinAST)
- js/src/frontend/BinSource.yaml (parser generator driver)
To use it:
```sh
$ cd $(topsrcdir)/js/src/frontend/binsource
% ./build.sh
```

10
js/src/frontend/binast/build.sh → js/src/frontend/binsource/build.sh
Просмотреть файл

@ -1,12 +1,12 @@
#!/bin/sh
cargo run -- \
../BinAST.webidl_ \
../BinAST.yaml \
../BinSource.webidl_ \
../BinSource.yaml \
--out-class ../BinASTParser-tmp.h \
--out-impl ../BinASTParser-tmp.cpp \
--out-enum ../BinASTEnum-tmp.h \
--out-token ../BinASTToken-tmp.h
--out-token ../BinToken-tmp.h
MACH=../../../../mach
@ -14,7 +14,7 @@ ${MACH} clang-format --path \
../BinASTParser-tmp.h \
../BinASTParser-tmp.cpp \
../BinASTEnum-tmp.h \
../BinASTToken-tmp.h
../BinToken-tmp.h
# Usage: update SRC DST
#
@ -36,4 +36,4 @@ update() {
update ../BinASTParser-tmp.h ../BinASTParser.h
update ../BinASTParser-tmp.cpp ../BinASTParser.cpp
update ../BinASTEnum-tmp.h ../BinASTEnum.h
update ../BinASTToken-tmp.h ../BinASTToken.h
update ../BinToken-tmp.h ../BinToken.h

2
js/src/frontend/binast/moz.build → js/src/frontend/binsource/moz.build
Просмотреть файл

@ -4,4 +4,4 @@
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
HOST_RUST_PROGRAMS += ['binast']
HOST_RUST_PROGRAMS += ['binsource']

64
js/src/frontend/binast/src/main.rs → js/src/frontend/binsource/src/main.rs
Просмотреть файл

@ -162,13 +162,13 @@ struct GlobalRules {
/// defining the tokens.
hpp_tokens_footer: Option<String>,
/// Documentation for the `BinASTKind` class enum.
/// Documentation for the `BinKind` class enum.
hpp_tokens_kind_doc: Option<String>,
/// Documentation for the `BinASTField` class enum.
/// Documentation for the `BinField` class enum.
hpp_tokens_field_doc: Option<String>,
/// Documentation for the `BinASTVariant` class enum.
/// Documentation for the `BinVariant` class enum.
hpp_tokens_variants_doc: Option<String>,
/// Per-node rules.
@ -532,7 +532,7 @@ enum MethodCallKind {
/// Fixed parameter of interface method.
const INTERFACE_PARAMS: &str =
"const size_t start, const BinASTKind kind, const BinASTFields& fields";
"const size_t start, const BinKind kind, const BinFields& fields";
/// Fixed arguments of interface method.
const INTERFACE_ARGS: &str =
@ -560,7 +560,7 @@ struct CPPExporter {
option_parsers_to_generate: Vec<OptionParserData>,
/// A mapping from symbol (e.g. `+`, `-`, `instanceof`, ...) to the
/// name of the symbol as part of `enum class BinASTVariant`
/// name of the symbol as part of `enum class BinVariant`
/// (e.g. `UnaryOperatorDelete`).
variants_by_symbol: HashMap<String, String>,
@ -601,7 +601,7 @@ impl CPPExporter {
list_parsers_to_generate.sort_by(|a, b| str::cmp(a.name.to_str(), b.name.to_str()));
option_parsers_to_generate.sort_by(|a, b| str::cmp(a.name.to_str(), b.name.to_str()));
// Prepare variant_by_symbol, which will let us lookup the BinASTVariant name of
// Prepare variant_by_symbol, which will let us lookup the BinVariant name of
// a symbol. Since some symbols can appear in several enums (e.g. "+"
// is both a unary and a binary operator), we need to collect all the
// string enums that contain each symbol and come up with a unique name
@ -944,14 +944,14 @@ impl CPPExporter {
spec_name = name))
.format(" \\\n")));
buffer.push_str("
enum class BinASTKind {
enum class BinKind {
#define EMIT_ENUM(name, _) name,
FOR_EACH_BIN_KIND(EMIT_ENUM)
#undef EMIT_ENUM
};
");
buffer.push_str(&format!("\n// The number of distinct values of BinASTKind.\nconst size_t BINASTKIND_LIMIT = {};\n\n\n", kind_limit));
buffer.push_str(&format!("\n// The number of distinct values of BinKind.\nconst size_t BINKIND_LIMIT = {};\n\n\n", kind_limit));
buffer.push_str("\n\n");
if self.rules.hpp_tokens_field_doc.is_some() {
buffer.push_str(&self.rules.hpp_tokens_field_doc.reindent(""));
@ -968,13 +968,13 @@ enum class BinASTKind {
enum_name = name.to_cpp_enum_case()))
.format(" \\\n")));
buffer.push_str("
enum class BinASTField {
enum class BinField {
#define EMIT_ENUM(name, _) name,
FOR_EACH_BIN_FIELD(EMIT_ENUM)
#undef EMIT_ENUM
};
");
buffer.push_str(&format!("\n// The number of distinct values of BinASTField.\nconst size_t BINASTFIELD_LIMIT = {};\n\n\n", field_limit));
buffer.push_str(&format!("\n// The number of distinct values of BinField.\nconst size_t BINFIELD_LIMIT = {};\n\n\n", field_limit));
if self.rules.hpp_tokens_variants_doc.is_some() {
buffer.push_str(&self.rules.hpp_tokens_variants_doc.reindent(""));
@ -995,13 +995,13 @@ enum class BinASTField {
.format(" \\\n")));
buffer.push_str("
enum class BinASTVariant {
enum class BinVariant {
#define EMIT_ENUM(name, _) name,
FOR_EACH_BIN_VARIANT(EMIT_ENUM)
#undef EMIT_ENUM
};
");
buffer.push_str(&format!("\n// The number of distinct values of BinASTVariant.\nconst size_t BINASTVARIANT_LIMIT = {};\n\n\n",
buffer.push_str(&format!("\n// The number of distinct values of BinVariant.\nconst size_t BINVARIANT_LIMIT = {};\n\n\n",
variants_limit));
buffer.push_str(&self.rules.hpp_tokens_footer.reindent(""));
@ -1243,8 +1243,8 @@ impl CPPExporter {
buffer.push_str(&format!("{bnf}
{first_line}
{{
BinASTKind kind;
BinASTFields fields(cx_);
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
const auto start = tokenizer_->offset();
@ -1280,14 +1280,14 @@ impl CPPExporter {
if rule_for_this_arm.disabled {
buffer_cases.push_str(&format!("
case BinASTKind::{variant_name}:
case BinKind::{variant_name}:
return raiseError(\"FIXME: Not implemented yet in this preview release ({variant_name})\");",
variant_name = node.to_cpp_enum_case()));
continue;
}
buffer_cases.push_str(&format!("
case BinASTKind::{variant_name}:
case BinKind::{variant_name}:
{call}
{arm_after} break;",
call = self.get_method_call("result", node,
@ -1458,15 +1458,15 @@ impl CPPExporter {
NamedType::Interface(_) => {
buffer.push_str(&format!("{first_line}
{{
BinASTKind kind;
BinASTFields fields(cx_);
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
{type_ok} result;
if (kind == BinASTKind::{null}) {{
if (kind == BinKind::{null}) {{
{none_block}
}} else if (kind == BinASTKind::{kind}) {{
}} else if (kind == BinKind::{kind}) {{
const auto start = tokenizer_->offset();
{before}{call}{after}
}} else {{
@ -1511,13 +1511,13 @@ impl CPPExporter {
&TypeSpec::TypeSum(_) => {
buffer.push_str(&format!("{first_line}
{{
BinASTKind kind;
BinASTFields fields(cx_);
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
{type_ok} result;
if (kind == BinASTKind::{null}) {{
if (kind == BinKind::{null}) {{
{none_block}
}} else {{
const auto start = tokenizer_->offset();
@ -1673,12 +1673,12 @@ impl CPPExporter {
// Generate public method
buffer.push_str(&format!("{first_line}
{{
BinASTKind kind;
BinASTFields fields(cx_);
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
if (kind != BinASTKind::{kind}) {{
if (kind != BinKind::{kind}) {{
return raiseInvalidKind(\"{kind}\", kind);
}}
const auto start = tokenizer_->offset();
@ -1714,7 +1714,7 @@ impl CPPExporter {
let fields_type_list = format!("{{ {} }}", interface.contents()
.fields()
.iter()
.map(|field| format!("BinASTField::{}", field.name().to_cpp_enum_case()))
.map(|field| format!("BinField::{}", field.name().to_cpp_enum_case()))
.format(", "));
let mut fields_implem = String::new();
@ -1755,7 +1755,7 @@ impl CPPExporter {
}
Some(IsNullable { is_nullable: false, content: Primitive::Offset }) => {
if needs_block {
(Some(format!("BinASTTokenReaderBase::SkippableSubTree {var_name};", var_name = var_name)),
(Some(format!("BinTokenReaderBase::SkippableSubTree {var_name};", var_name = var_name)),
Some(format!("MOZ_TRY_VAR({var_name}, tokenizer_->readSkippableSubTree());", var_name = var_name)))
} else {
(None,
@ -1881,7 +1881,7 @@ impl CPPExporter {
// The following strategy is designed for old versions of clang.
format!("
#if defined(DEBUG)
const BinASTField expected_fields[{number_of_fields}] = {fields_type_list};
const BinField expected_fields[{number_of_fields}] = {fields_type_list};
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)",
fields_type_list = fields_type_list,
@ -1889,7 +1889,7 @@ impl CPPExporter {
};
buffer.push_str(&format!("{first_line}
{{
MOZ_ASSERT(kind == BinASTKind::{kind});
MOZ_ASSERT(kind == BinKind::{kind});
BINJS_TRY(CheckRecursionLimit(cx_));
{check_fields}
{pre}{fields_implem}
@ -1960,11 +1960,11 @@ impl CPPExporter {
cases = enum_.strings()
.iter()
.map(|symbol| {
format!(" case BinASTVariant::{binastvariant_variant}:
format!(" case BinVariant::{binvariant_variant}:
return {kind}::{specialized_variant};",
kind = kind,
specialized_variant = symbol.to_cpp_enum_case(),
binastvariant_variant = self.variants_by_symbol.get(symbol)
binvariant_variant = self.variants_by_symbol.get(symbol)
.unwrap()
)
})

0
js/src/frontend/binast/src/refgraph.rs → js/src/frontend/binsource/src/refgraph.rs
Просмотреть файл

16
js/src/frontend/moz.build
Просмотреть файл

@ -72,14 +72,14 @@ if CONFIG['JS_BUILD_BINAST']:
'BinASTParser.cpp',
'BinASTParserBase.cpp',
'BinASTParserPerTokenizer.cpp',
'BinASTRuntimeSupport.cpp',
'BinASTToken.cpp',
'BinASTTokenReaderBase.cpp',
'BinASTTokenReaderMultipart.cpp',
'BinSourceRuntimeSupport.cpp',
'BinToken.cpp',
'BinTokenReaderBase.cpp',
'BinTokenReaderMultipart.cpp',
]
DIRS += [
'binast'
'binsource'
]
# Instrument BinAST files for fuzzing as we have a fuzzing target for BinAST.
@ -89,6 +89,6 @@ if CONFIG['JS_BUILD_BINAST']:
SOURCES['BinASTParser.cpp'].flags += libfuzzer_flags
SOURCES['BinASTParserBase.cpp'].flags += libfuzzer_flags
SOURCES['BinASTParserPerTokenizer.cpp'].flags += libfuzzer_flags
SOURCES['BinASTToken.cpp'].flags += libfuzzer_flags
SOURCES['BinASTTokenReaderBase.cpp'].flags += libfuzzer_flags
SOURCES['BinASTTokenReaderMultipart.cpp'].flags += libfuzzer_flags
SOURCES['BinToken.cpp'].flags += libfuzzer_flags
SOURCES['BinTokenReaderBase.cpp'].flags += libfuzzer_flags
SOURCES['BinTokenReaderMultipart.cpp'].flags += libfuzzer_flags

4
js/src/jsapi-tests/testBinASTReader.cpp
Просмотреть файл

@ -459,10 +459,10 @@ void runTestFromPath(JSContext* cx, const char* path) {
BEGIN_TEST(testBinASTReaderMultipartECMAScript2) {
#if defined(XP_WIN)
runTestFromPath<js::frontend::BinASTTokenReaderMultipart>(
runTestFromPath<js::frontend::BinTokenReaderMultipart>(
cx, "jsapi-tests\\binast\\parser\\multipart\\");
#else
runTestFromPath<js::frontend::BinASTTokenReaderMultipart>(
runTestFromPath<js::frontend::BinTokenReaderMultipart>(
cx, "jsapi-tests/binast/parser/multipart/");
#endif // defined(XP_XIN)
return true;

7
js/src/shell/js.cpp
Просмотреть файл

@ -85,7 +85,7 @@
#include "jit/JitRealm.h"
#include "jit/shared/CodeGenerator-shared.h"
#include "js/ArrayBuffer.h" // JS::{CreateMappedArrayBufferContents,NewMappedArrayBufferWithContents,IsArrayBufferObject,GetArrayBufferLengthAndData}
#include "js/BuildId.h" // JS::BuildIdCharVector, JS::SetProcessBuildIdOp
#include "js/BuildId.h" // JS::BuildIdCharVector, JS::SetProcessBuildIdOp
#include "js/CharacterEncoding.h"
#include "js/CompilationAndEvaluation.h"
#include "js/CompileOptions.h"
@ -5109,7 +5109,7 @@ static bool BinParse(JSContext* cx, unsigned argc, Value* vp) {
Directives directives(false);
GlobalSharedContext globalsc(cx, ScopeKind::Global, directives, false);
auto parseFunc = ParseBinASTData<frontend::BinASTTokenReaderMultipart>;
auto parseFunc = ParseBinASTData<frontend::BinTokenReaderMultipart>;
if (!parseFunc(cx, buf_data, buf_length, &globalsc, usedNames, options,
sourceObj)) {
return false;
@ -10889,8 +10889,7 @@ int main(int argc, char** argv, char** envp) {
"Forcibly activate tiering and block "
"instantiation on completion of tier2")
#ifdef ENABLE_WASM_GC
||
!op.addBoolOption('\0', "wasm-gc", "Enable experimental wasm GC features")
|| !op.addBoolOption('\0', "wasm-gc", "Enable experimental wasm GC features")
#else
|| !op.addBoolOption('\0', "wasm-gc", "No-op")
#endif

17
js/src/vm/JSScript.cpp
Просмотреть файл

@ -2631,32 +2631,31 @@ XDRResult ScriptSource::XDR(XDRState<mode>* xdr,
#if defined(JS_BUILD_BINAST)
UniquePtr<frontend::BinASTSourceMetadata>& binASTMetadata =
ss->binASTMetadata_;
uint32_t numBinASTKinds;
uint32_t numBinKinds;
uint32_t numStrings;
if (mode == XDR_ENCODE) {
numBinASTKinds = binASTMetadata->numBinASTKinds();
numBinKinds = binASTMetadata->numBinKinds();
numStrings = binASTMetadata->numStrings();
}
MOZ_TRY(xdr->codeUint32(&numBinASTKinds));
MOZ_TRY(xdr->codeUint32(&numBinKinds));
MOZ_TRY(xdr->codeUint32(&numStrings));
if (mode == XDR_DECODE) {
// Use calloc, since we're storing this immediately, and filling it
// might GC, to avoid marking bogus atoms.
auto metadata = static_cast<frontend::BinASTSourceMetadata*>(
js_calloc(frontend::BinASTSourceMetadata::totalSize(numBinASTKinds,
js_calloc(frontend::BinASTSourceMetadata::totalSize(numBinKinds,
numStrings)));
if (!metadata) {
return xdr->fail(JS::TranscodeResult_Throw);
}
new (metadata)
frontend::BinASTSourceMetadata(numBinASTKinds, numStrings);
new (metadata) frontend::BinASTSourceMetadata(numBinKinds, numStrings);
ss->setBinASTSourceMetadata(metadata);
}
for (uint32_t i = 0; i < numBinASTKinds; i++) {
frontend::BinASTKind* binASTKindBase = binASTMetadata->binASTKindBase();
MOZ_TRY(xdr->codeEnum32(&binASTKindBase[i]));
for (uint32_t i = 0; i < numBinKinds; i++) {
frontend::BinKind* binKindBase = binASTMetadata->binKindBase();
MOZ_TRY(xdr->codeEnum32(&binKindBase[i]));
}
RootedAtom atom(xdr->cx());

2
js/src/vm/JSScript.h
Просмотреть файл

@ -25,7 +25,7 @@
#include "jstypes.h"
#include "frontend/BinASTRuntimeSupport.h"
#include "frontend/BinSourceRuntimeSupport.h"
#include "frontend/NameAnalysisTypes.h"
#include "gc/Barrier.h"
#include "gc/Rooting.h"

2
js/src/vm/Runtime.h
Просмотреть файл

@ -24,7 +24,7 @@
#include "builtin/AtomicsObject.h"
#include "builtin/intl/SharedIntlData.h"
#include "builtin/Promise.h"
#include "frontend/BinASTRuntimeSupport.h"
#include "frontend/BinSourceRuntimeSupport.h"
#include "frontend/NameCollections.h"
#include "gc/GCRuntime.h"
#include "gc/Tracer.h"