AltME groups: search

If you look at the Win32 API, for example, it's a huge mess of sets 
of deprecated interfaces that were replaced by new sets with slightly 
extended interfaces. So it's not only an issue in unreliable Internet 
programming, but also in low-level system programming

Not that any of you would have issues with creating such a thing 
but here is an R2 version of the Colineau's (Jocko) Google translate 
app he created in Red. (Note, I didn't add all of the routines but 
if you take a look at Colineau's code it's all there.)  Also, the 
female voice (use gTTS function instead of TTS function) is much 
better than the male in my opinion unless you want to hear "This 
is Amiga Speaking." and feel nostalgic.

rebol [
	title: {googletts.r}
	date: 20-aug-2011
	usage: {gtts "Hello World." or tts "Hello World."}	
]

lib: load/library %tts-jc.dll

TTS: make routine! [
	lpStr [string!]
	return: [integer!]		
] lib "TTS"

gTTS: make routine! [
	lpStr [string!]
	return: [integer!]		
] lib "gTTS"

-----

I created some nice memory tools for my son who is in law school 
with this by setting up the string and tweaking it and then recording 
it (I use Sound Forge). If I get some free time I'd like to create 
a dialect so that I can make an interactive tool with visual reinforcements. 
As I mentioned, you have to tweak the words and punctuation and that 
creates a problem with just reading the text normally, hence I'll 
require a mechanism to sort all that out.

Oh, the dll is in the http://www.colineau.fr/rebol/downloads/demoTTS_Red.zip
file

For the demos at the upcoming conferences, I've started working on 
a GTK+ binding

I can open a GTK window now

just a detail on my dll :

tts uses the SAPI4 or SAPI5 voice synthesis normally installed on 
the PC (you can install other voices), while gTTS uses the Google 
TTS api. 

For the details on the SAPI5 interface, see http://www.colineau.fr/rebol/R3_extensions.html#section-2

The following class of expressions is not emitting correct native 
code: A <op> B, where A is an integer! expression and B is byte! 
variable.

You can also send me the source code, and I'll do the internal debugging, 
it is probably a minor error.

I've released a fix for your compilation issue.

It took me a day to hook up a (quit) signal to a GTK program. GTK 
is incredibly bloated

I can now load a GDK image and set it as the GTK window icon

Now I can add a text label to the window

And now a button with an associated action callback

I'm going to return to cURL for a while to see if I can trigger the 
problem there

A regression in today's commit or an older issue?

If you can send me a short sample, I can do some investigations.

Doc: why UNTIL doesn't return a value. It can simply return TRUE, 
because if loop is over the last expression evaluated as TRUE. So 
it can always return TRUE. No?

It would be useful if there would be a BREAK that would return FALSE

Why don't you add it as a wish on github?

Tested now with downloads up to 56 MB, in diverse chunks from a few 
hundred bytes to 16 K

I had to go through the Blogger registration process again to post 
a comment

Anyway, there's a new commenter to the last article

About Blogger: this platform is a real PIA in many ways. When I will 
have some time, I will look at how to move out, probably going to 
WordPress, or setting up my own blog using the script from Cheyenne's 
web site (I would need to integrate an anti-spam service like Akismet 
in such case).

I am proud to present my first Red/System dialect, for GTK. Here's 
an example of a window with a title, an icon, a label, an input field 
and a button with an associated action function:

That's really a smart use of 'typed function attribute.

Is 'fixed a function call in the dialect?

So it's a sort of static dialect. Red dialects will be much more 
dynamic

Thanks. I've been talking about such techniques for many years in 
Syllable and in general, and nobody will ever believe me. I'm very 
happy to now have a tool to show them

If that is so, it is in some mystery Python binding that is hidden 
very well. In the known PyGTK binding, it would be 2.5 to 3 times 
as long, with a lot of boilerplate code inbetween

Do you think that adding a symbol! type would be a big help for building 
such dialects at this point?

Yes, but it occurred to me a day or two ago that it can be done simpler, 
if you support first class constants, which I would like anyway

You also have to use a complicated word, because defines of simple 
words could mess up the program elsewhere

