#!/bin/bash
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# * This source file is part of libspmt.                            *
# *                                                                 *
# * See the file "LICENSE" for the copyright information and for    *
# * the terms and conditions for copying, distribution and          *
# * modification of this source file.                               *
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

# $Date$

# FIXME: would be good to have empty functions matching those in #ifdefs generated as well

source util.sh

# $1 module to include
# output on stdout
function generate_include {
    echo $1 |
    awk '{
           printf "#include \"'"$1"'.h\"\n"
         }'
}

# $1 kind of prototype (LIBRARY, PRIVATE, PUBLIC, SPMT_NOINLINE)
# $2 file to operate on
# output on stdout
# returns 0 if found, 1 otherwise
# expects the kind of prototype to be on a line all by itself
function generate_prototypes {
    awk '/^'"$1"'$/ {
           found=1;
           printf "%s ", $0;
           getline;
           printf "%s ", $0;
           getline;
           printf "%s;\n", $0;
         }
         END {
           if (found==0)
             {
               exit 1;
             }
         }' $2
    return $?
}

# generates includes and PRIVATE prototypes at start of module
# $1 module base
# output on stdout
function generate_module_prologue {
    echo $1 |
    awk '{
           printf "#ifndef %s_C\n", toupper($1);
           printf "#define %s_C\n", toupper($1);
           printf "#ifdef %s_C\n", toupper($1);
           printf "#endif /* %s_C */\n", toupper($1);
           printf "\n";
         }'
    echo '#include "private.h"'
    cat $1.c |
    strip_prologue "${end} prologue" > $1.stripped
    uses=`cat $1.c | 
    grep -v FIXME |
    find_tokens_with_prefix spmt |
    awk '{
           printf "^%s \\\\(|", $1;
         }
         END {
           printf "\n";
         }' |
    sed 's/|$//'`
    grep -lE ''"${uses}"'' *.c |
    sed -e 's/\.c$//' | sort | uniq |
    awk '{printf "#include \"%s.h\"\n", $1;}'
    generate_prototypes 'PRIVATE' $1.stripped
}

# $1 module.c file to generate
# output on stdout
function generate_module_c {
    base=`echo $1 | sed 's/\.c$//'`
    cat ../license_block.c
    generate_module_prologue ${base} > ${base}.prologue
    cat ${base}.prologue ${base}.stripped
    rm ${base}.prologue ${base}.stripped
}

# $1 module base
# output on stdout
function generate_module_header {
    echo $1 |
    awk '{
           printf "#ifndef %s_H\n", toupper($1);
           printf "#define %s_H\n", toupper($1);
           printf "\n";
         }'
    generate_prototypes 'LIBRARY$|^SPMT_NOINLINE' $1.c
    echo $1 | 
    awk '{
           printf "\n";
           printf "#ifdef SPMT_WPA\n";
           printf "#include \"%s.c\"\n", $1;
           printf "#endif /* SPMT_WPA */\n";
           printf "\n";
           printf "#endif /* !%s_H */\n", toupper($1);
         }'
}

# $1 module.h to generate
# output on stdout
function generate_module_h {
    base=`echo $1 | sed 's/\.h$//'`
    cat ../generated_block.c
    generate_module_header ${base}
}

# $1 enum specification
# output on stdout
function generate_enums_c {
    cat ../generated_block.c
    echo "#ifndef ENUMS_C"
    echo "#define ENUMS_C"
    echo "#ifdef ENUMS_C"
    echo "#endif /* ENUMS_C */"
    echo
    echo "#include \"private.h"\"
    echo "#include \"enums.h"\"
    echo
    ls *.enum |
    while read enum
      do
      base=`echo ${enum} | sed 's/\.c//'`
      awk -f enums.c.awk < ${base}
    done
    echo "#endif /* !ENUMS_C */"
}

