(** Code generation. *)
(* Memory info command for virtual domains.
   (C) Copyright 2008 Richard W.M. Jones, Red Hat Inc.
   http://libvirt.org/

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *)

(**
   This module is concerned with actually generating code
   for types, parsers, etc.

   We generate two output files, [kernel.mli] is the interface
   to the kernel structures, and [kernel.ml] is the implementation.
*)

type code =
    Camlp4.PreCast.Syntax.Ast.str_item * Camlp4.PreCast.Syntax.Ast.sig_item

(** {2 Generate types}

    Our internal types, representing kernel structures.
*)

val generate_types :
  (string
   * (string * (Pahole_parser.f_type * bool)) list) list ->
  code
    (** [generate_types structures] generates the
	types used to store each structure.
    *)

(** {2 Generate offset functions}

    [offset_of_<struct>_<field> kernel_version] functions.

    These actually play a very minor role: We just use them when
    adjusting [list_head] pointers which cross between structure
    types, so we only generate functions for those right now.
*)

val generate_offsets :
  (string * ((Pahole_parser.info * Pahole_parser.structure) list
	     * (string * (Pahole_parser.f_type * bool)) list)) list ->
  code
    (** [generate_offsets] generates the offset functions. *)

(** {2 Generate parsers}

    Functions which parse the different structures from bitstrings
    into our internal types.
*)

val generate_parsers :
  (string * ((string * (Pahole_parser.f_type * bool)) list
	     * Minimizer.parser_ list)) list ->
  code * (string, string) Hashtbl.t
    (** [generate_parsers] generates the parser functions.

	We cannot generate the complete code here because we
	don't want camlp4 parsing this file to substitute bitmatch
	code yet.  So we only generate labels, which get substituted
	by the contents of the returned hash table in {!output_implem}.
    *)

(** {2 Generate version maps}

    The version maps are functions such as [size_of_<struct> kernel_version]
    which return some aspects of the structures and fields that
    depend at runtime on the kernel version.
*)

val generate_version_maps :
  (string * ((Pahole_parser.info * Pahole_parser.structure) list
	     * (string, Minimizer.parser_) Hashtbl.t)) list ->
  code

(** {2 Generate followers}

    The "followers" are functions which recursively follow every
    structure in the kernel, starting out at known root structures
    such as [init_task] and [init_net].  Their job is to (a) find
    every kernel structure, (b) ensure it is loaded into our
    memory map, (c) produce a map of address -> structure.
*)

val generate_followers :
  string list ->
  (string * (string * (Pahole_parser.f_type * bool)) list) list ->
  code
  (** [generate_followers] generates the follower functions. *)

(** {2 Output final files} *)

val output_interf : output_file:string ->
  Camlp4.PreCast.Syntax.Ast.sig_item ->
  Camlp4.PreCast.Syntax.Ast.sig_item ->
  Camlp4.PreCast.Syntax.Ast.sig_item ->
  Camlp4.PreCast.Syntax.Ast.sig_item ->
  Camlp4.PreCast.Syntax.Ast.sig_item ->
  unit
  (** Output the interface file. *)

val output_implem : output_file:string ->
  Camlp4.PreCast.Syntax.Ast.str_item ->
  Camlp4.PreCast.Syntax.Ast.str_item ->
  Camlp4.PreCast.Syntax.Ast.str_item ->
  (string, string) Hashtbl.t ->
  Camlp4.PreCast.Syntax.Ast.str_item ->
  Camlp4.PreCast.Syntax.Ast.str_item ->
  unit
  (** Output the implementation file. *)