AltME groups: search

10 x 10 x is two factors?

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

However, Windows, OS X and Android are missing from the OS entries

If I run this code

s: declare struct! [
	f [float!]
]
s/f: 12345678.9
p: as byte-ptr! s
v: p/value
w: 256 * as integer! p/value
x: 256 * as integer! v
print [x ".." w]

I get  this result: 52480..4194304


Why the difference? Shouldn't W and X be same as V is same as P/VALUE?

Why the difference? Shouldn't W and X be same as V is same as P/VALUE? 
  I checekd that v = p/value so it would appear to be the type casting 
that is the problem. I checekd the spec and casting a byte! to and 
integer! should be okay. So it seems like it is a bug.

Doc, I can still reproduce it with this code:

x: 0.0
x: either x > 0.0 [x][0.0 - x]
print [x lf]

If I assign the result to 'y instead of 'x, it works.

Ah, that's not the reason. It happens when the condition is FALSE 
and FALSE block ends with expession.So the above code works for x 
= 1.0

When I change order, the code works:

x: 0.0
x: either x <= 0.0 [0.0 - x][x]
print [x lf]

But this also throws 11: float stack check error when used in function:

fabs: func [x [float!] return: [float!] ][
	either x < 0.0 [0.0 - x][x]
]
print [fabs -3.14 lf]

Final workaround :)

fabs: func [
	x			[float!]
	return:	[float!]
][
	x: either x < 0.0 [0.0 - x][x]
	x
]
print [fabs -3.14 lf]

Kaj: since latest commits in `namespaces` branch, you can now do:

ctx: context [
    #import [
        LIBM-file cdecl [
            sin: "sin" [
	    x           [float!]
	    return: [float!]
	]
        ]
    ]
]

print ctx/sin 1.0

;-)

Or for me on OS X :

Schulz:Red peter$ rebol -qs red-system/rsc.r red-system/tests/hello.reds

Cannot access source file: red-system/tests/hello.reds

Peter: the lib-test file is crashing here on my OS X 10.6.2 image 
with following error:

dyld: lazy symbol binding failed: Symbol not found: _strnlen

  Referenced from: /Users/dk/Desktop/Red/red-system/tests/runnable/lib-test
  Expected in: flat namespace


After researching a bit about it, it seems that strnlen() is (was?) 
not supported by OS X.

Nenad" "Peter: the lib-test file is crashing here on my OS X 10.6.2 
image with following error:"


Did you install Xcode including the Unix libs?  I wrote the tests 
under OS X 10.6 but am now running on 10.7.

I just checked on my old machine, I did re-wrtie the lib tests on 
OS X 10.6 but on OS X 10.7.

I meant that I re-wrote the lib tests on OS X 10.7 not 10.6.

2.

#enum fooEnum! [x y: x z] ;<-- possible
c: context [

 #enum SomeEnum! [foo boo: foo] ;<-- *** Compilation Error: cannot 
 resolve literal enum value for: c/boo 
]

comment in REBOL is just native function which takes one argument 
and does nothing.

>> comment (x: 2 + 2) x
== 4

The SQLite binding now works on OS X, thanks to Peter

