pzol

#[feature(macro_rules)];

use std::hashmap::HashMap;

macro_rules! lazy_init(
    ($(static ref $n:ident : $t:ty = $e:expr;)*) => (
        $(
            struct $n;
            impl $n {
                #[allow(dead_code)]

pzol

#[allow(ctypes, dead_code)];
#[feature(globs)];

use std::vec;

pub type UBool     = u8;
pub type UProperty = int;
pub type UChar     = u16;
pub type UChar32   = i32;

pzol

fn pos(pos: int, len: uint) -> uint {
  let ilen = len as int;
  let result = match pos {
        p if p < 0 && ilen + p < 0 => 0,
        p if p < 0                => ilen + p,
        p                         => p
  } as uint;
  result
}

pzol

#[allow(ctypes, dead_code)];
#[feature(globs)];

use std::str;
use std::libc::{ c_char };


pub type UChar     = u16;
pub type UChar32   = i32;

pzol

/* soon to be auto-generated */

use std::cmp::{Equal, Less, Greater};
use std::vec::ImmutableVector;
use std::option::None;

static LETTER_UPPERCASE : &'static [(char, char)] = &[
  ('\x41', '\x5a')
];

pzol

struct LowerChars<'a> {
  chars: std::str::Chars<'a>
}

fn lower<'a>(s: &'a str) -> LowerChars<'a> {
  LowerChars { chars: s.chars() }
}

impl<'a> Iterator<char> for LowerChars<'a> {
  fn next(&mut self) -> Option<char> {

pzol

struct UpperChars<'a> {
  chars: std::str::Chars<'a>
}

struct LowerChars<'a> {
  chars: std::str::Chars<'a>
}

fn lower_chars<'a>(s: &'a str) -> LowerChars<'a> {
  LowerChars { chars: s.chars() }

pzol

mod unicode {
  struct Cluster<'a> {
    chars: &'a [char]
  }

  pub fn unpack<'a>(s: &str) ->  &'a [Cluster<'a>] {
    let mut clusters = ~[];
    // let cluster = Cluster { chars: &'static [] };
    // clusters.push(cluster);
    clusters.as_slice()

pzol

#[feature(macro_rules)];

struct Grapheme<'r> {
  codepoint: &'r [CodePoint]
}

struct Graphemes<'r> {
  chars: std::str::Chars<'r>
}

pzol

trait Locale {
  fn to_upper(s: &str) {}
}

struct Indifferent;
impl Locale for Indifferent {}

#[test]
fn test_indifferent(){
  let l: &Locale = &Indifferent;