diff --git a/parse_magic.py b/parse_magic.py index 4bb4050..07c4643 100644 --- a/parse_magic.py +++ b/parse_magic.py @@ -31,91 +31,112 @@ class UglyHeader: self.negation = negation self.necessitation = necessitation -# NOTE: Global variable used to keep track of solution models -solutions: List[Tuple[Model, Dict]] = [] +class ModelBuilder: + def __init__(self): + self.size : int = 0 + self.carrier_set : Set[ModelValue] = set() + self.num_negation: int = 0 + self.mnegation: Optional[ModelFunction] = None + self.num_order: int = 0 + self.mconjunction: Optional[ModelFunction] = None + self.mdisjunction: Optional[ModelFunction] = None + self.num_designated: int = 0 + self.designated_values: Set[ModelValue] = set() + self.num_implication: int = 0 + self.mimplication: Optional[ModelFunction] = None def parse_matrices(infile: SourceFile) -> List[Tuple[Model, Dict]]: - global solutions solutions = [] # Reset header = parse_header(infile) - process_sizes(infile, header) + current_model_parts = ModelBuilder() + process_sizes(infile, header, current_model_parts, solutions) + return solutions -def process_sizes(infile: SourceFile, header: UglyHeader): +def process_sizes(infile: SourceFile, header: UglyHeader, current_model_parts: ModelBuilder, solutions: List[Tuple[Model, Dict]]): """Stage 1""" while True: size = parse_size(infile) if size is None: break carrier_set = carrier_set_from_size(size) - process_negations(infile, header, size, carrier_set) + current_model_parts.size = size + current_model_parts.carrier_set = carrier_set + process_negations(infile, header, current_model_parts, solutions) -def process_negations(infile: SourceFile, header: UglyHeader, size: int, carrier_set: Set[ModelValue]): +def process_negations(infile: SourceFile, header: UglyHeader, current_model_parts: ModelBuilder, solutions: List[Tuple[Model, Dict]]): """Stage 2 (Optional)""" num_negation = 0 while True: mnegation = None if header.negation: - mnegation = parse_single_negation(infile, size) + mnegation = parse_single_negation(infile, current_model_parts.size) if mnegation is None: break num_negation += 1 - process_orders(infile, header, size, carrier_set, num_negation, mnegation) + current_model_parts.num_negation = num_negation + current_model_parts.mnegation = mnegation + + process_orders(infile, header, current_model_parts, solutions) if not header.negation: break -def process_orders(infile: SourceFile, header: UglyHeader, size: int, carrier_set: Set[ModelValue], num_negation: int, mnegation: Optional[ModelFunction]): +def process_orders(infile: SourceFile, header: UglyHeader, current_model_parts: ModelBuilder, solutions: List[Tuple[Model, Dict]]): """Stage 3""" num_order = 0 while True: - result = parse_single_order(infile, size) + result = parse_single_order(infile, current_model_parts.size) if result is None: break - mconjunction, mdisjunction = result num_order += 1 - process_designateds(infile, header, size, carrier_set, num_negation, mnegation, num_order, mconjunction, mdisjunction) + mconjunction, mdisjunction = result + current_model_parts.num_order = num_order + current_model_parts.mconjunction = mconjunction + current_model_parts.mdisjunction = mdisjunction + process_designateds(infile, header, current_model_parts, solutions) -def process_designateds(infile: SourceFile, header: UglyHeader, size: int, carrier_set: Set[ModelValue], num_negation: int, mnegation: Optional[ModelFunction], num_order: int, mconjunction: Optional[ModelFunction], mdisjunction: Optional[ModelFunction]): +def process_designateds(infile: SourceFile, header: UglyHeader, current_model_parts: ModelBuilder, solutions: List[Tuple[Model, Dict]]): """Stage 4""" num_designated = 0 while True: - designated_values = parse_single_designated(infile, size) + designated_values = parse_single_designated(infile, current_model_parts.size) if designated_values is None: break num_designated += 1 - process_implications(infile, header, size, carrier_set, num_negation, mnegation, num_order, mconjunction, mdisjunction, num_designated, designated_values) + current_model_parts.num_designated = num_designated + current_model_parts.designated_values = designated_values + process_implications(infile, header, current_model_parts, solutions) def process_implications( - infile: SourceFile, header: UglyHeader, size: int, carrier_set: Set[ModelValue], num_negation: int, mnegation: Optional[ModelFunction], - num_order: int, mconjunction: Optional[ModelFunction], mdisjunction: Optional[ModelFunction], num_designated: int, designated_values: Set[ModelValue]): + infile: SourceFile, header: UglyHeader, current_model_parts: ModelBuilder, solutions: List[Tuple[Model, Dict]]): """Stage 5""" - results = parse_implications(infile, size) + results = parse_implications(infile, current_model_parts.size) for num_implication, mimplication in enumerate(results, 1): - process_model(size, carrier_set, num_negation, mnegation, num_order, mconjunction, mdisjunction, num_designated, designated_values, num_implication, mimplication) + current_model_parts.num_implication = num_implication + current_model_parts.mimplication = mimplication + process_model(current_model_parts, solutions) -def process_model( - size: int, carrier_set: Set[ModelValue], num_negation: int, mnegation: Optional[ModelFunction], - num_order: int, mconjunction: Optional[ModelFunction], mdisjunction: Optional[ModelFunction], num_designated: int, - designated_values: Set[ModelValue], num_implication: int, mimplication: ModelFunction): +def process_model(mp: ModelBuilder, solutions: List[Tuple[Model, Dict]]): """Create Model""" - global solutions + assert mp.mimplication is not None + assert len(mp.carrier_set) > 0 - logical_operations = { mimplication } - model_name = f"{size}{'.' + str(num_negation) if num_negation != 0 else ''}.{num_order}.{num_designated}.{num_implication}" - model = Model(carrier_set, logical_operations, designated_values, name=model_name) + logical_operations = { mp.mimplication } + model_name = f"{mp.size}{'.' + str(mp.num_negation) if mp.num_negation != 0 else ''}.{mp.num_order}.{mp.num_designated}.{mp.num_implication}" + model = Model(mp.carrier_set, logical_operations, mp.designated_values, name=model_name) interpretation = { - Implication: mimplication + Implication: mp.mimplication } - if mnegation is not None: - logical_operations.add(mnegation) - interpretation[Negation] = mnegation - if mconjunction is not None: - logical_operations.add(mconjunction) - interpretation[Conjunction] = mconjunction - if mdisjunction is not None: - logical_operations.add(mdisjunction) - interpretation[Disjunction] = mdisjunction + if mp.mnegation is not None: + logical_operations.add(mp.mnegation) + interpretation[Negation] = mp.mnegation + if mp.mconjunction is not None: + logical_operations.add(mp.mconjunction) + interpretation[Conjunction] = mp.mconjunction + if mp.mdisjunction is not None: + logical_operations.add(mp.mdisjunction) + interpretation[Disjunction] = mp.mdisjunction solutions.append((model, interpretation)) print(f"Parsed Matrix {model.name}") @@ -343,7 +364,7 @@ if __name__ == "__main__": parser = argparse.ArgumentParser(description="VSP Checker") parser.add_argument("--verbose", action='store_true', help="Print out all parsed matrices") args = vars(parser.parse_args()) - parse_matrices(SourceFile(sys.stdin)) + solutions = parse_matrices(SourceFile(sys.stdin)) print(f"Parsed {len(solutions)} matrices") num_has_vsp = 0 for i, (model, interpretation) in enumerate(solutions):