#ifndef LPYTHON_PARSER_SEMANTICS_H

#define LPYTHON_PARSER_SEMANTICS_H

#include <cstring>

#include <lpython/python_ast.h>

#include <libasr/string_utils.h>

#include <lpython/parser/parser_exception.h>

using namespace LCompilers::LPython::AST;

using LCompilers::Location;

using LCompilers::Vec;

using LCompilers::LPython::Key_Val;

using LCompilers::LPython::Args;

using LCompilers::LPython::Arg;

using LCompilers::LPython::Fn_Arg;

using LCompilers::LPython::Args_;

using LCompilers::LPython::Var_Kw;

using LCompilers::LPython::Kw_or_Star_Arg;

using LCompilers::LPython::Call_Arg;

using LCompilers::LPython::Key_Val_Pattern;

static inline char* name2char(const ast_t *n) {

return down_cast2<Name_t>(n)->m_id;

}

Vec<ast_t*> A2LIST(Allocator &al, ast_t *x) {

}

static inline char** REDUCE_ARGS(Allocator &al, const Vec<ast_t*> args) {

char **a = al.allocate<char*>(args.size());

for (size_t i=0; i < args.size(); i++) {

a[i] = name2char(args.p[i]);

}

return a;

}

template <typename T, astType type>

static inline T** vec_cast(const Vec<ast_t*> &x) {

T **s = (T**)x.p;

for (size_t i=0; i < x.size(); i++) {

LCOMPILERS_ASSERT((s[i]->base.type == type))

}

return s;

}

#define FLOC(a, b) a.first = b.first;

#define LLOC(a, b) a.last = b.last;

#define VEC_CAST(x, type) vec_cast<type##_t, astType::type>(x)

#define STMTS(x) VEC_CAST(x, stmt)

#define EXPRS(x) VEC_CAST(x, expr)

#define EXPR(x) (down_cast<expr_t>(x))

#define STMT(x) (down_cast<stmt_t>(x))

#define EXPR2STMT(x) ((stmt_t*)make_Expr_t(p.m_a, x->base.loc, x))

static inline expr_t* EXPR_OPT(const ast_t *f)

{

if (f) {

return EXPR(f);

} else {

return nullptr;

}

}

#define SET_EXPR_CTX_(y, ctx) \

case exprType::y: { \

if(is_a<y##_t>(*EXPR(x))) \

((y##_t*)x)->m_ctx = ctx; \

break; \

}

static inline ast_t* SET_EXPR_CTX_01(ast_t* x, expr_contextType ctx) {

LCOMPILERS_ASSERT(is_a<expr_t>(*x))

switch(EXPR(x)->type) {

SET_EXPR_CTX_(Attribute, ctx)

SET_EXPR_CTX_(Subscript, ctx)

SET_EXPR_CTX_(Starred, ctx)

SET_EXPR_CTX_(Name, ctx)

SET_EXPR_CTX_(List, ctx)

SET_EXPR_CTX_(Tuple, ctx)

default : { break; }

}

return x;

}

static inline Vec<ast_t*> SET_EXPR_CTX_02(Vec<ast_t*> x, expr_contextType ctx) {

}

#define RESULT(x) p.result.push_back(p.m_a, STMT(x))

#define LIST_NEW(l) l.reserve(p.m_a, 4)

#define LIST_ADD(l, x) l.push_back(p.m_a, x)

#define PLIST_ADD(l, x) l.push_back(p.m_a, *x)

#define OPERATOR(op, l) operatorType::op

#define AUGASSIGN_01(x, op, y, l) make_AugAssign_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(x, Store)), op, EXPR(y))

#define ANNASSIGN_01(x, y, l) make_AnnAssign_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(x, Store)), EXPR(y), nullptr, 1)

#define ANNASSIGN_02(x, y, val, l) make_AnnAssign_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(x, Store)), EXPR(y), EXPR(val), 1)

#define DELETE_01(e, l) make_Delete_t(p.m_a, l, \

EXPRS(SET_EXPR_CTX_02(SET_CTX_02(e, Del), Del)), e.size())

#define EXPR_01(e, l) make_Expr_t(p.m_a, l, EXPR(e))

#define RETURN_01(l) make_Return_t(p.m_a, l, nullptr)

#define RETURN_02(e, l) make_Return_t(p.m_a, l, EXPR(e))

#define YIELD_01(l) make_Yield_t(p.m_a, l, nullptr)

#define YIELD_02(exec, l) make_Yield_t(p.m_a, l, EXPR(exec))

#define YIELD_03(value, l) make_YieldFrom_t(p.m_a, l, EXPR(value))

#define PASS(l) make_Pass_t(p.m_a, l)

#define BREAK(l) make_Break_t(p.m_a, l)

#define CONTINUE(l) make_Continue_t(p.m_a, l)

#define RAISE_01(l) make_Raise_t(p.m_a, l, nullptr, nullptr)

#define RAISE_02(exec, l) make_Raise_t(p.m_a, l, EXPR(exec), nullptr)

#define RAISE_03(exec, cause, l) make_Raise_t(p.m_a, l, EXPR(exec), EXPR(cause))

#define ASSERT_01(test, l) make_Assert_t(p.m_a, l, EXPR(test), nullptr)

#define ASSERT_02(test, msg, l) make_Assert_t(p.m_a, l, EXPR(test), EXPR(msg))

#define GLOBAL(names, l) make_Global_t(p.m_a, l, \

REDUCE_ARGS(p.m_a, names), names.size())

#define NON_LOCAL(names, l) make_Nonlocal_t(p.m_a, l, \

REDUCE_ARGS(p.m_a, names), names.size())

static inline ast_t *SET_CTX_01(ast_t *x, expr_contextType ctx) {

if(is_a<Tuple_t>(*EXPR(x))) {

size_t n_elts = down_cast2<Tuple_t>(x)->n_elts;

for(size_t i=0; i < n_elts; i++) {

SET_EXPR_CTX_01((ast_t *) down_cast2<Tuple_t>(x)->m_elts[i], ctx);

}

}

return x;

}