for example and then check for that code. But you'd get a manual 
sort of symbol table that would take space

and have constants be real types that you can check for, you'd be 
able to stretch simple dialects a lot further

Supporting first class constants would require to duplicate all existing 
types... I was thinking recently about adding a PROTECT keyword that 
would allow to mark any variable as immutable, so they would act 
as constants. But I guess that such option wouldn't help much for 
dialects, unless I would also add a PROTECTED? keyword to detect 
them.

Enumerations would also help; they're sort of a namespace type for 
constants

I think that extending the RTTI system to distinguish different type 
of structs (or at least aliased structs) should be doable without 
that. Aliases are already a form of user-defined type.

Having more people testing red/system would probably help speed things 
up a little.

Agreed with Peter, as Red/System becomes more important now, it needs 
to be strengthen a bit more. I will publish an updated roadmap duing 
the SFD event in two weeks.

Kaj: I have added in the last commit a new virtual path for querying 
aliases unique ID value: system/alias/<name> 


The system/alias/... paths are replaced during compilation with a 
unique ID that should match the one passed for "typed" functions. 
So now you basically have RTTI on aliases too.

As it might be a bit verbose in some cases, macros would be welcome 
to shorten them. In such case, the convention of a "type-" prefix 
on the alias name would be a good one to follow (will document that 
in the spec later today).

I also plan to add a SWITCH function soon, maybe before the SFD. 
It should be able to resolve alias names without the system/alias/ 
path prefix.

What I'm a bit worried about, though, is binary compatibility. How 
are the values of type IDs determined?

I suppose they shift when the program uses different aliases. That's 
no problem for monolithic programs, but it would be when you try 
to define an interface to a library or other subsystem

If I ask GTK to determine an object's type, it takes care that it 
works across versions of the GTK library. You can't use these aliases 
to build such a library

I'm trying to make a decision about which language to learn for my 
own use.

hmm, nope. seems there's a bug in my debug fix

Can't test the new struct detection due to a new bug

It's a Heisenbug, so I'll check in the broken code

It might be caused by a uncaught wrong definition in your imports, 
that is messing up the imported function arguments parsing code.

I hope you'll make a nice web page for your GTK binding once finished. 
It also deserves some docs for the dialect API.

People are not really supposed to use this binding

 It's a very nice binding that could motivate some C coders from Rebol 
 community (or outside) to take a closer look at Red/System and start 
 hacking with it. It could be a good way to attract new users.

just testing for a while... having:
	MagickGetImageWidth: "MagickGetImageWidth" [
		;{Returns the image width.}
		*wand     [wand!]
		return:  [integer!]
	]

When I do:
	width: MagickGetImageWidth *wand
	print ["image width: " width " " MagickGetImageWidth *wand]
I get:
	image width: 78 0000004E
I was expection:
	image width: 78 78
What do you think?

(but that's a detail... I'm still waiting for the decimal support)

A lot of work. :)

It would mainly need a full backend code generator for supporting 
floating numbers. It would also require to add some runtime conversion 
with other numerical types and probably many small additions at all 
stages of compilation.

I guess it would take, at least, a full week of work to support floats 
fully.

It prints warnings when you start from a command prompt

I do a quick test on Linux, just in case...

missing widget

 in itself is already a bug. If it would recognise it as system/alias/gdk-image! 
 it would say "missing icon"

Yes, I have located the issue in compiler code, I am now looking 
for a durable fix.

Pushed a temporary new fix for #172, let me know if it works for 
you now.

Implemented attaching an object to a (button) action

Here's an example that gets input from a line entry field:

Added a few more examples

adding some actions could be attractive for a demo

Sure, if you can double my hours in a day

A fairly impressive demo is to start the client before the server

unfortunatelly raspberrypi website is a mess

The cURL binding still works, but I don't have a nice example for 
it yet

It demoes mouse events, drawing, program arguments and loading a 
bitmap file

I've added a sample.bmp file from SDL for easy access

I don't think there's a quide guide on getting started for people 
new to red and/or rebol ...

Ah, that's a weird transformation. I'll add it. Thanks for testing!

The page there refers to a number of "free" utils for unpacking dmg 
files .. though for windows

