Ticket #447: hash_cleanup.patch

File hash_cleanup.patch, 17.3 KB (added by cotto, 6 years ago)
  • DEPRECATED.pod

     
    165165 
    166166L<https://trac.parrot.org/parrot/ticket/443> 
    167167 
    168 =item src/hash.c API cleanup [eligible in 1.1] 
    169  
    170 After the 1.0 release, the following functions will return a Hash* instead of taking a Hash** as an argument: 
    171  
    172 =over 4 
    173  
    174 =item * parrot_new_hash_x 
    175  
    176 =item * parrot_new_cstring_hash 
    177  
    178 =item * parrot_new_pointer_hash 
    179  
    180168=back 
    181169 
    182 L<https://trac.parrot.org/parrot/ticket/447> 
    183  
    184 =back 
    185  
    186170=head1 Compiler tools 
    187171 
    188172=over 4 
  • src/hash.c

     
    3737/* HEADERIZER BEGIN: static */ 
    3838/* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */ 
    3939 
    40 PARROT_CANNOT_RETURN_NULL 
    4140PARROT_WARN_UNUSED_RESULT 
    42 PARROT_MALLOC 
    43 static Hash * create_hash(PARROT_INTERP, 
    44     PARROT_DATA_TYPE val_type, 
    45     Hash_key_type hkey_type, 
    46     ARGIN(hash_comp_fn compare), 
    47     ARGIN(hash_hash_key_fn keyhash)) 
    48         __attribute__nonnull__(1) 
    49         __attribute__nonnull__(4) 
    50         __attribute__nonnull__(5); 
    51  
    52 PARROT_WARN_UNUSED_RESULT 
    5341PARROT_PURE_FUNCTION 
    5442static int cstring_compare(SHIM_INTERP, 
    5543    ARGIN(const char *a), 
     
    126114        __attribute__nonnull__(1) 
    127115        __attribute__nonnull__(2); 
    128116 
    129 #define ASSERT_ARGS_create_hash __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    130        PARROT_ASSERT_ARG(interp) \ 
    131     || PARROT_ASSERT_ARG(compare) \ 
    132     || PARROT_ASSERT_ARG(keyhash) 
    133117#define ASSERT_ARGS_cstring_compare __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    134118       PARROT_ASSERT_ARG(a) \ 
    135119    || PARROT_ASSERT_ARG(b) 
     
    824808 
    825809/* 
    826810 
    827 =item C<void parrot_new_hash> 
     811=item C<Hash* parrot_new_hash> 
    828812 
    829813Creates a new Parrot STRING hash in C<hptr>. 
    830814 
     
    833817*/ 
    834818 
    835819PARROT_EXPORT 
    836 void 
    837 parrot_new_hash(PARROT_INTERP, ARGOUT(Hash **hptr)) 
     820PARROT_CANNOT_RETURN_NULL 
     821Hash* 
     822parrot_new_hash(PARROT_INTERP) 
    838823{ 
    839824    ASSERT_ARGS(parrot_new_hash) 
    840     parrot_new_hash_x(interp, 
    841             hptr, 
     825    return parrot_create_hash(interp, 
    842826            enum_type_PMC, 
    843827            Hash_key_type_STRING, 
    844             STRING_compare,     /* STRING compare */ 
    845             (hash_hash_key_fn)key_hash_STRING);    /*        hash */ 
     828            STRING_compare, 
     829            (hash_hash_key_fn)key_hash_STRING); 
    846830} 
    847831 
    848832 
     
    861845parrot_new_pmc_hash(PARROT_INTERP, ARGOUT(PMC *container)) 
    862846{ 
    863847    ASSERT_ARGS(parrot_new_pmc_hash) 
    864     parrot_new_pmc_hash_x(interp, 
    865             container, 
    866             enum_type_PMC, 
    867             Hash_key_type_STRING, 
    868             STRING_compare,     /* STRING compare */ 
    869             (hash_hash_key_fn)key_hash_STRING);    /*        hash */ 
     848    Hash * const hash = parrot_create_hash(interp, enum_type_PMC, 
     849            Hash_key_type_STRING, STRING_compare, 
     850            (hash_hash_key_fn)key_hash_STRING); 
     851    PMC_struct_val(container) = hash; 
     852    hash->container           = container; 
    870853} 
    871854 
    872855 
    873856/* 
    874857 
    875 =item C<void parrot_new_cstring_hash> 
     858=item C<Hash* parrot_new_cstring_hash> 
    876859 
    877860Creates a new C string hash in C<hptr>. 
    878861 
     
    881864*/ 
    882865 
    883866PARROT_EXPORT 
    884 void 
    885 parrot_new_cstring_hash(PARROT_INTERP, ARGOUT(Hash **hptr)) 
     867PARROT_CANNOT_RETURN_NULL 
     868Hash* 
     869parrot_new_cstring_hash(PARROT_INTERP) 
    886870{ 
    887871    ASSERT_ARGS(parrot_new_cstring_hash) 
    888     parrot_new_hash_x(interp, 
    889             hptr, 
     872    return parrot_create_hash(interp, 
    890873            enum_type_PMC, 
    891874            Hash_key_type_cstring, 
    892             (hash_comp_fn)cstring_compare,     /* cstring compare */ 
    893             (hash_hash_key_fn)key_hash_cstring);    /*        hash */ 
     875            (hash_comp_fn)cstring_compare, 
     876            (hash_hash_key_fn)key_hash_cstring); 
    894877} 
    895878 
    896879 
    897880/* 
    898881 
    899 =item C<static Hash * create_hash> 
     882=item C<Hash * parrot_create_hash> 
    900883 
    901884Creates and initializes a hash.  Function pointers determine its behaviors. 
    902885The container passed in is the address of the hash PMC that is using it.  The 
     
    911894PARROT_CANNOT_RETURN_NULL 
    912895PARROT_WARN_UNUSED_RESULT 
    913896PARROT_MALLOC 
    914 static Hash * 
    915 create_hash(PARROT_INTERP, PARROT_DATA_TYPE val_type, Hash_key_type hkey_type, 
     897Hash * 
     898parrot_create_hash(PARROT_INTERP, PARROT_DATA_TYPE val_type, Hash_key_type hkey_type, 
    916899        ARGIN(hash_comp_fn compare), ARGIN(hash_hash_key_fn keyhash)) 
    917900{ 
    918     ASSERT_ARGS(create_hash) 
     901    ASSERT_ARGS(parrot_create_hash) 
    919902    HashBucket  *bp; 
    920903    Hash * const hash = mem_allocate_zeroed_typed(Hash); 
    921904    size_t       i; 
     
    10481031 
    10491032/* 
    10501033 
    1051 =item C<void parrot_new_hash_x> 
     1034=item C<Hash * parrot_new_pointer_hash> 
    10521035 
    1053 Creates and stores a new hash in C<hptr>. 
     1036Create and return a new hash with void * keys and values. 
    10541037 
    1055 FIXME: This function can go back to just returning the hash struct 
    1056 pointer once Buffers can define their own custom mark routines. 
    1057  
    1058 The problem is: During GC stack walking the item on the stack must be 
    1059 a PMC. When an auto C<Hash*> is seen, it doesn't get properly marked 
    1060 (only the C<Hash*> buffer is marked, not its contents). By passing the 
    1061 C<**hptr> up to the Hash's init function, the newly constructed PMC is 
    1062 on the stack I<including> this newly constructed Hash, so that it gets 
    1063 marked properly. 
    1064  
    10651038=cut 
    10661039 
    10671040*/ 
    10681041 
    1069 void 
    1070 parrot_new_hash_x(PARROT_INTERP, 
    1071         ARGOUT(Hash **hptr), 
    1072         PARROT_DATA_TYPE val_type, 
    1073         Hash_key_type hkey_type, 
    1074         NOTNULL(hash_comp_fn compare), 
    1075         NOTNULL(hash_hash_key_fn keyhash)) 
    1076 { 
    1077     ASSERT_ARGS(parrot_new_hash_x) 
    1078     *hptr = create_hash(interp, val_type, hkey_type, compare, keyhash); 
    1079 } 
    1080  
    1081  
    1082 /* 
    1083  
    1084 =item C<void parrot_new_pmc_hash_x> 
    1085  
    1086 Creates a new PMC hash. 
    1087  
    1088 Like parrot_new_hash_x but w/o the described problems.  The passed in 
    1089 C<container> PMC gets stored in the Hash and the newly created Hash is in 
    1090 PMC_struct_val(container). 
    1091  
    1092 =cut 
    1093  
    1094 */ 
    1095  
    1096 void 
    1097 parrot_new_pmc_hash_x(PARROT_INTERP, 
    1098         ARGMOD(PMC *container), 
    1099         PARROT_DATA_TYPE val_type, 
    1100         Hash_key_type hkey_type, 
    1101         NOTNULL(hash_comp_fn compare), 
    1102         NOTNULL(hash_hash_key_fn keyhash)) 
    1103 { 
    1104     ASSERT_ARGS(parrot_new_pmc_hash_x) 
    1105     Hash * const hash         = create_hash(interp, val_type, hkey_type, 
    1106                                             compare, keyhash); 
    1107     PMC_struct_val(container) = hash; 
    1108     hash->container           = container; 
    1109 } 
    1110  
    1111  
    1112 /* 
    1113  
    1114 =item C<void parrot_new_pointer_hash> 
    1115  
    1116 Creates a new hash with void * keys and values, storing it via the passed-in 
    1117 Hash **. 
    1118  
    1119 =cut 
    1120  
    1121 */ 
    1122  
    11231042PARROT_EXPORT 
    1124 void 
    1125 parrot_new_pointer_hash(PARROT_INTERP, ARGOUT(Hash **hptr)) 
     1043PARROT_CANNOT_RETURN_NULL 
     1044Hash * 
     1045parrot_new_pointer_hash(PARROT_INTERP) 
    11261046{ 
    11271047    ASSERT_ARGS(parrot_new_pointer_hash) 
    1128     parrot_new_hash_x(interp, hptr, enum_type_ptr, Hash_key_type_ptr, 
     1048    return parrot_create_hash(interp, enum_type_ptr, Hash_key_type_ptr, 
    11291049            pointer_compare, key_hash_pointer); 
    11301050} 
    11311051 
     
    11481068Parrot_new_INTVAL_hash(PARROT_INTERP, UINTVAL flags) 
    11491069{ 
    11501070    ASSERT_ARGS(Parrot_new_INTVAL_hash) 
     1071    Hash *hash; 
    11511072    PMC * const h = (flags & PObj_constant_FLAG) 
    11521073                  ? constant_pmc_new_noinit(interp, enum_class_Hash) 
    11531074                  : pmc_new_noinit(interp, enum_class_Hash); 
    11541075 
    1155     parrot_new_pmc_hash_x(interp, h, enum_type_INTVAL, Hash_key_type_int, 
    1156             int_compare, key_hash_int); 
     1076    hash = parrot_create_hash(interp,  
     1077            enum_type_INTVAL, Hash_key_type_int, int_compare, key_hash_int); 
     1078    PMC_struct_val(h) = hash; 
     1079    hash->container   = h; 
    11571080    PObj_active_destroy_SET(h); 
    11581081    return h; 
    11591082} 
  • src/string/api.c

     
    299299 
    300300    /* Set up the cstring cache, then load the basic encodings and charsets */ 
    301301    if (!interp->parent_interpreter) { 
    302         parrot_new_cstring_hash(interp, &const_cstring_hash); 
    303         interp->const_cstring_hash  = (Hash *)const_cstring_hash; 
     302        const_cstring_hash = parrot_new_cstring_hash(interp); 
     303        interp->const_cstring_hash  = const_cstring_hash; 
    304304        Parrot_charsets_encodings_init(interp); 
    305305    } 
    306306    /* initialize the constant string table */ 
  • src/multidispatch.c

     
    14111411{ 
    14121412    ASSERT_ARGS(Parrot_mmd_cache_create) 
    14131413    /* String hash. */ 
    1414     Hash *cache; 
    1415     parrot_new_hash(interp, &cache); 
     1414    Hash *cache = parrot_new_hash(interp); 
    14161415    return cache; 
    14171416} 
    14181417 
  • src/pmc/addrregistry.pmc

     
    5555        PMC_data(SELF)      = addr_registry; 
    5656        PObj_custom_mark_destroy_SETALL(SELF); 
    5757 
    58         parrot_new_pmc_hash_x(INTERP, SELF, enum_type_int, Hash_key_type_PMC, 
     58        registry = parrot_create_hash(INTERP, enum_type_int, Hash_key_type_PMC, 
    5959                              int_compare, key_hash_int); 
    6060 
    61         registry            = (Hash *)PMC_struct_val(SELF); 
     61        PMC_struct_val(SELF) = registry; 
     62        addr_registry->hash  = registry; 
     63        registry->container  = SELF; 
    6264 
    63         /* this hack can go away when parrot_new_pmc_hash_x behaves */ 
    64         addr_registry->hash = registry; 
    65         registry->container = SELF; 
    6665    } 
    6766 
    6867    VTABLE void destroy() { 
  • src/pmc/lexinfo.pmc

     
    6262    } 
    6363 
    6464    VTABLE void init_pmc(PMC *sub) { 
     65        Hash *hash; 
    6566        PARROT_ASSERT(PObj_constant_TEST(SELF)); 
    6667        PMC_pmc_val(SELF) = sub; 
    6768 
    68         parrot_new_pmc_hash_x(INTERP, SELF, 
     69        hash = parrot_create_hash(INTERP, 
    6970            (PARROT_DATA_TYPE)enum_hash_int, 
    7071            Hash_key_type_STRING, 
    7172            (hash_comp_fn)Parrot_str_not_equal,     /* STRING compare */ 
    7273            (hash_hash_key_fn)Parrot_str_to_hashval); /*        hash    */ 
    7374 
     75        PMC_struct_val(SELF) = hash; 
     76        hash->container      = SELF; 
    7477        PObj_active_destroy_SET(SELF); 
    7578    } 
    7679 
  • src/vtables.c

     
    6565    /* when called from global PMC initialization, not all vtables have isa_hash 
    6666     * when called at runtime, they do */ 
    6767    if (base_vtable->isa_hash) { 
    68         parrot_new_hash(interp, &new_vtable->isa_hash); 
     68        new_vtable->isa_hash = parrot_new_hash(interp); 
    6969        parrot_hash_clone(interp, base_vtable->isa_hash, new_vtable->isa_hash); 
    7070    } 
    7171 
  • src/packfile.c

     
    152152        __attribute__nonnull__(1) 
    153153        __attribute__nonnull__(2) 
    154154        __attribute__nonnull__(3) 
    155         FUNC_MODIFIES(*segp) 
    156         FUNC_MODIFIES(*cursor); 
     155        FUNC_MODIFIES(*segp); 
    157156 
    158157PARROT_WARN_UNUSED_RESULT 
    159158PARROT_CAN_RETURN_NULL 
     
    30793078        PARROT_ASSERT(interp->thread_data); 
    30803079 
    30813080        if (!interp->thread_data->const_tables) { 
    3082             interp->thread_data->const_tables = mem_allocate_typed(Hash); 
    3083             parrot_new_pointer_hash(interp, &interp->thread_data->const_tables); 
     3081            interp->thread_data->const_tables = parrot_new_pointer_hash(interp); 
    30843082        } 
    30853083 
    30863084        tables     = interp->thread_data->const_tables; 
  • lib/Parrot/Pmc2c/PMCEmitter.pm

     
    563563            PObj_constant_FLAG|PObj_external_FLAG)); 
    564564 
    565565        /* set up isa hash */ 
    566         parrot_new_hash(interp, &isa_hash); 
     566        isa_hash = parrot_new_hash(interp); 
    567567        vt_clone->isa_hash     = isa_hash; 
    568568EOC 
    569569    } 
     
    573573        vt_clone->provides_str = CONST_STRING_GEN(interp, "$provides"); 
    574574 
    575575        /* set up isa hash */ 
    576         parrot_new_hash(interp, &isa_hash); 
     576        isa_hash = parrot_new_hash(interp); 
    577577        vt_clone->isa_hash     = isa_hash; 
    578578EOC 
    579579    } 
  • include/parrot/hash.h

     
    180180        __attribute__nonnull__(2); 
    181181 
    182182PARROT_EXPORT 
    183 void parrot_new_cstring_hash(PARROT_INTERP, ARGOUT(Hash **hptr)) 
    184         __attribute__nonnull__(1) 
    185         __attribute__nonnull__(2) 
    186         FUNC_MODIFIES(*hptr); 
     183PARROT_CANNOT_RETURN_NULL 
     184Hash* parrot_new_cstring_hash(PARROT_INTERP) 
     185        __attribute__nonnull__(1); 
    187186 
    188187PARROT_EXPORT 
    189 void parrot_new_hash(PARROT_INTERP, ARGOUT(Hash **hptr)) 
    190         __attribute__nonnull__(1) 
    191         __attribute__nonnull__(2) 
    192         FUNC_MODIFIES(*hptr); 
     188PARROT_CANNOT_RETURN_NULL 
     189Hash* parrot_new_hash(PARROT_INTERP) 
     190        __attribute__nonnull__(1); 
    193191 
    194192PARROT_EXPORT 
    195193PARROT_WARN_UNUSED_RESULT 
     
    204202        FUNC_MODIFIES(*container); 
    205203 
    206204PARROT_EXPORT 
    207 void parrot_new_pointer_hash(PARROT_INTERP, ARGOUT(Hash **hptr)) 
    208         __attribute__nonnull__(1) 
    209         __attribute__nonnull__(2) 
    210         FUNC_MODIFIES(*hptr); 
     205PARROT_CANNOT_RETURN_NULL 
     206Hash * parrot_new_pointer_hash(PARROT_INTERP) 
     207        __attribute__nonnull__(1); 
    211208 
    212209PARROT_WARN_UNUSED_RESULT 
    213210PARROT_PURE_FUNCTION 
     
    233230        __attribute__nonnull__(3) 
    234231        FUNC_MODIFIES(*hash); 
    235232 
    236 void parrot_new_hash_x(PARROT_INTERP, 
    237     ARGOUT(Hash **hptr), 
     233PARROT_CANNOT_RETURN_NULL 
     234PARROT_WARN_UNUSED_RESULT 
     235PARROT_MALLOC 
     236Hash * parrot_create_hash(PARROT_INTERP, 
    238237    PARROT_DATA_TYPE val_type, 
    239238    Hash_key_type hkey_type, 
    240     NOTNULL(hash_comp_fn compare), 
    241     NOTNULL(hash_hash_key_fn keyhash)) 
     239    ARGIN(hash_comp_fn compare), 
     240    ARGIN(hash_hash_key_fn keyhash)) 
    242241        __attribute__nonnull__(1) 
    243         __attribute__nonnull__(2) 
    244         __attribute__nonnull__(5) 
    245         __attribute__nonnull__(6) 
    246         FUNC_MODIFIES(*hptr); 
     242        __attribute__nonnull__(4) 
     243        __attribute__nonnull__(5); 
    247244 
    248 void parrot_new_pmc_hash_x(PARROT_INTERP, 
    249     ARGMOD(PMC *container), 
    250     PARROT_DATA_TYPE val_type, 
    251     Hash_key_type hkey_type, 
    252     NOTNULL(hash_comp_fn compare), 
    253     NOTNULL(hash_hash_key_fn keyhash)) 
    254         __attribute__nonnull__(1) 
    255         __attribute__nonnull__(2) 
    256         __attribute__nonnull__(5) 
    257         __attribute__nonnull__(6) 
    258         FUNC_MODIFIES(*container); 
    259  
    260245#define ASSERT_ARGS_parrot_dump_hash __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    261246       PARROT_ASSERT_ARG(hash) 
    262247#define ASSERT_ARGS_parrot_hash_clone __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
     
    300285       PARROT_ASSERT_ARG(interp) \ 
    301286    || PARROT_ASSERT_ARG(hash) 
    302287#define ASSERT_ARGS_parrot_new_cstring_hash __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    303        PARROT_ASSERT_ARG(interp) \ 
    304     || PARROT_ASSERT_ARG(hptr) 
     288       PARROT_ASSERT_ARG(interp) 
    305289#define ASSERT_ARGS_parrot_new_hash __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    306        PARROT_ASSERT_ARG(interp) \ 
    307     || PARROT_ASSERT_ARG(hptr) 
     290       PARROT_ASSERT_ARG(interp) 
    308291#define ASSERT_ARGS_Parrot_new_INTVAL_hash __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    309292       PARROT_ASSERT_ARG(interp) 
    310293#define ASSERT_ARGS_parrot_new_pmc_hash __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    311294       PARROT_ASSERT_ARG(interp) \ 
    312295    || PARROT_ASSERT_ARG(container) 
    313296#define ASSERT_ARGS_parrot_new_pointer_hash __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    314        PARROT_ASSERT_ARG(interp) \ 
    315     || PARROT_ASSERT_ARG(hptr) 
     297       PARROT_ASSERT_ARG(interp) 
    316298#define ASSERT_ARGS_int_compare __attribute__unused__ int _ASSERT_ARGS_CHECK = 0 
    317299#define ASSERT_ARGS_key_hash_int __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    318300       PARROT_ASSERT_ARG(value) 
     
    323305       PARROT_ASSERT_ARG(interp) \ 
    324306    || PARROT_ASSERT_ARG(hash) \ 
    325307    || PARROT_ASSERT_ARG(func) 
    326 #define ASSERT_ARGS_parrot_new_hash_x __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
     308#define ASSERT_ARGS_parrot_create_hash __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    327309       PARROT_ASSERT_ARG(interp) \ 
    328     || PARROT_ASSERT_ARG(hptr) \ 
    329310    || PARROT_ASSERT_ARG(compare) \ 
    330311    || PARROT_ASSERT_ARG(keyhash) 
    331 #define ASSERT_ARGS_parrot_new_pmc_hash_x __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    332        PARROT_ASSERT_ARG(interp) \ 
    333     || PARROT_ASSERT_ARG(container) \ 
    334     || PARROT_ASSERT_ARG(compare) \ 
    335     || PARROT_ASSERT_ARG(keyhash) 
    336312/* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */ 
    337313/* HEADERIZER END: src/hash.c */ 
    338314 
  • compilers/imcc/imclexer.c

     
    54955495        m = mem_allocate_zeroed_typed(macro_t); 
    54965496 
    54975497        if (!IMCC_INFO(interp)->macros) 
    5498             parrot_new_cstring_hash(interp, &IMCC_INFO(interp)->macros); 
     5498            IMCC_INFO(interp)->macros = parrot_new_cstring_hash(interp); 
    54995499        parrot_hash_put(interp, IMCC_INFO(interp)->macros, 
    55005500            PARROT_const_cast(char *, name), m); 
    55015501    }