SYMBOL INDEX (942 symbols across 71 files)

FILE: boot/src/lib.rs
  constant TABLE_LENGTH (line 45) | const TABLE_LENGTH: usize = 512;
  constant HUGE_PAGE_SIZE (line 47) | const HUGE_PAGE_SIZE: u64 = 2 * 1024 * 1024;
  constant ENTRY_FLAGS_PW (line 49) | const ENTRY_FLAGS_PW: u64 = 0b11;
  type Table (line 52) | type Table = [TableEntry; TABLE_LENGTH];
  type PageTable (line 54) | trait PageTable: Sized {
    method set_top_level (line 57) | unsafe fn set_top_level(&'static self) {
  type TableEntry (line 71) | struct TableEntry(u64);
    method map_to_table (line 78) | unsafe fn map_to_table(&mut self, to: &'static Table) {
    method map_to_page (line 84) | unsafe fn map_to_page(&mut self, number: usize) {
  type Gdt (line 110) | pub struct Gdt { _null: u64
  type GdtPointer (line 115) | pub struct GdtPointer { /// the length of the GDT
    method load (line 123) | unsafe fn load (&self) {
    method from (line 130) | fn from(gdt: &'static Gdt) -> Self {
  function boot_write (line 146) | fn boot_write(s: &[u8]) {
  function create_page_tables (line 167) | unsafe fn create_page_tables() {
  function set_long_mode (line 188) | unsafe fn set_long_mode() {
  function is_multiboot_supported (line 221) | unsafe fn is_multiboot_supported() -> bool {
  function _start (line 232) | pub unsafe extern "C" fn _start() {
  function panic_fmt (line 263) | fn panic_fmt() -> ! {

FILE: build.rs
  function main (line 3) | fn main() {

FILE: cpu/src/armv7/mod.rs
  constant ARCH_BITS (line 12) | pub const ARCH_BITS: u8 = 64;

FILE: cpu/src/lib.rs
  type Port (line 51) | pub struct Port<T> { raw_port: UnsafePort

FILE: cpu/src/x86/mod.rs
  constant ARCH_BITS (line 16) | pub const ARCH_BITS: u8 = 32;

FILE: cpu/src/x86_64/context.rs
  type Registers (line 22) | pub struct Registers { pub rsi: u64
    method to_array (line 38) | pub unsafe fn to_array(&self) -> [u64; 9] {
    method empty (line 48) | pub const fn empty() -> Self {
    method push (line 61) | pub unsafe fn push() {
    method pop (line 81) | pub unsafe fn pop() {
    method fmt (line 97) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type InterruptFrame (line 111) | pub struct InterruptFrame {
    method fmt (line 145) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function test_interrupt_frame_correct_size (line 136) | fn test_interrupt_frame_correct_size() {
  type Context (line 165) | pub struct Context { /// Value of the stack pointer (`rsp`) register
    method empty (line 175) | pub fn empty() -> Self {

FILE: cpu/src/x86_64/msr.rs
  constant IA32_EFER (line 12) | pub const IA32_EFER: u32 = 0xc0000080;
  function write (line 19) | pub unsafe fn write(msr: u32, value: u64) {
  function read (line 29) | pub unsafe fn read(msr: u32) -> u64 {
  function enable_nxe (line 44) | pub unsafe fn enable_nxe() {

FILE: cpu/src/x86_64/task.rs
  type StateDescriptor (line 15) | pub struct StateDescriptor { pub upper: segment::Descriptor
  type StateSegment (line 23) | pub struct StateSegment {
    method new (line 40) | pub const fn new() -> Self {

FILE: cpu/src/x86_all/control_regs/cr0.rs
  function read (line 116) | pub unsafe fn read() -> Flags {
  function write (line 129) | pub unsafe fn write(flags: Flags) {
  method fmt (line 136) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: cpu/src/x86_all/control_regs/cr4.rs
  function read (line 8) | pub unsafe fn read() -> Flags {
  function write (line 21) | pub unsafe fn write(flags: Flags) {
  method fmt (line 111) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: cpu/src/x86_all/control_regs/mod.rs
  type CrState (line 21) | pub struct CrState { /// `%cr0` contains flags that control the CPU's op...
    method fmt (line 35) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function dump (line 42) | pub fn dump() -> CrState {
  function read (line 72) | pub unsafe fn read() -> usize {
  function write (line 85) | pub unsafe fn write(value: usize) {
  function read (line 105) | pub unsafe fn read() -> PAddr {
  function read (line 119) | pub unsafe fn read() -> PAddr {
  function write (line 133) | pub unsafe fn write(addr: PAddr) {
  function write (line 147) | pub unsafe fn write(addr: PAddr) {
  function current_pagetable_frame (line 159) | pub unsafe fn current_pagetable_frame() -> PhysicalPage {
  function set_pagetable_frame (line 169) | pub unsafe fn set_pagetable_frame(frame: PhysicalPage) {

FILE: cpu/src/x86_all/dtable.rs
  type Pointer (line 21) | pub struct Pointer<T: DTable> { /// the length of the descriptor table
  type DTable (line 42) | pub trait DTable: Sized {
    method get_ptr (line 78) | fn get_ptr(&self) -> Pointer<Self> {
    method entry_count (line 88) | fn entry_count(&self) -> usize;
    method load (line 91) | fn load(&'static self);

FILE: cpu/src/x86_all/flags.rs
  method iopl (line 86) | pub fn iopl(&self) -> PrivilegeLevel {
  function read (line 94) | pub fn read() -> Flags {

FILE: cpu/src/x86_all/interrupts/idt/gate32.rs
  type Gate (line 28) | pub struct Gate { /// bits 0 - 15 of the offset
    method absent (line 67) | pub const fn absent() -> Self {
    method from (line 84) | fn from(handler: ErrorCodeHandler) -> Self {
    method from (line 105) | fn from(handler: ErrorCodeHandler) -> Self {
  method new_trap (line 47) | pub const fn new_trap() -> Self {
  method new_interrupt (line 52) | pub const fn new_interrupt() -> Self {

FILE: cpu/src/x86_all/interrupts/idt/gate64.rs
  method new_trap (line 20) | pub const fn new_trap() -> Self {
  method new_task (line 25) | pub const fn new_task() -> Self {
  method new_interrupt (line 30) | pub const fn new_interrupt() -> Self {
  type Gate (line 47) | pub struct Gate<H = InterruptHandler>
    method from (line 185) | fn from(handler: *const u8) -> Self {
  function absent (line 78) | pub const fn absent() -> Self {
  function set_handler (line 92) | pub fn set_handler<F>(&mut self, handler: F) -> &mut Self
  function set_trap (line 100) | pub fn set_trap(&mut self) -> &mut Self {
  method default (line 109) | fn default() -> Self {
  type Target (line 123) | type Target = GateFlags;
  function deref (line 125) | fn deref(&self) -> &Self::Target { &self.flags }
  function deref_mut (line 129) | fn deref_mut(&mut self) -> &mut Self::Target { &mut self.flags }
  function from (line 138) | fn from(handler: InterruptHandler) -> Self {
  function from (line 159) | fn from(handler: ErrorCodeHandler) -> Self {

FILE: cpu/src/x86_all/interrupts/idt/mod.rs
  constant ENTRIES (line 17) | pub const ENTRIES: usize = 256;
  method is_trap (line 102) | pub fn is_trap(&self) -> bool {
  method is_present (line 107) | pub fn is_present(&self) -> bool {
  method set_present (line 112) | pub fn set_present(&mut self, present: bool) -> &mut Self {
  method get_dpl (line 119) | pub fn get_dpl(&self) -> PrivilegeLevel {
  method set_dpl (line 124) | pub fn set_dpl(&mut self, dpl: PrivilegeLevel) -> &mut Self {
  method default (line 133) | fn default() -> Self { GateFlags { bits: 0 } }
  type Idt (line 143) | pub struct Idt {
    type Output (line 184) | type Output = Gate;
    method index (line 187) | fn index(&self, index: usize) -> &Gate {
    method index_mut (line 197) | fn index_mut(&mut self, index: usize) -> &mut Self::Output {
    method new (line 209) | pub const fn new() -> Self {
    method enable_interrupts (line 239) | pub unsafe fn enable_interrupts() { asm!("sti") }
    method disable_interrupts (line 241) | pub unsafe fn disable_interrupts() { asm!("cli") }
    method add_handler (line 245) | pub fn add_handler<Handler>( &mut self
    method add_gate (line 255) | pub fn add_gate(&mut self, idx: usize, gate: Gate) -> &mut Self {
  method default (line 175) | fn default() -> Self {
  type Entry (line 263) | type Entry = Gate;
  method entry_count (line 265) | fn entry_count(&self) -> usize { ENTRIES }
  method load (line 267) | fn load(&'static self) {

FILE: cpu/src/x86_all/interrupts/idt/tests.rs
  function test_task_gate_32 (line 1) | fn test_task_gate_32() { assert_eq!(super::TASK_GATE_32.bits, 5)}
  function test_int_gate_32 (line 2) | fn test_int_gate_32() { assert_eq!(super::INT_GATE_32.bits, 14)}
  function test_trap_gate_32 (line 4) | fn test_trap_gate_32() { assert_eq!(super::TRAP_GATE_32.bits, 16)}

FILE: cpu/src/x86_all/interrupts/mod.rs
  constant NUM_EXCEPTIONS (line 28) | pub const NUM_EXCEPTIONS: usize = 32;
  type InterruptHandler (line 31) | pub type InterruptHandler = extern "x86-interrupt" fn (&InterruptFrame);
  type ErrorCodeHandler (line 33) | pub type ErrorCodeHandler = extern "x86-interrupt" fn (&InterruptFrame, ...
  type ExceptionInfo (line 37) | pub struct ExceptionInfo { /// The name of the exception
  method fmt (line 73) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function timer (line 89) | pub extern "x86-interrupt" fn timer(_frame: &InterruptFrame) {
  function page_fault (line 99) | pub extern "x86-interrupt" fn page_fault( frame: &InterruptFrame, error_...
  function test (line 117) | pub extern "x86-interrupt" fn test(_frame: &InterruptFrame) {

FILE: cpu/src/x86_all/interrupts/pics.rs
  constant OFFSET (line 29) | const OFFSET: u8 = 0x20;
  constant FOLLOWER_CMD_PORT (line 31) | const FOLLOWER_CMD_PORT: u16 = 0xA0;
  constant LEADER_CMD_PORT (line 33) | const LEADER_CMD_PORT: u16 = OFFSET as u16;
  type Command (line 38) | enum Command { /// Command to set the PIC to 8086 mode
  type IRQ (line 55) | pub enum IRQ { /// System timer IRQ
  type PIC (line 85) | pub struct PIC {
    method leader (line 97) | pub const fn leader() -> PIC {
    method follower (line 105) | pub const fn follower() -> PIC {
    method is_leader (line 114) | pub fn is_leader(&self) -> bool {
    method send_command (line 120) | fn send_command(&self, command: Command) {
    method send_data (line 127) | pub fn send_data(&self, data: u8) {
    method initialize (line 134) | pub fn initialize(&self) {
    method read_isr (line 140) | pub fn read_isr(&self) -> u8 {
    method read_irr (line 147) | pub fn read_irr(&self) -> u8 {
  type IRQHandler (line 155) | trait IRQHandler {
    method handles (line 157) | fn handles(&self, irq: IRQ) -> bool;
    method end_interrupt (line 159) | fn end_interrupt(&self, irq: IRQ);
    method handles (line 164) | fn handles(&self, irq: IRQ) -> bool {
    method end_interrupt (line 168) | fn end_interrupt(&self, _: IRQ) {
    method handles (line 227) | fn handles(&self, irq: IRQ) -> bool {
    method end_interrupt (line 232) | fn end_interrupt(&self, irq: IRQ) {
  type BothPICs (line 176) | struct BothPICs (PIC, PIC);
    method new (line 181) | const fn new() -> Self {
    method initialize (line 186) | pub unsafe fn initialize(&mut self) {
  function initialize (line 251) | pub unsafe fn initialize() {
  function end_pic_interrupt (line 265) | pub unsafe fn end_pic_interrupt(interrupt_id: u8) {

FILE: cpu/src/x86_all/mod.rs
  type PrivilegeLevel (line 51) | pub enum PrivilegeLevel { /// Ring 0 is the most privileged ring
    method current_iopl (line 62) | pub fn current_iopl() -> Self { flags::read().iopl() }
  type UnsafePort (line 65) | pub struct UnsafePort(u16);
    method new (line 69) | pub const unsafe fn new(number: u16) -> UnsafePort { UnsafePort(number) }
    method in8 (line 72) | pub unsafe fn in8(&self) -> u8 {
    method in16 (line 82) | pub unsafe fn in16(&self) -> u16 {
    method in32 (line 93) | pub unsafe fn in32(&self) -> u32 {
    method out8 (line 103) | pub unsafe fn out8(&self, value: u8) {
    method out16 (line 111) | pub unsafe fn out16(&self, value: u16) {
    method out32 (line 119) | pub unsafe fn out32(&self, value: u32) {
    type Error (line 130) | type Error = Void;
    method read (line 133) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
    method read_all (line 146) | fn read_all(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
    type Error (line 161) | type Error = Void;
    method write (line 163) | fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {

FILE: cpu/src/x86_all/segment.rs
  constant GDT_SIZE (line 26) | pub const GDT_SIZE: usize = 2;
  type Gdt (line 31) | pub struct Gdt { _null: Descriptor
    type Entry (line 46) | type Entry = Descriptor;
    method entry_count (line 51) | fn entry_count(&self) -> usize { GDT_SIZE }
    method load (line 54) | fn load(&self) {
  constant GDT_SIZE (line 40) | pub const GDT_SIZE: usize = 512;
  type Gdt (line 43) | pub type Gdt = [Descriptor; GDT_SIZE];
    type Entry (line 46) | type Entry = Descriptor;
    method entry_count (line 51) | fn entry_count(&self) -> usize { GDT_SIZE }
    method load (line 54) | fn load(&self) {
  method new (line 121) | pub const fn new(index: u16) -> Self {
  method from_raw (line 126) | pub const fn from_raw(bits: u16) -> Self {
  method from_cs (line 131) | pub fn from_cs() -> Self {
  method index (line 142) | pub fn index(&self) -> u16 {
  method set_global (line 149) | pub fn set_global(&mut self) -> &mut Self {
  method set_local (line 157) | pub fn set_local(&mut self) -> &mut Self {
  method set_rpl (line 165) | pub fn set_rpl(&mut self, rpl: PrivilegeLevel) -> &mut Self {
  method get_rpl (line 171) | pub fn get_rpl(&self) -> PrivilegeLevel {
  method load_ss (line 177) | pub unsafe fn load_ss(&self) {
  method load_ds (line 185) | pub unsafe fn load_ds(&self) {
  method load_es (line 193) | pub unsafe fn load_es(&self) {
  method load_fs (line 201) | pub unsafe fn load_fs(&self) {
  method load_gs (line 209) | pub unsafe fn load_gs(&self) {
  method load_cs (line 223) | pub unsafe fn load_cs(&self) {
  method default (line 238) | fn default() -> Self { Selector::from_cs() }
  method fmt (line 242) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Descriptor (line 264) | pub struct Descriptor { /// The last 8 bits of the base address
    method null (line 279) | pub const fn null() -> Self {
    method new (line 289) | pub fn new(base: u32, limit: u32) -> Self {
    method get_limit (line 305) | pub fn get_limit(&self) -> u32 {
  method default (line 313) | fn default() -> Self { Descriptor::null() }
  method null (line 352) | pub const fn null() -> Self {
  method from_raw (line 357) | pub const fn from_raw(bits: u16) -> Self {
  method get_dpl (line 362) | pub fn get_dpl(&self) -> PrivilegeLevel {
  method is_system (line 369) | pub fn is_system(&self) -> bool {
  method is_present (line 374) | pub fn is_present(&self) -> bool {
  method is_available (line 379) | pub fn is_available(&self) -> bool {
  method is_accessed (line 386) | pub fn is_accessed(&self) -> bool {
  method get_system_type (line 395) | pub fn get_system_type(&self) -> Option<SysType> {
  method get_code_type (line 408) | pub fn get_code_type(&self) -> Option<CodeFlags> {
  method get_data_type (line 421) | pub fn get_data_type(&self) -> Option<DataFlags> {
  method get_limit_part (line 430) | fn get_limit_part(&self) -> u32 {
  type Type (line 438) | pub enum Type { /// The type bits interpreted as a system segment
  type SysType (line 449) | pub enum SysType { /// System segment used for storing a local descripto...
  method is_read_only (line 477) | pub fn is_read_only(&self) -> bool {
  method is_accessed (line 482) | pub fn is_accessed(&self) -> bool {
  method is_expand_down (line 487) | pub fn is_expand_down(&self) -> bool {
  method is_exec_only (line 510) | pub fn is_exec_only(&self) -> bool {
  method is_readable (line 515) | pub fn is_readable(&self) -> bool {
  method is_accessed (line 520) | pub fn is_accessed(&self) -> bool {
  method is_conforming (line 525) | pub fn is_conforming(&self) -> bool {

FILE: cpu/src/x86_all/timer.rs
  function rtdsc (line 21) | pub unsafe fn rtdsc() -> u64 {
  function rtdscp (line 33) | pub unsafe fn rtdscp() -> u64 {
  function is_available (line 43) | pub fn is_available() -> Result<(), &'static str> {
  function get_timestamp (line 58) | pub fn get_timestamp() -> Result<u64, &'static str> {
  function wait_get_timestamp (line 65) | pub fn wait_get_timestamp() -> Result<u64, &'static str> {

FILE: elf/src/file.rs
  type Header (line 33) | pub trait Header: Sized {
    method from_slice (line 37) | fn from_slice<'a>(input: &'a [u8]) -> ElfResult<&'a Self>;
    method parse_section (line 42) | fn parse_section<'a>(&'a self, input: &'a [u8], idx: u16)
    method sh_range (line 45) | fn sh_range(&self) -> Range<usize> {
    method ph_range (line 50) | fn ph_range(&self) -> Range<usize> {
    method section_index (line 60) | fn section_index(&self, idx: usize) -> Range<usize> {
    method program_header_index (line 70) | fn program_header_index(&self, idx: usize) -> Range<usize> {
    method ident (line 77) | fn ident(&self) -> Ident;
    method get_type (line 78) | fn get_type(&self) -> Type;
    method machine (line 79) | fn machine(&self) -> Machine;
    method entry_point (line 81) | fn entry_point(&self) -> usize;
    method ph_offset (line 83) | fn ph_offset(&self) -> usize;
    method ph_count (line 85) | fn ph_count(&self) -> usize;
    method ph_entry_size (line 87) | fn ph_entry_size(&self) -> usize;
    method sh_offset (line 91) | fn sh_offset(&self) -> usize;
    method sh_count (line 95) | fn sh_count(&self) -> usize;
    method sh_entry_size (line 99) | fn sh_entry_size(&self) -> usize;
    method flags (line 102) | fn flags(&self) -> u32;
    method sh_str_idx (line 106) | fn sh_str_idx(&self) -> usize;
  constant MAGIC (line 226) | pub const MAGIC: Magic = [0x7f, b'E', b'L', b'F'];
  type Magic (line 229) | pub type Magic = [u8; 4];
  type Ident (line 235) | pub struct Ident {
    method check_magic (line 256) | pub fn check_magic(&self) -> bool { self.magic == MAGIC }
    method is_valid (line 259) | pub fn is_valid(&self) -> bool {
  type Class (line 272) | pub enum Class {
    method is_valid (line 284) | pub fn is_valid(&self) -> bool {
    method check (line 294) | fn check(&self) -> ElfResult<()> {
    method check (line 306) | fn check(&self) -> ElfResult<()> {
  type DataEncoding (line 322) | pub enum DataEncoding {
    method is_valid (line 336) | pub fn is_valid(&self) -> bool {
  type OsAbi (line 346) | pub enum OsAbi { /// Ox00 also represents "none"
  type Version (line 362) | pub enum Version { None = 0, Current = 1 }
  type TypeRepr (line 365) | struct TypeRepr(u16);
    method as_type (line 370) | pub fn as_type(&self) -> Type {
    method fmt (line 383) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Type (line 389) | pub enum Type { None
  type Machine (line 400) | pub enum Machine { None    = 0

FILE: elf/src/lib.rs
  type Section (line 85) | pub type Section<W> = section::Header<Word = W>;
  type ProgramHeader (line 86) | pub type ProgramHeader<W> = program::Header<Word = W>;
  type FileHeader (line 88) | pub type FileHeader<W> = file::HeaderRepr<W>;
  type ElfResult (line 91) | pub type ElfResult<T> = Result<T, &'static str>;
  type ElfWord (line 93) | pub trait ElfWord: Sized + Copy + Clone
  type DefaultWord (line 101) | type DefaultWord = u32;
  type DefaultWord (line 103) | type DefaultWord = u64;
  type ValidatesWord (line 106) | trait ValidatesWord<Word: ElfWord> {
    method check (line 107) | fn check(&self) -> ElfResult<()>;
  type Image (line 115) | pub struct Image< 'bytes             // lifetime of the byte slice
  function sh_str_table (line 148) | pub fn sh_str_table(&'a self) -> section::StrTable<'a> {
  type Error (line 167) | type Error = &'static str;
  function try_from (line 169) | fn try_from(bytes: &'a [u8]) -> ElfResult<Self> {
  function extract_from_slice (line 241) | unsafe fn extract_from_slice<'slice, T: Sized>( data: &'slice [u8]
  function into (line 270) | fn into(self) -> FrameRange {

FILE: elf/src/program.rs
  type Header (line 27) | pub trait Header: Sized {
    method ty (line 34) | fn ty(&self) -> Type;
    method offset (line 37) | fn offset(&self) -> usize;
    method vaddr (line 40) | fn vaddr(&self) -> Self::Word;
    method paddr (line 43) | fn paddr(&self) -> Self::Word;
    method file_size (line 48) | fn file_size(&self) -> usize;
    method mem_size (line 53) | fn mem_size(&self) -> usize;
    method flags (line 58) | fn flags(&self) -> Flags;
    method align (line 60) | fn align(&self) -> usize;
  type Type (line 95) | pub enum Type {

FILE: elf/src/section.rs
  constant SHN_UNDEF (line 17) | pub const SHN_UNDEF: u16        = 0;
  constant SHN_LORESERVE (line 18) | pub const SHN_LORESERVE: u16    = 0xff00;
  constant SHN_LOPROC (line 19) | pub const SHN_LOPROC: u16       = 0xff00;
  constant SHN_HIPROC (line 20) | pub const SHN_HIPROC: u16       = 0xff1f;
  constant SHN_LOOS (line 21) | pub const SHN_LOOS: u16         = 0xff20;
  constant SHN_HIOS (line 22) | pub const SHN_HIOS: u16         = 0xff3f;
  constant SHN_ABS (line 23) | pub const SHN_ABS: u16          = 0xfff1;
  constant SHN_COMMON (line 24) | pub const SHN_COMMON: u16       = 0xfff2;
  constant SHN_XINDEX (line 25) | pub const SHN_XINDEX: u16       = 0xffff;
  constant SHN_HIRESERVE (line 26) | pub const SHN_HIRESERVE: u16    = 0xffff;
  constant SHT_LOOS (line 28) | pub const SHT_LOOS: u32   = 0x60000000;
  constant SHT_HIOS (line 29) | pub const SHT_HIOS: u32   = 0x6fffffff;
  constant SHT_LOPROC (line 30) | pub const SHT_LOPROC: u32 = 0x70000000;
  constant SHT_HIPROC (line 31) | pub const SHT_HIPROC: u32 = 0x7fffffff;
  constant SHT_LOUSER (line 32) | pub const SHT_LOUSER: u32 = 0x80000000;
  constant SHT_HIUSER (line 33) | pub const SHT_HIUSER: u32 = 0xffffffff;
  type Header (line 46) | pub trait Header: fmt::Debug {
    method end_address (line 55) | fn end_address(&self) -> PAddr {
    method is_writable (line 60) | fn is_writable(&self) -> bool {
    method is_allocated (line 65) | fn is_allocated(&self) -> bool {
    method is_executable (line 70) | fn is_executable(&self) -> bool {
    method is_mergeable (line 75) | fn is_mergeable(&self) -> bool {
    method is_uniform (line 80) | fn is_uniform(&self) -> bool {
    method get_name (line 87) | fn get_name<'a>(&self, strtab: StrTable<'a>) -> &'a str {
    method name_offset (line 92) | fn name_offset(&self) -> u32;
    method get_type (line 94) | fn get_type(&self) -> ElfResult<Type>;
    method flags (line 95) | fn flags(&self) -> Flags;
    method address (line 96) | fn address(&self) -> PAddr;
    method offset (line 97) | fn offset(&self) -> usize;
    method length (line 100) | fn length(&self) -> usize;
    method link (line 101) | fn link(&self) -> u32;
    method info (line 102) | fn info(&self) -> u32;
    method address_align (line 103) | fn address_align(&self) -> Self::Word;
    method entry_length (line 104) | fn entry_length(&self) -> usize;
  function fmt (line 146) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method fmt (line 216) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Contents (line 229) | pub enum Contents<'a> {
  type TypeRepr (line 247) | struct TypeRepr(u32);
    method as_type (line 252) | fn as_type(&self) -> ElfResult<Type> {
  type Type (line 284) | pub enum Type {
  type Sections (line 371) | pub struct Sections<'a, W: 'a>
  function new (line 380) | pub fn new(curr: &'a HeaderRepr<W>, remaining: u32, size: u32)
  type Item (line 393) | type Item = &'a Header<Word = W>;
  method next (line 395) | fn next(&mut self) -> Option<Self::Item> {
  type ElfChar (line 417) | type ElfChar = u8;
  type StrTable (line 431) | pub struct StrTable<'a>(&'a [ElfChar]);
  function from (line 435) | fn from(binary: &'a [ElfChar]) -> Self { StrTable(binary) }
  function at_index (line 450) | pub fn at_index(&'a self, i: usize) -> Option<&'a str> {
  type Target (line 476) | type Target = [ElfChar];
  function deref (line 478) | fn deref(&self) -> &Self::Target { self.0 }
  type IntoIter (line 482) | type IntoIter = Strings<'a>;
  type Item (line 483) | type Item = &'a str;
  method into_iter (line 487) | fn into_iter(self) -> Self::IntoIter { Strings(&self.0) }
  function is_null (line 491) | fn is_null(ch: &ElfChar) -> bool { *ch == b'\0' }
  function read_to_null (line 497) | fn read_to_null<'a>(bytes: &'a [ElfChar]) -> Option<&'a [ElfChar]> {
  type Strings (line 504) | pub struct Strings<'a>(&'a [ElfChar]);
  type Item (line 507) | type Item = &'a str;
  method next (line 509) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 541) | fn size_hint(&self) -> (usize, Option<usize>) {

FILE: memory/src/arch/x86/mod.rs
  type PAddr (line 13) | pub struct PAddr(u32);
    method into (line 19) | fn into(self) -> u32 { self.as_u32() }
    method from (line 23) | fn from(u: u32) -> Self { PAddr::from_u32(u) }
    method from (line 27) | fn from(ptr: *mut u8) -> Self { PAddr::from_ptr(ptr) }
    method from_ptr (line 31) | pub fn from_ptr(ptr: *mut u8) -> Self { PAddr(ptr as u32) }
    method from_u32 (line 32) | pub const fn from_u32(u: u32) -> Self { PAddr(u) }
    method as_u32 (line 33) | pub const fn as_u32(&self) -> u32 { self.0 }

FILE: memory/src/arch/x86_64/mod.rs
  constant PAGE_SHIFT (line 14) | pub const PAGE_SHIFT: u8 = 12;
  constant PAGE_SIZE (line 16) | pub const PAGE_SIZE: u64 = 1 << PAGE_SHIFT;
  constant LARGE_PAGE_SIZE (line 18) | pub const LARGE_PAGE_SIZE: u64 = 1024 * 1024 * 2;
  constant HUGE_PAGE_SIZE (line 20) | pub const HUGE_PAGE_SIZE: u64 = 1024 * 1024 * 1024;
  method fmt (line 38) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Output (line 44) | type Output = Self;
  method add (line 46) | fn add(self, rhs: usize) -> Self {
  type Output (line 52) | type Output = Self;
  method sub (line 54) | fn sub(self, rhs: usize) -> Self {
  method add_assign (line 60) | fn add_assign(&mut self, rhs: usize) {
  method sub_assign (line 66) | fn sub_assign(&mut self, rhs: usize) {
  method base_addr (line 75) | pub const fn base_addr(&self) -> PAddr {
  method containing_addr (line 81) | pub const fn containing_addr(addr: PAddr) -> PhysicalPage {
  method as_ptr (line 87) | pub unsafe fn as_ptr<T>(&self) -> *const T {
  method as_mut_ptr (line 93) | pub unsafe fn as_mut_ptr<T>(&self) -> *mut T {

FILE: memory/src/lib.rs
  type Addr (line 37) | pub trait Addr: ops::Add<Self> + ops::Sub<Self>
    method align_down (line 45) | fn align_down(&self, align: Self::Repr) -> Self;
    method align_up (line 46) | fn align_up(&self, align: Self::Repr) -> Self;
    method is_page_aligned (line 49) | fn is_page_aligned(&self) -> bool;
  method from_ptr (line 64) | pub fn from_ptr<T>(ptr: *mut T) -> Self { VAddr(ptr as usize) }
  method from_usize (line 67) | pub const fn from_usize(u: usize) -> Self { VAddr(u) }
  method as_usize (line 70) | pub const fn as_usize(&self) -> usize { self.0 }
  method pml4_index (line 73) | pub fn pml4_index(&self) -> usize {
  method pdpt_index (line 78) | pub fn pdpt_index(&self) -> usize {
  method pd_index (line 83) | pub fn pd_index(&self) -> usize {
  method pt_index (line 88) | pub fn pt_index(&self) -> usize {
  type PageRange (line 97) | pub type PageRange = Range<VirtualPage>;
  type FrameRange (line 98) | pub type FrameRange = Range<PhysicalPage>;
  type Page (line 102) | pub trait Page
    method containing (line 121) | fn containing(addr: Self::Address) -> Self;
    method base (line 124) | fn base(&self) -> Self::Address;
    method end_address (line 127) | fn end_address(&self) -> Self::Address;
    method range_of (line 143) | fn range_of(&self, n: usize) -> Range<Self> {
    method range_until (line 149) | fn range_until(&self, end: Self) -> Range<Self> {
    method number (line 153) | fn number(&self) -> usize;
  method containing_addr (line 165) | fn containing_addr( addr: VAddr) -> Self {
  method fmt (line 174) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type MemRange (line 185) | pub trait MemRange {
    method length (line 188) | fn length(&self) -> usize;
    method drop_front (line 191) | fn drop_front(&mut self, n: usize) -> &mut Self;
    method drop_back (line 194) | fn drop_back(&mut self, n: usize) -> &mut Self;
    method add_front (line 197) | fn add_front(&mut self, n: usize) -> &mut Self;
    method add_back (line 200) | fn add_back(&mut self, n: usize) -> &mut Self;
    method length (line 219) | fn length(&self) -> usize {
    method drop_front (line 224) | fn drop_front(&mut self, n: usize) -> &mut Self {
    method drop_back (line 231) | fn drop_back(&mut self, n: usize) -> &mut Self {
    method add_front (line 238) | fn add_front(&mut self, n: usize) -> &mut Self {
    method add_back (line 244) | fn add_back(&mut self, n: usize) -> &mut Self {
  type RangeIter (line 251) | pub struct RangeIter<'a, P>
  type Item (line 258) | type Item = P;
  method next (line 260) | fn next(&mut self) -> Option<P> {

FILE: paging/src/arch/x86_64/cr3.rs
  function current_pml4 (line 13) | pub unsafe fn current_pml4() -> *mut Table<PML4Level> {
  function set_pml4 (line 23) | pub unsafe fn set_pml4(pml4: Table<PML4Level>) {

FILE: paging/src/arch/x86_64/mod.rs
  type ActivePageTable (line 31) | pub struct ActivePageTable { pml4: ActivePML4 }
    type Target (line 34) | type Target = ActivePML4;
    method deref (line 36) | fn deref(&self) -> &ActivePML4 {
    method deref_mut (line 42) | fn deref_mut(&mut self) -> &mut ActivePML4 {
    method new (line 48) | pub unsafe fn new() -> ActivePageTable {
    method using (line 54) | pub fn using<F>( &mut self
    method replace_with (line 103) | pub fn replace_with(&mut self, new_table: InactivePageTable)
  type ActivePML4 (line 127) | pub struct ActivePML4(Unique<Table<PML4Level>>);
    method fmt (line 130) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method new (line 280) | pub unsafe fn new() -> Self {
    method pml4 (line 284) | fn pml4(&self) -> &Table<PML4Level> {
    method pml4_mut (line 288) | fn pml4_mut(&mut self) -> &mut Table<PML4Level> {
    method is_mapped (line 294) | pub fn is_mapped(&self, page: &VirtualPage) -> bool {
  type Flags (line 136) | type Flags = EntryFlags;
  method translate (line 138) | fn translate(&self, vaddr: VAddr) -> Option<PAddr> {
  method translate_page (line 144) | fn translate_page(&self, page: VirtualPage) -> Option<PhysicalPage> {
  method map (line 173) | fn map<A>( &mut self, page: VirtualPage, frame: PhysicalPage
  method identity_map (line 205) | fn identity_map<A>(&mut self, frame: PhysicalPage, flags: EntryFlags
  method map_to_any (line 215) | fn map_to_any<A>( &mut self
  method unmap (line 233) | fn unmap<A>(&mut self, page: VirtualPage, alloc: &mut A) -> MapResult<()>
  type InactivePageTable (line 303) | pub struct InactivePageTable {
    method new (line 308) | pub fn new( frame: PhysicalPage
  function test_paging (line 328) | pub fn test_paging<A>(alloc: &mut A) -> MapResult<()>
  function kernel_remap (line 368) | pub fn kernel_remap<A>(params: &InitParams, alloc: &mut A)

FILE: paging/src/arch/x86_64/table.rs
  constant N_ENTRIES (line 20) | pub const N_ENTRIES: usize = 512;
  constant PAGE_TABLE_SIZE (line 22) | pub const PAGE_TABLE_SIZE: usize = N_ENTRIES * PAGE_SIZE as usize;
  constant PML4_VADDR (line 25) | pub const PML4_VADDR: u64 =  0xffffffff_fffff000;
  constant PML4_PTR (line 28) | pub const PML4_PTR: *mut Table<PML4Level> = PML4_VADDR as *mut _;
  constant ENTRY_FLAGS_MASK (line 31) | pub const ENTRY_FLAGS_MASK: u64 = (PAGE_SIZE as u64 - 1) as u64;
  type Table (line 35) | pub struct Table<L>
  function fmt (line 43) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type TableLevel (line 52) | pub trait TableLevel {
    constant ADDR_SHIFT_AMOUNT (line 54) | const ADDR_SHIFT_AMOUNT: usize;
    constant PAGE_SHIFT_AMOUNT (line 56) | const PAGE_SHIFT_AMOUNT: usize;
    constant INDEX_MASK (line 58) | const INDEX_MASK: usize = 0o777;
    constant ADDR_SHIFT_AMOUNT (line 104) | const ADDR_SHIFT_AMOUNT: usize = 39;
    constant PAGE_SHIFT_AMOUNT (line 105) | const PAGE_SHIFT_AMOUNT: usize = 27;
    constant ADDR_SHIFT_AMOUNT (line 108) | const ADDR_SHIFT_AMOUNT: usize = 30;
    constant PAGE_SHIFT_AMOUNT (line 109) | const PAGE_SHIFT_AMOUNT: usize = 18;
    constant ADDR_SHIFT_AMOUNT (line 112) | const ADDR_SHIFT_AMOUNT: usize = 21;
    constant PAGE_SHIFT_AMOUNT (line 113) | const PAGE_SHIFT_AMOUNT: usize = 9;
    constant ADDR_SHIFT_AMOUNT (line 116) | const ADDR_SHIFT_AMOUNT: usize = 12;
    constant PAGE_SHIFT_AMOUNT (line 117) | const PAGE_SHIFT_AMOUNT: usize = 0;
  type IndexOf (line 62) | pub trait IndexOf<I> {
    method index_of (line 63) | fn index_of(i: I) -> usize;
  method index_of (line 71) | fn index_of(addr: VAddr) -> usize {
  method index_of (line 81) | fn index_of(page: VirtualPage) -> usize {
  method index_of (line 92) | fn index_of(i: usize) -> usize { i }
  type PML4Level (line 96) | pub enum PML4Level {}
  type PDPTLevel (line 97) | pub enum PDPTLevel {}
  type PDLevel (line 98) | pub enum PDLevel   {}
  type PTLevel (line 99) | pub enum PTLevel   {}
  type Sublevel (line 120) | pub trait Sublevel: TableLevel {
    type Next (line 124) | type Next = PDPTLevel;
    type Next (line 127) | type Next = PDLevel;
    type Next (line 130) | type Next = PTLevel;
  function page_table_for (line 135) | pub fn page_table_for(&self, page: VirtualPage) -> Option<&Table<PTLevel...
  function page_table_mut_for (line 142) | pub fn page_table_mut_for(&mut self, page: VirtualPage)
  type Output (line 154) | type Output = Entry;
  function index (line 156) | fn index(&self, i: I) -> &Entry {
  function index_mut (line 164) | fn index_mut(&mut self, i: I) -> &mut Entry {
  function zero (line 173) | pub fn zero(&mut self) -> &mut Self {
  function start_paddr (line 184) | pub fn start_paddr(&self) -> PAddr {
  function frame (line 190) | pub fn frame(&self) -> PhysicalPage {
  function next_table_addr (line 201) | fn next_table_addr(&self, i: usize) -> Option<VAddr> {
  function next_table (line 213) | pub fn next_table<I>(&self, i: I) -> Option<&Table<L::Next>>
  function next_table_mut (line 221) | pub fn next_table_mut<I>(&self, i: I) -> Option<& mut Table<L::Next>>
  function create_next (line 231) | pub fn create_next<A>(&mut self, i: VirtualPage, alloc: &mut A)
  method is_huge (line 291) | pub fn is_huge(&self) -> bool {
  method is_present (line 297) | pub fn is_present(&self) -> bool {
  method set_present (line 302) | pub fn set_present(&mut self, present: bool) -> &mut Self {
  method set_writable (line 309) | pub fn set_writable(&mut self, writable: bool) -> &mut Self {
  method set_executable (line 316) | pub fn set_executable(&mut self, executable: bool) -> &mut Self {
  type Entry (line 324) | pub struct Entry(u64);
    method new (line 328) | pub fn new(addr: PAddr) -> Self {
    method do_huge (line 335) | pub fn do_huge(&self, offset: usize) -> Option<PhysicalPage> {
    method is_unused (line 350) | pub fn is_unused(&self) -> bool {
    method set_unused (line 356) | pub fn set_unused(&mut self) {
    method is_huge (line 362) | pub fn is_huge(&self) -> bool {
    method flags (line 368) | pub fn flags(&self) -> EntryFlags {
    method get_addr (line 374) | pub fn get_addr(&self) -> PAddr {
    method get_frame (line 379) | pub fn get_frame(&self) -> Option<PhysicalPage> {
    method set (line 388) | pub fn set(&mut self, frame: PhysicalPage, flags: EntryFlags) {
  method from (line 397) | fn from(section: &'a elf::Section<u64>) -> Self {

FILE: paging/src/arch/x86_64/temp.rs
  type TempPage (line 11) | pub struct TempPage { page: VirtualPage
    type Target (line 18) | type Target = VirtualPage;
    method deref (line 19) | fn deref(&self) -> &VirtualPage { &self.page }
    method deref_mut (line 23) | fn deref_mut(&mut self) -> &mut VirtualPage { &mut self.page }
    method new (line 34) | pub fn new<A>(number: usize, alloc: &mut A) -> Self
    method map_to (line 49) | pub fn map_to( &mut self
    method map_to_table (line 61) | pub fn map_to_table( &mut self
    method unmap (line 71) | pub fn unmap(&mut self, table: &mut ActivePageTable) -> MapResult<()> {
  type FrameCache (line 82) | pub struct FrameCache([Option<PhysicalPage>; 3]);
    method new (line 86) | pub fn new<A>(alloc: &mut A) -> Self
  method allocate (line 99) | unsafe fn allocate(&mut self) -> AllocResult<PhysicalPage> {
  method deallocate (line 110) | unsafe fn deallocate(&mut self, frame: PhysicalPage) {
  method allocate_range (line 117) | unsafe fn allocate_range(&mut self, _num: usize)
  method deallocate_range (line 122) | unsafe fn deallocate_range(&mut self, _range: FrameRange) {

FILE: paging/src/arch/x86_64/tlb.rs
  function flush_all (line 8) | pub unsafe fn flush_all() {
  type Flush (line 14) | pub trait Flush {
    method invlpg (line 19) | unsafe fn invlpg(self);
    method invlpg (line 42) | unsafe fn invlpg(self) {
    method invlpg (line 53) | unsafe fn invlpg(self) {

FILE: paging/src/lib.rs
  type MapResult (line 39) | pub type MapResult<T = ()> = Result<T, MapErr>;
  type MapErr (line 42) | pub enum MapErr<P: Page + fmt::Debug = VirtualPage> {
  function fmt (line 52) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Mapper (line 57) | pub trait Mapper {
    method translate (line 66) | fn translate(&self, vaddr: VAddr) -> Option<PAddr>;
    method translate_page (line 69) | fn translate_page(&self, page: VirtualPage) -> Option<PhysicalPage>;
    method map (line 78) | fn map<A>( &mut self, page: VirtualPage, frame: PhysicalPage
    method identity_map (line 89) | fn identity_map<A>( &mut self, frame: PhysicalPage
    method map_to_any (line 103) | fn map_to_any<A>( &mut self, page: VirtualPage
    method unmap (line 112) | fn unmap<A>(&mut self, page: VirtualPage, alloc: &mut A) -> MapResult<()>

FILE: paging/src/stack.rs
  type Stack (line 18) | pub type Stack = Range<VAddr>;
  type StackAllocator (line 20) | pub trait StackAllocator {
    method allocate (line 21) | fn allocate<A>( &mut self
    method allocate (line 30) | fn allocate<A>( &mut self

FILE: params/src/lib.rs
  constant MAX_MEM_AREAS (line 33) | const MAX_MEM_AREAS: usize = 32;
  type ElfSections (line 37) | pub type ElfSections = elf::section::Sections<'static, u64>;
  type ElfSections (line 41) | pub type ElfSections = elf::section::Sections<'static, u32>;
  type InitParams (line 45) | pub struct InitParams {
    method elf_sections (line 103) | pub fn elf_sections(&self) ->  ElfSections {
    method multiboot_start (line 116) | pub fn multiboot_start(&self) -> PAddr {
    method multiboot_end (line 128) | pub fn multiboot_end(&self) -> PAddr {
    method kernel_frames (line 142) | pub fn kernel_frames(&self) -> FrameRange {
    method heap_frames (line 155) | pub fn heap_frames(&self) -> FrameRange {
    method stack_frames (line 165) | pub fn stack_frames(&self) -> FrameRange {
    method mem_map (line 171) | pub fn mem_map(&self) -> mem::Map {
  method default (line 76) | fn default() -> Self {

FILE: params/src/mem.rs
  type Map (line 7) | pub type Map<'a> = Iter<'a, Area>;
  type Area (line 11) | pub struct Area {

FILE: sos_alloc/src/borrow.rs
  type Lender (line 6) | pub trait Lender {
    method borrow (line 8) | fn borrow(&self) -> Self::Borrowed;
  type BorrowedPtr (line 21) | pub struct BorrowedPtr<'alloc, A>
  function new (line 34) | pub fn new( ptr: Address
  type Target (line 49) | type Target = Unique<u8>;
  method deref (line 50) | fn deref(&self) ->  &Self::Target { &self.ptr }
  method drop (line 56) | fn drop(&mut self) {
  type Borrowed (line 69) | pub struct Borrowed<'alloc, A, T>
  function new (line 81) | pub fn new( value: Unique<T>, allocator: &'alloc Mutex<A>)
  type Target (line 93) | type Target = T;
  method deref (line 94) | fn deref(&self) ->  &Self::Target { unsafe { self.value.as_ref() } }
  method deref_mut (line 100) | fn deref_mut(&mut self) ->  &mut Self::Target {
  method drop (line 108) | fn drop(&mut self) {

FILE: sos_alloc/src/buddy/math.rs
  constant B (line 2) | const B: [usize; 5]
  constant S (line 7) | const S: [usize; 5] = [ 1, 2, 4, 8, 16 ];
  constant B (line 10) | const B: [usize; 6]
  constant S (line 16) | const S: [usize; 6] = [ 1, 2, 4, 8, 16, 32 ];
  type PowersOf2 (line 18) | pub trait PowersOf2 {
    method is_pow2 (line 19) | fn is_pow2(&self) -> bool;
    method next_pow2 (line 20) | fn next_pow2(&self) -> Self;
    method log2 (line 21) | fn log2(&self) -> Self;
    method is_pow2 (line 25) | fn is_pow2(&self) -> bool {
    method next_pow2 (line 30) | fn next_pow2(&self) -> usize {
    method log2 (line 46) | fn log2(&self) -> usize {
    method log2 (line 61) | fn log2(&self) -> usize {
  function test_next_pow2 (line 82) | fn test_next_pow2() {
  function test_is_pow2 (line 102) | fn test_is_pow2() {
  function test_log2 (line 116) | fn test_log2() {
  function our_next_pow2 (line 126) | fn our_next_pow2(b: &mut Bencher) {
  function std_next_power_of_two (line 138) | fn std_next_power_of_two(b: &mut Bencher) {
  function our_is_pow2 (line 150) | fn our_is_pow2(b: &mut Bencher) {
  function std_is_power_of_two (line 162) | fn std_is_power_of_two(b: &mut Bencher) {

FILE: sos_alloc/src/buddy/mod.rs
  type FreeList (line 33) | pub type FreeList = List<Unique<FreeBlock>, FreeBlock>;
  type FreeBlock (line 36) | pub struct FreeBlock { next: RawLink<FreeBlock>
    method as_ptr (line 40) | unsafe fn as_ptr(&self) -> *mut u8 { mem::transmute(self) }
  method prev (line 44) | fn prev(&self) -> &RawLink<FreeBlock> {
  method next (line 47) | fn next(&self) -> &RawLink<FreeBlock> {
  method prev_mut (line 50) | fn prev_mut(&mut self) -> &mut RawLink<FreeBlock> {
  method next_mut (line 53) | fn next_mut(&mut self) -> &mut RawLink<FreeBlock> {
  type Heap (line 66) | pub struct Heap<'a> {
  function new (line 104) | pub unsafe fn new( start_addr: Address
  function add_block (line 162) | pub unsafe fn add_block(&mut self, block: Address) {
  function alloc_size (line 179) | pub fn alloc_size(&self, layout: &Layout) -> Result<usize, AllocErr> {
  function alloc_order (line 220) | pub fn alloc_order(&self, layout: &Layout) -> Result<usize, AllocErr> {
  function order_alloc_size (line 232) | fn order_alloc_size(&self, order: usize) -> usize {
  function push_block (line 237) | unsafe fn push_block(&mut self, ptr: *mut u8, order: usize) {
  function pop_block (line 243) | unsafe fn pop_block(&mut self, order: usize) -> Option<*mut u8>{
  function split_block (line 269) | unsafe fn split_block( &mut self
  function get_buddy (line 307) | pub unsafe fn get_buddy( &self
  function remove_block (line 343) | pub fn remove_block(&mut self, order: usize, block: Address) -> bool {
  method alloc (line 364) | unsafe fn alloc(&mut self, layout: Layout) -> Result<Address, AllocErr> {
  method dealloc (line 409) | unsafe fn dealloc(&mut self, ptr: Address, layout: Layout) {

FILE: sos_alloc/src/buddy/system.rs
  constant NUM_FREE_LISTS (line 9) | pub const NUM_FREE_LISTS: usize = 19;
  function init_heap (line 33) | pub unsafe fn init_heap(start_addr: *mut u8, heap_size: usize ) {
  function __rust_allocate (line 46) | pub extern "C" fn __rust_allocate(size: usize, align: usize) -> *mut u8 {
  function __rust_deallocate (line 66) | pub extern "C" fn __rust_deallocate( ptr: *mut u8, old_size: usize
  function __rust_reallocate (line 77) | pub extern "C" fn __rust_reallocate( ptr: *mut u8, old_size: usize
  function __rust_reallocate_inplace (line 96) | pub extern "C" fn __rust_reallocate_inplace( _ptr: *mut u8
  function __rust_usable_size (line 105) | pub extern "C" fn __rust_usable_size(size: usize, _: usize) -> usize {
  type BuddyFrameAllocator (line 113) | pub struct BuddyFrameAllocator;
    method new (line 117) | pub const fn new() -> Self { BuddyFrameAllocator }

FILE: sos_alloc/src/buddy/test.rs
  function memalign (line 11) | fn memalign(alignment: usize, size: usize) -> *mut u8;
  function memalign (line 14) | fn memalign(alignment: usize, size: usize) -> *mut u8;
  function free (line 17) | fn free(ptr: *mut u8);
  constant HEAP_ALIGN (line 20) | const HEAP_ALIGN: usize = 4096;
  constant HEAP_SIZE (line 21) | const HEAP_SIZE: usize = 256;
  function test_allocation_size_and_order (line 24) | fn test_allocation_size_and_order() {
  function test_get_buddy (line 84) | fn test_get_buddy() {
  function test_alloc_and_dealloc (line 118) | fn test_alloc_and_dealloc() {

FILE: sos_alloc/src/bump_ptr.rs
  type BumpPtr (line 19) | pub struct BumpPtr { start: PAddr
    method new (line 25) | pub const fn new(start: PAddr, end: PAddr) -> Self {
  method alloc (line 34) | unsafe fn alloc(&mut self, layout: Layout) -> Result<Address, AllocErr> {
  method dealloc (line 46) | unsafe fn dealloc(&mut self, _ptr: Address, _layout: Layout) {

FILE: sos_alloc/src/first_fit.rs
  constant SIZE (line 6) | const SIZE: usize = 256;
  type FirstFit (line 9) | pub struct FirstFit<'a> {
  method allocate (line 15) | unsafe fn allocate(&self) -> Option<PhysicalPage> {
  method deallocate (line 19) | unsafe fn deallocate(&self, _frame: PhysicalPage) {
  method allocate_range (line 23) | unsafe fn allocate_range(&self, num: usize) -> Option<FrameRange> {
  method deallocate_range (line 37) | unsafe fn deallocate_range(&self, _range: FrameRange) {

FILE: sos_alloc/src/frame/mem_map.rs
  type MemMapAllocator (line 29) | pub struct MemMapAllocator<'a> { next_free: Frame
  function next_area (line 36) | fn next_area(&mut self) {
  function from (line 53) | fn from(params: &'a InitParams) -> Self {
  method allocate (line 74) | unsafe fn allocate(&mut self) -> AllocResult<Frame> {
  method deallocate (line 121) | unsafe fn deallocate(&mut self, _frame: Frame) {
  method allocate_range (line 126) | unsafe fn allocate_range(&mut self, _num: usize) -> AllocResult<FrameRan...
  method deallocate_range (line 130) | unsafe fn deallocate_range(&mut self, _range: FrameRange) {

FILE: sos_alloc/src/frame/mod.rs
  type Allocator (line 19) | pub trait Allocator: Sized  {
    method allocate (line 22) | unsafe fn allocate(&mut self) -> AllocResult<Frame>;
    method deallocate (line 24) | unsafe fn deallocate(&mut self, frame: Frame);
    method allocate_range (line 27) | unsafe fn allocate_range(&mut self, num: usize) -> AllocResult<FrameRa...
    method deallocate_range (line 29) | unsafe fn deallocate_range(&mut self, range: FrameRange);
  type Lender (line 36) | pub trait Lender<A>
    method borrow (line 50) | fn borrow(&self) -> AllocResult<BorrowedFrame<A>>;
    method borrow_range (line 69) | fn borrow_range(&self, num: usize) -> AllocResult<BorrowedFrameRange<A>>;
  function borrow (line 75) | fn borrow(&self) -> AllocResult<BorrowedFrame<A>> {
  function borrow_range (line 83) | fn borrow_range(&self, num: usize) -> AllocResult<BorrowedFrameRange<A>> {
  type BorrowedFrame (line 99) | pub struct BorrowedFrame<'alloc, A>
  type Target (line 109) | type Target = Frame;
  function deref (line 110) | fn deref(&self) ->  &Self::Target { &self.frame }
  function deref_mut (line 116) | fn deref_mut(&mut self) ->  &mut Self::Target { &mut self.frame }
  method drop (line 122) | fn drop(&mut self) {
  type BorrowedFrameRange (line 128) | pub struct BorrowedFrameRange<'alloc, A>
  type Target (line 138) | type Target = FrameRange;
  function deref (line 139) | fn deref(&self) -> &Self::Target { &self.range }
  function deref_mut (line 145) | fn deref_mut(&mut self) -> &mut Self::Target { &mut self.range }
  method drop (line 151) | fn drop(&mut self) {

FILE: sos_alloc/src/free.rs
  type List (line 8) | pub type List = IList<Unique<Block>, Block>;
  type Block (line 13) | pub struct Block { next: RawLink<Block>
    method as_ptr (line 17) | pub unsafe fn as_ptr(&self) -> *mut u8 { mem::transmute(self) }
  method prev (line 21) | fn prev(&self) -> &RawLink<Block> {
  method next (line 24) | fn next(&self) -> &RawLink<Block> {
  method prev_mut (line 27) | fn prev_mut(&mut self) -> &mut RawLink<Block> {
  method next_mut (line 30) | fn next_mut(&mut self) -> &mut RawLink<Block> {

FILE: sos_alloc/src/lib.rs
  type AllocResult (line 84) | pub type AllocResult<T> = Result<T, AllocErr>;
  type Size (line 86) | pub type Size = usize;
  type Capacity (line 87) | pub type Capacity = usize;
  type Alignment (line 88) | pub type Alignment = usize;
  type Address (line 90) | pub type Address = *mut u8;
  type Excess (line 97) | pub struct Excess(Address, Capacity);
  function size_align (line 99) | fn size_align<T>() -> (usize, usize) {
  type Layout (line 110) | pub struct Layout {
    method from_size_align (line 130) | pub fn from_size_align(size: usize, align: usize) -> Layout {
    method size (line 137) | pub fn size(&self) -> usize { self.size }
    method align (line 140) | pub fn align(&self) -> usize { self.align }
    method new (line 143) | pub fn new<T>() -> Self {
    method for_value (line 151) | pub fn for_value<T: ?Sized>(t: &T) -> Self {
    method align_to (line 167) | pub fn align_to(&self, align: Alignment) -> Self {
    method padding_needed_for (line 189) | pub fn padding_needed_for(&self, align: Alignment) -> usize {
    method repeat (line 204) | pub fn repeat(&self, n: usize) -> Option<(Self, usize)> {
    method extend (line 227) | pub fn extend(&self, next: Self) -> Option<(Self, usize)> {
    method repeat_packed (line 240) | pub fn repeat_packed(&self, n: usize) -> Option<Self> {
    method extend_packed (line 264) | pub fn extend_packed(&self, next: Self) -> Option<(Self, usize)> {
    method new_unchecked (line 281) | pub unsafe fn new_unchecked<T>() -> Self {
    method extend_unchecked (line 298) | pub unsafe fn extend_unchecked(&self, next: Self) -> (Self, usize) {
    method repeat_unchecked (line 307) | pub unsafe fn repeat_unchecked(&self, n: usize) -> (Self, usize) {
    method repeat_packed_unchecked (line 316) | pub unsafe fn repeat_packed_unchecked(&self, n: usize) -> Self {
    method extend_packed_unchecked (line 336) | pub unsafe fn extend_packed_unchecked(&self, next: Self) -> (Self, usi...
    method array (line 343) | pub fn array<T>(n: usize) -> Option<Self> {
    method array_unchecked (line 356) | pub fn array_unchecked<T>(n: usize) -> Self {
  type AllocErr (line 367) | pub enum AllocErr {
    method invalid_input (line 386) | pub fn invalid_input(details: &'static str) -> Self {
    method is_memory_exhausted (line 389) | pub fn is_memory_exhausted(&self) -> bool {
    method is_request_unsupported (line 392) | pub fn is_request_unsupported(&self) -> bool {
  type CannotReallocInPlace (line 400) | pub struct CannotReallocInPlace;
  type Allocator (line 427) | pub unsafe trait Allocator {
    method alloc (line 443) | unsafe fn alloc(&mut self, layout: Layout) -> Result<Address, AllocErr>;
    method dealloc (line 450) | unsafe fn dealloc(&mut self, ptr: Address, layout: Layout);
    method oom (line 465) | fn oom(&mut self, _: AllocErr) -> ! {
    method usable_size (line 496) | unsafe fn usable_size(&self, layout: &Layout) -> (Capacity, Capacity) {
    method realloc (line 540) | unsafe fn realloc(&mut self,
    method alloc_excess (line 565) | unsafe fn alloc_excess(&mut self, layout: Layout) -> Result<Excess, Al...
    method realloc_excess (line 573) | unsafe fn realloc_excess(&mut self,
    method realloc_in_place (line 604) | unsafe fn realloc_in_place(&mut self,
    method alloc_one (line 623) | unsafe fn alloc_one<T>(&mut self) -> Result<Unique<T>, AllocErr>
    method dealloc_one (line 641) | unsafe fn dealloc_one<T>(&mut self, mut ptr: Unique<T>)
    method alloc_array (line 657) | unsafe fn alloc_array<T>(&mut self, n: usize) -> Result<Unique<T>, All...
    method realloc_array (line 683) | unsafe fn realloc_array<T>(&mut self,
    method dealloc_array (line 704) | unsafe fn dealloc_array<T>(&mut self, ptr: Unique<T>, n: usize) -> Res...
    method alloc_unchecked (line 730) | unsafe fn alloc_unchecked(&mut self, layout: Layout) -> Option<Address> {
    method realloc_unchecked (line 762) | unsafe fn realloc_unchecked(&mut self,
    method alloc_excess_unchecked (line 772) | unsafe fn alloc_excess_unchecked(&mut self, layout: Layout) -> Option<...
    method realloc_excess_unchecked (line 778) | unsafe fn realloc_excess_unchecked(&mut self,
    method alloc_array_unchecked (line 793) | unsafe fn alloc_array_unchecked<T>(&mut self, n: usize) -> Option<Uniq...
    method realloc_array_unchecked (line 807) | unsafe fn realloc_array_unchecked<T>(&mut self,
    method dealloc_array_unchecked (line 826) | unsafe fn dealloc_array_unchecked<T>(&mut self, ptr: Unique<T>, n: usize)

FILE: sos_alloc/src/place.rs
  type IntermediateAlloc (line 25) | pub struct IntermediateAlloc<'alloc, A, T>
  type Place (line 37) | type Place = IntermediateAlloc<'alloc, A, Data>;
  function make_place (line 40) | fn make_place(self) -> Self::Place {
  function pointer (line 53) | fn pointer(&mut self) -> *mut Data {
  type Owner (line 69) | type Owner = Data;
  function finalize (line 74) | unsafe fn finalize(self) -> Self::Owner {

FILE: sos_alloc/src/system.rs
  type Tier (line 14) | pub enum Tier<'a> {
  type Target (line 23) | type Target = Allocator + 'static ;
  method deref (line 24) | fn deref(&self) -> &Self::Target{
  method alloc (line 36) | unsafe fn alloc(&mut self, layout: Layout) -> AllocResult<Address> {
  method dealloc (line 47) | unsafe fn dealloc(&mut self, ptr: Address, layout: Layout) {
  type SystemAllocator (line 59) | pub struct SystemAllocator(Mutex<Tier<'static>>);
    method borrow_ptr (line 68) | pub fn borrow_ptr<'alloc>(&'alloc self, layout: Layout)
    method borrow (line 78) | pub fn borrow<'alloc, T>(&'alloc self)

FILE: sos_intrusive/src/list/mod.rs
  type OwnedRef (line 25) | pub unsafe trait OwnedRef<T> {
    method from_raw (line 26) | unsafe fn from_raw(ptr: *mut T) -> Self;
    method take (line 27) | unsafe fn take(self);
    method get (line 28) | fn get(&self) -> &T;
    method get_mut (line 29) | fn get_mut(&mut self) -> &mut T;
  type Node (line 36) | pub trait Node: Sized {
    method next (line 37) | fn next(&self) -> &RawLink<Self>;
    method prev (line 38) | fn prev(&self) -> &RawLink<Self>;
    method next_mut (line 40) | fn next_mut(&mut self) -> &mut RawLink<Self>;
    method prev_mut (line 41) | fn prev_mut(&mut self) -> &mut RawLink<Self>;
  type List (line 49) | pub struct List<T, N>
  function new (line 73) | pub const fn new() -> Self {
  function len (line 81) | pub fn len(&self) -> usize {
  function front (line 90) | pub fn front(&self) -> Option<&N> {
  function back (line 100) | pub fn back(&self) -> Option<&N> {
  function front_mut (line 109) | pub fn front_mut(&mut self) -> Option<&mut N> {
  function back_mut (line 118) | pub fn back_mut(&mut self) -> Option<&mut N> {
  function is_empty (line 123) | pub fn is_empty(&self) -> bool {
  function push_front (line 129) | pub fn push_front(&mut self, mut item: T) {
  function push_back (line 161) | pub fn push_back(&mut self, mut item: T) {
  function pop_front (line 194) | pub fn pop_front(&mut self) -> Option<T> {
  function pop_back (line 221) | pub fn pop_back(&mut self) -> Option<T> {
  function peek_front (line 244) | pub fn peek_front(&self) -> Option<&N> {
  function cursor_mut (line 249) | pub fn cursor_mut<'a>(&'a mut self) -> ListCursorMut<'a, T, N> {
  function from_iter (line 259) | fn from_iter<I: IntoIterator<Item=T>>(iterator: I) -> Self {
  type Cursor (line 266) | pub trait Cursor {
    method next (line 269) | fn next(&mut self) -> Option<Self::Item>;
    method prev (line 270) | fn prev(&mut self) -> Option<Self::Item>;
    method get (line 271) | fn get(&self) -> Option<Self::Item>;
    method seek_forward (line 272) | fn seek_forward(&mut self, n: usize) -> Option<Self::Item>;
    method seek_backward (line 273) | fn seek_backward(&mut self, n: usize) -> Option<Self::Item>;
  type ListCursorMut (line 287) | pub struct ListCursorMut<'a, T, N>
  function next (line 310) | pub fn next(&mut self) -> Option<&mut N> {
  function prev (line 345) | pub fn prev(&mut self) -> Option<&mut N> {
  function peek_next (line 357) | pub fn peek_next(&self) -> Option<&N> {
  function peek_prev (line 373) | pub fn peek_prev(&self) -> Option<&N> {
  function remove (line 386) | pub fn remove(&mut self) -> Option<T> {
  function find_and_remove (line 416) | pub fn find_and_remove<P>(&mut self, predicate: P) -> Option<T>
  function seek_forward (line 432) | pub fn seek_forward(&mut self, n: usize) -> Option<&mut N> {
  function seek_backward (line 441) | pub fn seek_backward(&mut self, n: usize) -> Option<&mut N> {
  function get (line 485) | fn get(&self) -> &T {
  function get_mut (line 489) | fn get_mut(&mut self) -> &mut T {
  function take (line 494) | unsafe fn take(self) {}
  function from_raw (line 496) | unsafe fn from_raw(ptr: *mut T) -> Self {
  function get (line 506) | fn get(&self) -> &T { &**self }
  function get_mut (line 507) | fn get_mut(&mut self) -> &mut T { &mut **self }
  function take (line 509) | unsafe fn take(self) {
  function from_raw (line 513) | unsafe fn from_raw(ptr: *mut T) -> Self {

FILE: sos_intrusive/src/list/test.rs
  type NumberedNode (line 14) | pub struct NumberedNode {
    method new (line 21) | pub fn new(number: usize) -> Self {
  method prev (line 31) | fn prev(&self) -> &RawLink<Self> {
  method next (line 35) | fn next(&self) -> &RawLink<Self> {
  method prev_mut (line 39) | fn prev_mut(&mut self) -> &mut RawLink<Self> {
  method next_mut (line 43) | fn next_mut(&mut self) -> &mut RawLink<Self> {
  method eq (line 49) | fn eq(&self, rhs: &Self) -> bool { self.number == rhs.number }
  type TestList (line 58) | type TestList = List<Box<NumberedNode>, NumberedNode>;
  function not_empty_after_push (line 61) | fn not_empty_after_push() {
  function contents_after_first_push (line 75) | fn contents_after_first_push() {
  function head_tail_same_first_push (line 85) | fn head_tail_same_first_push() {
  function head_tail_not_same_second_push (line 96) | fn head_tail_not_same_second_push() {
  function contents_after_pushes (line 107) | fn contents_after_pushes() {
  function test_pop_front (line 128) | fn test_pop_front() {
  function test_pop_back (line 165) | fn test_pop_back() {

FILE: sos_intrusive/src/rawlink.rs
  type RawLink (line 23) | pub struct RawLink<T>(*mut T);
  method default (line 34) | fn default() -> Self { Self::none() }
  function fmt (line 39) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function none (line 56) | pub const fn none() -> RawLink<T> { RawLink(ptr::null_mut()) }
  function some (line 63) | pub fn some(thing: &mut T) -> RawLink<T> { RawLink(thing) }
  function from_raw (line 65) | pub const fn from_raw(ptr: *mut T) -> RawLink<T> { RawLink(ptr) }
  function resolve (line 77) | pub unsafe fn resolve<'a>(&self) -> Option<&'a T> {
  function resolve_mut (line 91) | pub unsafe fn resolve_mut<'a>(&self) -> Option<&'a mut T> {
  function as_raw (line 105) | pub unsafe fn as_raw(&self) -> *mut T { self.0 }
  function is_some (line 108) | pub fn is_some(&self) -> bool { !self.is_none() }
  function is_none (line 111) | pub fn is_none(&self) -> bool { self.0.is_null() }
  function take (line 115) | pub fn take(&mut self) -> Self { mem::replace(self, Self::none()) }
  function map (line 117) | pub unsafe fn map<U, F: FnOnce(T) -> U>(self, _f: F) -> RawLink<U> {

FILE: sos_intrusive/src/stack/mod.rs
  type Node (line 29) | pub trait Node: Sized {
    method next (line 30) | fn next(&self) -> &RawLink<Self>;
    method next_mut (line 31) | fn next_mut(&mut self) -> &mut RawLink<Self>;
  type Stack (line 39) | pub struct Stack<T, N>
  function new (line 52) | pub const fn new() -> Self {
  function len (line 59) | pub fn len(&self) -> usize {
  function peek (line 68) | pub fn peek(&self) -> Option<&N> {
  function peek_mut (line 78) | pub fn peek_mut(&mut self) -> Option<&mut N> {
  function is_empty (line 83) | pub fn is_empty(&self) -> bool {
  function push (line 88) | pub fn push(&mut self, mut item: T) {
  function pop (line 103) | pub fn pop(&mut self) -> Option<T> {
  function from_iter (line 121) | fn from_iter<I: IntoIterator<Item=T>>(iterator: I) -> Self {

FILE: sos_intrusive/src/stack/test.rs
  type NumberedNode (line 14) | pub struct NumberedNode {
    method new (line 20) | pub fn new(number: usize) -> Self {
  method next (line 30) | fn next(&self) -> &RawLink<Self> {
  method next_mut (line 34) | fn next_mut(&mut self) -> &mut RawLink<Self> {
  method eq (line 40) | fn eq(&self, rhs: &Self) -> bool { self.number == rhs.number }
  type TestStack (line 49) | type TestStack = Stack<Box<NumberedNode>, NumberedNode>;
  function not_empty_after_push (line 52) | fn not_empty_after_push() {
  function contents_after_first_push (line 65) | fn contents_after_first_push() {
  function contents_after_pushes (line 75) | fn contents_after_pushes() {
  function test_pop_front (line 88) | fn test_pop_front() {

FILE: src/arch/x86_64/drivers/serial.rs
  type Serial (line 33) | pub struct Serial(Option<SerialPort>);
    method write_str (line 37) | fn write_str(&mut self, s: &str) -> fmt::Result {
  type SerialPort (line 69) | pub struct SerialPort { data_port: Port<u8>
    method new (line 75) | fn new(port: u16) -> SerialPort {
    method has_byte (line 98) | pub fn has_byte(&self) -> bool {
    method is_empty (line 103) | pub fn is_empty(&self) -> bool {
    method read_byte (line 108) | pub fn read_byte(&self) -> u8 {
    method write_byte (line 114) | pub fn write_byte(&self, byte: u8) {
    type Error (line 121) | type Error = Void;
    method read (line 124) | fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
    method read_all (line 135) | fn read_all(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
    type Error (line 149) | type Error = Void;
    method write (line 151) | fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
    method write_str (line 165) | fn write_str(&mut self, s: &str) -> fmt::Result {

FILE: src/arch/x86_64/drivers/vga.rs
  function clear (line 26) | pub fn clear() {

FILE: src/arch/x86_64/interrupts.rs
  function initialize (line 28) | pub unsafe fn initialize() -> Result<(), ()>{
  function keyboard (line 182) | pub extern "x86-interrupt" fn keyboard(_frame: &InterruptFrame) {
  function breakpoint (line 200) | pub extern "x86-interrupt" fn breakpoint(frame: &InterruptFrame) {
  function empty_handler (line 210) | pub extern "x86-interrupt" fn empty_handler(_frame: &InterruptFrame) {

FILE: src/arch/x86_64/mod.rs
  constant ARCH_BITS (line 17) | pub const ARCH_BITS: u8 = 64;
  function long_mode_init (line 47) | pub unsafe extern "C" fn long_mode_init() {
  function arch_init (line 68) | pub extern "C" fn arch_init(multiboot_addr: PAddr) {

FILE: src/arch/x86_all/bda.rs
  type Word (line 15) | type Word = u16;
  constant PORTS_ADDR (line 19) | const PORTS_ADDR: usize = 0x0400;
  type Ports (line 33) | struct Ports {

FILE: src/arch/x86_all/multiboot2.rs
  constant END_TAG_LEN (line 21) | const END_TAG_LEN: u32 = 8;
  constant HEADER_LEN (line 23) | const HEADER_LEN: u32 = 24;
  constant MAGIC (line 25) | pub const MAGIC: u32 = 0xe85250d6;
  type HeaderArch (line 28) | pub enum HeaderArch {
  type Header (line 34) | pub struct Header {
  type Info (line 55) | pub struct Info { pub length: u32
    method start_addr (line 63) | pub fn start_addr(&self) -> PAddr {
    method end_addr (line 67) | pub fn end_addr(&self) -> PAddr {
    method from (line 73) | pub unsafe fn from(addr: PAddr) -> Result<&'static Self, &'static str> {
    method get_tag (line 97) | pub fn get_tag(&'static self, tag_type: TagType) -> Option<&'static Ta...
    method mem_map (line 108) | pub fn mem_map(&'static self) -> Option<&'static MemMapTag> {
    method elf_sections (line 119) | pub fn elf_sections(&'static self) -> Option<&'static ElfSectionsTag> {
    method tags (line 128) | fn tags(&'static self) -> Tags { Tags(&self.tag_start as *const Tag) }
    method has_end (line 131) | fn has_end(&self) -> bool {
    method kernel_frames (line 142) | pub fn kernel_frames(&'static self) -> Result<FrameRange, &'static str> {
  type IntoIter (line 160) | type IntoIter = Tags;
  type Item (line 161) | type Item = &'static Tag;
  method into_iter (line 162) | fn into_iter(self) -> Self::IntoIter { self.tags() }
  type Tag (line 201) | pub struct Tag { /// the type of this tag.
  type TagType (line 211) | pub enum TagType { /// Tag that indicates the end of multiboot tags
  type Tags (line 227) | pub struct Tags(*const Tag);
    method advance (line 230) | fn advance(&mut self, size: u32) {
  type Item (line 237) | type Item = &'static Tag;
  method next (line 240) | fn next(&mut self) -> Option<Self::Item> {
  type MemMapTag (line 253) | pub struct MemMapTag { tag: Tag
    method areas (line 262) | pub fn areas(&'static self) -> MemAreas {
  type Item (line 275) | type Item = &'static MemArea;
  type IntoIter (line 276) | type IntoIter = MemAreas;
  method into_iter (line 278) | fn into_iter(self) -> Self::IntoIter { self.areas() }
  type CommandLineTag (line 285) | pub struct CommandLineTag { tag: Tag
  type ModulesTag (line 295) | pub struct ModulesTag { tag: Tag
  type MemAreaType (line 306) | pub enum MemAreaType { Available = 1
  type MemArea (line 314) | pub struct MemArea { /// the starting address of the memory area
    method address (line 324) | pub fn address(&self) -> PAddr {
    method fmt (line 343) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function into (line 331) | fn into(self) -> mem::Area {
  type MemAreas (line 351) | pub struct MemAreas { curr: *const MemArea
  type Item (line 357) | type Item = &'static MemArea;
  method next (line 359) | fn next(&mut self) -> Option<&'static MemArea> {
  type Word (line 382) | pub type Word = u32;
  type Word (line 384) | pub type Word = u64;
  type ElfSectionsTag (line 389) | pub struct ElfSectionsTag { tag: Tag
    method sections (line 402) | pub fn sections(&'static self) -> Sections<'static, Word> {
  type Item (line 413) | type Item = <Self::IntoIter as Iterator>::Item;
  type IntoIter (line 414) | type IntoIter = Sections<'static, Word>;
  method into_iter (line 416) | fn into_iter(self) -> Self::IntoIter { self.sections() }

FILE: src/heap.rs
  function initialize (line 13) | pub unsafe fn initialize<'a>(params: &InitParams) -> Result<&'a str, &'a...

FILE: src/io/keyboard.rs
  type Scancode (line 17) | pub struct Scancode(u8);
    method to_ascii (line 20) | fn to_ascii(&self) -> Option<u8> {
  type Keyboard (line 33) | pub struct Keyboard { /// Port for reading data from the keyboard
    method read_scancode (line 42) | pub fn read_scancode(&self) -> Scancode {
  constant TO_ASCII_LOW (line 48) | const TO_ASCII_LOW: &'static [u8; 17]
  constant TO_ASCII_MID1 (line 51) | const TO_ASCII_MID1: &'static [u8; 14] = b"\tqwertyuiop[]\r";
  constant TO_ASCII_MID2 (line 54) | const TO_ASCII_MID2: &'static [u8; 11] = b"asdfghjkl;'";
  constant TO_ASCII_HIGH (line 57) | const TO_ASCII_HIGH: &'static [u8; 10] = b"zxcvbnm,./";
  method default (line 76) | fn default() -> Self { Modifiers::new() }
  method new (line 81) | pub const fn new() -> Self {
  method is_shifted (line 86) | pub fn is_shifted(&self) -> bool {
  method is_uppercase (line 91) | pub fn is_uppercase(&self) -> bool {
  method update (line 96) | fn update(&mut self, scancode: Scancode) {
  method modify (line 112) | fn modify(&self, ascii: u8) -> u8 {
  function read_char (line 129) | pub fn read_char() -> Option<char> {

FILE: src/logger.rs
  type SerialLogger (line 15) | struct SerialLogger;
    method enabled (line 34) | fn enabled(&self, _metadata: &LogMetadata) -> bool {
    method log (line 39) | fn log(&self, record: &LogRecord) {
    method enabled (line 72) | fn enabled(&self, metadata: &LogMetadata) -> bool {
    method log (line 77) | fn log(&self, record: &LogRecord) {
  function initialize (line 17) | pub fn initialize() -> Result<(), log::SetLoggerError> {
  function shutdown (line 25) | pub fn shutdown() -> Result<(), log::ShutdownLoggerError> {

FILE: src/main.rs
  constant VERSION_STRING (line 72) | pub const VERSION_STRING: &'static str
  function kernel_main (line 77) | pub fn kernel_main() -> ! {
  function kernel_init (line 114) | pub fn kernel_init(params: &InitParams) {
  function main (line 160) | fn main() {

FILE: util/src/io.rs
  type Read (line 24) | pub trait Read {
    method read (line 53) | fn read(&mut self, buf: &mut [u8])     -> Result<usize, Self::Error>;
    method read_all (line 62) | fn read_all(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;
  type Write (line 81) | pub trait Write {
    method write (line 108) | fn write(&mut self, buf: &[u8])       -> Result<usize, Self::Error>;

FILE: util/src/lib.rs
  type Void (line 26) | pub enum Void {}
    method fmt (line 28) | fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
  type Align (line 33) | pub trait Align: Sized + Copy //+ One
    method align_up (line 38) | fn align_up(&self, to: Self) -> Self {
    method align_down (line 42) | fn align_down(&self, to: Self) -> Self {

FILE: vga/src/lib.rs
  constant X_MAX (line 100) | pub const X_MAX: usize = 80;
  constant Y_MAX (line 101) | pub const Y_MAX: usize = 25;
  type Buffer (line 104) | pub type Buffer = [[Char; X_MAX]; Y_MAX];
  constant ANSI_ESCAPE (line 106) | const ANSI_ESCAPE: &'static str = "\x1b";
  constant FG_MASK (line 107) | const FG_MASK: u8 = 0b0000_1111;
  constant BG_MASK (line 108) | const BG_MASK: u8 = 0b1111_0000;
  type Color (line 113) | pub enum Color { Black = 0
  type Palette (line 132) | pub struct Palette(u8);
    method new (line 136) | pub const fn new(fg: Color, bg: Color) -> Self {
    method set_foreground (line 142) | pub fn set_foreground(&self, fg: Color) -> Self {
    method set_background (line 148) | pub fn set_background(&self, bg: Color) -> Self {
    method foreground (line 153) | pub fn foreground(&self) -> Color {
    method background (line 158) | pub fn background(&self) -> Color {
  type Char (line 166) | pub struct Char { pub ascii: u8
    method empty (line 172) | pub const fn empty() -> Self {
  type Terminal (line 177) | pub struct Terminal { buffer: ptr::Unique<Buffer>
    method x_position (line 185) | pub fn x_position(&self) -> usize {
    method new (line 199) | pub const unsafe fn new( colors: Palette
    method buffer (line 211) | fn buffer(&mut self) -> &mut  Buffer {
    method set_colors (line 216) | pub fn set_colors(&mut self, bg: Color, fg: Color) -> &mut Self {
    method scroll (line 222) | fn scroll(&mut self) {
    method clear (line 257) | pub fn clear(&mut self) -> &mut Self {
    method write_byte (line 278) | pub fn write_byte(&mut self, byte: u8) -> &mut Self {
    method handle_ansi_escape (line 313) | fn handle_ansi_escape(&self, escape_code: &str) -> Result {
  type AnsiEscapeIter (line 373) | struct AnsiEscapeIter<'a> { curr_slice: &'a str
  function new (line 379) | pub fn new(s: &'a str) -> Self {
  type Item (line 387) | type Item = &'a str;
  method next (line 389) | fn next(&mut self) -> Option<Self::Item> {
  method write_str (line 425) | fn write_str(&mut self, s: &str) -> Result {

FILE: vga/src/panic.rs
  function rust_begin_unwind (line 26) | pub extern "C" fn rust_begin_unwind( args: Arguments

FILE: vga/src/status.rs
  type Status (line 4) | pub trait Status {
    method okay (line 5) | fn okay(&mut self) -> Result ;
    method fail (line 6) | fn fail(&mut self) -> Result ;
    method okay (line 10) | fn okay(&mut self) -> Result {
    method fail (line 19) | fn fail(&mut self) -> Result {