/*

 * Generation of interface headers.

 *

 * Copyright (C) 2019, 2022 Paul Boddie <paul@boddie.org.uk>

 *

 * 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., 51 Franklin Street, Fifth Floor,

 * Boston, MA  02110-1301, USA

 */

#include <stdlib.h>

#include <string.h>

#include "client.h"

#include "common.h"

#include "config.h"

#include "declaration.h"

#include "includes.h"

#include "interface.h"

#include "server.h"

#include "structure.h"

#include "templates.h"

/* Emit compound interface includes. */

static void write_compound_includes(FILE *fp, struct interface *iface)

{

  struct interface_ref *base;

  for (base = iface->bases; base != NULL; base = base->tail)

  {

    /* Only output includes where the base resides in a different file. */

    if (strcmp(iface->output_basename, base->iface->output_basename))

      fprintf(fp, compound_interface_include, base->iface->output_basename);

  }

}

/* Write the reference type members. */

static void write_reference_type_members(FILE *fp, struct interface_ref *base)

{

  if (base == NULL)

    return;

  /* Reverse the list by processing subsequent members first. */

  write_reference_type_members(fp, base->tail);

  fprintf(fp, compound_ref_type_definition_member_c,

          base->name, base->name);

}

/* Generate a reference type for C language interfaces. */

static void write_reference_type(FILE *fp, struct interface *iface)

{

  struct interface *i;

  if (is_compound_interface(iface))

  { 

    fprintf(fp, compound_ref_type_definition_prologue_c, L4_CAP_TYPE);

    write_reference_type_members(fp, iface->bases);

    fprintf(fp, compound_ref_type_definition_epilogue_c,

            iface->name);

  }

  else

    fprintf(fp, ref_type_definition_c, L4_CAP_TYPE, iface->name);

}

/* Augment compound interface class declarations. */

static void write_compound_interface_bases_c(FILE *fp, struct interface *iface)

{

  struct interface_ref *base;

  for (base = iface->bases; base != NULL; base = base->tail)

    fprintf(fp, interface_body_base_c, base->name, base->name);

}

/* Augment compound interface type declarations. */

static void write_compound_interface_bases_cpp(FILE *fp, struct interface *iface)

{

  struct interface_ref *base;

  int first;

  for (base = iface->bases, first = 1; base != NULL; base = base->tail, first = 0)

    fprintf(fp, interface_prologue_base_cpp, first ? " : " : ", ", base->name);

}

/* Write the definition of an interface to the given file for use by client or

   server components. Client headers employ such definitions as do server

   interface headers, whereas server wrapper headers employ other descriptions

   of their operations. */

void write_interface_definition(struct interface *iface,

                                enum component_role component, FILE *fp)

{

  int cpp = (conf.language == CPP_LANGUAGE);

  int client = (component == CLIENT_ROLE);

  int input_items = get_max_input_items(iface);

  char *class_name = get_interface_class_name(iface, component);

  char *name = iface->name;

  /* Emit include statements. */

  write_includes_separator(iface->includes, fp);

  write_includes(iface->includes, fp);

  write_compound_includes(fp, iface);

  /* Generate interface abstractions. */

  if (!cpp)

  {

    /* Define an object reference type for C. */

    if (!client)

      write_reference_type(fp, iface);

    /* Define C client signatures representing the client functions. */

    else

      write_signatures(iface->signatures, DECLARATION_ROLE,

                       fp, iface, write_client_signature);

  }

  /* Begin any namespace, defining the class or type.

     C++ code employs an abstract server interface and a concrete client

     interface class.

     C code only employs a server interface which is instantiated for client

     use elsewhere by employing the client functions. */

  if (cpp || !client)

  {

    if (cpp)

    {

      fprintf(fp, interface_prologue_cpp, class_name);

      /* Inherit from the actual interface in the client. */

      if (client)

        fprintf(fp, client_interface_prologue_cpp, name);

    }

    else

      fputs(interface_prologue_c, fp);

    /* Augment the interface declaration with base interfaces for compound

       interfaces. */

    if (!client && cpp && is_compound_interface(iface))

      write_compound_interface_bases_cpp(fp, iface);

    /* Start the class or type body. */

    fputs(interface_body_begin, fp);

    /* Augment the interface declaration with base interfaces for compound

       interfaces. */

    if (!client && !cpp && is_compound_interface(iface))

      write_compound_interface_bases_c(fp, iface);

    /* Define any state and initialisation details of a class. */

    if (cpp)

    {

      if (client)

        fprintf(fp, client_interface_endpoint_declaration_cpp, L4_CAP_TYPE);

      if (iface->signatures != NULL)

        fputs(interface_signatures_prologue_cpp, fp);

      /* Define a constructor. */

      if (client)

        fprintf(fp, client_interface_constructor_cpp, class_name, L4_CAP_TYPE);

    }

    /* Emit signatures. */

    write_signatures(iface->signatures, MEMBER_DECLARATION_ROLE,

                     fp, iface,

                     client ? write_client_signature

                            : write_server_interface_signature);

    /* Terminate the class or type body. */

    if (cpp)

      fputs(interface_epilogue_cpp, fp);

    else

      fprintf(fp, interface_epilogue_c, name);

  }

  /* Define the maximum number of expected items for the interface. */

  if (!client)

    fprintf(fp, expected_items_definition, name, input_items);

  /* Define an object type for C and declare a client interface. */

  if (!cpp && !client)

    fprintf(fp, object_type_definition_c, name, name, name);

  if (!cpp && client)

    fprintf(fp, client_interface_declaration_c, name, name);

  /* Emit opcodes and message access structures with the generic server

     interface, these being common to both client and server. */

  if (!client && (iface->signatures != NULL))

  {

    write_opcode_definition(iface, fp);

    write_structures(iface->signatures, fp, iface);

  }

  /* Emit a conversion macro for compound interface dispatch. */

  if (!client)

  {

    if (cpp)

      fprintf(fp, compound_interface_conversion_cpp, name);

    else

      fprintf(fp, compound_interface_conversion_c, name, name, name, name);

  }

  free(class_name);

}