static inline Vec<ast_t*> SET_CTX_02(Vec<ast_t*> x, expr_contextType ctx) {

}

#define ASSIGNMENT(targets, val, l) make_Assign_t(p.m_a, l, \

EXPRS(SET_EXPR_CTX_02(SET_CTX_02(targets, Store), Store)), targets.size(), \

EXPR(val), nullptr)

#define ASSIGNMENT2(targets, val, type_comment, l) make_Assign_t(p.m_a, l, \

EXPRS(SET_EXPR_CTX_02(SET_CTX_02(targets, Store), Store)), targets.size(), \

EXPR(val), extract_type_comment(p, l, type_comment))

static inline ast_t* TUPLE_02(Allocator &al, Location &l, Vec<ast_t*> elts) {

if(is_a<expr_t>(*elts[0]) && elts.size() == 1) {

return (ast_t*) elts[0];

}

return make_Tuple_t(al, l, EXPRS(elts), elts.size(), expr_contextType::Load);

}

#define TUPLE_01(elts, l) TUPLE_02(p.m_a, l, elts)

#define TUPLE_03(elts, l) make_Tuple_t(p.m_a, l, \

EXPRS(elts), elts.size(), expr_contextType::Load)

#define TUPLE_EMPTY(l) make_Tuple_t(p.m_a, l, \

nullptr, 0, expr_contextType::Load)

Vec<ast_t*> TUPLE_APPEND(Allocator &al, Vec<ast_t*> x, ast_t *y) {

}

#define TUPLE_(x, y) TUPLE_APPEND(p.m_a, x, y)

static inline alias_t *IMPORT_ALIAS_01(Allocator &al, Location &l,

char *name, char *asname){

alias_t *r = al.allocate<alias_t>();

r->loc = l;

r->m_name = name;

r->m_asname = asname;

return r;

}

static inline char *mod2char(Allocator &al, Vec<ast_t*> module) {

std::string s = "";

for (size_t i=0; i<module.size(); i++) {

s.append(name2char(module[i]));

if (i < module.size()-1)s.append(".");

}

LCompilers::Str str;

str.from_str_view(s);

return str.c_str(al);

}

#define MOD_ID_01(module, l) IMPORT_ALIAS_01(p.m_a, l, \

mod2char(p.m_a, module), nullptr)

#define MOD_ID_02(module, as_id, l) IMPORT_ALIAS_01(p.m_a, l, \

mod2char(p.m_a, module), name2char(as_id))

#define MOD_ID_03(star, l) IMPORT_ALIAS_01(p.m_a, l, \

(char *)"*", nullptr)

int dot_count = 0;

#define DOT_COUNT_01() dot_count++;

#define DOT_COUNT_02() dot_count = dot_count + 3;

#define IMPORT_01(names, l) make_Import_t(p.m_a, l, names.p, names.size())

#define IMPORT_02(module, names, l) make_ImportFrom_t(p.m_a, l, \

mod2char(p.m_a, module), names.p, names.size(), 0)

#define IMPORT_03(names, l) make_ImportFrom_t(p.m_a, l, \

nullptr, names.p, names.size(), dot_count); dot_count = 0

#define IMPORT_04(module, names, l) make_ImportFrom_t(p.m_a, l, \

mod2char(p.m_a, module), names.p, names.size(), dot_count); \

dot_count = 0

#define IF_STMT_01(e, stmt, l) make_If_t(p.m_a, l, \

EXPR(e), STMTS(stmt), stmt.size(), nullptr, 0)

#define IF_STMT_02(e, stmt, orelse, l) make_If_t(p.m_a, l, \

EXPR(e), STMTS(stmt), stmt.size(), STMTS(orelse), orelse.size())

#define IF_STMT_03(e, stmt, orelse, l) make_If_t(p.m_a, l, \

EXPR(e), STMTS(stmt), stmt.size(), STMTS(A2LIST(p.m_a, orelse)), 1)

#define TERNARY(test, body, orelse, l) make_IfExp_t(p.m_a, l, \

EXPR(test), EXPR(body), EXPR(orelse))

static inline char *extract_type_comment(LCompilers::LPython::Parser &p,

Location &loc, LCompilers::Str &s) {

std::string str = s.str();

str.erase(str.begin()); // removes "#" at the beginning

str.erase(0, str.find_first_not_of(' ')); // trim left spaces

std::string::size_type pos = 5;

str = str.substr(pos, str.size());

str.erase(str.find_last_not_of(' ') + 1); // trim right spaces

str.erase(0, str.find_first_not_of(' ')); // trim left spaces

size_t i = 0;

bool flag = true;

std::string kw{"ignore"};

while (i < 6) {

if(str[i] == kw[i]) {

i++;

} else {

flag = false;

break;

}

}

if (flag) {

pos = 6;

str = str.substr(pos, str.size());

s.from_str_view(str);

p.type_ignore.push_back(p.m_a, down_cast<type_ignore_t>(

make_TypeIgnore_t(p.m_a, loc, 0, s.c_str(p.m_a))));

return nullptr;

} else {

s.from_str_view(str);

return s.c_str(p.m_a);

}

}

#define FOR_01(target, iter, stmts, l) make_For_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(SET_CTX_01(target, Store), Store)), EXPR(iter), \

STMTS(stmts), stmts.size(), nullptr, 0, nullptr)

#define FOR_02(target, iter, stmts, orelse, l) make_For_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(SET_CTX_01(target, Store), Store)), EXPR(iter), \

STMTS(stmts), stmts.size(), STMTS(orelse), orelse.size(), nullptr)

#define FOR_03(target, iter, type_comment, stmts, l) make_For_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(SET_CTX_01(target, Store), Store)), EXPR(iter), \

