Chastity's Chess Challenge

Chastity’s Chess Blog

  • 6502 Assembly monochrome demo

    As if learning Intel x86 Assembly wasn’t weird enough, I have decided to learn some basic 6502 Assembly. This CPU was used in the NES and the Apple 2 computers. I found an Easy 6502 emulator that runs entirely within a web page. The only form of output is the pixels in a window that represent memory addresses on a fictional computer. I made a very cool demo. Below is my source code.

    ;this part draws vertical stripes
lda #$0
tax
tay
loop_stripe_vertical:
sta $200,x
inx
eor #$1
iny
cpy #$0
bne loop_stripe_vertical

;this part makes a checkerboard
lda #$0
tax
tay
loop_checkerboard:
sta $380,x
inx
eor #$1

iny
cpy #$20
bne color_keep_checker

pha ;push A to the stack
lda #$0 ;load A with zero
tay ;transfer A to Y
pla ;pull original A back from stack
eor #$1

color_keep_checker:
cpx #$0
bne loop_checkerboard

;this part draws horizontal stripes
lda #$0
tax
tay
loop_stripe_horizontal:
sta $500,x
inx
;eor #$1

iny
cpy #$20
bne color_keep

pha ;push A to the stack
lda #$0 ;load A with zero
tay ;transfer A to Y
pla ;pull original A back from stack
eor #$1

color_keep:
cpx #$0
bne loop_stripe_horizontal

    When assembled and run, the result looks like this. Small routines that draw stripes and a checkerboard based on the way this specific emulator works.

    This example, while extremely cool, is limited in its usefulness compared to a program that runs on a PC with a way of outputting text to a terminal. If I find the right kind of emulator, I would like to figure out how to rewrite some of my Intel Assembly programs into 6502 Assembly. Honestly, the languages are different but the math is still the same once I find the correct name of the instruction to do what I want. I am following this reference.

    http://www.6502.org/tutorials/6502opcodes.html

  • Chastity Windows Reverse Engineering Notes

    The Windows version of FASM includes header files for the Windows API. It also includes some examples, but not a single one of them were a simple “Hello World” console program.

    Fortunately, I was able to find one that actually assembled and ran on the FASM forum. Below is the source code.

    format PE console
include 'win32ax.inc'
.code
start:
invoke  WriteConsole, <invoke GetStdHandle,STD_OUTPUT_HANDLE>,"Hello World!",12,0
invoke  ExitProcess,0
.end start

    To get it working required me to keep the include files in a location I remembered and set the include environment variable. I found this out from the FASM Windows documentation.

    set include=C:\fasm\INCLUDE

    However, there was another problem. The example that I found online and got working uses macros, most specifically, one called “invoke”. While this works if you include the headers, it hides the details of what is actually happening. Therefore, I decided to reverse engineer the process by using NOP instructions to sandwich the bytes of machine code.

    90 hex is the byte for NOP (No OPeration). So to extract the macro call that exits the program, I use this.

    db 10h dup 90h
invoke  ExitProcess,0
db 10h dup 90h

    Then I disassemble the executable and find the actual instructions given.

    ndisasm main.exe -b 32 > disasm.txt

    As simple as this method is, it actually works. For example, this output is given as part of the output.

    0000022D  90                nop
0000022E  90                nop
0000022F  90                nop
00000230  90                nop
00000231  90                nop
00000232  90                nop
00000233  90                nop
00000234  90                nop
00000235  90                nop
00000236  90                nop
00000237  90                nop
00000238  90                nop
00000239  90                nop
0000023A  90                nop
0000023B  90                nop
0000023C  90                nop
0000023D  6A00              push dword 0x0
0000023F  FF1548204000      call dword near [0x402048]
00000245  90                nop
00000246  90                nop
00000247  90                nop
00000248  90                nop
00000249  90                nop
0000024A  90                nop
0000024B  90                nop
0000024C  90                nop
0000024D  90                nop
0000024E  90                nop
0000024F  90                nop
00000250  90                nop
00000251  90                nop
00000252  90                nop
00000253  90                nop
00000254  90                nop

    There can be no mistake that it is that location between the NOPs where the relevant code is. Therefore, I replaced the macro that exits the program with this.

    ;Exit the process with code 0
 push 0
 call [ExitProcess]

    What I learned

    As I repeated the same process for the other macros, I found that the way system calls in Windows work is that the numbers are pushed onto the stack in the reverse order they are needed. I was able to decode the macros and get a working program without the use of “invoke”. Here is the full source!

    format PE console
