AltME groups: search

call_gmon_start is support for the gnu profiler

(again, all of the above are functions linked into the program binary 
by gcc)

I need to add support for Syllable, I have the right doc from Kaj 
for that, so no problem.


For Darwin, I would need the right stack layout description on starting 
a new process, I haven't found yet a recent and official description 
for that, just a lost page in google's cache from 2009: http://webcache.googleusercontent.com/search?q=cache:4zQ0NwtOKdsJ:blogs.embarcadero.com/eboling/2009/10/13/5620+MacOSX+stack+layout+on+start&cd=4&hl=fr&ct=clnk&gl=fr

from that doc, the osx stack layout looks identical to linux/elf

identical from the main() POV, but I'm not sure that's the right 
kernel stack layout before libc is initialized.

in that doc, it's not describing the stack for main() but the stack 
layout as setup for the entry point ("_start")

Okay, libc-init is now working fine for Linux and conforming to Gcc 
ABI. Once again, man has won over the machine, but I wonder how many 
neurons were killed both in my and Andreas brain during the battle...;-)

the reverse ... you probably grew a few :)

The documentation seems to describe that when you write a floating 
point constant, it will be a float32! if it fits. However, it turns 
out that it is interpreted as float64!

Indeed, the spec is misleading here. All literals are float64!, float32! 
has no literal form.

So the only way to construct a float32! from a literal, is by casting 
(`as float32!`) from a float64! literal.

(So it's propapbly best to remove the "syntax" section in the float32! 
spec and add a note describing the above.)

In the tracker

Doc - so your sister tweets about the Red development? Cool :-)

Why not delete the Twitter message if it was an error?

Can we view the code that does this?

(2/3 inline binding code and the rest is very plain OpenGL and, yuck, 
GLUT.)

Looks good and the code looks some much easier on the eye than C 
to me.

Just updated the Gist, you can now rotate using the arrow keys:
https://gist.github.com/d3b0e5c6fdbc4f19ff7a

Had to enable double buffering to stop the flickering. Another 4 
lines.

harr..harr. andreas the human coding machine :))

I know. OK, maybe I need an advice. I was looking into some C code 
educatory example, which contained something like:

char multi[5][10];

decomposed to:

    multi[0] = {'0','1','2','3','4','5','6','7','8','9'}
    multi[1] = {'a','b','c','d','e','f','g','h','i','j'}
    multi[2] = {'A','B','C','D','E','F','G','H','I','J'}
    multi[3] = {'9','8','7','6','5','4','3','2','1','0'}
    multi[4] = {'J','I','H','G','F','E','D','C','B','A'}


which gets stored in a memory block of a "0123456789abcdefghijABCDEFGHIJ9876543210JIHGFEDCBA" 
value.


If I would be supposed (for any reason :-), to interface to such 
a construct, I would simply use a pointer in Red, and would be responsible 
to manually decompose/treat the value of arrays, not to break it 
for the C level code?

And, as you know, an array type and a pointer type are (for most 
things) interchangeable, a `char[50]` is the same as a `char*`, therefore 
a `char[5][10]` is also the same as a `char*`.

OK, thanks. So btw - how are REBOL blocks (most probably), implemented 
in the C level? As structs of "arrays", chars?

Endo: it's guaranteed to be a single, contiguous area of memory. 
So yes, that behaviour is the case for all compilers and all memory 
models and all hardware (if they claim compliance with the C standard).

When I will write app in Red, it will compile to Red/System in the 
first pass, and then to the native code from R/S? So that it means, 
that you write Red in R/S? Hmm, if Carl would release R3 sources, 
it would not help you much, as you plan to write Red in R/S, not 
C?

from the mailing list http://www.arnoldvanhofwegen.com/pics/banners/redlang.png

I like e.g. part of this one -if you would turn the arrows 90 grades, 
it could imitate REBOL prompt sign >> RED - http://www.logofactory.cz/msys/uploads/logos/48.jpg

A simple vector style of Red Riding Hood's hood, maybe with one twinkling 
eye peeking out, and the tag line "Don't be afraid". :-)

We can't work like that imo :-) I went thru the process several times. 
We have to define qualities we want to reflect, etc. But RED, red 
is "just" a color. What can represent that? Something red, perhaps 
:-)

