2001-09-28 07:09:38 +00:00
|
|
|
|
/*
|
2002-11-06 16:32:28 +00:00
|
|
|
|
qc-lex.l
|
2001-09-28 07:09:38 +00:00
|
|
|
|
|
2002-11-06 16:32:28 +00:00
|
|
|
|
lexer for quakec
|
2001-09-28 07:09:38 +00:00
|
|
|
|
|
2002-11-06 16:32:28 +00:00
|
|
|
|
Copyright (C) 2001 Bill Currie <bill@taniwha.org>
|
2001-09-28 07:09:38 +00:00
|
|
|
|
|
2002-11-06 16:32:28 +00:00
|
|
|
|
Author: Bill Currie <bill@taniwha.org>
|
|
|
|
|
Date: 2001/06/12
|
2001-09-28 07:09:38 +00:00
|
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
|
|
|
modify it under the terms of the GNU General Public License
|
|
|
|
|
as published by the Free Software Foundation; either version 2
|
|
|
|
|
of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
|
|
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to:
|
|
|
|
|
|
|
|
|
|
Free Software Foundation, Inc.
|
|
|
|
|
59 Temple Place - Suite 330
|
|
|
|
|
Boston, MA 02111-1307, USA
|
|
|
|
|
|
|
|
|
|
*/
|
2023-10-08 01:57:57 +00:00
|
|
|
|
%option bison-locations
|
2023-10-10 17:34:39 +00:00
|
|
|
|
%option bison-bridge
|
|
|
|
|
%option reentrant
|
2023-10-08 01:57:57 +00:00
|
|
|
|
%option prefix="qc_yy"
|
|
|
|
|
%option noyywrap
|
|
|
|
|
%option debug
|
2023-10-21 01:12:41 +00:00
|
|
|
|
%option stack
|
2023-10-08 01:57:57 +00:00
|
|
|
|
|
2023-10-20 11:31:15 +00:00
|
|
|
|
%top{
|
2002-06-01 04:41:25 +00:00
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
|
# include "config.h"
|
|
|
|
|
#endif
|
2003-01-14 20:18:29 +00:00
|
|
|
|
|
2002-06-01 04:41:25 +00:00
|
|
|
|
#ifdef HAVE_STRING_H
|
|
|
|
|
# include <string.h>
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef HAVE_STRINGS_H
|
|
|
|
|
# include <strings.h>
|
|
|
|
|
#endif
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <ctype.h>
|
|
|
|
|
|
2002-06-27 22:48:28 +00:00
|
|
|
|
#include <QF/dstring.h>
|
2001-06-13 07:16:39 +00:00
|
|
|
|
#include <QF/hash.h>
|
2001-10-24 22:50:06 +00:00
|
|
|
|
#include <QF/sys.h>
|
2023-10-24 06:58:37 +00:00
|
|
|
|
#include <QF/va.h>
|
2002-06-27 22:48:28 +00:00
|
|
|
|
|
2020-06-21 14:15:17 +00:00
|
|
|
|
#include "tools/qfcc/include/class.h"
|
2023-10-25 12:07:50 +00:00
|
|
|
|
#include "tools/qfcc/include/cpp.h"
|
2020-06-21 14:15:17 +00:00
|
|
|
|
#include "tools/qfcc/include/debug.h"
|
|
|
|
|
#include "tools/qfcc/include/diagnostic.h"
|
|
|
|
|
#include "tools/qfcc/include/expr.h"
|
|
|
|
|
#include "tools/qfcc/include/grab.h"
|
|
|
|
|
#include "tools/qfcc/include/options.h"
|
|
|
|
|
#include "tools/qfcc/include/pragma.h"
|
|
|
|
|
#include "tools/qfcc/include/qfcc.h"
|
2023-10-20 11:31:15 +00:00
|
|
|
|
#include "tools/qfcc/include/rua-lang.h"
|
2020-06-21 14:15:17 +00:00
|
|
|
|
#include "tools/qfcc/include/shared.h"
|
|
|
|
|
#include "tools/qfcc/include/strpool.h"
|
|
|
|
|
#include "tools/qfcc/include/struct.h"
|
|
|
|
|
#include "tools/qfcc/include/symtab.h"
|
|
|
|
|
#include "tools/qfcc/include/type.h"
|
|
|
|
|
#include "tools/qfcc/include/value.h"
|
2023-10-20 11:31:15 +00:00
|
|
|
|
}
|
2020-06-21 14:15:17 +00:00
|
|
|
|
|
2023-10-20 11:31:15 +00:00
|
|
|
|
%{
|
2003-04-16 19:41:52 +00:00
|
|
|
|
#ifndef YY_PROTO
|
|
|
|
|
# define YY_PROTO(x) x
|
|
|
|
|
#else
|
|
|
|
|
# define YY_FLEX_REALLOC_HACK
|
|
|
|
|
#endif
|
|
|
|
|
|
2023-10-19 14:05:47 +00:00
|
|
|
|
#define YY_NO_INPUT // debian flex
|
|
|
|
|
#define YY_NO_UNPUT // debian flex
|
|
|
|
|
#define YY_NO_YYINPUT
|
|
|
|
|
#define YY_NO_YYUNPUT
|
2023-10-08 01:57:57 +00:00
|
|
|
|
|
2023-10-20 11:31:15 +00:00
|
|
|
|
#define YYSTYPE rua_tok_t
|
|
|
|
|
#define YYLTYPE rua_loc_t
|
2001-06-12 21:06:28 +00:00
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
typedef struct {
|
|
|
|
|
bool saw_true;
|
|
|
|
|
bool saw_else;
|
|
|
|
|
bool own_state;
|
|
|
|
|
bool enabled;
|
2023-10-26 11:31:54 +00:00
|
|
|
|
int line;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
} rua_cond_t;
|
|
|
|
|
|
|
|
|
|
typedef struct DARRAY_TYPE (rua_cond_t) rua_cond_stack_t;
|
2023-10-31 01:48:11 +00:00
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
YY_BUFFER_STATE buffer;
|
|
|
|
|
rua_cond_stack_t cond_stack;
|
|
|
|
|
} rua_incl_t;
|
|
|
|
|
|
2023-10-24 14:32:13 +00:00
|
|
|
|
typedef struct DARRAY_TYPE (rua_macro_t *) rua_macro_list_t;
|
2023-10-31 01:48:11 +00:00
|
|
|
|
typedef struct DARRAY_TYPE (rua_incl_t) rua_include_stack_t;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
|
2023-10-20 11:31:15 +00:00
|
|
|
|
typedef struct rua_extra_s {
|
|
|
|
|
int start_state;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
bool preprocessor;
|
|
|
|
|
bool recording;
|
2023-10-24 05:01:21 +00:00
|
|
|
|
bool params;
|
2023-10-24 06:58:37 +00:00
|
|
|
|
bool expand;
|
2023-10-26 11:31:54 +00:00
|
|
|
|
bool suppressed;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
qc_yypstate *qc_state;
|
|
|
|
|
pre_yypstate *pre_state;
|
2023-10-29 15:41:06 +00:00
|
|
|
|
pre_yypstate *args_state;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
rua_cond_stack_t cond_stack;
|
2023-10-25 12:07:50 +00:00
|
|
|
|
rua_include_stack_t include_stack;
|
2023-10-24 15:20:12 +00:00
|
|
|
|
dstring_t *dstr;
|
2023-10-23 09:32:06 +00:00
|
|
|
|
symtab_t *macro_tab;
|
2023-10-29 15:41:06 +00:00
|
|
|
|
rua_macro_t *pending_macro; // function-type waiting for args
|
2023-11-03 04:54:08 +00:00
|
|
|
|
rua_macro_t *macro; // macro being expanded
|
2023-10-24 06:58:37 +00:00
|
|
|
|
yyscan_t subscanner;
|
2023-10-20 11:31:15 +00:00
|
|
|
|
} rua_extra_t;
|
|
|
|
|
#define YY_EXTRA_TYPE rua_extra_t *
|
|
|
|
|
|
|
|
|
|
rua_extra_t *qc_yyget_extra (yyscan_t yyscanner) __attribute__((pure));
|
2023-10-10 17:34:39 +00:00
|
|
|
|
int yyget_lineno (yyscan_t yyscanner) __attribute__((pure));
|
|
|
|
|
int yyget_column (yyscan_t yyscanner) __attribute__((pure));
|
|
|
|
|
YYSTYPE *yyget_lval (yyscan_t yyscanner) __attribute__((pure));
|
|
|
|
|
YYLTYPE *yyget_lloc (yyscan_t yyscanner) __attribute__((pure));
|
|
|
|
|
int yyget_leng (yyscan_t yyscanner) __attribute__((pure));
|
|
|
|
|
char *yyget_text (yyscan_t yyscanner) __attribute__((pure));
|
|
|
|
|
int yyget_debug (yyscan_t yyscanner) __attribute__((pure));
|
|
|
|
|
FILE *yyget_in (yyscan_t yyscanner) __attribute__((pure));
|
|
|
|
|
FILE *yyget_out (yyscan_t yyscanner) __attribute__((pure));
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
static int directive (const char *token, yyscan_t scanner);
|
2023-10-10 17:34:39 +00:00
|
|
|
|
static int keyword_or_id (YYSTYPE *lval, const char *token);
|
2023-10-26 11:31:54 +00:00
|
|
|
|
static void update_loc (rua_loc_t *loc, size_t textlen);
|
|
|
|
|
static void save_text (rua_tok_t *tok, const char *text, size_t textlen,
|
|
|
|
|
int state);
|
2023-10-24 13:06:01 +00:00
|
|
|
|
static void next_line (rua_loc_t *loc, yyscan_t scanner);
|
2023-10-26 11:31:54 +00:00
|
|
|
|
static void dump_state_stack (void *scanner);
|
|
|
|
|
static void dump_token (rua_tok_t *tok, rua_loc_t *loc, int state);
|
|
|
|
|
static void dump_debug (int act, const char *text, int state);
|
2001-06-25 22:11:20 +00:00
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
typedef enum {
|
2023-10-20 12:15:17 +00:00
|
|
|
|
rua_eof = 1,
|
2023-10-24 04:23:06 +00:00
|
|
|
|
rua_ignore,
|
2023-10-20 12:15:17 +00:00
|
|
|
|
rua_error,
|
2023-10-24 04:23:06 +00:00
|
|
|
|
rua_id,
|
2023-10-20 12:15:17 +00:00
|
|
|
|
rua_number,
|
|
|
|
|
rua_vector,
|
2023-10-20 16:13:32 +00:00
|
|
|
|
rua_string,
|
|
|
|
|
rua_char,
|
2023-10-23 13:00:14 +00:00
|
|
|
|
rua_space,
|
2023-10-30 04:25:48 +00:00
|
|
|
|
rua_ellipsis,
|
2023-10-31 01:37:02 +00:00
|
|
|
|
rua_asx,
|
|
|
|
|
rua_incop,
|
2023-10-20 12:15:17 +00:00
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
rua_num_term,
|
|
|
|
|
} rua_term;
|
|
|
|
|
|
2023-10-26 11:31:54 +00:00
|
|
|
|
#define YY_USER_ACTION \
|
|
|
|
|
update_loc (yylloc, yyleng); \
|
|
|
|
|
save_text (yylval, yytext, yyleng, yystart()); \
|
|
|
|
|
if (0) { dump_debug (yy_act, yytext, yystart()); } \
|
|
|
|
|
if (0) { dump_token (yylval, yylloc, yystart ()); } \
|
|
|
|
|
if (0) { dump_state_stack(yyscanner); }
|
2001-06-13 07:16:39 +00:00
|
|
|
|
|
2001-06-12 21:06:28 +00:00
|
|
|
|
%}
|
|
|
|
|
|
2011-01-14 03:10:28 +00:00
|
|
|
|
s [ \t]
|
|
|
|
|
m [\-+]
|
|
|
|
|
D [0-9]
|
2023-10-20 12:15:17 +00:00
|
|
|
|
IDs [a-zA-Z_]
|
|
|
|
|
IDc [a-zA-Z_0-9]
|
|
|
|
|
ID {IDs}{IDc}*
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
FD [fFdD]
|
|
|
|
|
UL ([uU]?([lL][lL]?)?)
|
|
|
|
|
ULFD ({UL}|{FD})
|
2011-01-14 03:10:28 +00:00
|
|
|
|
RANGE \.\.
|
|
|
|
|
ELLIPSIS \.\.\.
|
|
|
|
|
FRAMEID {ID}(\.{ID})*
|
2012-11-22 11:42:00 +00:00
|
|
|
|
PRAGMAID {ID}(-{ID})*
|
2023-10-20 16:13:32 +00:00
|
|
|
|
s_string \"(\\.|[^"\\])*\"
|
|
|
|
|
c_string '(\\.|[^'\\])*'
|
2023-10-22 11:56:12 +00:00
|
|
|
|
h_string <[^>]*>
|
|
|
|
|
q_string \"[^\"]*\"
|
2001-06-12 21:06:28 +00:00
|
|
|
|
|
2023-10-20 12:15:17 +00:00
|
|
|
|
pp_number \.?{D}({IDc}|'{IDc}|[eEpP]{m}|\.)*
|
2023-10-20 16:17:11 +00:00
|
|
|
|
pp_vnumber '({s}*{m}?{pp_number}){2,4}{s}*'{ULFD}?
|
2023-10-20 12:15:17 +00:00
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
%x GRAB_FRAME GRAB_OTHER GRAB_WRITE
|
|
|
|
|
%x COMMENT LCOMMENT
|
2023-10-28 14:51:12 +00:00
|
|
|
|
%x DIRECTIVE TEXT
|
|
|
|
|
%x PRAGMA VECTOR
|
|
|
|
|
%s PREPROC PREEXPR
|
|
|
|
|
%s MACRO ARGS
|
2023-10-26 11:31:54 +00:00
|
|
|
|
%x CONT
|
2001-06-13 18:35:41 +00:00
|
|
|
|
|
2001-06-12 21:06:28 +00:00
|
|
|
|
%%
|
2023-10-22 11:56:12 +00:00
|
|
|
|
auto extra = qc_yyget_extra (yyscanner);
|
2023-10-20 16:17:11 +00:00
|
|
|
|
yyset_debug (0, yyscanner);
|
|
|
|
|
grab_frame = GRAB_FRAME;
|
|
|
|
|
grab_other = GRAB_OTHER;
|
|
|
|
|
grab_write = GRAB_WRITE;
|
|
|
|
|
yylval->pointer = 0; // ensure pointer vals are null
|
|
|
|
|
|
2023-10-26 11:31:54 +00:00
|
|
|
|
<COMMENT>"/*" { warning (0, "nested /* in comment"); yymore();}
|
2023-10-23 13:00:14 +00:00
|
|
|
|
<COMMENT>\*+"/" { yy_pop_state (yyscanner); return -rua_space; }
|
2023-10-26 11:31:54 +00:00
|
|
|
|
<COMMENT>\r*\n { next_line (yylloc, yyscanner); yymore();}
|
|
|
|
|
<COMMENT>[^*/\n]* { yymore(); }/* munch on anything but possible end of comment */
|
|
|
|
|
<COMMENT>\/+[^*\n]* { yymore(); }/* handle /s not followed by * */
|
2023-10-30 04:22:57 +00:00
|
|
|
|
<COMMENT>\*+/[^/] { yymore(); }/* handle *s not followed by / */
|
2023-10-20 16:17:11 +00:00
|
|
|
|
<COMMENT><<EOF>> { error (0, "EOF in comment"); return 0; }
|
2023-10-26 11:31:54 +00:00
|
|
|
|
<*>"/*" { yy_push_state (COMMENT, yyscanner); yymore(); }
|
2023-10-30 05:32:11 +00:00
|
|
|
|
<*>"//" {
|
2023-10-26 11:31:54 +00:00
|
|
|
|
yymore();
|
2023-10-30 05:32:11 +00:00
|
|
|
|
yy_push_state (LCOMMENT, yyscanner);
|
|
|
|
|
}
|
|
|
|
|
<LCOMMENT>[^\\\r\n]+ /* consume all but \ and EOL (see line continuation) */
|
|
|
|
|
<LCOMMENT>[\\]+/[^\r\n] /* consume \ */
|
|
|
|
|
<LCOMMENT>\r*\n {
|
|
|
|
|
next_line (yylloc, yyscanner);
|
|
|
|
|
yy_pop_state (yyscanner);
|
2023-10-26 11:31:54 +00:00
|
|
|
|
int state = yystart ();
|
|
|
|
|
if (state == PREEXPR || state == PREPROC
|
2023-10-28 14:51:12 +00:00
|
|
|
|
|| state == DIRECTIVE || state == MACRO) {
|
2023-10-26 11:31:54 +00:00
|
|
|
|
return PRE_EOD;
|
|
|
|
|
}
|
|
|
|
|
}
|
2001-06-13 07:16:39 +00:00
|
|
|
|
|
2023-10-24 13:06:01 +00:00
|
|
|
|
<ARGS>^# { return '#'; }
|
2023-10-25 03:19:19 +00:00
|
|
|
|
^#{s}+/{D} {
|
|
|
|
|
yy_push_state (PREPROC, yyscanner);
|
|
|
|
|
extra->preprocessor = true;
|
|
|
|
|
return PRE_LINE;
|
|
|
|
|
}
|
2023-10-26 11:31:54 +00:00
|
|
|
|
<CONT>^. { yyless (yyleng - 1); yy_pop_state (yyscanner); }
|
2023-10-28 14:51:12 +00:00
|
|
|
|
<*>^{s}*#{s}* {
|
2023-10-22 11:56:12 +00:00
|
|
|
|
yy_push_state (DIRECTIVE, yyscanner);
|
|
|
|
|
extra->preprocessor = true;
|
|
|
|
|
}
|
2023-10-24 13:06:01 +00:00
|
|
|
|
<ARGS><<EOF>> { return 0; }
|
|
|
|
|
<ARGS>^{s}* { return -rua_space; }
|
2023-10-22 11:56:12 +00:00
|
|
|
|
|
|
|
|
|
<DIRECTIVE>{ID} { {
|
|
|
|
|
int tok = directive (yytext, yyscanner);
|
|
|
|
|
if (tok >= 0) {
|
|
|
|
|
return tok;
|
|
|
|
|
}
|
|
|
|
|
} }
|
2023-10-30 04:28:45 +00:00
|
|
|
|
<PREPROC>{ID} { return PRE_ID; }
|
2023-10-22 11:56:12 +00:00
|
|
|
|
<PREPROC>{ID}\( { return PRE_IDp; }
|
|
|
|
|
|
2023-10-30 04:25:48 +00:00
|
|
|
|
<ARGS>\r*\n { next_line (yylloc, yyscanner); return -rua_space; }
|
2023-10-22 11:56:12 +00:00
|
|
|
|
<DIRECTIVE>\r*\n |
|
|
|
|
|
<PREEXPR>\r*\n |
|
|
|
|
|
<MACRO,TEXT>\r*\n |
|
2023-10-24 13:06:01 +00:00
|
|
|
|
<PREPROC>\r*\n { next_line (yylloc, yyscanner); return PRE_EOD; }
|
2023-10-22 11:56:12 +00:00
|
|
|
|
|
|
|
|
|
<TEXT>[^\\\r\n]* { return PRE_TEXT; }
|
|
|
|
|
<TEXT>[\\]* { return PRE_TEXT; }
|
|
|
|
|
<MACRO>## { return PRE_CONCAT; }
|
|
|
|
|
<MACRO># { return '#'; }
|
2023-10-27 08:22:47 +00:00
|
|
|
|
<PREPROC>{h_string} { return PRE_HSTRING; }
|
|
|
|
|
<PREPROC>{q_string} { return PRE_QSTRING; }
|
2023-10-29 04:59:17 +00:00
|
|
|
|
<PREEXPR>{q_string} { return PRE_QSTRING; }
|
2023-10-23 09:32:06 +00:00
|
|
|
|
<PREEXPR>defined { return PRE_DEFINED; }
|
|
|
|
|
<PREEXPR>{ID} { return PRE_ID; }
|
2023-10-22 11:56:12 +00:00
|
|
|
|
|
2023-10-30 04:28:45 +00:00
|
|
|
|
<INITIAL,ARGS,MACRO>{
|
2023-10-24 13:06:01 +00:00
|
|
|
|
{ID} |
|
|
|
|
|
@{ID} { return -rua_id; }
|
|
|
|
|
}
|
2023-10-20 16:17:11 +00:00
|
|
|
|
@ { return '@'; }
|
|
|
|
|
|
|
|
|
|
{pp_number} { return -rua_number; }
|
|
|
|
|
{pp_vnumber} { return -rua_vector; }
|
2023-10-20 12:15:17 +00:00
|
|
|
|
<VECTOR>{pp_number} { return -rua_number; }
|
|
|
|
|
<VECTOR>{m} { return yytext[0]; }
|
|
|
|
|
<VECTOR>' { return -rua_eof; }
|
2002-01-04 08:45:24 +00:00
|
|
|
|
|
2023-10-20 16:13:32 +00:00
|
|
|
|
{s_string} { return -rua_string; };
|
|
|
|
|
{c_string} { return -rua_char; }
|
2023-10-20 16:17:11 +00:00
|
|
|
|
|
2023-10-31 01:37:02 +00:00
|
|
|
|
[+\-*/&|^%]= { return -rua_asx; }
|
|
|
|
|
"%%=" { return -rua_asx; }
|
|
|
|
|
"<<=" { return -rua_asx; }
|
|
|
|
|
">>=" { return -rua_asx; }
|
2023-10-20 16:17:11 +00:00
|
|
|
|
|
|
|
|
|
[!(){}.*/&|^~+\-=\[\];,#%?:] { return yytext[0]; }
|
|
|
|
|
|
2023-10-24 10:50:31 +00:00
|
|
|
|
"·" { return QC_DOT; }
|
|
|
|
|
"â‹€" { return QC_WEDGE; }
|
|
|
|
|
"•" { return QC_DOT; }
|
|
|
|
|
"∧" { return QC_WEDGE; }
|
|
|
|
|
"∨" { return QC_REGRESSIVE; }
|
|
|
|
|
"†" { return QC_REVERSE; }
|
|
|
|
|
"∗" { return QC_STAR; }
|
|
|
|
|
"×" { return QC_CROSS; }
|
|
|
|
|
"⋆" { return QC_DUAL; }
|
2023-10-20 16:17:11 +00:00
|
|
|
|
|
2023-10-24 10:50:31 +00:00
|
|
|
|
"%%" { return QC_MOD; }
|
2023-10-20 16:17:11 +00:00
|
|
|
|
|
2023-10-30 04:25:48 +00:00
|
|
|
|
{ELLIPSIS} { return -rua_ellipsis; }
|
2023-10-20 16:17:11 +00:00
|
|
|
|
|
2023-10-24 10:50:31 +00:00
|
|
|
|
"<<" { return QC_SHL; }
|
|
|
|
|
">>" { return QC_SHR; }
|
2023-10-20 16:17:11 +00:00
|
|
|
|
|
2023-10-24 10:50:31 +00:00
|
|
|
|
"&&" { return QC_AND; }
|
|
|
|
|
"||" { return QC_OR; }
|
|
|
|
|
"==" { return QC_EQ; }
|
|
|
|
|
"!=" { return QC_NE; }
|
|
|
|
|
"<=" { return QC_LE; }
|
|
|
|
|
">=" { return QC_GE; }
|
|
|
|
|
"<" { return QC_LT; }
|
|
|
|
|
">" { return QC_GT; }
|
2023-10-20 16:17:11 +00:00
|
|
|
|
|
2023-10-31 01:37:02 +00:00
|
|
|
|
"++" { return -rua_incop; }
|
|
|
|
|
"--" { return -rua_incop; }
|
2023-10-20 16:17:11 +00:00
|
|
|
|
|
|
|
|
|
"$"{s}*{FRAMEID} {
|
|
|
|
|
int ret = do_grab (yytext);
|
|
|
|
|
if (ret >= 0) {
|
|
|
|
|
yylval->value.expr = new_int_expr (ret, false);
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_VALUE;
|
2023-10-20 16:17:11 +00:00
|
|
|
|
} else {
|
2023-10-21 01:12:41 +00:00
|
|
|
|
yy_push_state (-ret, yyscanner);
|
2023-10-20 16:17:11 +00:00
|
|
|
|
}
|
2011-01-06 07:30:25 +00:00
|
|
|
|
}
|
2001-06-12 21:06:28 +00:00
|
|
|
|
|
2023-10-20 16:17:11 +00:00
|
|
|
|
<GRAB_FRAME>{FRAMEID} { add_frame_macro (yytext); }
|
2011-01-06 07:30:25 +00:00
|
|
|
|
<GRAB_OTHER>[^\r\n]* /* skip */
|
2023-10-20 16:13:32 +00:00
|
|
|
|
<GRAB_WRITE>{s_string} {
|
2012-11-21 11:50:45 +00:00
|
|
|
|
const char *s = make_string (yytext, 0);
|
|
|
|
|
write_frame_macros (s);
|
|
|
|
|
BEGIN (GRAB_OTHER); // ignore rest of line
|
|
|
|
|
}
|
2023-10-25 00:25:00 +00:00
|
|
|
|
<PRAGMA>{PRAGMAID} |
|
|
|
|
|
<PRAGMA>@{PRAGMAID} { return PRE_ID; }
|
|
|
|
|
<PRAGMA>\r*\n { next_line (yylloc, yyscanner); return PRE_EOD; }
|
2001-06-13 18:35:41 +00:00
|
|
|
|
|
2023-10-26 11:31:54 +00:00
|
|
|
|
<*>\\\r*\n {
|
|
|
|
|
/* line continuation */
|
|
|
|
|
next_line (yylloc, yyscanner);
|
|
|
|
|
}
|
|
|
|
|
<CONT><<EOF>> {
|
|
|
|
|
warning (0, "\\ at end of file");
|
|
|
|
|
yy_pop_state (yyscanner);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2023-10-20 16:17:11 +00:00
|
|
|
|
<*>\r*\n {
|
2023-10-24 13:06:01 +00:00
|
|
|
|
next_line (yylloc, yyscanner);
|
2023-10-21 01:12:41 +00:00
|
|
|
|
if (yyg->yy_start_stack_ptr) {
|
|
|
|
|
yy_pop_state (yyscanner);
|
2023-10-28 14:51:12 +00:00
|
|
|
|
extra->preprocessor = false;
|
2023-10-21 01:12:41 +00:00
|
|
|
|
}
|
2020-02-15 10:41:20 +00:00
|
|
|
|
}
|
2001-06-12 21:06:28 +00:00
|
|
|
|
|
2023-10-23 13:00:14 +00:00
|
|
|
|
<*>{s}+ { return -rua_space; }
|
2001-06-13 07:16:39 +00:00
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
<*>. {
|
|
|
|
|
error (0, "all your typo are belong to us:%d %d-%d",
|
|
|
|
|
yystart(),
|
|
|
|
|
yylloc->first_column, yylloc->last_column);
|
|
|
|
|
}
|
2001-06-12 21:06:28 +00:00
|
|
|
|
|
|
|
|
|
%%
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
#define ARRCOUNT(_k) (sizeof (_k) / sizeof (_k[0]))
|
|
|
|
|
|
2001-06-13 07:16:39 +00:00
|
|
|
|
typedef struct {
|
2011-01-17 13:33:33 +00:00
|
|
|
|
const char *name;
|
|
|
|
|
int value;
|
2023-02-04 09:26:54 +00:00
|
|
|
|
specifier_t spec;
|
2001-06-13 07:16:39 +00:00
|
|
|
|
} keyword_t;
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
typedef struct {
|
|
|
|
|
const char *name;
|
|
|
|
|
int value;
|
|
|
|
|
} directive_t;
|
|
|
|
|
|
|
|
|
|
// preprocessor directives in ruamoko and quakec
|
|
|
|
|
static directive_t rua_directives[] = {
|
|
|
|
|
{"include", PRE_INCLUDE},
|
|
|
|
|
{"embed", PRE_EMBED},
|
|
|
|
|
{"define", PRE_DEFINE},
|
|
|
|
|
{"undef", PRE_UNDEF},
|
|
|
|
|
{"error", PRE_ERROR},
|
|
|
|
|
{"warning", PRE_WARNING},
|
2023-10-28 14:51:12 +00:00
|
|
|
|
{"notice", PRE_NOTICE},
|
2023-10-22 11:56:12 +00:00
|
|
|
|
{"pragma", PRE_PRAGMA},
|
|
|
|
|
{"line", PRE_LINE},
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static directive_t cond_directives[] = {
|
|
|
|
|
{"if", PRE_IF},
|
|
|
|
|
{"ifdef", PRE_IFDEF},
|
|
|
|
|
{"ifndef", PRE_IFNDEF},
|
|
|
|
|
{"else", PRE_ELSE},
|
|
|
|
|
{"elif", PRE_ELIF},
|
|
|
|
|
{"elifdef", PRE_ELIFDEF},
|
|
|
|
|
{"elifndef", PRE_ELIFNDEF},
|
|
|
|
|
{"endif", PRE_ENDIF},
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
|
directive_get_key (const void *dir, void *unused)
|
|
|
|
|
{
|
|
|
|
|
return ((directive_t*)dir)->name;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
directive (const char *token, yyscan_t scanner)
|
|
|
|
|
{
|
|
|
|
|
static hashtab_t *rua_directive_tab;
|
|
|
|
|
static hashtab_t *cond_directive_tab;
|
|
|
|
|
|
|
|
|
|
yy_pop_state (scanner); // pop DIRECTIVE off the stack
|
|
|
|
|
yy_push_state (PREPROC, scanner);
|
|
|
|
|
|
|
|
|
|
if (!rua_directive_tab) {
|
|
|
|
|
rua_directive_tab = Hash_NewTable (253, directive_get_key, 0, 0, 0);
|
|
|
|
|
cond_directive_tab = Hash_NewTable (253, directive_get_key, 0, 0, 0);
|
|
|
|
|
|
|
|
|
|
for (size_t i = 0; i < ARRCOUNT(rua_directives); i++) {
|
|
|
|
|
Hash_Add (rua_directive_tab, &rua_directives[i]);
|
|
|
|
|
}
|
|
|
|
|
for (size_t i = 0; i < ARRCOUNT(cond_directives); i++) {
|
|
|
|
|
Hash_Add (cond_directive_tab, &cond_directives[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-10-28 14:51:12 +00:00
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
directive_t *directive = Hash_Find (cond_directive_tab, token);
|
2023-10-28 14:51:12 +00:00
|
|
|
|
if (!directive && !extra->suppressed) {
|
2023-10-22 11:56:12 +00:00
|
|
|
|
directive = Hash_Find (rua_directive_tab, token);
|
|
|
|
|
if (!directive) {
|
|
|
|
|
error (0, "invalid directive `%s`", token);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!directive) {
|
2023-10-30 05:32:11 +00:00
|
|
|
|
yy_pop_state (scanner);// suppressed non-conditional directive
|
|
|
|
|
yy_push_state (LCOMMENT, scanner);
|
|
|
|
|
extra->preprocessor = false;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
//auto lex = qc_yyget_extra (scanner);
|
|
|
|
|
//lex->current_lang = &lex->pre_lang;
|
|
|
|
|
return directive->value;
|
|
|
|
|
}
|
|
|
|
|
|
2022-02-03 15:25:31 +00:00
|
|
|
|
// These keywords are part of the Ruamoko language and require the QuakeForge
|
|
|
|
|
// Ruamoko VM.
|
|
|
|
|
static keyword_t rua_keywords[] = {
|
2023-02-04 09:26:54 +00:00
|
|
|
|
#define VEC_TYPE(type_name, base_type) \
|
2023-10-24 10:50:31 +00:00
|
|
|
|
{ #type_name, QC_TYPE_SPEC, .spec = { .type = &type_##type_name } },
|
2022-02-03 15:25:31 +00:00
|
|
|
|
#include "tools/qfcc/include/vec_types.h"
|
|
|
|
|
};
|
|
|
|
|
|
2012-12-22 07:31:14 +00:00
|
|
|
|
// These keywords are all part of the Ruamoko (Objective-QC) language.
|
|
|
|
|
// The first time any one of them is encountered, the class system will be
|
|
|
|
|
// initialized.
|
|
|
|
|
// If not compiling for the QuakeForge VM, or if Ruamoko has been disabled,
|
|
|
|
|
// then they will be unavailable as keywords.
|
|
|
|
|
static keyword_t obj_keywords[] = {
|
2023-10-24 10:50:31 +00:00
|
|
|
|
{"id", QC_OBJECT_NAME, .spec = { .type = &type_id } },
|
|
|
|
|
{"Class", QC_TYPE_SPEC, .spec = { .type = &type_Class } },
|
|
|
|
|
{"Method", QC_TYPE_SPEC, .spec = { .type = &type_method } },
|
|
|
|
|
{"Super", QC_TYPE_SPEC, .spec = { .type = &type_super } },
|
|
|
|
|
{"SEL", QC_TYPE_SPEC, .spec = { .type = &type_SEL } },
|
|
|
|
|
{"IMP", QC_TYPE_SPEC, .spec = { .type = &type_IMP } },
|
|
|
|
|
|
|
|
|
|
{"@class", QC_CLASS },
|
|
|
|
|
{"@defs", QC_DEFS },
|
|
|
|
|
{"@encode", QC_ENCODE },
|
|
|
|
|
{"@end", QC_END },
|
|
|
|
|
{"@implementation", QC_IMPLEMENTATION },
|
|
|
|
|
{"@interface", QC_INTERFACE },
|
|
|
|
|
{"@private", QC_PRIVATE },
|
|
|
|
|
{"@protected", QC_PROTECTED },
|
|
|
|
|
{"@protocol", QC_PROTOCOL },
|
|
|
|
|
{"@public", QC_PUBLIC },
|
|
|
|
|
{"@reference", QC_REFERENCE },
|
|
|
|
|
{"@selector", QC_SELECTOR },
|
|
|
|
|
{"@self", QC_SELF },
|
|
|
|
|
{"@this", QC_THIS },
|
2012-12-22 07:31:14 +00:00
|
|
|
|
|
|
|
|
|
// This is a hack to trigger the initialization of the class
|
|
|
|
|
// sytem if it is seen before any other Objective-QC symbol. Otherwise,
|
|
|
|
|
// it is just an identifier, though it does reference a built-in type
|
|
|
|
|
// created by the class system.
|
|
|
|
|
{"obj_module", 0 },
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// These keywords are extensions to QC and thus available only in advanced
|
|
|
|
|
// or extended code. However, if they are preceeded by an @ (eg, @for), then
|
|
|
|
|
// they are always available. This is to prevent them from causing trouble
|
|
|
|
|
// for traditional code that might use these words as identifiers, but still
|
|
|
|
|
// make the language features available to traditional code.
|
|
|
|
|
static keyword_t at_keywords[] = {
|
2023-10-24 10:50:31 +00:00
|
|
|
|
{"for", QC_FOR },
|
|
|
|
|
{"goto", QC_GOTO },
|
|
|
|
|
{"break", QC_BREAK },
|
|
|
|
|
{"continue", QC_CONTINUE},
|
|
|
|
|
{"switch", QC_SWITCH },
|
|
|
|
|
{"case", QC_CASE },
|
|
|
|
|
{"default", QC_DEFAULT },
|
|
|
|
|
{"nil", QC_NIL },
|
|
|
|
|
{"struct", QC_STRUCT },
|
|
|
|
|
{"union", QC_STRUCT },
|
|
|
|
|
{"enum", QC_ENUM },
|
|
|
|
|
{"typedef", QC_TYPEDEF },
|
|
|
|
|
{"extern", QC_EXTERN },
|
|
|
|
|
{"static", QC_STATIC },
|
|
|
|
|
{"sizeof", QC_SIZEOF },
|
|
|
|
|
{"not", QC_NOT },
|
|
|
|
|
{"auto", QC_TYPE_SPEC, .spec = { .type = &type_auto } },
|
2012-12-22 07:31:14 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// These keywords require the QuakeForge VM to be of any use. ie, they cannot
|
|
|
|
|
// be supported (sanely) by v6 progs.
|
|
|
|
|
static keyword_t qf_keywords[] = {
|
2023-10-24 10:50:31 +00:00
|
|
|
|
{"quaternion", QC_TYPE_SPEC, .spec = { .type = &type_quaternion } },
|
|
|
|
|
{"double", QC_TYPE_SPEC, .spec = { .type = &type_double } },
|
|
|
|
|
{"int", QC_TYPE_SPEC, .spec = { .type = &type_int } },
|
|
|
|
|
{"unsigned", QC_TYPE_SPEC, .spec = { .is_unsigned = 1 } },
|
|
|
|
|
{"signed", QC_TYPE_SPEC, .spec = { .is_signed = 1 } },
|
|
|
|
|
{"long", QC_TYPE_SPEC, .spec = { .is_long = 1 } },
|
|
|
|
|
{"short", QC_TYPE_SPEC, .spec = { .is_short = 1 } },
|
|
|
|
|
|
|
|
|
|
{"@function", QC_TYPE_SPEC, .spec = { .type = &type_func } },
|
|
|
|
|
{"@args", QC_ARGS, },
|
|
|
|
|
{"@va_list", QC_TYPE_SPEC, .spec = { .type = &type_va_list } },
|
|
|
|
|
{"@param", QC_TYPE_SPEC, .spec = { .type = &type_param } },
|
|
|
|
|
{"@return", QC_AT_RETURN, },
|
|
|
|
|
|
|
|
|
|
{"@hadamard", QC_HADAMARD, },
|
|
|
|
|
{"@cross", QC_CROSS, },
|
|
|
|
|
{"@dot", QC_DOT, },
|
|
|
|
|
{"@wedge", QC_WEDGE, },
|
|
|
|
|
{"@regressive", QC_REGRESSIVE, },
|
|
|
|
|
{"@geometric", QC_GEOMETRIC, },
|
|
|
|
|
{"@algebra", QC_ALGEBRA, },
|
2012-12-22 07:31:14 +00:00
|
|
|
|
};
|
|
|
|
|
|
2022-02-02 14:51:37 +00:00
|
|
|
|
// These keywors are always available. Other than the @ keywords, they
|
2012-12-22 07:31:14 +00:00
|
|
|
|
// form traditional QuakeC.
|
2001-06-13 07:16:39 +00:00
|
|
|
|
static keyword_t keywords[] = {
|
2023-10-24 10:50:31 +00:00
|
|
|
|
{"void", QC_TYPE_SPEC, .spec = { .type = &type_void } },
|
|
|
|
|
{"float", QC_TYPE_SPEC, .spec = { .type = &type_float } },
|
|
|
|
|
{"string", QC_TYPE_SPEC, .spec = { .type = &type_string } },
|
|
|
|
|
{"vector", QC_TYPE_SPEC, .spec = { .type = &type_vector } },
|
|
|
|
|
{"entity", QC_TYPE_SPEC, .spec = { .type = &type_entity } },
|
|
|
|
|
{"local", QC_LOCAL, },
|
|
|
|
|
{"return", QC_RETURN, },
|
|
|
|
|
{"while", QC_WHILE, },
|
|
|
|
|
{"do", QC_DO, },
|
|
|
|
|
{"if", QC_IF, },
|
|
|
|
|
{"else", QC_ELSE, },
|
|
|
|
|
{"@system", QC_SYSTEM, },
|
|
|
|
|
{"@overload", QC_OVERLOAD, },
|
|
|
|
|
{"@attribute", QC_ATTRIBUTE, },
|
|
|
|
|
{"@handle", QC_HANDLE, },
|
2001-06-13 07:16:39 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const char *
|
2012-07-18 13:34:37 +00:00
|
|
|
|
keyword_get_key (const void *kw, void *unused)
|
2001-06-13 07:16:39 +00:00
|
|
|
|
{
|
|
|
|
|
return ((keyword_t*)kw)->name;
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-22 07:31:14 +00:00
|
|
|
|
static int
|
2023-10-10 17:34:39 +00:00
|
|
|
|
process_keyword (YYSTYPE *lval, keyword_t *keyword, const char *token)
|
2012-12-22 07:31:14 +00:00
|
|
|
|
{
|
2023-10-23 13:00:14 +00:00
|
|
|
|
if (lval->text == lval->str_text) {
|
|
|
|
|
lval->text = save_string (lval->str_text);
|
|
|
|
|
}
|
2023-10-24 10:50:31 +00:00
|
|
|
|
if (keyword->value == QC_STRUCT) {
|
2023-10-20 11:31:15 +00:00
|
|
|
|
lval->value.op = token[0];
|
2023-10-24 10:50:31 +00:00
|
|
|
|
} else if (keyword->value == QC_OBJECT_NAME) {
|
2012-12-22 07:31:14 +00:00
|
|
|
|
symbol_t *sym;
|
|
|
|
|
|
|
|
|
|
sym = symtab_lookup (current_symtab, token);
|
2023-10-20 11:31:15 +00:00
|
|
|
|
lval->value.symbol = sym;
|
2022-01-19 12:32:01 +00:00
|
|
|
|
// the global id symbol is always just a name so attempts to redefine
|
|
|
|
|
// it globally can be caught and treated as an error, but it needs to
|
|
|
|
|
// be redefinable when in an enclosing scope.
|
|
|
|
|
if (sym->sy_type == sy_name) {
|
|
|
|
|
// this is the global id (object)
|
2023-10-20 11:31:15 +00:00
|
|
|
|
lval->value.spec = (specifier_t) {
|
2023-02-08 02:18:42 +00:00
|
|
|
|
.type = sym->type,
|
|
|
|
|
.sym = sym,
|
|
|
|
|
};
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_OBJECT_NAME;
|
2022-01-19 12:32:01 +00:00
|
|
|
|
} else if (sym->sy_type == sy_type) {
|
|
|
|
|
// id has been redeclared via a typedef
|
2023-10-20 11:31:15 +00:00
|
|
|
|
lval->value.spec = (specifier_t) {
|
2023-02-04 09:26:54 +00:00
|
|
|
|
.type = sym->type,
|
|
|
|
|
.sym = sym,
|
|
|
|
|
};
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_TYPE_NAME;
|
2022-01-19 12:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
// id has been redelcared as a variable (hopefully)
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_NAME;
|
2012-12-22 07:31:14 +00:00
|
|
|
|
} else {
|
2023-10-20 11:31:15 +00:00
|
|
|
|
lval->value.spec = keyword->spec;
|
2012-12-22 07:31:14 +00:00
|
|
|
|
}
|
|
|
|
|
return keyword->value;
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-06 07:30:25 +00:00
|
|
|
|
static int
|
2023-10-10 17:34:39 +00:00
|
|
|
|
keyword_or_id (YYSTYPE *lval, const char *token)
|
2001-06-13 07:16:39 +00:00
|
|
|
|
{
|
|
|
|
|
static hashtab_t *keyword_tab;
|
2012-12-22 07:31:14 +00:00
|
|
|
|
static hashtab_t *qf_keyword_tab;
|
|
|
|
|
static hashtab_t *at_keyword_tab;
|
|
|
|
|
static hashtab_t *obj_keyword_tab;
|
2022-02-03 15:25:31 +00:00
|
|
|
|
static hashtab_t *rua_keyword_tab;
|
2012-12-22 07:31:14 +00:00
|
|
|
|
|
|
|
|
|
keyword_t *keyword = 0;
|
2011-01-17 13:33:33 +00:00
|
|
|
|
symbol_t *sym;
|
2001-06-13 07:16:39 +00:00
|
|
|
|
|
2001-12-08 08:19:48 +00:00
|
|
|
|
if (!keyword_tab) {
|
2007-04-06 05:52:20 +00:00
|
|
|
|
size_t i;
|
2012-12-22 07:31:14 +00:00
|
|
|
|
|
2020-03-25 06:43:16 +00:00
|
|
|
|
keyword_tab = Hash_NewTable (253, keyword_get_key, 0, 0, 0);
|
|
|
|
|
qf_keyword_tab = Hash_NewTable (253, keyword_get_key, 0, 0, 0);
|
|
|
|
|
at_keyword_tab = Hash_NewTable (253, keyword_get_key, 0, 0, 0);
|
|
|
|
|
obj_keyword_tab = Hash_NewTable (253, keyword_get_key, 0, 0, 0);
|
2022-02-03 15:25:31 +00:00
|
|
|
|
rua_keyword_tab = Hash_NewTable (253, keyword_get_key, 0, 0, 0);
|
2012-12-22 07:31:14 +00:00
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
for (i = 0; i < ARRCOUNT(keywords); i++)
|
2012-12-22 07:31:14 +00:00
|
|
|
|
Hash_Add (keyword_tab, &keywords[i]);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
for (i = 0; i < ARRCOUNT(qf_keywords); i++)
|
2012-12-22 07:31:14 +00:00
|
|
|
|
Hash_Add (qf_keyword_tab, &qf_keywords[i]);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
for (i = 0; i < ARRCOUNT(at_keywords); i++)
|
2012-12-22 07:31:14 +00:00
|
|
|
|
Hash_Add (at_keyword_tab, &at_keywords[i]);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
for (i = 0; i < ARRCOUNT(obj_keywords); i++)
|
2012-12-22 07:31:14 +00:00
|
|
|
|
Hash_Add (obj_keyword_tab, &obj_keywords[i]);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
for (i = 0; i < ARRCOUNT(rua_keywords); i++)
|
2022-02-03 15:25:31 +00:00
|
|
|
|
Hash_Add (rua_keyword_tab, &rua_keywords[i]);
|
2001-06-13 07:16:39 +00:00
|
|
|
|
}
|
2012-12-22 07:31:14 +00:00
|
|
|
|
if (options.traditional < 1) {
|
2022-02-03 15:25:31 +00:00
|
|
|
|
if (options.code.progsversion == PROG_VERSION) {
|
|
|
|
|
keyword = Hash_Find (rua_keyword_tab, token);
|
|
|
|
|
}
|
|
|
|
|
if (!keyword) {
|
|
|
|
|
keyword = Hash_Find (obj_keyword_tab, token);
|
|
|
|
|
if (keyword) {
|
|
|
|
|
if (!obj_initialized)
|
|
|
|
|
class_init ();
|
|
|
|
|
}
|
2011-01-17 13:33:33 +00:00
|
|
|
|
}
|
2012-12-22 07:31:14 +00:00
|
|
|
|
if (!keyword)
|
|
|
|
|
keyword = Hash_Find (qf_keyword_tab, token);
|
|
|
|
|
}
|
|
|
|
|
if (!keyword && options.traditional < 2)
|
|
|
|
|
keyword = Hash_Find (at_keyword_tab, token);
|
|
|
|
|
if (!keyword && token[0] == '@') {
|
|
|
|
|
keyword = Hash_Find (at_keyword_tab, token + 1);
|
|
|
|
|
if (keyword)
|
|
|
|
|
token += 1;
|
2001-06-13 07:16:39 +00:00
|
|
|
|
}
|
2012-12-22 07:31:14 +00:00
|
|
|
|
if (!keyword)
|
|
|
|
|
keyword = Hash_Find (keyword_tab, token);
|
|
|
|
|
if (keyword && keyword->value)
|
2023-10-10 17:34:39 +00:00
|
|
|
|
return process_keyword (lval, keyword, token);
|
2002-05-07 16:55:54 +00:00
|
|
|
|
if (token[0] == '@') {
|
|
|
|
|
return '@';
|
|
|
|
|
}
|
2011-01-17 13:33:33 +00:00
|
|
|
|
sym = symtab_lookup (current_symtab, token);
|
|
|
|
|
if (!sym)
|
|
|
|
|
sym = new_symbol (token);
|
2023-10-20 11:31:15 +00:00
|
|
|
|
lval->value.symbol = sym;
|
2023-02-04 09:26:54 +00:00
|
|
|
|
if (sym->sy_type == sy_type) {
|
2023-10-20 11:31:15 +00:00
|
|
|
|
lval->value.spec = (specifier_t) {
|
2023-02-04 09:26:54 +00:00
|
|
|
|
.type = sym->type,
|
|
|
|
|
.sym = sym,
|
|
|
|
|
};
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_TYPE_NAME;
|
2023-02-04 09:26:54 +00:00
|
|
|
|
}
|
2011-02-13 07:05:09 +00:00
|
|
|
|
if (sym->sy_type == sy_class)
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_CLASS_NAME;
|
|
|
|
|
return QC_NAME;
|
2001-06-13 07:16:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-10-20 12:15:17 +00:00
|
|
|
|
enum {
|
|
|
|
|
suff_error = -1,
|
|
|
|
|
suff_implicit,
|
|
|
|
|
suff_unsigned,
|
|
|
|
|
suff_long,
|
|
|
|
|
suff_unsigned_long,
|
|
|
|
|
suff_float,
|
|
|
|
|
suff_double,
|
|
|
|
|
suff_long_double,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
parse_suffix (const char *suffix, bool fp)
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
{
|
2023-10-20 12:15:17 +00:00
|
|
|
|
int expl = suff_implicit;
|
|
|
|
|
bool unsign = false;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
|
2023-10-20 12:15:17 +00:00
|
|
|
|
if (!*suffix) {
|
|
|
|
|
return 0;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
if (fp) {
|
|
|
|
|
if (*suffix == 'f' || *suffix == 'F') {
|
|
|
|
|
expl = suff_float;
|
|
|
|
|
suffix++;
|
|
|
|
|
} else if (*suffix == 'd' || *suffix == 'D') {
|
|
|
|
|
// treat as explicit double unless it's a proper C decimal
|
|
|
|
|
// suffix, in which case the decimal part will be ignored
|
2023-10-28 14:51:12 +00:00
|
|
|
|
// (non-standard, but no decimal support)
|
2023-10-20 12:15:17 +00:00
|
|
|
|
expl = suff_double;
|
|
|
|
|
suffix++;
|
|
|
|
|
if (*suffix == 'f' || *suffix == 'F'
|
|
|
|
|
|| *suffix == 'd' || *suffix == 'D'
|
|
|
|
|
|| *suffix == 'l' || *suffix == 'L') {
|
|
|
|
|
warning (0, "decimal fp treated as binary fp");
|
|
|
|
|
expl = suff_double;
|
|
|
|
|
suffix++;
|
|
|
|
|
}
|
|
|
|
|
} else if (*suffix == 'l' || *suffix == 'L') {
|
|
|
|
|
expl = suff_long_double;
|
|
|
|
|
suffix++;
|
2022-11-12 11:04:19 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
} else {
|
|
|
|
|
if (*suffix == 'f' || *suffix == 'F') {
|
|
|
|
|
expl = suff_float;
|
|
|
|
|
suffix++;
|
|
|
|
|
} else if (*suffix == 'd' || *suffix == 'D') {
|
|
|
|
|
expl = suff_double;
|
|
|
|
|
suffix++;
|
|
|
|
|
} else {
|
|
|
|
|
if (*suffix == 'u' || *suffix == 'U') {
|
|
|
|
|
unsign = true;
|
|
|
|
|
expl = suff_unsigned;
|
|
|
|
|
suffix++;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
if (*suffix == 'l' || *suffix == 'L') {
|
|
|
|
|
expl = unsign ? suff_unsigned_long : suff_long;
|
|
|
|
|
suffix++;
|
|
|
|
|
if (*suffix == 'l' || *suffix == 'L') {
|
|
|
|
|
suffix++;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
if (!unsign && (*suffix == 'u' || *suffix == 'U')) {
|
|
|
|
|
expl = suff_unsigned_long;
|
|
|
|
|
suffix++;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (*suffix) {
|
|
|
|
|
return suff_error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return expl;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
parse_number (rua_tok_t *tok, yyscan_t scanner)
|
|
|
|
|
{
|
|
|
|
|
bool binary = false;
|
|
|
|
|
const char *type = "integer";
|
|
|
|
|
bool hex = false;
|
|
|
|
|
bool fp = false;
|
|
|
|
|
char buf[tok->textlen + 1], *dst = buf;
|
|
|
|
|
const char *src = tok->text;
|
|
|
|
|
if ((*dst = *src++) == '0') {
|
|
|
|
|
switch ((*++dst = *src++)) {
|
|
|
|
|
case 'b': case 'B':
|
|
|
|
|
binary = true;
|
|
|
|
|
type = "binary";
|
|
|
|
|
break;
|
|
|
|
|
case 'x': case 'X':
|
|
|
|
|
hex = true;
|
|
|
|
|
type = "hexadecimal";
|
|
|
|
|
break;
|
|
|
|
|
case '.':
|
|
|
|
|
fp = true;
|
|
|
|
|
break;
|
|
|
|
|
case '1' ... '9':
|
|
|
|
|
type = "octal"; // unless fp becomes true
|
|
|
|
|
break;
|
|
|
|
|
case '\'': case '_':
|
|
|
|
|
if (*src == 'b' || *src == 'B' || *src == 'x' || *src == 'X') {
|
|
|
|
|
error (0, "digit separator outside digit sequence");
|
|
|
|
|
return -rua_error;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (*dst) {
|
|
|
|
|
dst += (*dst != '\'' && *dst != '_');
|
|
|
|
|
while ((*dst = *src++)) {
|
|
|
|
|
if (hex && (*dst == 'p' || *dst == 'P')) {
|
|
|
|
|
fp = true;
|
|
|
|
|
}
|
|
|
|
|
if (!hex && (*dst == 'e' || *dst == 'E')) {
|
|
|
|
|
fp = true;
|
|
|
|
|
}
|
|
|
|
|
if (*dst == '.') {
|
|
|
|
|
fp = true;
|
|
|
|
|
}
|
|
|
|
|
// strip out digit separators (' is standard C, _ is a rust
|
|
|
|
|
// thing, but it does look a bit nicerer than ', so why not).
|
|
|
|
|
dst += (*dst != '\'' && *dst != '_');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// use long long to avoid bit-size issues on windows
|
|
|
|
|
long long lvalue = 0;
|
|
|
|
|
double fvalue = 0;
|
|
|
|
|
char *endptr = 0;
|
|
|
|
|
if (binary) {
|
|
|
|
|
// to get here, 0b (or 0B) was seen, so buf is guaranted to start with
|
|
|
|
|
// that
|
|
|
|
|
lvalue = strtoll (buf + 2, &endptr, 2);
|
|
|
|
|
} else {
|
|
|
|
|
if (fp) {
|
|
|
|
|
fvalue = strtod (buf, &endptr);
|
|
|
|
|
} else {
|
|
|
|
|
lvalue = strtoll (buf, &endptr, 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int expl = parse_suffix (endptr, fp);
|
|
|
|
|
if (expl < 0) {
|
|
|
|
|
error (0, "invalid suffix \"%s\" on %s constant", endptr,
|
|
|
|
|
fp ? "floating" : type);
|
|
|
|
|
return -rua_error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fp) {
|
|
|
|
|
if (expl == suff_float) {
|
|
|
|
|
tok->value.expr = new_float_expr (fvalue);
|
|
|
|
|
} else {
|
|
|
|
|
if (expl == suff_long_double) {
|
|
|
|
|
warning (0, "long double treated as double");
|
|
|
|
|
expl = suff_double;
|
|
|
|
|
}
|
|
|
|
|
tok->value.expr = new_double_expr (fvalue, expl == suff_implicit);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (expl == suff_unsigned) {
|
|
|
|
|
tok->value.expr = new_uint_expr (lvalue);
|
|
|
|
|
} else if (expl == suff_long || expl == suff_implicit) {
|
|
|
|
|
tok->value.expr = new_long_expr (lvalue, expl == suff_implicit);
|
|
|
|
|
} else if (expl == suff_unsigned_long) {
|
|
|
|
|
tok->value.expr = new_ulong_expr (lvalue);
|
|
|
|
|
} else if (expl == suff_float) {
|
|
|
|
|
tok->value.expr = new_float_expr (lvalue);
|
|
|
|
|
} else if (expl == suff_double) {
|
|
|
|
|
tok->value.expr = new_double_expr (lvalue, false);
|
|
|
|
|
} else {
|
|
|
|
|
internal_error (0, "invalid suffix enum: %d", expl);
|
|
|
|
|
}
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_VALUE;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-10-20 12:15:17 +00:00
|
|
|
|
typedef struct {
|
|
|
|
|
yyscan_t scanner;
|
|
|
|
|
yybuffer buffer;
|
|
|
|
|
} buffer_raii_t;
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
qc_restore_buffer (buffer_raii_t *raii)
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
{
|
2023-10-20 12:15:17 +00:00
|
|
|
|
yy_switch_to_buffer (raii->buffer, raii->scanner);
|
|
|
|
|
}
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
|
2023-10-20 12:15:17 +00:00
|
|
|
|
static void
|
|
|
|
|
qc_delete_buffer (buffer_raii_t *raii)
|
|
|
|
|
{
|
|
|
|
|
yy_delete_buffer (raii->buffer, raii->scanner);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
parse_vector (rua_tok_t *tok, yyscan_t scanner)
|
|
|
|
|
{
|
|
|
|
|
const char *end = tok->text + tok->textlen;
|
|
|
|
|
while (end > tok->text && *--end != '\'') continue;
|
|
|
|
|
|
|
|
|
|
const char *start = tok->text + 1;
|
|
|
|
|
auto yyg = (struct yyguts_t *)scanner;
|
|
|
|
|
auto __attribute__((cleanup (qc_restore_buffer)))
|
|
|
|
|
saved_buffer = (buffer_raii_t) {
|
|
|
|
|
.scanner = scanner,
|
|
|
|
|
.buffer = YY_CURRENT_BUFFER,
|
|
|
|
|
};
|
|
|
|
|
auto __attribute__((cleanup (qc_delete_buffer)))
|
|
|
|
|
buffer = (buffer_raii_t) {
|
|
|
|
|
.scanner = scanner,
|
|
|
|
|
.buffer = yy_scan_bytes (start, end - start, scanner),
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int token;
|
|
|
|
|
rua_tok_t vtok = { .location = tok->location, };
|
|
|
|
|
vtok.location.first_column++;
|
|
|
|
|
const expr_t *components[4+1] = {}; // currently, max of 4
|
|
|
|
|
bool negate[4] = {};
|
|
|
|
|
int width = 0;
|
|
|
|
|
|
2023-10-21 01:12:41 +00:00
|
|
|
|
yy_push_state (VECTOR, scanner);
|
2023-10-20 12:15:17 +00:00
|
|
|
|
do {
|
|
|
|
|
token = yylex (&vtok, &vtok.location, scanner);
|
|
|
|
|
if (-token == rua_number) {
|
|
|
|
|
token = parse_number (&vtok, scanner);
|
|
|
|
|
}
|
2023-10-24 10:50:31 +00:00
|
|
|
|
if (token == QC_VALUE) {
|
2023-10-20 12:15:17 +00:00
|
|
|
|
if (width < 4) {
|
|
|
|
|
components[width] = vtok.value.expr;
|
|
|
|
|
}
|
|
|
|
|
width++;
|
|
|
|
|
} else if (token == '-') {
|
|
|
|
|
if (width < 4) {
|
|
|
|
|
negate[width] = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} while (token && token != -rua_eof);
|
2023-10-21 01:12:41 +00:00
|
|
|
|
yy_pop_state (scanner);
|
2023-10-20 12:15:17 +00:00
|
|
|
|
|
|
|
|
|
if (width > 4) {
|
|
|
|
|
error (0, "too many components in vector literal");
|
|
|
|
|
width = 4;
|
|
|
|
|
return -rua_error;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
bool fp = false;
|
|
|
|
|
for (int i = 0; i < width; i++) {
|
|
|
|
|
if (!components[i]->implicit) {
|
|
|
|
|
error (0, "explict numeric constant in vector literal."
|
|
|
|
|
" Suggest suffix after closing '.");
|
|
|
|
|
return -rua_error;
|
2022-11-12 11:04:19 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
fp |= is_double (get_type (components[i]));
|
2022-11-12 11:04:19 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
|
|
|
|
|
// end points at the final ' and thus any suffix is after that
|
|
|
|
|
int expl = parse_suffix (++end, fp);
|
|
|
|
|
if (expl < 0) {
|
|
|
|
|
error (0, "invalid suffix \"%s\" on %s vector constant", end,
|
|
|
|
|
fp ? "floating" : "integer");
|
|
|
|
|
return -rua_error;
|
|
|
|
|
}
|
|
|
|
|
union {
|
|
|
|
|
pr_float_t f[4];
|
|
|
|
|
pr_int_t i[4];
|
|
|
|
|
pr_double_t d[4];
|
|
|
|
|
pr_long_t l[4];
|
|
|
|
|
pr_type_t t[PR_SIZEOF (lvec4)];
|
|
|
|
|
} data;
|
|
|
|
|
type_t *type = 0;
|
|
|
|
|
if (expl == suff_long_double) {
|
|
|
|
|
warning (0, "long double treated as double");
|
|
|
|
|
expl = suff_double;
|
|
|
|
|
}
|
|
|
|
|
if (expl == suff_float) {
|
|
|
|
|
for (int i = 0; i < width; i++) {
|
|
|
|
|
auto c = components[i];
|
|
|
|
|
if (is_double (get_type (c))) {
|
|
|
|
|
data.f[i] = expr_double (c);
|
|
|
|
|
} else {
|
|
|
|
|
data.f[i] = expr_long (c);
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
if (negate[i]) {
|
|
|
|
|
data.f[i] = -data.f[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
type = &type_float;
|
2023-10-20 12:15:17 +00:00
|
|
|
|
} else if (expl == suff_double) {
|
|
|
|
|
for (int i = 0; i < width; i++) {
|
|
|
|
|
auto c = components[i];
|
|
|
|
|
if (is_double (get_type (c))) {
|
|
|
|
|
data.d[i] = expr_double (c);
|
|
|
|
|
} else {
|
|
|
|
|
data.d[i] = expr_long (c);
|
|
|
|
|
}
|
|
|
|
|
if (negate[i]) {
|
|
|
|
|
data.d[i] = -data.d[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
type = &type_double;
|
2023-10-20 12:15:17 +00:00
|
|
|
|
} else if (expl == suff_implicit) {
|
|
|
|
|
if (fp) {
|
|
|
|
|
for (int i = 0; i < width; i++) {
|
|
|
|
|
auto c = components[i];
|
|
|
|
|
if (is_double (get_type (c))) {
|
|
|
|
|
data.f[i] = expr_double (c);
|
|
|
|
|
} else {
|
|
|
|
|
data.f[i] = expr_long (c);
|
|
|
|
|
}
|
|
|
|
|
if (negate[i]) {
|
|
|
|
|
data.f[i] = -data.f[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
type = &type_float;
|
|
|
|
|
} else {
|
|
|
|
|
for (int i = 0; i < width; i++) {
|
|
|
|
|
auto c = components[i];
|
|
|
|
|
data.i[i] = expr_long (c);
|
|
|
|
|
if (negate[i]) {
|
|
|
|
|
data.i[i] = -data.i[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
type = &type_int;
|
|
|
|
|
}
|
|
|
|
|
} else if (expl == suff_unsigned) {
|
|
|
|
|
for (int i = 0; i < width; i++) {
|
|
|
|
|
auto c = components[i];
|
|
|
|
|
data.i[i] = fp ? expr_double (c) : expr_long (c);
|
|
|
|
|
if (negate[i]) {
|
|
|
|
|
data.i[i] = -data.i[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
type = &type_uint;
|
|
|
|
|
} else if (expl == suff_long || expl == suff_unsigned_long) {
|
|
|
|
|
for (int i = 0; i < width; i++) {
|
|
|
|
|
auto c = components[i];
|
|
|
|
|
data.l[i] = expr_long (c);
|
|
|
|
|
if (negate[i]) {
|
|
|
|
|
data.l[i] = -data.l[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
type = expl == suff_unsigned_long ? &type_ulong : &type_long;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
|
|
|
|
type = vector_type (type, width);
|
2023-10-20 12:15:17 +00:00
|
|
|
|
tok->value.expr = new_value_expr (new_type_value (type, data.t),
|
|
|
|
|
expl == suff_implicit);
|
|
|
|
|
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_VALUE;
|
[qfcc] Extend vector literal processing
With this, all vector widths and types are supported: 2, 3, 4 and int,
uint, long, ulong, float and double, along with support for suffixes to
make the type explicit: '1 2'd specifies a dvec2 constant, while '1 2 3'u
is a uivec3 constant. Default types are double (dvec2, dvec3, dvec4) for
literals with float-type components, and int (ivec2...) for those with
integer-type components.
2022-04-29 02:49:45 +00:00
|
|
|
|
}
|
2023-10-10 17:34:39 +00:00
|
|
|
|
|
2023-10-20 16:13:32 +00:00
|
|
|
|
static int
|
|
|
|
|
parse_string (rua_tok_t *tok, int type, yyscan_t scanner)
|
|
|
|
|
{
|
|
|
|
|
const char *str = make_string (tok->text, 0);
|
|
|
|
|
if (type == rua_char) {
|
|
|
|
|
if (str[1]) {
|
|
|
|
|
warning (0, "multibyte char constant");
|
|
|
|
|
}
|
|
|
|
|
tok->value.expr = new_int_expr (*str, false);
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_VALUE;
|
2023-10-20 16:13:32 +00:00
|
|
|
|
} else {
|
|
|
|
|
tok->value.expr = new_string_expr (str);
|
2023-10-24 10:50:31 +00:00
|
|
|
|
return QC_STRING;
|
2023-10-20 16:13:32 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-20 11:31:15 +00:00
|
|
|
|
static void
|
2023-10-24 13:06:01 +00:00
|
|
|
|
next_line (rua_loc_t *loc, yyscan_t scanner)
|
2023-10-20 11:31:15 +00:00
|
|
|
|
{
|
2023-10-24 13:06:01 +00:00
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-10-20 11:31:15 +00:00
|
|
|
|
loc->first_line = loc->last_line;
|
|
|
|
|
loc->first_column = loc->last_column;
|
2023-10-21 02:35:58 +00:00
|
|
|
|
loc->last_column = 1;
|
|
|
|
|
loc->last_line++;
|
|
|
|
|
pr.source_line++;
|
2023-10-30 23:42:28 +00:00
|
|
|
|
if (!extra->recording && options.preprocess_output) {
|
2023-10-26 11:31:54 +00:00
|
|
|
|
puts ("");
|
|
|
|
|
}
|
2023-10-21 02:35:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2023-10-26 11:31:54 +00:00
|
|
|
|
update_loc (rua_loc_t *loc, size_t textlen)
|
|
|
|
|
{
|
|
|
|
|
loc->first_line = loc->last_line;
|
|
|
|
|
loc->first_column = loc->last_column;
|
|
|
|
|
// \n handling rules will take care of the column and line
|
|
|
|
|
loc->last_column += textlen;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
save_text (rua_tok_t *tok, const char *text, size_t textlen, int state)
|
2023-10-21 02:35:58 +00:00
|
|
|
|
{
|
2023-10-26 11:31:54 +00:00
|
|
|
|
/*if (state == TEXT) {
|
2023-10-24 13:18:23 +00:00
|
|
|
|
while (isspace (*text)) {
|
|
|
|
|
text++;
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-10-23 13:00:14 +00:00
|
|
|
|
if (state == COMMENT || state == LCOMMENT || isspace (*text)) {
|
|
|
|
|
tok->str_text[0] = ' ';
|
|
|
|
|
tok->str_text[1] = 0;
|
|
|
|
|
tok->text = tok->str_text;
|
|
|
|
|
textlen = 1;
|
2023-10-26 11:31:54 +00:00
|
|
|
|
} else */if (textlen < sizeof (tok->text)) {
|
2023-10-23 13:00:14 +00:00
|
|
|
|
strncpy (tok->str_text, text, textlen);
|
|
|
|
|
tok->str_text[textlen] = 0;
|
|
|
|
|
tok->text = tok->str_text;
|
|
|
|
|
} else {
|
|
|
|
|
tok->text = save_string (text);
|
2023-10-20 11:31:15 +00:00
|
|
|
|
}
|
2023-10-23 13:00:14 +00:00
|
|
|
|
tok->textlen = textlen;
|
2023-10-20 11:31:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-10-24 13:06:01 +00:00
|
|
|
|
static rua_expr_t
|
|
|
|
|
token_expr (int token, const rua_tok_t *tok)
|
|
|
|
|
{
|
|
|
|
|
return (rua_expr_t) {
|
|
|
|
|
.location = tok->location,
|
|
|
|
|
.textlen = tok->textlen,
|
|
|
|
|
.token = token,
|
|
|
|
|
.text = save_string (tok->text),
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-04 12:08:40 +00:00
|
|
|
|
static rua_tok_t
|
|
|
|
|
expr_token (const rua_expr_t *e)
|
|
|
|
|
{
|
|
|
|
|
return (rua_tok_t) {
|
|
|
|
|
.location = e->location,
|
|
|
|
|
.textlen = e->textlen,
|
|
|
|
|
.text = e->text, // macro token strings use save_string
|
|
|
|
|
.token = e->token,
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-03 04:54:08 +00:00
|
|
|
|
static bool
|
|
|
|
|
join_tokens (rua_expr_t *out, const rua_expr_t *p1, const rua_expr_t *p2,
|
|
|
|
|
rua_extra_t *extra)
|
2023-10-24 06:58:37 +00:00
|
|
|
|
{
|
2023-11-06 02:28:17 +00:00
|
|
|
|
auto str = va (0, "%s%s", p1 ? p1->text : "", p2 ? p2->text : "");
|
2023-11-03 04:54:08 +00:00
|
|
|
|
yy_scan_string (str, extra->subscanner);
|
2023-11-06 02:28:17 +00:00
|
|
|
|
rua_tok_t tok = {};
|
|
|
|
|
if (p1) {
|
|
|
|
|
tok.location = p1->location;
|
|
|
|
|
}
|
2023-11-03 04:54:08 +00:00
|
|
|
|
int token = yylex (&tok, &tok.location, extra->subscanner);
|
|
|
|
|
if (token && yylex (&tok, &tok.location, extra->subscanner)) {
|
|
|
|
|
error (0, "pasting \"%s\" and \"%s\" does not give a valid"
|
|
|
|
|
" preprocessing token", p1->text, p2->text);
|
2023-11-06 02:28:17 +00:00
|
|
|
|
out->token = -rua_space;
|
|
|
|
|
out->text = " ";
|
2023-11-03 04:54:08 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
*out = token_expr (token, &tok);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2023-10-24 06:58:37 +00:00
|
|
|
|
|
2023-11-03 04:54:08 +00:00
|
|
|
|
static bool
|
|
|
|
|
stringize_arg (rua_expr_t *out, rua_macro_t *arg, rua_extra_t *extra)
|
|
|
|
|
{
|
|
|
|
|
dstring_copystr (extra->dstr, "\"");
|
|
|
|
|
for (auto e = arg->tokens; e; e = e->next) {
|
|
|
|
|
auto str = quote_string (e->text);
|
|
|
|
|
dstring_appendstr (extra->dstr, str);
|
|
|
|
|
}
|
|
|
|
|
dstring_appendstr (extra->dstr, "\"");
|
|
|
|
|
*out = (rua_expr_t) {
|
|
|
|
|
.textlen = extra->dstr->size - 1,
|
|
|
|
|
.token = -rua_string,
|
|
|
|
|
.text = save_string (extra->dstr->str),
|
|
|
|
|
};
|
|
|
|
|
return true;
|
2023-10-24 06:58:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-10-20 12:15:17 +00:00
|
|
|
|
static int
|
2023-10-24 04:23:06 +00:00
|
|
|
|
preproc_token (rua_extra_t *extra, int token, rua_tok_t *tok, yyscan_t *scanner)
|
|
|
|
|
{
|
2023-10-24 13:06:01 +00:00
|
|
|
|
if (!token) {
|
|
|
|
|
return token;
|
|
|
|
|
}
|
2023-10-24 04:23:06 +00:00
|
|
|
|
if (token < 0) {
|
|
|
|
|
rua_term term = -token;
|
|
|
|
|
switch (term) {
|
|
|
|
|
case rua_ignore:
|
|
|
|
|
case rua_num_term:
|
|
|
|
|
internal_error (0, "unexpected rua token: %d", term);
|
|
|
|
|
case rua_eof:
|
|
|
|
|
case rua_error:
|
2023-10-24 13:06:01 +00:00
|
|
|
|
case rua_id:
|
2023-10-30 04:25:48 +00:00
|
|
|
|
case rua_ellipsis:
|
2023-10-31 01:37:02 +00:00
|
|
|
|
case rua_asx:
|
|
|
|
|
case rua_incop:
|
2023-10-24 04:23:06 +00:00
|
|
|
|
break;
|
|
|
|
|
case rua_number:
|
2023-10-24 12:51:57 +00:00
|
|
|
|
if (!extra->recording) {
|
|
|
|
|
token = parse_number (tok, scanner);
|
|
|
|
|
}
|
2023-10-24 04:23:06 +00:00
|
|
|
|
break;
|
|
|
|
|
case rua_vector:
|
2023-10-31 01:37:02 +00:00
|
|
|
|
if (!extra->recording) {
|
|
|
|
|
token = parse_vector (tok, scanner);
|
|
|
|
|
}
|
2023-10-24 04:23:06 +00:00
|
|
|
|
break;
|
|
|
|
|
case rua_string:
|
|
|
|
|
case rua_char:
|
|
|
|
|
break;
|
|
|
|
|
case rua_space:
|
2023-10-24 05:01:21 +00:00
|
|
|
|
if (!extra->recording || extra->params) {
|
2023-10-24 04:23:06 +00:00
|
|
|
|
token = -rua_ignore;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-10-24 05:01:21 +00:00
|
|
|
|
if (-token != rua_ignore && extra->recording) {
|
2023-10-24 16:09:36 +00:00
|
|
|
|
if (token == PRE_ID) {
|
|
|
|
|
token = -rua_id;
|
|
|
|
|
}
|
2023-10-24 04:23:06 +00:00
|
|
|
|
tok->token = token;
|
2023-10-24 13:06:01 +00:00
|
|
|
|
if (token != PRE_EOD && token != ',' && token != '(' && token != ')') {
|
2023-10-24 04:23:06 +00:00
|
|
|
|
token = PRE_TOKEN;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return token;
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-30 09:52:02 +00:00
|
|
|
|
static const expr_t *
|
|
|
|
|
convert_long (const expr_t *value)
|
|
|
|
|
{
|
|
|
|
|
pr_long_t v = expr_long (value);
|
|
|
|
|
if (is_int (type_default)) {
|
|
|
|
|
if (v < INT32_MIN || v > UINT32_MAX) {
|
|
|
|
|
warning (0, "integer value truncated");
|
|
|
|
|
}
|
|
|
|
|
return new_int_expr (v, true);
|
|
|
|
|
} else {
|
|
|
|
|
float f = v;
|
|
|
|
|
if (f != v) {
|
|
|
|
|
warning (0, "cannot represent value");
|
|
|
|
|
}
|
|
|
|
|
return new_float_expr (f);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-24 04:23:06 +00:00
|
|
|
|
static int
|
|
|
|
|
qc_token (rua_extra_t *extra, int token, rua_tok_t *tok, yyscan_t *scanner)
|
2023-10-20 12:15:17 +00:00
|
|
|
|
{
|
|
|
|
|
auto value = &tok->value;
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
if (token < 0) {
|
|
|
|
|
rua_term term = -token;
|
|
|
|
|
switch (term) {
|
2023-10-24 04:23:06 +00:00
|
|
|
|
case rua_ignore:
|
|
|
|
|
case rua_num_term:
|
|
|
|
|
internal_error (0, "unexpected rua token: %d", term);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
case rua_eof:
|
|
|
|
|
case rua_error:
|
2023-10-24 04:23:06 +00:00
|
|
|
|
break;
|
|
|
|
|
case rua_id:
|
|
|
|
|
token = keyword_or_id (tok, tok->text);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
break;
|
|
|
|
|
case rua_number:
|
|
|
|
|
token = parse_number (tok, scanner);
|
2023-10-24 10:50:31 +00:00
|
|
|
|
if (token == QC_VALUE && value->expr->implicit) {
|
2023-10-22 11:56:12 +00:00
|
|
|
|
if (is_long (get_type (value->expr))) {
|
2023-10-30 09:52:02 +00:00
|
|
|
|
value->expr = convert_long (value->expr);
|
2023-10-20 12:15:17 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2023-10-22 11:56:12 +00:00
|
|
|
|
break;
|
|
|
|
|
case rua_vector:
|
|
|
|
|
token = parse_vector (tok, scanner);
|
|
|
|
|
break;
|
|
|
|
|
case rua_string:
|
|
|
|
|
case rua_char:
|
|
|
|
|
token = parse_string (tok, -token, scanner);
|
|
|
|
|
break;
|
2023-10-23 13:00:14 +00:00
|
|
|
|
case rua_space:
|
2023-10-30 23:42:28 +00:00
|
|
|
|
if (options.preprocess_output) {
|
2023-10-23 13:00:14 +00:00
|
|
|
|
printf (" ");
|
|
|
|
|
}
|
|
|
|
|
break;
|
2023-10-30 04:25:48 +00:00
|
|
|
|
case rua_ellipsis:
|
|
|
|
|
token = QC_ELLIPSIS;
|
|
|
|
|
break;
|
2023-10-31 01:37:02 +00:00
|
|
|
|
case rua_asx:
|
|
|
|
|
token = QC_ASX;
|
|
|
|
|
tok->value.op = tok->text[0];
|
|
|
|
|
switch (tok->text[1]) {
|
|
|
|
|
case '=': break;
|
|
|
|
|
case '%': tok->value.op = QC_MOD; break;
|
|
|
|
|
case '<': tok->value.op = QC_SHL; break;
|
|
|
|
|
case '>': tok->value.op = QC_SHR; break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case rua_incop:
|
|
|
|
|
token = QC_INCOP;
|
|
|
|
|
tok->value.op = tok->text[0];
|
|
|
|
|
break;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
}
|
2023-10-24 04:23:06 +00:00
|
|
|
|
return token;
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-24 13:06:01 +00:00
|
|
|
|
static void
|
2023-11-04 12:08:40 +00:00
|
|
|
|
rua_reset_args (rua_macro_t *macro)
|
2023-10-24 13:06:01 +00:00
|
|
|
|
{
|
2023-11-03 04:54:08 +00:00
|
|
|
|
macro->num_args = 0;
|
|
|
|
|
|
|
|
|
|
int num_params = macro->num_params;
|
|
|
|
|
if (num_params < 0) {
|
|
|
|
|
num_params = -num_params;
|
|
|
|
|
}
|
|
|
|
|
if (!macro->args) {
|
|
|
|
|
macro->args = calloc (num_params, sizeof (rua_macro_t *));
|
|
|
|
|
for (int i = 0; i < num_params; i++) {
|
|
|
|
|
macro->args[i] = malloc (sizeof (rua_macro_t));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
for (int i = 0; i < num_params; i++) {
|
|
|
|
|
auto arg = macro->args[i];
|
|
|
|
|
*arg = (rua_macro_t) {
|
|
|
|
|
.tail = &arg->tokens,
|
|
|
|
|
};
|
|
|
|
|
}
|
2023-11-04 12:08:40 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
rua_start_args (void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
extra->recording = true;
|
|
|
|
|
|
|
|
|
|
rua_reset_args (extra->pending_macro);
|
2023-10-24 13:06:01 +00:00
|
|
|
|
yy_push_state (ARGS, scanner);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
rua_end_args (void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
extra->recording = false;
|
|
|
|
|
yy_pop_state (scanner);
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-04 12:08:40 +00:00
|
|
|
|
static void __attribute__((used))
|
|
|
|
|
dump_macro (rua_macro_t *macro)
|
|
|
|
|
{
|
|
|
|
|
printf ("\n%s: ", macro->name);
|
|
|
|
|
for (auto t = macro->tokens; t; t = t->next) {
|
|
|
|
|
printf ("%s", t->text);
|
|
|
|
|
}
|
|
|
|
|
for (int i = 0; i < macro->num_args; i++) {
|
|
|
|
|
dump_macro (macro->args[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-24 04:23:06 +00:00
|
|
|
|
static int
|
|
|
|
|
qc_process (rua_extra_t *extra, int token, rua_tok_t *tok, yyscan_t scanner)
|
|
|
|
|
{
|
|
|
|
|
auto loc = &tok->location;
|
|
|
|
|
|
2023-10-24 06:58:37 +00:00
|
|
|
|
if (-token == rua_ignore) {
|
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-29 15:41:06 +00:00
|
|
|
|
rua_macro_t *macro = 0;
|
|
|
|
|
if (extra->pending_macro) {
|
|
|
|
|
if (extra->recording) {
|
|
|
|
|
token = preproc_token (extra, token, tok, scanner);
|
|
|
|
|
int status = pre_yypush_parse (extra->args_state, token,
|
|
|
|
|
tok, &tok->location, scanner);
|
|
|
|
|
if (status == YYPUSH_MORE) {
|
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
}
|
|
|
|
|
rua_end_args (scanner);
|
2023-11-03 04:54:08 +00:00
|
|
|
|
|
2023-10-29 15:41:06 +00:00
|
|
|
|
macro = extra->pending_macro;
|
|
|
|
|
extra->pending_macro = 0;
|
|
|
|
|
if (status != 0) {
|
|
|
|
|
error (0, "unterminated argument list invoking macro \"%s\"",
|
|
|
|
|
macro->name);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2023-11-03 04:54:08 +00:00
|
|
|
|
|
|
|
|
|
int num_args = macro->num_args;
|
|
|
|
|
if (num_args == 1 && !macro->args[0]->num_tokens) {
|
2023-10-29 15:41:06 +00:00
|
|
|
|
num_args = 0;
|
|
|
|
|
}
|
2023-10-30 04:25:48 +00:00
|
|
|
|
if (macro->num_params >= 0) {
|
|
|
|
|
if (num_args != macro->num_params) {
|
|
|
|
|
error (0, "macro \"%s\" passed %d arguments, but takes"
|
|
|
|
|
" just %d", macro->name, num_args,
|
|
|
|
|
macro->num_params);
|
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (num_args < ~macro->num_params) {
|
|
|
|
|
error (0, "macro \"%s\" requires %d arguments, but only"
|
|
|
|
|
" %d given", macro->name, ~macro->num_params,
|
|
|
|
|
num_args);
|
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
}
|
2023-10-29 15:41:06 +00:00
|
|
|
|
}
|
|
|
|
|
} else if (token == -rua_space) {
|
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
} else if (token == '(') {
|
|
|
|
|
rua_start_args (scanner);
|
|
|
|
|
token = PRE_ARGS;
|
|
|
|
|
int status = pre_yypush_parse (extra->args_state, token,
|
|
|
|
|
tok, &tok->location, scanner);
|
|
|
|
|
if (status != YYPUSH_MORE) {
|
|
|
|
|
internal_error (0, "can't start parsing macro args");
|
|
|
|
|
}
|
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
} else {
|
2023-11-03 04:54:08 +00:00
|
|
|
|
// XXX put id back into stream to be passed to main parser
|
|
|
|
|
// (expansion failed)
|
2023-10-29 15:41:06 +00:00
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
}
|
|
|
|
|
} else if (extra->expand || (!extra->preprocessor && !extra->suppressed)) {
|
2023-10-24 06:58:37 +00:00
|
|
|
|
symbol_t *sym = 0;
|
2023-10-27 08:27:02 +00:00
|
|
|
|
if (token == -rua_id || (extra->preprocessor && token == PRE_ID)) {
|
2023-10-24 06:58:37 +00:00
|
|
|
|
sym = symtab_lookup (extra->macro_tab, tok->text);
|
|
|
|
|
}
|
|
|
|
|
if (sym) {
|
2023-10-29 15:41:06 +00:00
|
|
|
|
if (sym->s.macro->params) {
|
|
|
|
|
extra->pending_macro = sym->s.macro;
|
2023-10-24 13:06:01 +00:00
|
|
|
|
return YYPUSH_MORE;
|
2023-10-29 15:41:06 +00:00
|
|
|
|
} else {
|
|
|
|
|
macro = sym->s.macro;
|
2023-10-24 13:06:01 +00:00
|
|
|
|
}
|
2023-10-24 06:58:37 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2023-10-29 15:41:06 +00:00
|
|
|
|
if (macro) {
|
2023-11-01 07:07:12 +00:00
|
|
|
|
if (macro->update) {
|
|
|
|
|
macro->update (macro, scanner);
|
|
|
|
|
}
|
2023-11-03 04:54:08 +00:00
|
|
|
|
if (macro->tokens) {
|
|
|
|
|
macro->next = extra->macro;
|
|
|
|
|
extra->macro = macro;
|
|
|
|
|
macro->cursor = macro->tokens;
|
|
|
|
|
}
|
2023-10-29 15:41:06 +00:00
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
}
|
2023-10-24 04:23:06 +00:00
|
|
|
|
if (extra->preprocessor) {
|
|
|
|
|
auto state = extra->pre_state;
|
|
|
|
|
token = preproc_token (extra, token, tok, scanner);
|
|
|
|
|
if (-token == rua_ignore) {
|
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
}
|
|
|
|
|
return pre_yypush_parse (state, token, tok, loc, scanner);
|
|
|
|
|
} else {
|
2023-10-28 14:51:12 +00:00
|
|
|
|
if (!extra->suppressed) {
|
2023-10-30 23:42:28 +00:00
|
|
|
|
if (options.preprocess_only) {
|
|
|
|
|
if (options.preprocess_output) {
|
|
|
|
|
printf ("%s", tok->text);
|
|
|
|
|
}
|
2023-10-28 14:51:12 +00:00
|
|
|
|
return token ? YYPUSH_MORE : 0;
|
|
|
|
|
}
|
|
|
|
|
token = qc_token (extra, token, tok, scanner);
|
|
|
|
|
if (token >= 0) {
|
|
|
|
|
auto state = extra->qc_state;
|
|
|
|
|
auto value = &tok->value;
|
|
|
|
|
return qc_yypush_parse (state, token, value, loc, scanner);
|
|
|
|
|
}
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
2023-10-20 12:15:17 +00:00
|
|
|
|
}
|
|
|
|
|
return YYPUSH_MORE;
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-03 04:54:08 +00:00
|
|
|
|
static rua_expr_t
|
|
|
|
|
next_macro_token (rua_extra_t *extra)
|
|
|
|
|
{
|
|
|
|
|
auto e = *extra->macro->cursor;
|
|
|
|
|
if (!(extra->macro->cursor = e.next)) {
|
|
|
|
|
auto macro = extra->macro;
|
|
|
|
|
extra->macro = extra->macro->next;
|
|
|
|
|
macro->next = 0;
|
|
|
|
|
}
|
|
|
|
|
return e;
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-06 02:28:17 +00:00
|
|
|
|
static rua_expr_t *
|
|
|
|
|
get_arg_token (bool last, rua_expr_t *arg, const rua_macro_t *macro)
|
|
|
|
|
{
|
|
|
|
|
symbol_t *sym;
|
|
|
|
|
|
|
|
|
|
if (arg->token == -rua_id && macro->params
|
|
|
|
|
&& (sym = symtab_lookup (macro->params, arg->text))
|
|
|
|
|
&& !macro->args[sym->s.offset]->next) {
|
|
|
|
|
auto a = macro->args[sym->s.offset];
|
|
|
|
|
if (last) {
|
|
|
|
|
if (a->tokens) {
|
|
|
|
|
return (rua_expr_t *) a->tail;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
} else {
|
|
|
|
|
return a->tokens;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return arg;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
copy_token (rua_macro_t *dst, const rua_expr_t *t)
|
|
|
|
|
{
|
|
|
|
|
rua_expr_t *e = malloc (sizeof (*e));
|
|
|
|
|
*e = *t;
|
|
|
|
|
e->next = 0;
|
|
|
|
|
*dst->tail = e;
|
|
|
|
|
dst->tail = &e->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
copy_arg_token (rua_macro_t *dst, bool skip_first, bool skip_last,
|
|
|
|
|
const rua_expr_t *arg, const rua_macro_t *macro)
|
|
|
|
|
{
|
|
|
|
|
symbol_t *sym;
|
|
|
|
|
|
|
|
|
|
if (arg->token == -rua_id && macro->params
|
|
|
|
|
&& (sym = symtab_lookup (macro->params, arg->text))
|
|
|
|
|
&& !macro->args[sym->s.offset]->next) {
|
|
|
|
|
auto a = macro->args[sym->s.offset];
|
|
|
|
|
if (!a->tokens) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
for (auto t = skip_first ? a->tokens->next : a->tokens;
|
|
|
|
|
t; t = t->next) {
|
|
|
|
|
if (skip_last && !t->next) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
copy_token (dst, t);
|
|
|
|
|
}
|
|
|
|
|
} else if (!skip_first && !skip_last) {
|
|
|
|
|
copy_token (dst, arg);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-04 12:08:40 +00:00
|
|
|
|
static int
|
|
|
|
|
next_token (rua_tok_t *tok, yyscan_t scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
int token;
|
|
|
|
|
rescan:
|
|
|
|
|
while (extra->macro && !extra->macro->cursor) {
|
|
|
|
|
auto macro = extra->macro;
|
|
|
|
|
extra->macro = macro->next;
|
|
|
|
|
macro->next = 0;
|
|
|
|
|
}
|
|
|
|
|
if (extra->macro && extra->macro->cursor) {
|
|
|
|
|
symbol_t *sym;
|
|
|
|
|
auto macro = extra->macro;
|
|
|
|
|
auto e = next_macro_token (extra);
|
|
|
|
|
token = e.token;
|
|
|
|
|
if (token == '#') {
|
|
|
|
|
sym = symtab_lookup (macro->params, e.next->text);
|
|
|
|
|
auto arg = macro->args[sym->s.offset];
|
|
|
|
|
stringize_arg (&e, arg, extra);
|
|
|
|
|
next_macro_token (extra); // consume arg
|
2023-11-06 02:28:17 +00:00
|
|
|
|
} else if (e.next && e.next->token == PRE_CONCAT) {
|
|
|
|
|
rua_macro_t *m = malloc (sizeof (*m));
|
|
|
|
|
*m = (rua_macro_t) {
|
|
|
|
|
.tail = &m->tokens,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
bool sf = false;
|
|
|
|
|
bool sl;
|
|
|
|
|
do {
|
|
|
|
|
auto p = get_arg_token (true, &e, macro);
|
|
|
|
|
auto n = get_arg_token (false, e.next->next, macro);
|
|
|
|
|
rua_expr_t cat;
|
|
|
|
|
if (!(sl = join_tokens (&cat, p, n, extra))) {
|
|
|
|
|
cat.location = e.next->location;
|
|
|
|
|
cat.token = -rua_space;
|
|
|
|
|
cat.text = " ";
|
|
|
|
|
}
|
|
|
|
|
copy_arg_token (m, sf, sl, &e, macro);
|
|
|
|
|
copy_token (m, &cat);
|
|
|
|
|
next_macro_token (extra); // consume ##
|
|
|
|
|
e = next_macro_token (extra);
|
|
|
|
|
sf = sl;
|
|
|
|
|
} while (e.next && e.next->token == PRE_CONCAT);
|
|
|
|
|
copy_arg_token (m, sl, false, &e, macro);
|
|
|
|
|
m->cursor = m->tokens;
|
|
|
|
|
m->next = extra->macro;
|
|
|
|
|
extra->macro = m;
|
|
|
|
|
goto rescan;
|
2023-11-04 12:08:40 +00:00
|
|
|
|
} else if (token == -rua_id && macro->params
|
|
|
|
|
&& (sym = symtab_lookup (macro->params, e.text))
|
|
|
|
|
&& !macro->args[sym->s.offset]->next) {
|
|
|
|
|
auto arg = macro->args[sym->s.offset];
|
|
|
|
|
arg->cursor = arg->tokens;
|
|
|
|
|
arg->next = extra->macro;
|
|
|
|
|
extra->macro = arg;
|
|
|
|
|
goto rescan;
|
|
|
|
|
} else if (token == -rua_id && !macro->name /* in arg */
|
|
|
|
|
&& (sym = symtab_lookup (extra->macro_tab, e.text))
|
|
|
|
|
&& !sym->s.macro->next) {
|
|
|
|
|
auto m = sym->s.macro;
|
|
|
|
|
if (m->update) {
|
|
|
|
|
m->update (m, scanner);
|
|
|
|
|
}
|
|
|
|
|
m->cursor = m->tokens;
|
|
|
|
|
if (!m->params) {
|
|
|
|
|
m->next = extra->macro;
|
|
|
|
|
extra->macro = m;
|
|
|
|
|
goto rescan;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
m->next = extra->pending_macro;
|
|
|
|
|
extra->pending_macro = m;
|
|
|
|
|
auto t = macro->cursor;
|
|
|
|
|
for (; t && t->token == -rua_space; t = t->next) continue;
|
|
|
|
|
// to be in an arg, a function-like macro must either have
|
|
|
|
|
// both open and close parans, or none
|
|
|
|
|
if (t && t->token == '(') {
|
|
|
|
|
rua_reset_args (m);
|
|
|
|
|
int paren = 1;
|
|
|
|
|
auto tk = expr_token (t);
|
|
|
|
|
auto a = rua_macro_arg (&tk, scanner);
|
|
|
|
|
for (t = t->next; t; t = t->next) {
|
|
|
|
|
if (t->token == '(') {
|
|
|
|
|
paren++;
|
|
|
|
|
} else if (t->token == ')') {
|
|
|
|
|
if (!(--paren)) {
|
|
|
|
|
t = t->next;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
tk = expr_token (t);
|
|
|
|
|
if (t->token == ',' && paren == 1) {
|
|
|
|
|
a = rua_macro_arg (&tk, scanner);
|
|
|
|
|
} else {
|
|
|
|
|
rua_macro_append (a, &tk, scanner);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
macro->cursor = t;
|
|
|
|
|
extra->pending_macro = m->next;
|
|
|
|
|
m->next = extra->macro;
|
|
|
|
|
extra->macro = m;
|
|
|
|
|
goto rescan;
|
|
|
|
|
}
|
|
|
|
|
*tok = expr_token (&e);
|
|
|
|
|
token = tok->token;
|
|
|
|
|
} else {
|
|
|
|
|
token = yylex (tok, &tok->location, scanner);
|
|
|
|
|
}
|
|
|
|
|
return token;
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-10 17:34:39 +00:00
|
|
|
|
int
|
|
|
|
|
qc_yyparse (FILE *in)
|
|
|
|
|
{
|
2023-10-22 11:56:12 +00:00
|
|
|
|
rua_extra_t extra = {
|
|
|
|
|
.qc_state = qc_yypstate_new (),
|
|
|
|
|
.pre_state = pre_yypstate_new (),
|
2023-10-29 15:41:06 +00:00
|
|
|
|
.args_state = pre_yypstate_new (),
|
2023-10-22 11:56:12 +00:00
|
|
|
|
.cond_stack = DARRAY_STATIC_INIT (8),
|
2023-10-25 12:07:50 +00:00
|
|
|
|
.include_stack = DARRAY_STATIC_INIT (8),
|
2023-10-24 15:20:12 +00:00
|
|
|
|
.dstr = dstring_new (),
|
2023-10-29 09:19:03 +00:00
|
|
|
|
.macro_tab = cpp_macros ? cpp_macros : new_symtab (0, stab_global),
|
2023-10-22 11:56:12 +00:00
|
|
|
|
};
|
2023-11-03 04:54:08 +00:00
|
|
|
|
yyscan_t scanner;
|
2023-10-10 17:34:39 +00:00
|
|
|
|
|
2023-10-20 11:31:15 +00:00
|
|
|
|
yylex_init_extra (&extra, &scanner);
|
2023-10-24 06:58:37 +00:00
|
|
|
|
yylex_init (&extra.subscanner);
|
2023-10-10 17:34:39 +00:00
|
|
|
|
yyset_in (in, scanner);
|
2023-11-03 04:54:08 +00:00
|
|
|
|
|
|
|
|
|
int status;
|
|
|
|
|
rua_tok_t tok = { .location = { 1, 1, 1, 1, pr.source_file }, };
|
2023-10-10 17:34:39 +00:00
|
|
|
|
do {
|
2023-11-04 12:08:40 +00:00
|
|
|
|
int token = next_token (&tok, scanner);
|
2023-10-31 01:48:11 +00:00
|
|
|
|
if (!token && extra.cond_stack.size) {
|
|
|
|
|
int ind = extra.cond_stack.size - 1;
|
|
|
|
|
auto cond = extra.cond_stack.a[ind];
|
|
|
|
|
error (0, "end of file in conditional started on %d", cond.line);
|
|
|
|
|
}
|
2023-10-25 12:07:50 +00:00
|
|
|
|
if (!token && extra.include_stack.size) {
|
2023-10-31 01:48:11 +00:00
|
|
|
|
//printf ("*** pop include %d\n", (int) extra.include_stack.size);
|
|
|
|
|
auto incl = DARRAY_REMOVE (&extra.include_stack);
|
2023-10-25 12:07:50 +00:00
|
|
|
|
struct yyguts_t * yyg = (struct yyguts_t*)scanner;//FIXME
|
|
|
|
|
yy_delete_buffer (YY_CURRENT_BUFFER, scanner);
|
|
|
|
|
set_line_file (-1, 0, 2);
|
2023-10-31 01:48:11 +00:00
|
|
|
|
yy_switch_to_buffer (incl.buffer, scanner);
|
|
|
|
|
DARRAY_CLEAR (&extra.cond_stack);
|
|
|
|
|
extra.cond_stack = incl.cond_stack;
|
2023-10-25 12:07:50 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
2023-11-03 04:54:08 +00:00
|
|
|
|
status = qc_process (&extra, token, &tok, scanner);
|
2023-10-10 17:34:39 +00:00
|
|
|
|
} while (status == YYPUSH_MORE);
|
|
|
|
|
|
2023-10-24 06:58:37 +00:00
|
|
|
|
yylex_destroy (extra.subscanner);
|
2023-10-10 17:34:39 +00:00
|
|
|
|
yylex_destroy (scanner);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
qc_yypstate_delete (extra.qc_state);
|
|
|
|
|
pre_yypstate_delete (extra.pre_state);
|
2023-10-29 15:41:06 +00:00
|
|
|
|
pre_yypstate_delete (extra.args_state);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
free (extra.cond_stack.a);
|
2023-10-25 12:07:50 +00:00
|
|
|
|
free (extra.include_stack.a);
|
2023-10-24 15:20:12 +00:00
|
|
|
|
dstring_delete (extra.dstr);
|
2023-10-10 17:34:39 +00:00
|
|
|
|
return status;
|
|
|
|
|
}
|
2023-10-22 11:56:12 +00:00
|
|
|
|
|
|
|
|
|
rua_macro_t *
|
2023-10-24 05:01:21 +00:00
|
|
|
|
rua_start_macro (const char *name, bool params, void *scanner)
|
2023-10-22 11:56:12 +00:00
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-10-27 08:26:00 +00:00
|
|
|
|
if (extra->suppressed) {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2023-10-28 14:51:12 +00:00
|
|
|
|
extra->recording = true;
|
2023-10-27 08:26:00 +00:00
|
|
|
|
extra->params = params;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
|
2023-10-24 14:32:13 +00:00
|
|
|
|
if (name) {
|
|
|
|
|
int len = strlen (name);
|
|
|
|
|
if (name[len - 1] == '(') {
|
|
|
|
|
name = save_substring (name, len - 1);
|
|
|
|
|
} else {
|
|
|
|
|
name = save_string (name);
|
|
|
|
|
}
|
2023-10-23 09:32:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
yy_pop_state (scanner);
|
|
|
|
|
yy_push_state (MACRO, scanner);
|
2023-10-23 09:32:06 +00:00
|
|
|
|
|
|
|
|
|
rua_macro_t *macro = malloc (sizeof (*macro));
|
|
|
|
|
*macro = (rua_macro_t) {
|
|
|
|
|
.name = name,
|
2023-10-24 15:52:36 +00:00
|
|
|
|
.params = params ? new_symtab (0, stab_param) : 0,
|
2023-10-23 09:32:06 +00:00
|
|
|
|
.tail = ¯o->tokens,
|
|
|
|
|
};
|
|
|
|
|
return macro;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-10-24 05:01:21 +00:00
|
|
|
|
rua_macro_t *
|
|
|
|
|
rua_end_params (rua_macro_t *macro, void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-10-27 08:26:00 +00:00
|
|
|
|
if (extra->suppressed) {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2023-10-24 05:01:21 +00:00
|
|
|
|
extra->params = false;
|
2023-10-24 15:20:12 +00:00
|
|
|
|
//macro->params->parent = extra->macro_tab;
|
2023-10-24 05:01:21 +00:00
|
|
|
|
return macro;
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
rua_macro_t *
|
|
|
|
|
rua_macro_append (rua_macro_t *macro, rua_tok_t *token, void *scanner)
|
|
|
|
|
{
|
2023-10-27 08:26:00 +00:00
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-11-03 04:54:08 +00:00
|
|
|
|
if (extra->suppressed || !macro) {
|
2023-10-27 08:26:00 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
2023-10-24 05:01:21 +00:00
|
|
|
|
if (token->token == -rua_space) {
|
|
|
|
|
if (!macro->tokens) {
|
|
|
|
|
// ignore leading space
|
|
|
|
|
return macro;
|
|
|
|
|
}
|
|
|
|
|
auto t = (rua_expr_t *) macro->tail;
|
|
|
|
|
if (t->token == '#' || t->token == PRE_CONCAT) {
|
|
|
|
|
// ignore space after '#' and '##'
|
|
|
|
|
return macro;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
rua_expr_t *expr = (rua_expr_t *) macro->tail;
|
|
|
|
|
if (token->token != PRE_CONCAT
|
|
|
|
|
|| !macro->tokens
|
|
|
|
|
|| expr->token != -rua_space) {
|
|
|
|
|
expr = malloc (sizeof (*expr));
|
2023-10-24 06:58:37 +00:00
|
|
|
|
macro->num_tokens++;
|
2023-10-24 05:01:21 +00:00
|
|
|
|
}
|
2023-10-24 13:06:01 +00:00
|
|
|
|
*expr = token_expr (token->token, token);
|
2023-10-23 09:32:06 +00:00
|
|
|
|
*macro->tail = expr;
|
|
|
|
|
macro->tail = &expr->next;
|
|
|
|
|
return macro;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
rua_macro_t *
|
|
|
|
|
rua_macro_param (rua_macro_t *macro, rua_tok_t *token, void *scanner)
|
|
|
|
|
{
|
2023-10-27 08:26:00 +00:00
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
if (extra->suppressed) {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2023-10-24 05:01:21 +00:00
|
|
|
|
if (token->token == -rua_space) {
|
|
|
|
|
// ignore spaces
|
|
|
|
|
return macro;
|
|
|
|
|
}
|
2023-10-30 04:25:48 +00:00
|
|
|
|
if (token->token != -rua_id && token->token != -rua_ellipsis) {
|
2023-10-23 09:32:06 +00:00
|
|
|
|
error (0, "expected parameter name, found \"%s\"", token->text);
|
|
|
|
|
return macro;
|
|
|
|
|
}
|
2023-10-30 04:25:48 +00:00
|
|
|
|
if (macro->num_params < 0) {
|
|
|
|
|
error (0, "... must be the last parameter");
|
|
|
|
|
return macro;
|
|
|
|
|
} else if (symtab_lookup (macro->params, token->text)) {
|
2023-10-23 09:32:06 +00:00
|
|
|
|
error (0, "duplicate macro parameter \"%s\"", token->text);
|
|
|
|
|
return macro;
|
|
|
|
|
}
|
|
|
|
|
auto sym = new_symbol (token->text);
|
2023-10-24 14:32:13 +00:00
|
|
|
|
sym->sy_type = sy_var;
|
|
|
|
|
sym->s.offset = macro->num_params++;
|
2023-10-23 09:32:06 +00:00
|
|
|
|
symtab_addsymbol (macro->params, sym);
|
2023-10-30 04:25:48 +00:00
|
|
|
|
if (token->token == -rua_ellipsis) {
|
|
|
|
|
macro->num_params = -macro->num_params;
|
|
|
|
|
}
|
2023-10-22 11:56:12 +00:00
|
|
|
|
return macro;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_macro_finish (rua_macro_t *macro, void *scanner)
|
|
|
|
|
{
|
2023-10-27 08:26:00 +00:00
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
if (extra->suppressed) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2023-10-23 09:32:06 +00:00
|
|
|
|
if (macro->tokens) {
|
2023-10-24 05:01:21 +00:00
|
|
|
|
while (((rua_expr_t *) macro->tail)->token == -rua_space) {
|
|
|
|
|
// space is never added as the first token, so it's guaranteed
|
|
|
|
|
// there is always at least two tokens
|
|
|
|
|
rua_expr_t *t;
|
|
|
|
|
for (t = macro->tokens; t->next->next; t = t->next) continue;
|
|
|
|
|
free (t->next);
|
|
|
|
|
t->next = 0;
|
|
|
|
|
macro->tail = &t->next;
|
2023-10-24 06:58:37 +00:00
|
|
|
|
macro->num_tokens--;
|
2023-10-24 05:01:21 +00:00
|
|
|
|
}
|
2023-10-23 09:32:06 +00:00
|
|
|
|
if (macro->tokens->token == PRE_CONCAT
|
|
|
|
|
|| ((rua_expr_t *) macro->tail)->token == PRE_CONCAT) {
|
|
|
|
|
error (0, "'##' cannot appear at either end of a macro expansion");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
for (auto t = macro->tokens; t; t = t->next) {
|
|
|
|
|
if (t->token == '#'
|
|
|
|
|
&& (!t->next
|
2023-10-24 16:09:36 +00:00
|
|
|
|
|| t->next->token != -rua_id
|
2023-10-23 09:32:06 +00:00
|
|
|
|
|| !symtab_lookup (macro->params, t->next->text))) {
|
|
|
|
|
error (0, "'#' is not followed by a macro parameter");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto macro_tab = extra->macro_tab;
|
|
|
|
|
auto sym = symtab_lookup (macro_tab, macro->name);
|
|
|
|
|
if (sym) {
|
|
|
|
|
auto o = sym->s.macro->tokens;
|
|
|
|
|
auto n = macro->tokens;
|
|
|
|
|
while (o && n && o->text == n->text) {
|
|
|
|
|
o = o->next;
|
|
|
|
|
n = n->next;
|
|
|
|
|
}
|
|
|
|
|
if (o || n) {
|
|
|
|
|
error (0, "\"%s\" redefined", macro->name);
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
sym = new_symbol (macro->name);
|
|
|
|
|
sym->sy_type = sy_macro;
|
|
|
|
|
sym->s.macro = macro;
|
|
|
|
|
symtab_addsymbol (macro_tab, sym);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-10-24 14:32:13 +00:00
|
|
|
|
rua_macro_t *
|
2023-10-30 04:25:48 +00:00
|
|
|
|
rua_macro_arg (rua_tok_t *token, void *scanner)
|
2023-10-24 14:32:13 +00:00
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-11-03 04:54:08 +00:00
|
|
|
|
auto macro = extra->pending_macro;
|
2023-10-30 04:25:48 +00:00
|
|
|
|
rua_macro_t *arg;
|
2023-11-03 04:54:08 +00:00
|
|
|
|
if (macro->num_params < 0 && macro->num_args == -macro->num_params) {
|
|
|
|
|
arg = macro->args[macro->num_args - 1];
|
2023-10-30 04:25:48 +00:00
|
|
|
|
rua_macro_append (arg, token, scanner);
|
|
|
|
|
} else {
|
2023-11-03 04:54:08 +00:00
|
|
|
|
if (macro->num_args < macro->num_params
|
|
|
|
|
|| macro->num_args < -macro->num_params) {
|
|
|
|
|
arg = macro->args[macro->num_args++];
|
|
|
|
|
} else {
|
|
|
|
|
// count the excess args for error reporting
|
|
|
|
|
macro->num_args++;
|
|
|
|
|
arg = 0;
|
|
|
|
|
}
|
2023-10-30 04:25:48 +00:00
|
|
|
|
}
|
2023-10-24 14:32:13 +00:00
|
|
|
|
return arg;
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-25 00:25:00 +00:00
|
|
|
|
void
|
|
|
|
|
rua_start_pragma (void *scanner)
|
|
|
|
|
{
|
2023-10-30 23:42:28 +00:00
|
|
|
|
if (options.preprocess_output) {
|
2023-10-25 00:25:00 +00:00
|
|
|
|
printf ("#pragma");
|
|
|
|
|
}
|
|
|
|
|
yy_pop_state (scanner);
|
|
|
|
|
yy_push_state (PRAGMA, scanner);
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
void
|
|
|
|
|
rua_start_text (void *scanner)
|
|
|
|
|
{
|
|
|
|
|
yy_pop_state (scanner);
|
|
|
|
|
yy_push_state (TEXT, scanner);
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-27 08:22:47 +00:00
|
|
|
|
void
|
|
|
|
|
rua_start_include (void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
extra->expand = true;
|
|
|
|
|
|
|
|
|
|
yy_pop_state (scanner);
|
|
|
|
|
yy_push_state (PREPROC, scanner);
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
void
|
|
|
|
|
rua_start_expr (void *scanner)
|
|
|
|
|
{
|
2023-10-24 06:58:37 +00:00
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-10-28 14:51:12 +00:00
|
|
|
|
extra->expand = !extra->suppressed;
|
2023-10-24 06:58:37 +00:00
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
yy_pop_state (scanner);
|
|
|
|
|
yy_push_state (PREEXPR, scanner);
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-24 06:58:37 +00:00
|
|
|
|
void
|
|
|
|
|
rua_expand_on (void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-10-28 14:51:12 +00:00
|
|
|
|
extra->expand = !extra->suppressed;
|
2023-10-24 06:58:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_expand_off (void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
extra->expand = false;
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
void
|
|
|
|
|
rua_end_directive (void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
extra->preprocessor = false;
|
|
|
|
|
extra->recording = false;
|
2023-10-24 06:58:37 +00:00
|
|
|
|
extra->expand = false;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
yy_pop_state (scanner);
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-26 11:31:54 +00:00
|
|
|
|
static void
|
|
|
|
|
dump_debug (int act, const char *text, int start)
|
|
|
|
|
{
|
|
|
|
|
if (act == 0) {
|
|
|
|
|
printf("--scanner backing up\n" );
|
|
|
|
|
} else if (act < YY_NUM_RULES) {
|
|
|
|
|
printf("--accepting rule at line %ld\n",
|
|
|
|
|
(long)yy_rule_linenum[act]);
|
|
|
|
|
} else if (act == YY_NUM_RULES) {
|
|
|
|
|
printf("--accepting default rule\n");
|
|
|
|
|
} else if (act == YY_NUM_RULES + 1 ) {
|
|
|
|
|
printf("--(end of buffer or a NUL)\n");
|
|
|
|
|
} else {
|
|
|
|
|
printf("--EOF (start condition %d)\n", start);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
static void
|
|
|
|
|
dump_state_stack (void *scanner)
|
|
|
|
|
{
|
2023-10-28 14:51:12 +00:00
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
auto yyg = (struct yyguts_t *)scanner;
|
|
|
|
|
for (int i = 0; i < yyg->yy_start_stack_ptr; i++) {
|
|
|
|
|
printf ("%d ", yyg->yy_start_stack[i]);
|
|
|
|
|
}
|
2023-10-28 14:51:12 +00:00
|
|
|
|
printf (": %d s:%s p:%s r:%s e:%s a:%s %s:%d\n", yystart (),
|
|
|
|
|
extra ? extra->suppressed ? "true" : "false" : "n/a",
|
|
|
|
|
extra ? extra->preprocessor ? "true" : "false" : "n/a",
|
|
|
|
|
extra ? extra->recording ? "true" : "false" : "n/a",
|
|
|
|
|
extra ? extra->expand ? "true" : "false" : "n/a",
|
|
|
|
|
extra ? extra->params ? "true" : "false" : "n/a",
|
2023-10-29 09:19:03 +00:00
|
|
|
|
pr.strings ? GETSTR(pr.source_file) : "", pr.source_line);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-10-26 11:31:54 +00:00
|
|
|
|
static void
|
|
|
|
|
dump_token (rua_tok_t *tok, rua_loc_t *loc, int state)
|
|
|
|
|
{
|
|
|
|
|
printf ("start: %2d [%3d %3d] [%3d %3d] '%s'\n", state,
|
|
|
|
|
loc->first_line, loc->first_column,
|
|
|
|
|
loc->last_line, loc->last_column,
|
|
|
|
|
quote_string (tok->text));
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-22 11:56:12 +00:00
|
|
|
|
void
|
2023-10-28 14:51:12 +00:00
|
|
|
|
rua_start_if (bool expand, void *scanner)
|
2023-10-22 11:56:12 +00:00
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
rua_cond_t cond = {
|
2023-10-28 14:51:12 +00:00
|
|
|
|
.saw_true = false,
|
2023-10-22 11:56:12 +00:00
|
|
|
|
.saw_else = false,
|
|
|
|
|
.own_state = true,
|
2023-10-28 14:51:12 +00:00
|
|
|
|
.enabled = false,
|
2023-10-26 11:31:54 +00:00
|
|
|
|
.line = pr.source_line,
|
2023-10-22 11:56:12 +00:00
|
|
|
|
};
|
|
|
|
|
if (extra->cond_stack.size) {
|
|
|
|
|
auto c = extra->cond_stack.a[extra->cond_stack.size - 1];
|
|
|
|
|
cond.own_state = c.own_state & c.enabled;
|
|
|
|
|
}
|
|
|
|
|
DARRAY_APPEND (&extra->cond_stack, cond);
|
2023-11-03 04:48:38 +00:00
|
|
|
|
extra->expand = expand;
|
|
|
|
|
|
|
|
|
|
yy_pop_state (scanner);
|
|
|
|
|
yy_push_state (PREEXPR, scanner);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_start_else (bool expand, void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
extra->expand = expand;
|
2023-10-28 14:51:12 +00:00
|
|
|
|
|
|
|
|
|
yy_pop_state (scanner);
|
|
|
|
|
yy_push_state (PREEXPR, scanner);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_if (bool pass, void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
if (!extra->cond_stack.size) {
|
|
|
|
|
internal_error (0, "#if without start_if");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
auto cond = &extra->cond_stack.a[extra->cond_stack.size - 1];
|
|
|
|
|
cond->saw_true = cond->enabled = pass;
|
|
|
|
|
//yy_pop_state (scanner); // remove DIRECTIVE/PREEXPR state
|
|
|
|
|
if (cond->own_state && !cond->enabled) {
|
2023-10-26 11:31:54 +00:00
|
|
|
|
extra->suppressed = true;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//printf ("#if on %s:%d %d\n", GETSTR(pr.source_file),
|
|
|
|
|
// cond->line, extra->suppressed);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
// put PREEXPR on the stack for EOD to pop
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//yy_push_state (PREEXPR, scanner);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_else (bool pass, const char *tok, void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
if (!extra->cond_stack.size) {
|
|
|
|
|
error (0, "#else without #if");
|
|
|
|
|
return;
|
|
|
|
|
}
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//yy_pop_state (scanner); // remove DIRECTIVE state
|
2023-10-22 11:56:12 +00:00
|
|
|
|
auto cond = &extra->cond_stack.a[extra->cond_stack.size - 1];
|
|
|
|
|
if (cond->saw_else) {
|
|
|
|
|
error (0, "#%s after #else", tok);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (cond->own_state && !cond->enabled) {
|
2023-10-26 11:31:54 +00:00
|
|
|
|
extra->suppressed = false;
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//yy_pop_state (scanner);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
pass &= !cond->saw_true;
|
|
|
|
|
cond->enabled = pass;
|
|
|
|
|
cond->saw_true |= pass;
|
|
|
|
|
cond->saw_else = strcmp (tok, "else") == 0;
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//printf ("#else on %s:%d for %d %d\n", GETSTR(pr.source_file),
|
|
|
|
|
// pr.source_line, cond->line, extra->suppressed);
|
2023-10-26 11:31:54 +00:00
|
|
|
|
cond->line = pr.source_line;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
if (cond->own_state && !cond->enabled) {
|
2023-10-26 11:31:54 +00:00
|
|
|
|
extra->suppressed = true;
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
// put PREEXPR on the stack for EOD to pop
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//yy_push_state (PREEXPR, scanner);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_endif (void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
if (!extra->cond_stack.size) {
|
|
|
|
|
error (0, "#endif without #if");
|
|
|
|
|
return;
|
|
|
|
|
}
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//yy_pop_state (scanner); // remove DIRECTIVE state
|
2023-10-22 11:56:12 +00:00
|
|
|
|
auto cond = DARRAY_REMOVE (&extra->cond_stack);
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//printf ("#endif on %s:%d for %d %d\n", GETSTR(pr.source_file),
|
|
|
|
|
// pr.source_line, cond.line, extra->suppressed);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
if (cond.own_state && !cond.enabled) {
|
2023-10-26 11:31:54 +00:00
|
|
|
|
extra->suppressed = false;
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//yy_pop_state (scanner);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
// put PREEXPR on the stack for EOD to pop
|
2023-10-28 14:51:12 +00:00
|
|
|
|
//yy_push_state (PREEXPR, scanner);
|
2023-10-22 11:56:12 +00:00
|
|
|
|
}
|
2023-10-23 09:32:06 +00:00
|
|
|
|
|
|
|
|
|
bool
|
|
|
|
|
rua_defined (const char *name, void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
auto macro_tab = extra->macro_tab;
|
|
|
|
|
return symtab_lookup (macro_tab, name);
|
|
|
|
|
}
|
2023-10-23 10:00:37 +00:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_undefine (const char *name, void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-10-26 11:31:54 +00:00
|
|
|
|
if (extra->suppressed) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2023-10-23 10:00:37 +00:00
|
|
|
|
auto macro_tab = extra->macro_tab;
|
|
|
|
|
auto sym = symtab_lookup (macro_tab, name);
|
|
|
|
|
if (sym) {
|
|
|
|
|
symtab_removesymbol (macro_tab, sym);
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-10-25 12:07:50 +00:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_include_file (const char *name, void *scanner)
|
|
|
|
|
{
|
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
2023-10-26 11:31:54 +00:00
|
|
|
|
if (extra->suppressed) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2023-10-25 12:07:50 +00:00
|
|
|
|
struct yyguts_t * yyg = (struct yyguts_t*)scanner;//FIXME
|
|
|
|
|
int quote = *name;
|
|
|
|
|
name = make_string (name, 0);
|
|
|
|
|
bool is_system;
|
|
|
|
|
auto found = cpp_find_file (name, quote, &is_system);
|
|
|
|
|
if (!found || !(yyin = fopen (found, "rb"))) {
|
|
|
|
|
error (0, "fatal error: %s: %s", name, strerror (errno));
|
|
|
|
|
exit (1);
|
|
|
|
|
}
|
2023-10-26 11:31:54 +00:00
|
|
|
|
//printf ("*** push include %s\n", name);
|
2023-10-25 12:07:50 +00:00
|
|
|
|
set_line_file (1, found, 1);
|
2023-10-31 01:48:11 +00:00
|
|
|
|
DARRAY_APPEND (&extra->include_stack, ((rua_incl_t) {
|
|
|
|
|
.buffer = YY_CURRENT_BUFFER,
|
|
|
|
|
.cond_stack = extra->cond_stack,
|
|
|
|
|
}));
|
|
|
|
|
extra->cond_stack = (rua_cond_stack_t) DARRAY_STATIC_INIT (8);
|
2023-10-25 12:07:50 +00:00
|
|
|
|
yy_switch_to_buffer (yy_create_buffer (yyin, YY_BUF_SIZE, scanner), scanner);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_embed_file (const char *name, void *scanner)
|
|
|
|
|
{
|
2023-10-26 11:31:54 +00:00
|
|
|
|
auto extra = qc_yyget_extra (scanner);
|
|
|
|
|
if (extra->suppressed) {
|
|
|
|
|
return;
|
2023-10-25 12:07:50 +00:00
|
|
|
|
}
|
2023-10-26 11:31:54 +00:00
|
|
|
|
internal_error (0, "not implemented");
|
2023-10-28 14:51:12 +00:00
|
|
|
|
(void)yy_top_state;
|
2023-10-25 12:07:50 +00:00
|
|
|
|
}
|
2023-10-29 09:19:03 +00:00
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
rua_parse_define (const char *def)
|
|
|
|
|
{
|
|
|
|
|
int status;
|
|
|
|
|
yyscan_t scanner;
|
|
|
|
|
rua_tok_t tok = { .location = { 1, 1, 1, 1 }, };
|
|
|
|
|
rua_extra_t extra = {
|
|
|
|
|
.preprocessor = true,
|
|
|
|
|
.pre_state = pre_yypstate_new (),
|
|
|
|
|
.macro_tab = cpp_macros,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
yylex_init_extra (&extra, &scanner);
|
|
|
|
|
yy_scan_string (def, scanner);
|
|
|
|
|
|
|
|
|
|
yy_push_state (PREPROC, scanner);
|
|
|
|
|
|
|
|
|
|
int token = -1;
|
|
|
|
|
do {
|
|
|
|
|
if (token == -1) {
|
|
|
|
|
token = PRE_DEFINE;
|
|
|
|
|
} else {
|
|
|
|
|
token = yylex (&tok, &tok.location, scanner);
|
|
|
|
|
status = 0;
|
|
|
|
|
}
|
|
|
|
|
while (token) {
|
|
|
|
|
status = qc_process (&extra, token, &tok, scanner);
|
2023-11-03 04:54:08 +00:00
|
|
|
|
if (status != YYPUSH_MORE || !extra.macro) {
|
2023-10-29 09:19:03 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2023-11-03 04:54:08 +00:00
|
|
|
|
auto expr = *extra.macro->cursor;
|
|
|
|
|
extra.macro->cursor = extra.macro->cursor->next;
|
|
|
|
|
if (!extra.macro->cursor) {
|
|
|
|
|
extra.macro = extra.macro->next;
|
|
|
|
|
}
|
2023-10-29 09:19:03 +00:00
|
|
|
|
token = expr.token;
|
2023-11-04 12:08:40 +00:00
|
|
|
|
tok = expr_token (&expr);
|
2023-10-29 09:19:03 +00:00
|
|
|
|
}
|
|
|
|
|
} while (status == YYPUSH_MORE);
|
|
|
|
|
|
|
|
|
|
yylex_destroy (scanner);
|
|
|
|
|
pre_yypstate_delete (extra.pre_state);
|
|
|
|
|
dstring_delete (extra.dstr);
|
|
|
|
|
return status;
|
|
|
|
|
}
|
2023-11-01 07:07:12 +00:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_macro_file (rua_macro_t *macro, void *scanner)
|
|
|
|
|
{
|
|
|
|
|
int file = pr.source_file;
|
|
|
|
|
if (macro->tokens && macro->tokens->location.file == file) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
macro->tokens = 0;
|
|
|
|
|
macro->tail = ¯o->tokens;
|
|
|
|
|
macro->num_tokens = 0;
|
|
|
|
|
|
|
|
|
|
rua_expr_t *expr = malloc (sizeof (*expr));
|
|
|
|
|
macro->num_tokens++;
|
|
|
|
|
const char *file_str = save_string (va (0, "\"%s\"",
|
|
|
|
|
quote_string (GETSTR (file))));
|
|
|
|
|
*expr = (rua_expr_t) {
|
|
|
|
|
.location = { .file = file },
|
|
|
|
|
.textlen = strlen (file_str),
|
|
|
|
|
.token = -rua_string,
|
|
|
|
|
.text = file_str,
|
|
|
|
|
};
|
|
|
|
|
*macro->tail = expr;
|
|
|
|
|
macro->tail = &expr->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
rua_macro_line (rua_macro_t *macro, void *scanner)
|
|
|
|
|
{
|
|
|
|
|
int line = pr.source_line;
|
|
|
|
|
|
|
|
|
|
if (macro->tokens && macro->tokens->location.first_line == line) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
macro->tokens = 0;
|
|
|
|
|
macro->tail = ¯o->tokens;
|
|
|
|
|
macro->num_tokens = 0;
|
|
|
|
|
|
|
|
|
|
rua_expr_t *expr = malloc (sizeof (*expr));
|
|
|
|
|
macro->num_tokens++;
|
|
|
|
|
const char *line_str = save_string (va (0, "%d", line));
|
|
|
|
|
*expr = (rua_expr_t) {
|
|
|
|
|
.location = { .first_line = line },
|
|
|
|
|
.textlen = strlen (line_str),
|
|
|
|
|
.token = -rua_number,
|
|
|
|
|
.text = line_str,
|
|
|
|
|
};
|
|
|
|
|
*macro->tail = expr;
|
|
|
|
|
macro->tail = &expr->next;
|
|
|
|
|
}
|