include 'win32ax.inc'

main:

;Write 13 bytes from a string to standard output
push 0              ;this must be zero. I have no idea why!  
push 13             ;number of bytes to write
push main_string    ;address of string to print
push -11            ;STD_OUTPUT_HANDLE = Negative Eleven
call [GetStdHandle] ;use the above handle
push eax            ;eax is return value of previous function
call [WriteConsole] ;all the data is in place, do the write thing!

;Exit the process with code 0
push 0
call [ExitProcess]

.end main

main_string db 'Hello World!',0Ah

    I don’t know much about the Windows API, but I did discover some helpful information when I searched the names of these functions that were part of the original macros.

    https://learn.microsoft.com/en-us/windows/console/getstdhandle
    https://learn.microsoft.com/en-us/windows/console/writeconsole

    Why I did this

    You might wonder why I even bothered to get a working Windows API program in Assembly Language. After all, I am a Linux user to the extreme. However, since Windows is the most used operating system for the average person, I figured that if I write any useful programs in Assembly for 32-bit Linux, I can probably port them over to Windows by changing just a few things.

    Since my toy programs are designed to write text to the console anyway and I don’t do GUI stuff unless I am programming a game in C with SDL, I now have enough information from this small Hello World example to theoretically write anything to the console that I might want to in an official Windows executable.

    Obviously I need to learn a lot more for bigger programs but this is the first Assembly program I have ever gotten working for Windows, despite my great success with DOS and Linux, which are easier because they are better documented and ARE TAUGHT BETTER by others. People programming Assembly in Windows have been ruined by macros which hide the actual instructions being used. As I learn how these things work, I will be sure to pass on the information to others!

  • chastehex-DOS-32-bit

    This is a video showing some very long source code of a DOS program I wrote using Assembly Language.

    This program is technically a 16 bit DOS .com program and yet it can access 32 bit addresses of the file it operates on because the LSEEK DOS call uses CX:DX as a 32 bit address by using two 16 bit registers. By modifying several parts of the program, I improved upon it greatly. It should theoretically be able to operate on any file less than 2 gigabytes even though the program itself never accesses more than 16 bytes at one time.

    I may have just invented the world’s smallest and fastest DOS hex dumper and editor. The official gitlab repository has the source code seen in this video as well as the Linux 32 bit Assembly and the original C version I wrote first when I invented this program.

    https://gitlab.com/chastitywhiterose/chastehex.git

    I will have to make more videos showing examples of how it can be used, but I have a readme file in the repository that explains what it does and why I made it.

    ——–D-2142——————————-
    INT 21 – DOS 2+ – “LSEEK” – SET CURRENT FILE POSITION
    AH = 42h
    AL = origin of move
    00h start of file
    01h current file position
    02h end of file
    BX = file handle
    CX:DX = (signed) offset from origin of new file position
    Return: CF clear if successful
    DX:AX = new file position in bytes from start of file
    CF set on error
    AX = error code (01h,06h) (see #01680 at AH=59h/BX=0000h)
    Notes: for origins 01h and 02h, the pointer may be positioned before the
    start of the file; no error is returned in that case (except under
    Windows NT), but subsequent attempts at I/O will produce errors
    if the new position is beyond the current end of file, the file will
    be extended by the next write (see AH=40h); for FAT32 drives, the
    file must have been opened with AX=6C00h with the “extended size”
    flag in order to expand the file beyond 2GB
    BUG: using this method to grow a file from zero bytes to a very large size
    can corrupt the FAT in some versions of DOS; the file should first
    be grown from zero to one byte and then to the desired large size
    SeeAlso: AH=24h,INT 2F/AX=1228h

  • DOS Assembly putstring function

    This is a small program which uses the putstring function I wrote. This function is one of 4 ultimate functions I have created which make up “chastelib”. DOS programming is simpler than Windows and is not that different from Linux in that system calls are done with an interrupt.

    org 100h

main:

mov ax,text
call putstring

mov ax,4C00h
int 21h

text db 'Hello World!',0Dh,0Ah,0

;This section is for the putstring function I wrote.
;It will print any zero terminated string that register ax points to

stdout dw 1 ; variable for standard output so that it can theoretically be redirected

putstring:

push ax
push bx
push cx
push dx

mov bx,ax                  ;copy ax to bx for use as index register

putstring_strlen_start:    ;this loop finds the length of the string as part of the putstring function

cmp [bx], byte 0           ;compare this byte with 0
jz putstring_strlen_end    ;if comparison was zero, jump to loop end because we have found the length
inc bx                     ;increment bx (add 1)
jmp putstring_strlen_start ;jump to the start of the loop and keep trying until we find a zero

putstring_strlen_end:

sub bx,ax                  ; sub ax from bx to get the difference for number of bytes
mov cx,bx                  ; mov bx to cx
mov dx,ax                  ; dx will have address of string to write

mov ah,40h                 ; select DOS function 40h write 
mov bx,[stdout]            ; file handle 1=stdout
int 21h                    ; call the DOS kernel

pop dx
pop cx
pop bx
pop ax

ret

    Anyone can assemble and run this source code, but you will need a DOS emulator like DOSBox in order for it to work. In fact, I have a video showing me assembling and running it inside of DOSBox.

    Lately I have been having a programming phase and am working on a book about programming in DOS. There is no money involved in this because nobody except nerds like me care about DOS. Speaking of nerds, if you follow my blog, don’t forget that this site was set up for teaching Chess. Leave me a comment if you play Chess online or live in Lee’s Summit. I am still playing Chess every day although some of my time has been taken up with programming in Assembly language because it is so much fun.

    If you like this post, you may be interested in my much longer post/book that is all about Assembly programming in DOS.

    Assembly Arithmetic Algorithms 16-bit DOS Edition

  • Chastity’s Hex Compare Tool

    Welcome to Chastity’s Hex Compare program also known as “chastecmp”. Enter two filenames as command line arguments such as:

    ./chastecmp file1.txt file2.txt

    It works for any binary files too, not just text. In fact for text comparison you want entirely different tools. This tool can be used to find the tiny differences between files in hexadecimal. It shows only those bytes which are different. I wrote it as a solution to a reddit user who asked how to compare two files in hexadecimal.

    It is an improvement over the Linux “cmp” tool which displays the offsets in decimal and the bytes in octal. Aside from using two different bases in the data, it falls short of usefulness because there are more hex editors than octal editors.

    Here are also some graphical tools I can recommend if you are looking for a GUI instead of my command line program.

    vbindiff
    wxHexeditor

    Below is the full source code:

    #include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[])
{
 int argx,x;
 FILE* fp[3]; /*file pointers*/
 int c1,c2;
 long flength[3]; /*length of the file opened*/
   
 /*printf("argc=%i\n",argc);*/

 if(argc<3)
 {
  printf("Welcome to Chastity's Hex Compare program also known as \"chastecmp\".\n\n");
  printf("Enter two filenames as command line arguments such as:\n");
  printf("%s file1.txt file2.txt\n",argv[0]);
  return 0;
 }

 argx=1;
 while(argx<3)
 {
   fp[argx] = fopen(argv[argx], "rb"); /*Try to open the file.*/
   if(!fp[argx]) /*If the pointer is NULL then this becomes true and the file open has failed!*/
   {
    printf("Error: Cannot open file \"%s\": ",argv[argx]);
    printf("No such file or directory\n");
    return 1;
   }
  /*printf("File \"%s\": opened.\n",argv[argx]);*/

  printf("fp[%X] = fopen(%s, \"rb\");\n",argx,argv[argx]);
  argx++;
 }

 printf("Comparing files %s and %s\n",argv[1],argv[2]);

 argx=1;
 while(argx<3)
 {
  fseek(fp[argx],0,SEEK_END); /*go to end of file*/
  flength[argx]=ftell(fp[argx]); /*get position of the file*/
  printf("length of file fp[%X]=%lX\n",argx,flength[argx]);
  fseek(fp[argx],0,SEEK_SET); /*go back to the beginning*/
  argx++;
 }

 x=0;
 while(x<flength[1])
 {
  c1 = fgetc(fp[1]);
  c2 = fgetc(fp[2]);
  if(c1!=c2)
  {
   printf("%08X: %02X %02X\n",x,c1,c2);
  }
  x++;  
 }

 argx=1;
 while(argx<3)
 {
  fclose(fp[argx]);
  printf("fclose(fp[%X]);\n",argx);
  argx++;
 }

 return 0;
}

  • Assembly Chaste Lib

    I have created two functions in x86 Assembly Language that allow me to output any zero terminated string or output any integer in any base from 2 to 36. I will show the full source so people can play with it. This uses system calls on Linux so it won’t work on Windows.

    first, the header file “chaste-lib.asm”

    ; This file is where I keep my function definitions.
; These are usually my string and integer output routines.

putstring: ; function to print zero terminated string pointed to by register eax

mov edx,eax ; copy eax to edx as well. Now both registers have the address of the main_string

strlen_start: ; this loop finds the lenge of the string as part of the putstring function

cmp [edx],byte 0 ; compare byte at address edx with 0
jz strlen_end ; if comparison was zero, jump to loop end because we have found the length
inc edx
jmp strlen_start

strlen_end:
sub edx,eax ; edx will now have correct number of bytes when we use it for the system write call

mov ecx,eax ; copy eax to ecx which must contain address of string to write
mov eax, 4  ; invoke SYS_WRITE (kernel opcode 4)
;mov ebx, 1  ; ebx=1 means write to the STDOUT file
int 80h     ; system call to write the message

ret ; this is the end of the putstring function return to calling location






radix dd 16 ;radix or base for integer output. 2=binary, 16=hexadecimal, 10=decimal

putint: ; function to output decimal form of whatever integer is in eax

push eax ;save eax on the stack to restore later

mov ebp,int_string+31 ;address of start digits

digits_start:

mov edx,0;
mov esi,[radix] ;radix is from memory location just before this function
div esi
cmp edx,10
jb decimal_digit
jge hexadecimal_digit

decimal_digit: ;we go here if it is only a digit 0 to 9
add edx,'0'
jmp save_digit

hexadecimal_digit:
sub edx,10
add edx,'A'


save_digit:

mov [ebp],dl
cmp eax,0
jz digits_end
dec ebp
jmp digits_start

digits_end:

mov eax,ebp ; now that the digits have been written to the string, display it!
call putstring

pop eax  ;load eax from the stack so it will be as it was before this function was called
ret

    next, the main source that includes the header: “main.asm”

    format ELF executable
entry main

include 'chaste-lib.asm'

main: ; the main function of our assembly function, just as if I were writing C.

; I can load any string address into eax and print it!

mov ebx, 1 ;ebx must be 1 to write to standard output

mov eax,msg
call putstring
mov eax,main_string ; move the address of main_string into eax register
call putstring

mov [radix],2 ; can choose radix for integer output!

mov eax,0
loop1:
call putint
inc eax
cmp eax,100h;
jnz loop1

mov eax, 1  ; invoke SYS_EXIT (kernel opcode 1)
mov ebx, 0  ; return 0 status on exit - 'No Errors'
int 80h

; this is where I keep my string variables

msg db 'Hello World!', 0Ah,0     ; assign msg variable with your message string
main_string db "This is Chastity's Assembly Language counting program!",0Ah,0
int_string db 32 dup '?',0Ah,0



; This Assembly source file has been formatted for the FASM assembler.
; The following 3 commands assemble, give executable permissions, and run the program
;
;	fasm main.asm
;	chmod +x main
;	./main

    If you have the fasm compiler, you can assemble this source on any Linux distribution running on an intel CPU. Assembly is platform specific but it runs really fast and the process of programming with it is enjoyable for me.

  • Assembly Language Counting Program

    I have been learning x86 assembly language. I know a little bit from years ago but now it is coming back to me. I formerly did 16 bit DOS hobby programs. This is 32 bit Linux programming in assembly using FASM as my assembler.

    format ELF executable
entry main

main: ; the main function of our assembly function, just as if I were writing C.

; I can load any string address into eax and print it!

mov eax,msg
call putstring
mov eax,main_string ; move the address of main_string into eax register
call putstring


mov eax,0
loop1:
call putint
inc eax
cmp eax,16;
jnz loop1

mov eax, 1  ; invoke SYS_EXIT (kernel opcode 1)
mov ebx, 0  ; return 0 status on exit - 'No Errors'
int 80h

; this is where I keep my string variables

msg: db 'Hello World!', 0Ah,0     ; assign msg variable with your message string
main_string db 'This is the assembly counting program!',0Ah,0
int_string db 32 dup '?',0Ah,0

; this is where I keep my function definitions

putstring: ; function to print zero terminated string pointed to by register eax

mov edx,eax ; copy eax to edx as well. Now both registers have the address of the main_string

strlen_start: ; this loop finds the lenge of the string as part of the putstring function

cmp [edx],byte 0 ; compare byte at address edx with 0
jz strlen_end ; if comparison was zero, jump to loop end because we have found the length
inc edx
jmp strlen_start

strlen_end:
sub edx,eax ; edx will now have correct number of bytes when we use it for the system write call

mov ecx,eax ; copy eax to ecx which must contain address of string to write
mov eax, 4  ; invoke SYS_WRITE (kernel opcode 4)
mov ebx, 1  ; write to the STDOUT file
int 80h     ; system call to write the message

ret ; this is the end of the putstring function return to calling location

putint: ; function to output decimal form of whatever integer is in eax

push eax ;save eax on the stack to restore later

mov ebx,int_string+31 ;address of start digits

digits_start:

mov edx,0;
mov esi,10
div esi
add edx,'0'
mov [ebx],dl
cmp eax,0
jz digits_end
dec ebx
jmp digits_start

digits_end:

mov eax,ebx ; now that the digits have been written to the string, display it!
call putstring

pop eax  ;load eax from the stack so it will be as it was before this function was called
ret

; This Assembly source file has been formatted for the FASM assembler.
; The following 3 commands assemble, give executable permissions, and run the program
;
;	fasm main.asm
;	chmod +x main
;	./main

    This program only works on computers with Intel x86 CPUs and running a Linux distribution. the “int 80h” instructions mean interrupt 128. For some reason, this calls the Linux kernel. I don’t know why it works this way but I do know enough assembly to write my own string and integer routines to replace printf since it is not available in pure assembly like I could in the C programming language.

  • The Negative Powers of Two

    The negative powers of two are what happens when you start at 1 and keep dividing by 2. Although normally fractional numbers of this sort can’t exist for the integer type, I can simulate it using an array of decimal digits and my pattern recognition to write the small program below which gives the correct digits.

    /*negative powers of two*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
 /*most important variable: number of digits*/
 int length=64;

 char *a;
 int alength=2,x,y,temp;

 a=(char*)malloc(length*sizeof(*a));if(a==NULL){printf("Failed to create array a\n");return(1);}

 x=0;
 while(x<length)
 {
  a[x]=0;
  x++;
 }
 a[0]=1;

 while(alength<length)
 {
  printf("%i.",a[0]);

  x=1;
  while(x<alength)
  {
   printf("%d",a[x]);
   x++;
  }
  printf("\n");

  y=0;
  x=0;
  while(x<length)
  {
   if( (a[x]&1)==1 ){temp=5;}else{temp=0;} 
   a[x]>>=1;
   a[x]+=y;
   y=temp;
   x++;
  }
  if(a[alength]>0){alength++;}

 }

 if(a!=NULL){free(a); a=NULL;}

 return 0;
}

    The output of the above program is:

    1.0
    0.5
    0.25
    0.125
    0.0625
    0.03125
    0.015625
    0.0078125
    0.00390625
    0.001953125
    0.0009765625
    0.00048828125
    0.000244140625
    0.0001220703125
    0.00006103515625
    0.000030517578125
    0.0000152587890625
    0.00000762939453125
    0.000003814697265625
    0.0000019073486328125
    0.00000095367431640625
    0.000000476837158203125
    0.0000002384185791015625
    0.00000011920928955078125
    0.000000059604644775390625
    0.0000000298023223876953125
    0.00000001490116119384765625
    0.000000007450580596923828125
    0.0000000037252902984619140625
    0.00000000186264514923095703125
    0.000000000931322574615478515625
    0.0000000004656612873077392578125
    0.00000000023283064365386962890625
    0.000000000116415321826934814453125
    0.0000000000582076609134674072265625
    0.00000000002910383045673370361328125
    0.000000000014551915228366851806640625
    0.0000000000072759576141834259033203125
    0.00000000000363797880709171295166015625
    0.000000000001818989403545856475830078125
    0.0000000000009094947017729282379150390625
    0.00000000000045474735088646411895751953125
    0.000000000000227373675443232059478759765625
    0.0000000000001136868377216160297393798828125
    0.00000000000005684341886080801486968994140625
    0.000000000000028421709430404007434844970703125
    0.0000000000000142108547152020037174224853515625
    0.00000000000000710542735760100185871124267578125
    0.000000000000003552713678800500929355621337890625
    0.0000000000000017763568394002504646778106689453125
    0.00000000000000088817841970012523233890533447265625
    0.000000000000000444089209850062616169452667236328125
    0.0000000000000002220446049250313080847263336181640625
    0.00000000000000011102230246251565404236316680908203125
    0.000000000000000055511151231257827021181583404541015625
    0.0000000000000000277555756156289135105907917022705078125
    0.00000000000000001387778780781445675529539585113525390625
    0.000000000000000006938893903907228377647697925567626953125
    0.0000000000000000034694469519536141888238489627838134765625
    0.00000000000000000173472347597680709441192448139190673828125
    0.000000000000000000867361737988403547205962240695953369140625
    0.0000000000000000004336808689942017736029811203479766845703125
    0.00000000000000000021684043449710088680149056017398834228515625

    I know this post is not exactly Chess related but I am thinking of using this site to double as a way to share some of my computer programming code too. I also may be able to create mathematical data structures to represent the game of Chess in some way.

    I am writing a book about Chess and so I may sometimes share cool programs like this that are heavily math related. My obsession with numbers is how I got my start in programming originally.

  • Installing SDL2 on Debian Linux

    The commands I used to install SDL version 2.32.8 from the source archive on my Debian Linux system.

    ./configure –prefix=/usr make sudo make install

    Sources I read

    Linux and other UNIX systems: * Run ‘./configure; make; make install’

    https://wiki.libsdl.org/SDL2/Installation

    At first I forgot to specify the /usr prefix. I messed up my system and nothing was compiling because the default /usr/local was where the new install was whereas all the other libraries were installed in subdirectories of /usr.

    Therefore I had to repead the command and then remove the sdl2-config file from the /usr/local/bin directory.

    Then everything compiled as before, even my Tetris game and my new LGBT font library.

    Technically I did not need the latest SDL2 version available but I wanted to learn how to install updates from source rather than only relying on the Debian repositories.

    This is because I am considering making my own Linux distribution.

  • 3 SDL Examples

    This post isn’t Chess related but it is still very nerdy. I have made 3 different SDL programs that all do the exact same thing. However they are written using different SDL versions over time as the API has changed. Therefore, SDL version 1,2, and 3 source code is provided as well as the commands to compile them!

    SDL Version 1

    #include <stdio.h>
