MAFCOG 1.0A Generic code generator for Mathematical Functions

-
r-
rr-
r
r
r:
r
r:
-r:
r
-
"I"
-
-"
r:
r-
•',/i-
Proceedings oflhe National Conference on
Compuling and Applications (NACCA '06)
Nauonal Engineering College. Kovilpattt, Tamil-Nadu
MAFCOG 1.0 A Generic code generator for Mathematical
Functions
Mrs. S. R.ldate 1 , Prof. S. H. Patil l , Mr. D. J. Male ,Mrs. M. M. Bewoor"
'lecturer In Computer Department, B. V.D.U. CO.E. Pune, India.
lprofessor In Computer Department, B. V.D. U. Co.E. Pune, India
Jsoftware Engineer In IBM Global Services India Pvt. Ltd. Pune, India.
4 "
lecturer In Computer Department, B. V.D. U. Co.E. Pune, India
Abstract
MAFCOG 1.0 (MAthematical Formula Analyzer and COde Generator) is a flexible, generic
code generator for java and other programming languages. A MAFCOG 1.0 user can define
the mathematical functions by formulating them using the inbuilt functions of MAFCOG.
"Alternatively, the user can use the defined formulas in the form of images. Thus MAFCOG
1.0 will use the formula, generate the code in the required language, and validates the same
for user inputs. User can use this code as plug-in or as a snippet as per the requirement. Using
JAVACC, Java Swing, and XML will develop the system.
1.0 RELEVANCE TO GENERATIVE
PROGRAMML~G
The goal of generative and componentbased
software engineering is to increase
the productivity, quality, and time-tomarket
in software development thanks to
the deployment of both standard
componentry and production automation.
One important paradigm shift implied here
is to build software systems from standard
componentry rather than "reinventing the
wheel" each time. This requires thinking in
terms of system families rather than single
systems. Another important paradigm shift
is to replace manual search, adaptation, and
assembly of components with the automatic
generation of needed components on
demand. Generative and component-based
software engineering seeks to integrate
domain engineering approaches,
"
produces a non-atomic, extended
computation (i.e., iteration or recursion)
361
component-based approaches, and
generative approaches. [REF 5]
1.1 Problem
The fundamental contribution of high-level
languages to programming productivity was
the ability of their compilers to transform a
compact representation of a mathematical
computation (i.e., an arithmetic expression
expressed in a mature notation borrowed
from mathematics) into an equivalent but
expansive and complexly interrelated series
of assembly language instructions. This
saves the programmer a significant amount
of work because the mathematical
expression is that are already inherently
composite. Thus, every operation on such
abstractions
because the operands are extended,
composite structures. And to compound the
,\
I'
I
\

..
,,-
r-
r-
r:
r:
"...
i
MA FCOG 1.0 A Generic CCNk Generator For Mathematical Functions
problem; the ideal use of such abstract,
domain specific operators and operands in
expressions that compose many such
operations together. [2]
Even w-nen developers have recurring
computer-readable metadata to process and
a clear idea of how code should by
structured, they can still find themselves in
need of a technique to automatically
generate me code for the mathematical
formula :.J avoid the drudge work of
repeatedly writing and tweaking it.
Generative programming is a technique that
addresses this problem. Using generative
programming techniques, any developer can
solve matcernatical problems in families,
rather than individually, saving time and
coding effort. This article describes these
techniques using MAFCOG 1.0, and builds
a sample template-driven code generator for
mathernaticz l expression. [ 4]
Applying generative programming produces
implementation code from three things:
• A Deans of specifying family
members,
• The implementation components
from which members can be
assern r-led, the configuration
knowledge mapping between a
specification of a member and a
finished member. In other words,
generative programming builds
implerr. entations from the code
patterns and lower-level
components, and the metadata that
brings r::e two together. [1,3]
•
MAFCt)G 1.0 is a tool provided to
the user to generate the code for the
specifiec language.
1.2. Tool Description
Code Generators are programs that
automatically generate high-level
code(Java, C, C-+ etc). These tools range
.~\ l' . ., .
362
in size and complexity. There are two types
of code generators: active and passive.
Active model maintain the code generated
by the generator long term. Passive models
create the initial code, and then it is the
responsibility of the engineer to maintain it.
A typical example of a passive code
generator is a wizard.
MAFCOG 1.0 will be the ideal tool
for professionals who need quick solution to
. technical problems. If user knows the
mathematical formula and the platform in
which the formula solution required to be
developed (Java, C++ etc) MAFCOG 1.0
lets him to add evaluation of mathematical
expression to his/her application easily. It
should support 7 operators (including
Parenthesis), 10 mathematical functions,
10-15 users defined variables and provides
complete error handling support.
MAFCOG 1.0 is a template driven
code generation product that streamlines the
application development process and.
slashes development time.· Using
breakthrough, template-driven technology
2. 0 OVERVIEW
MAFCOG 1.0 will help Java developers
create sophisticated code for mathematical
functions faster, more efficiently and more
economically. Code templates provided are
Developer modifiable.
The benefits provided by MAFCOG 1.0
approach include higher developer
productivity, better software quality, and
lower maintenance costs.
2.1 Measurable Productivity Gains
Generating code by definition is
always going to be much faster than
hand coding. The productivity gain
when writing the mathematical code is
at least 70%, with the coding part of the
design, code, and test cycle eliminated.

