EP1609061A2 - Method and array for changing software or source code - Google Patents

Method and array for changing software or source code

Info

Publication number
EP1609061A2
EP1609061A2 EP20040739074 EP04739074A EP1609061A2 EP 1609061 A2 EP1609061 A2 EP 1609061A2 EP 20040739074 EP20040739074 EP 20040739074 EP 04739074 A EP04739074 A EP 04739074A EP 1609061 A2 EP1609061 A2 EP 1609061A2
Authority
EP
European Patent Office
Prior art keywords
code
lt
gt
formulated
codeml
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.)
Withdrawn
Application number
EP20040739074
Other languages
German (de)
French (fr)
Inventor
Roy Oberhauser
Christian Reichel
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.)
Siemens AG
Original Assignee
Siemens AG
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
Priority to DE10314831 priority Critical
Priority to DE2003114832 priority patent/DE10314832B3/en
Priority to DE10314834A priority patent/DE10314834A1/en
Priority to DE2003114835 priority patent/DE10314835A1/en
Priority to DE10314832 priority
Priority to DE10314834 priority
Priority to DE10314835 priority
Priority to DE10314831A priority patent/DE10314831A1/en
Application filed by Siemens AG filed Critical Siemens AG
Priority to PCT/EP2004/003301 priority patent/WO2004088549A2/en
Publication of EP1609061A2 publication Critical patent/EP1609061A2/en
Application status is Withdrawn legal-status Critical

Links

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/51Source to source

Abstract

The invention basically relates to the following: in a first variant, selected components of a software are used as variation points, wherein said components are transformed into a first XML code. The software, which is now in mixed form, is delivered. On the user side, the first code is converted into a second XML code depending only upon transformation rules by means of one or more transformations, e.g. XSLT. In a second variant, a first XML code, which contains at least one language extension, is converted into a second, more easily verifiable XML code without said language extensions depending on transformation rules. In a third variant, a source code formulated in XML is transformed in such a way that a new source code is obtained after back-conversion into the original programming language, in which not only the presentation but also the actual program content or functionality has been changed. In a fourth variant, a source code formulated in XML, for instance, with initial states, code fragments to be exchanged and foreign language modules tailored to the corresponding natural language of the user, are mixed by means of transformation, whereby a new source code is obtained after back-conversion, in which not only the presentation but also the actual program content or functionality has been changed.

Description

description

Method and arrangement for changing of software source code or

The invention relates to a method and an arrangement for changing software or source code, which, converted software or a source code, in a representation in a meta-markup language, such as XML, there, for example, transformed with XSLT and then at the / these in the meta-markup language transformed representation formulated into a modified software or in a modified source code, for example, the same source language is converted back.

Although some possibilities for subsequent changes or modifications of software are known from the prior art, but all have some disadvantages compared to the invention:

One way to influence software is provided using a parameterization. Configuration files are typically used for parameterization and storage of application specific "parameter data 1 *. The

Structure and organization of these files is then set during the development phase, and can be changed under any circumstances after delivery of the software.

Plugins open up the possibility already "delivered" 'to extend to compiled software functionality characteristics. It is therefore necessary that the structures for integration and use of plugins already created during the development phase and those adopted (interfaces, ...).

Code generators generate source code or binary code with the aid of templates / templates at predetermined locations such. B. means are given parameter is completed. In this way it is possible that such. B. for customers Various different software is produced that is different at precisely defined points. Here only specific sites (and not any digits) in the code can be changed, which must be specified exactly with the creation of the template. Code generators are typically used on developer site.

US Patent Application US 6052531A1 is a special

Applicability of known variation points in the form of updates / patches.

From the Internet at http: // beautyj .berlios.de / Java source code transformation tool known BeautyJ in which a Java source code is converted to an XML representation of means Sourclet API, for example by inserting spaces or revised comments certain points, embellished "and then the modified source code into Java source code can be converted back.

A transformation using XSLT is here for this purpose, only proposed but not implemented.

The object underlying the invention is now to provide a method and an arrangement for the modification of

indicate source where / is reached a further more flexible and efficient modification of the software or the source code.

This object is achieved as regards the method by the

Features of claims 1, 6, 8 and 13 and solved with regard to the arrangement by the features of the claims 22 to 26 according to the invention. The further claims relate to preferred embodiments of the invention.

The invention consists essentially in the fact that selected components of a software used in a first variant, as the variation points by being converted into a in a meta-markup language, for example. XLML formulated first code, the software will now be delivered in mixed form, and the first code to be customer-converted by one or more transforms, for example. XSLT, only as a function of transformation rules in a formulated in the meta markup language second code that in a second variant, a formulated in a meta-markup language first code, the at least one said extension includes a function of transformation rules is converted into a formulated in the meta markup language easily verifiable second code without these language extensions, that a transformed in a meta markup language source code is transformed in such a way in a third variant is that, after a Conversion back to the original programming language created ei new source code, in which not only the appearance but also the actual program content or functionality has been changed, or that in a fourth variant of a transformed into a meta-markup language source code with example output states, exchanged code - fragments and tailored to the respective natural language of the user language modules is mixed by transformation, which, after a conversion back to a new source code is created in which not only the appearance but also the actual

Program content and the functionality has been changed.

The invention is explained in more detail below with reference to the drawings shown in the examples. Here, Figure 1 shows an overall block diagram showing a first variant of the invention,

Figure 2 is an overall block diagram showing a second variant of the invention,

Figure 3 is a block diagram for explaining the transfer of PreProcessing- extensions according to the invention,

Figure 4 is an overall block diagram for explaining a third variant of the invention,

Figure 5 is a block diagram for explaining the modification according to the invention by the use of aspects

Figure 6 is a block diagram for explaining the insertion of Migrierbarkeits- functionality according to the invention,

Figure 7 is a block diagram for explaining the modification of the present invention through the use of templates, filters and patterns,

Figure 8 overall block diagram for explaining a fourth variant of the invention,

9 is a block diagram for explaining the replacement of code fragments according to the invention,

Figure 10 is a block diagram for explaining the insertion of status data according to the invention,

Figure 11 is a block diagram for explaining the

Variations of the incorporation of information and according to the invention Figure 12 is a block diagram for explaining the incorporation of foreign language modules according to the invention for the internationalization of the source code.

First variant of the invention

1 shows an overall block diagram for explaining the invention is shown, in which initially a software SW consisting of source code SCI, SC2 and SC is converted into an extraditable software SW *, with some parts of the software such as. SCI now / byte as a binary code Code Bl are available, and other parts such as. SC2 are converted by a converter COV in a formulated in a meta-markup language first code CodeML so that it from now on variation points VP form in the executable software SW *, for instance. VP1. This software SW * may be modified in a manner that / or at run time, the code shown in the meta-markup language VP, for example. VP2, with a transformation T and transformation rules TR in a second formulated in the meta markup language code CodeML * is converted, which is now available as either * modified variation point for example. VP2 * in SW or is converted by a converter Rconv after the transformation T in a source code SC * followed by COMP in a bytecode / binary code VP2b *. In both cases, SW and SW differ * at the sites of variation points and in this way to meet specific needs (eg. Tookit exchange, updates, etc.) can be customized.