#include <SDL.h>
int width=1280,height=720;
int loop=1;
SDL_Surface *surface;
SDL_Event e;
int main(int argc, char **argv)
{
 if(SDL_Init(SDL_INIT_EVERYTHING)){return 1;}

 SDL_putenv("SDL_VIDEO_WINDOW_POS=center");
 SDL_WM_SetCaption("SDL1 Program",NULL);
 surface=SDL_SetVideoMode(width,height,32,SDL_SWSURFACE);
 if(surface==NULL){return 1;}

 SDL_FillRect(surface,NULL,0xFF00FF);

 while(loop)
 {
  while(SDL_PollEvent(&e))
  {
   if(e.type==SDL_QUIT){loop=0;}
   if(e.type==SDL_KEYUP){if(e.key.keysym.sym==SDLK_ESCAPE){loop=0;}}
  }
  SDL_Flip(surface);
 }

 SDL_Quit();
 return 0;    
}

/*
SDL1 program that creates a window but nothing else.
Closes when user presses Esc or clicks the X of the window.
This is to test whether SDL1 programs can be compiled.

 With the sdl-config script:
 gcc -Wall -ansi -pedantic sdl1-test.c -o sdl1-test `sdl-config --cflags --libs` && ./sdl1-test

 Without the sdl-config script:
 gcc -Wall -ansi -pedantic sdl1-test.c -o sdl1-test -I/usr/include/SDL -D_GNU_SOURCE=1 -L/usr/lib/x86_64-linux-gnu -lSDL && ./sdl1-test
*/

    SDL Version 2

    #include <stdio.h>
