fork(1) download
copy 
  1. /*
  2.  * Because we are using the kindly-provided services of
  3.  * http://i...content-available-to-author-only...e.com , we mush together three separate
  4.  * files using some preprocessor tricks.  The files are
  5.  * identified individually so that you can copy and paste
  6.  * them into their own files, if you so choose.  The
  7.  * stuff that only matters for this http://i...content-available-to-author-only...e.com
  8.  * paste is every line that contains the text
  9.  * 'ALL_IN_ONE'.  This very comment section is also not
  10.  * part of the three files
  11.  */
  12.  
  13. #ifndef MULDIM_TEST_C_ /* ALL_IN_ONE */
  14. #define MULDIM_TEST_C_ /* ALL_IN_ONE */
  15.  
  16.  
  17.  
  18.   /**** muldim_test.c - Shao Miller, April 4th, 2012 */
  19.  
  20.   #include <stdlib.h>
  21.   #include <stdio.h>
  22.  
  23. #if 0 /* ALL_IN_ONE */
  24.   #include "muldim.h"
  25. #else /* ALL_IN_ONE */
  26. #include "prog.c" /* ALL_IN_ONE */
  27. #endif /* ALL_IN_ONE */
  28.  
  29.   /*** Macros */
  30.   #define CountOf(array) (sizeof (array) / sizeof *(array))
  31.  
  32.   int main(void) {
  33.       int result;
  34.       muldim_t arr;
  35.       muldim_t end;
  36.       int test[2][3][4];
  37.       int i, j, k, * ip;
  38.  
  39.       /* Assume failure */
  40.       result = EXIT_FAILURE;
  41.  
  42.       /* Same dimensions as 'test' */
  43.       arr = muldim_zalloc(sizeof (int), 3, 2, 3, 4);
  44.       if (!arr.ptr) {
  45.           goto err_arr;
  46.         }
  47.  
  48.       muldim_dmp(arr);
  49.  
  50.       end = muldim_get(arr, 3, 1, 2, 4);
  51.       if (!end.ptr) {
  52.           goto err_end;
  53.         }
  54.  
  55.       muldim_dmp(end);
  56.  
  57.       printf(
  58.           "(\n"
  59.           "    (char *) (test[1][2] + 4) -\n"
  60.           "    (char *) test[0][0]\n"
  61.           "  ) == %d\n",
  62.           (
  63.               (char *) (test[1][2] + 4) -
  64.               (char *) test[0][0]
  65.             )
  66.         );
  67.  
  68.       printf(
  69.           "(\n"
  70.           "    (char *) end.ptr -\n"
  71.           "    (char *) arr.ptr\n"
  72.           "  ) == %d\n",
  73.           (
  74.               (char *) end.ptr -
  75.               (char *) arr.ptr
  76.             )
  77.         );
  78.  
  79.       /* Same dimensions as 'test' */
  80.       for (i = 0; i < CountOf(test); ++i) {
  81.           for (j = 0; j < CountOf(test[0]); ++j) {
  82.               ip = muldim_get(arr, 2, i, j).ptr;
  83.               for (k = 0; k < CountOf(test[0][0]); ++k) {
  84.                   if (ip[k]) {
  85.                       printf("muldim_zalloc failed!\n");
  86.                       goto err_nonzero;
  87.                     }
  88.                   ip[k] = 42;
  89.                   continue;
  90.                 }
  91.               continue;
  92.             }
  93.           continue;
  94.         }
  95.  
  96.       /* Success */
  97.       printf("Yay\n");
  98.       result = EXIT_SUCCESS;
  99.  
  100.       err_nonzero:
  101.  
  102.       err_end:
  103.  
  104.       free(arr.mem);
  105.       err_arr:
  106.  
  107.       return result;
  108.     }
  109.  
  110.  
  111.  
  112. #else /* ALL_IN_ONE */
  113.  
  114.  
  115.  
  116.   /**** muldim.h  - Shao Miller, April 4th, 2012 */
  117.  
  118.   #ifndef MULDIM_H_
  119.  
  120.   #include <stddef.h>
  121.  
  122.   /*** Macros */
  123.   #define MULDIM_H_
  124.  
  125.   /*** Object types */
  126.  
  127.   typedef struct s_muldim s_muldim, muldim_t;
  128.  
  129.   /*** Struct/union definitions */
  130.  
  131.   struct s_muldim {
  132.       void * ptr;
  133.       size_t dims;
  134.       size_t stride;
  135.       size_t * dims_at;
  136.       void * mem;
  137.     };
  138.  
  139.   /*** Function declarations */
  140.  
  141.   extern muldim_t muldim_alloc(size_t base_sz, size_t dims, ...);
  142.   extern muldim_t muldim_zalloc(size_t base_sz, size_t dims, ...);
  143.   extern muldim_t muldim_get(muldim_t muldim, size_t dims, ...);
  144.   extern void muldim_dmp(muldim_t muldim);
  145.  
  146.   #endif /* MULDIM_H_ */
  147.  
  148.  
  149.  
  150.   /**** muldim.c  - Shao Miller, April 4th, 2012 */
  151.  
  152.   #include <stddef.h>
  153.   #include <stdarg.h>
  154.   #include <stdlib.h>
  155.   #include <stdio.h>
  156.  
  157. #if 0 /* ALL_IN_ONE */
  158.   #include "muldim.h"
  159. #endif /* ALL_IN_ONE */
  160.  
  161.   /*** Function declarations */
  162.  
  163.   static size_t sz_add(size_t x, size_t y);
  164.   static size_t sz_mul(size_t x, size_t y);
  165.  
  166.   /*** Struct/union definitions */
  167.  
  168.   struct s_muldim_wrapper {
  169.       muldim_t muldim;
  170.       size_t dims_hdr[1];
  171.     };
  172.  
  173.   /*** Object definitions */
  174.   static const muldim_t new_muldim;
  175.  
  176.   /*** Function definitions */
  177.  
  178.   muldim_t muldim_alloc(size_t base_sz, size_t dims, ...) {
  179.       register const size_t dims_offset = offsetof(
  180.           struct s_muldim_wrapper,
  181.           dims_hdr
  182.         );
  183.       muldim_t result;
  184.       size_t dims_sz;
  185.       size_t hdr_sz;
  186.       va_list vargs;
  187.       size_t array_sz;
  188.       size_t i;
  189.       int dim;
  190.       size_t total_sz;
  191.       char * ptr;
  192.       size_t * dims_at;
  193.  
  194.       result = new_muldim;
  195.  
  196.       if (!base_sz) {
  197.           goto err_base_sz;
  198.         }
  199.  
  200.       dims_sz = sz_mul(dims, sizeof result.dims_at[0]);
  201.       if (!dims_sz) {
  202.           goto err_dims_sz;
  203.         }
  204.  
  205.       hdr_sz = sz_add(dims_offset, dims_sz);
  206.       if (!hdr_sz) {
  207.           goto err_hdr_sz;
  208.         }
  209.       hdr_sz = sz_add(base_sz, hdr_sz);
  210.       if (!hdr_sz) {
  211.           goto err_hdr_sz;
  212.         }
  213.       hdr_sz = hdr_sz - 1;
  214.       hdr_sz = hdr_sz / base_sz;
  215.       hdr_sz = hdr_sz * base_sz;
  216.  
  217.       va_start(vargs, dims);
  218.       array_sz = base_sz;
  219.       for (i = dims; i; --i) {
  220.           dim = va_arg(vargs, int);
  221.           if (dim < 1) {
  222.               goto err_dim;
  223.             }
  224.  
  225.           array_sz = sz_mul(array_sz, (size_t) dim);
  226.           if (!array_sz) {
  227.               goto err_array_sz;
  228.             }
  229.  
  230.           continue;
  231.         }
  232.       va_end(vargs);
  233.  
  234.       total_sz = sz_add(hdr_sz, array_sz);
  235.       if (!total_sz) {
  236.           goto err_total_sz;
  237.         }
  238.  
  239.       ptr = malloc(total_sz);
  240.       if (!ptr) {
  241.           goto err_ptr;
  242.         }
  243.  
  244.       /* Success */
  245.  
  246.       dims_at = (void *) (ptr + dims_offset);
  247.  
  248.       va_start(vargs, dims);
  249.       for (i = 0; i < dims; ++i) {
  250.           dim = va_arg(vargs, int);
  251.           dims_at[i] = (size_t) dim;
  252.  
  253.           continue;
  254.         }
  255.       va_end(vargs);
  256.  
  257.       result.ptr = ptr + hdr_sz;
  258.       result.dims = dims;
  259.       result.stride = array_sz;
  260.       result.dims_at = dims_at;
  261.       result.mem = ptr;
  262.  
  263.       *(muldim_t *) ptr = result;
  264.       return result;
  265.  
  266.       free(ptr);
  267.       err_ptr:
  268.  
  269.       err_total_sz:
  270.  
  271.       err_array_sz:
  272.  
  273.       err_dim:
  274.  
  275.       err_hdr_sz:
  276.  
  277.       err_dims_sz:
  278.  
  279.       err_base_sz:
  280.  
  281.       return result;
  282.     }
  283.  
  284.   muldim_t muldim_zalloc(size_t base_sz, size_t dims, ...) {
  285.       register const size_t dims_offset = offsetof(
  286.           struct s_muldim_wrapper,
  287.           dims_hdr
  288.         );
  289.       muldim_t result;
  290.       size_t dims_sz;
  291.       size_t hdr_sz;
  292.       va_list vargs;
  293.       size_t array_sz;
  294.       size_t i;
  295.       int dim;
  296.       size_t total_sz;
  297.       char * ptr;
  298.       size_t * dims_at;
  299.  
  300.       result = new_muldim;
  301.  
  302.       if (!base_sz) {
  303.           goto err_base_sz;
  304.         }
  305.  
  306.       dims_sz = sz_mul(dims, sizeof result.dims_at[0]);
  307.       if (!dims_sz) {
  308.           goto err_dims_sz;
  309.         }
  310.  
  311.       hdr_sz = sz_add(dims_offset, dims_sz);
  312.       if (!hdr_sz) {
  313.           goto err_hdr_sz;
  314.         }
  315.       hdr_sz = sz_add(base_sz, hdr_sz);
  316.       if (!hdr_sz) {
  317.           goto err_hdr_sz;
  318.         }
  319.       hdr_sz = hdr_sz - 1;
  320.       hdr_sz = hdr_sz / base_sz;
  321.       hdr_sz = hdr_sz * base_sz;
  322.  
  323.       va_start(vargs, dims);
  324.       array_sz = base_sz;
  325.       for (i = dims; i; --i) {
  326.           dim = va_arg(vargs, int);
  327.           if (dim < 1) {
  328.               goto err_dim;
  329.             }
  330.  
  331.           array_sz = sz_mul(array_sz, (size_t) dim);
  332.           if (!array_sz) {
  333.               goto err_array_sz;
  334.             }
  335.  
  336.           continue;
  337.         }
  338.       va_end(vargs);
  339.  
  340.       total_sz = sz_add(hdr_sz, array_sz);
  341.       if (!total_sz) {
  342.           goto err_total_sz;
  343.         }
  344.  
  345.       total_sz = total_sz / base_sz;
  346.       ptr = calloc(total_sz, base_sz);
  347.       if (!ptr) {
  348.           goto err_ptr;
  349.         }
  350.  
  351.       /* Success */
  352.  
  353.       dims_at = (void *) (ptr + dims_offset);
  354.  
  355.       va_start(vargs, dims);
  356.       for (i = 0; i < dims; ++i) {
  357.           dim = va_arg(vargs, int);
  358.           dims_at[i] = (size_t) dim;
  359.  
  360.           continue;
  361.         }
  362.       va_end(vargs);
  363.  
  364.       result.ptr = ptr + hdr_sz;
  365.       result.dims = dims;
  366.       result.stride = array_sz;
  367.       result.dims_at = dims_at;
  368.       result.mem = ptr;
  369.  
  370.       *(muldim_t *) ptr = result;
  371.       return result;
  372.  
  373.       free(ptr);
  374.       err_ptr:
  375.  
  376.       err_total_sz:
  377.  
  378.       err_array_sz:
  379.  
  380.       err_dim:
  381.  
  382.       err_hdr_sz:
  383.  
  384.       err_dims_sz:
  385.  
  386.       err_base_sz:
  387.  
  388.       return result;
  389.     }
  390.  
  391.   muldim_t muldim_get(muldim_t muldim, size_t dims, ...) {
  392.       char * ptr;
  393.       va_list vargs;
  394.       int dim;
  395.  
  396.       if (!dims || dims > muldim.dims) {
  397.           goto err_dims;
  398.         }
  399.  
  400.       ptr = muldim.ptr;
  401.       va_start(vargs, dims);
  402.       while (dims--) {
  403.           dim = va_arg(vargs, int);
  404.           if (dim < 0 || dim > muldim.dims_at[0]) {
  405.               goto err_dim;
  406.             }
  407.  
  408.           muldim.stride = muldim.stride / muldim.dims_at[0];
  409.           ptr = ptr + muldim.stride * dim;
  410.           --muldim.dims;
  411.           ++muldim.dims_at;
  412.  
  413.           continue;
  414.         }
  415.       va_end(vargs);
  416.  
  417.       /* Success */
  418.  
  419.       muldim.ptr = ptr;
  420.       return muldim;
  421.  
  422.       err_dim:
  423.  
  424.       err_dims:
  425.  
  426.       return new_muldim;
  427.     }
  428.  
  429.   void muldim_dmp(muldim_t muldim) {
  430.       printf(
  431.           "ptr == %p\n"
  432.           "dims == %u\n"
  433.           "stride == %u\n"
  434.           "dims_at == %p\n"
  435.           "mem == %p\n",
  436.           muldim.ptr,
  437.           (unsigned int) muldim.dims,
  438.           (unsigned int) muldim.stride,
  439.           (void *) muldim.dims_at,
  440.           muldim.mem
  441.         );
  442.       printf("dimensions: { ");
  443.       while (muldim.dims--) {
  444.           printf("%u, ", (unsigned int) muldim.dims_at++[0]);
  445.           continue;
  446.         }
  447.       printf("}\n");
  448.       return;
  449.     }
  450.  
  451.   static size_t sz_add(size_t x, size_t y) {
  452.       size_t result;
  453.  
  454.       result = x + y;
  455.       if (result <= x || result <= y) {
  456.           /* Wrap-around */
  457.           return 0;
  458.         }
  459.       return result;
  460.     }
  461.  
  462.   static size_t sz_mul(size_t x, size_t y) {
  463.       size_t result;
  464.  
  465.       result = x * y;
  466.       if (result <= x || result <= y) {
  467.           /* Wrap-around */
  468.           return 0;
  469.         }
  470.       return result;
  471.     }
  472.  
  473.  
  474.  
  475. #endif /* ALL_IN_ONE */
Success #stdin #stdout 0.02s 1852KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
ptr == 0x92db028
dims == 3
stride == 96
dims_at == 0x92db01c
mem == 0x92db008
dimensions: { 2, 3, 4, }
ptr == 0x92db088
dims == 0
stride == 4
dims_at == 0x92db028
mem == 0x92db008
dimensions: { }
(
    (char *) (test[1][2] + 4) -
    (char *) test[0][0]
  ) == 96
(
    (char *) end.ptr -
    (char *) arr.ptr
  ) == 96
Yay
https://ideone.com/qmEQl
language:
C (gcc 8.3)
created:
12 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!