shadowmint

import ctypes
import unittest
import time
import os.path
from sdl2 import *
from sdl2.sdlmixer import *


class MixerTests(unittest.TestCase):

shadowmint

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship, backref
from kivy.graphics import Rectangle
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.widget import Widget

shadowmint

import re
import sys
import os
import time
import logging
import subprocess
import time
from os.path import expanduser, join, abspath, dirname

shadowmint

            /* Load page navigation */
            public loadNav():void {
                var nav = new bs.widgets.Nav(this._$nav.find(PageLayout.NAV_ACCORDION));
                nav.register('bedroom-layout', () => {
                    console.log(this);
                    this._loadPage('room_selector_nav.html', 'room_selector_page.html').then(() => {
                        bs.app.room.loadRoom();
                    });
                });
                nav.register('bedroom-doors', () => {

shadowmint

#[macro_escape];

#[macro_export]
macro_rules! trace(
  ($($arg:tt)*) => (
    ::std::io::stdout().write_line(format_args!(::std::fmt::format, $($arg)*))
  );
)

#[test]

shadowmint

use game_state::GameState;

mod game_state;

pub struct GameWindow {
  window: ~int,
  state: ~GameState,
}

impl GameWindow {

shadowmint

extern crate uuid;

use uuid::Uuid;
use std::fmt;

struct BlahLF {
  id: Uuid
}

struct StateLF;

shadowmint

macro_rules! trace(
  ($($arg:tt)*) => (
    { let x = ::std::io::stdout().write_line(format_args!(::std::fmt::format, $($arg)*)); println!("{}", x); }
  );
)

macro_rules! nstrcmp(
  ($x:ident, $y:ident, $n:expr) => (
    $x.len() >= $n && $y.len() >= $n && $x.slice(0, $n) == $y.slice(0, $n)
  );

shadowmint

use std::cast;

#[deriving(Show)]
struct Node<T> {
  next:Option<~Node<T>>,
  data:Option<T>
}

enum NodeErr {
  Nope

shadowmint

#[feature(macro_rules)];
#[crate_id = "junk#0.1"];

#[no_mangle]
pub fn dothing(a: int, b:int) -> int {
  return a + b;
}


#[macro_escape]