/**
 * Copyright 2017 Matt Acosta
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { Character } from './Character';
import { ISourceText } from '../text/ISourceText';
import { LexerBase } from './Lexer';
import { PhpLexerState } from './PhpLexerState';
import { PhpVersion } from './PhpVersion';
import { TemplateSpan } from './TemplateSpan';
import { Token } from './Token';
import { TokenKind } from '../language/TokenKind';
/**
 * Tokenizes PHP source text.
 *
 * IMPORTANT: This class is performance critical and must make every effort to
 * allow native optimization by the V8 engine.
 */
export declare class PhpLexer extends LexerBase<Token, PhpLexerState> {
    /**
     * A map of cast types to their associated tokens.
     */
    protected static readonly CastTokens: ReadonlyMap<string, TokenKind>;
    /**
     * A map of keywords to their associated tokens.
     */
    protected static readonly KeywordTokens: ReadonlyMap<string, TokenKind>;
    /**
     * Determines if short open tags "<?" are permitted. Defaults to `false`.
     */
    protected allowShortOpen: boolean;
    /**
     * Determines if the lexer should scan text as if PHP were aware of UTF-16
     * encoded characters. Defaults to `false`.
     */
    protected allowUtf16: boolean;
    /**
     * The default scanning mode when starting to scan text, or when not in a
     * pre-defined region.
     *
     * @see PhpLexer.templateStack
     */
    protected defaultState: PhpLexerState;
    /**
     * The indentation to remove from lines in a flexdoc template.
     */
    protected flexibleIndent: string;
    /**
     * Temporary storage for spans within a string template.
     */
    protected interpolations: TemplateSpan[];
    /**
     * The version of PHP to parse tokens as.
     */
    protected phpVersion: PhpVersion;
    /**
     * A pre-defined list containing state transitions for a region of text.
     */
    protected templateStack: TemplateSpan[];
    /**
     * The kind of token that was scanned.
     */
    protected tokenKind: TokenKind;
    /**
     * The starting offset of the token that was scanned.
     */
    protected tokenStart: number;
    /**
     * The size of a `long` used by PHP.
     */
    private ptrSize;
    /**
     * Constructs a `PhpLexer` object.
     *
     * @param {ISourceText} text
     *   The source text to tokenize.
     * @param {PhpVersion=} phpVersion
     *   The version of PHP to parse tokens as. Defaults to `PhpVersion.Latest`.
     * @param {boolean=} is64Bit
     *   Determines if the lexer should scan numbers as if PHP were compiled with
     *   64-bit support. Defaults to `true`.
     * @param {boolean=} allowUtf16
     *   Determines if the lexer should scan text as if PHP were aware of UTF-16
     *   encoded characters. Defaults to `false`.
     *
     * @todo Add `start` and `length` parameters?
     */
    constructor(text: ISourceText, phpVersion?: PhpVersion, is64Bit?: boolean, allowUtf16?: boolean);
    /**
     * The current lexing state.
     */
    get currentState(): PhpLexerState;
    /**
     * The text currently being scanned.
     */
    get sourceText(): ISourceText;
    /**
     * A list of regions within a string template that may be rescanned for
     * additional tokens. This list is empty for all other tokens.
     */
    get templateSpans(): TemplateSpan[];
    /**
     * Scans the source text until a token is found.
     */
    lex(state: PhpLexerState): Token;
    /**
     * Initializes the lexer with predetermined lexing regions found after
     * scanning a `FlexdocTemplate` token.
     */
    rescanInterpolatedFlexdoc(spans: TemplateSpan[]): void;
    /**
     * Initializes the lexer with predetermined lexing regions found after
     * scanning a `HeredocTemplate` token.
     */
    rescanInterpolatedHeredoc(spans: TemplateSpan[]): void;
    /**
     * Initializes the lexer with predetermined lexing regions found after
     * scanning a `ShellCommandTemplate` token.
     */
    rescanInterpolatedShellCommand(spans: TemplateSpan[]): void;
    /**
     * Initializes the lexer with predetermined lexing regions found after
     * scanning a `StringTemplate` token.
     *
     * This method should only be used on a new, temporary `PhpLexer` object,
     * that was created with the text of the `StringTemplate` token.
     *
     * @see PhpLexer.templateSpans
     */
    rescanInterpolatedString(spans: TemplateSpan[]): void;
    /**
     * Sets the source text to tokenize.
     *
     * @param {ISourceText} text
     *   The source text to tokenize.
     * @param {number=} start
     *   The offset within the text to start tokenizing. Defaults to 0.
     * @param {number=} length
     *   The maximum number of characters to tokenize. Defaults to the length
     *   of the text.
     */
    setText(text: ISourceText, start?: number, length?: number): void;
    /**
     * Determines if the given heredoc (or nowdoc) label is present at the
     * lexer's current position.
     *
     * @param {string} label
     *   The label used to delimit the string.
     */
    protected isHeredocEnd(label: string): boolean;
    /**
     * Tokenizes a starting or ending heredoc label.
     */
    protected lexHeredocLabel(): PhpLexerState;
    /**
     * Tokenizes inline text until a PHP open tag is encountered.
     */
    protected lexInlineText(): PhpLexerState;
    /**
     * Tokenizes the text of a nowdoc string.
     */
    protected lexNowdoc(): PhpLexerState;
    /**
     * Tokenizes object operators and property names.
     *
     * @todo Unused.
     */
    protected lexProperty(): PhpLexerState;
    /**
     * Tokenizes the region of source text that contains PHP script.
     */
    protected lexScript(): PhpLexerState;
    /**
     * Tokenizes the regions within a string template that are not part of an
     * interpolation.
     */
    protected lexString(): PhpLexerState;
    /**
     * Tokenizes an identifier found in a string template.
     *
     * This is slightly different than scanning outside of a string, because
     * keyword tokens are not permitted.
     */
    protected lexVariableName(): PhpLexerState;
    /**
     * Tokenizes an element access offset found in a string template.
     */
    protected lexVariableOffset(): PhpLexerState;
    /**
     * Scans the digits of a binary integer.
     */
    protected scanBinDigits(): number;
    /**
     * Scans for the indent in a flexible heredoc.
     */
    protected scanFlexdocIndent(): number;
    /**
     * Scans the indentation of the end label in a flexdoc template.
     */
    protected scanHeredocEndLabelIndent(): number;
    /**
     * Scans the digits of a hexadecimal integer.
     */
    protected scanHexDigits(): number;
    /**
     * Scans an identifier and determines if it is a keyword.
     */
    protected scanIdentifierOrKeyword(): number;
    /**
     * Scans for additional characters that may be part of an identifer name.
     */
    protected scanIdentifierPart(): number;
    /**
     * Scans inline text within an interpolated string.
     */
    protected scanInterpolatedInlineText(): number;
    /**
     * Scans any PHP script within an interpolated string.
     */
    protected scanInterpolatedScript(delimiter: Character): number;
    /**
     * Scans the contents of a possible interpolated string.
     *
     * @param {Character|string} delimiter
     *   A closing quote or label used to delimit a heredoc or nowdoc string.
     * @param {TemplateSpan[]=} spans
     *   An array to store any scanned interpolations within the string.
     * @param {number=} startLength
     *   The length of the string's starting token. For heredoc and nowdoc
     *   strings this length includes the '<<<' operator, whitespace, and
     *   optional quotation marks. For other strings, this is simply the length
     *   of the quote character.
     *
     * @return {number}
     *   The length of the interpolated string (not including the string
     *   terminator).
     *
     * State transitions for interpolated strings:
     *
     * InDoubleQuote
     * Input        Token              Transition
     * "$LABEL"     T_VARIABLE         Continue
     * "$LABEL["    T_VARIABLE         Start InVariableOffset
     * "$LABEL->*"  T_VARIABLE         Start LookingForProperty
     * "${"         T_DOLLAR_OPEN_...  Start LookingForVariableName
     * "{$"         "{"                Start InScript
     * "\""         "\""               End current state
     * "ANY"        T_ENCAPSED_AND...  Continue
     *
     * LookingForVariableName
     * Input        Token              Transition
     * "LABEL["     T_STRING_VARNAME   End current state, Start InScript
     * "LABEL}"     T_STRING_VARNAME   End current state, Start InScript
     * "ANY"        ---                End current state, Start Inscript
     *
     * LookingForProperty
     * Input        Token              Transition
     * "\s"         T_WHITESPACE       Continue
     * "->"         T_OBJECT_OPERATOR  Continue
     * "LABEL"      T_STRING           End current state
     * "ANY"        ---                End current state
     *
     * InVariableOffset
     * Input        Token              Transition         Remarks
     * "\d"         T_NUM_STRING       Continue           Also includes 0x and 0b numbers.
     * "LABEL"      T_STRING           Continue
     * "$LABEL"     T_VARIABLE         Continue
     * "TOKEN"      "TOKEN"            Continue           Also includes '{', '}', '"', '`'.
     * "]"          "]"                End current state
     * "\s"         T_ENCAPSED_AND...  End current state  Also includes '\\', '\'', and '#'.
     * "ANY"        ---                Throw
     */
    protected scanInterpolatedString(delimiter: Character | string, spans?: TemplateSpan[], startLength?: number): number;
    /**
     * Scans the offset of an interpolated variable.
     *
     * Unlike PHP's implementation which also attempts to lex a variety of
     * invalid tokens, this method only scans for a sequence of characters that
     * result in a valid production. This has several benefits:
     *
     * - The lexer doesn't have to try and tokenize a bunch of garbage.
     * - Invalid characters don't become uncacheable skipped tokens, which
     *   results in a faster parse and fewer objects being created.
     * - The lexer can immediately go back to scanning the string, which makes it
     *   much more likely to produce the desired tokens (PHP doesn't even try to
     *   recover gracefully).
     */
    protected scanInterpolatedVariableOffset(): number;
    /**
     * Scans the remaining portion of a line comment until a line break or close
     * tag is found.
     */
    protected scanLineComment(): number;
    /**
     * Scans the remaining portion of a multiple-line comment.
     */
    protected scanMultipleLineComment(): number;
    /**
     * Scans the remaining portion of a nowdoc until the end label is found.
     */
    protected scanNowdoc(label: string): number;
    /**
     * Scans for constant text within a nowdoc string.
     */
    protected scanNowdocString(): number;
    /**
     * Scans a decimal integer or floating-point number.
     *
     * A long consists of:
     * - One or more digits.
     *
     * A double consists of:
     * - Zero or more digits followed by a decimal point and one or more digits.
     * - One or more digits followed by a decimal point and zero or more digits.
     *
     * A double with exponent consists of:
     * - A long or double followed by 'e' or 'E', then an optional '+' or '-', and
     *   finally a long.
     */
    protected scanNumber(): number;
    /**
     * Scans for the digits of a number.
     *
     * @param {(ch: number) => boolean} predicate
     *   A callback used to determine what characters are valid digits in the
     *   number.
     *
     * @returns A tuple containing the total length of the scanned digits, and
     *   how many separators were present.
     */
    protected scanNumberPart(predicate: (ch: number) => boolean): [number, number];
    /**
     * Scans a hexadecimal or binary number. If not found, a decimal
     * or octal number is scanned instead.
     */
    protected scanNumberWithPrefix(): number;
    /**
     * Scans for an octal escape sequence.
     */
    protected scanOctalEscape(): number;
    /**
     * Scans the contents of a constant string.
     */
    protected scanSingleQuoteString(): number;
    /**
     * Scans for constant text within a string template.
     */
    protected scanStringTemplateLiteral(): number;
    /**
     * Scans for a unicode escape sequence.
     */
    protected scanUnicodeEscape(): number;
    /**
     * Scans any remaining whitespace characters.
     */
    protected scanWhitespace(): number;
    /**
     * Determines if an object operator and property name are present at the
     * scanner's current location.
     */
    protected startsWithObjectProperty(): boolean;
    /**
     * Returns a keyword or identifier token for the scanned text.
     */
    protected textToIdentifierToken(): TokenKind;
    /**
     * Attempts to scan for a heredoc or nowdoc string. If not found, a left
     * shift token is scanned instead.
     */
    protected tryScanHeredoc(spans: TemplateSpan[]): number;
    /**
     * Attempts to scan for a variable name in a string template that uses "${}"
     * syntax to explicity specify the name. If not found, nothing is scanned.
     */
    protected tryScanInterpolatedVariableName(): number;
    /**
     * Attempts to scan for a PHP script opening tag. If not found, nothing is
     * scanned.
     */
    protected tryScanOpenTag(): number;
    /**
     * Attempts to scan a full type cast token. If not found, only the opening
     * parenthesis is scanned instead.
     *
     * @todo Disabled optimization: Unsupported phi use of const or let variable.
     */
    protected tryScanTypeCast(): number;
    /**
     * Attempts to scan for the opening label or a heredoc string. If not found,
     * nothing is scanned.
     */
    private tryScanHeredocStartLabel;
}