void f(void)
{
  // declarations
  if (some_expression)
  {
    // more declarations
  }
}
    

#define UNICODE
#define _UNICODE

#include <windows.h>
#include <tchar.h>

#pragma comment(lib,"User32.lib")

//void mainCRTStartup(void)
int WinMainCRTStartup()
{

    SetThreadAffinityMask(GetCurrentThread(),1);

    {

        LARGE_INTEGER t, f;

        QueryPerformanceCounter(&t);
        QueryPerformanceFrequency(&f);

    }

    return 30;
}    

#define STRICT
#define WIN32_LEAN_AND_MEAN

#define UNICODE
#define _UNICODE

#include <windows.h>
#include <windowsx.h>

#pragma warning( disable : 4133 ) //incompatible types - from 'const char *' to 'LPCWSTR'

//VARS

const int g_paranoid = 1;

const int g_window_w = 320;
const int g_window_h = 240;

//used by:
//int_to_wstring
wchar_t g_tempzero[12];
const wchar_t* g_tempzero_endzero = &g_tempzero[10]; //[10] and [11] will always be 0, for wchar_t and for char.
const char* g_tempzero_hexstart = &g_tempzero[1];  //10 - 1 - 8   //(char*)g_tempzero_endzero - 8;


const HINSTANCE g_hInstance = 0x400000;
//g_hInstance = GetModuleHandle(NULL);
//g_hInstance = __ImageBase;

const wchar_t      g_appname[] = L"showjpg";

//FUNCAHEAD
LRESULT CALLBACK WndProc( HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam );
void FUCK();
wchar_t* wcscpy_return_end(wchar_t* dst, wchar_t* src);
char* strcpy_return_end(char* dst, char* src);
wchar_t* int_to_wstring(int the_int);
char* int_to_string(int the_int);
char* int_to_hexstring(UINT32 the_int);
int wstring_to_int(wchar_t* the_string);


void main()
{
        MSG  msg;
        BOOL res;

        ZeroMemory( &msg, sizeof( msg ) );

        //MessageBox(0, L"HAHA", L"HAHA", 0);

        {
                WNDCLASS WndClass;
                
                WndClass.style         = CS_HREDRAW | CS_VREDRAW;
                WndClass.lpfnWndProc   = WndProc;
                WndClass.cbClsExtra    = 0;
                WndClass.cbWndExtra    = 0;
                WndClass.hInstance     = g_hInstance;
                WndClass.hIcon         = NULL;
                WndClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
                WndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
                WndClass.lpszMenuName  = NULL/*MAKEINTRESOURCE(IDR_MENU)*/;
                WndClass.lpszClassName = g_appname;
                
                res = RegisterClass (&WndClass);
                if (!res) FUCK();
        }

        {
                HWND hwnd;

                RECT rc;
        
                // Calculate size of window based on desired client window size
                rc.left = 0;
                rc.top = 0;
                rc.right = g_window_w;
                rc.bottom = g_window_h;
                AdjustWindowRect( &rc, WS_OVERLAPPEDWINDOW, FALSE );
                
                /*HWND */hwnd = CreateWindow(g_appname, g_appname,
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, CW_USEDEFAULT,
                        rc.right-rc.left, rc.bottom-rc.top,
                        NULL, NULL, g_hInstance, NULL);
                
                if (hwnd == NULL) FUCK();
                
                ShowWindow(hwnd, SW_SHOWDEFAULT);
                UpdateWindow(hwnd);
        }

        while( msg.message != WM_QUIT )
    {
                if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
        {
            //TranslateMessage( &msg );
            DispatchMessage( &msg );
        }
        else
                {
                        Sleep(1);
                }
        }

        /*while (1)
        {
                while (PeekMessage(&Msg, g_hwndMain, 0, 0, PM_NOREMOVE))
                {
                        BOOL bGetResult = GetMessage(&Msg, NULL, 0, 0);
                        TranslateMessage(&Msg);
                        DispatchMessage(&Msg);
                        if (bGetResult==0)
                                g_bRunning = false;
                }
                if (g_bRunning)
                {
                        CheckSurfaces();
                        HeartBeat();
                }
        }*/

}


LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        switch( msg )
    {
        case WM_KEYDOWN:
        case WM_RBUTTONDOWN:
        case WM_CLOSE:
                {
                        DestroyWindow(hwnd);
                        return 0;
                }
        case WM_DESTROY:
                {
                        PostQuitMessage( 0 );
                        return 0;
                }
        }
        return DefWindowProc(hwnd, msg, wParam, lParam);
        //return 0;
}

void FUCK() {

        wchar_t* numstring;
        int numstring_length;
        wchar_t* buf;
        wchar_t* buf2;
        wchar_t* buf3;
        wchar_t* buf4;
        wchar_t* buf5;


        DWORD error = GetLastError();
        

        wchar_t* errorString;
    FormatMessageW(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        error,
        MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
        (LPWSTR)&errorString,
        0, NULL );

        /*wchar_t* */numstring = int_to_wstring(error);
        /*int */numstring_length = (wchar_t*)g_tempzero_endzero - numstring;



        /*wchar_t* */buf = (wchar_t*)LocalAlloc(LMEM_ZEROINIT, 
        (lstrlenW((LPCWSTR)errorString) + numstring_length) * sizeof(TCHAR));

        /*wchar_t* */buf2 = wcscpy_return_end(buf, L"FUCK | ");
        /*wchar_t* */buf3 = wcscpy_return_end(buf2, numstring);
        /*wchar_t* */buf4 = wcscpy_return_end(buf3, L" | ");
        /*wchar_t* */buf5 = wcscpy_return_end(buf4, errorString);

        //StringCchPrintf((LPTSTR)lpDisplayBuf, 
 //       LocalSize(lpDisplayBuf) / sizeof(TCHAR),
        //      TEXT("FUCK: %d: %s"), 
 //       error, errorString); 

        MessageBox(0, buf, L"!!!!", 0);

        LocalFree(buf);
    LocalFree(errorString);
    

        __debugbreak();
}


wchar_t* wcscpy_return_end(wchar_t* dst, wchar_t* src) {
        while(1) {
                wchar_t temp = *src++;
                *dst++ = temp;
                if (! temp) return dst-1;
        }
};

char* strcpy_return_end(char* dst, char* src) {
        while(1) {
                char temp = *src++;
                *dst++ = temp;
                if (! temp) return dst-1;
        }
};



wchar_t* int_to_wstring(int the_int) {
        //if (the_int > 9999999999)
        int ostatok;
        wchar_t* cur = g_tempzero_endzero;
        cur--;
        
        while (the_int) {
                ostatok = the_int % 10;
                the_int = the_int / 10;

                *cur = L'0' + ostatok;
                cur--;
        }
        cur++;
        
        return cur;
}

char* int_to_string(int the_int) {
        //if (the_int > 9999999999)
        //LATER: add overflow check
        int ostatok;
        char* cur = (char*)g_tempzero_endzero;
        cur--;
        while (the_int) {
                ostatok = the_int % 10;
                the_int = the_int / 10;

                *cur = '0' + ostatok;
                cur--;
        }
        cur++;
        
        return cur;
}

char* int_to_hexstring(UINT32 the_int) {
        //if (the_int > 9999999999)
        int ostatok;
        char* cur = (char*)g_tempzero_endzero;
        cur--;
        while (the_int) {
                ostatok = the_int % 16;
                the_int = the_int / 16;

                if (ostatok < 10) {
                        *cur = '0' + ostatok;
                } else {
                        *cur = 'a' + ostatok - 10;
                }
                cur--;
        }
        while(cur != g_tempzero_hexstart) {
                *cur--=' ';
        }
        cur++;
        
        return cur;
}

