Bug 2477.

7 files changed, 168 insertions, 37 deletions

diff --git a/cpp/CHANGES b/cpp/CHANGES
index 1e567c310d2..76c290b1c06 100644
--- a/cpp/CHANGES
+++ b/cpp/CHANGES
@@ -11,6 +11,8 @@ Changes since version 3.2.X (binary incompatible)
   now generates a hyperlink to the base. (Previously, only
   the name of the base was shown, without a hyperlink.)
 
+- slice2html now generates documentation for Slice constant definitions.
+
 - slice2html now generates the scoped name for the <h1> element
   of each page instead of the unqualified name. For example,
   it now shows "Ice::DNSException" instead of "DNSException".
diff --git a/cpp/include/Slice/Parser.h b/cpp/include/Slice/Parser.h
index 8608af9b070..490875d91b1 100644
--- a/cpp/include/Slice/Parser.h
+++ b/cpp/include/Slice/Parser.h
@@ -134,11 +134,19 @@ typedef std::list<StructPtr> StructList;
 typedef std::list<SequencePtr> SequenceList;
 typedef std::list<DictionaryPtr> DictionaryList;
 typedef std::list<EnumPtr> EnumList;
+typedef std::list<ConstPtr> ConstList;
 typedef std::list<OperationPtr> OperationList;
 typedef std::list<DataMemberPtr> DataMemberList;
 typedef std::list<ParamDeclPtr> ParamDeclList;
 typedef std::list<EnumeratorPtr> EnumeratorList;
-typedef std::pair<SyntaxTreeBasePtr, std::string> SyntaxTreeBaseString;
+
+struct ConstDef
+{
+    TypePtr type;
+    SyntaxTreeBasePtr value;
+    std::string valueAsString;
+    std::string valueAsLiteral;
+};
 
 // ----------------------------------------------------------------------
 // CICompare -- function object to do case-insensitive string comparison.
@@ -406,7 +414,7 @@ public:
     EnumPtr createEnum(const std::string&, bool, NodeType = Real);
     EnumeratorPtr createEnumerator(const std::string&);
     ConstPtr createConst(const std::string, const TypePtr&, const StringList&, const SyntaxTreeBasePtr&,
-                         const std::string&, NodeType = Real);
+                         const std::string&, const std::string&, NodeType = Real);
     TypeList lookupType(const std::string&, bool = true);
     TypeList lookupTypeNoBuiltin(const std::string&, bool = true);
     ContainedList lookupContained(const std::string&, bool = true);
@@ -418,6 +426,7 @@ public:
     SequenceList sequences() const;
     DictionaryList dictionaries() const;
     EnumList enums() const;
+    ConstList consts() const;
     ContainedList contents() const;
     bool hasNonLocalClassDecls() const;
     bool hasNonLocalClassDefs() const;
@@ -840,6 +849,7 @@ public:
     TypePtr type() const;
     StringList typeMetaData() const;
     std::string value() const;
+    std::string literal() const;
     virtual bool uses(const ContainedPtr&) const;
     virtual ContainedType containedType() const;
     virtual std::string kindOf() const;
@@ -852,12 +862,14 @@ public:
 
 protected:
 
-    Const(const ContainerPtr&, const std::string&, const TypePtr&, const StringList&, const std::string&);
+    Const(const ContainerPtr&, const std::string&, const TypePtr&,
+          const StringList&, const std::string&, const std::string&);
     friend class Container;
 
     TypePtr _type;
     StringList _typeMetaData;
     std::string _value;
+    std::string _literal;
 };
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/Slice/Grammar.y b/cpp/src/Slice/Grammar.y
index 0e8b7274525..3b38486d84c 100644
--- a/cpp/src/Slice/Grammar.y
+++ b/cpp/src/Slice/Grammar.y
@@ -1588,9 +1588,12 @@ const_initializer
     IntegerTokPtr intVal = IntegerTokPtr::dynamicCast($1);
     ostringstream sstr;
     sstr << intVal->v;
