World: r3wp

an then 32 bits for miliseconds or something like this?

The unix-timestamp could be any date/time.. so I think I have to 
work top down.. first find the year then month, day, hour, min, sec. 
    Kind of like building a binary number from a decimal.. top-down.

Precision (ms) is used/not used depending on the OS / config.

I have some MRTG/RRDTool files that I am parsing for certain data 
and they all use the unix-timestamp format (not including ms)

i thought it is just an integer. So it is more complicated build, 
with year, month etc?

Yeah.  the date -> unixTime function from someone else (maybe Gabrielle) 
is..
to-unix-time: func [date] [
  date/date - 1-1-1970 * 86400 + to-integer date/time
]

then you could reverse that. as my example shows, you can add times 
to dates. i think it works also in that large range.

Yeah.  My problem (I think) is accounting for leap years and the 
different lengths of months.

Little casio watches know all of this info (Year/month/day/time). 
 I suspect it is in a static table inside the watch.  I have been 
looking for something like this on the web.

I could easily build a table for month lengths.. it is the leap-year 
that I just don't want to think about.

That should be inbuild. i guess rebol stores internally just a big 
integer too.

you could try
  1-1-1970 + unix-seconds
and see what happens.

1-1-1970 + to-time unix-seconds

You might be on to something.. I did unix time (now) and it returned 
24-Dec-13007.  However, maybe I need to subtract not add.  I will 
play with this SIMPLE solution.  (I always try to look at it harder 
than it probably needs to be).  Thanks.

>> 1-Jan-1970/0:0:0 + to-time to-unix-time 15-Apr-2006/15:41:0
== 15-Apr-2006/15:41

Looks like the time just needs to be inlcuded...

i've this function: f: [variable] [variable: 100]
variable: 10
f variable
== 100
variable
== 10

the question is 1 why do i never noticed this :) and second how do 
i pass values by reference

You're not talking about this ?

 f: func ['word][ set word 10 ]

This might do it -- change the way you define f:
 use [variable] [f: [variable] [variable: 100]]
variable: 10
== 10
f variable
== 10
variable
== 10

note: "variable" is a global value still i get no results from this 
:(

>> f: func ['variable][ set variable 100 ]
>> variable: 10
== 10
>> f variable
== 100
>> variable
== 100

thanks graham it worked well

I rarely change values by reference, only series/objects. values 
i simply assign new.
 f: func[variable][100]
 variable: variable 100
If not, i at least mark the word, like
 f: func[variable][ set variable 100]
 f 'variable

Its style, but in rebol i rarely see a function changes a word, so 
i am avoiding to be surprised.

O.K.
Thanks to everyone for their help.

I offer my final (not that it's the best) rendition of these conversion 
functions.


to-unix-time: func [
  "Create unix-timestamp.  Author: Gabriele_3-Aug-2002."
  date [date!] "Rebol-format date. (non-Milisecond type)."
][
  date/date - 1-1-1970 * 86400 + to-integer date/time
]

from-unix-time: func [

  "Create rebol-timestamp from unix-timestamp.  Author: Rebolers-Altme_2005."
  utime [integer!] "Unix timestamp."
][
  unixTimestampConstant + to-time utime
]  

-- OR an all-in-one --

unixTimestamp: func [

  "Rebol date to/from unix timestamp conversion.  Authors: Many rebolers.."

  varIn "Enter either a Date!type or Integer!type to convert to/from 
  unix/rebol."
][

   unixTimestampConstant: 1970-01-01/00:00:00           ;Reference.
   varOut: "ERR"

   if ((type? varIn) = date!) [                         ;from rebol, 
   to unix.

     varOut: varIn/date - 1-1-1970 * 86400 + to-integer varIn/time
   ]

   if ((type? varIn) = integer!) [                      ;from unix to 
   rebol.

     if (varIn >= 0) [                                  ;B.U.  (before 
     Unix.)
       varOut: unixTimestampConstant + to-time utime
     ]
   ]
   return varOut
]

John.

>> difference now 1-1-1970
== 313646:34:14
>> to integer! difference now 1-1-1970
== 1129127658

BIG TYPO on the last post.. 

unixTimestamp: func [

  "Rebol date to/from unix timestamp conversion.  Authors: Many rebolers.."

  varIn "Enter either a Date!type or Integer!type to convert to/from 
  unix/rebol."
][

   unixTimestampConstant: 1970-01-01/00:00:00           ;Reference.
   varOut: "ERR"

   if ((type? varIn) = date!) [                         ;from rebol, 
   to unix.

     varOut: varIn/date - 1-1-1970 * 86400 + to-integer varIn/time
   ]

   if ((type? varIn) = integer!) [                      ;from unix to 
   rebol.

     if (varIn >= 0) [                                  ;B.U.  (before 
     Unix.)
       varOut: unixTimestampConstant + to-time varIn
     ]
   ]
   return varOut
]

John.
BIG TYPO on the last post.. 

unixTimestamp: func [

  "Rebol date to/from unix timestamp conversion.  Authors: Many rebolers.."

  varIn "Enter either a Date!type or Integer!type to convert to/from 
  unix/rebol."
][

   unixTimestampConstant: 1970-01-01/00:00:00           ;Reference.
   varOut: "ERR"

   if ((type? varIn) = date!) [                         ;from rebol, 
   to unix.

     varOut: varIn/date - 1-1-1970 * 86400 + to-integer varIn/time
   ]

   if ((type? varIn) = integer!) [                      ;from unix to 
   rebol.

     if (varIn >= 0) [                                  ;B.U.  (before 
     Unix.)
       varOut: unixTimestampConstant + to-time varIn
     ]
   ]
   return varOut
]

John.

Is there a way to have small decimal numbers shown, as you write 
them, when converted to a string? Instead of this:
>> to-string 0.08
== "8E-2"
I would like the output to be "0.08".

:-)) last week or so there was rather long discussion here :-)

I have form-decimal function for that, but others might have posted 
other solutions ...

wait a bit - will look into my flash disk if I have it here, otherwise 
I have it at my work on my PC ...

ok

try this - found some arcane version, hopefully it will work ...

form-decimal: function [num][tmp main rest sign base][

     either found? find tmp: to-string num "E" [

              parse tmp [
                 copy main to "."
                 skip
                 copy rest to "E"
                 skip
                 mark: (sign: copy/part mark 1)
                 skip
                 copy base to end
               ]


        either sign = "-" [

                tmp: "0."

                loop ((to-integer base) - 1) [insert tail tmp "0"]
                insert tail tmp rest
        ][
                tmp: copy ""

                insert tail tmp join main rest

                loop ((to-integer base) - (length? rest)) [insert tail tmp "0"]  
                    
                           
        ] 
     
      tmp                 

     ][num] 

]

but please - take into account that my coding capabilities are, ehm, 
rather weak :-)

