(*
 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.
*)

(* Str *)

signature Str = sig
type regexp
val regexp: string -> regexp
val regexp_case_fold: string -> regexp
val quote: string -> string
val regexp_string: string -> regexp
val regexp_string_case_fold: string -> regexp
val string_match: regexp -> string -> int -> bool
val search_forward: regexp -> string -> int -> int
val search_backward: regexp -> string -> int -> int
val string_partial_match: regexp -> string -> int -> bool
val matched_string: string -> string
val match_beginning: unit -> int
val match_end: unit -> int
val matched_group: int -> string -> string
val group_beginning: int -> int
val group_end: int -> int
val global_replace: regexp -> string -> string -> string
val replace_first: regexp -> string -> string -> string
val global_substitute: regexp -> (string -> string) -> string -> string
val substitute_first: regexp -> (string -> string) -> string -> string
val replace_matched : string -> string -> string
val split: regexp -> string -> string list
val bounded_split: regexp -> string -> int -> string list
val split_delim: regexp -> string -> string list
val bounded_split_delim: regexp -> string -> int -> string list

type split_result = Text of string | Delim of string

val full_split: regexp -> string -> split_result list
val bounded_full_split: regexp -> string -> int -> split_result list
val string_before: string -> int -> string
val string_after: string -> int -> string
val first_chars: string -> int -> string
val last_chars: string -> int -> string
end

(* Dbm *)

signature Dbm = sig
type t
type open_flag =
   Dbm_rdonly | Dbm_wronly | Dbm_rdwr | Dbm_create
