MarkJr94

import Network.HTTP.Conduit
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as L
import qualified Data.ByteString.UTF8 as BU
import qualified Data.ByteString.Lazy.UTF8 as LU
import qualified Data.Text as T
import Data.Conduit
import qualified Data.Conduit.List as CL
import qualified Data.Conduit.Binary as CB
import System.IO

MarkJr94

#[feature(globs)]

fn private() {
    println("I am private");
}

mod test {
    use super::*;

    #[test]

MarkJr94

fn main()
    // get list of paths

    assert!(paths.len() > 0);

    let mut in_common = 0;

    while paths.iter().all(|path|{
        path.components().nth(in_common).map_default(false |comp| {
            paths[0].components().nth(in_common).map_default(false, |ref_comp| {

MarkJr94

Root crate span = 0:10192
Root crate Location: ../rustfind/rustfind.rs
Mod Location: ../rustfind/rustfind.rs
Mod span = 837:855
Mod name: rf_common
Mod Location: ../rustfind/rustfind.rs
Mod span = 856:878
Mod name: find_ast_node
Mod Location: ../rustfind/rustfind.rs
Mod span = 879:903

MarkJr94

macro_rules! kill(
    ($thing:expr) => (
        ::macros::destroy($thing);
    )
)

#[inline]
pub fn destroy<T>(_: T) {

}

MarkJr94

macro_rules! expect(
    ($expr:expr, $value:expr) => ( $expr )
)

macro_rules! likely(
    ($expr:expr) => ( expect!($expr != false, true))
)

macro_rules! unlikely(
    ($expr:expr) => ( expect!($expr != false, false))

MarkJr94

#[feature(macro_rules)];

#[allow(missing_doc)]
#[packed]
pub struct SIZE_T {
    v: uint
}
 
macro_rules! AARCH(
    ($expr:expr) => (

MarkJr94

use std::cast::transmute;
use std::libc::{c_longlong};

macro_rules! A32(
    ($expr:expr) => (
        let thing: *u32 = transmute($expr);
        *thing
    )
)

MarkJr94

extern mod extra;
extern mod http;

use extra::url::Url;
use http::client::RequestWriter;
use http::method::{Get, Post};

type Session = ();

pub fn get_resp(url: Url, post_data: Option<~[u8]>, s: Option<&Session>) -> Result<~[u8], ~str> {

MarkJr94

pub fn get_secrets() -> (~str, ~str) {
    use std::rt::io::{file, Open, Read, Stream};
    use std::path::Path;
    use std::rt::io::file::FileInfo;
    use std::str::from_utf8;

    let mut reader : file::FileReader = Path::new("secrets.txt").open_reader(Open)
        .expect("Secret file couldn't be opened");

    let s: ~str = from_utf8(reader.read_to_end());