---

defs.cc

/*
*  Name:      defs.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   CODEGEN definitions
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  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.
*/

#include <cstring>
#include <mpcl/text/codegen/defs.hh>


namespace mpcl
{

  namespace text
  {

    namespace codegen
    {

      //
      //  E X P O R T E D   V A R I A B L E S
      //

      //
      //  Tag definitions.
      //

      //
      //  <!-- ... -->
      //
      const char*   pkcCommentTagPattern = "[[:space:]]*<!--%t-->[[:space:]]*";

      //
      //  <!doctype dfaml [{system="value" | public="value"}]>
      //
      const char*   pkcDOCTYPE_TagPattern_1 = "[[:space:]]*<!doctype"
                                              "[[:space:]]+cdml[[:space:]]*>";
      const char*   pkcDOCTYPE_TagPattern_2 = "[[:space:]]*<!doctype"
                                              "[[:space:]]+cdml[[:space:]]+system[[:space:]]*>";
      const char*   pkcDOCTYPE_TagPattern_3 = "[[:space:]]*<!doctype"
                                              "[[:space:]]+cdml[[:space:]]+system"
                                              "[[:space:]]+%q[[:space:]]*>";
      const char*   pkcDOCTYPE_TagPattern_4 = "[[:space:]]*<!doctype"
                                              "[[:space:]]+cdml[[:space:]]+public"
                                              "[[:space:]]+%q[[:space:]]*>";
      //
      //  <cdml target="value" [inherit="value"]>...</dfaml>
      //
      const char*   pkcCDML_TagPattern_1  = "[[:space:]]*<cdml"
                                            "[[:space:]]+target[[:space:]]*="
                                            "[[:space:]]*%q"
                                            "[[:space:]]*>[[:blank:]]*\n?";
      const char*   pkcCDML_TagPattern_2  = "[[:space:]]*<cdml"
                                            "[[:space:]]+target[[:space:]]*="
                                            "[[:space:]]*%q"
                                            "[[:space:]]+inherit[[:space:]]*="
                                            "[[:space:]]*%q"
                                            "[[:space:]]*>[[:blank:]]*\n?";
      const char*   pkcCDML_TagPattern_3  = "[[:space:]]*<cdml"
                                            "[[:space:]]+inherit[[:space:]]*="
                                            "[[:space:]]*%q"
                                            "[[:space:]]+target[[:space:]]*="
                                            "[[:space:]]*%q"
                                            "[[:space:]]*>[[:blank:]]*\n?";
      const char*   pkcCDML_EndTagPattern = "[[:space:]]*</cdml[[:space:]]*>";

      //
      //  <desc>...</desc>
      //
      const char*   pkcDESC_ElementPattern = "[[:space:]]*<desc"
                                             "[[:space:]]*>[[:blank:]]*\n?"
                                             "%t[[:blank:]]*\n?</desc[[:space:]]*>";

      //
      //  <declare>...</declare>
      //
      const char*   pkcDECLARE_TagPattern    = "[[:space:]]*<declare[[:space:]]*>[[:blank:]]*\n?";
      const char*   pkcDECLARE_EndTagPattern = "[[:space:]]*</declare[[:space:]]*>";

      //
      //  <instruct name="value">...</instruct>
      //
      const char*   pkcINSTRUCT_TagPattern    = "[[:space:]]*<instruct[[:space:]]+"
                                                "name[[:space:]]*=[[:space:]]*"
                                                "%q[[:space:]]*>";
      const char*   pkcINSTRUCT_EndTagPattern = "[[:space:]]*</instruct[[:space:]]*>";

      //
      //  <variable name="value" [type={normal|file}]>
      //
      const char*   pkcVARIABLE_ElementPattern_1 = "[[:space:]]*<variable"
                                                   "[[:space:]]+name[[:space:]]*=[[:space:]]*%q"
                                                   "[[:space:]]*>%t</variable[[:space:]]*>";
      const char*   pkcVARIABLE_ElementPattern_2 = "[[:space:]]*<variable"
                                                   "[[:space:]]+name[[:space:]]*=[[:space:]]*%q"
                                                   "[[:space:]]+type[[:space:]]*=[[:space:]]*%q"
                                                   "[[:space:]]*>%t</variable[[:space:]]*>";
      const char*   pkcVARIABLE_ElementPattern_3 = "[[:space:]]*<variable"
                                                   "[[:space:]]+type[[:space:]]*=[[:space:]]*%q"
                                                   "[[:space:]]+name[[:space:]]*=[[:space:]]*%q"
                                                   "[[:space:]]*>%t</variable[[:space:]]*>";