:-) Ok, thanks Pekr!

eh, does not seem to work ...

I will look into it and try to post correct version ...

Try this one:

form-decimal: func [num /local tmp main rest sign base][

     either found? find tmp: to-string num "E" [

              parse tmp [
                 [copy main to "." 
                  skip
                  copy rest to "E"
                  |
                  copy rest to "E"
                  (main: copy "")  
                  ]
             
                 skip
                 mark: (sign: copy/part mark 1)
                 skip
                 copy base to end
               ]


        either sign = "-" [

                tmp: copy "0."

                loop ((to-integer base) - 1) [insert tail tmp "0"]
                insert tail tmp rest
        ][
                tmp: copy ""

                insert tail tmp join main rest

                loop ((to-integer base) - (length? rest)) [insert tail tmp "0"]  
                    
                           
        ] 
     
      tmp                 

     ][num] 

]

first one did not take into account 1E-2, simply a version, where 
there is no "." in it ....

and I believe folks here will introduce just few lines version later 
:-)

On 6-October Volker posted this reply:


Pekr: "I did not find an easier way, so I parse for E, then I distinguish 
the sign, the number -5 in above case, and then I compose the string 
:-)"
!> a: 123.456 reduce[to integer! a remainder a 1]
== [123 0.456000000000003]

Maybe the base for something better (dont know how easy that parsing 
is?)

turned out to be http://polly.rebol.it/test/test/snippets/epad1.r
. longer and not so readable. but seems to work.

I think, this version do the job:

form-decimal: func [n /local p d] [
	if p: find n #"E" [
		if d: remove find n #"." [d: index? d p: back p]
		if not d [if d: remove find n #"," [d: index? d p: back p]]
		if not d [d: 2]
		either p/2 = #"-" [
			insert/dup n #"0" (to-integer skip p 2) - 1
			insert n "0."
		][
			insert/dup p #"0" (to-integer next p) - (index? p) + d
		]
		clear find n #"E"
	]
	n
]

nope, not quite

This must be it:

form-decimal: func [n /local p d] [
	if p: find n #"E" [
		if d: remove find n #"." [d: index? d p: back p]
		if not d [if d: remove find n #"," [d: index? d p: back p]]
		if not d [d: index? p]
		either p/2 = #"-" [
			insert/dup n #"0" (to-integer skip p 2) - d + 1
			insert n "0."
		][
			insert/dup p #"0" (to-integer next p) - (index? p) + d
		]
		clear find n #"E"
	]
	n
]

Maybe there should be a
n: form n
in the beginning to support more datatypes.

Is there any way Rebol files can be made to be multi-user friendly?

Louis, multi-user friendly!? What do you mean? That one user can 
lock a file for some time, so others can't access it? Or what?

Louis, in Core or View ? In View, you can read/write to the public 
cache.

This is VIEW-ROOT (the directory you selected during install, by 
default it is in a windows user profile directory).

When you click on an app from a rebsite, it is saved (by READ-THRU, 
PATH-THRU) into the public cache before running.
So, if it is your app, say at 
http://yoursite.com/app.r
then it could save prefs files to
path-thru http://yoursite.com/app-prefs.r
eg.
	save path-thru http://yoursite.com/app-prefs.r[my prefs data]