AldoMX · November 13, 2022 22:19 · lem0nify · May 13, 2024
diff --git a/README.md b/README.md
diff --git a/Cargo.toml b/Cargo.toml
 [package]
 name = "hello_world"
 version = "0.1.0"
 edition = "2021"

 [profile.dev]
 panic = "abort"

 [profile.release]
 lto = true
 panic = "abort"

 [dependencies]
 lazy_static = { version = "1.4.0", features = ["spin_no_std"] }

 [dependencies.windows-sys]
 version = "0.42.0"
 features = [
    "Win32_Foundation",
    "Win32_Storage_FileSystem",
    "Win32_System_Console",
    "Win32_System_IO",
    "Win32_System_Memory",
    "Win32_System_Threading",
 ]
diff --git a/main.rs b/main.rs
 #![feature(default_alloc_error_handler)]
 #![no_main]
 #![no_std]

 #[macro_use]
 extern crate alloc;

 #[macro_use]
 extern crate lazy_static;

 use alloc::{
    alloc::{GlobalAlloc, Layout},
    string::String,
    vec::Vec,
 };
 use core::{
    ffi::{c_char, c_int, c_void},
    panic::PanicInfo,
    ptr::null_mut,
 };
 use windows_sys::Win32::{
    Foundation::{HANDLE, INVALID_HANDLE_VALUE},
    Storage::FileSystem::WriteFile,
    System::Console::{GetStdHandle, STD_OUTPUT_HANDLE},
    System::Memory::{GetProcessHeap, HeapAlloc, HeapFree},
    System::Threading::ExitProcess,
 };

 #[panic_handler]
 unsafe fn panic(_info: &PanicInfo) -> ! {
    ExitProcess(0xdeafbeef)
 }

 #[cfg(target_env = "msvc")]
 #[link(name = "msvcrt")]
 extern "C" {}

 #[cfg(target_env = "msvc")]
 #[link(name = "vcruntime")]
 extern "C" {}

 #[cfg(target_env = "msvc")]
 #[link(name = "ucrt")]
 extern "C" {}

 #[cfg(target_env = "gnu")]
 #[link(name = "stdc++")]
 extern "C" {
    fn __gxx_personality_v0(
        version: c_int,
        actions: c_int,
        exception_class: *const c_char,
        exception_object: *mut c_void,
        context: *mut c_void,
    ) -> c_int;
 }

 #[cfg(target_env = "gnu")]
 #[no_mangle]
 unsafe fn rust_eh_personality(
    version: c_int,
    actions: c_int,
    exception_class: *const c_char,
    exception_object: *mut c_void,
    context: *mut c_void,
 ) -> c_int {
    __gxx_personality_v0(version, actions, exception_class, exception_object, context)
 }

 #[derive(Default)]
 struct Allocator;

 unsafe impl GlobalAlloc for Allocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        // GetProcessHeap() may return a null pointer, in which case the program will crash.
        // I'm fine with this behavior, but you may want to extend this code to call HeapCreate()
        // when GetProcessHeap() returns a null pointer.
        HeapAlloc(GetProcessHeap(), 0, layout.size()) as *mut u8
    }

    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
        // GetProcessHeap() may return a null pointer, in which case the program will crash.
        // I'm fine with this behavior, but you may want to extend this code to use the handle
        // returned by HeapCreate().
        HeapFree(GetProcessHeap(), 0, ptr as *const c_void);
    }
 }

 #[global_allocator]
 static GLOBAL_ALLOCATOR: Allocator = Allocator;

 pub struct StdOut {
    handle: HANDLE,
 }

 impl StdOut {
    const NEWLINE_BYTES: &'static [u8] = &['\r' as u8, '\n' as u8, 0];

    // Use the `STD_OUT` singleton instead
    pub fn _new() -> Self {
        let handle = unsafe { GetStdHandle(STD_OUTPUT_HANDLE) };
        StdOut { handle }
    }

    pub fn is_handle_valid(&self) -> bool {
        self.handle != INVALID_HANDLE_VALUE
    }

    pub fn print_bytes(&self, bytes: Vec<u8>) -> usize {
        let mut bytes_written = 0u32;
        let buffer_size = bytes.len() as u32;
        if self.is_handle_valid() {
            unsafe {
                WriteFile(
                    self.handle,
                    bytes.as_ptr() as *const c_void,
                    buffer_size,
                    &mut bytes_written,
                    null_mut(),
                );
            }
        }
        bytes_written as usize
    }

    pub fn print(&self, txt: String) -> usize {
        let mut bytes = txt.into_bytes();
        bytes.push(0);
        self.print_bytes(bytes)
    }

    pub fn println(&self, txt: String) -> usize {
        let mut bytes = txt.into_bytes();
        bytes.extend_from_slice(Self::NEWLINE_BYTES);
        self.print_bytes(bytes)
    }
 }

 #[no_mangle]
 pub extern "C" fn main(_argc: c_int, _argv: *const *const c_char) -> isize {
    STD_OUT.println(format!("Hello, {}!", "World"));
    0
 }

 lazy_static! {
    pub static ref STD_OUT: StdOut = StdOut::_new();
 }
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
 [toolchain]
 channel = "nightly-i686-pc-windows-gnu"
	[package]
	name = "hello_world"
	version = "0.1.0"
	edition = "2021"

	[profile.dev]
	panic = "abort"

	[profile.release]
	lto = true
	panic = "abort"

	[dependencies]
	lazy_static = { version = "1.4.0", features = ["spin_no_std"] }

	[dependencies.windows-sys]
	version = "0.42.0"
	features = [
	"Win32_Foundation",
	"Win32_Storage_FileSystem",
	"Win32_System_Console",
	"Win32_System_IO",
	"Win32_System_Memory",
	"Win32_System_Threading",
	]
	#![feature(default_alloc_error_handler)]
	#![no_main]
	#![no_std]

	#[macro_use]
	extern crate alloc;

	#[macro_use]
	extern crate lazy_static;

	use alloc::{
	alloc::{GlobalAlloc, Layout},
	string::String,
	vec::Vec,
	};
	use core::{
	ffi::{c_char, c_int, c_void},
	panic::PanicInfo,
	ptr::null_mut,
	};
	use windows_sys::Win32::{
	Foundation::{HANDLE, INVALID_HANDLE_VALUE},
	Storage::FileSystem::WriteFile,
	System::Console::{GetStdHandle, STD_OUTPUT_HANDLE},
	System::Memory::{GetProcessHeap, HeapAlloc, HeapFree},
	System::Threading::ExitProcess,
	};

	#[panic_handler]
	unsafe fn panic(_info: &PanicInfo) -> ! {
	ExitProcess(0xdeafbeef)
	}

	#[cfg(target_env = "msvc")]
	#[link(name = "msvcrt")]
	extern "C" {}

	#[cfg(target_env = "msvc")]
	#[link(name = "vcruntime")]
	extern "C" {}

	#[cfg(target_env = "msvc")]
	#[link(name = "ucrt")]
	extern "C" {}

	#[cfg(target_env = "gnu")]
	#[link(name = "stdc++")]
	extern "C" {
	fn __gxx_personality_v0(
	version: c_int,
	actions: c_int,
	exception_class: *const c_char,
	exception_object: *mut c_void,
	context: *mut c_void,
	) -> c_int;
	}

	#[cfg(target_env = "gnu")]
	#[no_mangle]
	unsafe fn rust_eh_personality(
	version: c_int,
	actions: c_int,
	exception_class: *const c_char,
	exception_object: *mut c_void,
	context: *mut c_void,
	) -> c_int {
	__gxx_personality_v0(version, actions, exception_class, exception_object, context)
	}

	#[derive(Default)]
	struct Allocator;

	unsafe impl GlobalAlloc for Allocator {
	unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
	// GetProcessHeap() may return a null pointer, in which case the program will crash.
	// I'm fine with this behavior, but you may want to extend this code to call HeapCreate()
	// when GetProcessHeap() returns a null pointer.
	HeapAlloc(GetProcessHeap(), 0, layout.size()) as *mut u8
	}

	unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
	// GetProcessHeap() may return a null pointer, in which case the program will crash.
	// I'm fine with this behavior, but you may want to extend this code to use the handle
	// returned by HeapCreate().
	HeapFree(GetProcessHeap(), 0, ptr as *const c_void);
	}
	}

	#[global_allocator]
	static GLOBAL_ALLOCATOR: Allocator = Allocator;

	pub struct StdOut {
	handle: HANDLE,
	}

	impl StdOut {
	const NEWLINE_BYTES: &'static [u8] = &['\r' as u8, '\n' as u8, 0];

	// Use the `STD_OUT` singleton instead
	pub fn _new() -> Self {
	let handle = unsafe { GetStdHandle(STD_OUTPUT_HANDLE) };
	StdOut { handle }
	}

	pub fn is_handle_valid(&self) -> bool {
	self.handle != INVALID_HANDLE_VALUE
	}

	pub fn print_bytes(&self, bytes: Vec<u8>) -> usize {
	let mut bytes_written = 0u32;
	let buffer_size = bytes.len() as u32;
	if self.is_handle_valid() {
	unsafe {
	WriteFile(
	self.handle,
	bytes.as_ptr() as *const c_void,
	buffer_size,
	&mut bytes_written,
	null_mut(),
	);
	}
	}
	bytes_written as usize
	}

	pub fn print(&self, txt: String) -> usize {
	let mut bytes = txt.into_bytes();
	bytes.push(0);
	self.print_bytes(bytes)
	}

	pub fn println(&self, txt: String) -> usize {
	let mut bytes = txt.into_bytes();
	bytes.extend_from_slice(Self::NEWLINE_BYTES);
	self.print_bytes(bytes)
	}
	}

	#[no_mangle]
	pub extern "C" fn main(_argc: c_int, _argv: const const c_char) -> isize {
	STD_OUT.println(format!("Hello, {}!", "World"));
	0
	}

	lazy_static! {
	pub static ref STD_OUT: StdOut = StdOut::_new();
	}