-    SyntaxTreeBaseStringTokPtr basestring = new SyntaxTreeBaseStringTok;
-    basestring->v = pair<SyntaxTreeBasePtr,string>(type, sstr.str());
-    $$ = basestring;
+    ConstDefTokPtr def = new ConstDefTok;
+    def->v.type = type;
+    def->v.value = type;
+    def->v.valueAsString = sstr.str();
+    def->v.valueAsLiteral = intVal->literal;
+    $$ = def;
 }
 | ICE_FLOATING_POINT_LITERAL
 {
@@ -1598,18 +1601,24 @@ const_initializer
     FloatingTokPtr floatVal = FloatingTokPtr::dynamicCast($1);
     ostringstream sstr;
     sstr << floatVal->v;
-    SyntaxTreeBaseStringTokPtr basestring = new SyntaxTreeBaseStringTok;
-    basestring->v = pair<SyntaxTreeBasePtr,string>(type, sstr.str());
-    $$ = basestring;
+    ConstDefTokPtr def = new ConstDefTok;
+    def->v.type = type;
+    def->v.value = type;
+    def->v.valueAsString = sstr.str();
+    def->v.valueAsLiteral = floatVal->literal;
+    $$ = def;
 }
 | scoped_name
 {
     StringTokPtr scoped = StringTokPtr::dynamicCast($1);
-    SyntaxTreeBaseStringTokPtr basestring = new SyntaxTreeBaseStringTok;
+    ConstDefTokPtr def = new ConstDefTok;
     ContainedList cl = unit->currentContainer()->lookupContained(scoped->v);
     if(cl.empty())
     {
-    	basestring->v = pair<SyntaxTreeBasePtr,string>(TypePtr(0), scoped->v);
+        def->v.type = TypePtr(0);
+        def->v.value = TypePtr(0);
+        def->v.valueAsString = scoped->v;
+        def->v.valueAsLiteral = scoped->v;
     }
     else
     {
@@ -1627,33 +1636,45 @@ const_initializer
 	    unit->error(msg); // $$ is dummy
 	}
 	unit->currentContainer()->checkIntroduced(scoped->v, enumerator);
-	basestring->v = pair<SyntaxTreeBasePtr,string>(enumerator, scoped->v);
+        def->v.type = enumerator->type();
+        def->v.value = enumerator;
+        def->v.valueAsString = scoped->v;
+        def->v.valueAsLiteral = scoped->v;
     }
-    $$ = basestring;
+    $$ = def;
 }
 | ICE_STRING_LITERAL
 {
     BuiltinPtr type = unit->builtin(Builtin::KindString);
     StringTokPtr literal = StringTokPtr::dynamicCast($1);
-    SyntaxTreeBaseStringTokPtr basestring = new SyntaxTreeBaseStringTok;
-    basestring->v = pair<SyntaxTreeBasePtr,string>(type, literal->v);
-    $$ = basestring;
+    ConstDefTokPtr def = new ConstDefTok;
+    def->v.type = type;
+    def->v.value = type;
+    def->v.valueAsString = literal->v;
+    def->v.valueAsLiteral = literal->literal;
+    $$ = def;
 }
 | ICE_FALSE
 {
     BuiltinPtr type = unit->builtin(Builtin::KindBool);
     StringTokPtr literal = StringTokPtr::dynamicCast($1);
-    SyntaxTreeBaseStringTokPtr basestring = new SyntaxTreeBaseStringTok;
-    basestring->v = pair<SyntaxTreeBasePtr,string>(type, literal->v);
-    $$ = basestring;
+    ConstDefTokPtr def = new ConstDefTok;
+    def->v.type = type;
+    def->v.value = type;
+    def->v.valueAsString = literal->v;
+    def->v.valueAsLiteral = "false";
+    $$ = def;
 }
 | ICE_TRUE
 {
     BuiltinPtr type = unit->builtin(Builtin::KindBool);
     StringTokPtr literal = StringTokPtr::dynamicCast($1);
-    SyntaxTreeBaseStringTokPtr basestring = new SyntaxTreeBaseStringTok;
-    basestring->v = pair<SyntaxTreeBasePtr,string>(type, literal->v);
-    $$ = basestring;
+    ConstDefTokPtr def = new ConstDefTok;
+    def->v.type = type;
+    def->v.value = type;
+    def->v.valueAsString = literal->v;
+    def->v.valueAsLiteral = "true";
+    $$ = def;
 }
 ;
 