2.~ Higher Quality:
v ,
'""
Generated code is error free and well
designed." Development teams are more
consistent. Automatic code generation
ensures that software developers are more
likelv to be focused on the business
requirements than the more mundane task
of coding.
2.3 Lower Maintenance Costs:
.,'
The code generated by MAFCOG 1.0 will
be very easy to understand and therefore
easier to maintain. The true long-term value
of code generation emerges when there are
new" business requirements. Ongoing
maintenance costs are reduced because it is
easier to regenerate code than to make
manual code changes. There are two
";:primary components used in MAFCOG 1.0
• Formula Parsing engine
• Code generation engine
The Formula Parsing engine is a platform
that hosts grammar files (called JJ files)
with the help of which, actual formula
parsing can be done. There are a variety of
grammar files that you can plug in to the
engine to generate code a particular way.
Code generation engine implements a
template-based" approach that allows to
specify the architectural aspects of the code
under construction. To do this, it provides a
specific Meta Model.
it comprises a set of rules for formula code
generation on how to read formula, splitting
them into tokens, interpret them, get the
rules from defined templates and extract
information from them to generate code.
The meta model planner then matches parts
and also provides the paths and directions
needed when creating a new template.
3.0 HO'V MAFCOG 1.0 GENERATES
CODE?
National Conference on Computing and Applications
363
The following describes the process used by
MAFCOG 1,0 engine to generate code.
Details of each step follow this section.
Figl.1 :\1AFCOGl.O Processes
3.1 Formula Parsing And Validation
The formula provided by the user wi 11 be
parsed and validated against the defined
grammar. The tokens from the formula are
split up into tokens and the information is
extracted to generate the code.
3.2 Xt\fL Template Parsing And Rules
Generation
Formula Parsing engine will provide the
input to XML parser, which is a ruleexpanding
planner, implemented in Java.
Rules have associated constraints that can
refer to knowledge bases (templates) that
are constructed from the input to the
generator. the planner matches parts of this
input to select appropriate templates (i.e.,
partial derivation trees) and then parse the
templates, generate rules and fills them with
data from the input.
. 3.3 Code Generation
This is where the heavy lifting happens.
This involves reading the XML rules,
selecting the appropriate data; bind it into a
proper format. More than one template can
be used to generate code for any given
class; the default templates may be used, or
a customized version may be used,
depending on configuration.
4. 0 MAFCOG 1.0 ARCHITECTURE:
As shown in Figure 1.2, MAFCOG 1.0
typically contains three layers Formula
j

:
I
1 "tOR~ ~.¥Y I' "S 't',:. .•••.•' " " " .. ',ni"' C~1"t''Yi:t.. xU ")"3 .
}.fA FCOG 1.0A Generic Code Generator For .~!:;!het1latical Functions
Parsing Layer, XML Parsing Layer, Code Expr: = Dumber
Generation Layer as described below.
4.1 Formula Parsing Layer
expr '+' expr
'expr '-' expr
expr ,*, expr
expr'Z'expr
The formula for which the code is
required to be generated is parsed and
validated against the defined grammar rules.
number:= digit+('.' Digit+)?
Digit.=tu'" 1'1'2'1'3';'4'1'5'1'6'1'7'1'8'1'9'
[7]
For parsing the formula and populate the JavaCC: JavaCC available for free, is a
data structures with the formula tokens, the parser generator It provides a Java
Grammar files and associated template
files will be used and data is populated.
The formula parsing includes following
analysis:
4.1.1 Lexical Analysis:
Language extension for specifying a
programming language's grammar. JavaCC
allows us to define grammar in a fashion
similar tc EBNF, making it easy to translate
EBNF grammar into the JavaCC format. [6]
Lexical analysis takes a cursory look at the
input data and divides .into" proper tokens.;
Tokens examples in mathematical
expression include. variable, symbols such
as IT numbers etc.
4.1.2 Syntactic analysis (Parsing):
During Syntactic analysis, a parser extracts
meaning from the program source code by
ensuring the syntactical correctness of input
data. During syntactic analysis a compiler
examines the input with respect to the rules
defined in the language's grammar. If any
rule is violated, the compiler. displays an
error message. A grammar rule should be
specified unambiguously and in entirety
with the EBNF (Extended Backus-Naur-
Form). Following grammar rules for small
language that describes basic. arithmetic
expression:
4.2. XlVILParsing Layer
Tasks fer parsing specifications and
generating code are executed In a
straightforward process presented in
figure 1.3 :-elow. The source code generator
that uses :::e rules to select the appropriate
data populated from templates and
assembles :~em into source code and writes
out the soi.-ce code
The XML parsing layer is broken out into
following c ompcnents
"," ,=' ." fit ",'