#include <SDL.h>
int width=1280,height=720;
int loop=1;
SDL_Window *window;
SDL_Surface *surface;
SDL_Event e;
int main(int argc, char **argv)
{
 if(SDL_Init(SDL_INIT_VIDEO))
 {
  printf( "SDL could not initialize! SDL_Error: %s\n",SDL_GetError());return -1;
 }
 window=SDL_CreateWindow("SDL2 Program",SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,width,height,SDL_WINDOW_SHOWN );
 if(window==NULL){printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );return -1;}
 surface = SDL_GetWindowSurface( window ); /*get surface for this window*/
 SDL_FillRect(surface,NULL,0xFF00FF);
 SDL_UpdateWindowSurface(window);
 printf("SDL Program Compiled Correctly\n");
 while(loop)
 {
  while(SDL_PollEvent(&e))
  {
   if(e.type == SDL_QUIT){loop=0;}
   if(e.type == SDL_KEYUP)
   {
    if(e.key.keysym.sym==SDLK_ESCAPE){loop=0;}
   }
  }
 }
 SDL_DestroyWindow(window);
 SDL_Quit();
 return 0;
}

/*
 This source file is an example to be included in Chastity's Code Cookbook. This example follows the SDL version 2 which works differently than the most up to date version (version 3 at this time). There is also an updated version in the same repository that works with version 3.

 Linux Compile Command:

 With the sdl2-config script:
 gcc -Wall -ansi -pedantic sdl2-test.c -o sdl2-test `sdl2-config --cflags --libs` && ./sdl2-test

 Without the sdl2-config script:
 gcc -Wall -ansi -pedantic sdl2-test.c -o sdl2-test -I/usr/include/SDL2 -lSDL2 && ./sdl2-test
*/

    SDL Version 3

    #include <stdio.h>
