C / C++ / MFC

char * buffer = "World!Hello, ";

char * buffer = "Hello, World!";

namespace CommonTools
  {
 /// Code by Shepel' Nikolay E., Moscow, Russia, published at 22 July 2017, http://www.codeproject.com.
#ifdef DEBUG
  uint32_t scroll_raw_buffer_last_rounds = 0;
#endif

  void scroll_raw_buffer (void *data , const uint32_t buffer_size, uint32_t distance)
  {
#ifdef DEBUG
    scroll_raw_buffer_last_rounds = 0; // Statistics about rounds...
#endif
    // Для реализации скроллинга необходим двойной запас по размеру буффера,
    // т.е. buffer_size<(UINT_MAX/2) если использовать в функции 32х разрядные
    // переменные, иначе можем выскачить за их максимальный размер, если
    // надо будет буффер сместить влево на 1.

    // WARNING!!!
    // We need double reserve for addressing buffer elements (buffer_size<(UINT_MAX/2)).
    // Otherwise we can get register overflow while scrolling buffer with
    // size>=INT_MAX to the left with distance==1
    if (buffer_size >= INT_MAX)
      throw CommonTools::Errors::Simple (CommonTools::Errors::StE_Overflow, __PLACE__);

    if ( (!data) || (buffer_size < 2)) return;
    distance %= buffer_size;
    if (!distance) return;
    TRAP_in_DEBUG (distance >= buffer_size, msg_interror)

    uint8_t *buf = (uint8_t *) data;
    const uint32_t shift_value = distance;



#ifdef DEBUG
    static const size_t max_stack_buffer = 256;
#else
    static const size_t max_stack_buffer = 1024;
#endif

    // If buffer size is quite small we can use the simplest way...
    if (buffer_size <= max_stack_buffer)
      {
        uint8_t *tmp_buf = (uint8_t *) alloca (buffer_size);
        memcpy (tmp_buf, buf, buffer_size);

        memcpy (buf + shift_value, tmp_buf, buffer_size - shift_value);
        memcpy (buf, tmp_buf + buffer_size - shift_value, shift_value);
        return;
      }

#ifdef DEBUG
    scroll_raw_buffer_last_rounds = 1;
#endif

    uint32_t bytes_left = buffer_size, bytes_per_round = 0;
    uint32_t total_rounds = 0;
    uint32_t round_number = 1; // [1...total_rounds]
    uint8_t  *next_data_buffer = 0;
    uint32_t dest_index;
#ifdef DEBUG
    const uint8_t * const out_of_buffer = buf + buffer_size;
#endif

    do // Starting "merry-go-round"
      {
        {
          const uint32_t round_start_offset = round_number - 1;
          dest_index = round_start_offset;
          if (dest_index >= buffer_size) dest_index -= buffer_size;
          uint8_t next_data = buf[dest_index];
          do
            {
              dest_index += shift_value; if (dest_index >= buffer_size) dest_index -= buffer_size;
              register uint8_t &destination = buf [dest_index];
              swap (destination, next_data);
              bytes_left--;
            }
          while (dest_index != round_start_offset);
        }

        if (!bytes_left) // If it was last round (or the single one) we finish here...
          break;
        if (round_number == 1)
          {
            bytes_per_round = buffer_size - bytes_left;
            total_rounds = buffer_size / bytes_per_round;
#ifdef DEBUG
            scroll_raw_buffer_last_rounds = total_rounds;
#endif
            // The residue of division must be zero !!!
            TRAP_in_DEBUG (buffer_size % bytes_per_round, msg_bogus_state)
          }
        round_number++;

        // If we come here so multiple rounds are required  for scroll operation
        // I think it is because buffer length and distance have common dividors... (I'm not strong in mathematics)
        // We can use some sort of optimisation in this case. We can move blocks of data.
        // The size of such blocks are limited by common dividors mensioned before...

        if (!next_data_buffer) // The temporary buffer for blocks operation.
          next_data_buffer = (uint8_t *) alloca (max_stack_buffer);

        // The code in cycle below is usefull if block_size>1.
        // We check this indirectly by means of condition in "for()" statement below.
        // Otherwise this cycle will be skipped and upper cycle
        // will be used with single byte code.
        for (;round_number  < total_rounds;) //the same condition as if we use "(total_rounds-round_number+1)>1" but less operations are required
          {
            const uint32_t rounds_left = total_rounds - round_number + 1;
            // Activating block move
            const size_t block_size = min_ct (max_stack_buffer, rounds_left);
            const uint32_t round_start_offset = round_number - 1;
            dest_index = round_start_offset;
            if (dest_index >= buffer_size) dest_index -= buffer_size;

            TRAP_in_DEBUG (buf + dest_index + block_size >= out_of_buffer, msg_interror)
            memcpy (next_data_buffer, buf + dest_index, block_size);
            TRAP_in_DEBUG (bytes_left < bytes_per_round*block_size, msg_interror)
            do // block move DO
              {
                dest_index += shift_value; if (dest_index >= buffer_size) dest_index -= buffer_size;
                register uint8_t *destination = buf + dest_index;

/**
        If region to copy overlaps the end of main buffer, special copy
        routine is required (see below).
        But this is never happens, because after the end of the buffer
        the beggining  starts. The beggining element is moved at the
        firstest step in upper cycle. The algo is designed that it is
        impossible if some byte is moved twice.
        So I left this commented (disabled) block (I am not sure that
        it is works good because it is never tested):
**/
/*
                if (destination + block_size > out_of_buffer)
                  {
                    const uint32_t part1 = out_of_buffer-destination;
                    TRAP_in_DEBUG (part1>block_size,msg_interror)
                    memswap (destination,next_data_buffer,part1);
                    const uint32_t part2 = block_size-part1;
                    memswap (buf,next_data_buffer+part1,part2);
                  }
                else
*/
              memswap (destination, next_data_buffer, block_size);
              } // EOF block move DO
            while (dest_index != round_start_offset);
            bytes_left -= bytes_per_round * block_size;
            round_number += block_size;
          } // EOF for (;round_number  < total_rounds;)
      } // Do "merry-go-round"
    while (bytes_left > 0);

    return;
  }

} // namespace CommonTools