The codes CodeML and CodeML or VP and VP * formulated for example in the meta markup language *, where "* XML means Extended Markup Language.

Of particular advantage here is that this must not be done by the program developer, but can be done by suitably equipped and informed customer. To this end, an operator or administrator needs on the customer side only a corresponding transformation T with the required Ersetzungs-, modification and removal rules apply TR to the

adapt software to their specific needs or perform an update or patching. When updating or patching of custom-matched occur frequently been problems because of inconsistencies that can be avoided by this invention and the possibility of the pipeline application or orderly sequential execution from the beginning.

The appended 1 program listings Listing 1 to Listing 5 illustrate this with a concrete example:

Typically, use different toolkits, which differ in terms of performance, price, etc. a software delivery to two different customers.

So here is to code the original one

Registration class

Import electrie.registry.Registry used a glue Toolkit, the second customer now has two new "registration class" import org.apache.axis .client.Call and import org.apache.axis .dient. use services from an Axis toolkit.

In XSL this may eg by

<Xsl: template match = "import">

<Xsl: if test = "dot / name =" Registry "^ <import> <dot> <dot> <dot> <dot> <name> org </ name> <name> apache </ name> </ dot> <name> axis </ name> </ dot>

<Name> client </ name> </ dot> <name> Call </ name> </ dot> </ import> <import> <dot>

<Dot> <dot> <dot> <name> org </ name> <name> apache </ name> </ dot> <name> axis </ Narae> </ dot> <name> client </ name> < / dot> <name> service </ name> </ dot> </ import> </ xsl: if> <xsl: if test = "! dot / name = 'registry'">

<Xsl: "." Copy-of select = /> </ xsl: if>

</ Xsl: template>

happen. Templates or templates are used in XSL to the defined in match pattern. The import template in Listing sample so on all the original import statements. In this specific example, it simply ignores all the original GI AEs reported registry import, and adds instead a two Axis-specific imports.

The inventive method still arise a number of additional advantages, such as:

1. There is only one system for problems such as patching,

Customizing, updating, etc. required and not a number of different partially proprietary tools.

2. The method is based on standards such as XML and XSLT and is subject to terms of convertibility into other languages ​​less restrictions than other methods for modifying source code.

3. No proprietary special solutions are required, even for special and complicated source code modifications, but it can run existing standards such as XSLT, XPath and XQuery are used.

4. This type of modification allows the creation of hierarchies among others by allowing for orderly, automated sequential execution (pipelines) of several transformations, for example. Patches.

5. The transformations can be stored for a general re-use in XSLT files, so that libraries can arise, for example for certain procedures. 6. It can be stored an XML representation of the source code in an XML database and adjusted as required using an XSLT easily to the customer's needs (customization).

7. By using the standard XML schema or DTD or corresponding XSLTs the code can advance (without compilation) on certain aspects correctness out checked (validated) are.

8. Usual XML tools can be used for simple processing or visualization and determination of relationships in the code.

9. Permanent XML-based libraries, the XPath

support requests that code reuse by finding a better code or code fragments or templates can be improved.

2. variant of the invention

In Figure 2 an overall block diagram for explaining the invention is shown in which a formulated in a meta-markup language first code CodeML containing a language extension LE and * is not valid code SC by Rconv be transferred, by a transformation T as a function of transformation rules TR containing a language converter LC, * excluding is converted into a formulated in the meta-markup language second code CodeML that does not contain this language extensions LE and, therefore, can be transformed into a source code SC * which in turn in a valid means of a compiler COMP binary code / byte code B * is convertible. The modified source code SC *, for example, in the Java programming language and the codes CodeML and CodeML * formulated for example in the meta markup language, where "XML" stands for Extended Markup Language.

The transformation T z. As an Extended Stylesheet Language Transformation or XSLT, is transformation rules TR, z. As described within XSL (Extended Stylesheet Language) files, for example, formulated in XSL rules. Uses include a Language Converter LC and describe how the can be transformed into XML-encoded source CodeML with a language extension LE in a variant with no language extension.

In Figure 3, a first embodiment is shown in which a formulated in a meta-markup language first code CodeML (etc., for example, <define> <ifdef>) contains a language extension for PreProcessing PPE, and using a transformant desk T as a function of

Transformation rules TR which a PreProcessing Language Converter PPLC have dissolves the PPE or uses, * is transformed into a formulated in the meta markup language second code CodeML without language extension.

The embodiment of the speech enhancement is typically in the form of elements for the generic programming 1, and / or for PreProcessing 2 and / or a developer künden- or specific grammar 3 and / or macros. 4

All language extension or the CodeML itself can be validated at any time through the use of DTDs (document type definitions) or XML Schema.

The programmer gets more freedom by the invention, as the grammar of the programming language used can be adapted to the needs of the programmer and an inverse transformation must take place only at the end of the program development to the normal grammar of the programming language. A significant advantage is also that a validation of language extensions can be done with a provided for normal programming language compiler is.

The annexed 2 program listings Listing 1 to Listing 3 show the resolution of PreProcessing-

PPE extensions on a concrete example in which the embodiment shown in Listing 1 class Test Output. java < "private" define name = "m" value => contains a PPE in the form of that influence on the values ​​of <m> takes elements, and by a transformation T as a function of transformation rules TR (here: PPLC) now is in the position shown in listing 2 XML-based form Testoutput.xjava * transferred, in which all <m> -Eleιtιente by a particular value on-'private "<private /> - be replaced ent Ele this, it becomes possible test output.. to transfer xjava * in the demonstrated in listing 3 source code test output. java.

The inventive method still results in a number of other advantages, such as:

1. There is only one system for problems such as customizing of programming languages, etc. is required and not a number of different partially proprietary tools.

2. The method is based on standards such as XML and XSLT and is subject to terms of convertibility into other languages ​​less restrictions than other methods for modifying source code.

3. No proprietary special solutions are required, even for special and complicated source code modifications, but it can run existing standards such as XSLT, XPath and XQuery are used.

4. This kind of modification allows the creation of hierarchies among others by the possibility of higher-level, automated sequential execution (pipelines) a plurality of transforms, eg. Voice adjustments.

5. The transformations can be stored for a general re-use in XSLT files, so that libraries can arise, for example for certain procedures.

6. It can store an XML representation of the source code in an XML database and, if required by a

XSTL be easily adapted to each customer and developer needs (customization).

