root/trunk/ProjectFortress/LibraryBuiltin/CompilerBuiltin.fss

(*******************************************************************************
    Copyright 2009 Sun Microsystems, Inc.,
    4150 Network Circle, Santa Clara, California 95054, U.S.A.
    All rights reserved.

    U.S. Government Rights - Commercial software.
    Government users are subject to the Sun Microsystems, Inc. standard
    license agreement and applicable provisions of the FAR and its supplements.

    Use is subject to license terms.

    This distribution may include materials developed by third parties.

    Sun, Sun Microsystems, the Sun logo and Java are trademarks or registered
    trademarks of Sun Microsystems, Inc. in the U.S. and other countries.
 ******************************************************************************)

component CompilerBuiltin
import java com.sun.fortress.nativeHelpers.{simplePrintln.nativePrintln => jPrintln}
import java com.sun.fortress.nativeHelpers.{simpleConcatenate.nativeConcatenate => jConcatenate,
                                            simpleConcatenate.nativeStrlen => jStrlen}
import java com.sun.fortress.nativeHelpers.{simpleIntArith.intToString => jIntToString,
                                            simpleIntArith.intAdd => jIntAdd,
                                            simpleIntArith.intSub => jIntSub,
                                            simpleIntArith.intMul => jIntMul,
                                            simpleIntArith.intDiv => jIntDiv,
                                            simpleIntArith.intLT => jIntLT,
                                            simpleIntArith.intLE => jIntLE,
                                            simpleIntArith.intGT => jIntGT,
                                            simpleIntArith.intGE => jIntGE,
                                            simpleIntArith.intEQ => jIntEQ,
                                            simpleIntArith.intNeg => jIntNeg,
                                            simpleIntArith.parseInt => jParseInt,
                                            simpleIntArith.intAbs => jIntAbs,
                                            simpleIntArith.longToInt => jLongToInt}
import java com.sun.fortress.nativeHelpers.{simpleDoubleArith.doubleToString => jDoubleToString,
                                            simpleDoubleArith.doubleAdd => jDoubleAdd,
                                            simpleDoubleArith.doubleSub => jDoubleSub,
                                            simpleDoubleArith.doubleMul => jDoubleMul,
                                            simpleDoubleArith.doubleDiv => jDoubleDiv,
                                            simpleDoubleArith.doubleLT => jDoubleLT,
                                            simpleDoubleArith.doubleLE => jDoubleLE,
                                            simpleDoubleArith.doubleGT => jDoubleGT,
                                            simpleDoubleArith.doubleGE => jDoubleGE,
                                            simpleDoubleArith.doubleEQ => jDoubleEQ,
                                            simpleDoubleArith.doubleNeg => jDoubleNeg,
                                            simpleDoubleArith.parseDouble => jParseDouble,
                                            simpleDoubleArith.doubleAbs => jDoubleAbs,
                                            simpleDoubleArith.doublePow => jDoublePow,
                                            simpleDoubleArith.doubleNanoTime => jNanoTime}
import java com.sun.fortress.nativeHelpers.{LocalRandom.localRandomDouble => jRandomDouble,
                                            LocalRandom.localRandomInt => jRandomInt }
import AnyType.{Any}
export CompilerBuiltin

nanoTime(): RR64 = jNanoTime()

trait Object extends Any
end Object

trait String
    getter isEmpty(): Boolean = (jStrlen(self) = 0)
    getter asString(): String = self
    opr |self| : ZZ32 = jStrlen(self)
    opr ||(self, b:String): String =  jConcatenate(self, b)
    opr juxtaposition(self, b:String): String = jConcatenate(self, b)
end

object FlatString extends String
end FlatString

println(s:String):() = jPrintln(s)
println(x:ZZ32):() = jPrintln(x.asString)
println(x:ZZ64):() = jPrintln(x.asString)
(* println(x:RR32):() = jPrintln(x.asString) *)
println(x:RR64):() = jPrintln(x.asString)

strToInt(s:String):ZZ32 = jParseInt(s)

trait Number excludes { String }
    getter asString(): String
end

trait ZZ64 extends Number excludes { RR64 }
    getter asZZ32(): ZZ32 = jLongToInt(self)
end

trait ZZ32 extends Number excludes { ZZ64, RR64 }
    coerce(x: IntLiteral) = x.asZZ32
    getter asZZ32(): ZZ32 = self
    getter asString(): String = jIntToString(self)
    opr |self| : ZZ32 = jIntAbs(self)
    opr -(self): ZZ32 = jIntNeg(self)
    opr +(self, other:ZZ32): ZZ32 = jIntAdd(self,other)
    opr -(self, other:ZZ32): ZZ32 = jIntSub(self,other)
    opr <(self, other:ZZ32): Boolean = jIntLT(self,other)
    opr <=(self, other:ZZ32): Boolean = jIntLE(self,other)
    opr >(self, other:ZZ32): Boolean = jIntGT(self,other)
    opr >=(self, other:ZZ32): Boolean = jIntGE(self,other)
    opr =(self, other:ZZ32): Boolean = jIntEQ(self,other)
    opr juxtaposition(self, other:ZZ32): ZZ32 = jIntMul(self,other)
    opr DOT(self, other:ZZ32): ZZ32 = jIntMul(self,other)
    opr DIV(self, other:ZZ32): ZZ32 = jIntDiv(self,other)
end

trait IntLiteral
    getter asZZ32(): ZZ32
    getter asZZ64(): ZZ64
(*
    getter asNN32(): NN32
    getter asZZ(): ZZ
    getter asRR32(): RR32
*)
    getter asRR64(): RR64
end

trait RR64 extends Number
    getter asString(): String = jDoubleToString(self)
    opr |self| : RR64 = jDoubleAbs(self)
    opr -(self): RR64 = jDoubleNeg(self)
    opr +(self, other:RR64): RR64 = jDoubleAdd(self,other)
    opr -(self, other:RR64): RR64 = jDoubleSub(self,other)
    opr <(self, other:RR64): Boolean = jDoubleLT(self,other)
    opr <=(self, other:RR64): Boolean = jDoubleLE(self,other)
    opr >(self, other:RR64): Boolean = jDoubleGT(self,other)
    opr >=(self, other:RR64): Boolean = jDoubleGE(self,other)
    opr =(self, other:RR64): Boolean = jDoubleEQ(self,other)
    opr juxtaposition(self, other:RR64): RR64 = jDoubleMul(self,other)
    opr DOT(self, other:RR64): RR64 = jDoubleMul(self,other)
    opr /(self, other:RR64): RR64 = jDoubleDiv(self,other)
    opr ^(self, other:RR64): RR64 = jDoublePow(self,other)
    opr ^(self, other:ZZ32): RR64 =
        if other > 2 then
            mid = other DIV 2
            if (mid + mid) = other then
                self2 = self self
                (self2)^mid
            else
                self (self^(other-1))
            end
        elif other = 2 then self self
        elif other = 1 then self
        elif other = 0 then 1.0
        else (* other < 0 then *) 1.0 / (self^(-other))
        end
end

trait RR32 extends Number
end

object FloatLiteral extends RR64
end

trait Boolean
end

true : Boolean = (0=0)
false : Boolean = (0=1)

(************************************************************
* Random numbers
************************************************************)

random(i:RR64): RR64 = jRandomDouble(i)
randomZZ32(x:ZZ32): ZZ32 = jRandomInt(0,x)

end