CA2346925A1 - Method and system for an extensible macro language - Google Patents
Method and system for an extensible macro language Download PDFInfo
- Publication number
- CA2346925A1 CA2346925A1 CA002346925A CA2346925A CA2346925A1 CA 2346925 A1 CA2346925 A1 CA 2346925A1 CA 002346925 A CA002346925 A CA 002346925A CA 2346925 A CA2346925 A CA 2346925A CA 2346925 A1 CA2346925 A1 CA 2346925A1
- Authority
- CA
- Canada
- Prior art keywords
- macro
- language
- keyword
- keywords
- code
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/466—Transaction processing
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99931—Database or file accessing
- Y10S707/99933—Query processing, i.e. searching
- Y10S707/99936—Pattern matching access
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99941—Database schema or data structure
- Y10S707/99943—Generating database or data structure, e.g. via user interface
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99941—Database schema or data structure
- Y10S707/99944—Object-oriented database structure
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99941—Database schema or data structure
- Y10S707/99944—Object-oriented database structure
- Y10S707/99945—Object-oriented database structure processing
Abstract
A method and system for an extensible macro language is provided. The system for providing the extensible language includes a parser and a macro handler (110) for processing macro commands not previously defined in the macro language. The parser (102) analyzes keywords in a macro language expression and recognizes one or more keywords (116) representing macro commands that were not previously defined in the macro language. The macro handler (110) receives the keyword in the macro expression and retrieves from a registry o f keywords, an executable code or procedure (112) associated with the keyword. The executable code (112) is run to process the macro command represented by the keyword. The template language registry may be argumented to include any keywords and associated codes for extending the macro language.
Description
METHOD AND SYSTEM FOR AN EXTENSIBLE MACRO LANGUAGE
$ CROSS-REFERENCE TO RELATED APPLICATIONS, The present application claims benefit of the filing date of U.S. Patent Application No. 60/104,682 entitled MODELING TOOL SYSTEMS AND METHODS, filed on October 16, 1998.
The present application is related to co-pending U.S.
Patent Application No. (Attorney Docket #22074661-25531) entitled METHOD FOR DETERMINING DIFFERENCES BETWEEN
1$ TWO OR MORE MODELS, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
The present application is related to a co-pending U.S. Patent Application No. (Attorney Docket #22074561-25532) entitled METHOD FOR IMPACT ANALYSIS OF A
MODEL, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
$ CROSS-REFERENCE TO RELATED APPLICATIONS, The present application claims benefit of the filing date of U.S. Patent Application No. 60/104,682 entitled MODELING TOOL SYSTEMS AND METHODS, filed on October 16, 1998.
The present application is related to co-pending U.S.
Patent Application No. (Attorney Docket #22074661-25531) entitled METHOD FOR DETERMINING DIFFERENCES BETWEEN
1$ TWO OR MORE MODELS, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
The present application is related to a co-pending U.S. Patent Application No. (Attorney Docket #22074561-25532) entitled METHOD FOR IMPACT ANALYSIS OF A
MODEL, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
2$ The present application is related to co-pending U.S.
Patent Application No. (Attorney Docket #220?4661-25534) entitled METHOD AND APPARATUS FOR PROVIDING ACCESS
TO A HIERARCHICAL DATA STORE THROUGH AN SQL INPUT, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
SUBSTITUTE SKEET (RULE 26) The present application is related to a co-pending U.S. Patent Application No. (Atty. Docket '#22074661-25535) entitled APPARATUS AND METHOD FOR MODELING~.TOOLS, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
DESCRIPTION
TECHNICAL FIELD OF THE INVENTION
The present invention relates in general to computer language processors and, particularly to an extensible macro language.
BACKGROUND OF THE INVENTION
A macro is a set of commands that can be played back to perform a given task. Examples of these tasks include inserting a commonly used name and address into a word 20 processor or executing a series of keystrokes to format a file. Tasks performed by macros are typically repetitive in nature allowing significant savings in time by executing the macro instead of manually repeating the commands.
25 Currently, different applications allow users to write macros and scripts within the confines of the allowed domain, i.e., within the confines of the specific application. For example, word processors typically allow users to create a macro by recording series of keystrokes 30 to be played back later. Other applications allow users to SUBSTITUTE SHEET (RULE 26) cxeate macros for retrieving and manipulating data within the confines of the applications. Thus, these applications include a limited set of macros, e.g., macro for recording keystrokes, a macro for retrieving data. The usex is then 5 typically limited to the macros provided by the application.
Frequently, however, each user using an application has a unique set of instructions or commands that the user would like to include as a macro in the application which was not previously provided. Because the macros are typically hard coded into the applications or into the macro language included in the applications, the only available method currently available to include additional macros into the application is to hard code the new macros into the application by modifying the source code~and recompiling it before the new macro can be used. Usually, however, this presents a problem because the user is not given an access to the source code of the macro language or 20 the application to modify. Moreover, it would be a tremendous burden on the application developers to try to cater to each individual user's preferences by customizing the applications to include the macros that the user would like to have.
Therefore, it is highly desirable to have an extensible macro language that would allow users to modify and extend the language to include their preferences when using the macro language. Furthermore, it is also highly SUBSTITUTE SHEET (RULE 26) desirable to be able to allow the users to extend the macro without having to modify or access the source coda of the macro language since the source code is treated as a proprietary property not distributed to the users, SUMMARY OF THE INVENTION
To overcome the above shortcomings of the prior art macro language processors the present invention provides an extensible macro language that allows users to write new macro commands that include procedures tailored to the specific needs of the users without a need to modify any source code of the macro language processor. The extensible macro language is enabled to process the new macro commands by recognizing the new macro commands unknown to the language and associating the new macro commands with procedure calls stored in a registry, i.e., a repository, thereby allowing dynamic extension of a macro language.
zo In the present invention, a mechanism fox dynamically registering new macro commands in a registry is also provided for allowing extensibility. To register new macro commands, the users may insert keywords representing the ?3 new macro commands and the associated codes or procedures in the registry for execution by the extensible macro language.
SUBSTITUTE SHEET (RULE 26) The present invention also defines a simplistic syntax fox the extended macro language for recognizing the new macro commands for what they are without needing Co know what functians they perform.
Patent Application No. (Attorney Docket #220?4661-25534) entitled METHOD AND APPARATUS FOR PROVIDING ACCESS
TO A HIERARCHICAL DATA STORE THROUGH AN SQL INPUT, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
SUBSTITUTE SKEET (RULE 26) The present application is related to a co-pending U.S. Patent Application No. (Atty. Docket '#22074661-25535) entitled APPARATUS AND METHOD FOR MODELING~.TOOLS, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
DESCRIPTION
TECHNICAL FIELD OF THE INVENTION
The present invention relates in general to computer language processors and, particularly to an extensible macro language.
BACKGROUND OF THE INVENTION
A macro is a set of commands that can be played back to perform a given task. Examples of these tasks include inserting a commonly used name and address into a word 20 processor or executing a series of keystrokes to format a file. Tasks performed by macros are typically repetitive in nature allowing significant savings in time by executing the macro instead of manually repeating the commands.
25 Currently, different applications allow users to write macros and scripts within the confines of the allowed domain, i.e., within the confines of the specific application. For example, word processors typically allow users to create a macro by recording series of keystrokes 30 to be played back later. Other applications allow users to SUBSTITUTE SHEET (RULE 26) cxeate macros for retrieving and manipulating data within the confines of the applications. Thus, these applications include a limited set of macros, e.g., macro for recording keystrokes, a macro for retrieving data. The usex is then 5 typically limited to the macros provided by the application.
Frequently, however, each user using an application has a unique set of instructions or commands that the user would like to include as a macro in the application which was not previously provided. Because the macros are typically hard coded into the applications or into the macro language included in the applications, the only available method currently available to include additional macros into the application is to hard code the new macros into the application by modifying the source code~and recompiling it before the new macro can be used. Usually, however, this presents a problem because the user is not given an access to the source code of the macro language or 20 the application to modify. Moreover, it would be a tremendous burden on the application developers to try to cater to each individual user's preferences by customizing the applications to include the macros that the user would like to have.
Therefore, it is highly desirable to have an extensible macro language that would allow users to modify and extend the language to include their preferences when using the macro language. Furthermore, it is also highly SUBSTITUTE SHEET (RULE 26) desirable to be able to allow the users to extend the macro without having to modify or access the source coda of the macro language since the source code is treated as a proprietary property not distributed to the users, SUMMARY OF THE INVENTION
To overcome the above shortcomings of the prior art macro language processors the present invention provides an extensible macro language that allows users to write new macro commands that include procedures tailored to the specific needs of the users without a need to modify any source code of the macro language processor. The extensible macro language is enabled to process the new macro commands by recognizing the new macro commands unknown to the language and associating the new macro commands with procedure calls stored in a registry, i.e., a repository, thereby allowing dynamic extension of a macro language.
zo In the present invention, a mechanism fox dynamically registering new macro commands in a registry is also provided for allowing extensibility. To register new macro commands, the users may insert keywords representing the ?3 new macro commands and the associated codes or procedures in the registry for execution by the extensible macro language.
SUBSTITUTE SHEET (RULE 26) The present invention also defines a simplistic syntax fox the extended macro language for recognizing the new macro commands for what they are without needing Co know what functians they perform.
According to the goals of the present invention, there is provided a parser and a macro handler for processing macro commands not previously defined in the macro language. The macro commands not previously defined or undefined in the macro language refer to those macro commands that were not included in the set of commands available in the macro language at the time of release and distribution to the users. The parser analyzes keywords in a macro language expression and recognizes one or more keywords representing macro commands that were not previously defined in the macro language. The macro handler receives the keyword in the macro expression and retrieves from a registry of keywords, an executable code associated with the keyword. The executable code is run to process the macro command represented by the keyword. The registry of keywords may be augmented to include any keywords and associated codes for extending the macro language.
Further features and advantages of the present invention as well as the structure and operation of various embodiments of the present invention are described in detail below with reference to the accompanying drawings.
SUBSTITUTE SHEET (RULE 26) In the drawings, like reference numbers indicate identical or functionally similar elements.
$ BRIEF DESCRIPTION OF THE DRAWINGS
Preferred embodiments of the present invention will now be described, by way of example only, with reference to the accompanying drawings in which:
Figure 1 is a block diagram illustrating the components of the extensible macro language of the present invention; and 1$ Figure 2 illustrates an example of a macro expression having an iterator macro.
DETAILED DESCRIPTION OF THE INVENTION
The present invention is directed to an extensible macro language which may be extended dynamically in the runtime environment without having to rebuild and recompile the macro language. Although the extensible macro language 2$ may include a predetermined set of macro commands, the present invention allows users to add additional or new macro commands as desired. Figure 1 is a block diagram 100 illustrating the components of the system for providing the extensible macro language of the present invention. The SUBSTITUTE SHEET (RULE 26) parser 102 includes a grammar or syntax 104 that the parser 102 employs to analyze and parse a given expression. As shown in Figure 1, the parser 102 receives a macro language expression 106 and parses the expression into components according to the syntax 104 of the macro language. The syntax used in one embodiment of the present invention will be described in more detail hereinbelow. Referring back to Figure 1, the parser 102 reads the expression 106 recognizing certain tokens predefined in the syntax that indicate a presence of a new macro command. In this example, when the parser 102 encounters curly braces in the expression 106, parser 102 treats the keywords, for example, "property (name)", embedded within the braces as a new macro command. Moreover, the parser 102 recognizes, based on the syntax 104, that the "name" embedded within the parenthesis is a parameter to the new macro c6mmand.
Other aspects of the syntax 104 may dictate that a string of characters outside any symbols to be interpreted as a literal string. Accordingly, the parser 102 breaks each element in the expression into components as shown at 108.
A novel feature of the parser 102 in the present invention is that the parser 102 is transparent to the actual content within the tokens, i.e., curly braces. That is, as long as the new macro commands or keywords are embedded within a 25 recognizable token, the parser 102 breaks the keywords down into components regardless of whether the keywords have been predefined in the macro language. Thus, as shown at 108, the macro expression 106 is broken down into components according to the syntax 104 of the extended SUBSTITUTE SHEET (RULE 26) WO 00123919 PCT/US99l24115 macro language. The new keyword "property" is broken down as a token component lOBa; the string "name" within the parenthesis is broken down as a parameter component 108b;
the string "likes" is broken down as a literal component 108c; and the string "pizza" is also broken down as a literal component 108d.
As shown in Figure 1, the present invention also includes a macro handler 110, and a repository 112 having keywords and their corresponding executable codes. The executable codes may be stored in the repository 112 as a pointer to the actual codes 114 for execution. The repository 112 includes one or more keywords and associated codes, and may be dynamically modified, e.g., new keywords and codes added to it as need arises by a user of the macro language. The repository 112 in the present invention may be a simple file with a table of keywords and associated codes. Alternatively, a separate database may be used as the repository 112.
After the macro expression has been parsed into separate components as described above with reference to the parser 102, the components are then passed to the macro handler 110 for additional processing. For the token component having the keyword "property" 108a, the macro handler checks a repository to the keyword "property". If found, the code associated with the keyword "property" is retrieved and executed. In executing the code, the macro handler 110 passes all the parameters found in the macro SUBSTITUTE SKEET (RULE 26) expression and parsed as parameters, to the executing code.
The macro handler 110 does not need to know any other processing that may be performed inside the code i~.self.
All that the macro handler 110 needs to recognize, is that the "property" is a keyword to be looked up in the repository 112 for its corresponding code, and the specified corresponding code in the repository 112 to be executed with any parameters. The corresponding code is typically specified in the repository 112 as a pointer to the actual code itself 114.
After the proper execution of the code 114 specified in the repository, the macro handler 110 accepts one or more outputs, if any, of the executed code and places the IS outputs back into the macro expression in place of the keyword. Thus, in the example shown in Figure 1,'the output of the code associated with the "property" with the parameter "name" may be MARY. Consequently, the result of the extended macro expression "{property (name)} likes pizza" at 106 is "Mary likes pizza" as shown at 116.
A novel feature of the present invention is that the macro handler, like the parser, need not know anything in the code or what type of functions are being performed by the executable code. The macro handier merely provides an initiation into the executable code hhat is associated with the keyword. In an exemplary embodiment of the present invention, it is left up to the users to define exactly what the code should do, and consequently, therefore, what SUBSTITUTE SHEET (RULE 26) command the keyword is to perform, thus providing a flexible and extensible macro language.
In the above example, the output MARY may have been 5 obtained in various ways transparent to the macro language.
For example, the name MARY may have been obtained by performing a search from the World Wide Web, or may have been obtained from a database using a query language, further illustrating the extensibility afforded by the 10 present invention.
~e Language Syntax The syntax or the grammar employed in one embodiment of the extensible macro language will now be described in detail. The extensible macro language of the present invention includes a syntax (Figure 1 104) comprising literals, macros, comments and operator/scoping characters.
Literal The syntax in this embodiment treats all text outside of curly braces as a literal, and is emitted exactly as typed. Within curly braces, text inside double quotes is treated as a literal. Such a scheme allows for embedding of a literal within macro calls. Some examples of a literal are illustrated as follows:
This text would be emitted just like this;
SUBSTITUTE SHEET (RULE 26) {"So would this text"}
Macros Macros include instructions to the macro processor, like procedures or functions in a programming language.
According to the syntax defined in the present invention, all macros are embedded within curly braces. In one embodiment, the macros fall into two categories: procedures macros and iterator macros.
Procedure macros are designed to perform some work.
They may expand to a value; they may declare a variable;
they may invoke a process. The actions performed axe entirely specified by the designer of the macro. In one embodiment, the macros must, however, return a "ttue" value upon successful completion of their task and a "false"
value upon failure.
The following expression illustrates a string literal, followed by a macro call for getting the page number when printing:
My Model Report - Page {HeaderPage} . Input My Model Report - Page 1 . Output In the above example, the HeaderPage is a macro defined by a user to extract a page number.
SLTBSTITLT~'E SHEET (RULE 26) Iterator macros allow the user to traverse across data structures. Iterators are distinguished by the ketywords "begin" and "end" that delimit a block of code following the iterator declaration. The code within the "begin/end"
block is executed once for each iteration. When the iterator has moved across all objects in its pool, control breaks out of the iteration block and continues to execute a next statement in the macro expression after the block.
The following block of macro expression illustrates a use of the iterator macro:
MyIterator begin DoSomething end In the above example, the procedure macro "DoSomething" executes once for each element returned by the "MyIterator" macro. The curly braces surrounding the entire fragment indicates that all expression within the ?3 braces is to be treated as macro code.
Parameters SUBSTITUTE SHEET (RULE 26) The syntax defined in the extensible macro language of the present invention allows for both procedure anjd iterator to accept and process parameters. Parameters may include strings, or other macros. To distinguish.
parameters, the parameters are enclosed within parenthesis following the macro. Macros may accept variable-length parameter lists, as desired. The following illustrates a macro expression having a parameter "foo":
{MacroWithParameters ("foo")~
Control blocks In some instances, it is desirable to have a block of a macro expression to fail if any portion of it fails. The following example illustrates one such instance:
{FirstName [MiddleInitial "."] LastName}
If there was no middle initial, the MiddleInitial macro would return a nil value or a fail value. In that case, the literal "." should not be printed. To accommodate for such conditions, the present invention includes in its syntax, square brackets ("[J") that denote a conditional expression. Thus, if the macro within the square brackets fails, the rest of the expression in the square brackets is not emitted. In the above example, if the MiddleInitial failed for lack of value, the literal "."
is not be printed.
SUBSTTTUTE SHEET (RULE 26) The conditional blocks have internal scope, i~.e., the failure of a conditional block does not affect the, surrounding code. For conditions in a block to affect the outer block, the syntax additionally includes what is referred to as a propagating conditional denoted by angle brackets. If any macro within a pair of angle brackets fails, the block within the angle brackets as well as the next outer block fails. The following examples illustrate macro expression with a conditional and a propagating conditional:
{ Print " " [ Print [ Fail ] ] ~ . input foo foo . output Print " " ( Print < Fail > ] ~ . input foo . output In both examples the "Print" macro outputs the word "foo". In the first example, the failed macro in square brackets is contained within its block. Thus, the next outer block having "Print" is executed ~,s well as the first "Print", resulting in the output "foo foo". In the second example, when a macro within angle brackets fails, the failure is propagated to the next block having the "Print"
macro. Thus, the next outer block with "Print" is not executed. Since this Print macro is contained within a pair of square brackets, the failure is contained in the SUBSTITUTE SHEET (RULE 26) black. Thus, the first "Print" macro is executed, resulting in the output "foo".
Figure 2 illustrates an example of a macro expression 5 including an iterator macro of the present invention. As described with reference to Figure I, the keyword "ForEach"
is recognized by the parser 102 (Figure 1) as a macro, and the word "Employee" is recognized as a parameter to the macro "ForEach". When the macro handler receives the token 10 keyword "ForEach", the macro handler 110 (Figure 1) performs a look-up of the keyword "ForEach" in the registry 112 and executes the corresponding code. The code for "ForEach" macro, fox example, may include instructions to perform commands found within the begin/end block of the 15 macro expression for all sub-objects 204b, 204c in a given object 204 having the type of the specified parameter °employee". In this macro expression 202, another macro exists within the begin/end block. Accordingly, the macro handler 110 (Figure 1) performs a look-up of the keyword °Property" in the registry 112 and executes the corresponding code fox each of the sub-objects 204b, 204c having employee type as specified in the "ForEach" keyword.
The code associated with the "Property" keyword, for example, may include instructions to print the value of the type specified in the parameter of the keyword "Property", in this case, an employee name as specified by "EmpName".
Consequently, the result of the macro expression 202 is the autput shown at 208, "Mary John".
SUBSTTTUTE SHEET (RULE 16) The extensible macro language of the present invention is useful for customizing macros specific to the needs of individual users. For example, the extensible macro language has been interfaced with the UMA Model for retrieving various objects from the UMA Model, as desired by a user. The UMA is disclosed in a co-pending U.S.
Patent Application No. (Atty. Docket #22074661-25535) entitled APPARATUS AND METHOD FOR MODELING TOOLS, filed on October 15, 1999, the disclosure of which is incorporated herein by reference in its entirety thereto.
Appendix A includes a brief description of the extensible macro language of the present invention as used in the UMA
Model and referred to as the UMA Template Language. The description in Appendix A explains one embodiment of the extensible macro language and should in no way be read as limiting the scope and capabilities of the extensible macro language to the descriptions contained therein.
While the invention has been particularly shown and described with respect to an embodiment thereof, it will be understood by those skilled in the art that the foregoing and other changes in form and details may be made therein without departing from the spirit and scope of the invention.
SUBSTITUTE SHEET (RULE 26) Overview The purpose of this document is to provide a brief introduction to the template, language implemented in UMA. It assumes you have a working knowledge of the objecUproperty metamodel of UMA.
It is not intended to provide an exhaustive explanation of the architecture.
UMA team members can provide you with such an explanation and they can direct you to many code samples that use this facility.
The purpose of the UMA Template Language (UTL) is to provide scripting capabilities to any IJMA-based application. These capabilities can be used for various features, including (but not limited to):
~ Macro expansion: Runtime expansion of code templates against the model.
Examples include trigger code and stored procedures in OR~Compass, and Visual Basic and Java components in SQL~Compass.
~ Scripting: Execution of a series of commands against the model. An example is the controller code for Forward Engineering in OR~Compass.
The architecture of UTL is intended to promote its use in as many aspects of an UMA-based product as possible. This is accomplished by allowing the users maximum flexibility in tailoring the language to the specific needs of his product, while providing as much implementation support as possible and exposing mechanisms that allow reuse of new implementation code.
To accomplish these goals, UTL:
1. defines a minimal syntax for the language;
Z. allows the user to write procedures and interators;
3. provides a mechanism for registering the procedures and iterators in registries.
Syntax Summary The following is a brief summary of the syntax of LTTL intended to provide the bare minimum necessary to understand the implementation. More information can be found in the documentation shipped with OR~Compass 1Ø
Template code consists of literals, macros, comments and a few operatorlscoping characters. Currently, UTL views all code as strings: numeric values are described by their string representation; most macros evaluate to strings. etc.2 ' In this documeat, '~sd' refers to the UMA application developer, not the end-user of the application.
= LTfL 1S, expected this fall, will also support numeric modes of operation that will provide better perfoanance when dealing with numbers. This will be useful for features such as volumetric calculations.
SUBSTITUTE SHEET (RULE 26) Literals In template source code, all text outside of curly braces is treated as a literal, and is emitted exactly as typed. Within curly braces, text inside double quotes is treated as a literal. The former allows large blocks of boilerplate to be entered, e.g. the bod~r of a stored procedure. The latter allows you to embed literals within macro calls.
Example:
This text would emit just like this.
{~So would this text."}
Macros Macros are special instructions to the macro processor...basically procedures.
All macros are contained within curly braces. Macros basically fall into two categories:
procedure macros and iterator macros.
Procedure macros are designed to perform some work. They may expand to a value; they may declare a variable; they may invoke a process. The actions) performed are entirely specified by the designer of the macro. The only constraint upon them is that they return True upon successful completion of their task and False upon failure.
Example~tlre following shows a string literal, followed by a macro call for getting the page nun:ber when printing:
My Model Report - Page {AeaderPage} a Input My Model Report - Page 1 ø Output Iterator macros allow the user to traverse across data structures. Iterators are distinguished by the keywords begin and end that delimit a block of code following the iterator declaration. All of the code within this begin/end block will be executed once for each iteration. When the iterator has moved across all objects in its pool, control will break out of the iteration block and execute the first statement after the block.
Example-the following executes the procedure macro DoSometl:ing once for each element returned by the Mylterator macro. Note the curly braces surrour:ding the entire code fragment...indicating that all code within is to be treated as macro code.
MyIterator begin DoSomething end Macros, both procedure and iterator, can take parameters. Parameters are strings, or anything that evaluates to a string, such as another macro. If a macro takes parameters, they are enclosed in parentheses after the macro. Since forward declaration of macros is not required, macros may accept variable-length parameter lists, if desired.
SUBSTITUTE SHEET (RULE 26) Example:
{ MacroWfthParameters("foo") ) Control blocks Occasionally, it is desirable to have an entire block of teirtplate code fail if any piece of it fails. An example would be where there was some boilerplate text followed by an optional value; if the value was not present, the boilerplate should not be cmitfed.
Any code enclosed in square brackets is conditional: it will all fail if any piece of it fails.
"Failure" means that a macro will not execute and a literal will not be emitted.
Example-if there is ~:o n:fiddle nan:e, tl:e period will not emit:
{ FirstName (Middlelnitial "."] LastName }
Conditional blocks hide their internal scope. This means that the failure of a conditional block has no effect on the surrounding code. Any code enclosed in angle brackets is propagating conditional: it will fail if any piece of it fails and it will propagate that failure out to the next block.
The best way to distinguish these two types of blocks is with examples. In both examples, the Print macro emits the word "foo" and the Fail macro fails no matter what.
Example of conditional block:
{ Print " " [ Print I Fail ] 1 } a Input foo foo a Output Example of propagating condition block:
{ Print " " ( Print < Fail > J } a Input foo a Ouput Architecture LWMDataButler 'The desired capabilities of LJ'TL are achieved using an object called a data butler. Data butlers are responsible for providing implementations for the macros encountered by the macro processor when executing template code. When the macro processor is invoked, a data butler interface3 is supplied to it. Essentially, a data butler is a use of the Strategy pattan.4 s Iataface defined in LWMDataButlerh ~ See Gamma, Helm, 3ohason Vlissides, Desif~n Patterns SUBSTITUTE SHEET (RULE 26) This accomplishes the first goal of the language design. By providing different data butlers to the macro processor, the grammar of UTL can be configured for the a plication and task at hand. Each data butler implementation can accept a set of keyword~(macros) appropriate for its task and reject keywords that are not acceptable. Further, a given keyword can be implemented in different ways by different data butlers, allowing template code to be ignorant of the underlying implementation. This is useful in allowing multiple products to work from the same templates when their underlying data models differ.
The LWMDataButler interface has five entry points:
// Handle procedure macro with no parameters virtual LWTBoolean SubstituteValue( coast LWTString & MacroName, LWTString & ExpansionValue) = 0 ;
// Handle procedure macro with parameters virtual LWTBoolean SubstituteValue( coast LWTString & MacroName, LWMStringList & ParameterList.
LWTString & ExpansionValue ) = 0 ;
// Fandle iterator macro with no parameters virtual LWTBoolean StartIteration( coast LWTString & IterName ) = 0 ;
// handle iterator macro with parameters virtual LWTBoolean Startiteration( coast LWTString & IterName, LWMStringList & ParameterList ) = 0 ;
// Handle iterator macro iteration virtual LWTBoolean NextIteration( coast LWTString & IterName ) = 0 ;
MCDataButlerl The second design goal of LTTL was to provide as much functionality as possible to the Fuser and to allow them to publish their own code for reuse.
Since the metaphor of an UMA model deals with all data at a very abstract Level-objects and properties-many grammatical elements of a template language can be written abstractly. These elements can be aggregated together to form the major portion of the language needed by any UMA-based product. The user could extend this base in the few areas that are product-specific. Ideally, the language should be extendable not only by the user, but by'the end-user of the user's product. This is accomplished in our solution.
There are two basic problems that are addressed by the solution:
1. A mechanism is needed to share implementations. As new keywords are added, they must be published.
SUBSTITITTE SHEET (RULE 26) 2. A mechanism is needed to control the context of a macro's execution. By this we refer to both the state of the UMA model at the time of execution, and to the specific objects) or property(ies) the macro affects.
To meet these criteria, a base implementation of a data butter exists in UMA.
This implementation, MCDataButlerIs, provides mechanisms fbr defining the desired grammar incrementally and for managing contextual information in an LIMA model.
This implementation is a superset of the LWMDataButler interface. Though the LWMDataButler interface is exposed, the user need not concern himself with it when implementing a data butler. The implementation in MCDataButlerI accomplishes all that has been found necessary to do in terms of implementing the LWMDataButler interface.
First, MCDataButlerI manages a registry of macro handlers. A macro handler is an object that knows how to perform a certain action, given a context.
Conceptually, a macro handler is an example of a Command pattern 6 The data butler maintains a dictionary of macro handlers keyed by macro name. When the macro processor requests the data butler to handle a macro (e.g. via SubstituteValue~ ), the data butler locates the appropriate macro handler in its dictionary and delegates control to it. The macro handler processes the request and returns control to the data butler who simply forwards the return value (if any) and Lhe success state to the macro processor.
A macro handler exposes an interface that is used by the data butler for invocation:
virtual LWTBoolean Execute( M~ataButlerI * Butler, coast LWTString & MacroName.
LWMStringList * Parameters.
L4lTString * Expansionvalue) - o;
MCDataButlerI exposes an implementation signature for registering new handlers:
void AddHandler( coast LWTString & Macro.
MCMacroHandler8ase * Handler):
In order to implement a grammar, a user can construct an implementation of an MCDataButierI and implement all required macro handlers. Alternatively, since the macro handler registry is a member variable of a data butler instead of a singleton, the user can subclass an existing data butler. This provides the user with all macros known to the subclass, plus those they develop. An example of this is the OR~Compass Forward Engineering data butler, it subclasses MCDataButler. The latter implements a wide variety of generic macros for creating objects, reading properties, iterating, constructing variables, etc. The Forward Engineering data butler implements one or two macros associated only with Forward Engineering (such as a macro for determining the correct s Implemcatation found in MCDataButlcrInterface.h ~ Op ci~. DesiRn Pattctns, SUBSTITUTE SHEET (RULE 26) execution command for a database) and ends up with a complete grammar for emitting DDL.
Second, MCDataButlerI manages a context stack. The context stack allows a Macro handler to know what object in the UMA model is being referenced when the macro executes. For example, the property ( ) macro retrieves a named property front an object. The macro handIcr for Property ( ) needs to know which object it should query.
MCDataButlerI maintains a stack of object references and exposes an interface for pushing and popping objects on this stack, as well as for querying the stack.
Macro handlers can query this interface to find out the context of their operation.
MCObject * LietCurrentContext(vofd);
void PopCurrentContext(void)r void PushCurrentContext(MCObject * Object):
Additionally, MCDataButlerI exposes a facility that allows MCObject iterators to manage the context automatically. Macro handlers for iterator macros can instantiate an iterator proxy. This is an object that automatically maintains the context stack for the iterator.
Upon instantiation, it pushes the first object being iterated onto the context stack. Each subsequent iteration causes a pop and a push to occur. When there are no more items to traverse, the stack is popped, leaving it in the state that existed when the iterator was encountered. These iterator proxies are maintained itr a stack of their own in order to manage nested iterators.
Example-the following sanrple code shows how the Property macro would behave d~erently depending upon the context. Assturre an entity named "MyTablel "that has an attribute "MyColuntnl " and a second attribute "MyColtcnrn2. "Assume a secorrd entity named "MyTable2" that has an attribute "MyColurnn3. " At the time tlris template code executes, we presume that the stack currently has the model on top due to some other cods ForEach( "UOEntities" ) begin property( "UPName" ) ForEach( "UPAttributes"
begin Property( "UPName" ) end and Input MyTablei MyColumni MyColumn2 MyTable2 MyColumn3 a Output SUBSTITUTE SHEET (RULE 26)
Further features and advantages of the present invention as well as the structure and operation of various embodiments of the present invention are described in detail below with reference to the accompanying drawings.
SUBSTITUTE SHEET (RULE 26) In the drawings, like reference numbers indicate identical or functionally similar elements.
$ BRIEF DESCRIPTION OF THE DRAWINGS
Preferred embodiments of the present invention will now be described, by way of example only, with reference to the accompanying drawings in which:
Figure 1 is a block diagram illustrating the components of the extensible macro language of the present invention; and 1$ Figure 2 illustrates an example of a macro expression having an iterator macro.
DETAILED DESCRIPTION OF THE INVENTION
The present invention is directed to an extensible macro language which may be extended dynamically in the runtime environment without having to rebuild and recompile the macro language. Although the extensible macro language 2$ may include a predetermined set of macro commands, the present invention allows users to add additional or new macro commands as desired. Figure 1 is a block diagram 100 illustrating the components of the system for providing the extensible macro language of the present invention. The SUBSTITUTE SHEET (RULE 26) parser 102 includes a grammar or syntax 104 that the parser 102 employs to analyze and parse a given expression. As shown in Figure 1, the parser 102 receives a macro language expression 106 and parses the expression into components according to the syntax 104 of the macro language. The syntax used in one embodiment of the present invention will be described in more detail hereinbelow. Referring back to Figure 1, the parser 102 reads the expression 106 recognizing certain tokens predefined in the syntax that indicate a presence of a new macro command. In this example, when the parser 102 encounters curly braces in the expression 106, parser 102 treats the keywords, for example, "property (name)", embedded within the braces as a new macro command. Moreover, the parser 102 recognizes, based on the syntax 104, that the "name" embedded within the parenthesis is a parameter to the new macro c6mmand.
Other aspects of the syntax 104 may dictate that a string of characters outside any symbols to be interpreted as a literal string. Accordingly, the parser 102 breaks each element in the expression into components as shown at 108.
A novel feature of the parser 102 in the present invention is that the parser 102 is transparent to the actual content within the tokens, i.e., curly braces. That is, as long as the new macro commands or keywords are embedded within a 25 recognizable token, the parser 102 breaks the keywords down into components regardless of whether the keywords have been predefined in the macro language. Thus, as shown at 108, the macro expression 106 is broken down into components according to the syntax 104 of the extended SUBSTITUTE SHEET (RULE 26) WO 00123919 PCT/US99l24115 macro language. The new keyword "property" is broken down as a token component lOBa; the string "name" within the parenthesis is broken down as a parameter component 108b;
the string "likes" is broken down as a literal component 108c; and the string "pizza" is also broken down as a literal component 108d.
As shown in Figure 1, the present invention also includes a macro handler 110, and a repository 112 having keywords and their corresponding executable codes. The executable codes may be stored in the repository 112 as a pointer to the actual codes 114 for execution. The repository 112 includes one or more keywords and associated codes, and may be dynamically modified, e.g., new keywords and codes added to it as need arises by a user of the macro language. The repository 112 in the present invention may be a simple file with a table of keywords and associated codes. Alternatively, a separate database may be used as the repository 112.
After the macro expression has been parsed into separate components as described above with reference to the parser 102, the components are then passed to the macro handler 110 for additional processing. For the token component having the keyword "property" 108a, the macro handler checks a repository to the keyword "property". If found, the code associated with the keyword "property" is retrieved and executed. In executing the code, the macro handler 110 passes all the parameters found in the macro SUBSTITUTE SKEET (RULE 26) expression and parsed as parameters, to the executing code.
The macro handler 110 does not need to know any other processing that may be performed inside the code i~.self.
All that the macro handler 110 needs to recognize, is that the "property" is a keyword to be looked up in the repository 112 for its corresponding code, and the specified corresponding code in the repository 112 to be executed with any parameters. The corresponding code is typically specified in the repository 112 as a pointer to the actual code itself 114.
After the proper execution of the code 114 specified in the repository, the macro handler 110 accepts one or more outputs, if any, of the executed code and places the IS outputs back into the macro expression in place of the keyword. Thus, in the example shown in Figure 1,'the output of the code associated with the "property" with the parameter "name" may be MARY. Consequently, the result of the extended macro expression "{property (name)} likes pizza" at 106 is "Mary likes pizza" as shown at 116.
A novel feature of the present invention is that the macro handler, like the parser, need not know anything in the code or what type of functions are being performed by the executable code. The macro handier merely provides an initiation into the executable code hhat is associated with the keyword. In an exemplary embodiment of the present invention, it is left up to the users to define exactly what the code should do, and consequently, therefore, what SUBSTITUTE SHEET (RULE 26) command the keyword is to perform, thus providing a flexible and extensible macro language.
In the above example, the output MARY may have been 5 obtained in various ways transparent to the macro language.
For example, the name MARY may have been obtained by performing a search from the World Wide Web, or may have been obtained from a database using a query language, further illustrating the extensibility afforded by the 10 present invention.
~e Language Syntax The syntax or the grammar employed in one embodiment of the extensible macro language will now be described in detail. The extensible macro language of the present invention includes a syntax (Figure 1 104) comprising literals, macros, comments and operator/scoping characters.
Literal The syntax in this embodiment treats all text outside of curly braces as a literal, and is emitted exactly as typed. Within curly braces, text inside double quotes is treated as a literal. Such a scheme allows for embedding of a literal within macro calls. Some examples of a literal are illustrated as follows:
This text would be emitted just like this;
SUBSTITUTE SHEET (RULE 26) {"So would this text"}
Macros Macros include instructions to the macro processor, like procedures or functions in a programming language.
According to the syntax defined in the present invention, all macros are embedded within curly braces. In one embodiment, the macros fall into two categories: procedures macros and iterator macros.
Procedure macros are designed to perform some work.
They may expand to a value; they may declare a variable;
they may invoke a process. The actions performed axe entirely specified by the designer of the macro. In one embodiment, the macros must, however, return a "ttue" value upon successful completion of their task and a "false"
value upon failure.
The following expression illustrates a string literal, followed by a macro call for getting the page number when printing:
My Model Report - Page {HeaderPage} . Input My Model Report - Page 1 . Output In the above example, the HeaderPage is a macro defined by a user to extract a page number.
SLTBSTITLT~'E SHEET (RULE 26) Iterator macros allow the user to traverse across data structures. Iterators are distinguished by the ketywords "begin" and "end" that delimit a block of code following the iterator declaration. The code within the "begin/end"
block is executed once for each iteration. When the iterator has moved across all objects in its pool, control breaks out of the iteration block and continues to execute a next statement in the macro expression after the block.
The following block of macro expression illustrates a use of the iterator macro:
MyIterator begin DoSomething end In the above example, the procedure macro "DoSomething" executes once for each element returned by the "MyIterator" macro. The curly braces surrounding the entire fragment indicates that all expression within the ?3 braces is to be treated as macro code.
Parameters SUBSTITUTE SHEET (RULE 26) The syntax defined in the extensible macro language of the present invention allows for both procedure anjd iterator to accept and process parameters. Parameters may include strings, or other macros. To distinguish.
parameters, the parameters are enclosed within parenthesis following the macro. Macros may accept variable-length parameter lists, as desired. The following illustrates a macro expression having a parameter "foo":
{MacroWithParameters ("foo")~
Control blocks In some instances, it is desirable to have a block of a macro expression to fail if any portion of it fails. The following example illustrates one such instance:
{FirstName [MiddleInitial "."] LastName}
If there was no middle initial, the MiddleInitial macro would return a nil value or a fail value. In that case, the literal "." should not be printed. To accommodate for such conditions, the present invention includes in its syntax, square brackets ("[J") that denote a conditional expression. Thus, if the macro within the square brackets fails, the rest of the expression in the square brackets is not emitted. In the above example, if the MiddleInitial failed for lack of value, the literal "."
is not be printed.
SUBSTTTUTE SHEET (RULE 26) The conditional blocks have internal scope, i~.e., the failure of a conditional block does not affect the, surrounding code. For conditions in a block to affect the outer block, the syntax additionally includes what is referred to as a propagating conditional denoted by angle brackets. If any macro within a pair of angle brackets fails, the block within the angle brackets as well as the next outer block fails. The following examples illustrate macro expression with a conditional and a propagating conditional:
{ Print " " [ Print [ Fail ] ] ~ . input foo foo . output Print " " ( Print < Fail > ] ~ . input foo . output In both examples the "Print" macro outputs the word "foo". In the first example, the failed macro in square brackets is contained within its block. Thus, the next outer block having "Print" is executed ~,s well as the first "Print", resulting in the output "foo foo". In the second example, when a macro within angle brackets fails, the failure is propagated to the next block having the "Print"
macro. Thus, the next outer block with "Print" is not executed. Since this Print macro is contained within a pair of square brackets, the failure is contained in the SUBSTITUTE SHEET (RULE 26) black. Thus, the first "Print" macro is executed, resulting in the output "foo".
Figure 2 illustrates an example of a macro expression 5 including an iterator macro of the present invention. As described with reference to Figure I, the keyword "ForEach"
is recognized by the parser 102 (Figure 1) as a macro, and the word "Employee" is recognized as a parameter to the macro "ForEach". When the macro handler receives the token 10 keyword "ForEach", the macro handler 110 (Figure 1) performs a look-up of the keyword "ForEach" in the registry 112 and executes the corresponding code. The code for "ForEach" macro, fox example, may include instructions to perform commands found within the begin/end block of the 15 macro expression for all sub-objects 204b, 204c in a given object 204 having the type of the specified parameter °employee". In this macro expression 202, another macro exists within the begin/end block. Accordingly, the macro handler 110 (Figure 1) performs a look-up of the keyword °Property" in the registry 112 and executes the corresponding code fox each of the sub-objects 204b, 204c having employee type as specified in the "ForEach" keyword.
The code associated with the "Property" keyword, for example, may include instructions to print the value of the type specified in the parameter of the keyword "Property", in this case, an employee name as specified by "EmpName".
Consequently, the result of the macro expression 202 is the autput shown at 208, "Mary John".
SUBSTTTUTE SHEET (RULE 16) The extensible macro language of the present invention is useful for customizing macros specific to the needs of individual users. For example, the extensible macro language has been interfaced with the UMA Model for retrieving various objects from the UMA Model, as desired by a user. The UMA is disclosed in a co-pending U.S.
Patent Application No. (Atty. Docket #22074661-25535) entitled APPARATUS AND METHOD FOR MODELING TOOLS, filed on October 15, 1999, the disclosure of which is incorporated herein by reference in its entirety thereto.
Appendix A includes a brief description of the extensible macro language of the present invention as used in the UMA
Model and referred to as the UMA Template Language. The description in Appendix A explains one embodiment of the extensible macro language and should in no way be read as limiting the scope and capabilities of the extensible macro language to the descriptions contained therein.
While the invention has been particularly shown and described with respect to an embodiment thereof, it will be understood by those skilled in the art that the foregoing and other changes in form and details may be made therein without departing from the spirit and scope of the invention.
SUBSTITUTE SHEET (RULE 26) Overview The purpose of this document is to provide a brief introduction to the template, language implemented in UMA. It assumes you have a working knowledge of the objecUproperty metamodel of UMA.
It is not intended to provide an exhaustive explanation of the architecture.
UMA team members can provide you with such an explanation and they can direct you to many code samples that use this facility.
The purpose of the UMA Template Language (UTL) is to provide scripting capabilities to any IJMA-based application. These capabilities can be used for various features, including (but not limited to):
~ Macro expansion: Runtime expansion of code templates against the model.
Examples include trigger code and stored procedures in OR~Compass, and Visual Basic and Java components in SQL~Compass.
~ Scripting: Execution of a series of commands against the model. An example is the controller code for Forward Engineering in OR~Compass.
The architecture of UTL is intended to promote its use in as many aspects of an UMA-based product as possible. This is accomplished by allowing the users maximum flexibility in tailoring the language to the specific needs of his product, while providing as much implementation support as possible and exposing mechanisms that allow reuse of new implementation code.
To accomplish these goals, UTL:
1. defines a minimal syntax for the language;
Z. allows the user to write procedures and interators;
3. provides a mechanism for registering the procedures and iterators in registries.
Syntax Summary The following is a brief summary of the syntax of LTTL intended to provide the bare minimum necessary to understand the implementation. More information can be found in the documentation shipped with OR~Compass 1Ø
Template code consists of literals, macros, comments and a few operatorlscoping characters. Currently, UTL views all code as strings: numeric values are described by their string representation; most macros evaluate to strings. etc.2 ' In this documeat, '~sd' refers to the UMA application developer, not the end-user of the application.
= LTfL 1S, expected this fall, will also support numeric modes of operation that will provide better perfoanance when dealing with numbers. This will be useful for features such as volumetric calculations.
SUBSTITUTE SHEET (RULE 26) Literals In template source code, all text outside of curly braces is treated as a literal, and is emitted exactly as typed. Within curly braces, text inside double quotes is treated as a literal. The former allows large blocks of boilerplate to be entered, e.g. the bod~r of a stored procedure. The latter allows you to embed literals within macro calls.
Example:
This text would emit just like this.
{~So would this text."}
Macros Macros are special instructions to the macro processor...basically procedures.
All macros are contained within curly braces. Macros basically fall into two categories:
procedure macros and iterator macros.
Procedure macros are designed to perform some work. They may expand to a value; they may declare a variable; they may invoke a process. The actions) performed are entirely specified by the designer of the macro. The only constraint upon them is that they return True upon successful completion of their task and False upon failure.
Example~tlre following shows a string literal, followed by a macro call for getting the page nun:ber when printing:
My Model Report - Page {AeaderPage} a Input My Model Report - Page 1 ø Output Iterator macros allow the user to traverse across data structures. Iterators are distinguished by the keywords begin and end that delimit a block of code following the iterator declaration. All of the code within this begin/end block will be executed once for each iteration. When the iterator has moved across all objects in its pool, control will break out of the iteration block and execute the first statement after the block.
Example-the following executes the procedure macro DoSometl:ing once for each element returned by the Mylterator macro. Note the curly braces surrour:ding the entire code fragment...indicating that all code within is to be treated as macro code.
MyIterator begin DoSomething end Macros, both procedure and iterator, can take parameters. Parameters are strings, or anything that evaluates to a string, such as another macro. If a macro takes parameters, they are enclosed in parentheses after the macro. Since forward declaration of macros is not required, macros may accept variable-length parameter lists, if desired.
SUBSTITUTE SHEET (RULE 26) Example:
{ MacroWfthParameters("foo") ) Control blocks Occasionally, it is desirable to have an entire block of teirtplate code fail if any piece of it fails. An example would be where there was some boilerplate text followed by an optional value; if the value was not present, the boilerplate should not be cmitfed.
Any code enclosed in square brackets is conditional: it will all fail if any piece of it fails.
"Failure" means that a macro will not execute and a literal will not be emitted.
Example-if there is ~:o n:fiddle nan:e, tl:e period will not emit:
{ FirstName (Middlelnitial "."] LastName }
Conditional blocks hide their internal scope. This means that the failure of a conditional block has no effect on the surrounding code. Any code enclosed in angle brackets is propagating conditional: it will fail if any piece of it fails and it will propagate that failure out to the next block.
The best way to distinguish these two types of blocks is with examples. In both examples, the Print macro emits the word "foo" and the Fail macro fails no matter what.
Example of conditional block:
{ Print " " [ Print I Fail ] 1 } a Input foo foo a Output Example of propagating condition block:
{ Print " " ( Print < Fail > J } a Input foo a Ouput Architecture LWMDataButler 'The desired capabilities of LJ'TL are achieved using an object called a data butler. Data butlers are responsible for providing implementations for the macros encountered by the macro processor when executing template code. When the macro processor is invoked, a data butler interface3 is supplied to it. Essentially, a data butler is a use of the Strategy pattan.4 s Iataface defined in LWMDataButlerh ~ See Gamma, Helm, 3ohason Vlissides, Desif~n Patterns SUBSTITUTE SHEET (RULE 26) This accomplishes the first goal of the language design. By providing different data butlers to the macro processor, the grammar of UTL can be configured for the a plication and task at hand. Each data butler implementation can accept a set of keyword~(macros) appropriate for its task and reject keywords that are not acceptable. Further, a given keyword can be implemented in different ways by different data butlers, allowing template code to be ignorant of the underlying implementation. This is useful in allowing multiple products to work from the same templates when their underlying data models differ.
The LWMDataButler interface has five entry points:
// Handle procedure macro with no parameters virtual LWTBoolean SubstituteValue( coast LWTString & MacroName, LWTString & ExpansionValue) = 0 ;
// Handle procedure macro with parameters virtual LWTBoolean SubstituteValue( coast LWTString & MacroName, LWMStringList & ParameterList.
LWTString & ExpansionValue ) = 0 ;
// Fandle iterator macro with no parameters virtual LWTBoolean StartIteration( coast LWTString & IterName ) = 0 ;
// handle iterator macro with parameters virtual LWTBoolean Startiteration( coast LWTString & IterName, LWMStringList & ParameterList ) = 0 ;
// Handle iterator macro iteration virtual LWTBoolean NextIteration( coast LWTString & IterName ) = 0 ;
MCDataButlerl The second design goal of LTTL was to provide as much functionality as possible to the Fuser and to allow them to publish their own code for reuse.
Since the metaphor of an UMA model deals with all data at a very abstract Level-objects and properties-many grammatical elements of a template language can be written abstractly. These elements can be aggregated together to form the major portion of the language needed by any UMA-based product. The user could extend this base in the few areas that are product-specific. Ideally, the language should be extendable not only by the user, but by'the end-user of the user's product. This is accomplished in our solution.
There are two basic problems that are addressed by the solution:
1. A mechanism is needed to share implementations. As new keywords are added, they must be published.
SUBSTITITTE SHEET (RULE 26) 2. A mechanism is needed to control the context of a macro's execution. By this we refer to both the state of the UMA model at the time of execution, and to the specific objects) or property(ies) the macro affects.
To meet these criteria, a base implementation of a data butter exists in UMA.
This implementation, MCDataButlerIs, provides mechanisms fbr defining the desired grammar incrementally and for managing contextual information in an LIMA model.
This implementation is a superset of the LWMDataButler interface. Though the LWMDataButler interface is exposed, the user need not concern himself with it when implementing a data butler. The implementation in MCDataButlerI accomplishes all that has been found necessary to do in terms of implementing the LWMDataButler interface.
First, MCDataButlerI manages a registry of macro handlers. A macro handler is an object that knows how to perform a certain action, given a context.
Conceptually, a macro handler is an example of a Command pattern 6 The data butler maintains a dictionary of macro handlers keyed by macro name. When the macro processor requests the data butler to handle a macro (e.g. via SubstituteValue~ ), the data butler locates the appropriate macro handler in its dictionary and delegates control to it. The macro handler processes the request and returns control to the data butler who simply forwards the return value (if any) and Lhe success state to the macro processor.
A macro handler exposes an interface that is used by the data butler for invocation:
virtual LWTBoolean Execute( M~ataButlerI * Butler, coast LWTString & MacroName.
LWMStringList * Parameters.
L4lTString * Expansionvalue) - o;
MCDataButlerI exposes an implementation signature for registering new handlers:
void AddHandler( coast LWTString & Macro.
MCMacroHandler8ase * Handler):
In order to implement a grammar, a user can construct an implementation of an MCDataButierI and implement all required macro handlers. Alternatively, since the macro handler registry is a member variable of a data butler instead of a singleton, the user can subclass an existing data butler. This provides the user with all macros known to the subclass, plus those they develop. An example of this is the OR~Compass Forward Engineering data butler, it subclasses MCDataButler. The latter implements a wide variety of generic macros for creating objects, reading properties, iterating, constructing variables, etc. The Forward Engineering data butler implements one or two macros associated only with Forward Engineering (such as a macro for determining the correct s Implemcatation found in MCDataButlcrInterface.h ~ Op ci~. DesiRn Pattctns, SUBSTITUTE SHEET (RULE 26) execution command for a database) and ends up with a complete grammar for emitting DDL.
Second, MCDataButlerI manages a context stack. The context stack allows a Macro handler to know what object in the UMA model is being referenced when the macro executes. For example, the property ( ) macro retrieves a named property front an object. The macro handIcr for Property ( ) needs to know which object it should query.
MCDataButlerI maintains a stack of object references and exposes an interface for pushing and popping objects on this stack, as well as for querying the stack.
Macro handlers can query this interface to find out the context of their operation.
MCObject * LietCurrentContext(vofd);
void PopCurrentContext(void)r void PushCurrentContext(MCObject * Object):
Additionally, MCDataButlerI exposes a facility that allows MCObject iterators to manage the context automatically. Macro handlers for iterator macros can instantiate an iterator proxy. This is an object that automatically maintains the context stack for the iterator.
Upon instantiation, it pushes the first object being iterated onto the context stack. Each subsequent iteration causes a pop and a push to occur. When there are no more items to traverse, the stack is popped, leaving it in the state that existed when the iterator was encountered. These iterator proxies are maintained itr a stack of their own in order to manage nested iterators.
Example-the following sanrple code shows how the Property macro would behave d~erently depending upon the context. Assturre an entity named "MyTablel "that has an attribute "MyColuntnl " and a second attribute "MyColtcnrn2. "Assume a secorrd entity named "MyTable2" that has an attribute "MyColurnn3. " At the time tlris template code executes, we presume that the stack currently has the model on top due to some other cods ForEach( "UOEntities" ) begin property( "UPName" ) ForEach( "UPAttributes"
begin Property( "UPName" ) end and Input MyTablei MyColumni MyColumn2 MyTable2 MyColumn3 a Output SUBSTITUTE SHEET (RULE 26)
Claims (5)
1. A method for providing an extensible macro language comprising:
analyzing a macro language expression;
determining based on a predetermined syntax of a macro language, one or more keywords in the analyzed macro language expression, the keyword representing a macro command not previously defined in the macro language;
retrieving a code associated with the keyword from a registry of keywords; and executing the code associated with the keyword.
analyzing a macro language expression;
determining based on a predetermined syntax of a macro language, one or more keywords in the analyzed macro language expression, the keyword representing a macro command not previously defined in the macro language;
retrieving a code associated with the keyword from a registry of keywords; and executing the code associated with the keyword.
2. The method for providing an extensible macro language as claimed in claim 1, further comprising:
extending the registry of keywords by inserting a new keyword and a code associated with the new keyword.
extending the registry of keywords by inserting a new keyword and a code associated with the new keyword.
3. A system for providing an extensible macro language, comprising:
a parser having a predefined syntax to determine one or more extended keywords embedded within a macro language expression, the extended keyword representing a macro command undefined in a predetermined set of macro, commands of a macro language;
a keyword repository having one or more keywords and associated codes; and a macro handler coupled to the parser for receiving the extended keyword from the parser, the macro handler in response to the received extended keyword, retrieving a code associated with the received extended keyword from the keyword repository and executing the code to run the macro command represented by the extended keyword.
a parser having a predefined syntax to determine one or more extended keywords embedded within a macro language expression, the extended keyword representing a macro command undefined in a predetermined set of macro, commands of a macro language;
a keyword repository having one or more keywords and associated codes; and a macro handler coupled to the parser for receiving the extended keyword from the parser, the macro handler in response to the received extended keyword, retrieving a code associated with the received extended keyword from the keyword repository and executing the code to run the macro command represented by the extended keyword.
4. The extensible macro language as claimed in claim 3, wherein the keyword repository is augmented to include new keywords and associated codes.
5. A method for parsing a macro language expression, comprising:
analyzing a macro language expression; and determining based on a predetermined syntax of a macro language, one or more keywords in the analyzed macro language expression, the keywords representing macro commands undefined in a predetermined set of macro commands of a macro language.
analyzing a macro language expression; and determining based on a predetermined syntax of a macro language, one or more keywords in the analyzed macro language expression, the keywords representing macro commands undefined in a predetermined set of macro commands of a macro language.
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US10468298P | 1998-10-16 | 1998-10-16 | |
US60/104,682 | 1998-10-16 | ||
PCT/US1999/024115 WO2000023919A1 (en) | 1998-10-16 | 1999-10-15 | Method and system for an extensible macro language |
Publications (1)
Publication Number | Publication Date |
---|---|
CA2346925A1 true CA2346925A1 (en) | 2000-04-27 |
Family
ID=22301805
Family Applications (5)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
CA002346924A Abandoned CA2346924A1 (en) | 1998-10-16 | 1999-10-15 | Apparatus and method for building modeling tools |
CA002346925A Abandoned CA2346925A1 (en) | 1998-10-16 | 1999-10-15 | Method and system for an extensible macro language |
CA002346928A Abandoned CA2346928A1 (en) | 1998-10-16 | 1999-10-15 | Accessing a hierarchical data store through an sql input |
CA002347467A Abandoned CA2347467A1 (en) | 1998-10-16 | 1999-10-15 | Impact analysis of a model |
CA002347495A Abandoned CA2347495A1 (en) | 1998-10-16 | 1999-10-15 | Method for determining differences between two or more models |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
CA002346924A Abandoned CA2346924A1 (en) | 1998-10-16 | 1999-10-15 | Apparatus and method for building modeling tools |
Family Applications After (3)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
CA002346928A Abandoned CA2346928A1 (en) | 1998-10-16 | 1999-10-15 | Accessing a hierarchical data store through an sql input |
CA002347467A Abandoned CA2347467A1 (en) | 1998-10-16 | 1999-10-15 | Impact analysis of a model |
CA002347495A Abandoned CA2347495A1 (en) | 1998-10-16 | 1999-10-15 | Method for determining differences between two or more models |
Country Status (13)
Country | Link |
---|---|
US (3) | US7711685B1 (en) |
EP (5) | EP1121655B1 (en) |
JP (6) | JP2002528789A (en) |
KR (5) | KR20010103603A (en) |
CN (5) | CN1129859C (en) |
AT (1) | ATE333125T1 (en) |
AU (5) | AU775431B2 (en) |
BR (5) | BR9914553A (en) |
CA (5) | CA2346924A1 (en) |
DE (1) | DE69932344T2 (en) |
HK (4) | HK1040441A1 (en) |
IL (10) | IL142484A0 (en) |
WO (5) | WO2000023917A1 (en) |
Families Citing this family (53)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP1121655B1 (en) * | 1998-10-16 | 2006-07-12 | Computer Associates Think, Inc. | Accessing a hierarchical data store through an sql input |
US7734457B2 (en) * | 1999-10-16 | 2010-06-08 | Computer Associates Think, Inc. | Method and system for generating dynamic comparison models |
US20050160401A1 (en) * | 1999-10-16 | 2005-07-21 | Computer Associates Think, Inc. | System and method for adding user-defined objects to a modeling tool |
US7194405B2 (en) * | 2000-04-12 | 2007-03-20 | Activepoint Ltd. | Method for presenting a natural language comparison of items |
US6480970B1 (en) * | 2000-05-17 | 2002-11-12 | Lsi Logic Corporation | Method of verifying data consistency between local and remote mirrored data storage systems |
US6853997B2 (en) * | 2000-06-29 | 2005-02-08 | Infoglide Corporation | System and method for sharing, mapping, transforming data between relational and hierarchical databases |
US7089256B2 (en) * | 2000-07-11 | 2006-08-08 | Knowledge Dynamics, Inc. | Universal data editor |
US7421587B2 (en) * | 2001-07-26 | 2008-09-02 | Mcafee, Inc. | Detecting computer programs within packed computer files |
US7069547B2 (en) | 2001-10-30 | 2006-06-27 | International Business Machines Corporation | Method, system, and program for utilizing impact analysis metadata of program statements in a development environment |
US7194475B2 (en) | 2001-10-30 | 2007-03-20 | International Business Machines Corporation | Method, system, and program for performing an impact analysis of program statements in at least one source code file |
US7069263B1 (en) * | 2002-02-19 | 2006-06-27 | Oracle International Corporation | Automatic trend analysis data capture |
CH703081B1 (en) * | 2003-03-19 | 2011-11-15 | Roland Pulfer | Analysis of a model of a complex system. |
CH698890B1 (en) * | 2003-03-19 | 2009-11-30 | Roland Pulfer | Modeling a complex system. |
CH703073B1 (en) * | 2003-03-19 | 2011-11-15 | Roland Pulfer | Comparing models a complex system. |
CA2429335A1 (en) * | 2003-05-22 | 2004-11-22 | Cognos Incorporated | System and method of determining impact of reports based on metadata model changes |
CN101416182B (en) * | 2003-10-22 | 2010-12-08 | 英特尔公司 | Expression grouping and evaluation |
KR100611098B1 (en) * | 2003-12-12 | 2006-08-09 | 한국전자통신연구원 | Satellite simulation modeling system using Interface Model |
US8793602B2 (en) | 2004-01-15 | 2014-07-29 | The Mathworks, Inc. | System and method for scheduling the execution of model components using model events |
US7484212B2 (en) * | 2004-02-27 | 2009-01-27 | International Business Machines Corporation | Methods and arrangements for automated change plan construction and impact analysis |
US7555531B2 (en) * | 2004-04-15 | 2009-06-30 | Microsoft Corporation | Efficient algorithm and protocol for remote differential compression |
US20060074980A1 (en) * | 2004-09-29 | 2006-04-06 | Sarkar Pte. Ltd. | System for semantically disambiguating text information |
GB2419700B (en) * | 2004-10-29 | 2010-03-31 | Hewlett Packard Development Co | Methods for indexing data, systems, software and apparatus relng thereto |
US20060168555A1 (en) * | 2005-01-21 | 2006-07-27 | Represas Ferrao Lucio E | Software development system and method |
EP1684170A3 (en) * | 2005-01-21 | 2007-01-24 | Outsystems, software em redes, S. A. | Software development system and method |
US7735062B2 (en) | 2005-01-21 | 2010-06-08 | Outsystems—Software Em Rede, S.A. | Software development system and method |
US20060168577A1 (en) * | 2005-01-21 | 2006-07-27 | Melo Antonio A V | Software development system and method |
JP4755427B2 (en) | 2005-02-23 | 2011-08-24 | インターナショナル・ビジネス・マシーンズ・コーポレーション | Database access system and database access method |
US20060259781A1 (en) * | 2005-04-29 | 2006-11-16 | Sony Corporation/Sony Electronics Inc. | Method and apparatus for detecting the falsification of metadata |
US20070006130A1 (en) * | 2005-06-02 | 2007-01-04 | Arnold Stamler | Model oriented method of automatically detecting alterations in the design of a software system |
CN100432999C (en) * | 2005-06-06 | 2008-11-12 | 上海宝信软件股份有限公司 | Method for data access for complete record by using list architecture under ORACLE |
US20070250927A1 (en) * | 2006-04-21 | 2007-10-25 | Wintutis, Inc. | Application protection |
US9626161B2 (en) * | 2006-12-12 | 2017-04-18 | Ca, Inc. | Computer readable medium and methods for filtering a dynamic comparison model |
US8156147B1 (en) | 2007-02-06 | 2012-04-10 | The Mathworks, Inc. | Sharing of instructions across model boundaries |
US8334995B2 (en) * | 2007-09-19 | 2012-12-18 | Sharp Laboratories Of America, Inc. | Method and system for adaptive control of imaging node |
US20090094616A1 (en) * | 2007-10-04 | 2009-04-09 | Delima Roberto | Comparing Middleware Configurations |
US20090138846A1 (en) * | 2007-11-23 | 2009-05-28 | Microsoft Corporation | Extended macro recording |
US7962457B2 (en) * | 2008-02-12 | 2011-06-14 | Computer Associates Think, Inc. | System and method for conflict resolution |
US8321407B2 (en) * | 2008-02-24 | 2012-11-27 | Panaya Ltd. | Methods for calculating a combined impact analysis repository |
US8170988B2 (en) * | 2008-04-17 | 2012-05-01 | The Boeing Company | System and method for synchronizing databases |
KR100956921B1 (en) * | 2008-04-28 | 2010-05-11 | 권순용 | database access method |
US20100088686A1 (en) * | 2008-10-06 | 2010-04-08 | Microsoft Corporation | Programming language with extensible syntax |
CN101587492B (en) * | 2009-05-11 | 2011-05-11 | 金蝶软件(中国)有限公司 | Method and system for positioning processed object |
KR100921255B1 (en) * | 2009-05-14 | 2009-10-13 | 주식회사 신시웨이 | Sql masking apparatus and method thereof |
US20110313736A1 (en) * | 2010-06-18 | 2011-12-22 | Bioproduction Group, a California Corporation | Method and Algorithm for Modeling and Simulating A Discrete-Event Dynamic System |
US8316314B2 (en) * | 2010-06-30 | 2012-11-20 | Thermo Electron Scientific Instruments Llc | Intelligent multi-functional macros language for analytical measurements |
US8706744B2 (en) | 2011-05-31 | 2014-04-22 | Ca, Inc. | Determining dependencies during macro expansion |
US20130139113A1 (en) * | 2011-11-30 | 2013-05-30 | Microsoft Corporation | Quick action for performing frequent tasks on a mobile device |
US8990187B2 (en) | 2012-05-21 | 2015-03-24 | Google Inc. | Efficient top-down hierarchical join on a hierarchically clustered data stream |
KR102270791B1 (en) | 2014-12-10 | 2021-06-29 | 삼성전자주식회사 | Method and apparatus for processing macro instruction |
CN107408113B (en) * | 2015-03-31 | 2020-03-31 | 华为技术有限公司 | Analysis engine and method for analyzing pre-generated data reports |
US10585648B2 (en) | 2016-06-01 | 2020-03-10 | The Mathworks, Inc. | Systems and methods for aggregating implicit and explicit event code of executable models |
KR102195838B1 (en) * | 2019-04-10 | 2020-12-28 | 주식회사 티맥스 소프트 | Method for managing database |
US11769489B2 (en) | 2021-01-28 | 2023-09-26 | Samsung Electronics Co., Ltd. | Electronic device and method for performing shortcut command in electronic device |
Family Cites Families (95)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US3656178A (en) * | 1969-09-15 | 1972-04-11 | Research Corp | Data compression and decompression system |
US4667290A (en) * | 1984-09-10 | 1987-05-19 | 501 Philon, Inc. | Compilers using a universal intermediate language |
US4787035A (en) * | 1985-10-17 | 1988-11-22 | Westinghouse Electric Corp. | Meta-interpreter |
JPS63181033A (en) * | 1987-01-23 | 1988-07-26 | Hitachi Ltd | Automatic program generating system |
US5070534A (en) * | 1988-10-17 | 1991-12-03 | International Business Machines Corporation | Simplified cad parametric macroinstruction capability including variational geometrics feature |
US4931928A (en) * | 1988-11-09 | 1990-06-05 | Greenfeld Norton R | Apparatus for analyzing source code |
GB2227339A (en) * | 1989-01-21 | 1990-07-25 | Kashinath Narayan Dandeker | Complex expression generator |
JPH0363581A (en) | 1989-04-28 | 1991-03-19 | Internatl Business Mach Corp <Ibm> | Method of testing electronic circuit |
US5276880A (en) * | 1989-12-15 | 1994-01-04 | Siemens Corporate Research, Inc. | Method for parsing and representing multi-versioned computer programs, for simultaneous and synchronous processing of the plural parses |
US5257363A (en) * | 1990-04-09 | 1993-10-26 | Meta Software Corporation | Computer-aided generation of programs modelling complex systems using colored petri nets |
US5699310A (en) * | 1990-06-29 | 1997-12-16 | Dynasty Technologies, Inc. | Method and apparatus for a fully inherited object-oriented computer system for generating source code from user-entered specifications |
FR2667711B1 (en) * | 1990-10-09 | 1992-11-27 | Thomson Csf | METHOD FOR RECOGNIZING OBJECTS IN IMAGES AND ITS APPLICATION TO TRACKING OBJECTS IN IMAGE SEQUENCES. |
US5295256A (en) * | 1990-12-14 | 1994-03-15 | Racal-Datacom, Inc. | Automatic storage of persistent objects in a relational schema |
US5507030A (en) * | 1991-03-07 | 1996-04-09 | Digitial Equipment Corporation | Successive translation, execution and interpretation of computer program having code at unknown locations due to execution transfer instructions having computed destination addresses |
US5596746A (en) | 1991-10-21 | 1997-01-21 | General Electric Company | Method for transforming relational data base schemas into object models using ideal table meta models |
US5421016A (en) | 1991-12-12 | 1995-05-30 | International Business Machines Corporation | System and method for dynamically invoking object methods from an application designed for static method invocation |
FR2688611A1 (en) * | 1992-03-12 | 1993-09-17 | Bull Sa | USE OF A LANGUAGE WHICH TYPES RELATES TO THE CONTENT OF THE VARIABLES AND ALLOWS TO HANDLE COMPLEX CONSTRUCTIONS. |
US5721895A (en) * | 1992-03-17 | 1998-02-24 | International Business Machines Corporation | Computer program product and program storage device for a data transmission dictionary for encoding, storing, and retrieving hierarchical data processing information for a computer system |
US5517641A (en) | 1992-05-27 | 1996-05-14 | Cdb Software, Inc. | Restartable method to reorganize DB2 tablespace records by determining new physical positions for the records prior to moving using a non sorting technic |
FR2694105B1 (en) | 1992-07-22 | 1994-11-25 | Bull Sa | Use of an on-board interpreter language for the creation of an interactive user interface definition tool. |
US5295059A (en) * | 1992-09-09 | 1994-03-15 | Allen-Bradley Company, Inc. | Programmable controller with ladder diagram macro instructions |
US5794229A (en) * | 1993-04-16 | 1998-08-11 | Sybase, Inc. | Database system with methodology for storing a database table by vertically partitioning all columns of the table |
JPH06332710A (en) * | 1993-05-21 | 1994-12-02 | Fujitsu Ltd | Object directional data processing system |
US5550971A (en) | 1993-06-30 | 1996-08-27 | U S West Technologies, Inc. | Method and system for generating a user interface adaptable to various database management systems |
JPH07244605A (en) * | 1994-03-03 | 1995-09-19 | Fujitsu Ltd | Data base system and its update method |
US5724425A (en) * | 1994-06-10 | 1998-03-03 | Sun Microsystems, Inc. | Method and apparatus for enhancing software security and distributing software |
US5742828A (en) * | 1994-08-03 | 1998-04-21 | Microsoft Corporation | Compiler and method for evaluation of foreign syntax expressions in source code |
US5694539A (en) * | 1994-08-10 | 1997-12-02 | Intrinsa Corporation | Computer process resource modelling method and apparatus |
US5495613A (en) * | 1994-08-18 | 1996-02-27 | Unisys Corporation | Method and apparatus for extending the capability of a system editor using high-level language transforms |
US5692195A (en) | 1994-08-31 | 1997-11-25 | International Business Machines Corporation | Parent class shadowing |
US5768564A (en) * | 1994-10-07 | 1998-06-16 | Tandem Computers Incorporated | Method and apparatus for translating source code from one high-level computer language to another |
US5732192A (en) | 1994-11-30 | 1998-03-24 | The United States Of America As Represented By The Administrator Of The National Aeronautics And Space Administration | Global qualitative flow-path modeling for local state determination in simulation and analysis |
US5721915A (en) | 1994-12-30 | 1998-02-24 | International Business Machines Corporation | Interaction between application of a log and maintenance of a table that maps record identifiers during online reorganization of a database |
US5768586A (en) * | 1995-01-10 | 1998-06-16 | Peoplesoft, Inc. | Net change management for object-oriented modeling |
US5513314A (en) | 1995-01-27 | 1996-04-30 | Auspex Systems, Inc. | Fault tolerant NFS server system and mirroring protocol |
US5644764A (en) * | 1995-01-31 | 1997-07-01 | Unisys Corporation | Method for supporting object modeling in a repository |
US5548754A (en) | 1995-02-07 | 1996-08-20 | International Business Machines Corporation | Optimization of SQL queries using early-out join transformations |
US5701487A (en) * | 1995-03-27 | 1997-12-23 | Sun Microsystems, Inc. | Method and apparatus for displaying locations of errors detected inside software macro calls |
JPH11504451A (en) | 1995-04-24 | 1999-04-20 | アスペクト・ディベロップメント・インコーポレイテッド | Modeling objects suitable for database structures, translating into relational database structures, and performing fluid searches on them |
US5737592A (en) * | 1995-06-19 | 1998-04-07 | International Business Machines Corporation | Accessing a relational database over the Internet using macro language files |
US5790861A (en) * | 1995-07-07 | 1998-08-04 | Sun Microsystems, Inc. | Method and apparatus for generating executable code from object-oriented C++ source code |
US5717924A (en) * | 1995-07-07 | 1998-02-10 | Wall Data Incorporated | Method and apparatus for modifying existing relational database schemas to reflect changes made in a corresponding object model |
US5638381A (en) * | 1995-07-21 | 1997-06-10 | Motorola, Inc. | Apparatus and method for deriving correspondence between storage elements of a first circuit model and storage elements of a second circuit model |
US6011917A (en) | 1995-08-23 | 2000-01-04 | International Business Machines Corporation | Method and computer system for generating process management computer programs from process models |
US5721929A (en) * | 1995-10-06 | 1998-02-24 | Electronic Data Systems Corporation | Method for extending a fourth generation programming language |
US5855014A (en) * | 1995-11-03 | 1998-12-29 | Application Partners, Inc. | Getfield function for a relational workgroup platform using keyword and workflow databases |
US6003037A (en) | 1995-11-14 | 1999-12-14 | Progress Software Corporation | Smart objects for development of object oriented software |
US5721925A (en) * | 1995-12-01 | 1998-02-24 | Unisys Corporation | Method for generically invoking operation in an object oriented repository |
US5802511A (en) * | 1996-01-02 | 1998-09-01 | Timeline, Inc. | Data retrieval method and apparatus with multiple source capability |
US5815415A (en) * | 1996-01-19 | 1998-09-29 | Bentley Systems, Incorporated | Computer system for portable persistent modeling |
US6091895A (en) | 1996-03-27 | 2000-07-18 | International Business Machines Corporation | Object oriented central maintenance for programs and scripts |
US5715453A (en) * | 1996-05-31 | 1998-02-03 | International Business Machines Corporation | Web server mechanism for processing function calls for dynamic data queries in a web page |
US5987123A (en) | 1996-07-03 | 1999-11-16 | Sun Microsystems, Incorporated | Secure file system |
US5819305A (en) * | 1996-08-23 | 1998-10-06 | Motorola, Inc. | Method and apparatus for configuring operating modes in a memory |
US5974201A (en) * | 1996-10-01 | 1999-10-26 | Siemens Corporate Research, Inc. | Smart image system |
US6112024A (en) | 1996-10-02 | 2000-08-29 | Sybase, Inc. | Development system providing methods for managing different versions of objects with a meta model |
US5761494A (en) | 1996-10-11 | 1998-06-02 | The Sabre Group, Inc. | Structured query language to IMS transaction mapper |
US6065002A (en) | 1996-10-31 | 2000-05-16 | Systems And Computer Technology Corporation | Simplified interface for relational database access using open database connectivity |
US5983016A (en) | 1996-11-12 | 1999-11-09 | International Business Machines Corporation | Execution engine in an object modeling tool |
US5857197A (en) | 1997-03-20 | 1999-01-05 | Thought Inc. | System and method for accessing data stores as objects |
US5905982A (en) | 1997-04-04 | 1999-05-18 | International Business Machines Corporation | Handling null values in SQL queries over object-oriented data |
US6182274B1 (en) * | 1997-05-01 | 2001-01-30 | International Business Machines Corporation | Reusing code in object-oriented program development |
US5978789A (en) | 1997-05-07 | 1999-11-02 | Lucent Technologies Inc. | Efficient hypothetical query evaluation in a database system |
US5878411A (en) | 1997-06-27 | 1999-03-02 | International Business Machines Corporation | Dependent object class and subclass mapping to relational data store |
US5822750A (en) * | 1997-06-30 | 1998-10-13 | International Business Machines Corporation | Optimization of correlated SQL queries in a relational database management system |
US6513152B1 (en) | 1997-07-23 | 2003-01-28 | International Business Machines Corporation | Object oriented framework mechanism for customization of object oriented frameworks |
US6081774A (en) * | 1997-08-22 | 2000-06-27 | Novell, Inc. | Natural language information retrieval system and method |
US6112304A (en) * | 1997-08-27 | 2000-08-29 | Zipsoft, Inc. | Distributed computing architecture |
US6292811B1 (en) * | 1997-09-19 | 2001-09-18 | Modernsoft, Inc. | Populating cells of an electronic financial statement |
US5974407A (en) | 1997-09-29 | 1999-10-26 | Sacks; Jerome E. | Method and apparatus for implementing a hierarchical database management system (HDBMS) using a relational database management system (RDBMS) as the implementing apparatus |
US6085120A (en) * | 1997-11-17 | 2000-07-04 | International Business Machines Corporation | Data system processing and method for creating application extension |
US6105043A (en) * | 1997-12-16 | 2000-08-15 | International Business Machines Corporation | Creating macro language files for executing structured query language (SQL) queries in a relational database via a network |
US6247020B1 (en) | 1997-12-17 | 2001-06-12 | Borland Software Corporation | Development system with application browser user interface |
US6243709B1 (en) | 1998-06-29 | 2001-06-05 | Sun Microsystems, Inc. | Method and apparatus for loading stored procedures in a database corresponding to object-oriented data dependencies |
US6374256B1 (en) | 1997-12-22 | 2002-04-16 | Sun Microsystems, Inc. | Method and apparatus for creating indexes in a relational database corresponding to classes in an object-oriented application |
US6114978A (en) | 1998-01-14 | 2000-09-05 | Lucent Technologies Inc. | Method and apparatus for assignment of shortcut key combinations in a computer software application |
US6453356B1 (en) | 1998-04-15 | 2002-09-17 | Adc Telecommunications, Inc. | Data exchange system and method |
US6052720A (en) | 1998-05-14 | 2000-04-18 | Sun Microsystems, Inc. | Generic schema for storing configuration information on a server computer |
US6446109B2 (en) | 1998-06-29 | 2002-09-03 | Sun Microsystems, Inc. | Application computing environment |
US6226792B1 (en) | 1998-10-14 | 2001-05-01 | Unisys Corporation | Object management system supporting the use of application domain knowledge mapped to technology domain knowledge |
US6859919B1 (en) | 1998-10-16 | 2005-02-22 | Computer Associates Think, Inc. | Object modeling tool with meta model semantic registry (rules) a meta data manager for object(s) properties an object/property interface for instance(s) of objects/properties received via object/property interface of the object factory registry |
EP1121655B1 (en) | 1998-10-16 | 2006-07-12 | Computer Associates Think, Inc. | Accessing a hierarchical data store through an sql input |
US6502234B1 (en) | 1999-01-15 | 2002-12-31 | International Business Machines Corporation | Component based wizard for creating wizards |
US6678882B1 (en) | 1999-06-30 | 2004-01-13 | Qwest Communications International Inc. | Collaborative model for software systems with synchronization submodel with merge feature, automatic conflict resolution and isolation of potential changes for reuse |
KR200258626Y1 (en) | 1999-06-30 | 2001-12-28 | 윤청목 | Mixer combined with Juice Extractor |
US6385767B1 (en) | 1999-09-30 | 2002-05-07 | Unisys Corporation | Method and system for creating and manipulating extensions to version control systems |
EP1247165B1 (en) | 1999-10-01 | 2006-05-03 | Infoglide Corporation | System and method for transforming a relational database to a hierarchical database |
US20050160401A1 (en) | 1999-10-16 | 2005-07-21 | Computer Associates Think, Inc. | System and method for adding user-defined objects to a modeling tool |
US7734457B2 (en) | 1999-10-16 | 2010-06-08 | Computer Associates Think, Inc. | Method and system for generating dynamic comparison models |
JP2001265361A (en) | 2000-03-14 | 2001-09-28 | Sony Corp | Device and method for providing information, device and method for providing information, and program storage medium |
US7353289B2 (en) | 2000-11-06 | 2008-04-01 | Telecommunication Systems, Inc. | System for an open architecture development platform with centralized synchronization |
US6754671B2 (en) | 2001-05-02 | 2004-06-22 | Sun Microsystems, Inc. | Apparatus for Meta Object Facility repository bootstrap |
US20030014439A1 (en) | 2001-06-20 | 2003-01-16 | International Business Machines Corporation | Defining a markup language representation for state chart data |
US7322025B2 (en) | 2001-07-17 | 2008-01-22 | Tata Consultancy Services Limited | Method and apparatus for versioning and configuration management of object models |
US6904588B2 (en) | 2001-07-26 | 2005-06-07 | Tat Consultancy Services Limited | Pattern-based comparison and merging of model versions |
-
1999
- 1999-10-15 EP EP99970761A patent/EP1121655B1/en not_active Expired - Lifetime
- 1999-10-15 CA CA002346924A patent/CA2346924A1/en not_active Abandoned
- 1999-10-15 IL IL14248499A patent/IL142484A0/en active IP Right Grant
- 1999-10-15 JP JP2000577559A patent/JP2002528789A/en active Pending
- 1999-10-15 JP JP2000577592A patent/JP2002528794A/en active Pending
- 1999-10-15 KR KR1020017004770A patent/KR20010103603A/en not_active Application Discontinuation
- 1999-10-15 JP JP2000577590A patent/JP2002528793A/en not_active Withdrawn
- 1999-10-15 CN CN99812190A patent/CN1129859C/en not_active Expired - Fee Related
- 1999-10-15 AU AU14452/00A patent/AU775431B2/en not_active Ceased
- 1999-10-15 KR KR1020017004595A patent/KR20010093777A/en not_active Application Discontinuation
- 1999-10-15 WO PCT/US1999/023876 patent/WO2000023917A1/en active IP Right Grant
- 1999-10-15 BR BR9914553-7A patent/BR9914553A/en not_active IP Right Cessation
- 1999-10-15 IL IL14248299A patent/IL142482A0/en active IP Right Grant
- 1999-10-15 WO PCT/US1999/024120 patent/WO2000023863A2/en not_active Application Discontinuation
- 1999-10-15 KR KR1020017004801A patent/KR20010089309A/en not_active Application Discontinuation
- 1999-10-15 WO PCT/US1999/024117 patent/WO2000023882A1/en not_active Application Discontinuation
- 1999-10-15 CN CN99812038A patent/CN1361891A/en active Pending
- 1999-10-15 CA CA002346925A patent/CA2346925A1/en not_active Abandoned
- 1999-10-15 AU AU13152/00A patent/AU772191B2/en not_active Ceased
- 1999-10-15 CN CN99812224A patent/CN1359489A/en active Pending
- 1999-10-15 EP EP99953188A patent/EP1129391A4/en not_active Withdrawn
- 1999-10-15 CN CN99812225A patent/CN1129068C/en not_active Expired - Fee Related
- 1999-10-15 AT AT99970761T patent/ATE333125T1/en not_active IP Right Cessation
- 1999-10-15 EP EP99956567A patent/EP1121654A4/en not_active Ceased
- 1999-10-15 WO PCT/US1999/024115 patent/WO2000023919A1/en not_active Application Discontinuation
- 1999-10-15 WO PCT/US1999/024118 patent/WO2000023883A1/en not_active Application Discontinuation
- 1999-10-15 CA CA002346928A patent/CA2346928A1/en not_active Abandoned
- 1999-10-15 IL IL14256499A patent/IL142564A0/en active IP Right Grant
- 1999-10-15 BR BR9914549-9A patent/BR9914549A/en not_active IP Right Cessation
- 1999-10-15 CN CNB998121916A patent/CN1192321C/en not_active Expired - Fee Related
- 1999-10-15 EP EP99956569.0A patent/EP1121639B1/en not_active Expired - Lifetime
- 1999-10-15 JP JP2000577558A patent/JP2002528788A/en active Pending
- 1999-10-15 IL IL14257299A patent/IL142572A0/en active IP Right Grant
- 1999-10-15 AU AU13154/00A patent/AU761228B2/en not_active Ceased
- 1999-10-15 KR KR1020017004671A patent/KR20010106514A/en not_active Application Discontinuation
- 1999-10-15 JP JP2000577541A patent/JP2002528783A/en active Pending
- 1999-10-15 AU AU65180/99A patent/AU6518099A/en not_active Abandoned
- 1999-10-15 BR BR9914427-1A patent/BR9914427A/en not_active IP Right Cessation
- 1999-10-15 AU AU12071/00A patent/AU1207100A/en not_active Abandoned
- 1999-10-15 IL IL14257199A patent/IL142571A0/en active IP Right Grant
- 1999-10-15 BR BR9914552-9A patent/BR9914552A/en not_active IP Right Cessation
- 1999-10-15 DE DE69932344T patent/DE69932344T2/en not_active Expired - Lifetime
- 1999-10-15 EP EP99970749.0A patent/EP1121640B1/en not_active Expired - Lifetime
- 1999-10-15 CA CA002347467A patent/CA2347467A1/en not_active Abandoned
- 1999-10-15 BR BR9914551-0A patent/BR9914551A/en not_active IP Right Cessation
- 1999-10-15 KR KR1020017004771A patent/KR20010103604A/en not_active Application Discontinuation
- 1999-10-15 CA CA002347495A patent/CA2347495A1/en not_active Abandoned
- 1999-10-16 US US09/419,749 patent/US7711685B1/en not_active Expired - Fee Related
- 1999-10-16 US US09/419,731 patent/US6601023B1/en not_active Expired - Lifetime
- 1999-10-16 US US09/419,736 patent/US6385610B1/en not_active Expired - Lifetime
-
2001
- 2001-04-05 IL IL142482A patent/IL142482A/en not_active IP Right Cessation
- 2001-04-05 IL IL142484A patent/IL142484A/en not_active IP Right Cessation
- 2001-04-12 IL IL142564A patent/IL142564A/en not_active IP Right Cessation
- 2001-04-12 IL IL142572A patent/IL142572A/en not_active IP Right Cessation
- 2001-04-12 IL IL142571A patent/IL142571A/en not_active IP Right Cessation
-
2002
- 2002-01-28 HK HK02100664.3A patent/HK1040441A1/en unknown
- 2002-01-28 HK HK02100665.2A patent/HK1040552A1/en unknown
- 2002-01-28 HK HK02100660.7A patent/HK1040440A1/en unknown
- 2002-03-04 HK HK02101645.5A patent/HK1042140A1/en unknown
-
2005
- 2005-05-11 JP JP2005138696A patent/JP2005285141A/en active Pending
Also Published As
Similar Documents
Publication | Publication Date | Title |
---|---|---|
AU772191B2 (en) | Method and system for an extensible macro language | |
Sutter et al. | C++ coding standards: 101 rules, guidelines, and best practices | |
Vermeulen | The elements of Java (tm) style | |
Kahn et al. | Metal: A formalism to specify formalisms | |
Patrascoiu | Yatl: Yet another transformation language-reference manual version 1.0 | |
JP5047621B2 (en) | Mechanisms for obtaining and applying syntax constraints in interactive environments | |
JP2007509411A (en) | Mechanism to provide data driven command line output | |
JP2007509407A (en) | A mechanism that provides an extension to command line instructions | |
US6665866B1 (en) | Extensible compiler utilizing a plurality of question handlers | |
Haase et al. | Introduction to openArchitectureWare 4.1. 2 | |
Schröer | The GENTLE Compiler Construction System | |
Davies et al. | Formality, evolution, and model-driven software engineering | |
Watson et al. | Spare parts: a C++ toolkit for string pattern recognition | |
Contractor et al. | Improving program matching to automatically repair introductory programs | |
Rao | Sams Teach Yourself C++ in One Hour a Day | |
Zingaro | Modern extensible languages | |
Baratta-Perez et al. | Ada system dependency analyzer tool | |
Wielemaker | SWI-Prolog 2.9. 6 | |
Wielemaker | SWI-Prolog 3.2 | |
Bartman | Srcql: A syntax-aware query language for exploring source code | |
Wielemaker | SWI-Prolog 5.1 | |
Wielemaker | SWI-Prolog 4.0 | |
de Champlain et al. | C# 2.0: Practical Guide for Programmers | |
Meffert et al. | Supporting program comprehension for refactoring operations with annotations | |
Lee et al. | Object-Oriented Programming |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
EEER | Examination request | ||
FZDE | Discontinued |