FROM UML TO ANSI-C - An Eclipse-Based Code Generation ...

Background
Workflow & Design
ANSI-C Meta-Model
Implementation of the Framework
Experience, Summary
FROM UML TO ANSI-C
An Eclipse-Based
Code Generation Framework
Horst Lichter
Matthias Funk
Alexander Nyßen
Research Group
Software Construction
horst.lichter@rwth-aachen.de
www.swc.rwth-aachen.de

Background & Motivation
Joined research project with ABB CRC
Context
Very similar products
Software is most important part
Challenges
European-wide distributed development
Hard memory and computation time
Programming language C

Components of the Solution
MeDUSA
Concepts
(MBD, UML)
Languages
ANSI-C
ViPER

MeDUSA
Method for UML2-based Construction of Embedded & Real-Time Software
Requirements
Modeling
Use Case Modeling
Use Case Details
Modeling
Analysis Modeling
Context Modeling
Information
Modeling
Intra- & Inter-Object
Modeling
Architectural Design
Modeling
Subsystem
Identification &
Consolidation
Structural & Behavioral
Architecture Design
Modeling
Detailed Design
Modeling
Detailed Structural
Design
Detailed Behavioral
Design
Implementation
Code Generation
Implementing &
Integration
C

ViPER
Visual Tooling Platform for Model-Based Engineering

Code Generation – Requirements
Adaptability
Different application domains require different UML elements
Different target platforms require library specific code generation
Separation of
conceptual transformation from UML to C
• application domain specific
code generation
Modular architecture
defined extension/modification points
shall be adaptable
may be reused or
adapted

2-Step Code Generation Strategy
Split the generation process in 2 modular steps!
Apply a model-to-model and a model-to-text transformation
UML
Model
Advantages
ANSI-C
Model
ANSI-C
Code
Each step can be developed and tested in isolation
Increased testability, reduced complexity
Easy adoption of the UML - ANSI-C m2m transformation
Stable code generation based on the ANSI-C model

2-Step Code Generation
Eclipse based technologies should be applied as far as possible
UML Modeling
Tool
UML
Meta Model
UML
Model
UML –ANSI-C
Transformator
ANSI-C
Meta Model
Transformation Generation
ANSI-C
Model
ANSI-C
Code
Generator
ANSI-C
Code
A B A produces B B A A consumes B A B B is instance of A

Core of ANSI-C Meta-Model
Based on C/C++ meta-model provided by Eclipse CDT project
TranslationUnit
aggregates all elements
language elements
preprocessor directives
comments (annotations)
Preprocessor directives
and annotations
stored as an ordered list
each has at most one
reference to its language
element
reused from
Eclipse CDT metamodel
. . . . . .

ANSI-C Meta-Model - Annotations
Comments contain information
expressed „non-structurally“ in
UML
Protected regions
mark sections in the C code where
custom code can be inserted
function body in .c files
Are save against re-generation
Prerequisite for practical usability
of the code generation framework

ANSI-C Meta-Model - Container
Containers
are needed to structurally organize C-Code
contain one or more translation units
may contain recursively containers
root of each
ANSI-C model

Generic UML - ANSI-C Transformation
Transformation strategy
UML packages are transformed into containers
All UML structural classifiers and types (of the design model) are
transformed generically into ANSI-C types
• struct and a set of functions
Constraint
• Declarations and implementations are generated into a
header and source file
• Since struct-declaration may need to refer recursively to
itself, an additional forward declaration header file is also
generated
Generalization is not supported
.h
_fdef.h
includes
.c

Implementing the Transformation with oAW
UML and ANSI-C model are EMF
models
openArchitectureWare
Framework for implementing
• M2M transformations
• M2T transformations (code
generation)
Check language
• Used to check source and
target models
Transformation language xTend
• scripts transform source model
elements to target model
elements
UML
Meta Model
UML
Model
UML –ANSI-C
Transformator
ANSI-C
Meta Model
ANSI-
C
Model

M2M-Transformation with xTend
/* starting point of transformation */
create ansic::Model this createModel
(uml::Model m,
uml::EncapsulatedClassifier topLevelComponent) :
// set name of model
setName(m.Name() == null ? "" : m.Name()) ->
// transform packages
subContainer.addAll(m.nestedPackage.transformPackage(m)) ->
// transform top-level classifier
subContainer.addAll(m.getGeneratedClassifiers().transformClassifier(m)) ->
// create a default main translation unit
m.getComponents().size > 0
? cm.translationUnit.add(m.createApplication(topLevelComponent))
: true
;

