US20120310957A1 - Determining Dependencies During Macro Expansion - Google Patents

Determining Dependencies During Macro Expansion Download PDF

Info

Publication number
US20120310957A1
US20120310957A1 US13/118,778 US201113118778A US2012310957A1 US 20120310957 A1 US20120310957 A1 US 20120310957A1 US 201113118778 A US201113118778 A US 201113118778A US 2012310957 A1 US2012310957 A1 US 2012310957A1
Authority
US
United States
Prior art keywords
dominant
dependent
objects
macro
formula
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.)
Granted
Application number
US13/118,778
Other versions
US8706744B2 (en
Inventor
Tad A. Deffler
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
CA Inc
Original Assignee
Computer Associates Think Inc
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by Computer Associates Think Inc filed Critical Computer Associates Think Inc
Priority to US13/118,778 priority Critical patent/US8706744B2/en
Assigned to COMPUTER ASSOCIATES THINK, INC. reassignment COMPUTER ASSOCIATES THINK, INC. ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: DEFFLER, TAD A.
Publication of US20120310957A1 publication Critical patent/US20120310957A1/en
Assigned to CA, INC. reassignment CA, INC. MERGER (SEE DOCUMENT FOR DETAILS). Assignors: COMPUTER ASSOCIATES THINK, INC.
Priority to US14/252,038 priority patent/US9355189B2/en
Application granted granted Critical
Publication of US8706744B2 publication Critical patent/US8706744B2/en
Expired - Fee Related legal-status Critical Current
Adjusted expiration legal-status Critical

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/30Information retrieval; Database structures therefor; File system structures therefor of unstructured textual data
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/90Details of database functions independent of the retrieved data types
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/41Compilation
    • G06F8/42Syntactic analysis
    • G06F8/427Parsing
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/41Compilation
    • G06F8/43Checking; Contextual analysis
    • G06F8/433Dependency analysis; Data or control flow analysis

Definitions

  • This invention relates generally to the field of computing technology and more specifically to determining dependencies during macro expansion.
  • a modeling product may model a system.
  • the modeling product may use objects to store information about the system.
  • Macro expansion language may be used to calculate the value of an object based on values of one or more other objects. If calculated values are not stored in the model, the values may be calculated as needed.
  • a parser parses a formula to yield one or more functions, at least one function comprising a dependent value of a dependent object.
  • One or more macro handlers configured to execute the functions are determined. At least one macro handler is instructed to register with one or more dominant objects on behalf of the dependent object, where the dominant objects are used to evaluate the dependent value.
  • a technical advantage of one embodiment may be that a parser can instruct a macro handler to register with one or more dominant objects on behalf of a dependent object. The registration allows a dominant object to notify the dependent object of a change in the dominant object.
  • FIG. 1 illustrates an example of a system that may be used to determine dependencies during macro expansion
  • FIG. 2 illustrates an example of a representation of a sample table
  • FIG. 3 illustrates an example of a tree of the objects of the table of FIG. 2 ;
  • FIG. 4 illustrates an example of a method for calculating a dependent value
  • FIG. 5 illustrates an example of a method for determining dependencies during macro expansion.
  • FIGS. 1 through 5 of the drawings like numerals being used for like and corresponding parts of the various drawings.
  • a modeling product may model a system.
  • the modeling product may use objects to store information about the system.
  • a dependent value of a dependent object may depend on one or more dominant values of one or more dominant objects.
  • the dominant values may be needed to calculate the dependent value. Accordingly, a change in a dominant value may yield a change in a dependent value.
  • a dependent object may register with a dominant object to receive a notification of changes.
  • the dependent object needs to identify the dominant objects in order to register with them.
  • the dependent object may examine formulas that it has to identify the dominant objects.
  • the dependent object typically has to perform the operations of a parser and a macro handler. This, however, entails that one object duplicates the operations another object, which breaks encapsulation.
  • FIG. 1 illustrates an example of a system 10 that may be used to determine dependencies during macro expansion.
  • system 10 may include a parser that can instruct a macro handler to register with one or more dominant objects on behalf of a dependent object. The registration allows a dominant object to notify the dependent object of a change in the dominant object.
  • system 10 includes one or more interfaces (IFs) 20 , logic 22 , and one or more memories 24 .
  • Logic 22 includes one or more processors 26 and applications 30 , such as a parser 32 and one or more macro handlers 34 .
  • Memories 24 store applications 30 and one or more objects 40 .
  • Parser 32 parses the source code of a computer program language to create an internal representation of the code. In certain embodiments, parser 32 parses a formula to yield one or more functions and determines one or more macro handlers 34 configured to execute the functions. Parser 32 instructs the macro handlers 34 to register with one or more dominant objects on behalf of one or more dependent objects.
  • FIG. 4 illustrates an example of a method for calculating a dependent value.
  • an external component 56 requests a dependent value from dependent object 54 at step 110 .
  • External component 56 may be a component that is separate from applications 30 , and may be an interface 20 , such as a display.
  • the dependent object sends the formula for the dependent value to parser 32 at step 112 .
  • Parser 32 detects a function and selects the appropriate macro handler 34 to execute the function at step 114 .
  • Macro handler 34 determines that dominant values are needed and then requests that the dependent object provides the dominant object at step 116 .
  • Macro handler 32 asks the dominant object 52 for its dominant value at step 118 . Macro handler 34 then returns the dominant value to parser 32 at step 120 . Parser inserts the dominant value into the formula and returns the dependent value to dependent object 54 at step 122 . Dependent object 54 returns the dependent value to external component 56 at step 110 , and the method terminates.
  • FIG. 5 illustrates an example of a method for determining dependencies during macro expansion.
  • notification operations are set up.
  • a notification operation instructs a dominant object to notify dependent objects of changes in dominant values.
  • dependent object 54 requests that parser 32 parses a formula at step 70 and provides parser 32 with the address of dependent object 54 .
  • Parser 32 requests that macro handlers 34 execute functions of the formula at step 72 .
  • Macro handler 34 registers with dominant objects 52 on behalf of dependent objects 54 for dependencies of the functions at step 74 .
  • the registration instructs dominant objects 52 to send notification of any changes in dominant values to the dependent object 54 's address.
  • Dominant object 52 notifies dependent object 54 of changes in dominant values at step 76 .
  • Dependent object 54 may then notify an external component of the changes.
  • the method may resolve difficulties of breaking encapsulation and/or runtime extensibility.
  • Parser 32 performs a parsing operations, and macro handlers 34 execute the functions, so encapsulation is maintained.
  • new functions can still perform registrations with the address of the dependent object, so no new navigation algorithms are required.
  • an entity that performs a first step that precedes (such as leads to) a second step may be regarded as facilitating the second step. For example, if an entity performs step A that precedes step B, the entity also facilitates step B.
  • a first entity that performs a first step that precedes a second step that may be performed by a second entity may be regarded as allowing the second entity to perform the second step. For example, if a first entity performs step A that precedes step B that may be performed by a second entity, the first entity also allows the second entity to perform step B.
  • Logic performs the operations of the component, for example, executes instructions to generate output from input.
  • Logic may include hardware, software, and/or other logic.
  • Logic may be encoded in one or more tangible media and may perform operations when executed by a computer.
  • Certain logic, such as a processor, may manage the operation of a component. Examples of a processor include one or more computers, one or more microprocessors, one or more applications, and/or other logic.
  • the operations of the embodiments may be performed by one or more computer readable media encoded with a computer program, software, computer executable instructions, and/or instructions capable of being executed by a computer.
  • the operations of the embodiments may be performed by one or more computer readable media storing, embodied with, and/or encoded with a computer program and/or having a stored and/or an encoded computer program.
  • a communication network may comprise all or a portion of one or more of the following: a public switched telephone network (PSTN), a public or private data network, a local area network (LAN), a metropolitan area network (MAN), a wide area network (WAN), a local, regional, or global communication or computer network such as the Internet, a wireline or wireless network, an enterprise intranet, other suitable communication link, or any combination of any of the preceding.
  • PSTN public switched telephone network
  • LAN local area network
  • MAN metropolitan area network
  • WAN wide area network
  • Internet local, regional, or global communication or computer network

Abstract

In certain embodiments, a parser parses a formula to yield one or more functions, at least one function comprising a dependent value of a dependent object. One or more macro handlers configured to execute the functions are determined. At least one macro handler is instructed to register with one or more dominant objects on behalf of the dependent object, where the dominant objects are used to evaluate the dependent value.

Description

    TECHNICAL FIELD
  • This invention relates generally to the field of computing technology and more specifically to determining dependencies during macro expansion.
  • BACKGROUND
  • A modeling product may model a system. The modeling product may use objects to store information about the system. Macro expansion language may be used to calculate the value of an object based on values of one or more other objects. If calculated values are not stored in the model, the values may be calculated as needed.
  • SUMMARY OF THE DISCLOSURE
  • In accordance with the present invention, disadvantages and problems associated with previous techniques for determining dependencies may be reduced or eliminated.
  • In certain embodiments, a parser parses a formula to yield one or more functions, at least one function comprising a dependent value of a dependent object. One or more macro handlers configured to execute the functions are determined. At least one macro handler is instructed to register with one or more dominant objects on behalf of the dependent object, where the dominant objects are used to evaluate the dependent value.
  • Certain embodiments of the invention may provide one or more technical advantages. A technical advantage of one embodiment may be that a parser can instruct a macro handler to register with one or more dominant objects on behalf of a dependent object. The registration allows a dominant object to notify the dependent object of a change in the dominant object.
  • Certain embodiments of the invention may include none, some, or all of the above technical advantages. One or more other technical advantages may be readily apparent to one skilled in the art from the figures, descriptions, and claims included herein.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • For a more complete understanding of the present invention and its features and advantages, reference is now made to the following description, taken in conjunction with the accompanying drawings, in which:
  • FIG. 1 illustrates an example of a system that may be used to determine dependencies during macro expansion;
  • FIG. 2 illustrates an example of a representation of a sample table;
  • FIG. 3 illustrates an example of a tree of the objects of the table of FIG. 2;
  • FIG. 4 illustrates an example of a method for calculating a dependent value; and
  • FIG. 5 illustrates an example of a method for determining dependencies during macro expansion.
  • DETAILED DESCRIPTION OF THE DRAWINGS
  • Embodiments of the present invention and its advantages are best understood by referring to FIGS. 1 through 5 of the drawings, like numerals being used for like and corresponding parts of the various drawings.
  • A modeling product may model a system. The modeling product may use objects to store information about the system. In certain situations, a dependent value of a dependent object may depend on one or more dominant values of one or more dominant objects. For example, the dominant values may be needed to calculate the dependent value. Accordingly, a change in a dominant value may yield a change in a dependent value.
  • Certain known techniques may be used to notify dependent objects of a change in a dominant value. According to certain known techniques, a dependent object may register with a dominant object to receive a notification of changes. In these techniques, the dependent object needs to identify the dominant objects in order to register with them. The dependent object may examine formulas that it has to identify the dominant objects. To examine formulas, the dependent object typically has to perform the operations of a parser and a macro handler. This, however, entails that one object duplicates the operations another object, which breaks encapsulation.
  • According to other known techniques, heuristic rules derived from real world patterns of dependencies are used to write notification operations for a computer program. For example, a change in a name of a table often changes the names of the columns of the table, so code may be written that instructs a table object to notify a column object of table name changes. The heuristic rules, however, may not capture all dependencies of a computer program. Moreover, the heuristic rules may include dependencies that are not present in the computer program.
  • FIG. 1 illustrates an example of a system 10 that may be used to determine dependencies during macro expansion. In certain embodiments, system 10 may include a parser that can instruct a macro handler to register with one or more dominant objects on behalf of a dependent object. The registration allows a dominant object to notify the dependent object of a change in the dominant object.
  • In the illustrated example, system 10 includes one or more interfaces (IFs) 20, logic 22, and one or more memories 24. Logic 22 includes one or more processors 26 and applications 30, such as a parser 32 and one or more macro handlers 34. Memories 24 store applications 30 and one or more objects 40.
  • Parser 32 parses the source code of a computer program language to create an internal representation of the code. In certain embodiments, parser 32 parses a formula to yield one or more functions and determines one or more macro handlers 34 configured to execute the functions. Parser 32 instructs the macro handlers 34 to register with one or more dominant objects on behalf of one or more dependent objects.
  • Parser 32 may update the registrations when a next formula (such as an updated formula or a new formula) is received. For example, parser 32 parses the next formula to yield a next function. Parser 32 determines a next macro handler 34 configured to execute the next function and instructs the next macro handler 34 to register with a next dominant object on behalf of a next dependent object. The next dominant object may be used to evaluate the next dependent object. Parser 32 may also instruct a macro handler 34 to remove the registrations of dominant objects of outdated formulas.
  • Macro handler 34 executes functions. For example, a macro handler 34 may obtain input for a function and then apply operators to the input. In certain situations, the input may include dominant values from dominant objects. Any suitable macro handler may be used, for example, a macro handler as described in U.S. Pat. No. 7,711,685 “Method and System for an Extensible Macro Language”, which is incorporated herein by reference.
  • In certain embodiments, a macro handler 34 receives a register instruction to register a dominant object of a formula on behalf of a dependent object. Macro handler identifies the dominant object of the formula and registers with the dominant object on behalf of the dependent object to allow the dominant object to notify the dependent object of a change in the dominant object.
  • FIG. 2 illustrates an example of a representation of a sample table 40, and FIG. 3 illustrates an example of a tree 50 of objects of table 40. In the example, object tree 50 includes a dominant object 52 and one or more dependent objects 54 (54 a-d). A dependent object 54 depends on a dominant object 52. In certain embodiments, the value of a dependant object may depend on one or more values of one or more dominant objects. In the embodiments, the formula for calculating the dependent value may use dominant values as input. For example, the formula may include a function that indicates a dominant value to be used as input and that may be used to obtain the dominant value. The formula may also include operators and strings that may be used to calculate the dependent value.
  • In the illustrated example, the dominant object 52 is the table, and the dependent objects 54 (54 a-d) are columns of the table. The names of the dependent objects depend on the name of the dominant object 52. The formulas for calculating the column names have the format: TableName( )+string, where TableName( ) is a function that may be used to obtain the table name, + is an operator for concatenation, and string is “_ID” for column name 54 a, “_NAME” for column name 54 b, “_ADDRESS” for column name 54 c, and “_PHONE” for column name 54 d. In the example, the table name is CUSTOMER, so the column names are CUSTOMER_ID, CUSTOMER_NAME, CUSTOMER_ADDRESS, and CUSTOMER_PHONE.
  • FIG. 4 illustrates an example of a method for calculating a dependent value. In the example, an external component 56 requests a dependent value from dependent object 54 at step 110. External component 56 may be a component that is separate from applications 30, and may be an interface 20, such as a display. The dependent object sends the formula for the dependent value to parser 32 at step 112. Parser 32 detects a function and selects the appropriate macro handler 34 to execute the function at step 114. Macro handler 34 determines that dominant values are needed and then requests that the dependent object provides the dominant object at step 116.
  • Macro handler 32 asks the dominant object 52 for its dominant value at step 118. Macro handler 34 then returns the dominant value to parser 32 at step 120. Parser inserts the dominant value into the formula and returns the dependent value to dependent object 54 at step 122. Dependent object 54 returns the dependent value to external component 56 at step 110, and the method terminates.
  • In certain situations, dependent object 54 may notify external component 56 of changes in a dependent value. A change in a dominant value may change a dependent value, so dependent object 54 may be notified of dominant value changes in order to notify external component 56 of changes in a dependent value. An example of a method for notifying dependent object 54 is described with reference to FIG. 5.
  • FIG. 5 illustrates an example of a method for determining dependencies during macro expansion. In the example, when a formula is placed into an object, notification operations are set up. A notification operation instructs a dominant object to notify dependent objects of changes in dominant values.
  • In the example, dependent object 54 requests that parser 32 parses a formula at step 70 and provides parser 32 with the address of dependent object 54. Parser 32 requests that macro handlers 34 execute functions of the formula at step 72. Macro handler 34 registers with dominant objects 52 on behalf of dependent objects 54 for dependencies of the functions at step 74. The registration instructs dominant objects 52 to send notification of any changes in dominant values to the dependent object 54's address. Dominant object 52 notifies dependent object 54 of changes in dominant values at step 76. Dependent object 54 may then notify an external component of the changes.
  • If the formula is changed, the dependencies may be updated in the following manner. Parser 32 evaluates the old formula and instructs macro handlers 34 to remove registrations associated with the old formula. Parser 32 evaluates the new formula and instructs macro handlers 34 to add registrations for the new formula.
  • In certain embodiments, the method may resolve difficulties of breaking encapsulation and/or runtime extensibility. Parser 32 performs a parsing operations, and macro handlers 34 execute the functions, so encapsulation is maintained. In addition, new functions can still perform registrations with the address of the dependent object, so no new navigation algorithms are required.
  • Modifications, additions, or omissions may be made to the systems and apparatuses disclosed herein without departing from the scope of the invention. The components of the systems and apparatuses may be integrated or separated. Moreover, the operations of the systems and apparatuses may be performed by more, fewer, or other components. For example, the operations of parser 32 and macro handler 34 may be performed by one component, or the operations of parser 32 may be performed by more than one component. Additionally, operations of the systems and apparatuses may be performed using any suitable logic comprising software, hardware, and/or other logic. As used in this document, “each” refers to each member of a set or each member of a subset of a set.
  • Modifications, additions, or omissions may be made to the methods disclosed herein without departing from the scope of the invention. The methods may include more, fewer, or other steps. Additionally, steps may be performed in any suitable order.
  • In certain embodiments, an entity that performs a first step that precedes (such as leads to) a second step may be regarded as facilitating the second step. For example, if an entity performs step A that precedes step B, the entity also facilitates step B. In certain embodiments, a first entity that performs a first step that precedes a second step that may be performed by a second entity may be regarded as allowing the second entity to perform the second step. For example, if a first entity performs step A that precedes step B that may be performed by a second entity, the first entity also allows the second entity to perform step B.
  • A component of the systems and apparatuses disclosed herein may include an interface, logic, memory, and/or other suitable element. An interface receives input, sends output, processes the input and/or output, and/or performs other suitable operation. An interface may comprise hardware and/or software.
  • Logic performs the operations of the component, for example, executes instructions to generate output from input. Logic may include hardware, software, and/or other logic. Logic may be encoded in one or more tangible media and may perform operations when executed by a computer. Certain logic, such as a processor, may manage the operation of a component. Examples of a processor include one or more computers, one or more microprocessors, one or more applications, and/or other logic.
  • In particular embodiments, the operations of the embodiments may be performed by one or more computer readable media encoded with a computer program, software, computer executable instructions, and/or instructions capable of being executed by a computer. In particular embodiments, the operations of the embodiments may be performed by one or more computer readable media storing, embodied with, and/or encoded with a computer program and/or having a stored and/or an encoded computer program.
  • A memory stores information. A memory may comprise one or more non-transitory, tangible, computer-readable, and/or computer-executable storage media. Examples of memory include computer memory (for example, Random Access Memory (RAM) or Read Only Memory (ROM)), mass storage media (for example, a hard disk), removable storage media (for example, a Compact Disk (CD) or a Digital Video Disk (DVD)), database and/or network storage (for example, a server), and/or other computer-readable medium.
  • Components of the systems and apparatuses may be coupled by any suitable communication network. A communication network may comprise all or a portion of one or more of the following: a public switched telephone network (PSTN), a public or private data network, a local area network (LAN), a metropolitan area network (MAN), a wide area network (WAN), a local, regional, or global communication or computer network such as the Internet, a wireline or wireless network, an enterprise intranet, other suitable communication link, or any combination of any of the preceding.
  • Although this disclosure has been described in terms of certain embodiments, alterations and permutations of the embodiments will be apparent to those skilled in the art. Accordingly, the above description of the embodiments does not constrain this disclosure. Other changes, substitutions, and alterations are possible without departing from the spirit and scope of this disclosure, as defined by the following claims.

Claims (21)

1. A method comprising:
parsing, by a parser using one or more processors, a formula to yield one or more functions, at least one function comprising a dependent value of a dependent object;
determining one or more macro handlers configured to execute the one or more functions; and
instructing at least one macro handler to register with one or more dominant objects on behalf of the dependent object, the one or more dominant objects used to evaluate the dependent value.
2. The method of claim 1, the instructing further comprising:
instructing the at least one macro handler such that the one or more dominant objects notify the dependent object of a change in one or more dominant values of the one or more dominant objects.
3. The method of claim 1, further comprising:
receiving a next formula; and
instructing the one or more macro handlers to remove the registrations with the one or more dominant objects.
4. The method of claim 1, further comprising:
parsing a next formula to yield one or more next functions, at least one next function comprising a next dependent value of a next dependent object;
determining one or more next macro handlers configured to execute the one or more next functions; and
instructing at least one macro handler to register with one or more next dominant objects on behalf of the next dominant object.
5. The method of claim 1, further comprising:
receiving the formula from the dependent object.
6. One or more non-transitory computer readable media storing code, when executed by one or more processors, configured to:
parse a formula to yield one or more functions, at least one function comprising a dependent value of a dependent object;
determine one or more macro handlers configured to execute the one or more functions; and
instruct at least one macro handler to register with one or more dominant objects on behalf of the dependent object, the one or more dominant objects used to evaluate the dependent value.
7. The media of claim 6, the instructing further comprising:
instructing the at least one macro handler such that the one or more dominant objects notify the dependent object of a change in one or more dominant values of the one or more dominant objects.
8. The media of claim 6, the code configured to:
receive a next formula; and
instruct the one or more macro handlers to remove the registrations with the one or more dominant objects.
9. The media of claim 6, the code configured to:
parse a next formula to yield one or more next functions, at least one next function comprising a next dependent value of a next dependent object;
determine one or more next macro handlers configured to execute the one or more next functions; and
instruct at least one macro handler to register with one or more next dominant objects on behalf of the next dominant object.
10. The media of claim 6, the code configured to:
receive the formula from the dependent object.
11. An apparatus comprising:
one or more memories configured to store a formula; and
one or more processors configured to:
parse the formula to yield one or more functions, at least one function comprising a dependent value of a dependent object;
determine one or more macro handlers configured to execute the one or more functions; and
instruct at least one macro handler to register with one or more dominant objects on behalf of the dependent object, the one or more dominant objects used to evaluate the dependent value.
12. The apparatus of claim 11, the instructing further comprising:
instructing the at least one macro handler such that the one or more dominant objects notify the dependent object of a change in one or more dominant values of the one or more dominant objects.
13. The apparatus of claim 11, the one or more processors configured to:
receive a next formula; and
instruct the one or more macro handlers to remove the registrations with the one or more dominant objects.
14. The apparatus of claim 11, the one or more processors configured to:
parse a next formula to yield one or more next functions, at least one next function comprising a next dependent value of a next dependent object;
determine one or more next macro handlers configured to execute the one or more next functions; and
instruct at least one macro handler to register with one or more next dominant objects on behalf of the next dominant object.
15. The apparatus of claim 11, the one or more processors configured to:
receive the formula from the dependent object.
16. A method comprising:
receiving, at a macro handler, a register instruction to register with one or more dominant objects of a function on behalf of at least one dependent object, a dependent value of the at least one dependent object depending on one or more dominant values of the one or more dominant objects;
identifying the one or more dominant objects of the function; and
registering with the one or more dominant objects on behalf of the at least one dependent object, the registration allowing a dominant object to notify the at least one dependent object of a change in a dominant value of the dominant object.
17. The method of claim 1, the registration allowing the at least one dependent object to provide a notification of a change in the dependent value due to the change in the one or more dominant values.
18. The method of claim 1, further comprising:
receiving an instruction to remove the registration, the instruction sent in response to a next formula; and
removing the registration.
19. One or more non-transitory computer readable media storing code, when executed by one or more processors, configured to:
receive, at a macro handler, a register instruction to register with one or more dominant objects of a function on behalf of at least one dependent object, a dependent value of the at least one dependent object depending on one or more dominant values of the one or more dominant objects;
identify the one or more dominant objects of the function; and
register with the one or more dominant objects on behalf of the at least one dependent object, the registration allowing a dominant object to notify the at least one dependent object of a change in a dominant value of the dominant object.
20. The media of claim 19, the registration allowing the at least one dependent object to provide a notification of a change in the dependent value due to the change in the one or more dominant values.
21. The media of claim 19, the code configured to:
receive an instruction to remove the registration, the instruction sent in response to a next formula; and
remove the registration.
US13/118,778 2011-05-31 2011-05-31 Determining dependencies during macro expansion Expired - Fee Related US8706744B2 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US13/118,778 US8706744B2 (en) 2011-05-31 2011-05-31 Determining dependencies during macro expansion
US14/252,038 US9355189B2 (en) 2011-05-31 2014-04-14 Determining dependencies during macro expansion

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US13/118,778 US8706744B2 (en) 2011-05-31 2011-05-31 Determining dependencies during macro expansion

Related Child Applications (1)

Application Number Title Priority Date Filing Date
US14/252,038 Continuation US9355189B2 (en) 2011-05-31 2014-04-14 Determining dependencies during macro expansion

Publications (2)

Publication Number Publication Date
US20120310957A1 true US20120310957A1 (en) 2012-12-06
US8706744B2 US8706744B2 (en) 2014-04-22

Family

ID=47262475

Family Applications (2)

Application Number Title Priority Date Filing Date
US13/118,778 Expired - Fee Related US8706744B2 (en) 2011-05-31 2011-05-31 Determining dependencies during macro expansion
US14/252,038 Expired - Fee Related US9355189B2 (en) 2011-05-31 2014-04-14 Determining dependencies during macro expansion

Family Applications After (1)

Application Number Title Priority Date Filing Date
US14/252,038 Expired - Fee Related US9355189B2 (en) 2011-05-31 2014-04-14 Determining dependencies during macro expansion

Country Status (1)

Country Link
US (2) US8706744B2 (en)

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20080126326A1 (en) * 2003-04-29 2008-05-29 Cognos Incorporated Database report generation
US7571431B2 (en) * 2003-04-29 2009-08-04 Microsoft Corporation Processing macro information and displaying via GUI in different tools
US7711685B1 (en) * 1998-10-16 2010-05-04 Computer Associates Think, Inc. Method and system for an extensible macro language

Family Cites Families (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5202996A (en) * 1985-10-11 1993-04-13 Hitachi, Ltd. Software structuring system and method by data table translation
US5603021A (en) * 1994-09-02 1997-02-11 Borland International, Inc. Methods for composing formulas in an electronic spreadsheet system
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
US7373354B2 (en) * 2004-02-26 2008-05-13 Sap Ag Automatic elimination of functional dependencies between columns

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7711685B1 (en) * 1998-10-16 2010-05-04 Computer Associates Think, Inc. Method and system for an extensible macro language
US20080126326A1 (en) * 2003-04-29 2008-05-29 Cognos Incorporated Database report generation
US7571431B2 (en) * 2003-04-29 2009-08-04 Microsoft Corporation Processing macro information and displaying via GUI in different tools

Also Published As

Publication number Publication date
US8706744B2 (en) 2014-04-22
US9355189B2 (en) 2016-05-31
US20140222836A1 (en) 2014-08-07

Similar Documents

Publication Publication Date Title
US10621211B2 (en) Language tag management on international data storage
US8732127B1 (en) Method and system for managing versioned structured documents in a database
US9754242B2 (en) Deployment mechanism for non-versioning business process artifacts
US10169393B2 (en) Tracking changes among similar documents
JPWO2016016975A1 (en) Development support system
US8527480B1 (en) Method and system for managing versioned structured documents in a database
US20130275369A1 (en) Data record collapse and split functionality
CN110795447A (en) Data processing method, data processing system, electronic device, and medium
US9002824B1 (en) Query plan management in shared distributed data stores
US8433729B2 (en) Method and system for automatically generating a communication interface
JP2007293723A (en) Database managing system and managing method
US9679092B1 (en) Constraint handling for parameterizable hardware description language
JP7230378B2 (en) Determination device, determination method and determination program
US9355189B2 (en) Determining dependencies during macro expansion
US10558640B2 (en) Dynamically adding custom data definition language syntax to a database management system
US20190018663A1 (en) Code lineage tool
CN114489950A (en) Component adapting method and device, electronic equipment and storage medium
US20130218928A1 (en) Information processing device
JP2007172223A (en) Repository system, method for managing repository, and its program
JP2018005315A (en) Regulation conversion support apparatus and regulation conversion support program
CN113377791A (en) Data processing method, system and computing equipment
JPWO2013031129A1 (en) Information processing apparatus, information processing method, and program
US9002810B1 (en) Method and system for managing versioned structured documents in a database
US10649979B1 (en) System, method, and computer program for maintaining consistency between a NoSQL database and non-transactional content associated with one or more files
US8321844B2 (en) Providing registration of a communication

Legal Events

Date Code Title Description
AS Assignment

Owner name: COMPUTER ASSOCIATES THINK, INC., NEW YORK

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:DEFFLER, TAD A.;REEL/FRAME:026360/0312

Effective date: 20110523

AS Assignment

Owner name: CA, INC., NEW YORK

Free format text: MERGER;ASSIGNOR:COMPUTER ASSOCIATES THINK, INC.;REEL/FRAME:032077/0801

Effective date: 20120327

STCF Information on status: patent grant

Free format text: PATENTED CASE

MAFP Maintenance fee payment

Free format text: PAYMENT OF MAINTENANCE FEE, 4TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1551)

Year of fee payment: 4

FEPP Fee payment procedure

Free format text: MAINTENANCE FEE REMINDER MAILED (ORIGINAL EVENT CODE: REM.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY

LAPS Lapse for failure to pay maintenance fees

Free format text: PATENT EXPIRED FOR FAILURE TO PAY MAINTENANCE FEES (ORIGINAL EVENT CODE: EXP.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY

STCH Information on status: patent discontinuation

Free format text: PATENT EXPIRED DUE TO NONPAYMENT OF MAINTENANCE FEES UNDER 37 CFR 1.362

FP Lapsed due to failure to pay maintenance fee

Effective date: 20220422