Step 1: Generate a list of the file names in Vim.

All the files I wanted were in the same folder, so I simply wrote

:r !dir /B *

If you have different folders, you would want file paths and not only file names. If you have other files in the same folder, you would want to specify a filter (like *.cpp).

Step 2: Record a macro.

Macros are wonderful if you want to repeat a few steps several times. First, position the cursor at the beginning of the line with the first file name. To record a macro, press q followed by the name of the register you want to record to macro to. Since I do not want to reuse this macro after I am done generating the file, I use the q register for my macro. You know, because I am too lazy to move my finger. Put together, this means you need to press qq in normal mode (i.e. after pressing Escape). The bottom left corner now says ‘recording’ to indicate it is, well, recording your macro.

'spiller inn' means 'recording'

Step 3: Read the contents of the current file name.

You now want to press

dd:$r <C-r>"<BS>

The details are explained below. You should see something like this (before pressing backspace):

Notice the first line is gone.

The <Key> construct is Vim notation to specify different keys and key combinations. <C-r> means ‘Hold down control and press r‘, <BS> means backspace and <CR> means the enter/return key (Carriage Return). Let’s break this down:

dd – delete the current line.
: – start an Ex command.
$ – append at the end of the file.
r – read the following into this buffer. This must be followed by a space.
<C-r>" – paste contents of the given buffer. The " buffer contains the previously deleted line.
<BS> – I need to press backspace to remove the ^M (which means carriage return) from Windows line endings. YMMV.

And then finally execute the command with the enter key.

And it goes a little something like something like this.

Step 4: Prepare the next macro run.

Take note of the line number above the cursor, i.e. the line with the last file name. In this example, the number is 13. Now, press gg to return to the first line, then q to stop recording the macro. You may do a test run of the macro by pressing @q if you want to.

Step 5: Finishing the text.

Do you remember the number from the previous step? Good. Now press n@q, but substitute n with the number from step 4. In our example, I would press 13@q. This would run the q macro 13 times.

Note: If you did a test run, decrement the number by one (since you have run the macro once), and press @@ instead of @q. @@ will re-run the previous macro and is faster to type than @q.

No files left, only beautiful code.

Voila! The files are all handily read into your buffer, ready to be pasted into Wordle.

For completeness, here’s the generated result based on the example code base:

Words on a screen.

But I am special, so I do want to.

First, let us recap what ::operator new and ::operator delete really are. (The double colons simply mean that they are in the global namespace, and not in the std namespace. But you probably already knew that.) “Oh, that’s easy,” you might say.” When you say ‘new Foo()‘, you call ::operator new, and when you ‘delete foo’, you call ::operator delete, right?”  Wrong. Well, it is true that those operators are called, but they are just two pieces in the big picture. We need to separate between ‘the new expression‘ (sometimes called the new operator), and ‘operator new’.

And so each bit allocated by operator new is flipped to its correct state

Operator new is fairly simple, but comes in many forms. It is responsible for allocating memory, much like malloc(). It has two main forms: operator new and operator new[]. Each of these has three global overloads: The normal version, a nothrow-version and placement new. The latter two are simple: The nothrow variant should return a null pointer if allocation fails, rather than call any new_handlers or throw std::bad_alloc. Placement operator new just returns its pointer argument – it is basically a no-op used to trick the new-expression into calling the constructor for us. Apart from these six global variants, each class can overload its own operator new, thus allowing for an arbitrary number of different ‘operator new’s. The typical reason for overloading operator new is to allow for more efficient memory storage on a per-class basis.

The new-expression is special. There are only two of them: new and new[]. Their mission is to allocate dynamic memory for whatever they are creating and call all the correct constructors. This includes constructors for each object in the case of new[]. The new-expression will also have to call the constructors for base classes or contained classes. They can not be overloaded or replaced.

As usual, Newton’s third law of C++ applies to new and delete – for every new there is an equal and opposite delete. Most of the above is equal (but opposite) for operator delete and the delete-expression.

Normally, if you are not satisfied with ::operator new, then you overload it for your particular class or classes. But for me, the situation is different. I am developing embedded software, and the platform we work on needs to carefully place objects in memory. For C code, this means that we use a function called umalloc() rather than regular malloc(). For C++, we need to ensure that the new-expression gets its memory through umalloc(), which means replacing ::operator new.

Yes, replacing. Not overloading. The global ‘operator new’s and ‘operator delete’s are implicitly declared, and we can replace them simply by providing a new definition. But the behavior of ::operator new is not as straightforward as you might think. You can’t just write:

void* operator new(size_t n) {
    void* new_memory = malloc(n);
    if (new_memory == nullptr) {
        return new_memory;
    }

    throw std::bad_alloc();
}

As the accepted answer to this question on StackOverflow explains, there is more to it than that, and most of it boils down to new_handlers. I will spare you the boring details (you can read the answer for more information), and simply jump straight to the code I ended up with:

#include <new>
#include <stdexcept>

// Scalar regular new
void* operator new(std::size_t n) throw(std::bad_alloc)
{
    using namespace std;

    for (;;) {
        void* allocated_memory = ::operator new(n, nothrow);
        if (allocated_memory != 0) return allocated_memory;

        // Store the global new handler
        new_handler global_handler = set_new_handler(0);
        set_new_handler(global_handler);

        if (global_handler) {
            global_handler();
        } else {
            throw bad_alloc();
        }
    }
}

// Scalar nothrow new
void* operator new(std::size_t n, std::nothrow_t const&) throw()
{
    if (n == 0) n = 1;

    return malloc(n);
}

// Array regular new
void* operator new[](std::size_t n) throw(std::bad_alloc)
{
    return ::operator new(n);
}

// Array nothrow new
void* operator new[](std::size_t n, std::nothrow_t const&) throw()
{
    return ::operator new(n, std::nothrow);
}

// Scalar regular delete (doesn't throw either)
void operator delete(void* p) throw()
{
    free(p);
}

// Scalar nothrow delete
void operator delete(void* p, std::nothrow_t const&) throw()
{
    ::operator delete(p);
}

// Array regular delete
void operator delete[](void* p) throw()
{
    ::operator delete(p);
}

// Array nothrow delete
void operator delete[](void* p, std::nothrow_t const&) throw()
{
    ::operator delete(p);
}

The reason we have nothrow-versions of operator delete, even when regular delete never throws, is because of the law of equal and opposite news and deletes - when memory has been allocated with nothrow new, it will be deallocated with nothrow delete.

With the exception of any bugs it may contain (I have not found any, so there are probably many left), this should be the typical way to replace ::operator new and ::operator delete. But you almost never want to do that anyway.

Unless you are special.

The steps we have taken so far include:

• Using a more mobile-friendly theme when visiting the site from a mobile browser. (If you ever have any problems with the mobile browser detection, we would love to hear from you!)
• Removing header image from the mobile theme.
• Limiting the number of posts shown.
• Splitting long posts into multiple pages when viewed on a mobile device.

We hope you enjoy reading codebloat on a mobile device!