Feature/yaml anchor and alias

.github/workflows/main_tests_on_raspberry_pi_os_arm64.yml

@@ -8,14 +8,15 @@ on:
 
 jobs:
   Build-and-Test:
-    runs-on: ubuntu-24.04
+#    runs-on: ubuntu-24.04
+    runs-on: ubuntu-24.04-arm
 
     steps:
       - name: checkout repository
         uses: actions/checkout@v4
 
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+#      - name: Set up QEMU
+#        uses: docker/setup-qemu-action@v3
 
       - name: Install build tools
         run: |

sstd/src/file/yaml.hpp

@@ -14,66 +14,73 @@ namespace sstd_yaml{
     //---
     // operation definition
 
-    const static uint8 ope_null   = 255;
-    const static uint8 ope_alloc  = 0; // allocate
-    const static uint8 ope_stack  = 1; // stacking a value to v_dst
-    const static uint8 ope_assign = 2; // assignemnt
+    const static uint8 ope_null     = 255;
+    const static uint8 ope_alloc    = 0; // allocate
+    const static uint8 ope_stack    = 1; // stacking a value to v_dst
+    const static uint8 ope_assign   = 2; // assignemnt
+//    const static uint8 ope_push_ref = 3; // pushing a reference address to the hash table
+//    const static uint8 ope_pull_ref = 4; // pulling a reference address from the hash table
 
     //---
     // type definition
 
-    // TODO: num_ -> type_ に名前を置換する
+    const static uint8 type_null          = 255;
+    const static uint8 type_str           = 0; // for BLOCK_STYLE
+    const static uint8 type_list          = 1; // for BLOCK_STYLE
+    const static uint8 type_hash          = 2; // for BLOCK_STYLE
+    const static uint8 type_list_and_hash = 3; // for BLOCK_STYLE
 
-    const static uint8 num_null             = 255;
-    const static uint8 num_block_style_base = 0;
-    const static uint8 num_str              = 0; // for BLOCK_STYLE
-    const static uint8 num_list             = 1; // for BLOCK_STYLE
-    const static uint8 num_hash             = 2; // for BLOCK_STYLE
-    const static uint8 num_list_and_hash    = 3; // for BLOCK_STYLE
-    const static uint8 num_flow_style_base  = 4;
-    // sstd_yaml::num_flow_style_base + sstd_yaml::num_str           4 // reserved number for FLOW_STYLE
-    // sstd_yaml::num_flow_style_base + sstd_yaml::num_list          5 // reserved number for FLOW_STYLE
-    // sstd_yaml::num_flow_style_base + sstd_yaml::num_hash          6 // reserved number for FLOW_STYLE
-    // sstd_yaml::num_flow_style_base + sstd_yaml::num_list_and_hash 7 // reserved number for FLOW_STYLE
+    const static uint8 format_null        = 255;
+    const static uint8 format_block_style = 0; // using indents to construct
+    const static uint8 format_flow_style  = 1; // list [] or {}
+
+    const static uint8 ref_type_null      = 255;
+    const static uint8 ref_type_anchor    = 0; // &
+    const static uint8 ref_type_alias     = 1; // *
 
     //---
     // token for proceed YAML parsing
 
     struct token {
         // Data for Debug YAML parsing
-        uint line_num_begin = 1;                       // beginning line number
-        uint line_num_end   = 1;                       // endding line number (for multipleline)
-        std::string rawStr;                            // A raw string splitted by line concering the YAML processing units.
+        uint line_num_begin = 1;                        // beginning line number
+        uint line_num_end   = 1;                        // endding line number (for multipleline)
+        std::string rawStr;                             // A raw string splitted by line concering the YAML processing units.
 
         // Data structure to load YAML
-        //uint type = sstd_yaml::num_null; // sstd_yaml::num_str;                // A destination type number of this line
-        uint type = sstd_yaml::num_str;                // A destination type number of this line
-        uint format = sstd_yaml::num_block_style_base; // If containing flow style notation
-        uint list_type_cnt = 0;                        // Number of list type. (`- - - v`)
-        uint hsc_lx = 0;                               // head space counts for list type
-        uint hsc_hx = 0;                               // head space counts for hash type
+        uint8 type = sstd_yaml::type_str;             // A destination type number of this line
+        uint8 format = sstd_yaml::format_block_style; // If containing flow style notation
+        uint8 ref_type = sstd_yaml::ref_type_null;    // If containing anchor or alias
+        uint list_type_cnt = 0;                       // Number of list type. (`- - - v`)
+        uint hsc_lx = 0;                              // head space counts for list type
+        uint hsc_hx = 0;                              // head space counts for hash type
 
-        bool hasValue = false; // If the value (val1 or val2) is vaild for each data type (list or hash).
-        bool key_is_dqed = false;
-        bool key_is_sqed = false;
-        bool val_is_dqed = false;
-        bool val_is_sqed = false;
+        bool hasValue = false; // If the value (val1 or val2) is vaild for each data type (list or hash)
+        bool key_is_dqed = false; // _dqed: double quated
+        bool key_is_sqed = false; // _sqed: single quated
+        bool val_is_dqed = false; // _dqed: double quated
+        bool val_is_sqed = false; // _sqed: single quated
         bool mult_line_val = false;
         std::string key; // key for "hash"
         std::string val; // value for "list" or "hash"
+        std::string aa_val; // value for anchor and alias
     };
     struct command{
         // Data for Debug YAML parsing
-        uint line_num_begin = 1;                       // beginning line number
-        uint line_num_end   = 1;                       // endding line number (for multipleline)
-        std::string rawStr;                            // A raw string splitted by line concering the YAML processing units.
-
+        uint line_num_begin = 1;                        // beginning line number
+        uint line_num_end   = 1;                        // endding line number (for multipleline)
+        std::string rawStr;                             // A raw string splitted by line concering the YAML processing units.
+        
         // Data structure to construct YAML
         uint ope; // operation
         uint hsc; // hsc: head space count
         uint8 type; // data type
         uint8 format; // data format
         std::string val; // value
+
+        // Anchor and Alias
+        uint8 ref_type = sstd_yaml::ref_type_null;    // If containing anchor or alias
+        std::string aa_val; // anchor and alias value
     };
 
     //---
@@ -102,13 +109,8 @@ namespace sstd_yaml{
 //-----------------------------------------------------------------------------------------------------------------------------------------------
 
 namespace sstd{
-    void print(const sstd_yaml::token& rhs);
-    void for_printn(const sstd_yaml::token& rhs);
-    void print_for_vT(const sstd_yaml::token& rhs);
-
-    void print(const sstd_yaml::command& rhs);
-    void for_printn(const sstd_yaml::command& rhs);
-    void print_for_vT(const sstd_yaml::command& rhs);
+    void print_base(const sstd_yaml::token& rhs);
+    void print_base(const sstd_yaml::command& rhs);
 
     bool yaml_load     (           sstd::terp::var & ret_yml,  const        char* s);
     bool yaml_load     (           sstd::terp::var & ret_yml,  const std::string& s);

sstd/src/memory/terp/terp.cpp

@@ -19,11 +19,6 @@ void _free_val(sstd::terp::var* _pVar, void*& _p, sstd::terp::srcr_tbl* _pSRCR_t
 //-----------------------------------------------------------------------------------------------------------------------------------------------
 // for internal use
 
-// cast
-std::string*                                    _cast2str (void* rhs){ return (                std::string*)rhs; }
-std::vector<sstd::void_ptr>*                    _cast2vec (void* rhs){ return (std::vector<sstd::void_ptr>*)rhs; }
-std::unordered_map<std::string,sstd::void_ptr>* _cast2hash(void* rhs){ return (std::unordered_map<std::string,sstd::void_ptr>*)rhs; }
-
 #define STR (*(std::string*)src.p())
 
 void sstd::terp::_to(     bool  & dst, const sstd::terp::var& src){
@@ -210,7 +205,11 @@ sstd::terp::var::var(        float      rhs): _type(sstd::num_str ), _is_referen
 sstd::terp::var::var(       double      rhs): _type(sstd::num_str ), _is_reference(false), _is_pSRCR_tbl_base(true), _pSRCR_tbl(new sstd::terp::srcr_tbl()), _p(new std::string(sstd::ssprintf(_format(rhs).c_str(), rhs))) {}
 sstd::terp::var::var(const char*        rhs): _type(sstd::num_str ), _is_reference(false), _is_pSRCR_tbl_base(true), _pSRCR_tbl(new sstd::terp::srcr_tbl()), _p(new std::string(rhs)) {}
 sstd::terp::var::var(const std::string& rhs): _type(sstd::num_str ), _is_reference(false), _is_pSRCR_tbl_base(true), _pSRCR_tbl(new sstd::terp::srcr_tbl()), _p(new std::string(rhs)) {}
-sstd::terp::var::var(const sstd::terp::srcr_tbl* rhs): _type(sstd::num_null), _is_reference(false), _is_pSRCR_tbl_base(false), _pSRCR_tbl((sstd::terp::srcr_tbl*)rhs), _p(NULL) {}
+
+sstd::terp::var::var(const sstd::terp::srcr_tbl* tbl                        ): _type(sstd::num_null), _is_reference(false), _is_pSRCR_tbl_base(false), _pSRCR_tbl((sstd::terp::srcr_tbl*)tbl), _p(NULL) {}
+sstd::terp::var::var(const sstd::terp::srcr_tbl* tbl, const class var&   rhs): _type(sstd::num_null), _is_reference(false), _is_pSRCR_tbl_base(false), _pSRCR_tbl((sstd::terp::srcr_tbl*)tbl), _p(NULL) { copy(rhs); }
+sstd::terp::var::var(const sstd::terp::srcr_tbl* tbl,       class var&&  rhs): _type(sstd::num_null), _is_reference(false), _is_pSRCR_tbl_base(false), _pSRCR_tbl((sstd::terp::srcr_tbl*)tbl), _p(NULL) { free(); move(std::move(rhs)); }
+sstd::terp::var::var(const sstd::terp::srcr_tbl* tbl, const char*        rhs): _type(sstd::num_str ), _is_reference(false), _is_pSRCR_tbl_base(false), _pSRCR_tbl((sstd::terp::srcr_tbl*)tbl), _p(new std::string(rhs)) {}
 
 sstd::terp::var::~var(){ sstd::terp::var::free(); }
 
@@ -574,8 +573,8 @@ sstd::terp::var& sstd::terp::var::operator=(const sstd::terp::var* pRhs_in){
 template <typename T>
 void sstd::terp::var::_overwrite(T* ptr){
     _free_val(this, _p, _pSRCR_tbl, _type, _is_reference);
-    this->_type = sstd::type2num(T());
-    this->_p    = ptr;
+    this->_type              = sstd::type2num(T());
+    this->_p                 = ptr;
 }
 sstd::terp::var& sstd::terp::var::operator=(const char* rhs){
     _overwrite(new std::string(rhs));
@@ -614,8 +613,9 @@ bool _is_equal_hash(const sstd::terp::var& lhs, const sstd::terp::var& rhs,
 
         auto itr_rhs = rhs.find(key.c_str());
         if(!(itr_rhs!=rhs.end())){ return false; }
-
-        if(!_is_equal(itr.second(), itr_rhs.second(), check_ref_flag, ref_addr_graph, check_ref_abs_addr, vStack_lhsP_and_rhsP, tbl_lhsAds_to_rhsAds)){ return false; }
+
+        //if(!_is_equal(itr.second(), itr_rhs.second(), check_ref_flag, ref_addr_graph, check_ref_abs_addr, vStack_lhsP_and_rhsP, tbl_lhsAds_to_rhsAds)){ return false; } // This is invalid implimentation. Because the "itr.second()" makes the new temporal object and the address of `pSRCR_tbl()` changed.
+        if(!_is_equal(lhs[key.c_str()], rhs[key.c_str()], check_ref_flag, ref_addr_graph, check_ref_abs_addr, vStack_lhsP_and_rhsP, tbl_lhsAds_to_rhsAds)){ return false; }
     }
 
     return true;
@@ -637,7 +637,7 @@ bool _is_equal(const sstd::terp::var& lhs, const sstd::terp::var& rhs,
     // ├────────────────────────────────┼───────────────────────────────────────────────┼──────────────┤
     // │ sstd::terp::equal_val()        │     true      │    false    │      false      │              │
     // ├────────────────────────────────┼───────────────────────────────────────────────┼──────────────┤
-    // │ sstd::terp::equal_refAbsAddr() │     true      │    true     │      false      │              │
+    // │ sstd::terp::equal_refAbsAddr() │     true      │    true     │      false      │              │ /* <- This is NOT implimented yet */
     // └────────────────────────────────┴───────────────────────────────────────────────┴──────────────┘
     // *1. Options:
     //       true:  sets to check the option
@@ -647,26 +647,28 @@ bool _is_equal(const sstd::terp::var& lhs, const sstd::terp::var& rhs,
     //       ref_flag:       'true' | 'false'
     //       ref_addr_graph: 'true' | 'false'
 
+    if(lhs.type()!=rhs.type()){ return false; }
+
+    if(ref_addr_graph){
+        tbl_lhsAds_to_rhsAds[ (sstd::terp::var*)&lhs ] = (sstd::terp::var*)&rhs;
+    }
     if(check_ref_flag){
         if(lhs.is_reference()!=rhs.is_reference()){ return false; }
         if(lhs.is_reference()){
             bool is_internal_ref_lhs = _is_internal_ref(&lhs);
             bool is_internal_ref_rhs = _is_internal_ref(&rhs);
+
             if(is_internal_ref_lhs != is_internal_ref_rhs){ return false; }
             if(is_internal_ref_lhs){
                 // If the reference is `internal` reference.
                 vStack_lhsP_and_rhsP.push_back( std::make_tuple((sstd::terp::var*)&lhs, (sstd::terp::var*)&rhs) );
+                return true; // Check the `vStack_lhsP_and_rhsP` later. (Just confirm the address consistency is enough.)
             }else{
                 // If the reference is `external` reference.
-                if(lhs.p() != rhs.p()){ sstd::printn_all("");return false; }
+                if(lhs.p() != rhs.p()){ return false; }
             }
         }
     }
-    if(lhs.type()!=rhs.type()){ return false; }
-
-    if(ref_addr_graph){
-        tbl_lhsAds_to_rhsAds[ (sstd::terp::var*)&lhs ] = (sstd::terp::var*)&rhs;
-    }
 
     switch(lhs.typeNum()){
     case sstd::num_str:           { return lhs.to<std::string>()==rhs.to<std::string>(); } break;
@@ -723,9 +725,11 @@ bool sstd::terp::var::operator!=(const sstd::terp::var& rhs){ return !sstd::terp
     }                                                                   \
     return *this;
 #define _OPE_SUBSCRIPT_KEY_BASE(pKey)                                   \
+    void* local_p = (! this->_is_reference) ? _p : (void*)((sstd::terp::var*)_p)->_p; \
+                                                                        \
     switch(_type){                                                      \
     case sstd::num_hash_terp_var: {                                     \
-        sstd::terp::var** ppVal = &(_CAST2HASH(_p)[pKey]);              \
+        sstd::terp::var** ppVal = &(_CAST2HASH(local_p)[pKey]);         \
         if(*ppVal==NULL){ (*ppVal)=new sstd::terp::var(_pSRCR_tbl); }   \
         return **ppVal;                                                 \
     } break;                                                            \
@@ -740,11 +744,13 @@ bool sstd::terp::var::operator!=(const sstd::terp::var& rhs){ return !sstd::terp
     }                                                                   \
     return *this;
 #define _OPE_SUBSCRIPT_KEY_BASE_CONST(pKey)                             \
+    void* local_p = (! this->_is_reference) ? _p : (void*)((sstd::terp::var*)_p)->_p; \
+                                                                        \
     switch(_type){                                                      \
     case sstd::num_hash_terp_var: {                                     \
-        sstd::terp::var* pVal = _CAST2HASH(_p)[pKey];                   \
-        if(pVal==NULL){ sstd::pdbg_err("Ope[](char*) is failed. NULL pointer detection error. pKey: `%s` is NOT allocated.\n", pKey); return *this; } \
-        return *pVal;                                                   \
+        sstd::terp::var** ppVal = &(_CAST2HASH(local_p)[pKey]);         \
+        if(*ppVal==NULL){ sstd::pdbg_err("Ope[](char*) is failed. NULL pointer detection error. pKey: `%s` is NOT allocated.\n", pKey); return *this; } \
+        return **ppVal;                                                 \
     } break;                                                            \
     default: { sstd::pdbg_err("Ope[](char*) is failed. Unexpedted data type. sstd::terp::var takes type number `%d`, but treat as a \"sstd::terp::hash()\".\n", _type); } break; \
     }                                                                   \
@@ -840,7 +846,10 @@ uint sstd::terp::var::erase(const char* pKey){
 
 sstd::terp::iterator sstd::terp::var::find(const char* pKey) const {
     switch(_type){
-    case sstd::num_hash_terp_var: { return sstd::terp::iterator( _CAST2HASH(_p).find(pKey) ); } break;
+    case sstd::num_hash_terp_var: {
+        void* local_p = (! this->_is_reference) ? _p : (void*)((sstd::terp::var*)_p)->_p;
+        return sstd::terp::iterator( _CAST2HASH(local_p).find(pKey) );
+    } break;
     case sstd::num_null:          {} break;
     default: { sstd::pdbg_err("ERROR\n"); }
     }
@@ -866,22 +875,22 @@ void sstd::terp::var::pop_back(){
 void sstd::terp::var::push_back(){ // push_back null
     NULL_CHECK(_p);
     if(_type!=sstd::num_vec_terp_var){ sstd::pdbg_err("push_back(char*) is failed. Unexpedted data type. This function requires sstd::num_vec_terp_var type, but takes %s type.\n", sstd::typeNum2str(this->_type).c_str()); return; }
-    _CAST2VEC(_p).push_back(new sstd::terp::var());
+    _CAST2VEC(_p).push_back(new sstd::terp::var((sstd::terp::srcr_tbl*)this->_pSRCR_tbl));
 }
 void sstd::terp::var::push_back(const char* pRhs){
     NULL_CHECK(_p);
     if(_type!=sstd::num_vec_terp_var){ sstd::pdbg_err("push_back(char*) is failed. Unexpedted data type. This function requires sstd::num_vec_terp_var type, but takes %s type.\n", sstd::typeNum2str(this->_type).c_str()); return; }
-    _CAST2VEC(_p).push_back(new sstd::terp::var(pRhs));
+    _CAST2VEC(_p).push_back(new sstd::terp::var((sstd::terp::srcr_tbl*)this->_pSRCR_tbl, pRhs));
 }
 void sstd::terp::var::push_back(const sstd::terp::var& rhs){
     NULL_CHECK(_p);
     if(_type!=sstd::num_vec_terp_var){ sstd::pdbg_err("push_back(var&) is failed. Unexpedted data type. This function requires sstd::num_vec_terp_var type, but takes %s type.\n", sstd::typeNum2str(this->_type).c_str()); return; }
-    _CAST2VEC(_p).push_back(new sstd::terp::var(rhs));
+    _CAST2VEC(_p).push_back(new sstd::terp::var((sstd::terp::srcr_tbl*)this->_pSRCR_tbl, rhs));
 }
 void sstd::terp::var::push_back(      sstd::terp::var&& rhs){
     NULL_CHECK(_p);
     if(_type!=sstd::num_vec_terp_var){ sstd::pdbg_err("push_back(var&) is failed. Unexpedted data type. This function requires sstd::num_vec_terp_var type, but takes %s type.\n", sstd::typeNum2str(this->_type).c_str()); return; }
-    _CAST2VEC(_p).push_back(new sstd::terp::var(std::move(rhs))); // call move constructor of "sstd::void_ptr::void_ptr()"
+    _CAST2VEC(_p).push_back(new sstd::terp::var((sstd::terp::srcr_tbl*)this->_pSRCR_tbl, std::move(rhs))); // call move constructor of "sstd::void_ptr::void_ptr()"
 }
 
 void sstd::terp::var::resize(uint len){