Skip to content

Commit c86ef9a

Browse files
benoitlxbenoitlx
committed
refactor: changing parser::parse output type
1 parent 85b5556 commit c86ef9a

2 files changed

Lines changed: 124 additions & 47 deletions

File tree

‎src/main.rs‎

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ struct Cli {
2525
#[arg(short = 's', long = "sep", default_value_t = String::from(""))]
2626
sep: String,
2727

28-
/// whether to turn off warnings
28+
/// whether to turn off warnings
2929
#[arg(long = "w-off")]
3030
warning_off: bool,
3131

@@ -47,10 +47,13 @@ fn main() {
4747

4848
let mut tokens: Vec<(Result<Token, ()>, std::ops::Range<usize>)> = lex.spanned().collect();
4949

50-
let (bit_stream, _, report) =
51-
parser::generate_bit_stream(&mut tokens, args.color, args.debug, &args.sep);
50+
let parser_report =
51+
parser::parse(&mut tokens, args.color, args.debug, &args.sep);
5252

53-
let (errors, warnings): (Vec<_>, Vec<_>)= report.into_iter().partition(|r| r.severity() != Some(Severity::Warning));
53+
let (errors, warnings): (Vec<_>, Vec<_>) = parser_report
54+
.report
55+
.into_iter()
56+
.partition(|r| r.severity() != Some(Severity::Warning));
5457

5558
let error_number = errors.len();
5659
let warning_number = warnings.len();
@@ -66,7 +69,10 @@ fn main() {
6669
println!("{:?}", e.with_source_code(content.clone()));
6770
}
6871

69-
println!("{} errors and {} warnings found in {}, exiting !", error_number, warning_number, args.file_path);
72+
println!(
73+
"{} errors and {} warnings found in {}, exiting !",
74+
error_number, warning_number, args.file_path
75+
);
7076
return;
7177
}
7278

@@ -88,6 +94,6 @@ fn main() {
8894
);
8995
}
9096

91-
println!("{}", bit_stream);
97+
println!("{}", parser_report.bit_stream);
9298
}
9399
}

‎src/parser.rs‎

