FROM UML TO ANSI-C

An Eclipse-based Code Generation Framework

Mathias Funk

Department of Electrical Engineering, Eindhoven University of Technology, The Netherlands

Alexander Nyβen, Horst Lichter

Research Group Software Construction, RWTH Aachen University, Germany

Keywords:

Embedded & Real-Time Systems, ANSI-C, UML, Code Generation.

Abstract:

Model-driven engineering has recently gained broad acceptance in the ﬁeld of embedded and real-time soft-

ware systems. While larger embedded and real-time systems, developed e.g. in aerospace, telecommunication,

or automotive industry, are quite well supported by model-driven engineering approaches based on the UML,

small embedded and real-time systems, as they can for example be found in the industrial automation industry,

are still handled a bit novercal. A major reason for this is that the code generation facilities, being offered by

most of the UML modeling tools on the market, do indeed support C/C++ code generation in all its particu-

lars, but neglect the generation of plain ANSI-C code. However, this would be needed for small embedded

and real-time systems, which have special characteristics in terms of hard time and space constraints.

Therefore we developed a framework, which allows to generate ANSI conformant C code from UML models.

It is built on top of Eclipse technology, so that it can be integrated easily with available UML modeling

tools. Because ﬂexibility and customizability are important requirements, the generation process consists of a

model-to-model transformation between the UML source model and an intermediate ANSI-C model, as well

as a ﬁnal model-to-text generation from the intermediate ANSI-C model into C code ﬁles. This approach has

several advantages compared to a direct code generation strategy.

1 INTRODUCTION &

MOTIVATION

Model-Driven Engineering (MDE) has become very

popular in recent times, particularly in the domain of

embedded software systems. Although model-driven

approaches like e.g. ROOM (Selic et al., 1994),

ROPES (Douglass, 1999), or COMET (Gomaa, 2000)

havebeen knownto the embedded application domain

for several years, they have never reached the very

break through. According to our observations, it was

not before the release of the current Uniﬁed Modeling

Language (UML) standard (OMG, 2007b) - as well as

the inception of the related SysML standard (OMG,

2007a) - that this trend has signiﬁcantly gained im-

pact.

One major reason for this is in our opinion today’s

availability of a broad range of mature, standard-

conformant UML and SysML modeling tools, as ad-

equate tool support is the precedence for a success-

ful application of MDE, because only thereby its full

beneﬁts can be unleashed.

However, while modeling from the early require-

ments engineering up to the late detailed design can

be quite well supported by those state-of-the-art UML

and SysML tools, we noticed that support for gener-

ating code from the resulting design models is often

not yet satisfying.

The main reason for this is that ﬂexible customiza-

tion of the code generation process is often not pos-

sible at all, or only with great effort, as nearly all

tool vendors have their own proprietary code gener-

ation API. Customization potentials are often limited

to what the vendor anticipated beforehand, which is

not always what the user expects or desires.

Another reason, closely related to the ﬁrst one

which emerges in the domain of small embedded and

real-time software systems, is that due to the hard

space and timing constraints those systems have to

face, code generation of mixed C/C++ code, as it is

Funk M., Nyβen A. and Lichter H. (2008).

FROM UML TO ANSI-C - An Eclipse-based Code Generation Framework.

In Proceedings of the Third International Conference on Software and Data Technologies - SE/GSDCA/MUSE, pages 12-19

DOI: 10.5220/0001874000120019

 SciTePress

solely offered by nearly all state-of-the-art UML and

SysML modeling tools, most often is not adequate.

Instead generation of ANSI conformant C code would

be needed for those systems, as this still is the state-

of-the-practice implementation language (van Solin-

gen, 2004) for which approved compilers are avail-

able.

As we aim at providing mature model-driven en-

gineering for the domain of small embedded and real-

time software systems (Nyen and Lichter, 2007), we

introduced a code generationframework(Funk, 2006)

(Kevinc, 2007) to support the ﬂexible and customiz-

able generation of ANSI-C code from UML models.

