<?xml version="1.0" encoding="utf-8"?>
<feed xml:lang="en" xmlns="http://www.w3.org/2005/Atom"><title>Recent posts to Sorting array of any-sized structure</title><link href="https://forge.codesys.com/forge/talk/Engineering/thread/f7cdba5c33/" rel="alternate"/><link href="https://forge.codesys.com/forge/talk/Engineering/thread/f7cdba5c33/feed.atom" rel="self"/><id>https://forge.codesys.com/forge/talk/Engineering/thread/f7cdba5c33/</id><updated>2023-08-18T12:32:13.619000Z</updated><subtitle>Recent posts to Sorting array of any-sized structure</subtitle><entry><title>Sorting array of any-sized structure</title><link href="https://forge.codesys.com/forge/talk/Engineering/thread/f7cdba5c33/?limit=25#d48a/b15a" rel="alternate"/><published>2023-08-18T12:32:13.619000Z</published><updated>2023-08-18T12:32:13.619000Z</updated><author><name>ihatemaryfisher</name><uri>https://forge.codesys.com/u/ihatemaryfisher/</uri></author><id>https://forge.codesys.com38bd4cb2618f0503f573310a7318daa498faa0bf</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;p&gt;With that I could make an array of varying size, but would still have to define the array type in the function's declaration&lt;/p&gt;
&lt;div class="codehilite"&gt;&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="err"&gt;VAR_IN_OUT&lt;/span&gt;
&lt;span class="err"&gt;    stArray: array [*..*] of &amp;lt;pre-defined data type&amp;gt;&lt;/span&gt;
&lt;span class="err"&gt;END_VAR&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;


&lt;p&gt;I wanted a function that could take an array of any type (e.g., a structured VAR) as an input. That way I could call it in multiple POUs to handle different arrays structures.&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>Sorting array of any-sized structure</title><link href="https://forge.codesys.com/forge/talk/Engineering/thread/f7cdba5c33/?limit=25#d48a" rel="alternate"/><published>2023-08-18T08:13:17.966000Z</published><updated>2023-08-18T08:13:17.966000Z</updated><author><name>TimvH</name><uri>https://forge.codesys.com/u/timvh/</uri></author><id>https://forge.codesys.com601fc6ff1ef914b98465310efd43e1d7e7e65730</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;p&gt;Look all the way at the end of the link below. This provides a way to use arrays with various lengths:&lt;br/&gt;
&lt;a href="https://content.helpme-codesys.com/en/CODESYS%20Development%20System/_cds_datatype_array.html" rel="nofollow"&gt;https://content.helpme-codesys.com/en/CODESYS%20Development%20System/_cds_datatype_array.html&lt;/a&gt;&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>Sorting array of any-sized structure</title><link href="https://forge.codesys.com/forge/talk/Engineering/thread/f7cdba5c33/?limit=25#d743" rel="alternate"/><published>2023-08-17T13:25:54.688000Z</published><updated>2023-08-17T13:25:54.688000Z</updated><author><name>ihatemaryfisher</name><uri>https://forge.codesys.com/u/ihatemaryfisher/</uri></author><id>https://forge.codesys.comcf51aa2ae555029a9c3d65eb51b826289e91a24d</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;p&gt;In my machine's operation, I need to display multiples tables containing arrays of structured variables. The arrays change during operation, and my supervisor has advised me to write a new bubble-sort for each array.&lt;/p&gt;
&lt;p&gt;I think I can make a function to sort an array of any data type.&lt;/p&gt;
&lt;p&gt;This was my own project, and I'm a relatively new coder. I want to know the weaknesses in my approach, and a better method, if one exists. As far as I can test, the function accepts an array of a structured variable &lt;em&gt;of any size&lt;/em&gt;, and sort it by any VAR in that structure. But it relies heavily on pointers, which I've heard are bad practice?&lt;/p&gt;
&lt;p&gt;Function call:&lt;/p&gt;
&lt;div class="codehilite"&gt;&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="err"&gt;// SORT BY BYTE-SIZED VAR&lt;/span&gt;
&lt;span class="err"&gt;IF xDoIt[6] THEN&lt;/span&gt;
&lt;span class="err"&gt;    FUNBubbleSortSansBuffer(&lt;/span&gt;
&lt;span class="err"&gt;        IN_pbySourcePointer := ADR(astArray[1]), // address of first byte in first element of array&lt;/span&gt;
&lt;span class="err"&gt;        IN_pbyComparePointer:= ADR(astArray[1].byCompByte),  // points to first byte of the comparing variable (variable you sort by)&lt;/span&gt;
&lt;span class="err"&gt;        IN_uiStructureSize  := SIZEOF(TYPE_STRUCTURE), // size, in bytes, of the structured variable&lt;/span&gt;
&lt;span class="err"&gt;        IN_uiCompareSize    := SIZEOF(astArray[1].byCompByte), // size, in bytes, of the comparing variable (variable you sort by)&lt;/span&gt;
&lt;span class="err"&gt;        diArrayElements     := UPPER_BOUND(astArray,1), // number of elements in array&lt;/span&gt;
&lt;span class="err"&gt;        IN_xSmallToLarge    := xSortOrder // whether to sort by small2large or large2small&lt;/span&gt;
&lt;span class="err"&gt;    );&lt;/span&gt;
&lt;span class="err"&gt;END_IF&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;


