• Weed <resume755 mail.ru> Apr 28 2009
• Robert Fraser <fraserofthenight gmail.com> Apr 29 2009
• Tomas Lindquist Olsen <tomas.l.olsen gmail.com> Apr 29 2009
• Georg Wrede <georg.wrede iki.fi> Apr 30 2009
• Georg Wrede <georg.wrede iki.fi> Apr 30 2009
• "Saaa" <empty needmail.com> Apr 29 2009
• Tomas Lindquist Olsen <tomas.l.olsen gmail.com> Apr 30 2009

Weed <resume755 mail.ru> writes:

Is it possible to implement support for Google Android on the D?

Robert Fraser <fraserofthenight gmail.com> writes:

Weed wrote:
 Is it possible to implement support for Google Android on the D?


Perhaps, but it'd be easier to implement support for D on the Google 
Android :-).

LDC might be able to generate .class files, which can be run through the 
Android thingy to get them into a format gor which Google doesn't have 
to pay Sun. The trick would be integrating D and Java's GCs. You can 
probably already get a *very* simple program which doesn't use the D 
runtime working by using LDC to generate a .bc, using the LLVM JVM 
backend to write out a .class file and run it through the google thing. 
Not sure if anyone's tried it, though.

Tomas Lindquist Olsen <tomas.l.olsen gmail.com> writes:

2009/4/29 Robert Fraser <fraserofthenight gmail.com>:
 Weed wrote:
 Is it possible to implement support for Google Android on the D?


 Perhaps, but it'd be easier to implement support for D on the Google Android
 :-).

 LDC might be able to generate .class files, which can be run through the
 Android thingy to get them into a format gor which Google doesn't have to
 pay Sun. The trick would be integrating D and Java's GCs. You can probably
 already get a *very* simple program which doesn't use the D runtime working
 by using LDC to generate a .bc, using the LLVM JVM backend to write out a
 .class file and run it through the google thing. Not sure if anyone's tried
 it, though.


According to wikipedia ( http://en.wikipedia.org/wiki/Google_Android )
it should be possible to run native ARM code, even though it's not
officially supported by google.

It's probably possible to get a full D implementation, but someone
would just have to fix Tango on ARM ;)

Georg Wrede <georg.wrede iki.fi> writes:

Tomas Lindquist Olsen wrote:
 2009/4/29 Robert Fraser <fraserofthenight gmail.com>:
 Weed wrote:
 Is it possible to implement support for Google Android on the D?


 :-).

 LDC might be able to generate .class files, which can be run through the
 Android thingy to get them into a format gor which Google doesn't have to
 pay Sun. The trick would be integrating D and Java's GCs. You can probably
 already get a *very* simple program which doesn't use the D runtime working
 by using LDC to generate a .bc, using the LLVM JVM backend to write out a
 .class file and run it through the google thing. Not sure if anyone's tried
 it, though.


 According to wikipedia ( http://en.wikipedia.org/wiki/Google_Android )
 it should be possible to run native ARM code, even though it's not
 officially supported by google.
 
 It's probably possible to get a full D implementation, but someone
 would just have to fix Tango on ARM ;)


I'd just hate to create statically linked programs on a small machine. 
Feels like a massive waste of space.

Typically I'd think the apps would be less than a thousand lines of 
code, and already having several tens of such binaries could either take 
a small or a huge amount of memory.

Georg Wrede <georg.wrede iki.fi> writes:

Tomas Lindquist Olsen wrote:
 On Thu, Apr 30, 2009 at 11:29 AM, Georg Wrede <georg.wrede iki.fi> wrote:
 Tomas Lindquist Olsen wrote:
 2009/4/29 Robert Fraser <fraserofthenight gmail.com>:
 Weed wrote:
 Is it possible to implement support for Google Android on the D?


 Android
 :-).

 LDC might be able to generate .class files, which can be run through the
 Android thingy to get them into a format gor which Google doesn't have to
 pay Sun. The trick would be integrating D and Java's GCs. You can
 probably
 already get a *very* simple program which doesn't use the D runtime
 working
 by using LDC to generate a .bc, using the LLVM JVM backend to write out a
 .class file and run it through the google thing. Not sure if anyone's
 tried
 it, though.


 it should be possible to run native ARM code, even though it's not
 officially supported by google.

 It's probably possible to get a full D implementation, but someone
 would just have to fix Tango on ARM ;)


 like a massive waste of space.

 Typically I'd think the apps would be less than a thousand lines of code,
 and already having several tens of such binaries could either take a small
 or a huge amount of memory.


 LDC has supported shared libs (including a shared runtime) for quite a
 while, of course I'm not sure about the state of PIC codegen in LLVM's
 ARM backend, but I'd guess it's working.


It's been my dream ever since I started with D (oh boy, ages ago) to be 
able to replace C as the preferred language for small gadgets. Maybe I 
will see the day, after all!

"Saaa" <empty needmail.com> writes:

 Is it possible to implement support for Google Android on the D?


 Perhaps, but it'd be easier to implement support for D on the Google 
 Android :-).

Tomas Lindquist Olsen <tomas.l.olsen gmail.com> writes:

On Thu, Apr 30, 2009 at 11:29 AM, Georg Wrede <georg.wrede iki.fi> wrote:
 Tomas Lindquist Olsen wrote:
 2009/4/29 Robert Fraser <fraserofthenight gmail.com>:
 Weed wrote:
 Is it possible to implement support for Google Android on the D?


 Perhaps, but it'd be easier to implement support for D on the Google
 Android
 :-).

 LDC might be able to generate .class files, which can be run through the
 Android thingy to get them into a format gor which Google doesn't have to
 pay Sun. The trick would be integrating D and Java's GCs. You can
 probably
 already get a *very* simple program which doesn't use the D runtime
 working
 by using LDC to generate a .bc, using the LLVM JVM backend to write out a
 .class file and run it through the google thing. Not sure if anyone's
 tried
 it, though.


 According to wikipedia ( http://en.wikipedia.org/wiki/Google_Android )
 it should be possible to run native ARM code, even though it's not
 officially supported by google.

 It's probably possible to get a full D implementation, but someone
 would just have to fix Tango on ARM ;)


 I'd just hate to create statically linked programs on a small machine. Feels
 like a massive waste of space.

 Typically I'd think the apps would be less than a thousand lines of code,
 and already having several tens of such binaries could either take a small
 or a huge amount of memory.


LDC has supported shared libs (including a shared runtime) for quite a
while, of course I'm not sure about the state of PIC codegen in LLVM's
ARM backend, but I'd guess it's working.