static AST block() {
Token *t = &tok;
AST a=0;
AST vdl, fdl, sts;
vdl = new_list(nVARDECLS);
fdl = new_list(nFUNCDECLS);
if(t->sym == '{') {
gettoken();
enter_block();
vardecls(vdl,fdl);
funcdecls(fdl);
sts = stmts();
a = make_AST(nBLOCK, vdl, fdl, sts, 0);
leave_block();
if (t->sym == '}') gettoken();
else parse_error("expected }");
} else {
parse_error("expected {");
}
return a;
}
static AST classdecl() {
Token *t = &tok;
AST a=0;
AST a1=0, a2=0, a3=0, a4 = 0, a5 = 0;
AST sdl = 0, vdl=0, fdl=0; /* struct, var and func decl list */
a1 = classhead();
if (t->sym == '{') {
gettoken();
enter_block();
sdl = new_list(nSTRUCTS);
vdl = new_list(nVARDECLS);
fdl = new_list(nFUNCDECLS);
a2 = structdecls(sdl);
if (t->sym == tCLASS) a3 = classdecls();
a4 = vardecls(vdl, fdl);
a5 = funcdecls(fdl);
leave_block();
if (t->sym == '}') {
gettoken();
a = make_AST(nCLASSBODY, a2, a3, a4, a5);
a = make_AST(nCLASSDECL, a1, a, 0, 0);
} else {
parse_error("expected }");
}
} else {
parse_error("expected {");
}
return a;
}
bn128_GT bn128_final_exponentiation(const bn128_Fq12 &elt)
{
enter_block("Call to bn128_final_exponentiation");
bn128_GT eltcopy = elt;
eltcopy.elem.final_exp();
leave_block("Call to bn128_final_exponentiation");
return eltcopy;
}
bn128_ate_G1_precomp bn128_ate_precompute_G1(const bn128_G1& P)
{
enter_block("Call to bn128_ate_precompute_G1");
bn128_ate_G1_precomp result;
bn::ecop::NormalizeJac(result.P, P.coord);
leave_block("Call to bn128_ate_precompute_G1");
return result;
}
bn128_ate_G2_precomp bn128_ate_precompute_G2(const bn128_G2& Q)
{
enter_block("Call to bn128_ate_precompute_G2");
bn128_ate_G2_precomp result;
bn::ecop::NormalizeJac(result.Q, Q.coord);
Fp2 T[3];
T[0] = result.Q[0];
T[1] = result.Q[1];
T[2] = Fp2(1);
Fp6 d;
doubling_step_for_flipped_miller_loop(T, d);
result.coeffs.emplace_back(d);
Fp6 e;
assert(Param::siTbl[1] == 1);
mixed_addition_step_for_flipped_miller_loop(result.Q, T, e);
result.coeffs.emplace_back(e);
bn::Fp6 l;
// 844kclk
for (size_t i = 2; i < Param::siTblNum; i++) {
doubling_step_for_flipped_miller_loop(T, l);
result.coeffs.emplace_back(l);
if (Param::siTbl[i]) {
mixed_addition_step_for_flipped_miller_loop(result.Q, T, l);
result.coeffs.emplace_back(l);
}
}
// addition step
Fp2 Q1[2];
bn::ecop::FrobEndOnTwist_1(Q1, result.Q);
Fp2 Q2[2];
bn::ecop::FrobEndOnTwist_2(Q2, result.Q);
Fp2::neg(Q2[1], Q2[1]);
// @memo z < 0
if (0)
{
bn::Fp2::neg(T[1], T[1]);
}
mixed_addition_step_for_flipped_miller_loop(Q1, T, d);
result.coeffs.emplace_back(d);
mixed_addition_step_for_flipped_miller_loop(Q2, T, e);
result.coeffs.emplace_back(e);
leave_block("Call to bn128_ate_precompute_G2");
return result;
}
void new_block_table (astree *block_node) {
for (auto &i : block_node->children) {
switch(i->symbol) {
case (TOK_VARDECL):
new_var_table(i);
break;
case (TOK_BLOCK): {
symbol_table *iblock = enter_block();
idents.push_back(iblock);
new_block_table(i);
exit_block();
break;
}
default:
break;
}
}
block_node->checked = true;
}
// Table for newly found function
void new_fn_table (astree *fn_node) {
if (fn_node == NULL || fn_node->children.empty()) return;
astree *type_node = fn_node->children[0];
if (type_node == NULL || type_node->children.empty()) return;
astree *name_node = type_node->children[0];
if (name_node == NULL) return;
astree *params_node = fn_node->children[1];
if (params_node == NULL) return;
astree *fnblock_node = fn_node->children[2];
if (fnblock_node == NULL) return;
symbol *fn_symbol = new_symbol(fn_node);
if (fn_symbol == NULL) return;
fn_symbol->attributes.set(ATTR_function);
fn_symbol->parameters = new vector<symbol*>();
symbol_dump(fn_symbol, (string *)name_node->clexinfo);
// new block
symbol_table *fn_table = enter_block();
idents.push_back(fn_table);
fprintf(oil_file, "%s __%s (\n", type_node->clexinfo->c_str(),
name_node->clexinfo->c_str());
// parameters
for (auto ¶m_type : params_node->children) {
new_fn_parameter(param_type, fn_table, fn_symbol);
if (param_type == params_node->children.back()) {
fprintf(oil_file, ")\n");
} else {
fprintf(oil_file, ",\n");
}
}
fprintf(oil_file, "{\n");
// block
new_block_table(fnblock_node);
exit_block();
sym_insertion(idents[blockstack.back()],
fn_symbol, (string*)name_node->clexinfo);
fn_node->checked = true;
fprintf(oil_file, "{\n");
}
static AST structdecl(){
Token *t = &tok;
AST struct_name = structname();
insert_SYM(get_text(struct_name), 0, tGLOBAL, 0); /* dummy */
AST a = new_list(nVARDECLS);
if (t->sym == '{'){
enter_block();
gettoken();
a = vardecls(a, 0);
leave_block();
if (t->sym == '}') gettoken();
else parse_error("Expected }");
if (t->sym == ';') gettoken();
else parse_error("Expected ;");
a = make_AST_structdecl(struct_name, a);
} else {
parse_error("Expected {");
}
return a;
}
// Perform a DFS traversal of passed in astree.
void fn_names_traversal (astree *root) {
if (root == NULL) return;
if (root->children.empty()) {
return;
} else {
for (auto &child : root->children) {
if (child->checked) continue;
switch(child->symbol) {
case TOK_STRUCT: new_type_table(child); break;
case TOK_FUNCTION: new_fn_table(child); break;
case TOK_VARDECL: new_var_table(child); break;
case TOK_BLOCK: {
symbol_table *iblock = enter_block();
idents.push_back(iblock);
new_block_table(child);
exit_block();
break;
}
}
fn_names_traversal(child);
}
}
}
