Source-to-source compiler | Wikipedia audio article

A source-to-source compiler, transcompiler
or transpiler is a type of compiler that takes the source code of a program written in one
programming language as its input and produces the equivalent source code in another programming
language. A source-to-source compiler may perform a
translation of a program at roughly the same level like from Pascal to C, while a traditional
compiler translates from a language like C to Assembler or Java to Bytecode. An automatic parallelizing compiler will frequently
take in a high level language program as an input and then transform the code and annotate
it with parallel code annotations (e.g., OpenMP) or language constructs (e.g. Fortran’s forall
statements).Another purpose of source-to-source-compiling is translating legacy code to use the next
version of the underlying programming language or an API that breaks backward compatibility. It will perform automatic code refactoring
which is useful when the programs to refactor are outside the control of the original implementer
(for example, converting programs from Python 2 to Python 3, or converting programs from
an old API to the new API) or when the size of the program makes it impractical or time
consuming to refactor it by hand. Transcompilers may either keep translated
code structure as close to the source code as possible to ease development and debugging
of the original source code, or may change the structure of the original code so much
that the translated code does not look like the source code. There are also debugging utilities that map
the transpiled source code back to the original code; for example, the JavaScript Source Map
standard allows mapping of the JavaScript code executed by a web browser back to the
original source in a transpiled-to-JavaScript language.Examples of transcompiled languages
include Closure Compiler, CoffeeScript, Dart, Haxe, TypeScript and Emscripten.==History==
One of the earliest programs of this kind was Digital Research’s XLT86 in 1981, a program
written by Gary Kildall, which translated .ASM source code for the Intel 8080 processor
into .A86 source code for the Intel 8086. Using global data flow analysis on 8080 register
usage, the translator would also optimize the output for code size and take care of
calling conventions, so that CP/M-80 and MP/M-80 programs could be ported to the CP/M-86 and
MP/M-86 platforms automatically. XLT86 itself was written in PL/I-80 and was
available for CP/M-80 platforms as well as for DEC VMS (for VAX 11/750 or 11/780).A similar,
but much less sophisticated program was TRANS.COM, written by Tim Paterson in 1980 as part of
86-DOS. It could translate some Z80 assembly source
code into .ASM source code for the 8086, but supported only a subset of opcodes, registers
and modes, often still requiring significant manual correction and rework afterwards. Also it did not carry out any register and
jump optimizations.==Programming language implementations==
The first implementations of some programming languages started as transcompilers, and the
default implementation for some of those languages are still transcompilers. In addition to the table below, a CoffeeScript
maintainer provides a list of languages that compile to JavaScript.==Porting a codebase==
When developers want to switch to a different language while retaining most of an existing
codebase, it might be better to use a transcompiler compared to rewriting the whole software by
hand. Depending on the quality of the transcompiler,
the code may or may not need manual intervention in order to work properly. This is different from “transcompiled languages”
where the specifications demand that the output source code always works without modification. All transpilers used to port a codebase will
expect manual adjustment of the output source code if there is a need to achieve maximum
code quality in terms of readability and platform convention.==Transcompiler pipelines==
A transcompiler pipeline is what results from recursive transcompiling. By stringing together multiple layers of tech,
with a transcompile step between each layer, technology can be repeatedly transformed,
effectively creating a distributed language independent specification. XSLT is a general purpose transform tool which
can be used between many different technologies, to create such a derivative code pipeline.==See also

Tags: , , , , , , , , , ,

There are no comments yet

Why not be the first

Leave a Reply

Your email address will not be published. Required fields are marked *