&lt;p&gt;Function:&lt;/p&gt;
&lt;div class="codehilite"&gt;&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;FUNCTION&lt;/span&gt; &lt;span class="nl"&gt;FUNBubbleSortSansBuffer&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;BOOL&lt;/span&gt;
&lt;span class="n"&gt;VAR_INPUT&lt;/span&gt;
    &lt;span class="nl"&gt;IN_pbySourcePointer&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;POINTER&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;BYTE&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// points to beginning of array (first byte of first element)&lt;/span&gt;
    &lt;span class="nl"&gt;IN_pbyComparePointer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;POINTER&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;BYTE&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// points to first byte of the comparing variable (variable you sort by)&lt;/span&gt;
    &lt;span class="nl"&gt;IN_uiStructureSize&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;UINT&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// size, in bytes, of the structured variable&lt;/span&gt;
    &lt;span class="nl"&gt;IN_uiCompareSize&lt;/span&gt;    &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;UINT&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// size, in bytes, of the comparing variable (variable you sort by)&lt;/span&gt;
    &lt;span class="nl"&gt;diArrayElements&lt;/span&gt;     &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;DINT&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// number of elements in array&lt;/span&gt;
    &lt;span class="nl"&gt;IN_xSmallToLarge&lt;/span&gt;    &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;BOOL&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// whether to sort by small2large or large2small&lt;/span&gt;
&lt;span class="n"&gt;END_VAR&lt;/span&gt;
&lt;span class="n"&gt;VAR&lt;/span&gt;
    &lt;span class="nl"&gt;j&lt;/span&gt;       &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;DINT&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// repeat iteration over array until array ends&lt;/span&gt;
    &lt;span class="nl"&gt;i&lt;/span&gt;       &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;DINT&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// iterarte over array, swapping when necesary&lt;/span&gt;
    &lt;span class="nl"&gt;k&lt;/span&gt;       &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;DINT&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// iterator from 1 to size of structure (stepping 'through' a single element in array)&lt;/span&gt;
    &lt;span class="nl"&gt;dwSize&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;DWORD&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// internal var for use in MEMUtils.MemCpy(&amp;lt;size&amp;gt;)&lt;/span&gt;

    &lt;span class="c1"&gt;// FOR SORTING BY BYTE VAR&lt;/span&gt;
    &lt;span class="nl"&gt;pbySourcePointer&lt;/span&gt;    &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;POINTER&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;BYTE&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nl"&gt;pbySourcePointer2&lt;/span&gt;   &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;POINTER&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;BYTE&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nl"&gt;pbyComparePointer&lt;/span&gt;   &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;POINTER&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;BYTE&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nl"&gt;pbyComparePointer2&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;POINTER&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;BYTE&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

    &lt;span class="nl"&gt;pbyPointerToBuffer&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;POINTER&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;BYTE&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// pointer to single byte buffer&lt;/span&gt;
    &lt;span class="nl"&gt;byBufferByte&lt;/span&gt;        &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;BYTE&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// single byte buffer&lt;/span&gt;
