X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/14957cd040308e3eeec43d26bae5d76da13fcd85..refs/heads/master:/parser/SourceProviderCacheItem.h diff --git a/parser/SourceProviderCacheItem.h b/parser/SourceProviderCacheItem.h index b9ab225..c0c507f 100644 --- a/parser/SourceProviderCacheItem.h +++ b/parser/SourceProviderCacheItem.h @@ -23,44 +23,138 @@ * THE POSSIBILITY OF SUCH DAMAGE. */ -#include "JSParser.h" +#ifndef SourceProviderCacheItem_h +#define SourceProviderCacheItem_h + +#include "ParserTokens.h" #include +#include #include namespace JSC { +struct SourceProviderCacheItemCreationParameters { + unsigned functionNameStart; + unsigned lastTockenLine; + unsigned lastTockenStartOffset; + unsigned lastTockenEndOffset; + unsigned lastTockenLineStartOffset; + unsigned endFunctionOffset; + bool needsFullActivation; + bool usesEval; + bool strictMode; + Vector> usedVariables; + Vector> writtenVariables; +#if ENABLE(ES6_ARROWFUNCTION_SYNTAX) + bool isBodyArrowExpression { false }; + JSTokenType tokenType { CLOSEBRACE }; +#endif +}; + +#if COMPILER(MSVC) +#pragma warning(push) +#pragma warning(disable: 4200) // Disable "zero-sized array in struct/union" warning +#endif + class SourceProviderCacheItem { + WTF_MAKE_FAST_ALLOCATED; public: - SourceProviderCacheItem(int closeBraceLine, int closeBracePos) - : closeBraceLine(closeBraceLine) - , closeBracePos(closeBracePos) - { - } - unsigned approximateByteSize() const - { - // The identifiers are uniqued strings so most likely there are few names that actually use any additional memory. - static const unsigned assummedAverageIdentifierSize = sizeof(RefPtr) + 2; - unsigned size = sizeof(*this); - size += usedVariables.size() * assummedAverageIdentifierSize; - size += writtenVariables.size() * assummedAverageIdentifierSize; - return size; - } - JSToken closeBraceToken() const + static std::unique_ptr create(const SourceProviderCacheItemCreationParameters&); + ~SourceProviderCacheItem(); + + JSToken endFunctionToken() const { JSToken token; +#if ENABLE(ES6_ARROWFUNCTION_SYNTAX) + token.m_type = isBodyArrowExpression ? tokenType : CLOSEBRACE; +#else token.m_type = CLOSEBRACE; - token.m_data.intValue = closeBracePos; - token.m_info.startOffset = closeBracePos; - token.m_info.endOffset = closeBracePos + 1; - token.m_info.line = closeBraceLine; +#endif + token.m_data.offset = lastTockenStartOffset; + token.m_location.startOffset = lastTockenStartOffset; + token.m_location.endOffset = lastTockenEndOffset; + token.m_location.line = lastTockenLine; + token.m_location.lineStartOffset = lastTockenLineStartOffset; + // token.m_location.sourceOffset is initialized once by the client. So, + // we do not need to set it here. return token; } + + unsigned functionNameStart : 31; + bool needsFullActivation : 1; + + unsigned endFunctionOffset : 31; + unsigned lastTockenLine : 31; + unsigned lastTockenStartOffset : 31; + unsigned lastTockenEndOffset: 31; - int closeBraceLine; - int closeBracePos; - bool usesEval; - Vector > usedVariables; - Vector > writtenVariables; + bool usesEval : 1; + + bool strictMode : 1; + + unsigned lastTockenLineStartOffset; + unsigned usedVariablesCount; + unsigned writtenVariablesCount; + + UniquedStringImpl** usedVariables() const { return const_cast(m_variables); } + UniquedStringImpl** writtenVariables() const { return const_cast(&m_variables[usedVariablesCount]); } +#if ENABLE(ES6_ARROWFUNCTION_SYNTAX) + bool isBodyArrowExpression; + JSTokenType tokenType; +#endif + +private: + SourceProviderCacheItem(const SourceProviderCacheItemCreationParameters&); + + UniquedStringImpl* m_variables[0]; }; +inline SourceProviderCacheItem::~SourceProviderCacheItem() +{ + for (unsigned i = 0; i < usedVariablesCount + writtenVariablesCount; ++i) + m_variables[i]->deref(); +} + +inline std::unique_ptr SourceProviderCacheItem::create(const SourceProviderCacheItemCreationParameters& parameters) +{ + size_t variableCount = parameters.writtenVariables.size() + parameters.usedVariables.size(); + size_t objectSize = sizeof(SourceProviderCacheItem) + sizeof(UniquedStringImpl*) * variableCount; + void* slot = fastMalloc(objectSize); + return std::unique_ptr(new (slot) SourceProviderCacheItem(parameters)); +} + +inline SourceProviderCacheItem::SourceProviderCacheItem(const SourceProviderCacheItemCreationParameters& parameters) + : functionNameStart(parameters.functionNameStart) + , needsFullActivation(parameters.needsFullActivation) + , endFunctionOffset(parameters.endFunctionOffset) + , lastTockenLine(parameters.lastTockenLine) + , lastTockenStartOffset(parameters.lastTockenStartOffset) + , lastTockenEndOffset(parameters.lastTockenEndOffset) + , usesEval(parameters.usesEval) + , strictMode(parameters.strictMode) + , lastTockenLineStartOffset(parameters.lastTockenLineStartOffset) + , usedVariablesCount(parameters.usedVariables.size()) + , writtenVariablesCount(parameters.writtenVariables.size()) +#if ENABLE(ES6_ARROWFUNCTION_SYNTAX) + , isBodyArrowExpression(parameters.isBodyArrowExpression) + , tokenType(parameters.tokenType) +#endif +{ + unsigned j = 0; + for (unsigned i = 0; i < usedVariablesCount; ++i, ++j) { + m_variables[j] = parameters.usedVariables[i].get(); + m_variables[j]->ref(); + } + for (unsigned i = 0; i < writtenVariablesCount; ++i, ++j) { + m_variables[j] = parameters.writtenVariables[i].get(); + m_variables[j]->ref(); + } } + +#if COMPILER(MSVC) +#pragma warning(pop) +#endif + +} + +#endif // SourceProviderCacheItem_h