LLVM_VERSION=$($LLVM_CONFIG --version)
case $LLVM_VERSION in
- (3.[2-6]*)
+ (3.[5-6]*)
msg "found ok version of LLVM: $LLVM_VERSION"
;;
(*)
- err "bad LLVM version: $LLVM_VERSION, need >=3.0svn"
+ err "bad LLVM version: $LLVM_VERSION, need >=3.5"
;;
esac
fi
LLVM_BINDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --bindir)
LLVM_INCDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --includedir)
LLVM_LIBDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --libdir)
+LLVM_LIBDIR_RUSTFLAGS_$(1)=-L "$$(LLVM_LIBDIR_$(1))"
LLVM_LIBS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --libs $$(LLVM_COMPONENTS))
LLVM_LDFLAGS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --ldflags)
# On FreeBSD, it may search wrong headers (that are for pre-installed LLVM),
$$(subst @,,$$(STAGE$(1)_T_$(2)_H_$(3))) \
$$(RUST_LIB_FLAGS_ST$(1)) \
-L "$$(RT_OUTPUT_DIR_$(2))" \
- -L "$$(LLVM_LIBDIR_$(2))" \
+ $$(LLVM_LIBDIR_RUSTFLAGS_$(2)) \
$$(LLVM_STDCPP_RUSTFLAGS_$(2)) \
$$(RUSTFLAGS_$(4)) \
--out-dir $$(@D) \
$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(3)) \
$$(subst @,,$$(STAGE$(1)_T_$(2)_H_$(3))) -o $$@ $$< --test \
-L "$$(RT_OUTPUT_DIR_$(2))" \
- -L "$$(LLVM_LIBDIR_$(2))" \
+ $$(LLVM_LIBDIR_RUSTFLAGS_$(2)) \
$$(RUSTFLAGS_$(4))
endef
it uses. Ordinary closures, in contrast, just create a reference into
the enclosing stack frame. Moving closures are most useful with Rust's
concurrency features, and so we'll just leave it at this for
-now. We'll talk about them more in the "Threads" section of the guide.
+now. We'll talk about them more in the "Concurrency" chapter of the book.
## Accepting closures as arguments
});
}
- rx.recv().ok().expect("Could not recieve answer");
+ rx.recv().ok().expect("Could not receive answer");
}
```
}
fn coordinate(&mut self, coordinate: f64) -> &mut CircleBuilder {
- self.coordinate = coordinate;
- self
+ self.coordinate = coordinate;
+ self
}
fn radius(&mut self, radius: f64) -> &mut CircleBuilder {
- self.radius = radius;
- self
+ self.radius = radius;
+ self
}
fn finalize(&self) -> Circle {
use std::slice;
use std::path::{Path, PathBuf};
+use session::early_error;
#[derive(Clone, Debug)]
pub struct SearchPaths {
} else {
(PathKind::All, path)
};
+ if path.is_empty() {
+ early_error("empty search path given via `-L`");
+ }
self.paths.push((kind, PathBuf::new(path)));
}
if i == 0 {
c.to_uppercase().collect::<String>()
} else {
- c.to_string()
+ c.to_lowercase().collect()
}
)).collect::<Vec<_>>().concat()
}
}
SaveIn(lldest) => {
match ty::eval_repeat_count(bcx.tcx(), &**count_expr) {
- 0 => bcx,
+ 0 => expr::trans_into(bcx, &**element, Ignore),
1 => expr::trans_into(bcx, &**element, SaveIn(lldest)),
count => {
let elem = unpack_datum!(bcx, expr::trans(bcx, &**element));
F: FnOnce(Block<'blk, 'tcx>, ValueRef, Ty<'tcx>) -> Block<'blk, 'tcx>,
{
let _icx = push_ctxt("tvec::iter_vec_loop");
- let fcx = bcx.fcx;
+ if bcx.unreachable.get() {
+ return bcx;
+ }
+
+ let fcx = bcx.fcx;
let loop_bcx = fcx.new_temp_block("expr_repeat");
let next_bcx = fcx.new_temp_block("expr_repeat: next");
ty: shortty(item),
name: item.name.clone().unwrap(),
path: fqp[..fqp.len() - 1].connect("::"),
- desc: shorter(item.doc_value()).to_string(),
+ desc: shorter(item.doc_value()),
parent: Some(did),
search_type: None,
});
ty: shortty(&item),
name: s.to_string(),
path: path.connect("::").to_string(),
- desc: shorter(item.doc_value()).to_string(),
+ desc: shorter(item.doc_value()),
parent: parent,
search_type: get_index_search_type(&item, parent_basename),
});
return s
}
-fn shorter<'a>(s: Option<&'a str>) -> &'a str {
+fn shorter<'a>(s: Option<&'a str>) -> String {
match s {
- Some(s) => match s.find("\n\n") {
- Some(pos) => &s[..pos],
- None => s,
- },
- None => ""
+ Some(s) => s.lines().take_while(|line|{
+ (*line).chars().any(|chr|{
+ !chr.is_whitespace()
+ })
+ }).collect::<Vec<_>>().connect("\n"),
+ None => "".to_string()
}
}
</tr>
",
*myitem.name.as_ref().unwrap(),
- Markdown(shorter(myitem.doc_value())),
+ Markdown(&shorter(myitem.doc_value())[..]),
class = shortty(myitem),
href = item_path(myitem),
title = full_path(cx, myitem),
// except according to those terms.
//! Traits, helpers, and type definitions for core I/O functionality.
-//!
-//! > **NOTE**: This module is very much a work in progress and is under active
-//! > development. At this time it is still recommended to use the `old_io`
-//! > module while the details of this module shake out.
#![stable(feature = "rust1", since = "1.0.0")]
/// A handle to a raw instance of the standard input stream of this process.
///
/// This handle is not synchronized or buffered in any fashion. Constructed via
-/// the `std::io::stdin_raw` function.
-pub struct StdinRaw(stdio::Stdin);
+/// the `std::io::stdio::stdin_raw` function.
+struct StdinRaw(stdio::Stdin);
/// A handle to a raw instance of the standard output stream of this process.
///
/// This handle is not synchronized or buffered in any fashion. Constructed via
-/// the `std::io::stdout_raw` function.
-pub struct StdoutRaw(stdio::Stdout);
+/// the `std::io::stdio::stdout_raw` function.
+struct StdoutRaw(stdio::Stdout);
/// A handle to a raw instance of the standard output stream of this process.
///
/// This handle is not synchronized or buffered in any fashion. Constructed via
-/// the `std::io::stderr_raw` function.
-pub struct StderrRaw(stdio::Stderr);
+/// the `std::io::stdio::stderr_raw` function.
+struct StderrRaw(stdio::Stderr);
/// Construct a new raw handle to the standard input of this process.
///
/// handles is **not** available to raw handles returned from this function.
///
/// The returned handle has no external synchronization or buffering.
-pub fn stdin_raw() -> StdinRaw { StdinRaw(stdio::Stdin::new()) }
+fn stdin_raw() -> StdinRaw { StdinRaw(stdio::Stdin::new()) }
/// Construct a new raw handle to the standard input stream of this process.
///
///
/// The returned handle has no external synchronization or buffering layered on
/// top.
-pub fn stdout_raw() -> StdoutRaw { StdoutRaw(stdio::Stdout::new()) }
+fn stdout_raw() -> StdoutRaw { StdoutRaw(stdio::Stdout::new()) }
/// Construct a new raw handle to the standard input stream of this process.
///
///
/// The returned handle has no external synchronization or buffering layered on
/// top.
-pub fn stderr_raw() -> StderrRaw { StderrRaw(stdio::Stderr::new()) }
+fn stderr_raw() -> StderrRaw { StderrRaw(stdio::Stderr::new()) }
impl Read for StdinRaw {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { self.0.read(buf) }
/// The `Read` trait is implemented for the returned value but the `BufRead`
/// trait is not due to the global nature of the standard input stream. The
/// locked version, `StdinLock`, implements both `Read` and `BufRead`, however.
-///
-/// To avoid locking and buffering altogether, it is recommended to use the
-/// `stdin_raw` constructor.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn stdin() -> Stdin {
static INSTANCE: Lazy<Mutex<BufReader<StdinRaw>>> = lazy_init!(stdin_init);
/// provided via the `lock` method.
///
/// The returned handle implements the `Write` trait.
-///
-/// To avoid locking and buffering altogether, it is recommended to use the
-/// `stdout_raw` constructor.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn stdout() -> Stdout {
static INSTANCE: Lazy<Mutex<LineWriter<StdoutRaw>>> = lazy_init!(stdout_init);
/// this function. No handles are buffered, however.
///
/// The returned handle implements the `Write` trait.
-///
-/// To avoid locking altogether, it is recommended to use the `stderr_raw`
-/// constructor.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn stderr() -> Stderr {
static INSTANCE: Lazy<Mutex<StderrRaw>> = lazy_init!(stderr_init);
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/DiagnosticPrinter.h"
-#if LLVM_VERSION_MINOR >= 5
#include "llvm/IR/CallSite.h"
-#else
-#include "llvm/Support/CallSite.h"
-#endif
//===----------------------------------------------------------------------===
//
static char *LastError;
-#if LLVM_VERSION_MINOR >= 5
extern "C" LLVMMemoryBufferRef
LLVMRustCreateMemoryBufferWithContentsOfFile(const char *Path) {
ErrorOr<std::unique_ptr<MemoryBuffer>> buf_or = MemoryBuffer::getFile(Path,
}
return wrap(buf_or.get().release());
}
-#else
-extern "C" LLVMMemoryBufferRef
-LLVMRustCreateMemoryBufferWithContentsOfFile(const char *Path) {
- OwningPtr<MemoryBuffer> buf;
- error_code err = MemoryBuffer::getFile(Path, buf, -1, false);
- if (err) {
- LLVMRustSetLastError(err.message().c_str());
- return NULL;
- }
- return wrap(buf.take());
-}
-#endif
extern "C" char *LLVMRustGetLastError(void) {
char *ret = LastError;
}
-#if LLVM_VERSION_MINOR >= 5
extern "C" void LLVMAddDereferenceableCallSiteAttr(LLVMValueRef Instr, unsigned idx, uint64_t b) {
CallSite Call = CallSite(unwrap<Instruction>(Instr));
AttrBuilder B;
AttributeSet::get(Call->getContext(),
idx, B)));
}
-#else
-extern "C" void LLVMAddDereferenceableCallSiteAttr(LLVMValueRef, unsigned, uint64_t) {}
-#endif
extern "C" void LLVMAddFunctionAttribute(LLVMValueRef Fn, unsigned index, uint64_t Val) {
Function *A = unwrap<Function>(Fn);
A->addAttributes(index, AttributeSet::get(A->getContext(), index, B));
}
-#if LLVM_VERSION_MINOR >= 5
extern "C" void LLVMAddDereferenceableAttr(LLVMValueRef Fn, unsigned index, uint64_t bytes) {
Function *A = unwrap<Function>(Fn);
AttrBuilder B;
B.addDereferenceableAttr(bytes);
A->addAttributes(index, AttributeSet::get(A->getContext(), index, B));
}
-#else
-extern "C" void LLVMAddDereferenceableAttr(LLVMValueRef, unsigned, uint64_t) {}
-#endif
extern "C" void LLVMAddFunctionAttrString(LLVMValueRef Fn, unsigned index, const char *Name) {
Function *F = unwrap<Function>(Fn);
AtomicOrdering order,
AtomicOrdering failure_order) {
return wrap(unwrap(B)->CreateAtomicCmpXchg(unwrap(target), unwrap(old),
- unwrap(source), order
-#if LLVM_VERSION_MINOR >= 5
- , failure_order
-#endif
+ unwrap(source), order,
+ failure_order
));
}
extern "C" LLVMValueRef LLVMBuildAtomicFence(LLVMBuilderRef B, AtomicOrdering order) {
return DIT(ref ? unwrap<MDNode>(ref) : NULL);
}
-#if LLVM_VERSION_MINOR >= 5
extern "C" const uint32_t LLVMRustDebugMetadataVersion = DEBUG_METADATA_VERSION;
-#else
-extern "C" const uint32_t LLVMRustDebugMetadataVersion = 1;
-#endif
extern "C" void LLVMRustAddModuleFlag(LLVMModuleRef M,
const char *name,
unwrapDI<DIType>(DerivedFrom),
unwrapDI<DIArray>(Elements),
RunTimeLang,
- unwrapDI<DIType>(VTableHolder)
-#if LLVM_VERSION_MINOR >= 4
- ,UniqueId
-#endif
+ unwrapDI<DIType>(VTableHolder),
+ UniqueId
));
}
#if LLVM_VERSION_MINOR < 6
if (AddrOpsCount > 0) {
SmallVector<llvm::Value *, 16> addr_ops;
- llvm::Type *Int64Ty = Type::getInt64Ty(VMContext);
- for (int i = 0; i < AddrOpsCount; ++i)
+ llvm::Type *Int64Ty = Type::getInt64Ty(unwrap<MDNode>(Scope)->getContext());
+ for (unsigned i = 0; i < AddrOpsCount; ++i)
addr_ops.push_back(ConstantInt::get(Int64Ty, AddrOps[i]));
return wrap(Builder->createComplexVariable(
LLVMMetadataRef* Ptr,
unsigned Count) {
return wrap(Builder->getOrCreateArray(
+#if LLVM_VERSION_MINOR >= 6
ArrayRef<Metadata*>(unwrap(Ptr), Count)));
+#else
+ ArrayRef<Value*>(reinterpret_cast<Value**>(Ptr), Count)));
+#endif
}
extern "C" LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(
AlignInBits,
Flags,
unwrapDI<DIArray>(Elements),
- RunTimeLang
-#if LLVM_VERSION_MINOR >= 4
- ,UniqueId
-#endif
+ RunTimeLang,
+ UniqueId
));
}
-#if LLVM_VERSION_MINOR < 5
-extern "C" void LLVMSetUnnamedAddr(LLVMValueRef Value, LLVMBool Unnamed) {
- unwrap<GlobalValue>(Value)->setUnnamedAddr(Unnamed);
-}
-#endif
-
extern "C" LLVMMetadataRef LLVMDIBuilderCreateTemplateTypeParameter(
DIBuilderRef Builder,
LLVMMetadataRef Scope,
os << ")";
}
-#if LLVM_VERSION_MINOR >= 5
extern "C" bool
LLVMRustLinkInExternalBitcode(LLVMModuleRef dst, char *bc, size_t len) {
Module *Dst = unwrap(dst);
}
return true;
}
-#else
-extern "C" bool
-LLVMRustLinkInExternalBitcode(LLVMModuleRef dst, char *bc, size_t len) {
- Module *Dst = unwrap(dst);
- MemoryBuffer* buf = MemoryBuffer::getMemBufferCopy(StringRef(bc, len));
- std::string Err;
- Module *Src = llvm::getLazyBitcodeModule(buf, Dst->getContext(), &Err);
- if (!Src) {
- LLVMRustSetLastError(Err.c_str());
- delete buf;
- return false;
- }
-
- if (Linker::LinkModules(Dst, Src, Linker::DestroySource, &Err)) {
- LLVMRustSetLastError(Err.c_str());
- return false;
- }
- return true;
-}
-#endif
-#if LLVM_VERSION_MINOR >= 5
extern "C" void*
LLVMRustOpenArchive(char *path) {
ErrorOr<std::unique_ptr<MemoryBuffer>> buf_or = MemoryBuffer::getFile(path,
return ret;
}
-#else
-extern "C" void*
-LLVMRustOpenArchive(char *path) {
- OwningPtr<MemoryBuffer> buf;
- error_code err = MemoryBuffer::getFile(path, buf, -1, false);
- if (err) {
- LLVMRustSetLastError(err.message().c_str());
- return NULL;
- }
- Archive *ret = new Archive(buf.take(), err);
- if (err) {
- LLVMRustSetLastError(err.message().c_str());
- return NULL;
- }
- return ret;
-}
-#endif
extern "C" const char*
#if LLVM_VERSION_MINOR >= 6
LLVMRustArchiveReadSection(Archive *ar, char *name, size_t *size) {
#endif
-#if LLVM_VERSION_MINOR >= 5
Archive::child_iterator child = ar->child_begin(),
end = ar->child_end();
for (; child != end; ++child) {
ErrorOr<StringRef> name_or_err = child->getName();
if (name_or_err.getError()) continue;
StringRef sect_name = name_or_err.get();
-#else
- Archive::child_iterator child = ar->begin_children(),
- end = ar->end_children();
- for (; child != end; ++child) {
- StringRef sect_name;
- error_code err = child->getName(sect_name);
- if (err) continue;
-#endif
if (sect_name.trim(" ") == name) {
StringRef buf = child->getBuffer();
*size = buf.size();
delete ar;
}
-#if LLVM_VERSION_MINOR >= 5
extern "C" void
LLVMRustSetDLLExportStorageClass(LLVMValueRef Value) {
GlobalValue *V = unwrap<GlobalValue>(Value);
V->setDLLStorageClass(GlobalValue::DLLExportStorageClass);
}
-#else
-extern "C" void
-LLVMRustSetDLLExportStorageClass(LLVMValueRef Value) {
- LLVMSetLinkage(Value, LLVMDLLExportLinkage);
-}
-#endif
extern "C" int
LLVMVersionMinor() {
extern "C" int
LLVMRustGetSectionName(LLVMSectionIteratorRef SI, const char **ptr) {
StringRef ret;
-#if LLVM_VERSION_MINOR >= 5
if (std::error_code ec = (*unwrap(SI))->getName(ret))
-#else
- if (error_code ec = (*unwrap(SI))->getName(ret))
-#endif
report_fatal_error(ec.message());
*ptr = ret.data();
return ret.size();
#![forbid(non_camel_case_types)]
#![allow(dead_code)]
+struct ONE_TWO_THREE;
+//~^ ERROR type `ONE_TWO_THREE` should have a camel case name such as `OneTwoThree`
+
struct foo { //~ ERROR type `foo` should have a camel case name such as `Foo`
bar: isize,
}
--- /dev/null
+// Copyright 2015 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.
+
+// compile-flags:-L native=
+// error-pattern: empty search path given via `-L`
+
+fn main() {
+}
--- /dev/null
+// Copyright 2015 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.
+
+// error-pattern:panic evaluated
+
+#[allow(unused_variables)]
+fn main() {
+ // This used to trigger an LLVM assertion during compilation
+ let x = [panic!("panic evaluated"); 2];
+}
--- /dev/null
+// Copyright 2015 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.
+
+// error-pattern:panic evaluated
+
+#[allow(unused_variables)]
+fn main() {
+ let x = [panic!("panic evaluated"); 0];
+}
projects / rust.git / commitdiff