cde/programs/nsgmls/Group.C

   1 /* $XConsortium: Group.C /main/1 1996/07/29 16:52:27 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 "Group.h"
  10 #include "MessageBuilder.h"
  11 #include "ParserMessages.h"
  12 #include "macros.h"
  13
  14 #ifdef SP_NAMESPACE
  15 namespace SP_NAMESPACE {
  16 #endif
  17
  18 AllowedGroupTokens::AllowedGroupTokens(GroupToken::Type t1, GroupToken::Type t2,
  19                                        GroupToken::Type t3, GroupToken::Type t4)
  20 : flags_(0)
  21 {
  22   allow(t1);
  23   allow(t2);
  24   allow(t3);
  25   allow(t4);
  26 }
  27
  28 AllowedGroupConnectors::AllowedGroupConnectors(GroupConnector::Type c1)
  29 : flags_(0)
  30 {
  31   allow(c1);
  32 }
  33
  34 AllowedGroupConnectors::AllowedGroupConnectors(GroupConnector::Type c1,
  35                                                GroupConnector::Type c2)
  36 : flags_(0)
  37 {
  38   allow(c1);
  39   allow(c2);
  40 }
  41
  42 AllowedGroupConnectors::AllowedGroupConnectors(GroupConnector::Type c1,
  43                                                GroupConnector::Type c2,
  44                                                GroupConnector::Type c3)
  45 : flags_(0)
  46 {
  47   allow(c1);
  48   allow(c2);
  49   allow(c3);
  50 }
  51
  52 AllowedGroupConnectors::AllowedGroupConnectors(GroupConnector::Type c1,
  53                                                GroupConnector::Type c2,
  54                                                GroupConnector::Type c3,
  55                                                GroupConnector::Type c4)
  56 : flags_(0)
  57 {
  58   allow(c1);
  59   allow(c2);
  60   allow(c3);
  61   allow(c4);
  62 }
  63
  64
  65 AllowedGroupConnectorsMessageArg::AllowedGroupConnectorsMessageArg(
  66   const AllowedGroupConnectors &allow,
  67   const ConstPtr<Syntax> &syntax)
  68 : allow_(allow),
  69   syntax_(syntax)
  70 {
  71 }
  72
  73 MessageArg *AllowedGroupConnectorsMessageArg::copy() const
  74 {
  75   return new AllowedGroupConnectorsMessageArg(*this);
  76 }
  77
  78 void AllowedGroupConnectorsMessageArg::append(MessageBuilder &builder) const
  79 {
  80   static GroupConnector::Type types[] = {
  81     GroupConnector::andGC, GroupConnector::orGC, GroupConnector::seqGC,
  82     GroupConnector::grpcGC, GroupConnector::dtgcGC
  83     };
  84   static Syntax::DelimGeneral delims[] = {
  85     Syntax::dAND, Syntax::dOR, Syntax::dSEQ,
  86     Syntax::dGRPC, Syntax::dDTGC
  87     };
  88   Boolean first = 1;
  89   for (size_t i = 0; i < SIZEOF(types); i++)
  90     if (allow_.groupConnector(types[i])) {
  91       if (!first)
  92         builder.appendFragment(ParserMessages::listSep);
  93       else
  94         first = 0;
  95       const StringC &delim = syntax_->delimGeneral(delims[i]);
  96       builder.appendFragment(ParserMessages::delimStart);
  97       builder.appendChars(delim.data(), delim.size());
  98       builder.appendFragment(ParserMessages::delimEnd);
  99     }
 100 }
 101
 102 AllowedGroupTokensMessageArg::AllowedGroupTokensMessageArg(
 103   const AllowedGroupTokens &allow,
 104   const ConstPtr<Syntax> &syntax)
 105 : allow_(allow),
 106   syntax_(syntax)
 107 {
 108 }
 109
 110 MessageArg *AllowedGroupTokensMessageArg::copy() const
 111 {
 112   return new AllowedGroupTokensMessageArg(*this);
 113 }
 114
 115 void AllowedGroupTokensMessageArg::append(MessageBuilder &builder) const
 116 {
 117   const MessageFragment *fragment[4];
 118   int nFragments = 0;
 119   if (allow_.groupToken(GroupToken::dataTagLiteral))
 120     fragment[nFragments++] = &ParserMessages::parameterLiteral;
 121   if (allow_.groupToken(GroupToken::dataTagGroup))
 122     fragment[nFragments++] = &ParserMessages::dataTagGroup;
 123   switch (allow_.group()) {
 124   case GroupToken::modelGroup:
 125     fragment[nFragments++] = &ParserMessages::modelGroup;
 126     break;
 127   case GroupToken::dataTagTemplateGroup:
 128     fragment[nFragments++] = &ParserMessages::dataTagTemplateGroup;
 129     break;
 130   default:
 131     break;
 132   }
 133   switch (allow_.nameStart()) {
 134   case GroupToken::name:
 135     fragment[nFragments++] = &ParserMessages::name;
 136     break;
 137   case GroupToken::nameToken:
 138     fragment[nFragments++] = &ParserMessages::nameToken;
 139     break;
 140   case GroupToken::elementToken:
 141     fragment[nFragments++] = &ParserMessages::elementToken;
 142     break;
 143   default:
 144     break;
 145   }
 146   Boolean first = 1;
 147   for (int i = 0; i < nFragments; i++) {
 148     if (!first)
 149       builder.appendFragment(ParserMessages::listSep);
 150     else
 151       first = 0;
 152     builder.appendFragment(*fragment[i]);
 153   }
 154   if (allow_.groupToken(GroupToken::pcdata)) {
 155     if (!first)
 156       builder.appendFragment(ParserMessages::listSep);
 157     StringC pcdata(syntax_->delimGeneral(Syntax::dRNI));
 158     pcdata += syntax_->reservedName(Syntax::rPCDATA);
 159     builder.appendChars(pcdata.data(), pcdata.size());
 160   }
 161 }
 162
 163 #ifdef SP_NAMESPACE
 164 }
 165 #endif