summaryrefslogtreecommitdiff
path: root/cpp/src
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/src')
-rw-r--r--cpp/src/Freeze/EvictorI.cpp12
-rw-r--r--cpp/src/Freeze/EvictorI.h4
-rw-r--r--cpp/src/Ice/Object.cpp14
-rw-r--r--cpp/src/Slice/Grammer.y130
-rw-r--r--cpp/src/Slice/GrammerUtil.h14
-rw-r--r--cpp/src/Slice/Parser.cpp43
-rw-r--r--cpp/src/Slice/Scanner.l137
-rw-r--r--cpp/src/slice2cpp/Gen.cpp14
-rw-r--r--cpp/src/slice2docbook/Gen.cpp92
-rw-r--r--cpp/src/slice2docbook/Gen.h1
10 files changed, 352 insertions, 109 deletions
diff --git a/cpp/src/Freeze/EvictorI.cpp b/cpp/src/Freeze/EvictorI.cpp
index dc402c0bf89..c3c8404a54b 100644
--- a/cpp/src/Freeze/EvictorI.cpp
+++ b/cpp/src/Freeze/EvictorI.cpp
@@ -33,6 +33,16 @@ Freeze::EvictorI::EvictorI(const DBPtr& db, const CommunicatorPtr& communicator)
}
}
+DBPtr
+Freeze::EvictorI::getDB()
+{
+ //
+ // No synchronizaton necessary, _db is immutable once the Evictor
+ // has been created
+ //
+ return _db;
+}
+
void
Freeze::EvictorI::setSize(Int evictorSize)
{
@@ -234,7 +244,7 @@ Freeze::EvictorI::finished(const ObjectAdapterPtr&, const string& identity, cons
//
if (_persistenceMode == SaveAfterMutatingOperation)
{
- if (servant->_isMutating(operation))
+ if (servant->__isMutating(operation))
{
_db->put(identity, servant);
}
diff --git a/cpp/src/Freeze/EvictorI.h b/cpp/src/Freeze/EvictorI.h
index 89164c8d17e..7252dd2db32 100644
--- a/cpp/src/Freeze/EvictorI.h
+++ b/cpp/src/Freeze/EvictorI.h
@@ -24,7 +24,9 @@ class EvictorI : public Evictor, public JTCMutex
public:
EvictorI(const Freeze::DBPtr&, const Ice::CommunicatorPtr&);
-
+
+ virtual DBPtr getDB();
+
virtual void setSize(Ice::Int);
virtual Ice::Int getSize();
diff --git a/cpp/src/Ice/Object.cpp b/cpp/src/Ice/Object.cpp
index a97fc148d9c..4c005c6df60 100644
--- a/cpp/src/Ice/Object.cpp
+++ b/cpp/src/Ice/Object.cpp
@@ -104,12 +104,16 @@ string Ice::Object::__names[] =
"_ping"
};
+string Ice::Object::__mutating[] =
+{
+};
+
DispatchStatus
-Ice::Object::__dispatch(Incoming& in, const string& name)
+Ice::Object::__dispatch(Incoming& in, const string& s)
{
string* b = __names;
string* e = __names + sizeof(__names) / sizeof(string);
- pair<string*, string*> r = equal_range(b, e, name);
+ pair<string*, string*> r = equal_range(b, e, s);
if (r.first == r.second)
{
return DispatchOperationNotExist;
@@ -132,7 +136,9 @@ Ice::Object::__dispatch(Incoming& in, const string& name)
}
bool
-Ice::Object::_isMutating(const std::string&)
+Ice::Object::__isMutating(const std::string& s)
{
- return false;
+ string* b = __mutating;
+ string* e = __mutating + sizeof(__mutating) / sizeof(string);
+ return ::std::binary_search(b, e, s);
}
diff --git a/cpp/src/Slice/Grammer.y b/cpp/src/Slice/Grammer.y
index ad41425efcf..3d01167da24 100644
--- a/cpp/src/Slice/Grammer.y
+++ b/cpp/src/Slice/Grammer.y
@@ -61,6 +61,7 @@ yyerror(const char* s)
%token ICE_SCOPE_DELIMITOR
%token ICE_IDENTIFIER
%token ICE_OP_IDENTIFIER
+%token ICE_OP_KEYWORD
%%
@@ -191,6 +192,10 @@ struct_decl
{
unit->error("structs can not be forward declared");
}
+| ICE_STRUCT keyword
+{
+ unit->error("keyword can not be used as struct name");
+}
;
// ----------------------------------------------------------------------
@@ -211,6 +216,13 @@ struct_def
{
unit->popContainer();
}
+| ICE_STRUCT keyword
+{
+ unit->error("keyword can not be used as struct name");
+}
+'{' struct_exports '}'
+{
+}
;
// ----------------------------------------------------------------------
@@ -286,6 +298,10 @@ class_decl
ContainerPtr cont = unit->currentContainer();
ClassDeclPtr cl = cont->createClassDecl(ident->v, local->v, false);
}
+| local ICE_CLASS keyword
+{
+ unit->error("keyword can not be used as class name");
+}
;
// ----------------------------------------------------------------------
@@ -313,6 +329,13 @@ class_def
{
unit->popContainer();
}
+| local ICE_CLASS keyword class_extends implements
+{
+ unit->error("keyword can not be used as class name");
+}
+'{' class_exports '}'
+{
+}
;
// ----------------------------------------------------------------------
@@ -380,6 +403,10 @@ interface_decl
ContainerPtr cont = unit->currentContainer();
ClassDeclPtr cl = cont->createClassDecl(ident->v, local->v, true);
}
+| local ICE_INTERFACE keyword
+{
+ unit->error("keyword can not be used as interface name");
+}
;
// ----------------------------------------------------------------------
@@ -402,6 +429,13 @@ interface_def
{
unit->popContainer();
}
+| local ICE_INTERFACE keyword interface_extends
+{
+ unit->error("keyword can not be used as interface name");
+}
+'{' interface_exports '}'
+{
+}
;
// ----------------------------------------------------------------------
@@ -501,7 +535,10 @@ operation
TypeStringListTokPtr outParms = TypeStringListTokPtr::dynamicCast($4);
TypeListTokPtr throws = TypeListTokPtr::dynamicCast($6);
ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
- cl->createOperation(name->v, returnType, inParms->v, outParms->v, throws->v, false);
+ if (cl)
+ {
+ cl->createOperation(name->v, returnType, inParms->v, outParms->v, throws->v, false);
+ }
}
| ICE_NONMUTATING return_type ICE_OP_IDENTIFIER parameters output_parameters ')' throws
{
@@ -511,8 +548,20 @@ operation
TypeStringListTokPtr outParms = TypeStringListTokPtr::dynamicCast($5);
TypeListTokPtr throws = TypeListTokPtr::dynamicCast($7);
ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
- cl->createOperation(name->v, returnType, inParms->v, outParms->v, throws->v, true);
+ if (cl)
+ {
+ cl->createOperation(name->v, returnType, inParms->v, outParms->v, throws->v, true);
+ }
+}
+| return_type ICE_OP_KEYWORD parameters output_parameters ')' throws
+{
+ unit->error("keyword can not be used as operation name");
}
+| ICE_NONMUTATING return_type ICE_OP_KEYWORD parameters output_parameters ')' throws
+{
+ unit->error("keyword can not be used as operation name");
+}
+;
// ----------------------------------------------------------------------
parameters
@@ -594,16 +643,18 @@ data_member
ClassDefPtr cl = ClassDefPtr::dynamicCast(unit->currentContainer());
if (cl)
{
- assert(!cl->isInterface());
cl->createDataMember(ident->v, type);
}
- else
+ StructPtr st = StructPtr::dynamicCast(unit->currentContainer());
+ if (st)
{
- StructPtr st = StructPtr::dynamicCast(unit->currentContainer());
- assert(st);
st->createDataMember(ident->v, type);
}
}
+| type keyword
+{
+ unit->error("keyword can not be used as data member name");
+}
;
// ----------------------------------------------------------------------
@@ -735,6 +786,10 @@ native_def
ContainerPtr cont = unit->currentContainer();
cont->createNative(ident->v);
}
+| ICE_NATIVE keyword
+{
+ unit->error("keyword can not be used as native name");
+}
;
// ----------------------------------------------------------------------
@@ -747,6 +802,10 @@ sequence_def
ContainerPtr cont = unit->currentContainer();
cont->createSequence(ident->v, type);
}
+| ICE_SEQUENCE '<' type '>' keyword
+{
+ unit->error("keyword can not be used as sequence name");
+}
;
// ----------------------------------------------------------------------
@@ -760,47 +819,73 @@ dictionary_def
ContainerPtr cont = unit->currentContainer();
cont->createDictionary(ident->v, keyType, valueType);
}
+| ICE_DICTIONARY '<' type ',' type '>' keyword
+{
+ unit->error("keyword can not be used as dictionary name");
+}
;
// ----------------------------------------------------------------------
enum_def
// ----------------------------------------------------------------------
-: ICE_ENUM ICE_IDENTIFIER '{' identifier_list '}'
+: ICE_ENUM ICE_IDENTIFIER
{
StringTokPtr ident = StringTokPtr::dynamicCast($2);
- StringListTokPtr enumerators = StringListTokPtr::dynamicCast($4);
ContainerPtr cont = unit->currentContainer();
- EnumPtr en = cont->createEnum(ident->v, enumerators->v);
+ EnumPtr en = cont->createEnum(ident->v);
+ $$ = en;
+}
+'{' enumerator_list '}'
+{
+ EnumPtr en = EnumPtr::dynamicCast($3);
+ EnumeratorListTokPtr enumerators = EnumeratorListTokPtr::dynamicCast($5);
+ en->setEnumerators(enumerators->v);
+}
+| ICE_ENUM keyword
+{
+ unit->error("keyword can not be used as enum name");
+}
+'{' enumerator_list '}'
+{
}
;
// ----------------------------------------------------------------------
-identifier_list
+enumerator_list
// ----------------------------------------------------------------------
-: ICE_IDENTIFIER ',' identifier_list
+: enumerator ',' enumerator_list
{
- StringTokPtr ident = StringTokPtr::dynamicCast($1);
- StringListTokPtr ens = StringListTokPtr::dynamicCast($3);
+ EnumeratorListTokPtr ens = EnumeratorListTokPtr::dynamicCast($1);
+ ens->v.splice(ens->v.end(), EnumeratorListTokPtr::dynamicCast($3)->v);
$$ = ens;
- ContainerPtr cont = unit->currentContainer();
- EnumeratorPtr en = cont->createEnumerator(ident->v);
- if (en)
- {
- ens->v.push_front(ident->v);
- }
}
-| ICE_IDENTIFIER
+| enumerator
+{
+ $$ = $1;
+}
+;
+
+// ----------------------------------------------------------------------
+enumerator
+// ----------------------------------------------------------------------
+: ICE_IDENTIFIER
{
StringTokPtr ident = StringTokPtr::dynamicCast($1);
- StringListTokPtr ens = new StringListTok;
+ EnumeratorListTokPtr ens = new EnumeratorListTok;
$$ = ens;
ContainerPtr cont = unit->currentContainer();
EnumeratorPtr en = cont->createEnumerator(ident->v);
if (en)
{
- ens->v.push_front(ident->v);
+ ens->v.push_front(en);
}
}
+| keyword
+{
+ unit->error("keyword can not be used as enumerator");
+ EnumeratorListTokPtr ens = new EnumeratorListTok;
+ $$ = ens;
+}
;
// ----------------------------------------------------------------------
@@ -904,5 +989,6 @@ keyword
| ICE_NONMUTATING
{
}
+;
%%
diff --git a/cpp/src/Slice/GrammerUtil.h b/cpp/src/Slice/GrammerUtil.h
index e8a354f4541..4641c6d49fc 100644
--- a/cpp/src/Slice/GrammerUtil.h
+++ b/cpp/src/Slice/GrammerUtil.h
@@ -22,6 +22,7 @@ class StringListTok;
class BoolTok;
class TypeListTok;
class ClassListTok;
+class EnumeratorListTok;
typedef ::IceUtil::Handle<StringTok> StringTokPtr;
typedef ::IceUtil::Handle<TypeStringListTok> TypeStringListTokPtr;
@@ -29,6 +30,7 @@ typedef ::IceUtil::Handle<StringListTok> StringListTokPtr;
typedef ::IceUtil::Handle<BoolTok> BoolTokPtr;
typedef ::IceUtil::Handle<TypeListTok> TypeListTokPtr;
typedef ::IceUtil::Handle<ClassListTok> ClassListTokPtr;
+typedef ::IceUtil::Handle<EnumeratorListTok> EnumeratorListTokPtr;
}
@@ -107,6 +109,18 @@ public:
ClassList v;
};
+// ----------------------------------------------------------------------
+// EnumeratorListTok
+// ----------------------------------------------------------------------
+
+class SLICE_API EnumeratorListTok : public GrammerBase
+{
+public:
+
+ EnumeratorListTok() { }
+ EnumeratorList v;
+};
+
}
#endif
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index 3aa831637bb..d2aa25f17f7 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -60,7 +60,7 @@ Slice::Type::Type(const UnitPtr& unit) :
// Builtin
// ----------------------------------------------------------------------
-Slice::Builtin::Kind
+Builtin::Kind
Slice::Builtin::kind()
{
return _kind;
@@ -484,7 +484,7 @@ Slice::Container::createDictionary(const string& name, const TypePtr& keyType, c
}
EnumPtr
-Slice::Container::createEnum(const string& name, const StringList& enumerators)
+Slice::Container::createEnum(const string& name)
{
ContainedList matches = _unit->findContents(thisScope() + name);
if (!matches.empty())
@@ -511,7 +511,7 @@ Slice::Container::createEnum(const string& name, const StringList& enumerators)
return 0;
}
- EnumPtr p = new Enum(this, name, enumerators);
+ EnumPtr p = new Enum(this, name);
_contents.push_back(p);
return p;
}
@@ -1071,7 +1071,7 @@ Slice::Container::checkInterfaceAndLocal(const string& name, bool defined,
// Module
// ----------------------------------------------------------------------
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::Module::containedType()
{
return ContainedTypeModule;
@@ -1132,7 +1132,7 @@ Slice::ClassDecl::isInterface()
return _interface;
}
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::ClassDecl::containedType()
{
return ContainedTypeClass;
@@ -1400,7 +1400,7 @@ Slice::ClassDef::hasDataMembers()
return _hasDataMembers;
}
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::ClassDef::containedType()
{
return ContainedTypeClass;
@@ -1530,7 +1530,7 @@ Slice::Struct::dataMembers()
return result;
}
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::Struct::containedType()
{
return ContainedTypeStruct;
@@ -1594,7 +1594,7 @@ Slice::Operation::nonmutating()
return _nonmutating;
}
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::Operation::containedType()
{
return ContainedTypeOperation;
@@ -1629,7 +1629,7 @@ Slice::DataMember::type()
return _type;
}
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::DataMember::containedType()
{
return ContainedTypeDataMember;
@@ -1652,7 +1652,7 @@ Slice::DataMember::DataMember(const ContainerPtr& container, const string& name,
// Native
// ----------------------------------------------------------------------
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::Native::containedType()
{
return ContainedTypeNative;
@@ -1682,7 +1682,7 @@ Slice::Sequence::type()
return _type;
}
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::Sequence::containedType()
{
return ContainedTypeSequence;
@@ -1719,7 +1719,7 @@ Slice::Dictionary::valueType()
return _valueType;
}
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::Dictionary::containedType()
{
return ContainedTypeDictionary;
@@ -1746,13 +1746,19 @@ Slice::Dictionary::Dictionary(const ContainerPtr& container, const string& name,
// Enum
// ----------------------------------------------------------------------
-Slice::StringList
-Slice::Enum::enumerators()
+EnumeratorList
+Slice::Enum::getEnumerators()
{
return _enumerators;
}
-Slice::Contained::ContainedType
+void
+Slice::Enum::setEnumerators(const EnumeratorList& ens)
+{
+ _enumerators = ens;
+}
+
+Contained::ContainedType
Slice::Enum::containedType()
{
return ContainedTypeEnum;
@@ -1764,12 +1770,11 @@ Slice::Enum::visit(ParserVisitor* visitor)
visitor->visitEnum(this);
}
-Slice::Enum::Enum(const ContainerPtr& container, const string& name, const StringList& enumerators) :
+Slice::Enum::Enum(const ContainerPtr& container, const string& name) :
Constructed(container, name),
Type(container->unit()),
Contained(container, name),
- SyntaxTreeBase(container->unit()),
- _enumerators(enumerators)
+ SyntaxTreeBase(container->unit())
{
}
@@ -1777,7 +1782,7 @@ Slice::Enum::Enum(const ContainerPtr& container, const string& name, const Strin
// Enumerator
// ----------------------------------------------------------------------
-Slice::Contained::ContainedType
+Contained::ContainedType
Slice::Enumerator::containedType()
{
return ContainedTypeEnumerator;
diff --git a/cpp/src/Slice/Scanner.l b/cpp/src/Slice/Scanner.l
index 5956871df0e..916b7b6935d 100644
--- a/cpp/src/Slice/Scanner.l
+++ b/cpp/src/Slice/Scanner.l
@@ -21,26 +21,21 @@ using namespace Slice;
%option noyywrap
%option never-interactive
-WS [ \t\v\n\r\f]
-S [ \t]
-D [0-9]
-L [a-zA-Z_]
-
%%
-^"#"{S}*{D}+{S}*$ {
+^"#"[[:blank:]]*[[:digit:]]+[[:blank:]]*$ {
unit->scanPosition(yytext);
}
-^"#"{S}*{D}+{S}+"\""[^\"]*"\"".*$ {
+^"#"[[:blank:]]*[[:digit:]]+[[:blank:]]+"\""[^\"]*"\"".*$ {
unit->scanPosition(yytext);
}
-^"#"{S}*"line"{S}+{D}+{S}*$ {
+^"#"[[:blank:]]*"line"[[:blank:]]+[[:digit:]]+[[:blank:]]*$ {
unit->scanPosition(yytext);
}
-^"#"{S}*"line"{S}+{D}+{S}+"\""[^\"]*"\"".*$ {
+^"#"[[:blank:]]*"line"[[:blank:]]+[[:digit:]]+[[:blank:]]+"\""[^\"]*"\"".*$ {
unit->scanPosition(yytext);
}
@@ -101,132 +96,218 @@ L [a-zA-Z_]
return ICE_MODULE;
}
+"module"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"class" {
return ICE_CLASS;
}
+"class"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"interface" {
return ICE_INTERFACE;
}
+"interface"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"struct" {
return ICE_STRUCT;
}
+"struct"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"local" {
return ICE_LOCAL;
}
+"local"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"extends" {
return ICE_EXTENDS;
}
+"extends"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"implements" {
return ICE_IMPLEMENTS;
}
+"implements"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"throws" {
return ICE_THROWS;
}
+"throws"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"void" {
return ICE_VOID;
}
+"void"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"byte" {
return ICE_BYTE;
}
+"byte"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"bool" {
return ICE_BOOL;
}
+"bool"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"short" {
return ICE_SHORT;
}
+"short"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"int" {
return ICE_INT;
}
+"int"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"long" {
return ICE_LONG;
}
+"long"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"float" {
return ICE_FLOAT;
}
+"float"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"double" {
return ICE_DOUBLE;
}
+"double"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"string" {
return ICE_STRING;
}
+"string"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"wstring" {
return ICE_WSTRING;
}
+"wstring"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"Object" {
return ICE_OBJECT;
}
+"Object"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"LocalObject" {
return ICE_LOCAL_OBJECT;
}
+"LocalObject"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"native" {
return ICE_NATIVE;
}
+"native"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"sequence" {
return ICE_SEQUENCE;
}
+"sequence"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"dictionary" {
return ICE_DICTIONARY;
}
+"dictionary"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"enum" {
return ICE_ENUM;
}
+"enum"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
"nonmutating" {
return ICE_NONMUTATING;
}
-"\\"?{L}({L}|{D})* {
- char* s = yytext;
-
- if (s[0] == '\\') // Strip leading backslash
- {
- ++s;
- }
-
+"nonmutating"[[:space:]]*"(" {
+ return ICE_OP_KEYWORD;
+}
+
+[[:alpha:]_][[:alnum:]_]* {
StringTokPtr ident = new StringTok;
- ident->v = s;
+ ident->v = yytext;
*yylvalp = ident;
return ICE_IDENTIFIER;
}
-"\\"?{L}({L}|{D})*{WS}*"(" {
- char* s = yytext;
-
- if (s[0] == '\\') // Strip leading backslash
- {
- ++s;
- }
-
+[[:alpha:]_][[:alnum:]_]*[[:space:]]*"(" {
StringTokPtr ident = new StringTok;
- ident->v = s;
+ ident->v = yytext;
ident->v.erase(ident->v.find_first_of(" \t\v\n\r\f("));
*yylvalp = ident;
return ICE_OP_IDENTIFIER;
}
-{WS} {
+[[:space:]] {
// Igore white-space
if (yytext[0] == '\n')
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index 93b0172359e..95ff7ec2e49 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -437,14 +437,14 @@ void
Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
{
string name = p->name();
- StringList enumerators = p->enumerators();
+ EnumeratorList enumerators = p->getEnumerators();
H << sp;
H << nl << "enum " << name;
H << sb;
- StringList::iterator en = enumerators.begin();
+ EnumeratorList::iterator en = enumerators.begin();
while (en != enumerators.end())
{
- H << nl << *en;
+ H << nl << (*en)->name();
if (++en != enumerators.end())
{
H << ',';
@@ -1545,9 +1545,9 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
H << nl << exp2 << "static ::std::string __mutating[" << allMutatingOpNames.size() << "];";
H << nl << exp2 << "virtual ::IceInternal::DispatchStatus "
<< "__dispatch(::IceInternal::Incoming&, const ::std::string&);";
- H << nl << exp2 << "virtual bool _isMutating(const ::std::string&);";
+ H << nl << exp2 << "virtual bool __isMutating(const ::std::string&);";
C << sp;
- C << nl << "::std::string " << scoped.substr(2) << "::__all[" << allOpNames.size() << "] =";
+ C << nl << "::std::string " << scoped.substr(2) << "::__all[] =";
C << sb;
q = allOpNames.begin();
while (q != allOpNames.end())
@@ -1560,7 +1560,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
}
C << eb << ';';
C << sp;
- C << nl << "::std::string " << scoped.substr(2) << "::__mutating[" << allMutatingOpNames.size() << "] =";
+ C << nl << "::std::string " << scoped.substr(2) << "::__mutating[] =";
C << sb;
q = allMutatingOpNames.begin();
while (q != allMutatingOpNames.end())
@@ -1601,7 +1601,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
C << eb;
C << sp;
C << nl << "bool" << nl << scoped.substr(2)
- << "::_isMutating(const ::std::string& s)";
+ << "::__isMutating(const ::std::string& s)";
C << sb;
C << nl << "::std::string* b = __mutating;";
C << nl << "::std::string* e = __mutating + " << allMutatingOpNames.size() << ';';
diff --git a/cpp/src/slice2docbook/Gen.cpp b/cpp/src/slice2docbook/Gen.cpp
index c3d16d4d726..ee3e6b952b3 100644
--- a/cpp/src/slice2docbook/Gen.cpp
+++ b/cpp/src/slice2docbook/Gen.cpp
@@ -322,33 +322,6 @@ Slice::Gen::visitContainer(const ContainerPtr& p)
end();
}
}
-
- {
- for (EnumList::iterator q = enums.begin(); q != enums.end(); ++q)
- {
- start("section id=" + containedToId(*q), (*q)->name());
-
- O.zeroIndent();
- O << nl << "<synopsis>enum <type>" << (*q)->name() << "</type>";
- O << sb;
- StringList enumerators = (*q)->enumerators();
- StringList::iterator r = enumerators.begin();
- while (r != enumerators.end())
- {
- O << nl << "<structfield>" << *r << "</structfield>";
- if (++r != enumerators.end())
- {
- O << ',';
- }
- }
- O << eb << ";</synopsis>";
- O.restoreIndent();
-
- printComment(*q);
-
- end();
- }
- }
{
for (NativeList::iterator q = natives.begin(); q != natives.end(); ++q)
@@ -629,6 +602,63 @@ Slice::Gen::visitStructStart(const StructPtr& p)
}
void
+Slice::Gen::visitEnum(const EnumPtr& p)
+{
+ start(_chapter + " id=" + containedToId(p), p->scoped().substr(2));
+
+ start("section", "Overview");
+ O.zeroIndent();
+ O << nl << "<synopsis>";
+ O << "enum <type>" << p->name() << "</type>";
+ O << "</synopsis>";
+ O.restoreIndent();
+
+ printComment(p);
+
+ EnumeratorList enumerators = p->getEnumerators();
+ enumerators.sort();
+ if (!enumerators.empty())
+ {
+ start("section", "Enumerator Index");
+ start("variablelist");
+
+ for (EnumeratorList::iterator q = enumerators.begin(); q != enumerators.end(); ++q)
+ {
+ start("varlistentry");
+ start("term");
+ O << nl << toString(*q, p->container());
+ end();
+ start("listitem");
+ printSummary(*q);
+ end();
+ end();
+ }
+
+ end();
+ end();
+ }
+
+ end();
+
+ {
+ for (EnumeratorList::iterator q = enumerators.begin(); q != enumerators.end(); ++q)
+ {
+ start("section id=" + containedToId(*q), (*q)->name());
+
+ O.zeroIndent();
+ O << nl << "<synopsis><constant>" << (*q)->name() << "</constant></synopsis>";
+ O.restoreIndent();
+
+ printComment(*q);
+
+ end();
+ }
+ }
+
+ end();
+}
+
+void
Slice::Gen::printHeader()
{
static const char* header =
@@ -994,6 +1024,14 @@ Slice::Gen::toString(const SyntaxTreeBasePtr& p, const ContainerPtr& container)
tag = "structname";
}
+ EnumeratorPtr en = EnumeratorPtr::dynamicCast(p);
+ if (en)
+ {
+ linkend = containedToId(en);
+ s = getScopedMinimized(en, container);
+ tag = "constant";
+ }
+
if (s.empty())
{
ContainedPtr contained = ContainedPtr::dynamicCast(p);
diff --git a/cpp/src/slice2docbook/Gen.h b/cpp/src/slice2docbook/Gen.h
index 3d005d1f6c7..ed2bde5dbb3 100644
--- a/cpp/src/slice2docbook/Gen.h
+++ b/cpp/src/slice2docbook/Gen.h
@@ -35,6 +35,7 @@ public:
virtual void visitContainer(const ContainerPtr&);
virtual bool visitClassDefStart(const ClassDefPtr&);
virtual bool visitStructStart(const StructPtr&);
+ virtual void visitEnum(const EnumPtr&);
private:
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-05 22:51:33 +0000