@@ -1665,17 +1686,19 @@ const_def
     StringListTokPtr metaData = StringListTokPtr::dynamicCast($2);
     TypePtr const_type = TypePtr::dynamicCast($3);
     StringTokPtr ident = StringTokPtr::dynamicCast($4);
-    SyntaxTreeBaseStringTokPtr value = SyntaxTreeBaseStringTokPtr::dynamicCast($6);
-    $$ = unit->currentContainer()->createConst(ident->v, const_type, metaData->v, value->v.first, value->v.second);
+    ConstDefTokPtr value = ConstDefTokPtr::dynamicCast($6);
+    $$ = unit->currentContainer()->createConst(ident->v, const_type, metaData->v,
+                                               value->v.value, value->v.valueAsString, value->v.valueAsLiteral);
 }
 | ICE_CONST meta_data type '=' const_initializer
 {
     StringListTokPtr metaData = StringListTokPtr::dynamicCast($2);
     TypePtr const_type = TypePtr::dynamicCast($3);
-    SyntaxTreeBaseStringTokPtr value = SyntaxTreeBaseStringTokPtr::dynamicCast($5);
+    ConstDefTokPtr value = ConstDefTokPtr::dynamicCast($5);
     unit->error("missing constant name");
-    $$ = unit->currentContainer()->createConst(IceUtil::generateUUID(), const_type, metaData->v, value->v.first,
-    					       value->v.second, Dummy); // Dummy
+    $$ = unit->currentContainer()->createConst(IceUtil::generateUUID(), const_type, metaData->v,
+                                               value->v.value, value->v.valueAsString,
+                                               value->v.valueAsLiteral, Dummy); // Dummy
 }
 ;
 
diff --git a/cpp/src/Slice/GrammarUtil.h b/cpp/src/Slice/GrammarUtil.h
index d8c6c9d3de6..8acd6e65667 100644
--- a/cpp/src/Slice/GrammarUtil.h
+++ b/cpp/src/Slice/GrammarUtil.h
@@ -25,7 +25,7 @@ class FloatingTok;
 class ExceptionListTok;
 class ClassListTok;
 class EnumeratorListTok;
-class SyntaxTreeBaseStringTok;
+class ConstDefTok;
 
 typedef ::IceUtil::Handle<StringTok> StringTokPtr;
 typedef ::IceUtil::Handle<StringListTok> StringListTokPtr;
@@ -37,7 +37,7 @@ typedef ::IceUtil::Handle<FloatingTok> FloatingTokPtr;
 typedef ::IceUtil::Handle<ExceptionListTok> ExceptionListTokPtr;
 typedef ::IceUtil::Handle<ClassListTok> ClassListTokPtr;
 typedef ::IceUtil::Handle<EnumeratorListTok> EnumeratorListTokPtr;
-typedef ::IceUtil::Handle<SyntaxTreeBaseStringTok> SyntaxTreeBaseStringTokPtr;
+typedef ::IceUtil::Handle<ConstDefTok> ConstDefTokPtr;
 
 // ----------------------------------------------------------------------
 // StringTok
@@ -49,6 +49,7 @@ public:
 
     StringTok() { }
     std::string v;
+    std::string literal;
 };
 
 // ----------------------------------------------------------------------
@@ -97,6 +98,7 @@ public:
 
     IntegerTok() { }
     IceUtil::Int64 v;
+    std::string literal;
 };
 
 // ----------------------------------------------------------------------
