Parser Rule Engine Decoupling for Formal Language Modification

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Conventional methods for modifying files written in formal languages, such as computer programs, face challenges in flexibility and maintainability due to the tight integration of modification rules with parsing code, requiring recreation of parsers for each modification.

Innovation Solution

A system comprising a parser and a rule engine separates the parsing of formal language files from the application of modification rules, allowing the parser to generate a data structure and issue queries to the rule engine for evaluation, thereby decoupling the definition and application of rules.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of manufacture

If modification rules are tightly integrated with parser code, then the parsing and modification can be performed together, but the system becomes difficult to maintain and requires recreation of the parser for each modification

Engineering Contradiction:

ImproveEase of maintaining modification rulesVSAvoidComplexity of parser structure

Core Design Contradiction:

Ease of manufactureVSDevice complexity

Solution Approach 1:

The system segments the formal language processing system into two independent components: a parser that handles lexical analysis and syntax parsing, and a separate rule engine that handles modification rules. This segmentation allows each component to be developed, maintained, and modified independently, resolving the contradiction between ease of maintenance and system complexity.

Inventive Principle:

Principle #1Segmentation

Solution Approach 2:

The modification rules are extracted from the parser code and placed into a separate rule engine. This extraction eliminates the need to modify parser code when adding or changing modification rules, making the system easier to maintain while keeping the parser structure simple and stable.

Inventive Principle:

Principle #2Taking out (Extraction)

2Adaptability or versatility

If the parser is recreated for each modification, then the modification can be implemented, but the development time and complexity increase

Engineering Contradiction:

ImproveAbility to apply different modification rulesVSAvoidTime to recreate parser

Core Design Contradiction:

Adaptability or versatilityVSLoss of time

Solution Approach 1:

The parser is designed as a universal component that can work with any set of modification rules through the rule engine interface. Once the parser is built, it can be reused indefinitely with different rule sets, providing adaptability without requiring recreation, thus eliminating time loss while maintaining versatility.

Inventive Principle:

Principle #6Universality (Multi-functionality)

3Productivity

If modification rules are interspersed with parser code, then the processing can be done in one pass, but the code becomes difficult to maintain and reuse

Engineering Contradiction:

ImproveProcessing efficiencyVSAvoidEase of maintaining code

Core Design Contradiction:

ProductivityVSEase of operation

Solution Approach 1:

The rule engine serves as an intermediary between the parser and the modification rules. The parser issues queries to the rule engine during the parsing process, and the rule engine returns evaluation results. This intermediary mechanism maintains processing efficiency while keeping the parser code clean and separate from modification logic, improving maintainability.

Inventive Principle:

Principle #24Intermediary (Mediator)

Data Source

PatentUS9063744B2Modifying a file written in a formal language

Publication Date: 2015.06.23 CA TECH INC

AI summary

In certain embodiments, a method for modifying a file written in a formal language comprises: (1) parsing an input file written in a formal language to generate a data structure of the input file; (2) issuing, during generation of the data structure, one or more queries to a rule engine for evaluation of one or more rules for modifying the input file; and (3) generating the data structure according to the evaluation of the one or more rules.