#include <SDL.h>
int width=1280,height=720;
int loop=1;
SDL_Window *window;
SDL_Surface *surface;
SDL_Event e;
int main(int argc, char **argv)
{
 if(!SDL_Init(SDL_INIT_VIDEO))
 {
  printf( "SDL could not initialize! SDL_Error: %s\n",SDL_GetError());return -1;
 }
 window=SDL_CreateWindow("SDL3 Program",width,height,0);
 if(window==NULL){printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );return -1;}
 surface = SDL_GetWindowSurface( window ); /*get surface for this window*/
 SDL_FillSurfaceRect(surface,NULL,0xFF00FF);
 SDL_UpdateWindowSurface(window);
 printf("SDL Program Compiled Correctly\n");
 while(loop)
 {
  while(SDL_PollEvent(&e))
  {
   if(e.type == SDL_EVENT_QUIT){loop=0;}
   if(e.type == SDL_EVENT_KEY_UP)
   {
    if(e.key.key==SDLK_ESCAPE){loop=0;}
   }
  }
 }
 SDL_DestroyWindow(window);
 SDL_Quit();
 return 0;
}

/*
 This source file is an example to be included in Chastity's Code Cookbook. By following the migration guide, I converted the SDL2-test program to the changes in SDL3.

 https://wiki.libsdl.org/SDL3/README-migration

 Windows Compile Command:

 gcc -Wall -ansi -pedantic sdl3-test.c -o sdl3-test -IC:/w64devkit/include/SDL3 -lSDL3 && sdl3-test

 Linux Compile Command:

 gcc -Wall -ansi -pedantic sdl3-test.c -o sdl3-test -I/usr/include/SDL3 -lSDL3 && ./sdl3-test

*/

    No matter which of those I compile and run, I get the same result:

    All the programs do is create a window and fill the whole thing with Magenta. It’s not that exciting, but it is pretty, and it shows that all 3 versions of SDL work on my Debian Linux machine.