File: flexml.pl%2Cv

package info (click to toggle)
flexml 1-5
links: PTS
area: main
in suites: potato, woody
size: 884 kB
ctags: 203
sloc: perl: 2,016; makefile: 160; ansic: 56; xml: 28
file content (6576 lines) | stat: -rwxr-xr-x 163,999 bytes
head	1.24;
access;
symbols;
locks; strict;
comment	@# @;


1.24
date	99.12.13.16.18.30;	author krisrose;	state Exp;
branches;
next	1.23;

1.23
date	99.12.09.16.18.39;	author krisrose;	state Exp;
branches;
next	1.22;

1.22
date	99.12.09.08.22.01;	author krisrose;	state Exp;
branches;
next	1.21;

1.21
date	99.12.09.03.47.43;	author krisrose;	state Exp;
branches;
next	1.20;

1.20
date	99.12.06.21.08.09;	author krisrose;	state Exp;
branches;
next	1.19;

1.19
date	99.12.03.23.46.37;	author krisrose;	state Exp;
branches;
next	1.18;

1.18
date	99.12.03.23.24.40;	author krisrose;	state Exp;
branches;
next	1.17;

1.17
date	99.12.03.02.08.56;	author krisrose;	state Exp;
branches;
next	1.16;

1.16
date	99.12.02.00.32.24;	author krisrose;	state Exp;
branches;
next	1.15;

1.15
date	99.12.01.03.41.19;	author krisrose;	state Exp;
branches;
next	1.14;

1.14
date	99.11.30.18.28.23;	author krisrose;	state Exp;
branches;
next	1.13;

1.13
date	99.11.29.16.09.02;	author krisrose;	state Exp;
branches;
next	1.12;

1.12
date	99.11.25.18.42.03;	author krisrose;	state Exp;
branches;
next	1.11;

1.11
date	99.11.25.03.01.47;	author krisrose;	state Exp;
branches;
next	1.10;

1.10
date	99.11.24.16.46.57;	author krisrose;	state Exp;
branches;
next	1.9;

1.9
date	99.11.23.17.28.07;	author krisrose;	state Exp;
branches;
next	1.8;

1.8
date	99.11.23.10.27.04;	author krisrose;	state Exp;
branches;
next	1.7;

1.7
date	99.11.23.10.10.36;	author krisrose;	state Exp;
branches;
next	1.6;

1.6
date	99.11.23.09.32.31;	author krisrose;	state Exp;
branches;
next	1.5;

1.5
date	99.11.23.04.03.05;	author krisrose;	state Exp;
branches;
next	1.4;

1.4
date	99.11.23.02.37.11;	author krisrose;	state Exp;
branches;
next	1.3;

1.3
date	99.11.22.18.41.48;	author krisrose;	state Exp;
branches;
next	1.2;

1.2
date	99.11.08.03.21.12;	author krisrose;	state Exp;
branches;
next	1.1;

1.1
date	99.10.26.16.19.45;	author krisrose;	state Exp;
branches;
next	;


desc
@@


