tools/sdbus++-gen-meson - openbmc/sdbusplus - Gitiles

 #!/usr/bin/env bash

 set -e

 function show_usage {
     cat \
 <<EOF
 Usage: $(basename "$0") [options] <command-args>*

 Generate meson.build files from a directory tree containing YAML files and
 facilitate building the sdbus++ sources.

 Options:
     --help              - Display this message
     --command <cmd>     - Command mode to execute (default 'meson').
     --directory <path>  - Root directory of the YAML source (default '.').
     --output <path>     - Root directory of the output (default '.').
     --tool <path>       - Path to the processing tool (default 'sdbus++').
     --version           - Display this tool's version string.

 Commands:
     meson               - Generate a tree of meson.build files corresponding
                           to the source YAML files.
     cpp <intf>          - Generate the source files from a YAML interface.
     markdown <intf>     - Generate the markdown files from a YAML interface.
     version             - Display this tool's version string.

 EOF
 }

 ## The version is somewhat arbitrary but is used to create a warning message
 ## if a repository contains old copies of the generated meson.build files and
 ## needs an update.  We should increment the version number whenever the
 ## resulting meson.build would change.
 tool_version="sdbus++-gen-meson version 1"
 function show_version {
     echo "$tool_version"
 }

 # Set up defaults.
 sdbuspp="sdbus++"
 outputdir="."
 cmd="meson"
 rootdir="."

 # Parse options.
 options="$(getopt -o hc:d:o:t:v --long help,command:,directory:,output:,tool:,version -- "$@")"
 eval set -- "$options"

 while true;
 do
     case "$1" in
         -h | --help)
             show_usage
             exit
             ;;

         -c | --command)
             shift
             cmd="$1"
             shift
             ;;

         -d | --directory)
             shift
             rootdir="$1"
             shift
             ;;

         -o | --output)
             shift
             outputdir="$1"
             shift
             ;;

         -t | --tool)
             shift
             sdbuspp="$1"
             shift
             ;;

         -v | --version)
             show_version
             exit
             ;;

         --)
             shift
             break
             ;;
     esac
 done

 ## Create an initially empty meson.build file.
 ## $1 - path to create meson.build at.
 function meson_empty_file {
     mkdir -p "$1"
     echo "# Generated file; do not modify." > "$1/meson.build"
 }

 ## Create the root-level meson.build
 ##
 ## Inserts rules to run the available version of this tool to ensure the
 ## version has not changed.
 function meson_create_root {
     meson_empty_file "$outputdir"

     cat >> "$outputdir/meson.build" \
 <<EOF
 sdbuspp_gen_meson_ver = run_command(
     sdbuspp_gen_meson_prog,
     '--version',
 ).stdout().strip().split('\n')[0]

 if sdbuspp_gen_meson_ver != '$tool_version'
     warning('Generated meson files from wrong version of sdbus++-gen-meson.')
     warning(
         'Expected "$tool_version", got:',
         sdbuspp_gen_meson_ver
     )
 endif

 EOF
 }

 ## hash-tables to store:
 ##      meson_paths - list of subdirectory paths for which an empty meson.build
 ##                    has already been created.
 ##      interfaces - list of interface paths which a YAML has been found and
 ##                   which YAML types (interface, errors, etc.).
 declare -A meson_paths
 declare -A interfaces

 ## Ensure the meson.build files to a path have been created.
 ## $1 - The path requiring to be created.
 function meson_create_path {

     meson_path="$outputdir"
     prev_meson_path=""

     # Split the path into segments.
     for part in $(echo "$1" | tr '/' '\n');
     do
         prev_meson_path="$meson_path"
         meson_path="$meson_path/$part"

         # Create the meson.build for this segment if it doesn't already exist.
         if [ "x" == "x${meson_paths[$meson_path]}" ];
         then
             meson_paths["$meson_path"]="1"
             meson_empty_file "$meson_path"

             # Add the 'subdir' link into the parent's meson.build.
             # We need to skip adding the links into the 'root' meson.build
             # because most repositories want to selectively add TLDs based
             # on config flags.  Let them figure out their own logic for that.
             if [ "x$outputdir" != "x$prev_meson_path" ];
             then
                 echo "subdir('$part')" >> "$prev_meson_path/meson.build"
             fi
         fi
     done
 }

 ## Generate the meson target for the source files (.cpp/.hpp) from a YAML
 ## interface.
 ##
 ## $1 - The interface to generate a target for.
 function meson_cpp_target {

     # Determine the source and output files based on the YAMLs present.
     sources=""
     outputs=""
     for s in ${interfaces[$1]};
     do
         sources="${sources}meson.source_root() / '$1.$s', "

         case "$s" in
             errors.yaml)
                 outputs="${outputs}'error.cpp', 'error.hpp', "
                 ;;

             interface.yaml)
                 outputs="${outputs}'server.cpp', 'server.hpp', "
                 outputs="${outputs}'client.hpp', "
                 ;;
         esac
     done

     # Create the target to generate the 'outputs'.
     cat >> "$outputdir/$1/meson.build" \
 <<EOF
 generated_sources += custom_target(
     '$1__cpp'.underscorify(),
     input: [ $sources ],
     output: [ $outputs ],
     command: [
         sdbuspp_gen_meson_prog, '--command', 'cpp',
         '--output', meson.current_build_dir(),
         '--tool', sdbusplusplus_prog,
         '--directory', meson.source_root(),
         '$1',
     ],
 )

 EOF
 }

 ## Generate the meson target for the markdown files from a YAML interface.
 ## $1 - The interface to generate a target for.
 function meson_md_target {

     # Determine the source files based on the YAMLs present.
     sources=""
     for s in ${interfaces[$1]};
     do
         sources="${sources}meson.source_root() / '$1.$s', "
     done

     # Create the target to generate the interface.md file.
     cat >> "$outputdir/$(dirname "$1")/meson.build" \
 <<EOF
 generated_others += custom_target(
     '$1__markdown'.underscorify(),
     input: [ $sources ],
     output: [ '$(basename "$1").md' ],
     command: [
         sdbuspp_gen_meson_prog, '--command', 'markdown',
         '--output', meson.current_build_dir(),
         '--tool', sdbusplusplus_prog,
         '--directory', meson.source_root(),
         '$1',
     ],
     build_by_default: true,
 )

 EOF
 }

 ## Handle command=meson by generating the tree of meson.build files.
 function cmd_meson {
     TLDs="com net org xyz"
     yamls=""

     # Find all the YAML files in the TLD subdirectories.
     for d in $TLDs;
     do
         dir="$rootdir/$d"
         if [ ! -d "$dir" ];
         then
             continue
         fi

         yamls="\
             $yamls \
             $(find "$dir" -name '*.interface.yaml' -o -name '*.errors.yaml') \
             "
     done

     # Sort YAMLs
     yamls="$(echo "$yamls" | tr " " "\n" | sort)"

     # Assign the YAML files into the hash-table by interface name.
     for y in $yamls;
     do
         rel="$(realpath "--relative-to=$rootdir" "$y")"
         dir="$(dirname "$rel")"
         ext="${rel#*.}"
         base="$(basename "$rel" ".$ext")"

         interfaces["$dir/$base"]="${interfaces[$dir/$base]} $ext"
     done

     # Create the meson.build files.
     meson_create_root
     sorted_ifaces="$(echo "${!interfaces[@]}" | tr " " "\n" | sort)"
     for i in ${sorted_ifaces};
     do
         meson_create_path "$i"
         meson_cpp_target "$i"
         meson_md_target "$i"
     done
 }

 ## Handle command=cpp by calling sdbus++ as appropriate.
 ## $1 - interface to generate.
 ##
 ## For an interface foo/bar, the outputdir is expected to be foo/bar.
 function cmd_cpp {

     if [ "x" == "x$1" ];
     then
         show_usage
         exit 1
     fi

     if [ ! -e "$rootdir/$1.interface.yaml" ] && \
         [ ! -e "$rootdir/$1.errors.yaml" ];
     then
         echo "Missing YAML for $1."
         exit 1
     fi

     mkdir -p "$outputdir"

     sdbusppcmd="$sdbuspp -r $rootdir"
     intf="${1//\//.}"

     if [ -e "$rootdir/$1.interface.yaml" ];
     then
         $sdbusppcmd interface server-header "$intf" > "$outputdir/server.hpp"
         $sdbusppcmd interface server-cpp "$intf" > "$outputdir/server.cpp"
         $sdbusppcmd interface client-header "$intf" > "$outputdir/client.hpp"
     fi

     if [ -e "$rootdir/$1.errors.yaml" ];
     then
         $sdbusppcmd error exception-header "$intf" > "$outputdir/error.hpp"
         $sdbusppcmd error exception-cpp "$intf" > "$outputdir/error.cpp"
     fi
 }

 ## Handle command=markdown by calling sdbus++ as appropriate.
 ## $1 - interface to generate.
 ##
 ## For an interface foo/bar, the outputdir is expected to be foo.
 function cmd_markdown {

     if [ "x" == "x$1" ];
     then
         show_usage
         exit 1
     fi

     if [ ! -e "$rootdir/$1.interface.yaml" ] && \
         [ ! -e "$rootdir/$1.errors.yaml" ];
     then
         echo "Missing YAML for $1."
         exit 1
     fi

     mkdir -p "$outputdir"

     sdbusppcmd="$sdbuspp -r $rootdir"
     intf="${1//\//.}"
     base="$(basename "$1")"

     echo -n > "$outputdir/$base.md"
     if [ -e "$rootdir/$1.interface.yaml" ];
     then
         $sdbusppcmd interface markdown "$intf" >> "$outputdir/$base.md"
     fi

     if [ -e "$rootdir/$1.errors.yaml" ];
     then
         $sdbusppcmd error markdown "$intf" >> "$outputdir/$base.md"
     fi
 }

 ## Handle command=version.
 function cmd_version {
     show_version
 }

 "cmd_$cmd" "$*"
	#!/usr/bin/env bash

	set -e

	function show_usage {
	cat \
	<<EOF
	Usage: $(basename "$0") [options] <command-args>*

	Generate meson.build files from a directory tree containing YAML files and
	facilitate building the sdbus++ sources.

	Options:
	--help - Display this message
	--command <cmd> - Command mode to execute (default 'meson').
	--directory <path> - Root directory of the YAML source (default '.').
	--output <path> - Root directory of the output (default '.').
	--tool <path> - Path to the processing tool (default 'sdbus++').
	--version - Display this tool's version string.

	Commands:
	meson - Generate a tree of meson.build files corresponding
	to the source YAML files.
	cpp <intf> - Generate the source files from a YAML interface.
	markdown <intf> - Generate the markdown files from a YAML interface.
	version - Display this tool's version string.

	EOF
	}

	## The version is somewhat arbitrary but is used to create a warning message
	## if a repository contains old copies of the generated meson.build files and
	## needs an update. We should increment the version number whenever the
	## resulting meson.build would change.
	tool_version="sdbus++-gen-meson version 1"
	function show_version {
	echo "$tool_version"
	}

	# Set up defaults.
	sdbuspp="sdbus++"
	outputdir="."
	cmd="meson"
	rootdir="."

	# Parse options.
	options="$(getopt -o hc:d:o:t:v --long help,command:,directory:,output:,tool:,version -- "$@")"
	eval set -- "$options"

	while true;
	do
	case "$1" in
	-h \| --help)
	show_usage
	exit
	;;

	-c \| --command)
	shift
	cmd="$1"
	shift
	;;

	-d \| --directory)
	shift
	rootdir="$1"
	shift
	;;

	-o \| --output)
	shift
	outputdir="$1"
	shift
	;;

	-t \| --tool)
	shift
	sdbuspp="$1"
	shift
	;;

	-v \| --version)
	show_version
	exit
	;;

	--)
	shift
	break
	;;
	esac
	done

	## Create an initially empty meson.build file.
	## $1 - path to create meson.build at.
	function meson_empty_file {
	mkdir -p "$1"
	echo "# Generated file; do not modify." > "$1/meson.build"
	}

	## Create the root-level meson.build
	##
	## Inserts rules to run the available version of this tool to ensure the
	## version has not changed.
	function meson_create_root {
	meson_empty_file "$outputdir"

	cat >> "$outputdir/meson.build" \
	<<EOF
	sdbuspp_gen_meson_ver = run_command(
	sdbuspp_gen_meson_prog,
	'--version',
	).stdout().strip().split('\n')[0]

	if sdbuspp_gen_meson_ver != '$tool_version'
	warning('Generated meson files from wrong version of sdbus++-gen-meson.')
	warning(
	'Expected "$tool_version", got:',
	sdbuspp_gen_meson_ver
	)
	endif

	EOF
	}

	## hash-tables to store:
	## meson_paths - list of subdirectory paths for which an empty meson.build
	## has already been created.
	## interfaces - list of interface paths which a YAML has been found and
	## which YAML types (interface, errors, etc.).
	declare -A meson_paths
	declare -A interfaces

	## Ensure the meson.build files to a path have been created.
	## $1 - The path requiring to be created.
	function meson_create_path {

	meson_path="$outputdir"
	prev_meson_path=""

	# Split the path into segments.
	for part in $(echo "$1" \| tr '/' '\n');
	do
	prev_meson_path="$meson_path"
	meson_path="$meson_path/$part"

	# Create the meson.build for this segment if it doesn't already exist.
	if [ "x" == "x${meson_paths[$meson_path]}" ];
	then
	meson_paths["$meson_path"]="1"
	meson_empty_file "$meson_path"

	# Add the 'subdir' link into the parent's meson.build.
	# We need to skip adding the links into the 'root' meson.build
	# because most repositories want to selectively add TLDs based
	# on config flags. Let them figure out their own logic for that.
	if [ "x$outputdir" != "x$prev_meson_path" ];
	then
	echo "subdir('$part')" >> "$prev_meson_path/meson.build"
	fi
	fi
	done
	}

	## Generate the meson target for the source files (.cpp/.hpp) from a YAML
	## interface.
	##
	## $1 - The interface to generate a target for.
	function meson_cpp_target {

	# Determine the source and output files based on the YAMLs present.
	sources=""
	outputs=""
	for s in ${interfaces[$1]};
	do
	sources="${sources}meson.source_root() / '$1.$s', "

	case "$s" in
	errors.yaml)
	outputs="${outputs}'error.cpp', 'error.hpp', "
	;;

	interface.yaml)
	outputs="${outputs}'server.cpp', 'server.hpp', "
	outputs="${outputs}'client.hpp', "
	;;
	esac
	done

	# Create the target to generate the 'outputs'.
	cat >> "$outputdir/$1/meson.build" \
	<<EOF
	generated_sources += custom_target(
	'$1__cpp'.underscorify(),
	input: [ $sources ],
	output: [ $outputs ],
	command: [
	sdbuspp_gen_meson_prog, '--command', 'cpp',
	'--output', meson.current_build_dir(),
	'--tool', sdbusplusplus_prog,
	'--directory', meson.source_root(),
	'$1',
	],
	)

	EOF
	}

	## Generate the meson target for the markdown files from a YAML interface.
	## $1 - The interface to generate a target for.
	function meson_md_target {

	# Determine the source files based on the YAMLs present.
	sources=""
	for s in ${interfaces[$1]};
	do
	sources="${sources}meson.source_root() / '$1.$s', "
	done

	# Create the target to generate the interface.md file.
	cat >> "$outputdir/$(dirname "$1")/meson.build" \
	<<EOF
	generated_others += custom_target(
	'$1__markdown'.underscorify(),
	input: [ $sources ],
	output: [ '$(basename "$1").md' ],
	command: [
	sdbuspp_gen_meson_prog, '--command', 'markdown',
	'--output', meson.current_build_dir(),
	'--tool', sdbusplusplus_prog,
	'--directory', meson.source_root(),
	'$1',
	],
	build_by_default: true,
	)

	EOF
	}

	## Handle command=meson by generating the tree of meson.build files.
	function cmd_meson {
	TLDs="com net org xyz"
	yamls=""

	# Find all the YAML files in the TLD subdirectories.
	for d in $TLDs;
	do
	dir="$rootdir/$d"
	if [ ! -d "$dir" ];
	then
	continue
	fi

	yamls="\
	$yamls \
	$(find "$dir" -name '.interface.yaml' -o -name '.errors.yaml') \
	"
	done

	# Sort YAMLs
	yamls="$(echo "$yamls" \| tr " " "\n" \| sort)"

	# Assign the YAML files into the hash-table by interface name.
	for y in $yamls;
	do
	rel="$(realpath "--relative-to=$rootdir" "$y")"
	dir="$(dirname "$rel")"
	ext="${rel#*.}"
	base="$(basename "$rel" ".$ext")"

	interfaces["$dir/$base"]="${interfaces[$dir/$base]} $ext"
	done

	# Create the meson.build files.
	meson_create_root
	sorted_ifaces="$(echo "${!interfaces[@]}" \| tr " " "\n" \| sort)"
	for i in ${sorted_ifaces};
	do
	meson_create_path "$i"
	meson_cpp_target "$i"
	meson_md_target "$i"
	done
	}

	## Handle command=cpp by calling sdbus++ as appropriate.
	## $1 - interface to generate.
	##
	## For an interface foo/bar, the outputdir is expected to be foo/bar.
	function cmd_cpp {

	if [ "x" == "x$1" ];
	then
	show_usage
	exit 1
	fi

	if [ ! -e "$rootdir/$1.interface.yaml" ] && \
	[ ! -e "$rootdir/$1.errors.yaml" ];
	then
	echo "Missing YAML for $1."
	exit 1
	fi

	mkdir -p "$outputdir"

	sdbusppcmd="$sdbuspp -r $rootdir"
	intf="${1//\//.}"

	if [ -e "$rootdir/$1.interface.yaml" ];
	then
	$sdbusppcmd interface server-header "$intf" > "$outputdir/server.hpp"
	$sdbusppcmd interface server-cpp "$intf" > "$outputdir/server.cpp"
	$sdbusppcmd interface client-header "$intf" > "$outputdir/client.hpp"
	fi

	if [ -e "$rootdir/$1.errors.yaml" ];
	then
	$sdbusppcmd error exception-header "$intf" > "$outputdir/error.hpp"
	$sdbusppcmd error exception-cpp "$intf" > "$outputdir/error.cpp"
	fi
	}

	## Handle command=markdown by calling sdbus++ as appropriate.
	## $1 - interface to generate.
	##
	## For an interface foo/bar, the outputdir is expected to be foo.
	function cmd_markdown {

	if [ "x" == "x$1" ];
	then
	show_usage
	exit 1
	fi

	if [ ! -e "$rootdir/$1.interface.yaml" ] && \
	[ ! -e "$rootdir/$1.errors.yaml" ];
	then
	echo "Missing YAML for $1."
	exit 1
	fi

	mkdir -p "$outputdir"

	sdbusppcmd="$sdbuspp -r $rootdir"
	intf="${1//\//.}"
	base="$(basename "$1")"

	echo -n > "$outputdir/$base.md"
	if [ -e "$rootdir/$1.interface.yaml" ];
	then
	$sdbusppcmd interface markdown "$intf" >> "$outputdir/$base.md"
	fi

	if [ -e "$rootdir/$1.errors.yaml" ];
	then
	$sdbusppcmd error markdown "$intf" >> "$outputdir/$base.md"
	fi
	}

	## Handle command=version.
	function cmd_version {
	show_version
	}

	"cmd_$cmd" "$*"