A ON manifest pre-processor needs the following attributes:

1) Can selectively "comment out" parts of the

   manifest.

2) Can perform string substitution in manifests.

3) Can include other files to be part of this manifest

   using either inline include statements or command

   line arguments.  In either case, a search path 

   for these files can be specified via one or more

   -I options ala cpp.

4) Can transform actions matching certain

   criteria, using specifications delivered as part of the

   manifest (or one of the included files).

Importer currently does the first two via simple recursive

string substitution:

Macros are of the form: $(MACRONAME) and can have

any string value, including another macro.  Macros

are found in each line, repeatedly substituted

until no more are found.  Expressions of macro

form w/o a value are passed through w/o modification.

Eliding lines from a manifest is done by using a

macro at the begining of the line that has a '#'

value, which is the manifest comment character.

As a practical matter, the macro names are assigned

in the importer Makefile to facilitate understanding;

eg

$(sparc_ONLY) has the value '#' unless the current

build is sparc; $(i386_ONLY) is similar.  On sparc,

$(ARCH64) is sparcv9, etc.

The importer files then use these macros to allow

a single file to be used for both architectures.

For including files, the easiest mechanism would be

some unique (distinct from either a comment, macro

or action line) syntax such as:

<include "path">

The specified path is searched w/o substitution for 

if it starts w/ "/"; otherwise any parameters specifed

via -I are preprended and then searched for in order.

Any files specified w/ -A would be searched for and appended

to the manifest as if they had be specified w/ <include "path">

at the end of the file.

Once the manifest preprocessor had performed macro substitution

and file inclusion, the last step would be executing any transformative

steps specified in the files.  These transformative steps would 

contain a set of matching criteria and the desired effect on the action:

<transform matching criteria -> operation>

matching criteria would be of the form

file|dir|signature|...     any action types

path=var/svc/manifest/.*xml

mode=0?1[0-7][0-7][0-7]

when python regexp rules would be used to find matching attributes.

If multiple attributes are specified they all must be true for the

transform to take effect, with exception that specifying multiple 

action types will match any specified.

operation specification looks like this:

drop				# discard this action

edit attribute regexp [replace]	# apply regexp to value of attribute;

     	       	      		# if match occurs, substitute replace for

				# portion of attribute value that matched.

				# If replace is omitted, remove the 

				# the attribute values that match regexp

set attribute value		# set specified attribute to value

add attribute value		# add value to attribute

Examples:

Add tags to smf manifest so they're properly imported:

<transform file path=var/svc/manifest/.*\.xml -> add refresh_fmri svc:/system/manifest-import:default>

Add tags to gnome icon files to rebuild icon cache:

<transform file path=usr/share/icons/.* -> add restart_fmri svc:/application/desktop-cache/icon-cache:default>

Change action location (including link targets) from usr/openwin to usr/X11:

<transform path=usr/openwin -> edit path usr/openwin usr/X11>

<transform target=.*openwin.* -> edit target openwin X11>

Command line

------------

pkgmog [-D macro=value] ... [-I includepath]... [-A filename] ... [inputfile [outputfile]]

Where:

inputfile is stdin if omitted

outputfile is stdout if omitted

-D defines the value of the specified macro; may be empty

-I adds the specified path to search for included files

-A appends the file to the end of the input as if the last line in the file

   included it

(pkgmog is short for package transmogrify)