7. By using the standard X or LSchema DTD or corresponding XSLTs the code can advance (without compilation), to certain aspects correctness out checked (validated) are.

8. Usual XML tools can be used for simple processing or visualization and determination of relationships in the code.

3. variant of the invention

4 shows an overall block diagram for explaining the invention is shown, in which initially a source code SC by a converter CONV is converted into formulated in a meta-markup language first code CodeML, wherein the source code SC with immediate

Compilation would result in a byte code or binary code B. The code CodeML shown in the meta-markup language is now modified in the way of a transformation T solely by the use of transformation rules TR, which consist of conditions C and / or logic L and / or code fragments CF, causing a second also in the meta-markup language code formulated CodeML * results. Another converter converts Rconv * after transformation in a source code SC * returns the code CodeML, which is typically formulated in the same language as the source code SC. By a compiler COMP modified code SC * in a modified byte code will eventually but B * or equal converted into executable binary code. It is essential here that the byte code B * principle differs from the byte code B or that the source code has been modified not only in its presentation, but also in its execution.

The source code SC and the modified source code SC *, for example, in the Java programming language and the codes CodeML and CodeML * formulated for example in the meta markup language, where "XML * Extended

Markup Language is.

The transformation T z. As an Extended Stylesheet Language Transformation or XSLT, is transformation rules TR, z. As described in XSL (Extended Stylesheet Language) files, for example, formulated in XSL rules TR among others. Describe how the combined in XML-encoded source CodeML with the code fragment CF, a new modified source code CodeML * with integrated CF, or a modification thereof, to form, which may now contain, for example, additional logging functionality.

In Figure 5, a first embodiment is shown, in which the transformation rules TR correspond especially aspect rules AR of Aspect Oriented Programming (AOP), which expressed in the AspectJ language least one pointcut PC and / or at least one Advice-type AT and / or at least one advice-Body AB may be included and allocated in sequence the components of Figure. 5

In this way can be realized (tool-independent) so-called AOP which generates in comparison to other possible methods, for example AspectJ, no additional overhead in the generated code CodeML * and not the usual restrictions (extra Ko piler, syntax, etc.) existing aspect languages ​​subject ,

As aspect is referred to in AOP a unit which intersecting concerns (crosscutting concerns), for example, a logging, modularized and encapsulates at one point. The corresponding code, previously traversed several modules, is in this case brought together with a single aspect.

The program listings in the appendix 3 Listing 1 to Listing 5 show this in a concrete example in which initially the file TestCalculator contained in Listing. 1 java is converted to an XML representation TestCalculator .xjava. In Listing 3, the description of one aspect is in the form of a file

Logging Aspect .xsl that contains all the necessary transformation rules and ensures that any method that a "bear cal * in its name, is found and at the beginning of the execution of this method a print command System.out.println (" calculate begin Λλ) and at the end of the execution of this method, a

Print command System.out.println ( "calculate end") is used.

If, for example in all 151 classes of a project, all methods that match the pattern "cal", eg public String calcValues ​​() o. Ä., Will be prompted to make a system output at the entrance and exit, it shall first with

match = "* [(fooled () = 'curly') and (ancestor: method [contains (name, 'cal')])]"

all methods with the "cal ΛX - pattern selected with

<Expr> <paren> <dot> <dot> <name> system </ name> <name> out </ name> </ dot> <name> println </ name> </ dot> <exprs> <expr>

<Xsl: text> "</ xsl: text> <xsl: value-of select =" .. / name "/ xxsl: text> begin" </ xsl: text> </ expr> </ exprs> </ paren > </ expr>

a statement "system. out.println (name of the method% +" begin ")," For example, system out. println ( "calculate eπd"), inserted with

<Xsl: copy-of select = "*" />

the original code of the method introduced with

<Expr> <paren> <dot> <dot> <name> system </ name> <name> Out </ NAMEx / dot> <name> println </ name> </ dot> <exprs> <expr>

<Xsl: text> "</ xsl: text> <xsl: value-of select =" .. / name "/ Xχsl: text> end" </ xsl: text> </ expr> </ exprs> </ paren > </ expr>

a statement "System, out. println (% name of the method% +" end ")" For example, system out. inserted println ( "calculate end").

So instead of causing a corresponding logging issue in all 151 classes, this can be done within a logging aspect at one point here. Changes must be made as well in only one place.

Figure 6 relates to a second application example of the invention in which a transformed code CodeML * is also generated from a source code CodeML by the transformation T, which has a mechanism for securing now (OLD) or determining (NEW) at least one condition for the desired ( includes versions) migration. The transformation rules TR are formed in this case such that they can be referred to as migration rules MR, and additionally at least in addition to C and L. A fragment, so-called checkpoints CP, to generate (CP Write) or (CP Read) for reading states ( CP Data) that allow migration from an older version B * oLD to a newer version B * NEW. Required for a migration format conversions of items to be system states can also be considered hereby. Future migrations need thus not be considered in advance, so that the testing effort and related potential program errors are avoided in early versions of the program. By automating the migration, human errors are avoided, as are migrating much more systematic.

In Figure 7, a third embodiment is shown in several sub-variations, also a is in XML encoded source CodeML converted by a transformation T into a modified CodeML * where. The

Transformation T is, however, effected herein by transformation rules TR, which consist in each variant at least C and L and in addition as in the reaction of templates TP least one template fragment TPF, for example. For the conversion into an EJB (Enterprise Java Bean) and the implementation of patterns P, at least one fragment PF pattern have, for example. for the application proxy, factory or singleton pattern. In the realization of filters FI can be eliminated satisfy C and L, since code is only removed, and thus, for example. Unnecessary output statements and comments. are converted by the appropriate application of patterns can proxy local calls in remote calls or similarly local classes in EJB classes (Enterprise Java Beans).

Conversely, T and corresponding rules TR from the XML-encoded source JavaML or a fragment of this code, a valid template TP are generated by means of a transformation that is applicable as a template for other source code.

The characteristics of the inventive method mentioned above can be done individually and in any sequence.

The inventive method still arise a number of additional advantages, such as:

1. It can be made fast and flexible changes in the source code.

2. There is only one system for problems such as pattern application migration, AOP, filtering, etc. required and not a number of different partially proprietary tools.

3. The method is based on standards such as XML and XSLT and is subject to terms of convertibility into other languages ​​less restrictions than other methods for modifying source code.

4. Even for special and complicated source code modifications no proprietary special solutions are required, but it can run existing standards such as XSLT, XPath and XQuery are used. 5. This type of modification allows the creation of hierarchies among others by the possibility of sequential execution (pipelines) of several transformations.

7. The transformations can be saved as general transformations for reuse in XSLT files, so that libraries can arise, for example for certain procedures.

8. It can be stored an XML representation of the source code in an XML database and adjusted as required using an XSLT easily to the customer's needs.

