thomcc

# helper fn that returns version number given $crate or $crate/$semver.
# both must be url-encoded but the / must be a / if provided.
# doesn't handle cases where the version/crate/whatever doesn't exist.
resolve_version() {
    # Perform `HEAD` request to `docs.rs/$1` and dump the redirected URL.
    # We expect this to go to `docs.rs/crate/$crate/$version`
    # or `docs.rs/$crate/$version/$crate/` depending on if the crate has
    # docs or idrk. Maybe a couple other urls are possible, it
    # took a bit of testing for the `sed` script to handle all cases I found.
    #

thomcc

use std::string::String;
use std::str::Chars;
use std::iter::{Enumerate, Peekable};

// an xml parser that's decent enough if you don't care about parsing perf
// and you completely control the input.
#[derive(Clone, Debug)]
pub struct XmlNode {
    pub tag: String,
    pub attributes: Vec<(String, String)>,

thomcc

static A: AtomicU8 = AtomicU8::new(0);
static B: AtomicU8 = AtomicU8::new(0);
const ORDER: Ordering = ???;

let writer_0 = thread::spawn(|| {
    A.store(1, ORDER);
});

let writer_1 = thread::spawn(|| {
    B.store(1, ORDER);

thomcc

struct Semaphore {
    raw: RawSemaphore,
    count: AtomicIsize,
}
impl Semaphore {
    #[inline]
    pub fn new(n: usize) -> Self {
        Self {
            raw: RawSemaphore::new(),

thomcc

#![cfg_attr(all(feature = "std", not(feature = "getrandom")), no_std)]

mod get_random;

#[repr(C, align(16))]
pub struct ChaCha8 {
    state: [u32; 16],
    seed: [u32; 8],
    ctr: u64,
    stream_id: u64,

thomcc

use core::sync::atomic::{*, Ordering::*};
use core::mem::MaybeUninit;
use core::cell::UnsafeCell;

/// A macro similar to `lazy_static::lazy_static!`, but that will attempt to
/// eagerly initialize the static value using [`on_startup!`](crate::on_startup).
#[macro_export]
macro_rules! eager_static {
    ($(
        $(#[$attr:meta])*

thomcc

//! See https://github.com/ocornut/imgui/issues/3606
use imgui::*;

mod support;

fn main() {
    let system = support::init(file!());
    system.main_loop(move |_, ui| {
        fx_window(ui, 0, |d, a, _b, sz, _mouse, t| {
            for n in 0..(((1.0 + (t * 5.7).sin()) * 40.0) as isize).max(0) {

thomcc

//! Note: don't use spin locks unless you're doing something
//! really strange. They only perform well on microbenchmarks.
use core::sync::atomic::{*, Ordering::*};

pub struct SpinLock(AtomicBool);

impl SpinLock {
    #[inline]
    pub const fn new() -> Self {
        Self(AtomicBool::new(false))

thomcc

#![no_std]
extern crate alloc;
#[cfg(test)]
extern crate std;

use alloc::sync::Arc;
use core::{
    cell::UnsafeCell,
    mem::MaybeUninit,
    ptr::{self, NonNull},

thomcc

// type Int = i128;
type Int = i64;

type Rat = (Int, Int);

/// Quick and dirty (no overflow handling) continued fraction-based
/// rational approximation.
///
/// Returns `(p/q, was_exact)` where p/q is an approximation of `n/d`,
/// where neither `p` nor `q` are above `limit`. `was_exact` is true if