(*
 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 Arg = sig
type spec =
    Unit of (unit -> unit)     (* Call the function with unit argument *)
  | Set of bool ref            (* Set the reference to true *)
  | Clear of bool ref          (* Set the reference to false *)
  | String of (string -> unit) (* Call the function with a string argument *)
  | Int of (int -> unit)       (* Call the function with an int argument *)
  | Float of (real -> unit)   (* Call the function with a float argument *)
  | Rest of (string -> unit)   
val parse : (string * spec * string) list -> (string -> unit) -> string -> unit
exception Bad of string
val usage: (string * spec * string) list -> string -> unit
val current: int ref
end

signature Array = sig
val length : 'a array -> int 
val get: 'a array -> int -> 'a 
val set: 'a array -> int -> 'a -> unit 
val make: int -> 'a -> 'a array 
val create: int -> 'a -> 'a array 
val init: int -> (int -> 'a) -> 'a array
val make_matrix: int -> int -> 'a -> 'a array array
val create_matrix: int -> int -> 'a -> 'a array array
val append: 'a array -> 'a array -> 'a array
val concat: 'a array list -> 'a array
val sub: 'a array -> int -> int -> 'a array
val copy: 'a array -> 'a array
val fill: 'a array -> int -> int -> 'a -> unit
val blit: 'a array -> int -> 'a array -> int -> int -> unit
val to_list: 'a array -> 'a list
val of_list: 'a list -> 'a array
val iter: ('a -> unit) -> 'a array -> unit
val map: ('a -> 'b) -> 'a array -> 'b array
val iteri: (int -> 'a -> unit) -> 'a array -> unit
val mapi: (int -> 'a -> 'b) -> 'a array -> 'b array
val fold_left: ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
val fold_right: ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
val unsafe_get: 'a array -> int -> 'a 
val unsafe_set: 'a array -> int -> 'a -> unit 
val sort : ('a -> 'a -> int) -> 'a array -> unit
val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
end

signature Buffer = sig
type t
val create : int -> t
val contents : t -> string
val length : t -> int
val clear : t -> unit
val reset : t -> unit
val add_char : t -> char -> unit
val add_string : t -> string -> unit
val add_substring : t -> string -> int -> int -> unit
val add_buffer : t -> t -> unit
val add_channel : t -> in_channel -> int -> unit
val output_buffer : out_channel -> t -> unit
end

signature Callback = sig
val register: string -> 'a -> unit
val register_exception: string -> exn -> unit
end

signature Char = sig
val code : char -> int 
val chr: int -> char
val escaped : char -> string
val lowercase: char -> char
val uppercase: char -> char
val unsafe_chr: int -> char 
end

signature Digest = sig
type t = string
val string: string -> t
val substring: string -> int -> int -> t
val channel: in_channel -> int -> t 
val file: string -> t
val output: out_channel -> t -> unit
val input: in_channel -> t
end

signature Filename = sig
val current_dir_name : string
val parent_dir_name : string
val concat : string -> string -> string
val is_relative : string -> bool
val is_implicit : string -> bool
val check_suffix : string -> string -> bool
val chop_suffix : string -> string -> string
val chop_extension : string -> string
val basename : string -> string
val dirname : string -> string
val temp_file: string -> string -> string
val quote : string -> string
end


signature Gc = sig
type stat = {
  minor_words : real,
  promoted_words : real,
  major_words : real,
  minor_collections : int,
  major_collections : int,
  heap_words : int,
  heap_chunks : int,
  live_words : int,
  live_blocks : int,
  free_words : int,
  free_blocks : int,
  largest_free : int,
  fragments : int,
  compactions : int
}
type control
(*
type control = {
  mutable minor_heap_size : int,
  mutable major_heap_increment : int,
  mutable space_overhead : int,
  mutable verbose : int,
  mutable max_overhead : int,
  mutable stack_limit : int
}
*)
val stat : unit -> stat 
val counters : unit -> real * real * real
val get : unit -> control 
val set : control -> unit 
val minor : unit -> unit 
val major : unit -> unit 
val full_major : unit -> unit 
val compact : unit -> unit 
val print_stat : out_channel -> unit
val allocated_bytes : unit -> real
val finalise : ('a -> unit) -> 'a -> unit
type alarm
val create_alarm : (unit -> unit) -> alarm
val delete_alarm : alarm -> unit
end


signature Hashtbl = sig
type ('a, 'b) t
val create : int -> ('a,'b) t
val clear : ('a, 'b) t -> unit
val add : ('a, 'b) t -> 'a -> 'b -> unit
val copy : ('a, 'b) t -> ('a, 'b) t
val find : ('a, 'b) t -> 'a -> 'b
val find_all : ('a, 'b) t -> 'a -> 'b list
val mem :  ('a, 'b) t -> 'a -> bool
val remove : ('a, 'b) t -> 'a -> unit
val replace : ('a, 'b) t -> 'a -> 'b -> unit
val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
val hash : 'a -> int
val hash_param : int -> int -> 'a -> int
end

signature Int32 = sig
val zero : int32
val one : int32
val minus_one : int32
val neg : int32 -> int32
val add : int32 -> int32 -> int32
val sub : int32 -> int32 -> int32
val mul : int32 -> int32 -> int32
val div : int32 -> int32 -> int32
val rem : int32 -> int32 -> int32
val succ : int32 -> int32
val pred : int32 -> int32
val abs : int32 -> int32
val max_int : int32
val min_int : int32
val logand : int32 -> int32 -> int32
val logor : int32 -> int32 -> int32
val logxor : int32 -> int32 -> int32
val lognot : int32 -> int32
val shift_left : int32 -> int -> int32
val shift_right : int32 -> int -> int32
val shift_right_logical : int32 -> int -> int32
val of_int : int -> int32
val to_int : int32 -> int
val of_float : real -> int32
val of_real : real -> int32
val to_float : int32 -> float
val to_real : int32 -> real
val of_string : string -> int32
val to_string : int32 -> string
val format : string -> int32 -> string
end

signature Int64 = sig
val zero : int64
val one : int64
val minus_one : int64
val neg : int64 -> int64
val add : int64 -> int64 -> int64
val sub : int64 -> int64 -> int64
val mul : int64 -> int64 -> int64
val div : int64 -> int64 -> int64
val rem : int64 -> int64 -> int64
val succ : int64 -> int64
val pred : int64 -> int64
val abs : int64 -> int64
val max_int : int64
val min_int : int64
val logand : int64 -> int64 -> int64
val logor : int64 -> int64 -> int64
val logxor : int64 -> int64 -> int64
val lognot : int64 -> int64
val shift_left : int64 -> int -> int64
val shift_right : int64 -> int -> int64
val shift_right_logical : int64 -> int -> int64
val of_int : int -> int64
val to_int : int64 -> int
val of_float : real -> int64
val to_float : int64 -> real
val of_real : real -> int64
val to_real : int64 -> real
val of_int32 : int32 -> int64
val to_int32 : int64 -> int32
val of_nativeint : nativeint -> int64
val to_nativeint : int64 -> nativeint
val of_string : string -> int64
val to_string : int64 -> string
val format : string -> int64 -> string
val bits_of_float : real -> int64 
val bits_of_real : real -> int64 
val float_of_bits : int64 -> real
val real_of_bits : int64 -> real
end


signature Map = sig
    type ('a, 'b) t
    val empty: ('a, 'b) t
    val add: 'a -> 'b -> ('a, 'b) t -> ('a, 'b) t
    val find: 'a -> ('a, 'b) t -> 'b
    val remove: 'a -> ('a, 'b) t -> ('a, 'b) t
    val mem: 'a -> ('a, 'b) t -> bool
    val iter: ('a -> 'b -> unit) -> ('a, 'b) t -> unit
    val map: ('a -> 'b) -> ('c, 'a) t -> ('c, 'b) t
    val mapi: ('a -> 'b -> 'c) -> ('a, 'b) t -> ('a, 'c) t
    val fold: ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
end

signature Nativeint = sig
val zero : nativeint
val one : nativeint
val minus_one : nativeint
val neg : nativeint -> nativeint 
val add : nativeint -> nativeint -> nativeint 
val sub : nativeint -> nativeint -> nativeint 
val mul : nativeint -> nativeint -> nativeint 
val div : nativeint -> nativeint -> nativeint 
val rem : nativeint -> nativeint -> nativeint 
val succ : nativeint -> nativeint
val pred : nativeint -> nativeint
val abs : nativeint -> nativeint
val size : int
val max_int : nativeint
val min_int : nativeint
val logand : nativeint -> nativeint -> nativeint 
val logor : nativeint -> nativeint -> nativeint 
val logxor : nativeint -> nativeint -> nativeint 
val lognot : nativeint -> nativeint
val shift_left : nativeint -> int -> nativeint 
val shift_right : nativeint -> int -> nativeint 
val shift_right_logical : nativeint -> int -> nativeint 
val of_int : int -> nativeint 
val to_int : nativeint -> int 
val of_float : real -> nativeint 
val of_real : real -> nativeint 
val to_float : nativeint -> real 
val to_real : nativeint -> real 
val of_int32 : int32 -> nativeint 
val to_int32 : nativeint -> int32 
val of_string : string -> nativeint 
val to_string : nativeint -> string
val format : string -> nativeint -> string 
end


signature Lazy = sig
type 'a status =
    Delayed of (unit -> 'a)
  | Value of 'a
  | Exception of exn

type 'a t = 'a status ref
val force: 'a t -> 'a
end

signature Lexing = sig
type lexbuf 
(* commented out because of mutable fields __cookcu__ *)
(* 
  { refill_buff : lexbuf -> unit,
    mutable lex_buffer : string,
    mutable lex_buffer_len : int,
    mutable lex_abs_pos : int,
    mutable lex_start_pos : int,
    mutable lex_curr_pos : int,
    mutable lex_last_pos : int,
    mutable lex_last_action : int,
    mutable lex_eof_reached : bool }
*)
val from_channel : in_channel -> lexbuf
val from_string : string -> lexbuf
val from_function : (string -> int -> int) -> lexbuf
val lexeme : lexbuf -> string
val lexeme_char : lexbuf -> int -> char
val lexeme_start : lexbuf -> int
val lexeme_end : lexbuf -> int
type lex_tables =
  { lex_base: string,
    lex_backtrk: string,
    lex_default: string,
    lex_trans: string,
    lex_check: string }
val engine: lex_tables -> int -> lexbuf -> int 
end

signature List = sig
val length : 'a list -> int
val hd : 'a list -> 'a
val tl : 'a list -> 'a list
val nth : 'a list -> int -> 'a
val rev : 'a list -> 'a list
val append : 'a list -> 'a list -> 'a list
val rev_append : 'a list -> 'a list -> 'a list
val concat  : 'a list list -> 'a list
val flatten : 'a list list -> 'a list
val iter : ('a -> unit) -> 'a list -> unit
val map : ('a -> 'b) -> 'a list -> 'b list
val rev_map : ('a -> 'b) -> 'a list -> 'b list
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val for_all : ('a -> bool) -> 'a list -> bool
val exists : ('a -> bool) -> 'a list -> bool
val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val mem : 'a -> 'a list -> bool
val memq : 'a -> 'a list -> bool
val find : ('a -> bool) -> 'a list -> 'a
val filter : ('a -> bool) -> 'a list -> 'a list
val find_all : ('a -> bool) -> 'a list -> 'a list
val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
val assoc : 'a -> ('a * 'b) list -> 'b
val assq : 'a -> ('a * 'b) list -> 'b
val mem_assoc : 'a -> ('a * 'b) list -> bool
val mem_assq : 'a -> ('a * 'b) list -> bool
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
val split : ('a * 'b) list -> 'a list * 'b list
val combine : 'a list -> 'b list -> ('a * 'b) list
val sort : ('a -> 'a -> int) -> 'a list -> 'a list
val stable_sort: ('a -> 'a -> int) -> 'a list -> 'a list
end

signature Marshal = sig
type extern_flags =
    No_sharing                          (* Don't preserve sharing *)
  | Closures                            (* Send function closures *)
val to_channel: out_channel -> 'a -> extern_flags list -> unit
val to_string: 'a -> extern_flags list -> string
val to_buffer: string -> int -> int -> 'a -> extern_flags list -> int
val from_channel: in_channel -> 'a 
val from_string: string -> int -> 'a
val header_size : int
val data_size : string -> int -> int
val total_size : string -> int -> int
end

signature Obj = sig
type t
val repr : 'a -> t 
val obj : t -> 'a 
val magic : 'a -> 'b 
val is_block : t -> bool 
val is_int : t -> bool
val tag : t -> int 
val size : t -> int 
val field : t -> int -> t 
val set_field : t -> int -> t -> unit 
val new_block : int -> int -> t 
val dup : t -> t 
val truncate : t -> int -> unit 
val no_scan_tag : int
val closure_tag : int
val infix_tag : int
val object_tag : int
val abstract_tag : int
val string_tag : int
val double_tag : int
val double_array_tag : int
val final_tag : int
val marshal : t -> string
val unmarshal : string -> int -> t * int
end


signature Oo = sig
val copy : 'a -> 'a
type label
val new_method: string -> label
type table
type meth
type t
type obj
val new_variable: table -> string -> int
val get_variable: table -> string -> int
val get_method_label: table -> string -> label
val get_method: table -> label -> meth
val set_method: table -> label -> meth -> unit
val narrow: table -> string list -> string list -> string list -> unit
val widen: table -> unit
val add_initializer: table -> (obj -> unit) -> unit
val create_table: string list -> table
val init_class: table -> unit

val create_object: table -> obj
val run_initializers: obj -> table -> unit
val send:   obj -> label -> t

type params
(* = {
    mutable compact_table : bool,
    mutable copy_parent : bool,
    mutable clean_when_copying : bool,
    mutable retry_count : int,
    mutable bucket_small_size : int
  } 
*)
val params : params
type stats =
  { classes: int, labels: int, methods: int, inst_vars: int, buckets: int,
    distrib : int array, small_bucket_count: int, small_bucket_max: int }
val stats: unit -> stats
val show_buckets: unit -> unit
end

signature Printexc = sig
val catch: ('a -> 'b) -> 'a -> 'b
val print: ('a -> 'b) -> 'a -> 'b
val to_string : exn -> string
end

signature Queue = sig
type 'a t
exception Empty
val create: unit -> 'a t
val add: 'a -> 'a t -> unit
val take: 'a t -> 'a
val peek: 'a t -> 'a
val clear : 'a t -> unit
val length: 'a t -> int
val iter: ('a -> unit) -> 'a t -> unit
end

signature Random = sig
val init : int -> unit
val full_init : int array -> unit
val self_init : unit -> unit
val bits : unit -> int
val int : int -> int
val float : real -> real
val real : real -> real
type state
val get_state : unit -> state
val set_state : state -> unit
end

signature Set = sig
    type 'a t
    val empty: 'a t
    val is_empty: 'a t -> bool
    val mem: 'a ->'a t-> bool
    val add: 'a ->'a t-> 'a t
    val singleton: 'a -> 'a t
    val remove: 'a ->'a t-> 'a t
    val union:'a t->'a t-> 'a t
    val inter:'a t->'a t-> 'a t
    val diff:'a t->'a t-> 'a t
    val compare:'a t->'a t-> int
    val equal:'a t->'a t-> bool
    val subset:'a t -> 'a t -> bool
    val iter: ('a -> unit) ->'a t-> unit
    val fold: ('a -> 'b -> 'b) ->'a t-> 'b -> 'b
    val for_all: ('a -> bool) ->'a t-> bool
    val exists: ('a -> bool) ->'a t-> bool
    val filter: ('a -> bool) ->'a t-> 'a t
    val partition: ('a -> bool) ->'a t->'a t * 'a t
    val cardinal:'a t-> int
    val elements:'a t-> 'a list
    val min_elt:'a t-> 'a
    val max_elt:'a t-> 'a
    val choose:'a t-> 'a
end

signature Stack = sig
type 'a t
exception Empty
val create : unit -> 'a t
val push : 'a -> 'a t -> unit
val pop : 'a t -> 'a
val top : 'a t -> 'a
val clear : 'a t -> unit
val copy : 'a t -> 'a t
val length : 'a t -> int
val iter : ('a -> unit) -> 'a t -> unit
end

signature Stream = sig
type 'a t
exception Failure
exception Error of string
val from : (int -> 'a option) -> 'a t
val of_list : 'a list -> 'a t
val of_string : string -> char t
val of_channel : in_channel -> char t
val iter : ('a -> unit) -> 'a t -> unit
val next : 'a t -> 'a
val empty : 'a t -> unit
val peek : 'a t -> 'a option
val junk : 'a t -> unit
val count : 'a t -> int
val npeek : int -> 'a t -> 'a list
val iapp : 'a t -> 'a t -> 'a t
val icons : 'a -> 'a t -> 'a t
val ising : 'a -> 'a t
val lapp : (unit -> 'a t) -> 'a t -> 'a t
val lcons : (unit -> 'a) -> 'a t -> 'a t
val lsing : (unit -> 'a) -> 'a t
val sempty : 'a t
val slazy : (unit -> 'a t) -> 'a t
val dump : ('a -> unit) -> 'a t -> unit
end

signature String = sig
val length : string -> int 
val get : string -> int -> char 
val set : string -> int -> char -> unit 
val create : int -> string 
val make : int -> char -> string
val copy : string -> string
val sub : string -> int -> int -> string
val fill : string -> int -> int -> char -> unit
val blit : string -> int -> string -> int -> int -> unit
val concat : string -> string list -> string
val iter : (char -> unit) -> string -> unit
val escaped : string -> string
val index : string -> char -> int
val rindex : string -> char -> int
val index_from : string -> int -> char -> int
val rindex_from : string -> int -> char -> int
val contains : string -> char -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
val unsafe_get : string -> int -> char 
val unsafe_set : string -> int -> char -> unit 
val unsafe_blit : string -> int -> string -> int -> int -> unit
val unsafe_fill : string -> int -> int -> char -> unit
end

signature Sys = sig
val argv: string array
val file_exists: string -> bool 
val remove: string -> unit 
val rename : string -> string -> unit 
val getenv: string -> string 
val command: string -> int 
val time: unit -> real 
val chdir: string -> unit 
val getcwd: unit -> string 
val interactive: bool ref
val os_type: string
val word_size: int
val max_string_length: int
val max_array_length: int
type signal_behavior =
    Signal_default
  | Signal_ignore
  | Signal_handle of (int -> unit)
val signal: int -> signal_behavior -> signal_behavior
val set_signal: int -> signal_behavior -> unit
val sigabrt: int   (* Abnormal termination *)
val sigalrm: int   (* Timeout *)
val sigfpe: int    (* Arithmetic exception *)
val sighup: int    (* Hangup on controlling terminal *)
val sigill: int    (* Invalid hardware instruction *)
val sigint: int    (* Interactive interrupt (ctrl-C) *)
val sigkill: int   (* Termination (cannot be ignored) *)
val sigpipe: int   (* Broken pipe *)
val sigquit: int   (* Interactive termination *)
val sigsegv: int   (* Invalid memory reference *)
val sigterm: int   (* Termination *)
val sigusr1: int   (* Application-defined signal 1 *)
val sigusr2: int   (* Application-defined signal 2 *)
val sigchld: int   (* Child process terminated *)
val sigcont: int   (* Continue *)
val sigstop: int   (* Stop *)
val sigtstp: int   (* Interactive stop *)
val sigttin: int   (* Terminal read from background process *)
val sigttou: int   (* Terminal write from background process *)
val sigvtalrm: int (* Timeout in virtual time *)
val sigprof: int   (* Profiling interrupt *)
exception Break
val catch_break: bool -> unit
type dir_handle
val opendir : string -> dir_handle
val readdir : dir_handle -> string
val closedir : dir_handle -> unit
end

signature Weak = sig
type 'a t
val create : int -> 'a t
val length : 'a t -> int
val set : 'a t -> int -> 'a option -> unit
val get : 'a t -> int -> 'a option
val get_copy : 'a t -> int -> 'a option
val check: 'a t -> int -> bool
val fill: 'a t -> int -> int -> 'a option -> unit
val blit : 'a t -> int -> 'a t -> int -> int -> unit
end