2 RELATED WORK

Many commercial MDE tools targeting the domain

of embedded and real-time systems exist on the mar-

ket (an inventory is provided by (Graaf et al., 2002),

a quite extensive comparison of case tools targeting

the embedded and real-time domain can be found in

(Sch¨atz et al., 2003)). Quite a few of those tools offer

UML modeling capabilities, as the UML has become

the predominant modeling language for MDE. Nearly

all of those tools supporting the UML do as well offer

direct code generation capabilities from UML mod-

els. However, as already mentioned, the offered gen-

eration capabilities are mostly inﬂexible and hard to

customize. Moreover, the generation of plain ANSI

conformant C code is often not supported. Instead,

most of the tools deliver proprietary runtime libraries

and concentrate on the generation of C++ code which

is not applicable to the domain of small embeddedand

real-time systems.

While commercially available tools thus only

marginally cover the regarded domain of small em-

bedded and real-time systems, academic approaches

do not seem to consider the domain at all. That

is, there are almost no approaches investigating the

generation of ANSI conformant C code from UML

models. The reason for this - as we think - is that

academic state-of-the-art and industrial state-of-the-

practice are separated by a time gap of around 10-15

years, so that real-world problems being relevant to

the regarded domain have simply gotten out of aca-

demic scope. That is, ANSI conformant C code gen-

eration from UML models has been inside academic

scope in the early days of the UML (e.g. the gener-

ation of C code from state machines or from simple

class diagrams), but after that not much research ef-

fort has been spent to those questions. For instance,

the generation of ANSI-C code from UML composite

structure or component diagrams, being introduced to

the UML in its recent version to especially address

embedded and real-time systems, has not been inves-

tigated yet.

The code generation framework we propose is in-

tended to ﬁll the described gap. It allows for rapid de-

velopment of custom ANSI-C code generators as they

are required by the regarded domain of small embed-

ded and real-time systems. We see this as a prereq-

uisite for the successful application of MDE technol-

ogy.

3 REQUIREMENTS

Besides the fundamental functional requirement to

support the generation of ANSI-C code from UML

models, the most important requirement for our code

generation framework is - as already mentioned - a

non-functional, namely to be ﬂexible and adaptable.

That is, the code generation process has to be such

that different transformation strategies, different ap-

plication domains, as well as different target plat-

forms are supported. Furthermore, as the code gen-

eration process may change over time, maintainance

has to be as straight-forward as possible.

In consequence, we demand that the code gener-

ation framework should have a very modular archi-

tecture, separating the logical transformation process

(i.e. how UML model elements are mapped to C lan-

guage constructs) from the rather technical process

of code generation. This way, changes to the logi-

cal transformation - which we consider to be the one

that most likely changes - can be done without affect-

ing the rather technical process of generating the C

language unit ﬁles which is considered to be rather

stable.

Eclipse has established itself as a de facto in-

dustry standard, and the related tools and technol-

ogy projects offer a mature C/C++ development en-

vironment (Eclipse CDT tools project (The Eclipse

Foundation, 2000a)) as well as underlying technol-

ogy for model-driven engineering based on UML

(Eclipse MDT (The Eclipse Foundation, 2000d) and

GMT (The Eclipse Foundation, 2000b) technology

projects). This led us to the decision to realize our

code generation framework based on that technology

as well. This way, it can be easily integrated with sev-

eral other UML and SysML modeling tools, as vari-

ous considerable tool manufacturers as IBM Rational,

Borland, Mentor Graphics, Gentleware, No Magic,

Embedded Plus (SysML Toolkit for Rational Soft-

ware Development Platform), and others build their

tools on top of Eclipse technologies.

FROM UML TO ANSI-C - An Eclipse-based Code Generation Framework

4 CONCEPT AND DESIGN

As already indicated, we decided to do the transfor-

mation of UML models into ANSI-C code in two

steps, namely a logical transformation step between

the UML model and an intermediate ANSI-C model,

which represents the C language elements as deﬁned