Lines changed: 112 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -51,18 +51,18 @@ pub struct ColType {
5151

5252
// TODO
5353
pub struct ParserReport {
54-
bit_stream: String,
55-
errors: Vec<Error>,
54+
pub bit_stream: String,
55+
pub report: Vec<Error>,
5656
id_collect: HashMap<String, ColType>,
5757
}
5858

5959
/// generate a bit stream from a Vec of Spanned Token
60-
pub fn generate_bit_stream(
60+
pub fn parse(
6161
tokens: &mut Vec<(Result<Token, ()>, Range<usize>)>,
6262
colorize: bool,
6363
debug: bool,
6464
sep: &str,
65-
) -> (String, HashMap<String, ColType>, Vec<Error>) {
65+
) -> ParserReport {
6666
colored::control::set_override(colorize);
6767
let mut bit_stream_with_id: Vec<String> = vec![];
6868

@@ -230,7 +230,14 @@ pub fn generate_bit_stream(
230230
let id_ref = id_collect.get(id);
231231

232232
if id_ref == None {
233-
id_collect.insert(id.clone(), ColType {val: adr, span: span.clone(), visited: false});
233+
id_collect.insert(
234+
id.clone(),
235+
ColType {
236+
val: adr,
237+
span: span.clone(),
238+
visited: false,
239+
},
240+
);
234241
} else {
235242
let other_span = (*id_ref.unwrap()).span.clone();
236243
let report = miette!(
@@ -253,7 +260,14 @@ pub fn generate_bit_stream(
253260
let id_ref = id_collect.get(id);
254261

255262
if id_ref == None {
256-
id_collect.insert(id.clone(), ColType {val: *val, span: span.clone(), visited: false});
263+
id_collect.insert(
264+
id.clone(),
265+
ColType {
266+
val: *val,
267+
span: span.clone(),
268+
visited: false,
269+
},
270+
);
257271
} else {
258272
let other_span = (*id_ref.unwrap()).span.clone();
259273
let report = miette!(
@@ -325,19 +339,27 @@ pub fn generate_bit_stream(
325339

326340
for (key, context) in id_collect.clone() {
327341
match context {
328-
ColType {val: _, span, visited: false} => {
342+
ColType {
343+
val: _,
344+
span,
345+
visited: false,
346+
} => {
329347
let report = miette!(
330348
severity = Severity::Warning,
331349
labels = vec![LabeledSpan::at(span, "Here"),],
332350
"Error: {key} declared but never used"
333351
);
334352
errors.push(report);
335353
}
336-
_ => ()
354+
_ => (),
337355
}
338356
}
339357

340-
(bit_stream.join(sep), id_collect, errors)
358+
ParserReport {
359+
bit_stream: bit_stream.join(sep),
360+
report: errors,
361+
id_collect: id_collect,
362+
}
341363
}
342364

343365
#[cfg(test)]
@@ -349,42 +371,91 @@ mod tests {
349371
fn test_define() {
350372
let src = "DEFINE foo 0\nDEFINE bar 1\nDEFINE titi 42\nDEFINE tata 73";
351373
let mut collection: HashMap<String, ColType> = HashMap::new();
352-
collection.insert("foo".to_string(), ColType {val: 0, span: 7..10, visited: false});
353-
collection.insert("bar".to_string(), ColType {val: 1, span: 20..23, visited: false});
354-
collection.insert("titi".to_string(), ColType {val: 42, span: 33..37, visited: false});
355-
collection.insert("tata".to_string(), ColType {val: 73, span: 48..52, visited: false});
374+
collection.insert(
375+
"foo".to_string(),
376+
ColType {
377+
val: 0,
378+
span: 7..10,
379+
visited: false,
380+
},
381+
);
382+
collection.insert(
383+
"bar".to_string(),
384+
ColType {
385+
val: 1,
386+
span: 20..23,
387+
visited: false,
388+
},
389+
);
390+
collection.insert(
391+
"titi".to_string(),
392+
ColType {
393+
val: 42,
394+
span: 33..37,
395+
visited: false,
396+
},
397+
);
398+
collection.insert(
399+
"tata".to_string(),
400+
ColType {
401+
val: 73,
402+
span: 48..52,
403+
visited: false,
404+
},
405+
);
356406

357407
let lex = Token::lexer(src);
358408

359409
let mut tokens: Vec<(Result<Token, ()>, std::ops::Range<usize>)> = lex.spanned().collect();
360410
assert_eq!(
361411
collection,
362-
generate_bit_stream(&mut tokens, false, false, "").1
412+
parse(&mut tokens, false, false, "").id_collect
363413
);
364414
assert_eq!(
365415
collection,
366-
generate_bit_stream(&mut tokens, false, true, "").1
416+
parse(&mut tokens, false, true, "").id_collect
367417
);
368418
}
369419

370420
#[test]
371421
fn test_label() {
372422
let src = "main:\nJMP\nlabel:\nJMP\nJMP\nJMP\nJMP\nJMP\nJMP\nJMP\nJMP\ntiti:";
373423
let mut collection: HashMap<String, ColType> = HashMap::new();
374-
collection.insert("main".to_string(), ColType {val: 0, span: 0..4, visited: false});
375-
collection.insert("label".to_string(), ColType {val: 16, span: 10..15, visited: false});
376-
collection.insert("titi".to_string(), ColType {val: 144, span: 49..53, visited: false});
424+
collection.insert(
425+
"main".to_string(),
426+
ColType {
427+
val: 0,
428+
span: 0..4,
429+
visited: false,
430+
},
431+
);
432+
collection.insert(
433+
"label".to_string(),
434+
ColType {
435+
val: 16,
436+
span: 10..15,
437+
visited: false,
438+
},
439+
);
440+
collection.insert(
441+
"titi".to_string(),
442+
ColType {
443+
val: 144,
444+
span: 49..53,
445+
visited: false,
446+
},
447+
);
377448

378449
let lex = Token::lexer(src);
379450

380451
let mut tokens: Vec<(Result<Token, ()>, std::ops::Range<usize>)> = lex.spanned().collect();
381452
assert_eq!(
382453
collection,
383-
generate_bit_stream(&mut tokens, false, false, "").1
454+
parse(&mut tokens, false, false, "").id_collect
384455
);
385456
assert_eq!(
386457
collection,
387-
generate_bit_stream(&mut tokens, false, true, "").1
458+
parse(&mut tokens, false, true, "").id_collect
388459
);
389460
}
390461

@@ -399,11 +470,11 @@ mod tests {
399470

400471
assert_eq!(
401472
expected,
402-
generate_bit_stream(&mut tokens, false, false, "\n").0
473+
parse(&mut tokens, false, false, "\n").bit_stream
403474
);
404475
assert_eq!(
405476
expected,
406-
generate_bit_stream(&mut tokens, false, true, "\n").0
477+
parse(&mut tokens, false, true, "\n").bit_stream
407478
);
408479
}
409480

@@ -414,8 +485,8 @@ mod tests {
414485
let lex = Token::lexer(src);
415486

416487
let mut tokens: Vec<(Result<Token, ()>, std::ops::Range<usize>)> = lex.spanned().collect();
417-
assert!(!generate_bit_stream(&mut tokens, false, false, "")
418-
.2
488+
assert!(!parse(&mut tokens, false, false, "")
489+
.report
419490
.is_empty());
420491
}
421492

@@ -431,11 +502,11 @@ mod tests {
431502

432503
assert_eq!(
433504
expected,
434-
generate_bit_stream(&mut tokens, false, false, "\n").0
505+
parse(&mut tokens, false, false, "\n").bit_stream
435506
);
436507
assert_eq!(
437508
expected,
438-
generate_bit_stream(&mut tokens, false, true, "\n").0
509+
parse(&mut tokens, false, true, "\n").bit_stream
439510
);
440511
}
441512

@@ -446,8 +517,8 @@ mod tests {
446517
let lex = Token::lexer(src);
447518

448519
let mut tokens: Vec<(Result<Token, ()>, std::ops::Range<usize>)> = lex.spanned().collect();
449-
assert!(!generate_bit_stream(&mut tokens, false, false, "")
450-
.2
520+
assert!(!parse(&mut tokens, false, false, "")
521+
.report
451522
.is_empty())
452523
}
453524

@@ -463,11 +534,11 @@ mod tests {
463534

464535
assert_eq!(
465536
expected,
466-
generate_bit_stream(&mut tokens, false, false, "\n").0
537+
parse(&mut tokens, false, false, "\n").bit_stream
467538
);
468539
assert_eq!(
469540
expected,
470-
generate_bit_stream(&mut tokens, false, true, "\n").0
541+
parse(&mut tokens, false, true, "\n").bit_stream
471542
);
472543
}
473544

@@ -483,11 +554,11 @@ mod tests {
483554

484555
assert_eq!(
485556
expected,
486-
generate_bit_stream(&mut tokens, false, false, "\n").0
557+
parse(&mut tokens, false, false, "\n").bit_stream
487558
);
488559
assert_eq!(
489560
expected,
490-
generate_bit_stream(&mut tokens, false, true, "\n").0
561+
parse(&mut tokens, false, true, "\n").bit_stream
491562
);
492563
}
493564

@@ -503,11 +574,11 @@ mod tests {
503574

504575
assert_eq!(
505576
expected,
506-
generate_bit_stream(&mut tokens, false, false, "\n").0
577+
parse(&mut tokens, false, false, "\n").bit_stream
507578
);
508579
assert_eq!(
509580
expected,
510-
generate_bit_stream(&mut tokens, false, true, "\n").0
581+
parse(&mut tokens, false, true, "\n").bit_stream
511582
);
512583
}
513584

@@ -520,7 +591,7 @@ mod tests {
520591

521592
let mut tokens: Vec<(Result<Token, ()>, std::ops::Range<usize>)> = lex.spanned().collect();
522593

523-
generate_bit_stream(&mut tokens, false, false, "");
594+
parse(&mut tokens, false, false, "");
524595
}
525596

526597
#[test]
@@ -535,11 +606,11 @@ mod tests {
535606

536607
assert_eq!(
537608
expected,
538-
generate_bit_stream(&mut tokens, false, false, "\n").0
609+
parse(&mut tokens, false, false, "\n").bit_stream
539610
);
540611
assert_eq!(
541612
expected,
542-
generate_bit_stream(&mut tokens, false, true, "\n").0
613+
parse(&mut tokens, false, true, "\n").bit_stream
543614
);
544615
}
545616

@@ -551,8 +622,8 @@ mod tests {
551622

552623
let mut tokens: Vec<(Result<Token, ()>, std::ops::Range<usize>)> = lex.spanned().collect();
553624

554-
assert!(!generate_bit_stream(&mut tokens, false, false, "")
555-
.2
625+
assert!(!parse(&mut tokens, false, false, "")
626+
.report
556627
.is_empty());
557628
}
558629

@@ -564,8 +635,8 @@ mod tests {
564635

565636
let mut tokens: Vec<(Result<Token, ()>, std::ops::Range<usize>)> = lex.spanned().collect();
566637

567-
assert!(!generate_bit_stream(&mut tokens, false, false, "")
568-
.2
638+
assert!(!parse(&mut tokens, false, false, "")
639+
.report
569640
.is_empty());
570641
}
571642
}

0 commit comments

Comments
 (0)