STMTS(stmts), stmts.size(), nullptr, 0, \

extract_type_comment(p, l, type_comment))

#define FOR_04(target, iter, stmts, orelse, type_comment, l) make_For_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(SET_CTX_01(target, Store), Store)), EXPR(iter), \

STMTS(stmts), stmts.size(), STMTS(orelse), orelse.size(), \

extract_type_comment(p, l, type_comment))

#define TRY_01(stmts, except, l) make_Try_t(p.m_a, l, \

STMTS(stmts), stmts.size(), \

VEC_CAST(except, excepthandler), except.size(), nullptr, 0, nullptr, 0)

#define TRY_02(stmts, except, orelse, l) make_Try_t(p.m_a, l, \

STMTS(stmts), stmts.size(), \

VEC_CAST(except, excepthandler), except.size(), \

STMTS(orelse), orelse.size(), nullptr, 0)

#define TRY_03(stmts, except, final, l) make_Try_t(p.m_a, l, \

STMTS(stmts), stmts.size(), \

VEC_CAST(except, excepthandler), except.size(), nullptr, 0, \

STMTS(final), final.size())

#define TRY_04(stmts, except, orelse, final, l) make_Try_t(p.m_a, l, \

STMTS(stmts), stmts.size(), \

VEC_CAST(except, excepthandler), except.size(), \

STMTS(orelse), orelse.size(), STMTS(final), final.size())

#define TRY_05(stmts, final, l) make_Try_t(p.m_a, l, \

STMTS(stmts), stmts.size(), \

nullptr, 0, nullptr, 0, STMTS(final), final.size())

#define EXCEPT_01(stmts, l) make_ExceptHandler_t(p.m_a, l, \

nullptr, nullptr, STMTS(stmts), stmts.size())

#define EXCEPT_02(e, stmts, l) make_ExceptHandler_t(p.m_a, l, \

EXPR(e), nullptr, STMTS(stmts), stmts.size())

#define EXCEPT_03(e, id, stmts, l) make_ExceptHandler_t(p.m_a, l, \

EXPR(e), name2char(id), STMTS(stmts), stmts.size())

#define MATCH_VALUE(val, l) down_cast<pattern_t>( \

make_MatchValue_t(p.m_a, l, EXPR(val)))

#define MATCH_SINGLETON(val, l) down_cast<pattern_t>( \

make_MatchSingleton_t(p.m_a, l, EXPR(val)))

#define MATCH_AS_01(pattern, id, l) down_cast<pattern_t>( \

make_MatchAs_t(p.m_a, l, pattern, name2char(id)))

#define MATCH_AS_02(id, l) down_cast<pattern_t>( \

make_MatchAs_t(p.m_a, l, nullptr, name2char(id)))

#define MATCH_OR(v, l) down_cast<pattern_t>(make_MatchOr_t(p.m_a, l, v.p, v.n))

#define MATCH_STAR(id, l) down_cast<pattern_t>( \

make_MatchStar_t(p.m_a, l, name2char(id)))

#define MATCH_SEQUENCE_01(l) down_cast<pattern_t>( \

make_MatchSequence_t(p.m_a, l, nullptr, 0))

#define MATCH_SEQUENCE_02(patterns, l) down_cast<pattern_t>( \

make_MatchSequence_t(p.m_a, l, patterns.p, patterns.n))

static inline Key_Val_Pattern* KEY_VAL_PATTERN(Allocator &al,

expr_t* key, pattern_t* value) {

Key_Val_Pattern* r = al.allocate<Key_Val_Pattern>();

r->key = key;

r->val = value;

return r;

}

pattern_t *match_mapping(Allocator &al, Location &l,

Vec<Key_Val_Pattern> items, char *rest) {

Vec<expr_t*> key;

key.reserve(al, items.size());

Vec<pattern_t*> val;

val.reserve(al, items.size());

for (auto &item : items) {

key.push_back(al, item.key);

val.push_back(al, item.val);

}

return down_cast<pattern_t>(

make_MatchMapping_t(al, l, key.p, key.n, val.p, val.n, rest));

}

#define MATCH_MAPPING_01(l) down_cast<pattern_t>( \

make_MatchMapping_t(p.m_a, l, nullptr, 0, nullptr, 0, nullptr))

#define MATCH_MAPPING_02(items, l) match_mapping(p.m_a, l, items, nullptr)

#define MATCH_MAPPING_03(items, rest, l) match_mapping(p.m_a, l, \

items, name2char(rest))

#define MATCH_MAPPING_04(rest, l) down_cast<pattern_t>( \

make_MatchMapping_t(p.m_a, l, nullptr, 0, nullptr, 0, name2char(rest)))

pattern_t *match_class(Allocator &al, Location &l, expr_t *cls,

pattern_t** m_patterns, size_t n_patterns,

Key_Val_Pattern* m_params, size_t n_params) {

Vec<char*> kwd_attrs;

kwd_attrs.reserve(al, n_params);

Vec<pattern_t*> kwd_patterns;

kwd_patterns.reserve(al, n_params);

for (size_t i = 0; i < n_params; i++) {

kwd_attrs.push_back(al, name2char((ast_t*)m_params[i].key));

kwd_patterns.push_back(al, m_params[i].val);

}

return down_cast<pattern_t>(make_MatchClass_t(al, l, cls,

m_patterns, n_patterns, kwd_attrs.p, kwd_attrs.n,

kwd_patterns.p, kwd_patterns.n));

}

#define MATCH_CLASS_01(cls, l) down_cast<pattern_t>( \

make_MatchClass_t(p.m_a, l, EXPR(cls), nullptr,0, \

nullptr, 0, nullptr, 0))

#define MATCH_CLASS_02(cls, args, l) match_class(p.m_a, l, \

EXPR(cls), args.p, args.n, nullptr, 0)

#define MATCH_CLASS_03(cls, args, kws, l) match_class(p.m_a, l, \

