diff --git a/src/buffer/line.rs b/src/buffer/line.rs index 8526085..a86ee4d 100644 --- a/src/buffer/line.rs +++ b/src/buffer/line.rs @@ -5,12 +5,12 @@ use std::mem; use std::str::Graphemes; use string_utils::{grapheme_count, grapheme_pos_to_byte_pos, is_line_ending}; -const TAB_WIDTH: uint = 4; +const TAB_WIDTH: usize = 4; /// Returns the visual width of a grapheme given a starting /// position on a line. -fn grapheme_vis_width_at_vis_pos(g: &str, pos: uint, tab_width: uint) -> uint { +fn grapheme_vis_width_at_vis_pos(g: &str, pos: usize, tab_width: usize) -> usize { match g { "\t" => { let ending_pos = ((pos / tab_width) + 1) * tab_width; @@ -138,7 +138,7 @@ impl Line { }; // Check for line ending - let mut le_size: uint = 0; + let mut le_size: usize = 0; let text_size = tl.text.len(); if tl.text.len() >= 3 { match unsafe{mem::transmute::<&[u8], &str>(tl.text.slice_from(text_size-3))} { @@ -216,7 +216,7 @@ impl Line { /// Returns the total number of unicode graphemes in the line - pub fn grapheme_count(&self) -> uint { + pub fn grapheme_count(&self) -> usize { let mut count = grapheme_count(self.as_str()); match self.ending { LineEnding::None => {}, @@ -228,13 +228,13 @@ impl Line { /// Returns the total number of unicode graphemes in the line, /// not counting the line ending grapheme, if any. - pub fn grapheme_count_sans_line_ending(&self) -> uint { + pub fn grapheme_count_sans_line_ending(&self) -> usize { grapheme_count(self.as_str()) } /// Returns the visual cell width of the line - pub fn vis_width(&self, tab_width: uint) -> uint { + pub fn vis_width(&self, tab_width: usize) -> usize { let mut width = 0; for g in self.as_str().graphemes(true) { @@ -246,7 +246,7 @@ impl Line { } - pub fn grapheme_at_index<'a>(&'a self, index: uint) -> &'a str { + pub fn grapheme_at_index<'a>(&'a self, index: usize) -> &'a str { let mut iter = self.grapheme_iter(); let mut i = 0; @@ -264,7 +264,7 @@ impl Line { } - pub fn grapheme_width_at_index(&self, index: uint, tab_width: uint) -> uint { + pub fn grapheme_width_at_index(&self, index: usize, tab_width: usize) -> usize { let mut iter = self.grapheme_vis_iter(tab_width); let mut i = 0; @@ -283,7 +283,7 @@ impl Line { /// Translates a grapheme index into a visual horizontal position - pub fn grapheme_index_to_closest_vis_pos(&self, index: uint, tab_width: uint) -> uint { + pub fn grapheme_index_to_closest_vis_pos(&self, index: usize, tab_width: usize) -> usize { let mut pos = 0; let mut iter = self.as_str().graphemes(true); @@ -302,7 +302,7 @@ impl Line { /// Translates a visual horizontal position to the closest grapheme index - pub fn vis_pos_to_closest_grapheme_index(&self, vis_pos: uint, tab_width: uint) -> uint { + pub fn vis_pos_to_closest_grapheme_index(&self, vis_pos: usize, tab_width: usize) -> usize { let mut pos = 0; let mut i = 0; let mut iter = self.as_str().graphemes(true); @@ -342,7 +342,7 @@ impl Line { /// Inserts `text` at grapheme index `pos`. /// NOTE: panics if it encounters a line ending in the text. - pub fn insert_text(&mut self, text: &str, pos: uint) { + pub fn insert_text(&mut self, text: &str, pos: usize) { // Find insertion position in bytes let byte_pos = grapheme_pos_to_byte_pos(self.as_str(), pos); @@ -398,7 +398,7 @@ impl Line { /// Remove the text between grapheme positions 'pos_a' and 'pos_b'. - pub fn remove_text(&mut self, pos_a: uint, pos_b: uint) { + pub fn remove_text(&mut self, pos_a: usize, pos_b: usize) { // Bounds checks if pos_a > pos_b { panic!("Line::remove_text(): pos_a must be less than or equal to pos_b."); @@ -427,7 +427,7 @@ impl Line { /// Insert a line break into the line, splitting it into two. /// This line stays as the first part of the split. The second /// part is returned. - pub fn split(&mut self, ending: LineEnding, pos: uint) -> Line { + pub fn split(&mut self, ending: LineEnding, pos: usize) -> Line { let mut other = Line::new(); // Inserting at very beginning: special cased for efficiency @@ -466,7 +466,7 @@ impl Line { /// Returns an iterator over the graphemes of the line - pub fn grapheme_iter_at_index<'a>(&'a self, index: uint) -> LineGraphemeIter<'a> { + pub fn grapheme_iter_at_index<'a>(&'a self, index: usize) -> LineGraphemeIter<'a> { let temp: &str = unsafe{mem::transmute(self.text.as_slice())}; let mut iter = LineGraphemeIter { @@ -484,7 +484,7 @@ impl Line { /// Returns an iterator over the graphemes of the line - pub fn grapheme_vis_iter<'a>(&'a self, tab_width: uint) -> LineGraphemeVisIter<'a> { + pub fn grapheme_vis_iter<'a>(&'a self, tab_width: usize) -> LineGraphemeVisIter<'a> { LineGraphemeVisIter { graphemes: self.grapheme_iter(), vis_pos: 0, @@ -563,7 +563,7 @@ pub fn str_to_line_ending(g: &str) -> LineEnding { } pub fn line_ending_to_str(ending: LineEnding) -> &'static str { - LINE_ENDINGS[ending as uint] + LINE_ENDINGS[ending as usize] } /// An array of string literals corresponding to the possible @@ -588,7 +588,7 @@ pub struct LineGraphemeIter<'a> { } impl<'a> LineGraphemeIter<'a> { - pub fn skip_graphemes(&mut self, n: uint) { + pub fn skip_graphemes(&mut self, n: usize) { for _ in range(0, n) { if let None = self.next() { break; @@ -616,7 +616,7 @@ impl<'a> Iterator for LineGraphemeIter<'a> { return None; } else { - return Some(LINE_ENDINGS[self.ending as uint]); + return Some(LINE_ENDINGS[self.ending as usize]); } } } @@ -632,12 +632,12 @@ impl<'a> Iterator for LineGraphemeIter<'a> { /// visual width. pub struct LineGraphemeVisIter<'a> { graphemes: LineGraphemeIter<'a>, - vis_pos: uint, - tab_width: uint, + vis_pos: usize, + tab_width: usize, } impl<'a> LineGraphemeVisIter<'a> { - pub fn skip_graphemes(&mut self, n: uint) { + pub fn skip_graphemes(&mut self, n: usize) { for _ in range(0, n) { if let None = self.next() { break; @@ -647,7 +647,7 @@ impl<'a> LineGraphemeVisIter<'a> { // Skips at least n visual positions, and returns the number of excess // skipped visual positions beyond n. - pub fn skip_vis_positions(&mut self, n: uint) -> uint { + pub fn skip_vis_positions(&mut self, n: usize) -> usize { let mut i = 0; while i < n { if let Some((_, _, width)) = self.next() { @@ -668,9 +668,9 @@ impl<'a> LineGraphemeVisIter<'a> { } impl<'a> Iterator for LineGraphemeVisIter<'a> { - type Item = (&'a str, uint, uint); + type Item = (&'a str, usize, usize); - fn next(&mut self) -> Option<(&'a str, uint, uint)> { + fn next(&mut self) -> Option<(&'a str, usize, usize)> { if let Some(g) = self.graphemes.next() { let pos = self.vis_pos; let width = grapheme_vis_width_at_vis_pos(g, self.vis_pos, self.tab_width); diff --git a/src/buffer/mod.rs b/src/buffer/mod.rs index f900630..301108b 100644 --- a/src/buffer/mod.rs +++ b/src/buffer/mod.rs @@ -30,17 +30,17 @@ impl Buffer { } - pub fn len(&self) -> uint { + pub fn len(&self) -> usize { self.text.grapheme_count } - pub fn line_count(&self) -> uint { + pub fn line_count(&self) -> usize { self.text.line_count } - pub fn get_grapheme<'a>(&'a self, index: uint) -> &'a str { + pub fn get_grapheme<'a>(&'a self, index: usize) -> &'a str { if index >= self.len() { panic!("Buffer::get_grapheme(): index past last grapheme."); } @@ -50,7 +50,7 @@ impl Buffer { } - pub fn get_grapheme_width(&self, index: uint, tab_width: uint) -> uint { + pub fn get_grapheme_width(&self, index: usize, tab_width: usize) -> usize { if index >= self.len() { panic!("Buffer::get_grapheme_width(): index past last grapheme."); } @@ -60,7 +60,7 @@ impl Buffer { } - pub fn get_line<'a>(&'a self, index: uint) -> &'a Line { + pub fn get_line<'a>(&'a self, index: usize) -> &'a Line { if index >= self.line_count() { panic!("get_line(): index out of bounds."); } @@ -81,7 +81,7 @@ impl Buffer { /// Removes the lines in line indices [line_a, line_b). - pub fn remove_lines(&mut self, line_a: uint, line_b: uint) { + pub fn remove_lines(&mut self, line_a: usize, line_b: usize) { // Nothing to do if line_a == line_b { return; @@ -107,12 +107,12 @@ impl Buffer { } - pub fn pos_2d_to_closest_1d(&self, pos: (uint, uint)) -> uint { + pub fn pos_2d_to_closest_1d(&self, pos: (usize, usize)) -> usize { return self.text.pos_2d_to_closest_1d_recursive(pos); } - pub fn pos_vis_2d_to_closest_1d(&self, pos: (uint, uint), tab_width: uint) -> uint { + pub fn pos_vis_2d_to_closest_1d(&self, pos: (usize, usize), tab_width: usize) -> usize { if pos.0 >= self.line_count() { return self.len(); } @@ -124,12 +124,12 @@ impl Buffer { } - pub fn pos_1d_to_closest_2d(&self, pos: uint) -> (uint, uint) { + pub fn pos_1d_to_closest_2d(&self, pos: usize) -> (usize, usize) { return self.text.pos_1d_to_closest_2d_recursive(pos); } - pub fn pos_1d_to_closest_vis_2d(&self, pos: uint, tab_width: uint) -> (uint, uint) { + pub fn pos_1d_to_closest_vis_2d(&self, pos: usize, tab_width: usize) -> (usize, usize) { let (v, h) = self.text.pos_1d_to_closest_2d_recursive(pos); let vis_h = self.get_line(v).grapheme_index_to_closest_vis_pos(h, tab_width); return (v, vis_h); @@ -137,13 +137,13 @@ impl Buffer { /// Insert 'text' at grapheme position 'pos'. - pub fn insert_text(&mut self, text: &str, pos: uint) { + pub fn insert_text(&mut self, text: &str, pos: usize) { self.text.insert_text(text, pos); } /// Remove the text between grapheme positions 'pos_a' and 'pos_b'. - pub fn remove_text(&mut self, pos_a: uint, pos_b: uint) { + pub fn remove_text(&mut self, pos_a: usize, pos_b: usize) { // Nothing to do if pos_a == pos_b { return; @@ -182,7 +182,7 @@ impl Buffer { /// Creates an iterator starting at the specified grapheme index. /// If the index is past the end of the text, then the iterator will /// return None on next(). - pub fn grapheme_iter_at_index<'a>(&'a self, index: uint) -> BufferGraphemeIter<'a> { + pub fn grapheme_iter_at_index<'a>(&'a self, index: usize) -> BufferGraphemeIter<'a> { BufferGraphemeIter { gi: self.text.grapheme_iter_at_index(index) } @@ -196,7 +196,7 @@ impl Buffer { } - pub fn line_iter_at_index<'a>(&'a self, index: uint) -> BufferLineIter<'a> { + pub fn line_iter_at_index<'a>(&'a self, index: usize) -> BufferLineIter<'a> { BufferLineIter { li: self.text.line_iter_at_index(index) } @@ -230,12 +230,12 @@ impl<'a> BufferGraphemeIter<'a> { // Skips the iterator n graphemes ahead. // If it runs out of graphemes before reaching the desired skip count, // returns false. Otherwise returns true. - pub fn skip_graphemes(&mut self, n: uint) -> bool { + pub fn skip_graphemes(&mut self, n: usize) -> bool { self.gi.skip_graphemes(n) } - pub fn skip_non_newline_graphemes(&mut self, n: uint) -> bool { - let mut i: uint = 0; + pub fn skip_non_newline_graphemes(&mut self, n: usize) -> bool { + let mut i: usize = 0; for g in self.gi { if is_line_ending(g) { diff --git a/src/buffer/node.rs b/src/buffer/node.rs index 7363ba0..44f61db 100644 --- a/src/buffer/node.rs +++ b/src/buffer/node.rs @@ -11,10 +11,10 @@ pub enum BufferNodeData { pub struct BufferNode { pub data: BufferNodeData, - pub tree_height: uint, + pub tree_height: usize, - pub grapheme_count: uint, - pub line_count: uint, + pub grapheme_count: usize, + pub line_count: usize, } impl BufferNode { @@ -129,10 +129,10 @@ impl BufferNode { /// Rebalances the tree under the node fn rebalance(&mut self) { loop { - let mut rot: int; + let mut rot: isize; if let BufferNodeData::Branch(ref mut left, ref mut right) = self.data { - let height_diff = (left.tree_height as int) - (right.tree_height as int); + let height_diff = (left.tree_height as isize) - (right.tree_height as isize); // Left side higher than right side if height_diff > 1 { @@ -184,7 +184,7 @@ impl BufferNode { } - pub fn get_grapheme_recursive<'a>(&'a self, index: uint) -> &'a str { + pub fn get_grapheme_recursive<'a>(&'a self, index: usize) -> &'a str { match self.data { BufferNodeData::Leaf(ref line) => { return line.grapheme_at_index(index); @@ -202,7 +202,7 @@ impl BufferNode { } - pub fn get_grapheme_width_recursive(&self, index: uint, tab_width: uint) -> uint { + pub fn get_grapheme_width_recursive(&self, index: usize, tab_width: usize) -> usize { match self.data { BufferNodeData::Leaf(ref line) => { return line.grapheme_width_at_index(index, tab_width); @@ -220,7 +220,7 @@ impl BufferNode { } - pub fn get_line_recursive<'a>(&'a self, index: uint) -> &'a Line { + pub fn get_line_recursive<'a>(&'a self, index: usize) -> &'a Line { match self.data { BufferNodeData::Leaf(ref line) => { if index != 0 { @@ -241,7 +241,7 @@ impl BufferNode { } - pub fn pos_2d_to_closest_1d_recursive(&self, pos: (uint, uint)) -> uint { + pub fn pos_2d_to_closest_1d_recursive(&self, pos: (usize, usize)) -> usize { match self.data { BufferNodeData::Leaf(ref line) => { if pos.0 != 0 { @@ -273,7 +273,7 @@ impl BufferNode { } - pub fn pos_1d_to_closest_2d_recursive(&self, pos: uint) -> (uint, uint) { + pub fn pos_1d_to_closest_2d_recursive(&self, pos: usize) -> (usize, usize) { match self.data { BufferNodeData::Leaf(_) => { return (0, min(pos, self.grapheme_count)); @@ -293,14 +293,14 @@ impl BufferNode { /// Insert 'text' at grapheme position 'pos'. - pub fn insert_text(&mut self, text: &str, pos: uint) { + pub fn insert_text(&mut self, text: &str, pos: usize) { // Byte indices - let mut b1: uint = 0; - let mut b2: uint = 0; + let mut b1: usize = 0; + let mut b2: usize = 0; // Grapheme indices - let mut g1: uint = 0; - let mut g2: uint = 0; + let mut g1: usize = 0; + let mut g2: usize = 0; // Iterate through graphemes for grapheme in text.grapheme_indices(true) { @@ -332,7 +332,7 @@ impl BufferNode { /// Inserts the given text string at the given grapheme position. /// Note: this assumes the given text has no newline graphemes. - pub fn insert_text_recursive(&mut self, text: &str, pos: uint) { + pub fn insert_text_recursive(&mut self, text: &str, pos: usize) { match self.data { // Find node for text to be inserted into BufferNodeData::Branch(ref mut left, ref mut right) => { @@ -356,7 +356,7 @@ impl BufferNode { /// Inserts a line break at the given grapheme position - pub fn insert_line_break_recursive(&mut self, ending: LineEnding, pos: uint) { + pub fn insert_line_break_recursive(&mut self, ending: LineEnding, pos: usize) { if ending == LineEnding::None { return; } @@ -387,8 +387,8 @@ impl BufferNode { if do_split { // Insert line break let new_line = old_line.split(ending, pos); - let new_node_a = box BufferNode::new_from_line(old_line); - let new_node_b = box BufferNode::new_from_line(new_line); + let new_node_a = Box::new(BufferNode::new_from_line(old_line)); + let new_node_b = Box::new(BufferNode::new_from_line(new_line)); self.data = BufferNodeData::Branch(new_node_a, new_node_b); @@ -404,12 +404,12 @@ impl BufferNode { /// Removes text between grapheme positions pos_a and pos_b. /// Returns true if a dangling left side remains from the removal. /// Returns false otherwise. - pub fn remove_text_recursive(&mut self, pos_a: uint, pos_b: uint, is_last: bool) -> bool { + pub fn remove_text_recursive(&mut self, pos_a: usize, pos_b: usize, is_last: bool) -> bool { let mut temp_node = BufferNode::new(); let mut total_side_removal = false; let mut dangling_line = false; let mut do_merge_fix = false; - let mut merge_line_number: uint = 0; + let mut merge_line_number: usize = 0; match self.data { BufferNodeData::Branch(ref mut left, ref mut right) => { @@ -509,8 +509,8 @@ impl BufferNode { mem::swap(this_line, &mut other_line); } - let new_node_a = box BufferNode::new_from_line(other_line); - let new_node_b = box BufferNode::new_from_line(line); + let new_node_a = Box::new(BufferNode::new_from_line(other_line)); + let new_node_b = Box::new(BufferNode::new_from_line(line)); self.data = BufferNodeData::Branch(new_node_a, new_node_b); } @@ -520,7 +520,7 @@ impl BufferNode { /// Removes lines in line number range [line_a, line_b) - pub fn remove_lines_recursive(&mut self, line_a: uint, line_b: uint) { + pub fn remove_lines_recursive(&mut self, line_a: usize, line_b: usize) { let mut remove_left = false; let mut remove_right = false; let mut temp_node = BufferNode::new(); @@ -573,7 +573,7 @@ impl BufferNode { } - pub fn merge_line_with_next_recursive(&mut self, line_number: uint, fetched_line: Option<&Line>) { + pub fn merge_line_with_next_recursive(&mut self, line_number: usize, fetched_line: Option<&Line>) { match fetched_line { None => { let line: Option = self.pull_out_line_recursive(line_number + 1); @@ -607,7 +607,7 @@ impl BufferNode { /// Removes a single line out of the text and returns it. - pub fn pull_out_line_recursive(&mut self, line_number: uint) -> Option { + pub fn pull_out_line_recursive(&mut self, line_number: usize) -> Option { let mut pulled_line = Line::new(); let mut temp_node = BufferNode::new(); let mut side_removal = false; @@ -702,7 +702,7 @@ impl BufferNode { /// Creates an iterator at the given grapheme index - pub fn grapheme_iter_at_index<'a>(&'a self, index: uint) -> BufferNodeGraphemeIter<'a> { + pub fn grapheme_iter_at_index<'a>(&'a self, index: usize) -> BufferNodeGraphemeIter<'a> { let mut node_stack: Vec<&'a BufferNode> = Vec::new(); let mut cur_node = self; let mut grapheme_i = index; @@ -763,7 +763,7 @@ impl BufferNode { /// Creates a line iterator starting at the given line index - pub fn line_iter_at_index<'a>(&'a self, index: uint) -> BufferNodeLineIter<'a> { + pub fn line_iter_at_index<'a>(&'a self, index: usize) -> BufferNodeLineIter<'a> { let mut node_stack: Vec<&'a BufferNode> = Vec::new(); let mut cur_node = self; let mut line_i = index; @@ -841,7 +841,7 @@ impl<'a> BufferNodeGraphemeIter<'a> { // Skips the iterator n graphemes ahead. // If it runs out of graphemes before reaching the desired skip count, // returns false. Otherwise returns true. - pub fn skip_graphemes(&mut self, n: uint) -> bool { + pub fn skip_graphemes(&mut self, n: usize) -> bool { // TODO: more efficient implementation for _ in range(0, n) { if let Option::None = self.next() { diff --git a/src/editor.rs b/src/editor.rs index 8fa7f02..0549719 100644 --- a/src/editor.rs +++ b/src/editor.rs @@ -14,8 +14,8 @@ use string_utils::grapheme_count; /// `vis_start` is the visual 2d horizontal position of the cursor. This /// doesn't affect editing operations at all, but is used for cursor movement. pub struct Cursor { - pub range: (uint, uint), // start, end - pub vis_start: uint, // start + pub range: (usize, usize), // start, end + pub vis_start: usize, // start } impl Cursor { @@ -26,7 +26,7 @@ impl Cursor { } } - pub fn update_vis_start(&mut self, buf: &Buffer, tab_width: uint) { + pub fn update_vis_start(&mut self, buf: &Buffer, tab_width: usize) { let (v, h) = buf.pos_1d_to_closest_2d(self.range.0); self.vis_start = buf.get_line(v).grapheme_index_to_closest_vis_pos(h, tab_width); } @@ -37,12 +37,12 @@ pub struct Editor { pub buffer: Buffer, pub file_path: Path, pub soft_tabs: bool, - pub tab_width: uint, + pub tab_width: usize, pub dirty: bool, // The dimensions and position of the editor's view within the buffer - pub view_dim: (uint, uint), // (height, width) - pub view_pos: (uint, uint), // (line, col) + pub view_dim: (usize, usize), // (height, width) + pub view_pos: (usize, usize), // (line, col) // The editing cursor position pub cursor: Cursor, @@ -91,14 +91,14 @@ impl Editor { } pub fn auto_detect_indentation_style(&mut self) { - let mut tab_blocks: uint = 0; - let mut space_blocks: uint = 0; - let mut space_histogram: [uint; 9] = [0, 0, 0, 0, 0, 0, 0, 0, 0]; + let mut tab_blocks: usize = 0; + let mut space_blocks: usize = 0; + let mut space_histogram: [usize; 9] = [0, 0, 0, 0, 0, 0, 0, 0, 0]; - let mut last_indent = (false, 0u); // (was_tabs, indent_count) + let mut last_indent = (false, 0us); // (was_tabs, indent_count) // Collect statistics - let mut line_i: uint = 0; + let mut line_i: usize = 0; for line in self.buffer.line_iter() { let mut g_iter = line.grapheme_iter(); match g_iter.next() { @@ -184,7 +184,7 @@ impl Editor { } } - pub fn update_dim(&mut self, h: uint, w: uint) { + pub fn update_dim(&mut self, h: usize, w: usize) { self.view_dim = (h, w); } @@ -257,13 +257,13 @@ impl Editor { self.remove_text_behind_cursor(1); } - pub fn insert_text_at_grapheme(&mut self, text: &str, pos: uint) { + pub fn insert_text_at_grapheme(&mut self, text: &str, pos: usize) { self.dirty = true; let buf_len = self.buffer.len(); self.buffer.insert_text(text, if pos < buf_len {pos} else {buf_len}); } - pub fn remove_text_behind_cursor(&mut self, grapheme_count: uint) { + pub fn remove_text_behind_cursor(&mut self, grapheme_count: usize) { let pos_b = self.cursor.range.0; let pos_a = if pos_b >= grapheme_count {pos_b - grapheme_count} else {0}; let tot_g = pos_b - pos_a; @@ -281,7 +281,7 @@ impl Editor { self.move_view_to_cursor(); } - pub fn remove_text_in_front_of_cursor(&mut self, grapheme_count: uint) { + pub fn remove_text_in_front_of_cursor(&mut self, grapheme_count: usize) { let pos_a = self.cursor.range.1; let pos_b = if (pos_a + grapheme_count) <= self.buffer.len() {pos_a + grapheme_count} else {self.buffer.len()}; @@ -328,7 +328,7 @@ impl Editor { self.move_view_to_cursor(); } - pub fn cursor_left(&mut self, n: uint) { + pub fn cursor_left(&mut self, n: usize) { if self.cursor.range.0 >= n { self.cursor.range.0 -= n; } @@ -343,7 +343,7 @@ impl Editor { self.move_view_to_cursor(); } - pub fn cursor_right(&mut self, n: uint) { + pub fn cursor_right(&mut self, n: usize) { if self.cursor.range.1 <= (self.buffer.len() - n) { self.cursor.range.1 += n; } @@ -358,7 +358,7 @@ impl Editor { self.move_view_to_cursor(); } - pub fn cursor_up(&mut self, n: uint) { + pub fn cursor_up(&mut self, n: usize) { let (v, _) = self.buffer.pos_1d_to_closest_vis_2d(self.cursor.range.0, self.tab_width); if v >= n { @@ -373,7 +373,7 @@ impl Editor { self.move_view_to_cursor(); } - pub fn cursor_down(&mut self, n: uint) { + pub fn cursor_down(&mut self, n: usize) { let (v, _) = self.buffer.pos_1d_to_closest_vis_2d(self.cursor.range.0, self.tab_width); if v < (self.buffer.line_count() - n) { @@ -433,7 +433,7 @@ impl Editor { self.move_view_to_cursor(); } - pub fn jump_to_line(&mut self, n: uint) { + pub fn jump_to_line(&mut self, n: usize) { let pos = self.buffer.pos_2d_to_closest_1d((n, 0)); let (v, _) = self.buffer.pos_1d_to_closest_vis_2d(pos, self.tab_width); self.cursor.range.0 = self.buffer.pos_vis_2d_to_closest_1d((v, self.cursor.vis_start), self.tab_width); diff --git a/src/main.rs b/src/main.rs index 52bde6c..0f497c7 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,5 @@ #![feature(old_orphan_check)] // Temporary, get rid of this once the new orphan check works well -#![feature(associated_types)] +#![allow(unstable)] extern crate rustbox; extern crate docopt; diff --git a/src/string_utils.rs b/src/string_utils.rs index 8a631da..0ace7f8 100644 --- a/src/string_utils.rs +++ b/src/string_utils.rs @@ -16,7 +16,7 @@ pub fn is_line_ending(text: &str) -> bool { } } -pub fn newline_count(text: &str) -> uint { +pub fn newline_count(text: &str) -> usize { let mut count = 0; for c in text.chars() { if c == '\n' { @@ -26,7 +26,7 @@ pub fn newline_count(text: &str) -> uint { return count; } -pub fn char_count(text: &str) -> uint { +pub fn char_count(text: &str) -> usize { let mut count = 0; for _ in text.chars() { count += 1; @@ -34,7 +34,7 @@ pub fn char_count(text: &str) -> uint { return count; } -pub fn grapheme_count(text: &str) -> uint { +pub fn grapheme_count(text: &str) -> usize { let mut count = 0; for _ in text.graphemes(true) { count += 1; @@ -42,7 +42,7 @@ pub fn grapheme_count(text: &str) -> uint { return count; } -pub fn char_and_newline_count(text: &str) -> (uint, uint) { +pub fn char_and_newline_count(text: &str) -> (usize, usize) { let mut char_count = 0; let mut newline_count = 0; @@ -56,8 +56,8 @@ pub fn char_and_newline_count(text: &str) -> (uint, uint) { return (char_count, newline_count); } -pub fn char_pos_to_byte_pos(text: &str, pos: uint) -> uint { - let mut i: uint = 0; +pub fn char_pos_to_byte_pos(text: &str, pos: usize) -> usize { + let mut i: usize = 0; for (offset, _) in text.char_indices() { if i == pos { @@ -73,8 +73,8 @@ pub fn char_pos_to_byte_pos(text: &str, pos: uint) -> uint { panic!("char_pos_to_byte_pos(): char position off the end of the string."); } -pub fn grapheme_pos_to_byte_pos(text: &str, pos: uint) -> uint { - let mut i: uint = 0; +pub fn grapheme_pos_to_byte_pos(text: &str, pos: usize) -> usize { + let mut i: usize = 0; for (offset, _) in text.grapheme_indices(true) { if i == pos { diff --git a/src/term_ui.rs b/src/term_ui.rs index ac68a45..7b29015 100644 --- a/src/term_ui.rs +++ b/src/term_ui.rs @@ -30,8 +30,8 @@ const K_CTRL_S: u16 = 19; pub struct TermUI { rb: rustbox::RustBox, editor: Editor, - width: uint, - height: uint, + width: usize, + height: usize, } @@ -159,8 +159,8 @@ impl TermUI { }, Ok(rustbox::Event::ResizeEvent(w, h)) => { - self.width = w as uint; - self.height = h as uint; + self.width = w as usize; + self.height = h as usize; self.editor.update_dim(self.height-1, self.width); }, @@ -239,8 +239,8 @@ impl TermUI { }, Ok(rustbox::Event::ResizeEvent(w, h)) => { - self.width = w as uint; - self.height = h as uint; + self.width = w as usize; + self.height = h as usize; self.editor.update_dim(self.height-1, self.width); }, @@ -261,7 +261,7 @@ impl TermUI { // Jump to line! if confirm { if let Some(n) = line.parse() { - let n2: uint = n; // Weird work-around: the type of n wasn't being inferred + let n2: usize = n; // Weird work-around: the type of n wasn't being inferred if n2 > 0 { self.editor.jump_to_line(n2-1); } @@ -275,7 +275,7 @@ impl TermUI { } - fn draw_editor(&self, editor: &Editor, c1: (uint, uint), c2: (uint, uint)) { + fn draw_editor(&self, editor: &Editor, c1: (usize, usize), c2: (usize, usize)) { let foreground = Color::Black; let background = Color::Cyan; @@ -291,8 +291,8 @@ impl TermUI { self.rb.print(c1.1 + 1, c1.0, rustbox::RB_NORMAL, foreground, background, name.as_slice()); // Percentage position in document - let percentage: uint = if editor.buffer.len() > 0 { - (((editor.cursor.range.0 as f32) / (editor.buffer.len() as f32)) * 100.0) as uint + let percentage: usize = if editor.buffer.len() > 0 { + (((editor.cursor.range.0 as f32) / (editor.buffer.len() as f32)) * 100.0) as usize } else { 100 @@ -321,7 +321,7 @@ impl TermUI { } - fn draw_editor_text(&self, editor: &Editor, c1: (uint, uint), c2: (uint, uint)) { + fn draw_editor_text(&self, editor: &Editor, c1: (usize, usize), c2: (usize, usize)) { let mut line_iter = editor.buffer.line_iter_at_index(editor.view_pos.0); let mut grapheme_index;