symbolism is that your wishes will be granted if you try hard enough, 
and the impossible is possible.  We don't need the wizard of oz to 
help us.

in this case, the wizard is Carl :)

can the ED be bolder?

What about 

>>RED
talk dialects


the >> is a play on the target image used in REBOL where >> is both 
from a console,and also an arrow head?

I know - the bottom slogan could be replaced by link to webpage ...

Maybe the Red pill as Doc alludes to. Or let Doc tell us what he 
wants the logo to symbolize.

Interesting designs indeed, I will try to list my wishes after the 
Devcon this weekend.

I like the stylized "R" in the "redlang" logo.

Yes, Redlang is probably the best one, and yes, they are maybe too 
corporate. I am more for a serious stuff, than for a fun ...

Those were just tries. Any of the above logo is imo better than what 
Graham originally posted. But I am not satisified either. Here's 
my take, what needs to be considered for the logo to actually "work":


- you should define a brief - namely a description of qualities/characteristics 
of Red. What is Red, what sets it apart, what does it mean to you, 
what should it mean to ppl, what differentiates it from others, etc.


- type of logo - only letters? Letters plus pictogram? Shoul pictogram 
only decorate logo, or is part of the name? Pictograms are often 
related to the business, but I am not sure, if you are easily able 
to relate pictogram to "red", as it is a name of the color. Nor am 
I sure, if pictogram would express a programming language. What I 
would suggest, would be either - pictogram contains "R", which also 
works as a filetype icon. Or pictogram expresses some quality - e.g. 
>> (REBOL/Red prompt), [R] block as one of the main concepts (series)


- color scheme - not much options with something named Red, right? 
:-)


- usability - you should think about the color scheme, and logo in 
various forms - normal, inverse, black&white, icon, letterhead, business 
card, ppt presentation, etc. You can look for inspiration to how 
I aproached 2zone media logo with the agency - http://www.xidys.com/pekr/2zone_media_logotypes/

So I can see, we have merget fast-float and the other branch, nice 
:-)

Doc - how goes your presentation for the Devcon? Interested in the 
Roadmap slide, which surely will be there :-)

I will present the same slides as last time, with just a few updates 
and enhancements.

I thnk Nenad is flying to the Devcon so he wont  need a roadmap.

Nenad is still here after the conference. We debugged SDL audio on 
Syllable. It works now, without libc-init workaround, and it wasn't 
the fault of the new libc-init code in Red

Yes, all the bindings that can work on Syllable do now without modifications. 
Except Syllable needs to have SDL video initialised even if you don't 
use it

The plan is slightly different :-)

and the plan is? :-)

I'm a bit hesitant to tell, because I'm not sure about the viability 
yet

You may have noticed an item "New Project Announcement" on the conference 
schedule

AGG/Cairo/Skia is the only solution acceptable for me, unless proven 
otherwise.

how big is actually enlightenment (the parts you need to use, to 
get a GUI and app done using it)?

as for the Enlightenment - is it mostly about windowing, compositing, 
or does it include even some widgets, so that you can make some apps 
using it?

Where one can download the OpenGL binding? Don't you want to put 
the bindings into the Red's github?

well played Gregg, I don't have the problem anymore

Enlightenment is very modular. The top two libraries are a widget 
set and a desktop environment and window manager, that you can choose 
to include or not

The widget set is my primary target, but I haven't got it to work 
yet

One could also just use the drawing library, which then seems to 
be about double the size of Cairo for example, but is much more intelligent

Yep. :-) The REBOL AGG engine is implemented in C++. You basically 
have to write the draw dialect interpreter in C++ to be able to use 
AGG or any of the other C++ engines

btw - I wonder if there would be some niche for the BlackBerry. They 
will switch to QNX, which is nice C. That would be like Amiga going 
back to QNX :-)

I don't think I've used Enlightenment in a decade. It was superfast 
at the time, but the UI was not so good. I'm not sure the UI itself 
is important for Enlightenment, but more the underpinnings?

I agree. The appearance is too geeky, but by the graphics geek kind. 
I want to build a more user friendly interface on it

I got the first Enlightenment example to run; so far just one of 
the included C examples from the Evas canvas library, on X11 on Syllable 
Server

