usr/src/cmd/man/src/util/nsgmls.src/lib/ParserApp.cxx

   1 // Copyright (c) 1996 James Clark
   2 // See the file COPYING for copying permission.
   3 #pragma ident   "%Z%%M% %I%     %E% SMI"
   4
   5 #ifdef __GNUG__
   6 #pragma implementation
   7 #endif
   8
   9 #include "splib.h"
  10 #include "ParserApp.h"
  11 #include "ParserAppMessages.h"
  12 #include "MessageArg.h"
  13 #include "Location.h"
  14 #include "macros.h"
  15 #include "sptchar.h"
  16 #include "ArcEngine.h"
  17
  18 #include <limits.h>
  19 #include <errno.h>
  20 #include <stdlib.h>
  21
  22 #ifndef DEFAULT_ERROR_LIMIT
  23 #define DEFAULT_ERROR_LIMIT 200
  24 #endif
  25
  26 #ifdef SP_NAMESPACE
  27 namespace SP_NAMESPACE {
  28 #endif
  29
  30 ParserApp::ParserApp(const char *requiredInternalCode)
  31 : EntityApp(requiredInternalCode),
  32   errorLimit_(DEFAULT_ERROR_LIMIT)
  33 {
  34   registerOption('a', SP_T("link_type"));
  35   registerOption('A', SP_T("arch"));
  36   registerOption('e');
  37   registerOption('E', SP_T("max_errors"));
  38   registerOption('g');
  39   registerOption('i', SP_T("entity"));
  40   registerOption('w', SP_T("warning_type"));
  41 }
  42
  43 void ParserApp::initParser(const StringC &sysid)
  44 {
  45   SgmlParser::Params params;
  46   params.sysid = sysid;
  47   params.entityManager = entityManager().pointer();
  48   params.options = &options_;
  49   parser_.init(params);
  50   if (arcNames_.size() > 0)
  51     parser_.activateLinkType(arcNames_[0]);
  52   for (size_t i = 0; i < activeLinkTypes_.size(); i++)
  53     parser_.activateLinkType(convertInput(activeLinkTypes_[i]));
  54   allLinkTypesActivated();
  55 }
  56
  57 void ParserApp::allLinkTypesActivated()
  58 {
  59   parser_.allLinkTypesActivated();
  60 }
  61
  62 int ParserApp::processSysid(const StringC &sysid)
  63 {
  64   initParser(sysid);
  65   ErrorCountEventHandler *eceh = makeEventHandler();
  66   if (errorLimit_)
  67     eceh->setErrorLimit(errorLimit_);
  68   return generateEvents(eceh);
  69 }
  70
  71 int ParserApp::generateEvents(ErrorCountEventHandler *eceh)
  72 {
  73   Owner<EventHandler> eh(eceh);
  74   parseAll(parser_, *eh, eceh->cancelPtr());
  75   unsigned errorCount = eceh->errorCount();
  76   if (errorLimit_ != 0 && errorCount >= errorLimit_)
  77     message(ParserAppMessages::errorLimitExceeded,
  78             NumberMessageArg(errorLimit_));
  79   return errorCount > 0;
  80 }
  81
  82 void ParserApp::parseAll(SgmlParser &parser,
  83                          EventHandler &eh,
  84                          const volatile sig_atomic_t *cancelPtr)
  85 {
  86   if (arcNames_.size() > 0) {
  87     SelectOneArcDirector director(arcNames_, eh);
  88     ArcEngine::parseAll(parser, director, director, cancelPtr);
  89   }
  90   else
  91     parser.parseAll(eh, cancelPtr);
  92 }
  93
  94 void ParserApp::processOption(AppChar opt, const AppChar *arg)
  95 {
  96   switch (opt) {
  97   case 'a':
  98     // activate link
  99     activeLinkTypes_.push_back(arg);
 100     break;
 101   case 'A':
 102     arcNames_.push_back(convertInput(arg));
 103     break;
 104   case 'E':
 105     {
 106       AppChar *end;
 107       unsigned long n = tcstoul((AppChar *)arg, &end, 10);
 108       if ((n == 0 && end == arg)
 109           || *end != SP_T('\0')
 110           || (n == ULONG_MAX && errno == ERANGE)
 111           || n > UINT_MAX)
 112         message(ParserAppMessages::badErrorLimit);
 113       else
 114         errorLimit_ = unsigned(n);
 115     }
 116     break;
 117   case 'e':
 118     // describe open entities in error messages
 119     addOption(MessageReporter::openEntities);
 120     break;
 121   case 'g':
 122     // show gis of open elements in error messages
 123     addOption(MessageReporter::openElements);
 124     break;
 125   case 'i':
 126     // pretend that arg is defined as INCLUDE
 127     options_.includes.push_back(convertInput(arg));
 128     break;
 129   case 'w':
 130     if (!enableWarning(arg))
 131       message(ParserAppMessages::unknownWarning,
 132               StringMessageArg(convertInput(arg)));
 133     break;
 134   default:
 135     EntityApp::processOption(opt, arg);
 136     break;
 137   }
 138 }
 139
 140 Boolean ParserApp::enableWarning(const AppChar *s)
 141 {
 142   enum { groupAll = 01, groupMinTag = 02, groupXML = 04 };
 143   static struct {
 144     // Explicit qualifier works around CodeWarrior bug
 145     const CmdLineApp::AppChar *name;
 146     PackedBoolean ParserOptions::*ptr;
 147     unsigned char groups;
 148   } table[] = {
 149     { SP_T("mixed"), &ParserOptions::warnMixedContent, groupAll },
 150     { SP_T("should"), &ParserOptions::warnShould, groupAll },
 151     { SP_T("duplicate"), &ParserOptions::warnDuplicateEntity, 0 },
 152     { SP_T("default"), &ParserOptions::warnDefaultEntityReference, groupAll },
 153     { SP_T("undefined"), &ParserOptions::warnUndefinedElement, groupAll },
 154     { SP_T("sgmldecl"), &ParserOptions::warnSgmlDecl, groupAll },
 155     { SP_T("unclosed"), &ParserOptions::noUnclosedTag, groupAll|groupMinTag },
 156     { SP_T("net"), &ParserOptions::noNet, groupMinTag },
 157     { SP_T("empty"), &ParserOptions::warnEmptyTag, groupAll|groupMinTag },
 158     { SP_T("unused-map"), &ParserOptions::warnUnusedMap, groupAll },
 159     { SP_T("unused-param"), &ParserOptions::warnUnusedParam, groupAll },
 160     { SP_T("notation-sysid"), &ParserOptions::warnNotationSystemId, 0 },
 161     { SP_T("inclusion"), &ParserOptions::warnInclusion, groupXML },
 162     { SP_T("exclusion"), &ParserOptions::warnExclusion, groupXML },
 163     { SP_T("rcdata-content"), &ParserOptions::warnRcdataContent, groupXML },
 164     { SP_T("cdata-content"), &ParserOptions::warnCdataContent, groupXML },
 165     { SP_T("ps-comment"), &ParserOptions::warnPsComment, groupXML },
 166     { SP_T("attlist-group-decl"), &ParserOptions::warnAttlistGroupDecl, groupXML },
 167     { SP_T("element-group-decl"), &ParserOptions::warnElementGroupDecl, groupXML },
 168     { SP_T("pi-entity"), &ParserOptions::warnPiEntity, groupXML },
 169     { SP_T("internal-sdata-entity"), &ParserOptions::warnInternalSdataEntity, groupXML },
 170     { SP_T("internal-cdata-entity"), &ParserOptions::warnInternalCdataEntity, groupXML },
 171     { SP_T("external-sdata-entity"), &ParserOptions::warnExternalSdataEntity, groupXML },
 172     { SP_T("external-cdata-entity"), &ParserOptions::warnExternalCdataEntity, groupXML },
 173     { SP_T("bracket-entity"), &ParserOptions::warnBracketEntity, groupXML },
 174     { SP_T("data-atts"), &ParserOptions::warnDataAttributes, groupXML },
 175     { SP_T("missing-system-id"), &ParserOptions::warnMissingSystemId, groupXML },
 176     { SP_T("conref"), &ParserOptions::warnConref, groupXML },
 177     { SP_T("current"), &ParserOptions::warnCurrent, groupXML },
 178     { SP_T("nutoken-decl-value"), &ParserOptions::warnNutokenDeclaredValue, groupXML },
 179     { SP_T("number-decl-value"), &ParserOptions::warnNumberDeclaredValue, groupXML },
 180     { SP_T("name-decl-value"), &ParserOptions::warnNameDeclaredValue, groupXML },
 181     { SP_T("named-char-ref"), &ParserOptions::warnNamedCharRef, groupXML },
 182     { SP_T("refc"), &ParserOptions::warnRefc, groupXML },
 183     { SP_T("temp-ms"), &ParserOptions::warnTempMarkedSection, groupXML },
 184     { SP_T("rcdata-ms"), &ParserOptions::warnRcdataMarkedSection, groupXML },
 185     { SP_T("instance-include-ms"), &ParserOptions::warnInstanceIncludeMarkedSection, groupXML },
 186     { SP_T("instance-ignore-ms"), &ParserOptions::warnInstanceIgnoreMarkedSection, groupXML },
 187     { SP_T("and-group"), &ParserOptions::warnAndGroup, groupXML },
 188     { SP_T("rank"), &ParserOptions::warnRank, groupXML },
 189     { SP_T("empty-comment-decl"), &ParserOptions::warnEmptyCommentDecl, groupXML },
 190     { SP_T("att-value-not-literal"), &ParserOptions::warnAttributeValueNotLiteral, groupXML },
 191     { SP_T("missing-att-name"), &ParserOptions::warnMissingAttributeName, groupXML },
 192     { SP_T("comment-decl-s"), &ParserOptions::warnCommentDeclS, groupXML },
 193     { SP_T("comment-decl-multiple"), &ParserOptions::warnCommentDeclMultiple, groupXML },
 194     { SP_T("missing-status-keyword"), &ParserOptions::warnMissingStatusKeyword, groupXML },
 195     { SP_T("multiple-status-keyword"), &ParserOptions::warnMultipleStatusKeyword, groupXML },
 196     { SP_T("instance-param-entity"), &ParserOptions::warnInstanceParamEntityRef, groupXML },
 197     { SP_T("min-param"), &ParserOptions::warnMinimizationParam, groupXML },
 198     { SP_T("mixed-content-xml"), &ParserOptions::warnMixedContentRepOrGroup, groupXML },
 199     { SP_T("name-group-not-or"), &ParserOptions::warnNameGroupNotOr, groupXML },
 200     { SP_T("pi-missing-name"), &ParserOptions::warnPiMissingName, groupXML },
 201     { SP_T("instance-status-keyword-s"), &ParserOptions::warnInstanceStatusKeywordSpecS, groupXML },
 202     { SP_T("external-data-entity-ref"), &ParserOptions::warnExternalDataEntityRef, groupXML },
 203     { SP_T("att-value-external-entity-ref"), &ParserOptions::warnAttributeValueExternalEntityRef, groupXML },
 204     { SP_T("data-delim"), &ParserOptions::warnDataDelim, groupXML },
 205     { SP_T("explicit-sgml-decl"), &ParserOptions::warnExplicitSgmlDecl, groupXML },
 206     { SP_T("internal-subset-ms"), &ParserOptions::warnInternalSubsetMarkedSection, groupXML },
 207     { SP_T("default-entity"), &ParserOptions::warnDefaultEntityDecl, groupXML },
 208     { SP_T("non-sgml-char-ref"), &ParserOptions::warnNonSgmlCharRef, groupXML },
 209     { SP_T("internal-subset-ps-param-entity"), &ParserOptions::warnInternalSubsetPsParamEntityRef, groupXML },
 210     { SP_T("internal-subset-ts-param-entity"), &ParserOptions::warnInternalSubsetTsParamEntityRef, groupXML },
 211     { SP_T("internal-subset-literal-param-entity"), &ParserOptions::warnInternalSubsetLiteralParamEntityRef, groupXML },
 212     { SP_T("idref"), &ParserOptions::errorIdref, 0 },
 213     { SP_T("significant"), &ParserOptions::errorSignificant, 0 },
 214     { SP_T("afdr"), &ParserOptions::errorAfdr, 0 },
 215   };
 216   static struct {
 217     const CmdLineApp::AppChar *name;
 218     unsigned char flag;
 219   } groupTable[] = {
 220     { SP_T("all"), groupAll },
 221     { SP_T("min-tag"), groupMinTag },
 222     { SP_T("xml"), groupXML },
 223   };
 224   PackedBoolean val = 1;
 225   if (tcsncmp(s, SP_T("no-"), 3) == 0) {
 226     s += 3;
 227     val = 0;
 228   }
 229   for (size_t i = 0; i < SIZEOF(groupTable); i++)
 230     if (tcscmp(s, groupTable[i].name) == 0) {
 231       for (size_t j = 0; j < SIZEOF(table); j++)
 232         if (table[j].groups & groupTable[i].flag) {
 233           // Use parentheses to work around Watcom 10.0a bug.
 234           (options_.*(table[j].ptr)) = val;
 235         }
 236       return 1;
 237     }
 238   for (size_t i = 0; i < SIZEOF(table); i++)
 239     if (tcscmp(s, table[i].name) == 0) {
 240       // Use parentheses to work around Watcom 10.0a bug.
 241       (options_.*(table[i].ptr)) = val;
 242       return 1;
 243     }
 244   if (tcscmp(s, SP_T("valid")) == 0) {
 245     options_.typeValid = val;
 246     return 1;
 247   }
 248   return 0;
 249 }
 250
 251 #ifdef SP_NAMESPACE
 252 }
 253 #endif