test.fc

;;; funcpp arguments: --TestDef=123 test.fcp -
;;; #define Outer 1
;;; #define Inner 0

;;; #include "test_inc.fc";

;;; ##### BEGIN INCLUDE test_inc.fc #####

;; This is an included file
;;; #define Inner 2;
;; This is an end of included file

;;; ##### END INCLUDE test_inc.fc #####


;;; #flag 1 IsOwner IsNotOwner
;;; Internal #define F_IsOwner 1
int .IsOwner?(int a)   asm "1 PUSHINT AND"; ;;; Internal #implicit
int .IsNotOwner?(int a)   asm "1 PUSHINT AND ISZERO"; ;;; Internal #implicit


b = 1; ;;; F_IsOwner=1
if (b.IsOwner?()) ;;; %IsOwner?
    c = b.IsNotOwner?(); ;;; %IsNotOwner?

a = 1 + 2 - OuterInner * Inner:Outer / Outer_Inner; ;;; Outer=1, Inner=2

;;; #accessor 1 seqno int
int _get_seqno_(tuple data) asm "1 INDEX";
(tuple, ()) ~_set_seqno_(tuple data, int value) asm "1 SETINDEX";

m = data._get_seqno_(); ;;; [seqno]

data~_set_seqno_(1); ;;; [~seqno=]
data~_set_seqno_(data._get_seqno_() + 1); ;;; [~seqno?=]

;;; #define deftest

;;; #ifdef deftest
deftest is defined
;;; #else
;;; #endif

anyway

;;; #undef deftest

;;; #ifdef deftest
;;; #else
deftest is not defined
;;; #endif

;;; #define deftest

;;; #ifdef deftest
;;; #ifndef badtest
;;; #dump
;; Defines:
;;   TestDef = 123
;;   Outer = 1
;;   Inner = 2
;;   F_IsOwner = 1
;;   deftest =
;; Implicits
;;   IsOwner?
;;   IsNotOwner?
;; Accessors
;;   seqno
;; Conditional stack
;;   True True
;;; #endif
;;; #endif

;;; #ifeq TestDef 123
good
;;; #endif

;;; #ifneq TestDef 111
good
;;; #endif

;;; #ifeq TestDef abc
;;; #endif

;;; #define Features good,ugly

;;; #ifsub Features good
good feature
;;; #endif

;;; #ifsub Features bad
;;; #endif

;;; #ifsub Features ugly
ugly feature
;;; #endif

;;; #mldefine multiline
;;; this
;;;     is
;;;         multi-line
;;;             define
;;; #end

before
this
    is
        multi-line
            define; ;;; multiline=this\n    is\n        multi-line\n            define
after

;; addr -> (int8 wc, uint256 addr)