int wstring_to_int(wchar_t* the_string) {
        wchar_t* cur = the_string;
        int the_int = 0;
        int x_num = 1;

        //find the zero
        while (*cur!=0) {
                cur++;
        }
        cur--;
        while (cur >= the_string) {
                the_int += (*cur - L'0')*x_num;
                x_num *= 10;
                cur--;
        }
        return the_int;
}    

"Avoid placing code and data together within a cache line, especially if the data becomes modified."

It doesn't, it just makes life for compilers easier. I haven't seen a compiler that does a good job at creating local variables. Usually they just increase esp once and access them like [ebp-4] [ebp-8], instead of actually using push pop instructions. (This needs checking though.)

for (int i = 0; i < 1000000; i++)
{
  if (condition)
  {
    int x, y;
    ...
  }
  else
  {
    int v, w;
    ...
  }
}    

sub esp, c
mov [esp+4],eax
mov [esp+8],ecx
mov [esp+c],edx
...
add esp, c    

push eax
push ecx
push edx
...
add esp, c    

Because I can measure program size without a problem, but I can't even notice the speed difference for the most part, even on my computer.

So, the question we are talking about now is, choosing between code like this:

It doesn't, it just makes life for compilers easier. I haven't seen a compiler that does a good job at creating local variables. Usually they just increase esp once and access them like [ebp-4] [ebp-8], instead of actually using push pop instructions. (This needs checking though.)

_main
_WndProc    

fatal error LNK1117: syntax error in option 'ORDER:functionorder.txt'    

think this separation improves performance

First is faster, because on cpu, operations are often executed in parallel. Second "push" has to wait for the first "push" to complete, because they both read and write the same register, esp.

The real problem is using registers properly, and using good calling conventions.

By the way, this is the reason the creation (and deletion) of variables mid function is a big deal for me, it will allow to use push pop more neatly, and will allow to reuse the stack space once its value no longer needed. Though, compilers already can detect the last use of a variable without the explicit deletion. And I'm not sure what code compilers choose for mid function variable creation. I don't know anything, I need to study the output.

I liked nested functions in Pascal, and put them in D. They turn out to be surprisingly useful:

1. Properly encapsulating their scope, as opposed to having static functions sit awkwardly somewhere else.
2. Factoring out common code within the function.
3. A lot of my need for goto statements vanished with nested functions.
4. Take the address of a nested function, and it serves as a lambda.
5. No need to create "Context" structs to pass local data to them.
6. They replace a lot of what C macros did.
7. They're inlineable, so are not costly.

I use them more and more as time goes by. It's a pity C doesn't have them, they'd fit nicely into the language.

void main() {
    MessageBoxW(0, L"hello", L"world", 0);
}    

Also, I heard here https://en.wikipedia.org/wiki/X86_calling_conventions about safecall, that encapsulates com exceptions. I'm not sure that this is a good thing, because while playing with direct3d for a bit I haven't seen any exceptions. I don't know if it's possible for direct3d functions to raise an exception, so it's inconvenient if safecall will generate extra code to catch them.

hr := SomeSafecallProcedure(…);
if Failed(hr) then
  raise …    

FreePascal uses register calling convention by default (like Delphi). Its IDE has good Windows support and a built-in debugger. It also supports nested functions (although so do GCC, TCC, maybe others??). Just saying, if you're constantly fighting against your tools, try something else. Hey, DimonSoft agrees with me.

I probably should register on some free pascal forum for this...

@rugxulo
Sorry, can you please compile this program with free pascal (or anything else), for 32bit windows? I want to see if the result will fit in 4 kilobytes. This probably requires to add some flags, to cut out runtime.

Code:

void main() {
    MessageBoxW(0, L"hello", L"world", 0);
}    

Program Hello;
uses windows;
begin
MessageBox(0,'Hello','Hello',0);
end.