mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-20 19:40:18 +00:00
remove *.cpp
This commit is contained in:
blueloveTH
parent
140255650d
commit
f3d876c5ef
File diff suppressed because it is too large
Load Diff
@ -1,778 +0,0 @@
|
||||
#include "pocketpy/compiler/expr.hpp"
|
||||
#include "pocketpy/interpreter/vm.hpp"
|
||||
#include "pocketpy/objects/codeobject.h"
|
||||
#include "pocketpy/objects/public.h"
|
||||
|
||||
namespace pkpy {
|
||||
|
||||
inline bool is_identifier(std::string_view s) {
|
||||
if(s.empty()) return false;
|
||||
if(!isalpha(s[0]) && s[0] != '_') return false;
|
||||
for(char c: s)
|
||||
if(!isalnum(c) && c != '_') return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
inline bool is_small_int(i64 value) { return value >= INT16_MIN && value <= INT16_MAX; }
|
||||
|
||||
int CodeEmitContext::get_loop() const noexcept{
|
||||
int index = curr_iblock;
|
||||
while(index >= 0) {
|
||||
CodeBlock* block = c11__at(CodeBlock, &co->blocks, index);
|
||||
if(block->type == CodeBlockType_FOR_LOOP) break;
|
||||
if(block->type == CodeBlockType_WHILE_LOOP) break;
|
||||
index = block->parent;
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
CodeBlock* CodeEmitContext::enter_block(CodeBlockType type) noexcept{
|
||||
CodeBlock block = {type, curr_iblock, co->codes.count, -1, -1};
|
||||
c11_vector__push(CodeBlock, &co->blocks, block);
|
||||
curr_iblock = co->blocks.count - 1;
|
||||
return c11__at(CodeBlock, &co->blocks, curr_iblock);
|
||||
}
|
||||
|
||||
void CodeEmitContext::exit_block() noexcept{
|
||||
CodeBlock* block = c11__at(CodeBlock, &co->blocks, curr_iblock);
|
||||
CodeBlockType curr_type = block->type;
|
||||
block->end = co->codes.count;
|
||||
curr_iblock = block->parent;
|
||||
assert(curr_iblock >= 0);
|
||||
if(curr_type == CodeBlockType_FOR_LOOP) {
|
||||
// add a no op here to make block check work
|
||||
emit_(OP_NO_OP, BC_NOARG, BC_KEEPLINE, true);
|
||||
}
|
||||
}
|
||||
|
||||
void CodeEmitContext::s_emit_decorators(int count) noexcept{
|
||||
assert(s_size() >= count);
|
||||
// [obj]
|
||||
for(int i=0; i<count; i++) {
|
||||
Expr* deco = s_popx();
|
||||
deco->emit_(this); // [obj, f]
|
||||
emit_(OP_ROT_TWO, BC_NOARG, deco->line); // [f, obj]
|
||||
emit_(OP_LOAD_NULL, BC_NOARG, BC_KEEPLINE); // [f, obj, NULL]
|
||||
emit_(OP_ROT_TWO, BC_NOARG, BC_KEEPLINE); // [obj, NULL, f]
|
||||
emit_(OP_CALL, 1, deco->line); // [obj]
|
||||
delete_expr(deco);
|
||||
}
|
||||
}
|
||||
|
||||
int CodeEmitContext::emit_(Opcode opcode, uint16_t arg, int line, bool is_virtual) noexcept{
|
||||
c11_vector__push(Bytecode, &co->codes, (Bytecode{(uint8_t)opcode, arg}));
|
||||
c11_vector__push(BytecodeEx, &co->codes_ex, (BytecodeEx{line, is_virtual, curr_iblock}));
|
||||
int i = co->codes.count - 1;
|
||||
BytecodeEx* codes_ex = (BytecodeEx*)co->codes_ex.data;
|
||||
if(line == BC_KEEPLINE) {
|
||||
codes_ex[i].lineno = i>=1 ? codes_ex[i-1].lineno : 1;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
void CodeEmitContext::revert_last_emit_() noexcept{
|
||||
c11_vector__pop(&co->codes);
|
||||
c11_vector__pop(&co->codes_ex);
|
||||
}
|
||||
|
||||
void CodeEmitContext::try_merge_for_iter_store(int i) noexcept{
|
||||
// [FOR_ITER, STORE_?, ]
|
||||
Bytecode* co_codes = (Bytecode*)co->codes.data;
|
||||
if(co_codes[i].op != OP_FOR_ITER) return;
|
||||
if(co->codes.count - i != 2) return;
|
||||
uint16_t arg = co_codes[i + 1].arg;
|
||||
if(co_codes[i + 1].op == OP_STORE_FAST) {
|
||||
revert_last_emit_();
|
||||
co_codes[i].op = OP_FOR_ITER_STORE_FAST;
|
||||
co_codes[i].arg = arg;
|
||||
return;
|
||||
}
|
||||
if(co_codes[i + 1].op == OP_STORE_GLOBAL) {
|
||||
revert_last_emit_();
|
||||
co_codes[i].op = OP_FOR_ITER_STORE_GLOBAL;
|
||||
co_codes[i].arg = arg;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
int CodeEmitContext::emit_int(i64 value, int line) noexcept{
|
||||
if(is_small_int(value)) {
|
||||
return emit_(OP_LOAD_SMALL_INT, (uint16_t)value, line);
|
||||
} else {
|
||||
return emit_(OP_LOAD_CONST, add_const(VAR(value)), line);
|
||||
}
|
||||
}
|
||||
|
||||
void CodeEmitContext::patch_jump(int index) noexcept{
|
||||
Bytecode* co_codes = (Bytecode*)co->codes.data;
|
||||
int target = co->codes.count;
|
||||
Bytecode__set_signed_arg(&co_codes[index], target - index);
|
||||
}
|
||||
|
||||
bool CodeEmitContext::add_label(StrName name) noexcept{
|
||||
bool ok = c11_smallmap_n2i__contains(&co->labels, name.index);
|
||||
if(ok) return false;
|
||||
c11_smallmap_n2i__set(&co->labels, name.index, co->codes.count);
|
||||
return true;
|
||||
}
|
||||
|
||||
int CodeEmitContext::add_varname(StrName name) noexcept{
|
||||
// PK_MAX_CO_VARNAMES will be checked when pop_context(), not here
|
||||
int index = c11_smallmap_n2i__get(&co->varnames_inv, name.index, -1);
|
||||
if(index >= 0) return index;
|
||||
c11_vector__push(uint16_t, &co->varnames, name.index);
|
||||
co->nlocals++;
|
||||
index = co->varnames.count - 1;
|
||||
c11_smallmap_n2i__set(&co->varnames_inv, name.index, index);
|
||||
return index;
|
||||
}
|
||||
|
||||
int CodeEmitContext::add_const_string(std::string_view key) noexcept{
|
||||
uint16_t* val = c11_smallmap_s2n__try_get(&_co_consts_string_dedup_map, {key.data(), (int)key.size()});
|
||||
if(val) {
|
||||
return *val;
|
||||
} else {
|
||||
// co->consts.push_back(VAR(key));
|
||||
c11_vector__push(PyVar, &co->consts, VAR(key));
|
||||
int index = co->consts.count - 1;
|
||||
key = c11__getitem(PyVar, &co->consts, index).obj_get<Str>().sv();
|
||||
c11_smallmap_s2n__set(&_co_consts_string_dedup_map, {key.data(), (int)key.size()}, index);
|
||||
return index;
|
||||
}
|
||||
}
|
||||
|
||||
int CodeEmitContext::add_const(PyVar v) noexcept{
|
||||
assert(!is_type(v, VM::tp_str));
|
||||
c11_vector__push(PyVar, &co->consts, v);
|
||||
return co->consts.count - 1;
|
||||
}
|
||||
|
||||
void CodeEmitContext::emit_store_name(NameScope scope, StrName name, int line) noexcept{
|
||||
switch(scope) {
|
||||
case NAME_LOCAL: emit_(OP_STORE_FAST, add_varname(name), line); break;
|
||||
case NAME_GLOBAL: emit_(OP_STORE_GLOBAL, StrName(name).index, line); break;
|
||||
case NAME_GLOBAL_UNKNOWN: emit_(OP_STORE_NAME, StrName(name).index, line); break;
|
||||
default: assert(false); break;
|
||||
}
|
||||
}
|
||||
|
||||
void NameExpr::emit_(CodeEmitContext* ctx) {
|
||||
int index = c11_smallmap_n2i__get(&ctx->co->varnames_inv, name.index, -1);
|
||||
if(scope == NAME_LOCAL && index >= 0) {
|
||||
ctx->emit_(OP_LOAD_FAST, index, line);
|
||||
} else {
|
||||
Opcode op = ctx->level <= 1 ? OP_LOAD_GLOBAL : OP_LOAD_NONLOCAL;
|
||||
if(ctx->is_compiling_class && scope == NAME_GLOBAL) {
|
||||
// if we are compiling a class, we should use OP_LOAD_ATTR_GLOBAL instead of OP_LOAD_GLOBAL
|
||||
// this supports @property.setter
|
||||
op = OP_LOAD_CLASS_GLOBAL;
|
||||
// exec()/eval() won't work with OP_LOAD_ATTR_GLOBAL in class body
|
||||
} else {
|
||||
// we cannot determine the scope when calling exec()/eval()
|
||||
if(scope == NAME_GLOBAL_UNKNOWN) op = OP_LOAD_NAME;
|
||||
}
|
||||
ctx->emit_(op, StrName(name).index, line);
|
||||
}
|
||||
}
|
||||
|
||||
bool NameExpr::emit_del(CodeEmitContext* ctx) {
|
||||
switch(scope) {
|
||||
case NAME_LOCAL: ctx->emit_(OP_DELETE_FAST, ctx->add_varname(name), line); break;
|
||||
case NAME_GLOBAL: ctx->emit_(OP_DELETE_GLOBAL, StrName(name).index, line); break;
|
||||
case NAME_GLOBAL_UNKNOWN: ctx->emit_(OP_DELETE_NAME, StrName(name).index, line); break;
|
||||
default: assert(false); break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NameExpr::emit_store(CodeEmitContext* ctx) {
|
||||
if(ctx->is_compiling_class) {
|
||||
ctx->emit_(OP_STORE_CLASS_ATTR, name.index, line);
|
||||
return true;
|
||||
}
|
||||
ctx->emit_store_name(scope, name, line);
|
||||
return true;
|
||||
}
|
||||
|
||||
void InvertExpr::emit_(CodeEmitContext* ctx) {
|
||||
child->emit_(ctx);
|
||||
ctx->emit_(OP_UNARY_INVERT, BC_NOARG, line);
|
||||
}
|
||||
|
||||
void StarredExpr::emit_(CodeEmitContext* ctx) {
|
||||
child->emit_(ctx);
|
||||
ctx->emit_(OP_UNARY_STAR, level, line);
|
||||
}
|
||||
|
||||
bool StarredExpr::emit_store(CodeEmitContext* ctx) {
|
||||
if(level != 1) return false;
|
||||
// simply proxy to child
|
||||
return child->emit_store(ctx);
|
||||
}
|
||||
|
||||
void NotExpr::emit_(CodeEmitContext* ctx) {
|
||||
child->emit_(ctx);
|
||||
ctx->emit_(OP_UNARY_NOT, BC_NOARG, line);
|
||||
}
|
||||
|
||||
void AndExpr::emit_(CodeEmitContext* ctx) {
|
||||
lhs->emit_(ctx);
|
||||
int patch = ctx->emit_(OP_JUMP_IF_FALSE_OR_POP, BC_NOARG, line);
|
||||
rhs->emit_(ctx);
|
||||
ctx->patch_jump(patch);
|
||||
}
|
||||
|
||||
void OrExpr::emit_(CodeEmitContext* ctx) {
|
||||
lhs->emit_(ctx);
|
||||
int patch = ctx->emit_(OP_JUMP_IF_TRUE_OR_POP, BC_NOARG, line);
|
||||
rhs->emit_(ctx);
|
||||
ctx->patch_jump(patch);
|
||||
}
|
||||
|
||||
void Literal0Expr::emit_(CodeEmitContext* ctx) {
|
||||
switch(token) {
|
||||
case TK_NONE: ctx->emit_(OP_LOAD_NONE, BC_NOARG, line); break;
|
||||
case TK_TRUE: ctx->emit_(OP_LOAD_TRUE, BC_NOARG, line); break;
|
||||
case TK_FALSE: ctx->emit_(OP_LOAD_FALSE, BC_NOARG, line); break;
|
||||
case TK_DOTDOTDOT: ctx->emit_(OP_LOAD_ELLIPSIS, BC_NOARG, line); break;
|
||||
default: assert(false);
|
||||
}
|
||||
}
|
||||
|
||||
void LongExpr::emit_(CodeEmitContext* ctx) {
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const_string(s.sv()), line);
|
||||
ctx->emit_(OP_BUILD_LONG, BC_NOARG, line);
|
||||
}
|
||||
|
||||
void ImagExpr::emit_(CodeEmitContext* ctx) {
|
||||
VM* vm = ctx->vm;
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const(VAR(value)), line);
|
||||
ctx->emit_(OP_BUILD_IMAG, BC_NOARG, line);
|
||||
}
|
||||
|
||||
void BytesExpr::emit_(CodeEmitContext* ctx) {
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const_string(s.sv()), line);
|
||||
ctx->emit_(OP_BUILD_BYTES, BC_NOARG, line);
|
||||
}
|
||||
|
||||
void LiteralExpr::emit_(CodeEmitContext* ctx) {
|
||||
VM* vm = ctx->vm;
|
||||
if(std::holds_alternative<i64>(value)) {
|
||||
i64 _val = std::get<i64>(value);
|
||||
ctx->emit_int(_val, line);
|
||||
return;
|
||||
}
|
||||
if(std::holds_alternative<f64>(value)) {
|
||||
f64 _val = std::get<f64>(value);
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const(VAR(_val)), line);
|
||||
return;
|
||||
}
|
||||
if(std::holds_alternative<Str>(value)) {
|
||||
std::string_view key = std::get<Str>(value).sv();
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const_string(key), line);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void NegatedExpr::emit_(CodeEmitContext* ctx) {
|
||||
VM* vm = ctx->vm;
|
||||
// if child is a int of float, do constant folding
|
||||
if(child->is_literal()) {
|
||||
LiteralExpr* lit = static_cast<LiteralExpr*>(child);
|
||||
if(std::holds_alternative<i64>(lit->value)) {
|
||||
i64 _val = -std::get<i64>(lit->value);
|
||||
ctx->emit_int(_val, line);
|
||||
return;
|
||||
}
|
||||
if(std::holds_alternative<f64>(lit->value)) {
|
||||
f64 _val = -std::get<f64>(lit->value);
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const(VAR(_val)), line);
|
||||
return;
|
||||
}
|
||||
}
|
||||
child->emit_(ctx);
|
||||
ctx->emit_(OP_UNARY_NEGATIVE, BC_NOARG, line);
|
||||
}
|
||||
|
||||
void SliceExpr::emit_(CodeEmitContext* ctx) {
|
||||
if(start) {
|
||||
start->emit_(ctx);
|
||||
} else {
|
||||
ctx->emit_(OP_LOAD_NONE, BC_NOARG, line);
|
||||
}
|
||||
|
||||
if(stop) {
|
||||
stop->emit_(ctx);
|
||||
} else {
|
||||
ctx->emit_(OP_LOAD_NONE, BC_NOARG, line);
|
||||
}
|
||||
|
||||
if(step) {
|
||||
step->emit_(ctx);
|
||||
} else {
|
||||
ctx->emit_(OP_LOAD_NONE, BC_NOARG, line);
|
||||
}
|
||||
|
||||
ctx->emit_(OP_BUILD_SLICE, BC_NOARG, line);
|
||||
}
|
||||
|
||||
void DictItemExpr::emit_(CodeEmitContext* ctx) {
|
||||
if(is_starred()) {
|
||||
assert(key == nullptr);
|
||||
value->emit_(ctx);
|
||||
} else {
|
||||
key->emit_(ctx);
|
||||
value->emit_(ctx);
|
||||
ctx->emit_(OP_BUILD_TUPLE, 2, line);
|
||||
}
|
||||
}
|
||||
|
||||
bool TupleExpr::emit_store(CodeEmitContext* ctx) {
|
||||
// TOS is an iterable
|
||||
// items may contain StarredExpr, we should check it
|
||||
int starred_i = -1;
|
||||
for(int i = 0; i < items.size(); i++) {
|
||||
if(!items[i]->is_starred()) continue;
|
||||
if(starred_i == -1)
|
||||
starred_i = i;
|
||||
else
|
||||
return false; // multiple StarredExpr not allowed
|
||||
}
|
||||
|
||||
if(starred_i == -1) {
|
||||
Bytecode* prev = c11__at(Bytecode, &ctx->co->codes, ctx->co->codes.count - 1);
|
||||
if(prev->op == OP_BUILD_TUPLE && prev->arg == items.size()) {
|
||||
// build tuple and unpack it is meaningless
|
||||
ctx->revert_last_emit_();
|
||||
} else {
|
||||
if(prev->op == OP_FOR_ITER) {
|
||||
prev->op = OP_FOR_ITER_UNPACK;
|
||||
prev->arg = items.size();
|
||||
} else {
|
||||
ctx->emit_(OP_UNPACK_SEQUENCE, items.size(), line);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// starred assignment target must be in a tuple
|
||||
if(items.size() == 1) return false;
|
||||
// starred assignment target must be the last one (differ from cpython)
|
||||
if(starred_i != items.size() - 1) return false;
|
||||
// a,*b = [1,2,3]
|
||||
// stack is [1,2,3] -> [1,[2,3]]
|
||||
ctx->emit_(OP_UNPACK_EX, items.size() - 1, line);
|
||||
}
|
||||
// do reverse emit
|
||||
for(int i = items.size() - 1; i >= 0; i--) {
|
||||
bool ok = items[i]->emit_store(ctx);
|
||||
if(!ok) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TupleExpr::emit_del(CodeEmitContext* ctx) {
|
||||
for(auto& e: items) {
|
||||
bool ok = e->emit_del(ctx);
|
||||
if(!ok) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void CompExpr::emit_(CodeEmitContext* ctx) {
|
||||
ctx->emit_(op0, 0, line);
|
||||
iter->emit_(ctx);
|
||||
ctx->emit_(OP_GET_ITER, BC_NOARG, BC_KEEPLINE);
|
||||
ctx->enter_block(CodeBlockType_FOR_LOOP);
|
||||
int curr_iblock = ctx->curr_iblock;
|
||||
int for_codei = ctx->emit_(OP_FOR_ITER, curr_iblock, BC_KEEPLINE);
|
||||
bool ok = vars->emit_store(ctx);
|
||||
// this error occurs in `vars` instead of this line, but...nevermind
|
||||
assert(ok); // this should raise a SyntaxError, but we just assert it
|
||||
ctx->try_merge_for_iter_store(for_codei);
|
||||
if(cond) {
|
||||
cond->emit_(ctx);
|
||||
int patch = ctx->emit_(OP_POP_JUMP_IF_FALSE, BC_NOARG, BC_KEEPLINE);
|
||||
expr->emit_(ctx);
|
||||
ctx->emit_(op1, BC_NOARG, BC_KEEPLINE);
|
||||
ctx->patch_jump(patch);
|
||||
} else {
|
||||
expr->emit_(ctx);
|
||||
ctx->emit_(op1, BC_NOARG, BC_KEEPLINE);
|
||||
}
|
||||
ctx->emit_(OP_LOOP_CONTINUE, curr_iblock, BC_KEEPLINE);
|
||||
ctx->exit_block();
|
||||
}
|
||||
|
||||
void FStringExpr::_load_simple_expr(CodeEmitContext* ctx, Str expr) {
|
||||
bool repr = false;
|
||||
if(expr.size >= 2 && expr.end()[-2] == '!') {
|
||||
switch(expr.end()[-1]) {
|
||||
case 'r':
|
||||
repr = true;
|
||||
expr = expr.slice(0, expr.size - 2);
|
||||
break;
|
||||
case 's':
|
||||
repr = false;
|
||||
expr = expr.slice(0, expr.size - 2);
|
||||
break;
|
||||
default: break; // nothing happens
|
||||
}
|
||||
}
|
||||
// name or name.name
|
||||
bool is_fastpath = false;
|
||||
if(is_identifier(expr.sv())) {
|
||||
ctx->emit_(OP_LOAD_NAME, StrName(expr.sv()).index, line);
|
||||
is_fastpath = true;
|
||||
} else {
|
||||
int dot = expr.index(".");
|
||||
if(dot > 0) {
|
||||
std::string_view a = expr.sv().substr(0, dot);
|
||||
std::string_view b = expr.sv().substr(dot + 1);
|
||||
if(is_identifier(a) && is_identifier(b)) {
|
||||
ctx->emit_(OP_LOAD_NAME, StrName(a).index, line);
|
||||
ctx->emit_(OP_LOAD_ATTR, StrName(b).index, line);
|
||||
is_fastpath = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(!is_fastpath) {
|
||||
int index = ctx->add_const_string(expr.sv());
|
||||
ctx->emit_(OP_FSTRING_EVAL, index, line);
|
||||
}
|
||||
|
||||
if(repr) { ctx->emit_(OP_REPR, BC_NOARG, line); }
|
||||
}
|
||||
|
||||
static bool is_fmt_valid_char(char c) {
|
||||
switch(c) {
|
||||
// clang-format off
|
||||
case '-': case '=': case '*': case '#': case '@': case '!': case '~':
|
||||
case '<': case '>': case '^':
|
||||
case '.': case 'f': case 'd': case 's':
|
||||
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
|
||||
return true;
|
||||
default: return false;
|
||||
// clang-format on
|
||||
}
|
||||
}
|
||||
|
||||
void FStringExpr::emit_(CodeEmitContext* ctx) {
|
||||
int i = 0; // left index
|
||||
int j = 0; // right index
|
||||
int count = 0; // how many string parts
|
||||
bool flag = false; // true if we are in a expression
|
||||
|
||||
while(j < src.size) {
|
||||
if(flag) {
|
||||
if(src[j] == '}') {
|
||||
// add expression
|
||||
Str expr = src.slice(i, j);
|
||||
// BUG: ':' is not a format specifier in f"{stack[2:]}"
|
||||
int conon = expr.index(":");
|
||||
if(conon >= 0) {
|
||||
Str spec = expr.substr(conon + 1);
|
||||
// filter some invalid spec
|
||||
bool ok = true;
|
||||
for(char c: spec)
|
||||
if(!is_fmt_valid_char(c)) {
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
if(ok) {
|
||||
_load_simple_expr(ctx, expr.slice(0, conon));
|
||||
ctx->emit_(OP_FORMAT_STRING, ctx->add_const_string(spec.sv()), line);
|
||||
} else {
|
||||
// ':' is not a spec indicator
|
||||
_load_simple_expr(ctx, expr);
|
||||
}
|
||||
} else {
|
||||
_load_simple_expr(ctx, expr);
|
||||
}
|
||||
flag = false;
|
||||
count++;
|
||||
}
|
||||
} else {
|
||||
if(src[j] == '{') {
|
||||
// look at next char
|
||||
if(j + 1 < src.size && src[j + 1] == '{') {
|
||||
// {{ -> {
|
||||
j++;
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const_string("{"), line);
|
||||
count++;
|
||||
} else {
|
||||
// { -> }
|
||||
flag = true;
|
||||
i = j + 1;
|
||||
}
|
||||
} else if(src[j] == '}') {
|
||||
// look at next char
|
||||
if(j + 1 < src.size && src[j + 1] == '}') {
|
||||
// }} -> }
|
||||
j++;
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const_string("}"), line);
|
||||
count++;
|
||||
} else {
|
||||
// } -> error
|
||||
// throw std::runtime_error("f-string: unexpected }");
|
||||
// just ignore
|
||||
}
|
||||
} else {
|
||||
// literal
|
||||
i = j;
|
||||
while(j < src.size && src[j] != '{' && src[j] != '}')
|
||||
j++;
|
||||
Str literal = src.slice(i, j);
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const_string(literal.sv()), line);
|
||||
count++;
|
||||
continue; // skip j++
|
||||
}
|
||||
}
|
||||
j++;
|
||||
}
|
||||
|
||||
if(flag) {
|
||||
// literal
|
||||
Str literal = src.slice(i, src.size);
|
||||
ctx->emit_(OP_LOAD_CONST, ctx->add_const_string(literal.sv()), line);
|
||||
count++;
|
||||
}
|
||||
|
||||
ctx->emit_(OP_BUILD_STRING, count, line);
|
||||
}
|
||||
|
||||
void SubscrExpr::emit_(CodeEmitContext* ctx) {
|
||||
lhs->emit_(ctx);
|
||||
rhs->emit_(ctx);
|
||||
Bytecode last_bc = c11__getitem(Bytecode, &ctx->co->codes, ctx->co->codes.count-1);
|
||||
if(rhs->is_name() && last_bc.op == OP_LOAD_FAST) {
|
||||
ctx->revert_last_emit_();
|
||||
ctx->emit_(OP_LOAD_SUBSCR_FAST, last_bc.arg, line);
|
||||
} else if(rhs->is_literal() && last_bc.op == OP_LOAD_SMALL_INT) {
|
||||
ctx->revert_last_emit_();
|
||||
ctx->emit_(OP_LOAD_SUBSCR_SMALL_INT, last_bc.arg, line);
|
||||
} else {
|
||||
ctx->emit_(OP_LOAD_SUBSCR, BC_NOARG, line);
|
||||
}
|
||||
}
|
||||
|
||||
bool SubscrExpr::emit_store(CodeEmitContext* ctx) {
|
||||
lhs->emit_(ctx);
|
||||
rhs->emit_(ctx);
|
||||
Bytecode last_bc = c11__getitem(Bytecode, &ctx->co->codes, ctx->co->codes.count-1);
|
||||
if(rhs->is_name() && last_bc.op == OP_LOAD_FAST) {
|
||||
ctx->revert_last_emit_();
|
||||
ctx->emit_(OP_STORE_SUBSCR_FAST, last_bc.arg, line);
|
||||
} else {
|
||||
ctx->emit_(OP_STORE_SUBSCR, BC_NOARG, line);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void SubscrExpr::emit_inplace(CodeEmitContext* ctx) {
|
||||
lhs->emit_(ctx);
|
||||
rhs->emit_(ctx);
|
||||
ctx->emit_(OP_DUP_TOP_TWO, BC_NOARG, line);
|
||||
ctx->emit_(OP_LOAD_SUBSCR, BC_NOARG, line);
|
||||
}
|
||||
|
||||
bool SubscrExpr::emit_store_inplace(CodeEmitContext* ctx) {
|
||||
// [a, b, val] -> [val, a, b]
|
||||
ctx->emit_(OP_ROT_THREE, BC_NOARG, line);
|
||||
ctx->emit_(OP_STORE_SUBSCR, BC_NOARG, line);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool SubscrExpr::emit_del(CodeEmitContext* ctx) {
|
||||
lhs->emit_(ctx);
|
||||
rhs->emit_(ctx);
|
||||
ctx->emit_(OP_DELETE_SUBSCR, BC_NOARG, line);
|
||||
return true;
|
||||
}
|
||||
|
||||
void AttribExpr::emit_(CodeEmitContext* ctx) {
|
||||
child->emit_(ctx);
|
||||
ctx->emit_(OP_LOAD_ATTR, name.index, line);
|
||||
}
|
||||
|
||||
bool AttribExpr::emit_del(CodeEmitContext* ctx) {
|
||||
child->emit_(ctx);
|
||||
ctx->emit_(OP_DELETE_ATTR, name.index, line);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool AttribExpr::emit_store(CodeEmitContext* ctx) {
|
||||
child->emit_(ctx);
|
||||
ctx->emit_(OP_STORE_ATTR, name.index, line);
|
||||
return true;
|
||||
}
|
||||
|
||||
void AttribExpr::emit_method(CodeEmitContext* ctx) {
|
||||
child->emit_(ctx);
|
||||
ctx->emit_(OP_LOAD_METHOD, name.index, line);
|
||||
}
|
||||
|
||||
void AttribExpr::emit_inplace(CodeEmitContext* ctx) {
|
||||
child->emit_(ctx);
|
||||
ctx->emit_(OP_DUP_TOP, BC_NOARG, line);
|
||||
ctx->emit_(OP_LOAD_ATTR, name.index, line);
|
||||
}
|
||||
|
||||
bool AttribExpr::emit_store_inplace(CodeEmitContext* ctx) {
|
||||
// [a, val] -> [val, a]
|
||||
ctx->emit_(OP_ROT_TWO, BC_NOARG, line);
|
||||
ctx->emit_(OP_STORE_ATTR, name.index, line);
|
||||
return true;
|
||||
}
|
||||
|
||||
void CallExpr::emit_(CodeEmitContext* ctx) {
|
||||
bool vargs = false;
|
||||
bool vkwargs = false;
|
||||
for(auto& arg: args)
|
||||
if(arg->is_starred()) vargs = true;
|
||||
for(auto& item: kwargs)
|
||||
if(item.second->is_starred()) vkwargs = true;
|
||||
|
||||
// if callable is a AttrExpr, we should try to use `fast_call` instead of use `boundmethod` proxy
|
||||
if(callable->is_attrib()) {
|
||||
auto p = static_cast<AttribExpr*>(callable);
|
||||
p->emit_method(ctx); // OP_LOAD_METHOD
|
||||
} else {
|
||||
callable->emit_(ctx);
|
||||
ctx->emit_(OP_LOAD_NULL, BC_NOARG, BC_KEEPLINE);
|
||||
}
|
||||
|
||||
if(vargs || vkwargs) {
|
||||
for(auto& item: args)
|
||||
item->emit_(ctx);
|
||||
ctx->emit_(OP_BUILD_TUPLE_UNPACK, (uint16_t)args.size(), line);
|
||||
|
||||
if(!kwargs.empty()) {
|
||||
for(auto& item: kwargs) {
|
||||
if(item.second->is_starred()) {
|
||||
assert(item.second->star_level() == 2);
|
||||
item.second->emit_(ctx);
|
||||
} else {
|
||||
// k=v
|
||||
int index = ctx->add_const_string(item.first.sv());
|
||||
ctx->emit_(OP_LOAD_CONST, index, line);
|
||||
item.second->emit_(ctx);
|
||||
ctx->emit_(OP_BUILD_TUPLE, 2, line);
|
||||
}
|
||||
}
|
||||
ctx->emit_(OP_BUILD_DICT_UNPACK, (int)kwargs.size(), line);
|
||||
ctx->emit_(OP_CALL_TP, 1, line);
|
||||
} else {
|
||||
ctx->emit_(OP_CALL_TP, 0, line);
|
||||
}
|
||||
} else {
|
||||
// vectorcall protocol
|
||||
for(auto& item: args)
|
||||
item->emit_(ctx);
|
||||
for(auto& item: kwargs) {
|
||||
i64 _val = StrName(item.first.sv()).index;
|
||||
ctx->emit_int(_val, line);
|
||||
item.second->emit_(ctx);
|
||||
}
|
||||
int KWARGC = kwargs.size();
|
||||
int ARGC = args.size();
|
||||
ctx->emit_(OP_CALL, (KWARGC << 8) | ARGC, line);
|
||||
}
|
||||
}
|
||||
|
||||
bool BinaryExpr::is_compare() const {
|
||||
switch(op) {
|
||||
case TK_LT:
|
||||
case TK_LE:
|
||||
case TK_EQ:
|
||||
case TK_NE:
|
||||
case TK_GT:
|
||||
case TK_GE: return true;
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
|
||||
void BinaryExpr::_emit_compare(CodeEmitContext* ctx, small_vector_2<int, 8>& jmps) {
|
||||
if(lhs->is_compare()) {
|
||||
static_cast<BinaryExpr*>(lhs)->_emit_compare(ctx, jmps);
|
||||
} else {
|
||||
lhs->emit_(ctx); // [a]
|
||||
}
|
||||
rhs->emit_(ctx); // [a, b]
|
||||
ctx->emit_(OP_DUP_TOP, BC_NOARG, line); // [a, b, b]
|
||||
ctx->emit_(OP_ROT_THREE, BC_NOARG, line); // [b, a, b]
|
||||
switch(op) {
|
||||
case TK_LT: ctx->emit_(OP_COMPARE_LT, BC_NOARG, line); break;
|
||||
case TK_LE: ctx->emit_(OP_COMPARE_LE, BC_NOARG, line); break;
|
||||
case TK_EQ: ctx->emit_(OP_COMPARE_EQ, BC_NOARG, line); break;
|
||||
case TK_NE: ctx->emit_(OP_COMPARE_NE, BC_NOARG, line); break;
|
||||
case TK_GT: ctx->emit_(OP_COMPARE_GT, BC_NOARG, line); break;
|
||||
case TK_GE: ctx->emit_(OP_COMPARE_GE, BC_NOARG, line); break;
|
||||
default: PK_UNREACHABLE()
|
||||
}
|
||||
// [b, RES]
|
||||
int index = ctx->emit_(OP_SHORTCUT_IF_FALSE_OR_POP, BC_NOARG, line);
|
||||
jmps.push_back(index);
|
||||
}
|
||||
|
||||
void BinaryExpr::emit_(CodeEmitContext* ctx) {
|
||||
small_vector_2<int, 8> jmps;
|
||||
if(is_compare() && lhs->is_compare()) {
|
||||
// (a < b) < c
|
||||
static_cast<BinaryExpr*>(lhs)->_emit_compare(ctx, jmps);
|
||||
// [b, RES]
|
||||
} else {
|
||||
// (1 + 2) < c
|
||||
if(inplace) {
|
||||
lhs->emit_inplace(ctx);
|
||||
} else {
|
||||
lhs->emit_(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
rhs->emit_(ctx);
|
||||
switch(op) {
|
||||
case TK_ADD: ctx->emit_(OP_BINARY_ADD, BC_NOARG, line); break;
|
||||
case TK_SUB: ctx->emit_(OP_BINARY_SUB, BC_NOARG, line); break;
|
||||
case TK_MUL: ctx->emit_(OP_BINARY_MUL, BC_NOARG, line); break;
|
||||
case TK_DIV: ctx->emit_(OP_BINARY_TRUEDIV, BC_NOARG, line); break;
|
||||
case TK_FLOORDIV: ctx->emit_(OP_BINARY_FLOORDIV, BC_NOARG, line); break;
|
||||
case TK_MOD: ctx->emit_(OP_BINARY_MOD, BC_NOARG, line); break;
|
||||
case TK_POW: ctx->emit_(OP_BINARY_POW, BC_NOARG, line); break;
|
||||
|
||||
case TK_LT: ctx->emit_(OP_COMPARE_LT, BC_NOARG, line); break;
|
||||
case TK_LE: ctx->emit_(OP_COMPARE_LE, BC_NOARG, line); break;
|
||||
case TK_EQ: ctx->emit_(OP_COMPARE_EQ, BC_NOARG, line); break;
|
||||
case TK_NE: ctx->emit_(OP_COMPARE_NE, BC_NOARG, line); break;
|
||||
case TK_GT: ctx->emit_(OP_COMPARE_GT, BC_NOARG, line); break;
|
||||
case TK_GE: ctx->emit_(OP_COMPARE_GE, BC_NOARG, line); break;
|
||||
|
||||
case TK_IN: ctx->emit_(OP_CONTAINS_OP, 0, line); break;
|
||||
case TK_NOT_IN: ctx->emit_(OP_CONTAINS_OP, 1, line); break;
|
||||
case TK_IS: ctx->emit_(OP_IS_OP, BC_NOARG, line); break;
|
||||
case TK_IS_NOT: ctx->emit_(OP_IS_NOT_OP, BC_NOARG, line); break;
|
||||
|
||||
case TK_LSHIFT: ctx->emit_(OP_BITWISE_LSHIFT, BC_NOARG, line); break;
|
||||
case TK_RSHIFT: ctx->emit_(OP_BITWISE_RSHIFT, BC_NOARG, line); break;
|
||||
case TK_AND: ctx->emit_(OP_BITWISE_AND, BC_NOARG, line); break;
|
||||
case TK_OR: ctx->emit_(OP_BITWISE_OR, BC_NOARG, line); break;
|
||||
case TK_XOR: ctx->emit_(OP_BITWISE_XOR, BC_NOARG, line); break;
|
||||
|
||||
case TK_DECORATOR: ctx->emit_(OP_BINARY_MATMUL, BC_NOARG, line); break;
|
||||
default: PK_FATAL_ERROR("unknown binary operator: %s\n", pk_TokenSymbols[op]);
|
||||
}
|
||||
|
||||
for(int i: jmps)
|
||||
ctx->patch_jump(i);
|
||||
}
|
||||
|
||||
void TernaryExpr::emit_(CodeEmitContext* ctx) {
|
||||
cond->emit_(ctx);
|
||||
int patch = ctx->emit_(OP_POP_JUMP_IF_FALSE, BC_NOARG, cond->line);
|
||||
true_expr->emit_(ctx);
|
||||
int patch_2 = ctx->emit_(OP_JUMP_FORWARD, BC_NOARG, true_expr->line);
|
||||
ctx->patch_jump(patch);
|
||||
false_expr->emit_(ctx);
|
||||
ctx->patch_jump(patch_2);
|
||||
}
|
||||
|
||||
} // namespace pkpy
|
||||
Loading…
x
Reference in New Issue
Block a user