;;; #storage
;;; uint8 a_byte;
int _get_a_byte_(tuple data) asm "0 INDEX";
(tuple, ()) ~_set_a_byte_(tuple data, int value) asm "0 SETINDEX";
;;; cell some_cell;
cell _get_some_cell_(tuple data) asm "1 INDEX";
(tuple, ()) ~_set_some_cell_(tuple data, cell value) asm "1 SETINDEX";
;;; uint32 seqno;
int _get_seqno_(tuple data) asm "2 INDEX";
(tuple, ()) ~_set_seqno_(tuple data, int value) asm "2 SETINDEX";
;;; string symbol;
slice _get_symbol_(tuple data) asm "3 INDEX";
(tuple, ()) ~_set_symbol_(tuple data, slice value) asm "3 SETINDEX";
;;; addr owner;
int _get_owner_(tuple data) asm "4 INDEX";
(tuple, ()) ~_set_owner_(tuple data, int value) asm "4 SETINDEX";
int _get_owner_wc_(tuple data) asm "5 INDEX";
(tuple, ()) ~_set_owner_wc_(tuple data, int value) asm "5 SETINDEX";
;;; uint256 owner_key;
int _get_owner_key_(tuple data) asm "6 INDEX";
(tuple, ()) ~_set_owner_key_(tuple data, int value) asm "6 SETINDEX";
;;; dict dictionary;
cell _get_dictionary_(tuple data) asm "7 INDEX";
(tuple, ()) ~_set_dictionary_(tuple data, cell value) asm "7 SETINDEX";
;;; uint24 unusual_int;
int _get_unusual_int_(tuple data) asm "8 INDEX";
(tuple, ()) ~_set_unusual_int_(tuple data, int value) asm "8 SETINDEX";
;;; int16 index;
int _get_index_(tuple data) asm "9 INDEX";
(tuple, ()) ~_set_index_(tuple data, int value) asm "9 SETINDEX";
;;; int8 chain_id;
int _get_chain_id_(tuple data) asm "10 INDEX";
(tuple, ()) ~_set_chain_id_(tuple data, int value) asm "10 SETINDEX";
;;; grams amount;
int _get_amount_(tuple data) asm "11 INDEX";
(tuple, ()) ~_set_amount_(tuple data, int value) asm "11 SETINDEX";
;;; #end
tuple storage_tuple(int v_a_byte, cell v_some_cell, int v_seqno, slice v_symbol, int v_owner, int v_owner_wc, int v_owner_key, cell v_dictionary, int v_unusual_int, int v_index, int v_chain_id, int v_amount) asm "12 TUPLE";
(int, cell, int, slice, int, int, int, cell, int, int, int, int) storage_untuple(tuple data) asm "12 UNTUPLE";
tuple load_data() inline_ref {
    slice cs = get_data().begin_parse();
    int v_a_byte = cs~load_uint(8);
    cell v_some_cell = cs~load_ref();
    int v_seqno = cs~load_uint(32);
    int v_symbol_size = cs~load_uint(8);
    slice v_symbol = cs~load_bits(v_symbol_size * 8);
    int v_owner = cs~load_uint(256);
    int v_owner_wc = cs~load_int(8);
    int v_owner_key = cs~load_uint(256);
    cell v_dictionary = cs~load_dict();
    int v_unusual_int = cs~load_uint(24);
    int v_index = cs~load_int(16);
    int v_chain_id = cs~load_int(8);
    int v_amount = cs~load_grams();
    cs.end_parse();
    return storage_tuple(v_a_byte, v_some_cell, v_seqno, v_symbol, v_owner, v_owner_wc, v_owner_key, v_dictionary, v_unusual_int, v_index, v_chain_id, v_amount);
}
() store_data(tuple data) impure inline_ref {
    (int v_a_byte, cell v_some_cell, int v_seqno, slice v_symbol, int v_owner, int v_owner_wc, int v_owner_key, cell v_dictionary, int v_unusual_int, int v_index, int v_chain_id, int v_amount) = storage_untuple(data);
    builder bld = begin_cell()
            .store_uint(v_a_byte, 8)
            .store_ref(v_some_cell)
            .store_uint(v_seqno, 32)
            .store_uint(v_symbol.slice_bits() / 8, 8)
            .store_slice(v_symbol)
            .store_uint(v_owner, 256)
            .store_int(v_owner_wc, 8)
            .store_uint(v_owner_key, 256)
            .store_dict(v_dictionary)
            .store_uint(v_unusual_int, 24)
            .store_int(v_index, 16)
            .store_int(v_chain_id, 8)
            .store_grams(v_amount)
    ;
    set_data(bld.end_cell());
}

int seqno() method_id {
	return storage_load()._get_seqno_(); ;;; [seqno]
}

int op = 0x4e73744b; ;;; @"NstK"=0x4e73744b