@@ -109,6 +111,7 @@ public:
 
     FloatingTok() { }
     double v;
+    std::string literal;
 };
 
 // ----------------------------------------------------------------------
@@ -160,15 +163,15 @@ public:
 };
 
 // ----------------------------------------------------------------------
-// SyntaxTreeBaseStringTok
+// ConstDefTok
 // ----------------------------------------------------------------------
 
-class SLICE_API SyntaxTreeBaseStringTok : public GrammarBase
+class SLICE_API ConstDefTok : public GrammarBase
 {
 public:
 
-    SyntaxTreeBaseStringTok() { }
-    SyntaxTreeBaseString v;
+    ConstDefTok() { }
+    ConstDef v;
 };
 
 }
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index e58f65d9ec6..e285263110e 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -1022,7 +1022,8 @@ Slice::Container::createEnumerator(const string& name)
 
 ConstPtr
 Slice::Container::createConst(const string name, const TypePtr& constType, const StringList& metaData,
-                              const SyntaxTreeBasePtr& literalType, const string& value, NodeType nt)
+                              const SyntaxTreeBasePtr& literalType, const string& value, const string& literal,
+                              NodeType nt)
 {
     checkPrefix(name);
 
@@ -1083,7 +1084,7 @@ Slice::Container::createConst(const string name, const TypePtr& constType, const
         return 0;
     }
 
-    ConstPtr p = new Const(this, name, constType, metaData, value);
+    ConstPtr p = new Const(this, name, constType, metaData, value, literal);
     _contents.push_back(p);
     return p;
 }
@@ -1448,6 +1449,21 @@ Slice::Container::enums() const
     return result;
 }
 
+ConstList
+Slice::Container::consts() const
+{
+    ConstList result;
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        ConstPtr q = ConstPtr::dynamicCast(*p);
+        if(q)
+        {
+            result.push_back(q);
+        }
+    }
+    return result;
+}
+
 ContainedList
 Slice::Container::contents() const
 {
@@ -4092,6 +4108,12 @@ Slice::Const::value() const
     return _value;
 }
 
+string
+Slice::Const::literal() const
+{
+    return _literal;
+}
+
 Contained::ContainedType
 Slice::Const::containedType() const
 {
@@ -4315,12 +4337,13 @@ Slice::Const::isInRange(const string& name, const TypePtr& constType, const stri
 }
 
 Slice::Const::Const(const ContainerPtr& container, const string& name, const TypePtr& type,
-                    const StringList& typeMetaData, const string& value) :
+                    const StringList& typeMetaData, const string& value, const string& literal) :
     SyntaxTreeBase(container->unit()), 
     Contained(container, name),
     _type(type), 
     _typeMetaData(typeMetaData),
-    _value(value)
+    _value(value),
+    _literal(literal)
 {
 }
 
