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