# output on stdout
function generate_spmt_h_prototypes {
    grep -l '^PUBLIC$' *.c |
    while read module
      do
      module_base=`echo ${module} | sed 's/\.c$//'`
      generate_prototypes 'PUBLIC' ${module} >> ${module}.public
      if test $? -eq 0; then
	  echo "/* ${module_base} */"
	  cat ${module}.public
	  echo
      fi
      rm ${module}.public
    done | sed -e 's/^PUBLIC/SPMT_PUBLIC/' -e '$ d'
}

function create_public_and_private_typedefs {
    ls *.c | grep -v private.c |
    while read module
      do
      module_base=`echo ${module} | sed 's/\.c$//'`
      if grep -q "struct spmt_${module_base}_struct" ${module}; then 
	  typedef="typedef struct spmt_${module_base}_struct spmt_${module_base}_t;"      
	  if grep -q "spmt_${module_base}_t \*" spmt.h.prototypes; then
	      echo ${typedef} >> public.typedefs
	  else
	      echo ${typedef} >> private.typedefs
	  fi
      fi
    done
}

function create_public_and_private_enums {
    ls *.enum |
    while read enum
    do
      base=`echo ${enum} | sed 's/\.enum//'`
      if grep -q "spmt_${base}_t" spmt.h.prototypes; then
	  awk -f enums.h.awk < ${enum} >> public.enums
      else
	  awk -f enums.h.awk < ${enum} >> private.enums
      fi
    done
}

# output on stdout
function generate_spmt_h {
    cat spmt.h |
    strip_between_markers "${start} struct typedefs" "${end} struct typedefs" |
    insert_file_after_marker "${start} struct typedefs" public.typedefs |
    strip_between_markers "${start} enums" "${end} enums" |
    insert_file_after_marker "${start} enums" public.enums |
    strip_between_markers "${start} function prototypes" "${end} function prototypes" |
    insert_file_after_marker "${start} function prototypes" spmt.h.prototypes
    rm -f public.typedefs
    rm -f public.enums
}

# output on stdout
function generate_private_h {
    cat private.h |
    strip_between_markers "${start} struct typedefs" "${end} struct typedefs" |
    insert_file_after_marker "${start} struct typedefs" private.typedefs |
    strip_between_markers "${start} enums" "${end} enums" |
    insert_file_after_marker "${start} enums" private.enums
    rm -f private.typedefs
    rm -f private.enums
}

# output on stdout
function generate_private_c {
    cat ../generated_block.c
    ls *.c |
    grep -v private.c |
    awk '{printf "#include \"%s\"\n", $1;}'
}

# output on stdout
function generate_Makefile_sources_am {
    cat ../generated_block.sh
    echo "ACTUAL_SOURCES = \\"
    ls *.c *.h | grep -v 'private\.c' |
    while read file
      do
      echo "${file} \\"
    done | sed '$ s/ \\//'
    echo
    echo "ENUMS = \\"
    ls *.enum |
    while read file
      do
      echo "${file} \\"
    done | sed '$ s/ \\//'
}

touch modules.list
cat modules.list | tr ' ' '\n' | sed -e 's/\.c$//' -e 's/\.h$//' | grep -vE 'private|spmt|enum' | sort | uniq |
while read module
  do
  echo processing ${module} module...
  generate_file_and_update_if_different generate_module_c ${module}.c
  generate_file_and_update_if_different generate_module_h ${module}.h
done

generate_file_and_update_if_different generate_enums_c enums.c
generate_file_and_update_if_different generate_module_h enums.h

generate_spmt_h_prototypes > spmt.h.prototypes
create_public_and_private_typedefs
create_public_and_private_enums
generate_file_and_update_if_different generate_spmt_h spmt.h
rm -f spmt.h.prototypes
generate_file_and_update_if_different generate_private_h private.h
generate_file_and_update_if_different generate_private_c private.c
generate_file_and_update_if_different generate_Makefile_sources_am Makefile.sources.am
touch modules.list