1.24
log
@pcdata -> {#PCDATA}
@
text
@#!/usr/bin/perl -w

# Flex(1) XML processor scanner generator.
# Copyright  1999 Kristoffer Rose.  All rights reserved.
#
# This file is part of the FleXML XML processor generator system.
# Copyright  1999 Kristoffer Rose.  All rights reserved.
#
# 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 2 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, write to the Free Software Foundation, Inc., 59
# Temple Place, Suite 330, Boston, MA 02111-1307 USA.

my $Id = '$Id: flexml.pl,v 1.23 1999/12/09 16:18:39 krisrose Exp krisrose $ ';
$Id =~ s/\s*\$\s*//go;

# IMPORTS.

use Getopt::Std;
use LWP::UserAgent;

use strict;

# FILES (must be global).

use vars qw/ $SKELETON /;	# the skeleton scanner
use vars qw/ $SCANNER /;	# generated XML processor (+ application if requested)
use vars qw/ $HEADER /;		# generated XML processor API header
use vars qw/ $ACTIONS /;	# the actions file
use vars qw/ $APPLICATION /;	# generated XML application

# OPTIONS (and other globals).

my $Use;			# usage string
my %opt = ();			# options

my $debug;			# -d option flag
my $verbose;			# -v option flag
my $lineno;			# -L option flag
my $nofail;			# -X option flag
my $uri;			# -u option uri
my $pubid;			# -p option string

my $dtd;			# DTD file name (or URI)
my $dtdrevision;		# DTD version pruned from file
my $cdtd;			# C identifier derived from DTD name

my @@inputs = ();		# input data stack (array of arrays of lines)
my @@inputnames = ();		# names of files on input data stack
my @@inputlinenos = ();		# line number in input files

# DTD regular expressions (extended to not mess up the counting).

my $NameChar = '[A-Za-z0-9.:_-]';
my $Name     = "[A-Za-z_:]$NameChar*";
my $Names    = "$Name(?:\s+$Name)*";
my $Nmtoken  = "$NameChar+";
my $Nmtokens = "$Nmtoken(?:\s+$Nmtoken)*";
my $Eq       = '\s*=\s*';
my $Literal  = '(?:\'[^\']*\'|"[^"]*")';

# DTD DESCRIPTION STRUCTURES.

my %source = ();	# DTD source lines associated to tag and tag/attribute.

my @@tags = ();		# Tags of the DTD.
my %roottags = ();	# Tags that may be the root tag.
my %ctag = ();		# C variable name of each tag.

my %states = ();	# $states{tag} is list of states used by tag element.
my %emptytrans = ();	# $emptytrans{state} contains empty transitions in automaton.

my %instates = ();	# $instates{tag} is list of states for element start/empty tag.
my %startstate = ();	# $startstate{tag} is the state entered after the start tag.
my %endstates = ();	# $endstates{tag} is list of states for element end tag.
my %exittrans = ();	# $exittrans{tag} is state transitions after end tag.

my %empty = ();		# $empty{tag} == true if the tag may be empty.
my %properempty = ();	# $empty{tag} == true if the tag is declared EMPTY
my %any = ();		# $any{tag} == true if the tag has ANY contents.
my %mixed = ();		# $mixed{tag} == true if the tag has Mixed (or ANY) contents.
my %children = ();	# $children{tag} == true if the tag has Element contents

my %inmixed = ();	# $inmixed{tag} == true if the tag occurs *in* Mixed contents.

my @@attributes = ();	# Attributes of the DTD.
my %catt = ();		# C variable name for attribute.

my %atttype = ();	# XML AttType (type) of tag/attribute
my %enumtype = ();	# whether the tag/attribute is an enumeration type
my %literaltype = ();	# whether the tag/attribute is a tokenized type
my %entitytype = ();	# whether the tag/attribute is of entity type
my %typeof = ();	# C type of tag/attribute

my %attdef = ();	# XML AttDef (default value) of tag/attribute
my %required = ();	# true if tag/attribute is required
my %fixed = ();		# true if tag/attribute has fixed default
my %initof = ();	# C initial attribute value of tag/attribute, if any

my %attlist = ();	# $attlist{tag} is comma-separated list of attribute
			# names allowed in tag elements.
my %withattr = ();	# $withattr{attribute} is comma-separated list of
			# elements within which the tag element may occur.

my %entity = ();	# general entity table (C strings)
my %parameter = ();	# parameter entity table (raw string)
my %external = ();      # external entity table (uris)

my %startok = ();	# start tag action already dumped
my %endok = ();		# end tag action already dumped



# UTILITIES.


sub printsource { # Print source lines of argument.
  my ($key) = @@_;
  local $_ = $source{$key};
  return if not $_;

  s:[*][/]:* /:g;		# avoid */ in output [sic]
  s/\n/\n  * /mg;
  print "\n /* " . $_ . "  */\n";
}


sub cquote { # Convert a string to C source format.
  local ($_) = @@_;
  s/\\/\\\\/g;			# First replace \ to avoid interference...
  s/\"/\\\"/g;
  s/\n/\\n/g; s/\r/\\r/g; s/\t/\\t/g; s/\f/\\f/g;
  s/[\0-\037\200-\377]/ sprintf("\\%.3o",ord($&)) /ge;
  $_
}


sub variablify { # Change XML Name to legal C variable name.
  local ($_) = @@_;
  s|-|_d_|go;
  s|:|_c_|go;
  s|/|__|go;
  $_
}


sub redistribute { # Print C comment with generated file "license".
  my ($pre) = @@_;
  print <<EOT;
$pre This program was generated with the FleXML XML processor generator,
$pre ($Id).
$pre Copyright  1999 Kristoffer Rose.  All rights reserved.
$pre
$pre You can redistribute and/or modify this program provided the following
$pre two conditions hold:
$pre
$pre 1. The program is distributed WITHOUT ANY WARRANTY from the author of
$pre    FleXML; without even the implied warranty of MERCHANTABILITY or
$pre    FITNESS FOR A PARTICULAR PURPOSE.
$pre
$pre 2. The program distribution conditions do not in any way affect the
$pre    distribution conditions of the FleXML system used to generate this
$pre    file or any version of FleXML derived from that system.
$pre
$pre Notice that these are explicit rights granted to you for files
$pre generated by the FleXML system.  For your rights in connection with
$pre the FleXML system itself please consult the GNU General Public License.
EOT
}


sub api_functions { # Print XML application interface functions.
  my ($pre,$post) = @@_;
  print "/* XML application entry points. */\n" if @@tags;
  for (@@tags) {
    print $pre . "void STag_$ctag{$_}(void)$post\n" unless $startok{$_};
    print $pre . "void ETag_$ctag{$_}(void)$post\n" unless $endok{$_};
  }
}


sub api_types { # Print XML application interface types.
  print "/* XML application data. */\n" if %atttype;
  for (keys %atttype) {
    if (m.($Nmtoken)[/]($Nmtoken).xo) {
      my ($tag,$attribute) = ($1,$2);
      print "typedef $typeof{$_} AT_$ctag{$tag}_$catt{$attribute};\n";
      print "#define AU_$ctag{$tag}_$catt{$attribute} NULL\n"
	if not $enumtype{$_};
    }
  }
}


sub api_data { # Print XML application interface parameters.
  my ($pre) = @@_;
  print "/* FleXML-provided data. */\n";
  print $pre . "char* pcdata;\n";
  for (keys %atttype) {
    if (m.($Nmtoken)[/]($Nmtoken).xo) {
      print $pre . "AT_$ctag{$1}_$catt{$2} A_$ctag{$1}_$catt{$2};\n";
    }
  }
}


sub expandparametersat { # Expand parameter entities in $_ at $place.
  my ($place) = @@_;
  while ( m/$place\s*%($Name);/ ) {
    if ($parameter{$1}) {
      s/$place(\s*)%($Name);/ ' '. $1 . $parameter{$2} . ' ' /xe;
    }
  }
}


sub geturl { # Insert contents of URL into input stream at current point

  my ($url) = @@_;
  $url = "file:$url" if not $url =~ m/:/;
  local $_ = $url;
  s.([^/:]*[/:])*..g;
  s/\.dtd$//;

  print STDOUT "Fetching URL <$url>.\n" if $verbose;
  my $ua = new LWP::UserAgent;  # Create a user agent object
  $ua->agent("FleXML/1 " . $ua->agent);
  my $req = new HTTP::Request GET => $url; # Create a request
  my $res = $ua->request($req);	# Pass request to the user agent and get a response
  if ($res->is_error) {
    die place()."URL <$url> could not be fetched.\n";
  }

  # Make the data available...
  push @@inputs, [ split /\r?\n/, $res->content ];
  if (@@{$inputs[$#inputs]}) {
    push @@inputnames, "$url";
    push @@inputlinenos, 0;
  }
  else {
    pop @@inputs;		# oops, empty.
  }

#  print STDOUT "Testing:\n";
#  my $i = 0;
#  for my $ref (@@inputs) {
#    print STDOUT " inputs[" . $i++ . "] =\n";
#    for my $line (@@{$ref}) {
#      print " | $line\n";
#    }
#  }
#  $i = 0;
#  for my $name (@@inputnames) {
#    print STDOUT " inputnames[" . $i++ . "] = `$name'\n";
#  }
#  $i = 0;
#  for my $no (@@inputlinenos) {
#    print STDOUT " inputlinenos[" . $i++ . "] = `$no'\n";
#  }
}


sub nextline {			# return one input line

  return undef unless @@inputs;

  my $line = shift @@{$inputs[$#inputs]};
  $inputlinenos[$#inputs]++;

  while (@@inputs and not @@{$inputs[$#inputs]}) { # discard exhausted inputs
    pop @@inputs;
    pop @@inputnames;
    pop @@inputlinenos;
  }

  return $line;
}


sub place {
  if (@@inputs) {
    local $_ = "\"$inputnames[$#inputs]\", line $inputlinenos[$#inputs]: ";
    s/"file:/"/;
    return $_;
  }
  else {
    return "";
  }
}


sub extractcp { # Split argument in one cp[48] and the rest.

  local ($_) = @@_;
  
  if ( m/^($Name[+?*]?)\s*/o ) {
    return ($1,$');
  }
  elsif ( m/^\s*\(/o ) {
    
    my $cp = '('; $_ = $';
    my $level = 1;

    while ($level > 0 and $_) {

      if ( m/^\s*\(\s*/o ) {
	$level++; $cp .= '('; $_ = $';
      }
      elsif ( m/^\s*(\)[+?*]?)\s*/o ) {
	$level--; $cp .= $1; $_ = $';
      }
      elsif ( m/^\s+/o ) {
	$_ = $';
      }
      else {
	m/[^()\s]+/o; $cp .= $&; $_ = $';
      }
    }
    return ($cp,$_);
  }
}


my $statecounter;

sub analysechildren { # Analyse DTD children specification; return
                      # true if it may be empty.  Uses global $statecounter.

  my ($tag,$re,$in,$out) = @@_;

  local $_ = $re;

  if ( m/^\s*($Name)\s*$/o ) { # tag

    my $thetag = $1;
    my %ins = ();
    if (exists $instates{$thetag}) {
      for (split /,/,$instates{$thetag}) { $ins{$_} = 'true'; }
    }
    $ins{$in} = 'true';
    $instates{$thetag} = join(',',keys %ins);
    $exittrans{$thetag} .= ($exittrans{$thetag}?',':'') . "$in=>$out" if $in ne $out;
    return undef;

  }
  elsif ( m/^((.|\n)+)\?\s*$/o ) { # re ?

    $emptytrans{$in} .= ($emptytrans{$in}?',':'') . $out unless $in eq $out;
    analysechildren($tag,$1,$in,$out);
    return 'true';

  }
  elsif ( m/^((.|\n)+)\+\s*$/o ) { # re +

    my $re = $1;
    my $s1 = "S_$ctag{$tag}_" . (++$statecounter);
    my $s2 = "S_$ctag{$tag}_" . (++$statecounter);
    $states{$tag} .= ",$s1,$s2";
    $emptytrans{$in} .= ($emptytrans{$in}?',':'') . $s1;
    $emptytrans{$s2} = "$s1,$out";
    return analysechildren($tag,$re,$s1,$s2);

  }
  elsif ( m/^((.|\n)+)\*\s*$/o ) { # re *

    return analysechildren($tag,"$1+?",$in,$out);

  }
  elsif ( m/^\s*\(\s*((.|\n)+)\s*\)\s*$/xo ) { # choice or seq

    local $_;
    my $cp;
    ($cp,$_) = extractcp($1);

    if ( m/^\s*$/ ) { # () with single member.

      return analysechildren($tag,$cp,$in,$out);

    }
    elsif ( m/^\s*([|,])\s*/m ) {
      my $type = "[$1]";
      my $maybeempty = ($type eq '[,]');
      my $state = $in;

      while ( m/^\s*$type\s*/ ) {
	$_ = $';

	if ($type eq '[|]') { # $cp is choice
	  $maybeempty = 'true' if analysechildren($tag,$cp,$in,$out);
	}
	else { # $cp is seq component
	  my $oldstate = $state;
	  $state = "S_$ctag{$tag}_" . (++$statecounter);
	  $states{$tag} .= ",$state";
	  $maybeempty = undef unless analysechildren($tag,$cp,$oldstate,$state);
	}
	($cp,$_) = extractcp($_);
      }

      # Last cp needs special treatment in sequence.
      if ($type eq '[|]') { # $cp is choice
        $maybeempty = 'true' if analysechildren($tag,$cp,$in,$out);
      }
      else { # $cp is seq component
	$maybeempty = undef unless analysechildren($tag,$cp,$state,$out);
      }

      $emptytrans{$in} .= ($emptytrans{$in}?',':'') . $out
	if $maybeempty and $in ne $out;
      return $maybeempty unless $_;
    }
  }
  die place()."DTD element `$tag' has nonsense fragment `$_'.\n";
}



# OPTIONS PROCESSING (explained in manual).


# Parse options.
$Use = "Usage: flexml [-ASHDvdnLXV] [-s skel] [-p pubid] [-u uri]\n"
     . "       [-r roottags] [-a actions] name[.dtd]";

getopts('ASHDvdnLXVp:s:u:r:a:', \%opt);

# Version!
print "FleXML version $Id.\n" if $opt{V} or $opt{v};
exit 0 if $opt{V};

# Debugging?
$debug = $opt{d};
$verbose = $opt{v};

# Line numbers?
$lineno = $opt{L};

# Exit without fail message?
$nofail = $opt{X};

# Specific root tags?
if ($opt{r}) {
  for (split ',',$opt{r}) { $roottags{$_} = 'true'; }
}

# Set skeleton scanner file name and check it is readable (if needed).
$SKELETON = ($opt{'s'} ? $opt{'s'} : './skel');
die "$0: No skeleton file $SKELETON.\n" if not -r $SKELETON and $opt{S};

# Set document type URI and PUBID.
$uri = $opt{u} if $opt{u};
$pubid = $opt{p} if $opt{p};

# Set DTD file name...and extract prefix for later
my $prefix = $ARGV[0];
if (defined $prefix and $#ARGV == 0) {
  $prefix =~ s/\.dtd$//;
  $dtd = "$prefix.dtd";		# Require .dtd extension on DTD
  geturl($dtd);			# Read the DTD
  $prefix =~ s|^([^:/]*[:/])*||;
  $cdtd = variablify($prefix);
}
else {
  die "$Use\n";
}  

# Selection options: If none of -SHDA specified then default to -SH.
# Furthermore -a implies -D.
$opt{S} = $opt{H} = 'true' unless ($opt{S} or $opt{H} or $opt{D} or $opt{A});
$opt{D} ||= $opt{a} unless $opt{A};

# Set default (DTD-based) output file names.
$SCANNER = "$prefix.l";
$HEADER =  "$prefix.h";
$APPLICATION = "$prefix-dummy.c";

# Set actions=based output file names, if any.
if ($ACTIONS = $opt{a}) {
  $opt{a} =~ s/\.[a-z]+$//;
  $APPLICATION = "$opt{a}.c";
}

# Stand-alone applications...
if ($opt{A}) {
  die "$0: -A conflicts with -SHD.\n" if ($opt{S} or $opt{H} or $opt{D});
  $SCANNER = $APPLICATION;
  $SCANNER =~ s/\.c$/.l/;
}

# Dry-run?
if ($opt{n}) {
  $opt{A} = $opt{S} = $opt{H} = $opt{D} = undef;
}


# PARSE DTD.


print STDOUT "Processing DTD in $dtd.\n" if $verbose;

$_ = '';			# Current entry

while (@@inputs) {		# While there are lines...

  my $orig = "$_";		# current source line(s)

  # Skip spaces and complete comments (but save as source).
  do {
    # Skip blank lines.
    $_ = nextline() while @@inputs and m/^\s*$/;

    # If we're looking at a parameter or external entity then expand it.
    if ( m/^\s*%($Name);/ ) {
      my $ent = $1;
      if ($parameter{$ent}) {
        expandparametersat('^');
      }
      elsif ($external{$ent}) {
        $_ = $';
        geturl($external{$ent});
      }
      else {
        die "Unknown entity `%$ent;'\n";
      }
    }

    # Skip (but save) comments.
    while ( m/^\s*<!--/ ) {
      until (m/-->/ or not @@inputs) { $_ .= "\n" . nextline(); }
      # Extract first DTD version number...
      if ( not $dtdrevision and /\$(Id|Header|Revision): [^\$]*\$/ ) {
	$dtdrevision = "$&";
	$dtdrevision =~ s/\s*\$\s*//go;
      }
      # Remove the comment to read on to next nonblank (but save as
      # source). 
      $orig .= ($orig?"\n":"").$1 if s/^\s*(<!--([^-]|-[^-]|--[^>])*-->)\s*//;
    }
    s/^\s*//;
  } until $_ or not @@inputs;

  # If we're looking at a parameter or external entity then expand and retry.
  if ( m/^\s*%($Name);/ ) {
    my $ent = $1;
    if ($parameter{$ent}) {
      expandparametersat('^');
    }
    elsif ($external{$ent}) {
      $_ = $';
      geturl($external{$ent});
      next;
    }
    else {
      die "Unknown entity `%$ent;'\n";
    }
  }

  die place()."Nonsense `$_'.\n" if /^[^<]/ or /^<[^!]/;

  # Read on until a full DTD <!...> or <?...?> entry is available.
  until (m/^\s*<![^>]*>/o or m/^\s*<[?]([^?]|[?][^>])*[?]>/o or not @@inputs) {
    my $line = nextline();
    $orig .= ($orig?"\n":"") . $line;
    $_ .= "\n" . $line;
  }

  unless ( m/^\s*<![^>]*>/o or m/^\s*<[?]([^?]|[?][^>])*[?]>/o ) {
    last if not @@inputs;
    die place()."Could not find end of declaration.\n";
  }

  # Clean out in $orig.
  $orig =~ s/\n+/\n/g;
  $orig =~ s/^\n*//g;
  $orig =~ s/\n*$//g;

  print STDOUT " [$_]\n" if $debug;

  # Processing instruction.
  if ( m/^\s*<[?]([^?]|[?][^>])*[?]>\s*/o ) {
    print STDERR place()."Warning: ignoring processing instruction $&.\n";
    $_ = $';
  }

  # Parse element declarations.
  elsif ( m/^<!ELEMENT\s+($Name)\s+([^>]*)>\s*/xo ) {

    $_ = $'; $source{$1} = "$orig";

    my $tag = $1;
    die place()."Repeated element $tag.\n" if $ctag{$tag};
    push @@tags, $tag;

    # Create C-friendly tag names.
    $ctag{$tag} = variablify($tag) unless $ctag{$tag};
    my $c = $ctag{$tag};

    local $_ = $2;
    expandparametersat(''); s/^\s+//;

    # All elements should be followed by nothing when at the root.
    $exittrans{$tag} .= ($exittrans{$tag}?',':'') . "ROOT_$c=>EPILOG"
      if not %roottags or $roottags{$tag};

    # Handle element declaration.
    if ( m/^EMPTY\s*$/o ) {
      $empty{$tag} = 'true';
      $properempty{$tag} = 'true';
      $states{$tag} = "E_$c";
      $startstate{$tag} = "E_$c";
      $endstates{$tag} = "E_$c";
    }
    elsif ( m/^ANY\s*$/o ) {
      $any{$tag} = 'true';
      $mixed{$tag} = 'true';
      $empty{$tag} = 'true';
      $states{$tag} = "IN_$c";
      $startstate{$tag} = "IN_$c";
      $endstates{$tag} = "IN_$c";
    }
    elsif ( m/^\(\s*\#PCDATA\s*\)\s*$/o
	    or m/^\(\s*\#PCDATA\s*((\|\s*$Name\s*)*)\)\*\s*$/xo ) {
      $mixed{$tag} = 'true';
      $empty{$tag} = 'true';
      if ($1) {
	my $desc = $1;
	$desc =~ s/^\s*\|\s*//o;
	for (split /\s*\|\s*/,$desc) {
	  $instates{$_} .= ($instates{$_}?',':'') . "IN_$c";
	  $inmixed{$_} = 'true';
	}
      }
      $states{$tag} = "IN_$c";
      $startstate{$tag} = "IN_$c";
      $endstates{$tag} = "IN_$c";
    }
    else {
      $children{$tag} = 'true';
      $statecounter = 0;
      $states{$tag} = "S_$c";
      $startstate{$tag} = "S_$c";
      $empty{$tag} = 'true' if analysechildren($tag,$_,"S_$c","E_$c");
      $states{$tag} .= ",E_$c";
      $endstates{$tag} = "E_$c";
    }
  }

  # Parse attribute declarations.
  elsif ( m/^<!ATTLIST\s+($Name)\s+([^>]*)>\s*/o ) {

    $_ = $';
    {
      my $tag = $1;
      local $_ = $2;

      expandparametersat(''); s/^\s+//;

      # Repeat while there are attribute declarations.
      while ( s/^($Name)\s+([A-Z]+|\(\s*$Nmtoken\s*(?:\|\s*$Nmtoken\s*)*\))
		(?:\s+(\#IMPLIED|\#REQUIRED|(?:\#FIXED\s+)?$Literal))?\s*//xo ) {

	my ($attribute,$type,$default) = ($1,$2,$3);

	if ($atttype{"$tag/$attribute"}) {
	  print place()."Warning: Redeclaration of element $tag attribute $attribute ignored.\n";
	}
	else {
	  if ($orig) { # to only print the source once once
	    $source{"$tag/$attribute"} = "$orig";
	    $orig = '';
	  }

	  $ctag{$tag} = variablify($tag) unless $ctag{$tag};
	  $catt{$attribute} = variablify($attribute) unless $catt{$attribute};

	  # Add atribute to the appropriate lists.
	  $attlist{$tag} .= ($attlist{$tag}?',':'') . "$attribute";
	  if ($withattr{$attribute}) {
	    $withattr{$attribute} .= ",$tag"; 
	  }
	  else {
	    push @@attributes, $attribute;
	    $withattr{$attribute} = "$tag"; 
	  }

	  # Analyse default value.
	  if (defined $default) {
	    if ($default eq '#REQUIRED') {
	      $required{"$tag/$attribute"} = 'true';
	      $default = undef;
	    }
	    elsif ($default eq '#IMPLIED') {
	      $default = undef;
	    }
	    else {
	      $fixed{"$tag/$attribute"} = 'true' if $default =~ s/\#FIXED\s+//o;
	      $default =~ s/^'([^'']*)'$/$1/o unless $default =~ s/^"([^""]*)"$/$1/o;
	    }
	  }

	  # Store attribute default string and type.
	  $attdef{"$tag/$attribute"} = $default if $default;
	  $atttype{"$tag/$attribute"} = $type;

	  # Handle enumeration types...
	  if ( $type =~ m/^\(((.|\n)*)\)$/x ) {
	    local $_ = $1;
	    s/\s+//go;
	    s/\|/,/go;
	    $enumtype{"$tag/$attribute"} = "$_";
	    s/$Nmtoken/ "A_$ctag{$tag}_$catt{$attribute}_" . variablify($&) /xge;
	    my $undefined = "AU_$ctag{$tag}_$catt{$attribute}";
	    s/^/enum \{ $undefined, /o;
	    s/$/ \}/o;
	    $typeof{"$tag/$attribute"} = "$_";
	    if ($default) {
	      $initof{"$tag/$attribute"} = "A_$ctag{$tag}_$catt{$attribute}_"
					 . variablify($default);
	    }
	    else {
	      $initof{"$tag/$attribute"} = "$undefined";
	    }
	  }
	  # ...and string/token types.
	  else {
	    $typeof{"$tag/$attribute"} = 'char*';
	    if ($default) {
	      $initof{"$tag/$attribute"} = "\"$default\"";
	    }
	    else {
	      $initof{"$tag/$attribute"} = 'NULL';
	    }

	    # Special treatment of token types.
	    if ( $type eq 'ID' or $type eq 'IDREF' ) {
	      $literaltype{"$tag/$attribute"} = '{Name}';
	      print STDERR place()."Warning: attribute type `$type' not validated.\n";
	    }
	    elsif ( $type eq 'IDREFS' ) {
	      $literaltype{"$tag/$attribute"} = '{Names}';
	      print STDERR place()."Warning: attribute type `$type' not validated.\n";
	    }
	    elsif ( $type eq 'NMTOKEN' ) {
	      $literaltype{"$tag/$attribute"} = '{Nmtoken}';
	    }
	    elsif ( $type eq 'NMTOKENS' ) {
	      $literaltype{"$tag/$attribute"} = '{Nmtokens}';
	    }
	    elsif ( $type eq 'ENTITY' ) {
	      die place()."ENTITY attribute type unimplemented.\n";
	    }
	    elsif ( $type eq 'ENTITIES' ) {
	      die place()."ENTITIES attribute type unimplemented.\n";
	    }
	    elsif ( $type ne 'CDATA' ) {
	      die place()."Unknown AttType `$type'.\n";
	    }

	  }
	}

	expandparametersat('^'); s/^\s+//; # to expand next set of declarations...
      }

      die place()."Nonsense ($_) in attribute list.\n" if $_;
    }

    $orig = '';			# in case there were no attributes...
  }

  # Parse internal parameter entity declaration.
  elsif ( m/^\s*<!ENTITY\s+%\s+($Name)\s+'([^'']*)'\s*>\s*/xo
	  or m/^\s*<!ENTITY\s+%\s+($Name)\s+"([^""]*)"\s*>\s*/xo ) {

    $_ = $'; $source{"%$1;"} = "$orig"; $orig = ''; # cycle

    my $name = $1;
    local $_ = $2;

    die "Entity `%$name;' doubly defined.\n" if $parameter{$name} or $external{$name};
    
    expandparametersat(''); s/^\s+//; s/\s+$//;
    s/\&\#([0-9]+|x[0-9a-fA-F]+);/
      (substr($1,0,1) eq 'x' ? chr(hex(substr($1,1))) : chr($1)) /ge;
    $parameter{$name} = $_;
  }

  # Parse external parameter entity declaration.
  elsif ( m/^<!ENTITY\s+%\s+($Name)\s+SYSTEM\s+'([^'']*)'\s*>\s*/xo
	  or m/^<!ENTITY\s+%\s+($Name)\s+SYSTEM\s+"([^""]*)"\s*>\s*/xo
	  or m/^<!ENTITY\s+%\s+($Name)\s+PUBLIC\s+$Literal\s+'([^'']*)'\s*>\s*/xo
	  or m/^<!ENTITY\s+%\s+($Name)\s+PUBLIC\s+$Literal\s+"([^""]*)"\s*>\s*/xo ) {

    $_ = $'; $source{"%$1;"} = "$orig"; $orig = ''; # cycle

    my $name = $1;
    die "Entity `%$name;' doubly defined.\n" if $parameter{$name} or $external{$name};
    $external{$name} = $2;
  }

  # Parse internal general entity declarations.
  elsif ( /^<!ENTITY\s+($Name)\s+['"]([^''""]*)["']\s*>\s*/xo ) {

    $_ = $'; $source{"&$1;"} = "$orig"; $orig = ''; # cycle

    my $name = $1;
    local $_ = $2;

    die "Entity `&$name;' doubly defined.\n" if $entity{$name};
    s/\&\#([0-9]+|x[0-9a-fA-F]+);/
      (substr($1,0,1) eq 'x' ? chr(hex(substr($1,1))) : chr($1)) /ge;
    $entity{$name} = cquote($_);
  }

  # Unrecognised declaration.
  else {
    die place()."Unrecognized declaration.\n";
  }

}

# Post-process DTD.

print STDOUT "Post-processing DTD.\n" if $verbose;

# Add transitive empty transitions until none can be found.
{ my $changed = 'true';
  while ($changed) {
    $changed = undef;
    for my $from (keys %emptytrans) {
      my %tos = (); for (split /,/,$emptytrans{$from}) { $tos{$_} = 'true'; }
      for my $to (keys %tos) {
	if (exists $emptytrans{$to}) {
	  for my $next (split /,/,$emptytrans{$to}) {
	    if (not $tos{$next}) {
	      $changed = $tos{$next} = 'true';
	    }
	  }
	}
      }
      $emptytrans{$from} = join ',',keys %tos;
    }
  }
}

# Complete all states with their `empty' equivalents.
for my $tag (@@tags) {

  # Complete and prune instates and endstates...
  my %ins = ();
  if (exists $instates{$tag}) {
    for (split ',',$instates{$tag}) { $ins{$_} = 'true'; }
  }
  my %ens = ();
  if (exists $endstates{$tag}) {
    for (split ',',$endstates{$tag}) { $ens{$_} = 'true'; }
  }

  # ...and exit transitions...
  my %exits = ();
  if (exists $exittrans{$tag}) {
    for (split ',',$exittrans{$tag}) { m/^($Name)=>($Name)$/o; $exits{$1} = $2; }
  }

  # Encode ANY as Mixed contents with all tags permitted.
  for (keys %any) { $ins{"IN_$_"} = 'true'; }

  # For each empty transition A->B add A where B occurs.
  for my $from (keys %emptytrans) {
    for my $to (split /,/,$emptytrans{$from}) {
      $ins{$from} = 'true' if $ins{$to};
      $ens{$from} = 'true' if $ens{$to};
      $exits{$from} = $exits{$to} if $exits{$to};
    }
  }

  # Completion done...now store'em right back.
  $instates{$tag} = join ',', keys %ins if %ins;
  $endstates{$tag} = join ',', keys %ens if %ens;
  $exittrans{$tag} = join ',', map "$_=>$exits{$_}", keys %exits if %exits;
}

if (not %roottags) {
  for (@@tags) { $roottags{$_} = 'true'; }
}


# Debugging: show DTD representation.

if ($debug) {

  print STDOUT "DTD debug output:\n" if $verbose;

  sub printhash {
    my ($name) = @@_;
    my @@keys = eval "keys \%$name";
    my @@values = eval "values \%$name";

    my $out = '';
    while (@@keys) { $out .= "\n " . pop(@@keys) . " => " . pop(@@values); }
    $out;
  }

  print '%opt = (' . printhash('opt') . ")\n";

  print '%source = (' . printhash('source') . ")\n";
  print "\n";

  print '@@tags = (' . join(',',@@tags) . ")\n";
  print '%ctag = (' . printhash('ctag') . ")\n";

  print '%states = (' . printhash('states') . ")\n";
  print '%instates = (' . printhash('instates') . ")\n";
  print '%endstates = (' . printhash('endstates') . ")\n";

  print '%emptytrans = (' . printhash('emptytrans') . ")\n";
  print '%exittrans = (' . printhash('exittrans') . ")\n";

  print '%empty = (' . printhash('empty') . ")\n";
  print '%any = (' . printhash('any') . ")\n";
  print '%mixed = (' . printhash('mixed') . ")\n";
  print '%children = (' . printhash('children') . ")\n";
  print '%inmixed = (' . printhash('inmixed') . ")\n";
  print "\n";

  print '@@attributes = (' . join(',',@@attributes) . ")\n";
  print '%catt = (' . printhash('catt') . ")\n";

  print '%atttype = (' . printhash('atttype') . ")\n";
  print '%enumtype = (' . printhash('enumtype') . ")\n";
  print '%literaltype = (' . printhash('literaltype') . ")\n";
  print '%typeof = (' . printhash('typeof') . ")\n";

  print '%attdef = (' . printhash('attdef') . ")\n";
  print '%required = (' . printhash('required') . ")\n";
  print '%fixed = (' . printhash('fixed') . ")\n";
  print '%initof = (' . printhash('initof') . ")\n";

  print '%attlist = (' . printhash('attlist') . ")\n";
  print '%withattr = (' . printhash('withattr') . ")\n";
  print "\n";

  print '%entity = (' . printhash('entity') . ")\n";
  print '%parameter = (' . printhash('parameter') . ")\n";
  print '%external = (' . printhash('external') . ")\n";
}


# WRITE API HEADER (if requested).


if ($opt{H}) {

  print STDOUT "Generating XML processor header in `$HEADER'.\n" if $verbose;

  open HEADER, "+>$HEADER";
  select HEADER;

  # Identification and license.
  print "/* XML processor/application API for $dtd"
      . ($dtdrevision ? " ($dtdrevision)" : "") . ".\n";
  print " * Generated " . `date +'%Y/%m/%d %T.'`;
  print " *\n";
  redistribute(" *");
  print " */\n";
  print "\n";

  # Output the declarations safeguarded againts repeated loading.
  print "#ifndef _FLEXML_${cdtd}_H\n";
  print "\n";
  api_functions('extern ',';');
  print "\n";
  api_types();
  print "\n";
  api_data('extern ');
  print "\n";

  print "/* XML application utilities. */\n";
  print "extern int element_context(int);\n";
  print "\n";
  print "/* XML processor entry point. */\n";
  print "extern int yylex(void);\n";
  print "\n";
  print "#endif\n";

  close HEADER;
}



# WRITE XML PROCESSOR (if requested).


if ($opt{S} or $opt{A}) {

  print STDOUT "Writing XML processor"
             . ($opt{a} || $opt{A} ? " and application" : "")
             . " onto `$SCANNER'.\n" if $verbose;

  open SCANNER, "+>$SCANNER";
  select SCANNER;

  open SKELETON;

  # Identification and license.
  print "/* Validating XML processor for $dtd"
      . ($dtdrevision ? " ($dtdrevision)" : "") . ".\n";
  print " * Generated " . `date +'%Y/%m/%d %T.'`;
  print " *\n";
  redistribute(" *");
  print " */\n";
  print "\n";

  # Skip initial comment.
  while (<SKELETON>) { last if m/^\%\{/; }
  print;

  # Copy body of skeleton scanner with substitutions...
  while (<SKELETON>) {

    if ( /^FLEXML_VERSION$/ ) {

      print "const char rcs_flexml[] =\n"
	  . " \"\$\" \"$Id \$\";\n";

      print "const char rcs_${cdtd}_dtd[] =\n"
	  . " \"\$\" \"$dtdrevision \$\";\n" if $dtdrevision;

    }
    elsif ( /^FLEXML_DEFINITIONS$/ ) {

      print "#define DEBUG\n" if $debug;
      print "#define FLEXML_yylineno\n" if $lineno;
      print "#define FLEXML_NOFAIL\n" if $nofail;
      print "#define FLEXML_HasMixed\n" if %inmixed;
      print "#define FLEXML_BUFFERSTACKSIZE 100000\n";
      print "\n";

      if ($opt{A}) {
	api_functions('static ',';');
	print "\n";
	api_types();
	print "\n";
	api_data('static ');
      }
      else {
	print "/* XML processor api. */\n";
	print "#include \"$HEADER\"\n";
	print "\n";
	api_data('');
      }

    }
    elsif ( /^FLEXML_FLEX_OPTIONS$/ ) {

      print "%option yylineno\n" if $lineno;
      print "%option debug\n" if $debug;
      print "%option nounput\n" if not %entity;

    }
    elsif ( /^FLEXML_START_CONDITIONS$/ ) {

      for (@@tags) {
	my $c = $ctag{$_};
	print "%x"
            . ($roottags{$_} ? " ROOT_$c" : "")
            . " AL_$c " . join(' ',split(',',$states{$_})) . "\n";
      }

    }
    elsif ( /^FLEXML_EXTRA_DEFINITIONS$/ ) {

      my ($state, $tag);

      print "%{\n";
      print "/* State names. */\n";
      print "char* statenames[IMPOSSIBLE];\n";
      print "\n";
      print "void FleXML_init(void)\n";
      print "{\n";

      for ('PROLOG','DOCTYPE','EPILOG','INCOMMENT','INPI','VALUE1','VALUE2','CDATA') {
	print "  statenames[$_] = NULL;\n";
      }
      for my $tag (@@tags) {
	my $c = $ctag{$tag};
	print "  statenames[ROOT_$c] = NULL;\n" if $roottags{$tag};
	print "  statenames[AL_$c] = NULL;\n";
	for (split ',',$states{$tag}) {
	  print "  statenames[$_] = \"$tag\";\n";
	}
      }
      print "}\n";
      print "%}\n";

    }
    elsif ( /^FLEXML_DOCTYPES$/ ) {

      my $sysid = ( $uri ? "(\"'$uri'\"|\"\\\"$uri\\\"\")"
			    : "(\"'$dtd'\"|\"\\\"$dtd\\\"\")" );

      for (keys %roottags) {
	my $c = $ctag{$_};
	print " \"<!DOCTYPE\"{S}\"$_\"{S}"
	    . "SYSTEM{S}" . $sysid . "{s}\">\" SET(ROOT_$c);\n";
	if ($pubid) {
	  print " \"<!DOCTYPE\"{S}\"$_\"{S}"
	      . "PUBLIC{S}(\"'$pubid'\"|\"\\\"$pubid\\\"\"){S}"
	      . $sysid . "{s}\">\" SET(ROOT_$c);\n";
	}
      }	  

    }
    elsif ( /^FLEXML_RULES$/ ) {

      # Dump all parameter entity declarations.
      for (keys %parameter) { printsource($_); }

      # Dump all start and empty tag recognition rules.
      for my $tag (@@tags) {

	my $myctag = $ctag{$tag};
	my @@myattributes = (exists $attlist{$tag} ? split /,/,"$attlist{$tag}" : ());
	my ($intag, $attribute);

	# Tag's source element and attribute declarations.
	printsource($tag);
	for my $attribute (@@myattributes) {
	  printsource("$tag/$attribute");
	}

	# Build element exit transition command.
	my $exitswitch = "";
	if (exists $exittrans{$tag}) {
	  $exitswitch .= "  switch (YY_START) {\n";
	  my %casesto = ();
	  for (split /,/,$exittrans{$tag}) {
	    if (m/^($Name)=>($Name)$/o) {
	      $casesto{$2} .= "case $1: ";
	    }
	  }
	  for (keys %casesto) {
	    $exitswitch .= "   $casesto{$_}SET($_); break;\n" 
	  }
	  $exitswitch .= "  }\n";
	}
	





	# Start or empty tag: initialise attribute list.
	print "\n";
	if ($roottags{$tag}) {
	  print "<ROOT_$myctag" . ($instates{$tag} ? ",$instates{$tag}" : "");
	}
	else {
	  print "<$instates{$tag}";
	}
	print ">\"<$tag\"{s} {\n";
	for my $attribute (@@myattributes) {
	  print "  A_${myctag}_$catt{$attribute} = " . $initof{"$tag/$attribute"} . ";\n";
	}
	print "  ENTER(AL_$myctag);\n";
	print "}\n";

	# Attribute list (of start or empty tag):
	print "\n";
	print "<AL_$myctag>{\n";

	for my $attribute (@@myattributes) {
	  my $type; # set by conditions
	  
	  if ($type = $enumtype{"$tag/$attribute"}) {

	    # - fixed enumeration attribute: generate one rule,
	    if ($fixed{"$tag/$attribute"}) {
		print " \"$attribute\"{Eq}\"'" . $attdef{"$tag/$attribute"} . "'\""
		    . " |\n"
		    . " \"$attribute\"{Eq}\"\\\"" . $attdef{"$tag/$attribute"} . "\\\"\""
		    . " A_${myctag}_$catt{$attribute}"
		    . " = " . $initof{"$tag/$attribute"} . ";\n";
	    }
	    else {
	      # - (non-fixed) enumeration attribute: generate a rule per value,
	      for my $alternative (split /,/,$type) {
		print " \"$attribute\"{Eq}\"'$alternative'\""
		    . " |\n"
		    . " \"$attribute\"{Eq}\"\\\"$alternative\\\"\""
		    . " A_${myctag}_$catt{$attribute}"
		    . " = A_${myctag}_$catt{$attribute}_" . variablify($alternative) . ";\n";
	      }
	    }
	  }
	  elsif ($fixed{"$tag/$attribute"}) {

	    # - fixed (non-enumeration) attribute: generate one rule per literal form,

	    print " \"$attribute\"{Eq}\"'" . $attdef{"$tag/$attribute"} . "'\""
	        . " |\n"
		. " \"$attribute\"{Eq}\"\\\"" . $attdef{"$tag/$attribute"} . "\\\"\""
		. " A_${myctag}_$catt{$attribute}"
		. " = " . $initof{"$tag/$attribute"} . ";\n";

	  }
	  elsif ($type = $literaltype{"$tag/$attribute"}) {

	    # - (non-fixed) literal-type attribute: scan literal string directly, or
	    print " \"$attribute\"{Eq}\'$type\' BUFFERLITERAL('\\\'',A_${myctag}_$catt{$attribute});\n";

	    print " \"$attribute\"{Eq}\\\"$type\\\" BUFFERLITERAL('\"',A_${myctag}_$catt{$attribute});\n";

	  }
	  else {

	    # - (non-fixed non-literal) attribute: scan string with entity expansion.
	    print " \"$attribute\"{Eq}\\' ENTER(VALUE1); BUFFERSET(A_${myctag}_$catt{$attribute});\n";
	    print " \"$attribute\"{Eq}\\\" ENTER(VALUE2); BUFFERSET(A_${myctag}_$catt{$attribute});\n";

	  }
	  print "\n";
	}
	#
	# - the end of a start tag means to enter the contents after
	#   checking that all required attributes were set.
	print " \">\" {\n";
	for my $attribute (@@myattributes) {
	  if ($required{"$tag/$attribute"}) {
	    print "  if (!A_$ctag{$tag}_" . variablify($attribute) . ")"
	        . " FAIL(\"Required attribute `$attribute' not set for `$tag' element.\");\n";
	  }
	}
	print "  LEAVE; STag_$myctag();"
	    . (%inmixed ? ' pushbuffer(pcdata);' : '')
	    . " pcdata = " .($mixed{$tag} ? 'BUFFERSET(pcdata)' : 'NULL'). ";"
	    . " ENTER($startstate{$tag});\n";
	print " }\n";
	#
	# - accept and handle empty tags straight away,
	if ($empty{$tag}) {
	  print " \"/>\" {\n";
	  for my $attribute (@@myattributes) {
	    if ($required{"$tag/$attribute"}) {
	      print "  if (!A_$ctag{$tag}_" . variablify($attribute) . ")"
		  . " FAIL(\"Required attribute `$attribute' not set for `$tag' element.\");\n";
	    }
	  }
	  print "  LEAVE; STag_$myctag();"
	      . (%inmixed ? ' pushbuffer(pcdata);' : '')
	      . ' pcdata = ' . ($mixed{$tag} ? '""' : 'NULL') . ';'
	      . " ETag_$myctag();"
	      . (%inmixed ? ' pcdata = popbuffer();' : '')
	      . "\n";
	  #
	  print $exitswitch;
	  print " }\n";
	}
	elsif (not $nofail) {
	  print " \"/>\" FAIL(\"`$tag' element cannot be empty.\");\n";
	}
	#
	# - spaces are skipped, and
	print " .       FAIL(\"Unexpected character \`%c\' in attribute list of $tag element.\", yytext[0]);\n" unless $nofail;
	#
	# - other stuff is an error.
	print " {Name} FAIL(\"Bad attribute `%s' in `$tag' element start tag.\",yytext);\n" unless $nofail;
	print " <<EOF>> FAIL(\"EOF in attribute list of `$tag' element.\");\n" unless $nofail;
	print "}\n";

	# End tag.
	print "\n";
	print "<$endstates{$tag}>{\n";
	print " \"</$tag\"{s}\">\" {\n";
	print "  LEAVE;\n";
	print "  BUFFERDONE;\n" if $mixed{$tag};
	print "  ETag_$myctag();\n";
	print "  pcdata = popbuffer();\n" if %inmixed;
	print $exitswitch;
	print " }\n";

	# Errors when expecting end tag.
	print " \"</\"{Name}{s}\">\" FAIL(\"Unexpected end-tag `%s': `</$tag>' expected.\",yytext);\n"
	  unless $nofail;
	print " .       FAIL(\"Unexpected character `%c': `</$tag>' expected.\",yytext[0]);\n"
	  unless $mixed{$tag} or $nofail;
	print " <<EOF>> FAIL(\"Premature EOF: `</$tag>' expected.\");\n" unless $nofail;
	print "}\n";

	# Errors when expecting root tag.
	if ($roottags{$tag} and $nofail) {
	  print "\n";
	  print "<ROOT_$myctag>{\n";
	  print " .       FAIL(\"Unexpected character `%c': `$tag' element expected.\",yytext[0]);\n";
	  print " <<EOF>> FAIL(\"EOF in prolog.\");\n";
	  print "}\n";
	}
      }

    }
    elsif ( /FLEXML_MIXED([,>])/ ) {

      if (%mixed) {
	print  "$`" . join(',', map("IN_$ctag{$_}", keys %mixed)) . "$1$'";
      }
      else {
	print "$`IMPOSSIBLE$1$'";
      }

    }
    elsif ( /FLEXML_NON_MIXED([,>])/ ) {

      my $sep = $`;
      for (@@tags) {
	print $sep . ($roottags{$_} ? "ROOT_$ctag{$_}," : "")
            . "AL_$ctag{$_}";
	print ",$states{$_}" if $properempty{$_} or $children{$_};
	$sep = ',';
      }
      print "$1$'";

    }
    elsif ( /FLEXML_COMMENTS([,>])/ ) {

      print "$`"
	  . join(',', map(($roottags{$_} ? "ROOT_$ctag{$_}," : "")
			  . "AL_$ctag{$_},$states{$_}", @@tags))
	  . "$1$'";

    }
    elsif ( /^FLEXML_ENTITIES$/ ) {

      # Process general entities.
      for my $ent (keys %entity) {
	printsource("%$ent;");
	print " \"&$ent;\" ENTITYTEXT(\"" . $entity{$ent} . "\");\n";
      }

      print " /* Non-defined standard entities... */\n";
      print "\"&amp;\"  BUFFERPUTC('&');\n" unless $entity{"amp"};
      print "\"&lt;\"   BUFFERPUTC('<');\n" unless $entity{"lt"};
      print "\"&gt;\"   BUFFERPUTC('>');\n" unless $entity{"gt"};
      print "\"&apos;\" BUFFERPUTC('\\\'');\n" unless $entity{"apos"};
      print "\"&quot;\" BUFFERPUTC('\"');\n" unless $entity{"quot"};

    }
    elsif ( /^FLEXML_FINAL$/ and not $nofail ) {

      # Catch-all error cases.
      for my $tag (@@tags) {
	 for (split ',',$states{$tag}) {
	   print "<$_>{\n";
	   print " .    FAIL(\"Unrecognized `%c' in $_.\",yytext[0]);\n";
	   print " [\\n] FAIL(\"Unrecognized newline in $_.\");\n";
	   print "}\n";
	 }
      }
      for ('PROLOG','DOCTYPE','EPILOG','INCOMMENT','INPI','VALUE1','VALUE2','CDATA','INITIAL','IMPOSSIBLE') {
	 print "<$_>{\n";
	 print " .   FAIL(\"Unrecognized `%c' in $_.\",yytext[0]);\n";
	 print " [\\n] FAIL(\"Unrecognized space in $_.\");\n";
	 print "}\n";
      }

    }
    elsif ( $nofail and /FAIL\(/ ) {
      #ignore
    }
    else {
      s/"\$Id/"\$" "Id/;
      print;
    }

  }

  close SKELETON;
  close SCANNER unless $opt{A};
}



# WRITE APPLICATION.


if ($opt{D}) {

  print STDOUT "Writing XML"
             . ($opt{a} ? "" : " dummy")
             . " application onto `$APPLICATION'.\n" if $verbose;

  open APPLICATION, "+>$APPLICATION";
  select APPLICATION;

  # Identification and license.
  print "/* XML application for $dtd"
      . ($dtdrevision ? " ($dtdrevision)" : "") . ".\n";
  print " * Includes actions from $ACTIONS.\n" if $ACTIONS;
  print " * Generated " . `date +'%Y/%m/%d %T.'`;
  print " *\n";
  redistribute(" *");
  print " */\n";
  print "\n";

  # Declarations.
  print "#include \"$HEADER\"\n";
  print "\n";

}

if ($opt{D} or $opt{A}) {

  # Get requested actions.
  if ($ACTIONS) {

    open ACTIONS, "./flexml-act $ACTIONS|";

    my ($tag,$attribute);
    my @@myattributes;
    my $lineno = 0;
    my $isstart = undef;

    while (<ACTIONS>) {
      ++$lineno;

      if ( m/^\#line ([0-9]+)/ ) {
	$lineno = $1;
      }
      elsif ( m/^void\s+STag_($Name)\(void\)$/xo ) {
	$tag = $1;
	die "\"$ACTIONS\", line $lineno: Unknown element `$tag'.\n" unless $ctag{$tag};
	$startok{$tag} = 'true';
	@@myattributes = (exists $withattr{$tag} ? split /,/,"$withattr{$tag}" : ());
	$isstart = 'true';
      }
      elsif ( m|^\}\s+\/\*\s+STag_($Name)\s+\*\/$|xo ) {
	$tag = undef;
	@@myattributes = ();
	$isstart = 'true';
      }
      elsif ( m/^void\s+ETag_($Name)\(void\)$/xo ) {
	$tag = $1;
	$endok{$1} = 'true';
	$isstart = undef;
      }

      # Make function names C-friendly (idempotently!)
      s/(\s+[SE])Tag_($Name)\(/$1Tag_$ctag{$2}\(/xg;

      # Replace special annotations with C equivalents.
      if ($tag) {

	while ( s/\{($Name)\}/A_$ctag{$tag}_$catt{$1}/x ) {
	  die "\"$ACTIONS\", line $lineno: Attributes only allowed in start tag.\n"
	    if not $isstart;
	  die "\"$ACTIONS\", line $lineno: Unknown attribute `$1' for <$tag>.\n"
	    if not $atttype{"$tag/$1"};
	}

	while ( s/\{[!]($Name)\}/AU_$ctag{$tag}_$catt{$1}/x ) {
	  die "\"$ACTIONS\", line $lineno: Attributes only allowed in start tag.\n"
	    if not $isstart;
	  die "\"$ACTIONS\", line $lineno: Unknown attribute `$1' for <$tag>.\n"
	    if not $atttype{"$tag/$1"};
	}

	while ( s|\{($Name)=($Name)\}|
		  "A_$ctag{$tag}_$catt{$1}_" . variablify($2); |xe ) {
	  die "\"$ACTIONS\", line $lineno: Attributes only allowed in start tag.\n"
	    if not $isstart;
	  my ($att,$elt) = ($1,$2);
	  die "\"$ACTIONS\", line $lineno: Unknown attribute $1 for <$tag>.\n"
	    if not $atttype{"$tag/$1"};
	  die "\"$ACTIONS\", line $lineno: Attribute $att does not have value $elt for <$tag>.\n"
	    if not $enumtype{"$tag/$att"} =~ m/\b$elt\b/ ;
	}

	while ( s|\{\#(PCDATA)\}|pcdata| ) {
	  die "\"$ACTIONS\", line $lineno: {#PCDATA} only allowed in end tag.\n"
	    if $isstart;
	  die "\"$ACTIONS\", line $lineno: {#PCDATA} only permitted in end tag with Mixed contents.\n"
	    if not $mixed{$tag};
	}

	die "\"$ACTIONS\", line $lineno: Malformed annotation `$&' in <$tag> action.\n"
	  if m|\{[^;\s]+\}|o;
      }
      print $_;

    }
    close ACTIONS;
    print "\n";
  }

  # Fill up with dummy declarations for the remaining functions.
  api_functions('',' {}');

}

if ($opt{D}) {
  close APPLICATION;
}
elsif ($opt{A}) {
  close SCANNER;
}




=pod

=head1 NAME

flexml - generate validating XML processor and applications from DTD

=head1 SYNOPSIS

B<flexml>
[B<-ASHDvdnLXV>]
[B<-s>I<skel>]
[B<-p>I<pubid>]
[B<-u>I<uri>]
[B<-r>I<rootags>]
[B<-a>I<actions>]
I<name>[F<.dtd>]

=head1 DESCRIPTION

I<Flexml> reads I<name>F<.dtd> which must be a DTD (Document Type
Definition) describing the format of XML (Extensible Markup Language)
documents, and produces a "validating" XML I<processor> with an
interface to support XML I<application>s.  Proper applications can be
generated optionally from special "action files", either for linking
or textual combination with the processor.

The generated processor will only validate documents that conform
strictly to the DTD, I<without extending it>, more precisely we in
practice restrict XML rule [28] to

  [28r] doctypedecl ::= '<!DOCTYPE' S Name S ExternalID S? '>'

where the C<ExternalId> denotes the used DTD.  (One might say, in
fact, that I<flexml> implements "non-extensible" markup. :)

The generated processor is a I<flex>(1) scanner, by default named
I<name>F<.l> with a corresponding C header file I<name>F<.h> for
separate compilation of generated applications.  Optionally I<flexml>
takes an I<actions> file with per-element actions and produces a C
file with element functions for an XML application with entry points
called from the XML processor (it can also fold the XML application
into the XML processor to make stand-alone XML applications but this
prevents sharing of the processor between applications).

In L</OPTIONS>Z<> we list the possible options, in L</ACTION FILE
FORMAT>Z<> we explain how to write applications, in L</COMPILATION> we
explain how to compile produced processors and applications into
executables, and in L</BUGS> we list the current limitations of the
system before giving standard references.

=head1 OPTIONS

I<Flexml> takes the following options.

=over 4

=item B<-A>

Generate a I<stand-alone> scanner application.  If combined with
B<-a>I<actions> then the application will be named as I<actions> with
the extension replaced by F<.l>, otherwise it will be in I<name>F<.l>.
Conflicts with B<-S>, B<-H>, and B<-D>.

=item B<-a> I<actions>

Uses the I<actions> file to produce an XML application in the file
with the same name as I<actions> after replacing the extension with
F<.c>.  If combined with B<-A> then instead the stand-alone
application will include the action functions.

=item B<-D>

Generate a dummy application I<name>F<-dummy.c> with just empty
functions to be called by the XML processor.  If combined with
B<-a>I<actions> then the application will insert the specified
actions and be named as I<actions> with the extension replaced by
F<.c>.  Conflicts with B<-A>; implied by B<-a> unless either of
B<-SHD> is specified.

=item B<-d>

Turns on debug mode in the flex scanner and also prints out the
details of the DTD analysis performed by I<flexml>.

=item B<-H>

Generate the header file I<name>F<.h>.  Conflicts with B<-A>; on by
default if none of B<-SHD> specified.

=item B<-L>

Makes the XML processor (as produced by I<flex>(1)) count the lines in
the input and keep it available to XML application actions in the
integer C<yylineno>.  (This is off by default as the performance
overhead is significant.)

=item B<-n>

"Dry-run": do not produce any of the output files.

=item B<-p> I<pubid>

Sets the document type to be C<PUBLIC> with the identifier I<pubid>
instead of C<SYSTEM>, the default.

=item B<-r> I<roottags>

Restricts the XML processor to validate only documents with one of the
root elements listed in the comma-separated I<roottags>.

=item B<-S>

Generate the scanner I<name>F<.l>.  Conflicts with B<-A>; on by
default if none of B<-SHD> specified.

=item B<-s> I<skel>

Use the skeleton scanner I<skel> instead of the default.

=item B<-u> I<uri>

Sets the URI of the DTD, used in the C<DOCTYPE> header, to the
specified I<uri> (the default is the DTD name).

=item B<-v>

Be verbose: echo each DTD declaration (after parameter expansion).

=item B<-V>

Print the version of I<flexml> and exit.

=back

=head1 ACTION FILE FORMAT

Action files, passed to the B<-a> option, are XML documents conforming
to the DTD F<flexml-act.dtd> which is the following:

  <!ELEMENT actions ((top|start|end)*,main?)>
  <!ENTITY % C-code "(#PCDATA)">
  <!ELEMENT top   %C-code;>
  <!ELEMENT start %C-code;>  <!ATTLIST start tag NMTOKEN #REQUIRED>
  <!ELEMENT end   %C-code;>  <!ATTLIST end   tag NMTOKEN #REQUIRED>
  <!ELEMENT main  %C-code;>

The elements should be used as follows:

=over 4

=item C<top>

Use for top-level C code such as global declarations, utility
functions, etc.

=item C<start>

Attaches the code as an action to the element with the name of the
required "C<tag>" attribute.  The "C<%C-code;>" component should be C
code suitable for inclusion in a C block (i.e., within C<{>...C<}> so
it may contain local variables); furthermore the following extensions
are available:

C<{>I<attribute>C<}>: Can be used to access the value of the
I<attribute> as set with I<attribute>C<=>I<value> in the start tag.
In C, C<{>I<attribute>C<}> will be interpreted depending on the
declaration of the attribute. If the attribute is declared as an
enumerated type like

  <!ATTLIST attrib (alt1 | alt2 |...) ...>

then the C attribute value is of an enumerated type with the elements
written C<{>I<attribute>C<=>I<alt1>C<}>,
C<{>I<attribute>C<=>I<alt2>C<}>, etc.; furthermore an I<unset>
attribute has the "value" C<{!>I<attribute>C<}>.  If the attribute is
not an enumeration then C<{>I<attribute>C<}> is a null-terminated C
string (of type C<char*>) and C<{!>I<attribute>C<}> is C<NULL>.

=item C<end>

Similarly attaches the code as an action to the end tag with the name
of the required "C<tag>" attribute; also here the "C<%C-code;>"
component should be C code suitable for inclusion in a C block.  In
case the element has "Mixed" contents, i.e, was declared to permit
C<#PCDATA>, then the following variable is available:

C<{#PCDATA}>: Contains the text (C<#PCDATA>) of the element as a
null-terminated C string (of type C<char*>).  In case the Mixed
contents element actually mixed text and child elements then C<pcdata>
contains the plain concatenation of the text fragments as one string.

=item C<main>

Finally, an optional "C<main>" element can contain the C C<main>
function of the XML application.  Normally the C<main> function should
include (at least) one call of the XML processor:

C<yylex()>:
Invokes the XML processor produced by I<flex>(1) on the XML document
found on the standard input (actually the C<yyin> file handle: see the
manual for I<flex>(1) for information on how to change this as well as
the name C<yylex>).

If no C<main> action is provided then the following is used:

  int main() { exit(yylex()); }

=back

It is advisable to use XML E<lt>C<![CDATA[> ... C<]]>E<gt> sections
for the C code to make sure that all characters are properly passed to
the output file.

Finally note that I<Flexml> handles empty elements
E<lt>I<tag>C</>E<gt> as equivalent to
E<lt>I<tag>E<gt>E<lt>C</>I<tag>E<gt>.

=head1 COMPILATION

The following I<make>(1) file fragment shows how one can compile
I<flexml>-generated programs:


  # Programs.
  FLEXML = flexml -v

  # Generate linkable XML processor with header for application.
  %.l %.h: %.dtd
	  $(FLEXML) $<

  # Generate C source from flex scanner.
  %.c: 	  %.l
	  $(FLEX) -Bs -o"$@@" "$<"

  # Generate XML application C source to link with processor.
  # Note: The dependency must be of the form "appl.c: appl.act proc.dtd".
  %.c:	  %.act
	  $(FLEXML) -D -a $^

  # Direct generation of stand-alone XML processor+application.
  # Note: The dependency must be of the form "appl.l: appl.act proc.dtd".
  %.l:	  %.act
	  $(FLEXML) -A -a $^

=head1 BUGS

The present version of I<flexml> is to be considered in "early beta"
state thus bugs should be expected (and the author would like to hear
about them).  Here are some known restrictions that we hope to
overcome in the future:

=over 4

=item *

The character set is merely ASCII (actually I<flex>(1) handles 8 bit
characters but only the ASCII character set is common with the XML
default UTF-8 encoding).

=item *

C<ID> type attributes are not validated for uniqueness; C<IDREF> and
C<IDREFS> attributes are not validated for existence.

=item *

The C<ENTITY> and C<ENTITIES> attribute types are not supported.

=item *

C<NOTATION> declarations are not supported.

=item *

The various C<xml:>-attributes are treated like any other attributes;
in particular C<xml:spaces> should be supported.

=item *

The XML processor currently uses a fixed-size buffer to read
C<pcdata>.  It should not.

=item *

The DTD parser is presently a perl hack so it may parse some DTDs
badly; in particular the expansion of parameter entities may not
conform fully to the XML specification.

=item *

A child should be able to "return" a value for the parent (also called
a I<synthesised attribute>).  Similarly an element in Mixed contents
should be able to inject text into the C<pcdata> of the parent.

=back

=head1 FILES

=over 4

=item F<./skel>

The skeleton scanner with the generic parts of XML scanning.

=item F</usr/share/doc/flexml/>

License, further documentation, and examples.

=back

=head1 SEE ALSO

I<flex>(1), Extensible Markup Language (XML) 1.0 (W3C Recommendation
REC-xml-1998-0210).

=head1 AUTHOR

I<Flexml> was written by Kristoffer Hgsbro Rose,
E<lt>C<krisrose@@debian.org>E<gt>.

=head1 COPYRIGHT

The program is Copyright (c) 1999 Kristoffer Rose (all rights
reserved) and distributed under the GNU General Public License (GPL,
also known as "copyleft", which clarifies that the author provides
absolutely no warranty for I<flexml> and ensures that I<flexml> is and
will remain available for all uses, even comercial).

=head1 ACKNOWLEDGEMENT

I am grateful to NTSys (France) for supporting the development of
I<flexml>.  Finally extend my severe thanks to Jef Poskanzer, Vern
Paxson, and the rest of the I<flex> maintainers and GNU developers for
a great tool.

=cut
@


1.23
log
@Released for Debian.
@
text
@d23 1
a23 1
my $Id = '$Id: flexml.pl,v 1.22 1999/12/09 08:22:01 krisrose Exp krisrose $ ';
d1108 2
a1109 1
      my $extid;
a1110 8
      if ($pubid) {
	$extid = "PUBLIC{S}(\"'$pubid'\"|\"\\\"$pubid\\\"\")";
      }
      else {
	$extid = 'SYSTEM';
      }
      $extid .= '{S}' . ( $uri ? "(\"'$uri'\"|\"\\\"$uri\\\"\")"
			       : "(\"'$dtd'\"|\"\\\"$dtd\\\"\")" );
d1112 9
a1120 2
	print " \"<!DOCTYPE\"{S}\"$_\"{S}" .$extid . "{s}\">\" SET(ROOT_$ctag{$_});\n";
      }
d1292 4
a1295 2
	print " \"</\"{Name}{s}\">\" FAIL(\"Unexpected end-tag `%s': `</$tag>' expected.\",yytext);\n" unless $nofail;
	print " .       FAIL(\"Unexpected character `%c': `</$tag>' expected.\",yytext[0]);\n" unless $mixed{$tag} or $nofail;
d1429 1
d1442 1
d1447 1
d1450 1
d1452 1
d1462 4
a1465 1
	  die "\"$ACTIONS\", line $lineno: Unknown attribute `$1' for <$tag>.\n" if not $atttype{"$tag/$1"};
d1469 4
a1472 1
	  die "\"$ACTIONS\", line $lineno: Unknown attribute `$1' for <$tag>.\n" if not $atttype{"$tag/$1"};
d1474 1
d1477 3
a1481 1
	  my ($att,$elt) = ($1,$2);
d1485 10
a1494 1
	die "\"$ACTIONS\", line $lineno: Malformed annotation `$&' in <$tag> action.\n" if m|\{[^;\s]+\}|o;
d1562 5
a1566 4
In L</OPTIONS>Z<> we list the possible options, in
L</ACTION FILE FORMAT>Z<> we explain how to write applications, and in
L</BUGS> we list the current limitations of the system before giving
standard references.
d1681 5
a1685 8
C<{>I<attribute>C<}>

=over 4

Can be used to access the value of the I<attribute> as set with
I<attribute>C<=>I<value> in the start tag.  In C, C<{>I<attribute>C<}>
will be interpreted depending on the declaration of the attribute. If
the attribute is declared as an enumerated type like
a1695 2
=back

d1704 4
a1707 10
C<pcdata>

=over 4

Contains the text (C<#PCDATA>) of the element as a null-terminated C
string (of type C<char*>).  In case the Mixed contents element
actually mixed text and child elements then C<pcdata> contains the
plain concatenation of the text fragments as one string.

=back
d1715 1
a1715 4
C<yylex()>

=over 4

a1720 2
=back

d1735 27
d1764 1
a1764 1
The present version of I<flexml> is to be considered in "late alpha"
@


1.22
log
@Oops: tricky stopped working...holding...
@
text
@d23 1
a23 1
my $Id = '$Id: flexml.pl,v 1.21 1999/12/09 03:47:43 krisrose Exp krisrose $ ';
a218 1
    print STDOUT "Expanding  `$_'\n";
d234 1
a234 1
  print STDOUT "Fetching URL <$url>..." if $verbose;
a239 1
    print STDOUT "failed.\n";
a241 1
  print STDOUT "done.\n" if $verbose;
d508 1
a508 1
print "Processing DTD in $dtd:\n" if $verbose;
d518 16
a533 3
    while (@@inputs and m/^\s*$/) {
      $_ = nextline();
      expandparametersat('^');
d535 2
d539 1
a539 1
      # Extract FIRST DTD version number...
d551 2
a552 2
  # Insert parameter or external entity and retry.
  if ( s/^%($Name);// ) {
a555 1
      next;
d558 1
d586 1
a586 1
  print STDOUT " [$_]\n" if $verbose;
d781 2
a782 2
  elsif ( m/^<!ENTITY\s+%\s+($Name)\s+'([^'']*)'\s*>\s*/xo
	  or m/^<!ENTITY\s+%\s+($Name)\s+"([^""]*)"\s*>\s*/xo ) {
a817 2
print "ENTITY &$name;\n";

d1343 1
a1343 1
	print " \"$ent\" ENTITYTEXT(\"" . $entity{$ent} . "\");\n";
@


1.21
log
@External entities added.
@
text
@d23 1
a23 1
my $Id = '$Id: flexml.pl,v 1.20 1999/12/06 21:08:09 krisrose Exp krisrose $ ';
d219 1
d521 4
a524 1
    $_ = nextline() while @@inputs and m/^\s*$/;
d539 1
a539 1
  # Insert external entity and retry.
d542 11
a552 3
    die "Unknown entity `%$ent;'\n" unless $external{$ent};
    geturl($external{$ent});
    next;
d656 1
a656 1
      while ( s/^($Name)\s+([A-Z]+|\(\s*$Nmtoken(?:\s*\|\s*$Nmtoken)*\))
d805 3
d1131 21
d1255 1
a1255 7
	  if (exists $exittrans{$tag}) {
	    print "  switch (YY_START) {\n";
	    for (split /,/,$exittrans{$tag}) {
	      print "   case $1: SET($2); break;\n" if m/^($Name)=>($Name)$/xo;
	    }
	    print "  }\n";
	  }
d1278 1
a1278 7
	if (exists $exittrans{$tag}) {
	  print "  switch (YY_START) {\n";
	  for (split /,/,$exittrans{$tag}) {
	    print "   case $1: SET($2); break;\n" if m/^($Name)=>($Name)$/xo;
	  }
	  print "  }\n";
	}
d1738 4
@


1.20
log
@Releasing.
@
text
@d1 1
a1 1
#!/usr/bin/perl
d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.19 1999/12/03 23:46:37 krisrose Exp krisrose $ ';
d26 1
d28 34
a61 2

# DTD DESCRIPTION STRUCTURES.
d63 7
d71 1
a71 1
%source = ();	# DTD source lines associated to tag and tag/attribute.
d73 1
a73 38
@@tags = ();	# Tags of the DTD.
%roottags = ();	# Tags that may be the root tag.
%ctag = ();     # C variable name of each tag.

%states = ();	# $states{tag} is list of states used by tag element.
%emptytrans = ();# $emptytrans{state} contains empty transitions in automaton.

%instates = ();	# $instates{tag} is list of states for element start/empty tag.
%startstate = ();# $startstate{tag} is the state entered after the start tag.
%endstates = ();# $endstates{tag} is list of states for element end tag.
%exittrans = ();# $exittrans{tag} is state transitions after end tag.

%empty = ();	# $empty{tag} == true if the tag may be empty.
%properempty = ();# $empty{tag} == true if the tag is declared EMPTY
%any = ();	# $any{tag} == true if the tag has ANY contents.
%mixed = ();	# $mixed{tag} == true if the tag has Mixed (or ANY) contents.
%children = ();	# $children{tag} == true if the tag has Element contents

%inmixed = ();	# $inmixed{tag} == true if the tag occurs *in* Mixed contents.

@@attributes = ();# Attributes of the DTD.
%catt = ();     # C variable name for attribute.

%atttype = ();	# XML AttType (type) of tag/attribute
%enumtype = (); # whether the tag/attribute is an enumeration type
%literaltype = ();# whether the tag/attribute is a tokenized type
%entitytype = ();# whether the tag/attribute is of entity type
%typeof = ();	# C type of tag/attribute

%attdef = ();   # XML AttDef (default value) of tag/attribute
%required = (); # true if tag/attribute is required
%fixed = ();    # true if tag/attribute has fixed default
%initof = ();   # C initial attribute value of tag/attribute, if any

%attlist = ();	# $attlist{tag} is comma-separated list of attribute
                # names allowed in tag elements.
%withattr = (); # $withattr{attribute} is comma-separated list of
                # elements within which the tag element may occur.
d75 42
a116 2
%entity = ();	# general entity table (C strings)
%parameter = ();# parameter entity table (raw string)
d118 2
a119 2
%startok = ();  # start tag action already dumped
%endok = ();    # end tag action already dumped
d180 1
d182 1
a182 1
  local ($pre,$post) = @@_;
d205 1
a205 1
  local ($pre) = @@_;
d216 1
a216 1
sub expandparametersat {
d218 67
a284 2
  while (s/$place(\s*)(%$Name;)/ ' '. $1 . $parameter{$2} . ' ' /xe) {
    die "\"$DTD\", line $.: Unknown parameter entity $2.\n" unless $parameter{$2};
d286 2
d291 8
a298 8
sub getnonblank {		# skip until a non-blank DTD line
                                # available in $_; expand it's
                                # parameters but return original (!)
  my $line = $_;
  until ($_ or eof DTD) {
    $_ = <DTD>; chomp;
    $line .= "\n" . $_;
    expandparametersat('^'); s/^\s+//;
a299 1
  $line;
d335 2
d347 5
a351 2
    my %ins = (); for (split /,/,$instates{$thetag}) { $ins{$_} = true; }
    $ins{$in} = true;
d361 1
a361 1
    return true;
d400 1
a400 1
	  $maybeempty = true if analysechildren($tag,$cp,$in,$out);
d413 1
a413 1
        $maybeempty = true if analysechildren($tag,$cp,$in,$out);
d424 1
a424 1
  die "\"$DTD\", line $.: DTD element $tag has nonsense fragment `$_'.\n";
d435 2
a436 2
use Getopt::Std; getopts('ASHDvdnLXVp:s:u:r:a:');
if ($#ARGV != 0) { die $Use."\n"; }
d439 2
a440 4
if ($opt_V) {
  print "FleXML version $Id.\n";
  exit 0;
}
d443 2
a444 2
$debug = $opt_d;
$verbose = $opt_v;
d447 1
a447 1
$lineno = $opt_L;
d450 1
a450 1
$nofail = $opt_X;
d453 2
a454 2
if ($opt_r) {
  for (split ',',$opt_r) { $roottags{$_} = true; }
d458 2
a459 2
$SKELETON = ($opt_s ? $opt_s : './skel');
die "$0: No skeleton file $SKELETON.\n" if not -r $SKELETON and $opt_S;
d461 3
a463 5
# Set DTD file name.
$prefix = $ARGV[0];
$prefix =~ s/\.dtd$//;
$DTD = "$prefix.dtd";
die "$0: No DTD file $DTD.\n" if not -r $DTD;
d465 12
a476 3
# Set document type URI and PUBID.
$uri = $opt_u if $opt_u;
$pubid = $opt_p if $opt_p;
d480 2
a481 2
$opt_S = $opt_H = true unless ($opt_S or $opt_H or $opt_D or $opt_A);
$opt_D ||= $opt_a unless $opt_A;
d489 3
a491 3
if ($ACTIONS = $opt_a) {
  $opt_a =~ s/\.[a-z]+$//;
  $APPLICATION = "$opt_a.c";
d495 2
a496 2
if ($opt_A) {
  die "$0: -A conflicts with -SHD.\n" if ($opt_S or $opt_H or $opt_D);
d502 2
a503 2
if ($opt_n) {
  $opt_A = $opt_S = $opt_H = $opt_D = undef;
a505 3
# Clean up for use as C variable name parts
$cprefix = variablify("$prefix");

a508 1
print "Processing DTD in $DTD:\n" if $verbose;
d510 24
d535 6
a540 35
# DTD regular expressions (extended to not mess up the counting).
$NameChar = '[A-Za-z0-9.:_-]';
$Name	  = "[A-Za-z_:]$NameChar*";
$Names 	  = "$Name(?:\s+$Name)*";
$Nmtoken  = "$NameChar+";
$Nmtokens = "$Nmtoken(?:\s+$Nmtoken)*";
$Eq       = '\s*=\s*';
$Literal  = '\'[^\']*\'|"[^"]*"';
$StartSep = '(^|,)';
$EndSep   = '(,|$)';

open DTD;

$orig = '';			# current source line(s)
$_ = '';			# current entity, possibly with trailing stuff

until (eof DTD) {		# One pass per item.

  $orig = getnonblank();

  # Skip any comments (but save as source).
  while ( m/^\s*<!--/ ) {
    until (m/-->/ or eof DTD) {
      my $line = <DTD>; chomp $line;
      $_ .= ($_?"\n":"") . $line;
      $orig .= "\n" . $line;
    }
    # Extract any DTD version number...
    if ( /\$(Id|Header|Revision): [^\$]*\$/ ) {
      $DTDrevision = "$&";
      $DTDrevision =~ s/\s*\$\s*//go;
    }
    # Remove the comment to read on to next nonblank (but save as source).
    s/^\s*<!--([^-]|-[^-]|--[^>])*-->\s*//g;
    $orig .= "\n" . getnonblank();
d543 2
d546 2
a547 2
  until (m/^\s*<![^>]*>/o or m/^\s*<[?]([^?]|[?][^>])*[?]>/o or eof DTD) {
    my $line = <DTD>; chomp $line;
d553 2
a554 2
    last if eof DTD;
    die "\"$DTD\", line $.: Could not find end of declaration.\n";
d562 1
a562 1
  print "[$_]\n" if $verbose;
d566 2
a567 2
    print "\"$DTD\", line $.: Warning: ignoring processing instruction $&.\n";
    $_ = $'; $orig = '';	# cycle
d573 1
a573 1
    $_ = $'; $source{$1} = "$orig"; $orig = ''; # cycle
d576 1
a576 1
    die "\"$DTD\", line $.: Repeated element $tag.\n" if $ctag{$tag};
d592 2
a593 2
      $empty{$tag} = true;
      $properempty{$tag} = true;
d599 3
a601 3
      $any{$tag} = true;
      $mixed{$tag} = true;
      $empty{$tag} = true;
d608 9
a616 7
      $mixed{$tag} = true;
      $empty{$tag} = true;
      my $desc = $1;
      $desc =~ s/^\s*\|\s*//o;
      for (split /\s*\|\s*/,"$desc") {
	$instates{$_} .= ($instates{$_}?',':'') . "IN_$c";
	$inmixed{$_} = true;
d623 1
a623 1
      $children{$tag} = true;
d627 1
a627 1
      $empty{$tag} = true if analysechildren($tag,$_,"S_$c","E_$c");
a636 1

d644 1
a644 1
      while ( s/^($Name)\s+([A-Z]+|\(\s*$Nmtoken(?:\s*\|\s*$Nmtoken)*\s*\))
d650 1
a650 1
	  print "\"$DTD\", line $.: Warning: Redeclaration of element $tag attribute $attribute ignored.\n";
d672 12
a683 10
	  if ("$default" eq '#REQUIRED') {
	    $required{"$tag/$attribute"} = true;
	    $default = undef;
	  }
	  elsif ($default eq '#IMPLIED') {
	    $default = undef;
	  }
	  else {
	    $fixed{"$tag/$attribute"} = true if $default =~ s/\#FIXED\s+//o;
	    $default =~ s/^'([^'']*)'$/$1/o unless $default =~ s/^"([^""]*)"$/$1/o;
d688 1
a688 1
	  $atttype{"$tag/$attribute"} = "$type";
d722 1
d726 1
d735 1
a735 1
	      die "\"$DTD\", line $.: ENTITY attribute type unimplemented.\n";
d738 1
a738 1
	      die "\"$DTD\", line $.: ENTITIES attribute type unimplemented.\n";
d741 1
a741 1
	      die "\"$DTD\", line $.: Unknown AttType `$type'.\n";
a744 3

	  # Store default value
	  $defaultdecl{"$tag/$attribute"} = $default;
d750 1
a750 1
      die "\"$DTD\", line $.: Nonsense ($_) in attribute list.\n" if $_;
d756 1
a756 1
  # parse internal parameter entity declarations.
d764 3
d770 14
a783 1
    $parameter{"%$name;"} = $_;
d793 1
d796 1
a796 1
    $entity{"&$name;"} = cquote($_);
d801 1
a801 1
    die "\"$DTD\", line $.: Unrecognized declaration.\n";
d806 1
a806 1
close DTD;
d808 1
a808 1
# Post-process DTD.
d811 1
a811 1
{ my $changed = true;
d815 1
a815 1
      my %tos = (); for (split /,/,$emptytrans{$from}) { $tos{$_} = true; }
d817 5
a821 4
	for my $next (split /,/,$emptytrans{$to}) {
	  if (not $tos{$next}) {
	    $changed = true;
	    $tos{$next} = true;
d834 8
a841 2
  my %ins = (); for (split ',',$instates{$tag}) { $ins{$_} = true; }
  my %ens = (); for (split ',',$endstates{$tag}) { $ens{$_} = true; }
d845 3
a847 1
  for (split ',',$exittrans{$tag}) { m/^($Name)=>($Name)$/o; $exits{$1} = $2; }
d850 1
a850 1
  for (keys %any) { $ins{"IN_$_"} = true; }
d855 2
a856 2
      $ins{$from} = true if $ins{$to};
      $ens{$from} = true if $ens{$to};
d868 1
a868 1
  for (@@tags) { $roottags{$_} = true; }
d876 2
d888 3
a890 1
  print '%source = (' . printhash(source) . ")\n";
d894 1
a894 1
  print '%ctag = (' . printhash(ctag) . ")\n";
d896 12
a907 12
  print '%states = (' . printhash(states) . ")\n";
  print '%instates = (' . printhash(instates) . ")\n";
  print '%endstates = (' . printhash(endstates) . ")\n";

  print '%emptytrans = (' . printhash(emptytrans) . ")\n";
  print '%exittrans = (' . printhash(exittrans) . ")\n";

  print '%empty = (' . printhash(empty) . ")\n";
  print '%any = (' . printhash(any) . ")\n";
  print '%mixed = (' . printhash(mixed) . ")\n";
  print '%children = (' . printhash(children) . ")\n";
  print '%inmixed = (' . printhash(inmixed) . ")\n";
d911 1
a911 1
  print '%catt = (' . printhash(catt) . ")\n";
d913 9
a921 9
  print '%atttype = (' . printhash(atttype) . ")\n";
  print '%enumtype = (' . printhash(enumtype) . ")\n";
  print '%literaltype = (' . printhash(literaltype) . ")\n";
  print '%typeof = (' . printhash(typeof) . ")\n";

  print '%attdef = (' . printhash(attdef) . ")\n";
  print '%required = (' . printhash(required) . ")\n";
  print '%fixed = (' . printhash(fixed) . ")\n";
  print '%initof = (' . printhash(initof) . ")\n";
d923 2
a924 2
  print '%attlist = (' . printhash(attlist) . ")\n";
  print '%withattr = (' . printhash(withattr) . ")\n";
d927 3
a929 2
  print '%entity = (' . printhash(entity) . ")\n";
  print '%parameter = (' . printhash(parameter) . ")\n";
d936 1
a936 1
if ($opt_H) {
d938 1
a938 1
  print "Generating XML processor header in $HEADER.\n" if $verbose;
d944 2
a945 2
  print "/* XML processor/application API for $DTD"
      . ($DTDrevision ? " ($DTDrevision)" : "") . ".\n";
d953 1
a953 1
  print "#ifndef _FLEXML_${cprefix}_H\n";
d978 1
a978 1
if ($opt_S or $opt_A) {
d980 3
a982 3
  print "Writing XML processor"
      . ($opt_a || $opt_A ? " and application" : "")
      . " onto $SCANNER.\n" if $verbose;
a988 3
  # Skip initial comment.
  while (<SKELETON>) { last if m/^\s*\*\//; }

d990 2
a991 2
  print "/* Validating XML processor for $DTD"
      . ($DTDrevision ? " ($DTDrevision)" : "") . ".\n";
d998 4
d1010 2
a1011 2
      print "const char rcs_${cprefix}_dtd[] =\n"
	  . " \"\$\" \"$DTDrevision \$\";\n" if $DTDrevision;
d1023 1
a1023 1
      if ($opt_A) {
d1083 2
a1084 4
      # Build pattern...
      my ($pub,$sys);
      $sys = "SYSTEM{S}" . ( $uri ? "(\"'$uri'\"|\"\\\"$uri\\\"\")"
			          : "(\"'$DTD'\"|\"\\\"$DTD\\\"\")");
d1086 4
a1089 2
	$pub = "PUBLIC{S}(\"'$pubid'\"|\"\\\"$pubid\\\"\")";
	$sys = undef if $pub and not $uri;
d1091 2
d1094 1
a1094 2
	print " \"<!DOCTYPE\"{S}\"$_\"{S}" .$sys . "{s}\">\" SET(ROOT_$ctag{$_});\n" if $sys;
	print " \"<!DOCTYPE\"{S}\"$_\"{S}" .$pub . "{s}\">\" SET(ROOT_$ctag{$_});\n" if $pub;
d1107 1
a1107 1
	my @@myattributes = split /,/,"$attlist{$tag}";
d1219 6
a1224 3
	  print "  switch (YY_START) {\n";
	  for (split /,/,$exittrans{$tag}) {
	    print "   case $1: SET($2); break;\n" if m/^($Name)=>($Name)$/xo;
a1225 1
	  print "  }\n";
d1248 6
a1253 3
	print "  switch (YY_START) {\n";
	for (split /,/,$exittrans{$tag}) {
	  print "   case $1: SET($2); break;\n" if m/^($Name)=>($Name)$/xo;
a1254 1
	print "  }\n";
d1308 1
a1308 1
	printsource($ent);
d1313 5
a1317 5
      print "\"&amp;\"  BUFFERPUTC('&');\n" unless $entity{"&amp;"};
      print "\"&lt;\"   BUFFERPUTC('<');\n" unless $entity{"&lt;"};
      print "\"&gt;\"   BUFFERPUTC('>');\n" unless $entity{"&gt;"};
      print "\"&apos;\" BUFFERPUTC('\\\'');\n" unless $entity{"&apos;"};
      print "\"&quot;\" BUFFERPUTC('\"');\n" unless $entity{"&quot;"};
d1350 1
a1350 1
  close SCANNER unless $opt_A;
d1358 1
a1358 1
if ($opt_D) {
d1360 3
a1362 3
  print "Writing XML"
      . ($opt_a ? "" : " dummy")
      . " application onto $APPLICATION.\n" if $verbose;
d1368 2
a1369 2

  print "/* XML application for $DTD" . ($DTDrevision ? " ($DTDrevision)" : "") . ".\n";
d1383 1
a1383 1
if ($opt_D or $opt_A) {
d1392 1
d1395 1
d1397 4
a1400 1
      if ( m/^void\s+STag_($Name)\(void\)$/xo ) {
d1402 3
a1404 3
	die "Unknown element `$tag'.\n" unless $ctag{$tag};
	$startok{$tag} = true;
	@@myattributes = split /,/,"$withattr{$tag}";
d1411 1
a1411 1
	$endok{$1} = true;
d1421 1
a1421 1
	  die "Unknown attribute $1 for <$tag>.\n" if not $atttype{"$tag/$1"};
d1425 1
a1425 1
	  die "Unknown attribute $1 for <$tag>.\n" if not $atttype{"$tag/$1"};
d1429 1
a1429 1
	  die "Unknown attribute $1 for <$tag>.\n"
d1432 1
a1432 1
	  die "Attribute $att does not have value $elt for <$tag>.\n"
d1435 1
a1435 1
	die "Malformed annotation $& in <$tag> action.\n" if m|\{[^;\s]+\}|o;
d1449 1
a1449 1
if ($opt_D) {
d1452 1
a1452 1
elsif ($opt_A) {
d1483 1
a1483 1
or textual combination with the processor
d1491 2
a1492 1
where the C<ExternalId> denotes the used DTD.
d1496 11
a1506 12
separate compilation of generated applications.  

Optionally I<flexml> takes an I<actions> file with per-element actions
and produces a C file with element functions for an XML application
with entry points called from the XML processor (it can also fold the
XML application into the XML processor to make stand-alone XML
applications but this prevents sharing of the processor between
applications).

In L</OPTIONS> we list the possible options, in L</ACTION FILE FORMAT>
we explain how to write applications, and in L</BUGS> we list the
current limitations of the system before giving standard references.
d1561 1
a1561 2
instead of C<SYSTEM>, the default.  If both B<-p> and B<-u> are
specified then both will be permitted.
d1580 1
a1580 1
specified I<uri>.  (The default is the file name of the DTD.)
d1604 2
d1621 2
a1624 2
=item C<{>I<attribute>C<}>

d1649 2
a1652 2
=item C<pcdata>

d1666 2
a1669 2
=item C<yylex()>

d1681 2
a1686 2
=back

d1719 5
@


1.19
log
@-n option added :)
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.18 1999/12/03 23:24:40 krisrose Exp krisrose $ ';
d37 2
a38 1
%states = ();	# $states{tag} is list of states used for tag element.
d43 1
a43 4

%emptytrans = ();# $emptytrans{state} contains empty transitions in automaton.
%intrans = ();  # $intrans{tag} is state translation table after start tag.
%outtrans = (); # $outtrans{tag} is state translation table after end tag.
d53 1
a53 1
@@attributes = (); # Attributes of the DTD.
d59 1
d73 1
a73 1
%parameter = (); # parameter entity table (raw string)
a85 1
  s/^(\s*\n)*//;
d148 1
a148 1
  print "/* FleXML-provided data types. */\n" if %atttype;
d180 3
a182 1
sub getnonblank {		# skip until a non-blank line available
d186 1
a186 1
    $line = $_;
d232 1
a232 1
  if ( m/^\s*($Name)\s*$/o or m/^\s*\(\s*($Name)\s*\)\s*$/o ) { # tag
d234 6
a239 17
    my $tag = $1;
    my $ins = $instates{$tag};
    $ins .= ($ins?',':'') . $in unless $ins =~ m/$StartSep$in$EndSep/;
    $instates{$tag} = $ins;

    if ($in ne $out) {
      if ( $intrans{$tag} =~ m/$StartSep$in=>$out$EndSep/ ) {
die "\"$DTD\", line $.: Oops...state transform tag: $in=>$out already registered?!\n";
      }
      elsif ( $intrans{$tag} =~ m/$StartSep$in=>([^,]*)$EndSep/ ) {
	die "\"$DTD\", line $.: DTD element $tag ambiguous ($in=>$out and $2).\n";
      }
      else {
	$intrans{$tag} .= ($intrans{$tag}?',':'') . "$in=>$out" 
      }
    }	      
    return false;
d242 1
a242 1
  elsif ( m/^((.|\n)+)\+\s*$/o ) { # re +
d244 3
a246 7
    my $re = $1;
    my $s = "S_$ctag{$tag}_" . (++$statecounter);
    $states{$tag} .= ",$s";
    my $maybeempty = analysechildren($tag,$re,$in,$s);
    analysechildren($tag,$re,$s,$s);
    $emptytrans{$s} = $out;
    return $maybeempty;
d249 1
a249 1
  elsif ( m/^((.|\n)+)\?\s*$/o ) { # re ?
d251 7
a257 3
    $emptytrans{$in} = $out unless $in eq $out;
    analysechildren($tag,$1,$in,$out);
    return true;
d291 1
a291 1
	  $maybeempty = false unless analysechildren($tag,$cp,$oldstate,$state);
d296 1
a296 1
      # Last cp needs special treatment (in sequence, at least).
d301 1
a301 1
	$maybeempty = false unless analysechildren($tag,$cp,$state,$out);
d304 2
a305 1
      $emptytrans{$in} = $out if $maybeempty and $in ne $out;
d318 1
a318 1
$Use = "Usage: flexml [-ASHDvdLX] [-s skel] [-p pubid] [-u uri]\n"
d320 1
a320 1
use Getopt::Std; getopts('ASHDvdnLXp:s:u:r:a:');
d323 6
d383 1
a383 1
  $opt_A = $opt_S = $opt_H = $opt_D = false;
d392 2
d413 1
a413 1
  getnonblank();
d420 1
d428 2
a429 4
    $orig .= "\n";
    $orig .= $& while s/^\s*<!--([^-]|-[^-]|--[^>])*-->\s*//m;
    $orig .= "\n" unless $_;
    $orig .= getnonblank();
a431 3
  # If we just have a plain line then we did not yet store the source.
  $orig .= $_ unless $orig;

d444 5
d474 1
a474 1
    $intrans{$tag} .= ($intrans{$tag}?',':'') . "ROOT_$c=>EPILOG"
d678 20
d700 7
a706 3
  # Complete instates and endstates...
  my $ins = $instates{$tag};
  my $ons = $endstates{$tag};
d709 1
a709 7
  for (keys %any) {
    $ins .= ($ins?',':'') . "IN_$_";
  }

  # Encode empty transitions A->B: add B where A occurs.
  for (keys %emptytrans) {
    my ($a,$b) = ($_,$emptytrans{$_});
d711 6
a716 7
    if ($ins =~ m/$StartSep$b$EndSep/) {
      $ins = "$`$1$a,$b$2$'" unless $ins =~ m/$StartSep$a$EndSep/;
      $intrans{$tag} .= ($intrans{$tag}?',':'') . "$a=>$b";
    }
    if ($ons =~ m/$StartSep$b$EndSep/) {
      $ons = "$`$1$a,$b$2$'" unless $ons =~ m/$StartSep$a$EndSep/;
      $outtrans{$tag} .= ($outtrans{$tag}?',':'') . "$a=>$b";
d720 4
a723 23
  $instates{$tag} = $ins if $ins;
  $endstates{$tag} = $ons if $ons;

  # Take transitive closure of intrans and outtrans.
  my %intranstag = ();
  for (split /,/,$intrans{$tag}) {
    $intranstag{$1} = $2 if m/^($Name)=>($Name)$/xo;
  }
  for (keys %intranstag) {
    my $a = $_;
    while ($a = $intranstag{$a}) { $intranstag{$_} = $a; }
  }
  $intrans{$tag} = join ',',(map "$_=>$intranstag{$_}",keys %intranstag);

  my %outtranstag = ();
  for (split /,/,$outtrans{$tag}) {
    $outtranstag{$1} = $2 if m/^($Name)=>($Name)$/xo;
  }
  for (keys %outtranstag) {
    my $a = $_;
    while ($a = $outtranstag{$a}) { $outtranstag{$_} = $a; }
  }
  $outtrans{$tag} = join ',',(map "$_=>$outtranstag{$_}",keys %outtranstag);
d739 1
d756 1
a756 3
  print '%intrans = (' . printhash(intrans) . ")\n";
  print '%outtrans = (' . printhash(outtrans) . ")\n";
  print '%inmixed = (' . printhash(inmixed) . ")\n";
d762 1
d791 3
d798 3
a800 3
  print "/* XML processor/application API for $DTD";
  print ",\n * ($DTDrevision)" if $DTDrevision;
  print ".\n * Generated " . `date +'%Y/%m/%d %T.'`;
d834 4
d847 3
a849 3
  print "/* Validating XML processor for $DTD";
  print ",\n * ($DTDrevision)" if $DTDrevision;
  print ".\n * Generated " . `date +'%Y/%m/%d %T.'`;
d988 1
a988 1
	  my $type;
d992 1
d1001 1
d1010 11
a1020 2
	    print " \"$attribute\"{Eq}{Literal}" # avoid backup
	        . " FAIL(\"`%s' illegal in `$tag' element start tag.\",yytext);\n" unless $nofail;
d1024 1
a1028 2
	    print " \"$attribute\"{Eq}{Literal}" # avoid backup
	        . " FAIL(\"`%s' illegal in `$tag' element start tag ($attribute declared $atttype{$tag}).\",yytext);\n" unless $nofail;
d1030 1
a1030 4
	  elsif ($fixed{"$tag/$attribute"}) {
	    print " \"$attribute\"{Eq}\"'" . $attdef{"$tag/$attribute"} . "'\""
	        . " A_${myctag}_$catt{$attribute}"
		. " = " . $initof{"$tag/$attribute"} . ";\n";
d1032 1
a1032 8
	    print " \"$attribute\"{Eq}\"\\\"" . $attdef{"$tag/$attribute"} . "\\\"\""
		. " A_${myctag}_$catt{$attribute}"
		. " = " . $initof{"$tag/$attribute"} . ";\n";

	    print " \"$attribute\"{Eq}{Literal}" # avoid backup
	        . " FAIL(\"`%s' illegal in `$tag' element start tag.\",yytext);\n" unless $nofail;
	  }
	  else {
d1035 1
d1040 10
a1049 5
	# - generic backup-avoiding rule,
	print " {Name}{Eq} FAIL(\"`%s' illegal in `$tag' element start tag.\",yytext);\n" unless $nofail;
	#
	# - the end of a start tag means to enter the contents,
	print " \">\"  LEAVE; STag_$myctag();"
a1051 1

d1053 1
a1053 1

d1057 8
a1064 2
	  print " \"/>\" {\n"
	      . "  LEAVE; STag_$myctag();"
d1070 1
a1070 5

	  my %setstateafter = ();
	  for (split /,/,$intrans{$tag}) {
	    $setstateafter{$1} .= " SET($2);" if m/^($Name)=>($Name)$/xo;
	  }
d1072 2
a1073 2
	  for (keys %setstateafter) {
	    print "   case $_:$setstateafter{$_} break;\n";
a1075 1

d1078 3
d1082 1
a1082 1
	# - spaces are skipped, and other stuff is an error.
d1084 3
d1090 1
a1090 16
	# Errors when expecting root tag.
	if ($roottags{$tag}) {
	  print "\n";
	  print "<ROOT_$myctag>{\n";
	  print " .       FAIL(\"Unexpected character `%c': `$tag' element expected.\",yytext[0]);\n" unless $nofail;
	  print " <<EOF>> FAIL(\"EOF in prolog.\");\n" unless $nofail;
	  print "}\n";
	}
      }

      # Dump all end tag recognition rules together (since they have
      # catch-alls).
      print "\n";
      print " /* End-tags. */\n";
      for my $tag (@@tags) {
	my $myctag = $ctag{$tag};
a1096 1

a1097 4
	my %setstateafter = ();
	for (split /,/,$intrans{$tag}) {
	  $setstateafter{$1} .= " SET($2);" if m/^($Name)=>($Name)$/xo;
	}
d1099 2
a1100 2
	for (keys %setstateafter) {
	  print "   case $_:$setstateafter{$_} break;\n";
a1102 1

d1105 1
d1107 1
a1107 1
	print " .       FAIL(\"Unexpected character `%c': `</$tag>' expected.\",yytext[0]);\n" unless ($mixed{$tag} or $nofail);
d1110 9
d1208 4
d1216 2
a1217 2
  print "/* XML application for $DTD generated " . `date +'%Y/%m/%d %T.'`;
  print " * ($DTDrevision).\n" if $DTDrevision;
d1219 1
d1311 1
a1311 1
[B<-ASHDvdnLX>]
d1430 4
d1550 2
a1551 1
C<ID>/C<IDREF> (and C<IDREFS>) are not validated for consistency.
d1555 1
a1555 1
The C<ENTITY> attribute type is not supported.
d1559 2
a1560 2
The various C<xml:>-attributes are ignored; in particular
C<xml:spaces> would be useful.
d1570 3
a1572 4
A child should be able to "return" a value for use by it's parent
(also called a I<synthesised attribute>).  Similarly an element in
Mixed contents should be able to inject text into the C<pcdata> of
the parent.
a1613 2

  $Id: flexml.pl,v 1.18 1999/12/03 23:24:40 krisrose Exp krisrose $
@


1.18
log
@Can now generate validating processors for XHTML!
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.17 1999/12/03 02:08:56 krisrose Exp krisrose $ ';
d330 1
a330 1
use Getopt::Std; getopts('ASHDvdLXp:s:u:r:a:');
d385 5
a392 1

d1301 1
a1301 1
[B<-ASHDvdLX>]
d1387 4
d1601 1
a1601 1
  $Id: flexml.pl,v 1.17 1999/12/03 02:08:56 krisrose Exp krisrose $
@


1.17
log
@Compiles xhtml.dtd!
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.16 1999/12/02 00:32:24 krisrose Exp krisrose $ ';
d34 1
d73 2
a74 2
%entity = ();	# general entity table
%parameter = (); # parameter entity table
d87 1
d96 10
d111 1
a111 1
  $_;
a174 1

d328 3
a330 2
$Use = 'Usage: flexml [-ASHDvdLX] [-s skel] [-p pubid] [-u uri] [-a actions] name[.dtd]';
use Getopt::Std; getopts('ASHDvdLXp:s:u:a:');
d343 5
d349 1
a349 1
$SKELETON = ($opt_s ? $opt_s : '/usr/share/flexml/skel');
d359 1
a359 6
if ($opt_u) {
  $uri = $opt_u
}
else {
  $uri = $DTD;
}
d471 2
a472 1
    $intrans{$tag} .= ($intrans{$tag}?',':'') . "ROOT_$c=>EPILOG";
d524 1
a524 1
      expandparametersat('^'); s/^\s+//;
d572 1
a572 1
	  if ( $type =~ m/^\((.*)\)$/x ) {
d628 2
d632 1
a632 1
      expandparametersat('^'); s/^\s+//; # to expand next set of declarations...
d647 3
a649 3
    s/\&\#([0-9]+);/ pack("c",$1) /ge;
    s/\&\#x([0-9a-fA-F]+);/ pack("c",hex($1)) /ge;
    $parameter{"%$name;"} = "$_";
d659 3
a661 3
    s/\&\#([0-9]+);/ pack("c",$1) /geo;
    s/\&\#x([0-9a-fA-F]+);/ pack("c",hex($1)) /geo;
    $entity{"&$name;"} = "$_";
d725 4
d894 3
a896 1
	print "%x ROOT_$c AL_$c " . join(' ',split(',',$states{$_})) . "\n";
d911 1
a911 1
      for ('PROLOG','DOCTYPE','EPILOG','COMMENT','VALUE1','VALUE2','CDATA') {
d916 1
a916 1
	print "  statenames[ROOT_$c] = NULL;\n";
d929 3
a931 1
      my $id;
d933 2
a934 4
	$id = "PUBLIC{S}(\"'$opt_p'\"|\"\\\"$opt_p\"\\\")";
      }
      else {
	$id = 'SYSTEM';
d936 3
a938 4
      $id .= "{S}(\"'$uri'\"|\"\\\"$uri\"\\\")";
      
      for (@@tags) {
	print " \"<!DOCTYPE\"{S}\"$_\"{S}" .$id . "{s}\">\" SET(ROOT_$ctag{$_});\n";
d945 1
a945 3
      for my $key (keys %source) {
	printsource($key) if $key =~ m/^\%/;
      }
d962 6
a967 1
	print "<ROOT_$myctag" . ($instates{$tag} ? ",$instates{$tag}" : "");
d1071 7
a1077 5
	print "\n";
	print "<ROOT_$myctag>{\n";
	print " .       FAIL(\"Unexpected character `%c': `$tag' element expected.\",yytext[0]);\n" unless $nofail;
	print " <<EOF>> FAIL(\"EOF in prolog.\");\n" unless $nofail;
	print "}\n";
d1127 2
a1128 1
	print $sep . "ROOT_$ctag{$_},AL_$ctag{$_}";
d1138 2
a1139 1
	  . join(',', map("ROOT_$ctag{$_},AL_$ctag{$_},$states{$_}", @@tags))
d1148 1
a1148 1
	print " \"$ent\" ENTITYTEXT(\"$entity{$ent}\");\n";
d1170 1
a1170 1
      for ('PROLOG','DOCTYPE','EPILOG','COMMENT','VALUE1','VALUE2','CDATA','INITIAL','IMPOSSIBLE') {
d1222 1
a1222 1
    open ACTIONS, "/usr/lib/flexml-act $ACTIONS|";
d1257 1
a1257 1
	       "A_$ctag{$tag}_$catt{$1}_" . variablify($2); |xe ) {
a1263 3
	s/\{pcdata\}/pcdata/gx;
	s/\{processor\}/yylex()/gx;

d1301 1
d1334 2
a1335 2
we explahow to write applications, and in L</BUGS> we list the current
limitations of the system before giving standard references.
d1386 7
a1392 2
instead of C<SYSTEM>; in any case followed by the DTD file name or the
I<uri> passed with B<-u>I<uri>.
d1471 1
a1471 1
=item C<{pcdata}>
d1488 1
a1488 1
=item C<{processor}>
d1492 2
a1493 1
manual for I<flex>(1) for information on how to change this).
d1499 1
a1499 1
  int main() { exit({process}); }
d1542 2
a1543 1
badly.
d1549 1
a1549 1
Mixed contents should be able to inject text into the C<{pcdata}> of
d1558 1
a1558 1
=item F</usr/share/flexml/skel>
d1593 1
a1593 1
  $Id: flexml.pl,v 1.16 1999/12/02 00:32:24 krisrose Exp krisrose $
@


1.16
log
@Manual updated...
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.15 1999/12/01 03:41:19 krisrose Exp krisrose $ ';
d39 2
a40 1
%outstates = ();# $outstates{tag} is list of states for element end tag.
d88 1
d162 1
a162 2
sub expandparameters { # Expand paremeter entities.
  local ($_) = @@_;
d164 3
a166 24
  # Upper limit of number of expandings (to avoid looping on cycles :)
  my $count = (keys %parameter) + 1;
  my $test = true;

  while ($test and $count > 0) {
    my $line = '';
    $test = false;

    while ($_) {
      if ( s/^\'[^']*\'|^\"[^"]*\"|^%\s+|^[^%"']//o ) {
	$line .= $&;
      }
      elsif ( s/^%$Name;//xo ) {
	$test = true;
	my $replacement = $parameter{$&};
	die "Line $.: Unknown parameter entity reference \`$&\'.\n" if not $replacement;
	$line .=  $replacement;
      }
      else {
	die "Messy line at >>>: \`$line>>>$_\'.\n";
      }
    }
    $_ = $line;
    $count--;
d168 1
a169 1
  die "Internal parameter entity expansion loop.\n" if $count<0;
d171 8
a178 1
  return $_;
d186 1
a186 1
  if ( m/^($Name[+?*]?)\s*/xo ) {
d221 1
a221 1
  if ( m/^\s*($Name)\s*$/xo or m/^\s*\(\s*($Name)\s*\)\s*$/xo ) { # tag
d230 1
a230 1
die "Oops...state transform tag: $in=>$out already registered?!\n";
d233 1
a233 1
	die "DTD element $tag ambiguous ($in=>$out and $2).\n";
d242 1
a242 1
  elsif ( m/^(.+)\+\s*$/o ) { # re +
d253 1
a253 1
  elsif ( m/^(.+)\?\s*$/o ) { # re ?
d260 1
a260 1
  elsif ( m/^(.+)\*\s*$/o ) { # re *
d265 1
a265 1
  elsif ( m/^\s*\(\s*(.+)\s*\)\s*$/xo ) { # choice or seq
d276 1
a276 1
    elsif ( m/^\s*([|,])\s*/ ) {
d308 1
a308 1
  die "DTD element $tag has nonsense fragment `$_'.\n";
d317 2
a318 2
$Use = 'Usage: flexml [-ASHDdLX] [-s skel] [-p pubid] [-u uri] [-a actions] name[.dtd]';
use Getopt::Std; getopts('ASHDdLXp:s:u:a:');
d323 1
d341 8
a348 5
# Set document type URI.
if ($opt_u) { $uri = $opt_u; }
else { $uri = $DTD; }
if ($opt_p) { $uri = 'PUBLIC "' . $opt_p . '" "' . $uri . '"'; }
else { $uri = 'SYSTEM "' . $uri . '"'; }
a351 1

d368 1
a368 1
  die "-A conflicts with -SHD.\n" if ($opt_S or $opt_H or $opt_D);
d394 24
a417 1
until (eof DTD) {	# we exit in reader below
d419 2
a420 2
  # Remove any "old" DTD entry and non-entry prefix.
  s/^<![^>]*>([^<]|<[^!])*//o;
d422 2
a423 4
  # Read until a full DTD <!...> entry is available in $_; take care
  # to store the unmodified line in $orig and bail out when there are
  # no more entries.
  while (not m/^<![^>]*>/o and not eof DTD) {
d425 1
a425 1
    $line = expandparameters($line);
a426 1
    s/^([^<]|<[^!])*//o;
d428 4
a431 3
  if (m/^(<![^>]*>)/o) {
    $orig = "$1";
    s/\s+/ /og;
d433 7
a439 2
  else {
    last;
d443 4
a446 1
  if ( m/^<!ELEMENT\s+($Name)\s+([^>]*)>/xo ) {
d448 1
a448 1
    die "Repeated element $tag.\n" if $source{$tag};
a449 1
    $source{$tag} = "$orig";
d453 1
d456 1
a456 1
    my $c = $ctag{$tag};
d465 3
a467 3
      $states{$tag} = "S_$c,E_$c";
      $outstates{$tag} = "E_$c";
      $emptytrans{"S_$c"} = "E_$c";
d474 2
a475 1
      $outstates{$tag} = "IN_$c";
d478 1
a478 1
	    or m/^\(\s*\#PCDATA\s*((\s*\|\s*$Name)*)\)\*\s*$/xo ) {
d488 2
a489 1
      $outstates{$tag} = "IN_$c";
d495 1
d498 1
a498 1
      $outstates{$tag} = "E_$c";
d503 1
a503 1
  elsif ( m/^<!ATTLIST\s+([a-zA-Z:_.-]+)\s+([^>]*)>/o ) {
d505 1
a505 2
    my $tag = $1;
    local $_ = $2;
d507 3
a509 3
    # Repeat while there are attribute declarations.
    while ( s/^($Name)\s+([A-Z]+|\(\s*$Nmtoken(?:\s*\|\s*$Nmtoken)*\s*\))
	      (?:\s+(\#IMPLIED|\#REQUIRED|(?:\#FIXED\s+)?$Literal))?\s*//xo ) {
d511 1
a511 1
      my ($attribute,$type,$default) = ($1,$2,$3);
d513 3
a515 8
      if ($atttype{"$tag/$attribute"}) {
	print "Warning: Redeclaration of element $tag attribute $attribute ignored.\n";
      }
      else {
	if ($orig) { # to only print the source once
	  $source{"$tag/$attribute"} = "$orig";
	  $orig = '';
	}
d517 1
a517 2
	$ctag{$tag} = variablify($tag) unless $ctag{$tag};
	$catt{$attribute} = variablify($attribute) unless $catt{$attribute};
d519 2
a520 4
	# Add atribute to the appropriate lists.
	$attlist{$tag} .= ($attlist{$tag}?',':'') . "$attribute";
	if ($withattr{$attribute}) {
	  $withattr{$attribute} .= ",$tag"; 
d523 4
a526 3
	  push @@attributes, $attribute;
	  $withattr{$attribute} = "$tag"; 
	}
d528 2
a529 12
	# Analyse default value.
	if ("$default" eq '#REQUIRED') {
	  $required{"$tag/$attribute"} = true;
	  $default = undef;
	}
	elsif ($default eq '#IMPLIED') {
	  $default = undef;
	}
	else {
	  $fixed{"$tag/$attribute"} = true if $default =~ s/\#FIXED\s+//o;
	  $default =~ s/^'([^'']*)'$/$1/o unless $default =~ s/^"([^""]*)"$/$1/o;
	}
d531 4
a534 17
	# Store attribute default string and type.
	$attdef{"$tag/$attribute"} = $default if $default;
	$atttype{"$tag/$attribute"} = "$type";

	# Handle enumeration types...
	if ( $type =~ m/^\((.*)\)$/x ) {
	  local $_ = $1;
	  s/\s+//go;
	  s/\|/,/go;
	  $enumtype{"$tag/$attribute"} = "$_";
	  s/$Nmtoken/ "A_$ctag{$tag}_$catt{$attribute}_" . variablify($&) /xge;
	  my $undefined = "AU_$ctag{$tag}_$catt{$attribute}";
	  s/^/enum \{ $undefined, /o;
	  s/$/ \}/o;
	  $typeof{"$tag/$attribute"} = "$_";
	  if ($default) {
	    $initof{"$tag/$attribute"} = "A_$ctag{$tag}_$catt{$attribute}_" . variablify($default);
d537 8
a544 1
	    $initof{"$tag/$attribute"} = "$undefined";
d546 2
a547 6
	}
	# ...and string/token types.
	else {
	  $typeof{"$tag/$attribute"} = 'char*';
	  if ($default) {
	    $initof{"$tag/$attribute"} = "\"$default\"";
d550 2
a551 1
	    $initof{"$tag/$attribute"} = 'NULL';
d554 22
a575 3
	  # Special treatment of token types.
	  if ( $type eq 'ID' or $type eq 'IDREF' ) {
	    $literaltype{"$tag/$attribute"} = '{Name}';
d577 33
a609 17
	  elsif ( $type eq 'IDREFS' ) {
	    $literaltype{"$tag/$attribute"} = '{Names}';
	  }
	  elsif ( $type eq 'NMTOKEN' ) {
	    $literaltype{"$tag/$attribute"} = '{Nmtoken}';
	  }
	  elsif ( $type eq 'NMTOKENS' ) {
	    $literaltype{"$tag/$attribute"} = '{Nmtokens}';
	  }
	  elsif ( $type eq 'ENTITY' ) {
	    die "ENTITY attribute type unimplemented.\n";
	  }
	  elsif ( $type eq 'ENTITIES' ) {
	    die "ENTITIES attribute type unimplemented.\n";
	  }
	  elsif ( $type ne 'CDATA' ) {
	    die "Unknown AttType `$type'.\n";
d612 2
d615 1
d617 1
a617 3
	# Store default value
	$defaultdecl{"$tag/$attribute"} = $default;
      }
d620 1
d623 12
a634 4
  # Parse internal parameter entity declarations.
  elsif ( /^<!ENTITY\s+%\s+([a-zA-Z:_.-]+)\s+"([^>]*)"\s*>/ ) {
    $parameter{"%$1;"} = "$2";
    $source{"%$1;"} = "$orig";
d638 9
a646 3
  elsif ( /^<!ENTITY\s+([a-zA-Z:_.-]+)\s+"([^>]*)"\s*>/ ) {
    $entity{"&$1;"} = "$2";
    $source{"&$1;"} = "$orig";
d649 3
a651 4
  # Save DTD RCS version number...
  elsif ( /\$(Id|Header|Revision): [^\$]*\$/ ) {
    $DTDrevision = "$&";
    $DTDrevision =~ s/\s*\$\s*//go;
d662 1
a662 1
  # Complete instates and outstates...
d664 1
a664 1
  my $ons = $outstates{$tag};
d686 1
a686 1
  $outstates{$tag} = $ons if $ons;
d732 1
a732 1
  print '%outstates = (' . printhash(outstates) . ")\n";
d907 10
a916 3
      my $uri1 = $uri; $uri1 =~ s/"/\\'/og; #'"
      my $uri2 = $uri; $uri2 =~ s/"/\\"/og;

d918 1
a918 3
	print ' "<!DOCTYPE"{S}' . $_ . '{S}'
            . '(' . $uri . '|' . $uri1 . ')'
	    . '{s}">"' . " SET(ROOT_$ctag{$_});\n";
d982 1
a982 1
	    print " \"$attribute\"{Eq}\"\'\"$type\"\'\" BUFFERLITERAL('\\\'',A_${myctag}_$catt{$attribute});\n";
d1016 1
a1016 1
	    . " ENTER(" . ($mixed{$tag} ? 'IN' : 'S') . "_$myctag);\n";
d1062 1
a1062 1
	print "<$outstates{$tag}>{\n";
d1121 1
a1121 1
	print " \"$ent\" ENTITYTEXT(\"$entity{$ent}\")\n";
d1124 7
d1132 1
a1132 1
    elsif ( /^FLEXML_FINAL$/ ) {
d1134 1
a1134 1
      # Process general entities.
d1151 1
a1151 1
    elsif ( $nofail and /FAIL/ ) {
d1204 1
d1273 1
a1273 1
[B<-ASHDdLX>]
d1285 11
a1295 8
interface to support XML I<application>s.  Proper XML applications can
be generated optionally from special "action files", either for
linking or textual combination with the processor

Not all XML DTDs are supported: the DTD file must contain a complete
C<extSubset> (XML rule [30]) with the further restriction that it
cannot contain any external entity declarations or "processing
instruction".
d1299 1
a1299 5
separate compilation of generated applications.  The generated
processor will only validate documents that conform strictly to the
DTD without extending it, more precisely we restrict XML rule [28] to

  [28s] doctypedecl ::= '<!DOCTYPE' S Name S ExternalID S? '>'
d1303 4
a1306 3
called from the XML processor (it can also fold the XML application
into the XML processor to make stand-alone XML applications but this
prevents sharing of the processor between applications).
a1311 39
=head1 STATIC DTD FORMAT

As metioned above, the XML processors generated by I<Flexml> are
restricted to validate documents that have their entire definition in
one "external DTD subset".  




However, the DTD itself should also obey certain restrictions that ensure that it can be completelt


Only internal (general and parameter) entities are handled.  I<Flexml>
currently rejects DTDs using or declaring external entities,
notations, etc.  More precisely we treat DTD files that match the
C<extSubset> production of XML with the additional restriction that it cannot

  [29] markupdecl ::= elementdecl | AttlistDecl
                      | EntityDecl | NotationDecl | PI
                      | Comment 

  [30] extSubset ::= TextDecl? extSubsetDecl

  [31] extSubsetDecl ::= ( markupdecl | conditionalSect | PEReference | S )*

  [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'

  [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children 

  [47] children ::= (choice | seq) ('?' | '*' | '+')?
  [48]       cp ::= (Name | choice | seq) ('?' | '*' | '+')?
  [49]   choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
  [50]      seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'






d1378 4
d1396 6
a1401 2
The contents of "C<top>" elements should be used for top-level C code
such as global declarations, utility functions, etc.
d1403 7
a1409 5
A "C<start>" element attaches the code as an action to the element
with the name of the required "C<tag>" attribute.  The "C<%C-code;>"
component should be C code suitable for inclusion in a C block (i.e.,
within C<{>...C<}> so it may contain local variables); furthermore the
following extensions are available:
d1431 7
a1437 6
An "C<end>" element similarly attaches the code as an action to the
end tag with the name of the required "C<tag>" attribute; also here
the "C<%C-code;>" component should be C code suitable for inclusion in
a C block.  In case the element has "Mixed" contents, i.e, was
declared to permit C<#PCDATA>, then the following variable is
available:
d1450 2
d1474 5
a1478 2
Note: I<Flexml> handles empty elements E<lt>I<tag>C</>E<gt> as
equivalent to E<lt>I<tag>E<gt>E<lt>C</>I<tag>E<gt>.
d1482 3
a1484 1
The present version of I<flexml> has some restrictions that we hope to
a1496 7
A child should be able to "return" a value for use by it's parent
(also called a I<synthesised attribute>).  Similarly an element in
Mixed contents should be able to inject text into the C<{pcdata}> of
the parent.

=item *

d1508 12
a1521 6
If you discover a bug, in particular if you have a DTD for which you
believe I<flexml> should run but it does not (or produces bad output),
then please don't hesitate to contact the author.  It is the goal that
I<flexml> may reject some valid DTDs but never a valid XML document
conforming to the restrictions summarised at the beginning of this manual.

d1561 1
a1561 1
  $Id: flexml.pl,v 1.15 1999/12/01 03:41:19 krisrose Exp krisrose $
@


1.15
log
@Works (still needs testing, though... :).
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.14 1999/11/30 18:28:23 krisrose Exp krisrose $ ';
d330 2
a331 2
$Use = 'Usage: flexml [-ASHDdLX] [-s skel] [-u uri] [-a actions] name[.dtd]';
use Getopt::Std; getopts('ASHDdLXs:u:a:');
a346 3
# Get URI if any.
$uri = $opt_u if $opt_u;

d353 7
a359 1
# Selection options: If none of -SHD specified then default to -SH.
d862 2
a863 1
      my $id = ($uri ? $uri : $DTD);
d866 2
a867 2
	print ' "<!DOCTYPE"{S}' . $_ . '{S}' . 'SYSTEM{S}'
            . '(' . "\\'" . $id . "\\'" . '|' . '\"' . $id . '\"' . ')'
d1179 2
d1215 3
a1217 1
[B<-ASHDdL>]
a1218 1
[B<-s>I<skel>]
d1226 65
a1290 10
documents.  It produces a validating XML processor for the DTD in the
form of a I<flex>(1) scanner I<name>F<.l> with a corresponding C
header file I<name>F<.h>.  (Not all XML DTDs are supported: see
L</BUGS>Z<> for a description of what is not (yet) implemented.)

Optionally it takes an I<actions> file with per-element actions and
produces a C file with element functions for an XML application called
from the XML processor (it can also fold the XML application into the
XML processor to make stand-alone XML applications but this prevents
sharing of the processor between applications).
a1291 1
The generated processor and applications are designed for speed.
d1295 1
a1295 1
I<Flexml> takes the following options:
d1301 4
a1304 4
Generate a I<stand-alone> scanner application.  If combined with B<-a>
the aplication will be names as I<actions> with the extension replaced
with F<.l>, otherwise it will be in I<name>F<.l>.  B<-A> conflicts
with B<-S>, B<-H>, and B<-D>.
d1306 1
a1306 1
=item B<-a>I<actions>
d1315 6
a1320 4
Generate the dummy application I<name>F<-dummy.c>.  If combined with
B<-a>I<actions> then the application will include the specified
actions and be named as I<actions> with the extension replaced with
F<.c>.
d1324 1
a1324 1
Turns on debug mode in the flex scanner and also prints out a the
d1329 2
a1330 1
Generate the header file I<name>F<.h>.
d1334 10
a1343 3
Makes the XML processor count the lines in the input and keep it
available to XML application actions as C<yylineno>.  (This is not the
default as the performance overhead is significant.)
d1347 2
a1348 1
Generate the scanner I<name>F<.l>.
d1350 1
a1350 1
=item B<-s>I<skel>
d1354 1
a1354 1
=item B<-u>I<uri>
a1358 1

d1361 1
a1361 1
=head1 ACTION FILES
d1366 1
a1366 1
  <!ELEMENT actions ((top|start|end)*,main)>
d1377 1
a1377 1
with the name of the requred "C<tag>" attribute.  The "C<%C-code;>"
d1388 1
a1388 1
appears as a null-terminated C string (of type C<char*>) except if
d1391 1
a1391 1
  <!ATTLIST attrib (alt1 | alt2 |...)*>
d1393 2
a1394 2
in which case an the attribute is of an enumerated type with the
elements written C<{>I<attribute>C<=>I<alt1>C<}>,
d1396 3
a1398 1
attribute has the "value" C<{!>I<attribute>C<}>.
d1403 5
a1407 4
end tag names as the required "C<tag>" attribute.  The "C<%C-code;>"
component should be C code suitable for inclusion in a C block (i.e.,
within C<{>...C<}>).  In case the element has "Mixed" contents then
the following variable is available:
d1411 1
a1411 1
=item C<pcdata>
d1420 1
a1420 1
Finally, a "C<main>" element should contain the entire C C<main>
d1426 1
a1426 1
=item C<yylex()>
d1434 1
a1434 1
If no C<main> action is provided then the following default is provided:
d1436 1
a1436 1
  int main() { exit(yylex()); }
d1447 2
a1448 7
I<Flexml> is restricted (by design) to validate XML documents with a
document type declaration of the simple form

  <!DOCTYPE root SYSTEM "uri">

because these can be efficiently parsed.  However, the present version
has more serious restrictions that we hope to overcome in the future:
d1455 2
a1456 2
characters but this only has the ASCII character set in common with
the UTF-8 encoding required by XML).
d1460 4
a1463 10
Element-content is restricted to declarations of the form

  <!ELEMENT tag (child1 | child2 | ... )*>

(essentially as Mixed contents without C<#PCDATA>).  This is being fixed.

=item *

A child should be able to insert a "cookie" (also called a
I<synthesised attribute>) in the data stream of the parent.
d1467 1
a1467 1
C<ID>/C<IDREF> consistency is not validated.
a1474 6
Only internal (general and parameter) entities are handled.  I<Flexml>
currently rejects DTDs using or declaring external entities,
notations, etc.

=item *

d1480 5
a1484 3
There are further restrictions on the form of DTDs because the present
DTD parser does not conform to the XML specification, however,
I<flexml> will complain rather than produce incorrect XML processors.
d1525 1
a1525 1
  $Id: flexml.pl,v 1.14 1999/11/30 18:28:23 krisrose Exp krisrose $
@


1.14
log
@Full DTD parsing almost done...still some nitty-gritty, though.
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.13 1999/11/29 16:09:02 krisrose Exp krisrose $ ';
d36 5
a40 1
%states = ();	# $states{tag} is list of states for tag element.
d42 2
a43 1
%restate = ();  # $restate{tag} is state translation table after tag element.
d46 1
a50 2
%instates = ();	# $instates{tag} is comma-separated list of element
                # contexts within which the tag element may occur.  
a126 1

a135 1

a149 1

a160 1

d237 3
a239 1
    $instates{$tag} .= ($instates{$tag}?',':'') . $in;
d242 1
a242 1
      if ( $restate{$tag} =~ m/(^|,)$in=>$out(,|$)/ ) {
d245 1
a245 1
      elsif ( $restate{$tag} =~ m/(^|,)$in=>([^,]*)(,|$)/ ) {
d249 1
a249 1
	$restate{$tag} .= ($restate{$tag}?',':'') . "$in=>$out" 
d396 2
d437 1
a437 1
    $restate{$tag} .= ($restate{$tag}?',':'') . "ROOT_$c=>EPILOG";
d442 1
d444 1
d452 1
d465 1
d473 1
d614 3
a616 2
  # Complete instates...
  my $ss = $instates{$tag};
d620 1
a620 1
    $ss .= ($ss?',':'') . "IN_$_";
d626 8
a633 2
    if ($ss =~ s/(^|,)$b(,|$)/$1$a,$b$2/) {
      $restate{$tag} .= ($restate{$tag}?',':'') . "$a=>$b";
d637 2
a638 1
  $instates{$tag} = $ss;
d640 4
a643 4
  # Take transitive closure of restate.
  my %restatetag = ();
  for (split /,/,$restate{$tag}) {
    $restatetag{$1} = $2 if m/^($Name)=>($Name)$/xo;
d645 1
a645 1
  for (keys %restatetag) {
d647 1
a647 1
    while ($a = $restatetag{$a}) { $restatetag{$_} = $a; }
d649 11
a659 1
  $restate{$tag} = join ',',(map "$_=>$restatetag{$_}",keys %restatetag);
d683 3
d687 3
a689 1
  print '%restate = (' . printhash(restate) . ")\n";
a694 3

  print '%instates = (' . printhash(instates) . ")\n";
  print '%inmixed = (' . printhash(inmixed) . ")\n";
d796 2
a797 1
      print "#define FLEXML_Mixed\n" if %inmixed;
d976 1
a976 1
	  for (split /,/,$restate{$tag}) {
a988 1
	print " {S}     SKIP;\n";
a995 1
	print " {S}     SKIP;\n";
d1008 1
a1008 1
	print "<" . ($mixed{$tag} ? 'IN' : 'E') . "_$myctag>{\n";
d1016 1
a1016 1
	for (split /,/,$restate{$tag}) {
a1026 2
	print " {S}     SKIP;\n" unless $mixed{$tag};

d1044 11
d1071 19
d1466 3
a1468 1
  $Id: flexml.pl,v 1.13 1999/11/29 16:09:02 krisrose Exp krisrose $
@


1.13
log
@Full DTD parsing in progress...currently not working.
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.12 1999/11/25 18:42:03 krisrose Exp krisrose $ ';
d34 1
a34 1
%ctag = ();     # C variable name for tag.
d36 3
a38 2
%states = ();	# states (,-separated) corresponding to tag.
%leavetags = ();# reverse state table to apply at end of each tag.
a40 1

a41 1

a42 2
%inmixed = ();	# $inmixed{tag} == true if the tag occurs *in* Mixed contents.

d45 1
a45 1
%instates = ();   # $instates{tag} is comma-separated list of element
d47 1
a47 3

%emptytransto = ();# $emptyransto{tag} == tag2 for empty: tag2->tag1.
%leavetags = ();# state transformations to do at end tag.
a61 3
%startok = ();  # start tag action already dumped
%endok = ();    # end tag action already dumped

a63 1

d68 1
d70 2
a71 1
%parameter = (); # parameter entity table
d114 4
d125 3
a127 3
  foreach $tag (@@tags) {
    print $pre . "void STag_$ctag{$tag}(void)$post\n" unless $startok{$tag};
    print $pre . "void ETag_$ctag{$tag}(void)$post\n" unless $endok{$tag};
d135 2
a136 2
  foreach $ta (keys %atttype) {
    if ($ta =~ m.($Nmtoken)[/]($Nmtoken).o) {
d138 1
a138 1
      print "typedef $typeof{$ta} AT_$ctag{$tag}_$catt{$attribute};\n";
d140 1
a140 1
	if not $enumtype{$ta};
d151 4
a154 4
  foreach $ta (keys %atttype) {
    my ($tag,$attribute);
    ($tag,$attribute) = ($1,$2) if $ta =~ m.($Nmtoken)[/]($Nmtoken).o;
    print $pre . "AT_$ctag{$tag}_$catt{$attribute} A_$ctag{$tag}_$catt{$attribute};\n";
d236 15
a250 1
print"Analyse: tag $1.\n";
d252 2
a253 1
    $instates{$1} .= ($instates{$1} ? "," : "") . $in;
d255 7
a261 3
    die "DTD element $tag ambiguous ($in).\n"
      if $leavetags{"$1,$in"} and $leavetags{"$1,$in"} ne $out;
    $leavetags{"$1,$in"} = $out unless $in eq $out;
a262 1
    return false;
d266 1
a266 3
print"Analyse: $1 ?\n";

    $emptytransto{$out} = $in unless $in eq $out;
d269 1
d273 1
a273 1
print"Analyse: $1 *\n";
a274 11
    $emptytransto{$out} = $in unless $in eq $out;
    analysechildren($tag,$1,$out,$out);
    return true;
  }
  elsif ( m/^(.+)\+\s*$/o ) { # re +

print"Analyse: $1 +\n";

    my $re = $1;
    analysechildren($tag,$re,$out,$out) unless $in eq $out;
    return analysechildren($tag,$re,$in,$out);
a277 2
print"Analyse: $1...\n";

a281 2
print" head: $cp\n";

d284 1
a284 1
print" recurse...\n";
a285 1
      return analysechildren($tag,$cp,$in,$out);
d289 1
a289 1
      my $result = ($type eq '[,]');
a291 2
print" type $type...\n";

a294 2
print" rest is $_...\n";

d296 1
a296 4

print" choice $cp...\n";

	  $result = true if analysechildren($tag,$cp,$in,$out);
a298 3

print" sequent $cp...\n";

a300 1
	  $result = false unless analysechildren($tag,$cp,$oldstate,$state);
d302 1
d309 1
a309 4

print" final choice $cp...\n";

        $result = true if analysechildren($tag,$cp,$in,$out);
d312 2
d315 2
a316 6
print" final sequent $cp...\n";

	$result = false unless analysechildren($tag,$cp,$state,$out);
      }
     
      return $result unless $_;
d328 1
a328 1
$Use = "Usage: flexml [-ASHDdLX] [-s skel] [-u uri] [-a actions] name[.dtd]";
d342 1
a342 1
$SKELETON = ($opt_s ? $opt_s : "/usr/share/flexml/skel");
d433 1
a433 1
    $leavetags{"$tag,ROOT_$c"} = 'EPILOG';
d438 2
a439 1
      $states{$tag} = "IN_$c";
d453 3
a455 3
      foreach $tag2 (split /\s*\|\s*/,"$desc") {
	$instates{$tag2} .= ($instates{$tag2} ? "," : "") . "IN_$c";
	$inmixed{$tag2} = true;
d462 3
a464 10
      $empty{$tag} = true if analysechildren($tag,$_,"S_$c","IN_$c");

      # Try to optimise non-needed states away...
      if ($empty{$tag}) {
	$states{$tag} = "IN_$c" . $states{$tag};
	delete $emptytransto{"IN_$c"};
      }
      else {
	$states{$tag} = "IN_$c,S_$c" . $states{$tag};
      }
d493 1
a493 1
	$attlist{$tag} .= ($attlist{$tag} ? "," : "") . "$attribute";
d539 1
a539 1
	  $typeof{"$tag/$attribute"} = "char*";
d544 1
a544 1
	    $initof{"$tag/$attribute"} = "NULL";
d548 2
a549 2
	  if ( $type eq "ID" or $type eq "IDREF" ) {
	    $literaltype{"$tag/$attribute"} = "{Name}";
d551 2
a552 2
	  elsif ( $type eq "IDREFS" ) {
	    $literaltype{"$tag/$attribute"} = "{Names}";
d554 2
a555 2
	  elsif ( $type eq "NMTOKEN" ) {
	    $literaltype{"$tag/$attribute"} = "{Nmtoken}";
d557 2
a558 2
	  elsif ( $type eq "NMTOKENS" ) {
	    $literaltype{"$tag/$attribute"} = "{Nmtokens}";
d560 1
a560 1
	  elsif ( $type eq "ENTITY" ) {
d563 1
a563 1
	  elsif ( $type eq "ENTITIES" ) {
d566 1
a566 1
	  elsif ( $type ne "CDATA" ) {
d601 6
a606 1
# DTD Post-processing.
d608 3
a610 4
# Expand ANY element contents into the corresponding Mixed contents.
foreach $tag (keys %any) {
  foreach $tag2 (@@tags) {
    $instates{$tag2} .= ($instates{$tag2} ? "," : "") . "IN_$tag";
a611 1
}
d613 5
a617 7
# Remove empty element content tag states.
foreach $tag (@@tags) {
  if ($empty{$tag}) {
    my $c = $ctag{$tag};
    foreach $tag2 (@@tags) {
      delete $leavetags{"$tag2,S_$c"};
      $instates{$tag2} =~ s/,S_$c$//;
d620 13
d635 1
d654 1
d656 3
a658 1
  print '%leavetags = (' . printhash(leavetags) . ")\n";
a661 1
  print '%inmixed = (' . printhash(inmixed) . ")\n";
d663 1
d665 1
a665 2
  print '%emptytransto = (' . printhash(emptytransto) . ")\n";
  print '%leavetags = (' . printhash(leavetags) . ")\n";
d667 1
d669 2
d674 2
d679 2
a682 3
  print '%catt = (' . printhash(catt) . ")\n";
  print '%typeof = (' . printhash(typeof) . ")\n";
  print '%initof = (' . printhash(initof) . ")\n";
d684 1
d767 1
a767 1
      print "#define FLEXML_inmixed\n" if %inmixed;
d795 3
a797 5
      my $tag;

      foreach $tag (@@tags) {
	my $c = $ctag{$tag};
	print "%x ROOT_$c AL_$c " . join(' ',split(',',$states{$tag})) . "\n";
d807 1
a807 1
      print "char* statenames[DISABLE];\n";
d812 2
a813 2
      foreach $state ('PROLOG','DOCTYPE','EPILOG','COMMENT','VALUE1','VALUE2','CDATA','DISABLE') {
	print "  statenames[$state] = \"$state\";\n";
d815 1
a815 1
      foreach $tag (@@tags) {
d817 4
a820 5

	print "  statenames[ROOT_$c] = \"document ($tag)\";\n";
	print "  statenames[AL_$c] = \"$tag (attributes)\";\n";
	foreach $state (split ',',$states{$tag}) {
	  print "  statenames[$state] = \"$tag\";\n";
d831 2
a832 2
      foreach $tag (@@tags) {
	print ' "<!DOCTYPE"{S}' . $tag . '{S}' . 'SYSTEM{S}'
d834 1
a834 1
	    . '{s}">"' . " SET(ROOT_$ctag{$tag});\n";
d841 1
a841 1
      foreach $key (keys %source) {
d846 1
a846 1
      foreach $tag (@@tags) {
d854 1
a854 1
	foreach $attribute (@@myattributes) {
d862 1
a862 1
	foreach $attribute (@@myattributes) {
d872 1
a872 1
	foreach $attribute (@@myattributes) {
d885 1
a885 1
	      foreach $alternative (split /,/,$type) {
d894 1
a894 1
	        . " FAIL(\"%s illegal in $tag element.\",yytext);\n" unless $nofail;
d903 1
a903 1
	        . " FAIL(\"%s illegal in $tag element ($attribute is #FIXED).\",yytext);\n" unless $nofail;
d915 1
a915 1
	        . " FAIL(\"%s illegal for $tag element.\",yytext);\n" unless $nofail;
d925 1
a925 1
	print " {Name}{Eq} FAIL(\"%s illegal in $tag.\",yytext);\n" unless $nofail;
d929 1
a929 1
	    . ($inmixed{$tag} ? ' pushbuffer(pcdata);' : '')
d931 3
a933 1
	    . " ENTER(" . ($empty{$tag} ? 'IN' : 'S') . "_$myctag);\n";
d937 12
a948 7
	  print " \"/>\" {\n";
	  print "  LEAVE; STag_$myctag();\n";
	  print "  pushbuffer(pcdata);\n" if $inmixed{$tag};
	  print "  pcdata = " . ($mixed{$tag} ? '""' : 'NULL') . ";\n";
	  print "  ETag_$myctag();\n";
	  print "  pcdata = popbuffer();\n" if $inmixed{$tag};

d950 2
a951 4
	  foreach $key (keys %leavetags) {
	    if ($key =~ m/$tag,($Name)/x) {
	      print "   case $1: SET($leavetags{$key}); break;\n"
	    }
d960 2
a961 2
	print " .       FAIL(\"Unexpected character \`%c\' in attribute list of $tag element.\", *yytext);\n" unless $nofail;
	print " <<EOF>> FAIL(\"EOF in attribute list of $tag element.\");\n" unless $nofail;
d968 1
a968 1
	print " .       FAIL(\"<$tag> root element expected.\");\n" unless $nofail;
d977 1
a977 1
      foreach $tag (@@tags) {
d980 1
a980 1
	print "<IN_$myctag>{\n";
d986 5
a990 1
	print "  pcdata = popbuffer();\n" if $inmixed{$tag};
d992 2
a993 4
	foreach $key (keys %leavetags) {
	  if ($key =~ m/$tag,($Name)/x) {
	    print "   case $1: SET($leavetags{$key})\n;"
	  }
d1001 3
a1003 3
	print " \"</\"{Name}{s}\">\" FAIL(\"Bad end tag: %s where </$tag> expected.\",yytext);\n" unless $nofail;
	print " .       FAIL(\"Unexpected character \`%c\' where </$tag> expected.\",*yytext);\n" unless ($mixed{$tag} or $nofail);
	print " <<EOF>> FAIL(\"Premature EOF: </$tag> expected.\");\n" unless $nofail;
d1014 1
a1014 1
	print "$`DISABLE$1$'";
d1028 1
a1028 1
      foreach $ent (keys %entity) {
d1410 1
a1410 1
  $Id: flexml.pl,v 1.12 1999/11/25 18:42:03 krisrose Exp krisrose $
@


1.12
log
@Stand-alone mode added and documented; still technical section to write.
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.11 1999/11/25 03:01:47 krisrose Exp krisrose $ ';
d36 4
a39 1
%empty = ();	# $empty{tag} == true if the tag is an empty tag.
d46 3
a48 1
%intags = ();   # $intags{tag} is comma-separated list of element
d51 3
d162 1
a162 1
sub expandparameters {
d166 2
a167 2
  # Expand parameter entities until none left (or we hit a cycle :)
  my $count = keys %parameter;
d192 2
d198 142
d345 2
a346 2
$Use = "Usage: flexml [-ASHDdL] [-s skel] [-u uri] [-a actions] name[.dtd]";
use Getopt::Std; getopts('SHDdLs:u:a:A');
d355 3
d447 1
d449 4
d455 1
d458 1
d460 2
a461 1
      $any{$tag} = true;
d463 9
a471 8
    elsif ( m/^\(\s*(\#PCDATA\s*\|\s*)?($Name\s*(\|\s*$Name\s*)*)\)\*\s*$/xo
	    or m/^\(\s*(\#PCDATA)\s*\)\s*$/o ) {
      if ($1) {
	$mixed{$tag} = true;
      }
      foreach $tag2 (split /[| ]+/,"$2") {
	$intags{$tag2} .= ($intags{$tag2} ? "," : "") . "$tag";
	$inmixed{$tag2} = true if $1;
d473 1
d476 12
a487 1
      die "$0: unsupported $orig";
d535 1
a535 1
	  $default =~ s/^'([^'']*)'$/\1/o unless $default =~ s/^"([^""]*)"$/\1/o;
d624 2
a626 1

d629 12
a640 1
    $intags{$tag2} .= ($intags{$tag2} ? "," : "") . "$tag";
d662 2
d668 4
a671 1
  print '%intags = (' . printhash(intags) . ")\n";
d796 2
d799 2
a800 2
	$c = $ctag{$tag};
	print "%x ROOT_$c AL_$c IN_$c\n";
d803 2
a804 2
      if ($debug) {
	print "%{\n";
d806 1
a806 1
	my ($state, $tag);
d808 17
a824 7
	foreach $state ('PROLOG','DOCTYPE','EPILOG','COMMENT','VALUE1','VALUE2','CDATA','DISABLE') {
	  print "#define X$state \"$state\"\n";
	}
	foreach $tag (@@tags) {
	  $c = $ctag{$tag};
	  print "#define XAL_$c   \"AL_$c\"\n";
	  print "#define XIN_$c   \"IN_$c\"\n";
a825 1
	print "%}\n";
d827 2
d838 1
a838 1
	    . '{s}">"' . " BEGIN(ROOT_$ctag{$tag});\n";
d864 1
a864 2
	print "<ROOT_$myctag";
	foreach $intag (split /,/,"$intags{$tag}") { print ",IN_$ctag{$intag}"; }
d883 2
a884 3
		    . " A_${myctag}_$catt{$attribute}"
		    . " = " . $initof{"$tag/$attribute"} . ";\n";
		print " \"$attribute\"{Eq}\"\\\"" . $attdef{"$tag/$attribute"} . "\\\"\""
d891 2
a892 4
		    . " A_${myctag}_$catt{$attribute}"
		    . " = A_${myctag}_$catt{$attribute}_" . variablify($alternative) . ";\n";

		print " \"$attribute\"{Eq}\"\\\"$alternative\\\"\""
d898 1
a898 1
	        . " FAIL(\"%s illegal in $tag element.\",yytext);\n";
d907 1
a907 1
	        . " FAIL(\"%s illegal in $tag element ($attribute is #FIXED).\",yytext);\n";
d919 1
a919 1
	        . " FAIL(\"%s illegal for $tag element.\",yytext);\n";
d929 1
a929 1
	print " {Name}{Eq} FAIL(\"%s illegal in $tag.\",yytext);\n";
d932 4
a935 4
	print " \">\"  LEAVE(AL_$myctag); STag_$myctag();";
	print " pushbuffer(pcdata);" if $inmixed{$tag};
	print " pcdata = " . ($mixed{$tag} ? 'BUFFERSET(pcdata)' : 'NULL') . ";";
	print " ENTER(IN_$myctag);\n";
d937 19
a955 5
	# - the end of an empty tag means handle it straight away,
	print " \"/>\" LEAVE(AL_$myctag); STag_$myctag();";
	print " pushbuffer(pcdata);" if $inmixed{$tag};
	print " pcdata = " . ($mixed{$tag} ? '""' : 'NULL') . ";";
	print " ETag_$myctag(); CHECKEPILOG($myctag);\n";
d959 2
a960 2
	print " .       FAIL(\"Unexpected character \`%c\' in attribute list of $tag element.\", *yytext);\n";
	print " <<EOF>> FAIL(\"EOF in attribute list of $tag element.\");\n";
a965 1
	print " \"<!--\"  ENTER(COMMENT);\n";
d967 2
a968 2
	print " .       FAIL(\"<$tag> root element expected.\");\n";
	print " <<EOF>> FAIL(\"EOF in prolog.\");\n";
d975 1
a975 1
      print " /* End-tags and nesting errors. */\n";
d980 15
a994 5
	print " \"</$tag\"{s}\">\" LEAVE(IN_$myctag);";
	print " BUFFERDONE;" if $mixed{$tag};
	print " ETag_$myctag();";
	print " pcdata = popbuffer();" if $inmixed{$tag};
	print " CHECKEPILOG($myctag);\n";
d998 3
a1000 3
	print " \"</\"{Name}{s}\">\" FAIL(\"Bad end tag: %s where </$tag> expected.\",yytext);\n";
	print " .       FAIL(\"Unexpected character \`%c\' where </$tag> expected.\",*yytext);\n" unless $mixed{$tag};
	print " <<EOF>> FAIL(\"Premature EOF: </$tag> expected.\");\n";
d1015 1
a1015 1
    elsif ( /FLEXML_NORMAL([,>])/ ) {
d1018 2
a1019 2
	  . join(',', map("IN_$ctag{$_}", keys %mixed)) . ','
	  . join(',', map("AL_$ctag{$_}", @@tags)) . "$1$'";
d1031 3
d1096 1
a1096 1
      s/(\s+[SE])Tag_($Name)\(/\1Tag_$ctag{$2}\(/xg;
d1407 1
a1407 1
  $Id: flexml.pl,v 1.11 1999/11/25 03:01:47 krisrose Exp krisrose $
@


1.11
log
@Almost ready...
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.10 1999/11/24 16:46:57 krisrose Exp krisrose $ ';
a115 1

d119 1
a119 1
  print "/* XML application entry points. */\n";
a123 1
  print "\n";
d128 2
a129 1
  print "/* FleXML-provided data types. */\n";
d193 2
a194 2
$Use = "Usage: flexml [-dSHDL] [-s skel] [-u uri] [-a actions] name[.dtd]";
use Getopt::Std; getopts('LdSHDs:u:a:');
d203 7
d219 2
a220 9
$opt_S = $opt_H = true unless ($opt_S or $opt_H or $opt_D);
$opt_D ||= $opt_a;

# Get URI if any.
$uri = $opt_u if $opt_u;

# Set skeleton scanner file name and check it is readable (if needed).
$SKELETON = ($opt_s ? $opt_s : "/usr/share/flexml/skel");
die "$0: No skeleton file $SKELETON.\n" if not -r $SKELETON and $opt_S;
d229 9
a237 3
  local $_ = $opt_a;
  s/\.(xml|act)$//;
  $APPLICATION = "$_.c";
d518 1
d520 1
d523 4
d540 1
a540 1
if ($opt_S) {
d564 1
a564 1
      print "const char* rcs_flexml =\n"
d567 1
a567 1
      print "const char* rcs_${cprefix}_dtd =\n"
a569 2
      print "#define DEBUG\n" if $debug;

d571 1
a571 1
    elsif ( /^FLEXML_API$/ ) {
d573 4
a576 2
      print "/* XML processor interface. */\n";
      print "#include \"$HEADER\"\n";
d578 14
a591 1
      api_data('');
d696 1
a696 1
	        . " FAIL(\"%s illegal in $tag element.\");\n";
d705 1
a705 1
	        . " FAIL(\"%s illegal in $tag element ($attribute is #FIXED).\");\n";
d717 1
a717 1
	        . " FAIL(\"%s illegal for $tag element.\");\n";
d727 1
a727 1
	print " {Name}{Eq} FAIL(\"%s illegal in $tag.\");\n";
d752 1
a752 1
	print " .       FAIL(\"$tag root element.\");\n";
d774 1
a774 1
	print " .       FAIL(\"Unexpected character \`%c\' where </$tag> expected.\");\n" unless $mixed{$tag};
d783 1
a783 1
	print "$`IN_" . join(',IN_', map($ctag{$_}, keys %mixed)) . "$1$'";
d790 7
d814 1
a814 1
  close SCANNER;
d840 4
d895 1
d901 3
d906 3
d922 1
a922 1
[B<-dSHD>]
d924 1
a925 1
[B<-s>I<skel>]
d932 4
a935 5
documents.  From this I<flexml> produces a validating XML processor
for the DTD in the form of a I<flex>(1) scanner I<name>F<.l> with a
corresponding C header file I<name>F<.h>.  (Not all XML DTDs are
supported: see L</BUGS>Z<> for a description of what is not (yet)
implemented.)
d939 5
a943 1
from the XML processor.
d951 20
a970 1
=item B<-S -H -D>
d972 8
a979 3
These options make it explicit that only the scanner, header, and/or
(dummy) application files should be generated.  If none of them are
given the default is B<-SH> (except B<-a> below implies B<-A>).
d987 5
a991 1
=item B<-a>I<actions>
d993 1
a993 3
Uses the I<actions> file to produce an XML application in the file
with the same name as I<actions> after replacing the extension with
F<.c>.
a999 8
=item B<-s>I<skel>

Use the skeleton scanner I<skel> instead of the default.

=item B<-d>

Turns on debug mode in the flex scanner and also prints out a the
details of the DTD analysis performed by I<flexml>.
d1013 1
d1121 4
d1129 5
d1178 2
@


1.10
log
@Program and manpage done.
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.9 1999/11/23 17:28:07 krisrose Exp krisrose $ ';
d132 6
a137 3
    my ($tag,$attribute);
    ($tag,$attribute) = ($1,$2) if $ta =~ m.($Nmtoken)[/]($Nmtoken).o;
    print "typedef $typeof{$ta} AT_$ctag{$tag}_$catt{$attribute};\n";
d194 2
a195 2
$Use = "Usage: flexml [-dSHD] [-s skel] [-u uri] [-a actions] name[.dtd]";
use Getopt::Std; getopts('dSHDs:u:a:');
d201 3
d254 1
a254 1
until (eof DTD) {
d259 3
a261 1
  # Read until a full DTD <!...> entry is available in $_.
d276 1
a276 1
  # Parse the understood element declarations.
d283 1
a283 1
    # Create C-friendly variable names.
d316 1
a316 1
    # Repeat while there are attribute declarations.  Alert: large regexp...
a414 2


d443 1
a443 1
# Fix ANY tags.
a450 1

d572 1
d607 1
a607 1
            . '(' . "\\'" . $uri . "\\'" . '|' . '\"' . $uri . '\"' . ')'
d671 2
d677 1
d680 14
d696 2
a697 12
	    if ($fixed{"$tag/$attribute"}) {
		print " \"$attribute\"{Eq}\"'" . $attdef{"$tag/$attribute"} . "'\""
		    . " A_${myctag}_$catt{$attribute}"
		    . " = " . $initof{"$tag/$attribute"} . ";\n";
		print " \"$attribute\"{Eq}\"\\\"" . $attdef{"$tag/$attribute"} . "\\\"\""
		    . " A_${myctag}_$catt{$attribute}"
		    . " = " . $initof{"$tag/$attribute"} . ";\n";
	    }
	    else {
	      print " \"$attribute\"{Eq}\\' ENTER(VALUE1); BUFFERSET(A_${myctag}_$catt{$attribute});\n";
	      print " \"$attribute\"{Eq}\\\" ENTER(VALUE2); BUFFERSET(A_${myctag}_$catt{$attribute});\n";
	    }
d702 3
d819 1
a819 1
      if ( m/^void STag_($Name)\(void\)$/ ) {
d824 1
a824 1
      elsif ( m|^\} \/\* STag_($Name) \*\/$| ) {
d828 1
a828 1
      elsif ( m/^void ETag_($Name)\(void\)$/ ) {
d832 2
a833 3
      s/\{($Name)\}/A_$ctag{$tag}_$catt{$1}/xg if $tag;
      s/\{($Name)\/($Name)\}/ "A_$ctag{$tag}_$catt{$1}_" . variablify($2); /xge if $tag;
      s/([SE])Tag_($Name)/\1Tag_$ctag{$2}/xg;
d835 21
d912 6
d921 2
a922 1
with the same name as I<actions> after stripping the extension.
d972 3
a974 2
elements written C<{>I<attribute>C</>I<alt1>C<}>,
C<{>I<attribute>C</>I<alt2>C<}>, etc.
@


1.9
log
@Works but manual/paper still in flux...
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.8 1999/11/23 10:27:04 krisrose Exp krisrose $ ';
d210 2
a211 2
# Get base URI.
$baseuri = $opt_u if $opt_u;
d230 1
a230 1
$prefix = variablify("$prefix");
d505 1
a505 1
  print "#ifndef _FLEXML_${prefix}_H\n";
d551 1
a551 1
      print "const char* rcs_${prefix}_dtd =\n"
d597 2
d600 3
a602 5
	print ' "<!DOCTYPE"{S}' . $tag . '{S}'
	    . 'SYSTEM{S}('
	    . "\\'" . "$baseuri$DTD" . "\\'"
	    . '|\"' . "$baseuri$DTD" . '\"'
	    . '){s}">"' . " BEGIN(ROOT_$ctag{$tag});\n";
d834 1
a834 1
# DOCUMENTATION.
a836 1

d839 1
a839 1
flexml - Generate validating XML processor from XML DTD.
d845 3
a847 4
[B<-s> I<skel>]
[B<-u> I<uri>]
[B<-a> I<actions>]
[B<-p> I<prefix>]
d850 1
d852 11
a862 1
=head1 DESCRIPTION
d864 1
a864 2
Assume that we have an XML (Extensibe Markup Language) document
C<my-joke.xml> containing
d866 1
a866 16
  <!DOCTYPE joke SYSTEM "my.dtd">
  <joke><line>My appartment is so small</line> <suspense/>
   <line type='punch-line'>the mice are round-shouldered</line></joke>

which we wish to create an XML "processor" to validate it with respest
to the DTD (Document Type Definition) in the file C<my.dtd> containing

  <!-- Small DTD for jokes (just for fun). -->
  <!ELEMENT joke (line|pause)*>
  <!ELEMENT line (#PCDATA)>
   <!ATTLIST line type (normal|question|punch-line) 'normal'>
  <!ELEMENT suspense EMPTY>

and that we furthermore wish to write an XML "application" for
displaying it in an amusing way.  I<Flexml> can do this in the
following easy steps (see L</OPTIONS> for variations):
d870 1
a870 1
=item 1
d872 3
a874 1
We start by generating the XML processor from C<my.dtd> with the command
d876 1
a876 1
  flexml my.dtd
d878 2
a879 3
This creates two program files: a I<scanner>, C<my.l>, and an I<API
header>, C<my.h>.  (There are some restrictions on the facilities that
can be used in the DTD, detailed in L</BUGS>.)
d881 1
a881 1
=item 2
d883 2
a884 63
The program files are already in C except for the scanner for which we
must generate the C code with a I<flex>(1) command like

  flex -Bspp -omy.c my.l

to create C<my.c> (the flags sets up I<flex> to create a "batch"
scanner with no default "fall-back" rules and with maximal warnings
about problematic constructions in the scanner source).  If you prefer
C++ then you can use I<flex++> instead of I<flex>.

=item 3

Now we have an XML processor but we cannot run it without an XML
application.  Fortunately I<flexml> has a built-in "dummy" application
which we can get out with

  flexml -D my.dtd

into a file C<my-dummy.c>.  We can now compile our first XML application:

  gcc -Wall -ansi -pedantic -omy-dummy my-dummy.c my.c -lfl

which is able to anwer whether a document is validating or not:

  ./my-dummy <my-joke.xml

will succeed (silently) whereas



These three files constitute a complete validating XML processor
(which does not yet interact with an application, however).  You
compile this XML processor with something like

  gcc -Wall -ansi -pedantic my.c my-dummy.o -omy

to create the "my" executable (again you can use any ANSI C compiler
instead of I<gcc>(1) as long as the libraries it supports are
sufficiently close to the ANSI and POSIX standards).  Actually the
above will only command if you

=item 4

You can now test your new XML validator filter on some XML files:

  ./my < my-test.xml

The C<./my> command should be silent (and succeed) when the document
is valid and protest otherwise (failing).  (Again the present version
will, in fact, reject some valid documents and accept some invalid
ones: see the L</BUGS> section for the details.)  The program will,
for example succeed with the input 


=item 5

Now we are ready to start writing XML applications.  You do this by
writing so-called I<action files> that contain a mixture of C and XML
to explain what you wish your application to do.  This has the
advantage that it is easy to interface your program to just about
everything, and that it will run fast.  (The disadvantage, of course,
is that you will be forced to program at the rather low level offered
by C and C++.)  We will discuss this phase in detail after the L</OPTIONS>.
d886 1
a886 1
  gcc -Wall -ansi -pedantic my-application.c my.o -omy-application
d888 1
a888 21
=item 6

Finally you compile and run you application.  If the user has written
the action file C<my-test.act>, for example, then this is achieved
with the command

  flexml -a my-application.xml my.dtd

which produces the XML application program C<my-application.c> which
you can compile and link with the command

  gcc my-application.c my.o my-dummy.o -omy-application

=back




=head1 OPTIONS

=over 4
a894 20
=item B<-SHD>

These options make it explicit that only the scanner, header, and/or
(dummy) application files should be generated.  If none of them are
given the default is B<-SH>.

=item B<-s> I<skel>

Use the skeleton scanner I<skel> instead of the default
F</usr/share/flexml/skel>.

=item B<-u> I<uri>

Sets the URI of the DTD, used in the C<DOCTYPE> header, to the
specified I<uri>.

=item B<-a> I<actions>

Uses the I<actions> file to produce an XML application in the file with the same name as I<aktions> after stripping the extension.

d897 1
a897 1
=head1 Writing XML applications
d899 2
a900 2
The format of the action files is rather simple; in fact it obeys the
following DTD:
d902 1
a902 2
  <!-- DTD for FleXML "action" files. -->
  <!ELEMENT actions (top|start|end)*>
d905 2
a906 2
  <!ELEMENT start %C-code;>  <!ATTLIST start tag NMTOKEN>
  <!ELEMENT end   %C-code;>  <!ATTLIST end tag NMTOKEN>
d908 2
a909 1
(The "C<%C-code;>" parameter entity is just for readability.)
d911 5
a915 4
The idea is simple: the XML processor is a "filter" that receives your
XML data in a stream.  For each start tag (or empty tag) in your DTD
that wish to act on upon receival, say E<lt>C<joke>...E<gt>, you must
write an "action".
d917 1
a917 1
  <start tag = 'joke'><![CDATA[ ... ]]></start>
d919 1
a919 4
where the "C<...>" is the C code you wish to execute for this start
tag.  While executing a "start action" you have access to the values
of all I<attributes> stored by that tag, but for efficiency their C
type depends on their declaration.
d921 10
a930 2
Let us illustrate this with an example: Assume we are given the
following DTD for jokes.
d932 1
a932 1
  
d934 5
d940 1
d942 1
d944 4
d949 1
d951 3
a953 105




=head1 DESCRIPTION

I<Flexml> takes an input DTD (Document Type Definition) describing the
format of XML (eXtensible Markup Language) documents, together with an
I<actions> file with the desired actions for some of the elements.

It produces a collection of four files on the output: the actual I<XML
processor> is a I<flex>(1) scanner stored in I<name>F<.l> (by
default), the I<XML application interface> is defined by the header
I<name>F<.h> and a full set of empty interface functions is written
onto I<name>F<-dummy.c>, and finally the actions file, if given with
B<-a>, is used to instantiate the actual I<XML application> in the
file I<name>F<-actions.c>.












The simplest way to get I<flexml> to do its job is to use I<make>(1).
Here are some default rules that fit the operation of I<flexml>.

The first pattern rule explicits how scanners, headers, and dummy
files are created from the DTD.

  %.l %.h %-dummy.c: %.dtd
	$(FLEXML) $<

Generating an application file requires an action specification so we
do it seperately.

  %-actions.c: %.act
	$(FLEXML) -Aa $< $*

Generating the C source of the scanner involves I<flex>(1).

  %.c: %.l
	$(FLEX) -o$@@ $<

Finally a hairy rule for constructing a library archive with each of
the dummy functions as a separate entity: this ensures that we can
always link with this library to complete an incomplete set of
actions.  The important part is the last line where all the individual
dummy files are assembled into a library archive.

  %-dummy.a:  %-dummy.c
        $(RM) $*-dummy-*.c
        (cat $< | while read line; do \
            f=`expr "$$line" : '[a-z][a-z]* \([A-Za-z_]*\)(.*'`; \
            if [ -n "$$f" ]; then \
                echo $$line > $*-dummy-$$f.c &&\
                $(CC) -c $*-dummy-$$f.c; \
            fi; done)
        ar r $*-dummy.a $*-dummy-*.o

With this setup the following dependencies ensure that the XML
application I<joke> can be built.  First the four generated files:

  joke.l joke.h joke-dummy.c:  joke.dtd
  joke-actions.c:                joke.act joke.dtd

Then the further processing of the files (which is standard apart from
the creative library archive above).

  joke.c:         joke.l
  joke.o:         joke.c joke.h

  joke-dummy.a: joke-dummy.c joke.h

  joke-actions.o: joke-actions.c joke.h

  joke:           joke.o joke-actions.o joke-dummy.a

The compilers etc. were instantiated as follows

  CC = gcc -Wall -ansi -pedantic
  FLEX = flex -Bsp
  FLEXML = flexml

=head1 THE ACTIONS FILE

The actions file must be a valid XML document conforming to the DTD in
F</usr/doc/flexml/flexml-act.dtd>.  This is a very simple DTD that
just contains the following:





The individual text "actions" should contain C (or C++) source code:
the code in the C<top> element will be inserted directly in the source
file of the application, that of a C<start> becomes the action to
invoke for each start E<lt>I<tag>E<gt>, and similarly for the end
E<lt>C</>I<tag>E<gt>.  (Empty tags are treated identically to tags
with empty contents).  However, some special notations are available:
d957 1
a957 1
=item C<{>I<attribute>C<}>
d959 3
a961 2
Can be used in a C<start> element action to denotes the value of the
I<attribute> as set with I<attribute>C<=>I<value> in the E<lt>I<tag>.
d963 1
a963 1
If the attribute is declared as an enumerated type like
d965 1
a965 1
  <!ATTLIST attrib (alt | alt |...)*>
d967 1
a967 3
then the possible values are written
C<{>I<attribute>C</>I<alt>C<}>,
C<{>I<attribute>C</>I<alt>C<}> I<etc.>
d969 3
a971 1
Otherwise it is a null-terminated C string.
d973 2
a974 9
=item C<pcdata>

Can be used in the C<end> element action to denote the text of the
element when it had "Mixed" contents (if the element had "element"
contents then C<pcdata> is C<NULL>).  In case the Mixed contents
element actually mixed text and child elements then C<pcdata> contains
the plain concatenation of the text fragments.

=back
d978 1
a978 1
I<Flexml> is by design restricted to validate XML documents with a
d981 1
a981 1
  <!DOCTYPE root SYSTEM "uri/name.dtd">
d990 6
d1013 3
a1015 1
Only internal entities are handled.
d1019 3
a1021 15
In addition to this there are several minor restrictions on the form
of DTDs.  This is not so serious, however, as this will be known
before using the generated XML processor and applications.

Uptil now I have mostly experimented with generating C scanners but
I<flex> can also generate C++ scanners and this should not change much
in the working of I<flexml>..

But please consider I<flexml> as "late alpha" software.

=head1 SEE ALSO

Extensible Markup Language (XML) 1.0 (W3C Recommendation
REC-xml-1998-0210) C<http://www.w3.org/TR/REC-xml>, I<make>(1),
I<flex>(1).
d1027 1
a1027 1
=item /usr/share/flexml/skel
d1031 1
a1031 1
=item /usr/share/flexmlskeleton-dummy.c
d1033 1
a1033 1
The skeleton of the dummy handle file.
d1037 5
d1044 2
a1045 2
I<Flexml> Was Written By Kristoffer Hgsbro Rose.  I am grateful to
NTSys.fr for support of this work.
d1049 12
a1060 3
The program is distributed under GNU GPL ("copyleft").

=cut
@


1.8
log
@Ready for release of Debian version 0.0.
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.7 1999/11/23 10:10:36 krisrose Exp krisrose $ ';
d59 3
d122 2
a123 2
    print $pre . "void STag_$ctag{$tag}(void)$post\n";
    print $pre . "void ETag_$ctag{$tag}(void)$post\n";
d191 2
a192 2
$Use = "Usage: flexml [-dSHDA] [-s skel] [-u uri] [-a actions] [-p prefix] name[.dtd]";
use Getopt::Std; getopts('dSHDAs:u:a:p:');
d204 5
a208 2
# Change prefix for output files (if requested).
$prefix = $opt_p if $opt_p;
d213 1
a213 1
# Set skeleton scanner file name and check it is readable.
d215 1
a215 1
die "$0: No skeleton file $SKELETON.\n" if not -r $SKELETON;
d217 4
a220 2
# Set actions file name.
$ACTIONS = $opt_a if $opt_a;
d222 5
a226 9
# if neither of -S, -H, or -D given then pick defaults.
if ($opt_S or $opt_H or $opt_D or $opt_A) {
  $opt_A = true if $opt_a;
}
else {
  $opt_S = true;
  $opt_H = true;
  $opt_D = true;
  $opt_A = $opt_a;
a228 6
# Set output file names.
$SCANNER = "$prefix.l";
$HEADER =  "$prefix.h";
$DUMMIES = "$prefix-dummies.c";
$CALLBACKS = "$prefix-actions.c";

d236 1
d488 1
a488 33
# CREATE PROCESSOR DUMMY ACTIONS (if requested).


if ($opt_D) {
  open DUMMIES, "+>$DUMMIES";
  select DUMMIES;

  # Identification and license.
  print "/* XML processor dummy actions for $DTD";
  print ",\n * ($DTDrevision)" if $DTDrevision;
  print ".\n * Generated " . `date +'%Y/%m/%d %T.'`;
  print " *\n";
  redistribute(" *");
  print " */\n";
  print "\n";

  # Declarations.
  print "#include \"$HEADER\"\n";
  print "\n";

  # Dummy declaration of each function.
  api_functions('',' {}');

  # Output a dummy main program [sic].
  print "\n";
  print "/* Default main program. */\n";
  print "int main() { return yylex(); }\n";

  close DUMMIES;
}


# CREATE PROCESSOR HEADER (if requested).
d496 1
a496 1
  print "/* XML processor header for $DTD";
d521 2
a522 1
# WRITE XML PROCESSOR.
d535 1
a535 1
  print "/* XML processor for $DTD";
d770 1
d772 1
a772 1
# ACTIONS
a773 1
if ($opt_A) {
d775 4
a778 2
  open CALLBACKS, "+>$CALLBACKS";
  select CALLBACKS;
d781 3
a783 4
  print "/* XML processor actions from $ACTIONS.\n";
  print " * Fits with $DTD";
  print ", ($DTDrevision)" if $DTDrevision;
  print ".\n * Generated " . `date +'%Y/%m/%d %T.'`;
d793 4
a796 2
  # Get data from actions file.
  open ACTIONS, "/usr/lib/flexml-act $ACTIONS|";
d798 2
a799 2
  my ($tag,$attribute);
  my @@myattributes;
d801 1
a801 1
  while (<ACTIONS>) {
d803 12
a814 8
    if ( m/^void STag_($Name)\(void\)$/ ) {
      $tag = $1;
      @@myattributes = split /,/,"$withattr{$tag}";
    }
    elsif ( m|^\} \/\* STag_($Name) \*\/$| ) {
      $tag = undef;
      @@myattributes = ();
    }
d816 3
a818 3
    s/\{($Name)\}/A_$ctag{$tag}_$catt{$1}/xg if $tag;
    s/\{($Name)\/($Name)\}/ "A_$ctag{$tag}_$catt{$1}_" . variablify($2); /xge if $tag;
    s/([SE])Tag_($Name)/\1Tag_$ctag{$2}/xg;
d820 1
a820 1
    print $_;
d822 2
d826 4
a829 2
  close ACTIONS;
  close CALLBACKS;
d832 1
d835 1
a836 1
=pod
d845 1
a845 1
[B<-dSHDA>]
d852 1
d855 116
a970 3
I<Flexml> takes an input DTD (Document Type Definition) describing the
format of XML (eXtensible Markup Language) documents, together with an
I<actions> file with the desired actions for some of the elements.
a971 7
It produces a collection of four files on the output: the actual I<XML
processor> is a I<flex(1)> scanner stored in I<name>F<.l> (by
default), the I<XML application interface> is defined by the header
I<name>F<.h> and a full set of empty interface functions is written
onto I<name>F<-dummies.c>, and finally the actions file, if given with
B<-a>, is used to instantiate the actual I<XML application> in the
file I<name>F<-actions.c>.
d982 1
a982 1
=item B<-SHDA>
d984 3
a986 2
These options make it explicit that only the scanner, header, dummies,
and/or application files should be generated (the default is B<-SHD>).
d1000 64
a1063 2
Uses the I<actions> file to produce an XML application (implies the
B<-A> option).  See the section I<The Actions File> below.
a1064 1
=item B<-p> I<prefix>
a1065 3
Use the I<prefix> instead of I<name> for all produced output files
(useful in conjunction with B<-a> because one can then reuse the
scanner, header, and dummies, because they only depend on the DTD).
a1066 1
=back
a1067 1
=head1 OPERATION
d1069 1
a1069 1
The simplest way to get I<flexml> to do its job is to use I<make(1)>.
d1075 1
a1075 1
  %.l %.h %-dummies.c: %.dtd
d1084 1
a1084 1
Generating the C source of the scanner involves I<flex(1)>.
d1095 2
a1096 2
  %-dummies.a:  %-dummies.c
        $(RM) -f $*-dummies-*.c
d1100 2
a1101 2
                echo $$line > $*-dummies-$$f.c &&\
                $(CC) -c $*-dummies-$$f.c; \
d1103 1
a1103 1
        ar r $*-dummies.a $*-dummies-*.o
d1108 1
a1108 1
  joke.l joke.h joke-dummies.c:  joke.dtd
d1117 1
a1117 1
  joke-dummies.a: joke-dummies.c joke.h
d1121 1
a1121 1
  joke:           joke.o joke-actions.o joke-dummies.a
a1134 1
  <!ELEMENT actions (top|start|end)*>
a1135 1
  <!ELEMENT top (#PCDATA)>
a1136 2
  <!ELEMENT start (#PCDATA)>
  <!ATTLIST start tag NMTOKEN>
a1137 2
  <!ELEMENT end (#PCDATA)>
  <!ATTLIST end tag NMTOKEN>
d1221 2
a1222 2
REC-xml-1998-0210) C<http://www.w3.org/TR/REC-xml>, I<make(1)>,
I<flex(1)>.
d1232 1
a1232 1
=item /usr/share/flexmlskeleton-dummies.c
d1234 1
a1234 1
The skeleton of the dummies handle file.
d1240 1
a1240 1
I<FlexML> was written by Kristoffer Hgsbro Rose.  I am grateful to
@


1.7
log
@Spellling mistakes fixed...
@
text
@d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.6 1999/11/23 09:32:31 krisrose Exp krisrose $ ';
d208 1
a208 1
$SKELETON = ($opt_s ? $opt_s : "/usr/share/flexml.skel");
d903 1
a903 1
F</usr/share/flexml.skel>.
d1090 1
a1090 1
=item /usr/share/flexml.skel
@


1.6
log
@Documentation updated.
@
text
@d6 1
a6 1
# This file is part of the FleXML XML processer generator system.
d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.5 1999/11/23 04:03:05 krisrose Exp krisrose $ ';
d96 1
a96 1
$pre This program was generated with the FleXML XML processer generator,
a1032 4
=item C<cookie(>I<>C<)>

A child can be 

d1057 5
d1073 6
@


1.5
log
@Works for simple examples
@
text
@a6 1
# See the companion README and INSTALL files for further information.
d23 1
a23 1
$Id = '$Id: flexml.pl,v 1.4 1999/11/23 02:37:11 krisrose Exp krisrose $ ';
d226 4
a229 4
$SCANNER = "$prefix.l" if $opt_S;
$HEADER =  "$prefix.h" if $opt_H;
$DUMMIES = "$prefix-dummies.c" if $opt_D;
$CALLBACKS = "$prefix-actions.c" if $opt_A;
d492 1
a492 1
if ($DUMMIES) {
d524 1
a524 1
if ($HEADER) {
d556 1
a556 1
if ($SCANNER and $SKELETON) {
d805 1
a805 1
if ($CALLBACKS) {
d825 1
a825 1
  open ACTIONS, "/usr/lib/flexml-act <$ACTIONS|";
d832 1
a832 1
    if ( m/^void STag_($Name)\(void\)$/xo ) {
d834 1
a834 1
      @@myattributes = split /,/,"$attlist{$tag}";
d836 1
a836 1
    elsif ( m/^void STag_($Name)\(void\)$/xo ) {
d841 6
a846 3
    s/\$([A-Za-z][A-Za-z0-9_]*)/A_$ctag{$tag}_$catt{$1}/xg;
    s/\$\{([A-Za-z][A-Za-z0-9_]*)\}/A_$ctag{$tag}_$catt{$1}/xg;
    print;
d856 2
d865 1
a865 1
[B<-dSHD>]
d870 1
a870 1
I<name>[C<.dtd>]
d875 12
a886 4
format of XML (eXtensible Markup Language) documents; this is assumed
to be in the file I<name>C<.dtd>.  The output is the L<flex(1)> source
file I<name>C<.l> that implements an I<XML processor> which will call
the following functions (that must be provided by the user):
d890 19
a908 1
=item C<void STag_>I<tag>C<(void)>
d910 1
a910 2
Called when the start-tag E<lt>I<tag>...E<gt> has been recognised.
The attributes are available
d912 2
a913 1
=item C<void ETag_>I<tag>C<(void)>
d915 5
a919 3
Called when the E<lt>C</>I<tag>E<gt> end-tag has been read.  If the
tag is of Mixed contents type then C<pcdata> string contains the
contents of all text in the element (otherwise C<pcdata> is C<NULL>).
d923 46
a968 2
You must generate the C-code od the XML processor with L<flex(1)> as
well as link with appropriate actions.
d970 2
d973 1
d975 32
a1006 1
=head1 OPTIONS
d1010 6
a1015 1
=item [B<-d>]
d1017 1
a1017 3
Generate a C source file I<name>C<-dummies.c> with dummy handlers for
all call-backs (that merely print the handled tag or attribute to
I<stdout>).
d1019 3
a1021 1
=item [B<-S> I<skel>C<.l>]
d1023 1
a1023 1
Use the skeleton scanner I<skel>C<.l> instead of the default.
d1025 1
a1025 1
=item [B<-o> I<name>C<.l>]
d1027 9
a1035 2
Write the generated scanner to I<name>C<.l> instead of to the name
obtained by replacing C<.dtd> with C<.l> in the DTD file name.
d1041 11
a1051 1
I<Flexml> only accepts DTDs with lines of the forms
d1053 1
a1053 4
	<!ELEMENT tag EMPTY>
	<!ELEMENT tag (#PCDATA)>
	<!ELEMENT tag (tag1|tag2|...|tagn)*>
	<!ATTLIST tag attribute CDATA>
d1055 1
a1055 2
plus internal entity declarations (and comments, of course) of the
forms
d1057 11
a1067 1
	<!ENTITY % name "string">
d1069 9
a1077 3
In fact it I<ignores> any lines not in this form (a rather serious
limitation).  A tag may be split over several lines but I<flexml> does
not handle several elements on a line.
d1083 1
a1083 1
=item /usr/lib/flexml/skeleton.l
d1087 1
a1087 1
=item /usr/lib/flexml/skeleton-dummies.c
d1095 2
a1096 1
Kristoffer Hgsbro Rose sponsored by NTSys.fr.
@


1.4
log
@Works except for seq element contents and the action generation.
@
text
@d24 1
a24 1
$Id = '$Id: flexml.pl,v 1.3 1999/11/22 18:41:48 krisrose Exp krisrose $ ';
d189 2
a190 2
$Use = "Usage: flexml [-dSHD] [-s skel] [-u uri] [-a actions] [-p prefix] name[.dtd]";
use Getopt::Std; getopts('dSHs:u:a:p:');
d216 2
a217 2
if ($opt_S or $opt_H or $opt_D) {
  die "$0: -a conflicts with -H.\n" if $opt_a and $opt_H;
d221 1
a221 1
  $opt_H = true unless $opt_a;
d223 1
d230 1
a230 1
$CALLBACKS = "$prefix-actions.c" if $opt_a;
d361 1
a361 1
	  s/$Nmtoken/ "AA_$ctag{$tag}_$catt{$attribute}_" . variablify($&) /xge;
d367 1
a367 1
	    $initof{"$tag/$attribute"} = "AA_$ctag{$tag}_$catt{$attribute}_" . variablify($default);
d585 3
a587 1
	  . " \"\$\" \"$DTDrevision\$\";\n" if $DTDrevision;
d611 16
d691 1
a691 1
		    . " = AA_${myctag}_$catt{$attribute}_" . variablify($alternative) . ";\n";
d695 1
a695 1
		    . " = AA_${myctag}_$catt{$attribute}_" . variablify($alternative) . ";\n";
d765 2
d826 1
a826 1
  open ACTIONS, "$FLEXMLACT $ACTIONS|";
d828 18
a848 2


@


1.3
log
@Working like mad...
@
text
@d24 2
a25 2
$Id = '$Id: flexml.pl,v 1.2 1999/11/08 03:21:12 krisrose Exp krisrose $ ';
$Id =~ s/\$//go;
d32 1
a32 2
%source = ();	# DTD source lines associated to tag and tag/attribute
                # pairs. 
d42 1
d51 2
a52 1
%enumtype = (); # whether the tag/attribute is an enumeration
a66 1
%entitysource = (); # - source
a68 1
%parametersource = (); # - source
d75 7
a81 4
sub indent { # Indent all lines of the argument by four spaces.
  local ($_) = @@_;
  s/^/  * /mg;
  " /* " . $_ . " */\n";
d104 1
a104 1
$pre 1. The program is distributed WITHOUT ANY WARRANTY from the author(s) of
d116 1
a116 1
  local ($pre) = @@_;
d120 2
a121 2
    print $pre . "void STag_$ctag{$tag}(void);\n";
    print $pre . "void ETag_$ctag{$tag}(void);\n";
a122 1
  print $pre . "void partial_pcdata(void);\n";
d163 1
a163 1
      if ( s/^\'[^']*\'|^\"[^"]\"|^%\s+|^[^%"']//o ) {
d173 1
a173 1
	die "Messy line: \`$line$_\'.\n";
d180 1
a180 1
  $_;
d189 1
a189 1
$Use = "Usage: flexml [-dSH] [-s skel] [-u uri] [-a actions] [-p prefix] name[.dtd]";
a213 1
die "$0: -a implies -S and conflicts with -H.\n" if $opt_a and $opt_H;
d215 15
a229 3
# Set output scanner and header file names.
$SCANNER = "$prefix.l" if not $opt_H or $opt_a;
$HEADER =  "$prefix.h" if not $opt_S and not $opt_a;
d290 3
d295 1
a295 3
      }
      if ($1) {
	$mixed{$tag} = true;
d315 1
a315 1
      if ($source{"$tag/$attribute"}) {
d319 4
a322 1
	$source{"$tag/$attribute"} = "$orig";
a337 1
	$attdef{"$tag/$attribute"} = $default if $default;
d342 6
a347 2
	elsif ($default =~ s/\#FIXED\s+//) {
	  $fixed{"$tag/$attribute"} = true;
a348 1
	$default =~ s/^'([^'']*)'$/\1/o unless $default =~ s/^"([^""]*)"$//;
d350 2
a351 1
	# Store attribute type.
d353 8
a360 3
	if (substr("$type",0,1) eq "(") {
	  local $_ = $type;
	  $enumtype{"$tag/$attribute"} = true;
d362 3
a364 6
	  s/\s*\|\s*/, /go;
	  s/$Nmtoken/ "AA_$ctag{$tag}_$catt{$attribute}_" . variablify($&) /xge;
	  s/^\(\s*/enum \{ $undefined, /o;
	  s/\s*\)$/ \}/o;
	  $type = $_;
	  $typeof{"$tag/$attribute"} = "$type";
d372 1
d381 24
d419 1
a419 1
    $parametersource{"%$1;"} = "$orig";
d425 1
a425 1
    $entitysource{"&$1;"} = "$orig";
d468 1
d473 2
d485 18
a502 1
  print '%entitysource = (' . printhash(entitysource) . ")\n";
d504 14
a517 2
  print '%parameter = (' . printhash(parameter) . ")\n";
  print '%parametersource = (' . printhash(parametersource) . ")\n";
d540 1
a540 1
  api_functions("extern ");
d542 4
a545 1
  api_data("extern ");
d554 1
a554 1
# WRITE XML PROCESSOR BASED ON SCANNER AND MAYBE ACTIONS.
a568 1
  print ";\n * with application actions from $ACTIONS" if $ACTIONS;
d581 1
a581 1
	  . " \"\$\" \"$Id\$\";\n";
d589 10
a598 6
      if ($HEADER) {
	print "/* XML processor interface. */\n";
	print "#include \"$HEADER\"\n";
	print "\n";
      }
      api_data("");
d604 2
a605 1
	print "%x ROOT_$tag AL_$tag IN_$tag\n";
d616 1
a616 1
	    . '){S}?">"' . " BEGIN(ROOT_$tag);\n";
d623 2
a624 5
      if (keys %parametersource) {
	print "\n";
	foreach $ent (keys %parametersource) {
	  print indent($parametersource{$ent});
	}
d630 1
d634 5
a638 3
	# Tag's source element.
	print "\n";
	print indent($source{$tag});
d642 3
a644 4
	print "<ROOT_$tag";
	foreach $intag (split /,/,"$intags{$tag}") { print ",IN_$intag"; }
	print ">\"<$tag\"{S}? {\n";
	print "  BUFFERINIT;\n";
d646 1
a646 3
	  if ($atttype{"$tag/$attribute"} eq "CDATA") {
	    print "  A_$ctag{$tag}_$catt{attribute} = " . $initof{"$tag/$attribute"} . ";\n";
	  }
d648 1
a648 10
	print "  ENTER(AL_$tag);\n";
	print "}\n";

	# Errors when expecting root tag.
	print "\n";
	print "<ROOT_$tag>{\n";
	print " \"<!--\"  ENTER(COMMENT);\n";
	print " {S}     SKIP;\n";
	print " .       FAIL(\"$tag root element.\");\n";
	print " <<EOF>> FAIL(\"EOF in prolog.\");\n";
d653 1
a653 1
	print "<AL_$tag>{\n";
d656 29
a684 4
	  print "\n";
	  print indent($source{"$tag/$attribute"});
	  if ($enumtype{"$tag/$attribute"}) {
	    print " /* ENUM TYPEM TO BE DEFINED */\n";
d687 12
a698 2
	    print " \"$attribute\"{Eq}\\' ENTER(VALUE1); BUFFERSET(A_$ctag{$tag}_$catt{$attribute});\n";
	    print " \"$attribute\"{Eq}\\\" ENTER(VALUE2); BUFFERSET(A_$ctag{$tag}_$catt{$attribute});\n";
d704 4
a707 8
	print " \">\"  LEAVE(AL_$tag); STag_$tag(); BUFFERINIT;";
	if ($mixed{$tag}) {
	  print " BUFFERSET(pcdata);";
	}
	else {
	  print " pcdata = NULL;"
	}
	print " ENTER(IN_$tag);\n";
d710 4
a713 8
	print " \"/>\" LEAVE(AL_$tag); STag_$tag(); BUFFERINIT;";
	if ($mixed{$tag}) {
	  print " pcdata = \"\";";
	}
	else {
	  print " pcdata = NULL;"
	}
	print " ETag_$tag(); CHECKEPILOG($tag);\n";
d721 8
d736 1
d738 7
a744 4
	print "<IN_$tag>{\n";
	print " \"</$tag\"{S}?\">\" LEAVE(IN_$tag);"
	    . ($mixed{$tag} ? " BUFFERDONE;" : "")
	    . " ETag_$tag(); CHECKEPILOG($tag);\n";
d755 1
a755 1
	print "$`IN_" . join(',IN_', keys %mixed) . "$1$'";
d758 1
a758 1
	print "$`DISABLE$comma$'";
d766 1
a766 2
	print "\n";
	print indent($entitysource{$ent});
d779 7
d787 12
a798 2
  # Add actions if requested.
  if ($ACTIONS) {
d800 10
a809 5
    open ACTIONS;
    while (<ACTIONS>) {
      print if /<actions>/;
    }
    close ACTIONS;
a810 1
  }
a811 1
  close SCANNER;
a813 1

a816 1

d819 1
a819 1
flexml - Generate flex(1) scanner from XML DTD.
d824 4
a827 1
[B<-s> I<skeleton-scanner>]
a828 1
[B<-o> I<name>C<.l>]
d834 4
a837 4
format of XML (eXtensible Markup Language) documents; this is assumed to
be in the file I<name>C<.dtd>.  The output is the L<flex(1)> source file
I<name>C<.l> where you have to provide the definitions of the
following call-back "handlers":
d841 1
a841 1
=item C<STag_>I<tag>C<(void)>
d843 2
a844 2
Called when the start-tag E<lt>I<tag>...E<gt> has been recognised but
before any attributes or contents have been read.
d846 1
a846 1
=item C<A_>I<tag>C<_>I<attribute>C<(char* value)>
d848 3
a850 2
Called for each I<attribute>C<=">I<value>C<"> attribute definition in
the I<tag>.
d852 4
a855 1
=item C<ETag_>I<tag>C<(char* pcdata)>
a856 4
Called when the E<lt>C</>I<tag>E<gt> end-tag has been read.  If the
tag is of type C<(#PCDATA)> then the C<pcdata> parameter is bound to
the contents as a string (with entities decoded), otherwise the
parameter is C<NULL>.
a857 1
=back
@


1.2
log
@ZzZzZzZ.
@
text
@d3 2
a4 2
# FleXML: fast lexical XML scanning.
# Copyright  1999 Kristoffer H. Rose.  All rights reserved.
d6 3
a8 4
# Description:	Translate DTD to flex(1) scanner
# Author:	Kristoffer Rose
# Created:	September 1999
# License:	GNU GPL ("copyleft")
d10 4
a13 4
#   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 2 of the License, or
#   (at your option) any later version.
d15 4
a18 4
#   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.
d20 3
a22 12
#   You should have received a copy of the GNU General Public License
#   along with this program; if not, write to the Free Software
#   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

$Header = '$Header: /plume/yquem/home/krisrose/cons/FleXML/RCS/flexml.pl,v 1.1 1999/10/26 16:19:45 krisrose Exp krisrose $'; #'sic
$Header =~ s/^\$//;

# Options processing.

$Usage = "Usage: flexml [-d] [-S skel.l] [-P prefix] name[.dtd]";
use Getopt::Std; getopts('dS:P:');
if ($#ARGV != 0) { die $Usage; }
d24 2
a25 4
$prefix = $ARGV[0];
$prefix =~ s/\.dtd$//;
$DTD = "$prefix.dtd";
die "$0: No DTD file $DTD.\n" if not -r $DTD;
a26 1
$prefix = $opt_P if $opt_P;
d28 2
a29 2
$SKELETON = ($opt_S ? $opt_S : "/usr/lib/flexml/skeleton.l");
die "$0: No skeleton file $SKELETON.\n" if not -r $SKELETON;
a30 7
$SKELETON_H = $SKELETON;
$SKELETON_H =~ s/\.l$/.h/;
die "$0: No skeleton file $SKELETON_H.\n" if not -r $SKELETON_H;

$SCANNER = "$prefix.l";
$HEADER =  "$prefix.h";
$DUMMIES = ($opt_d ? "$prefix-dummies.c" : "");
d32 2
a33 1
# Initialise structures.
d36 28
a63 5
%source = ();	# DTD source lines associated to tag and tag/attribute pairs.
%mixed = ();	# $mixed{tag} == true if the tag is a mixed tag.
%attlist = ();	# $attlist{tag} is comma-separated list of attribute names.
%parsed = ();	# parsed entity table
%parsedsource = (); # parsed entity source lines
d65 2
a66 1
# Open DTD and extract information.
d68 22
a89 1
open DTD;
a90 1
while (<DTD>) {
d92 19
a110 1
  chomp;
a111 3
  # Erase up till <! and append up till >.
  next unless s/^([^<]|<[^!])*<!/<!/;
  local $orig = $_;
d113 7
a119 4
  while (not eof DTD and not m/^<![^>]*>/) {
    local $line = <DTD>; chomp $line;
    $_ .= " " . $line;
    $orig .= "\n" . $line;
d121 3
d125 7
a131 9
  # Expand all parsed entities until none left (beware of cycles :)
  local @@entities = keys %parsed;
  local $count = $#entities + 1;
  while ($count > 0) {
    local $test = 0;
    foreach $ent (@@entities) {
      $test = $count if s/$ent/$parsed{$ent}/g;
    }
    $count = $test - 1;
d133 5
d139 6
a144 29
  # Parse the understood element types.
  if ( /<!ELEMENT\s+([a-zA-Z:_.-]+)\s+(EMPTY|\(\s*\#PCDATA\s*\))\s*>/ ) {
    die "Repeated element $1.\n" if $source{$1};
    push @@tags, $1;
    $mixed{$1} = true;
    $source{$1} = "/* $orig */\n";
  }
  elsif ( /<!ELEMENT\s+([a-zA-Z:_.-]+)\s+[a-zA-Z:_.-|(),* ]+\s*>/ ) {
    die "Repeated element $1.\n" if $source{$1};
    push @@tags, $1;
    $source{$1} = "/* $orig */\n";
  }
  elsif ( /<!ELEMENT\s+[^>]*>/ ) {
    die "$0: unsupported $orig";
  }
  elsif ( /<!ATTLIST\s+([a-zA-Z:_.-]+)\s+([a-zA-Z:_.-]+)\s+CDATA(\s+\#[A-Z]+)?\s*>/ ) {
    $attlist{$1} .= ($attlist{$1} ? "," : "") . "$2";
    $source{"$1/$2"} = "/* $orig */\n";
  }
  elsif ( /<!ATTLIST\s+[^>]*>/ ) {
    die "$0: unsupported $orig";
  }
  elsif ( /<!ENTITY\s+%\s+([a-zA-Z:_.-]+)\s+"([^>]*)"\s*>/ ) {
    $parsed{"%$1;"} = "$2";
    $parsedsource{"%$1;"} = "/* $orig */\n";
  }
  elsif ( /<!ENTITY\s+([a-zA-Z:_.-]+)\s+"([^>]*)"\s*>/ ) {
    $parsed{"&$1;"} = "$2";
    $parsedsource{"&$1;"} = "/* $orig */\n";
a145 5
  elsif ( /[\$]Header: [^\$]*\$/ ) {
    $DTDrevision = "$&";
    $DTDrevision =~ s/^\$//;
  }

a147 1
close DTD;
d149 1
a149 1
# Indenting
a150 1
sub indent {
d152 27
a178 1
  s/^/    /mg;
a181 1
# Copy skeleton scanner header to output scanner with substitutions.
d183 58
a240 1
if ($HEADER) {
d242 14
a255 3
  open SKELETON_H;
  open HEADER, "+>$HEADER";
  select HEADER;
d257 6
a262 1
  while (<SKELETON_H>) {
d264 2
a265 1
    if ( /^FLEXML_IFDEF$/ ) {
d267 1
a267 1
      print "#ifdef _FLEXML_${prefix}_H\n"
d269 18
d288 1
a288 1
    elsif ( /^FLEXML_TOPMATTER$/ ) {
d290 2
a291 5
      print " * This file instantiated for FleXML scanner for $DTD.\n"
	  . " * Generated " . localtime() . ".\n";
       
    }
    elsif ( /^FLEXML_VERSION$/ ) {
d293 2
a294 2
      print "static char* rcs_flexml = \"\$\"\n"
          . "\"$Header\";\n";
d296 3
a298 3
      print "\n"
	  . "static char* rcs_${prefix}_dtd = \"\$\"\n"
	  . "\"$DTDrevision\";\n" if $DTDrevision;
d300 1
a300 2
    }
    elsif ( /^FLEXML_API$/ ) {
d302 2
a303 9
      print "\n";
      print "/* User-defined functions. */\n";
      foreach $tag (@@tags) {
	print "#ifndef STag_$tag\n";
	print "extern void STag_$tag(void);\n";
	print "#endif\n";
	print "#ifndef ETag_$tag\n";
	print "extern void ETag_$tag(void);\n";
	print "#endif\n";
d305 2
d308 51
a358 6
      print "\n";
      print "/* FleXML-provided data. */\n";
      print "extern char* pcdata;\n";
      foreach $tag (@@tags) {
	foreach $attribute (split ",","$attlist{$tag}") {
	  print "extern char* Attribute_${attribute};\n";
d360 5
d366 15
d382 11
a392 5
    }
    else {
      s/^"\$Header/"\$" "Header/;
      print;
    }
d394 3
d398 69
a467 1
  close SKELETON_H;
a470 1
# Copy skeleton scanner to output with substitutions.
d472 4
a475 1
if ($SCANNER) {
a476 1
  open SKELETON;
d480 4
a483 1
  while (<SKELETON>) {
d485 9
a493 1
    if ( /^FLEXML_TOPMATTER$/ ) {
d495 2
a496 2
      print " * This file instantiated as FleXML scanner for $DTD.\n"
	  . " * Generated " . localtime() . ".\n";
d498 1
a498 2
    }
    elsif ( /^FLEXML_VERSION$/ ) {
d500 2
a501 2
      print "static char* rcs_flexml = \"\$\"\n"
          . "\"$Header\";\n";
d503 2
a504 3
      print "\n"
	  . "static char* rcs_${prefix}_dtd = \"\$\"\n"
	  . "\"$DTDrevision\";\n" if $DTDrevision;
d509 4
a512 10
      print "/* User-defined functions. */\n";
      print "#include \"$HEADER\"\n";

      print "\n";
      print "/* FleXML-provided data. */\n";
      print "char* pcdata;\n";
      foreach $tag (@@tags) {
	foreach $attribute (split ",","$attlist{$tag}") {
	  print "char* Attribute_${attribute};\n";
	}
d514 1
d520 1
a520 4

	print "%x AL_$tag\n";
	print "%s IN_$tag\n" if not $mixed{$tag} ;

d524 1
a524 1
    elsif ( /^FLEXML_DOCTYPE$/ ) {
d526 7
a532 5
      print ' "<!DOCTYPE"{S}{Name}{S}"SYSTEM"{S}\"'
	  . $DTD
	  . '\"{S}">" |' . "\n";

      # Todo: {Name} must be root element.
d537 2
a538 2
      # Dump all parsed entity declarations.
      if (keys %parsedsource) {
d540 2
a541 2
	foreach $ent (keys %parsedsource) {
 	  print indent($parsedsource{$ent});
d545 1
d548 2
a549 1
	local @@tagatts = split ",","$attlist{$tag}";
d555 1
a555 1
	# Start tag begins with <tag.
d557 8
a564 3
	print "\"<$tag\"{s} {\n";
	foreach $attribute (@@tagatts) {
	  print "  Attribute_${attribute} = NULL;\n";
a565 1
	print "  BUFFERINIT;\n";
d569 14
a582 2
	# Save each encountered permitted attribute.
	foreach $attribute (@@tagatts) {
d585 7
a592 8
	  print "<AL_$tag>\"$attribute\"{Eq}\\' {\n";
	  print "  ENTER(VALUE1);\n";
	  print "  BUFFERSET(Attribute_$attribute);\n";
	  print "}\n";
	  print "<AL_$tag>\"$attribute\"{Eq}\\\" {\n";
	  print "  ENTER(VALUE2);\n";
	  print "  BUFFERSET(Attribute_$attribute);\n";
	  print "}\n";
d594 3
a596 9

	# Start tag is done so call start tag action and pass into
	# PCDATA state for mixed contents or the appropriate element
	# state for element contents.
	print "\n";
	print "<AL_$tag>\">\" {\n";
	print "  LEAVE(AL_$tag);\n";
	print "  STag_$tag();\n";
	print "  BUFFERINIT;\n";
d598 1
a598 2
	  print "  BUFFERSET(pcdata);\n";
	  print "  ENTER(PCDATA);\n";
d601 1
a601 2
	  print "  pcdata = NULL;\n";
	  print "  ENTER(IN_$tag);\n";
d603 4
a606 4
	print "}\n";

	# End tag encountered.
	print "\n";
d608 1
a608 2
	  print "<PCDATA>\"</$tag\"{s}\">\" {\n";
	  print "  LEAVE(PCDATA);\n";
d611 1
a611 2
	  print "<IN_$tag>\"</$tag\"{s}\">\" {\n";
	  print "  LEAVE(IN_$tag);\n";
d613 6
a618 1
	print "  ETag_$tag();\n";
d621 7
a627 1
	# Special case for EMPTY tags.
d629 7
a635 5
	print "<AL_$tag>\"/>\" {\n";
	print "  LEAVE(AL_$tag);\n";
	print "  STag_$tag();\n";
	print "  pcdata = NULL;\n";
	print "  ETag_$tag();\n";
d637 14
d652 5
d661 1
a661 1
      s/^"\$Header/"\$" "Header/;
a667 10
  close SCANNER;
}


# Copy skeleton dummy handlers to dummy output if requested.

if ($DUMMIES) {

  local $DUMMYSKELETON = $SKELETON;
  $DUMMYSKELETON =~ s/\.l$/-dummies.c/;
d669 2
a670 10
  open DUMMYSKELETON;
  open DUMMIES, "+>$DUMMIES";
  select DUMMIES;

  while (<DUMMYSKELETON>) {

    if ( /^FLEXML_TOPMATTER$/ ) {

      print " * Note: this file instantiated with dummies for $DTD.\n"
          . " * Generated " . localtime() . ".\n";
d672 3
d676 1
a676 1
    elsif ( /^FLEXML_VERSION$/ ) {
d678 1
a678 2
      print "static char* rcs_flexml = \"\$\"\n"
          . "\"$Header\";\n";
d680 2
a681 3
      print "\n"
	  . "static char* rcs_${prefix}_dtd = \"\$\"\n"
	  . "\"$DTDrevision\";\n" if $DTDrevision;
a682 22
    }
    elsif ( /^FLEXML_API$/ ) {

      print "/* User-defined functions. */\n";
      print "#include \"$HEADER\"\n";

    }
    elsif ( /^FLEXML_DUMMIES$/ ) {

      if (keys %parsedsource) {
	foreach $ent (keys %parsedsource) {
 	  print $parsedsource{$ent};
	}
	print "\n";
      }

      foreach $tag (@@tags) {
	print "\n";
	print "$source{$tag}";
	foreach $attribute (split ",","$attlist{$tag}") {
	  print $source{"$tag/$attribute"};
	}
d684 2
a685 23
	print "\n"
	    . "void STag_$tag(void)\n"
	    . "{\n"
	    . "    FLEXML_DUMMY_STag(\"$tag\");\n";

	foreach $attribute (split ",","$attlist{$tag}") {
	  print "    FLEXML_DUMMY_Attribute(${attribute});\n";
	}	  
	print "}\n";
	print "\n";
	print "void ETag_$tag(void)\n"
	    . "{\n"
	    . "    FLEXML_DUMMY_ETag(\"$tag\",pcdata);\n"
	    . "}\n";
      }

    }
    else {
      s/^\$Header/\$" "Header/;
      print;
    }
  }
}
a687 2
# Finally the documentation.

d694 5
a698 1
B<flexml> [B<-d>] [B<-S> I<skel>C<.l>] [B<-o> I<name>C<.l>] I<name>[C<.dtd>]
d703 1
a703 1
format of XML (eXtended Markup Language) documents; this is assumed to
d715 1
a715 1
=item C<Attribute_>I<tag>C<_>I<attribute>C<(char* value)>
d759 8
a766 4
plus simple parsed entity declarations (and comments, of
course).  In fact it I<ignores> any lines not in this form (a rather
serious limitation).  A tag may be split over several lines but
I<flexml> does not handle several elements on a line.
@


1.1
log
@Initial revision
@
text
@d25 1
a25 1
$Header = '$Header: /var/cvsroot/ntsys/FleXML/flexml.pl,v 1.20 1999/09/14 20:47:09 krisrose Exp $'; #'sic
d30 2
a31 3
$Usage = "Usage: flexml [-d] [-S skel.l] [-o name.l] name[.dtd]";

use Getopt::Std; getopts('dS:o:');
a35 1

d39 2
d44 6
a49 1
$SCANNER = ($opt_o ? $opt_o : "$prefix.l");
d56 4
a59 4
%leaf = ();	# $leaf{tag} == true if the tag is a leaf tag.
%attlist = ();	# $attlist{tag} is list of attribute names.
%entity = ();	# entity table
%entitysource = (); # entity source lines
d79 2
a80 2
  # Expand all declared entities until none left (beware of cycles :)
  local @@entities = keys %entity;
d85 1
a85 1
      $test = $count if s/$ent/$entity{$ent}/g;
d94 1
a94 1
    $leaf{$1} = true;
d106 1
a106 1
    $attlist{$1} .= " $2";
d112 4
d117 2
a118 6
    $entity{"&$1;"} = "$2";
    $entitysource{"&$1;"} = "/* $orig */\n";
  }
  elsif ( /<!ENTITY\s+%\s+([a-zA-Z:_.-]+)\s+"([^>]*)"\s*>/ ) {
    $entity{"%$1;"} = "$2";
    $entitysource{"%$1;"} = "/* $orig */\n";
d137 66
a202 1
# Copy skeleton scanner to output scanner with substitutions.
d228 1
a228 1
    elsif ( /^FLEXML_HANDLER_DECLARATIONS$/ ) {
d230 6
d237 2
a238 8

	print "\n"
	    . "void STag_$tag(void);\n"
	    . "void ETag_$tag(char*);\n";

	foreach $attribute (split " ","$attlist{$tag}") {

	  print "void Attribute_${tag}_${attribute}(char*);\n";
d247 2
a248 2
	print SCANNER ("%x AL_$tag\n") if $attlist{$tag};
	print SCANNER ("%s IN_$tag\n") if not $leaf{$tag} ;
d253 9
d264 2
a265 1
      if (keys %entitysource) {
d267 2
a268 2
	foreach $ent (keys %entitysource) {
 	  print indent($entitysource{$ent});
d274 5
a278 2
	print "\n"
	    . indent($source{$tag});
d280 24
a303 1
	local $inner = ($leaf{$tag} ? "PCDATA" : "IN_$tag");
d305 17
a321 3
	print "\"<$tag\"{s}\"/>\"		STag($tag), ETag($tag);\n"
	    . "\"<$tag\"{s}\">\"		STag($tag), ENTER($inner);\n"
	    . "<$inner>\"</$tag\"{s}\">\"	ETag($tag), LEAVE($inner);\n";
d323 12
a334 1
	if ($attlist{$tag}) {
d336 8
a343 3
	  print "\"<$tag\"{S}		STag($tag), ENTER(AL_$tag);\n"
	      . "<AL_$tag>\"/>\"		LEAVE(AL_$tag), ETag($tag);\n"
	      . "<AL_$tag>\">\"		LEAVE(AL_$tag), ENTER(PCDATA);\n";
a344 5
	  foreach $attribute (split " ","$attlist{$tag}") {
	    print indent($source{"$tag/$attribute"});
	    print "<AL_$tag>\"$attribute\"{Eq}{Q}	Attribute($tag,$attribute);\n";
	  }
	}
d349 1
a349 1
      s/^\$Header/\$" "Header/;
d389 6
d397 3
a399 3
      if (keys %entitysource) {
	foreach $ent (keys %entitysource) {
 	  print $entitysource{$ent};
d405 5
a411 2
	    . $source{$tag}
	    . "\n"
d414 8
a421 4
	    . "    flexml_dummy_STag(\"$tag\");\n"
	    . "}\n"
	    . "\n"
	    . "void ETag_$tag(char* text)\n"
d423 1
a423 1
	    . "    flexml_dummy_ETag(\"$tag\",text);\n"
a424 12

	foreach $attribute (split " ","$attlist{$tag}") {

	  print "\n"
	      . $source{"$tag/$attribute"}
	      . "\n"
	      . "void Attribute_${tag}_${attribute}(char* value)\n"
	      . "{\n"
	      . "    flexml_dummy_Attribute(\"$tag\",\"$attribute\",value);\n"
	      . "}\n";
	}
	print "\n";
d505 4
a508 4
plus simple internal entity declarations (and comments, of course).
In fact it I<ignores> any lines not in this form (a rather serious
limitation).  A tag may be split over several lines but I<flexml> does
not handle several elements on a line.
@