Methods and apparatus for automatic translation of a computer program language code

US 20090313613A1
(19) United States
(12) Patent Application Publication (10) Pub. No.: US 2009/0313613 A1
Ben-Artzi et al. (43) Pub. Date: Dec. 17, 2009
(54) METHODS AND APPARATUS FOR
AUTOMATIC TRANSLATION OF A
COMPUTER PROGRAM LANGUAGE CODE
(75) Inventors: Guy Ben-Artzi, Palo Alto, CA
(US); Yotam Shacham, Palo Alto,
CA (U S); Yehuda Levi, Rishon
LeZion (IL); Russell W. McMahon,
Woodside, CA (US); Amatzia
Ben-Artzi, Palo Alto, CA (U S);
Alexei Alexevitch, HertZlia (IL);
Alexander Glyakov, Petach Tikva
(IL); Tal Lavian, Sunnyvale, CA
(Us)
Correspondence Address:
CONNOLLY BOVE LODGE & HUTZ LLP
1875 EYE STREET, N.W., SUITE 1100
WASHINGTON, DC 20006 (US)
(73) Assignee: Real Dice Inc., Carson City, NV
(Us)
(21) Appl. No.: 12/484,622
(22) Filed: Jun. 15, 2009
Related US. Application Data
(60) Provisional application No. 61/ 132,264, ?led on Jun.
16, 2008.
Publication Classi?cation
(51) Int. Cl.
G06F 9/45 (2006.01)
(52) US. Cl. ...................................................... .. 717/137
(57) ABSTRACT
Embodiments of the methods and apparatus for automatic
cross language program code translation are provided. One or
more characters of a source programming language code are
tokeniZed to generate a list of tokens. Thereafter, the list of
tokens is parsed to generate a grammatical data structure
comprising one or more data nodes. The grammatical data
structure may be an abstract syntax tree. The one or more data
nodes of the grammatical data structure are processed to
generate a document object model comprising one or more
portable data nodes. Subsequently, the one or more portable
data nodes in the document object model are analyzed to
generate one or more characters of a target programming
language code.
I Start l
802 Tokenize one or more characters of a source programming
language code to generate a list of tokens
804 Parse the list of tokens to generate an abstract syntax tree
806 Process the abstract syntax tree to generate a document
object model
808 Analyze one or more nodes in the documents object model
to generate one or more characters of a target
programming language code
I Stop l

Patent Application Publication Dec. 17, 2009 Sheet 1 0f 8 US 2009/0313613 A1
nmow
HU@25 0
00?
68:93
mFNo
LOHMLQCQ
38m
/ 52mm hmNEmxE.

Patent Application Publication Dec. 17, 2009 Sheet
I Start l
30f8 US 2009/0313613 A1
Select a feature of the source programming ianguage
l
Is the selected feature or
the target programming
language?
304
a similar feature present in

302
V
Retain the selected
feature
Remove the feature of the source
programming language
l
Is there any other feature
Yes in the source
programming language?
FIG. 3
308
310