&lt;span class="n"&gt;END_VAR&lt;/span&gt;

&lt;span class="nl"&gt;dwSize&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;UINT_TO_DWORD&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;IN_uiStructureSize&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// get structure size (number of bytes)&lt;/span&gt;
&lt;span class="nl"&gt;pbyPointerToBuffer&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;ADR&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;byBufferByte&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// assign pointer to address of buffer byte (because MEMUtils.MemCpy requires a pointer input)&lt;/span&gt;
&lt;span class="n"&gt;CASE&lt;/span&gt; &lt;span class="n"&gt;IN_uiCompareSize&lt;/span&gt; &lt;span class="n"&gt;OF&lt;/span&gt; &lt;span class="c1"&gt;// depending on the size of the VAR to sort by (current functionality for BYTE and WORD/INT&lt;/span&gt;
    &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="c1"&gt;// BYTE (8 BIT)&lt;/span&gt;
        &lt;span class="n"&gt;FOR&lt;/span&gt; &lt;span class="nl"&gt;j&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;diArrayElements&lt;/span&gt; &lt;span class="n"&gt;DO&lt;/span&gt; &lt;span class="c1"&gt;// for number of elements in array&lt;/span&gt;
            &lt;span class="n"&gt;FOR&lt;/span&gt; &lt;span class="nl"&gt;i&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;diArrayElements&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;DO&lt;/span&gt; &lt;span class="c1"&gt;// same thing, but row[i+1] row is included in swap logic&lt;/span&gt;
                &lt;span class="nl"&gt;pbySourcePointer&lt;/span&gt;    &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;IN_pbySourcePointer&lt;/span&gt;  &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;dwSize&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// point at #1 byte in array element[i]&lt;/span&gt;
                &lt;span class="nl"&gt;pbySourcePointer2&lt;/span&gt;   &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;pbySourcePointer&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;dwSize&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;           &lt;span class="c1"&gt;// point at #1 byte in array element[i+1]&lt;/span&gt;

                &lt;span class="c1"&gt;// NOTE: because of memory locations, each array element is offset from one another by a number of bytes equal to the size of the structure&lt;/span&gt;
                &lt;span class="c1"&gt;// We can "walk" from array[i] to array[i+1] via steps equal to the size of the structure&lt;/span&gt;
                &lt;span class="c1"&gt;// e.g., ADR(array[i+1]) == ADR(array[i]) + SIZEOF([array datatype])&lt;/span&gt;

                &lt;span class="nl"&gt;pbyComparePointer&lt;/span&gt;   &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;IN_pbyComparePointer&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;dwSize&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// point to sorting variable in array element[i]&lt;/span&gt;
                &lt;span class="nl"&gt;pbyComparePointer2&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;pbyComparePointer&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;dwSize&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;          &lt;span class="c1"&gt;// point to sorting variable in array element[i+1]&lt;/span&gt;

                &lt;span class="c1"&gt;// using sort order (small -&amp;gt; large/large -&amp;gt; small)&lt;/span&gt;
                &lt;span class="n"&gt;IF&lt;/span&gt; &lt;span class="nf"&gt;SEL&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;IN_xSmallToLarge&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;pbyComparePointer2&lt;/span&gt;&lt;span class="o"&gt;^&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;pbyComparePointer&lt;/span&gt;&lt;span class="o"&gt;^&lt;/span&gt;&lt;span class="p"&gt;),(&lt;/span&gt;&lt;span class="n"&gt;pbyComparePointer2&lt;/span&gt;&lt;span class="o"&gt;^&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="n"&gt;pbyComparePointer&lt;/span&gt;&lt;span class="o"&gt;^&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="n"&gt;THEN&lt;/span&gt;
                    &lt;span class="c1"&gt;// This is where it gets tricky. We've identified pointers for the starting bytes of aArray[i] and aArray[i+1]&lt;/span&gt;
                    &lt;span class="c1"&gt;// and we know the size of aArray[i]. We are going to swap individual bytes, one at a time, from aArray[i] and aArray[i+1]&lt;/span&gt;
                    &lt;span class="c1"&gt;// this allows us to use only a single byte var as a buffer or temporary data storage&lt;/span&gt;
                    &lt;span class="c1"&gt;// e.g., consider a structure consisting of a word, a byte, and a string. it is stored like this&lt;/span&gt;
                        &lt;span class="c1"&gt;//                  |------WORD-------|     |--BYTE-|       |STRING------...|&lt;/span&gt;
                        &lt;span class="c1"&gt;//  astArray[1] ==  1000 0100 0010 0001     1100 0011       1010 1010.... etc&lt;/span&gt;
                        &lt;span class="c1"&gt;//  astArray[2] ==  0001 0010 0100 1000     0011 1100       0101 0101.... etc&lt;/span&gt;
                    &lt;span class="c1"&gt;// performing a single swap (copy into a buffer, etc.) of the first byte of each array element creates this&lt;/span&gt;
                        &lt;span class="c1"&gt;//  astArray[1] ==  0001 0100 0010 0001     1100 0011       1010 1010.... etc&lt;/span&gt;
                        &lt;span class="c1"&gt;//  astArray[2] ==  1000 0010 0100 1000     0011 1100       0101 0101.... etc&lt;/span&gt;
                    &lt;span class="c1"&gt;// incrementing the pointer adresses for the swap by 1 and swapping again swaps the next byte in each array element&lt;/span&gt;
                        &lt;span class="c1"&gt;//  astArray[1] ==  0001 0010 0010 0001     1100 0011       1010 1010.... etc&lt;/span&gt;
                        &lt;span class="c1"&gt;//  astArray[2] ==  1000 0100 0100 1000     0011 1100       0101 0101.... etc&lt;/span&gt;
                    &lt;span class="c1"&gt;// continuing this from k to SIZEOF(TYPE_STRUCTURE) results in a toally swapped row&lt;/span&gt;
                    &lt;span class="n"&gt;FOR&lt;/span&gt; &lt;span class="nl"&gt;k&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="n"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;IN_uiStructureSize&lt;/span&gt; &lt;span class="n"&gt;DO&lt;/span&gt;
                        &lt;span class="c1"&gt;// copy single byte[k] of array element 1 to buffer&lt;/span&gt;
                        &lt;span class="n"&gt;MEMUtils&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;MemCpy&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nl"&gt;pbyDest&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;pbyPointerToBuffer&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;    &lt;span class="nl"&gt;pbySrc&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;pbySourcePointer&lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nl"&gt;dwSize&lt;/span&gt;   &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;                  
                        &lt;span class="c1"&gt;// copy single byte[k] of array element 2 to 1&lt;/span&gt;
                        &lt;span class="n"&gt;MEMUtils&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;MemCpy&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nl"&gt;pbyDest&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;pbySourcePointer&lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;    &lt;span class="nl"&gt;pbySrc&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;pbySourcePointer2&lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nl"&gt;dwSize&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
                        &lt;span class="c1"&gt;// copy buffer to byte[k] array element 2 &lt;/span&gt;
                        &lt;span class="n"&gt;MEMUtils&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;MemCpy&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nl"&gt;pbyDest&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;pbySourcePointer2&lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nl"&gt;pbySrc&lt;/span&gt;  &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;pbyPointerToBuffer&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;dwSize&lt;/span&gt;   &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
                    &lt;span class="n"&gt;END_FOR&lt;/span&gt;
                &lt;span class="n"&gt;END_IF&lt;/span&gt;
            &lt;span class="n"&gt;END_FOR&lt;/span&gt;
        &lt;span class="n"&gt;END_FOR&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;

&lt;/div&gt;</summary></entry></feed>