Yes, as I said, I have it running on X. As far as I can see: it could 
also be using the SDL backend, which I'm trying to get to work

I have ImageMagick installed from the GoboLinux layer

The title text as shown?

I don't think the Evas examples are very special, but I'll make a 
shot

Yes, Server is non-graphical. At least, it only has DirectFB and 
SDL built in, and no desktop. Workstation is Server plus X11 from 
a GoboLinux layer and the ROX desktop from ZeroInstall

I finally succeeded in compiling the Enlightenment widget set and 
desktop

Sounds like a major milestone.  Bring the next conference forward 
to show it off!

:-) It's only the first steps yet, that are guaranteed to work because 
it's on Linux. The major question is whether I can port it to Syllable 
Desktop

Here's the widget set:

Can you give us a tiny taste of the RED code?

Kaj is reporting a success of compiling this software.  He hasn't 
done the binding to Red/system yet?

I am releasing v0.2.5, if you have some unreported bugs to fix, it's 
the right time to add them to the bugtracker. Kaj, let me know if 
there are any regression for the bindings.

Will you blog? What are latest changes? The bugfixes mainly?

Kaj: is the latest revision working fine with all bindings? (at least, 
w/o regressions)

Had to fix the comment syntax for the Goodbye Cruel GTK+ World

I've changed the developing branch of the C library binding to be 
the main branch again (technically, it isn't a merge):

Anti-intuitive ? It makes the generated code simpler to write since 
the parameters are pushed in reversal order so that the called function 
can unstack them in order.
C compilers do the same IIRC.
But I agree it's not rebol compliant.

I'm not sure if C forces any order for parameters evaluation.

But i'm sure it makes the compiler's task easier to evaluate in reversal.

Could it be that when a function is applied to multiple argument 
expressions, f exp1 exp2, they are computed in reverse order?


I agree that it is not intuitive, but doing otherwise would make 
it more complicated to support external libs. It could be possible 
to preallocate the stack and fill it in reverse order, so that arguments 
are executed in right order for the user, but that wouldn't work 
for variadic functions (can't preallocate the stack before compiling 
all the arguments).


It would be nice to add a ticket in the tracker to keep this issue 
in mind.

As we do the compilation and code generation in one pass in current 
Red/System, we can't look ahead to determine the boundaries of each 
expression in a variadic block of arguments in advance, to be able 
to extract their datatype.

OK. It got me in trouble, though, because I used this statement in 
the Fibonacci computation:

In the C version I already noticed that I had to put the computation 
in front of the reporting, but I hadn't expected this, and certainly 
not in a language that looks like REBOL

Actually, the single pass nature of Red/System strengthened my assumption 
that the computation would be in natural order

We have a "chunked" compilation mode that could be used to re-order 
the code once generated, but I'm not sure it could work in such case. 
The best thing to do for now is to document it in the tracker.

that's what Doc replied on his blog:


@Thomas: for the very first Red alpha, only memory management, basic 
datatypes and a few natives/actions. Ports and I/O will probably 
be added in following alpha versions, as PARSE. If we don't hit any 
walls, we should have it a few weeks, probably a month.

The first Red will probably have all the capabilities of Red/System, 
so I think it will be able to do quite a lot

The current partilal support for float does not support casting between 
float and integer datatypes

Support for converting between integer! and float!/float32! has not 
been implemented yet. The only way to achieve it right now is to 
rely on an external lib (libc?) or implement your own conversion 
routine in Red/System.

Yes, the C library binding can do that

FYI, I am making good progress on the Red runtime, but I had to start 
implementing the Red compiler earlier than planned, to be able to 
define more accurately the right runtime API that the compiler needs. 
So at the time that the runtime will be ready, I should have a first 
Red compiler partial implementation working.

To convert to an integer value, you have to go through strings. You 
can use the format function in C-library.reds for that, but I see 
I haven't defined a shorter float wrapper yet

Doc - we are watching your progress via the Twitter messages, and 
looking into Github :-)

I've added some floating point convenience wrappers matching the 
other data types

Note that the string returned by form-float should be freed

The other way around is already used in my Fibonacci and Mandelbrot 
time processing:

Once the Red runtime is more fleshed out I'll see what is still useful 
to add in Red/System

I wrote a binding with the Evince document viewer for the Document 
Freedom Day tomorrow: