Skip to content

Commit ed4ca2e

Browse files
progvalprogval
committed
Remove warnings and fix small issues.
1 parent 632fabe commit ed4ca2e

5 files changed

Lines changed: 31 additions & 41 deletions

File tree

‎src/objects/mod.rs‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,6 @@ extern crate itertools;
22
use std::collections::HashMap;
33
use std::collections::HashSet;
44
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
5-
use std::borrow::Cow;
65
use std::rc::Rc;
76
use std::cell::RefCell;
87
use std::fmt;
@@ -196,7 +195,7 @@ impl ObjectRef {
196195
}
197196
},
198197
ObjectContent::RandomAccessIterator(ref container, ref index, ref version) => {
199-
format!("<iterator on {} at index {}>", store.deref(container).class.repr(store), version)
198+
format!("<iterator on {} at index {} and version {}>", store.deref(container).class.repr(store), index, version)
200199
}
201200
ObjectContent::OtherObject => format!("<{} instance>", obj.class.repr(store)),
202201
}

‎src/primitives/mod.rs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -5,11 +5,11 @@ use std::rc::Rc;
55
use std::cell::RefCell;
66
use std::iter::IntoIterator;
77
use super::sandbox::EnvProxy;
8-
use super::state::{State, PyResult, PyFunction, raise, return_value};
8+
use super::state::{State, PyFunction, raise, return_value};
99
use super::objects::{ObjectRef, ObjectContent, Object, ObjectStore};
1010
use super::processor::frame::Frame;
1111
use super::processor::instructions::{Instruction, InstructionDecoder};
12-
use super::varstack::{VarStack, VectorVarStack};
12+
use super::varstack::VectorVarStack;
1313

1414
macro_rules! parse_first_arguments {
1515
( $funcname:expr, $store:expr, $args:ident, $args_iter:ident, $( $argname:tt $argexpected:tt : { $($argpattern:pat => $argcode:block,)* } ),* ) => {{
@@ -83,7 +83,7 @@ fn build_class<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>,
8383
};
8484

8585

86-
let mut attributes = Rc::new(RefCell::new(HashMap::new()));
86+
let attributes = Rc::new(RefCell::new(HashMap::new()));
8787
let cls_ref = state.store.allocate(Object::new_class(name, Some(attributes.clone()), state.primitive_objects.type_.clone(), bases));
8888

8989
let mut instructions: Vec<Instruction> = InstructionDecoder::new(code.code.iter()).collect();
@@ -94,7 +94,7 @@ fn build_class<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>,
9494
instructions.push(Instruction::PushImmediate(cls_ref.clone()));
9595
instructions.push(Instruction::ReturnValue);
9696

97-
let mut frame = Frame {
97+
let frame = Frame {
9898
object: cls_ref,
9999
var_stack: VectorVarStack::new(),
100100
block_stack: vec![],
@@ -164,7 +164,7 @@ fn isinstance<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>,
164164
}
165165
}
166166

167-
fn iter<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, mut args: Vec<ObjectRef>) {
167+
fn iter<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, args: Vec<ObjectRef>) {
168168
if args.len() != 1 {
169169
panic!(format!("__primitives__.iter takes 1 arguments, not {}", args.len()))
170170
}
@@ -179,7 +179,7 @@ fn iter<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, mut ar
179179
};
180180
match container.content {
181181
ObjectContent::List(ref v) | ObjectContent::Tuple(ref v) => v.get(index).map(|r| r.clone()),
182-
ref c => panic!(format!("RandomAccessIterator does not support {}", container_ref.repr(&state.store)))
182+
_ => panic!(format!("RandomAccessIterator does not support {}", container_ref.repr(&state.store)))
183183
}
184184
};
185185
match value {
@@ -195,7 +195,7 @@ fn iter<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, mut ar
195195
}
196196
}
197197
}
198-
ref c => {
198+
_ => {
199199
let repr = iterator_ref.repr(&state.store);
200200
let exc = Object::new_instance(None, state.primitive_objects.typeerror.clone(), ObjectContent::OtherObject);
201201
let exc = state.store.allocate(exc);

‎src/processor/frame.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
use std::collections::HashMap;
22
use std::rc::Rc;
33
use std::cell::RefCell;
4-
use super::super::varstack::{VarStack, VectorVarStack};
5-
use super::super::objects::{ObjectRef, ObjectStore, ObjectContent, Code};
4+
use super::super::varstack::VectorVarStack;
5+
use super::super::objects::{ObjectRef, Code};
66
use super::instructions::{Instruction, InstructionDecoder};
77

88
#[derive(Debug)]

‎src/processor/mod.rs‎

Lines changed: 19 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,15 @@
11
pub mod instructions;
22
pub mod frame;
33

4-
use super::objects::{Code, ObjectStore, ObjectRef, ObjectContent, PrimitiveObjects, Object};
5-
use super::varstack::{VarStack, VectorVarStack};
4+
use super::objects::{ObjectRef, ObjectContent, Object};
5+
use super::varstack::VarStack;
66
use self::instructions::{CmpOperator, Instruction};
77
use self::frame::{Block, Frame};
88
use std::fmt;
99
use std::collections::HashMap;
1010
use std::io::Read;
1111
use std::cell::RefCell;
1212
use std::rc::Rc;
13-
use std::iter::FromIterator;
1413
use super::marshal;
1514
use super::state::{State, PyResult, unwind, raise, return_value};
1615
use super::sandbox::EnvProxy;
@@ -141,11 +140,11 @@ fn call_function<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame
141140
let frame = call_stack.last_mut().unwrap();
142141
frame.var_stack.push(func_ref.new_instance(&mut state.store, args, kwargs))
143142
},
144-
ObjectContent::Function(ref func_module, ref code_ref, ref defaults) => {
143+
ObjectContent::Function(ref _func_module, ref code_ref, ref defaults) => {
145144
let code = state.store.deref(code_ref).content.clone();
146145
if let ObjectContent::Code(code) = code {
147146

148-
let mut locals = Rc::new(RefCell::new(defaults.clone()));
147+
let mut locals = defaults.clone();
149148

150149
if let Some(starargs_name) = code.get_varargs_name() { // If it has a *args argument
151150
if code.argcount > args.len() {
@@ -155,7 +154,7 @@ fn call_function<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame
155154
let obj_ref = state.store.allocate(state.primitive_objects.new_tuple(to_vararg));
156155

157156
// Bind *args
158-
assert_eq!(None, locals.borrow_mut().insert(starargs_name.clone(), obj_ref));
157+
assert_eq!(None, locals.insert(starargs_name.clone(), obj_ref));
159158
}
160159
else if code.argcount != args.len() { // If it has no *args argument
161160
panic!(format!("{}() takes {} arguments, but {} was/were given.", code.name, code.argcount, args.len()))
@@ -165,7 +164,6 @@ fn call_function<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame
165164
let mut remaining_kwargs = vec![]; // arguments that will go to **kwargs
166165
{
167166
let explicit_keywords = code.keywords();
168-
let mut locals = locals.borrow_mut();
169167
for (key, value) in kwargs.into_iter() {
170168
let key_str = match state.store.deref(&key).content {
171169
ObjectContent::String(ref s) => s,
@@ -182,7 +180,7 @@ fn call_function<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame
182180

183181
if let Some(starkwargs_name) = code.get_varkwargs_name() { // If it has a **kwargs argument
184182
let obj_ref = state.store.allocate(state.primitive_objects.new_dict(remaining_kwargs));
185-
locals.borrow_mut().insert(starkwargs_name.clone(), obj_ref);
183+
locals.insert(starkwargs_name.clone(), obj_ref);
186184
}
187185
else { // If it has no **kwargs argument
188186
if remaining_kwargs.len() != 0 {
@@ -192,13 +190,12 @@ fn call_function<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame
192190

193191
// Bind positional arguments
194192
{
195-
let mut locals = locals.borrow_mut();
196193
for (argname, argvalue) in code.varnames.iter().zip(args) {
197194
locals.insert(argname.clone(), argvalue);
198195
};
199196
}
200197

201-
let new_frame = Frame::new(func_ref.clone(), *code, locals);
198+
let new_frame = Frame::new(func_ref.clone(), *code, Rc::new(RefCell::new(locals)));
202199
call_stack.push(new_frame);
203200
}
204201
else {
@@ -350,9 +347,9 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
350347
Instruction::PopExcept => {
351348
let frame = call_stack.last_mut().unwrap();
352349
let mut three_last = frame.var_stack.pop_all_and_get_n_last(3).unwrap(); // TODO: check
353-
let exc_type = three_last.pop();
354-
let exc_value = three_last.pop();
355-
let exc_traceback = three_last.pop();
350+
let _exc_type = three_last.pop();
351+
let _exc_value = three_last.pop();
352+
let _exc_traceback = three_last.pop();
356353
// TODO: do something with exc_*
357354
pop_stack!(state, frame.block_stack);
358355
},
@@ -409,7 +406,7 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
409406
}
410407
Instruction::BuildTuple(size) => {
411408
let frame = call_stack.last_mut().unwrap();
412-
let mut content = py_unwrap!(state, frame.var_stack.pop_many(size), ProcessorError::StackTooSmall);
409+
let content = py_unwrap!(state, frame.var_stack.pop_many(size), ProcessorError::StackTooSmall);
413410
let tuple = state.primitive_objects.new_tuple(content);
414411
frame.var_stack.push(state.store.allocate(tuple));
415412
}
@@ -515,9 +512,9 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
515512
Instruction::CallFunction(nb_args, nb_kwargs) => {
516513
// See “Call constructs” at:
517514
// http://security.coverity.com/blog/2014/Nov/understanding-python-bytecode.html
518-
let mut kwargs;
519-
let mut args;
520-
let mut func;
515+
let kwargs;
516+
let args;
517+
let func;
521518
{
522519
let frame = call_stack.last_mut().unwrap();
523520
kwargs = py_unwrap!(state, frame.var_stack.pop_n_pairs(nb_kwargs), ProcessorError::StackTooSmall);
@@ -571,13 +568,13 @@ fn call_module_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Fr
571568
};
572569
let module_obj = state.store.allocate(state.primitive_objects.new_module(module_name.clone(), code_ref));
573570
state.modules.insert(module_name.clone(), Rc::new(RefCell::new(HashMap::new())));
574-
let mut call_stack = vec![Frame::new(module_obj, *code, state.modules.get(&module_name).unwrap().clone())];
575-
let res = run_code(state, &mut call_stack);
571+
call_stack.push(Frame::new(module_obj, *code, state.modules.get(&module_name).unwrap().clone()));
572+
let res = run_code(state, call_stack);
576573
res // Do not raise exceptions before the pop()
577574
}
578575

579576
/// Get the code of a module from its name
580-
pub fn get_module_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, module_name: String) -> PyResult {
577+
pub fn get_module_code<EP: EnvProxy>(state: &mut State<EP>, module_name: String) -> PyResult {
581578
// Load the code
582579
let mut module_bytecode = state.envproxy.open_module(module_name.clone());
583580
let mut buf = [0; 12];
@@ -587,20 +584,14 @@ pub fn get_module_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec
587584
}
588585
match marshal::read_object(&mut module_bytecode, &mut state.store, &state.primitive_objects) {
589586
Err(e) => state.raise_processor_error(ProcessorError::UnmarshalError(e)),
590-
Ok(module_code_ref) => {
591-
let module_code = match state.store.deref(&module_code_ref).content {
592-
ObjectContent::Code(ref code) => code.clone(),
593-
ref o => return state.raise_processor_error(ProcessorError::NotACodeObject(format!("module code {:?}", o))),
594-
};
595-
PyResult::Return(state.store.allocate(state.primitive_objects.new_module(module_name.clone(), module_code_ref)))
596-
}
587+
Ok(module_code_ref) => PyResult::Return(state.store.allocate(state.primitive_objects.new_module(module_name.clone(), module_code_ref))),
597588
}
598589
}
599590

600591
/// Entry point to run code. Loads builtins in the code's namespace and then run it.
601592
pub fn call_main_code<EP: EnvProxy>(state: &mut State<EP>, code_ref: ObjectRef) -> PyResult {
602593
let mut call_stack = Vec::new();
603-
let builtins_code_ref = py_try!(get_module_code(state, &mut call_stack, "builtins".to_string()));
594+
let builtins_code_ref = py_try!(get_module_code(state, "builtins".to_string()));
604595
py_try!(call_module_code(state, &mut call_stack, "builtins".to_string(), builtins_code_ref));
605596

606597
let mut call_stack = Vec::new();

‎src/state.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ use std::cell::RefCell;
22
use std::collections::HashMap;
33
use std::rc::Rc;
44
use super::sandbox::EnvProxy;
5-
use super::objects::{Code, ObjectStore, ObjectRef, ObjectContent, PrimitiveObjects, Object};
5+
use super::objects::{ObjectStore, ObjectRef, ObjectContent, PrimitiveObjects, Object};
66
use super::processor::ProcessorError;
77
use super::processor::frame::{Block, Frame};
88
use super::primitives;
@@ -42,7 +42,7 @@ pub fn unwind<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>,
4242
// Unwind block stack
4343
while let Some(block) = frame.block_stack.pop() {
4444
match block {
45-
Block::Loop(begin, end) => { // Non-try…except block, exit it.
45+
Block::Loop(_begin, _end) => { // Non-try…except block, exit it.
4646
}
4747
Block::TryExcept(begin, end) => {
4848
// Found a try…except block

0 commit comments

Comments
 (0)