exception Dbm_error of string
val opendbm : string -> open_flag list -> int -> t 
val close : t -> unit
val find : t -> string -> string
val add : t -> string -> string -> unit 
val replace : t -> string -> string -> unit
val remove : t -> string -> unit
val firstkey : t -> string
val nextkey : t -> string
val iter : (string -> string -> 'a) -> t -> unit
end

(* Thread *)

signature Thread = sig
type t
val create : ('a -> 'b) -> 'a -> t
val self : unit -> t
val id : t -> int 
val exit : unit -> unit
val kill : t -> unit
val delay: float -> unit
val join : t -> unit
val wait_read : Unix.file_descr -> unit
val wait_write : Unix.file_descr -> unit
val wait_timed_read : Unix.file_descr -> float -> bool
val wait_timed_write : Unix.file_descr -> float -> bool
val select :
  Unix.file_descr list -> Unix.file_descr list ->
  Unix.file_descr list -> float ->
  Unix.file_descr list * Unix.file_descr list * Unix.file_descr list
val wait_pid : int -> int * Unix.process_status
val wait_signal : int list -> int
val yield : unit -> unit
val critical_section: bool ref
val sleep : unit -> unit
val wakeup : t -> unit
end

signature Condition = sig
type t
val create: unit -> t
val wait: t -> Mutex.t -> unit
val signal: t -> unit
val broadcast: t -> unit
end

signature Event = sig
type 'a channel
val new_channel: unit -> 'a channel
type 'a event
val send: 'a channel -> 'a -> unit event
val receive: 'a channel -> 'a event
val always: 'a -> 'a event
val choose: 'a event list -> 'a event
val wrap: 'a event -> ('a -> 'b) -> 'b event
val wrap_abort: 'a event -> (unit -> unit) -> 'a event
val guard: (unit -> 'a event) -> 'a event
val sync: 'a event -> 'a
val select: 'a event list -> 'a
val poll: 'a event -> 'a option
end

signature ThreadUnix = sig
val execv : string -> string array -> unit
val execve : string -> string array -> string array -> unit
val execvp : string -> string array -> unit
val wait : unit -> int * Unix.process_status
val waitpid : Unix.wait_flag list -> int -> int * Unix.process_status
val system : string -> Unix.process_status

val read : Unix.file_descr -> string -> int -> int -> int
val write : Unix.file_descr -> string -> int -> int -> int

val timed_read :
      Unix.file_descr ->
      string -> int -> int -> float -> int
val timed_write :
      Unix.file_descr ->
      string -> int -> int -> float -> int

val select :
  Unix.file_descr list -> Unix.file_descr list ->
  Unix.file_descr list -> float ->
        Unix.file_descr list * Unix.file_descr list * Unix.file_descr list

val pipe : unit -> Unix.file_descr * Unix.file_descr
val open_process_in: string -> in_channel
val open_process_out: string -> out_channel
val open_process: string -> in_channel * out_channel
val open_process_full:
      string -> string array -> in_channel * out_channel * in_channel

val sleep : int -> unit
val socket : Unix.socket_domain ->
             Unix.socket_type -> int -> Unix.file_descr
val socketpair : Unix.socket_domain -> Unix.socket_type ->
                 int -> Unix.file_descr * Unix.file_descr
val accept : Unix.file_descr -> Unix.file_descr * Unix.sockaddr
val connect : Unix.file_descr -> Unix.sockaddr -> unit
val recv : Unix.file_descr -> string ->
           int -> int -> Unix.msg_flag list -> int
val recvfrom : Unix.file_descr -> string -> int -> int ->
               Unix.msg_flag list -> int * Unix.sockaddr
val send : Unix.file_descr -> string -> int -> int ->
           Unix.msg_flag list -> int
val sendto : Unix.file_descr -> string -> int -> int ->
             Unix.msg_flag list -> Unix.sockaddr -> int
val open_connection : Unix.sockaddr -> in_channel * out_channel
val establish_server :
      (in_channel -> out_channel -> 'a) ->
      Unix.sockaddr -> unit
end


(* Dynlink *)

signature Dynlink = sig
val init : unit -> unit
val loadfile : string -> unit
val loadfile_private : string -> unit
val add_interfaces : string list -> string list -> unit
val add_available_units : (string * Digest.t) list -> unit
val clear_available_units : unit -> unit
val allow_unsafe_modules : bool -> unit
type linking_error =
    Undefined_global of string
  | Unavailable_primitive of string
  | Uninitialized_global of string
type error =
    Not_a_bytecode_file of string
  | Inconsistent_import of string
  | Unavailable_unit of string
  | Unsafe_file
  | Linking_error of string * linking_error
  | Corrupted_interface of string
  | File_not_found of string
  | Cannot_open_dll of string

exception Error of error
val error_message: error -> string
val digest_interface : string -> string list -> Digest.t
end

(* Bigarray *)

signature Bigarray = sig
type float32_elt
type float64_elt
type int8_signed_elt
type int8_unsigned_elt
type int16_signed_elt
type int16_unsigned_elt
type int_elt
type int32_elt
type int64_elt
type nativeint_elt
type ('a, 'b) kind
val float32: (float, float32_elt) kind
val float64: (float, float64_elt) kind
val int8_signed: (int, int8_signed_elt) kind
val int8_unsigned: (int, int8_unsigned_elt) kind
val int16_signed: (int, int16_signed_elt) kind
val int16_unsigned: (int, int16_unsigned_elt) kind
val int: (int, int_elt) kind
val int32: (int32, int32_elt) kind
val int64: (int64, int64_elt) kind
val nativeint: (nativeint, nativeint_elt) kind
val char: (char, int8_unsigned_elt) kind
type c_layout
type fortran_layout
type 'a layout
val c_layout: c_layout layout
val fortran_layout: fortran_layout layout

structure Genarray: sig
  type ('a, 'b, 'c) t
  val create:
    ('a, 'b) kind -> 'c layout -> int array -> ('a, 'b, 'c) t
  val num_dims: ('a, 'b, 'c) t -> int 
  val nth_dim: ('a, 'b, 'c) t -> int -> int 
  val get: ('a, 'b, 'c) t -> int array -> 'a 
  val set: ('a, 'b, 'c) t -> int array -> 'a -> unit
  val sub_left:
    ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) t
  val sub_right:
    ('a, 'b, fortran_layout) t ->
    int -> int -> ('a, 'b, fortran_layout) t
  val slice_left:
    ('a, 'b, c_layout) t -> int array -> ('a, 'b, c_layout) t
  val slice_right:
    ('a, 'b, fortran_layout) t -> int array -> ('a, 'b, fortran_layout) t
  val blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit
  val fill: ('a, 'b, 'c) t -> 'a -> unit 
  val map_file:
    Unix.file_descr -> ('a, 'b) kind -> 'c layout ->
    bool -> int array -> ('a, 'b, 'c) t 
  end

structure Array1: sig
  type ('a, 'b, 'c) t
  val create:
    ('a, 'b) kind -> 'c layout -> int -> ('a, 'b, 'c) t
  val dim: ('a, 'b, 'c) t -> int
  val get: ('a, 'b, 'c) t -> int -> 'a 
  val set: ('a, 'b, 'c) t -> int -> 'a -> unit 
  val sub: ('a, 'b, 'c) t -> int -> int -> ('a, 'b, 'c) t
  val blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit
  val fill: ('a, 'b, 'c) t -> 'a -> unit 
  val of_array:
    ('a, 'b) kind -> 'c layout -> 'a array -> ('a, 'b, 'c) t
  val map_file: Unix.file_descr -> ('a, 'b) kind -> 'c layout ->
                bool -> int -> ('a, 'b, 'c) t
end

structure Array2: sig
  type ('a, 'b, 'c) t
  val create:
    ('a, 'b) kind ->
    'c layout -> int -> int -> ('a, 'b, 'c) t
  val dim1: ('a, 'b, 'c) t -> int
  val dim2: ('a, 'b, 'c) t -> int
  val get: ('a, 'b, 'c) t -> int -> int -> 'a 
  val set: ('a, 'b, 'c) t -> int -> int -> 'a -> unit 
  val sub_left:
    ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) t
  val sub_right:
    ('a, 'b, fortran_layout) t ->
    int -> int -> ('a, 'b, fortran_layout) t 
  val slice_left:
    ('a, 'b, c_layout) t -> int -> ('a, 'b, c_layout) Array1.t
  val slice_right:
    ('a, 'b, fortran_layout) t -> int -> ('a, 'b, fortran_layout) Array1.t
  val blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit
  val fill: ('a, 'b, 'c) t -> 'a -> unit 
  val of_array:
    ('a, 'b) kind -> 'c layout -> 'a array array -> ('a, 'b, 'c) t
  val map_file: Unix.file_descr -> ('a, 'b) kind -> 'c layout ->
                bool -> int -> int -> ('a, 'b, 'c) t
end

structure Array3: sig
  type ('a, 'b, 'c) t
  val create:
    ('a, 'b) kind -> 'c layout ->
    int -> int -> int -> ('a, 'b, 'c) t
  val dim1: ('a, 'b, 'c) t -> int
  val dim2: ('a, 'b, 'c) t -> int
  val dim3: ('a, 'b, 'c) t -> int
  val get: ('a, 'b, 'c) t -> int -> int -> int -> 'a 
  val set: ('a, 'b, 'c) t -> int -> int -> int -> 'a -> unit 
  val sub_left:
    ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) t
  val sub_right:
    ('a, 'b, fortran_layout) t ->
    int -> int -> ('a, 'b, fortran_layout) t
  val slice_left_1:
    ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) Array1.t
  val slice_right_1:
    ('a, 'b, fortran_layout) t -> int -> int -> 
        ('a, 'b, fortran_layout) Array1.t
  val slice_left_2:
    ('a, 'b, c_layout) t -> int -> ('a, 'b, c_layout) Array2.t
  val slice_right_2:
    ('a, 'b, fortran_layout) t -> int -> ('a, 'b, fortran_layout) Array2.t
  val blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit
  val fill: ('a, 'b, 'c) t -> 'a -> unit 
  val of_array:
        ('a, 'b) kind -> 'c layout ->
        'a array array array -> ('a, 'b, 'c) t
  val map_file: Unix.file_descr -> ('a, 'b) kind -> 'c layout ->
             bool -> int -> int -> int -> ('a, 'b, 'c) t
end

val genarray_of_array1: ('a, 'b, 'c) Array1.t -> ('a, 'b, 'c) Genarray.t
val genarray_of_array2: ('a, 'b, 'c) Array2.t -> ('a, 'b, 'c) Genarray.t
val genarray_of_array3: ('a, 'b, 'c) Array3.t -> ('a, 'b, 'c) Genarray.t
val array1_of_genarray: ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array1.t
val array2_of_genarray: ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array2.t
val array3_of_genarray: ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array3.t

val reshape : ('a, 'b, 'c) Genarray.t -> int array -> ('a, 'b, 'c) Genarray.t
val reshape_1 : ('a, 'b, 'c) Genarray.t -> int -> ('a, 'b, 'c) Array1.t
val reshape_2 : ('a, 'b, 'c) Genarray.t -> int -> int -> ('a, 'b, 'c) Array2.t
val reshape_3 :
  ('a, 'b, 'c) Genarray.t -> int -> int -> int -> ('a, 'b, 'c) Array3.t

end