by the respective language grammar (Kernighan and

Ritchie, 1988), as well as a subsequent generation

step from the intermediate ANSI-C model to C code.

UML

Model

UML

Modeling

Tool

UML- ANSI-C

Transformator

ANSI-C

Model

ANSI-C

Code

Generator

ANSI-C

Code

UML

Meta Model

ANSI-C

Meta Model

Transformation Generation

A produces B

A A consumes B

B is instance of A

Figure 1: Code Generation Strategy.

In the sense of model-driven engineering, the

code generation process itself therefore consists of

a model-to-model transformation between the UML

source model and an intermediate ANSI-C model, as

well as a ﬁnal model-to-text generation from the inter-

mediate ANSI-C model into C code ﬁles, as demon-

strated in Figure 1.

This approach, using an intermediate ANSI-C

model, has several advantages compared to a direct

code generation strategy.

First, as the logical mapping between the UML

model elements and their ANSI-C representations

can be dealt with isolated from the technical domain

of generating the source code ﬁles, easy adoption

and customization of the transformation logic can be

achieved without having to go into the technical de-

tails of the generation.

Second, as the model-to-text generation process

can on the other hand be regarded as rather stable

and does not have to be changed in the normal case,

but can be reused as-is, this leads to increased robust-

ness and stability of any code generator being built on

top of the framework. Furthermore, increased main-

tainability and testability can be expected because the

separation allows for maintainance and testing of both

parts individually. This is in particular the case for the

logical transformation process, which is realized in

the technical domain of model-to-model transforma-

tion, so that the transformation strategy itself can be

easily tested by checking the source and target models

affected by the transformation.

Further, it can as well be ensured that the ﬁnally

generated source code is ANSI conformant, as this

is already ensured by the syntactical correctness and

well-formedness of the intermediate ANSI-C meta

model.

Such a solution offers the advantage of an overall

reduced complexity. One can imagine that a combina-

tion of both steps, bringing the two problemstogether,

would be much harder and error-prone to solve, let

alone the reduced quality in terms of testability and

maintainability. In this sense, the decision to split the

overall process into a transformation and a generation

part already simpliﬁes the development, adaption and

extension of the framework.

4.1 ANSI-C Meta Model

Having motivated the need for an intermediate ANSI-

C model, the conception of a respective ANSI-C meta

model was an essential part in the realization of our

framework. Indeed, its realization is quite straight-

forward, as it has to represent the whole C language

grammar (Kernighan and Ritchie, 1988). According

to this, a C translation unit (which corresponds to a .h

or .c ﬁle) contains three main language items, namely

preprocessor constructs, language constructs (i.e. ab-

stract syntax tree elements), and annotations (com-

ments) that may be attached to both types of con-

structs.

The corresponding part of the meta model is

displayed in Figure 2. It shows the integration of

preprocessor constructs and abstract syntax tree

elements, as well as annotations, which can appear

admixed in the source code but which are han-

dled each during different stages of the compilation

process. They will therefore not interfere during com-

pilation, but have to coexist in the model. As it has to

be possible to add preprocessor elements before, af-