.wOE
EQCSZ EcoEEEuQQqO 69:52
('0 + N
@52 #665535602
E5
Qwow
BNEBS. Eim comwmaxw wwim wow
or
Now

mom
uw3w0omm 6$‘25:.5395292 30 EEE
nvom
Em5i“ wméuei EcbEomiEwmEwEa mxm
mwom
owcm
AU
nwow EmE 6EQ2E2cQ8wQ0Q EQEQZ c5o:Eu8u3< 0 6852 cEo0o5E6mw!
mwow

hwow
UoQwQoQw
w3EmEZ . 5F5
coz?owm mw 35om: 25
houmtmcmwo
N00
TE5mci: Bnoowoomw cothiomn mo 5Low:w 3z EwoL@Eamsm>Qmz x C

M
M.NoE
U m
M3m
m
w
m38,%8
Em:N5E
m3EmEz .
m
Patent Application Publication
muoo
AENa5m9Ui: 0
:orEmEmQ ww .3ow5: 3:

( Start )
V
802 Tokenize one or more characters of a source programming
ianguage code to generate a list of tokens
v
804 Parse the list of tokens to generate an abstract syntax tree
V
806 Process the abstract syntax tree to generate a document
object model
V
808 Anatyze one or more nodes in the documents object model
to generate one or more characters of a target
programming language code
V
( Stop |
FIG. 8

US 2009/0313613 A1
METHODS AND APPARATUS FOR
AUTOMATIC TRANSLATION OF A
COMPUTER PROGRAM LANGUAGE CODE
CROSS-REFERENCE TO RELATED
APPLICATION
[0001] This application draws priority from US. Provi
sional Patent Application No. 61/132,264, ?led on Jun. 16,
2008, and hereby incorporated by reference herein in its
entirety.
FIELD OF THE INVENTION
[0002] The invention relates to computer aided translation
of programming languages and more speci?cally the inven
tion relates to real-time automatic translation of computer
programming language code.
BACKGROUND OF THE INVENTION
[0003] Various users across the globe communicate or per
form various activities on computer and device netWorks.
Moreover, the users interact With each other through the net
Works, such as the Internet. Typically, the users use devices
like personal computers to interact over the Internet. The
users can interact from various Internet Websites or social
networking sites, for example, Facebook, Myspace, Hi5, and
Orkut etc. Recently, the development in mobile devices such
as cell phones, smartphones and PDAs, computers, laptops
and the like has enabled them to be used for performing
various activities on netWorks such as the Internet. Moreover,
the mobile devices can be used for real-time interaction With
other users on the netWork. The interaction or communication
can be in the form of chatting, playing interactive online
games, broWsing, shopping, music, video, banking, business
and the like.
[0004] The rapid pace of innovation in technology has gen
erated various types of devices and platforms. Moreover, the
number of devices is increasing rapidly. For example, there
are various operating systems available for the devices such
as WindoWs, Linux, Macintosh, and Symbian, etc. Moreover,
a large number of J 2ME platforms are available for the mobile
devices such as cell phones. Furthermore, the mobile devices
have a Wide rage of capabilities in terms of screen siZe, screen
type, screen resolution, processor, and memory etc. The
applications for these devices have to be developed based on
their platforms. Therefore, each application has to be ported
to other platforms. For example, in case of computer games
the programming languages typically used are JAVA, C#,
C++, Action Script, and the like. Therefore, an application
developed in Action Script programming language may have
to be ported to other programming language When not sup
ported by a device platform. Further, neW applications are
being continuously developed for different device platforms.
[0005] Typically, the programming code of an application
is translated manually from one programming language to
another. HoWever, manual translation requires speci?c and
in-depth knoWledge of the programming languages of the
different operating systems. Moreover, manual translation is
a very time consuming process. Furthermore, the program
ming languages are constantly developed or get modi?ed.
Moreover, the applications have to be developed on speci?c
development platforms compatible With the programming
language used for development and the operating system of a
device. As a result, a completed revision of the application
Dec. 17, 2009
code may be required to make the interaction possible. Some
mechanisms, such as emulation of applications are available
to support multiple devices. HoWever, the existing mecha
nisms generate application program codes that are large or
require heavy processing time. The problem is compounded
With the continuously increasing number of device platforms
and technology.
[0006] A mechanism is therefore desirable to automate the
task of cross translating one programming language into
another.
SUMMARY
[0007] The invention provides a method for automatic
translation of a computer program language code. The
method comprises tokeniZing one or more characters of a
source programming language code to generate a list of
tokens. The list of tokens is parsed to generate an abstract
syntax tree, Wherein the abstract syntax tree comprises one or
more data nodes. Thereafter, the one or more data nodes of the
abstract syntax tree are processed to generate a document
object model, Wherein the document object model comprises
one or more portable data nodes. Subsequently, the one or
more portable data nodes in the document object model are
analyZed to generate one or more characters of a target pro
gramming language code.
[0008] The invention further provides a computer-imple
mented method for automatic translation of a computer pro
gram language code for real-time applications. The computer
implemented method comprises tokeniZing one or more char
acters of a source programming language code to generate a
list of tokens based on a set of expression rules. The list of
tokens is parsed to generate an abstract syntax tree based on a
set of grammar rules, Wherein the abstract syntax tree com
prises one or more data nodes. Thereafter, the one or more
data nodes of the abstract syntax tree are processed to gener
ate a document object model, Wherein the document object
model comprises one or more portable nodes. Subsequently,
the one or more portable nodes of the document object model
are analyZed to generate one or more characters of a target
[0009] The present invention further provides an apparatus
for automatic translation of a computer program language
code. The apparatus comprises a tokeniZer con?gured token
iZe one or more characters of a source programming language
code to generate a list of tokens. Further, the apparatus com
prises a parser con?gured to parse the list of tokens to gener
ate an abstract syntax tree, Wherein the abstract syntax tree
comprises one or more data nodes; a generator con?gured to
process the one or more data nodes of the abstract syntax tree
to generate a document object model, Wherein the document
object model comprises one or more portable data nodes; and
an analyZer con?gured to process the one or more portable
data nodes in the document object model to generate one or
more characters of a target programming language code.
[0010] The present invention further provides a computer
readable medium having computer-executable instructions
for performing a method for language translation of a com
puter program code, said method comprising the steps of:
tokeniZing one or more characters of a source programming
language code to generate a list of tokens based on a set of
expression rules; parsing the list of tokens to generate an
abstract syntax tree based on a set of grammar rule, Wherein
the abstract syntax tree comprises one or more data nodes;
processing the one or more data nodes of the abstract syntax

US 2009/0313613 A1
tree to generate a document object model, Wherein the docu
ment object model comprises one or more portable nodes;
and analyzing the one or more portable nodes of the document
object model to generate one or more characters of a target
[0011] The present invention further provides a computer
implemented system for automatic translation of a computer
program language code, comprising: means for tokeniZing
one or more characters of a source programming language
code to generate a list of tokens; means for parsing the list of
tokens to generate an abstract syntax tree, Wherein the
abstract syntax tree comprises one or more data nodes; means
for processing the one or more data nodes of the abstract
syntax tree to generate a document object model, Wherein the
document object model comprises one or more portable data
nodes; and means for analyZing the one or more portable data
nodes in the document object model to generate one or more
characters of a target programming language code.
BRIEF DESCRIPTION OF THE DRAWINGS
[0012] Having thus described the invention in general
terms, reference Will noW be made to the accompanying
draWings, Which are not necessarily draWn to scale, and
Wherein:
[0013] FIG. 1 is a functional overvieW of an apparatus for
automatic translation of a source programming language
code to a target programming language, in accordance With
an embodiment of the invention;
[0014] FIG. 2 illustrates an exemplary feature map for a
programming language code, in accordance With an embodi
ment of the invention;
[0015] FIG. 3 illustrates a ?owchart diagram for normaliZ
ing a source programming language code, in accordance With
an embodiment of the invention;
[0016] FIG. 4 illustrates operation of a tokeniZer, in accor
dance With an embodiment of the invention;
[0017] FIG. 5 illustrates operation of a parser, in accor
[0018] FIG. 6 illustrates operation of a generator, in accor
[0019] FIG. 7 illustrates operation of an analyZer, in accor
dance With an embodiment of the invention; and
[0020] FIG. 8 illustrates a ?owchart diagram for translation
of a source programming language code to a target program
ming language, in accordance With an embodiment of the
invention.
DETAILED DESCRIPTION OF THE INVENTION
[0021] Illustrative embodiments of the invention noW Will
be described more fully hereinafter With reference to the
accompanying draWings, in Which some, but not all embodi
ments of the invention are shoWn. Indeed, the invention may
be embodied in many different forms and should not be
construed as limited to the embodiments set forth herein;
rather, these embodiments are provided so that this disclosure
Will satisfy applicable legal requirements. Like numbers refer
to like elements throughout.
[0022] FIG. 1 is a functional overvieW of an apparatus 104
for automatic translation of a source programming language
code to a target programming language. As shoWn, device
102a and 1021) may communicate to interact and share infor
mation. Devices 102a and 1021) can be, but not limited to a
mobile phone, a laptop, a personal computer, a smartphone
Dec. 17, 2009
and the like. In an embodiment of the invention, devices 1 02a
and 10219 are mobile devices communicating through net
Work 100. Similarly, various other devices can be connected
over netWork 100. Devices 102a and 1021) may interact With
each other by using applications such as chatting, games,
messaging, and so forth. Devices 102a-b may have different
hardWare and softWare platforms. Examples of softWare plat
forms include operating systems such as WindoWs, Linux,
Macintosh, Symbian, and so forth. Moreover, devices 102a-b
may have different hardWare such as the screen siZe, screen
resolution, audio and video functionality, processors and so
forth. Therefore, the applications executing on the devices
102a and 1021) have to be compatible With the operating
systems and platform of these devices.
[0023] The compatibility of the application may be main
tained by translating the programming language code of the
application based on the platforms of device 10211 to 1021).
Examples of the application include softWare games or rich
media applications. In case of softWare games or rich media,
the development environment can be typically divided into
four object oriented programming languages: C++, JAVA,
Action Script, and C#. Therefore, translation of programming
language code is generally required across these object ori
ented programming languages. Moreover, these object ori
ented programming languages share various similar features
and thus can be translated into one another. For example, each
of the above programming languages share the features such
as ‘if statement’, ‘arguments’, ‘binary expressions’, and so
forth. Exemplary feature map for the above mentioned pro
gramming languages is explained in detail in conjunction
With FIG. 2.
[0024] Apparatus 104 automatically translates the pro
gramming language code of the application for devices 102a
and 10219. As shoWn in FIG. 1, apparatus 104 comprises a
tokeniZer 106, parser 108, a generator 110, and an analyZer
112.Apparatus 104 is hereinafter referred to as translator 104.
TokeniZer 106 transforms streams of characters from the
source programming language code into a list of tokens. In an
embodiment of the invention, the source programming lan
guage is a computer game development language. Exemplary
operation of tokeniZer 106 is explained in detail in conjunc
tion With FIG. 4. Parser 108 analyZes the list of tokens gen
erated by tokeniZer 106 to determine a grammatical data
structure. The grammatical data structure is de?ned on the
basis of the programming languages to be cross-translated.
The grammatical data structure is hereinafter referred to as an
Abstract Syntax Tree (AST). Exemplary operation of parser
108 is explained in detail in conjunction With FIG. 5. Gen
erator 110 operates on the AST generated by parser 108 to
generate a Document Object Model (DOM). The DOM is a
simpli?ed data structure of the AST. Exemplary operation of
generator 110 is explained in detail in conjunction With FIG.
6. The DOM is transformed by analyZer 112 into program
ming code of a target programming language. Exemplary
operation of analyZer 112 is explained in detail in conjunction
With FIG. 7. Consequently, the programming code of the
source programming language is translated into the program
ming code of the target programming language by translator
104. In an embodiment of the invention, the source program
ming language is a computer game development language.
[0025] FIG. 2 shoWs an exemplary feature map 202 for
programming languages. Different programming languages
comprise different features. HoWever, various features in the
object oriented programming languages may be similar or

