use std::io::{self, BufRead, Error};
mod ascii_parser;
mod binary_parser;
mod serializer;
use crate::graph::{AigBuilder, AigGraph, NodeId, SymbolKind, SymbolTable};
use ascii_parser::parse_ascii_aiger_into_graph;
use binary_parser::parse_binary_aiger_into_graph;
pub use serializer::*;
#[derive(Debug)]
pub struct AigerHeader {
pub mode: AigerMode,
pub max_var: usize,
pub num_inputs: usize,
pub num_latches: usize,
pub num_outputs: usize,
pub num_and_gates: usize,
pub num_bad_states: usize,
pub num_invariants: usize,
pub num_justice: usize,
pub num_fairness: usize,
}
#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
pub enum AigerMode {
Ascii,
Binary,
}
impl AigerMode {
pub const fn ext(&self) -> &'static str {
match self {
AigerMode::Ascii => "aag",
AigerMode::Binary => "aig",
}
}
}
impl AigerHeader {
pub fn num_labels(&self) -> usize {
self.num_outputs
+ self.num_bad_states
+ self.num_invariants
+ self.num_justice
+ self.num_fairness
}
}
pub fn run_parser_with_options(
reader: &mut impl BufRead,
pre_optimize: bool,
) -> io::Result<(AigGraph, SymbolTable, String)> {
let header: AigerHeader = verify_aiger_header(reader)?;
match header.mode {
AigerMode::Ascii => parse_ascii_aiger_into_graph(header, reader, pre_optimize),
AigerMode::Binary => parse_binary_aiger_into_graph(header, reader, pre_optimize),
}
}
fn parse_optional_field(parser: &mut LineParser) -> usize {
let val = parser.parse_int().unwrap_or(0);
parser.skip_whitespace();
val
}
pub fn verify_aiger_header(reader: &mut impl BufRead) -> Result<AigerHeader, Error> {
let mut parser = LineParser::default();
parser.read_line(reader)?;
let tag = parser.parse_word();
let mode = match tag {
b"aag" => AigerMode::Ascii,
b"aig" => AigerMode::Binary,
_ => panic!("Invalid tag, must be either 'aag' or 'aig'"),
};
debug_assert_eq!(mode.ext().as_bytes(), tag);
let [max_var, num_inputs, num_latches, num_outputs, num_and_gates] = parser
.parse_ints()
.expect("Header must have format: aag/aig M I L O A [B C J F]");
parser.skip_whitespace();
let num_bad_states = parse_optional_field(&mut parser);
let num_invariants = parse_optional_field(&mut parser);
let num_justice = parse_optional_field(&mut parser);
let num_fairness = parse_optional_field(&mut parser);
assert!(parser.rest().is_empty(), "extra data on header line");
let expected_max_var: usize = num_inputs + num_latches + num_and_gates;
if max_var < expected_max_var {
panic!(
"ASCII AIGER requires M >= I + L + A, Binary requires M = I + L + A, got M={} and I+L+A={}",
max_var, expected_max_var
)
}
if max_var != expected_max_var && mode == AigerMode::Binary {
panic!(
"Binary AIGER requires M = I + L + A, got M={} and I+L+A={}",
max_var, expected_max_var
);
}
Ok(AigerHeader {
mode,
max_var,
num_inputs,
num_latches,
num_outputs,
num_and_gates,
num_bad_states,
num_invariants,
num_justice,
num_fairness,
})
}
fn resolve_labels_and_latches(
mut label_lits: Vec<usize>,
latch_inputs: Vec<(NodeId, usize)>,
header: &AigerHeader,
graph: &mut AigBuilder,
literals: &Literals,
) {
for (latch_id, latch_input_lit) in latch_inputs {
let latch_input_id: NodeId = literals.get(latch_input_lit);
graph.node(latch_id).set_latch_input(latch_input_id);
}
label_lits.reverse();
for _ in 0..header.num_outputs {
graph.add_output(literals.get(label_lits.pop().unwrap()));
}
for _ in 0..header.num_bad_states {
graph.add_bad_state(literals.get(label_lits.pop().unwrap()));
}
for _ in 0..header.num_invariants {
graph.add_invariant(literals.get(label_lits.pop().unwrap()));
}
for _ in 0..header.num_justice {
graph.add_justice(literals.get(label_lits.pop().unwrap()));
}
for _ in 0..header.num_fairness {
graph.add_fairness(literals.get(label_lits.pop().unwrap()));
}
debug_assert!(label_lits.is_empty());
}
#[derive(Default)]
struct Literals(Vec<NodeId>);
impl Literals {
fn new(max_var: usize) -> Self {
let mut map = vec![NodeId::NONE; max_var + 1];
map[0] = NodeId::FALSE;
Self(map)
}
fn split(literal: usize) -> (usize, bool) {
(literal >> 1, literal & 1 == 1)
}
fn add(&mut self, literal: usize, id: NodeId) {
let (var_idx, inverted) = Self::split(literal);
self.0[var_idx] = if inverted { id.invert() } else { id };
}
fn get(&self, literal: usize) -> NodeId {
let (var_idx, inverted) = Self::split(literal);
match self.0[var_idx] {
NodeId::NONE => panic!("Unknown aiger literal: {}", literal),
regular_node => {
if inverted {
regular_node.invert()
} else {
regular_node
}
}
}
}
}
#[derive(Default)]
pub struct LineParser {
pub buf: Vec<u8>,
pub pos: usize,
}
impl LineParser {
pub fn new(buf: Vec<u8>) -> Self {
Self { buf, pos: 0 }
}
pub fn clear(&mut self) {
self.buf.clear();
self.pos = 0;
}
pub fn rest(&self) -> &[u8] {
&self.buf[self.pos..]
}
pub fn read_line<R: BufRead>(&mut self, reader: &mut R) -> std::io::Result<bool> {
self.clear();
reader.read_until(b'\n', &mut self.buf)?;
Ok(self.buf.is_empty())
}
fn peek(&self) -> Option<u8> {
self.buf.get(self.pos).copied()
}
fn skip(&mut self) {
debug_assert!(self.pos < self.buf.len());
self.pos += 1;
}
fn pop_if(&mut self, pred: impl Fn(u8) -> bool) -> Option<u8> {
if let Some(byte) = self.peek()
&& pred(byte)
{
self.skip();
Some(byte)
} else {
None
}
}
pub fn parse_int(&mut self) -> Option<usize> {
let mut out: Option<usize> = None;
while let Some(byte) = self.pop_if(|b| b.is_ascii_digit()) {
let value = byte - b'0';
out = Some(match out {
Some(old) => old * 10 + (value as usize),
None => value as usize,
});
}
out
}
pub fn skip_whitespace(&mut self) {
while self.pop_if(|b| b.is_ascii_whitespace()).is_some() {}
}
pub fn parse_ints<const N: usize>(&mut self) -> Option<[usize; N]> {
let mut failed = false;
let arr = std::array::from_fn(|_| {
self.skip_whitespace();
match self.parse_int() {
Some(i) => i,
None => {
failed = true;
0
}
}
});
if failed { None } else { Some(arr) }
}
pub fn parse_word(&mut self) -> &[u8] {
let start_pos = self.pos;
while self.pop_if(|b| !b.is_ascii_whitespace()).is_some() {}
&self.buf[start_pos..self.pos]
}
}
struct LineReader<'a, R: BufRead> {
reader: &'a mut R,
parser: LineParser,
}
impl<'a, R: BufRead> LineReader<'a, R> {
fn new(reader: &'a mut R) -> Self {
LineReader {
reader,
parser: LineParser::default(),
}
}
fn read_int(&mut self) -> std::io::Result<Option<usize>> {
self.parser.read_line(self.reader)?;
Ok(self.parser.parse_int())
}
fn read_ints<const N: usize>(&mut self) -> std::io::Result<Option<[usize; N]>> {
self.parser.read_line(self.reader)?;
Ok(self.parser.parse_ints())
}
}
fn parse_symbol_table_and_comments<R: BufRead>(
reader: &mut LineReader<R>,
) -> Result<(SymbolTable, String), Error> {
let st = parse_symbol_table(reader)?;
let mut comments = "".to_string();
if !reader.parser.rest().is_empty() && reader.parser.rest().trim_ascii() == b"c" {
reader.reader.read_to_string(&mut comments)?;
}
Ok((st, comments))
}
fn parse_symbol_table<R: BufRead>(reader: &mut LineReader<R>) -> Result<SymbolTable, Error> {
reader.parser.clear();
let mut st = SymbolTable::default();
reader.parser.read_line(reader.reader)?;
while let Some(kind) = reader.parser.pop_if(SymbolKind::is_tag) {
let index = reader.parser.parse_int().expect("expected an index");
reader.parser.skip_whitespace();
let name = std::str::from_utf8(reader.parser.rest())
.expect("expected valid utf-8")
.trim_ascii();
let kind = SymbolKind::from_tag(kind).unwrap();
st.name_symbol(kind, index, name);
reader.parser.read_line(reader.reader)?;
}
Ok(st)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn just_int() {
let mut parser = LineParser::new("42".as_bytes().to_vec());
assert_eq!(parser.parse_int(), Some(42));
assert!(parser.rest().is_empty());
}
#[test]
fn int_with_stuff() {
let mut parser = LineParser::new("42x".as_bytes().to_vec());
assert_eq!(parser.parse_int(), Some(42));
assert_eq!(parser.rest().len(), 1);
}
#[test]
fn two_ints() {
let mut parser = LineParser::new("42 27 x".as_bytes().to_vec());
assert_eq!(parser.parse_ints(), Some([42, 27]));
assert_eq!(parser.rest().len(), 2);
}
}