M2M-Transformation with xTend
ansic::Container transformPackage(uml::Package p, uml::Model m) :
let c = new ansic::Container :
c.setName(p.Name()) ->
;
/* process nested packages recursively; add their container
representations to subcontainer list */
c.subContainer.addAll(p.nestedPackage.transformPackage(m)) ->
/* classifiers of the package are transformed into subcontainers */
c.subContainer.addAll
(p.getGeneratedClassifiers().transformClassifier(m)) -> c
ansic::Container transformClassifier(uml::Classifier c, uml::Model m) :
let con = new ansic::Container :
con.setName(c.Name()) ->
con.translationUnit.add(c.createSourceFile(c.getFullyQualifiedName())) ->
con.translationUnit.add(c.createHeaderFile(c.getFullyQualifiedName())) ->
con.translationUnit.add(c.createForwardDecl(c.getFullyQualifiedName())) ->
con
;

Code Generation
xPand language of oAW
template based language
code generation is done by a
sequence of template expansions
used to generate C-Code from the
ANSI-C model
For each element of the ANSI-C
meta model a xPand template is
provided
The generation process starts at the
top-level Model element
ANSI-C
Meta
Model
ANSI-
C
Model
ANSI-C
Code
Generator
ANSI-
C
Code

xPand - Examples
«DEFINE E FOR ansic::Model»
«EXPAND Container::E FOREACH (List[ansic::Container])subContainer»
«EXPAND TranslationUnit::E FOREACH
(List[ansic::TranslationUnit])translationUnit»
«ENDDEFINE»
«DEFINE E FOR ansic::TranslationUnit»
«FILE container.getFullFilePath() + "/" + name»/
*************************************************************
* File: «name»
* Generated by ViPER.Codegen
*************************************************************/
«EXPAND PreprocessorElement::E FOREACH getOrphanPreprocessorStatements()»
«EXPAND ASTElement::E FOREACH astElement»
«ENDFILE»
«ENDDEFINE»

Architecture of the Framework
default generic
transformation
reference code
generation

GUI
Integration in Eclipse Workbench
Transformation and generation
wizzards
Wizzards guide the user through
the process
Called from special context menus

UML Structural Design Example
Subsystem CurrentOutput Component
Parts
Ports UML structural
classifiers

Generated Code

Framework Application
Development of a platform-dependent code generator
Generates C code for the Renesas M16C target platform
new UML meta model
elements
Steps
Enhance the UML meta-model by domain specific classifiers
• using UML profile mechanism
Adapt the default transformation
• create/modify xTend scripts

Adapted Transformation
create ansic::Model this createModel(uml::Model m,
uml::EncapsulatedClassifier topLevelComponent) :
// set name of model
setName(m.Name() == null ? "" : m.Name()) ->
subContainer.addAll(m.nestedPackage.transformPackage(m)) ->
triggerObjectsCount(getPeriodicTriggerObjects(m)) > 0
? subContainer.addAll(getPeriodicTriggerObjects(m).
transformPeriodicTriggerObjectClassifier(m))
: true
->
triggerObjectsCount(getAperiodicTriggerObjects(m)) > 0
? subContainer.addAll(getAperiodicTriggerObjects(m).
transformAperiodicTriggerObjectClassifier(m))
: true
...
xTend scripts are modified
new scripts are implemented for a new classifiers

Experience
Only the transformation unit has to be customized
Only local changes/extension were necessary
The reference generation unit was not subject to change
The overall implementation effort could be significantly
reduced
Technical details related to the generation process could be
delegated to the reference generation unit
Detailed know-how of the applied technology is necessary

Summary
Code generation is mandatory in a MDD approach
To reduce complexity a 2-step generation strategy was
chosen
M2M transformation UML meta-model -> ANSI-C meta-model
M2T transformation ANSI-C model -> Code
ANSI-C meta model contains all element to represent
language elements
annotations and preprocessor directives
structural organization of C-Code
oAW framework was used to implement
default generic transformation of UML structural classifiers
reference code generation based on the ANSI-C model
First experience is very promising

More information is available from the ViPER home page
www.viper.sc
Alexander Nyßen any@swc.rwth-aachen.de