US 2009/0313613 A1
common. Generally, a feature in one programming language
can be emulated in other programming languages. For
example, a feature in Action Script 3 (AS3) programming
language, the ‘star notation’ can be emulated by the ‘void*’
feature in C++ or ‘object’ feature in JAVA programming
language. As another example, ‘pure virtual’ feature in C++
programming language can be emulated by ‘assert(false)’
feature in AS3 programming language. Moreover, the fea
tures of one programming language can be mapped equiva
lently to features of the other programming languages With
out emulation. The programming languages that have
common features or the features can be mapped to each other
are referred to as equivalent programming languages.
[0026] As shoWn, in FIG. 2, feature map 202 is draWn for
C++, JAVA, Action Script 3 (AS3), and C# programming
languages. However, feature map 202 is not limited to these
programming languages only. Feature map 202 comprises
C++ features 204, JAVA features 206, AS3 features 208, and
C# features 210. C++ features 204 comprise C++ speci?c
features 212. Similarly, JAVA speci?c features 214, AS3 spe
ci?c features 216, and C# speci?c features 218 are the fea
tures that are speci?c to these programming languages only.
Examples of C++ speci?c features 212 include, but are not
limited to ‘operator overloading, ‘function overloading’,
‘templates’ and so forth. Examples of JAVA speci?c features
214 include, but are not limited to ‘function overloading’,
‘generics’, ‘iterators’ and so forth. Examples of AS3 speci?c
features 216 include, but are not limited to ‘rest notation,
‘ start expression, ‘for-in statement’ and so forth. Examples of
C# speci?c features 218 include, but are not limited to ‘re?ec
tion’ and so forth. Programming language speci?c features
such as C++ speci?c features 212, JAVA speci?c features 214,
AS3 speci?c features 216, and C# speci?c features 218, may
require different run-time environment requirements. For
example, emulating generic data types for a target program
ming language may require signi?cant code space. Similarly,
emulation of a target programming language code that does
not involve the concept of threads may require huge process
ing overhead. As yet another example, LISP is a program
ming language that contains various high level functional
ities. Moreover, the design of LISP programming language is
different from programming languages such as JAVA, C++,
C#, and the like. Therefore, emulation of a programming code
Written in LISP may require huge overhead for programming
language code space and processing resources. The program
ming languages that do not have common features or the
features cannot be mapped to each other are referred to as
non-equivalent programming languages.
[0027] As shoWn in FIG. 2, feature map 202 comprises
common features 220 for each of the programming lan
guages. Common features 220 are the features that are com
mon to these programming languages. Therefore, common
features 220 can be cross-translated across these program
ming languages. In an embodiment of the invention, common
features 220 can be emulated across these programming lan
guages. Examples of common features 220 include, but are
not limited to ‘access visibility’, ‘arguments’, ‘Boolean lit
eral’, ‘member’, ‘method’, ‘sWitch statement’, ‘if statement’,
and so forth. Common features 220 can be translated betWeen
the programming languages Without losing performance, i.e.,
space usage or processing resources and processing time.
[0028] Analysis of common features 220 enable the assess
ment of the portability of the programming languages. More
over, the object oriented programming languages can be
Dec. 17, 2009
made portable by analyZing the common features 220 and
normalizing the programming languages. The normalizing of
programming languages is discussed in conjunction With
FIG. 3.
[0029] FIG. 3 illustrates a ?owchart diagram for normaliZ
ing the source programming language according to an
embodiment of the invention. The source programming lan
guage and the target programming language include features
or functions that enable the development of rich media con
tent applications. In an embodiment of the invention, the
source programming language and the target programming
language are object oriented programming languages. The
source programming language and the target programming
language may have some common features. Further, some
features in the source programming language may be equiva
lent to the features of the target programming language. The
features in the source programming language that are com
mon or equivalent to the features in the target programming
language are hereinafter referred to as equivalent features.
Moreover, some feature of the source programming language
may not be available or supported in the target programming
language. The features of the source programming language
that are not available or supported in the target programming
language are hereinafter referred to as non-equivalent fea
tures. In an embodiment of the invention, the features and
corresponding de?nitions of the features for the source and
the target programming languages are maintained in a data
base. The source programming language is normaliZed based
on the equivalent and non-equivalent features. In an embodi
ment of the invention, the programming languages are nor
maliZed by a normaliZer. The normaliZer is a module in trans
lator 104, Which processes the features of the source and the
target programming languages.
[0030] At step 302, a feature of the source programming
language is selected. Thereafter, at step 304 it is determined if
the feature is available in the target programming language.
At step 306, the selected feature from the source program
ming language is matched With the features of the target
programming language. Therefore, in case an equivalent fea
ture is available in the target programming language, then the
equivalent feature is retained. In an embodiment of the inven
tion, the features are matched on the basis of feature de?ni
tion. In another embodiment of the invention, the features are
matched based on semantic meaning of the de?nition. In yet
another embodiment of the invention, the features are mapped
based on the output received from execution of the features.
[0031] In case the feature is non-equivalent to features in
the target programming language, then the non-equivalent
feature is removed, at step 308. In an embodiment of the
invention, the non-equivalent features are replaced With an
equivalent feature of the target programming language.
[0032] Subsequently, at step 310 it is determined if other
features in the source programming language required to be
processed. Thereafter, the above steps are performed itera
tively to process all the features of the source programming
language. As a result, the source and the target programming
languages are made equivalent and can be cross-translated.
[0033] FIG. 4 illustrates operation of tokeniZer 106, in
accordance With an embodiment of the invention. As shoWn,
tokeniZer 106 comprises a collection of regular expression
rules 404. In an embodiment of the invention, tokeniZer 106 is
a lexical analyZer. Regular expression rules 404 de?ne a ?nite
state machine for tokeniZer 1 06. Regular expression rules 404

