476 lines
14 KiB
C
476 lines
14 KiB
C
|
// SPDX-License-Identifier: LGPL-3.0-or-later
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \file lexer.h
|
||
|
|
*
|
||
|
|
* C-compliant non-allocating UTF-8 text lexer.
|
||
|
|
*
|
||
|
|
* \author Lorenzo Cogotti
|
||
|
|
* \copyright The DoubleFourteen Code Forge (C) All Rights Reserved
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef DF_LEXER_H_
|
||
|
|
#define DF_LEXER_H_
|
||
|
|
|
||
|
|
#include "utf/utfdef.h"
|
||
|
|
|
||
|
|
/// Maximum allowed token length inside text parsed by `Lex`.
|
||
|
|
#define MAXTOKLEN 256
|
||
|
|
|
||
|
|
/// String token type
|
||
|
|
#define TT_STRING U16_C(1)
|
||
|
|
/// Literal token type
|
||
|
|
#define TT_LITERAL U16_C(2)
|
||
|
|
/// Numeric token type
|
||
|
|
#define TT_NUMBER U16_C(3)
|
||
|
|
/// Token type for names or identifiers
|
||
|
|
#define TT_NAME U16_C(4)
|
||
|
|
/// Punctuation token type
|
||
|
|
#define TT_PUNCT U16_C(5)
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Token subtype flags for `TT_NUMBER`
|
||
|
|
*
|
||
|
|
* @{
|
||
|
|
*/
|
||
|
|
|
||
|
|
#define TT_INT BIT(0) ///< integer
|
||
|
|
#define TT_DEC BIT(1) ///< decimal number
|
||
|
|
#define TT_HEX BIT(2) ///< hexadecimal number
|
||
|
|
#define TT_OCT BIT(3) ///< octal number
|
||
|
|
#define TT_BIN BIT(4) ///< binary number
|
||
|
|
#define TT_LONG BIT(5) ///< long int
|
||
|
|
#define TT_LLONG BIT(6) ///< long long int
|
||
|
|
#define TT_UNSIGNED BIT(7) ///< unsigned int
|
||
|
|
#define TT_FLOAT BIT(8) ///< floating point number
|
||
|
|
#define TT_SINGLE_PREC BIT(9) ///< float
|
||
|
|
#define TT_DOUBLE_PREC BIT(10) ///< double
|
||
|
|
#define TT_EXT_PREC BIT(11) ///< long double
|
||
|
|
#define TT_INF BIT(12) ///< infinite 1.#INF
|
||
|
|
#define TT_INDEF BIT(13) ///< indefinite 1.#IND
|
||
|
|
#define TT_NAN BIT(14) ///< NaN
|
||
|
|
#define TT_IPADDR BIT(15) ///< ip address (address may still be ill-formed, e.g. `102948.22.999.1`)
|
||
|
|
#define TT_IPV4 BIT(16) ///< ipv4 address format
|
||
|
|
#define TT_IPV6 BIT(17) ///< ipv6 address format
|
||
|
|
#define TT_IPV6LIT BIT(18) ///< ipv6 address is expressed as literal (e.g. `[2001:db8:a::123]`)
|
||
|
|
#define TT_IPV6ZONE BIT(19) ///< ipv6 address contains a zone index/string (e.g. `fe80::1ff:fe23:4567:890a%3`)
|
||
|
|
#define TT_IPPORT BIT(20) ///< ip address includes a port
|
||
|
|
|
||
|
|
/** @} */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Token flags
|
||
|
|
*
|
||
|
|
* @{
|
||
|
|
*/
|
||
|
|
|
||
|
|
/// Indicates `Tok` originally exceeded `MAXTOKLEN` and was consequently truncated.
|
||
|
|
#define TT_TRUNC BIT(15)
|
||
|
|
|
||
|
|
/** @} */
|
||
|
|
|
||
|
|
/// Lexer punctuation token descriptor (text -> token `subtype`).
|
||
|
|
typedef struct Punctuation Punctuation;
|
||
|
|
struct Punctuation {
|
||
|
|
const char *p; ///< NULL for last element in punctuation list.
|
||
|
|
Uint32 id; ///< Puntuation identifier (returned in `Tok->subtype`)
|
||
|
|
};
|
||
|
|
|
||
|
|
// punctuation ids
|
||
|
|
#define P_RSHIFT_ASSIGN 1
|
||
|
|
#define P_LSHIFT_ASSIGN 2
|
||
|
|
#define P_PARMS 3
|
||
|
|
#define P_PRECOMPMERGE 4
|
||
|
|
|
||
|
|
#define P_LOGIC_AND 5
|
||
|
|
#define P_LOGIC_OR 6
|
||
|
|
#define P_LOGIC_GEQ 7
|
||
|
|
#define P_LOGIC_LEQ 8
|
||
|
|
#define P_LOGIC_EQ 9
|
||
|
|
#define P_LOGIC_UNEQ 10
|
||
|
|
|
||
|
|
#define P_MUL_ASSIGN 11
|
||
|
|
#define P_DIV_ASSIGN 12
|
||
|
|
#define P_MOD_ASSIGN 13
|
||
|
|
#define P_ADD_ASSIGN 14
|
||
|
|
#define P_SUB_ASSIGN 15
|
||
|
|
#define P_INC 16
|
||
|
|
#define P_DEC 17
|
||
|
|
|
||
|
|
#define P_BIN_AND_ASSIGN 18
|
||
|
|
#define P_BIN_OR_ASSIGN 19
|
||
|
|
#define P_BIN_XOR_ASSIGN 20
|
||
|
|
#define P_RSHIFT 21
|
||
|
|
#define P_LSHIFT 22
|
||
|
|
|
||
|
|
#define P_POINTERREF 23
|
||
|
|
#define P_MUL 24
|
||
|
|
#define P_DIV 25
|
||
|
|
#define P_MOD 26
|
||
|
|
#define P_ADD 27
|
||
|
|
#define P_SUB 28
|
||
|
|
#define P_ASSIGN 29
|
||
|
|
|
||
|
|
#define P_BIN_AND 30
|
||
|
|
#define P_BIN_OR 31
|
||
|
|
#define P_BIN_XOR 32
|
||
|
|
#define P_BIN_NOT 33
|
||
|
|
|
||
|
|
#define P_LOGIC_NOT 34
|
||
|
|
#define P_LOGIC_GREATER 35
|
||
|
|
#define P_LOGIC_LESS 36
|
||
|
|
|
||
|
|
#define P_REF 37
|
||
|
|
#define P_COMMA 38
|
||
|
|
#define P_SEMICOLON 39
|
||
|
|
#define P_COLON 40
|
||
|
|
#define P_QUESTIONMARK 41
|
||
|
|
|
||
|
|
#define P_PARENOPEN 42
|
||
|
|
#define P_PARENCLOSE 43
|
||
|
|
#define P_BRACEOPEN 44
|
||
|
|
#define P_BRACECLOSE 45
|
||
|
|
#define P_SQBRACKETOPEN 46
|
||
|
|
#define P_SQBRACKETCLOSE 47
|
||
|
|
#define P_BACKSLASH 48
|
||
|
|
|
||
|
|
#define P_PRECOMP 49
|
||
|
|
#define P_DOLLAR 50
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Token returned by `Lex`.
|
||
|
|
*
|
||
|
|
* Contains token text and information.
|
||
|
|
*/
|
||
|
|
typedef struct Tok Tok;
|
||
|
|
struct Tok {
|
||
|
|
Uint16 type;
|
||
|
|
Uint16 flags;
|
||
|
|
Uint32 subtype;
|
||
|
|
|
||
|
|
unsigned linesCrossed;
|
||
|
|
unsigned spacesBeforeToken;
|
||
|
|
unsigned line;
|
||
|
|
|
||
|
|
long long intvalue;
|
||
|
|
double floatvalue;
|
||
|
|
|
||
|
|
Tok *nextToken;
|
||
|
|
|
||
|
|
char text[MAXTOKLEN]; // NOTE: last element to allow partial allocation
|
||
|
|
};
|
||
|
|
|
||
|
|
/// Disregard lexer errors
|
||
|
|
#define L_NOERR BIT(0)
|
||
|
|
/// Disregard lexer warnings
|
||
|
|
#define L_NOWARN BIT(1)
|
||
|
|
/// Disregard both errors and warnings
|
||
|
|
#define L_QUIET (L_NOERR | L_NOWARN)
|
||
|
|
/// Use console colors when reporting errors and warnings
|
||
|
|
#define L_COLORED BIT(2)
|
||
|
|
/// Parse all tokens as strings, instead of breaking them using full-fledged C rules
|
||
|
|
#define L_STRONLY BIT(3)
|
||
|
|
/// Allow file paths within tokens
|
||
|
|
#define L_ALLOWPATHS BIT(4)
|
||
|
|
/// Do not allow escapes within strings
|
||
|
|
#define L_NOSTRESC BIT(5)
|
||
|
|
/// Do not concatenate consecutive strings
|
||
|
|
#define L_NOSTRCAT BIT(6)
|
||
|
|
/// Concatenate strings separated by a backslash+newline
|
||
|
|
#define L_ALLOWBACKSLASHSTRCAT BIT(7)
|
||
|
|
/// Allow multichar literals
|
||
|
|
#define L_ALLOWMULTICHARLIT BIT(8)
|
||
|
|
/// Accepts IP addresses (parsed as `TT_NUMBER`)
|
||
|
|
#define L_ALLOWIPADDR BIT(9)
|
||
|
|
/// IP addresses with port numbers, IPv6 literals or zone ids won't be accepted,
|
||
|
|
/// only meaningful if used with `L_ALLOWIPADDR`.
|
||
|
|
#define L_PLAINIPADDRONLY BIT(10)
|
||
|
|
/// Allow special floating point exception tokens (0.#INF, 0.#IND).
|
||
|
|
#define L_ALLOWFLOATEXC BIT(10)
|
||
|
|
/// Allow truncating tokens exceeding `MAXTOKLEN`.
|
||
|
|
#define L_ALLOWTRUNC BIT(11)
|
||
|
|
/// Do not search base `#include` paths (used by PC library).
|
||
|
|
#define L_NOBASEINCLUDES BIT(12)
|
||
|
|
|
||
|
|
/// Special callback, invokes immediate program termination after reporting a lexer message
|
||
|
|
#define LEX_QUIT ((void (*)(Lex *, const char *, void *)) -1)
|
||
|
|
/// Special callback, makes the lexer ignore the the warning or error
|
||
|
|
/// (same behavior as `L_NOERR` and `L_NOWARN`, but as an explicit callback).
|
||
|
|
#define LEX_IGN ((void (*)(Lex *, const char *, void *)) 0)
|
||
|
|
/// Special callback, makes the lexer print an error or warning message to `stderr`,
|
||
|
|
/// doesn't terminate execution.
|
||
|
|
#define LEX_WARN ((void (*)(Lex *, const char *, void *)) 1)
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief A lexer, breaks text into single tokens, keeping track of the current position.
|
||
|
|
*
|
||
|
|
* \note This struct should be considered opaque.
|
||
|
|
*/
|
||
|
|
typedef struct Lex Lex;
|
||
|
|
struct Lex {
|
||
|
|
char *pos, *lim;
|
||
|
|
unsigned line;
|
||
|
|
Uint16 flags;
|
||
|
|
Boolean8 hasError;
|
||
|
|
Boolean8 hasBufferedToken;
|
||
|
|
Rune nr;
|
||
|
|
|
||
|
|
const Punctuation *puncts;
|
||
|
|
|
||
|
|
void *obj;
|
||
|
|
void (*Error)(Lex *, const char *, void *);
|
||
|
|
void (*Warn)(Lex *, const char *, void *);
|
||
|
|
|
||
|
|
Lex *nextLexer;
|
||
|
|
|
||
|
|
Tok buf;
|
||
|
|
char name[MAXTOKLEN];
|
||
|
|
};
|
||
|
|
|
||
|
|
/// Register callbacks for lexer warning and error triggers.
|
||
|
|
FORCE_INLINE void SetLexerErrorFunc(Lex *p,
|
||
|
|
void (*errf)(Lex *, const char *, void *),
|
||
|
|
void (*warnf)(Lex *, const char *, void *),
|
||
|
|
void *obj)
|
||
|
|
{
|
||
|
|
p->Error = errf;
|
||
|
|
p->Warn = warnf;
|
||
|
|
p->obj = obj;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Set parsing session name and initial line number.
|
||
|
|
*
|
||
|
|
* \param [out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] name Name for this parsing session
|
||
|
|
* \param [in] line Initial line number, 0 is implicitly changed to 1
|
||
|
|
*/
|
||
|
|
void BeginLexerSession(Lex *p, const char *name, unsigned line);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Setup lexer to parse text, sized.
|
||
|
|
*
|
||
|
|
* \param [out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] text Text to be parsed, must have at least `n` chars
|
||
|
|
* \param [in] n Number of chars in `text`
|
||
|
|
*/
|
||
|
|
void SetLexerTextn(Lex *p, const char *text, size_t n);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Setup lexer to parse text.
|
||
|
|
*
|
||
|
|
* \param [out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] text `NUL` terminated text to be parsed
|
||
|
|
*/
|
||
|
|
FORCE_INLINE void SetLexerText(Lex *p, const char *text)
|
||
|
|
{
|
||
|
|
EXTERNC size_t strlen(const char *);
|
||
|
|
|
||
|
|
SetLexerTextn(p, text, strlen(text));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Change lexer flags.
|
||
|
|
*
|
||
|
|
* \param [out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] flags New flags for the lexer
|
||
|
|
*/
|
||
|
|
FORCE_INLINE void SetLexerFlags(Lex *p, unsigned flags)
|
||
|
|
{
|
||
|
|
p->flags = flags;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Retrieve current lexer flags.
|
||
|
|
FORCE_INLINE unsigned GetLexerFlags(Lex *p)
|
||
|
|
{
|
||
|
|
return p->flags;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Trigger an error over a lexer.
|
||
|
|
CHECK_PRINTF(2, 3) void LexerError(Lex *p, const char *fmt, ...);
|
||
|
|
/**
|
||
|
|
* Trigger a warning over a lexer.
|
||
|
|
*/
|
||
|
|
CHECK_PRINTF(2, 3) void LexerWarning(Lex *p, const char *fmt, ...);
|
||
|
|
|
||
|
|
/// Test whether a lexer reached the end.
|
||
|
|
FORCE_INLINE Boolean IsLexerEndOfFile(Lex *p)
|
||
|
|
{
|
||
|
|
return (p->pos >= p->lim || *p->pos == '\0') && !p->hasBufferedToken;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Test whether a lexer encountered an error.
|
||
|
|
FORCE_INLINE Boolean HasLexerError(Lex *p)
|
||
|
|
{
|
||
|
|
return p->hasError;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Read and return next token.
|
||
|
|
*
|
||
|
|
* \param [in,out] p A lexer, must not be `NULL`
|
||
|
|
* \param [out] dest Storage for the returned token, must not be `NULL`
|
||
|
|
*
|
||
|
|
* \return If a new token has been read, then `tok->text` is returned,
|
||
|
|
* `NULL` is returned if a parsing error has been encountered,
|
||
|
|
* or no more tokens are available.
|
||
|
|
*/
|
||
|
|
char *Lex_ReadToken(Lex *p, Tok *dest);
|
||
|
|
/**
|
||
|
|
* \brief Read and return next token in the same line.
|
||
|
|
*
|
||
|
|
* This is a variant of `Lex_ReadToken()` useful to implement
|
||
|
|
* a C Preprocessor, it avoids parsing spanning more than one line.
|
||
|
|
* `\` followed by a newline is recognized and treated as a regular
|
||
|
|
* space.
|
||
|
|
*/
|
||
|
|
char *Lex_ReadTokenOnLine(Lex *p, Tok *dest);
|
||
|
|
/**
|
||
|
|
* \brief Expects an integral token, reading and returning its value.
|
||
|
|
*
|
||
|
|
* \param [in,out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] optionalSign Allow an optional `+` or `-` sign before the
|
||
|
|
* token, if set to `FALSE` only unsigned
|
||
|
|
* integers are allowed.
|
||
|
|
*
|
||
|
|
* \return The token value, 0 on error, use `HasLexerError()` to distinguish
|
||
|
|
* between actual 0 and error value.
|
||
|
|
*/
|
||
|
|
long long Lex_ParseInt(Lex *p, Boolean optionalSign);
|
||
|
|
/**
|
||
|
|
* \brief Expects a boolean token, reading and returning its value.
|
||
|
|
*
|
||
|
|
* \param [in,out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] allowNumeric Convert numeric values to booleans, 0 for
|
||
|
|
* `FALSE`, any other numeric value for `TRUE`
|
||
|
|
*
|
||
|
|
* \return The boolean value, `FALSE` on error or end of file,
|
||
|
|
* use `HasLexerError()` or `IsLexerEndOfFile()` to distinguish
|
||
|
|
* between actual `FALSE` and error value.
|
||
|
|
*/
|
||
|
|
Boolean Lex_ParseBool(Lex *p, Boolean allowNumeric);
|
||
|
|
/**
|
||
|
|
* \brief Expects a floating point token, reading and returning its value.
|
||
|
|
*
|
||
|
|
* \param [in,out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] optionalSign Allow an optional `+` or `-` sign before the
|
||
|
|
* token, if set to `FALSE` only non-negative
|
||
|
|
* values are allowed.
|
||
|
|
*
|
||
|
|
* \return The float value, 0 on error or end of file,
|
||
|
|
* use `HasLexerError()` or `IsLexerEndOfFile()` to distinguish
|
||
|
|
* between actual 0 and error value.
|
||
|
|
*/
|
||
|
|
double Lex_ParseFloat(Lex *p, Boolean optionalSign);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Read a one dimensional matrix (vector of length `n`) from `p` into `dest`.
|
||
|
|
*
|
||
|
|
* Matrix format is:
|
||
|
|
* ```
|
||
|
|
* (x y z w ...)
|
||
|
|
* ```
|
||
|
|
*
|
||
|
|
* \return `TRUE` on success, `FALSE` on error.
|
||
|
|
*/
|
||
|
|
Boolean Lex_ParseMatrix1(Lex *p, float *dest, size_t n);
|
||
|
|
/**
|
||
|
|
* \brief `Lex_ParseMatrix1()` variant for two dimensional matrixes.
|
||
|
|
*
|
||
|
|
* Matrix format is:
|
||
|
|
* ```
|
||
|
|
* ((x0 y0 z0 w0 ...) (x1 y1 z1 w1 ...) ...)
|
||
|
|
* ```
|
||
|
|
*/
|
||
|
|
Boolean Lex_ParseMatrix2(Lex *p, float *dest, size_t n, size_t m);
|
||
|
|
/// `Lex_ParseMatrix1()` variant for tridimensional matrixes.
|
||
|
|
Boolean Lex_ParseMatrix3(Lex *p, float *dest, size_t n, size_t m, size_t u);
|
||
|
|
|
||
|
|
/// Discard any buffered token and any in text token up to a new line.
|
||
|
|
void Lex_SkipLine(Lex *p);
|
||
|
|
/**
|
||
|
|
* \brief Skip every token until `tok` is encountered.
|
||
|
|
*
|
||
|
|
* \param [in,out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] tok Token to look for, must not be `NULL`
|
||
|
|
*
|
||
|
|
* \return `tok` on success, `NULL` on error or end of file.
|
||
|
|
*/
|
||
|
|
char *Lex_SkipUntil(Lex *p, const char *tok);
|
||
|
|
/**
|
||
|
|
* \brief Expect and skip section enclosed within braces.
|
||
|
|
*
|
||
|
|
* Braced sections are enclosed by punctuation tokens of id `P_BRACEOPEN` and
|
||
|
|
* `P_BRACECLOSE`.
|
||
|
|
*
|
||
|
|
* \param [in,out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] parseFirstBrace Whether the function should expect the next
|
||
|
|
* token to be the first brace of the section
|
||
|
|
* (`TRUE`) or it should assume the first brace
|
||
|
|
* has already been parsed (`FALSE`).
|
||
|
|
*
|
||
|
|
* \return `TRUE` if section was skipped successfully, `FALSE` on error
|
||
|
|
* (either unbalanced braces or unexpected token).
|
||
|
|
*/
|
||
|
|
Boolean Lex_SkipBracedSection(Lex *p, Boolean parseFirstBrace);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Expect a token, matching and returning it, raises error on mismatch.
|
||
|
|
*
|
||
|
|
* \param [in,out] p A lexer, must not be `NULL`
|
||
|
|
* \param [in] tok Token to be expected, must not be `NULL`
|
||
|
|
*
|
||
|
|
* \return On success `tok` is returned, on error `NULL`.
|
||
|
|
*/
|
||
|
|
char *Lex_MatchToken(Lex *p, const char *tok);
|
||
|
|
/**
|
||
|
|
* \brief Expect any token, raises an error if none is found.
|
||
|
|
*
|
||
|
|
* \param [in,out] p A lexer, must not be `NULL`
|
||
|
|
* \param [out] dest Storage for returned token, must not be `NULL`
|
||
|
|
*
|
||
|
|
* \return On success `tok->text` is returned, on error `NULL`.
|
||
|
|
*/
|
||
|
|
char *Lex_MatchAnyToken(Lex *p, Tok *dest);
|
||
|
|
/**
|
||
|
|
* \brief Expect a token of a specific `type` and `subtype`, raise error on mismatch.
|
||
|
|
*
|
||
|
|
* \param [in,out] p A lexer, must not be `NULL`
|
||
|
|
* \param [out] dest Storage for returned token, must not be `NULL`
|
||
|
|
* \param [in] type Token type to be expected
|
||
|
|
* \param [in] subtype Subtype mask for the expected token
|
||
|
|
*
|
||
|
|
* \return On success `tok->text`, `NULL` otherwise.
|
||
|
|
*/
|
||
|
|
char *Lex_MatchTokenType(Lex *p, Tok *dest, int type, unsigned subtype);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check whether next token matches `tok`.
|
||
|
|
*
|
||
|
|
* If token matches it is read from `p` and returned, as in `Lex_ReadToken()`,
|
||
|
|
* otherwise `p` is left unaltered (except for parsing errors).
|
||
|
|
*/
|
||
|
|
char *Lex_CheckToken(Lex *p, const char *tok);
|
||
|
|
/// Similar to `Lex_CheckToken()`, but matches by token `type` and `subtype`.
|
||
|
|
char *Lex_CheckTokenType(Lex *, Tok *dest, int type, unsigned subtype);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Peek next token from `p` and test whether it matches with `tok`.
|
||
|
|
*
|
||
|
|
* In no case next token is consumed from `p`, lexer is left unaltered
|
||
|
|
* (except for parsing errors).
|
||
|
|
*/
|
||
|
|
char *Lex_PeekToken(Lex *p, const char *tok);
|
||
|
|
/// Similar to `Lex_PeekToken()`, but matches by token `type` and `subtype`.
|
||
|
|
char *Lex_PeekTokenType(Lex *p, Tok *dest, int type, unsigned subtype);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* \brief Place a token back into the lexer.
|
||
|
|
*
|
||
|
|
* Only one token may be placed back into the lexer at a time,
|
||
|
|
* it will be returned back on the next call to `Lex_ReadToken()`.
|
||
|
|
*/
|
||
|
|
void Lex_UngetToken(Lex *p, const Tok *tok);
|
||
|
|
|
||
|
|
#endif
|