#!/bin/sh
# Minimal Object-Oriented style PreProcessor.
# Copyright (C) 2006-2008, 2015 Free Software Foundation, Inc.
# Written by Bruno Haible <bruno@clisp.org>, 2006.
#
# 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 3 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, see <http://www.gnu.org/licenses/>.
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# Usage: moopp source.oo.c source.oo.h superclass.oo.h ...
# Arguments:
# - the source file of the class,
# - the header file declaring the class,
# - the header file declaring its superclass,
# - etc. up to the root class.
# Creates four files in the current directory:
# - source.c, the preprocessing result of source.oo.c,
# - source.h, the preprocessing result of source.oo.h,
# - class.priv.h, a file declaring the private fields of the class,
# - class.vt.h, a file declaring the virtual function table of the class.
# This implementation of the preprocessor is a quick hack. It makes assumptions
# about the source code:
# - GNU indentation style,
# - the struct declaration must be in a single line,
# - no comments on the struct declaration line,
# - no #ifs in relevant position,
# - ...
# Someday this should be rewritten to use a proper tokenizer and parser.
# func_usage
# outputs to stdout the --help usage message.
func_usage ()
{
echo "\
Usage: moopp [OPTION]... SOURCE.oo.c SOURCE.oo.h SUPERCLASS.oo.h ...
Preprocesses SOURCE.oo.c into CLASS.c and SOURCE.oo.h into CLASS.h,
where CLASS is the name of the class defined in these files.
See moo.h for the object-oriented features and the syntax of the input files.
Options:
--help print this help and exit
--version print version information and exit
--dllexport=NAME Arrange so that the specified class name can be accessed
from outside the shared library it is compiled into.
This option can be repeated.
Report bugs to <bruno@clisp.org>."
}
# func_version
# outputs to stdout the --version message.
func_version ()
{
echo "$progname (GNU $package) $version"
echo "Copyright (C) 2006-2007 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law."
echo "Written by" "Bruno Haible"
}
# func_fatal_error message
# outputs to stderr a fatal error message, and terminates the program.
func_fatal_error ()
{
echo "moopp: *** $1" 1>&2
echo "moopp: *** Stop." 1>&2
exit 1
}
# Command-line option processing.
# Removes the OPTIONS from the arguments. Sets the variables:
# - dllexports list of class names to export from Woe32 DLLs
dllexports=
while test $# -gt 0; do
case "$1" in
--dllexport | --dllexpor | --dllexpo | --dllexp | --dllex | --dlle )
shift
if test $# = 0; then
func_fatal_error "missing argument for --dllexport"
fi
case "$1" in
-*) func_fatal_error "missing argument for --dllexport" ;;
esac
dllexports="$dllexports $1"
shift ;;
--dllexport=* )
arg=`echo "X$1" | sed -e 's/^X--dllexport=//'`
dllexports="$dllexports $arg"
shift ;;
--help | --hel | --he | --h )
func_usage
exit 0 ;;
--version | --versio | --versi | --vers | --ver | --ve | --v )
func_version
exit 0 ;;
-- ) # Stop option prcessing
shift; break ;;
-* )
func_fatal_error "unrecognized option: $option"
;;
* )
break ;;
esac
done
if test $# -lt 2; then
func_fatal_error "Usage: $0 [OPTION]... source.oo.c source.oo.h superclass.oo.h ..."
fi
# Check that all files exist.
for file
do
test -r "$file" || {
func_fatal_error "file $file does not exist"
}
done
source_impl_file="$1"
source_header_file="$2"
shift
shift
case "$source_impl_file" in
*.oo.c) ;;
*) func_fatal_error "invalid class source file name: $source_impl_file" ;;
esac
case "$source_header_file" in
*.oo.h) ;;
*) func_fatal_error "invalid class header file name: $source_header_file" ;;
esac
# A sed expression that removes empty lines.
sed_remove_empty_lines='/^$/d'
# A sed expression that removes ANSI C and ISO C99 comments.
sed_remove_comments="
/[/][/*]/{
ta
:a
s,^\\(\\([^\"'/]\\|\"\\([^\\\"]\\|[\\].\\)*\"\\|'\\([^\\']\\|[\\].\\)*'\\|[/][^\"'/*]\\|[/]\"\\([^\\\"]\\|[\\].\\)*\"\\|[/]'\\([^\\']\\|[\\].\\)*'\\)*\\)//.*,\\1,
te
s,^\\(\\([^\"'/]\\|\"\\([^\\\"]\\|[\\].\\)*\"\\|'\\([^\\']\\|[\\].\\)*'\\|[/][^\"'/*]\\|[/]\"\\([^\\\"]\\|[\\].\\)*\"\\|[/]'\\([^\\']\\|[\\].\\)*'\\)*\\)/[*]\\([^*]\\|[*][^/*]\\)*[*][*]*/,\\1 ,
ta
/^\\([^\"'/]\\|\"\\([^\\\"]\\|[\\].\\)*\"\\|'\\([^\\']\\|[\\].\\)*'\\|[/][^\"'/*]\\|[/]\"\\([^\\\"]\\|[\\].\\)*\"\\|[/]'\\([^\\']\\|[\\].\\)*'\\)*[/][*]/{
s,^\\(\\([^\"'/]\\|\"\\([^\\\"]\\|[\\].\\)*\"\\|'\\([^\\']\\|[\\].\\)*'\\|[/][^\"'/*]\\|[/]\"\\([^\\\"]\\|[\\].\\)*\"\\|[/]'\\([^\\']\\|[\\].\\)*'\\)*\\)/[*].*,\\1 ,
tu
:u
n
s,^\\([^*]\\|[*][^/*]\\)*[*][*]*/,,
tv
s,^.*\$,,
bu
:v
}
:e
}"
# The same thing as an extended regular expression, for use with
# sed --regexp-extended.
sed_remove_comments_ERE="
/[/][/*]/{
ta
:a
s,^(([^\"'/]|\"([^\\\"]|[\\].)*\"|'([^\\']|[\\].)*'|[/][^\"'/*]|[/]\"([^\\\"]|[\\].)*\"|[/]'([^\\']|[\\].)*')*)//.*,\\1,
te
s,^(([^\"'/]|\"([^\\\"]|[\\].)*\"|'([^\\']|[\\].)*'|[/][^\"'/*]|[/]\"([^\\\"]|[\\].)*\"|[/]'([^\\']|[\\].)*')*)/[*]([^*]|[*][^/*])*[*][*]*/,\\1 ,
ta
/^([^\"'/]|\"([^\\\"]|[\\].)*\"|'([^\\']|[\\].)*'|[/][^\"'/*]|[/]\"([^\\\"]|[\\].)*\"|[/]'([^\\']|[\\].)*')*[/][*]/{
s,^(([^\"'/]|\"([^\\\"]|[\\].)*\"|'([^\\']|[\\].)*'|[/][^\"'/*]|[/]\"([^\\\"]|[\\].)*\"|[/]'([^\\']|[\\].)*')*)/[*].*,\\1 ,
tu
:u
n
s,^([^*]|[*][^/*])*[*][*]*/,,
tv
s,^.*\$,,
bu
:v
}
:e
}"
# Check that 'sed' supports the kind of regular expressions used in
# sed_remove_comments. The use of \| meaning alternation of basic regular
# expressions is a GNU extension.
sed_test='s,^\(\(a\|X\)*\)//.*,\1,'
sed_result=`echo 'aaa//bcd' | sed -e "$sed_test"`
test "$sed_result" = 'aaa' \
|| func_fatal_error "The 'sed' program is not GNU sed. Try installing GNU sed."
# func_check_impl_syntax file
# Check the syntax of the source implementation file.
# Output:
# - classname name of the class being defined (without 'struct')
# - superclassname name of the superclass, or empty for a root class
# - impl_decl_lineno line number of the class name declaration ('struct')
# - impl_beg_lineno line number of the start of the class declaration ('{')
# - impl_end_lineno line number of the end of the class declaration ('}')
# - fields field declarations, including preprocessor directives
func_check_impl_syntax ()
{
file="$1"
sed -e "$sed_remove_comments" < "$file" | grep '^fields:' > /dev/null || {
func_fatal_error "$file does not contain 'fields:'"
}
test `sed -e "$sed_remove_comments" < "$file" | grep -c '^fields:'` = 1 || {
func_fatal_error "$file contains more than one 'fields:'"
}
fields_lineno=`sed -e "$sed_remove_comments" < "$file" | grep -n '^fields:' | sed -e 's,:.*,,'`
sed_before_fields="$fields_lineno"',$d'
impl_decl_lineno=`sed -e "$sed_remove_comments" < "$file" | sed -e "$sed_before_fields" | grep -n '^struct[ ]' | tail -n 1 | sed -e 's,:.*,,'`
test -n "$impl_decl_lineno" || {
func_fatal_error "$file: class declaration not found"
}
class_line=`sed -e "$sed_remove_comments" < "$file" | sed -n -e "$impl_decl_lineno"'p'`
sed_extract_classname='s,^struct[ ][ ]*\([A-Za-z_0-9]*\).*,\1,p'
classname=`echo "$class_line" | sed -n -e "$sed_extract_classname"`
test -n "$classname" || {
func_fatal_error "$0: $file: class name not recognized at line $impl_decl_lineno"
}
superclassname=
if echo "$class_line" | grep ':' > /dev/null; then
sed_extract_superclassname='s,^.*:[ ]*struct[ ][ ]*\([A-Za-z_0-9]*\).*,\1,p'
superclassname=`echo "$class_line" | sed -n -e "$sed_extract_superclassname"`
test -n "$superclassname" || {
func_fatal_error "$file: superclass name not recognized at line $impl_decl_lineno"
}
fi
impl_beg_lineno=`sed -e "$sed_remove_comments" < "$file" | sed -e "$sed_before_fields" | grep -n '^{' | tail -n 1 | sed -e 's,:.*,,'`
{ test -n "$impl_beg_lineno" && test "$impl_decl_lineno" -lt "$impl_beg_lineno"; } || {
func_fatal_error "$file: opening brace of class declaration not found after line $impl_decl_lineno"
}
sed_after_fields='1,'"$fields_lineno"'d'
impl_end_lineno=`sed -e "$sed_remove_comments" < "$file" | sed -e "$sed_after_fields" | grep -n '^}' | sed -e '1q' | sed -e 's,:.*,,'`
test -n "$impl_end_lineno" || {
func_fatal_error "$file: closing brace of class declaration not found after line $fields_lineno"
}
impl_end_lineno=`expr $fields_lineno + $impl_end_lineno`
sed_extract_fields="$impl_end_lineno"',$d;1,'"$fields_lineno"'d'
fields=`sed -e "$sed_remove_comments" < "$file" | sed -e "$sed_extract_fields"`
}
# func_check_header_syntax file
# Check the syntax of a header file.
# Output:
# - classname name of the class being defined (without 'struct')
# - superclassname name of the superclass, or empty for a root class
# - class_decl_lineno line number of the class name declaration ('struct')
# - class_beg_lineno line number of the start of the class declaration ('{')
# - class_end_lineno line number of the end of the class declaration ('}')
# - methods newline-separated list of method declarations
func_check_header_syntax ()
{
file="$1"
sed -e "$sed_remove_comments" < "$file" | grep '^methods:' > /dev/null || {
func_fatal_error "$file does not contain 'methods:'"
}
test `sed -e "$sed_remove_comments" < "$file" | grep -c '^methods:'` = 1 || {
func_fatal_error "$file contains more than one 'methods:'"
}
methods_lineno=`sed -e "$sed_remove_comments" < "$file" | grep -n '^methods:' | sed -e 's,:.*,,'`
sed_before_methods="$methods_lineno"',$d'
class_decl_lineno=`sed -e "$sed_remove_comments" < "$file" | sed -e "$sed_before_methods" | grep -n '^struct[ ]' | tail -n 1 | sed -e 's,:.*,,'`
test -n "$class_decl_lineno" || {
func_fatal_error "$file: class declaration not found"
}
class_line=`sed -e "$sed_remove_comments" < "$file" | sed -n -e "$class_decl_lineno"'p'`
sed_extract_classname='s,^struct[ ][ ]*\([A-Za-z_0-9]*\).*,\1,p'
classname=`echo "$class_line" | sed -n -e "$sed_extract_classname"`
test -n "$classname" || {
func_fatal_error "$0: $file: class name not recognized at line $class_decl_lineno"
}
superclassname=
if echo "$class_line" | grep ':' > /dev/null; then
sed_extract_superclassname='s,^.*:[ ]*struct[ ][ ]*\([A-Za-z_0-9]*\).*,\1,p'
superclassname=`echo "$class_line" | sed -n -e "$sed_extract_superclassname"`
test -n "$superclassname" || {
func_fatal_error "$file: superclass name not recognized at line $class_decl_lineno"
}
fi
class_beg_lineno=`sed -e "$sed_remove_comments" < "$file" | sed -e "$sed_before_methods" | grep -n '^{' | tail -n 1 | sed -e 's,:.*,,'`
{ test -n "$class_beg_lineno" && test "$class_decl_lineno" -lt "$class_beg_lineno"; } || {
func_fatal_error "$file: opening brace of class declaration not found after line $class_decl_lineno"
}
sed_after_methods='1,'"$methods_lineno"'d'
class_end_lineno=`sed -e "$sed_remove_comments" < "$file" | sed -e "$sed_after_methods" | grep -n '^}' | sed -e '1q' | sed -e 's,:.*,,'`
test -n "$class_end_lineno" || {
func_fatal_error "$file: closing brace of class declaration not found after line $methods_lineno"
}
class_end_lineno=`expr $methods_lineno + $class_end_lineno`
sed_extract_methods="$class_end_lineno"',$d;1,'"$methods_lineno"'d'
methods=`sed -e "$sed_remove_comments" < "$file" | sed -e "$sed_extract_methods" | tr '\n' ' ' | tr ';' '\n' | sed -e 's,[ ]*$,,'`
sed_remove_valid_arg1_lines='/([ ]*'"$classname"'_t[ ]*[A-Za-z_0-9]*[ ]*[,)]/d'
sed_extract_method_name='s,^.*[^A-Za-z_0-9]\([A-Za-z_0-9][A-Za-z_0-9]*\)[ ]*(.*$,\1,'
methods_with_bad_arg1=`echo "$methods" | sed -e "$sed_remove_empty_lines" -e "$sed_remove_valid_arg1_lines" -e "$sed_extract_method_name"`
if test -n "$methods_with_bad_arg1"; then
methods_with_bad_arg1=`{ echo "$methods_with_bad_arg1" | sed -e 's/$/, /' | tr -d '\n'; echo; } | sed -e 's/\(, \)*$//'`
func_fatal_error "$file: some methods don't have a first argument of type ${classname}_t: $methods_with_bad_arg1"
fi
}
func_check_impl_syntax "$source_impl_file"
impl_classname="$classname"
impl_superclassname="$superclassname"
func_check_header_syntax "$source_header_file"
main_classname="$classname"
main_superclassname="$superclassname"
main_class_decl_lineno="$class_decl_lineno"
main_class_beg_lineno="$class_beg_lineno"
main_class_end_lineno="$class_end_lineno"
main_methods="$methods"
all_superclasses=
all_methods="$methods"
inherited_methods=
last_header_file="$source_header_file"
expected_superclassname="$superclassname"
for file
do
if test -z "$expected_superclassname"; then
func_fatal_error "file $last_header_file does not specify a superclass; superfluous command line argument $file"
fi
func_check_header_syntax "$file"
all_superclasses="$classname $all_superclasses"
all_methods="$methods
$all_methods"
inherited_methods="$methods
$inherited_methods"
if test "$classname" != "$expected_superclassname"; then
func_fatal_error "file $last_header_file specifies superclass '$expected_superclassname', but file $file defines class '$classname'"
fi
last_header_file="$file"
expected_superclassname="$superclassname"
done
if test -n "$expected_superclassname"; then
func_fatal_error "$0: file $last_header_file specifies superclass '$expected_superclassname', please specify the header file that defines it as additional command line argument"
fi
if test "$impl_classname" != "$main_classname"; then
func_fatal_error "file $source_header_file specifies class '$main_classname', but file $source_impl_file specifies class '$impl_classname'"
fi
if test "$impl_superclassname" != "$main_superclassname"; then
if test -z "$main_superclassname"; then
func_fatal_error "file $source_header_file specifies no superclass, but file $source_impl_file specifies a superclass '$impl_superclassname'"
fi
if test -z "$impl_superclassname"; then
func_fatal_error "file $source_header_file specifies a superclass '$main_superclassname', but file $source_impl_file specifies no superclass"
fi
func_fatal_error "file $source_header_file specifies a superclass '$main_superclassname', but file $source_impl_file specifies a superclass '$impl_superclassname'"
fi
# func_start_creation file
# starts the creation of the named file.
func_start_creation ()
{
file="$1"
if test -f "$file"; then
echo "Updating $file (backup in ${file}~)"
mv -f "$file" "${file}~" || func_fatal_error "failed"
else
echo "Creating $file"
fi
}
# func_emit_priv_h newfile
# outputs to $newfile the contents of class.priv.h.
func_emit_priv_h ()
{
newfile="$1"
{
echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */'
echo
if test -n "${main_superclassname}"; then
echo "/* Field layout of superclass. */"
echo "#include \"${main_superclassname}.priv.h\""
echo
fi
echo "/* Field layout of ${main_classname} class. */"
echo "struct ${main_classname}_representation"
echo "{"
if test -n "${main_superclassname}"; then
echo " struct ${main_superclassname}_representation base;"
else
echo " const void *vtable;"
fi
echo "$fields" | sed -e "$sed_remove_empty_lines"
echo "};"
} > "$newfile"
}
# func_emit_vt_h newfile
# outputs to $newfile the contents of class.vt.h.
func_emit_vt_h ()
{
newfile="$1"
{
echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */'
echo
if test -n "${main_superclassname}"; then
echo "/* Virtual function table layout of superclass. */"
echo "#include \"${main_superclassname}.vt.h\""
echo
fi
echo "/* Virtual function table layout of ${main_classname} class. */"
echo "$main_methods" | sed -e "$sed_remove_empty_lines" -e 's/\([^A-Za-z_0-9]\)\([A-Za-z_0-9][A-Za-z_0-9]*\)[ ]*([^,)]*/\1(*\2) (THIS_ARG/' -e 's,$,;,'
} > "$newfile"
}
# In C++ mode, we have a precise type checking. But in C mode, we have only
# loose type checking: So that rootclass_t and subclass_t are assignment
# compatible, we have to define subclass_t as identical to rootclass_t.
# Therefore we need an alias name for the representation of any type in the
# hierarchy.
if test -z "$main_superclassname"; then
main_repclassalias="any_${main_classname}_representation"
else
main_repclassalias="${main_classname}_representation"
fi
sed_extract_method_rettype='s,^\(.*[^A-Za-z_0-9]\)[A-Za-z_0-9][A-Za-z_0-9]*[ ]*(.*$,\1,
s,^[ ]*,,
s,[ ]*$,,'
sed_extract_method_name='s,^.*[^A-Za-z_0-9]\([A-Za-z_0-9][A-Za-z_0-9]*\)[ ]*(.*$,\1,'
sed_extract_method_arglist='s,^.*[^A-Za-z_0-9][A-Za-z_0-9][A-Za-z_0-9]*[ ]*([^,)]*\(.*\)).*$,'"${main_classname}_t"' first_arg\1,'
sed_extract_method_args='s,^.*[^A-Za-z_0-9]\([A-Za-z_0-9][A-Za-z_0-9]*\)$,\1,'
# func_emit_source_h newfile newfile_base
# outputs to $newfile the contents of source.h.
source_header_file_base=`echo "$source_header_file" | sed -e 's,^.*/,,'`
func_emit_source_h ()
{
newfile="$1"
newfile_base="$2"
# Use DLL_VARIABLE if and only if the main classname is among the names
# specified with --dllexport options.
dllexport_for_variables=
for name in $dllexports; do
if test "${main_classname}" = "${name}"; then
dllexport_for_variables=" DLL_VARIABLE"
break
fi
done
{
echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */'
echo
echo "#line 1 \"${source_header_file_base}\""
cat "$source_header_file" | sed -e "${main_class_decl_lineno}"',$d'
echo "#line "`expr 3 + ${main_class_decl_lineno} + 1`" \"$newfile_base\""
echo "struct ${main_repclassalias};"
echo "/* ${main_classname}_t is defined as a pointer to struct ${main_repclassalias}."
echo " In C++ mode, we use a smart pointer class."
echo " In C mode, we have no other choice than a typedef to the root class type. */"
echo "#if IS_CPLUSPLUS"
echo "struct ${main_classname}_t"
echo "{"
echo "private:"
echo " struct ${main_repclassalias} *_pointer;"
echo "public:"
echo " ${main_classname}_t () : _pointer (NULL) {}"
echo " ${main_classname}_t (struct ${main_repclassalias} *pointer) : _pointer (pointer) {}"
echo " struct ${main_repclassalias} * operator -> () { return _pointer; }"
echo " operator struct ${main_repclassalias} * () { return _pointer; }"
atroot=yes
for classname in $all_superclasses; do
if test -n "$atroot"; then
repclassalias="any_${classname}_representation"
else
repclassalias="${classname}_representation"
fi
echo " operator struct ${repclassalias} * () { return (struct ${repclassalias} *) _pointer; }"
atroot=
done
# The 'operator void *' is needed to avoid ambiguous conversion chains.
echo " operator void * () { return _pointer; }"
# The 'operator ==' and 'operator !=' are needed to avoid ambiguous comparisons with NULL.
echo " bool operator == (const void *p) { return _pointer == p; }"
echo " bool operator != (const void *p) { return _pointer != p; }"
atroot=yes
for classname in $all_superclasses; do
if test -n "$atroot"; then
repclassalias="any_${classname}_representation"
else
repclassalias="${classname}_representation"
fi
echo " operator ${classname}_t () { return (${classname}_t) (struct ${repclassalias} *) _pointer; }"
# The 'explicit' constructors allow to downcast.
echo " explicit ${main_classname}_t (${classname}_t x) : _pointer ((struct ${main_repclassalias} *) (void *) x) {}"
atroot=
done
echo "};"
echo "#else"
if test -n "${main_superclassname}"; then
echo "typedef ${main_superclassname}_t ${main_classname}_t;"
else
echo "typedef struct ${main_repclassalias} * ${main_classname}_t;"
fi
echo "#endif"
echo
echo "/* Functions that invoke the methods. */"
echo "$all_methods" | sed -e "$sed_remove_empty_lines" -e 's/\([^A-Za-z_0-9]\)\([A-Za-z_0-9][A-Za-z_0-9]*\)[ ]*([^,)]*/\1'"${main_classname}_"'\2 ('"${main_classname}_t first_arg"'/' -e 's,^,extern ,' -e 's,$,;,'
echo
# Now come the implementation details.
echo "/* Type representing an implementation of ${main_classname}_t. */"
echo "struct ${main_classname}_implementation"
echo "{"
echo " const typeinfo_t * const *superclasses;"
echo " size_t superclasses_length;"
echo " size_t instance_size;"
echo "#define THIS_ARG ${main_classname}_t first_arg"
echo "#include \"${main_classname}.vt.h\""
echo "#undef THIS_ARG"
echo "};"
echo
echo "/* Public portion of the object pointed to by a ${main_classname}_t. */"
echo "struct ${main_classname}_representation_header"
echo "{"
echo " const struct ${main_classname}_implementation *vtable;"
echo "};"
echo
echo "#if HAVE_INLINE"
echo
echo "/* Define the functions that invoke the methods as inline accesses to"
echo " the ${main_classname}_implementation."
echo " Use #define to avoid a warning because of extern vs. static. */"
echo
echo "$all_methods" | sed -e "$sed_remove_empty_lines" |
while read method; do
rettype=`echo "$method" | sed -e "$sed_extract_method_rettype"`
name=`echo "$method" | sed -e "$sed_extract_method_name"`
arglist=`echo "$method" | sed -e "$sed_extract_method_arglist"`
if test "$arglist" = "void"; then
args=
else
args=`{ echo "$arglist" | tr ',' '\n' | sed -e "$sed_extract_method_args" | tr '\n' ','; echo; } | sed -e 's/,$//'`
fi
if test "$rettype" = "void"; then
return=
else
return="return "
fi
echo "# define ${main_classname}_${name} ${main_classname}_${name}_inline"
echo "static inline $rettype"
echo "${main_classname}_${name} ($arglist)"
echo "{"
echo " const struct ${main_classname}_implementation *vtable ="
echo " ((struct ${main_classname}_representation_header *) (struct ${main_repclassalias} *) first_arg)->vtable;"
echo " ${return}vtable->${name} ($args);"
echo "}"
echo
done
echo "#endif"
echo
echo "extern${dllexport_for_variables} const typeinfo_t ${main_classname}_typeinfo;"
if test -n "${main_superclassname}"; then
superclasses_array_initializer="${main_superclassname}_SUPERCLASSES"
else
superclasses_array_initializer="NULL"
fi
echo "#define ${main_classname}_SUPERCLASSES &${main_classname}_typeinfo, ${superclasses_array_initializer}"
if test -n "${main_superclassname}"; then
echo "#define ${main_classname}_SUPERCLASSES_LENGTH (1 + ${main_superclassname}_SUPERCLASSES_LENGTH)"
else
echo "#define ${main_classname}_SUPERCLASSES_LENGTH (1 + 1)"
fi
echo
echo "extern${dllexport_for_variables} const struct ${main_classname}_implementation ${main_classname}_vtable;"
echo
echo "#line "`expr $main_class_end_lineno + 1`" \"${source_header_file_base}\""
cat "$source_header_file" | sed -e "1,${main_class_end_lineno}d"
} > "$newfile"
}
# func_emit_source_c newfile newfile_base
# outputs to $newfile the contents of source.c.
source_impl_file_base=`echo "$source_impl_file" | sed -e 's,^.*/,,'`
func_emit_source_c ()
{
newfile="$1"
newfile_base="$2"
{
echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */'
echo
echo "#line 1 \"${source_impl_file_base}\""
cat "$source_impl_file" | sed -e "${impl_decl_lineno}"',$d'
echo "#line "`expr 3 + ${impl_decl_lineno} + 1`" \"$newfile_base\""
# In C mode, where subclass_t is identical to rootclass_t, we define the
# any_rootclass_representation type to the right one for subclass.
if test -n "$all_superclasses"; then
for classname in $all_superclasses; do
rootclassname="$classname"
break
done
else
rootclassname="$main_classname"
fi
echo "#if !IS_CPLUSPLUS"
echo "#define ${main_classname}_representation any_${rootclassname}_representation"
echo "#endif"
echo "#include \"${main_classname}.priv.h\""
echo
echo "const typeinfo_t ${main_classname}_typeinfo = { \"${main_classname}\" };"
echo
echo "static const typeinfo_t * const ${main_classname}_superclasses[] ="
echo " { ${main_classname}_SUPERCLASSES };"
echo
if test -n "${main_superclassname}"; then
echo "#define super ${main_superclassname}_vtable"
echo
fi
echo "#line "`expr $impl_end_lineno + 1`" \"${source_impl_file_base}\""
cat "$source_impl_file" | sed -e "1,${impl_end_lineno}d" | sed -e "s,${main_classname}::,${main_classname}__,g"
echo
lineno=`wc -l < "$newfile"`
echo "#line "`expr $lineno + 2`" \"$newfile_base\""
# Define trivial stubs for methods that are not defined or overridden.
inherited_method_names=`echo "$inherited_methods" | sed -e "$sed_remove_empty_lines" | sed -e "$sed_extract_method_name"`
echo "$all_methods" | sed -e "$sed_remove_empty_lines" |
while read method; do
rettype=`echo "$method" | sed -e "$sed_extract_method_rettype"`
name=`echo "$method" | sed -e "$sed_extract_method_name"`
arglist=`echo "$method" | sed -e "$sed_extract_method_arglist"`
if test "$arglist" = "void"; then
args=
else
args=`{ echo "$arglist" | tr ',' '\n' | sed -e "$sed_extract_method_args" | tr '\n' ','; echo; } | sed -e 's/,$//'`
fi
if test "$rettype" = "void"; then
return=
else
return="return "
fi
if cat "$source_impl_file" | sed -e "1,${impl_end_lineno}d" | sed -e "$sed_remove_comments" | grep "${main_classname}::${name} *(" > /dev/null; then
# The class defines or overrides the method.
:
else
# Add a stub for the method.
inherited=
for i in $inherited_method_names; do
if test "$i" = "$name"; then
inherited=yes
fi
done
# First a prototype, to avoid gcc -Wmissing-prototypes warnings.
echo "$rettype ${main_classname}__${name} ($arglist);"
echo "$rettype"
echo "${main_classname}__${name} ($arglist)"
echo "{"
if test -n "$inherited"; then
echo " ${return}super.${name} ($args);"
else
echo " /* Abstract (unimplemented) method called. */"
echo " abort ();"
# Avoid C++ compiler warning about missing return value.
echo " #ifndef __GNUC__"
echo " ${return}${main_classname}__${name} ($args);"
echo " #endif"
fi
echo "}"
echo
fi
done
echo
echo "const struct ${main_classname}_implementation ${main_classname}_vtable ="
echo "{"
echo " ${main_classname}_superclasses,"
echo " sizeof (${main_classname}_superclasses) / sizeof (${main_classname}_superclasses[0]),"
echo " sizeof (struct ${main_classname}_representation),"
echo "$all_methods" | sed -e "$sed_remove_empty_lines" |
while read method; do
name=`echo "$method" | sed -e "$sed_extract_method_name"`
echo " ${main_classname}__${name},"
done
echo "};"
echo
echo "#if !HAVE_INLINE"
echo
echo "/* Define the functions that invoke the methods. */"
echo
echo "$all_methods" | sed -e "$sed_remove_empty_lines" |
while read method; do
rettype=`echo "$method" | sed -e "$sed_extract_method_rettype"`
name=`echo "$method" | sed -e "$sed_extract_method_name"`
arglist=`echo "$method" | sed -e "$sed_extract_method_arglist"`
if test "$arglist" = "void"; then
args=
else
args=`{ echo "$arglist" | tr ',' '\n' | sed -e "$sed_extract_method_args" | tr '\n' ','; echo; } | sed -e 's/,$//'`
fi
if test "$rettype" = "void"; then
return=
else
return="return "
fi
echo "$rettype"
echo "${main_classname}_${name} ($arglist)"
echo "{"
echo " const struct ${main_classname}_implementation *vtable ="
echo " ((struct ${main_classname}_representation_header *) (struct ${main_repclassalias} *) first_arg)->vtable;"
echo " ${return}vtable->${name} ($args);"
echo "}"
echo
done
echo "#endif"
} > "$newfile"
}
# Generate the files in the source directory, not in the current directory.
# This is needed because they need to be distributed, since not all platforms
# have GNU 'sed' preinstalled.
sed_butbase='s,[^/]*$,,'
destdir=`echo "$source_impl_file" | sed -e "$sed_butbase"`
# Generate the source.h file first. The Makefile.am snippets rely on the
# fact that the other generated files have the same or a newer timestamp.
#
# Also, generate the source.c file last. The Makefile.am snippets don't know
# about the other generated files; they assume that when the source.c file
# is finished, this command is complete.
new_source_header_file_base=`echo "$source_header_file_base" | sed -e 's,\.oo\.h$,.h,'`
new_source_header_file="${destdir}$new_source_header_file_base"
func_start_creation "$new_source_header_file"
func_emit_source_h "$new_source_header_file" "$new_source_header_file_base" \
|| func_fatal_error "failed"
new_priv_header_file="${destdir}${main_classname}.priv.h"
func_start_creation "$new_priv_header_file"
func_emit_priv_h "$new_priv_header_file" \
|| func_fatal_error "failed"
new_vt_header_file="${destdir}${main_classname}.vt.h"
func_start_creation "$new_vt_header_file"
func_emit_vt_h "$new_vt_header_file" \
|| func_fatal_error "failed"
new_source_impl_file_base=`echo "$source_impl_file_base" | sed -e 's,\.oo\.c$,.c,'`
new_source_impl_file="${destdir}$new_source_impl_file_base"
func_start_creation "$new_source_impl_file"
func_emit_source_c "$new_source_impl_file" "$new_source_impl_file_base" \
|| func_fatal_error "failed"