cde/programs/nsgmls/Param.C

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $XConsortium: Param.C /main/1 1996/07/29 17:00:13 cde-hp $ */
  24 // Copyright (c) 1994 James Clark
  25 // See the file COPYING for copying permission.
  26
  27 #ifdef __GNUG__
  28 #pragma implementation
  29 #endif
  30 #include "splib.h"
  31 #include "Param.h"
  32 #include "MessageBuilder.h"
  33 #include "macros.h"
  34 #include "ParserMessages.h"
  35
  36 #ifdef SP_NAMESPACE
  37 namespace SP_NAMESPACE {
  38 #endif
  39
  40 AllowedParams::AllowedParams(Param::Type p1,
  41                              Param::Type p2,
  42                              Param::Type p3,
  43                              Param::Type p4,
  44                              Param::Type p5,
  45                              Param::Type p6,
  46                              Param::Type p7,
  47                              Param::Type p8,
  48                              Param::Type p9,
  49                              Param::Type p10)
  50 {
  51   init();
  52   allow(p1);
  53   allow(p2);
  54   allow(p3);
  55   allow(p4);
  56   allow(p5);
  57   allow(p6);
  58   allow(p7);
  59   allow(p8);
  60   allow(p9);
  61   allow(p10);
  62 }
  63
  64 AllowedParams::AllowedParams(const Param::Type *v, int n)
  65 {
  66   init();
  67   for (int i = 0; i < n; i++)
  68     allow(v[i]);
  69 }
  70
  71 void AllowedParams::init()
  72 {
  73   for (int i = 0; i < Syntax::nNames; i++)
  74     reservedNames_[i] = 0;
  75   mainMode_ = mdMode;
  76   mdc_ = 0;
  77   rni_ = 0;
  78   dso_ = 0;
  79   inclusions_ = 0;
  80   exclusions_ = 0;
  81   extraDelimiter_ = Param::invalid;
  82   group_ = Param::invalid;
  83   nameStart_ = Param::invalid;
  84   digit_ = Param::invalid;
  85   nmchar_ = Param::invalid;
  86   literal_ = Param::invalid;
  87 }
  88
  89
  90 void AllowedParams::allow(Param::Type p)
  91 {
  92   switch (p) {
  93   case Param::invalid:
  94     break;
  95   case Param::dso:
  96     dso_ = 1;
  97     break;
  98   case Param::mdc:
  99     mdc_ = 1;
 100     break;
 101   case Param::minus:
 102     ASSERT(mainMode_ == mdMode);
 103     mainMode_ = mdMinusMode;
 104     extraDelimiter_ = p;
 105     break;
 106   case Param::pero:
 107     ASSERT(mainMode_ == mdMode);
 108     mainMode_ = mdPeroMode;
 109     extraDelimiter_ = p;
 110     break;
 111   case Param::inclusions:
 112     inclusions_ = 1;
 113     break;
 114   case Param::exclusions:
 115     exclusions_ = 1;
 116     break;
 117   case Param::nameGroup:
 118   case Param::nameTokenGroup:
 119   case Param::modelGroup:
 120     ASSERT(group_ == Param::invalid);
 121     group_ = p;
 122     break;
 123   case Param::number:
 124     ASSERT(digit_ == Param::invalid);
 125     digit_ = p;
 126     break;
 127   case Param::minimumLiteral:
 128   case Param::tokenizedAttributeValueLiteral:
 129   case Param::attributeValueLiteral:
 130   case Param::systemIdentifier:
 131   case Param::paramLiteral:
 132     ASSERT(literal_ == Param::invalid);
 133     literal_ = p;
 134     break;
 135   case Param::name:
 136   case Param::entityName:
 137   case Param::paramEntityName:
 138     ASSERT(nameStart_ == Param::invalid);
 139     nameStart_ = p;
 140     break;
 141   case Param::attributeValue:
 142     ASSERT(nameStart_ == Param::invalid);
 143     nameStart_ = p;
 144     ASSERT(digit_ == Param::invalid);
 145     digit_ = p;
 146     ASSERT(nmchar_ == Param::invalid);
 147     nmchar_ = p;
 148     break;
 149   default:
 150     if (p < Param::indicatedReservedName) {
 151       ASSERT(nameStart_ == Param::invalid
 152              || nameStart_ == Param::reservedName);
 153       ASSERT(rni_ == 0);
 154       nameStart_ = Param::reservedName;
 155       reservedNames_[p - Param::reservedName] = 1;
 156     }
 157     else {
 158       ASSERT(nameStart_ != Param::reservedName);
 159       rni_ = 1;
 160       reservedNames_[p - Param::indicatedReservedName] = 1;
 161     }
 162     break;
 163   }
 164 }
 165
 166 AllowedParamsMessageArg::AllowedParamsMessageArg(
 167   const AllowedParams &allow,
 168   const ConstPtr<Syntax> &syntax)
 169 : allow_(allow),
 170   syntax_(syntax)
 171 {
 172 }
 173
 174 MessageArg *AllowedParamsMessageArg::copy() const
 175 {
 176   return new AllowedParamsMessageArg(*this);
 177 }
 178
 179 void AllowedParamsMessageArg::append(MessageBuilder &builder) const
 180 {
 181   Syntax::DelimGeneral delims[3];
 182   int nDelims = 0;
 183   if (allow_.mdc())
 184     delims[nDelims++] = Syntax::dMDC;
 185   if (allow_.dso())
 186     delims[nDelims++] = Syntax::dDSO;
 187   switch (allow_.mainMode()) {
 188   case mdMinusMode:
 189     delims[nDelims++] = Syntax::dMINUS;
 190     break;
 191   case mdPeroMode:
 192     delims[nDelims++] = Syntax::dPERO;
 193     break;
 194   default:
 195     break;
 196   }
 197   Boolean first = 1;
 198   int i;
 199   for (i = 0; i < nDelims; i++) {
 200     if (!first)
 201       builder.appendFragment(ParserMessages::listSep);
 202     else
 203       first = 0;
 204     const StringC &delim = syntax_->delimGeneral(delims[i]);
 205     builder.appendFragment(ParserMessages::delimStart);
 206     builder.appendChars(delim.data(), delim.size());
 207     builder.appendFragment(ParserMessages::delimEnd);
 208   }
 209   const MessageFragment *fragment[5];
 210   int nFragments = 0;
 211   if (allow_.inclusions())
 212     fragment[nFragments++] = &ParserMessages::inclusions;
 213   if (allow_.exclusions())
 214     fragment[nFragments++] = &ParserMessages::exclusions;
 215   switch (allow_.literal()) {
 216   case Param::minimumLiteral:
 217     fragment[nFragments++] = &ParserMessages::minimumLiteral;
 218     break;
 219   case Param::attributeValueLiteral:
 220   case Param::tokenizedAttributeValueLiteral:
 221     fragment[nFragments++] = &ParserMessages::attributeValueLiteral;
 222     break;
 223   case Param::systemIdentifier:
 224     fragment[nFragments++] = &ParserMessages::systemIdentifier;
 225     break;
 226   case Param::paramLiteral:
 227     fragment[nFragments++] = &ParserMessages::parameterLiteral;
 228     break;
 229   }
 230   switch (allow_.nameStart()) {
 231   case Param::name:
 232   case Param::entityName:
 233   case Param::paramEntityName:
 234     fragment[nFragments++] = &ParserMessages::name;
 235     break;
 236   case Param::attributeValue:
 237     fragment[nFragments++] = &ParserMessages::attributeValue;
 238     break;
 239   }
 240   if (allow_.digit() == Param::number)
 241     fragment[nFragments++] = &ParserMessages::number;
 242
 243   for (i = 0; i < nFragments; i++) {
 244     if (!first)
 245       builder.appendFragment(ParserMessages::listSep);
 246     else
 247       first = 0;
 248     builder.appendFragment(*fragment[i]);
 249   }
 250   if (allow_.rni() || allow_.nameStart() == Param::reservedName) {
 251     for (int i = 0; i < Syntax::nNames; i++) {
 252       if (allow_.reservedName(Syntax::ReservedName(i))) {
 253         if (!first)
 254           builder.appendFragment(ParserMessages::listSep);
 255         else
 256           first = 0;
 257         StringC str;
 258         if (allow_.rni())
 259           str = syntax_->delimGeneral(Syntax::dRNI);
 260         str += syntax_->reservedName(Syntax::ReservedName(i));
 261         builder.appendChars(str.data(), str.size());
 262       }
 263     }
 264   }
 265 }
 266
 267 #ifdef SP_NAMESPACE
 268 }
 269 #endif