9. The use of standards XmlSchema or DTD or corresponding XSLTs the code can advance (without compilation) on certain aspects correctness out checked (validated) are.

10. Usual XML visualization tools tools can be used for simple processing or visualization and determination of relationships in the code.

11. Permanent XML-based program libraries that support XPath queries, code reuse through better finding a code or code fragments or templates can be improved.

4. variant of the invention

8 shows an overall block diagram for explaining the invention is shown, in which initially a source code SC by a converter CONV is converted into formulated in a meta-markup language first code CodeML, wherein the source code SC with immediate compile a byte code or binary code B can result. For the example shown in the meta-markup language code CodeML is now an additional information INFO on the way of a transformation T described by transformation rules TR code CodeML and ultimately added to the source code SC, whereby a second also formulated in the meta-markup language code CodeML * results. Another converter converts Rconv * after transformation in a source code SC * returns the code CodeML, which is typically formulated in the same language as the source code SC. By a compiler COMP modified code SC * in a modified byte code will eventually but B * or equal converted into executable binary code. It is essential here that the byte code B * is different from the byte code B or that the source code has been modified not only in its presentation, but also in its execution.

The source code SC and the modified source code SC *, for example, in the Java programming language and the codes CodeML and CodeML * formulated for example in the meta markup language, where "XML * stands for Extended Markup Language.

In Figure 10, a first embodiment is shown in which the additional information INFO as data D, for example. Initialization states SSDB, state data SDa, database data De, any data x, the CodeML be mixed, said data for example, solid states or values represent constants and variables. In this way, the source code SC can be supplied and transformed with solid states, so that a required condition for the duration of the program, for example as initialization SSDB, immediately available and will not be separately determined uss. In this way, object-states can be introduced into the code that allow for Restarting (recovery) of an interrupted program in the same place with the same conditions without additional complicated programmatic arrangements for this must be taken.

The transformation T z. B.- an Extended Stylesheet Language Transformation or XSLT, is transformation rules TR, z. As described in XSL (Extended Stylesheet Language) files, for example, formulated in XSL rules. Describe, inter alia, as is combined in XML-encoded source CodeML with the state data from D to a new modified source code CodeML * with SSDB, SDa and to form De.

The rules of a transformation T can thereby be of such a nature that the information but are admixed in their original form in a modified form by the rules.

The rules of a transformation T can thereby be distinct in such a way that the transformation be influenced T eg using if-conditions by which information or data.

The appended 4 program listings Listing 1 to Listing 6 show this in a concrete example in which in a test class of the source code, the uninitialized variable string m_sWelcome in an initialized form m_sWelcome String = "hello"; is transformed. Here, the Listing 1 that is converted to an XML representation Test Output .xjava shows the corresponding Java program Test Output .java. In Listing 3, the XML file state.xml is shown with the state value "hello". In Listing 4, the transformation instruction is then followed for mixing Mixing.xsl that provide with instructions as template match = and apply-templates that the code is modified at the right place.

In Figure 9, a second embodiment is shown in which a coded in XML code fragment CFb with an original encoded in XML source code CodeML containing a code fragment CFa, is transformed by the transformation T such that in the modified XML-encoded source CodeML * a code fragment CFb is included instead of the previously existing fragment CFa. The transformation T is thereby controlled from transformation rules TR. Such exchange of code fragments can be called * eg as "patching in certain circumstances. By the inventive method, a patching can be achieved in a consistent manner with a maximum degree of freedom for the software developer, and this can be effected for example automatically under consideration of mutual dependencies.

a concrete case by the listings 1A to 6A of the program listings in the appendix 5 is shown for this embodiment. Test Output from the Java source code. java is again a text output. java generated. In Listing 3A kan see CodeFragment.xml file that provides a code fragment. The listing 4A now contains the file patching. sl the rules for the transformation T, where again the template match = and apply-templates instructions are used. In the listing 5A of the contents of the file is then TestOutput.xjava (*) with the modified XML source code in Listing 6A in the file Test Output. java (*), the modified Java source code shown. In this example, in the public test class string assignment string _sWelcome = "hello" is; by a string assignment string m_sWelcome =

can; 'is replaced, wherein the fixed value so here) "hello" is replaced, and, for example, mistakenly "" By the requested from the system property "WELCOME hardcoded * value assignment now patched" * are System.getPropertyC'WELCOME.

Figure 11 relates to a third application example of the

Invention, in which the information INFO of Drawing Figure 1 be mixed not only in the manner indicated above in the form of information INFOl but also additionally form of embedded in the transformation rules information INF02 or fragments.

Figure 12 relates to a fourth application example of the invention in which XML source code CodeML with the code fragment CF, containing the foreign language fragments LFl and LF2, T is combined by the transformation to a modified code CodeML *, for example, adapted to the natural language of the user (Ll = German) to get. The transformation XSLT is determined here by transformation rules TR which specifies the to change of its source code as well as the respective selected natural language, for example, German or english. The inventive method is thus a localization and internationalization of the source code in an efficient and economical way, achieved while minimizing the requisite additional runtime.

The characteristics of the inventive method mentioned above can be done individually and in any sequence.

The inventive method results in a number of advantages, such as:

1. It can be made fast and flexible changes in the source code. 2. It's just a system for problems such as patching, customizing, updating, etc. required and not a number of different partially proprietary tools.

3. The method is based on standards such as XML and XSLT and is subject to terms of convertibility into other languages ​​less restrictions than other methods for modifying source code.

4. Even for special and complicated source code modifications no proprietary special solutions are required, but it can run existing standards such as XSLT, XPath and XQuery are used.

5. This type of modification allows the creation of

Hierarchies among others by the possibility of higher-level, automated sequential execution (pipelines) a plurality of transforms, for example. Patches.

7. The transformations for a general

Reuse in XSLT files are saved so that libraries can arise, for example for certain procedures.

8. It can store an XML representation of the source code in an XML database and, if required by a

XSTL be adapted easily to the customer's needs (customization).

9. By using the standard XML schema or DTD or corresponding XSLTs the code can advance (without compilation) on certain aspects correctness out checked (validated) are.

10. Usual XML tools can be used for simple processing or visualization and determination of relationships in the code. 11. Permanent XML-based program libraries that support XPath queries, code reuse through better finding a code or code fragments or templates can be improved.

Annex 1 :

Listing 1: Test Registry. Java

import electπc.registry. registry; public class Test Registry

{

, // Another source in which something has to be changed}

Listing 2: TestRegistry.xjava

<? xml versιon = "1.0" encodmg = "UTF-8"?> <3 ava>

<Ιmport>

<DotXdotXname> electrιc </ nameXname> regιstry </ NAMEx / dotXname> Regιstry </ name> </ dot> </ ιmport> <class> <modιfιersXpublιc / X / modιfιers>

<Name> TestRegιstry </ name> <block>

<Block> </ class>

</] Ava>