US 2009/0313613 A1
represent patterns that may be contained in text analyzed by
tokeniZer 106. Example de?nitions of various types of regular
expressions may be:
Identi?er: is a sequence of letters ‘a’—‘Z’ or ‘A’—‘Z’.
Assignment operator: is the character ‘I’
Addition operator: is the character ‘+’
Semicolon: is the character ‘;’
Number: is a sequence of characters ‘0’—‘9’
[0034] The programming code of source programming lan
guage is processed as stream of characters by tokeniZer 106.
An input stream 402 of characters represent an expression in
the source programming code: ‘Sum:2+3;’. As shoWn in
FIG. 2, input stream 402 comprises the regular expression as
input characters ‘S’,‘u’,‘m’,‘:’,2,‘+’,3, and ‘;’. Input stream
402 is scanned one input character at a time by tokeniZer 106.
The scanned input stream 402 is processed on the basis of
regular expression rules 404. As a result, a list of tokens 406
is generated. Therefore, every time a rule in regular expres
sion rules 404 is completed a neW token is added to the output
list.
[0035] In an embodiment of the invention, list of tokens 406
comprises columns of token list 408a and token type list
4081). Token list 408a comprises the tokens generated from
input stream 402 and the token type list 408!) comprises the
description for the type of tokens. Tokens in list of tokens 406
are categorized block of text. Referring to list of tokens 406,
the token ‘Sum’ in tokens 40811 is de?ned by tokeniZer 106 as
an ‘identi?er’ in type 4081). Similarly, the complete program
ming code of the source programming language can be pro
cessed to form a list of tokens. Subsequently, list of tokens
406 is processed by parser 108 to generate structured infor
mation.
[0036] FIG. 5 illustrates operation of parser 108, in accor
dance With an embodiment of the invention. List of tokens
406 generated by tokeniZer 106 does not provide any infor
mation on contextual correctness of the tokens. Therefore, the
order of tokens in the list may not be contextually correct. For
example, the expression ‘Sum 3+:2;’ is not a correct expres
sion. HoWever, this expression can be processed by tokeniZer
106 to generate a list of tokens. Parser 108 analyZes list of
tokens 406 generated by tokeniZer 106. In an embodiment of
the invention, parser 108 performs syntactic analysis of list of
tokens 406. Parser 108 can implement top-doWn parsing, in
an embodiment of the invention. Therefore, tokens in list of
tokens 406 are consumed from left to right. In another
embodiment of the invention, parser 108 can implement bot
tom-up parsing. Therefore, parser 108 locates the basic ele
ments in list of tokens 406 and then locates the elements
containing the basic elements.
[0037] Parser 108 analyZes list of tokens 406 to generate an
Abstract Syntax Tree (AST) 502. AST 502 is a grammatical
data structure and de?nes the relationship betWeen the tokens
in list of tokens 406. AST 502 is generated based on grammar
rules de?ned in parser 108. The grammar de?ned in parser
108 can be context-free grammar or attribute grammar.
[0038] Exemplary grammar rules in parser 108 include:
Assignment StatementQIdenti?eFExpression;
ExpressionQLiteral OR Binary Expression
Binary Expression—>Expression Operator Expression
LiteralQNumber OR Identi?er
Dec. 17, 2009
[0039] The arroWs in the above rules indicate the direction
of the pattern matching reduction. Therefore, based on the
above example a statement such as ‘ Sum:3+2’ is termed as an
assignment statement. Similarly, based on the above rules, the
statement ‘3+2’ is termed as a Binary Expression.
[0040] The grammar rules in parser 108 can be recursive.
Therefore, one or more rules may be applied recursively on an
expression to prepare AST 502. AST 502 comprises data
nodes 504. Data nodes 504 comprise a hierarchal data struc
ture that represents the structure of the program code. For
example, data node 504c comprises binary expression and
data nodes 504d, 504e, and 504f comprise number and opera
tor, Which are subsets of the binary expression. In an embodi
ment of the invention, the grammar rules can reference token
de?nition rules to de?ne data nodes of AST 502. Therefore,
AST 502 comprises structural information and relation
betWeen data nodes 504. In an embodiment of the invention,
parser 108 can be programmed based on the rules required for
analyZing list of tokens 406.
[0041] FIG. 6 illustrates operation of generator 110, in
accordance With an embodiment of the invention. Generator
110 operates on AST 602 to generate a Document Object
Model (DOM) 604. DOM 604 is a simpli?ed data structure of
AST 602. As shoWn in FIG. 6, AST 602 is an exemplary data
structure representation of a variable declaration in the Action
Script 3 (AS3) programming language. The variable declara
tion for this example in AS# programming language is ‘var
i:int;’.
[0042] Data node 60611 of AST 602 is referred to as the
parent node of data nodes 606b, 6060, and 606d. Generator
110 analyZes AST 602 to identify portable data nodes. Data
nodes 606a-d inAST 602 comprises meta structure and meta
data of the programming code. HoWever, the metadata may
not be required for generation of DOM 604, as the meta
structure is deduced from the other data nodes in AST 602.
Therefore, data node 606!) is removed by generator 110,
because data node 60611 is a declaration node and the meta
structure can be deduced from node 606a. Therefore, DOM
604 contains only portable data nodes from AST 602. As a
result, DOM 604 includes a simple data structure of the
programming code and is generic to any programming lan
guage. The above example explains the operation of genera
tor 110 from the perspective of AS3 programming language.
HoWever, the same process can essentially be performed on
anAST developed for any programming language code and is
not limited to any particular programming language code.
[0043] FIG. 7 shoWs operation of analyZer 112 according to
an exemplary embodiment of the invention. AnalyZer 112
processes a document object model to generate programming
code in the target programming language. AnalyZer 112 pro
cesses the structure of DOM 604 to translate the input code of
source programming language into an output code 702 cor
responding to the target programming language. Output code
702 is generated based on the features of the target program
ming language. For example, output code 702 may be ‘int i’
in case the target programming language is JAVA. AnalyZer
112 processes the portable data nodes of DOM 604 in a
standard depth ?rst manner. Therefore, as shoWn for DOM
604, portable data node 60611, which is the parent node, is
processed ?rst folloWed by portable data nodes 6060 and
606d.
[0044] AnalyZer 112 processes nodes 606 to generate
tokens corresponding to a DOM node in the target program
ming language code. In an embodiment of the invention, to

