This is a fake README.  If it were a real README, it would probably
do something useful like tell you how to use this project template
to create a fabulous project.  It would likely say something like:

  a) change the name of the project directory to that of your project.

  b) change the name of the PROJECT macro in the Makefile to match.  Set
the version and release number.

  c) change project.1, project.c, project.h and project.spec ditto.  Use
no version names.

  d) change project header in the COPYING file.  Keep or discard the
"b" variant clause on the GPL -- I like it, but you may be religious
about GPL stuff (which is fine -- the beverage clause is at least half
joke:-).

  e) I tend to lay things out like:  

    project.1 (man page)
    project.c (dummy main program, basically NO functionality)
    project.h (common include file, used in all subroutine source files)
    parsecl.c (command line parser and Usage().  Also sets global defaults.)
    subsection1.c  (e.g. hello.c in the example project.)
    subsection2.c
    ...

Of course things may get a bit more complex than this if you have more
than one make target, but the Makefile contains a commented out example
of at least one way to handle building two or more small programs or a
big program and a small program in this directory/project.  Note that
this is NOT the "GNU Way" and does not use autoconf (which I find a
cumbersome PITA for simple projects).

If you do the same, add subroutine1.c subroutine2.c and so forth to the
SOURCES macro in the Makefile.

  f) This is a good time to put the whole thing under CVS.  If not
before.

  g) The project template should actually build as delivered.  It should
also build a tarball (project-version.release.tgz) as delivered.  To get
it to build an rpm too, you must do the following:

   i) Create a barebones rpm build tree.  I put all my sources in ~/Src
(as in ~/Src/project) and have my own rpm build tree in ~/Src/rpm_tree.
This is basically:

   ./rpm_tree
             \
             |-BUILD
             |-RPMS
             |-SOURCES
             |-SPECS
             |-SRPMS

(all empty and chmod 755).  Note that this is in USERSPACE.  You don't
need to be root to build root-installed rpm's.

  ii) Create the file ~/.rpmmacros containing:

%_topdir        /home/rgb/Src/rpm_tree

(where you should put in the path to YOUR tree, not mine:-).

 iii) You'll need to edit the RPM_TOPDIR macro in the Makefile to
point to this directory.  If I were REALLY good I'd make this a part of
the project, but it really is reusable and should be outside the project
source tree.

  iv) Edit the project.spec file and make the obvious changes.  This is
not intended to be an RPM build tutorial, but the enclosed spec file
should be pretty obvious.  If you complete the aforementioned two steps
before messing too much with the project template, you SHOULD be able to
execute "make rpm" and have it crank out both installation rpm's and src
rpms totally automagically.  Then all you have to do is install your own
sources and rename everything while keeping this working.  Note that it
is a GOOD IDEA to "make tgz" after all final edits (including such details
as changing version numbers in the Makefile) and before doing "make rpm".

   v) Complicated dependencies, fancy distributions, and so forth are
all up to you.  As I said, this isn't a tutorial in rpm building, just
a useful small project template.

  h) Yes, you'll need to edit the man page and change the number to match
the appropriate man section (probably 1 or 8).  Software without man pages
sucks.

  h) So have at it.  Run a normal edit/compile/debug cycle until everything
is happy.  Update the version/release numbers.  make tgz.  make rpm.  Pop
the tgz, src rpm and rpm files on your favorite repository, and they
SHOULD work whereever.  I believe they're even relocatable, although I
haven't actually tried to relocate them.

Note also that the tar command in the makefile has provision for things
like Cruft junk directories.

                 