Listing 3: VariationPointTl. sΣsl

<Xsl: stylesheet versιon = "l .0" xmlns: xsl = "http: //www.w3.org/1999/XSL/Transform"> <i *************** ******************

*** copy template ** ii * ÜAii & **** "■ '* i J *** • * • J - 1 **** *** ά ^. 5

<xsl: template match- "J '"> <xsl: copyXxsl: apply-templates / X / xsl: copy>

</ Xsl: template>

*** Vario Transportation Point Transformation 1 ** ******* ** ****************** * ************* ***** * -> <xsl: template match = "ιmport">

<Xsl: ιf test = "dot / name = 'Registry'"> <import> <dot>

<DotXdotXdotXname> org </ nameXname> apache </ NAMEx / dotXname> axιs </ NAMEx / dot> <name> clιent </ NAMEx / dot> <name> Call </ name>

</ Dot> </ ιmport> <ιmρort>

<Dot> <dotXdotXdotXname> org </ nameXname> apache </ NAMEx / dotXname> axιs </ NAMEx / dot>

<Name> clιent </ NAMEx / dotXname> Serv ce </ name> </ dot> </ ιmport> </ xsl: if> <xsl: ιf test = "dot / name '=' Regιstry '">

<Xsl: "." Copy-of select = /> </ xsl: ιf>

</ Xsl: template> </ xsl: stylesheet> Listing 4: Test Registry. java (*)

<? Xml version = "1.0" enσoding = "UTF-8"?> <J ava> <import> <dot>

<DotXdot> <dot> <name> org </ nameXname> apache </ NAMEx / dot> <name> axis </ NAMEx / dot> <name> client </ name> </ dotXname> Call </ name> </ dot> </ import> <import> <dot>

<Dot> <dotXdot> <name> org </ nameXname> apache </ NAMEx / dot> <name> axis </ NAMEx / dot> <name> client </ NAMEx / dotXname> Service </ name> </ dot> </ import> <class>

<ModifiersXpublic / X / modifiers> <name> Test Registry </ name> <block>

<Block> </ class> </ java>

Listing 5: TestRegistry.java (*) import org. Apache. axis .dient .Call; // Axis import org. Apache. axis .client. Service; public class Test {Registry

... // Another source has been changed somewhat in the}

Annex 2

Listing 1: TestOutput.xjava

<? Xml version = "1.0" encoding = "UTF-8"?> <J ava>

<Define name = "" value = "private"> <class>

<Odifiers> <m / x / modifiers> <name> Testθutput </ name> <block> <var>

<Type> <name> string </ name> </ type> <name> m_s elcome </ name> </ var> </ block> </ class> </ java>

Listing 2: TestOutpu xjava *

<? Xml version = "1.0" encoding = "UTF-8"?> <J ava> <class>

<Modifiers> <private / x / modifiers> <name> Testθutput </ name> <block> <var> <type> <name> string </ name> </ type>

<Name> m_sWelcome </ na e> </ var> </ block> </ class> </ java>

Listing 3: Test Output Java

private class Test {Output

String m_sWelcome;

Annex 3}

