C Development - Revision history

1BitFeverDreams: /* Calypsi */

2026-04-30T05:59:07Z

Calypsi

← Older revision		Revision as of 01:59, 30 April 2026
Line 7:		Line 7:
	=== Calypsi ===		=== Calypsi ===

	Dedicated [[Calypsi] wiki page.		Dedicated [[Calypsi]] wiki page.

	Website with all the info: [https://www.calypsi.cc/ Calypsi]		Website with all the info: [https://www.calypsi.cc/ Calypsi]

1BitFeverDreams: /* Calypsi */

2026-04-30T05:58:55Z

Calypsi

← Older revision		Revision as of 01:58, 30 April 2026
Line 7:		Line 7:
	=== Calypsi ===		=== Calypsi ===

	Dedicated [[~~llvm-mos]~~] wiki page.		Dedicated [[Calypsi] wiki page.

	Website with all the info: [https://www.calypsi.cc/ Calypsi]		Website with all the info: [https://www.calypsi.cc/ Calypsi]

1BitFeverDreams: /* C Compilers */ massive revamp, sent info into separate page per compiler

2026-04-30T05:57:42Z

C Compilers: massive revamp, sent info into separate page per compiler

Show changes

1BitFeverDreams: /* Compiling a program, scripts from Mu0n */

2026-04-28T20:50:55Z

Compiling a program, scripts from Mu0n

← Older revision		Revision as of 16:50, 28 April 2026
Line 243:		Line 243:
	Here's the shell script ("c.sh") I use to simply compile a program, this works regardless if your project uses one .c file or multiples. Adjust your absolute paths to what you have on your modern computer. "projectname" is the folder of your project inside the "doodles" folder.		Here's the shell script ("c.sh") I use to simply compile a program, this works regardless if your project uses one .c file or multiples. Adjust your absolute paths to what you have on your modern computer. "projectname" is the folder of your project inside the "doodles" folder.

	run it using the command ~~<nowiki><code>~~./c.sh myprojectname~~</code></nowiki>~~<pre>		run it using the command '''./c.sh myprojectname'''<pre>
	#!/bin/bash		#!/bin/bash

Line 272:		Line 272:
	</pre>Here's the shell script ("car.sh" = Compile And Run) I use to compile a program and send it over to my Wildbits through the foenixmgr script. This assumes that your host is win11 and python is run from that, from inside WSL ubuntu. Tweak to your setup's situation, of course.		</pre>Here's the shell script ("car.sh" = Compile And Run) I use to compile a program and send it over to my Wildbits through the foenixmgr script. This assumes that your host is win11 and python is run from that, from inside WSL ubuntu. Tweak to your setup's situation, of course.

	run it using the command ~~<nowiki><code>~~./car.sh myprojectname~~</code></nowiki>~~<pre>		run it using the command '''./car.sh myprojectname'''<pre>
	#!/bin/bash		#!/bin/bash

1BitFeverDreams: /* Compiling a program, scripts from Mu0n */ car script

2026-04-28T20:48:58Z

Compiling a program, scripts from Mu0n: car script

← Older revision		Revision as of 16:48, 28 April 2026
Line 272:		Line 272:
	</pre>Here's the shell script ("car.sh" = Compile And Run) I use to compile a program and send it over to my Wildbits through the foenixmgr script. This assumes that your host is win11 and python is run from that, from inside WSL ubuntu. Tweak to your setup's situation, of course.		</pre>Here's the shell script ("car.sh" = Compile And Run) I use to compile a program and send it over to my Wildbits through the foenixmgr script. This assumes that your host is win11 and python is run from that, from inside WSL ubuntu. Tweak to your setup's situation, of course.

	run it using the command <nowiki><code>./car.sh myprojectname</code></nowiki>		run it using the command <nowiki><code>./car.sh myprojectname</code></nowiki><pre>
			#!/bin/bash

			# --- 1. CONFIGURATION ---
			OSCAR_BIN="/mnt/d/F256/oscar64/bin/oscar64"
			# Use the Windows python launcher (it handles COM8 perfectly)
			PYTHON_EXE="python.exe"
			# Use the Windows path for the script (escaped backslashes)
			FOENIX_MGR="D:\\F256\\llvm-mos\\f256dev\\FoenixMgr\\FoenixMgr\\fnxmgr.py"

			# --- 2. ARGUMENTS ---
			PROJ_NAME="$1"
			SRC_DIR="${PROJ_NAME}/src/"
			SRC_FILE="${PROJ_NAME}/src/${PROJ_NAME}.c"
			OUT_DIR="${PROJ_NAME}/"
			BIN_FILE="${PROJ_NAME}.pgz"
			FLAGS="-tm=f256k -n -i=../f256lib"
			# --- 3. Gather all files in src/

			mapfile -t CFILES < <(find "$SRC_DIR" -maxdepth 1 -type f -name "*.c")

			# --- 4. COMPILE ---
			echo "Compiling:"
			printf '%s\n' "${CFILES[@]}"
			echo
			echo "Linking into ${OUT_DIR}/${PROJ_NAME}.pgz"
			$OSCAR_BIN $FLAGS "${CFILES[@]}" -o="./$OUT_DIR/$PROJ_NAME.pgz"

			# --- 5. TRANSFER ---
			if [ $? -eq 0 ]; then
			echo "Transferring to F256K2 via Windows Python..."
			# We use the Windows path for the file we just built
			WIN_BIN_PATH="D:\\F256\\f256lib-oscar64\\doodles\\${PROJ_NAME}\\${BIN_FILE}"

			$PYTHON_EXE "$FOENIX_MGR" --port COM8 --run-pgz "$WIN_BIN_PATH"
			else
			echo "Compilation failed."
			exit 1
			fi
			</pre>

1BitFeverDreams: /* Trampoline scheme for functions in higher memory */

2026-04-28T20:48:06Z

Trampoline scheme for functions in higher memory

← Older revision		Revision as of 16:48, 28 April 2026
Line 191:		Line 191:
	Here is the list of stuff you must define for it to work:		Here is the list of stuff you must define for it to work:

	* A specific number for your code's block = physical address / 0x2000 you have in mind to stash your code. For example, to use the 8kb of code space between 0x10000 and 0x11FFF, this will be "overlay block 8". For the space between 0x12000 and 0x13FFF, this is "overlay block 9"<pre>		* A specific number for your code's block = physical address / 0x2000 you have in mind to stash your code. For example, to use the 8kb of code space between 0x10000 and 0x11FFF, this will be "overlay block 8". For the space between 0x12000 and 0x13FFF, this is "overlay block 9"
			<pre>
	#define OVL1_BLOCK 8 // Physical 0x10000		#define OVL1_BLOCK 8 // Physical 0x10000
	</pre>		</pre>
	* #pragma directive such as:<pre>		* #pragma directive such as:
			<pre>
	// Overlay 1: stored at physical 0x10000, compiled to run at 0xA000		// Overlay 1: stored at physical 0x10000, compiled to run at 0xA000
	#pragma section( ovl1_code, 0 )		#pragma section( ovl1_code, 0 )

1BitFeverDreams: /* Trampoline scheme for functions in higher memory */

2026-04-28T20:47:27Z

Trampoline scheme for functions in higher memory

← Older revision		Revision as of 16:47, 28 April 2026
Line 191:		Line 191:
	Here is the list of stuff you must define for it to work:		Here is the list of stuff you must define for it to work:

	* A specific number for your code's block = physical address / 0x2000 you have in mind to stash your code. For example, to use the 8kb of code space between 0x10000 and 0x11FFF, this will be "overlay block 8". For the space between 0x12000 and 0x13FFF, this is "overlay block 9"		* A specific number for your code's block = physical address / 0x2000 you have in mind to stash your code. For example, to use the 8kb of code space between 0x10000 and 0x11FFF, this will be "overlay block 8". For the space between 0x12000 and 0x13FFF, this is "overlay block 9"<pre>
			#define OVL1_BLOCK 8 // Physical 0x10000
			</pre>
	* #pragma directive such as:<pre>		* #pragma directive such as:<pre>
	// Overlay 1: stored at physical 0x10000, compiled to run at 0xA000		// Overlay 1: stored at physical 0x10000, compiled to run at 0xA000

1BitFeverDreams: more details for oscar64

2026-04-28T20:45:09Z

more details for oscar64

← Older revision		Revision as of 16:45, 28 April 2026
Line 183:		Line 183:
	//return to normalcy		//return to normalcy
	#pragma data(data)</pre>		#pragma data(data)</pre>

			==== Trampoline scheme for functions in higher memory ====
			Much like assets, you will have to use the #pragma directive to set up a section and region for each chunk of RAM. Since a trampoline scheme gets used here in conjunction with the machine's MMU, these regions should be 0x2000 big, or 8kb.

			Keep in mind that these chunks of RAM will be swapped in and out of the 0xA000 to 0xBFFF 8kb chunk visible by the CPU.

			Here is the list of stuff you must define for it to work:

			* A specific number for your code's block = physical address / 0x2000 you have in mind to stash your code. For example, to use the 8kb of code space between 0x10000 and 0x11FFF, this will be "overlay block 8". For the space between 0x12000 and 0x13FFF, this is "overlay block 9"
			* #pragma directive such as:<pre>
			// Overlay 1: stored at physical 0x10000, compiled to run at 0xA000
			#pragma section( ovl1_code, 0 )
			#pragma region( ovl1, 0x10000, 0x12000, , , { ovl1_code }, 0xA000 )
			</pre>
			* Forward declaration of a trampoline function used to access the higher memory function, such as:
			<pre>
			// ---------------------------------------------------------------------------
			// Forward declarations of trampolines (in main code, always visible)
			// ---------------------------------------------------------------------------

			void firstSegment(int arg1, int arg2);


			// Trampolines save the current bank 5 mapping, switch to the target
			// overlay's physical block, call the FAR function, then restore the
			// original mapping. This supports nested cross-overlay calls.

			void firstSegment(int arg1, int arg2) {
			volatile byte saved = PEEK(OVERLAY_MMU_REG);
			POKE(OVERLAY_MMU_REG, OVL1_BLOCK);
			FAR_firstSegment(arg1, arg2);
			POKE(OVERLAY_MMU_REG, saved);
			}

			</pre>

			* Your far memory function in between #pragma code directives:
			<pre>
			#pragma code( ovl1_code )

			void FAR_firstSegment(int arg1, int arg2) {
			textPrint("firstSegment = ");
			textPrintInt((int32_t)(arg1 + arg2));
			textPrint("\n");
			// Call into overlay 2 via trampoline (in main memory)
			}

			//return to normalcy
			#pragma code( code )
			</pre>Note: it's perfectly ok to define multiples of these high memory regions. One far memory function can call another far memory function from another region without issue, but it has to call it through its lower memory trampoline.

			==== Compiling a program, scripts from Mu0n ====
			I use a pair of scripts that are located in BASEPATH/f256lib-oscar64/doodles/

			Here's the shell script ("c.sh") I use to simply compile a program, this works regardless if your project uses one .c file or multiples. Adjust your absolute paths to what you have on your modern computer. "projectname" is the folder of your project inside the "doodles" folder.

			run it using the command <nowiki><code>./c.sh myprojectname</code></nowiki><pre>
			#!/bin/bash

			# --- 1. CONFIGURATION ---
			OSCAR_BIN="/mnt/d/F256/oscar64/bin/oscar64"
			# Use the Windows python launcher (it handles COM8 perfectly)
			PYTHON_EXE="python.exe"
			# Use the Windows path for the script (escaped backslashes)
			FOENIX_MGR="D:\\F256\\llvm-mos\\f256dev\\FoenixMgr\\FoenixMgr\\fnxmgr.py"

			# --- 2. ARGUMENTS ---
			PROJ_NAME="$1"
			SRC_DIR="${PROJ_NAME}/src/"
			SRC_FILE="${PROJ_NAME}/src/${PROJ_NAME}.c"
			OUT_DIR="${PROJ_NAME}/"
			BIN_FILE="${PROJ_NAME}.pgz"
			FLAGS="-tm=f256k -n -v -i=../f256lib"
			# --- 3. Gather all files in src/

			mapfile -t CFILES < <(find "$SRC_DIR" -maxdepth 1 -type f -name "*.c")

			# --- 4. COMPILE ---
			echo "Compiling:"
			printf '%s\n' "${CFILES[@]}"
			echo
			echo "Linking into ${OUT_DIR}/${PROJ_NAME}.pgz"
			$OSCAR_BIN $FLAGS "${CFILES[@]}" -o="./$OUT_DIR/$PROJ_NAME.pgz"
			</pre>Here's the shell script ("car.sh" = Compile And Run) I use to compile a program and send it over to my Wildbits through the foenixmgr script. This assumes that your host is win11 and python is run from that, from inside WSL ubuntu. Tweak to your setup's situation, of course.

			run it using the command <nowiki><code>./car.sh myprojectname</code></nowiki>

1BitFeverDreams: /* C Compilers */ oscar64 main link up top

2026-04-28T20:26:03Z

C Compilers: oscar64 main link up top

← Older revision		Revision as of 16:26, 28 April 2026
Line 3:		Line 3:
	* [https://www.calypsi.cc/ Calypsi]		* [https://www.calypsi.cc/ Calypsi]
	* [[llvm-mos]]		* [[llvm-mos]]
	* oscar64		* [https://github.com/sdwfrost/oscar64 oscar64] (read below for detailed install instructions)

	=== LLVM-MOS ===		=== LLVM-MOS ===

1BitFeverDreams: embedding assets for oscar64

2026-04-28T20:24:08Z

embedding assets for oscar64

@@ Line 87: / Line 87: @@
 Oscar64 was adapted for the F256/WildBits by swdfrost and [https://github.com/sdwfrost/oscar64 here is a link its github page]. You will also need the adaptation of the f256lib (ported over from llvm-mos) [https://github.com/sdwfrost/f256lib-oscar64 from this github page] as well, which also includes many projects examples as well. </blockquote>
 ==== Getting set up on Windows 10/11 (-Mu0n) ====
@@ Line 136: / Line 139: @@
   '''BASEPATH/oscar64/bin/oscar64 -tm=f256k -n -i=BASEPATH/f256lib-oscar64/f256lib BASEPATH/f256lib-oscar64/doodles/myproject/src/myproject.c -o=BASEPATH/f256lib-oscar64/doodles/myproject/myproject.pgz'''