I tried Linux loop mounting and 7-Zip, but my versions don't seem 
to support DMG. It's just much easier if someone with a Mac has a 
quick look

I have a mac but daughter has password protected it .. and she no 
longer lives here!

Kaj: the lib name is SDL but when properly installed, it should be 
referenced as: /Library/Frameworks/SDL.framework/Versions/A/SDL

Graham: there's no such guide yet. You have a few basic instructions 
for installing Red/System and compiling the Hello script here: https://github.com/dockimbel/Red

I've added an example to the cURL binding, for reading a web page

There are no "standard" arrays in Red/System though I'm sure that 
there will be, or something which provides the same functionality 
in Red (when it becomes available).


args is not a standard array and is navigated through pointer arithmetic 
just like  a c-string. I suspect that args points to a list of pointers 
each of which contains the address of a command-line argument.


So the first entry in Args holds the memory address of the first 
command-line entry, the second the second command line entry, etc.


The syntax args/item gets you to the data pointed at by the relevant 
entry in args.

So the compiler doesn't treat item as an index but as a command to 
derefence the pointer heid in the current position of args.

*** Compilation Error: a variable is already using the same name: 
window
*** in file: %tests/hello-GTK-world.reds

You shouldn't need to use the verbose option, unless you want to 
have a closer look at what the compiler is doing internally, or to 
more easily locate a compiler internal error.

BTW, I had a great time at Software Freedom Day and met very interesting 
peoples. Thanks to Bas & Kaj for organizing it and inviting me.

I will release the slides in a few minutes, so people can watch the 
slides more comfortably.

The C library's vprintf() function is the one that gets passed one 
argument that is a list of the variable arguments. This seems to 
match the declaration of a variadic Red function, so I thought PRINT 
would match vprintf(). Looking at it again, is it the other way around 
and does PRINT match printf() ?

Kaj, I downloaded all files again and tried it on another PC with 
Win 7 (x64). Same compilation error, but I also noticed while running 
do/args %rsc.r "%tests/hello-GTK-world.reds"

The first run


*** Warning: type casting from pointer! to pointer! is not necessary
*** in: %tests/hello-GTK-world.reds
*** at:  [as integer! :gtk-quit null

*** Compilation Error: invalid struct member alias in: type
*** in file: %tests/hello-GTK-world.reds
*** in function: window
*** at:  [type system/alias/gdk-image! [

The next runs


*** Compilation Error: a variable is already using the same name: 
window
*** in file: %tests/hello-GTK-world.reds
*** in function: window
*** at:  [

The meaning of [variadic] is relative to the context. ;-) In imports, 
it will just pass a stack of arguments as expected by the C calling 
convention. When used in a Red/System function, it will add more 
information on stack.

Dockimbel, no, I didn't realize there was a difference, but now I 
have and it compiled OK. Thanks.

Good! I will make a new 0.2.2 release asap to avoid such issues with 
the older version.

I have a similar error here. It's on my todo list, I'll investigate 
that issue in a couple of hours.

I think I get what is going wrong: the action handler calling convention 
is inferred as stdcall, because it is passed to a Red/System 'button 
function. But this function is passing it to an imported C function, 
so the hanlder's calling convention should be cdecl.

The compiler can't infer correctly in such case, so we need a way 
to force the cdecl convention on the callback function.

I guess a solution could be to implement a 'cdecl attribute support, 
to be able to manually force the right convention. But that would 
make things it a bit more complicated for the GTK binding user. 


Another option would be to define a trampoline function in the GTK 
binding that would call the user callback. That trampoline function 
would be directly (no nested calls) passed as argument to the imported 
function, so the compiler could infer its calling convention correctly.

Thinking. I'm a bit foggy today

Have to get back into Red. I've been looking into Freecoin and other 
stuff for a few days

How complicated would it be to make a Red binding for Freecoin?

It's quite a mess, and that's why everybody is rewriting stuff

Freecoin still has the Bitcoin interface, so you'd have to do JSON 
with a daemon. Not very comfortable until you have PARSE

I've decided to first port some of it to Syllable and wait a while 
with the bindings