US 2009/0313613 A1
generate DOM of the target programming language, analyzer
112 executes functions that map betWeen the meta-structure
of the source programming language feature and the charac
ter stream of the target programming language. Therefore,
DOM 604 is parsed to generate an abstract syntax tree and
thereafter, the abstract syntax tree is converted to program
ming code of the target programming language by analyZer
112. In an embodiment of the invention, the processing by
analyZer 112 comprises recursive scanning of DOM 604 to
generate the target programming language code. Example
pseudo-code of functions that analyZer 112 executes for
translating DOM 604 to AS3 or Java are discussed beloW:
Example 1
Functions for Conversion of DOM 604 to Java Pro
gramming Language
[0045]
1 Function DeconstructASTToJava(node)
2 {
3 If (node is oftype Declaration)
4 Print(DeconstructDeclarationToJava(node))
5 Else
76
8 Function DeconstructDeclarationToJava (node)
9
10 Print(DeconstructType(node.getChild(1)));
11 Print(“ “);
12 Print(DeconstructNaIne(node.getChild(0)));
13 Print(“;”);
14 }
[0046] AnalyZer 112 may run the functions in example 1 on
DOM 604 to generate output code 702. As shoWn in example
1, the function DeconstructASTToJava(node) is de?ned in
the lines 1 to 7. This function reads the parent node of DOM
604, Which is portable data node 606a and calls the function
DeconstructDeclarationToJava(node) de?ned in the lines 8 to
14, When portable data node 60611 is a type of declaration. The
function DeconstructDeclarationToJava(node) reads the
child nodes in DOM 604, Which are portable data nodes 6060
and 606d. Subsequently, the function DeconstructDeclarati
onToJava(node) generates output code 702. In this case out
put code 702 is ‘int i; ’, Which is a proper integer declaration in
JAVA programming language. Similarly, various other func
tions can be Written to analyZe other types of data nodes in the
tree structure of DOM 604 and completely translate source
programming language code to target programming language
code.
Example 2
Functions for Conversion of DOM 604 to Action
Script3 Programming Language
[0047]
1 Function DeconstructASTToAS3 (node)
2 {
3 If (node is oftype Declaration)
4 Print(DeconstructDeclarationToAS3 (node));
5 Else
Dec. 17, 2009
-continued
6
7
8 Function DeconstructDeclarationToAS3 (node)
9
10 Print(“var ”);
11 Print(DeconstructType(node.getChild(1)));
12 Print(“:“);
13 Print(DeconstructNaIne(node.getChild(2)));
14 Print(“;”);
15 }
[0048] AnalyZer 112 may run the functions in example 2 on
DOM 604 to generate output code 702. As shoWn in example
2, the function DeconstructASTToAS3(node) is de?ned in
the lines 1 to 7. This function reads the parent node of DOM
604, Which is portable data node 606a and calls the function
DeconstructDeclarationToAS3(node) de?ned in the lines 8 to
15, When portable data node 60611 is a type of declaration. The
function DeconstructDeclarationToAS3(node) reads the
child nodes in DOM 604, Which are portable data nodes 6060
and 606d. Subsequently, the function DeconstructDeclarati
onToAS3(node) generates output code 702. In this case out
put code 702 is ‘var: int i;’, Which is a proper integer decla
ration in AS3 programming language. Similarly, various
other functions can be Written to analyZe other types of data
nodes in the tree structure of DOM 604 and completely trans
late source programming language code to target program
ming language code. In an embodiment of the invention,
DOM 604 can be analyZed to generate an output code in any
other equivalent programming language.
[0049] FIG. 8 illustrates a ?owchart diagram for cross
translation of the source programming language code to a
target programming language code, in accordance With an
embodiment of the invention. At step 802, an input stream of
one or more characters of a source programming language
code is received at tokeniZer 106. Subsequently, the input
stream is analyZed lexically to generate a list of tokens.
Examples of the characters in the input stream include alpha
bets, numerals, special characters, mathematical operators,
their combination and so forth. In an embodiment of the
invention, the characters are processed sequentially to gener
ate the list of tokens.
[0050] The order of tokens in the list of tokens may not be
contextually correct. Therefore, the list of token is analyZed
syntactically by parser 108 to generate a grammatical data
structure, at step 804. In an embodiment of the invention, the
grammatical data structure is a hierarchical data structure and
is referred to as anAbstract Syntax Tree (AST). Thereafter, at
step 806, the AST is processed by generator 110 to generate a
document object model. Document object model is a simpli
?ed grammatical data structure in a hierarchical data structure
format. Subsequently, the document object model is pro
cessed by analyZer 112 to generate a target list of tokens. The
target list of tokens is thereafter processed by analyZer 112 to
generate the target programming language code, at step 808.
[0051] Embodiments of the invention are described above
With reference to block diagrams and schematic illustrations
of methods and systems according to embodiments of the
invention. It Will be understood that each block of the dia
grams and combinations of blocks in the diagrams can be
implemented by computer program instructions. These com
puter program instructions may be loaded onto one or more
general purpose computers, special purpose computers, or

US 2009/0313613 A1
other programmable data processing translator to produce
machines, such that the instructions Which execute on the
computers or other programmable data processing translator
create means for implementing the functions speci?ed in the
block or blocks. Such computer program instructions may
also be stored in a computer-readable memory that can direct
a computer or other programmable data processing apparatus
to function in a particular manner, such that the instructions
stored in the computer-readable memory produce an article of
manufacture including instruction means that implement the
function speci?ed in the block or blocks. Furthermore, such
computer program instructions may be made available for
doWnload and/or doWnloaded over a communication net
Work.
[0052] While the invention has been described in connec
tion With What is presently considered to be the most practical
and various embodiments, it is to be understood that the
invention is not to be limited to the disclosed embodiments,
but on the contrary, is intended to cover various modi?cations
and equivalent arrangements included Within the spirit and
scope of the appended claims.
[0053] This Written description uses examples to disclose
the invention, including the best mode, and also to enable any
person skilled in the art to practice the invention, including
making and using any devices or systems and performing any
incorporated methods. The patentable scope the invention is
de?ned in the claims, and may include other examples that
occur to those skilled in the art. Such other examples are
intended to be Within the scope of the claims if they have
structural elements that do not differ from the literal language
of the claims, or if they include equivalent structural elements
With insubstantial differences from the literal languages of
the claims.
We claim:
1. A method for automatic translation of a computer pro
gram language code, comprising:
tokenizing one or more characters of a source program
ming language code to generate a list of tokens;
parsing the list of tokens to generate a grammatical data
structure, Wherein the grammatical data structure com
prises one or more data nodes;
processing the one or more data nodes of the grammatical
data structure to generate a document object model,
Wherein the document object model comprises one or
more portable data nodes; and
analyzing the one or more portable data nodes in the docu
ment object model to generate one or more characters of
a target programming language code.
2. The method of claim 1, Wherein the grammatical data
structure comprises an abstract syntax tree.
3. The method of claim 1, Wherein the source programming
language and the target programming language are object
oriented programming languages.
4. The method of claim 1 further comprising normalizing
the source programming language, Wherein one or more fea
tures of the source programming language are managedbased
on one or more features of the target programming language.
5. The method of claim 4, Wherein the source programming
language and the target programming language comprise one
or more equivalent features.
6. The method of claim 4, further comprising doWnloading
computer-executable instructions that, if executed by a com
puting device, cause the computing device to execute said
normalizing.
Dec. 17, 2009
7. The method of claim 4, Wherein normalizing the source
programming language comprises:
identifying one or more non-equivalent and one or more
equivalent features from the one or more features in the
source programming language, Wherein the one or more
non-equivalent features and the one or more equivalent
features are identi?ed based on the one or more features
of the target programming language; and
removing the one or more non-equivalent features of the
source programming language.
8. The method of claim 4 Wherein normalizing the source
programming language comprises:
identifying one or more non-equivalent features from the
one or more features in the source programming lan
guage, Wherein the one or more non-equivalent features
are identi?ed based on the one or more features of the
target programming language; and
replacing the one or more non-equivalent features With the
one or more equivalent features of the source program
ming language.
9. The method of claim 4 further comprising emulating the
source programming language, Wherein one or more non
equivalent features of the source programming language are
emulated.
10. The method of claim 1, Wherein tokenizing comprises
processing the one or more characters of the source program
ming language code based on a set of expression rules.
11. The method of claim 1, Wherein parsing comprises
processing the list of tokens based on a set of grammar rules.
12. The method of claim 1, Wherein processing the one or
more data nodes of the grammatical data structure comprises:
scanning the one or more data nodes in the grammatical
data structure to identify one or more metadata nodes;
and
removing the one or more metadata nodes to generate the
one or more portable data nodes.
13. The method of claim 1, Wherein analyzing the one or
more portable data nodes in the document object model com
prises:
processing recursively the one or more portable data nodes
in the document object model to generate a target list of
tokens; and
analyzing the target list of tokens to generate the one or
more characters of the target programming language
code.
14. The method of claim 1, further comprising doWnload
ing computer-executable instructions that, if executed by a
computing device, cause the computing device to execute
said tokenizing.
said parsing.
said processing.
17. An apparatus for automatic translation of a computer
program language code, the apparatus comprising.
a tokenizer con?gured to tokenize one or more characters
of a source programming language code to generate a
list of tokens;

US 2009/0313613 A1
a parser con?gured to parse the list of tokens to generate a
grammatical data structure, Wherein the grammatical
data structure comprises one or more data nodes;
a generator con?gured to process the one or more data
nodes of the grammatical data structure to generate a
document object model, Wherein the document object
model comprises one or more portable data nodes; and
an analyZer con?gured to process the one or more portable
data nodes in the document object model to generate one
or more characters of a target programming language
code.
18. The apparatus of claim 17, Wherein the source pro
gramming language and the target programming language
comprise one or more equivalent features.
19. The apparatus of claim 17, further comprising a nor
maliZer con?gured to:
identify one or more non-equivalent and one or more
equivalent features from the one or more features in the
source programming language, Wherein the one or more
non-equivalent features and the one or more equivalent
features are identi?ed based on the one or more features
of the target programming language; and
remove the one or more non-equivalent features of the
source programming language.
20. The apparatus of claim 19, Wherein the normaliZer is
further con?gured to remove the one or more non-equivalent
features of the source programming language.
21. The apparatus of claim 17, Wherein the tokeniZer com
prises a ?nite state machine.
22. The apparatus of claim 17, Wherein the grammatical
data structure comprises an abstract syntax tree.
23. The apparatus of claim 17, Wherein the tokeniZer is
con?gured to process the one or more characters of the source
programming language code based on a set of expression
rules.
24. The apparatus of claim 17, Wherein the parser is con
?gured to process the list of tokens based on a set of grammar
rules.
25. The apparatus of claim 17, Wherein the generator is
con?gured to scan the one or more data nodes in the gram
matical data structure to identify one or more portable data
nodes.
26. The apparatus of claim 17, Wherein the analyZer is
con?gured to recursively process the one or more portable
data nodes in the document object model to generate a target
list of tokens.
27. The apparatus of claim 17, further comprising an emu
lator con?gured to emulate one or more features non-equiva
lent of the source programming language.
28. The apparatus of claim 17, Wherein the one or more
data nodes in the abstract syntax tree represent a grammatical
data structure of the list of tokens.
29. The apparatus of claim 17, Wherein the generator is
further con?gured to:
scan the one or more data nodes in the abstract syntax tree
to identify one or more metadata nodes; and
remove the one or more metadata nodes to generate the one
or more portable data nodes.
30. The apparatus of claim 17, Wherein the analyZer is
further con?gured to:
process recursively the one or more portable data nodes in
the document object model to generate a target list of
tokens; and
Dec. 17, 2009
analyZe the target list of tokens to generate the one or more
characters of the target programming language code.
31. The apparatus of claim 17, Wherein the source pro
gramming language and the target programming language are
object oriented programming languages.
32. A computer-readable medium having computer-ex
ecutable instructions for performing a method for language
translation of a computer program code, said method com
prising:
tokeniZing one or more characters of a source program
ming language code to generate a list of tokens based on
a set of expression rules;
parsing the list of tokens to generate a grammatical data
structure based on a set of grammar rule, Wherein the
grammatical data structure comprises one or more data
nodes;
data structure to generate a document object model,
Wherein the document object model comprises one or
more portable nodes; and
analyZing the one or more portable nodes of the document
object model to generate one or more characters of a
target programming language code.
33. The computer-readable medium of claim 32, Wherein
the grammatical data structure comprises an abstract syntax
tree.
the list of tokens is parsed based on a set of grammar rules.
the source programming language is a computer-game devel
opment language.
36. The computer-readable medium of claim 32, Where
data structure comprises:
scanning the one or more data nodes in the grammatical
data structure to identify one or more metadata nodes;
and
removing the one or more metadata nodes to generate the
one or more portable data nodes.
analyZing the one or more portable data nodes in the docu
ment object model comprises:
processing recursively the one or more portable data nodes
in the document object model to generate a target list of
tokens; and
analyZing the target list of tokens to generate the one or
more characters of the target programming language
code.
the source programming language and the target program
ming language are object oriented programming languages.
39. A system for automatic translation of a computer pro
gram language code, comprising:
means for tokeniZing one or more characters of a source
programming language code to generate a list of tokens;
means for parsing the list of tokens to generate a grammati
cal data structure, Wherein the grammatical data struc
ture comprises one or more data nodes;
means for processing the one or more data nodes of the
grammatical data structure to generate a document
object model, Wherein the document object model com
prises one or more portable data nodes; and