EXPR(cls), args.p, args.n, kws.p, kws.n)

#define MATCH_CLASS_04(cls, kws, l) match_class(p.m_a, l, \

EXPR(cls), nullptr, 0, kws.p, kws.n)

static inline match_case_t* match_case(Allocator &al, Location &l,

pattern_t* pattern, expr_t* guard, Vec<ast_t*> body) {

match_case_t* r = al.allocate<match_case_t>();

r->loc = l;

r->m_pattern = pattern;

r->m_guard = guard;

r->m_body = STMTS(body);

r->n_body = body.size();

return r;

}

#define MATCH_CASE_01(pattern, body, l) match_case(p.m_a, l, \

pattern, nullptr, body)

#define MATCH_CASE_02(pattern, guard, body, l) match_case(p.m_a, l, \

pattern, EXPR(guard), body)

#define MATCH_01(subject, cases, l) make_Match_t(p.m_a, l, \

EXPR(subject), cases.p, cases.n)

static inline withitem_t* WITH_ITEM(Allocator &al, Location &l,

expr_t* context_expr, expr_t* optional_vars) {

withitem_t* r = al.allocate<withitem_t>();

r->loc = l;

r->m_context_expr = context_expr;

r->m_optional_vars = optional_vars;

return r;

}

#define WITH_ITEM_01(expr, vars, l) WITH_ITEM(p.m_a, l, \

EXPR(expr), EXPR(SET_EXPR_CTX_01(vars, Store)))

#define WITH_ITEM_02(expr, l) WITH_ITEM(p.m_a, l, EXPR(expr), nullptr)

#define WITH_01(items, body, l) make_With_t(p.m_a, l, \

items.p, items.size(), STMTS(body), body.size(), nullptr)

#define WITH_02(items, body, type_comment, l) make_With_t(p.m_a, l, \

items.p, items.size(), STMTS(body), body.size(), \

extract_type_comment(p, l, type_comment))

static inline Arg *FUNC_ARG(Allocator &al, Location &l, char *arg,

expr_t* e, expr_t* defaults) {

Arg *r = al.allocate<Arg>();

r->_arg.loc = l;

r->_arg.m_arg = arg;

r->_arg.m_annotation = e;

r->_arg.m_type_comment = nullptr;

if(defaults){

r->default_value = true;

} else {

r->default_value = false;

}

r->defaults = defaults;

return r;

}

Arg** ARG2LIST(Allocator &al, Arg *x) {

Arg** v = al.allocate<Arg*>(1);

v[0] = x;

return v;

}

#define FUNC_ARGS1_(x) \

Vec<arg_t> _m_##x; \

_m_##x.reserve(al, 4); \

r->arguments.m_##x = _m_##x.p; \

r->arguments.n_##x = _m_##x.n;

#define FUNC_ARGS_(x, kw) \

if(n_##x > 0) { \

for(size_t i = 0; i < n_##x; i++) { \

_m_##x.push_back(al, m_##x[i]->_arg); \

if(m_##x[i]->default_value) { \

if (kw == 0) { \

defaults.push_back(al, m_##x[i]->defaults); \

} else { \

kw_defaults.push_back(al, m_##x[i]->defaults); \

} \

} else { \

if (kw == 1) { \

kw_defaults.push_back(al, \

(expr_t*)make_ConstantNone_t(al, l, nullptr)); \

} \

} \

} \

r->arguments.m_##x = _m_##x.p; \

r->arguments.n_##x = _m_##x.n; \

}

static inline Args *FUNC_ARGS_01(Allocator &al, Location &l, Fn_Arg *parameters) {

Args *r = al.allocate<Args>();

Vec<expr_t*> defaults;

defaults.reserve(al, 4);

Vec<expr_t*> kw_defaults;

kw_defaults.reserve(al, 4);

FUNC_ARGS1_(posonlyargs);

FUNC_ARGS1_(args);

FUNC_ARGS1_(vararg);

FUNC_ARGS1_(kwonlyargs);

FUNC_ARGS1_(kwarg);

r->arguments.loc = l;

if(parameters != nullptr) {

Arg** m_posonlyargs = parameters->posonlyargs.p;

size_t n_posonlyargs = parameters->posonlyargs.n;

FUNC_ARGS_(posonlyargs, 0);

}

if(parameters != nullptr && parameters->args_val) {

Arg** m_args = parameters->args->args.p;

size_t n_args = parameters->args->args.n;

FUNC_ARGS_(args, 0);

if(parameters->args->var_kw_val) {

Arg** m_vararg = parameters->args->var_kw->vararg.p;

size_t n_vararg = parameters->args->var_kw->vararg.n;

FUNC_ARGS_(vararg, 0);

Arg** m_kwonlyargs = parameters->args->var_kw->kwonlyargs.p;

size_t n_kwonlyargs = parameters->args->var_kw->kwonlyargs.n;

FUNC_ARGS_(kwonlyargs, 1);

Arg** m_kwarg = parameters->args->var_kw->kwarg.p;

size_t n_kwarg = parameters->args->var_kw->kwarg.n;

FUNC_ARGS_(kwarg, 2);

}

}

r->arguments.m_kw_defaults = kw_defaults.p;

r->arguments.n_kw_defaults = kw_defaults.n;

r->arguments.m_defaults = defaults.p;

r->arguments.n_defaults = defaults.n;

return r;

}

#define ARGS_01(arg, l) FUNC_ARG(p.m_a, l, \

name2char((ast_t *)arg), nullptr, nullptr)

#define ARGS_02(arg, annotation, l) FUNC_ARG(p.m_a, l, \

name2char((ast_t *)arg), EXPR(annotation), nullptr)

#define ARGS_03(arg, defaults, l) FUNC_ARG(p.m_a, l, \

name2char((ast_t *)arg), nullptr, EXPR(defaults))

#define ARGS_04(arg, ann, defaults, l) FUNC_ARG(p.m_a, l, \

