pintos-os.org Git - pspp/blob - rust/src/cooked.rs

   1 use std::{
   2     borrow::Cow, cell::RefCell, cmp::Ordering, collections::HashMap, iter::repeat, ops::Range,
   3     rc::Rc,
   4 };
   5
   6 use crate::{
   7     encoding::{default_encoding, get_encoding, Error as EncodingError},
   8     endian::Endian,
   9     format::{Error as FormatError, Spec, UncheckedSpec},
  10     identifier::{Error as IdError, Identifier},
  11     raw::{self, RawDocumentLine, RawStr, RawString, VarDisplayRecord, VarType, ProductInfoRecord},
  12 };
  13 use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
  14 use encoding_rs::{DecoderResult, Encoding};
  15 use num::integer::div_ceil;
  16 use ordered_float::OrderedFloat;
  17 use thiserror::Error as ThisError;
  18
  19 pub use crate::raw::{CategoryLabels, Compression};
  20
  21 #[derive(ThisError, Debug)]
  22 pub enum Error {
  23     // XXX this is really an internal error and maybe we should change the
  24     // interfaces to make it impossible
  25     #[error("Missing header record")]
  26     MissingHeaderRecord,
  27
  28     #[error("{0}")]
  29     EncodingError(EncodingError),
  30
  31     #[error("Using default encoding {0}.")]
  32     UsingDefaultEncoding(String),
  33
  34     #[error("Variable record from offset {:x} to {:x} specifies width {width} not in valid range [-1,255).", offsets.start, offsets.end)]
  35     InvalidVariableWidth { offsets: Range<u64>, width: i32 },
  36
  37     #[error("This file has corrupted metadata written by a buggy version of PSPP.  To ensure that other software can read it correctly, save a new copy of the file.")]
  38     InvalidLongMissingValueFormat,
  39
  40     #[error("File creation date {creation_date} is not in the expected format \"DD MMM YY\" format.  Using 01 Jan 1970.")]
  41     InvalidCreationDate { creation_date: String },
  42
  43     #[error("File creation time {creation_time} is not in the expected format \"HH:MM:SS\" format.  Using midnight.")]
  44     InvalidCreationTime { creation_time: String },
  45
  46     #[error("{id_error}  Renaming variable to {new_name}.")]
  47     InvalidVariableName {
  48         id_error: IdError,
  49         new_name: Identifier,
  50     },
  51
  52     #[error(
  53         "Substituting {new_spec} for invalid print format on variable {variable}.  {format_error}"
  54     )]
  55     InvalidPrintFormat {
  56         new_spec: Spec,
  57         variable: Identifier,
  58         format_error: FormatError,
  59     },
  60
  61     #[error(
  62         "Substituting {new_spec} for invalid write format on variable {variable}.  {format_error}"
  63     )]
  64     InvalidWriteFormat {
  65         new_spec: Spec,
  66         variable: Identifier,
  67         format_error: FormatError,
  68     },
  69
  70     #[error("Renaming variable with duplicate name {duplicate_name} to {new_name}.")]
  71     DuplicateVariableName {
  72         duplicate_name: Identifier,
  73         new_name: Identifier,
  74     },
  75
  76     #[error("Dictionary index {dict_index} is outside valid range [1,{max_index}].")]
  77     InvalidDictIndex { dict_index: usize, max_index: usize },
  78
  79     #[error("Dictionary index {0} refers to a long string continuation.")]
  80     DictIndexIsContinuation(usize),
  81
  82     #[error("Variables associated with value label are not all of identical type.  Variable {numeric_var} is numeric, but variable {string_var} is string.")]
  83     ValueLabelsDifferentTypes {
  84         numeric_var: Identifier,
  85         string_var: Identifier,
  86     },
  87
  88     #[error(
  89         "Value labels may not be added to long string variable {0} using record types 3 or 4."
  90     )]
  91     InvalidLongStringValueLabel(Identifier),
  92
  93     #[error("Invalid multiple response set name.  {0}")]
  94     InvalidMrSetName(IdError),
  95
  96     #[error("Multiple response set {mr_set} includes unknown variable {short_name}.")]
  97     UnknownMrSetVariable {
  98         mr_set: Identifier,
  99         short_name: Identifier,
 100     },
 101
 102     #[error("Multiple response set {0} has no variables.")]
 103     EmptyMrSet(Identifier),
 104
 105     #[error("Multiple response set {0} has only one variable.")]
 106     OneVarMrSet(Identifier),
 107
 108     #[error("Multiple response set {0} contains both string and numeric variables.")]
 109     MixedMrSet(Identifier),
 110
 111     #[error(
 112         "Invalid numeric format for counted value {number} in multiple response set {mr_set}."
 113     )]
 114     InvalidMDGroupCountedValue { mr_set: Identifier, number: String },
 115
 116     #[error("Counted value {value} has width {width}, but it must be no wider than {max_width}, the width of the narrowest variable in multiple response set {mr_set}.")]
 117     TooWideMDGroupCountedValue {
 118         mr_set: Identifier,
 119         value: String,
 120         width: usize,
 121         max_width: u16,
 122     },
 123
 124     #[error("Long string value label for variable {name} has width {width}, which is not in the valid range [{min_width},{max_width}].")]
 125     InvalidLongValueLabelWidth {
 126         name: Identifier,
 127         width: u32,
 128         min_width: u16,
 129         max_width: u16,
 130     },
 131
 132     #[error("Invalid attribute name.  {0}")]
 133     InvalidAttributeName(IdError),
 134
 135     #[error("Invalid short name in long variable name record.  {0}")]
 136     InvalidShortName(IdError),
 137
 138     #[error("Invalid name in long variable name record.  {0}")]
 139     InvalidLongName(IdError),
 140
 141     #[error("Invalid variable name in very long string record.  {0}")]
 142     InvalidLongStringName(IdError),
 143
 144     #[error("Invalid variable name in long string value label record.  {0}")]
 145     InvalidLongStringValueLabelName(IdError),
 146
 147     #[error("Invalid variable name in attribute record.  {0}")]
 148     InvalidAttributeVariableName(IdError),
 149
 150     // XXX This is risky because `text` might be arbitarily long.
 151     #[error("Text string contains invalid bytes for {encoding} encoding: {text}")]
 152     MalformedString { encoding: String, text: String },
 153
 154     #[error("Details TBD")]
 155     TBD,
 156 }
 157
 158 #[derive(Clone, Debug)]
 159 pub enum Record {
 160     Header(HeaderRecord),
 161     Variable(VariableRecord),
 162     ValueLabel(ValueLabelRecord),
 163     Document(DocumentRecord),
 164     IntegerInfo(IntegerInfoRecord),
 165     FloatInfo(FloatInfoRecord),
 166     VariableSets(VariableSetRecord),
 167     VarDisplay(VarDisplayRecord),
 168     MultipleResponse(MultipleResponseRecord),
 169     LongStringMissingValues(LongStringMissingValuesRecord),
 170     LongStringValueLabels(LongStringValueLabelRecord),
 171     Encoding(EncodingRecord),
 172     NumberOfCases(NumberOfCasesRecord),
 173     ProductInfo(ProductInfoRecord),
 174     LongNames(LongNameRecord),
 175     VeryLongStrings(VeryLongStringRecord),
 176     FileAttributes(FileAttributeRecord),
 177     VariableAttributes(VariableAttributeRecord),
 178     OtherExtension(Extension),
 179     //Case(Vec<Value>),
 180 }
 181
 182 pub use crate::raw::EncodingRecord;
 183 pub use crate::raw::Extension;
 184 pub use crate::raw::FloatInfoRecord;
 185 pub use crate::raw::IntegerInfoRecord;
 186 pub use crate::raw::NumberOfCasesRecord;
 187
 188 type DictIndex = usize;
 189
 190 pub struct Variable {
 191     pub dict_index: DictIndex,
 192     pub short_name: Identifier,
 193     pub long_name: Option<Identifier>,
 194     pub width: VarWidth,
 195 }
 196
 197 pub struct Decoder {
 198     pub compression: Option<Compression>,
 199     pub endian: Endian,
 200     pub encoding: &'static Encoding,
 201     pub variables: HashMap<DictIndex, Variable>,
 202     pub var_names: HashMap<Identifier, DictIndex>,
 203     n_dict_indexes: usize,
 204     n_generated_names: usize,
 205 }
 206
 207 #[derive(Default)]
 208 struct Headers<'a> {
 209     header: Option<&'a raw::HeaderRecord<RawString>>,
 210     variables: Vec<&'a raw::VariableRecord<RawString, RawStr<8>>>,
 211     value_labels: Vec<&'a raw::ValueLabelRecord<RawStr<8>, RawString>>,
 212     document: Option<&'a raw::DocumentRecord<RawDocumentLine>>,
 213     integer_info: Option<&'a raw::IntegerInfoRecord>,
 214     float_info: Option<&'a raw::FloatInfoRecord>,
 215     variable_sets: Vec<&'a raw::VariableSetRecord>,
 216     var_display: Option<&'a raw::VarDisplayRecord>,
 217     multiple_response: Vec<&'a raw::MultipleResponseRecord<RawString>>,
 218     long_string_value_labels: Vec<&'a raw::LongStringValueLabelRecord<RawString>>,
 219     long_string_missing_values: Vec<&'a raw::LongStringMissingValueRecord<RawString, RawStr<8>>>,
 220     encoding: Option<&'a raw::EncodingRecord>,
 221     number_of_cases: Option<&'a raw::NumberOfCasesRecord>,
 222     product_info: Option<&'a raw::ProductInfoRecord>,
 223     long_names: Option<&'a raw::LongNamesRecord>,
 224     very_long_strings: Vec<&'a raw::VeryLongStringsRecord>,
 225     file_attributes: Vec<&'a raw::FileAttributeRecord>,
 226     variable_attributes: Vec<&'a raw::VariableAttributeRecord>,
 227     other_extensions: Vec<&'a raw::Extension>,
 228     cases: Option<&'a Rc<RefCell<raw::Cases>>>,
 229 }
 230
 231 fn set_or_warn<T>(option: &mut Option<T>, value: T, warn: &impl Fn(Error)) {
 232     if option.is_none() {
 233         let _ = option.insert(value);
 234     } else {
 235         warn(Error::TBD);
 236     }
 237 }
 238
 239 impl<'a> Headers<'a> {
 240     fn new(headers: &'a Vec<raw::Record>, warn: &impl Fn(Error)) -> Headers<'a> {
 241         let mut h = Headers::default();
 242         for header in headers {
 243             match header {
 244                 raw::Record::Header(record) => set_or_warn(&mut h.header, record, warn),
 245                 raw::Record::Variable(record) => h.variables.push(record),
 246                 raw::Record::ValueLabel(record) => h.value_labels.push(record),
 247                 raw::Record::Document(record) => set_or_warn(&mut h.document, record, warn),
 248                 raw::Record::IntegerInfo(record) => set_or_warn(&mut h.integer_info, record, warn),
 249                 raw::Record::FloatInfo(record) => set_or_warn(&mut h.float_info, record, warn),
 250                 raw::Record::VariableSets(record) => h.variable_sets.push(record),
 251                 raw::Record::VarDisplay(record) => set_or_warn(&mut h.var_display, record, warn),
 252                 raw::Record::MultipleResponse(record) => h.multiple_response.push(record),
 253                 raw::Record::LongStringValueLabels(record) => {
 254                     h.long_string_value_labels.push(record)
 255                 }
 256                 raw::Record::LongStringMissingValues(record) => {
 257                     h.long_string_missing_values.push(record)
 258                 }
 259                 raw::Record::Encoding(record) => set_or_warn(&mut h.encoding, record, warn),
 260                 raw::Record::NumberOfCases(record) => {
 261                     set_or_warn(&mut h.number_of_cases, record, warn)
 262                 }
 263                 raw::Record::ProductInfo(record) => set_or_warn(&mut h.product_info, record, warn),
 264                 raw::Record::LongNames(record) => set_or_warn(&mut h.long_names, record, warn),
 265                 raw::Record::VeryLongStrings(record) => h.very_long_strings.push(record),
 266                 raw::Record::FileAttributes(record) => h.file_attributes.push(record),
 267                 raw::Record::VariableAttributes(record) => h.variable_attributes.push(record),
 268                 raw::Record::OtherExtension(record) => h.other_extensions.push(record),
 269                 raw::Record::EndOfHeaders(_) => (),
 270                 raw::Record::ZHeader(_) => (),
 271                 raw::Record::ZTrailer(_) => (),
 272                 raw::Record::Cases(record) => set_or_warn(&mut h.cases, record, warn),
 273                 raw::Record::Text(_) => todo!(),
 274
 275             }
 276         }
 277         h
 278     }
 279 }
 280
 281 pub fn decode(
 282     headers: Vec<raw::Record>,
 283     encoding: Option<&'static Encoding>,
 284     warn: &impl Fn(Error),
 285 ) -> Result<Vec<Record>, Error> {
 286     let h = Headers::new(&headers, warn);
 287     let Some(header) = h.header else {
 288         return Err(Error::MissingHeaderRecord);
 289     };
 290     let encoding = match encoding {
 291         Some(encoding) => encoding,
 292         None => {
 293             let encoding = h.encoding.map(|record| record.0.as_str());
 294             let character_code = h.integer_info.map(|record| record.character_code);
 295             match get_encoding(encoding, character_code) {
 296                 Ok(encoding) => encoding,
 297                 Err(err @ EncodingError::Ebcdic) => return Err(Error::EncodingError(err)),
 298                 Err(err) => {
 299                     warn(Error::EncodingError(err));
 300                     // Warn that we're using the default encoding.
 301                     default_encoding()
 302                 }
 303             }
 304         }
 305     };
 306
 307     //let mut dictionary = Dictionary::new(encoding);
 308
 309     let mut decoder = Decoder {
 310         compression: header.compression,
 311         endian: header.endian,
 312         encoding,
 313         variables: HashMap::new(),
 314         var_names: HashMap::new(),
 315         n_dict_indexes: 0,
 316         n_generated_names: 0,
 317     };
 318
 319     let mut output = Vec::with_capacity(headers.len());
 320
 321     // Decode the records that don't use variables at all.
 322     if let Some(header) = HeaderRecord::try_decode(&mut decoder, header, warn)? {
 323         output.push(Record::Header(header))
 324     }
 325     if let Some(raw) = h.document {
 326         if let Some(document) = DocumentRecord::try_decode(&mut decoder, raw, warn)? {
 327             output.push(Record::Document(document))
 328         }
 329     }
 330     if let Some(raw) = h.integer_info {
 331         output.push(Record::IntegerInfo(raw.clone()));
 332     }
 333     if let Some(raw) = h.float_info {
 334         output.push(Record::FloatInfo(raw.clone()));
 335     }
 336     if let Some(raw) = h.product_info {
 337         output.push(Record::ProductInfo(raw.clone()));
 338     }
 339     if let Some(raw) = h.number_of_cases {
 340         output.push(Record::NumberOfCases(raw.clone()))
 341     }
 342 /*
 343     for &raw in &h.file_attributes {
 344         let s = decoder.decode_string_cow(&raw.text.0, warn);
 345         output.push(Record::FileAttributes(FileAttributeRecord::parse(
 346             &decoder, &s, warn,
 347         )?));
 348     }
 349     for &raw in &h.other_extensions {
 350         output.push(Record::OtherExtension(raw.clone()));
 351     }
 352     // Decode the variable records, which are the basis of almost everything
 353     // else.
 354     for &raw in &h.variables {
 355         if let Some(variable) = VariableRecord::try_decode(&mut decoder, raw, warn)? {
 356             output.push(Record::Variable(variable));
 357         }
 358     }
 359
 360     // Decode value labels and weight variable.  These use indexes into the
 361     // variable records, so we need to parse them before those indexes become
 362     // invalidated by very long string variables.
 363     for &raw in &h.value_labels {
 364         if let Some(value_label) = ValueLabelRecord::try_decode(&mut decoder, raw, warn)? {
 365             output.push(Record::ValueLabel(value_label));
 366         }
 367     }
 368     // XXX weight
 369     if let Some(raw) = h.var_display {
 370         output.push(Record::VarDisplay(raw.clone()));
 371     }
 372
 373     // Decode records that use short names.
 374         for &raw in &h.multiple_response {
 375             if let Some(mrr) = MultipleResponseRecord::try_decode(&mut decoder, raw, warn)? {
 376                 output.push(Record::MultipleResponse(mrr))
 377             }
 378         }
 379     for &raw in &h.very_long_strings {
 380         let s = decoder.decode_string_cow(&raw.text.0, warn);
 381         output.push(Record::VeryLongStrings(VeryLongStringRecord::parse(
 382             &decoder, &s, warn,
 383         )?));
 384     }
 385
 386     // Rename variables to their long names.
 387     for &raw in &h.long_names {
 388         let s = decoder.decode_string_cow(&raw.text.0, warn);
 389         output.push(Record::LongNames(LongNameRecord::parse(
 390             &mut decoder,
 391             &s,
 392             warn,
 393         )?));
 394     }
 395
 396     // Decode recods that use long names.
 397     for &raw in &h.variable_attributes {
 398         let s = decoder.decode_string_cow(&raw.text.0, warn);
 399         output.push(Record::VariableAttributes(VariableAttributeRecord::parse(
 400             &decoder, &s, warn,
 401         )?));
 402     }
 403     for &raw in &h.long_string_value_labels {
 404         if let Some(mrr) = LongStringValueLabelRecord::try_decode(&mut decoder, raw, warn)? {
 405             output.push(Record::LongStringValueLabels(mrr))
 406         }
 407     }
 408     for &raw in &h.long_string_missing_values {
 409         if let Some(mrr) = LongStringMissingValuesRecord::try_decode(&mut decoder, raw, warn)? {
 410             output.push(Record::LongStringMissingValues(mrr))
 411         }
 412     }
 413     for &raw in &h.variable_sets {
 414         let s = decoder.decode_string_cow(&raw.text.0, warn);
 415         output.push(Record::VariableSets(VariableSetRecord::parse(&s, warn)?));
 416     }
 417 */
 418     Ok(output)
 419 }
 420
 421 impl Decoder {
 422     fn generate_name(&mut self) -> Identifier {
 423         loop {
 424             self.n_generated_names += 1;
 425             let name = Identifier::new(&format!("VAR{:03}", self.n_generated_names), self.encoding)
 426                 .unwrap();
 427             if !self.var_names.contains_key(&name) {
 428                 return name;
 429             }
 430             assert!(self.n_generated_names < usize::MAX);
 431         }
 432     }
 433     fn decode_string_cow<'a>(&self, input: &'a [u8], warn: &impl Fn(Error)) -> Cow<'a, str> {
 434         let (output, malformed) = self.encoding.decode_without_bom_handling(input);
 435         if malformed {
 436             warn(Error::MalformedString {
 437                 encoding: self.encoding.name().into(),
 438                 text: output.clone().into(),
 439             });
 440         }
 441         output
 442     }
 443     fn decode_string(&self, input: &[u8], warn: &impl Fn(Error)) -> String {
 444         self.decode_string_cow(input, warn).into()
 445     }
 446     pub fn decode_identifier(
 447         &self,
 448         input: &[u8],
 449         warn: &impl Fn(Error),
 450     ) -> Result<Identifier, IdError> {
 451         let s = self.decode_string_cow(input, warn);
 452         Identifier::new(&s, self.encoding)
 453     }
 454     fn get_var_by_index(&self, dict_index: usize) -> Result<&Variable, Error> {
 455         let max_index = self.n_dict_indexes;
 456         if dict_index == 0 || dict_index > max_index {
 457             return Err(Error::InvalidDictIndex {
 458                 dict_index,
 459                 max_index,
 460             });
 461         }
 462         let Some(variable) = self.variables.get(&(dict_index - 1)) else {
 463             return Err(Error::DictIndexIsContinuation(dict_index));
 464         };
 465         Ok(variable)
 466     }
 467
 468     /// Returns `input` decoded from `self.encoding` into UTF-8 such that
 469     /// re-encoding the result back into `self.encoding` will have exactly the
 470     /// same length in bytes.
 471     ///
 472     /// XXX warn about errors?
 473     fn decode_exact_length<'a>(&self, input: &'a [u8]) -> Cow<'a, str> {
 474         if let (s, false) = self.encoding.decode_without_bom_handling(input) {
 475             // This is the common case.  Usually there will be no errors.
 476             s
 477         } else {
 478             // Unusual case.  Don't bother to optimize it much.
 479             let mut decoder = self.encoding.new_decoder_without_bom_handling();
 480             let mut output = String::with_capacity(
 481                 decoder
 482                     .max_utf8_buffer_length_without_replacement(input.len())
 483                     .unwrap(),
 484             );
 485             let mut rest = input;
 486             while !rest.is_empty() {
 487                 match decoder.decode_to_string_without_replacement(rest, &mut output, true) {
 488                     (DecoderResult::InputEmpty, _) => break,
 489                     (DecoderResult::OutputFull, _) => unreachable!(),
 490                     (DecoderResult::Malformed(a, b), consumed) => {
 491                         let skipped = a as usize + b as usize;
 492                         output.extend(repeat('?').take(skipped));
 493                         rest = &rest[consumed..];
 494                     }
 495                 }
 496             }
 497             assert_eq!(self.encoding.encode(&output).0.len(), input.len());
 498             output.into()
 499         }
 500     }
 501 }
 502
 503 pub trait TryDecode: Sized {
 504     type Input<'a>;
 505     fn try_decode(
 506         decoder: &mut Decoder,
 507         input: &Self::Input<'_>,
 508         warn: impl Fn(Error),
 509     ) -> Result<Option<Self>, Error>;
 510 }
 511
 512 pub trait Decode<Input>: Sized {
 513     fn decode(decoder: &Decoder, input: &Input, warn: impl Fn(Error)) -> Self;
 514 }
 515
 516 impl<const N: usize> Decode<RawStr<N>> for String {
 517     fn decode(decoder: &Decoder, input: &RawStr<N>, warn: impl Fn(Error)) -> Self {
 518         decoder.decode_string(&input.0, &warn)
 519     }
 520 }
 521
 522 #[derive(Clone, Debug)]
 523 pub struct HeaderRecord {
 524     pub eye_catcher: String,
 525     pub weight_index: Option<usize>,
 526     pub n_cases: Option<u64>,
 527     pub creation: NaiveDateTime,
 528     pub file_label: String,
 529 }
 530
 531 fn trim_end_spaces(mut s: String) -> String {
 532     s.truncate(s.trim_end_matches(' ').len());
 533     s
 534 }
 535
 536 impl TryDecode for HeaderRecord {
 537     type Input<'a> = crate::raw::HeaderRecord<RawString>;
 538
 539     fn try_decode(
 540         decoder: &mut Decoder,
 541         input: &Self::Input<'_>,
 542         warn: impl Fn(Error),
 543     ) -> Result<Option<Self>, Error> {
 544         let eye_catcher = trim_end_spaces(decoder.decode_string(&input.eye_catcher.0, &warn));
 545         let file_label = trim_end_spaces(decoder.decode_string(&input.file_label.0, &warn));
 546         let creation_date = decoder.decode_string_cow(&input.creation_date.0, &warn);
 547         let creation_date =
 548             NaiveDate::parse_from_str(&creation_date, "%e %b %Y").unwrap_or_else(|_| {
 549                 warn(Error::InvalidCreationDate {
 550                     creation_date: creation_date.into(),
 551                 });
 552                 Default::default()
 553             });
 554         let creation_time = decoder.decode_string_cow(&input.creation_time.0, &warn);
 555         let creation_time =
 556             NaiveTime::parse_from_str(&creation_time, "%H:%M:%S").unwrap_or_else(|_| {
 557                 warn(Error::InvalidCreationTime {
 558                     creation_time: creation_time.into(),
 559                 });
 560                 Default::default()
 561             });
 562         Ok(Some(HeaderRecord {
 563             eye_catcher,
 564             weight_index: input.weight_index.map(|n| n as usize),
 565             n_cases: input.n_cases.map(|n| n as u64),
 566             creation: NaiveDateTime::new(creation_date, creation_time),
 567             file_label,
 568         }))
 569     }
 570 }
 571
 572 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 573 pub enum VarWidth {
 574     Numeric,
 575     String(u16),
 576 }
 577
 578 impl PartialOrd for VarWidth {
 579     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
 580         match (self, other) {
 581             (VarWidth::Numeric, VarWidth::Numeric) => Some(Ordering::Equal),
 582             (VarWidth::String(a), VarWidth::String(b)) => Some(a.cmp(b)),
 583             _ => None,
 584         }
 585     }
 586 }
 587
 588 impl VarWidth {
 589     const MAX_STRING: u16 = 32767;
 590
 591     fn n_dict_indexes(self) -> usize {
 592         match self {
 593             VarWidth::Numeric => 1,
 594             VarWidth::String(w) => div_ceil(w as usize, 8),
 595         }
 596     }
 597
 598     fn width_predicate(
 599         a: Option<VarWidth>,
 600         b: Option<VarWidth>,
 601         f: impl Fn(u16, u16) -> u16,
 602     ) -> Option<VarWidth> {
 603         match (a, b) {
 604             (Some(VarWidth::Numeric), Some(VarWidth::Numeric)) => Some(VarWidth::Numeric),
 605             (Some(VarWidth::String(a)), Some(VarWidth::String(b))) => {
 606                 Some(VarWidth::String(f(a, b)))
 607             }
 608             _ => None,
 609         }
 610     }
 611
 612     /// Returns the wider of `self` and `other`:
 613     /// - Numerical variable widths are equally wide.
 614     /// - Longer strings are wider than shorter strings.
 615     /// - Numerical and string types are incomparable, so result in `None`.
 616     /// - Any `None` in the input yields `None` in the output.
 617     pub fn wider(a: Option<VarWidth>, b: Option<VarWidth>) -> Option<VarWidth> {
 618         Self::width_predicate(a, b, |a, b| a.max(b))
 619     }
 620
 621     /// Returns the narrower of `self` and `other` (see [`Self::wider`]).
 622     pub fn narrower(a: Option<VarWidth>, b: Option<VarWidth>) -> Option<VarWidth> {
 623         Self::width_predicate(a, b, |a, b| a.min(b))
 624     }
 625 }
 626
 627 impl From<VarWidth> for VarType {
 628     fn from(source: VarWidth) -> Self {
 629         match source {
 630             VarWidth::Numeric => VarType::Numeric,
 631             VarWidth::String(_) => VarType::String,
 632         }
 633     }
 634 }
 635
 636 #[derive(Clone, Debug)]
 637 pub struct VariableRecord {
 638     pub width: VarWidth,
 639     pub name: Identifier,
 640     pub print_format: Spec,
 641     pub write_format: Spec,
 642     pub missing_values: MissingValues,
 643     pub label: Option<String>,
 644 }
 645
 646 #[derive(Clone, Debug)]
 647 pub struct MissingValues {
 648     /// Individual missing values, up to 3 of them.
 649     pub values: Vec<Value>,
 650
 651     /// Optional range of missing values.
 652     pub range: Option<(Value, Value)>,
 653 }
 654
 655 impl Decode<raw::MissingValues<RawStr<8>>> for MissingValues {
 656     fn decode(
 657         decoder: &Decoder,
 658         input: &raw::MissingValues<RawStr<8>>,
 659         _warn: impl Fn(Error),
 660     ) -> Self {
 661         MissingValues {
 662             values: input
 663                 .values
 664                 .iter()
 665                 .map(|value| Value::decode(value, decoder))
 666                 .collect(),
 667             range: input
 668                 .range
 669                 .as_ref()
 670                 .map(|(low, high)| (Value::decode(low, decoder), Value::decode(high, decoder))),
 671         }
 672     }
 673 }
 674
 675 fn decode_format(raw: raw::Spec, width: VarWidth, warn: impl Fn(Spec, FormatError)) -> Spec {
 676     UncheckedSpec::try_from(raw)
 677         .and_then(Spec::try_from)
 678         .and_then(|x| x.check_width_compatibility(width))
 679         .unwrap_or_else(|error| {
 680             let new_format = Spec::default_for_width(width);
 681             warn(new_format, error);
 682             new_format
 683         })
 684 }
 685
 686 impl TryDecode for VariableRecord {
 687     type Input<'a> = raw::VariableRecord<RawString, RawStr<8>>;
 688
 689     fn try_decode(
 690         decoder: &mut Decoder,
 691         input: &Self::Input<'_>,
 692         warn: impl Fn(Error),
 693     ) -> Result<Option<VariableRecord>, Error> {
 694         let width = match input.width {
 695             0 => VarWidth::Numeric,
 696             w @ 1..=255 => VarWidth::String(w as u16),
 697             -1 => return Ok(None),
 698             _ => {
 699                 return Err(Error::InvalidVariableWidth {
 700                     offsets: input.offsets.clone(),
 701                     width: input.width,
 702                 })
 703             }
 704         };
 705         let name = trim_end_spaces(decoder.decode_string(&input.name.0, &warn));
 706         let name = match Identifier::new(&name, decoder.encoding) {
 707             Ok(name) => {
 708                 if !decoder.var_names.contains_key(&name) {
 709                     name
 710                 } else {
 711                     let new_name = decoder.generate_name();
 712                     warn(Error::DuplicateVariableName {
 713                         duplicate_name: name.clone(),
 714                         new_name: new_name.clone(),
 715                     });
 716                     new_name
 717                 }
 718             }
 719             Err(id_error) => {
 720                 let new_name = decoder.generate_name();
 721                 warn(Error::InvalidVariableName {
 722                     id_error,
 723                     new_name: new_name.clone(),
 724                 });
 725                 new_name
 726             }
 727         };
 728         let variable = Variable {
 729             dict_index: decoder.n_dict_indexes,
 730             short_name: name.clone(),
 731             long_name: None,
 732             width,
 733         };
 734         decoder.n_dict_indexes += width.n_dict_indexes();
 735         assert!(decoder
 736             .var_names
 737             .insert(name.clone(), variable.dict_index)
 738             .is_none());
 739         assert!(decoder
 740             .variables
 741             .insert(variable.dict_index, variable)
 742             .is_none());
 743
 744         let print_format = decode_format(input.print_format, width, |new_spec, format_error| {
 745             warn(Error::InvalidPrintFormat {
 746                 new_spec,
 747                 variable: name.clone(),
 748                 format_error,
 749             })
 750         });
 751         let write_format = decode_format(input.write_format, width, |new_spec, format_error| {
 752             warn(Error::InvalidWriteFormat {
 753                 new_spec,
 754                 variable: name.clone(),
 755                 format_error,
 756             })
 757         });
 758         let label = input
 759             .label
 760             .as_ref()
 761             .map(|label| decoder.decode_string(&label.0, &warn));
 762         Ok(Some(VariableRecord {
 763             width,
 764             name,
 765             print_format,
 766             write_format,
 767             missing_values: MissingValues::decode(decoder, &input.missing_values, warn),
 768             label,
 769         }))
 770     }
 771 }
 772
 773 #[derive(Clone, Debug)]
 774 pub struct DocumentRecord(Vec<String>);
 775
 776 impl TryDecode for DocumentRecord {
 777     type Input<'a> = crate::raw::DocumentRecord<RawDocumentLine>;
 778
 779     fn try_decode(
 780         decoder: &mut Decoder,
 781         input: &Self::Input<'_>,
 782         warn: impl Fn(Error),
 783     ) -> Result<Option<Self>, Error> {
 784         Ok(Some(DocumentRecord(
 785             input
 786                 .lines
 787                 .iter()
 788                 .map(|s| trim_end_spaces(decoder.decode_string(&s.0, &warn)))
 789                 .collect(),
 790         )))
 791     }
 792 }
 793
 794 trait TextRecord
 795 where
 796     Self: Sized,
 797 {
 798     const NAME: &'static str;
 799     fn parse(input: &str, warn: impl Fn(Error)) -> Result<Self, Error>;
 800 }
 801
 802 #[derive(Clone, Debug)]
 803 pub struct VariableSet {
 804     pub name: String,
 805     pub vars: Vec<String>,
 806 }
 807
 808 impl VariableSet {
 809     fn parse(input: &str) -> Result<Self, Error> {
 810         let (name, input) = input.split_once('=').ok_or(Error::TBD)?;
 811         let vars = input.split_ascii_whitespace().map(String::from).collect();
 812         Ok(VariableSet {
 813             name: name.into(),
 814             vars,
 815         })
 816     }
 817 }
 818
 819 trait WarnOnError<T> {
 820     fn warn_on_error<F: Fn(Error)>(self, warn: &F) -> Option<T>;
 821 }
 822 impl<T> WarnOnError<T> for Result<T, Error> {
 823     fn warn_on_error<F: Fn(Error)>(self, warn: &F) -> Option<T> {
 824         match self {
 825             Ok(result) => Some(result),
 826             Err(error) => {
 827                 warn(error);
 828                 None
 829             }
 830         }
 831     }
 832 }
 833
 834 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 835 pub enum Value {
 836     Number(Option<OrderedFloat<f64>>),
 837     String(String),
 838 }
 839
 840 impl Value {
 841     pub fn decode(raw: &raw::Value<RawStr<8>>, decoder: &Decoder) -> Self {
 842         match raw {
 843             raw::Value::Number(x) => Value::Number(x.map(|x| x.into())),
 844             raw::Value::String(s) => Value::String(decoder.decode_exact_length(&s.0).into()),
 845         }
 846     }
 847 }
 848
 849 #[derive(Clone, Debug)]
 850 pub struct ValueLabel {
 851     pub value: Value,
 852     pub label: String,
 853 }
 854
 855 #[derive(Clone, Debug)]
 856 pub struct ValueLabelRecord {
 857     pub var_type: VarType,
 858     pub labels: Vec<ValueLabel>,
 859     pub variables: Vec<Identifier>,
 860 }
 861
 862 impl TryDecode for ValueLabelRecord {
 863     type Input<'a> = crate::raw::ValueLabelRecord<RawStr<8>, RawString>;
 864     fn try_decode(
 865         decoder: &mut Decoder,
 866         input: &Self::Input<'_>,
 867         warn: impl Fn(Error),
 868     ) -> Result<Option<ValueLabelRecord>, Error> {
 869         let variables: Vec<&Variable> = input
 870             .dict_indexes
 871             .iter()
 872             .filter_map(|&dict_index| {
 873                 decoder
 874                     .get_var_by_index(dict_index as usize)
 875                     .warn_on_error(&warn)
 876             })
 877             .filter(|&variable| match variable.width {
 878                 VarWidth::String(width) if width > 8 => {
 879                     warn(Error::InvalidLongStringValueLabel(
 880                         variable.short_name.clone(),
 881                     ));
 882                     false
 883                 }
 884                 _ => true,
 885             })
 886             .collect();
 887         let mut i = variables.iter();
 888         let Some(&first_var) = i.next() else {
 889             return Ok(None);
 890         };
 891         let var_type: VarType = first_var.width.into();
 892         for &variable in i {
 893             let this_type: VarType = variable.width.into();
 894             if var_type != this_type {
 895                 let (numeric_var, string_var) = match var_type {
 896                     VarType::Numeric => (first_var, variable),
 897                     VarType::String => (variable, first_var),
 898                 };
 899                 warn(Error::ValueLabelsDifferentTypes {
 900                     numeric_var: numeric_var.short_name.clone(),
 901                     string_var: string_var.short_name.clone(),
 902                 });
 903                 return Ok(None);
 904             }
 905         }
 906         let labels = input
 907             .labels
 908             .iter()
 909             .map(|raw::ValueLabel { value, label }| {
 910                 let label = decoder.decode_string(&label.0, &warn);
 911                 let value = Value::decode(value, decoder);
 912                 ValueLabel { value, label }
 913             })
 914             .collect();
 915         let variables = variables
 916             .iter()
 917             .map(|&variable| variable.short_name.clone())
 918             .collect();
 919         Ok(Some(ValueLabelRecord {
 920             var_type,
 921             labels,
 922             variables,
 923         }))
 924     }
 925 }
 926
 927 #[derive(Clone, Debug)]
 928 pub struct VariableSetRecord(Vec<VariableSet>);
 929
 930 impl TextRecord for VariableSetRecord {
 931     const NAME: &'static str = "variable set";
 932     fn parse(input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
 933         let mut sets = Vec::new();
 934         for line in input.lines() {
 935             if let Some(set) = VariableSet::parse(line).warn_on_error(&warn) {
 936                 sets.push(set)
 937             }
 938         }
 939         Ok(VariableSetRecord(sets))
 940     }
 941 }
 942
 943 #[derive(Clone, Debug)]
 944 pub struct LongName {
 945     pub short_name: Identifier,
 946     pub long_name: Identifier,
 947 }
 948
 949 impl LongName {
 950     fn new(decoder: &mut Decoder, short_name: &str, long_name: &str) -> Result<LongName, Error> {
 951         let short_name =
 952             Identifier::new(short_name, decoder.encoding).map_err(Error::InvalidShortName)?;
 953         let long_name =
 954             Identifier::new(long_name, decoder.encoding).map_err(Error::InvalidLongName)?;
 955         Ok(LongName {
 956             short_name,
 957             long_name,
 958         })
 959     }
 960 }
 961
 962 #[derive(Clone, Debug)]
 963 pub struct LongNameRecord(Vec<LongName>);
 964
 965 impl LongNameRecord {
 966     pub fn parse(decoder: &mut Decoder, input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
 967         let mut names = Vec::new();
 968         for pair in input.split('\t').filter(|s| !s.is_empty()) {
 969             if let Some((short_name, long_name)) = pair.split_once('=') {
 970                 if let Some(long_name) =
 971                     LongName::new(decoder, short_name, long_name).warn_on_error(&warn)
 972                 {
 973                     names.push(long_name);
 974                 }
 975             } else {
 976                 warn(Error::TBD)
 977             }
 978         }
 979         Ok(LongNameRecord(names))
 980     }
 981 }
 982
 983 #[derive(Clone, Debug)]
 984 pub struct VeryLongString {
 985     pub short_name: Identifier,
 986     pub length: u16,
 987 }
 988
 989 impl VeryLongString {
 990     fn parse(decoder: &Decoder, input: &str) -> Result<VeryLongString, Error> {
 991         let Some((short_name, length)) = input.split_once('=') else {
 992             return Err(Error::TBD);
 993         };
 994         let short_name =
 995             Identifier::new(short_name, decoder.encoding).map_err(Error::InvalidLongStringName)?;
 996         let length: u16 = length.parse().map_err(|_| Error::TBD)?;
 997         if length > VarWidth::MAX_STRING {
 998             return Err(Error::TBD);
 999         }
1000         Ok(VeryLongString { short_name, length })
1001     }
1002 }
1003
1004 #[derive(Clone, Debug)]
1005 pub struct VeryLongStringRecord(Vec<VeryLongString>);
1006
1007 impl VeryLongStringRecord {
1008     pub fn parse(decoder: &Decoder, input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
1009         let mut very_long_strings = Vec::new();
1010         for tuple in input
1011             .split('\0')
1012             .map(|s| s.trim_end_matches('\t'))
1013             .filter(|s| !s.is_empty())
1014         {
1015             if let Some(vls) = VeryLongString::parse(decoder, tuple).warn_on_error(&warn) {
1016                 very_long_strings.push(vls)
1017             }
1018         }
1019         Ok(VeryLongStringRecord(very_long_strings))
1020     }
1021 }
1022
1023 #[derive(Clone, Debug)]
1024 pub struct Attribute {
1025     pub name: Identifier,
1026     pub values: Vec<String>,
1027 }
1028
1029 impl Attribute {
1030     fn parse<'a>(
1031         decoder: &Decoder,
1032         input: &'a str,
1033         warn: &impl Fn(Error),
1034     ) -> Result<(Option<Attribute>, &'a str), Error> {
1035         let Some((name, mut input)) = input.split_once('(') else {
1036             return Err(Error::TBD);
1037         };
1038         let mut values = Vec::new();
1039         loop {
1040             let Some((value, rest)) = input.split_once('\n') else {
1041                 return Err(Error::TBD);
1042             };
1043             if let Some(stripped) = value
1044                 .strip_prefix('\'')
1045                 .and_then(|value| value.strip_suffix('\''))
1046             {
1047                 values.push(stripped.into());
1048             } else {
1049                 warn(Error::TBD);
1050                 values.push(value.into());
1051             }
1052             if let Some(rest) = rest.strip_prefix(')') {
1053                 let attribute = Identifier::new(name, decoder.encoding)
1054                     .map_err(Error::InvalidAttributeName)
1055                     .warn_on_error(warn)
1056                     .map(|name| Attribute { name, values });
1057                 return Ok((attribute, rest));
1058             };
1059             input = rest;
1060         }
1061     }
1062 }
1063
1064 #[derive(Clone, Debug)]
1065 pub struct AttributeSet(pub Vec<Attribute>);
1066
1067 impl AttributeSet {
1068     fn parse<'a>(
1069         decoder: &Decoder,
1070         mut input: &'a str,
1071         sentinel: Option<char>,
1072         warn: &impl Fn(Error),
1073     ) -> Result<(AttributeSet, &'a str), Error> {
1074         let mut attributes = Vec::new();
1075         let rest = loop {
1076             match input.chars().next() {
1077                 None => break input,
1078                 c if c == sentinel => break &input[1..],
1079                 _ => {
1080                     let (attribute, rest) = Attribute::parse(decoder, input, &warn)?;
1081                     if let Some(attribute) = attribute {
1082                         attributes.push(attribute);
1083                     }
1084                     input = rest;
1085                 }
1086             }
1087         };
1088         Ok((AttributeSet(attributes), rest))
1089     }
1090 }
1091
1092 #[derive(Clone, Debug)]
1093 pub struct FileAttributeRecord(AttributeSet);
1094
1095 impl FileAttributeRecord {
1096     pub fn parse(decoder: &Decoder, input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
1097         let (set, rest) = AttributeSet::parse(decoder, input, None, &warn)?;
1098         if !rest.is_empty() {
1099             warn(Error::TBD);
1100         }
1101         Ok(FileAttributeRecord(set))
1102     }
1103 }
1104
1105 #[derive(Clone, Debug)]
1106 pub struct VarAttributeSet {
1107     pub long_var_name: Identifier,
1108     pub attributes: AttributeSet,
1109 }
1110
1111 impl VarAttributeSet {
1112     fn parse<'a>(
1113         decoder: &Decoder,
1114         input: &'a str,
1115         warn: &impl Fn(Error),
1116     ) -> Result<(Option<VarAttributeSet>, &'a str), Error> {
1117         let Some((long_var_name, rest)) = input.split_once(':') else {
1118             return Err(Error::TBD);
1119         };
1120         let (attributes, rest) = AttributeSet::parse(decoder, rest, Some('/'), warn)?;
1121         let var_attribute = Identifier::new(long_var_name, decoder.encoding)
1122             .map_err(Error::InvalidAttributeVariableName)
1123             .warn_on_error(warn)
1124             .map(|name| VarAttributeSet {
1125                 long_var_name: name,
1126                 attributes,
1127             });
1128         Ok((var_attribute, rest))
1129     }
1130 }
1131
1132 #[derive(Clone, Debug)]
1133 pub struct VariableAttributeRecord(Vec<VarAttributeSet>);
1134
1135 impl VariableAttributeRecord {
1136     pub fn parse(decoder: &Decoder, mut input: &str, warn: impl Fn(Error)) -> Result<Self, Error> {
1137         let mut var_attribute_sets = Vec::new();
1138         while !input.is_empty() {
1139             let Some((var_attribute, rest)) =
1140                 VarAttributeSet::parse(decoder, input, &warn).warn_on_error(&warn)
1141             else {
1142                 break;
1143             };
1144             if let Some(var_attribute) = var_attribute {
1145                 var_attribute_sets.push(var_attribute);
1146             }
1147             input = rest;
1148         }
1149         Ok(VariableAttributeRecord(var_attribute_sets))
1150     }
1151 }
1152
1153 #[derive(Clone, Debug)]
1154 pub enum MultipleResponseType {
1155     MultipleDichotomy {
1156         value: Value,
1157         labels: CategoryLabels,
1158     },
1159     MultipleCategory,
1160 }
1161
1162 impl MultipleResponseType {
1163     fn decode(
1164         decoder: &Decoder,
1165         mr_set: &Identifier,
1166         input: &raw::MultipleResponseType,
1167         min_width: VarWidth,
1168         warn: &impl Fn(Error),
1169     ) -> Result<Self, Error> {
1170         let mr_type = match input {
1171             raw::MultipleResponseType::MultipleDichotomy { value, labels } => {
1172                 let value = decoder.decode_string_cow(&value.0, warn);
1173                 let value = match min_width {
1174                     VarWidth::Numeric => {
1175                         let number: f64 = value.trim().parse().map_err(|_| {
1176                             Error::InvalidMDGroupCountedValue {
1177                                 mr_set: mr_set.clone(),
1178                                 number: value.into(),
1179                             }
1180                         })?;
1181                         Value::Number(Some(number.into()))
1182                     }
1183                     VarWidth::String(max_width) => {
1184                         let value = value.trim_end_matches(' ');
1185                         let width = value.len();
1186                         if width > max_width as usize {
1187                             return Err(Error::TooWideMDGroupCountedValue {
1188                                 mr_set: mr_set.clone(),
1189                                 value: value.into(),
1190                                 width,
1191                                 max_width,
1192                             });
1193                         };
1194                         Value::String(value.into())
1195                     }
1196                 };
1197                 MultipleResponseType::MultipleDichotomy {
1198                     value,
1199                     labels: *labels,
1200                 }
1201             }
1202             raw::MultipleResponseType::MultipleCategory => MultipleResponseType::MultipleCategory,
1203         };
1204         Ok(mr_type)
1205     }
1206 }
1207
1208 #[derive(Clone, Debug)]
1209 pub struct MultipleResponseSet {
1210     pub name: Identifier,
1211     pub min_width: VarWidth,
1212     pub max_width: VarWidth,
1213     pub label: String,
1214     pub mr_type: MultipleResponseType,
1215     pub dict_indexes: Vec<DictIndex>,
1216 }
1217
1218 impl MultipleResponseSet {
1219     fn decode(
1220         decoder: &Decoder,
1221         input: &raw::MultipleResponseSet<Cow<str>>,
1222         warn: &impl Fn(Error),
1223     ) -> Result<Self, Error> {
1224         let mr_set_name =
1225             Identifier::new(&input.name, decoder.encoding).map_err(Error::InvalidMrSetName)?;
1226
1227         let mut dict_indexes = Vec::with_capacity(input.short_names.len());
1228         for short_name in input.short_names.iter() {
1229             let short_name = match Identifier::new(&short_name, decoder.encoding) {
1230                 Ok(name) => name,
1231                 Err(error) => {
1232                     warn(Error::InvalidMrSetName(error));
1233                     continue;
1234                 }
1235             };
1236             let Some(&dict_index) = decoder.var_names.get(&short_name) else {
1237                 warn(Error::UnknownMrSetVariable {
1238                     mr_set: mr_set_name.clone(),
1239                     short_name: short_name.clone(),
1240                 });
1241                 continue;
1242             };
1243             dict_indexes.push(dict_index);
1244         }
1245
1246         match dict_indexes.len() {
1247             0 => return Err(Error::EmptyMrSet(mr_set_name)),
1248             1 => return Err(Error::OneVarMrSet(mr_set_name)),
1249             _ => (),
1250         }
1251
1252         let Some((Some(min_width), Some(max_width))) = dict_indexes
1253             .iter()
1254             .map(|dict_index| decoder.variables[dict_index].width)
1255             .map(|w| (Some(w), Some(w)))
1256             .reduce(|(na, wa), (nb, wb)| (VarWidth::narrower(na, nb), VarWidth::wider(wa, wb)))
1257         else {
1258             return Err(Error::MixedMrSet(mr_set_name));
1259         };
1260
1261         let mr_type =
1262             MultipleResponseType::decode(decoder, &mr_set_name, &input.mr_type, min_width, warn)?;
1263
1264         Ok(MultipleResponseSet {
1265             name: mr_set_name,
1266             min_width,
1267             max_width,
1268             label: input.label.to_string(),
1269             mr_type,
1270             dict_indexes,
1271         })
1272     }
1273 }
1274
1275 #[derive(Clone, Debug)]
1276 pub struct MultipleResponseRecord(pub Vec<MultipleResponseSet>);
1277
1278 impl TryDecode for MultipleResponseRecord {
1279     type Input<'a> = raw::MultipleResponseRecord<Cow<'a, str>>;
1280
1281     fn try_decode(
1282         decoder: &mut Decoder,
1283         input: &Self::Input<'_>,
1284         warn: impl Fn(Error),
1285     ) -> Result<Option<Self>, Error> {
1286         let mut sets = Vec::with_capacity(input.0.len());
1287         for set in &input.0 {
1288             match MultipleResponseSet::decode(decoder, set, &warn) {
1289                 Ok(set) => sets.push(set),
1290                 Err(error) => warn(error),
1291             }
1292         }
1293         Ok(Some(MultipleResponseRecord(sets)))
1294     }
1295 }
1296
1297 #[derive(Clone, Debug)]
1298 pub struct LongStringMissingValues {
1299     /// Variable name.
1300     pub var_name: Identifier,
1301
1302     /// Missing values.
1303     pub missing_values: MissingValues,
1304 }
1305
1306 impl LongStringMissingValues {
1307     fn decode(
1308         decoder: &Decoder,
1309         input: &raw::LongStringMissingValues<RawString, RawStr<8>>,
1310         warn: &impl Fn(Error),
1311     ) -> Result<Self, Error> {
1312         let var_name = decoder.decode_string(&input.var_name.0, warn);
1313         let var_name = Identifier::new(var_name.trim_end(), decoder.encoding)
1314             .map_err(Error::InvalidLongStringValueLabelName)?;
1315
1316         let missing_values = MissingValues::decode(decoder, &input.missing_values, warn);
1317
1318         Ok(LongStringMissingValues {
1319             var_name,
1320             missing_values,
1321         })
1322     }
1323 }
1324
1325 #[derive(Clone, Debug)]
1326 pub struct LongStringMissingValuesRecord(Vec<LongStringMissingValues>);
1327
1328 impl TryDecode for LongStringMissingValuesRecord {
1329     type Input<'a> = raw::LongStringMissingValueRecord<RawString, RawStr<8>>;
1330
1331     fn try_decode(
1332         decoder: &mut Decoder,
1333         input: &Self::Input<'_>,
1334         warn: impl Fn(Error),
1335     ) -> Result<Option<Self>, Error> {
1336         let mut labels = Vec::with_capacity(input.0.len());
1337         for label in &input.0 {
1338             match LongStringMissingValues::decode(decoder, label, &warn) {
1339                 Ok(set) => labels.push(set),
1340                 Err(error) => warn(error),
1341             }
1342         }
1343         Ok(Some(LongStringMissingValuesRecord(labels)))
1344     }
1345 }
1346
1347 #[derive(Clone, Debug)]
1348 pub struct LongStringValueLabels {
1349     pub var_name: Identifier,
1350     pub width: VarWidth,
1351     pub labels: Vec<ValueLabel>,
1352 }
1353
1354 impl LongStringValueLabels {
1355     fn decode(
1356         decoder: &Decoder,
1357         input: &raw::LongStringValueLabels<RawString>,
1358         warn: &impl Fn(Error),
1359     ) -> Result<Self, Error> {
1360         let var_name = decoder.decode_string(&input.var_name.0, warn);
1361         let var_name = Identifier::new(var_name.trim_end(), decoder.encoding)
1362             .map_err(Error::InvalidLongStringValueLabelName)?;
1363
1364         let min_width = 9;
1365         let max_width = VarWidth::MAX_STRING;
1366         if input.width < 9 || input.width > max_width as u32 {
1367             return Err(Error::InvalidLongValueLabelWidth {
1368                 name: var_name,
1369                 width: input.width,
1370                 min_width,
1371                 max_width,
1372             });
1373         }
1374         let width = input.width as u16;
1375
1376         let mut labels = Vec::with_capacity(input.labels.len());
1377         for (value, label) in input.labels.iter() {
1378             let value = Value::String(decoder.decode_exact_length(&value.0).into());
1379             let label = decoder.decode_string(&label.0, warn);
1380             labels.push(ValueLabel { value, label });
1381         }
1382
1383         Ok(LongStringValueLabels {
1384             var_name,
1385             width: VarWidth::String(width),
1386             labels,
1387         })
1388     }
1389 }
1390
1391 #[derive(Clone, Debug)]
1392 pub struct LongStringValueLabelRecord(pub Vec<LongStringValueLabels>);
1393
1394 impl TryDecode for LongStringValueLabelRecord {
1395     type Input<'a> = raw::LongStringValueLabelRecord<RawString>;
1396
1397     fn try_decode(
1398         decoder: &mut Decoder,
1399         input: &Self::Input<'_>,
1400         warn: impl Fn(Error),
1401     ) -> Result<Option<Self>, Error> {
1402         let mut labels = Vec::with_capacity(input.0.len());
1403         for label in &input.0 {
1404             match LongStringValueLabels::decode(decoder, label, &warn) {
1405                 Ok(set) => labels.push(set),
1406                 Err(error) => warn(error),
1407             }
1408         }
1409         Ok(Some(LongStringValueLabelRecord(labels)))
1410     }
1411 }
1412
1413 #[cfg(test)]
1414 mod test {
1415     use encoding_rs::WINDOWS_1252;
1416
1417     #[test]
1418     fn test() {
1419         let mut s = String::new();
1420         s.push(char::REPLACEMENT_CHARACTER);
1421         let encoded = WINDOWS_1252.encode(&s).0;
1422         let decoded = WINDOWS_1252.decode(&encoded[..]).0;
1423         println!("{:?}", decoded);
1424     }
1425
1426     #[test]
1427     fn test2() {
1428         let charset: Vec<u8> = (0..=255).collect();
1429         println!("{}", charset.len());
1430         let decoded = WINDOWS_1252.decode(&charset[..]).0;
1431         println!("{}", decoded.len());
1432         let encoded = WINDOWS_1252.encode(&decoded[..]).0;
1433         println!("{}", encoded.len());
1434         assert_eq!(&charset[..], &encoded[..]);
1435     }
1436 }