DE102016202484A1 - Method, apparatus and system for generating a compilation - Google Patents

Method, apparatus and system for generating a compilation Download PDF

Info

Publication number
DE102016202484A1
DE102016202484A1 DE102016202484.1A DE102016202484A DE102016202484A1 DE 102016202484 A1 DE102016202484 A1 DE 102016202484A1 DE 102016202484 A DE102016202484 A DE 102016202484A DE 102016202484 A1 DE102016202484 A1 DE 102016202484A1
Authority
DE
Germany
Prior art keywords
class
subclass
public
file
internal
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.)
Pending
Application number
DE102016202484.1A
Other languages
German (de)
Inventor
Daniele Bordes
Markus Hosch
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.)
Bayerische Motoren Werke AG
Original Assignee
Bayerische Motoren Werke 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
Application filed by Bayerische Motoren Werke AG filed Critical Bayerische Motoren Werke AG
Priority to DE102016202484.1A priority Critical patent/DE102016202484A1/en
Publication of DE102016202484A1 publication Critical patent/DE102016202484A1/en
Pending legal-status Critical Current

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/70Software maintenance or management
    • G06F8/71Version control; Configuration management
    • 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/423Preprocessors
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/20Software design
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/41Compilation

Abstract

Die bisher bekannte Trennung von Implementierung und Schnittstelle beim Programmieren führt zu ineffizienter Speichernutzung, unnötigen Übersetzungsschritten und Netzwerkbelastungen. Erfindungsgemäß wird das Problem gelöst durch ein Verfahren zur Erzeugung eines Kompilats (30) in einer Entwicklungsumgebung (60) mit: – einer Benutzerklasse (61) mit zumindest einer Definition umfassend eine Definition zumindest eines Klassenmembers der Benutzerklasse (61); – einer Teilklasse (62), wobei die Teilklasse (62) zumindest einen internen Klassenmember (63) und zumindest einen öffentlichen Klassenmember (64) aufweist; und – zumindest einer öffentlichen Datei (41, 51, 51‘), die eine Deklaration von zumindest einem öffentlichen Klassenmember (66) der Teilklasse (62) enthält, wobei die öffentliche Datei (41, 51, 51‘) keine Deklaration von dem internen Klassenmember (63) der Teilklasse (61) enthält, wobei das Verfahren die Schritte aufweist: – Einbinden des öffentlichen Klassenmembers (66) der Teilklasse (62) und/oder einer Referenz auf eine Objektinstanz der Teilklasse (62) in der Definition der Benutzerklasse (61); – Erzeugen eines Kompilats (67) von der Benutzerklasse (61) unter Bezugnahme der Definition der Benutzerklasse (61) und der öffentlichen Datei (41, 51, 51‘).The previously known separation of implementation and interface in programming leads to inefficient memory usage, unnecessary translation steps and network loads. According to the invention, the problem is solved by a method for creating a compilation (30) in a development environment (60) comprising: - a user class (61) having at least one definition comprising a definition of at least one class member of the user class (61); A subclass (62), the subclass (62) having at least one internal class member (63) and at least one public class member (64); and at least one public file (41, 51, 51 ') containing a declaration of at least one public class member (66) of the subclass (62), wherein the public file (41, 51, 51') is not a declaration of the internal Class member (63) of the subclass (61), the method comprising the steps of: - incorporating the public class member (66) of the subclass (62) and / or a reference to an object instance of the subclass (62) in the definition of the user class ( 61); - generating a compilation (67) from the user class (61) with reference to the definition of the user class (61) and the public file (41, 51, 51 ').

Description

Die Erfindung betrifft ein Verfahren zur Erzeugung eines Kompilats, eine entsprechende Vorrichtung und ein System. The invention relates to a method for generating a compilation, a corresponding device and a system.

Moderne Programmiersprachen, insbesondere objektorientierte Programmiersprachen, sehen eine Vielzahl von Abstraktionsmechanismen vor, um die logischen und funktionellen Bestandteile eines Programms zu trennen. Solch eine Trennung von Programmteilen ist aus verschiedenen Gründen wünschenswert. So ist zum einen eine erhöhte Übersichtlichkeit über die einzelnen Programmkomponenten gewährleistet, da die Quellcodedateien nur logisch zusammengehörende Komponenten aufweisen. Zum anderen wird es möglich, dass bei der Durchführung von Änderungen nicht unnötig große Dateien anderen Entwicklern zur Verfügung gestellt werden müssen. Letzteres kann sonst zu unnötigem Kompilieren von Quellcode führen. Modern programming languages, especially object-oriented programming languages, provide a variety of abstraction mechanisms to separate the logical and functional components of a program. Such a separation of program parts is desirable for various reasons. On the one hand, an increased clarity over the individual program components is ensured since the source code files have only logically associated components. On the other hand, it is possible that when making changes, unnecessarily large files need not be made available to other developers. The latter can otherwise lead to unnecessary compilation of source code.

So ist es in der Programmiersprache C++ üblich, die Deklaration von Klassenmembern (z.B. Methoden oder Eigenschaften) einer Klasse in sogenannte Headerdateien auszulagern. Der Begriff Deklaration („Declaration“) wird im Folgenden verwendet, wie er im Entwurf des C++ Standards N4567 in Abschnitt 6.7 definiert ist. Die Implementierung, also die Definition, der Klassenmember liegt dann getrennt von ihrer Deklaration vor. Der Begriff Klassenmember („class member“) wird im Folgenden so verwandt, wie er im Entwurf des C++ Standards Nr. N4567 im Abschnitt 9.2 definiert ist. So it is customary in the C ++ programming language to outsource the declaration of class members (eg methods or properties) of a class into so-called header files. The term declaration ("declaration") is used in the following as it was in the draft C ++ Standards N4567 is defined in section 6.7. The implementation, ie the definition, of the class members is then separate from their declaration. The term class member is hereafter used as it was in the C ++ draft Standards No. N4567 defined in section 9.2.

Ein Design wie oben beschrieben, ist in 1 gezeigt. Dabei wird die Headerdatei 1 von einer Implementierungsdatei 4, z.B. mit einer „#include“ Prä-Prozessor Anweisung, eingebunden. Die Headerdatei 1 wird mit den Deklarationen von „private“ und „public“ Klassenmembern 2 gefüllt. Die entsprechenden Definitionen der Klassenmember 2 sind in der Implementierung 4 gespeichert. Ein Programmierer, der die Klasse verwenden will, kann in einer Benutzerklassendatei 3 die Headerdatei 1 einbinden, um auf die deklarierten Klassenmember 2 der Headerdatei 1 zuzugreifen. Zur Kompilierung benötigen Programmierer, die die in der Headerdatei 1 deklarierten Klassenmember 2 nutzen möchten, nur die Headerdatei 1, ohne eine kompilierte Version der Implementierung 4 in der eigenen Entwicklungsumgebung vorliegen zu haben. A design as described above is in 1 shown. This will be the header file 1 from an implementation file 4 , eg with a "#include" pre-processor instruction, integrated. The header file 1 comes with the declarations of "private" and "public" class members 2 filled. The corresponding definitions of the class members 2 are in the implementation 4 saved. A programmer who wants to use the class can do so in a user class file 3 the header file 1 incorporate to the declared class members 2 the header file 1 access. For compilation, programmers need the ones in the header file 1 declared class members 2 want to use only the header file 1 without a compiled version of the implementation 4 in your own development environment.

Objektorientierte Programmiersprachen wie C++ unterscheiden zwischen „private“ und „public“ Klassenmembern. Im Folgenden werden die Begriffe „private“ und „public“ Klassenmember so verstanden, wie sie im C++ Entwurf N4567 im Abschnitt 11 definiert sind. „Private“ Klassenmember können dabei nur durch die Klasse bzw. Klassenmember der Klasse verwendet werden, in der die „private“ Klassenmember definiert sind. Die „public“ Klassenmember können hingegen auch von außerhalb der Klasse verwendet werden. Object-oriented programming languages such as C ++ distinguish between "private" and "public" class members. In the following, the terms "private" and "public" class members are understood as defined in section 11 of C ++ draft N4567. Private class members can only be used by the class or class members of the class in which the private class members are defined. The public class members, on the other hand, can also be used from outside the class.

Nach Stand der Technik ist es nicht möglich „private“ und „public“ Klassenmember einer Klasse zu trennen, d.h. diese müssen alle in der gleichen Headerdatei deklariert sein. Informationen über die „private“ Klassenmember sind jedoch nur für die Programmierer notwendig, die einen Konstruktor-Aufruf oder einen Kopiervorgang ausführen müssen. Dabei muss der Compiler Informationen über die Größe der Klasse zur Verfügung haben. Alle anderen Klassen, die nur Referenzen auf Klasseninstanzen der Klasse verwenden oder „public“ Methoden der Klasse, mit Ausnahme von Konstruktoren, aufrufen, benötigen keine Informationen über die als „private“ deklarierten Klassenmember. Trotzdem sind Informationen über die „private“ Klassenmember wegen des „#include“ Mechanismus und der vorgenannten unmöglichen Trennung immer vorhanden. Klassen, die nur Referenzen auf eine und/oder auf eine Vielzahl an Klasseninstanzen der Klasse verwenden oder „public“ Methoden der Klasse, mit Ausnahme von Konstruktoren, aufrufen, werden im Folgenden als „Benutzerklasse“ bezeichnet. According to the prior art, it is not possible to separate "private" and "public" class members of a class, i. they must all be declared in the same header file. However, information about the "private" class members is only necessary for programmers who need to perform a constructor call or copy operation. The compiler needs to have information about the size of the class. All other classes that use only references to class instances of the class or that call "public" methods of the class, with the exception of constructors, do not need information about the class members declared as "private". Nevertheless, information about the "private" class members is always present because of the "#include" mechanism and the aforementioned impossible separation. Classes that use only references to one and / or a plurality of class instances of the class, or that call public methods of the class, with the exception of constructors, are hereafter referred to as "user class."

Der beschriebene Mechanismus hat den großen Nachteil, dass bei Änderungen an nicht verwendeten Klassenmembern alle Benutzerklassen trotzdem neu übersetzt werden müssen. Dieses Problem kann die Übersetzungszeit deutlich verlängern. Der Effekt tritt insbesondere auf, wenn die Deklaration der Klassenmember noch zusätzlich die Verarbeitung von weiteren „#include“ Anweisungen und somit Informationen aus anderen Headerdateien benötigt. Insgesammt führen die beschriebenen Effekte zu einem verlängerten Entwicklungszyklus und erhöhten Entwicklungskosten, zum Beispiel, weil Testläufe nicht in einer wünschenswerten Frequenz durchgeführt werden können. The mechanism described has the great disadvantage that when changing to unused class members all user classes still need to be recompiled. This problem can significantly increase the translation time. In particular, the effect occurs when the declaration of the class members additionally requires the processing of further "#include" statements and thus information from other header files. Taken together, the described effects lead to a prolonged development cycle and increased development costs, for example because test runs can not be performed at a desirable frequency.

Im Stand der Technik werden diese Probleme nur teilweise gelöst. Einen möglichen Ansatz zur Trennung der Deklaration von der Implementierung von Klassenmembern stellt das Entwurfsmuster „Handle/Body“ 14 (auch bekannt als „Pointer to Implementation“-Idiom) bereit, wie in 2A gezeigt. Dabei stellt eine „Handle“ Klasse 16 eine öffentliche Schnittstelle einer Klasse bereit und die „Handle“ Klasse enthält einen als „private“ deklarierten Zeiger 15 auf eine Implementierungsklasse 17 (der „Body“ Klasse). Für die Deklaration des Zeigers 15 ist nur eine sogenannte Vorausdeklaration („Forward Declaration“) der Implementierungsklasse 17 nötig. In einer Benutzerklasse 18 ist es nicht notwendig die Headerdatei der Implementierungsklasse 17 einzubinden, weshalb die Benutzerklasse 18 nicht neu übersetzt werden muss, falls einige „private“ Klassenmember der Implementierungsklasse 17 geändert werden. In the prior art, these problems are only partially solved. One possible approach to separating the declaration of class member implementation is the handle / body design pattern. 14 (also known as "pointer to implementation" idiom) ready as in 2A shown. It represents a "handle" class 16 a public interface of a class, and the Handle class contains a pointer declared as private 15 to an implementation class 17 (the "body" class). For the declaration of the pointer 15 is just a so-called forward declaration of the implementation class 17 necessary. In a user class 18 it is not necessary the implementation class header file 17 which is why the user class 18 does not need to be recompiled if some "private" class members of the implementation class 17 be changed.

Mit dem beschriebenen Ansatz wird also eine komplette Abstraktion der Schnittstelle von ihrer Implementierung erreicht. Nachteilig an dem gezeigten Ansatz ist, dass jede Instanz der „Handle“-Klasse 16 den Zeiger 15 auf die Implementierungsklasse 17 enthält. Dabei treten jedoch nachteilige technische Effekte auf:

  • – zusätzlicher Speicherverbrauch, wegen des Speicherplatzes für den Zeiger 15, und
  • – zusätzliche CPU Belastung, wegen der Dereferenzierung des Zeigers 15 zur Laufzeit.
The approach described thus achieves a complete abstraction of the interface from its implementation. The disadvantage of the approach shown is that each instance of the "Handle" class 16 the pointer 15 on the implementation class 17 contains. However, disadvantageous technical effects occur:
  • - Additional memory consumption, because of the memory space for the pointer 15 , and
  • - additional CPU load, due to the dereferencing of the pointer 15 at runtime.

Einen anderen möglichen Ansatz bietet lediglich Polymorphismus 10, wie in 2B gezeigt. Dabei stellt eine abstrakte Klasse 11 eine öffentliche Schnittstelle mit Methoden bereit. Eine konkrete Implementierungsklasse 12 enthält die konkrete Implementierung der Schnittstelle und umfasst die „private“ Klassenmember. Eine Benutzerklasse 13 braucht nur die Headerdatei der abstrakten Klasse 11 einbinden. Die Benutzerklasse 13 braucht nicht wieder übersetzt zu werden, falls einige „private“ Klassenmember der Implementierungsklasse 12 geändert werden. Dieser Ansatz bietet wie der vorherige „Handle/Body“ Ansatz eine komplette Abstraktion der Schnittstelle von ihrer Implementierung. Nachteil ist, dass jede Instanz der Implementierungsklasse 12 einen zusätzlichen Zeiger auf eine virtuelle Tabelle hat, die Methoden der Klasse auf konkrete Realisierungen abbildet. Dieses führt zu den gleichen zusätzlichen Speicher und CPU Kosten, wie dies bereits im Zusammenhang mit dem „Handle/Body“ Entwurfsmuster beschrieben wurde. Another possible approach is polymorphism 10 , as in 2 B shown. It represents an abstract class 11 a public interface with methods ready. A concrete implementation class 12 Contains the concrete implementation of the interface and includes the "private" class members. A user class 13 only needs the header file of the abstract class 11 integrated. The user class 13 does not need to be translated again if some "private" class members of the implementation class 12 be changed. Like the previous handle / body approach, this approach provides a complete abstraction of the interface from its implementation. Disadvantage is that every instance of the implementation class 12 has an extra pointer to a virtual table that maps methods of the class to concrete implementations. This results in the same additional memory and CPU cost as already described in connection with the handle / body design pattern.

Diese zusätzlichen Kosten könnten insbesondere in Embedded Systemen bedeutungsvoll sein, weil ein zusätzlicher Speicherverbrauch und eine zusätzliche CPU Belastung ein teureres Steuergerät erforderlich machen können. Dieses verursacht ein teureres Endprodukt. These additional costs could be significant, especially in embedded systems, because additional memory consumption and CPU overhead may require a more expensive controller. This causes a more expensive end product.

Ausgehend von dem beschriebenen Stand der Technik stellt sich die Aufgabe, eine Vorrichtung, ein Verfahren und ein System bereitzustellen, welches die genannten Nachteile adressiert. Dabei soll insbesondere der Speicherverbrauch gesenkt werden, und die Übersetzungszeit reduziert werden. Insbesondere soll ein Verfahren bereitgestellt werden, welches die Kompilierzeit und/oder die Prä-Prozessorverarbeitung und/oder die Linkerverarbeitung verkürzt. Starting from the described prior art, the object is to provide a device, a method and a system which addresses the disadvantages mentioned. In particular, the memory consumption is to be reduced, and the translation time can be reduced. In particular, a method is to be provided which shortens the compilation time and / or the preprocessing processing and / or the linker processing.

Diese Aufgabe wird gelöst durch ein Verfahren gemäß Anspruch 1, eine Vorrichtung gemäß Anspruch 8 und ein System gemäß Anspruch 12. This object is achieved by a method according to claim 1, a device according to claim 8 and a system according to claim 12.

Insbesondere wird die Aufgabe durch ein Verfahren zur Erzeugung eines Kompilats in einer Entwicklungsumgebung gelöst, wobei die Entwicklungsumgebung eine Benutzerklasse mit zumindest einer Definition aufweist, umfassend eine Definition zumindest eines Klassenmembers der Benutzerklasse. Ferner weist die Entwicklungsumgebung eine Teilklasse auf, wobei die Teilklasse zumindest einen internen Klassenmember und zumindest einen öffentlichen Klassenmember aufweist. Darüber hinaus ist zumindest eine öffentliche Datei vorgesehen, die eine Deklaration von zumindest einem öffentlichen Klassenmember der Teilklasse enthält, wobei die öffentliche Datei keine Deklaration von dem internen Klassenmember der Teilklasse enthält. In particular, the object is achieved by a method for generating a compilation in a development environment, the development environment having a user class with at least one definition comprising a definition of at least one class member of the user class. Furthermore, the development environment has a subclass, wherein the subclass has at least one internal class member and at least one public class member. In addition, at least one public file is provided that contains a declaration from at least one public class member of the subclass, where the public file does not contain a declaration from the subclass's internal class member.

Das Verfahren weist die folgenden Schritte auf:

  • – Einbinden des öffentlichen Klassenmembers der Teilklasse und/oder einer Referenz auf eine Objektinstanz der Teilklasse in der Definition der Benutzerklasse; und
  • – Erzeugen eines Kompilats von der Benutzerklasse unter Bezugnahme der Definition der Benutzerklasse und der öffentlichen Datei.
The method comprises the following steps:
  • - Including the public class member of the subclass and / or a reference to an object instance of the subclass in the definition of the user class; and
  • Generating a compilation from the user class with reference to the definition of the user class and the public file.

Die Entwicklungsumgebung umfasst somit zwei Klassen, wobei die Benutzerklasse Methoden enthalten kann, die eine Objektinstanz der Teilklasse referenziert. Eine Klasse kann als ein Bauplan bzw. ein abstraktes Modell für eine Reihe von ähnlichen Objektinstanzen in einer objektorientierten Programmiersprache verstanden werden. Zum Beispiel kann in einer Methode der Benutzerklasse die Adresse einer Objektinstanz der Teilklasse als Parameter übergeben werden. Innerhalb der Methode kann dann auf die öffentlichen Klassenmember der Teilklasse, die in der öffentlichen Datei deklariert sind, zugegriffen werden. Die öffentliche Datei wirkt also als eine Art öffentliche Schnittstelle zwischen der Benutzerklasse und der Teilklasse. Dabei ist der Begriff öffentliche Datei nicht einschränkend gemeint. Öffentlich beschreibt, dass die Datei zum Austausch zwischen Programmierern bzw. Programmteilen gedacht ist. Eine Datei kann ein Bestand zusammengehörender Daten sein, der auf einem Speichermedium gespeichert sein kann. Öffentlich Klassenmember können demnach Klassenmember einer Klasse sein, die zusammen eine öffentliche Schnittstelle bilden. Der Name „Teilklasse“ ist nicht einschränkend zu verstehen, sondern bedeutet lediglich, dass die Teilklasse über eine öffentliche Schnittstelle, insbesondere in Form einer öffentlichen Datei, verfügt. The development environment thus includes two classes, where the user class may include methods that reference an object instance of the subclass. A class can be understood as a blueprint or an abstract model for a number of similar object instances in an object-oriented programming language. For example, in a user class method, the address of an object instance of the subclass can be passed as a parameter. Within the method, the public class members of the subclass declared in the public file can then be accessed. The public file thus acts as a kind of public interface between the user class and the subclass. The term public file is not meant to be limiting. Publicly describes that the file is intended for exchange between programmers or program parts. A file may be a collection of related data that may be stored on a storage medium. Public class members can therefore be class members of a class that together form a public interface. The name "Subclass" is not meant to be limiting, but merely means that the subclass has a public interface, particularly in the form of a public file.

Die öffentliche Datei umfasst jedoch nicht die Deklaration von internen Klassenmembern der Teilklasse. Es wird also eine Schnittstelle für die Benutzerklasse bereitgestellt, die eine wirkliche Trennung von internen und öffentlichen Klassenmembern der Teilklasse erlaubt. Es ist zu beachten, dass hier eine neue Abstraktionsebene eingeführt wird, die sich von den klassischen Klassenmember-Zugriffsmechanismen („public“, „private“, „protected“) unterscheidet. Der Begriff „intern“ ist dabei nicht als einschränkend anzusehen. „Intern“ kann zumindest alle Klassenmember umfassen, die entweder als „private“ deklariert sind und/oder bei deren Zugriff sämtliche Informationen über eine Klasse benötigt werden, wie z.B. beim Aufruf eines Klassenkonstruktors. Um die Größe des Rückgabewertes (also einer Klasseninstanz) des Klassenkonstruktors zu berechnen, ist es nämlich erforderlich, die Größe der Klasseninstanz bestimmen zu können. Interne Klassenmember können also als „public“ sowie als „private“ deklarierte Klassenmember sein. However, the public file does not include the declaration of internal class members of the subclass. Thus, an interface is provided for the user class that allows a true separation of internal and public class members of the subclass. It should be noted that here a new level of abstraction is introduced, which differs from the classic class member access mechanisms ("public", "private", "protected"). The term "internal" is not to be considered as limiting. "Internal" may include at least all class members that are either declared as "private" and / or whose access requires all the information about a class, such as: when calling a class constructor. In fact, to calculate the size of the return value (that is, a class instance) of the class constructor, it is necessary to be able to determine the size of the class instance. Internal class members can therefore be declared public as well as private class members.

Ein Kompilat kann eine Einheit von Instruktionen sein, die in einer Zielsprache codiert sind, beispielsweise Maschinencode, der durch einen Prozessor ausgeführt werden kann. Es sind aber auch weitere Zielsprachen möglich, wie z.B. Java Bytecode oder die .Net Zwischensprache CIL (Common Intermediate Language). A compilation may be a unit of instructions encoded in a target language, such as machine code, that may be executed by a processor. But there are also other target languages possible, such. Java bytecode or the .Net intermediate language CIL (Common Intermediate Language).

Insbesondere kann ein Kompilat als eine Datei auf einem Speichermedium gespeichert sein. In particular, a compilation may be stored as a file on a storage medium.

In einer weiteren Ausführungsform der Erfindung kann das Verfahren das Erzeugen eines zweiten Kompilats der Teilklasse unter Bezugnahme der öffentlichen Datei und einer Deklaration des internen Klassenmembers umfassen, wobei das erste Kompilat zumindest teilweise auf einer ersten Recheneinheit und das zweite Kompilat zumindest teilweise auf einer zweiten Recheneinheit erzeugt wird. In a further embodiment of the invention, the method may comprise generating a second compilation of the subclass with reference to the public file and a declaration of the internal class member, wherein the first compilation is generated at least partially on a first arithmetic unit and the second compilation at least partially on a second arithmetic unit becomes.

Es ist möglich, ein Kompilat der Teilklasse unter Bezugnahme der öffentlichen Datei und eines internen Klassenmembers zu erzeugen. Es werden also zum Kompilieren der Teilklasse mehr Informationen benötigt als zum Kompilieren der Benutzerklasse. Daraus folgt, dass wenn die Kompilate auf unterschiedlichen Recheneinheiten erzeugt werden, auf den Recheneinheiten unterschiedliche Dateien benötigt werden. Zum Beispiel können auf der ersten Recheneinheit nur die Benutzerklasse und die öffentliche Datei vorhanden sein, und auf der zweiten Recheneinheit die Teilklasse, die öffentliche Datei und die Deklaration des internen Klassenmembers. Kommt es im Folgenden zu Änderungen an der öffentlichen Datei auf der zweiten Recheneinheit, so muss zum Kompilieren der Benutzerklasse nur die öffentliche Datei der ersten Recheneinheit zur Verfügung gestellt werden. Die Notwendigkeit von übermäßigem Dateiaustausch zwischen den Recheneinheiten wird also reduziert. Insbesondere, wenn der interne Klassenmember geändert wird, ist gar kein Dateiaustausch notwendig. It is possible to create a compile of the subclass by referring to the public file and an internal class member. More information is needed to compile the subclass than compiling the user class. It follows that if the compilations are generated on different arithmetic units, different files are needed on the arithmetic units. For example, only the user class and the public file may be present on the first arithmetic unit and the subclass, the public file and the declaration of the internal class member on the second arithmetic unit. If changes to the public file on the second arithmetic unit occur in the following, only the public file of the first arithmetic unit must be made available for compiling the user class. The need for excessive file exchange between the arithmetic units is thus reduced. In particular, when the internal class member is changed, no file exchange is necessary.

In einer weiteren Ausführungsform kann das Verfahren ein Erzeugen eines ausführbaren Programms durch einen Linker umfassen, der dazu ausgebildet ist, das erste Kompilat und das zweite Kompilat zu verbinden. In another embodiment, the method may include generating an executable program by a linker configured to connect the first compilation and the second compilation.

Ein Linker kann dazu verwendet werden, die einzelnen Kompilate zu einem ausführbaren Programm zusammenzuführen. Dabei kann eine Namensauflösung durchgeführt werden, die unter anderem dazu führt, dass jeder Methodenaufruf und jede Variablenverwendung einer richtigen Speicheradresse zugeordnet werden. Es findet eine Umwandlung von symbolischen Speicheradressen zu richtigen Speicheradressen statt. A linker can be used to merge the individual compilations into one executable program. This can be done a name resolution, which among other things, that each method call and each variable usage are assigned to a correct memory address. There is a conversion of symbolic memory addresses to correct memory addresses.

In einer Ausführungsform kann das Verfahren ferner eine Zuordnung einer internen Datei zu der Teilklasse umfassen, wobei in der internen Datei die öffentliche Datei als Deklarationsort für öffentliche Klassenmember der Teilklasse spezifiziert ist und der Schritt der Erzeugung des zweiten Kompilats weiter ein Zuordnen des Deklarationsorts des öffentlichen Klassenmembers zu einer Implementierung der Teilklasse unter Verwendung der internen Datei umfasst. In one embodiment, the method may further comprise associating an internal file with the subclass, wherein in the internal file the public file is specified as a subclass public class member declaring location, and the step of generating the second compilation further comprises associating the public class member declaring location to an implementation of the subclass using the internal file.

Es kann also eine interne Datei der Teilklasse zugeordnet sein, wobei durch die interne Datei auf die öffentliche Datei Bezug genommen werden kann. Während der Erzeugung eines Kompilats kann also mittels der internen Datei eine Zuordnung der öffentlichen Klassenmember zu der Implementierung der öffentlichen Klassenmember hergestellt werden. Dabei kann die öffentliche Datei so ausgestaltet sein, dass in dieser keinerlei Informationen über die Implementierung bereitgestellt werden. Lediglich die interne Datei bezieht sich auf die öffentliche Datei. Es liegt also eine saubere Trennung der einzelnen Abstraktionsebenen vor. Thus, an internal file of the subclass can be assigned, whereby the internal file can refer to the public file. During the creation of a compilation, an allocation of the public class members to the implementation of the public class members can thus be established by means of the internal file. In this case, the public file can be designed in such a way that no information about the implementation is provided in it. Only the internal file refers to the public file. So there is a clean separation of the individual levels of abstraction.

In einer weiteren Ausführungsform kann die Entwicklungsumgebung eine zweite öffentliche Datei aufweisen, wobei die zweite öffentliche Datei eine Deklaration von zumindest einem zweiten öffentlichen Klassenmember der Teilklasse enthält, der sich von dem zumindest einen öffentlichen Klassenmember zumindest teilweise unterscheidet. Darüber hinaus kann die Entwicklungsumgebung eine zweite Benutzerklasse umfassen, die unter Verwendung der zweiten öffentlichen Datei eine Referenz auf eine Objektinstanz der Teilklasse verwendet. Das Verfahren kann dann weiter das Erzeugen eines dritten Kompilats von der zweiten Benutzerklasse unter Verwendung der zweiten öffentlichen Datei aufweisen. In another embodiment, the development environment may include a second public file, wherein the second public file includes a declaration of at least a second public class member of the subclass that is at least partially different from the at least one public class member. In addition, the development environment may include a second user class that uses the second public file to reference an object instance of the subclass. The method may then further include generating a third compilation from the second user class using the second public file.

Der Teilklasse können also auch mehrere öffentliche Dateien zugeordnet sein, wobei die öffentlichen Dateien unterschiedliche Deklarationen von öffentlichen Klassenmembern umfassen. Damit werden unterschiedliche öffentliche Schnittstellen der Teilklasse zur Verwendung durch Benutzerklassen angeboten, die je nach Anwendungsfall ausgewählt werden können. Zum Beispiel könnte eine erste öffentliche Datei eine erste Teilmenge von öffentlichen Klassenmembern, wie z.B. Methoden, deklarieren und die zweite öffentliche Datei könnte eine zweite Teilmenge von öffentlichen Klassenmembern deklarieren. Je nachdem, welche Methoden oder andere öffentlichen Klassenmember eine Benutzerklasse benötigt, können unterschiedliche öffentliche Dateien eingebunden werden. Dies führt weiter zu einem verbesserten Programmdesign, da eine Benutzerklasse genau solche öffentliche Klassenmember einbinden kann, die sie benötigt. Die Anzahl unnötiger Kompiliervorgänge wird also weiter reduziert, da eine Benutzerklasse nur dann neu kompiliert werden muss, wenn sich die verwendete öffentliche Datei oder die Benutzerklasse ändert. The subclass may also have multiple public files associated with it, with the public files containing different declarations of public class members. This offers different public interfaces of the subclass for use by user classes, which can be selected depending on the application. For example, a first public file could include a first subset of public class members, such as a. Declare methods, and the second public file could declare a second subset of public class members. Depending on which methods or other public class members require a user class, different public files can be included. This further leads to improved program design, as a user class can include exactly those public class members it needs. The number of unnecessary compile-time operations is thus further reduced, because a user class only has to be recompiled if the public file or user class used changes.

In einer weiteren Ausführungsform kann die interne Datei einen Bezeichner aufweisen, wobei der Bezeichner dazu verwendet werden kann, um die Deklaration des zumindest einen öffentlichen Klassenmembers der Teilklasse zuzuordnen. In another embodiment, the internal file may include an identifier, where the identifier may be used to associate the declaration of the at least one public class member with the subclass.

Es ist somit möglich, dass die interne Datei festlegt, welche Deklarationen der öffentlichen Klassenmember der Teilklasse zugeordnet werden sollen. Es können also nicht ohne weiteres zusätzliche öffentliche Dateien definiert werden, ohne die interne Datei zu verändern. Dies hat den Vorteil, dass externe Programmierer nicht ohne Zustimmung des Programmierers der internen Datei neue öffentliche Schnittstellen zur Verfügung stellen können. Dies ist vorteilhaft, da somit die Stabilität der Teilklasse durch den Programmierer der internen Datei sichergestellt werden kann. It is thus possible for the internal file to specify which declarations to associate with the public class members of the subclass. Thus, additional public files can not easily be defined without changing the internal file. This has the advantage that external programmers can not provide new public interfaces to the internal file without the consent of the programmer. This is advantageous, since thus the stability of the subclass can be ensured by the programmer of the internal file.

Die Aufgabe wird ferner durch ein computerlesbares Speichermedium gelöst, das Instruktionen aufweist, die zumindest einen Prozessor dazu veranlassen, das beschriebene Verfahren zu implementieren, wenn die Instruktion durch den bzw. die Prozessor/en ausgeführt werden. The object is further achieved by a computer-readable storage medium having instructions that cause at least one processor to implement the described method when the instruction is executed by the processor (s).

Des Weiteren wird die Aufgabe gelöst durch eine Vorrichtung zur Erzeugung eines Kompilats, Folgendes aufweisend:

  • – eine Benutzerklasse;
  • – eine Teilklasse, wobei die Teilklasse zumindest einen internen Klassenmember und zumindest einen öffentlichen Klassenmember aufweist; und
  • – eine öffentliche Datei, die eine Deklaration von zumindest einem öffentlichen Klassenmember der Teilklasse enthält, wobei die öffentliche Datei nicht eine Deklaration von dem internen Klassenmember der Teilklasse enthält;
  • – einen Compiler, der dazu ausgebildet ist, unter Verwendung der öffentlichen Datei ein Kompilat der Benutzerklasse zu erzeugen, und wobei die Benutzerklasse auf eine Referenz auf eine Objektinstanz der Teilklasse Bezug nimmt.
Furthermore, the object is achieved by a device for generating a compilation, comprising:
  • A user class;
  • A subclass, the subclass having at least one internal class member and at least one public class member; and
  • A public file containing a declaration of at least one public class member of the subclass, the public file not containing a declaration from the subclass's internal class member;
  • A compiler adapted to generate a user class compilation using the public file, and wherein the user class references a reference to an object instance of the subclass.

In einer Ausführungsform kann der Compiler dazu ausgebildet sein, unter Verwendung der öffentlichen Datei und einer Deklaration des zumindest einen internen Klassenmembers, ein zweites Kompilat der Teilklasse zu erzeugen. In one embodiment, the compiler may be configured to generate a second compilation of the subclass using the public file and a declaration of the at least one internal class member.

In einer weiteren Ausführungsform kann die Vorrichtung ferner eine interne Datei aufweisen, die der Teilklasse zugeordnet ist, wobei in der internen Datei die öffentliche Datei als ein Deklarationsort für öffentliche Klassenmember der Teilklasse spezifiziert ist. Dabei kann bzw. können der Compiler und/oder Linker weiter dazu ausgebildet sein, den Deklarationsort der öffentlichen Klassenmember einer Implementierung der Teilklasse zuzuordnen. In another embodiment, the device may further comprise an internal file associated with the subclass, wherein in the internal file the public file is specified as a subclass public class member declaration location. In this case, the compiler and / or linker can also be designed to assign the declaration location of the public class members to an implementation of the subclass.

Es ergeben sich ähnliche oder identische Vorteile, wie dies bereits in Verbindung mit dem Verfahren beschrieben wurde. There are similar or identical advantages as already described in connection with the method.

In einer weiteren Ausführungsform kann der Compiler als ein C++ Compiler ausgebildet sein. Insbesondere kann ein Compiler ein Programm sein, das Quellcode von einer Ausgangssprache, vorzugsweise C++ Instruktionen, in eine Zielsprache, vorzugsweise Maschinencode, übersetzt. In another embodiment, the compiler may be implemented as a C ++ compiler. In particular, a compiler may be a program that translates source code from a source language, preferably C ++ instructions, into a target language, preferably machine code.

Insbesondere bei der Programmiersprache C++ treten die beschriebenen Effekte hervor. C++ bietet keine echte Trennung von der Schnittstelle und Implementierung einer Klasse, da dort (in der Datei), wo die öffentlichen Klassenmember einer Klasse deklariert werden, auch die internen Klassenmember einer Klasse deklariert werden müssen. Dies ist auch der Fall, wenn die internen Klassenmember einer Klasse nicht von einer Benutzerklasse benötigt werden. Especially with the programming language C ++, the described effects emerge. C ++ does not really separate from the interface and implementation of a class, because there (in the file), where the public class members of a class are declared, the internal class members of a class must also be declared. This is also the case if the internal class members of a class are not required by a user class.

In einer weiteren Ausführungsform kann der Compiler einen Prä-Prozessor umfassen. In another embodiment, the compiler may include a pre-processor.

Wenn der Compiler auch einen Prä-Prozessor umfasst, ist es möglich, sämtliche Schritte zur Erzeugung eines Programms mit der beschriebenen Vorrichtung durchzuführen. Durch eine Trennung der Deklaration in öffentliche und interne Klassenmember wird der Prä-Prozessor ferner effizient arbeiten, da die Größe der zu verarbeitenden Dateien reduziert wird. Insbesondere bei großen Programmen führt dies zu einem erheblichen Produktivitätsgewinn. If the compiler also includes a pre-processor, it is possible to perform all the steps of creating a program with the described device. By separating the declaration into public and internal class members, the pre-processor will also work efficiently, reducing the size of the files being processed. Especially for large programs, this leads to a significant productivity gain.

Die Aufgabe wird ferner durch ein System gelöst, welches umfasst:

  • – einen Erstellungsprozessrechner, Folgendes aufweisend: – ein erstes ausführbares Programm, wobei das erste ausführbare Programm durch ein erstes Kompilieren einer Benutzerklasse und einer Teilklasse in einer ersten Version unter Verwendung einer öffentlichen Datei und einer internen Datei erzeugt ist, wobei – die Teilklasse in der ersten Version zumindest einen internen Klassenmember und zumindest einen öffentlichen Klassenmember aufweist; – die Benutzerklasse zumindest eine Referenz auf eine Objektinstanz der Teilklasse in der ersten Version aufweist; – die öffentliche Datei zumindest eine Deklaration von zumindest einem öffentlichen Klassenmember der Teilklasse in der ersten Version enthält, wobei die öffentliche Datei keine Deklaration von dem internen Klassenmember der Teilklasse in der ersten Version enthält; – die interne Datei zumindest eine Deklaration von zumindest einem internen Klassenmember der Teilklasse in der ersten Version enthält; – ein Empfangsmodul, das dazu ausgebildet ist, Quellcode von einer ersten Entwicklungsumgebung zu empfangen;
  • – die erste Entwicklungsumgebung, Quellcode aufweisend, wobei – der Quellcode die Teilklasse in einer zweiten Version definiert; und – die Teilklasse in der zweiten Version zumindest einen internen Klassenmember aufweist, der von dem internen Klassenmember der Teilklasse in der ersten Version verschieden ist; wobei der Erstellungsprozessrechner dazu ausgebildet ist:
  • – von der ersten Entwicklungsumgebung den Quellcode zum Empfangen; und
  • – ein zweites ausführbares Programm durch ein zweites Kompilieren des Quellcodes erzeugt ist, nicht durch ein zweites Kompilieren der Benutzerklasse.
The object is further achieved by a system comprising:
  • A creation process computer, comprising: a first executable program, the first executable program being created by first compiling a user class and a subclass in a first version using a public file and an internal file, wherein: the subclass in the first Version has at least one internal class member and at least one public class member; The user class has at least one reference to an object instance of the subclass in the first version; The public file contains at least a declaration of at least one public class member of the subclass in the first version, the public file containing no declaration of the sub class's internal class member in the first version; The internal file contains at least a declaration of at least one internal class member of the subclass in the first version; A receiving module adapted to receive source code from a first development environment;
  • The first development environment, having source code, wherein: the source code defines the subclass in a second version; and - the subclass in the second version has at least one internal class member different from the internal class member of the subclass in the first version; wherein the creation process computer is configured to:
  • From the first development environment the source code for receiving; and
  • - A second executable program is created by a second compilation of the source code, not by a second compilation of the user class.

Das beschriebene System umfasst also einen Erstellungsprozessrechner („build-server“), der ein erstes ausführbares Programm aufweist, welches durch ein erstes Kompilieren auf dem Erstellungsprozessrechner erzeugt ist. Dabei umfasst das erste Kompilieren das Kompilieren einer Benutzerklasse und einer Teilklasse in einer ersten Version. Die Benutzerklasse weist zumindest eine Referenz auf eine Objektinstanz der Teilklasse auf. Die Benutzerklasse kann also die Teilklasse in der ersten Version verwenden. Dieses kann unter Verwendung einer öffentlichen Datei geschehen, die zumindest eine Deklaration von zumindest einem öffentlichen Klassenmember der Teilklasse in der ersten Version enthält. Die öffentliche Datei kann also wieder als öffentliche Schnittstelle der Teilklasse angesehen werden. Thus, the system described comprises a build process server having a first executable program created by a first compilation on the build process computer. The first compilation involves compiling a user class and a subclass in a first version. The user class has at least one reference to an object instance of the subclass. The user class can therefore use the subclass in the first version. This can be done using a public file containing at least a declaration from at least one public class member of the subclass in the first version. The public file can be viewed as a public interface of the subclass again.

Ferner ist das erste ausführbare Programm unter Verwendung einer internen Datei kompiliert. Die interne Datei umfasst dabei zumindest eine Deklaration von zumindest einem internen Klassenmember der Teilklasse in der ersten Version. Die interne Datei kann also all jene Klassenmember definieren, die nicht zur öffentlichen Schnittstelle der Teilklasse gehören. Furthermore, the first executable program is compiled using an internal file. The internal file comprises at least a declaration of at least one internal class member of the subclass in the first version. The internal file can therefore define all those class members that do not belong to the public interface of the subclass.

Kommt es in einer Entwicklungsumgebung zu Änderungen an einem internen Klassenmember der Teilklasse, so stellt das erste Ausführbare Programm nicht mehr eine aktuelle Version des Entwicklungsstandes dar. Ein Programmierer kann daher den Quellcode, der die Teilklasse in einer zweiten Version definiert an den Erstellungsprozessrechner senden. Der Erstellungsprozessrechner kann dann ein zweites, aktuelles ausführbares Programm erzeugen. In a development environment, when changes are made to an internal class member of the subclass, the first executable program is no longer an up-to-date version of the development state. A programmer may therefore designate the source code that defines the subclass in a second version send to the creation process computer. The build process computer may then generate a second, current executable program.

Wenn die Änderungen sich jedoch auf die internen Klassenmember der Teilklasse beschränken, so ist es nur notwendig den Quellcode, der die Teilklasse in der zweiten Version definiert, erneut zu kompilieren. Ein erneutes Kompilieren der Benutzerklasse entfällt. Insgesamt werden also der Prozessor und weitere Hardware Ressourcen des Erstellungsprozessrechners geschont. However, if the changes are limited to the subclass's internal class members, then it is only necessary to recompile the source code that defines the subclass in the second version. Recompiling the user class is no longer necessary. Overall, therefore, the processor and other hardware resources of the creation process computer are spared.

In einer weiteren Ausführungsform kann der Erstellungsprozessrechner dazu ausgebildet sein, Objektinstanzen der in den ausführbaren Programmen definierten Klassen zu instanziieren. In another embodiment, the creation process computer may be configured to instantiate object instances of the classes defined in the executable programs.

Der Erstellungsprozessrechner kann als eine Art Laufzeitumgebung ausgebildet sein, sodass der Erstellungsprozessrechner Objektinstanzen von Klassen zur Laufzeit erzeugt. Eine Laufzeitumgebung kann sämtliche, zur Ausführung von Programmen benötigte Softwarekomponenten umfassen. Somit wird die Funktionalität der einzelnen Klassen an einer Stelle zur Verfügung gestellt bzw. ausgeführt. The creation process computer may be designed as a kind of runtime environment, such that the build process computer generates object instances of classes at runtime. A runtime environment may include all the software components needed to execute programs. Thus, the functionality of the individual classes is made available or executed in one place.

In einer weiteren Ausführungsform kann die Entwicklungsumgebung auf einer ersten Recheneinheit ausgeführt werden und Entwicklungsprozessrechner kann auf einer zweiten Recheneinheit ausgeführt werden. Die erste Recheneinheit kann dazu ausgebildet sein, Quellcode über einen Kommunikationskanal an das Empfangsmodul des Erstellungsprozessrechners, zu senden. In a further embodiment, the development environment may be executed on a first computing unit, and development process computers may be executed on a second computing unit. The first arithmetic unit may be configured to send source code via a communication channel to the receiving module of the creation process computer.

Die oben beschriebenen technischen Effekte treten insbesondere hervor, wenn der Quellcode über einen Kommunikationskanal an den Erstellungsprozessrechner gesendet werden muss. Gerade bei umfangreichem Quellcode, wie es in der Praxis häufig vorkommt, kann dies zu erheblichen Netzauslastungen führen. Der Kommunikationskanal kann selbstverständlich jeglicher Art sein, wie z.B. eine Internetverbindung, eine WLAN-Verbindung oder auch eine Bluetooth-Verbindung. Auch eine BUS Verbindung ist möglich, wie sie z.B. im Automobilbereich eingesetzt werden. The above-described technical effects emerge in particular when the source code has to be sent to the creation process computer via a communication channel. Especially with extensive source code, as often occurs in practice, this can lead to significant network utilization. Of course, the communication channel can be of any kind, e.g. an internet connection, a wi-fi connection or even a bluetooth connection. Also a BUS connection is possible, as e.g. be used in the automotive sector.

Ferner kann eine dritte Recheneinheit mit einer zweiten Entwicklungsumgebung vorgesehen sein, die die öffentliche Datei enhält. Ferner kann eine Netzwerkverbindung zwischen der zweiten und dritten Recheneinheit mit der ersten und zweiten Entwicklungsumgebung bestehen, wobei die Entwicklungsumgebungen dazu ausgebildet sein können, öffentliche Dateien zwischen den Entwicklungsumgebungen hin und her zu senden bzw. zu empfangen. Furthermore, a third processor may be provided with a second development environment containing the public file. Further, a network connection between the second and third arithmetic unit may exist with the first and second development environments, wherein the development environments may be configured to send and receive public files between the development environments.

In einer weiteren Ausführungsform kann der Erstellungsprozessrechner weiter dazu ausgebildet sein, Test, insbesondere Integrationstests und/oder Unit-Tests und/oder Regressionstests an den ausführbaren Programmen durchzuführen. In another embodiment, the creation process computer may be further configured to perform tests, in particular integration tests and / or unit tests and / or regression tests on the executable programs.

Typischerweise werden in dem Entwicklungsprozess eines Softwareproduktes kontinuierlich Integrationstests mit den verschiedenen Komponenten bzw. Klassen durchgeführt. Dabei wird getestet, ob die verschiedenen Komponenten auch zusammen ihre spezifizierten Aufgaben zuverlässig ausführen. In vielen Anwendungsfällen müssen diese Integrationstests regelmäßig durchgeführt werden, insbesondere dann, wenn sich die Klassen verändern. Wie bereits weiter oben beschrieben, ist es bei der vorliegenden Erfindung nicht notwendig, bei einer Änderung der internen Klassenmember der Teilklasse, die Benutzerklasse neu zu kompilieren, so dass die Anzahl der notwendigen Integrationstests reduziert wird. Auch hiermit wird wieder die Prozessorauslastung des Erstellungsprozessrechners reduziert. Typically, in the development process of a software product, integration tests are continuously performed on the various components or classes. It is tested whether the various components together perform their specified tasks reliably. In many applications, these integration tests must be performed regularly, especially as the classes change. As described above, in the present invention, when the class member's internal class members change, it is not necessary to recompile the user class, so that the number of necessary integration tests is reduced. Again, this reduces the processor utilization of the build process computer.

Nachfolgend wird die Erfindung mittels mehrerer Ausführungsbeispiele beschrieben, die anhand von Abbildungen näher erläutert werden. Hierbei zeigen: The invention will be described by means of several embodiments, which are explained in more detail with reference to figures. Hereby show:

1 eine schematische Darstellung von Sourcecode-Dateien nach dem Stand der Technik; 1 a schematic representation of source code files according to the prior art;

2A eine schematische Darstellung des Handle/Body Entwurfsmusters nach dem Stand der Technik; 2A a schematic representation of the handle / body design pattern according to the prior art;

2B eine schematische Darstellung eines polymorphen Typs nach dem Stand der Technik; 2 B a schematic representation of a polymorphic type according to the prior art;

3 den grundsätzlichen Ablauf der Programmerzeugung 30 in C++; 3 the basic course of program generation 30 in C ++;

4 eine schematische Darstellung eines partiellen Klassendesigns 40; 4 a schematic representation of a partial class design 40 ;

5 eine schematische Darstellung eines partiellen Klassendesigns mit einer Vielzahl an öffentlichen Schnittstellen 50; 5 a schematic representation of a partial class design with a variety of public interfaces 50 ;

6 eine schematische Darstellung einer Entwicklungsumgebung 60; 6 a schematic representation of a development environment 60 ;

7 eine schematische Darstellung einer Testumgebung 70; 7 a schematic representation of a test environment 70 ;

8 eine schematische Darstellung eines Verfahrens zur Erzeugung eines Programms. 8th a schematic representation of a method for generating a program.

1 zeigt die Dateistruktur eines typischen C++ Programms nach dem Stand der Technik. Dabei werden die Klassenmember 2 einer Klasse in einer Headerdatei 1 deklariert. Die Headerdatei 1 wird typischerweise über eine „#include“-Prä-Prozessor-Anweisung in eine Implementierungsdatei 4 inkludiert, wo die Klassenmember 2 der Klasse definiert werden. Die Implementierung 4 enthält somit die Methodendefinitionen, wie z.B. den Konstruktor einer Klasse oder andere „private“ und „public“ Methoden der Klasse. Eine Benutzerklassendatei 3, die die in der Implementierungsdatei 4 definierten „public“-Methoden verwenden möchte, muss auch über eine „#include“-Prä-Prozessor-Anweisung die Headerdatei 1 inkludieren. Dies ist notwendig, um die Datentypen, also den benötigten Speicher, der in der Implementierungsdatei 4 verwendeten Klassenmember 2 in der Benutzerklassendatei 3 bekannt zu machen. 1 shows the file structure of a typical C ++ program according to the prior art. Thereby the class members become 2 a class in a header file 1 declared. The header file 1 is typically passed through an #include preprocessor statement into an implementation file 4 included where the class members 2 to be defined in the class. The implementation 4 thus contains the method definitions, such as the constructor of a class or other "private" and "public" methods of the class. A user class file 3 that are in the implementation file 4 To use defined "public" methods, you must also use a "#include" preprocessor statement to specify the header file 1 include. This is necessary to get the data types, ie the needed memory, in the implementation file 4 used class members 2 in the user class file 3 to make known.

Exemplarisch ist dies im Folgenden C++ Code illustriert:

Figure DE102016202484A1_0002
Figure DE102016202484A1_0003
As an example, this is illustrated in the following C ++ code:
Figure DE102016202484A1_0002
Figure DE102016202484A1_0003

Der vorstehende Code zeigt exemplarisch die Verwendung einer „Stack“-Implementierung. Der „Stack“ umfasst „private“ und „public“ Klassenmember, die in der Datei „Stack.h“ deklariert sind. Eine Benutzerklasse „UserClass“ kann auf die „public“ Klassenmember des „Stacks“ zugreifen, indem die Header Datei 1 („Stack.h“) durch die Benutzerklassendatei 3 („User.cpp“) eingebunden wird. The above code exemplifies the use of a "stack" implementation. The "stack" includes "private" and "public" class members declared in the Stack.h file. A user class "UserClass" can access the "public" class members of the "stacks" by adding the header file 1 ("Stack.h") through the user class file 3 ("User.cpp") is included.

Nachteilig ist, dass die Headerdatei 1 („Stack.h“) sämtliche Deklarationen der Klassenmember 2 der Implementierungsklasse 4 deklariert. Wenn z.B. in der Benutzerklassendatei 3 („User.cpp“) kein Konstruktor-Aufruf durchgeführt wird, so ist es nach dem Stand der Technik nicht möglich, die Deklaration des Klassen-Konstruktors aus dem Deklarationsteil der Headerdatei 1 zu entfernen. Es werden also unnötige Informationen in die Benutzerklassendatei 3 eingefügt. The disadvantage is that the header file 1 ("Stack.h") all declarations of class members 2 the implementation class 4 declared. For example, in the user class file 3 ("User.cpp") no constructor call is made, so it is not possible in the prior art, the declaration of the class constructor from the declaration part of the header file 1 to remove. So there will be unnecessary information in the user class file 3 inserted.

Um eine Trennung von Implementierung und Schnittstelle einer Klasse zu erzielen, könnten das sogenannte Handle/Body Entwurfsmuster 14 (2A) oder der reine Polymorphismus 10 (2B) verwendet werden, die weiter oben schon beschrieben sind. Wie bereits erklärt, haben beide Ansätze den Nachteil, dass jede Instanz der „Handle“-Klasse 16 bei dem Handle/Body Entwurfsmuster 14 einen Zeiger 15 auf die Implementierungsklasse 17 benötigt. Ferner benötigt jede Instanz der Implementierungsklasse 12 beim Polymorphismus 10 einen Zeiger auf die virtuelle Tabelle. To achieve a separation of implementation and interface of a class, the so-called handle / body design pattern 14 ( 2A ) or the pure polymorphism 10 ( 2 B ), which are already described above. As explained earlier, both approaches have the disadvantage that every instance of the "handle" class 16 at the handle / body design pattern 14 a pointer 15 on the implementation class 17 needed. Furthermore, each instance requires the implementation class 12 at polymorphism 10 a pointer to the virtual table.

Beide Ansätze führen zu unnötigem zusätzlichen Speicherbedarf oder zusätzlicher CPU Belastung. Both approaches lead to unnecessary additional memory or additional CPU load.

3 zeigt den grundsätzlichen Ablauf der Erzeugung eines Programms 36 in C++. In einem ersten Schritt werden sämtliche Quelldateien durch einen Prä-Prozessor 31 verarbeitet. Insbesondere werden dabei in rekursiver Art und Weise „#include“-Anweisungen ausgeführt. Eine „#include“-Anweisung veranlasst den Prä-Prozessor 31 dazu, die in den jeweiligen „#include“-Anweisungen angegebenen Dateien textuell in die Datei einzufügen, in der die „#include“-Anweisung definiert ist. Es wird also der Inhalt der angegebenen Datei mit dem „#include“-Aufruf ersetzt. Der Prä-Prozessor erzeugt Kompilationseinheiten 32, die als Eingabe in den Compiler 33 dienen. 3 shows the basic process of creating a program 36 in C ++. In a first step, all source files are processed by a pre-processor 31 processed. In particular, "#include" statements are executed in a recursive manner. An #include statement causes the pre-processor 31 to insert textually the files specified in the respective "#include" statements into the file in which the "#include" statement is defined. It will replace the contents of the specified file with the "#include" call. The pre-processor generates compilation units 32 as input to the compiler 33 serve.

Die Kompilationseinheiten 32 können jeweils getrennt durch den Compiler 33 kompiliert werden. Die Kompilationseinheiten 32 können also auch parallel kompiliert werden, z.B. auf mehreren Prozessoren oder auch auf verschiedenen PCs. Der Compiler 33 erzeugt aus jeder Kompilationseinheit 32 ein Kompilat 34, welches Objektcode ist. Das Kompilat 34 besteht hauptsächlich aus Maschinencode, der durch einen Prozessor ausgeführt werden kann. In den allermeisten Fällen ist es jedoch notwendig, mehrere Programmkomponenten, die durch mehrere Kompilate 34 repräsentiert werden, zu einem gemeinsamen Programm 36 zusammenzuführen. The compilation units 32 can each be separated by the compiler 33 be compiled. The compilation units 32 They can also be compiled in parallel, eg on several processors or on different PCs. The compiler 33 generated from each compilation unit 32 a compilation 34 which object code is. The compilation 34 consists mainly of machine code that can be executed by a processor. In most cases, however, it is necessary to run multiple program components through multiple compilations 34 be represented, to a common program 36 merge.

Ein Linker 35 verbindet die verschiedenen Kompilate 34 zu einem ausführbaren Programm 36. Das ausführbare Programm 36 kann dabei z.B. aus einer einzigen Datei bestehen. Es ist jedoch auch möglich, dass das Linken während der Ausführung eines Programms 36 ausgeführt wird, sogenanntes dynamisches Linken. A linker 35 connects the different compilations 34 to an executable program 36 , The executable program 36 can consist of eg a single file. However, it is also possible that the left while running a program 36 is executed, so-called dynamic left.

4 zeigt eine schematische Darstellung eines partiellen Klassendesigns 40 in einem ersten Ausführungsbeispiel. Dabei dient eine öffentliche Datei 41 als öffentliche Schnittstelle für eine Klasse. Interne Klassenmember 44 sind in einer internen Datei 43 deklariert. Eine Implementierungsdatei 45 fügt über eine Include-Anweisung die Deklarationen der internen Klassenmember 44 in die Implementierungsdatei 45 ein. Ebenso bindet die interne Datei 43 die öffentliche Datei 41 ein. Somit sind keine Informationen über die interne Datei 43 in der öffentlichen Datei 41 gespeichert. Darüber hinaus sind keine Informationen über die Implementierungsdatei 45 in der internen Datei 43 gespeichert. Es liegt also eine saubere Trennung der unterschiedlichen Abstraktionsebenen vor. 4 shows a schematic representation of a partial class design 40 in a first embodiment. This is a public file 41 as a public interface for a class. Internal class members 44 are in an internal file 43 declared. An implementation file 45 adds via an include Instruction the declarations of the internal class members 44 in the implementation file 45 one. Likewise binds the internal file 43 the public file 41 one. Thus, there is no information about the internal file 43 in the public file 41 saved. In addition, there is no information about the implementation file 45 in the internal file 43 saved. So there is a clean separation of the different levels of abstraction.

Die öffentliche 41 und die interne Datei 43 sind dabei wie Header-Dateien aus dem Stand der Technik aufgebaut. Um jedoch eine Zuordnung der einzelnen Komponenten herzustellen, bedarf es neuer Sprachelemte. Das Folgende Codebeispiel zeigt eine öffentliche Datei 41 in dem ersten Ausführungsbeispiel:

Figure DE102016202484A1_0004
The public 41 and the internal file 43 are structured like header files from the state of the art. However, to create an assignment of the individual components, it requires new Sprachelemte. The following code sample shows a public file 41 in the first embodiment:
Figure DE102016202484A1_0004

Die Datei „StackInterface.h“ definiert die öffentliche Schnittstelle der Klasse „Stack“. Wie aus dem obigen Codebeispiel deutlich wird, sind nur „public“ Methoden deklariert. Ein Programmierer, der folglich die Datei „Stackinterface.h“ über eine „#include“-Anweisung einbindet, hat keinerlei Informationen über die „private“ Klassenmember der Klasse „Stack“. The StackInterface.h file defines the public interface of the Stack class. As you can see in the code example above, only "public" methods are declared. Thus, a programmer who incorporates the Stackinterface.h file through an #include statement has no information about the stack private class members.

Die internen Klassenmember 44 der Klasse Stack werden in der internen Datei 43 deklariert, wie im Folgenden gezeigt:

Figure DE102016202484A1_0005
The internal class members 44 the class stack will be in the internal file 43 declared as shown below:
Figure DE102016202484A1_0005

Wie aus dem obigen Beispiel deutlich wird, kann die interne Datei 43 auch die Deklaration von „public“-Klassenmembern umfassen. Dies ist insbesondere notwendig, um einen Konstruktoraufruf auf solche Klassen zu beschränken, die die interne Datei 43 einbinden. Der Klassenkonstruktor kann insbesondere nicht in der öffentlichen Datei 41 deklariert sein, da ein Aufruf des Konstruktors erfordert, dass die gesamte Größe der Klasse bekannt ist, also auch interne Klassenmember 44. As can be seen from the example above, the internal file 43 also include the declaration of "public" class members. This is especially necessary to restrict a constructor call to such classes as the internal file 43 integrated. Specifically, the class constructor can not be in the public file 41 declared, since a call to the constructor requires that the entire size of the class is known, including internal class members 44 ,

Die Anweisung „partial StackInterface“ gibt an, dass es sich bei dem Folgenden Code um die interne Datei 43 mit internen Klassenmembern 44 der Klasse handelt. Die Anweisung „export Stackinterface“ in der öffentlichen Datei 41 wird über den Bezeichner „StackInterface“ der Klasse „Stack“ in der internen Datei 43 zugeordnet. The partial stackInterface statement indicates that the following code is the internal file 43 with internal class members 44 the class is acting. The statement "export stackinterface" in the public file 41 is specified by the "StackInterface" identifier of the "Stack" class in the internal file 43 assigned.

Eine Benutzerklassendatei 42, die auf öffentliche Klassenmember 46 der in der öffentlichen Datei 41 definierten Klasse zugreift, kann durch eine „#include“-Anweisung die öffentliche Datei 41 einbinden. Die Benutzerklassendatei 42 hat also nur Zugriff auf die öffentlichen Klassenmember 46, welche in der öffentlichen Datei 41 deklariert sind. A user class file 42 on public class members 46 in the public file 41 can access the public file through an "#include" statement 41 integrated. The user class file 42 So it only has access to the public class members 46 which in the public file 41 are declared.

Mit dem gezeigten partiellen Klassendesign 40 ist es also möglich, einerseits eine logische Trennung aller Programmkomponenten zu erreichen, sowie die in die Benutzerklassendatei 42 einzubindende Headerdatei 41 kleinzuhalten. With the shown partial class design 40 So it is possible, on the one hand to achieve a logical separation of all program components, as well as the in the user class file 42 Include header file 41 small injury.

Sollte der Programmierer der internen Datei 43 Änderungen an internen Klassenmembern 44 vornehmen, so ist es nicht notwendig, dass der Programmierer der Benutzerklassendatei 42 diese neu kompiliert. Should the programmer of the internal file 43 Changes to internal class members 44 so it is not necessary that the programmer of the user class file 42 recompiled these.

5 zeigt eine schematische Darstellung eines zweiten Ausführungsbeispiels der vorliegenden Erfindung. In dem Ausführungsbeispiel der 5, werden eine Vielzahl von öffentlichen Dateien 51, 51‘ bereitgestellt, die von unterschiedlichen Benutzerklassendateien 52, 52‘ verwendet werden können. Dabei gibt es trotzdem nur eine einzige interne Datei 53 mit internen Klassenmembern 54 und eine Implementierungsdatei 55. Somit ist gewährleistet, dass jede Benutzerklassendatei 52, 52‘ genau jene öffentliche Datei verwenden kann, die sie benötigt. Dies erlaubt eine große Flexibilität in der Ausgestaltung eines Programms. 5 shows a schematic representation of a second embodiment of the present invention. In the embodiment of 5 , be a variety of public files 51 . 51 ' provided by different user class files 52 . 52 ' can be used. There is still only one internal file 53 with internal class members 54 and an implementation file 55 , This ensures that every user class file 52 . 52 ' can use exactly the public file that needs it. This allows a great deal of flexibility in the design of a program.

6 zeigt eine Entwicklungsumgebung 60 mit einer Benutzerklasse 61, einer Teilklasse 62 und einem Compiler 65 in einem weiteren Ausführungsbeispiel der Erfindung. 6 shows a development environment 60 with a user class 61 , a subclass 62 and a compiler 65 in a further embodiment of the invention.

Die Teilklasse 62 umfasst interne Klassenmember 63 sowie öffentliche Klassenmember 64. Die Benutzerklasse 61 ist so ausgebildet, dass sie öffentliche Klassenmember 64 der Teilklasse 62 verwendet. Dies kann z.B. durch einen Methodenaufruf einer Methode einer Objektinstanz vom Typ der Teilklasse 62 sein. Dies ist im Folgenden Codebeispiel gezeigt.

Figure DE102016202484A1_0006
The subclass 62 includes internal class members 63 as well as public class members 64 , The user class 61 is designed to be public class members 64 the subclass 62 used. This can be done, for example, by a method call of a method of an object instance of the type of the subclass 62 be. This is shown in the following code example.
Figure DE102016202484A1_0006

Die Benutzerklasse 61 verwendet öffentliche Klassenmember 64 der Teilklasse 62. So sind die Methoden „push“ und „isFull“ in der öffentlichen Datei 41, 51, 51‘ der Teilklasse 62 deklariert. The user class 61 uses public class members 64 the subclass 62 , So the methods "push" and "isFull" are in the public file 41 . 51 . 51 ' the subclass 62 declared.

Zum Kompilieren der Benutzerklasse 61 ist es notwendig, dass die Benutzerklasse 61 sowie die Deklarationen der öffentlichen Klassenmember 66 an den Compiler 65 übergeben werden. Der Compiler 65 erzeugt aus diesen beiden Einheiten ein Kompilat der Benutzerklasse 67. Das Kompilat der Benutzerklasse 67 umfasst Maschinencode, der durch einen Prozessor ausgeführt werden kann. To compile the user class 61 it is necessary that the user class 61 as well as the declarations of public class members 66 to the compiler 65 be handed over. The compiler 65 generates from these two units a compilation of the user class 67 , The compilation of the user class 67 includes machine code that can be executed by a processor.

7 zeigt eine schematische Darstellung einer Testumgebung 70 zum Integrieren und Testen von Softwarekomponenten. Die Testumgebung 70 umfasst eine erste Recheneinheit 71, eine zweite Recheneinheit 74 und einen Erstellungsprozessrechner 77. Die erste und zweite Recheneinheit 71, 74 umfassen jeweils eine Entwicklungsumgebung 72, 75 sowie Sendemodule 73, 76. Die Recheneinheiten 71, 74 sind dazu ausgebildet, Quellcode von Programmkomponenten mittels der Sendemodule 73, 76 über Kommunikationskanäle 80, 80‘ an ein Empfangsmodul 78 des Erstellungsprozessrechners 77 zu senden. Das Empfangsmodul 78 übergibt den Quellcode an einen Integrationsserver 79, der dazu ausgebildet ist, aus dem Quellcode ein ausführbares Programm zu erzeugen und auszuführen. Insbesondere ist der Integrationsserver 79 dazu ausgebildet, eine Reihe von Tests an dem ausführbaren Programm durchzuführen. Solche Tests können umfassen: Unit-Tests, Integration-Tests, Regressions-Tests oder auch Kompatibilitäts-Tests. Dabei werden eine Reihe von Tests immer dann ausgeführt, wenn ein neues ausführbares Programm erzeugt wird. Das ist zumindest dann der Fall, wenn eine neue Version einer Klasse als Quellcode über einen der Kommunikationskanäle 80, 80‘ übertragen wird. 7 shows a schematic representation of a test environment 70 for integrating and testing software components. The test environment 70 comprises a first arithmetic unit 71 , a second arithmetic unit 74 and a creation process computer 77 , The first and second arithmetic unit 71 . 74 each include a development environment 72 . 75 as well as transmission modules 73 . 76 , The computing units 71 . 74 are designed to source code of program components by means of the transmission modules 73 . 76 via communication channels 80 . 80 ' to a receiving module 78 of the creation process computer 77 to send. The receiving module 78 Passes the source code to an integration server 79 which is designed to generate and execute an executable program from the source code. In particular, the integration server 79 designed to perform a series of tests on the executable program. Such tests may include: unit testing, Integration tests, regression tests or compatibility tests. A series of tests are always executed when a new executable program is created. This is at least the case when a new version of a class as source code over one of the communication channels 80 . 80 ' is transmitted.

Das Empfangsmodul 78 kann eine Reihe von Softwarekomponenten, wie Netzwerkkartentreiber und/oder eine Netzwerkschnittstelle umfassen. Ferner kann das Empfangsmodul 78 auch Hardware umfassen, die dazu ausgebildet ist, Daten über einen Kommunikationskanal 80, 80‘ zu empfangen und/oder zu verarbeiten. The receiving module 78 may include a number of software components, such as network card drivers and / or a network interface. Furthermore, the receiving module 78 also include hardware adapted to receive data over a communication channel 80 . 80 ' to receive and / or process.

Es ist von Vorteil, wenn die Anzahl der Kompilationsvorgänge reduziert wird. In der ersten Entwicklungsumgebung 72 wird in dem aktuellen Ausführungsbeispiel eine Benutzerklasse 61 entwickelt, die nur öffentliche Klassenmember 64 einer Teilklasse 62 verwendet. Kommt es zu Änderungen an den internen Klassenmembern 63 der Teilklasse 62, so ist es nicht notwendig die Benutzerklasse 61 erneut zu kompilieren. Somit entfällt das Kompilieren der Benutzerklasse 61, wenn sich nur die internen Klassenmember 63 der Teilklasse 62 ändern und diese Änderungen an den Erstellungsprozessrechners 77 gesendet werden. It is an advantage to reduce the number of compilation operations. In the first development environment 72 becomes a user class in the current embodiment 61 developed only public class members 64 a subclass 62 used. Is there any change to the internal class members? 63 the subclass 62 so it is not necessary the user class 61 recompile again. This eliminates the need to compile the user class 61 if only the internal class members 63 the subclass 62 Change and make these changes to the build process computer 77 be sent.

8 zeigt im Detail ein Verfahren zur Erzeugung eines Programms 98 unter Verwendung von einem partiellen Klassendesign 40, 50, wie dies in Zusammenhang mit den 4 und 5 beschrieben wurde. In einem ersten Schritt 91 wird eine öffentliche Datei 41, 51, 51‘ in eine Benutzerklasse 61 bzw. einer Benutzerklassendatei 42, 52 eingebunden, wie z.B. über eine „#include“-Prä-Prozessor-Anweisung. Die Benutzerklassendatei 42, 52 kann dann auf sämtliche öffentliche Klassenmember 46, 64 der Teilklasse 62 zugreifen. 8th shows in detail a method for generating a program 98 using a partial class design 40 . 50 as related to the 4 and 5 has been described. In a first step 91 becomes a public file 41 . 51 . 51 ' into a user class 61 or a user class file 42 . 52 embedded, such as via a "#include" preprocessor statement. The user class file 42 . 52 can then apply to all public class members 46 . 64 the subclass 62 access.

In einem zweiten Schritt 92 wird in der Benutzerklassendatei 42, 52 festgelegt, dass eine Referenz auf eine Objektinstanz der Teilklasse 62 verwendet werden soll. Selbstverständlich sind hier verschiedenste Ausgestaltungen denkbar, wie z.B. das Verwenden von öffentlichen Methoden, der Zugriff auf öffentliche Klassenmember, sowie die jegliche Weitergabe von Referenzen auf Klasseninstanzen der Teilklasse an weitere Klassen. In a second step 92 will be in the user class file 42 . 52 set a reference to an object instance of the subclass 62 should be used. Of course, here are a variety of configurations conceivable, such as the use of public methods, access to public class members, as well as any transfer of references to class instances of the subclass to other classes.

Im nächsten Schritt 93 verarbeitet ein Prä-Prozessor 31 die Benutzerklassendatei 42, 52, um die „#include“-Anweisungen aufzulösen. Dabei werden die „#include“-Anweisungen textuell durch den Inhalt der referenzierten Datei 41, 51 ersetzt. Die durch den Prä-Prozessor 93 erzeugte Kompilationseinheit 94 umfasst die Benutzerklassendatei 42, 52 sowie den kompletten Inhalt der öffentlichen Datei 41, 51. In the next step 93 processes a pre-processor 31 the user class file 42 . 52 to resolve the #include statements. In doing so, the "#include" statements are textualized by the content of the referenced file 41 . 51 replaced. The through the preprocessor 93 generated compilation unit 94 includes the user class file 42 . 52 as well as the complete contents of the public file 41 . 51 ,

Der Compiler 95 erzeugt Objektcode 96, der im Wesentlichen aus Maschinencode besteht. Dabei wird aus jeder Kompilationseinheit 94 ein zugehöriges Kompilat 96 erzeugt. Sind mehrere Kompilate 96 bzw. Objektcodeeinheiten 96 vorhanden, so können diese im nächsten Schritt 97 durch einen Linker 35 zu einem ausführbaren Programm 98 verbunden werden. Das ausführbare Programm 98 kann dann im Schritt 99 durch eine Laufzeitumgebung ausgeführt werden. The compiler 95 generates object code 96 which consists essentially of machine code. It turns into each compilation unit 94 an associated compilation 96 generated. Are several compilations 96 or object code units 96 available, so these may be in the next step 97 through a linker 35 to an executable program 98 get connected. The executable program 98 can then in the step 99 run through a runtime environment.

BezugszeichenlisteLIST OF REFERENCE NUMBERS

1 1
Headerdatei header file
2 2
„private“ und „public“ Klassenmember "Private" and "public" class members
3 3
Benutzerklassendatei User class file
4, 45, 55, 22 4, 45, 55, 22
Implementierung / Implementierungsdatei Implementation / Implementation File
10 10
Polymorphismus polymorphism
11 11
Abstrakte Klasse Abstract class
12 12
Implementierungsklasse implementation class
13 13
Benutzerklasse der Abstrakten Klasse in Polymorphismus User class of abstract class in polymorphism
14 14
Handle/Body Entwurfsmuster Handle / Body design pattern
15 15
Zeiger auf Body in Handle/Body Entwurfsmuster Pointer to body in handle / body design pattern
16 16
Handle Klasse in Handle/Body Entwurfsmuster Handle class in handle / body design pattern
17 17
Body Klasse in Handle/Body Entwurfsmuster Body class in handle / body design pattern
18 18
Benutzerklasse der Handle Klasse in Handle/Body EntwurfsmusterUser class of handle class in handle / body design pattern
30 30
Prozess zur Erzeugung eines Programms Process of creating a program
31 31
Prä-Prozessor Preprocessor
32, 94 32, 94
Kompilationseinheit compilation unit
33, 65 33, 65
Compiler compiler
34, 96 34, 96
Objektcode / Kompilat Object code / Compilation
35 35
Linker left
36, 98 36, 98
Programm program
40 40
partielles Klassendesign partial class design
41, 51, 51‘ 41, 51, 51 '
öffentliche Datei/ öffentliche Schnittstelle public file / public interface
42, 52, 52‘ 42, 52, 52 '
Benutzerklassendatei User class file
43 53 43 53
Interne Datei / interne Schnittstelle Internal file / internal interface
44, 54 44, 54
interne Klassenmember internal class members
45, 55 45, 55
Implementierungsdatei implementation file
46 46
öffentliche Klassenmember public class members
50 50
partielles Klassendesign mit einer Vielzahl an öffentlichen Schnittstellenpartial class design with a variety of public interfaces
60 60
Entwicklungsumgebung development environment
61 61
Benutzerklasse user class
62 62
Teilklasse subclass
63 63
interner Klassenmember internal class member
64 64
öffentlicher Klassenmember public class member
66 66
Deklaration der öffentlichen Klassenmember Declaration of public class members
67 67
Kompilat der Benutzerklasse Compilation of the user class
70 70
Testumgebung test environment
71 71
erste Recheneinheit first arithmetic unit
72 72
erste Entwicklungsumgebung first development environment
73 73
erstes Sendemodul first transmission module
74 74
zweite Recheneinheit second arithmetic unit
75 75
zweite Entwicklungsumgebung second development environment
76 76
zweite Sendeeinrichtung second transmitting device
77 77
Erstellungsprozessrechner Creation process computer
78 78
Empfangsmodul receiver module
79 79
Integrationsserver integration server
80, 80‘ 80, 80 '
Kommunikationskanal communication channel
91 91
Einbinden einer Datei Include a file
92 92
Übergabe einer Objektinstanz in einer Klasse Transfer of an object instance in a class
93 93
Prä-Prozessor-Ausführung Pre-processor execution
95 95
Kompilieren Compile
97 97
Linken left
99 99
Ausführung execution

ZITATE ENTHALTEN IN DER BESCHREIBUNG QUOTES INCLUDE IN THE DESCRIPTION

Diese Liste der vom Anmelder aufgeführten Dokumente wurde automatisiert erzeugt und ist ausschließlich zur besseren Information des Lesers aufgenommen. Die Liste ist nicht Bestandteil der deutschen Patent- bzw. Gebrauchsmusteranmeldung. Das DPMA übernimmt keinerlei Haftung für etwaige Fehler oder Auslassungen.This list of the documents listed by the applicant has been generated automatically and is included solely for the better information of the reader. The list is not part of the German patent or utility model application. The DPMA assumes no liability for any errors or omissions.

Zitierte Nicht-PatentliteraturCited non-patent literature

  • Standards N4567 [0003] Standards N4567 [0003]
  • Standards Nr. N4567 [0003] Standards No. N4567 [0003]

Claims (15)

Verfahren zur Erzeugung eines Kompilats (30) in einer Entwicklungsumgebung (60) mit: – einer Benutzerklasse (61) mit zumindest einer Definition umfassend eine Definition zumindest eines Klassenmembers der Benutzerklasse (61); – einer Teilklasse (62), wobei die Teilklasse (62) zumindest einen internen Klassenmember (44, 54, 63) und zumindest einen öffentlichen Klassenmember (64) aufweist; und – zumindest einer öffentlichen Datei (41, 51, 51‘), die eine Deklaration von zumindest einem öffentlichen Klassenmember (66) der Teilklasse (62) enthält, wobei die öffentliche Datei (41, 51, 51‘) keine Deklaration von dem internen Klassenmember (44, 54, 63) der Teilklasse (61) enthält, gekennzeichnet durch: – Einbinden des öffentlichen Klassenmembers (66) der Teilklasse (62) und/oder einer Referenz auf eine Objektinstanz der Teilklasse (62) in der Definition der Benutzerklasse (61); – Erzeugen eines Kompilats (67) von der Benutzerklasse (61) unter Bezugnahme der Definition der Benutzerklasse (61) und der öffentlichen Datei (41, 51, 51‘). Method for generating a compilation ( 30 ) in a development environment ( 60 ) with: - a user class ( 61 ) with at least one definition comprising a definition of at least one class member of the user class ( 61 ); - a subclass ( 62 ), where the subclass ( 62 ) at least one internal class member ( 44 . 54 . 63 ) and at least one public class member ( 64 ) having; and - at least one public file ( 41 . 51 . 51 ' ), which is a declaration of at least one public class member ( 66 ) of the subclass ( 62 ), where the public file ( 41 . 51 . 51 ' ) no declaration from the internal class member ( 44 . 54 . 63 ) of the subclass ( 61 ), characterized by: - incorporating the public class member ( 66 ) of the subclass ( 62 ) and / or a reference to an object instance of the subclass ( 62 ) in the definition of the user class ( 61 ); - Create a compilation ( 67 ) of the user class ( 61 ) referring to the definition of the user class ( 61 ) and the public file ( 41 . 51 . 51 ' ). Verfahren nach Anspruch 1, gekennzeichnet durch: – Erzeugen eines zweiten Kompilats (67) der Teilklasse (62) unter Bezugnahme der öffentlichen Datei (41, 51, 51‘) und einer Deklaration des internen Klassenmembers (44, 54, 63), wobei das erste Kompilat (67) zumindest teilweise auf einer ersten Rechneinheit (71) und das zweite Kompilat zumindest teilweise auf einer zweiten Recheneinheit (74) erzeugt werden. Method according to claim 1, characterized by: generating a second compilation ( 67 ) of the subclass ( 62 ) referring to the public file ( 41 . 51 . 51 ' ) and a declaration of the internal class member ( 44 . 54 . 63 ), where the first compilation ( 67 ) at least partially on a first computing unit ( 71 ) and the second compilation at least partially on a second arithmetic unit ( 74 ) be generated. Verfahren nach einem der vorhergehenden Ansprüche, insbesondere nach Anspruch 2, gekennzeichnet durch: – Erzeugen eines ausführbaren Programms (98) durch einen Linker (35), der dazu ausgebildet ist, das erste Kompilat (67) und das zweite Kompilat (67) zu verbinden. Method according to one of the preceding claims, in particular according to claim 2, characterized by: - generating an executable program ( 98 ) by a linker ( 35 ), which is adapted to the first compilation ( 67 ) and the second compilation ( 67 ) connect to. Verfahren nach einem der vorhergehenden Ansprüche, insbesondere nach Anspruch 2, gekennzeichnet durch eine Zuordnung einer internen Datei (43) zu der Teilklasse (62), und wobei in der internen Datei (43, 53) die öffentliche Datei (41, 51, 51‘) als Deklarationsort für öffentliche Klassenmember (64) der Teilklasse (62) spezifiziert ist und der Schritt der Erzeugung des zweiten Kompilats weiter umfassend: – Zuordnen des Deklarationsorts des öffentlichen Klassenmembers (64) zu einer Implementierung (45, 55) der Teilklasse (62) unter Verwendung der internen Datei (43). Method according to one of the preceding claims, in particular according to claim 2, characterized by an assignment of an internal file ( 43 ) to the subclass ( 62 ), and where in the internal file ( 43 . 53 ) the public file ( 41 . 51 . 51 ' ) as the declaration location for public class members ( 64 ) of the subclass ( 62 ) and the step of generating the second compilation further comprises: assigning the declaration location of the public class member ( 64 ) to an implementation ( 45 . 55 ) of the subclass ( 62 ) using the internal file ( 43 ). Verfahren nach einem der vorhergehenden Ansprüche, gekennzeichnet durch, die Entwicklungsumgebung (60), die ferner aufweist: – eine zweite öffentliche Datei (51‘), wobei die zweite öffentliche Datei (51‘) eine Deklaration von zumindest einem zweiten öffentlichen Klassenmember (64) der Teilklasse (62) enthält, der sich von dem öffentlichen Klassenmember (64) zumindest teilweise unterscheidet; und – eine zweite Benutzerklasse (61), die unter Verwendung der zweiten öffentlichen Datei (51‘) eine Referenz auf eine Objektinstanz der Teilklasse (62) verwendet wobei das Verfahren ferner aufweist: – Erzeugen eines dritten Kompilats (67) von der zweiten Benutzerklasse (61) unter Verwendung der zweiten öffentlichen Datei (51‘). Method according to one of the preceding claims, characterized by the development environment ( 60 ), further comprising: - a second public file ( 51 ' ), the second public file ( 51 ' ) a declaration from at least one second public class member ( 64 ) of the subclass ( 62 ), which differs from the public class member ( 64 ) at least partially differentiates; and a second user class ( 61 ) using the second public file ( 51 ' ) a reference to an object instance of the subclass ( 62 The method further comprises: generating a third compilation ( 67 ) of the second user class ( 61 ) using the second public file ( 51 ' ). Verfahren nach einem der vorhergehenden Ansprüche, dadurch gekennzeichnet, dass die interne Datei (43, 53) einen Bezeichner aufweist, wobei der Bezeichner dazu verwendet wird, die Deklaration des zumindest einen öffentlichen Klassenmembers (64) der Teilklasse (62) zuzuordnen. Method according to one of the preceding claims, characterized in that the internal file ( 43 . 53 ) has an identifier, the identifier being used to indicate the declaration of the at least one public class member ( 64 ) of the subclass ( 62 ). Computer-lesbares Speichermedium, das Instruktionen aufweist, die zumindest einen Prozessor dazu veranlassen das Verfahren nach einem der vorhergehenden Ansprüche zu implementieren, wenn die Instruktionen durch den Prozessor ausgeführt werden.  A computer-readable storage medium having instructions that cause at least one processor to implement the method of any one of the preceding claims when the instructions are executed by the processor. Vorrichtung (60) zur Erzeugung eines Kompilats (60), Folgendes aufweisend: – eine Benutzerklasse (61); – eine Teilklasse (62), wobei die Teilklasse (62) zumindest einen internen Klassenmember (44, 54, 63) und zumindest einen öffentlichen Klassenmember (64) aufweist; und – eine öffentliche Datei (41, 51, 51‘), die eine Deklaration von zumindest einem öffentlichen Klassenmember (64) der Teilklasse (62) enthält, wobei die öffentliche Datei (41, 51, 51‘) nicht eine Deklaration von dem internen Klassenmember (44, 54, 63) der Teilklasse (62) enthält; – einen Compiler (33, 65), der dazu ausgebildet ist, unter Verwendung der öffentlichen Datei (41, 51, 51‘) ein Kompilat (67) der Benutzerklasse (61) zu erzeugen, dadurch gekennzeichnet, dass die Benutzerklasse (61) auf eine Referenz auf eine Objektinstanz der Teilklasse (62) Bezug nimmt. Contraption ( 60 ) for creating a compilation ( 60 ), Comprising: - a user class ( 61 ); - a subclass ( 62 ), where the subclass ( 62 ) at least one internal class member ( 44 . 54 . 63 ) and at least one public class member ( 64 ) having; and - a public file ( 41 . 51 . 51 ' ), which is a declaration of at least one public class member ( 64 ) of the subclass ( 62 ), where the public file ( 41 . 51 . 51 ' ) not a declaration from the internal class member ( 44 . 54 . 63 ) of the subclass ( 62 ) contains; - a compiler ( 33 . 65 ), which is adapted to use the public file ( 41 . 51 . 51 ' ) a compilation ( 67 ) of the user class ( 61 ), characterized in that the user class ( 61 ) to a reference to an object instance of the subclass ( 62 ) Refers. Vorrichtung (60) nach Anspruch 8, dadurch gekennzeichnet, dass der Compiler (33, 65) dazu ausgebildet ist, unter Verwendung der öffentlichen Datei (41, 51, 51‘) und einer Deklaration des zumindest einen internen Klassenmembers (44, 54, 63), ein zweites Kompilat (67) der Teilklasse (62) zu erzeugen. Contraption ( 60 ) according to claim 8, characterized in that the compiler ( 33 . 65 ) is designed using the public file ( 41 . 51 . 51 ' ) and a declaration of the at least one internal class member ( 44 . 54 . 63 ), a second compilation ( 67 ) of the subclass ( 62 ) to create. Vorrichtung (60) nach einem der Ansprüche 8 oder 9, dadurch gekennzeichnet, dass die Vorrichtung ferner aufweist: – eine interne Datei (43, 53), die der Teilklasse (62) zugeordnet ist, wobei in der internen Datei (43, 53) die öffentliche Datei (41, 51, 51‘) als ein Deklarationsort für öffentliche Klassenmember (64) der Teilklasse (62) spezifiziert ist, wobei der Compiler (33, 65) und/oder Linker (35) weiter dazu ausgebildet ist, den Deklarationsorts der öffentlichen Klassenmember (64) einer Implementierung (45, 55) der Teilklasse (62) zuzuordnen. Contraption ( 60 ) according to one of claims 8 or 9, characterized in that the device further comprises: - an internal file ( 43 . 53 ), the subclass ( 62 ), where in the internal file ( 43 . 53 ) the public file ( 41 . 51 . 51 ' ) as a public class member declaration location ( 64 ) of the subclass ( 62 ), the compiler ( 33 . 65 ) and / or linker ( 35 ) is further adapted to the declaration location of the public class members ( 64 ) of an implementation ( 45 . 55 ) of the subclass ( 62 ). Vorrichtung (60) nach einem der Ansprüche 8 bis 10, dadurch gekennzeichnet, dass der Compiler (33, 65) als ein C++ Compiler (33, 65) ausgebildet ist, und/oder der Compiler (33, 65) einen Präprozessor (31) umfasst. Contraption ( 60 ) according to one of claims 8 to 10, characterized in that the compiler ( 33 . 65 ) as a C ++ compiler ( 33 . 65 ), and / or the compiler ( 33 . 65 ) a preprocessor ( 31 ). System (70) umfassend: – einen Erstellungsprozessrechner (77), Folgendes aufweisend: – ein erstes ausführbares Programm, wobei das erste ausführbare Programm durch ein erstes Kompilieren einer Benutzerklasse (61) und einer Teilklasse (62) in einer ersten Version unter Verwendung einer öffentlichen Datei (41, 51, 51‘) und einer internen Datei (53) erzeugt ist, wobei – die Teilklasse (62) in der ersten Version zumindest einen internen Klassenmember (44, 45, 63) und zumindestens einen öffentlichen Klassenmember (46) aufweist; – die Benutzerklasse (61) zumindest eine Referenz auf eine Objektinstanz der Teilklasse (62) in der ersten Version aufweist; – die öffentliche Datei (41, 51, 51‘) zumindest eine Deklaration von zumindest einem öffentlichen Klassenmember (46, 64) der Teilklasse (62) in der ersten Version enthält, wobei die öffentliche Datei (41, 51, 51‘) keine Deklaration von dem internen Klassenmember (44, 54, 63) der Teilklasse (61) in der ersten Version enthält – die interne Datei zumindest eine Deklaration von zumindest einem internen Klassenmember (63) der Teilklasse (62) in der ersten Version enthält; – ein Empfangsmodul (78), das dazu ausgebildet ist, Quellcode von einer ersten Entwicklungsumgebung (72) zu empfangen; – die erste Entwicklungsumgebung (72), Quellcode aufweisend, wobei – der Quellcode die Teilklasse (62) in einer zweiten Version definiert; und – die Teilklasse (62) in der zweiten Version zumindest einen internen Klassenmember aufweist, der von dem internen Klassenmember der Teilklasse (62) in der ersten Version verschieden ist; wobei der Erstellungsprozessrechner (77) dazu ausgebildet ist: – von der ersten Entwicklungsumgebung (72) den Quellcode zu Empfangen; und – ein zweites ausführbares Programm durch ein zweites Kompilieren des Quellcodes zu erzeugen, nicht durch ein zweites Kompilieren der Benutzerklasse (61). System ( 70 ) comprising: a creation process computer ( 77 ), Comprising: - a first executable program, the first executable program being compiled by first compiling a user class ( 61 ) and a subclass ( 62 ) in a first version using a public file ( 41 . 51 . 51 ' ) and an internal file ( 53 ), where - the subclass ( 62 ) in the first version at least one internal class member ( 44 . 45 . 63 ) and at least one public class member ( 46 ) having; - the user class ( 61 ) at least one reference to an object instance of the subclass ( 62 ) in the first version; - the public file ( 41 . 51 . 51 ' ) at least one declaration from at least one public class member ( 46 . 64 ) of the subclass ( 62 ) in the first version, where the public file ( 41 . 51 . 51 ' ) no declaration from the internal class member ( 44 . 54 . 63 ) of the subclass ( 61 ) in the first version contains - the internal file at least a declaration of at least one internal class member ( 63 ) of the subclass ( 62 ) in the first version; A receiving module ( 78 ), which is adapted to source code from a first development environment ( 72 ) to recieve; - the first development environment ( 72 ), Having source code, wherein - the source code is the subclass ( 62 ) defined in a second version; and - the subclass ( 62 ) in the second version has at least one internal class member, which has been created by the internal class member of the subclass ( 62 ) is different in the first version; wherein the creation process computer ( 77 ) is designed to: - from the first development environment ( 72 ) to receive the source code; and to create a second executable program by second compiling the source code, not by second compiling the user class ( 61 ). System (70) nach Anspruch 12, dadurch gekennzeichnet, dass der Erstellungsprozessrechner (77) weiter dazu ausgebildet ist, Objektinstanzen die in den ausführbaren Programmen (67) definierten Klassen zu instanziieren. System ( 70 ) according to claim 12, characterized in that the creation process computer ( 77 ) is further adapted to object instances in the executable programs ( 67 ) to instantiate defined classes. System (70) nach einem der Ansprüche 10 bis 13, dadurch gekennzeichnet, dass – die Entwicklungsumgebung (72) auf einer ersten Recheneinheit (71) ausgeführt, – der Erstellungsprozessrechner (77) auf einer zweiten Recheneinheit (81) ausgeführt wird, wobei die erste Recheneinheit (71) dazu ausgebildet ist, den Quellcode über einen Kommunikationskanal (80, 80‘) an das Empfangsmodul (78) des Erstellungsprozessrechners (77) zu senden. System ( 70 ) according to one of claims 10 to 13, characterized in that - the development environment ( 72 ) on a first arithmetic unit ( 71 ), - the creation process computer ( 77 ) on a second arithmetic unit ( 81 ) is performed, wherein the first arithmetic unit ( 71 ) is adapted to the source code via a communication channel ( 80 . 80 ' ) to the receiving module ( 78 ) of the creation process computer ( 77 ) to send. System (70) nach einem der Ansprüche 10–14, dadurch gekennzeichnet, dass der Erstellungsprozessrechner (77) weiter dazu ausgebildet ist, Tests, insbesondere Integrationstests und/oder Unit-Tests und/oder Regressionstests, an den ausführbaren Programmen durchzuführen. System ( 70 ) according to any one of claims 10-14, characterized in that the creation process computer ( 77 ) is further adapted to perform tests, in particular integration tests and / or unit tests and / or regression tests, on the executable programs.
DE102016202484.1A 2016-02-18 2016-02-18 Method, apparatus and system for generating a compilation Pending DE102016202484A1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
DE102016202484.1A DE102016202484A1 (en) 2016-02-18 2016-02-18 Method, apparatus and system for generating a compilation

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
DE102016202484.1A DE102016202484A1 (en) 2016-02-18 2016-02-18 Method, apparatus and system for generating a compilation

Publications (1)

Publication Number Publication Date
DE102016202484A1 true DE102016202484A1 (en) 2017-08-24

Family

ID=59522630

Family Applications (1)

Application Number Title Priority Date Filing Date
DE102016202484.1A Pending DE102016202484A1 (en) 2016-02-18 2016-02-18 Method, apparatus and system for generating a compilation

Country Status (1)

Country Link
DE (1) DE102016202484A1 (en)

Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5613120A (en) * 1994-10-20 1997-03-18 Silicon Graphics, Inc. System and method for enabling, without recompilation, modification of class definitions and implementations in an object-oriented computer program

Patent Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5613120A (en) * 1994-10-20 1997-03-18 Silicon Graphics, Inc. System and method for enabling, without recompilation, modification of class definitions and implementations in an object-oriented computer program

Non-Patent Citations (2)

* Cited by examiner, † Cited by third party
Title
Standards N4567
Standards Nr. N4567

Similar Documents

Publication Publication Date Title
DE69924857T2 (en) PROGRAM CODE CONVERSION
EP0689694B1 (en) Process for the machine-generation of parallel processable command groups from a program for super-scalar microprocessors
DE102013200029A1 (en) PROVIDING POWERFUL VERSIONS COMPILED CODES FOR A CPU IN A SYSTEM OF HETEROGENIC GUNS
DE112013001711T5 (en) Optimize subroutine calls based on the architectural level of a called subroutine
DE102007025397B4 (en) Multi-processor system and method of operation
DE102005040075A1 (en) Dynamically connecting modules in a pre-operating system environment
CH633643A5 (en) METHOD FOR BLOCK-FREE INTERLOCKED SIMULTANEOUS PROCESSING OF MULTIPLE TASKS BY MEANS OF SEVERAL PROGRAMS IN A DATA PROCESSING SYSTEM.
DE112012000303T5 (en) Dynamic binary optimization
EP1738257B1 (en) Method for preventing data inconsistency between accesses of different functions of an application to a global variable in a data processing installation
DE60102694T2 (en) MODULAR COMPUTER SYSTEM AND METHOD
DE202012013466U1 (en) Pre parsed headers for compilation
DE112011103406T5 (en) Management of unmodified objects
DE112013001735T5 (en) Optimizing the linking of instructions
DE69933323T2 (en) compiler
DE102018202446A1 (en) Method for modularizing a software architecture
WO2014161731A1 (en) Method for checking and/or transformation of a computer program with first-class static functions
DE102018208267A1 (en) TECHNOLOGY USING TAX RELIEF GRAPHS FOR CONVERTING CONTROL FLOW PROGRAMS IN DATA FLOW PROGRAMS
DE112018002316T5 (en) CODE COVERAGE TRACKING FOR A MICROCONTROLLER PROGRAM
DE10109848B4 (en) A programmable logic controller and programmer for generating a sequence program for a programmable logic controller
EP1622022A1 (en) Automatic generation of test cases
DE112010003774T5 (en) COMPATIBILITY AT OBJECT LEVEL AND CLASS SCALING USING SEMANTIC VALUES
DE102016202484A1 (en) Method, apparatus and system for generating a compilation
DE102018127317B3 (en) METHOD AND DEVICES FOR COMPUTER-IMPLEMENTED GENERATION OF AN EXECUTABLE PROGRAM CODE AND FOR EXECUTING AN EXECUTABLE PROGRAM CODE
DE102019132485A1 (en) Management of access restrictions within a system-on-chip
DE102006041002B4 (en) Method to adapt a program to a cache, and circuitry

Legal Events

Date Code Title Description
R163 Identified publications notified
R079 Amendment of ipc main class

Free format text: PREVIOUS MAIN CLASS: G06F0009450000

Ipc: G06F0009440000

R012 Request for examination validly filed
R079 Amendment of ipc main class

Free format text: PREVIOUS MAIN CLASS: G06F0009440000

Ipc: G06F0008540000