Oldes: I've changed the 'comment implementation to be more like REBOL, 
so it consumes the next expression, but does not generate code for 
it (so you're above example with 'x won't work in Red/System). Also, 
it cannot be used in functions spec blocks anymore, so we still don't 
have a true multiline comment support. Suggestions about that are 
welcome.

About the native GUI option (using only what the OS provides), I'm 
pretty confident that the minimum common should be enough to cover 
most needs for business apps, I will do a prototype for the Red IDE. 
Having a free drawing x-platform canvas, for games and non-native 
GUI would also be needed, SDL seems to be the best backend for that 
AFAIK (that gives us also OpenGL for free).

So far, my short-list of encodings to support are UTF-8 and UTF-16LE. 
UTF-32 might be needed at some point in the future, but for now, 
I'm not aware of any system that uses it?


The Unicode standard by itself is not the problem (having just one 
encoding would have helped, though). The issue lies in different 
OSes supporting different encodings, so it makes the choice for an 
internal x-platform encoding hard. It's a matter of Red internal 
trade-offs, so I need to study the possible internal resources usage 
for each one and decide which one is the more appropriate. So far, 
I was inclined to support both UTF-8 and UTF-16LE fully, but I'm 
not sure yet that's the best choice. To avoid surprizing users with 
inconsistent string operation performances, I thought to give users 
explicit control over string format, if they need such control (by 
default, Red would handle all automatically internally). For example, 
on Windows::

    s: "hello"		;-- UTF-8 literal string

    print s		;-- string converted to UCS2 for printing through win32 
    API
    write %file s	;-- string converted back to UTF-8

    set-modes s 'encoding 'UTF-16 ;-- user deciding on format
or
    s/encoding: 'UTF-16

    print length? s	;-- Length? then runs in O(1), no surprize.



Supporting ANSI as internal encoding seems useless, being able to 
just export/import it should suffice.

BTW, Brian, IIRC, OS X relies on UTF-8 internally not UTF-16.

Brian: I was wrong for OS X, it uses UTF-16 internally according 
to http://en.wikipedia.org/wiki/UTF-16

That was under OS X, it runs okay under Windows.

The output I'm seeing on both Linux and OS X is the same as on V0.3.0 
before you applied the patch.

All tests pass on Linux and OS X after latest master branch commit. 
Thanks.

Kaj: ok, I will have a deeper look in mmap syscall later, I'm currently 
debugging the OS X version.

Kaj: I can reproduce a similar memory allocation error on OS X too, 
so I hope that fixing it there will fix it on Syllable too.

Ok, got Red working fine on OS X too.

cURL is included in almost all open source based operating systems, 
including OS X

Fixed the math library in the C library binding; should now also 
work on OS X and Android

Hi Kaj on my macbook:

Last login: Fri Oct 19 07:21:16 on 
ttys001

 MacBook-van-Arnold-160:~ Arnold$ 
 /Users/Arnold/Downloads/Red\(/System\)\ 
 Testing-dc1b702068063b65/Darwin/Red/hello 
 ; exit;
Hello, world!
§±ÖÁµ, ºÌüµ!
`O}Y, NLu
Dobrý den sv
te
logout

[Proces voltooid]

 /Users/Arnold/Downloads/Red\(/System\)\ Testing-dc1b702068063b65/Darwin/Red/Fibonacci 
 ; exit;

MacBook-van-Arnold-160:~ Arnold$ /Users/Arnold/Downloads/Red\(/System\)\ 
Testing-dc1b702068063b65/Darwin/Red/Fibonacci ; exit;
Fibonacci 35: 9227465
logout

[Proces voltooid]


MacBook-van-Arnold-160:~ Arnold$ /Users/Arnold/Downloads/Red\(/System\)\ 
Testing-dc1b702068063b65/Darwin/Red/empty ; exit;
logout

[Proces voltooid]
I took the programs from the Red tree under Darwin

Doc - the less time I have, the less I am willing to spend my free 
time, just to get around various things, where I need to get to the 
point. Multiplexing on 2zone advertising, new 2zone project, initial 
works for my new photo studio, X-zone wifi network, doing some charity 
for children next week, and my primary work, Walmark, I am being 
put on 5 new projects :-)

Keep in mind though that another occasion when you use computed indices 
with PICK/POKE is when you do stuff like s/(x) or s/(x): val, since 
path references for series should be using PICK/POKE internally.

Same with x/0.

the performance of the Red program is a bit dissappointing

 Maybe I should have kept Red project secret until v1.0 to avoid "deceiving" 
 people who thinks that any v0.x version should be equal to a v1.0...;-)

I gave the topic of the "speed" more thoughts, and though I am very 
uneducated in lower level internals and language designs, I think 
that I might have more understanding, why I can't think about Red 
being just a compiler to Red/System in a 1:1 manner. In such a case, 
Red would not be needed. What needs to be included in the final exe 
is kind of "engine", supporting stuff like GC, all the dynamic things, 
type checking engine, etc etc. 


When I ask myself, if I am willing to exchange dynamic stuff for 
speed, I say - no, at least not necessarily. It was just that I got 
trapped by first R/S performance tests, and thinking that if Red 
compile, it has to be almost that fast too.


As for waiting for 1.x and possible optimisations - I don't believe 
optimisations can change things drastically, at least non in order 
of a magnitude. But - we will see.

It would be really nice to have automatic builds+tests running on 
all major supported platforms for each new commit on main branch, 
and an automatic report generated online. That would really saves 
us time and avoid missing some obvious regressions.


I know that Andreas started working on that. Andreas, do you already 
have a good plan to achieve it?  Do you need help/resources?


I can provide a Linux server for Linux/x86 targets. Having a Windows 
machine online + MacOS X would be great. Also a Linux/ARM (RPi for 
example) that is always up and reachable from the net could nicely 
complete the list.

Doc, would this Linux server you could provide be able to run VMs 
with OS X and Windows in order to do multi-platform automated builds? 
I'm thinking we could set things up like Unity does (see the link 
below). JetBrains provides TeamCity (the continuous integration server) 
for free to OS projects with an active community.


http://blogs.unity3d.com/2011/10/21/build-engineering-and-infrastructure-how-unity-does-it/

From the Unity link: "Most of these are virtual machines running 
Windows, Mac OS X, and Linux." 


I though Apple was explicitly forbidding to install Mac OS X on anything 
other than Apple hardware? Do they sell special licenses for VM?

Re atomic operation: atomic "x: x + 1", for example.

Ok, I see what you mean. Like in C, you can already write "thread-safe" 
code in Red/System by using only variables on stack. If you need 
concurrent access to global variables, usually, the OS are already 
providing some API for that (locks, semaphores, mutex,...). I haven't 
chosen yet how it will be implemented at Red/System level, there 
are different options. For example, it could be handled by the language 
directly using a similar construct as in Java:

    synchronize [ x: x + 1 ]


In my early design notes, I have researched only how to handle concurrency 
at Red level, I've left the underlying Red/System part as an "implementation 
detail". I plan to start working on it after I/O will be implemented.

@Doc : About the R2/R3/Red console enhancements, I've always missed 
the MS way to move/select  from left to right (on a word by word 
basis - MOVING on a word-by-word is CTRL+left / right Arrow and adding 
the SHIFT key in combination with the CTRL means SELECT - it's that 
simple) but going to the beginning or ending of the line is at least 
a welcome start ... if we want to go this way - and then going right 
or left on a character basis - as is for now!  And for right-handed 
ppl it would also be welcome to restore the old MS way of handling 
the current left-handed ppl to do CTRL-X / C / V  - which were CTRL-DEL 
or SHIFT-DEL / CTRL-Insert / SHIFT-Insert - but this kind of thing 
I can add myself when time comes ... it's just a matter of being 
more productive - it's far from being a "caprice des Dieux". For 
opponents : If you've never experimented it - you then never used 
it either on a regular basis and you can't catch why I regret this 
not being supported anymore in recent MS software too ... but this 
is deceptive either from them since it costs so few to leave it there 
in the first place. However I must admit that on my iPhone and other 
mobile tools I will miss it in anyway - until I code my own keyboard 
for this use too !!!

using the latest commit under OS X

I know that François Jouen is already using Red/System to make image 
capturing from multiple cameras on OS X. Also as a rule of thumb, 
everything that is doable in C can be also achieved in Red/System.

No one will be impressed with normal GUI, email, database capabilities, 
even if it's 10x more productive, but anything multimedia, video, 
3D, etc. which demonstrates "modern" capabilities, and beats other 
solutions, works on mobile, etc., then they're much more likely to 
go "hmmm".

I was pretty sure GDK required X.

You could compile GDK on DirectFB instead of X, but it would be a 
lot of work

Livecode cross-compiles to any platform.  I can build Windows, Mac, 
Linux, Android, and Web apps, and X-code projects, with the click 
of a button *all on my Windows machine (or on a Mac or Linux box, 
if I want).

red>> %/x

*** Script error: action 42 not defined for type: 2

I've added executables for all six current Red target platforms: 
Syllable, Linux, Linux-ARM, Android, Darwin (OS X) and MSDOS (Windows)

So back then, the Red/System binary took 15x the time of the C binary 
to run to completion. And yes, that was before the float optimisations 
:)

Do you have OS X 10.5 yet?

:) It's hard to get the best wording. When I read "the iPhone default 
compression is 85%", I would expect the JPEG file to be 85% the size 
of the uncompressed TIFF file. This is not the case. An uncompressed 
TIFF file from GCam is 23.9 MB, a JPEG is 10x smaller at around 2 
MB. The quality is 85% meaning you loose 15% information, if you 
save as JPEG and not TIFF.


I went with "The JPEG format is compressed at 85% quality setting, 
as is customary on the iPhone."

Thanks again, guys.

regarding version: this .apk should be compatible and run on Adroid 
v2.2.x (FROYO) and up

e.g. col 1 would be a union of all available words, and each row 
would have a check if lang-x supports it.

AFAIU, 0.4.x for Syllable Server sounds appropriate (it seems to 
be "just" a Linux distribution).

set 'parse-phone-num func [
        num [string!]
        /local  digit digits sep _ext_  ch nums pin ext
    ] [
        digit:  charset "0123456798"
        digits: [some digit]
        sep:    charset "()-._"
        _ext_:  ["ext" opt "." | "x"]

        nums: copy ""
        rules: [
            any [
                some [sep | copy ch digit (append nums ch)]
                | _ext_ copy ext digits
                | "pin" copy pin digits
            ]
            end
        ]
        either parse trim num rules 
            [reduce ['num nums 'ext ext 'pin pin]]
            [none]
    ]

    set 'well-formed-phone-number? func [num /local data] [
        either none? data: parse-phone-num num [false] [
            any [
                found? find [7 10] length? data/num
                all [11 = length? data/num  data/num/1 = #"1"]
            ]
        ]
    ]

layout [x: text "test"]
;update x/text with a long text
x/line-list: none
show x

hah! I wrote something similar:

indent: func [s /local x] [parse/all s [x: (insert x "^-") any [thru 
newline x: (insert x "^-")]] s]

When I use rename function to rename a file, the file date on my 
Mac OS X changes too. When I change a name using finder, carefully 
clicking the file and renaming it, the date does not change. Doe 
sthis happen on other platforms too? How to steer this behaviour?

Guiseppe: "I am not ablie to understand the use of Break. Why it 
is useful ?"
I'll try to explain:

>> parse/all "http://a.txthttp://b.dat"[any [to "http://"copy 
x any [".txt" | ".dat" | skip] (print x)]]

http://a.txthttp://b.dat;it prints just one line, from the first 
http:// to the last .dat


>> parse/all "http://a.txthttp://b.dat"[any [to "http://"copy 
x any [".txt" break | ".dat" break | skip] (print x)]]

http://a.txt;now it works as expected, from http:// to .txt 
and breaks
http://b.dat;and from the next http:// to .dat

But still there is a problem in your example. Here I'll try to explain:


>> parse/all "http://a.txthttp://b.dat"[any [to "http://"copy 
x any [thru ".txt" (print 1) break | thru ".dat" (print 2) break 
| skip (print 3)] (print x)]]
1
http://a.txt
2
http://b.dat


it looks correct. but actually it depends on which one is first (.txt 
or .dat)

here is the problem:

>> parse/all "http://a.txthttp://b.dat"[any [to "http://"copy 
x [thru ".dat" (print 1) | thru ".txt" (print 2) | skip (print 3)] 
(print x)]]
1
http://a.txthttp://b.dat

Arnold: I believe that Rebol/View uses Windows Codepages under Windows, 
MacRoman on OS X and ISO-8859-1 on  Linux. Sadly this means it only 
really supports true ASCII characterrs cross platform unless you 
manage encoding your self.

It compares words and types, not values.
>> o: context [a: 1 b: "x"]
>> p: context [b: "x" a: 1]
>> s: context [b: "o" a: 1]
>> similar? o p
== true
>> similar? o c
== true

here is the tests:
>> rle "aaabbcx"
== [3 #"a" 2 #"b" 1 #"c" 1 #"x"]
>>
>> rle []
== []
>>
>> rle ""
== []
>>
>> rle [a]
== [1 a]
>>
>> rle [a a a a a]
== [5 a]
>> rle [a a a a a b b]
== [5 a 2 b]

Here's a version for R3 parse, with some optimizations:

rle2: funct ["Run length encode" b [series!]] [
	output: copy [] x: none

 r: either any-block? :b [qr: copy [quote 1] [(qr/2: :x) any qr]] 
 [[any x]]
	parse :b [any [pos1: set x skip r pos2: (
		reduce/into [subtract index? :pos2 index? :pos1 :x] tail output
	)]]
	output
]

rle2: funct ["Run length encode" b [series!]] [
	output: copy [] x: none

 r: either any-block? :b [qr: copy [quote 1] [(qr/2: :x) any qr]] 
 [[any x]]
	parse/case :b [any [pos1: set x skip r pos2: (
		reduce/into [subtract index? :pos2 index? :pos1 :x] tail output
	)]]
	output
]

>> rle2 [a a A b b c d D d d d]
== [2 a 1 A 2 b 1 c 1 d 1 D 3 d]

Here's a R2 solution with same rules for string! and block! series:

rle: func [s [series!] /local out c i][
    out: make block! 1

    parse/case/all s [
        any [
            [end | c: (
                c: either word? c/1 [to-lit-word c/1][c/1]
                i: 1
            )]
           skip
           some [
               c (i: i + 1)
               | (repend out [i c]) break
           ]
       ]
    ]
    out
]

>> rle "aaabbcx"
== [3 #"a" 2 #"b" 1 #"c" 1 #"x"]

>> rle [a a a a a]
== [5 a]

>> rle [a a a a a b b]
== [5 a 2 b]

>> rle [a a A b b c d D d d d]
== [3 a 2 b 1 c 5 d]

R3 version, same /into option:


rle: funct ["Run length encode" s [series!] /into output [any-block!]] 
[
	unless into [output: make block! 2] x: none

 r: either any-block? :s [qr: copy [quote 1] [(qr/2: :x) any qr]] 
 [[any x]]
	parse/case :s [any [pos1: set x skip r pos2: (

  output: reduce/into [subtract index? :pos2 index? :pos1 :x] :output
	)]]
	either into [:output] [head :output]
]

Sorry, same unset problems, have to use POKE:


rle: funct ["Run length encode" s [series!] /into output [any-block!]] 
[
	unless into [output: make block! 2] x: none

 r: either any-block? :s [qr: copy [quote 1] [(poke qr 2 :x) any qr]] 
 [[any x]]
	parse/case :s [any [pos1: set x skip r pos2: (

  output: reduce/into [subtract index? :pos2 index? :pos1 :x] :output
	)]]
	either into [:output] [head :output]
]

Ehm.. what about the decoder? how do I decode unset! values?
I was using somthing like:

decode-rle: func [b /local r] [r: copy [] foreach [x y] b [loop x 
[append r y]]]

decode-rle: func [b /local r i] [

 i: 0  r: make block! foreach [x y] b [i: i + x] ;better for big blocks?
 foreach [x y] b [loop x [append r y]]
]

In mezzanine style:

decode-rle: func [
	"Decode a run length encoded block"
	rle [any-block!] "Block of [integer value]"

 /into "Insert into a buffer instead (returns position after insert)"
	output [series!] "The output buffer (modified)"
	/local x
] [
	unless into [
		x: 0  foreach [i v] :rle [x: x + :i]  output: make block! x
	]

 foreach [i v] :rle [output: insert/only/dup :output get/any 'v :i]
	either into [:output] [head :output]
]


Instead of testing for strict format compliance of the input block, 
it uses get-words to keep people from sneaking in functions and then 
passes the length value to + and INSERT/dup, counting on the type 
tests of those functions to do the screening for us.

decode-rle: func [
	"Decode a run length encoded block"
	rle [any-block!] "Block of [integer value]"

 /into "Insert into a buffer instead (returns position after insert)"
	output [series!] "The output buffer (modified)"
	/local x
] [
	unless into [
		x: 0  output: make block! forskip rle 2 [x: x + :rle/1]
	]
	forskip rle 2 [output: insert/only/dup :output :rle/2 :rle/1]
	either into [:output] [head :output]
]

Here's a version of my last one above, but with Steeve's trick adapted 
to make a /compare option. It defaults to its old case-sensitive 
behavior.

rle: func [
	"Run length encode to series of [length value]"
	s [series!] "The series to encode"

 /into {Insert into a buffer instead (returns position after insert)}
	output [any-block!] "The output buffer (modified)"
	/compare "Comparator function for equvilance"
	comparator [any-function!]
	/local x r qr b e
] [
	unless into [output: make block! 2] x: none
	r: case [
		compare [[any [e: if (apply :comparator [:x :e/1]) skip]]]
		any-string? :s [[any x]]
		'else [qr: copy [quote 1] [(poke qr 2 :x) any qr]
	]
	parse/case :s [any [b: set x skip r e: (
		output: reduce/into [offset? :b :e :x] :output
	)]]
	either into [:output] [head :output]
]

Whoops, forgot a bracket:

rle: func [
	"Run length encode to series of [length value]"
	s [series!] "The series to encode"

 /into {Insert into a buffer instead (returns position after insert)}
	output [any-block!] "The output buffer (modified)"
	/compare "Comparator function for equvilance"
	comparator [any-function!]
	/local x r qr b e
] [
	unless into [output: make block! 2] x: none
	r: case [
		compare [[any [e: if (apply :comparator [:x :e/1]) skip]]]
		any-string? :s [[any x]]
		'else [qr: copy [quote 1] [(poke qr 2 :x) any qr]]
	]
	parse/case :s [any [b: set x skip r e: (
		output: reduce/into [offset? :b :e :x] :output
	)]]
	either into [:output] [head :output]
]

Yes. It uses the IF and QUOTE operations, SET working on string parsing, 
PARSE default /all, :x meaning GET/any 'x, REDUCE/into, and equality 
finctions handling unset! values.

Functions and objects aren't copied, but everything else seems to 
be:


>> a: reduce ["" #{} 'a/b [] quote () make list! [] make hash! [] 
does [] context []]

== ["" #{} a/b [] () make list! [] make hash! [] func [][] make object! 
[
    ]]
>> b: bind/copy a 'a

== ["" #{} a/b [] () make list! [] make hash! [] func [][] make object! 
[
    ]]
>> map-each [x: y] b [same? :y first at a index? x]
== [false false false false false false false true true]

map-each [x: y] [...] is an interesting use. I sometimes needed to 
get that "index" value but I didn't know that usage so I used forall 
instead. Good to learn.

Got it, thanks a lot. I didn't know that FIRST gives me a "new" word, 
I thought that I'm BINDing *the* word itself and it should stay BINDed.

This confused me a bit:
>> o: context [a: 1 b: 2 c: 3]

>> foreach x bind [a b c] o [probe get x] ;this works, BINDs block 
to O

>> foreach x [a b c] [probe get bind x o] ;this works too, BINDs 
the word 'X to O

No, it doesn't bind 'x, it binds x, which is evaluated to 'a, 'b 
or 'c.

If you write in the loop: bind 'x o, it will fail, because 'x is 
not defined in o.

Endo, when you are using set-words with MAP-EACH and R3's FOREACH, 
be sure to include at least one regular word, or it won't advance 
and you'll get an endless loop. We made that possible in order to 
support the foreach [x:] data [... take x ...] code pattern. It's 
the type of thing that would generate a warning in other languages, 
but REBOL is inherently incompatible with warnings.

so you couldn't do   x + recur [ y ]

example:

            safe: tail-func [x] [
                if x > 20000 [print x exit]
                tail-call x + 1
            ]

Test case:

safe: rfunc [x] [
    if x < 5000 [recur x + 1]
    x
]
safe 1000
== 5000

re "any spec accepted", here are differences:

>> safe: rfunc [throw] [if x < 20000 [recur x + 1]]
** Script Error: throw has no value
** Where: throw-on-error
** Near: rfunc [throw] [if x < 20000 [recur x + 1]]

, while:


>> safe: tail-func [throw] [if throw < 20000 [tail-call throw + 1]]
>> safe 0
== none

What I specifically mean is this:

f: rfunc [x] [if x = 2 [g/recur 3 5]]

which does not look like making sense, although it can be written

However, Steeve, you probably do not understand what the problem 
with the

    f: rfunc [x] [if x = 2 [g/recur 3 5]]


code is. The problem in a nutshell is that the G/RECUR call uses 
G/RECUR calling convention and "expects" the G/RECUR call to be used; 
however, the CATCH/NAME+THROW/NAME pair does not respect that and 
actually would do the call of F/RECUR.

in R2 map! is there just for compability. map! = hash! in R2.

x: make map! [a 1 b 2]
series? x ; == true (for R2)
series? x ; == false (for R3)

We've done that for two years now, but that was on our in-house Syllable 
Workstation, Syllable Server with GoboLinux transplanted on top of 
it. Now I'm running on pure Syllable Server, with X built from source

On the other hand, I've just spent the equivalent of a full work 
week just to get the legacy fonts in X that R2/View needs

I've got the Enlightenment stack running on X now, up to the widget 
set

That was a lot easier than View. It's currently a very minimal X 
configuration

I've got GTK 2 built from source running on X now, but GTK 3 bombs 
out

Now I've got Qt running on X. That didn't work in the GoboLinux mix

Are you sure Max?
>> x: to-url "@@@"
== @@@

End user downloads X's app/uses your

End user X downloads Y's app/uses Y's web site; X tries to access 
a function that uses your site; Y requests a temp key from you; Y 
directs X to your site with temp key, X says Y is OK, you give X 
a PIN; X goes back to Y, enters PIN; Y requests the permanent key 
from you.  Y can now do anything on your site on behalf of X.