name2char((ast_t *)arg), EXPR(ann), EXPR(defaults))

static inline void ADD_TYPE_COMMENT_(LCompilers::LPython::Parser &p, Location l,

Vec<Arg*> &x, LCompilers::Str &type_comment) {

x[x.size() - 1]->_arg.m_type_comment = extract_type_comment(p, l, type_comment);

}

#define ADD_TYPE_COMMENT(x, type_comment, l) \

ADD_TYPE_COMMENT_(p, l, x, type_comment)

static inline Fn_Arg *FN_ARG(Allocator &al, Arg** m_posonlyargs,

size_t n_posonlyargs, Args_ *args) {

Fn_Arg *r = al.allocate<Fn_Arg>();

r->posonlyargs.p = m_posonlyargs;

r->posonlyargs.n = n_posonlyargs;

if(args) {

r->args_val = true;

} else {

r->args_val = false;

}

r->args = args;

return r;

}

static inline Args_ *ARGS(Allocator &al, Arg** m_args,

size_t n_args, Var_Kw *var_kw) {

Args_ *r = al.allocate<Args_>();

r->args.p = m_args;

r->args.n = n_args;

if(var_kw) {

r->var_kw_val = true;

} else {

r->var_kw_val = false;

}

r->var_kw = var_kw;

return r;

}

static inline Var_Kw *VAR_KW(Allocator &al,

Arg** m_kwarg, size_t n_kwarg,

Arg** m_kwonlyargs, size_t n_kwonlyargs,

Arg** m_vararg, size_t n_vararg) {

Var_Kw *r = al.allocate<Var_Kw>();

r->kwarg.p = m_kwarg;

r->kwarg.n = n_kwarg;

r->kwonlyargs.p = m_kwonlyargs;

r->kwonlyargs.n = n_kwonlyargs;

r->vararg.p = m_vararg;

r->vararg.n = n_vararg;

return r;

}

#define PARAMETER_LIST_01(posonlyargs, args) \

FN_ARG(p.m_a, posonlyargs.p, posonlyargs.n, args)

#define PARAMETER_LIST_02(args) FN_ARG(p.m_a, nullptr, 0, args)

#define PARAMETER_LIST_03(args, var_kw) ARGS(p.m_a, args.p, args.n, var_kw)

#define PARAMETER_LIST_04(var_kw) ARGS(p.m_a, nullptr, 0, var_kw)

#define PARAMETER_LIST_05(kwonlyargs) VAR_KW(p.m_a, nullptr, 0, \

kwonlyargs.p, kwonlyargs.n, nullptr, 0)

#define PARAMETER_LIST_06(kwarg) VAR_KW(p.m_a, ARG2LIST(p.m_a, kwarg), 1, \

nullptr, 0, nullptr, 0)

#define PARAMETER_LIST_07(kwonlyargs, kwarg) VAR_KW(p.m_a, \

ARG2LIST(p.m_a, kwarg), 1, kwonlyargs.p, kwonlyargs.n, nullptr, 0)

#define PARAMETER_LIST_08(vararg) VAR_KW(p.m_a, nullptr, 0, \

nullptr, 0, ARG2LIST(p.m_a, vararg), 1)

#define PARAMETER_LIST_09(vararg, kwonlyargs) VAR_KW(p.m_a, nullptr, 0, \

kwonlyargs.p, kwonlyargs.n, ARG2LIST(p.m_a, vararg), 1)

#define PARAMETER_LIST_10(vararg, kwarg) VAR_KW(p.m_a, \

ARG2LIST(p.m_a, kwarg), 1, nullptr, 0, ARG2LIST(p.m_a, vararg), 1)

#define PARAMETER_LIST_11(vararg, kwonlyargs, kwarg) VAR_KW(p.m_a, \

ARG2LIST(p.m_a, kwarg), 1, kwonlyargs.p, kwonlyargs.n, \

ARG2LIST(p.m_a, vararg), 1)

#define PARAMETER_LIST_12(l) FUNC_ARGS_01(p.m_a, l, nullptr)

#define FUNCTION_01(decorator, id, args, stmts, l) \

make_FunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), EXPRS(decorator), decorator.size(), \

nullptr, nullptr)

#define FUNCTION_02(decorator, id, args, return, stmts, l) \

make_FunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), EXPRS(decorator), decorator.size(), \

EXPR(return), nullptr)

#define FUNCTION_03(decorator, id, args, stmts, type_comment, l) \

make_FunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), EXPRS(decorator), decorator.size(), \

nullptr, extract_type_comment(p, l, type_comment))

#define FUNCTION_04(decorator, id, args, return, stmts, type_comment, l) \

make_FunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), EXPRS(decorator), decorator.size(), \

EXPR(return), extract_type_comment(p, l, type_comment))

#define CLASS_01(decorator, id, stmts, l) make_ClassDef_t(p.m_a, l, \

name2char(id), nullptr, 0, nullptr, 0, \

STMTS(stmts), stmts.size(), \

EXPRS(decorator), decorator.size())

#define CLASS_02(decorator, id, args, stmts, l) make_ClassDef_t(p.m_a, l, \

name2char(id), args->expr.p, args->expr.n, args->kw.p, args->kw.n, \

STMTS(stmts), stmts.size(), \

EXPRS(decorator), decorator.size())

#define ASYNC_FUNCTION_01(decorator, id, args, stmts, l) \

make_AsyncFunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), EXPRS(decorator), decorator.size(), \

nullptr, nullptr)

#define ASYNC_FUNCTION_02(decorator, id, args, return, stmts, l) \

make_AsyncFunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), EXPRS(decorator), decorator.size(), \

EXPR(return), nullptr)

#define ASYNC_FUNCTION_03(id, args, stmts, l) \

make_AsyncFunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), nullptr, 0, nullptr, nullptr)

#define ASYNC_FUNCTION_04(id, args, return, stmts, l) \

make_AsyncFunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), nullptr, 0, EXPR(return), nullptr)

#define ASYNC_FUNCTION_05(decorator, id, args, stmts, type_comment, l) \

make_AsyncFunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), EXPRS(decorator), decorator.size(), \

nullptr, extract_type_comment(p, l, type_comment))

#define ASYNC_FUNCTION_06(decorator, id, args, return, stmts, type_comment, l) \

make_AsyncFunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), EXPRS(decorator), decorator.size(), \

EXPR(return), extract_type_comment(p, l, type_comment))

#define ASYNC_FUNCTION_07(id, args, stmts, type_comment, l) \

make_AsyncFunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), nullptr, 0, nullptr,\

extract_type_comment(p, l, type_comment))

#define ASYNC_FUNCTION_08(id, args, return, stmts, type_comment, l) \

make_AsyncFunctionDef_t(p.m_a, l, name2char(id), args->arguments, \

STMTS(stmts), stmts.size(), nullptr, 0, EXPR(return),\

extract_type_comment(p, l, type_comment))

#define ASYNC_FOR_01(target, iter, stmts, l) make_AsyncFor_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(SET_CTX_01(target, Store), Store)), EXPR(iter), \

STMTS(stmts), stmts.size(), nullptr, 0, nullptr)

#define ASYNC_FOR_02(target, iter, stmts, orelse, l) make_AsyncFor_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(SET_CTX_01(target, Store), Store)), EXPR(iter), \

STMTS(stmts), stmts.size(), STMTS(orelse), orelse.size(), nullptr)

#define ASYNC_FOR_03(target, iter, stmts, type_comment, l) make_AsyncFor_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(SET_CTX_01(target, Store), Store)), EXPR(iter), \

STMTS(stmts), stmts.size(), nullptr, 0, \

extract_type_comment(p, l, type_comment))

#define ASYNC_FOR_04(target, iter, stmts, orelse, type_comment, l) make_AsyncFor_t(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(SET_CTX_01(target, Store), Store)), EXPR(iter), \

STMTS(stmts), stmts.size(), STMTS(orelse), orelse.size(), \

extract_type_comment(p, l, type_comment))

#define ASYNC_WITH_01(items, body, l) make_AsyncWith_t(p.m_a, l, \

items.p, items.size(), STMTS(body), body.size(), nullptr)

#define ASYNC_WITH_02(items, body, type_comment, l) make_AsyncWith_t(p.m_a, l, \

items.p, items.size(), STMTS(body), body.size(), \

extract_type_comment(p, l, type_comment))

#define WHILE_01(e, stmts, l) make_While_t(p.m_a, l, \

EXPR(e), STMTS(stmts), stmts.size(), nullptr, 0)

#define WHILE_02(e, stmts, orelse, l) make_While_t(p.m_a, l, \

EXPR(e), STMTS(stmts), stmts.size(), STMTS(orelse), orelse.size())

