fn visit_f32(&mut self) -> bool;
fn visit_f64(&mut self) -> bool;
- fn visit_f128(&mut self) -> bool;
fn visit_char(&mut self) -> bool;
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/")]
#![experimental]
-#![feature(managed_boxes, macro_rules, quad_precision_float)]
+#![feature(managed_boxes, macro_rules)]
#![allow(experimental)]
pub mod fmt;
true
}
- fn visit_f128(&mut self) -> bool {
- self.align_to::<f128>();
- if ! self.inner.visit_f128() { return false; }
- self.bump_past::<f128>();
- true
- }
-
fn visit_char(&mut self) -> bool {
self.align_to::<char>();
if ! self.inner.visit_char() { return false; }
fn visit_f32(&mut self) -> bool { self.write::<f32>() }
fn visit_f64(&mut self) -> bool { self.write::<f64>() }
- fn visit_f128(&mut self) -> bool { fail!("not implemented") }
fn visit_char(&mut self) -> bool {
self.get::<char>(|this, &ch| {
Some(Ident{ident, span}) => match token::get_ident(ident).get() {
"f32" => Some(ast::TyF32),
"f64" => Some(ast::TyF64),
- "f128" => Some(ast::TyF128),
_ => {
cx.span_err(span, "invalid floating point type in hexfloat!");
None
("overloaded_calls", Active),
("unboxed_closure_sugar", Active),
- ("quad_precision_float", Active),
+ ("quad_precision_float", Removed),
// A temporary feature gate used to enable parser extensions needed
// to bootstrap fix for #5723.
/// A set of features to be used by later passes.
pub struct Features {
pub default_type_params: Cell<bool>,
- pub quad_precision_float: Cell<bool>,
pub issue_5723_bootstrap: Cell<bool>,
pub overloaded_calls: Cell<bool>,
}
pub fn new() -> Features {
Features {
default_type_params: Cell::new(false),
- quad_precision_float: Cell::new(false),
issue_5723_bootstrap: Cell::new(false),
overloaded_calls: Cell::new(false),
}
sess.abort_if_errors();
sess.features.default_type_params.set(cx.has_feature("default_type_params"));
- sess.features.quad_precision_float.set(cx.has_feature("quad_precision_float"));
sess.features.issue_5723_bootstrap.set(cx.has_feature("issue_5723_bootstrap"));
sess.features.overloaded_calls.set(cx.has_feature("overloaded_calls"));
}
'D' => return ty::mk_mach_int(ast::TyI64),
'f' => return ty::mk_mach_float(ast::TyF32),
'F' => return ty::mk_mach_float(ast::TyF64),
- 'Q' => return ty::mk_mach_float(ast::TyF128),
_ => fail!("parse_ty: bad numeric type")
}
}
match t {
TyF32 => mywrite!(w, "Mf"),
TyF64 => mywrite!(w, "MF"),
- TyF128 => mywrite!(w, "MQ")
}
}
ty::ty_enum(def, ref substs) => {
table.intern("char", TyChar);
table.intern("f32", TyFloat(TyF32));
table.intern("f64", TyFloat(TyF64));
- table.intern("f128", TyFloat(TyF128));
table.intern("int", TyInt(TyI));
table.intern("i8", TyInt(TyI8));
table.intern("i16", TyInt(TyI16));
ty::ty_float(float_ty) => match float_ty {
ast::TyF32 => ("f32".to_string(), DW_ATE_float),
ast::TyF64 => ("f64".to_string(), DW_ATE_float),
- ast::TyF128 => ("f128".to_string(), DW_ATE_float)
},
_ => cx.sess().bug("debuginfo::basic_type_metadata - t is invalid type")
};
ty::ty_uint(ast::TyU64) => self.leaf("u64"),
ty::ty_float(ast::TyF32) => self.leaf("f32"),
ty::ty_float(ast::TyF64) => self.leaf("f64"),
- ty::ty_float(ast::TyF128) => self.leaf("f128"),
// Should rename to vec_*.
ty::ty_vec(ref mt, Some(sz)) => {
ty!(llvm::LLVMDoubleTypeInContext(ccx.llcx))
}
- pub fn f128(ccx: &CrateContext) -> Type {
- ty!(llvm::LLVMFP128TypeInContext(ccx.llcx))
- }
-
pub fn bool(ccx: &CrateContext) -> Type {
Type::i1(ccx)
}
match t {
ast::TyF32 => Type::f32(ccx),
ast::TyF64 => Type::f64(ccx),
- ast::TyF128 => Type::f128(ccx)
}
}
def_prim_ty!(TY_U64, super::ty_uint(ast::TyU64), 12)
def_prim_ty!(TY_F32, super::ty_float(ast::TyF32), 14)
def_prim_ty!(TY_F64, super::ty_float(ast::TyF64), 15)
- def_prim_ty!(TY_F128, super::ty_float(ast::TyF128), 16)
pub static TY_BOT: t_box_ = t_box_ {
sty: super::ty_bot,
#[inline]
pub fn mk_f64() -> t { mk_prim_t(&primitives::TY_F64) }
-#[inline]
-pub fn mk_f128() -> t { mk_prim_t(&primitives::TY_F128) }
-
#[inline]
pub fn mk_uint() -> t { mk_prim_t(&primitives::TY_UINT) }
match tm {
ast::TyF32 => mk_f32(),
ast::TyF64 => mk_f64(),
- ast::TyF128 => mk_f128()
}
}
Some(ty::mk_mach_uint(uit))
}
ast::TyFloat(ft) => {
- if ft == ast::TyF128 && !tcx.sess.features.quad_precision_float.get() {
- tcx.sess.span_err(path.span, "quadruple precision floats are \
- missing complete runtime support");
- tcx.sess.span_note(path.span, "add \
- #[feature(quad_precision_float)] \
- to the crate attributes to enable");
- }
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
Some(ty::mk_mach_float(ft))
}
pub enum Primitive {
Int, I8, I16, I32, I64,
Uint, U8, U16, U32, U64,
- F32, F64, F128,
+ F32, F64,
Char,
Bool,
Nil,
"str" => Some(Str),
"f32" => Some(F32),
"f64" => Some(F64),
- "f128" => Some(F128),
"slice" => Some(Slice),
"tuple" => Some(PrimitiveTuple),
_ => None,
U64 => "u64",
F32 => "f32",
F64 => "f64",
- F128 => "f128",
Str => "str",
Bool => "bool",
Char => "char",
ty::ty_uint(ast::TyU64) => Primitive(U64),
ty::ty_float(ast::TyF32) => Primitive(F32),
ty::ty_float(ast::TyF64) => Primitive(F64),
- ty::ty_float(ast::TyF128) => Primitive(F128),
ty::ty_str => Primitive(Str),
ty::ty_box(t) => Managed(box t.clean()),
ty::ty_uniq(t) => Unique(box t.clean()),
ast::TyUint(ast::TyU64) => return Primitive(U64),
ast::TyFloat(ast::TyF32) => return Primitive(F32),
ast::TyFloat(ast::TyF64) => return Primitive(F64),
- ast::TyFloat(ast::TyF128) => return Primitive(F128),
},
def::DefTyParam(_, i, _) => return Generic(i),
def::DefTyParamBinder(i) => return TyParamBinder(i),
pub enum FloatTy {
TyF32,
TyF64,
- TyF128
}
impl fmt::Show for FloatTy {
match t {
TyF32 => "f32".to_string(),
TyF64 => "f64".to_string(),
- TyF128 => "f128".to_string(),
}
}
let s_fty = match fty {
ast::TyF32 => "TyF32",
ast::TyF64 => "TyF64",
- ast::TyF128 => "TyF128"
};
let e_fty = mk_ast_path(cx, sp, s_fty);
let e_fident = mk_ident(cx, sp, fident);
/* FIXME (#2252): if this is out of range for either a
32-bit or 64-bit float, it won't be noticed till the
back-end. */
- } else if c == '1' && n == '2' && self.nextnextch().unwrap_or('\x00') == '8' {
- self.bump();
- self.bump();
- self.bump();
- let last_bpos = self.last_pos;
- self.check_float_base(start_bpos, last_bpos, base);
- return token::LIT_FLOAT(str_to_ident(num_str.as_slice()), ast::TyF128);
}
let last_bpos = self.last_pos;
- self.err_span_(start_bpos, last_bpos, "expected `f32`, `f64` or `f128` suffix");
+ self.err_span_(start_bpos, last_bpos, "expected `f32` or `f64` suffix");
}
if is_float {
let last_bpos = self.last_pos;
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(quad_precision_float)]
-
-static x: f128 = 1.0 + 2.0;
-
-fn foo(a: f128) -> f128 { a }
-
-pub fn main() {
- let y = x;
- foo(y);
-}
fn visit_f32(&mut self) -> bool { true }
fn visit_f64(&mut self) -> bool { true }
- fn visit_f128(&mut self) -> bool { true }
fn visit_char(&mut self) -> bool { true }