      //
      //  <clause name="value" [target="value"] [nocheck]>...</clause>
      //
      const char*   pkcCLAUSE_TagBegin       = "[[:space:]]*<clause";
      const char*   pkcCLAUSE_TagNameAttr    = "[[:space:]]+name[[:space:]]*=[[:space:]]*%q";
      const char*   pkcCLAUSE_TagTargetAttr  = "[[:space:]]+target[[:space:]]*=[[:space:]]*%q";
      const char*   pkcCLAUSE_TagNoCheckAttr = "[[:space:]]+nocheck";
      const char*   pkcCLAUSE_TagEnd         = "[[:space:]]*>[[:blank:]]*\n?";
      const char*   pkcCLAUSE_BodyPattern    = "%t[[:blank:]]*</clause[[:space:]]*>";

      //
      //  Entity definitions.
      //
      const char*   pkcEntityPrefix      = "&";
      const char*   pkcGT_EntityPattern  = "&gt;";
      const char*   pkcGT_EntityValue    = ">";
      const char*   pkcLT_EntityPattern  = "&lt;";
      const char*   pkcLT_EntityValue    = "<";
      const char*   pkcNL_EntityPattern  = "&nl;";
      const char*   pkcNL_EntityValue    = "\n";
      const char*   pkcEOC_EntityPattern = "&eoc;";
      const char*   pkcAMP_EntityPattern = "&amp;";
      const char*   pkcAMP_EntityValue   = "&";

      //
      //  Entity lengths definitions.
      //
      size_t   zEntityPrefixLength      = std::strlen (pkcEntityPrefix);
      size_t   zGT_EntityPatternLength  = std::strlen (pkcGT_EntityPattern);
      size_t   zGT_EntityValueLength    = std::strlen (pkcGT_EntityValue);
      size_t   zLT_EntityPatternLength  = std::strlen (pkcLT_EntityPattern);
      size_t   zLT_EntityValueLength    = std::strlen (pkcLT_EntityValue);
      size_t   zNL_EntityPatternLength  = std::strlen (pkcNL_EntityPattern);
      size_t   zNL_EntityValueLength    = std::strlen (pkcNL_EntityValue);
      size_t   zEOC_EntityPatternLength = std::strlen (pkcEOC_EntityPattern);
      size_t   zAMP_EntityPatternLength = std::strlen (pkcAMP_EntityPattern);
      size_t   zAMP_EntityValueLength   = std::strlen (pkcAMP_EntityValue);

      //
      //  This is the separator used when encoding (name-mangling)
      //  clauses with an associated target.
      //
      const char*   pkcTargetSeparator = "::";

    }  // namespace codegen

  }  // namespace text

}  // namespace mpcl


//
//  E X P O R T E D   F U N C T I O N S
//

void mpcl::text::codegen::
InstantiateEntities (TString& ryTARGET_STRING)
{

  using std::strncmp;

  const char*   pkcBase;
  size_t        zOffset = 0;
  
  //
  //  Replace all entities.
  //
  while ( TString::npos != (zOffset = ryTARGET_STRING.find (pkcEntityPrefix, zOffset)) )
  {
    pkcBase = ryTARGET_STRING.c_str() + zOffset;
    if ( !strncmp (pkcBase, pkcGT_EntityPattern, zGT_EntityPatternLength) )
    {
      ryTARGET_STRING.replace (zOffset, zGT_EntityPatternLength, pkcGT_EntityValue);
      zOffset += zGT_EntityValueLength;
    }
    else if ( !strncmp (pkcBase, pkcLT_EntityPattern, zLT_EntityPatternLength) )
    {
      ryTARGET_STRING.replace (zOffset, zLT_EntityPatternLength, pkcLT_EntityValue);
      zOffset += zLT_EntityValueLength;
    }
    else if ( !strncmp (pkcBase, pkcNL_EntityPattern, zNL_EntityPatternLength) )
    {
      ryTARGET_STRING.replace (zOffset, zNL_EntityPatternLength, pkcNL_EntityValue);
      zOffset += zNL_EntityValueLength;
    }
    else if ( !strncmp (pkcBase, pkcEOC_EntityPattern, zEOC_EntityPatternLength) )
    {
      ryTARGET_STRING.erase (zOffset);
      break;
    }
    else if ( !strncmp (pkcBase, pkcAMP_EntityPattern, zAMP_EntityPatternLength) )
    {
      ryTARGET_STRING.replace (zOffset, zAMP_EntityPatternLength, pkcAMP_EntityValue);
      zOffset += zAMP_EntityValueLength;
    }
    else
    {
      zOffset += zEntityPrefixLength;
    }
  }
  
}  // InstantiateEntities()

---