diff --git a/doc/rust.texi b/doc/rust.texi
index 09524a8055de1..540b209c0745c 100644
--- a/doc/rust.texi
+++ b/doc/rust.texi
@@ -2954,9 +2954,8 @@ analogous to a @code{become} expression in Newsqueak or Alef.} destroys the
current function activation frame and replaces it with an activation frame for
the called function. In other words, @code{be} executes a tail-call. The
syntactic form of a @code{be} expression is therefore limited to @emph{tail
-position}: its argument must be a @emph{call expression}, and it must be the
-last expression in a block.
-
+position}: its argument must be a @emph{call expression} or a @{trivial cast}
+of a @emph{call expression}, and it must be the last expression in a block.
An example of a @code{be} expression:
@example
fn print_loop(n: int) @{
@@ -2971,6 +2970,7 @@ fn print_loop(n: int) @{
The above example executes in constant space, replacing each frame with a new
copy of itself.
+
@end ignore
@@ -3001,6 +3001,7 @@ execution and destroying the iterator frame.
@cindex As expression
@cindex Cast
@cindex Typecast
+@cindex Trivial cast
Executing an @code{as} expression casts the value on the left-hand side to the
type on the right-hand side.
@@ -3018,6 +3019,10 @@ fn avg(v: [float]) -> float @{
@}
@end example
+A cast is a @emph{trivial cast} iff the type of the casted expression and the
+target type are identical after replacing all occurences of @code{int},
+@code{uint}, @code{float} with their machine type equivalents of the
+target architecture in both types.
@node Ref.Expr.Fail
@subsection Ref.Expr.Fail
diff --git a/src/comp/middle/check_const.rs b/src/comp/middle/check_const.rs
index d9e96b0cb7366..a7b3c388d59e9 100644
--- a/src/comp/middle/check_const.rs
+++ b/src/comp/middle/check_const.rs
@@ -25,6 +25,7 @@ fn check_item(tcx: ty::ctxt, it: @item, &&s: (), v: visit::vt<()>) {
fn check_const_expr(tcx: ty::ctxt, ex: @expr, &&s: (), v: visit::vt<()>) {
visit::visit_expr(ex, s, v);
alt ex.node {
+ expr_cast(_, _) { }
expr_lit(_) { }
expr_binary(_, _, _) { /* subexps covered by visit */ }
expr_unary(u, _) {
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index 237b00899536f..6a70d9e109deb 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -4086,7 +4086,12 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
if !ty::expr_is_lval(tcx, a) { ret trans_expr(bcx, a, dest); }
else { ret lval_to_dps(bcx, a, dest); }
}
- ast::expr_cast(val, _) { ret trans_cast(bcx, val, e.id, dest); }
+ ast::expr_cast(val, _) {
+ alt tcx.cast_map.find(e.id) {
+ some(ty::triv_cast.) { ret trans_expr(bcx, val, dest); }
+ _ { ret trans_cast(bcx, val, e.id, dest); }
+ }
+ }
ast::expr_anon_obj(anon_obj) {
ret trans_anon_obj(bcx, e.span, anon_obj, e.id, dest);
}
@@ -4115,7 +4120,7 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
// that is_call_expr(ex) -- but we don't support that
// yet
// FIXME
- check (ast_util::is_call_expr(ex));
+ check (ast_util::is_tail_call_expr(ex));
ret trans_be(bcx, ex);
}
ast::expr_fail(expr) {
@@ -4448,7 +4453,8 @@ fn trans_ret(bcx: @block_ctxt, e: option::t<@ast::expr>) -> @block_ctxt {
fn build_return(bcx: @block_ctxt) { Br(bcx, bcx_fcx(bcx).llreturn); }
// fn trans_be(cx: &@block_ctxt, e: &@ast::expr) -> result {
-fn trans_be(cx: @block_ctxt, e: @ast::expr) : ast_util::is_call_expr(e) ->
+fn trans_be(cx: @block_ctxt, e: @ast::expr) :
+ast_util::is_tail_call_expr(e) ->
@block_ctxt {
// FIXME: Turn this into a real tail call once
// calling convention issues are settled
@@ -5178,6 +5184,16 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
// that does so later on?
fn trans_const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
alt e.node {
+ ast::expr_cast(e1, _) {
+ alt ccx_tcx(cx).cast_map.find(e.id) {
+ some(ty::triv_cast.) { trans_const_expr(cx, e1) }
+ _ {
+ cx.sess.span_err(e.span,
+ "non-trivial cast in constant expression");
+ fail;
+ }
+ }
+ }
ast::expr_lit(lit) { ret trans_crate_lit(cx, *lit); }
ast::expr_binary(b, e1, e2) {
let te1 = trans_const_expr(cx, e1);
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 5a290f7efc6d8..100154ae6856d 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -32,6 +32,7 @@ export ast_constr_to_constr;
export bind_params_in_type;
export block_ty;
export constr;
+export cast_type;
export constr_general;
export constr_table;
export count_ty_params;
@@ -102,6 +103,8 @@ export substitute_type_params;
export t;
export tag_variants;
export tag_variant_with_id;
+export triv_cast;
+export triv_eq_ty;
export ty_param_substs_opt_and_ty;
export ty_param_kinds_and_ty;
export ty_native_fn;
@@ -128,6 +131,7 @@ export ty_param;
export ty_ptr;
export ty_rec;
export ty_tag;
+export ty_to_machine_ty;
export ty_tup;
export ty_type;
export ty_uint;
@@ -198,6 +202,12 @@ type mt = {ty: t, mut: ast::mutability};
// the types of AST nodes.
type creader_cache = hashmap<{cnum: int, pos: uint, len: uint}, ty::t>;
+tag cast_type {
+ /* cast may be ignored after substituting primitive with machine types
+ since expr already has the right type */
+ triv_cast;
+}
+
type ctxt =
// constr_table fn_constrs,
// We need the ext_map just for printing the types of tags defined in
@@ -206,6 +216,7 @@ type ctxt =
sess: session::session,
def_map: resolve::def_map,
ext_map: resolve::ext_map,
+ cast_map: hashmap<ast::node_id, cast_type>,
node_types: node_type_table,
items: ast_map::map,
freevars: freevars::freevar_map,
@@ -393,6 +404,7 @@ fn mk_ctxt(s: session::session, dm: resolve::def_map,
sess: s,
def_map: dm,
ext_map: em,
+ cast_map: ast_util::new_node_hash(),
node_types: ntt,
items: amap,
freevars: freevars,
@@ -1481,6 +1493,38 @@ fn eq_raw_ty(&&a: @raw_t, &&b: @raw_t) -> bool {
fn eq_ty(&&a: t, &&b: t) -> bool { ret a == b; }
+// Convert type to machine type
+// (i.e. replace uint, int, float with target architecture machine types)
+//
+// FIXME somewhat expensive but this should only be called rarely
+fn ty_to_machine_ty(cx: ctxt, ty: t) -> t {
+ fn sub_fn(cx: ctxt, uint_ty: t, int_ty: t, float_ty: t, in: t) -> t {
+ alt struct(cx, in) {
+ ty_uint. { ret uint_ty; }
+ ty_int. { ret int_ty; }
+ ty_float. { ret float_ty; }
+ _ { ret in; }
+ }
+ }
+
+ let cfg = cx.sess.get_targ_cfg();
+ let uint_ty = mk_mach(cx, cfg.uint_type);
+ let int_ty = mk_mach(cx, cfg.int_type);
+ let float_ty = mk_mach(cx, cfg.float_type);
+ let fold_m = fm_general(bind sub_fn(cx, uint_ty, int_ty, float_ty, _));
+
+ ret fold_ty(cx, fold_m, ty);
+}
+
+// Two types are trivially equal if they are either
+// equal or if they are equal after substituting all occurences of
+// machine independent primitive types by their machine type equivalents
+// for the current target architecture
+fn triv_eq_ty(cx: ctxt, &&a: t, &&b: t) -> bool {
+ ret eq_ty(a, b)
+ || eq_ty(ty_to_machine_ty(cx, a), ty_to_machine_ty(cx, b));
+}
+
// Type lookups
fn node_id_to_ty_param_substs_opt_and_ty(cx: ctxt, id: ast::node_id) ->
ty_param_substs_opt_and_ty {
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index fc0a4de5245da..c76f1318a75ce 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -1848,8 +1848,21 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
}
ast::expr_be(e) {
// FIXME: prove instead of assert
- assert (ast_util::is_call_expr(e));
+ assert (ast_util::is_tail_call_expr(e));
check_expr_with(fcx, e, fcx.ret_ty);
+
+ alt e.node {
+ ast::expr_cast(_, _) {
+ alt tcx.cast_map.find(e.id) {
+ option::some(ty::triv_cast.) { }
+ _ { tcx.sess.span_err(expr.span,
+ "non-trivial cast of tail-call return value");
+ }
+ }
+ }
+ _ { /* regular tail call */ }
+ }
+
bot = true;
write::nil_ty(tcx, id);
}
@@ -2103,15 +2116,21 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
ast::expr_cast(e, t) {
bot = check_expr(fcx, e);
let t_1 = ast_ty_to_ty_crate(fcx.ccx, t);
- // FIXME: there are more forms of cast to support, eventually.
+ let t_e = expr_ty(tcx, e);
- if !(type_is_scalar(fcx, expr.span, expr_ty(tcx, e)) &&
- type_is_scalar(fcx, expr.span, t_1)) {
+ // FIXME there are more forms of cast to support, eventually.
+ if !( type_is_scalar(fcx, expr.span, t_e)
+ && type_is_scalar(fcx, expr.span, t_1)) {
tcx.sess.span_err(expr.span,
"non-scalar cast: " +
ty_to_str(tcx, expr_ty(tcx, e)) + " as " +
ty_to_str(tcx, t_1));
}
+
+ // mark as triv_cast for later dropping in trans
+ if ty::triv_eq_ty(tcx, t_1, t_e)
+ { tcx.cast_map.insert(expr.id, ty::triv_cast); }
+
write::ty_only_fixup(fcx, id, t_1);
}
ast::expr_vec(args, mut) {
diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs
index da7b5a449534e..e190a77b50510 100644
--- a/src/comp/syntax/ast_util.rs
+++ b/src/comp/syntax/ast_util.rs
@@ -1,4 +1,4 @@
-import std::{str, option};
+import std::{str, option, int, map};
import codemap::span;
import ast::*;
@@ -6,6 +6,13 @@ fn respan<copy T>(sp: span, t: T) -> spanned<T> {
ret {node: t, span: sp};
}
+fn new_node_hash<copy V>() -> map::hashmap<node_id, V> {
+ fn node_id_hash(&&i: node_id) -> uint { ret int::hash(i as int); }
+ fn node_id_eq(&&a: node_id, &&b: node_id) -> bool
+ { ret int::eq(a as int, b as int); }
+ ret map::mk_hashmap(node_id_hash, node_id_eq);
+}
+
/* assuming that we're not in macro expansion */
fn mk_sp(lo: uint, hi: uint) -> span {
ret {lo: lo, hi: hi, expanded_from: codemap::os_none};
@@ -168,6 +175,14 @@ pure fn is_call_expr(e: @expr) -> bool {
alt e.node { expr_call(_, _, _) { true } _ { false } }
}
+pure fn is_tail_call_expr(e: @expr) -> bool {
+ alt e.node {
+ expr_call(_, _, _) { true }
+ expr_cast(inner_e, _) { is_call_expr(inner_e) }
+ _ { false }
+ }
+}
+
fn is_constraint_arg(e: @expr) -> bool {
alt e.node {
expr_lit(_) { ret true; }
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 6d751dff64550..95aa3ffc434c0 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -962,7 +962,7 @@ fn parse_bottom_expr(p: parser) -> @ast::expr {
let e = parse_expr(p);
// FIXME: Is this the right place for this check?
- if /*check*/ast_util::is_call_expr(e) {
+ if /*check*/ ast_util::is_tail_call_expr(e) {
hi = e.span.hi;
ex = ast::expr_be(e);
} else { p.fatal("Non-call expression in tail call"); }
diff --git a/src/lib/ctypes.rs b/src/lib/ctypes.rs
index 48c4a85fcbcdb..82e414a864ce5 100644
--- a/src/lib/ctypes.rs
+++ b/src/lib/ctypes.rs
@@ -5,6 +5,7 @@ Definitions useful for C interop
*/
type c_int = i32;
+type c_uint = u32;
type void = int; // Not really the same as C
type long = int;
@@ -15,8 +16,20 @@ type intptr_t = uint;
type uintptr_t = uint;
type uint32_t = u32;
-// This *must* match with "import c_float = fXX" in std::math per arch
-type c_float = f64;
+// machine type equivalents of rust int, uint, float
+
+#[cfg(target_arch="x86")]
+type m_int = i32;
+#[cfg(target_arch="x86_64")]
+type m_int = i64;
+
+#[cfg(target_arch="x86")]
+type m_uint = u32;
+#[cfg(target_arch="x86_64")]
+type m_uint = u64;
+
+// This *must* match with "import m_float = fXX" in std::math per arch
+type m_float = f64;
type size_t = uint;
type ssize_t = int;
diff --git a/src/lib/math.rs b/src/lib/math.rs
index 7b4308668b48a..72056548ca578 100644
--- a/src/lib/math.rs
+++ b/src/lib/math.rs
@@ -18,11 +18,11 @@ export
// These two must match in width according to architecture
-import ctypes::c_float;
+import ctypes::m_float;
import ctypes::c_int;
-import c_float = math_f64;
+import m_float = math_f64;
-// FIXME replace with redirect to c_float::consts::FOO as soon as it works
+// FIXME replace with redirect to m_float::consts::FOO as soon as it works
mod consts {
/*
Const: pi
@@ -140,7 +140,7 @@ Function: acos
Returns the arccosine of an angle (measured in rad)
*/
pure fn acos(x: float) -> float
- { c_float::acos(x as c_float) as float }
+ { m_float::acos(x as m_float) as float }
/*
Function: asin
@@ -148,7 +148,7 @@ Function: asin
Returns the arcsine of an angle (measured in rad)
*/
pure fn asin(x: float) -> float
- { c_float::asin(x as c_float) as float }
+ { m_float::asin(x as m_float) as float }
/*
Function: atan
@@ -156,7 +156,7 @@ Function: atan
Returns the arctangents of an angle (measured in rad)
*/
pure fn atan(x: float) -> float
- { c_float::atan(x as c_float) as float }
+ { m_float::atan(x as m_float) as float }
/*
@@ -165,7 +165,7 @@ Function: atan2
Returns the arctangent of an angle (measured in rad)
*/
pure fn atan2(y: float, x: float) -> float
- { c_float::atan2(y as c_float, x as c_float) as float }
+ { m_float::atan2(y as m_float, x as m_float) as float }
/*
Function: ceil
@@ -173,7 +173,7 @@ Function: ceil
Returns the smallest integral value less than or equal to `n`
*/
pure fn ceil(n: float) -> float
- { c_float::ceil(n as c_float) as float }
+ { m_float::ceil(n as m_float) as float }
/*
Function: cos
@@ -181,7 +181,7 @@ Function: cos
Returns the cosine of an angle `x` (measured in rad)
*/
pure fn cos(x: float) -> float
- { c_float::cos(x as c_float) as float }
+ { m_float::cos(x as m_float) as float }
/*
Function: cosh
@@ -190,7 +190,7 @@ Returns the hyperbolic cosine of `x`
*/
pure fn cosh(x: float) -> float
- { c_float::cosh(x as c_float) as float }
+ { m_float::cosh(x as m_float) as float }
/*
@@ -199,7 +199,7 @@ Function: exp
Returns `consts::e` to the power of `n*
*/
pure fn exp(n: float) -> float
- { c_float::exp(n as c_float) as float }
+ { m_float::exp(n as m_float) as float }
/*
Function: abs
@@ -207,7 +207,7 @@ Function: abs
Returns the absolute value of `n`
*/
pure fn abs(n: float) -> float
- { c_float::abs(n as c_float) as float }
+ { m_float::abs(n as m_float) as float }
/*
Function: floor
@@ -215,7 +215,7 @@ Function: floor
Returns the largest integral value less than or equal to `n`
*/
pure fn floor(n: float) -> float
- { c_float::floor(n as c_float) as float }
+ { m_float::floor(n as m_float) as float }
/*
Function: fmod
@@ -223,7 +223,7 @@ Function: fmod
Returns the floating-point remainder of `x/y`
*/
pure fn fmod(x: float, y: float) -> float
- { c_float::fmod(x as c_float, y as c_float) as float }
+ { m_float::fmod(x as m_float, y as m_float) as float }
/*
Function: ln
@@ -231,7 +231,7 @@ Function: ln
Returns the natural logaritm of `n`
*/
pure fn ln(n: float) -> float
- { c_float::ln(n as c_float) as float }
+ { m_float::ln(n as m_float) as float }
/*
Function: ldexp
@@ -239,7 +239,7 @@ Function: ldexp
Returns `x` multiplied by 2 to the power of `n`
*/
pure fn ldexp(n: float, i: int) -> float
- { c_float::ldexp(n as c_float, i as c_int) as float }
+ { m_float::ldexp(n as m_float, i as c_int) as float }
/*
Function: ln1p
@@ -248,7 +248,7 @@ Returns the natural logarithm of `1+n` accurately,
even for very small values of `n`
*/
pure fn ln1p(n: float) -> float
- { c_float::ln1p(n as c_float) as float }
+ { m_float::ln1p(n as m_float) as float }
/*
Function: log10
@@ -256,7 +256,7 @@ Function: log10
Returns the logarithm to base 10 of `n`
*/
pure fn log10(n: float) -> float
- { c_float::log10(n as c_float) as float }
+ { m_float::log10(n as m_float) as float }
/*
Function: log2
@@ -264,7 +264,7 @@ Function: log2
Returns the logarithm to base 2 of `n`
*/
pure fn log2(n: float) -> float
- { c_float::log2(n as c_float) as float }
+ { m_float::log2(n as m_float) as float }
/*
@@ -281,8 +281,8 @@ The fractional part of `n`
*/
pure fn modf(n: float, &iptr: float) -> float {
unchecked {
- let f = iptr as c_float;
- let r = c_float::modf(n as c_float, f) as float;
+ let f = iptr as m_float;
+ let r = m_float::modf(n as m_float, f) as float;
iptr = f as float;
ret r;
}
@@ -303,13 +303,13 @@ Returns:
The fractional part of `n`
*/
pure fn frexp(n: float, &exp: c_int) -> float
- { c_float::frexp(n as c_float, exp) as float }
+ { m_float::frexp(n as m_float, exp) as float }
/*
Function: pow
*/
pure fn pow(v: float, e: float) -> float
- { c_float::pow(v as c_float, e as c_float) as float }
+ { m_float::pow(v as m_float, e as m_float) as float }
/*
@@ -319,7 +319,7 @@ Returns the integral value nearest to `x` (according to the
prevailing rounding mode) in floating-point format
*/
pure fn rint(x: float) -> float
- { c_float::rint(x as c_float) as float }
+ { m_float::rint(x as m_float) as float }
/*
Function: round
@@ -329,7 +329,7 @@ Return the integral value nearest to `x` rounding half-way
cases away from zero, regardless of the current rounding direction.
*/
pure fn round(x: float) -> float
- { c_float::round(x as c_float) as float }
+ { m_float::round(x as m_float) as float }
/*
Function: sin
@@ -337,7 +337,7 @@ Function: sin
Returns the sine of an angle `x` (measured in rad)
*/
pure fn sin(x: float) -> float
- { c_float::sin(x as c_float) as float }
+ { m_float::sin(x as m_float) as float }
/*
Function: sinh
@@ -345,7 +345,7 @@ Function: sinh
Returns the hyperbolic sine of an angle `x` (measured in rad)
*/
pure fn sinh(x: float) -> float
- { c_float::sinh(x as c_float) as float }
+ { m_float::sinh(x as m_float) as float }
/*
Function: sqrt
@@ -353,7 +353,7 @@ Function: sqrt
Returns the square root of `x`
*/
pure fn sqrt(x: float) -> float
- { c_float::sqrt(x as c_float) as float }
+ { m_float::sqrt(x as m_float) as float }
/*
Function: tan
@@ -362,7 +362,7 @@ Returns the tangent of an angle `x` (measured in rad)
*/
pure fn tan(x: float) -> float
- { c_float::tan(x as c_float) as float }
+ { m_float::tan(x as m_float) as float }
/*
Function: tanh
@@ -371,7 +371,7 @@ Returns the hyperbolic tangent of an angle `x` (measured in rad)
*/
pure fn tanh(x: float) -> float
- { c_float::tanh(x as c_float) as float }
+ { m_float::tanh(x as m_float) as float }
/*
Function: trunc
@@ -380,7 +380,7 @@ Returns the integral value nearest to but no larger in magnitude than `x`
*/
pure fn trunc(x: float) -> float
- { c_float::trunc(x as c_float) as float }
+ { m_float::trunc(x as m_float) as float }
diff --git a/src/test/compile-fail/non-triv-cast-be.rs b/src/test/compile-fail/non-triv-cast-be.rs
new file mode 100644
index 0000000000000..14f2c0bfdcd69
--- /dev/null
+++ b/src/test/compile-fail/non-triv-cast-be.rs
@@ -0,0 +1,19 @@
+// error-pattern: non-trivial cast of tail-call return value
+use std;
+
+import std::ctypes::*;
+
+fn foo_float() -> m_float { ret 0.0 as m_float; }
+fn bar_float() -> bool { be foo_float() as bool; }
+
+fn foo_int() -> m_int { ret 0 as m_int; }
+fn bar_int() -> bool { be foo_int() as bool; }
+
+fn foo_uint() -> m_uint { ret 0u as m_uint; }
+fn bar_uint() -> bool { be foo_uint() as bool; }
+
+fn main() {
+ assert bar_float() == 0.0;
+ assert bar_int() == 0.0;
+ assert bar_uint() == 0.0;
+}
\ No newline at end of file
diff --git a/src/test/run-pass/triv-cast-be.rs b/src/test/run-pass/triv-cast-be.rs
new file mode 100644
index 0000000000000..de78341a199c5
--- /dev/null
+++ b/src/test/run-pass/triv-cast-be.rs
@@ -0,0 +1,26 @@
+use std;
+
+import std::ctypes::*;
+
+fn foo_float() -> m_float { ret 0.0 as m_float; }
+fn bar_float() -> float { be foo_float() as float; }
+
+fn foo_int() -> m_int { ret 0 as m_int; }
+fn bar_int() -> int { be foo_int() as int; }
+
+fn foo_uint() -> m_uint { ret 0u as m_uint; }
+fn bar_uint() -> uint { be foo_uint() as uint; }
+
+fn foo_long() -> long { ret 0 as long; }
+fn bar_long() -> int { be foo_long() as int; }
+
+fn foo_ulong() -> ulong { ret 0u as ulong; }
+fn bar_ulong() -> uint { be foo_uint() as uint; }
+
+fn main() {
+ assert bar_float() == 0.0;
+ assert bar_int() == 0;
+ assert bar_uint() == 0u;
+ assert bar_long() == 0;
+ assert bar_ulong() == 0u;
+}
\ No newline at end of file
diff --git a/src/test/run-pass/triv-cast-const.rs b/src/test/run-pass/triv-cast-const.rs
new file mode 100644
index 0000000000000..59d7d618d2313
--- /dev/null
+++ b/src/test/run-pass/triv-cast-const.rs
@@ -0,0 +1,15 @@
+use std;
+
+import std::ctypes::*;
+
+// This will be more interesting once there is support
+// for consts that refer to other consts, i.e. math_f64::consts::pi as m_float
+#[cfg(target_arch="x86")]
+const foo: m_int = 0i32 as m_int;
+
+#[cfg(target_arch="x86_64")]
+const foo: m_int = 0i64 as m_int;
+
+fn main() {
+ assert foo == 0 as m_int;
+}
\ No newline at end of file