cde/programs/nsgmls/Param.C

   1 /* $XConsortium: Param.C /main/1 1996/07/29 17:00:13 cde-hp $ */
   2 // Copyright (c) 1994 James Clark
   3 // See the file COPYING for copying permission.
   4
   5 #ifdef __GNUG__
   6 #pragma implementation
   7 #endif
   8 #include "splib.h"
   9 #include "Param.h"
  10 #include "MessageBuilder.h"
  11 #include "macros.h"
  12 #include "ParserMessages.h"
  13
  14 #ifdef SP_NAMESPACE
  15 namespace SP_NAMESPACE {
  16 #endif
  17
  18 AllowedParams::AllowedParams(Param::Type p1,
  19                              Param::Type p2,
  20                              Param::Type p3,
  21                              Param::Type p4,
  22                              Param::Type p5,
  23                              Param::Type p6,
  24                              Param::Type p7,
  25                              Param::Type p8,
  26                              Param::Type p9,
  27                              Param::Type p10)
  28 {
  29   init();
  30   allow(p1);
  31   allow(p2);
  32   allow(p3);
  33   allow(p4);
  34   allow(p5);
  35   allow(p6);
  36   allow(p7);
  37   allow(p8);
  38   allow(p9);
  39   allow(p10);
  40 }
  41
  42 AllowedParams::AllowedParams(const Param::Type *v, int n)
  43 {
  44   init();
  45   for (int i = 0; i < n; i++)
  46     allow(v[i]);
  47 }
  48
  49 void AllowedParams::init()
  50 {
  51   for (int i = 0; i < Syntax::nNames; i++)
  52     reservedNames_[i] = 0;
  53   mainMode_ = mdMode;
  54   mdc_ = 0;
  55   rni_ = 0;
  56   dso_ = 0;
  57   inclusions_ = 0;
  58   exclusions_ = 0;
  59   extraDelimiter_ = Param::invalid;
  60   group_ = Param::invalid;
  61   nameStart_ = Param::invalid;
  62   digit_ = Param::invalid;
  63   nmchar_ = Param::invalid;
  64   literal_ = Param::invalid;
  65 }
  66
  67
  68 void AllowedParams::allow(Param::Type p)
  69 {
  70   switch (p) {
  71   case Param::invalid:
  72     break;
  73   case Param::dso:
  74     dso_ = 1;
  75     break;
  76   case Param::mdc:
  77     mdc_ = 1;
  78     break;
  79   case Param::minus:
  80     ASSERT(mainMode_ == mdMode);
  81     mainMode_ = mdMinusMode;
  82     extraDelimiter_ = p;
  83     break;
  84   case Param::pero:
  85     ASSERT(mainMode_ == mdMode);
  86     mainMode_ = mdPeroMode;
  87     extraDelimiter_ = p;
  88     break;
  89   case Param::inclusions:
  90     inclusions_ = 1;
  91     break;
  92   case Param::exclusions:
  93     exclusions_ = 1;
  94     break;
  95   case Param::nameGroup:
  96   case Param::nameTokenGroup:
  97   case Param::modelGroup:
  98     ASSERT(group_ == Param::invalid);
  99     group_ = p;
 100     break;
 101   case Param::number:
 102     ASSERT(digit_ == Param::invalid);
 103     digit_ = p;
 104     break;
 105   case Param::minimumLiteral:
 106   case Param::tokenizedAttributeValueLiteral:
 107   case Param::attributeValueLiteral:
 108   case Param::systemIdentifier:
 109   case Param::paramLiteral:
 110     ASSERT(literal_ == Param::invalid);
 111     literal_ = p;
 112     break;
 113   case Param::name:
 114   case Param::entityName:
 115   case Param::paramEntityName:
 116     ASSERT(nameStart_ == Param::invalid);
 117     nameStart_ = p;
 118     break;
 119   case Param::attributeValue:
 120     ASSERT(nameStart_ == Param::invalid);
 121     nameStart_ = p;
 122     ASSERT(digit_ == Param::invalid);
 123     digit_ = p;
 124     ASSERT(nmchar_ == Param::invalid);
 125     nmchar_ = p;
 126     break;
 127   default:
 128     if (p < Param::indicatedReservedName) {
 129       ASSERT(nameStart_ == Param::invalid
 130              || nameStart_ == Param::reservedName);
 131       ASSERT(rni_ == 0);
 132       nameStart_ = Param::reservedName;
 133       reservedNames_[p - Param::reservedName] = 1;
 134     }
 135     else {
 136       ASSERT(nameStart_ != Param::reservedName);
 137       rni_ = 1;
 138       reservedNames_[p - Param::indicatedReservedName] = 1;
 139     }
 140     break;
 141   }
 142 }
 143
 144 AllowedParamsMessageArg::AllowedParamsMessageArg(
 145   const AllowedParams &allow,
 146   const ConstPtr<Syntax> &syntax)
 147 : allow_(allow),
 148   syntax_(syntax)
 149 {
 150 }
 151
 152 MessageArg *AllowedParamsMessageArg::copy() const
 153 {
 154   return new AllowedParamsMessageArg(*this);
 155 }
 156
 157 void AllowedParamsMessageArg::append(MessageBuilder &builder) const
 158 {
 159   Syntax::DelimGeneral delims[3];
 160   int nDelims = 0;
 161   if (allow_.mdc())
 162     delims[nDelims++] = Syntax::dMDC;
 163   if (allow_.dso())
 164     delims[nDelims++] = Syntax::dDSO;
 165   switch (allow_.mainMode()) {
 166   case mdMinusMode:
 167     delims[nDelims++] = Syntax::dMINUS;
 168     break;
 169   case mdPeroMode:
 170     delims[nDelims++] = Syntax::dPERO;
 171     break;
 172   default:
 173     break;
 174   }
 175   Boolean first = 1;
 176   int i;
 177   for (i = 0; i < nDelims; i++) {
 178     if (!first)
 179       builder.appendFragment(ParserMessages::listSep);
 180     else
 181       first = 0;
 182     const StringC &delim = syntax_->delimGeneral(delims[i]);
 183     builder.appendFragment(ParserMessages::delimStart);
 184     builder.appendChars(delim.data(), delim.size());
 185     builder.appendFragment(ParserMessages::delimEnd);
 186   }
 187   const MessageFragment *fragment[5];
 188   int nFragments = 0;
 189   if (allow_.inclusions())
 190     fragment[nFragments++] = &ParserMessages::inclusions;
 191   if (allow_.exclusions())
 192     fragment[nFragments++] = &ParserMessages::exclusions;
 193   switch (allow_.literal()) {
 194   case Param::minimumLiteral:
 195     fragment[nFragments++] = &ParserMessages::minimumLiteral;
 196     break;
 197   case Param::attributeValueLiteral:
 198   case Param::tokenizedAttributeValueLiteral:
 199     fragment[nFragments++] = &ParserMessages::attributeValueLiteral;
 200     break;
 201   case Param::systemIdentifier:
 202     fragment[nFragments++] = &ParserMessages::systemIdentifier;
 203     break;
 204   case Param::paramLiteral:
 205     fragment[nFragments++] = &ParserMessages::parameterLiteral;
 206     break;
 207   }
 208   switch (allow_.nameStart()) {
 209   case Param::name:
 210   case Param::entityName:
 211   case Param::paramEntityName:
 212     fragment[nFragments++] = &ParserMessages::name;
 213     break;
 214   case Param::attributeValue:
 215     fragment[nFragments++] = &ParserMessages::attributeValue;
 216     break;
 217   }
 218   if (allow_.digit() == Param::number)
 219     fragment[nFragments++] = &ParserMessages::number;
 220
 221   for (i = 0; i < nFragments; i++) {
 222     if (!first)
 223       builder.appendFragment(ParserMessages::listSep);
 224     else
 225       first = 0;
 226     builder.appendFragment(*fragment[i]);
 227   }
 228   if (allow_.rni() || allow_.nameStart() == Param::reservedName) {
 229     for (int i = 0; i < Syntax::nNames; i++) {
 230       if (allow_.reservedName(Syntax::ReservedName(i))) {
 231         if (!first)
 232           builder.appendFragment(ParserMessages::listSep);
 233         else
 234           first = 0;
 235         StringC str;
 236         if (allow_.rni())
 237           str = syntax_->delimGeneral(Syntax::dRNI);
 238         str += syntax_->reservedName(Syntax::ReservedName(i));
 239         builder.appendChars(str.data(), str.size());
 240       }
 241     }
 242   }
 243 }
 244
 245 #ifdef SP_NAMESPACE
 246 }
 247 #endif