r3wp [groups: 83 posts: 189283]
  • Home
  • Script library
  • AltME Archive
  • Mailing list
  • Articles Index
  • Site search
 

World: r3wp

[Core] Discuss core issues

DanielSz
10-Oct-2007
[8757x3]
Thanks, Pekr, DocKimbel would be indeed the person to ask because 
of his work on the mySQL drivers. After all, a directory (on which 
LDAP focuses)  is nothing but a specialized database. I'm not sure 
what my needs are because I just started playing with it. Maybe Rebol 
can assist in the conversion of external sources (CSV for example) 
to ldif format and possibly populating the directory automatically.
Softinnov says the following on its web site:
This project aims to propose a standard LDAP support for REBOL/Core 
by implementing the LDAP protocol using REBOL schemes (ldap://), 
so standard functions like open, insert, find, remove,... can be 
used directly on the port.


The implementation is an on-going work and has been suspended for 
some months now (due to higher priority projects). The current alpha 
supports the following features : 
BER encoding/decoding logic.
REBOL dialect for BER structures representation.
Basic LDAP v3 protocol.
Searching for record using a high level dialect
Port handler implemented.
What's not currently implemented: 
Clean and reliable low-level I/O.
Full v2/v3 protocol support.
Adding, Modifying, Deleting data.
Authentication.

The current work has been done following the classic REBOL port! 
communication model, that means : synchronous communications. There's 
great chances that I choose to port the current work under Uniserve 
to benefit from a full async model and not push the sync version 
to the end...
Henrik
11-Oct-2007
[8760x9]
I'm stuck with a BIND problem. What may cause a value that is a string 
to become NONE when it's bound to a block? It's only this one value 
out of several that I have problems with. There are other strings 
bound to the block that work correctly. I have no idea what's going 
on. Suggestions?
the bind is in a foreach loop that very roughly looks like so:

a: [c d e]

f: [stuff (c)  more stuff (d)]

foreach :a b [
...stuff
  compose/deep bind f 'c
...stuff
]


For some reason 'c in the bound block is NONE. I tried binding to 
'd, copy/deep the block, but nothing.
If I probe 'c just before the bind, it has the correct value
if I change 'c to some random word, that doesn't help either.
I think I'm figuring it out.... nasty bind problem
DO MOLDing a block should shake off all bindings right? it doesn't 
seem to happen here.
Very interesting stuff... but hard to explain. I've not solved the 
problem, but my bindings are apparently a mess.
YEAH!
sorry about that, but this problem has bugged me for several days. 
Finally nailed it. I figured it out: If you have a function with 
local words, FOREACH creates its own context for the words that it 
uses. I had 'value both as a local word and as a word inside the 
FOREACH, hence the confusion.
[unknown: 5]
11-Oct-2007
[8769]
I have had problems before with using 'value.  I try to avoid it 
now - maybe it was a foreach function - I don't recall.
Henrik
15-Oct-2007
[8770]
is there a simple way of converting a block of true/false values 
into bits in a binary?
Gregg
15-Oct-2007
[8771]
Use INSERT for the true values, and remember that bitsets have a 
zero base.

>> bs: make bitset! []
== make bitset! #{
0000000000000000000000000000000000000000000000000000000000000000
}
>> blk: [true false true false true false true]
== [true false true false true false true]
>> repeat i length? blk [if blk/:i [insert bs i - 1]]
== make bitset! #{
7F00000000000000000000000000000000000000000000000000000000000000
}
Henrik
15-Oct-2007
[8772x3]
I see. :-/
hmm.. can't convert that to an integer.
to-integer trim to-binary bs

seems to work.
Terry
16-Oct-2007
[8775]
a: [11 22 33 44 55 66 77 88 99]