ter, and inside (structured) AST elements (e.g. inside

ForStatement

, before the ﬁrst nested

Statement

and as it further possible to add annotations be-

fore, after, and inside (structured) preprocessor

statements as well as AST elements, respective

relationships between the meta model elements were

designed (in case of a structure

ASTElement

PreprocessorElement

innerLeadingPosition

and innerTrainlingPosition

refer to the posi-

tions directly before the ﬁrst nested element as well as

directly after the last nested one; in case of unstruc-

tured

ASTElements

and

PreprocessorElements

those associations are undeﬁned).

Down from the

PrepocessorElement

and

ASTElement

meta model elements, the construc-

tion of the ANSI-C meta model is a pretty simple

translation of the respective C language grammar

elements, so we do not present this in very detail

here.

Annotations

are more interesting as they

may appear in the form of

Comments

as well as

ICSOFT 2008 - International Conference on Software and Data Technologies

Figure 2: Core of the ANSI-C Meta Model.

Figure 3: Annotations Hierarchy.

ProtectedRegionAnnotations

(cf. Figure 3).

Comments

have to be represented in the ANSI-

C meta model to offer the possibility to trans-

port knowledge that is expressed “non-structurally”

from the UML model to the ANSI-C model.

ProtectedRegionAnnotations

, have special se-

mantics regarding the code generation process,

namely to mark sections inside the source code where

custom code can be inserted, being preserved from

manipulation by subsequent re-generation runs. We

stress this point, as this is a prerequisite for the prac-

tical usability of a code generation framework, as

thereby users can alter, specialize or remove gener-

ated code and tailor the constructs to their needs.

The C language grammar naturally just deﬁnes the

structure of elements embedded into a single transla-

tion unit (.h or .c ﬁle). As a complete model-to-model

transformation will have to deal with a potentially

high number of translation units, additional structur-

ing means are needed. That is why the container hier-

archy as displayed in Figure 4 was introduced. Con-

tainers allow to structurally organize translation units.

They will be transferred into ﬁle system folders dur-

ing the ﬁnal generation of C code, and thus allow to

specify which translation units are grouped together

into folders.

Figure 4: Container Hierarchy.

As already indicated in the introduction, we de-

cided to use Eclipse technology for the technical

implementation of the ANSI-C meta model. Be-

sides Eclipse has become generally accepted in prac-

tice, the fact that an Eclipse Modeling Framework

(EMF) (The Eclipse Foundation, 2000c) based im-

plementation of the UML meta model is provided by

the Eclipse Model Development Tools (MDT) (The

Eclipse Foundation, 2000d) project, was a signiﬁcant

FROM UML TO ANSI-C - An Eclipse-based Code Generation Framework

driverfor this decision. This way, the model-to-model

transformationcan be easily realized whithout leaving

the technical domain of EMF.

4.2 Model-to-model Transformation

As already elaborated, the logical mapping from

UML elements to their ANSI-C representations is re-

alized by a model-to-model transformation between a

UML input model and an ANSI-C output model. This

allows us to separate the logical aspects of the code

generation process from the rather technical process

of generating the source code ouput ﬁles.

As both input and output models are based on

EMF technology, the realization of such model-to-

model transformations can be achieved quite easily

with the technology offered by the Eclipse Generative

Modeling Techniques (GMT) project (The Eclipse

Foundation, 2000b).

We decided to use the thereby provided openAr-

chitectureWare (OAW) framework for this purpose.

It provides powerful mechanisms to operate on EMF-

based models, by offering three script languages to

specify model-to-model and model-to-text transfor-

mation and generation, as well as for checking mod-

els.

ansic::Container createPackage(uml::Package p) :

/* create a new container */

let

d =

new

ansic::Container :

/* provide the name of the newly created container */

d.setName(p.Name()) ->

/* process nested packages recursively; add their

container representations to subcontainer list */

d.subContainer.addAll(p.nestedPackage.createPackage()) ->

/* classifiers contained in the package are transformed

into sub containers, which contain .h and .c transl.

units for the actually realizing the classifier */

d.subContainer.addAll(p.getGeneratedClassifiers()

.createClassifier()) -> d

;

Figure 5: xTend Code for Transformation of UML

Package

A model-to-model transformation can in this con-

text be described in the form of transformation rules,

being speciﬁed in the functional oAW xTend script

language. The example in Figure 5 shows a transfor-

mation rule for a UML package (and its nested pack-

ages and classiﬁers).

4.3 Model-to-text Generation

While the logical information about the transfor-

mation of UML model elements into their respec-

tive ANSI-C representations is encapsulated by the

model-to-model transformation, the actual code gen-

eration step is a simple model-to-text generation pro-

cess. It is rather straight-forward because the ANSI-C

model is simply different representation of the trans-

lation unit’s syntax tree structure.

As before, oAW technology is employed to real-

ize the model-to-text generation. That is, the transla-

tion unit as well as each of its contained language ele-

ments are generated based on oAW’s xPand language.

xPand is a template based language, i.e. the text frag-

ment that is generated for each model element is spec-

iﬁed in form of a parameterizable text template. An

example for an xPand template is shown in Figure 6.

It depicts the template for a translation unit which is

transferred into a ﬁle containing a top comment. Gen-

eration of contained preprocessor and AST elements

is delegated to respective templates.

DEFINE

FOR

ansic::TranslationUnit

FILE

container.getFullFilePath() + "/" + name/

*************************************************

* File: name

* Generated by ViPER.Codegen

*************************************************/

EXPAND

ASTElement::E

FOREACH

getOrphanPreprocessorStatements()

EXPAND

ASTElement::E

FOREACH

astElement

ENDFILE

ENDDEFINE

Figure 6: xPand Code for Generation of

TranslationUnit

5 FRAMEWORK

ARCHITECTURE

In order to use a code generator in daily work, it has

to be integrated with other development tools (com-

piler, editor, etc.). We decided to realize our frame-

work in the form of extensible Eclipse plug-ins. This

does not only allow for integration into the Eclipse

IDE itself, but as well into other development envi-

ronments built on top of Eclipse. We decided to split

the architecture of our framework into two subsys-

tems, the core, which realizes the underlying trans-

formation and generation processes, and the user in-

terface, which queries information from the user and

ICSOFT 2008 - International Conference on Software and Data Technologies

controls the transformation and generation processes.

We will describe both in the following.

5.1 Core Subsystem

The model-to-model transformation and the model-

to-text generation are realized in this subsystem by

respective transformation and generation units, as de-

picted in Figure 7.

Figure 7: Core Subsystem Architecture.

Reading input source models as well as writ-

ing output target models is realized with the help

of model readers and writers which are specializa-

tions of generic oAW provided XMI readers and writ-

ers. xTend and xPand scripts which realize the actual

transformation and generation respectively are exe-

cuted by the oAW workﬂow engine.

To be able to customize and extend the frame-

work constituents, both units offer extension mech-

anisms where customized components for model-to-

model transformation and model-to-text generation

can be inserted. While the model-to-model transfor-

mation is regardedto be subject to changes quite often

during development (most customizations will affect

this part of the over-all code generation process), the

model-to-text generation part is regarded to be rather

stable, as it translates already similar structures from

the model representation into the textual represanta-

tion of source code. However, it might be that cus-

tomization is needed there as well, e.g. because run-

time libraries or platform-speciﬁc ﬁles have to be gen-

erated together with the source code. Therefore we

provide an extension mechanism for this part as well.

All extensions have to offer a check component

(realized by an oAW Check script) which is used to

verify that the respective source model is a valid in-

put model for the respective transformation or gener-

ation step, and a transformation respectively genera-

tion component, which bundles the xTend or xPand

scripts realizing the transfomation respectively gener-

ation.

We developed so-called contributions to both ex-

tension points to demonstrate the capabilities of the

framework. The reference implementation for the

model-to-text generation part is regarded to be an es-

sential part of the framework itself as it can be reused

in different code generation scenarios. In contrast,

the default implementation contributing the model-to-

model transformation is understood as a mere demon-

stration example. It will most likely be replaced with

a custom transformation by end users of the frame-

work. We used it to demonstrate the capabilities of the

framework by generating ANSI conformant C code

from the structural information captured in a UML

model.

5.2 User Interface Subsystem

The core transformation and generation units are inte-

grated into the Eclipse with the help of wizards, which

are called from respective context menus integrated

into the Eclipse navigator view. This gives direct ac-

cess to the desired transformation respectively gener-

ation functionality when a UML and ANSI-C model

is selected as a resource in the Eclipse workbench.

Figure 8 gives an overview on how this integration is

achieved with the help of so called ActionDelegates.

By choosing the respective context menu entry, a

wizard is started and guides the user through the trans-

formation or generation step. In both cases, the se-

lected input model is ﬁrst validated using the provided

check component. After that, further parametrization

data needed for the transformation respectively gen-

Figure 8: User Interface Subsystem Architecture.

FROM UML TO ANSI-C - An Eclipse-based Code Generation Framework

eration step is collected and passed to the underlying

core component. Afterwards, the execution of the re-

spective core component is started from the wizard

and the results of the transformation or generation

step are displayed to the user, giving the possibility

to cancel the operation.

6 EVALUATION

We evaluated our code generation framework by im-

plementing a platform-dependentcode generator. The

code generator produces customized ANSI confor-

mant C code for the Renesas M16C target platform

(Renesas Technology, 2008), which is a typical repre-

sentative for the domain of small embedded and real-

time systems. Based on the default transformation

unit provided by the framework, the M16C generator

supports the generation of ANSI conformant C code

from the structural information contained in a UML

model, i.e. the structural information contributed to a

UML model by means of UML structure diagrams.

The concept of customizability was proofed so far

as the customization did indeed affect only the trans-

formation part of our code generator and was there-

fore restricted to local changes only. The reference

generation was not subject to change because it solely

dependends on the intermediate ANSI-C model and

does not contain any platform dependencies.

Experience thus showed that the separation of

transformation and generation logic is a reasonable

approach. In contrast to the standalone development

of a comparable code generator, the overall imple-

mentation effort could be signiﬁcantly reduced, as

all technical details related to the generation pro-

cess could be delegated to the reference generation

unit. This would even hold if the transformation unit

were developed from scratch, not based on the default

transformation unit provided with the framework.

What can of course not be concealed is that the im-

plementation the transformation logic entails an ini-

tial learning effort. This holds for the technical im-

plementation, which is done in terms of developing

oAW xTend scripts, as well as for the logical transfor-

mation, which requires knowledge about the ANSI-C

model structure. This has to be taken into considera-

tion.

Statements about the quality, performance, or

maintainability of the generated code, as well as

of the effort related to the construction of concrete

input UML models for this speciﬁc code genera-

tor can of course not be generalized to properties

of the overall code generation framework. How-

ever, it can be stated that - as experience showed -

the maintainability and customizability of the gen-

erated code depends much on the appropriate usage

ProtectedRegionAnnotations

in the design of

the logical transformation process. They mark those

source code locations which should not be affected by

re-generation runs of the generator and thus allow the

user to safely insert own code fragments. To this ex-

tend, the quality and robustness of the generated code

directly depends on how well necessary additions or

changes to the generated code are anticipated in the

transformation logic design.

7 SUMMARY & CONCLUSIONS

As we stated in the introduction, we see that model-

driven engineering based on the UML is getting more

and more impact in the domain of small embedded

systems. Due to the fact that small embedded sys-

tems are subject to hard space and timing constraints,

Java code generators are not appropriate. Further-

more, C++ also has not saturated the ﬁeld yet. In this

sense, the C language is still the primary program-

ming language in this domain.

We believe that the full beneﬁts of a model-driven

engineering approach can only be unleashed with the

help of adequate tool support. This is the motivation

for the need for a code generator, supporting the gen-

eration of ANSI conformant C code out of UML mod-

els. Our solution is a ﬂexible and customizable frame-

work to support the realization of custom ANSI-C

code generators. As Eclipse has become the predomi-

nant integrateddevelopmentenvironment, we decided

to have our framework residing in that technical do-

main as well in order to achieve a seamless integration

with such tools.

The framework as well as the custom code gen-

erators used for evaluation purposes, are made avail-

able as part of the ViPER platform being offered by

our group. They can be obtained from the ViPER

project site (RWTH Aachen University, Research

Group Software Construction, 2005). We are con-

vinced that our contribution supports the adoption of

a model-driven engineering approach in the domain

of small embedded systems, which is currently not

the main focus of UML modeling tool vendors, but

which is a domain, where model-driven engineering

can improve a lot, showing all its advantages.

REFERENCES

Douglass, B. P. (1999). Doing Hard Time - Developing

Real-Time Systems with UML, Objects, Frameworks,

ICSOFT 2008 - International Conference on Software and Data Technologies

and Patterns. Addison Wesley - Object Technology

Series.

Funk, M. (2006). Generierung von efﬁzientem C-Code

aus UML2-Strukturdiagrammen. Diploma Thesis,

RWTH Aachen University, http://www.swc.rwth-

aachen.de/lufgi/teaching/theses/completed/Mathias

Funk Thesis Report.pdf.

Gomaa, H. (2000). Designing Concurrent, Distributed, And

Real-Time Applications with UML. Addison Wesley -

Object Technology Series.

Graaf, B., Lormans, M., and Toetenel, H. (2002). Software

technologies for embedded systems: An industry in-

ventory. In PROFES ’02: Proceedings of the 4th In-

ternational Conference on Product Focused Software

Process Improvement, pages 453–465, London, UK.

Springer-Verlag.

Kernighan, B. W. and Ritchie, D. M. (1988). The C Pro-

gramming Language - Second Edition. Prentice Hall

- Software Series.

Kevinc, O. (2007). Erweiterung des ViPER Codegenerators

um Nebenluﬁgkeit und Zeitverhalten. Diploma The-

sis, RWTH Aachen University, http://www.swc.rwth-

aachen.de/lufgi/teaching/theses/completed/Oezguer

Kevinc Thesis Report.pdf.

Nyen, A. and Lichter, H. (2007). MeDUSA - MethoD for

Uml2-based Design of Embedded Software Applica-

tions. Technical Report AIB-2007-07, RWTH Aachen

University.

OMG (2007a). OMG Systems Modeling Lan-

guage (OMG SysML) Speciﬁcation. OMG

Proposed Available Speciﬁcation 07-02-04.

http://www.omg.org/docs/ptc/07-02-04.pdf.

OMG (2007b). UML Superstructure Speciﬁca-

tion, v2.1.2. OMG Formal Document 07-11-

02.http://www.omg.org/cgi-bin/doc?formal/07-11-02.

Renesas Technology (2008). M16C Family

(R32C/M32C/M16C/R8C). http://www.renesas.com/

fmwk.jsp?cnt=m16c family landing.jspfp=/products/

mpumcu/m16c family, retrieved: 2008/14/05.

RWTH Aachen University, Research Group Soft-

ware Construction (2005). ViPER project site.

http://www.viper.sc, retrieved: 2008/13/03.

Sch¨atz, B., Hain, T., Houdek, F., W.Prenninger, Rappl, M.,

Romberg, J., Slotosch, O., Strecker, M., and Wis-

speintner, A. (2003). CASE-Tools for Embedded Sys-

tems. Technical Report TUM-I0309, TU M¨unchen.

Selic, B., Gullekson, G., and Ward, P. T. (1994). Real-Time

Object-Oriented Modeling. Wiley.

The Eclipse Foundation (2000a). Eclipse C/C++

Development Tooling (CDT) project site.

http://www.eclipse.org/cdt, retrieved: 2008/13/03.

The Eclipse Foundation (2000b). Eclipse Gen-

erative Modeling Technologies project site.

http://www.eclipse.org/gmt, retrieved: 2008/13/03.

The Eclipse Foundation (2000c). Eclipse Model-

ing - Eclipse Modeling Framework (EMF) project

site. http://www.eclipse.org/modeling/emf, retrieved:

2008/13/03.

The Eclipse Foundation (2000d). Eclipse Mod-

eling - Model Development Tools (MDT)

project site, http://www.eclipse.org/MDT.

http://www.eclipse.org/modeling/mdt, retrieved:

2008/13/03.

van Solingen, R. (2004). State of the practice in European

embedded software engineering. In MOOSE seminar,

Oulu, Finland.

FROM UML TO ANSI-C - An Eclipse-based Code Generation Framework