feat(js & c-api): Rename Memory segment functions data segment.

CHANGELOG.md

@@ -15,6 +15,15 @@ full changeset diff at the end of each section.
 Current Trunk
 -------------
 
+ - Rename `MemorySegment` functions to `DataSegment` in the c and js apis
+   - Rename `BinaryenGetNumMemorySegments` to `BinaryenGetNumDataSegments` in c api.
+   - Rename `BinaryenGetMemorySegmentByteOffset` to `BinaryenGetDataSegmentByteOffset` in c api.
+   - Rename `BinaryenGetMemorySegmentByteLength` to `BinaryenGetDataSegmentByteLength` in c api.
+   - Rename `BinaryenGetMemorySegmentPassive` to `BinaryenGetDataSegmentPassive` in c api.
+   - Rename `BinaryenCopyMemorySegmentData` to `BinaryenCopyDataSegmentData` in c api.
+   - Rename `module.getNumMemorySegments` to `module.getNumDataSegments` in js api.
+   - Rename `module.getMemorySegmentInfo` to `module.getDataSegmentInfo` in js api.
+
 v129
 ----
 

src/binaryen-c.cpp

@@ -5489,7 +5489,7 @@ void BinaryenSetMemory(BinaryenModuleRef module,
 
 // Memory segments
 
-uint32_t BinaryenGetNumMemorySegments(BinaryenModuleRef module) {
+uint32_t BinaryenGetNumDataSegments(BinaryenModuleRef module) {
   return ((Module*)module)->dataSegments.size();
 }
 BinaryenDataSegmentRef BinaryenGetDataSegment(BinaryenModuleRef module,
@@ -5507,8 +5507,8 @@ BinaryenDataSegmentRef BinaryenGetDataSegmentByIndex(BinaryenModuleRef module,
 const char* BinaryenDataSegmentGetName(BinaryenDataSegmentRef segment) {
   return ((DataSegment*)segment)->name.str.data();
 }
-uint32_t BinaryenGetMemorySegmentByteOffset(BinaryenModuleRef module,
-                                            BinaryenDataSegmentRef segment) {
+uint32_t BinaryenGetDataSegmentByteOffset(BinaryenModuleRef module,
+                                          BinaryenDataSegmentRef segment) {
   auto* wasm = (Module*)module;
 
   auto globalOffset = [&](const Expression* const& expr,
@@ -5625,14 +5625,13 @@ bool BinaryenMemoryIs64(BinaryenModuleRef module, const char* name) {
   }
   return memory->is64();
 }
-size_t BinaryenGetMemorySegmentByteLength(BinaryenDataSegmentRef segment) {
+size_t BinaryenGetDataSegmentByteLength(BinaryenDataSegmentRef segment) {
   return ((DataSegment*)segment)->data.size();
 }
-bool BinaryenGetMemorySegmentPassive(BinaryenDataSegmentRef segment) {
+bool BinaryenGetDataSegmentPassive(BinaryenDataSegmentRef segment) {
   return ((DataSegment*)segment)->isPassive;
 }
-void BinaryenCopyMemorySegmentData(BinaryenDataSegmentRef segment,
-                                   char* buffer) {
+void BinaryenCopyDataSegmentData(BinaryenDataSegmentRef segment, char* buffer) {
   std::copy(((DataSegment*)segment)->data.cbegin(),
             ((DataSegment*)segment)->data.cend(),
             buffer);

src/binaryen-c.h

@@ -3003,25 +3003,24 @@ BINARYEN_API bool BinaryenMemoryIsShared(BinaryenModuleRef module,
 BINARYEN_API bool BinaryenMemoryIs64(BinaryenModuleRef module,
                                      const char* name);
 
-// Memory segments. Query utilities.
+// Data segments. Query utilities.
 
 BINARYEN_REF(DataSegment);
 
-BINARYEN_API uint32_t BinaryenGetNumMemorySegments(BinaryenModuleRef module);
+BINARYEN_API uint32_t BinaryenGetNumDataSegments(BinaryenModuleRef module);
 BINARYEN_API BinaryenDataSegmentRef
 BinaryenGetDataSegment(BinaryenModuleRef module, const char* segmentName);
 BINARYEN_API BinaryenDataSegmentRef
 BinaryenGetDataSegmentByIndex(BinaryenModuleRef module, BinaryenIndex index);
 BINARYEN_API const char*
 BinaryenDataSegmentGetName(BinaryenDataSegmentRef segment);
-BINARYEN_API uint32_t BinaryenGetMemorySegmentByteOffset(
+BINARYEN_API uint32_t BinaryenGetDataSegmentByteOffset(
   BinaryenModuleRef module, BinaryenDataSegmentRef segment);
 BINARYEN_API size_t
-BinaryenGetMemorySegmentByteLength(BinaryenDataSegmentRef segment);
-BINARYEN_API bool
-BinaryenGetMemorySegmentPassive(BinaryenDataSegmentRef segment);
-BINARYEN_API void BinaryenCopyMemorySegmentData(BinaryenDataSegmentRef segment,
-                                                char* buffer);
+BinaryenGetDataSegmentByteLength(BinaryenDataSegmentRef segment);
+BINARYEN_API bool BinaryenGetDataSegmentPassive(BinaryenDataSegmentRef segment);
+BINARYEN_API void BinaryenCopyDataSegmentData(BinaryenDataSegmentRef segment,
+                                              char* buffer);
 BINARYEN_API void BinaryenAddDataSegment(BinaryenModuleRef module,
                                          const char* segmentName,
                                          const char* memoryName,

src/js/binaryen.js-post.js

@@ -2769,8 +2769,8 @@ function wrapModule(module, self = {}) {
       return memoryInfo;
     });
   };
-  self['getNumMemorySegments'] = function() {
-    return Module['_BinaryenGetNumMemorySegments'](module);
+  self['getNumDataSegments'] = function() {
+    return Module['_BinaryenGetNumDataSegments'](module);
   };
   /**
    * Gets the data segment with the given name.
@@ -2795,9 +2795,9 @@ function wrapModule(module, self = {}) {
     return Module['_BinaryenGetDataSegmentByIndex'](module, index);
   };
   /**
-   * Queries information about a memory segment.
+   * Queries information about a data segment.
    * 
-   * @param {number} segment  - A MemorySegmentRef referring to the memory segment to get information about.
+   * @param {number} segment  - A DataSegmentRef referring to the data segment to get information about.
    * @returns {Object} An object containing the following fields:
    *   - `name`: The name of the segment.
    *   - `offset`: If the segment is active, the offset expression of the segment. Otherwise, `null`.
@@ -2806,19 +2806,19 @@ function wrapModule(module, self = {}) {
     * 
     * @throws If the given segment reference is invalid.
    */
-  self['getMemorySegmentInfo'] = function(segment) {
-    const passive = Boolean(Module['_BinaryenGetMemorySegmentPassive'](segment));
+  self['getDataSegmentInfo'] = function(segment) {
+    const passive = Boolean(Module['_BinaryenGetDataSegmentPassive'](segment));
     let offset = null;
     if (!passive) {
-      offset = Module['_BinaryenGetMemorySegmentByteOffset'](module, segment);
+      offset = Module['_BinaryenGetDataSegmentByteOffset'](module, segment);
     }
     return {
       'name': UTF8ToString(Module['_BinaryenDataSegmentGetName'](segment)),
       'offset': offset,
       'data': (function(){
-        const size = Module['_BinaryenGetMemorySegmentByteLength'](segment);
+        const size = Module['_BinaryenGetDataSegmentByteLength'](segment);
         const ptr = _malloc(size);
-        Module['_BinaryenCopyMemorySegmentData'](segment, ptr);
+        Module['_BinaryenCopyDataSegmentData'](segment, ptr);
         const res = new Uint8Array(size);
         res.set(HEAP8.subarray(ptr, ptr + size));
         _free(ptr);

test/binaryen.js/kitchen-sink.js

@@ -1195,9 +1195,9 @@ function test_for_each() {
   ], false);
   assert(module.getDataSegment(expected_names[0]) !== 0);
   assert(module.getDataSegment("NonExistantSegment") === 0);
-  for (i = 0; i < module.getNumMemorySegments(); i++) {
+  for (i = 0; i < module.getNumDataSegments(); i++) {
     var segment = module.getDataSegmentByIndex(i);
-    var info = module.getMemorySegmentInfo(segment);
+    var info = module.getDataSegmentInfo(segment);
     assert(expected_names[i] === info.name);
     assert(expected_offsets[i] === info.offset);
     var data8 = new Uint8Array(info.data);

test/example/c-api-kitchen-sink.c

@@ -2021,16 +2021,16 @@ void test_for_each() {
                       makeInt32(module, expected_offsets[1]));
     assert(BinaryenGetDataSegment(module, segmentNames[0]) != NULL);
     assert(BinaryenGetDataSegment(module, "NonExistentSegment") == NULL);
-    for (i = 0; i < BinaryenGetNumMemorySegments(module); i++) {
+    for (i = 0; i < BinaryenGetNumDataSegments(module); i++) {
       char out[15] = {};
       BinaryenDataSegmentRef segment = BinaryenGetDataSegmentByIndex(module, i);
       assert(segment != NULL);
       assert(BinaryenDataSegmentGetName(segment) != NULL);
-      assert(BinaryenGetMemorySegmentByteOffset(module, segment) ==
+      assert(BinaryenGetDataSegmentByteOffset(module, segment) ==
              expected_offsets[i]);
-      assert(BinaryenGetMemorySegmentByteLength(segment) == segmentSizes[i]);
-      assert(BinaryenGetMemorySegmentPassive(segment) == segmentPassives[i]);
-      BinaryenCopyMemorySegmentData(segment, out);
+      assert(BinaryenGetDataSegmentByteLength(segment) == segmentSizes[i]);
+      assert(BinaryenGetDataSegmentPassive(segment) == segmentPassives[i]);
+      BinaryenCopyDataSegmentData(segment, out);
       assert(0 == strcmp(segmentDatas[i], out));
     }
   }