1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use super::MAX_LINE_LEN;
use crate::error;
use crate::lang::{Column, Error, Line, LineNumber, MaxValue};
use std::collections::{btree_map::Values, BTreeMap};
use std::ops::{Range, RangeInclusive};
use std::sync::Arc;

#[derive(Debug, Clone, Default)]
pub struct Listing {
    source: Arc<BTreeMap<LineNumber, Line>>,
    pub indirect_errors: Arc<Vec<Error>>,
    pub direct_errors: Arc<Vec<Error>>,
}

impl Listing {
    pub fn clear(&mut self) {
        self.source = Arc::default();
        self.indirect_errors = Arc::default();
        self.direct_errors = Arc::default();
    }

    pub fn is_empty(&self) -> bool {
        self.source.is_empty()
    }

    pub fn insert(&mut self, line: Line) -> Option<Line> {
        Arc::get_mut(&mut self.source)
            .unwrap()
            .insert(line.number(), line)
    }

    pub fn remove(&mut self, ln: LineNumber) -> Option<Line> {
        Arc::get_mut(&mut self.source).unwrap().remove(&ln)
    }

    pub fn remove_range(&mut self, range: RangeInclusive<LineNumber>) -> bool {
        let to_remove = self
            .source
            .range(range)
            .map(|(k, _)| *k)
            .collect::<Vec<LineNumber>>();
        if to_remove.is_empty() {
            return false;
        }
        let source = Arc::get_mut(&mut self.source).unwrap();
        for line_number in to_remove {
            source.remove(&line_number);
        }
        true
    }

    pub fn line(&self, num: usize) -> Option<(String, Vec<Range<usize>>)> {
        if num > LineNumber::max_value() as usize {
            return None;
        }
        let mut range = Some(num as u16)..=Some(num as u16);
        self.list_line(&mut range)
    }

    pub fn lines(&self) -> Values<'_, LineNumber, Line> {
        self.source.values()
    }

    /// Used for loading a new Listing from a file.
    pub fn load_str(&mut self, line: &str) -> Result<(), Error> {
        if line.len() > MAX_LINE_LEN {
            return Err(error!(LineBufferOverflow));
        }
        let line = Line::new(line);
        if line.is_empty() {
            if !line.is_direct() {
                Arc::get_mut(&mut self.source)
                    .unwrap()
                    .remove(&line.number());
            }
            Ok(())
        } else if line.is_direct() {
            Err(error!(DirectStatementInFile))
        } else {
            self.insert(line);
            Ok(())
        }
    }

    pub fn list_line(
        &self,
        range: &mut RangeInclusive<LineNumber>,
    ) -> Option<(String, Vec<Range<usize>>)> {
        let mut source_range = self.source.range(range.clone());
        if let Some((line_number, line)) = source_range.next() {
            if line_number < range.end() {
                if let Some(num) = line_number {
                    *range = Some(num + 1)..=*range.end();
                }
            } else {
                *range = Some(LineNumber::max_value() + 1)..=Some(LineNumber::max_value() + 1);
            }
            let columns: Vec<Column> = self
                .indirect_errors
                .iter()
                .filter_map(|e| {
                    if e.line_number() == *line_number {
                        Some(e.column())
                    } else {
                        None
                    }
                })
                .collect();
            return Some((line.to_string(), columns));
        }
        None
    }
}