(*
 Oukseh Lee

 Copyright(c) 2000-2004 KAIST/SNU Research On Program Analysis System
 (National Creative Research Initiative Center 1998-2003)
 http://ropas.snu.ac.kr/n

 All rights reserved. This file is distributed under the terms of
 an Open Source License.
*)

signature Pervasives = sig

(* OCaml types *)
type float = real
type int32
type int64
type nativeint
(***************)

exception Exit

val invalid_arg: string -> 'a
val failwith: string -> 'a

val compare: 'a -> 'a -> int 
val min: 'a -> 'a -> 'a
val max: 'a -> 'a -> 'a

val or : bool -> bool -> bool 


val succ : int -> int 
val pred : int -> int 
val mod : int -> int -> int
val abs : int -> int
val max_int: int
val min_int: int

val land : int -> int -> int
val lor : int -> int -> int
val lxor : int -> int -> int
val lnot: int -> int
val lsl : int -> int -> int
val lsr : int -> int -> int
val asr : int -> int -> int 

val sqrt : real -> real 
val exp : real -> real 
val log : real -> real 
val log10 : real -> real 
val cos : real -> real 
val sin : real -> real 
val tan : real -> real 
val acos : real -> real 
val asin : real -> real 
val atan : real -> real 
val atan2 : real -> real -> real 
val cosh : real -> real 
val sinh : real -> real 
val tanh : real -> real 
val ceil : real -> real 
val floor : real -> real 
val abs_float : real -> real
val abs_real : real -> real
val mod_float : real -> real -> real
val mod_real : real -> real
val frexp : real -> real * int 
val ldexp : real -> int -> real 
val modf : real -> real * real 
val float : int -> real 
val float_of_int : int -> real 
val real_of_int : int -> real
val truncate : real -> int 
val int_of_float : real -> int
val int_of_real : real -> int 
val infinity : real
val neg_infinity : real
val nan : real
val max_float : real
val max_real : real
val min_float : real
val min_real : real
val epsilon_float : real
val epsilon : real

type fpclass =
  FP_normal (* Normal number, none of the below *) 
| FP_subnormal (* Number very close to 0.0, has reduced precision *) 
| FP_zero (* Number is 0.0 or -0.0 *) 
| FP_infinite (* Number is positive or negative infinity *) 
| FP_nan (* Not a number: result of an undefined operation *) 

val classify_float : real -> fpclass
val classify_real : real -> fpclass

val int_of_char : char -> int 
val char_of_int : int -> char
val ignore : 'a -> unit 
val string_of_bool : bool -> string
val bool_of_string : string -> bool
val string_of_int : int -> string
val int_of_string : string -> int 
val string_of_float : real -> string
val string_of_real : real -> string
val float_of_string : string -> real 
val real_of_string : string -> real

val fst : 'a * 'b -> 'a 
val snd : 'a * 'b -> 'b 

type in_channel
type out_channel

val stdin : in_channel
val stdout : out_channel
val stderr : out_channel

val print_char : char -> unit
val print_string : string -> unit
val print_int : int -> unit
val print_float : real -> unit
val print_real : real -> unit
val print_endline : string -> unit
val print_newline : unit -> unit


val prerr_char : char -> unit
val prerr_string : string -> unit
val prerr_int : int -> unit
val prerr_float : real -> unit
val prerr_real : real -> unit
val prerr_endline : string -> unit
val prerr_newline : unit -> unit


val read_line : unit -> string
val read_int : unit -> int
val read_float : unit -> real
val read_real : unit -> real

type open_flag =
    Open_rdonly | Open_wronly | Open_append
  | Open_creat | Open_trunc | Open_excl
  | Open_binary | Open_text | Open_nonblock
           
val open_out : string -> out_channel
val open_out_bin : string -> out_channel
val open_out_gen : open_flag list -> int -> string -> out_channel
val flush : out_channel -> unit
val output_char : out_channel -> char -> unit
val output_string : out_channel -> string -> unit
val output : out_channel -> string -> int -> int -> unit
val output_byte : out_channel -> int -> unit
val output_binary_int : out_channel -> int -> unit
val output_value : out_channel -> 'a -> unit
val seek_out : out_channel -> int -> unit
val pos_out : out_channel -> int
val out_channel_length : out_channel -> int
val close_out : out_channel -> unit
val set_binary_mode_out : out_channel -> bool -> unit

val open_in : string -> in_channel
val open_in_bin : string -> in_channel
val open_in_gen : open_flag list -> int -> string -> in_channel
val input_char : in_channel -> char
val input_line : in_channel -> string
val input : in_channel -> string -> int -> int -> int
val really_input : in_channel -> string -> int -> int -> unit
val input_byte : in_channel -> int
val input_binary_int : in_channel -> int
val input_value : in_channel -> 'a
val seek_in : in_channel -> int -> unit
val pos_in : in_channel -> int
val in_channel_length : in_channel -> int
val close_in : in_channel -> unit
val set_binary_mode_in : in_channel -> bool -> unit

val incr : int ref -> unit 
val decr : int ref -> unit 

val exit : int -> 'a
val at_exit: (unit -> unit) -> unit
val unsafe_really_input : in_channel -> string -> int -> int -> unit
val do_at_exit: unit -> unit

end