diff --git a/cpp/src/Slice/Scanner.l b/cpp/src/Slice/Scanner.l
index bfad0da0545..ab223e51bdc 100644
--- a/cpp/src/Slice/Scanner.l
+++ b/cpp/src/Slice/Scanner.l
@@ -177,9 +177,11 @@ floating_literal	(({fractional_constant}{exponent_part}?)|((\+|-)?[[:digit:]]+{e
 
 \" {
     StringTokPtr str = new StringTok;
+    str->literal = "\"";
     while(true)
     {
 	char c = static_cast<char>(yyinput());
+        str->literal += c;
 	if(c == '"')
 	{
 	    break;
@@ -196,6 +198,7 @@ floating_literal	(({fractional_constant}{exponent_part}?)|((\+|-)?[[:digit:]]+{e
 	else if(c == '\\')
 	{
 	    char next = static_cast<char>(yyinput());
+            str->literal += next;
 	    switch(next)
 	    {
 		case '\\':
@@ -263,6 +266,7 @@ floating_literal	(({fractional_constant}{exponent_part}?)|((\+|-)?[[:digit:]]+{e
 		    unsigned short us = next - '0';
 		    if(octalDigits.find_first_of(next = static_cast<char>(yyinput())) != string::npos)
 		    {
+                        str->literal += next;
 		    	us = us * 8 + next - '0';
 			if(octalDigits.find_first_of(next = static_cast<char>(yyinput())) != string::npos)
 			{
@@ -289,6 +293,7 @@ floating_literal	(({fractional_constant}{exponent_part}?)|((\+|-)?[[:digit:]]+{e
 		    IceUtil::Int64 ull = 0;
 		    while(isxdigit(next = static_cast<char>(yyinput())))
 		    {
+                        str->literal += next;
 			ull *= 16;
 			if(isdigit(next))
 			{
@@ -332,6 +337,7 @@ floating_literal	(({fractional_constant}{exponent_part}?)|((\+|-)?[[:digit:]]+{e
 
 {integer_constant} {
     IntegerTokPtr itp = new IntegerTok;
+    itp->literal = string(yytext);
     *yylvalp = itp;
     if(!IceUtil::stringToInt64(string(yytext), itp->v))
     {
@@ -349,6 +355,7 @@ floating_literal	(({fractional_constant}{exponent_part}?)|((\+|-)?[[:digit:]]+{e
     FloatingTokPtr ftp = new FloatingTok;
     *yylvalp = ftp;
     string literal(yytext);
+    ftp->literal = literal;
     char lastChar = literal[literal.size() - 1];
     if(lastChar == 'f' || lastChar == 'F')
     {
diff --git a/cpp/src/slice2html/Gen.cpp b/cpp/src/slice2html/Gen.cpp
index e88d3d7e2ea..8a946ca2dfc 100644
--- a/cpp/src/slice2html/Gen.cpp
+++ b/cpp/src/slice2html/Gen.cpp
@@ -2127,6 +2127,27 @@ Slice::ModuleGenerator::visitContainer(const ContainerPtr& p)
         end();
     }
 
+    ConstList consts = p->consts();
+
+    if(!consts.empty())
+    {
+        start("h2");
+        _out << "Constant Index";
+        end();
+        start("dl");
+        for(ConstList::const_iterator q = consts.begin(); q != consts.end(); ++q)
+        {
+            start("dt", "Symbol");
+            _out << toString(*q, p, false, true);
+            end();
+            start("dd");
+            string metadata;
+            printSummary(*q, p, (*q)->findMetaData("deprecate", metadata));
+            end();
+        }
+        end();
+    }
+
     assert(_out.currIndent() == indent);
 
     if(!sequences.empty())
@@ -2204,6 +2225,46 @@ Slice::ModuleGenerator::visitContainer(const ContainerPtr& p)
             end();
         }
     }
+
+    if(!consts.empty())
+    {
+        start("h2");
+        _out << "Constants";
+        end();
+        for(ConstList::const_iterator q = consts.begin(); q != consts.end(); ++q)
+        {
+            start("dl");
+            start("dt");
+            start("span", "Synopsis");
+            _out << "const " << toString((*q)->type(), p, false, true) << " " << toString(*q, p) << " = ";
+            if(EnumPtr::dynamicCast((*q)->type()))
+            {
+                _out << toString((*q)->value(), p, false, true);
+            }
+            else
+            {
+                 _out << (*q)->literal();
+            }
+            _out << ";";
+            end();
+            end();
+
+            start("dd");
+            string metadata, deprecateReason;
+            if((*q)->findMetaData("deprecate", metadata))
+            {
+                deprecateReason = "This type is deprecated.";
+                if(metadata.find("deprecate:") == 0 && metadata.size() > 10)
+                {
+                    deprecateReason = metadata.substr(10);
+                }
+            }
+
+            printComment(*q, p, deprecateReason, true);
+            end();
+            end();
+        }
+    }
 }
 
 Slice::ExceptionGenerator::ExceptionGenerator(XMLOutput& o, const Files& files)