static inline ast_t* BOOLOP_01(Allocator &al, Location &loc,

boolopType op, ast_t *x, ast_t *y) {

expr_t* x1 = EXPR(x);

expr_t* y1 = EXPR(y);

Vec<expr_t*> v;

v.reserve(al, 4);

/*

v.push_back(al, x1);

v.push_back(al, y1);

return make_BoolOp_t(al, loc, op, v.p, v.n);

}

#define BOOLOP(x, op, y, l) BOOLOP_01(p.m_a, l, op, x, y)

#define BINOP(x, op, y, l) make_BinOp_t(p.m_a, l, \

EXPR(x), operatorType::op, EXPR(y))

#define UNARY(x, op, l) make_UnaryOp_t(p.m_a, l, unaryopType::op, EXPR(x))

#define COMPARE(x, op, y, l) make_Compare_t(p.m_a, l, \

EXPR(x), cmpopType::op, EXPRS(A2LIST(p.m_a, y)), 1)

#define MEMBERSHIP(x, op, y, l) make_Membership_t(p.m_a, l, \

EXPR(x), membershipopType::op, EXPR(y))

static inline ast_t* concat_string(Allocator &al, Location &l,

expr_t *string, std::string str, expr_t *string_literal) {

std::string str1 = "";

ast_t* tmp = nullptr;

Vec<expr_t *> exprs;

exprs.reserve(al, 4);

// TODO: Merge two concurrent ConstantStr's into one in the JoinedStr

if (string_literal) {

if (is_a<ConstantStr_t>(*string)

&& is_a<ConstantStr_t>(*string_literal)) {

str1 = std::string(down_cast<ConstantStr_t>(string)->m_value);

str = std::string(down_cast<ConstantStr_t>(string_literal)->m_value);

str1 = str1 + str;

tmp = make_ConstantStr_t(al, l, LCompilers::s2c(al, str1), nullptr);

} else if (is_a<JoinedStr_t>(*string)

&& is_a<JoinedStr_t>(*string_literal)) {

JoinedStr_t *t = down_cast<JoinedStr_t>(string);

for (size_t i = 0; i < t->n_values; i++) {

exprs.push_back(al, t->m_values[i]);

}

t = down_cast<JoinedStr_t>(string_literal);

for (size_t i = 0; i < t->n_values; i++) {

exprs.push_back(al, t->m_values[i]);

}

tmp = make_JoinedStr_t(al, l, exprs.p, exprs.size());

} else if (is_a<JoinedStr_t>(*string)

&& is_a<ConstantStr_t>(*string_literal)) {

JoinedStr_t *t = down_cast<JoinedStr_t>(string);

for (size_t i = 0; i < t->n_values; i++) {

exprs.push_back(al, t->m_values[i]);

}

exprs.push_back(al, string_literal);

tmp = make_JoinedStr_t(al, l, exprs.p, exprs.size());

} else if (is_a<ConstantStr_t>(*string)

&& is_a<JoinedStr_t>(*string_literal)) {

exprs.push_back(al, string);

JoinedStr_t *t = down_cast<JoinedStr_t>(string_literal);

for (size_t i = 0; i < t->n_values; i++) {

exprs.push_back(al, t->m_values[i]);

}

tmp = make_JoinedStr_t(al, l, exprs.p, exprs.size());

} else if (is_a<ConstantBytes_t>(*string)

&& is_a<ConstantBytes_t>(*string_literal)) {

str1 = std::string(down_cast<ConstantBytes_t>(string)->m_value);

str1 = str1.substr(0, str1.size() - 1);

str = std::string(down_cast<ConstantBytes_t>(string_literal)->m_value);

str = str.substr(2, str.size());

str1 = str1 + str;

tmp = make_ConstantBytes_t(al, l, LCompilers::s2c(al, str1), nullptr);

} else {

throw LCompilers::LPython::parser_local::ParserError(

"The byte and non-byte literals can not be combined", l);

}

} else {

if (is_a<ConstantStr_t>(*string)) {

str1 = std::string(down_cast<ConstantStr_t>(string)->m_value);

str1 = str1 + str;

tmp = make_ConstantStr_t(al, l, LCompilers::s2c(al, str1), nullptr);

} else if (is_a<JoinedStr_t>(*string)) {

JoinedStr_t *t = down_cast<JoinedStr_t>(string);

for (size_t i = 0; i < t->n_values; i++) {

exprs.push_back(al, t->m_values[i]);

}

exprs.push_back(al, (expr_t *)make_ConstantStr_t(al, l,

LCompilers::s2c(al, str), nullptr));

tmp = make_JoinedStr_t(al, l, exprs.p, exprs.size());

} else {

LCOMPILERS_ASSERT(false);

}

}

return tmp;

}

#define SYMBOL(x, l) make_Name_t(p.m_a, l, \

x.c_str(p.m_a), expr_contextType::Load)

#define INTEGER(x, l) make_ConstantInt_t(p.m_a, l, x, nullptr)

#define STRING1(x, l) make_ConstantStr_t(p.m_a, l, str_unescape_c(p.m_a, x), nullptr)

#define STRING2(x, y, l) concat_string(p.m_a, l, EXPR(x), str_unescape_c(p.m_a, y), nullptr)

#define STRING3(prefix, x, l) PREFIX_STRING(p.m_a, l, prefix.c_str(p.m_a), x.c_str(p.m_a))

#define STRING4(x, s, l) concat_string(p.m_a, l, EXPR(x), "", EXPR(s))

#define FLOAT(x, l) make_ConstantFloat_t(p.m_a, l, x, nullptr)

#define COMPLEX(x, l) make_ConstantComplex_t(p.m_a, l, 0, x, nullptr)

#define BOOL(x, l) make_ConstantBool_t(p.m_a, l, x, nullptr)

static inline ast_t *PREFIX_STRING(Allocator &al, Location &l, char *prefix, char *s){

Vec<expr_t *> exprs;

exprs.reserve(al, 4);

ast_t *tmp = nullptr;

if (strcmp(prefix, "U") == 0 ) {

return make_ConstantStr_t(al, l, s, nullptr);

}

for (size_t i = 0; i < strlen(prefix); i++) {

prefix[i] = tolower(prefix[i]);

}

if (strcmp(prefix, "f") == 0 || strcmp(prefix, "fr") == 0

|| strcmp(prefix, "rf") == 0) {

std::string str = std::string(s);

std::string s1 = "\"";

std::string id;

std::vector<std::string> strs;

bool open_paren = false;

for (size_t i = 0; i < str.length(); i++) {

if(str[i] == '{') {

if(s1 != "\"") {

s1.push_back('"');

strs.push_back(s1);

s1 = "\"";

}

open_paren = true;

} else if (str[i] != '}' && open_paren) {

id.push_back(s[i]);

} else if (str[i] == '}') {

if(id != "") {

strs.push_back(id);

id = "";

}

open_paren = false;

} else if (!open_paren) {

s1.push_back(s[i]);

}

if(i == str.length()-1 && s1 != "\"") {

s1.push_back('"');

strs.push_back(s1);

}

}

for (size_t i = 0; i < strs.size(); i++) {

if (strs[i][0] == '"') {

strs[i] = strs[i].substr(1, strs[i].length() - 2);

tmp = make_ConstantStr_t(al, l, LCompilers::s2c(al, strs[i]), nullptr);

exprs.push_back(al, down_cast<expr_t>(tmp));

} else {

tmp = make_Name_t(al, l,

LCompilers::s2c(al, strs[i]), expr_contextType::Load);

tmp = make_FormattedValue_t(al, l, EXPR(tmp), -1, nullptr);

exprs.push_back(al, down_cast<expr_t>(tmp));

}

}

tmp = make_JoinedStr_t(al, l, exprs.p, exprs.size());

} else if (strcmp(prefix, "b") == 0) {

LCompilers::Str s_;

s_.from_str(al, std::string(s));

std::string str = std::string(str_unescape_c(al, s_));

str = "b'" + str + "'";

tmp = make_ConstantBytes_t(al, l, LCompilers::s2c(al, str), nullptr);

} else if ( strcmp(prefix, "br") == 0 || strcmp(prefix, "rb") == 0) {

std::string str = std::string(s);

str = "b'" + str + "'";

tmp = make_ConstantBytes_t(al, l, LCompilers::s2c(al, str), nullptr);

} else if (strcmp(prefix, "r") == 0 ) {

tmp = make_ConstantStr_t(al, l, s, nullptr);

} else if (strcmp(prefix, "u") == 0 ) {

tmp = make_ConstantStr_t(al, l, s, LCompilers::s2c(al, "u"));

} else {

throw LCompilers::LCompilersException("The string is not recognized by the parser.");

}

return tmp;

}

static inline keyword_t *CALL_ARG_KW(Allocator &al, Location &l,

char *arg, expr_t* val) {

keyword_t *r = al.allocate<keyword_t>();

r->loc = l;

r->m_arg = arg;

r->m_value = val;

return r;

}

#define CALL_KW_01(arg, val, l) CALL_ARG_KW(p.m_a, l, \

name2char(arg), EXPR(val))

#define CALL_EXPR_01(val, l) CALL_ARG_KW(p.m_a, l, nullptr, EXPR(val))

static inline Kw_or_Star_Arg *KW_OR_EXPR(Allocator &al,

expr_t *expr, keyword_t *kw_arg) {

Kw_or_Star_Arg *r = al.allocate<Kw_or_Star_Arg>();

r->star_arg = expr;

r->kw_arg = kw_arg;

return r;

}

#define CALL_KW_02(id, e, l) KW_OR_EXPR(p.m_a, nullptr, CALL_KW_01(id, e, l))

#define CALL_EXPR_02(e, l) KW_OR_EXPR(p.m_a, EXPR(e), nullptr)

static inline Call_Arg *CALL_ARG(

Allocator &al,

Kw_or_Star_Arg *m_expr_or_kw, size_t n_expr_or_kw,

keyword_t *m_kw, size_t n_kw

) {

Call_Arg *r = al.allocate<Call_Arg>();

Vec<expr_t*> exprs;

exprs.reserve(al, n_expr_or_kw);

Vec<keyword_t> kws;

kws.reserve(al, n_kw);

for (size_t i=0; i<n_expr_or_kw; i++) {

if (m_expr_or_kw[i].star_arg != nullptr) {

exprs.push_back(al, m_expr_or_kw[i].star_arg);

} else if (m_expr_or_kw[i].kw_arg != nullptr) {

kws.push_back(al, *m_expr_or_kw[i].kw_arg);

}

}

for (size_t i=0; i<n_kw; i++) {

kws.push_back(al, m_kw[i]);

}

r->expr.p = exprs.p;

r->expr.n = exprs.n;

r->kw.p = kws.p;

r->kw.n = kws.n;

return r;

}

#define CALL_ARG_00() CALL_ARG(p.m_a, nullptr, 0, nullptr, 0)

#define CALL_ARG_01(exprs) CALL_ARG(p.m_a, exprs.p, exprs.n, nullptr, 0)

#define CALL_ARG_02(kwargs) CALL_ARG(p.m_a, nullptr, 0, kwargs.p, kwargs.n)

#define CALL_ARG_03(exprs, kwargs) CALL_ARG(p.m_a, exprs.p, exprs.n, \

kwargs.p, kwargs.n)

#define CALL_01(func, args, l) make_Call_t(p.m_a, l, \

EXPR(func), args->expr.p, args->expr.n, args->kw.p, args->kw.n)

#define CALL_02(func, comp, l) make_Call_t(p.m_a, l, \

EXPR(func), EXPRS(comp), comp.size(), nullptr, 0)

static inline comprehension_t *COMP(Allocator &al, Location &l,

expr_t *target, expr_t* iter, expr_t **ifs, size_t ifs_size,

int64_t is_async) {

comprehension_t *r = al.allocate<comprehension_t>();

r->loc = l;

r->m_target = target;

r->m_iter = iter;

r->m_ifs = ifs;

r->n_ifs = ifs_size;

r->m_is_async = is_async;

return r;

}

#define COMP_FOR_01(target, iter, l) COMP(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(target, Store)), EXPR(iter), nullptr, 0, 0)

#define COMP_FOR_02(target, iter, ifs, l) COMP(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(target, Store)), EXPR(iter), \

EXPRS(ifs), ifs.size(), 0)

#define COMP_FOR_03(target, iter, l) COMP(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(target, Store)), EXPR(iter), nullptr, 0, 1)

#define COMP_FOR_04(target, iter, ifs, l) COMP(p.m_a, l, \

EXPR(SET_EXPR_CTX_01(target, Store)), EXPR(iter), \

EXPRS(ifs), ifs.size(), 1)

#define GENERATOR_EXPR(elt, generators, l) make_GeneratorExp_t(p.m_a, l, \

EXPR(elt), generators.p, generators.n)

#define LIST(e, l) make_List_t(p.m_a, l, \

EXPRS(e), e.size(), expr_contextType::Load)

#define ATTRIBUTE_REF(val, attr, l) make_Attribute_t(p.m_a, l, \

EXPR(val), name2char(attr), expr_contextType::Load)

static inline ast_t* ID_TUPLE_02(Allocator &al, Location &l, Vec<ast_t*> elts) {

if(is_a<expr_t>(*elts[0]) && elts.size() == 1) {

return (ast_t*) SET_EXPR_CTX_01(elts[0], Store);

}

return make_Tuple_t(al, l, EXPRS(SET_EXPR_CTX_02(SET_CTX_02(elts, Store), Store)),

elts.size(), expr_contextType::Store);

}

#define ID_TUPLE_01(elts, l) ID_TUPLE_02(p.m_a, l, elts)

#define ID_TUPLE_03(elts, l) make_Tuple_t(p.m_a, l, \

EXPRS(SET_EXPR_CTX_02(SET_CTX_02(elts, Store), Store)), elts.size(), \

expr_contextType::Store)

#define LIST_COMP_1(expr, generators, l) make_ListComp_t(p.m_a, l, \

EXPR(expr), generators.p, generators.n)

#define SET_COMP_1(expr, generators, l) make_SetComp_t(p.m_a, l, \

EXPR(expr), generators.p, generators.n)

#define DICT_COMP_1(key, val, generators, l) make_DictComp_t(p.m_a, l, \

EXPR(key), EXPR(val), generators.p, generators.n)

#define COMP_EXPR_1(expr, generators, l) make_GeneratorExp_t(p.m_a, l, \

EXPR(expr), generators.p, generators.n)

#define ELLIPSIS(l) make_ConstantEllipsis_t(p.m_a, l, nullptr)