US 2009/0313613 A1
means for analyzing the one or more portable data nodes in
the document object model to generate one or more
characters of a target programming language code.
40. The system of claim 39, Wherein the grammatical data
structure comprises an abstract syntax tree.
41. The system of claim 39, Wherein the list of tokens
comprises one or more categoriZed blocks of the one or more
characters of the source programming language code.
42. The system of claim 39, Wherein the source program
ming language is a computer-game development language.
43. The system of claim 39, Wherein the target program
ming language is a computer-game development language.
44. The system of claim 39 further comprising means for
normalizing the source programming language, Wherein one
or more features of the source programming language are
managed based on one or more features of the target pro gram
ming language
45. The system of claim 44, Wherein the means for normal
iZing the source programming language comprises:
means for identifying one or more non-equivalent and one
or more equivalent features from the one or more fea
tures in the source programming language, Wherein the
one or more non-equivalent features and the one or more
equivalent features are identi?ed based on the one or
more features of the target programming language; and
means for removing the one or more non-equivalent fea
tures of the source programming language
46. The system of claim 39, Wherein the means for pro
cessing the grammatical data structure comprises:
means for scanning the one or more data nodes in the
grammatical data structure to identify one or more meta
data nodes; and
means for removing the one or more metadata nodes to
generate the one or more portable data nodes.
47. The system of claim 39, Wherein the means for analyZ
ing the one or more portable data nodes in the document
object model comprises:
means for processing recursively the one or more portable
data nodes in the document object model to generate a
target list of tokens; and
Dec. 17, 2009
means for analyZing the target list of tokens to generate the
one or more characters of the target programming lan
guage code.
48. The system of claim 39, Wherein the source program
ming language and the target programming language are
object oriented programming languages.
49. A method for automatic translation of computer pro
gramming language code Written in a source programming
language to obtain computer programming language code in
a target programming language, comprising:
identifying one or more non-equivalent and one or more
equivalent features in the source programming lan
guage, Wherein the one or more non-equivalent features
and the one or more equivalent features are identi?ed
based on features of the target programming language;
and
performing, to obtain processed source code, at least one
operation selected from the group consisting of: remov
ing the one or more non-equivalent features of the source
programming language; and replacing the one or more
non-equivalent features With the one or more equivalent
features of the source programming language; and
translating the processed source code into the target pro
gramming language.
50. The method of claim 49 further comprising emulating
one or more non-equivalent features of the source program
ming language.
said identifying, said performing, and said translating.
52. The method of claim 49, further comprising providing
for doWnload computer-executable instructions that, if
executed by a computing device, cause the computing device
to execute said identifying, said performing, and said trans
lating.
53. A computer-readable medium having computer-ex
ecutable instructions for performing the method of claim 49.
* * * * *

Methods and apparatus for automatic translation of a computer program language code

More Related Content

Viewers also liked (16)

Similar to Methods and apparatus for automatic translation of a computer program language code (20)

More from Tal Lavian Ph.D. (20)

Recently uploaded (20)

Methods and apparatus for automatic translation of a computer program language code