b: 44
foreach [ s p v] a [ if s = b [ remove s p v ???]
sqlab
16-Oct-2007
[8776]
while [pick set [s p v] a 1] [if s = b  [remove/part a 3  a: skip 
a -3] a: skip a 3]
btiffin
16-Oct-2007
[8777x2]
Another opinion piece;
While developing I've taken to starting each script with


;; if a symbol exists and is true, when will evaluate the block of 
code
;; when/not will evaluate the code if the symbol is not set
when: func ['condition [word!] code [block!] /not] [
    either not [
        unless value? condition code
    ][
        if all [value? condition  get condition] code
    ]
]

This allows for

; See if testing requested as script argument or it could be set 
by a caller
when/not testing [

    if all [system/script/args  find system/script/args "/test"] [
        testing: on
    ]
]
; If requested, try loading the test facility or stub it.
when testing [
    absent test [
        if error? try [do %../Test/test.r] [
            test: func ["test stub" drop [block!]] []
        ]
    ]
]


I had been using  given  and  absent (for when/not).  Anyone got 
a better way of handling conditional load sequences and command line 
argument passing that supports development cycles while not having 
to change the code for testing, autodocing  and production rollout?
Oops, an absent snuck in there from and older (untested...sad) cut'n'paste
   when testing [  when/not test ...
Terry
16-Oct-2007
[8779]
Thanks sq
Ladislav
17-Oct-2007
[8780]
foreach [ s p v] a [ if s = b [ remove s p v ???]
 - this is the Rebol way:
remove-each [s p v] a [s = b]
Terry
17-Oct-2007
[8781]
Cool, was wondering how remove-each worked, thanks Ladislav.
Sorry sq.
sqlab
17-Oct-2007
[8782]
I learned something too
Terry
21-Oct-2007
[8783x2]
With inline javascript in HTML, it's not uncommon to find a brace, 
apostrophe and a double quote in a single line  ie:


<a href="#"  onclick="$('test').function(){'some', 'options';}">Hrmm</a>

So, what's the best method for prepping this for output?

output: {}   ... then escape the all braces?
Braces are ok, if there's always a pair.. otherwise i guess the best 
method is braces, and escape any in the string with ^{   or ^}
Graham
21-Oct-2007
[8785x2]
it gets really messy though
what we need is some other way to enclose literal strings that are 
full of " ' and {}
Terry
21-Oct-2007
[8787]
aye
Gregg
21-Oct-2007
[8788]
I would avoid the "some other way", because you're always going to 
hit the issue with some char. At least escapes are consistent and 
easy to reason about. Of course, that doesn't help when they aren't 
used properly.
Graham
21-Oct-2007
[8789x2]
that other way would be the way it is done in embedded sql, you can 
often redefine the termination character.
So, I would want some way to redefine temporarily the {  or } pair. 
 Eg use a pipe character instead .. hardly ever see those used in 
 web pages
Oldes
25-Oct-2007
[8791]
Is there any script to detect JPG size without need to load the image?
btiffin
25-Oct-2007
[8792]
Rebol.org  exif-image.r  (uses exif-core.r) and has a jpeg-size function. 
 Didn't read enough to see if it loads the whole file before it looks 
for the size fieldsm but I don't think Piotr's routines requires 
a load.
Oldes
25-Oct-2007
[8793x2]
it would not be working if exif tag is not present.. never mind... 
I could probably enhance my jpg-analyse script.. decoding Start Of 
Frame marker, which may contain the real size info
yes.. it's bytes 5,6 for width and 7,8 for height after #{FFC0} marker
Graham
25-Oct-2007
[8795x2]
Is there any way for a rebol process to detect other versions of 
itself running and to kill them?
encapped
Terry
25-Oct-2007
[8797]
for windows you could use the winapi
Steeve
25-Oct-2007
[8798x9]
very strange behaviour when using skip command during parsing of 
a binary string
f: read/binary %15.jpg

get-len: [header: skip  (len: to integer! as-binary cp/part header 
2) ]
skip-len: [:header (header: skip header len) :header]
parse f [
        #{FFD8}   ; jpeg Header
        [
                #{FFE0}                         ;JFIF header

                        get-len                 ;get length of a header (2 octets)

                         #{4A46494600}          ;yeah it's a JFIF (confirmation)
                        skip-len
                        some [
                                #{FF}

                                        #{C0}           ;good ! i found the length properties

                                        (print ["height" to integer! as-binary cp/part at header 6 2])

                                        (print ["width" to integer! as-binary cp/part at header 8 2])
                                        break

                                | #{FF}                 ;don't know this header
                                        skip    
                                        get-len 
                                        skip-len
                                | 

                                        [end  skip]     ;error format
                        ]
                        
                        
                | #{FFE1}                       ;EXIF header

                        get-len                 ;get length of a header
                                                ;... to do
                        [end skip]
        ]
        to end
]
very strange behaviour of skip and copy, i should check what release 
i use
it's just a proof of concept, it's not usable as-is for an open/seek 
 file mode
made an async parser (not fully tested - some problems may occur 
when the parser go back in the stream )

but the concept works :  when the parser encouter a skip command, 
the data are not readed from the file but the offset is modified.
REBOL []

parse-async: func [
        file rules
        /local port buffer offset getf seek meta & && result
][
        port: open/seek/binary  file
        buffer: clear #{}
        offset: 1
        getf: func [len][
                offset: offset - length? buffer
                clear buffer 
                append buffer copy/part at port offset len 
                offset: offset + len 
        ]
        seek: [(offset: offset + 1)]
        ..: func [blk] [change/part & compose/deep blk && ]
        parse rules meta: [
                some [

                        &: binary! &&: (.. [buffer: (to-paren reduce ['getf length? &/1]) 
                        (&/1)]) :& 3 skip 
                        | &: 'skip &&: (.. [seek]) :& skip
                        | &: 'get word! integer! &&:

                                (.. [buffer: (to-paren compose/deep [getf (&/3) set [(&/2)] to integer! 
                                as-binary cp buffer]) to end]) :& 4 skip

                        | &: string! &&: (.. [(as-binary &/1)]) :& 
                        | 'end 'skip 
                        | into meta
                        | skip
                ]
        ]
        result: parse/all buffer rules
        close port
        result
 ]
 
if parse-async %15.jpg [
        #{FFD8}   ; jpeg Header
        [
                 #{FFE0}                        ;JFIF header

                        get len 2               ;get data length  for the current header 
                        (2 bytes)

                         "JFIF"                 ;yeah it's a JFIF (confirmation)

                        (len: len - 6) len skip ;skip data (len) times
                        some [

                                 #{FFC0}        ;good ! i found the length properties

                                        2 skip  ; skip length of this header

                                        skip    ; filler ??? always = #{08}
                                        get height 2
                                        get width 2
                                        break   ; finished

                                | #{FF} skip    ;skip this header
                                        get len 2 
                                        (len: len - 2) len skip
                                | 

                                        [end skip]     ;error format
                        ]

                | #{FFE1}                       ;EXIF header

                        get len 2               ;get length of a header
                                                ;... to do
                        [end skip]
        ]
        to end
][
   ?? height
   ?? width
]        
halt
perhaps it's not clear, but this parser do not load all the file 
in memory but  only the needed part to retrieve the width and the 
height.
you can probe the contain of the 'buffer'  variable to have a proof
the concept of async parsing could be extended at any type of serie