jado

@jadon.io

74 Followers 231 Following

https://jadon.io https://github.com/phase

$#[cfg(test)] mod tests { use super::*; use reader::read_class::read_class; #[test] fn test_write_class() { let mut expected_class = ClassFile::new(ClassVersion::JDK_11, "example/Foo"); expected_class.add_interface("example/IFoo"); let mut buf = vec![0; 1024]; write_class(&expected_class, &mut buf); let actual_class = read_class(&mut buf).expect("failed to read class"); assert_eq!(expected_class, actual_class); } }$

$/// A thread-safe interner that requires a 'static lifetime. pub struct StaticInternMap { map: RwLock<StringInternMap>, } impl StaticInternMap { pub fn new(capacity: usize) -> StaticInternMap { StaticInternMap { map: RwLock::new(StringInternMap::with_capacity(capacity)) } } /// Intern a string, returning a yarn. /// The yarn is always 128 bits long and may be an inlined string (where len < SSO_LEN) /// or a &'static str pointing into a buffer. /// Safety: &'static self is required because the allocated strings the Yarns may point to /// need to live for the lifetime of the program. pub fn intern(&'static self, name: &str) -> Yarn { if let Some(yarn) = Yarn::inlined(name) { return yarn; } // Safety: Yarn is assuming this 'static lifetime we pass it will never be dropped. // The 'static lifetime within the StringInternMap is only valid // for the life of the map instance, because the String buffers // being pointed to are *owned* by the map. unsafe { // grab read lock, get existing interned string that matches let map = self.map.read().expect("can't grab lock"); if let Some(ptr) = map.find_existing(name) { return Yarn::from_static(ptr); } drop(map); // not already interned, grab write lock let mut map = self.map.write().expect("can't grab lock"); let id = map.store(name); let ptr: &'static str = map.lookup_unchecked(id); return Yarn::from_static(ptr); } } } static STATIC_MAP: LazyLock<StaticInternMap> = LazyLock::new(|| StaticInternMap::new(1024)); pub fn intern(name: &str) -> Yarn { STATIC_MAP.intern(name) }$

$/// Like a Cow<'a, str> but you can plug in your own type. #[derive(Yokeable)] pub enum Ident<'a, O> { Owned(O), Borrowed(&'a str), } impl<'a, O: Clone + From<&'a str>> Ident<'a, O> { pub fn new(s: &'a str) -> Self { Ident::Borrowed(s) } pub fn as_owned(&self) -> O { match self { Ident::Owned(s) => s.clone(), Ident::Borrowed(s) => (*s).into(), } } /// Any lifetime 'b is fine here because we're always returning an owned ustr. pub fn mutate<'b>(&mut self, f: impl FnOnce(&mut O)) -> Ident<'b, O> { let mut owned = self.as_owned(); f(&mut owned); Ident::Owned(owned) } } /// C is our cart, could be an Arc<[u8]> or something. pub struct ID<C>(Yoke<Ident<'static, Ustr>, C>); impl<C> ID<C> { pub fn as_str(&self) -> &str { let ident = self.0.get(); match ident { Ident::Owned(s) => s.as_str(), Ident::Borrowed(s) => s, } } } pub struct ClassFile<C> { name: ID<C>, }$

map of arizona showing the navajo nation follows DST but the hopi reservation inside it doesn’t follow DST

impl WriteBackendMethods for JvmCodegen {
type Module = ClassFile;
type TargetMachine = ();
type TargetMachineError = ();
type ModuleBuffer = ModuleBuffer;
type ThinData = ();
type ThinBuffer = ThinBuffer;

it runs successfully and passes all the tests

$#![feature(no_core, lang_items, rustc_attrs, intrinsics, decl_macro)] #![no_core] #![allow(internal_features)] #[lang = "sized"] pub trait Sized {} #[lang = "copy"] pub unsafe trait Copy {} unsafe impl Copy for bool {} unsafe impl Copy for u8 {} unsafe impl Copy for u16 {} unsafe impl Copy for u32 {} unsafe impl Copy for u64 {} unsafe impl Copy for usize {} unsafe impl Copy for i8 {} unsafe impl Copy for i16 {} unsafe impl Copy for i32 {} unsafe impl Copy for isize {} unsafe impl Copy for f32 {} unsafe impl Copy for f64 {} unsafe impl Copy for char {} unsafe impl<'a, T: ?Sized> Copy for &'a T {} unsafe impl<T: ?Sized> Copy for *const T {} unsafe impl<T: ?Sized> Copy for *mut T {} pub mod libc { #[link(name = "c")] extern "C" { pub fn puts(s: *const u8) -> i32; pub fn printf(format: *const i8, ...) -> i32; pub fn malloc(size: usize) -> *mut u8; pub fn free(ptr: *mut u8); pub fn memcpy(dst: *mut u8, src: *const u8, size: usize); pub fn memmove(dst: *mut u8, src: *const u8, size: usize); pub fn strncpy(dst: *mut u8, src: *const u8, size: usize); } }$

screenshot of a terminal showing me running `./y rustc examples/basic_math.rs` in the rustc_codegen_c repo. it fails with

error[E0463]: can't find crate for `mini_core`
--> examples/basic_math.rs:7:1
|
7 | extern crate mini_core;
| ^^^^^^^^^^^^^^^^^^^^^^^ can't find crate

which is odd because the author of the PR I link is also running on macOS but doesn't seem to have this issue?

screenshot of the rustc_codegen_c github page

screenshot of the 'Basic functionality' section of the linked yoke design doc.

$A screenshot from carbon.now.sh showing this code: pub export const testZigString = mapStr("Zig"); /// Map a string to the character set used by FireRed. /// This will also append a sentinel value. fn mapStr(comptime str: []const u8) [str.len + 1]c_char { comptime var buffer = [_]c_char{0xFF} ** (str.len + 1); for (str, 0..) |ch, i| { buffer[i] = mapChar(ch); } return buffer; } fn mapChar(ch: u8) u8 { return switch (ch) { '0' => 0xA1, '1' => 0xA2, '2' => 0xA3, '3' => 0xA4, '4' => 0xA5, '5' => 0xA6, '6' => 0xA7, '7' => 0xA8, ... 'ä' => 0xF4, 'ö' => 0xF5, 'ü' => 0xF6, '$' => 0xFF, else => ch, }; }$