Modular complier with a class independent parser and a plurality of class dependent parsers

• US 4,914,585 A
• Filed: 05/23/1988
• Issued: 04/03/1990
• Est. Priority Date: 05/23/1988
• Status: Expired due to Term

• Current Assignee: Hewlett-Packard Company (HP Inc.)
• Original Assignee: Hewlett-Packard Company (HP Inc.)
• Inventors: Packard, Barbara B., Stearns, Glenn, Watson, Ralph T.
• Primary Examiner(s): Zache, Raulfe B.
• Application Number:
  US07/197,795
• Time in Patent Office: 680 Days
• Field of Search: 364/200, 364/300, 364/900
• US Class Current: 716/106
• CPC Class Codes: G06F 8/427 Parsing

Abstract

A modular compiler is used to compile code for execution by an agent engine and a plurality of application programs. The modular compiler includes a class independent compiler which parses program code which is to be executed by the agent engine. The modular compiler also includes a class dependent parser for each application program. Each class dependent parser parses program code which is to be executed by its respective application program. When an application program is added to the computing system, an associated class dependent parser is added to the modular compiler. When an application program is removed from the computing system, the associated class dependent parser is removed from the modular compiler.

Claims

1. In a computing system having a plurality of applications and a primary executing program, a modular compiler comprising:

a class independent parser for parsing program code which includes commands to be executed by the primary executing program;

a plurality of class dependent parsers, each class dependent parser for parsing program code which includes commands to be executed by one application from the plurality of applications, each class dependent parser being added to the modular compiler and logically coupled to the class independent parser when an application for which that class dependent parser parses program code which includes commands to be executed by the application is added to the computing system, and each class dependent parser being removed from the modulator compiler when the application is removed from the computing system.

2. A modulator compiler as in claim 1 additionally comprising:

a scanner, logically coupled to the class independent parser, which scans a source file containing code and delivers tokens to the class independent parser and each class dependent parser in the plurality of class dependent parsers; and

,

an expression parser, logically coupled to the class independent parser and called by the class independent parser and each class dependent parser added to the modular compiler, which parses expressions and returns expression tokens to the scanner.

3. In a computing system having a plurality of applications and a primary executing program, a modular compiler comprising:

a class independent parser for parsing program code which includes commands to be executed by the primary executing program;

first scanner routine, logically coupled to the class independent parser, which returns a token to the class independent parser when the first scanner routine is called by the class independent parser;

a plurality of class dependent parsers, logically coupled to the first scanner routine, called by the first scanner routine, each class dependent parser parsing a different set of commands;

a plurality of scanner routines, one scanner routine from the plurality of scanner routines being called by a class dependent parser from the plurality of class dependent parsers so that each class dependent parser, is logically coupled to and calls its own scanner routine, and the called scanner routine returns a token to a calling class dependent parser; and

,

an input stream processor, logically coupled to and called by the first scanner routine and each scanner routine from the plurality of scanner routines, which returns a token to the scanner routine calling the input stream processor.

4. A modular compiler as in claim 3 additionally comprising:

an expression parser, logically coupled to and called by the class independent parser and each of the class dependent parsers, which parses expressions.

5. A modular compiler as in claim 3, wherein the first scanner routine includes a focus means for determining which one out of the class dependent parsers and the input stream processor to call.

6. A modular compiler as in claim 3, wherein the first scanner routine includes means for calling the input stream processor and returning the token received from the input stream processor to the class independent parser upon one of the class dependent parsers returning an error.

7. In a computing system, a method for compiling program code into commands to be executed by a primary executing program and a plurality of applications, each application executing a different set of commands, the method comprising the steps performed by a computer of:

(a) parsing program code which contains commands to be executed by the primary executing program using a class independent parser; and

(b) parsing program code which contains commands to be executed by an application with a class dependent parser which parses commands for that application.

8. In a computing system, a method for generating code using a class independent parser, at least one class dependent parser, a class independent scanner routine for the class independent parser and a class dependent scanner routine for each class dependent parser, the method comprising the steps performed by a computer of:

(a) calling the class independent scanner routine from the independent parser;

(b) when a first class dependent parser has precedence performing the following substeps;

(b.1) calling from the class independent scanner routine the first class dependent parser;

(b.2) at least once calling from the first class dependent parser a first class dependent scanner for the first class dependant parser;

(b.3) returning from the first class dependent scanner to the first class dependent parser a token every time the first class dependent parser calls the first class dependent scanner;

(b.4) attempting with the first class dependent parser to parse tokens received from the first class dependent parser;

(b.5) returning from the first class dependent parser to the class independent scanner routine an error when the first class dependent parser is unable to parse a token received from the first class dependent scanner;

(c) returning a token from the class independent scanner routine to the class independent parser.

9. A method as in claim 8 wherein substep (b.4) includes the following substep:

(b.4.a) calling semantic routines to generate application dependent commands embedded within code when the first class dependent parser recognizes the tokens received from the first class dependent scanner, the commands to be extracted by a primary executing program and forwarded to an application for execution.

10. A method as in claim 9 additionally comprising the following step:

(d) when the independent parser recognizes the token from the scanner, calling semantic routines to generate code for execution by the agent.