Listing 1: TestCalculator.java public class TestCalculator {private int z; public void calculate (int x, int y) {z = x + y; }

Listing 2: TestCalcuIator.xjava <? Xml version = ". 1 0" encoding = "UTF-8">

<J ava> <class>

<ModifiersXpublic / X / modifiers> <name> TestCalculator </ name> <block>

<Var>

<ModifiersXprivate / X / modifiers> <typeXint / X / typeXname> z </ name> </ var> <method> <modifiers> <public / X / modifiers>

<Type> <void / X / type> <name> calculate </ name> <params>

<Param> <type> <int /> </ type> <name> x </ name> </ param> <paramxtype> <int / x / type> <name> y </ name> </ param>

</ Params> <curly> <expr> <a> <name> z </ name>

<PlusXname> x </ nameXname> y </ NAMEx / plus> code </ expr> </ curly> </ method>

</ Block> </ class> </ java>

Listing 3: LoggingAspectxsI

<Xsl: stylesheet version = "l .0" xmlns: xsl = "http: // www third org / 1999 / XSL / Transform."> <J *************** ******************

*** copy template ** *********************************>

<Xsl: template match = "*">

<Xsl: copyXxsl: apply-templates / X / xsl: copy> </ xsl: template>

<1 * *** *** * ** ** *** ***** * ** ** *** * * * **

*** logging aspect ** <xsl: copy> <<xsl: template matσh = "* [(rmethod [contains (name, 'cal')] ancestor) (name () = 'curly') and]"> expr> <paren> <dotXdotXname> system </ nameXname> out </ NAMEx / dotXname> println </ NAMEx / dot> <exprs> <expr> <xsl: text> "</ xsl: text> <xsl: value- of select = ".. / name" / Xχsl: text> begin "</ xsl: text> </ expr> </ exprs> </ paren> </ expr>

<Xsl: copy-of select = "*" /> <expr> <paren> <dot> <dotXname> System </ nameXname> Out </ NAMEx / dot> <name> println </ NAMEx / dot> <exprs> <expr>

<xsl: text> "</ xsl: textXxsl: value-of select =" .. / name "/ Xxsl: text> end" </ xsl: text> </ expr> </ exprs> </ paren> </ expr> </ xsl: copy> </ xsl: template> </ xsl: stylesheet>

Listing 4: TestCaIculator * .xjava

<? Xml version = "1.0" encoding = "UTF-8"?> <J ava>

<Class>

<ModifiersXpublic / X / modifiers> <name> TestCalculator </ name> <block> <var>

<ModifiersXprivate / X / modifierΞ> <typeXint / X / type> <name> z </ name> </ var> <method>

<ModifiersXpublic / X / modifiers> <typeXvoid / x / type>

<Name> calculate </ name> <params>

<ParamXtypeXint / X / type> <name> x </ NAMEx / param> <paramXtypeXint / X / typeXname> y </ NAMEx / param> </ params>

<Curly> <paren>

<Dot> <dot> <name> system </ name> <na ne> Out </ name> </ dot> <naιne> println </ name> </ dot> <e3φrs e3φ> "calculata begin" </ axprX / exprs>

</ Paren> </ expr> <expr> <a> <name> z </ name>

<PlusXname> x </ name> <name> y </ NAMEx / plus> code </ expr> <expr> <paren>

<Dotx: dotXname> System </ nameXname> Out </ NAMEx / dotXname> println </ naπιeX / dot> <exprsXexpr> "calculate end" </ exprX / exprs> </ paren> </ expr> </ curly>

</ Method> </ block> </ class> </ ava>

Listing 5: TestCalculator * .java public class TestCalculator 'private int z; public void calculate (int x, int y) ■ system. out. println ( "calculate begin"); z = x + y;

System. out. println ( "calculate end");

Annex 4

Listing 1: Test Output. Java

public class Test {Output

String m_sWelcome;

}

Listing 2: TestOutputxjava

<? Xml version = "1.0" encoding = "UTF-8"?> <Java> <class> <modifiersXpublic / x / modifiers> <name> Testθutput </ name> <block> <var>

<TypeXname> string </ NAMEx / type> <name> m_sWelcome </ name>

</ Var> </ block> </ class> </ java>

Listing 3: State. ml

<? Xml version encoding = "1.0" = "UTF-8"?> <State name = "m_s elcome"> <value> "hello" </ value> </ state>

Listing 4: Mixing.xsl

<Xsl: stylesheet version = "1.0" xmlns: xsl = "http: // www 3.org/1999/XSL/Transform.">

<J *********************************

*** copy template ** ********************************* ->

<Xsl: template match = "*">

<Xsl: copyXxsl: apply-templates / X / xsl: copy> </ xsl: template> <; ********************************* *** mixing template **

********************************* ->

<Xsl: emplate match = "* [(name () = 'var') and (name = 'm_sWelcome')]"> <xsl: copy> <xsl: copy-of select = "*" /> <a>

<Expr> <xsl: value-of select = "// state [@ name = 'm_s elcome'] / value" /> </ expr> code </ xsl: copy> </ xsl: template> < / xsl: stylesheet>

Listing 5: Test Output. xjava (*)

<? Xml version = "1.0" encoding = "UTF-8"?> <Java> <class>

<Modifiers> <public / x / modifiers> <name> Testθutput </ name> <block> <var>

<TypeXname> string </ name> </ type> <name> m_s elcome </ Narae> <a> <expr> "hello" </ expr>

</ __> </ var> </ block> </ class> </ java>

Listing 6: Test Output. java (*)

public class Test {Output

String m_sWelcome = "hello";

}

Appendix 5

Listing 1A: Test Output Java

public class Test {Output

String m_s elcome = "ello";

}

Listing 2A: TestOutputxjava

<? Xml version = "1.0" encoding = "UTF-8"?> <J ava> <class> <modifiersXpublic / x / modifiers> <name> Testθutput </ name> <block> <var>

<TypeXname> string </ name> </ type> <name> m_sWelcome </ name>

<a>

<Expr> "hello" </ expr> code </ var> </ block> </ class> </ java>

Listing 3A: code fragment. xml

<? Encoding xml version = "1.0" = "UTF-8"?> <Fragment name = "m_sWelcome"> <expr> <paren> <dot> <name> system </ name> <name> getProperty </ NAMEx / dot> <exprs> <expr> "ELC0ME" </ exprX / exprs> </ paren> </ expr> </ fragment>

Listing 4A: Patching. sl

<Xsl: stylesheet version = "1.0" xmlns: xsl = "http: //www.w3.org/1999/XSL/Transform">

<J *********************************

*** copy template ** *********************************>

<Xsl: template match = "*"> <xsl: copyXxsl: apply-templates / x / xsl: copy>

</ Xsl: template>

<Ι *********************************

*** patching template * "*

********************************* -> <xsl: template match = "* [(name () = ' a ') and (ancestor: var / name =' m_sWelcome ')] "> <xsl: copy>

<Xsl: copy-of select = "// fragment [@ name = 'm_sWelcome'] / expr" /> </ xsl: copy> </ xsl: template> </ xsl: stylesheet>

Listing 5A: Test Output. xjava (*)

<? Xml version = "1.0" encoding = "UTF-8"?> <J ava>

<Class>

<Modifiers> <public / X / modifiers> <name> s Te tθutput </ name> <block> <var>

<Type> <name> string </ NAMEx / type>

<Name> m_s elcome </ name>

<a>

<Expr> <paren>

<Dot> <name> system </ name> <name> getProperty </ NAMEx / dot> <exprsxexpr> "ELC0 E" </ expr> </ exprs> </ paren> </ expr> </a>

</ Var> </ block> </ class> </ java>

Listing 6A: Test Output. java (*)

public class Test Output

{String = m_sWelcome System.getPropert ( "elcome"

}

Claims

claims
1. A method for modification of software, - in which in advance by the manufacturer consisting of an only source (SCI, SC2, SC) original software a mixed form of the original software is formed such that at least a part (SCI) of the source text in a Byteoder binary code compiled (B1, .., B) and at least one further part (SC2) of the source text in a formulated in a meta-markup language code (CodeML) for at least one point of variation (VP2, ..VP) is converted,
- in which then the customer as required only at least one variation point (VP2) of the hybrid (SW) of the original software by a transformation (T) as a function of transformation rules (TR) in at least one formulated in the meta markup language other code (CodeML *) is converted and
- in which the other code (CodeML *) directly an altered variation point (VP2 *) forms a custom software (SW *) or from the other code (CodeML *) by a converter (Rconv) a source code (SC *), and then by a compiler (COMP) is a binary or byte code (B *) of the modified variation point (Vpb2) a custom software (SW *) is formed, with the original (SW) and the customized software (SW *) in their execution, or different program content.
2. The method of claim 1, wherein the transformation rules (TR) comprise at least one modification rule for a variation point.
3. The method of claim 1 or 2, wherein the modification usually abuts an update to a newer software version or a patching.
4. The method of claim 1 or 2, wherein the modification is at least one variation point (VP) by the transformation at runtime.
5. The method according to any one of the preceding claims, wherein the programming language Java source code and the meta-markup language XML is the variation points and in which the transformation and the rule description means of XSLT and XSL occurs.
6. A method for modifying the source code, - in which a formulated in a meta-markup language first code (CodeML) with at least formulated in a meta-markup language language extensions (LE) is available as output code that
- (TR) in at which the output code by a transformation (T) in dependence on a transformation rules in the
Meta-markup language formulated second code (CodeML *) without the formulated in the meta-markup language language extensions (LE) is transferred,
- in which the transformation rules form a language converter (LC), the language extensions (LE) of the first
Codes so dissolve or applies that they (Rconv) are of no corresponding language extension has processed by a back converter, and
- in which the second code in a formulated in the first programming language or a programming language other second source code (SC *) can be converted, and a valid binary code / ByteCode (B *) is obtained.
7. The method of claim 6, at least one language extension in which the second code (CodeML *) (LE *) taken regenerated or from the first code (CodeML), and this generation or acquisition of speech converter (LC) performs.
8. A method for modifying the source code,
- in which a formulated in a first programming language source code (SC) in a formulated in a meta-markup language first code (CodeML) is converted,
takes place at which a transformation (T) only in response to transformation rules TR in a formulated in the meta markup language second code (CodeML *), and - - in which the second code in a in the first
Programming language or any other programming language formulated second source code (SC *) is changed, wherein the first and the second source code in their functionality (B, B *) are different.
9. The method of claim 8, wherein the transformation rules (TR) at least one condition C and a logic component L and / or code fragment CF self-contained.
10. The method of claim 8 or 9, wherein the transformation rules (TR) at least one fragment in the form of a template (TPF) and / or at least one pattern (PF) entalten wherein effected with the aid of the transformation T is at least a code change.
11. The method of claim 10, is adapted in the TR, that with the aid of the transformations T a mechanism for securing at least one system state to the second source code (CodeML *) are introduced to allow migration in other versions.
12. The method of claim 8 or 9, is formed in the at least one template with the transformation T from the first code or a fragment of the first code (TP).
13. A method for modifying the source code,
- in which a formulated in a first programming language source code (SC) in a formulated in a meta-markup language first code (CodeML) is converted,
- in which a formulated in the meta-markup language, the subsequent program execution (B *) influencing information (INFO) by a transformation (T) to this first code replacing or not replacing added and then the also formulated in the meta-markup language second code ( CodeML *) is formed, wherein the transformation is a function of formulated in a Transforrαationsbeschreibungsspräche transformation rules (TR), and - in which the second code in a in the first
Programming language or any other programming language formulated second source code (SC *) is changed, wherein the program content or program sequence (B) of the first source code (SC) by the program content or program sequence (B *) of the second source code (SC *) differs.
14. The method of claim 13, wherein the information (INFO) at least one code fragment
(CFB), and wherein the second source code is formed by at least one included in the first source code fragment
(CFA) is replaced with the help of the transformation by the at least one fragment contained in the code fragment (CFB).
15. The method of claim 13, wherein the information (INFO) special data (D) in the form of initialization states (SSDB) or state data (SDA) or database data (De) included.
16. The method of claim 15, wherein the transformation rules (TR) of this information (D) can be influenced.
17. The method according to any one of claims 13 to 16, wherein the data (D) and / or code fragments (CF) are additionally embedded in the transformation rules.
18. The method according to any one of claims 13 to 17, are added at the checkpoints generated by means of a transformation data so that is, the internal state of the original program at the restart of the program available, or can be used by this.
19. A method according to any one of claims 13 to 17, wherein the information (INFO) updates or patches contain.
contained 20. The process according to claim 13 to 17, wherein the fragments (LFl, LF2) information for the internationalization which serve to adapt to different natural languages.
21. The method according to any one of claims 13 to 17 carry, originate in which data and / or code fragments from a library and tailored to customers or groups of customers information.
22. The arrangement for changing software,
- in a mixed form of an original software is present such that at least part (SCI) of
converting source code into a binary code or byte (B1, .., B) compiled and at least one further part (SC2) of the source text in a formulated in a meta-markup language code (CodeML) for at least one point of variation (VP2, ..VP) is
- is in the means for transforming (T) present such that only required at least one
Variation point (VP2) of the hybrid (SW) of the original software by the transformation (T) as a function of transformation rules (TR) is convertible into at least one formulated in the meta markup language other code (CodeML *), wherein the other code (CodeML * ) directly an altered variation point (VP2 *) a custom software (SW *) or forms (from the other code CodeML *) by a converter (Rconv) a source code (SC *), and then (by means of a compiler COMP) is a binary or ByteCode (B *) (* SW) can be formed of the modified variation point (Vpb2) of an adapted software and wherein the original (SW) and the customized software (SW *) differ in their program sequence or program content.
23. The arrangement for changing source code,
- in which a processor is present such that a transformation (T) of the output code (CodeML) as a function of formulated in an extended style description language transformation rules (TR) and a speech converter contained therein (LC) is performed so that either in the meta -Auszeichnungssprache formulated second code (CodeML *) without the formulated in the meta markup language extensions (LE) of the first code (CodeML), or formulated in the meta-markup language second code (CodeML *) with new and / or the original in the meta-markup language formulated language extensions (LE) is generated, and
- wherein a feedback converter (Rconv) is such provided, that this second code in a formulated in the first programming language or any other programming language source code (SC *) is transformed.
24. The arrangement for changing source code,
- is in a first converter (CONV) present such that a formulated in a first programming language source code (SC) in a formulated in a meta-markup language first code (CodeML) is converted, - in which a processor is present such that the CodeML by a transformation (T) only in response to transformation rules (TR) in a formulated in the meta markup language second code (CodeML *) is converted and - wherein a second converter (Rconv) present such that this second code in a formulated in the first programming language or a programming language other second source code (CodeML *) is changed, wherein the first and the second source code in their functionality or content (B, B *) are different.
25 arrangement for changing source code,
- is in a first converter (CONV) present such that a formulated in a first programming language
Source code (SC) in a formulated in a meta-markup language first code (CodeML) is converted,
- in which a processor is present such that a formulated in the meta-markup language, the subsequent program execution (B *) influencing information (INFO) by a transformation (T) to this first code replacing or not replacing added and so likewise in the meta markup language formulated second code (CodeML *) is formed, wherein the transformation in dependence of formulated in a transformation description language transformation rules (TR) is effected, and - in which a second converter (Rconv) present such that this second code in a in is converted to the first programming language or any other programming language formulated second source code (SC *), wherein the program content or program sequence (B) of the first source code (SC) by the program content or program sequence (B *) of the second source code (SC *) differs ,
EP20040739074 2003-04-01 2004-03-29 Method and array for changing software or source code Withdrawn EP1609061A2 (en)

Priority Applications (9)

Application Number Priority Date Filing Date Title
DE2003114832 DE10314832B3 (en) 2003-04-01 2003-04-01 Computer software modification method with initial conversion of selected software components at modification points and delivery in mixed form for final conversion of software components on user side
DE10314834A DE10314834A1 (en) 2003-04-01 2003-04-01 Computer software modification method with initial conversion of selected software components at modification points and delivery in mixed form for final conversion of software components on user side
DE2003114835 DE10314835A1 (en) 2003-04-01 2003-04-01 Computer software modification method with initial conversion of selected software components at modification points and delivery in mixed form for final conversion of software components on user side
DE10314832 2003-04-01
DE10314834 2003-04-01
DE10314831 2003-04-01
DE10314835 2003-04-01
DE10314831A DE10314831A1 (en) 2003-04-01 2003-04-01 Computer software modification method with initial conversion of selected software components at modification points and delivery in mixed form for final conversion of software components on user side
PCT/EP2004/003301 WO2004088549A2 (en) 2003-04-01 2004-03-29 Method and array for changing software or source code

Publications (1)

Publication Number Publication Date
EP1609061A2 true EP1609061A2 (en) 2005-12-28

Family

ID=33136033

Family Applications (1)

Application Number Title Priority Date Filing Date
EP20040739074 Withdrawn EP1609061A2 (en) 2003-04-01 2004-03-29 Method and array for changing software or source code

Country Status (3)

Country Link
US (1) US8473937B2 (en)
EP (1) EP1609061A2 (en)
WO (1) WO2004088549A2 (en)

Families Citing this family (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20070240040A1 (en) * 2006-04-05 2007-10-11 Christopher Peters Non-compiled portable algorithm
US8079027B2 (en) * 2006-09-08 2011-12-13 Via Technologies, Inc. Programming language translation systems and methods
JP5664237B2 (en) * 2008-05-13 2015-02-04 日本電気株式会社 XML processing apparatus, XML processing method, and XML processing program
CN101650648A (en) * 2008-08-14 2010-02-17 鸿富锦精密工业(深圳)有限公司;鸿海精密工业股份有限公司 System and method for dynamically calling functional module
US8984165B2 (en) * 2008-10-08 2015-03-17 Red Hat, Inc. Data transformation
US9965453B2 (en) * 2009-10-15 2018-05-08 Microsoft Technology Licensing, Llc Document transformation
US9223570B2 (en) * 2013-03-14 2015-12-29 Red Hat, Inc. Migration assistance using compiler metadata

Family Cites Families (19)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6052531A (en) * 1998-03-25 2000-04-18 Symantec Corporation Multi-tiered incremental software updating
US6981212B1 (en) * 1999-09-30 2005-12-27 International Business Machines Corporation Extensible markup language (XML) server pages having custom document object model (DOM) tags
US7188332B2 (en) * 1999-10-05 2007-03-06 Borland Software Corporation Methods and systems for relating a data definition file and a data model for distributed computing
DE10121790B4 (en) * 2000-06-03 2006-11-23 International Business Machines Corp. Software configuration method for use in a computer system
US7000230B1 (en) * 2000-06-21 2006-02-14 Microsoft Corporation Network-based software extensions
US7219332B2 (en) * 2000-07-07 2007-05-15 Microsoft Corporation Configuring software components(merge) with transformation component using configurable and non-configurable data elements
US20050091666A1 (en) * 2000-08-14 2005-04-28 Transvirtual Technologies, Inc. Portable operating environment for information devices
US7739308B2 (en) * 2000-09-08 2010-06-15 Oracle International Corporation Techniques for automatically provisioning a database over a wide area network
JP2002182915A (en) * 2000-12-19 2002-06-28 Tokio Marine & Fire Insurance Co Ltd Source program storage method, its system, source program restoring method and system, and compiling method and device
US20020143816A1 (en) * 2001-03-06 2002-10-03 Geiger Michael P. Method and system for using a generalized execution engine to transform a document written in a markup-based declarative template language into specified output formats
US7310653B2 (en) * 2001-04-02 2007-12-18 Siebel Systems, Inc. Method, system, and product for maintaining software objects during database upgrade
US7703009B2 (en) * 2001-04-09 2010-04-20 Huang Evan S Extensible stylesheet designs using meta-tag information
US20040015890A1 (en) * 2001-05-11 2004-01-22 Windriver Systems, Inc. System and method for adapting files for backward compatibility
US20040015832A1 (en) * 2001-05-25 2004-01-22 Michael Stapp Method and apparatus for generating source code
WO2003102767A2 (en) * 2002-05-29 2003-12-11 Globespan Virata Incorporated Method and system for providing a command-line interface syntax from an xml specification
US7721202B2 (en) * 2002-08-16 2010-05-18 Open Invention Network, Llc XML streaming transformer
US7069504B2 (en) * 2002-09-19 2006-06-27 International Business Machines Corporation Conversion processing for XML to XML document transformation
CA2409079A1 (en) * 2002-10-21 2004-04-21 Ibm Canada Limited-Ibm Canada Limitee Creating multiple and cascading business interpretations from raw application data using transformation layering
US7346897B2 (en) * 2002-11-20 2008-03-18 Purenative Software Corporation System for translating programming languages

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
See references of WO2004088549A2 *

Also Published As

Publication number Publication date
US20090210864A1 (en) 2009-08-20
WO2004088549A2 (en) 2004-10-14
WO2004088549A3 (en) 2005-02-24
US8473937B2 (en) 2013-06-25

Similar Documents

Publication Publication Date Title
Czarnecki et al. Feature-based survey of model transformation approaches
Czarnecki et al. Generative programming for embedded software: An industrial experience report
Nystrom et al. Polyglot: An extensible compiler framework for Java
Bodoff et al. The J2EE tutorial
Bettini Implementing domain-specific languages with Xtext and Xtend
Miles AspectJ Cookbook: Aspect Oriented Solutions to Real-World Problems
US6742175B1 (en) Component-based source code generator
US6493661B1 (en) Reusable multi-language support facility for software
US7434209B2 (en) Method and apparatus for performing native binding to execute native code
Flatt Composable and compilable macros:: you want it when?
US5230049A (en) Program source code translator
Kats et al. The spoofax language workbench: rules for declarative specification of languages and IDEs
Visser WebDSL: A case study in domain-specific language engineering
US7370318B1 (en) System and methodology for asynchronous code refactoring with symbol injection
Aßmann Invasive software composition
US20050044537A1 (en) Extendable compiler framework
JP2007529063A (en) Method and apparatus for performing native binding
JP5204070B2 (en) Method for generating a tool for merging customizations made to a first version of a software product when migrating to a second version of the software product, a computer usable medium and a data processing system
EP1491999A2 (en) Software development infrastructure
Li et al. Tool support for refactoring functional programs
US20040003388A1 (en) Preparation of a software configuration using an XML type programming language
US5805899A (en) Method and apparatus for internal versioning of objects using a mapfile
Efftinge et al. oAW xText: A framework for textual DSLs
US6738967B1 (en) Compiling for multiple virtual machines targeting different processor architectures
US7774435B2 (en) System and method for batch tuning intelligent devices

Legal Events

Date Code Title Description
17P Request for examination filed

Effective date: 20050909

AK Designated contracting states:

Kind code of ref document: A2

Designated state(s): AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HU IE IT LI LU MC NL PL PT RO SE SI SK TR

AX Request for extension of the european patent to

Extension state: AL LT LV MK

RIN1 Inventor (correction)

Inventor name: REICHEL, CHRISTIAN

Inventor name: OBERHAUSER, ROY

DAX Request for extension of the european patent (to any country) deleted
RBV Designated contracting states (correction):

Designated state(s): DE FR GB

17Q First examination report

Effective date: 20100629

RAP1 Transfer of rights of an ep published application

Owner name: SIEMENS AKTIENGESELLSCHAFT

RAP1 Transfer of rights of an ep published application

Owner name: SIEMENS AKTIENGESELLSCHAFT

18D Deemed to be withdrawn

Effective date: 20161001