;;; #storage global
;;; uint8 a_byte;
global int g_a_byte;
;;; cell some_cell;
global cell g_some_cell;
;;; uint32 seqno;
global int g_seqno;
;;; string symbol;
global slice g_symbol;
;;; addr owner;
global int g_owner;
global int g_owner_wc;
;;; uint256 owner_key;
global int g_owner_key;
;;; dict dictionary;
global cell g_dictionary;
;;; uint24 unusual_int;
global int g_unusual_int;
;;; int16 index;
global int g_index;
;;; int8 chain_id;
global int g_chain_id;
;;; grams amount;
global int g_amount;
;;; #end
() load_data() inline_ref {
    slice cs = get_data().begin_parse();
    g_a_byte = cs~load_uint(8);
    g_some_cell = cs~load_ref();
    g_seqno = cs~load_uint(32);
    int g_symbol_size = cs~load_uint(8);
    g_symbol = cs~load_bits(g_symbol_size * 8);
    g_owner = cs~load_uint(256);
    g_owner_wc = cs~load_int(8);
    g_owner_key = cs~load_uint(256);
    g_dictionary = cs~load_dict();
    g_unusual_int = cs~load_uint(24);
    g_index = cs~load_int(16);
    g_chain_id = cs~load_int(8);
    g_amount = cs~load_grams();
    cs.end_parse();
}
() store_data(tuple data) impure inline_ref {
    builder bld = begin_cell()
            .store_uint(g_a_byte, 8)
            .store_ref(g_some_cell)
            .store_uint(g_seqno, 32)
            .store_uint(g_symbol.slice_bits() / 8, 8)
            .store_slice(g_symbol)
            .store_uint(g_owner, 256)
            .store_int(g_owner_wc, 8)
            .store_uint(g_owner_key, 256)
            .store_dict(g_dictionary)
            .store_uint(g_unusual_int, 24)
            .store_int(g_index, 16)
            .store_int(g_chain_id, 8)
            .store_grams(g_amount)
    ;
    set_data(bld.end_cell());
}

;;; #storage local
;;; uint256 owner_key;
int _get_local_owner_key_(tuple data) asm "0 INDEX";
(tuple, ()) ~_set_local_owner_key_(tuple data, int value) asm "0 SETINDEX";
;;; addr owner_addr;
int _get_local_owner_addr_(tuple data) asm "1 INDEX";
(tuple, ()) ~_set_local_owner_addr_(tuple data, int value) asm "1 SETINDEX";
int _get_local_owner_addr_wc_(tuple data) asm "2 INDEX";
(tuple, ()) ~_set_local_owner_addr_wc_(tuple data, int value) asm "2 SETINDEX";
;;; uint32 expiry;
int _get_local_expiry_(tuple data) asm "3 INDEX";
(tuple, ()) ~_set_local_expiry_(tuple data, int value) asm "3 SETINDEX";
;;; cell data;
cell _get_local_data_(tuple data) asm "4 INDEX";
(tuple, ()) ~_set_local_data_(tuple data, cell value) asm "4 SETINDEX";
;;; #end
tuple struct_local_tuple(int v_owner_key, int v_owner_addr, int v_owner_addr_wc, int v_expiry, cell v_data) asm "5 TUPLE";
(int, int, int, int, cell) struct_local_untuple(tuple data) asm "5 UNTUPLE";
tuple unpack_local(slice cs) inline_ref {
    int v_owner_key = cs~load_uint(256);
    int v_owner_addr = cs~load_uint(256);
    int v_owner_addr_wc = cs~load_int(8);
    int v_expiry = cs~load_uint(32);
    cell v_data = cs~load_ref();
    cs.end_parse();
    return struct_local_tuple(v_owner_key, v_owner_addr, v_owner_addr_wc, v_expiry, v_data);
}
cell pack_local(tuple data) impure inline_ref {
    (int v_owner_key, int v_owner_addr, int v_owner_addr_wc, int v_expiry, cell v_data) = struct_local_untuple(data);
    builder bld = begin_cell()
            .store_uint(v_owner_key, 256)
            .store_uint(v_owner_addr, 256)
            .store_int(v_owner_addr_wc, 8)
            .store_uint(v_expiry, 32)
            .store_ref(v_data)
    ;
    return bld.end_cell();
}

something~_set_local_expiry_(a + other._get_local_expiry_()); ;;; [~local:expiry=], [local:expiry]

;; Context dependent lookup
some_local~_set_local_owner_key_(other_local._get_local_owner_key_()); ;;; [~local:owner_key=], [local:owner_key]
some_local~_set_local_owner_key_(some_local._get_local_owner_key_() & 0); ;;; [~local:owner_key?=]