.
r
r -
;;-
"
.r-
r
r
r:
,
;.
!'r
~r
• r
j'
I I
I
!
~ I"'"
,
I"'"
r:
r:
r
----
Formula
D..r.nlUon
XMI..Pars.ng I..ayer .
XMt.. Templates
, Parsing
.S:
Ruks
.
r
- j~ ~.
•••
4.2.1 Formula PI1T.\'I!TEngine Out Put:
The Data Structures containing the details
of the formula are extracted and provided as
input to the X~tL reader and parser. The
XML reader and parser will read templates
accordingly for generating the code. The
Out put from Formula Parser engine
includes the detnil s such as "Target
Language", Tokcns, Operands used,
Mathematical operators (Power, Square,
Square Root etc.)
4.2.2 TII(~XML
Parser:
This' part generates two things:
• A programm i:1g language
.capable of complex logic;
··1encra~~. c- .. -
'... . . ':r,,!!\ m;.:1~~;I' .
Proceedings of the National Conference on
Computing and Applications (NACCA '06)
National Engineering College. Kovtlpatti, Tamil Nadu
.~rc.... I
. .. , E'~~'~"':-i' ;
-u: ....,.,
C4de Genera ••on Layer
Temporary templates will be dynamically
created to store the code blocks for further
use as explained above.
',4.2.4 The logic module that generates
rules: .
After reading the XML templates in the
XML documents and navigating through it,
MAFCOG LO generator will pick up
information in different parts of the
templates to select and assemble the
templates into proper code thus generating
the pseudo-code after reading the
Document Reader And .. APPLICATION nude's target-language
• An XML utiliry for the language ..
For MAFCOG 1,0 the language to be used
as "Java" and X~IL utility as "JDOM"_ The
XML document reader-and parser will read
out the Out put from Formula Parser engine.
and parse the Xl\IL templates accordingly
4.2.3 The template lihrary:
The XML Templates. which will be read, are as
• Mathkules
• JavaDOC
• Control Structures.
CeneriJre :
- :. attribute .The code blocks generated will be
. stored .in temporary templates in template
that is library for further use.
TtmpIL~!..~
XMLParSing L!'rer
Fig 1.3 XML Parsing Layer
4.3. Code Generation Layer
Code Generation Layer
Source Code Generator will read the XML
rules, selecting the appropriate data
structures populated from XML templates,
inserting the proper variables into the
365 ~I
\

I \
MA FCOG 1.0 A Generic Code Generator For Mathematical Functions
templates and nesting the templates inside
each other as needed.
S.O USER INTERFACE DESIGN
The user interface shows command
hierarchy that defines following major
system menu categories. The menu bar, the
tool palette and all sub functions. The GUI
contains the button hierarchy as: to enter the
mathematical formula, update; save and
undo the changes. The tool bar contains the.
, !Ii
Figl.4 MAFCOG 1.0 GUI
The rightmost window is used to initialize
the variables in order to test the generated
JAVA code. .
6. USING MAFCOG 1.0 ,.
~ The design of MAFCOG 1.0 is founded on
,..,--.xibility. It can serve small organization
-- intent on having quality. coding
"~ctices consistently. implemented
r- ·,••roughout the organization." Improved
coding practices will be quickly propagated.
,.... and will stay with the organization even
if star programmers have left. Knowledge
-- stays and accumulates with the
,.. organization, neatly encapsulated in the
template library.
r- 7.0 CONCLUSION
r- The premise of a code generator is that it
pushes code re-use much further without
~\366
icons for code generation, edition, save, and
test the developed code. The menu bar
contains the operation as code generation,
edition, save and test the developed code.
Middle window is reserved to display the
JAVA code 'generated for specified
mathematical expression. Lower window is
used to display messages, exceptions and
evallHition of execution results
contravening the OOP approach; the
templates must follow proper OOP
structure. We are trying to create better
code, not more bad code faster. While
having a class should allow for code that is
more useful we still have to build the class
that will do this. MAFCOG 1.0 will give us
the ability to build an OOP class that has
less error and follows coding standards that
have been building over the years.
8. REFERENCES
[I] Generative Programming (http://wwwia.tu-ilmenau.de/-czam'generate/engl.html)
[2] The xJen Architecture by Michel Katz
(http://www.codegeneration.netltikiread_article.php?
artic1eId=32)
[3] Generative and Component-Based
Software Engineering (http://www-ia.tuilmenau.de/-czarn/generate/engl.html)
[4] Generative Programming: Modem
Techniques to Automate Repetitive
Programming Tasks: MSDN Magazine,
December 200 I
[5] Generative Programming - Methods,
Tools, and Applications by Krzysztof
Czarnecki and Ulrich W. Eisenecker.
(http://www.generative-programming.org)
[6] https://javacc.dev.java.net