Skip to content

Commit 6d9bdf9

Browse files
author
Palmer Cox
committed
Rename all variables that have uppercase characters in their names to use only lowercase characters
1 parent fe50c75 commit 6d9bdf9

File tree

21 files changed

+541
-541
lines changed

21 files changed

+541
-541
lines changed

‎src/compiletest/runtest.rs

Lines changed: 80 additions & 80 deletions
Large diffs are not rendered by default.

‎src/libnum/bigint.rs

Lines changed: 67 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -266,14 +266,14 @@ impl Mul<BigUint, BigUint> for BigUint {
266266
// (a1*b1 + a0*b0 - (a1-b0)*(b1-a0)) * base +
267267
// a0*b0
268268
let half_len = cmp::max(s_len, o_len) / 2;
269-
let (sHi, sLo) = cut_at(self, half_len);
270-
let (oHi, oLo) = cut_at(other, half_len);
269+
let (s_hi, s_lo) = cut_at(self, half_len);
270+
let (o_hi, o_lo) = cut_at(other, half_len);
271271

272-
let ll = sLo * oLo;
273-
let hh = sHi * oHi;
272+
let ll = s_lo * o_lo;
273+
let hh = s_hi * o_hi;
274274
let mm = {
275-
let (s1, n1) = sub_sign(sHi, sLo);
276-
let (s2, n2) = sub_sign(oHi, oLo);
275+
let (s1, n1) = sub_sign(s_hi, s_lo);
276+
let (s2, n2) = sub_sign(o_hi, o_lo);
277277
match (s1, s2) {
278278
(Equal, _) | (_, Equal) => hh + ll,
279279
(Less, Greater) | (Greater, Less) => hh + ll + (n1 * n2),
@@ -1778,10 +1778,10 @@ mod biguint_tests {
17781778
#[test]
17791779
fn test_add() {
17801780
for elm in sum_triples.iter() {
1781-
let (aVec, bVec, cVec) = *elm;
1782-
let a = BigUint::from_slice(aVec);
1783-
let b = BigUint::from_slice(bVec);
1784-
let c = BigUint::from_slice(cVec);
1781+
let (a_vec, b_vec, c_vec) = *elm;
1782+
let a = BigUint::from_slice(a_vec);
1783+
let b = BigUint::from_slice(b_vec);
1784+
let c = BigUint::from_slice(c_vec);
17851785

17861786
assert!(a + b == c);
17871787
assert!(b + a == c);
@@ -1791,10 +1791,10 @@ mod biguint_tests {
17911791
#[test]
17921792
fn test_sub() {
17931793
for elm in sum_triples.iter() {
1794-
let (aVec, bVec, cVec) = *elm;
1795-
let a = BigUint::from_slice(aVec);
1796-
let b = BigUint::from_slice(bVec);
1797-
let c = BigUint::from_slice(cVec);
1794+
let (a_vec, b_vec, c_vec) = *elm;
1795+
let a = BigUint::from_slice(a_vec);
1796+
let b = BigUint::from_slice(b_vec);
1797+
let c = BigUint::from_slice(c_vec);
17981798

17991799
assert!(c - a == b);
18001800
assert!(c - b == a);
@@ -1842,21 +1842,21 @@ mod biguint_tests {
18421842
#[test]
18431843
fn test_mul() {
18441844
for elm in mul_triples.iter() {
1845-
let (aVec, bVec, cVec) = *elm;
1846-
let a = BigUint::from_slice(aVec);
1847-
let b = BigUint::from_slice(bVec);
1848-
let c = BigUint::from_slice(cVec);
1845+
let (a_vec, b_vec, c_vec) = *elm;
1846+
let a = BigUint::from_slice(a_vec);
1847+
let b = BigUint::from_slice(b_vec);
1848+
let c = BigUint::from_slice(c_vec);
18491849

18501850
assert!(a * b == c);
18511851
assert!(b * a == c);
18521852
}
18531853

18541854
for elm in div_rem_quadruples.iter() {
1855-
let (aVec, bVec, cVec, dVec) = *elm;
1856-
let a = BigUint::from_slice(aVec);
1857-
let b = BigUint::from_slice(bVec);
1858-
let c = BigUint::from_slice(cVec);
1859-
let d = BigUint::from_slice(dVec);
1855+
let (a_vec, b_vec, c_vec, d_vec) = *elm;
1856+
let a = BigUint::from_slice(a_vec);
1857+
let b = BigUint::from_slice(b_vec);
1858+
let c = BigUint::from_slice(c_vec);
1859+
let d = BigUint::from_slice(d_vec);
18601860

18611861
assert!(a == b * c + d);
18621862
assert!(a == c * b + d);
@@ -1866,10 +1866,10 @@ mod biguint_tests {
18661866
#[test]
18671867
fn test_div_rem() {
18681868
for elm in mul_triples.iter() {
1869-
let (aVec, bVec, cVec) = *elm;
1870-
let a = BigUint::from_slice(aVec);
1871-
let b = BigUint::from_slice(bVec);
1872-
let c = BigUint::from_slice(cVec);
1869+
let (a_vec, b_vec, c_vec) = *elm;
1870+
let a = BigUint::from_slice(a_vec);
1871+
let b = BigUint::from_slice(b_vec);
1872+
let c = BigUint::from_slice(c_vec);
18731873

18741874
if !a.is_zero() {
18751875
assert_eq!(c.div_rem(&a), (b.clone(), Zero::zero()));
@@ -1880,11 +1880,11 @@ mod biguint_tests {
18801880
}
18811881

18821882
for elm in div_rem_quadruples.iter() {
1883-
let (aVec, bVec, cVec, dVec) = *elm;
1884-
let a = BigUint::from_slice(aVec);
1885-
let b = BigUint::from_slice(bVec);
1886-
let c = BigUint::from_slice(cVec);
1887-
let d = BigUint::from_slice(dVec);
1883+
let (a_vec, b_vec, c_vec, d_vec) = *elm;
1884+
let a = BigUint::from_slice(a_vec);
1885+
let b = BigUint::from_slice(b_vec);
1886+
let c = BigUint::from_slice(c_vec);
1887+
let d = BigUint::from_slice(d_vec);
18881888

18891889
if !b.is_zero() { assert!(a.div_rem(&b) == (c, d)); }
18901890
}
@@ -2351,10 +2351,10 @@ mod bigint_tests {
23512351
#[test]
23522352
fn test_add() {
23532353
for elm in sum_triples.iter() {
2354-
let (aVec, bVec, cVec) = *elm;
2355-
let a = BigInt::from_slice(Plus, aVec);
2356-
let b = BigInt::from_slice(Plus, bVec);
2357-
let c = BigInt::from_slice(Plus, cVec);
2354+
let (a_vec, b_vec, c_vec) = *elm;
2355+
let a = BigInt::from_slice(Plus, a_vec);
2356+
let b = BigInt::from_slice(Plus, b_vec);
2357+
let c = BigInt::from_slice(Plus, c_vec);
23582358

23592359
assert!(a + b == c);
23602360
assert!(b + a == c);
@@ -2370,10 +2370,10 @@ mod bigint_tests {
23702370
#[test]
23712371
fn test_sub() {
23722372
for elm in sum_triples.iter() {
2373-
let (aVec, bVec, cVec) = *elm;
2374-
let a = BigInt::from_slice(Plus, aVec);
2375-
let b = BigInt::from_slice(Plus, bVec);
2376-
let c = BigInt::from_slice(Plus, cVec);
2373+
let (a_vec, b_vec, c_vec) = *elm;
2374+
let a = BigInt::from_slice(Plus, a_vec);
2375+
let b = BigInt::from_slice(Plus, b_vec);
2376+
let c = BigInt::from_slice(Plus, c_vec);
23772377

23782378
assert!(c - a == b);
23792379
assert!(c - b == a);
@@ -2427,10 +2427,10 @@ mod bigint_tests {
24272427
#[test]
24282428
fn test_mul() {
24292429
for elm in mul_triples.iter() {
2430-
let (aVec, bVec, cVec) = *elm;
2431-
let a = BigInt::from_slice(Plus, aVec);
2432-
let b = BigInt::from_slice(Plus, bVec);
2433-
let c = BigInt::from_slice(Plus, cVec);
2430+
let (a_vec, b_vec, c_vec) = *elm;
2431+
let a = BigInt::from_slice(Plus, a_vec);
2432+
let b = BigInt::from_slice(Plus, b_vec);
2433+
let c = BigInt::from_slice(Plus, c_vec);
24342434

24352435
assert!(a * b == c);
24362436
assert!(b * a == c);
@@ -2440,11 +2440,11 @@ mod bigint_tests {
24402440
}
24412441

24422442
for elm in div_rem_quadruples.iter() {
2443-
let (aVec, bVec, cVec, dVec) = *elm;
2444-
let a = BigInt::from_slice(Plus, aVec);
2445-
let b = BigInt::from_slice(Plus, bVec);
2446-
let c = BigInt::from_slice(Plus, cVec);
2447-
let d = BigInt::from_slice(Plus, dVec);
2443+
let (a_vec, b_vec, c_vec, d_vec) = *elm;
2444+
let a = BigInt::from_slice(Plus, a_vec);
2445+
let b = BigInt::from_slice(Plus, b_vec);
2446+
let c = BigInt::from_slice(Plus, c_vec);
2447+
let d = BigInt::from_slice(Plus, d_vec);
24482448

24492449
assert!(a == b * c + d);
24502450
assert!(a == c * b + d);
@@ -2479,21 +2479,21 @@ mod bigint_tests {
24792479
}
24802480

24812481
for elm in mul_triples.iter() {
2482-
let (aVec, bVec, cVec) = *elm;
2483-
let a = BigInt::from_slice(Plus, aVec);
2484-
let b = BigInt::from_slice(Plus, bVec);
2485-
let c = BigInt::from_slice(Plus, cVec);
2482+
let (a_vec, b_vec, c_vec) = *elm;
2483+
let a = BigInt::from_slice(Plus, a_vec);
2484+
let b = BigInt::from_slice(Plus, b_vec);
2485+
let c = BigInt::from_slice(Plus, c_vec);
24862486

24872487
if !a.is_zero() { check(&c, &a, &b, &Zero::zero()); }
24882488
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); }
24892489
}
24902490

24912491
for elm in div_rem_quadruples.iter() {
2492-
let (aVec, bVec, cVec, dVec) = *elm;
2493-
let a = BigInt::from_slice(Plus, aVec);
2494-
let b = BigInt::from_slice(Plus, bVec);
2495-
let c = BigInt::from_slice(Plus, cVec);
2496-
let d = BigInt::from_slice(Plus, dVec);
2492+
let (a_vec, b_vec, c_vec, d_vec) = *elm;
2493+
let a = BigInt::from_slice(Plus, a_vec);
2494+
let b = BigInt::from_slice(Plus, b_vec);
2495+
let c = BigInt::from_slice(Plus, c_vec);
2496+
let d = BigInt::from_slice(Plus, d_vec);
24972497

24982498
if !b.is_zero() {
24992499
check(&a, &b, &c, &d);
@@ -2522,21 +2522,21 @@ mod bigint_tests {
25222522
check_sub(&a.neg(), &b.neg(), q, &r.neg());
25232523
}
25242524
for elm in mul_triples.iter() {
2525-
let (aVec, bVec, cVec) = *elm;
2526-
let a = BigInt::from_slice(Plus, aVec);
2527-
let b = BigInt::from_slice(Plus, bVec);
2528-
let c = BigInt::from_slice(Plus, cVec);
2525+
let (a_vec, b_vec, c_vec) = *elm;
2526+
let a = BigInt::from_slice(Plus, a_vec);
2527+
let b = BigInt::from_slice(Plus, b_vec);
2528+
let c = BigInt::from_slice(Plus, c_vec);
25292529

25302530
if !a.is_zero() { check(&c, &a, &b, &Zero::zero()); }
25312531
if !b.is_zero() { check(&c, &b, &a, &Zero::zero()); }
25322532
}
25332533

25342534
for elm in div_rem_quadruples.iter() {
2535-
let (aVec, bVec, cVec, dVec) = *elm;
2536-
let a = BigInt::from_slice(Plus, aVec);
2537-
let b = BigInt::from_slice(Plus, bVec);
2538-
let c = BigInt::from_slice(Plus, cVec);
2539-
let d = BigInt::from_slice(Plus, dVec);
2535+
let (a_vec, b_vec, c_vec, d_vec) = *elm;
2536+
let a = BigInt::from_slice(Plus, a_vec);
2537+
let b = BigInt::from_slice(Plus, b_vec);
2538+
let c = BigInt::from_slice(Plus, c_vec);
2539+
let d = BigInt::from_slice(Plus, d_vec);
25402540

25412541
if !b.is_zero() {
25422542
check(&a, &b, &c, &d);

‎src/librustc/back/link.rs

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -68,15 +68,15 @@ pub fn llvm_err(sess: Session, msg: ~str) -> ! {
6868

6969
pub fn WriteOutputFile(
7070
sess: Session,
71-
Target: lib::llvm::TargetMachineRef,
72-
PM: lib::llvm::PassManagerRef,
73-
M: ModuleRef,
74-
Output: &Path,
75-
FileType: lib::llvm::FileType) {
71+
target: lib::llvm::TargetMachineRef,
72+
pm: lib::llvm::PassManagerRef,
73+
m: ModuleRef,
74+
output: &Path,
75+
file_type: lib::llvm::FileType) {
7676
unsafe {
77-
Output.with_c_str(|Output| {
77+
output.with_c_str(|output| {
7878
let result = llvm::LLVMRustWriteOutputFile(
79-
Target, PM, M, Output, FileType);
79+
target, pm, m, output, file_type);
8080
if !result {
8181
llvm_err(sess, ~"could not write output");
8282
}
@@ -138,7 +138,7 @@ pub mod write {
138138
})
139139
}
140140

141-
let OptLevel = match sess.opts.optimize {
141+
let opt_level = match sess.opts.optimize {
142142
session::No => lib::llvm::CodeGenLevelNone,
143143
session::Less => lib::llvm::CodeGenLevelLess,
144144
session::Default => lib::llvm::CodeGenLevelDefault,
@@ -152,14 +152,14 @@ pub mod write {
152152
(sess.targ_cfg.os == abi::OsMacos &&
153153
sess.targ_cfg.arch == abi::X86_64);
154154

155-
let tm = sess.targ_cfg.target_strs.target_triple.with_c_str(|T| {
156-
sess.opts.cg.target_cpu.with_c_str(|CPU| {
157-
target_feature(&sess).with_c_str(|Features| {
155+
let tm = sess.targ_cfg.target_strs.target_triple.with_c_str(|t| {
156+
sess.opts.cg.target_cpu.with_c_str(|cpu| {
157+
target_feature(&sess).with_c_str(|features| {
158158
llvm::LLVMRustCreateTargetMachine(
159-
T, CPU, Features,
159+
t, cpu, features,
160160
lib::llvm::CodeModelDefault,
161161
lib::llvm::RelocPIC,
162-
OptLevel,
162+
opt_level,
163163
true,
164164
use_softfp,
165165
no_fp_elim
@@ -185,7 +185,7 @@ pub mod write {
185185
if !sess.opts.cg.no_prepopulate_passes {
186186
llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
187187
llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
188-
populate_llvm_passes(fpm, mpm, llmod, OptLevel);
188+
populate_llvm_passes(fpm, mpm, llmod, opt_level);
189189
}
190190

191191
for pass in sess.opts.cg.passes.iter() {

‎src/librustc/lib/llvm.rs

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1774,25 +1774,25 @@ pub mod llvm {
17741774
}
17751775
}
17761776

1777-
pub fn SetInstructionCallConv(Instr: ValueRef, CC: CallConv) {
1777+
pub fn SetInstructionCallConv(instr: ValueRef, cc: CallConv) {
17781778
unsafe {
1779-
llvm::LLVMSetInstructionCallConv(Instr, CC as c_uint);
1779+
llvm::LLVMSetInstructionCallConv(instr, cc as c_uint);
17801780
}
17811781
}
1782-
pub fn SetFunctionCallConv(Fn: ValueRef, CC: CallConv) {
1782+
pub fn SetFunctionCallConv(fn_: ValueRef, cc: CallConv) {
17831783
unsafe {
1784-
llvm::LLVMSetFunctionCallConv(Fn, CC as c_uint);
1784+
llvm::LLVMSetFunctionCallConv(fn_, cc as c_uint);
17851785
}
17861786
}
1787-
pub fn SetLinkage(Global: ValueRef, Link: Linkage) {
1787+
pub fn SetLinkage(global: ValueRef, link: Linkage) {
17881788
unsafe {
1789-
llvm::LLVMSetLinkage(Global, Link as c_uint);
1789+
llvm::LLVMSetLinkage(global, link as c_uint);
17901790
}
17911791
}
17921792

1793-
pub fn SetUnnamedAddr(Global: ValueRef, Unnamed: bool) {
1793+
pub fn SetUnnamedAddr(global: ValueRef, unnamed: bool) {
17941794
unsafe {
1795-
llvm::LLVMSetUnnamedAddr(Global, Unnamed as Bool);
1795+
llvm::LLVMSetUnnamedAddr(global, unnamed as Bool);
17961796
}
17971797
}
17981798

@@ -1802,20 +1802,20 @@ pub fn set_thread_local(global: ValueRef, is_thread_local: bool) {
18021802
}
18031803
}
18041804

1805-
pub fn ConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
1805+
pub fn ConstICmp(pred: IntPredicate, v1: ValueRef, v2: ValueRef) -> ValueRef {
18061806
unsafe {
1807-
llvm::LLVMConstICmp(Pred as c_ushort, V1, V2)
1807+
llvm::LLVMConstICmp(pred as c_ushort, v1, v2)
18081808
}
18091809
}
1810-
pub fn ConstFCmp(Pred: RealPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
1810+
pub fn ConstFCmp(pred: RealPredicate, v1: ValueRef, v2: ValueRef) -> ValueRef {
18111811
unsafe {
1812-
llvm::LLVMConstFCmp(Pred as c_ushort, V1, V2)
1812+
llvm::LLVMConstFCmp(pred as c_ushort, v1, v2)
18131813
}
18141814
}
18151815

1816-
pub fn SetFunctionAttribute(Fn: ValueRef, attr: Attribute) {
1816+
pub fn SetFunctionAttribute(fn_: ValueRef, attr: Attribute) {
18171817
unsafe {
1818-
llvm::LLVMAddFunctionAttr(Fn, attr as c_uint)
1818+
llvm::LLVMAddFunctionAttr(fn_, attr as c_uint)
18191819
}
18201820
}
18211821
/* Memory-managed object interface to type handles. */
@@ -1879,9 +1879,9 @@ impl Drop for target_data_res {
18791879
}
18801880
}
18811881

1882-
pub fn target_data_res(TD: TargetDataRef) -> target_data_res {
1882+
pub fn target_data_res(td: TargetDataRef) -> target_data_res {
18831883
target_data_res {
1884-
TD: TD
1884+
TD: td
18851885
}
18861886
}
18871887

@@ -1915,9 +1915,9 @@ impl Drop for pass_manager_res {
19151915
}
19161916
}
19171917

1918-
pub fn pass_manager_res(PM: PassManagerRef) -> pass_manager_res {
1918+
pub fn pass_manager_res(pm: PassManagerRef) -> pass_manager_res {
19191919
pass_manager_res {
1920-
PM: PM
1920+
PM: pm
19211921
}
19221922
}
19231923

@@ -1982,9 +1982,9 @@ impl Drop for section_iter_res {
19821982
}
19831983
}
19841984

1985-
pub fn section_iter_res(SI: SectionIteratorRef) -> section_iter_res {
1985+
pub fn section_iter_res(si: SectionIteratorRef) -> section_iter_res {
19861986
section_iter_res {
1987-
SI: SI
1987+
SI: si
19881988
}
19891989
}
19901990

0 commit comments

Comments
 (0)