use std::local_data;
use std::rand;
use std::rand::RngUtil;
+use std::ptr::to_unsafe_ptr;
#[deriving(Clone, Encodable, Decodable, Eq, IterBytes)]
pub enum binop {
}
// create a fresh name that maps to the same string as the old one.
+// note that this guarantees that ptr_eq(ident_to_str(src),interner_get(fresh_name(src)));
+// that is, that the new name and the old one are connected to ptr_eq strings.
pub fn fresh_name(src : &ast::Ident) -> Name {
gensym(ident_to_str(src))
// following: debug version. Could work in final except that it's incompatible with
// good error messages and uses of struct names in ambiguous could-be-binding
- // locations.
+ // locations. Also definitely destroys the guarantee given above about ptr_eq.
/*let num = rand::rng().gen_uint_range(0,0xffff);
gensym(fmt!("%s_%u",ident_to_str(src),num))*/
}
+// it looks like there oughta be a str_ptr_eq fn, but no one bothered to implement it?
+pub fn str_ptr_eq<T>(a: @str, b: @str) -> bool {
+ // doesn't compile! ...because of rebase mangling. this should be fixed
+ // in the commit that follows this.
+ let (a_ptr, b_ptr): (*uint, *uint) = (to_unsafe_ptr(a), to_unsafe_ptr(b));
+ a_ptr == b_ptr
+}
+
+
+
+// return true when two identifiers refer (through the intern table) to the same ptr_eq
+// string. This is used to compare identifiers in places where hygienic comparison is
+// not wanted (i.e. not lexical vars).
+
// create a fresh mark.
pub fn fresh_mark() -> Mrk {
gensym("mark")
#[cfg(test)]
mod test {
use super::*;
+ use std::io;
+ use std::managed;
+ use ast;
+ use ast_util;
+
+
+ #[test] fn t1() {
+ let ghi = str_to_ident("ghi");
+ assert_eq!(ident_to_str(&ghi),@"ghi");
+ let fresh = ast::Ident::new(fresh_name(&ghi));
+ assert_eq!(ident_to_str(&fresh),@"ghi");
+ assert!(str_ptr_eq(ident_to_str(&ghi),ident_to_str(&fresh)));
+ assert_eq!(3,4);
+ }
}