Merge branch 'master' of github.com:doxygen/doxygen

3 files changed, 513 insertions, 241 deletions

diff --git a/src/docparser.cpp b/src/docparser.cpp
index 20ee1f0..4b1ce94 100644
--- a/src/docparser.cpp
+++ b/src/docparser.cpp
@@ -616,16 +616,28 @@ static void detectNoDocumentedParams()
         g_memberDef->setHasDocumentedParams(TRUE);
       }
     }
-    //printf("Member %s hadDocumentedReturnType()=%d hasReturnCommand=%d\n",
+    //printf("Member %s hasDocumentedReturnType()=%d hasReturnCommand=%d\n",
     //    g_memberDef->name().data(),g_memberDef->hasDocumentedReturnType(),g_hasReturnCommand);
     if (!g_memberDef->hasDocumentedReturnType() && // docs not yet found
         g_hasReturnCommand)
     {
       g_memberDef->setHasDocumentedReturnType(TRUE);
     }
+    else if ( // see if return type is documented in a function w/o return type
+        g_hasReturnCommand &&
+        (//returnType.isEmpty()              || // empty return type
+         returnType.find("void")!=-1       || // void return type
+         returnType.find("subroutine")!=-1 || // fortran subroutine
+         g_memberDef->isConstructor()      || // a constructor
+         g_memberDef->isDestructor()          // or destructor
+        )
+       )
+    {
+      warn_doc_error(g_fileName,doctokenizerYYlineno,"documented empty return type of  %s",g_memberDef->qualifiedName().data());
+    }
     else if ( // see if return needs to documented 
         g_memberDef->hasDocumentedReturnType() ||
-        returnType.isEmpty()         || // empty return type
+        //returnType.isEmpty()         || // empty return type
         returnType.find("void")!=-1  || // void return type
         returnType.find("subroutine")!=-1 || // fortran subroutine
         g_memberDef->isConstructor() || // a constructor
@@ -634,18 +646,6 @@ static void detectNoDocumentedParams()
     {
       g_memberDef->setHasDocumentedReturnType(TRUE);
     }
-    else if ( // see if return type is documented in a function w/o return type
-        g_memberDef->hasDocumentedReturnType() &&
-        (returnType.isEmpty()              || // empty return type
-         returnType.find("void")!=-1       || // void return type
-         returnType.find("subroutine")!=-1 || // fortran subroutine
-         g_memberDef->isConstructor()      || // a constructor
-         g_memberDef->isDestructor()          // or destructor
-        )
-       )
-    {
-      warn_doc_error(g_fileName,doctokenizerYYlineno,"documented empty return type");
-    }
   }
 }
 
diff --git a/src/translator_br.h b/src/translator_br.h
index c2d079a..01c5b9f 100644
--- a/src/translator_br.h
+++ b/src/translator_br.h
@@ -18,6 +18,8 @@
  *    Thanks to Jorge Ramos, Fernando Carijo and others for their contributions.
  *
  * History:
+ * 20190203:
+ *	- Slice methods added;
  * 20180612:
  *	- Updated to 1.8.15;
  * 20170123:
@@ -47,7 +49,7 @@
 #ifndef TRANSLATOR_BR_H
 #define TRANSLATOR_BR_H
 
-class TranslatorBrazilian : public TranslatorAdapter_1_8_15
+class TranslatorBrazilian : public Translator
 {
   public:
 
@@ -2088,118 +2090,253 @@ class TranslatorBrazilian : public TranslatorAdapter_1_8_15
     // new since 1.8.15
     //////////////////////////////////////////////////////////////////////////
 
-        /** VHDL design unit hierarchy */
-        virtual QCString trDesignUnitHierarchy()
-        { return "Hierarquia da Unidade de Design"; }
-        /** VHDL design unit list */
-        virtual QCString trDesignUnitList()
-        { return "Lista de Unidades de Design"; }
-        /** VHDL design unit members */
-        virtual QCString trDesignUnitMembers()
-        { return "Membros da Unidade de Design"; }
-        /** VHDL design unit list description */
-        virtual QCString trDesignUnitListDescription()
-        {
-            return "Esta é uma lista de todos os membros de unidades de design "
-            		"com ligações para as entidades às quais pertencem:";
-        }
-        /** VHDL design unit index */
-        virtual QCString trDesignUnitIndex()
-        { return "Índice de Unidades de Design"; }
-        /** VHDL design units */
-        virtual QCString trDesignUnits()
-        { return "Unidades de Design"; }
-        /** VHDL functions/procedures/processes */
-        virtual QCString trFunctionAndProc()
-        { return "Funções/Procedimentos/Processos"; }
-        /** VHDL type */
-        virtual QCString trVhdlType(uint64 type,bool single)
-        {
-          switch(type)
-          {
-            case VhdlDocGen::LIBRARY:
-              if (single) return "Biblioteca";
-              else        return "Bibliotecas";
-            case VhdlDocGen::PACKAGE:
-              if (single) return "Pacote";
-              else        return "Pacotes";
-            case VhdlDocGen::SIGNAL:
-              if (single) return "Sinal";
-              else        return "Sinais";
-            case VhdlDocGen::COMPONENT:
-              if (single) return "Componente";
-              else        return "Componentes";
-            case VhdlDocGen::CONSTANT:
-              if (single) return "Constante";
-              else        return "Constantes";
-            case VhdlDocGen::ENTITY:
-              if (single) return "Entidade";
-              else        return "Entidades";
-            case VhdlDocGen::TYPE:
-              if (single) return "Tipo";
-              else        return "Tipos";
-            case VhdlDocGen::SUBTYPE:
-              if (single) return "Subtipo";
-              else        return "Subtipos";
-            case VhdlDocGen::FUNCTION:
-              if (single) return "Função";
-              else        return "Funções";
-            case VhdlDocGen::RECORD:
-              if (single) return "Registro";
-              else        return "Registros";
-            case VhdlDocGen::PROCEDURE:
-              if (single) return "Procedimento";
-              else        return "Procedimentos";
-            case VhdlDocGen::ARCHITECTURE:
-              if (single) return "Arquitetura";
-              else        return "Arquiteturas";
-            case VhdlDocGen::ATTRIBUTE:
-              if (single) return "Atributo";
-              else        return "Atributos";
-            case VhdlDocGen::PROCESS:
-              if (single) return "Processo";
-              else        return "Processos";
-            case VhdlDocGen::PORT:
-              if (single) return "Porta";
-              else        return "Portas";
-            case VhdlDocGen::USE:
-              if (single) return "cláusula de uso";
-              else        return "cláusulas de uso";
-            case VhdlDocGen::GENERIC:
-              if (single) return "Generico";
-              else        return "Genericos";
-            case VhdlDocGen::PACKAGE_BODY:
-              return "Corpo do Pacote";
-            case VhdlDocGen::UNITS:
-              return "Unidades";
-            case VhdlDocGen::SHAREDVARIABLE:
-              if (single) return "Variável Compartilhada";
-              else        return "Variáveis Compartilhadas";
-            case VhdlDocGen::VFILE:
-              if (single) return "Arquivo";
-              else        return "Arquivos";
-            case VhdlDocGen::GROUP:
-              if (single) return "Grupo";
-              else        return "Grupos";
-            case VhdlDocGen::INSTANTIATION:
-                if (single) return "Instância";
-                else        return "Instâncias";
-            case VhdlDocGen::ALIAS:
-              if (single) return "Apelido";
-              else        return "Apelidos";
-            case VhdlDocGen::CONFIG:
-              if (single) return "Configuração";
-              else        return "Configurações";
-            case VhdlDocGen::MISCELLANEOUS:
-              return "Outros"; // Is this correct for VHDL?
-            case VhdlDocGen::UCF_CONST:
-              return "Restrições";
-            default:
-              return "Classe";
-          }
-        }
-        virtual QCString trCustomReference(const char *name)
-        { return "Referência de " + QCString(name); }
+    /** VHDL design unit hierarchy */
+    virtual QCString trDesignUnitHierarchy()
+    { return "Hierarquia da Unidade de Design"; }
+    /** VHDL design unit list */
+    virtual QCString trDesignUnitList()
+    { return "Lista de Unidades de Design"; }
+    /** VHDL design unit members */
+    virtual QCString trDesignUnitMembers()
+    { return "Membros da Unidade de Design"; }
+    /** VHDL design unit list description */
+    virtual QCString trDesignUnitListDescription()
+    {
+        return "Esta é uma lista de todos os membros de unidades de design "
+        		"com ligações para as entidades às quais pertencem:";
+    }
+    /** VHDL design unit index */
+    virtual QCString trDesignUnitIndex()
+    { return "Índice de Unidades de Design"; }
+    /** VHDL design units */
+    virtual QCString trDesignUnits()
+    { return "Unidades de Design"; }
+    /** VHDL functions/procedures/processes */
+    virtual QCString trFunctionAndProc()
+    { return "Funções/Procedimentos/Processos"; }
+    /** VHDL type */
+    virtual QCString trVhdlType(uint64 type,bool single)
+    {
+      switch(type)
+      {
+        case VhdlDocGen::LIBRARY:
+          if (single) return "Biblioteca";
+          else        return "Bibliotecas";
+        case VhdlDocGen::PACKAGE:
+          if (single) return "Pacote";
+          else        return "Pacotes";
+        case VhdlDocGen::SIGNAL:
+          if (single) return "Sinal";
+          else        return "Sinais";
+        case VhdlDocGen::COMPONENT:
+          if (single) return "Componente";
+          else        return "Componentes";
+        case VhdlDocGen::CONSTANT:
+          if (single) return "Constante";
+          else        return "Constantes";
+        case VhdlDocGen::ENTITY:
+          if (single) return "Entidade";
+          else        return "Entidades";
+        case VhdlDocGen::TYPE:
+          if (single) return "Tipo";
+          else        return "Tipos";
+        case VhdlDocGen::SUBTYPE:
+          if (single) return "Subtipo";
+          else        return "Subtipos";
+        case VhdlDocGen::FUNCTION:
+          if (single) return "Função";
+          else        return "Funções";
+        case VhdlDocGen::RECORD:
+          if (single) return "Registro";
+          else        return "Registros";
+        case VhdlDocGen::PROCEDURE:
+          if (single) return "Procedimento";
+          else        return "Procedimentos";
+        case VhdlDocGen::ARCHITECTURE:
+          if (single) return "Arquitetura";
+          else        return "Arquiteturas";
+        case VhdlDocGen::ATTRIBUTE:
+          if (single) return "Atributo";
+          else        return "Atributos";
+        case VhdlDocGen::PROCESS:
+          if (single) return "Processo";
+          else        return "Processos";
+        case VhdlDocGen::PORT:
+          if (single) return "Porta";
+          else        return "Portas";
+        case VhdlDocGen::USE:
+          if (single) return "cláusula de uso";
+          else        return "cláusulas de uso";
+        case VhdlDocGen::GENERIC:
+          if (single) return "Generico";
+          else        return "Genericos";
+        case VhdlDocGen::PACKAGE_BODY:
+          return "Corpo do Pacote";
+        case VhdlDocGen::UNITS:
+          return "Unidades";
+        case VhdlDocGen::SHAREDVARIABLE:
+          if (single) return "Variável Compartilhada";
+          else        return "Variáveis Compartilhadas";
+        case VhdlDocGen::VFILE:
+          if (single) return "Arquivo";
+          else        return "Arquivos";
+        case VhdlDocGen::GROUP:
+          if (single) return "Grupo";
+          else        return "Grupos";
+        case VhdlDocGen::INSTANTIATION:
+            if (single) return "Instância";
+            else        return "Instâncias";
+        case VhdlDocGen::ALIAS:
+          if (single) return "Apelido";
+          else        return "Apelidos";
+        case VhdlDocGen::CONFIG:
+          if (single) return "Configuração";
+          else        return "Configurações";
+        case VhdlDocGen::MISCELLANEOUS:
+          return "Outros"; // Is this correct for VHDL?
+        case VhdlDocGen::UCF_CONST:
+          return "Restrições";
+        default:
+          return "Classe";
+      }
+    }
+    virtual QCString trCustomReference(const char *name)
+    { return "Referência de " + QCString(name); }
+
+    /* Slice */
+    virtual QCString trConstants()
+    {
+        return "Constantes";
+    }
+    virtual QCString trConstantDocumentation()
+    {
+        return "Constantes";
+    }
+    virtual QCString trSequences()
+    {
+        return "Sequências";
+    }
+    virtual QCString trSequenceDocumentation()
+    {
+        return "Sequências";
+    }
+    virtual QCString trDictionaries()
+    {
+        return "Dicionários";
+    }
+    virtual QCString trDictionaryDocumentation()
+    {
+        return "Dicionários";
+    }
+    virtual QCString trSliceInterfaces()
+    {
+        return "Interfaces";
+    }
+    virtual QCString trInterfaceIndex()
+    {
+        return "Índice de Interfaces";
+    }
+    virtual QCString trInterfaceList()
+    {
+        return "Lista de Interfaces";
+    }
+    virtual QCString trInterfaceListDescription()
+    {
+        return "Estas são as interfaces com suas respectivas descrições:";
+    }
+    virtual QCString trInterfaceHierarchy()
+    {
+        return "Hierarquia de Interfaces";
+    }
+    virtual QCString trInterfaceHierarchyDescription()
+    {
+        return "Esta é a lista parcialmente ordenadas de heranças:";
+    }
+    virtual QCString trInterfaceDocumentation()
+    {
+        return "Interfaces";
+    }
+    virtual QCString trStructs()
+    {
+        return "Estruturas";
+    }
+    virtual QCString trStructIndex()
+    {
+        return "Índice de Estruturas";
+    }
+    virtual QCString trStructList()
+    {
+        return "Lista de Estruturas";
+    }
+    virtual QCString trStructListDescription()
+    {
+        return "Estas são as estruturas com suas respectivas descrições:";
+    }
+    virtual QCString trStructDocumentation()
+    {
+        return "Estruturas";
+    }
+    virtual QCString trExceptionIndex()
+    {
+        return "Índice the Exceções";
+    }
+    virtual QCString trExceptionList()
+    {
+        return "Lista de Exceções";
+    }
+    virtual QCString trExceptionListDescription()
+    {
+        return "Estas são as exceções com suas respectivas descrições:";
+    }
+    virtual QCString trExceptionHierarchy()
+    {
+        return "Hierarquia de Exceções";
+    }
+    virtual QCString trExceptionHierarchyDescription()
+    {
+        return "Esta é a lista parcialmente ordenadas de heranças:";
+    }
+    virtual QCString trExceptionDocumentation()
+    {
+        return "Exceções";
+    }
+    virtual QCString trCompoundReferenceSlice(const char *clName, ClassDef::CompoundType compType, bool isLocal)
+    {
+      QCString result=(QCString)"Referência ";
+      switch(compType)
+      {
+        case ClassDef::Class:      result+="da Classe "; break;
+        case ClassDef::Struct:     result+="da Estrutura "; break;
+        case ClassDef::Union:      result+="da União "; break;
+        case ClassDef::Interface:  result+="da Interface "; break;
+        case ClassDef::Protocol:   result+="do Protocolo "; break;
+        case ClassDef::Category:   result+="da Categoria "; break;
+        case ClassDef::Exception:  result+="da Exceção "; break;
+        default: break;
+      }
+      if (isLocal) result+="Local ";
+      result+= clName;
+      return result;
+    }
+    virtual QCString trOperations()
+    {
+        return "Operações";
+    }
+    virtual QCString trOperationDocumentation()
+    {
+        return "Operações";
+    }
+    virtual QCString trDataMembers()
+    {
+        return "Dados Membros";
+    }
+    virtual QCString trDataMemberDocumentation()
+    {
+        return "Dados Membros";
+    }
+
+//////////////////////////////////////////////////////////////////////////
+
 };
 
 #endif
diff --git a/src/translator_pt.h b/src/translator_pt.h
index 23faf7f..970cf45 100644
--- a/src/translator_pt.h
+++ b/src/translator_pt.h
@@ -24,6 +24,8 @@
  * VERSION HISTORY
  * ---------------
  * History:
+ * 20190203:
+ *	- Slice methods added;
  * 20180612:
  *	- Updated to 1.8.15;
  * 20131129:
@@ -57,7 +59,7 @@
 #define TRANSLATOR_PT_H
 
 
-class TranslatorPortuguese : public TranslatorAdapter_1_8_15
+class TranslatorPortuguese : public Translator
 {
   public:
 
@@ -2025,120 +2027,253 @@ class TranslatorPortuguese : public TranslatorAdapter_1_8_15
     // new since 1.8.15
     //////////////////////////////////////////////////////////////////////////
 
-        /** VHDL design unit hierarchy */
-        virtual QCString trDesignUnitHierarchy()
-        { return "Hierarquia da Unidade de Design"; }
-        /** VHDL design unit list */
-        virtual QCString trDesignUnitList()
-        { return "Lista de Unidades de Design"; }
-        /** VHDL design unit members */
-        virtual QCString trDesignUnitMembers()
-        { return "Membros da Unidade de Design"; }
-        /** VHDL design unit list description */
-        virtual QCString trDesignUnitListDescription()
-        {
-            return "Esta é uma lista de todos os membros de unidades de design "
-            		"com ligações para as entidades às quais pertencem:";
-        }
-        /** VHDL design unit index */
-        virtual QCString trDesignUnitIndex()
-        { return "Índice de Unidades de Design"; }
-        /** VHDL design units */
-        virtual QCString trDesignUnits()
-        { return "Unidades de Design"; }
-        /** VHDL functions/procedures/processes */
-        virtual QCString trFunctionAndProc()
-        { return "Funções/Procedimentos/Processos"; }
-        /** VHDL type */
-        virtual QCString trVhdlType(uint64 type,bool single)
-        {
-          switch(type)
-          {
-            case VhdlDocGen::LIBRARY:
-              if (single) return "Biblioteca";
-              else        return "Bibliotecas";
-            case VhdlDocGen::PACKAGE:
-              if (single) return "Pacote";
-              else        return "Pacotes";
-            case VhdlDocGen::SIGNAL:
-              if (single) return "Sinal";
-              else        return "Sinais";
-            case VhdlDocGen::COMPONENT:
-              if (single) return "Componente";
-              else        return "Componentes";
-            case VhdlDocGen::CONSTANT:
-              if (single) return "Constante";
-              else        return "Constantes";
-            case VhdlDocGen::ENTITY:
-              if (single) return "Entidade";
-              else        return "Entidades";
-            case VhdlDocGen::TYPE:
-              if (single) return "Tipo";
-              else        return "Tipos";
-            case VhdlDocGen::SUBTYPE:
-              if (single) return "Subtipo";
-              else        return "Subtipos";
-            case VhdlDocGen::FUNCTION:
-              if (single) return "Função";
-              else        return "Funções";
-            case VhdlDocGen::RECORD:
-              if (single) return "Registro";
-              else        return "Registros";
-            case VhdlDocGen::PROCEDURE:
-              if (single) return "Procedimento";
-              else        return "Procedimentos";
-            case VhdlDocGen::ARCHITECTURE:
-              if (single) return "Arquitetura";
-              else        return "Arquiteturas";
-            case VhdlDocGen::ATTRIBUTE:
-              if (single) return "Atributo";
-              else        return "Atributos";
-            case VhdlDocGen::PROCESS:
-              if (single) return "Processo";
-              else        return "Processos";
-            case VhdlDocGen::PORT:
-              if (single) return "Porta";
-              else        return "Portas";
-            case VhdlDocGen::USE:
-              if (single) return "cláusula de uso";
-              else        return "cláusulas de uso";
-            case VhdlDocGen::GENERIC:
-              if (single) return "Generico";
-              else        return "Genericos";
-            case VhdlDocGen::PACKAGE_BODY:
-              return "Corpo do Pacote";
-            case VhdlDocGen::UNITS:
-              return "Unidades";
-            case VhdlDocGen::SHAREDVARIABLE:
-              if (single) return "Variável Compartilhada";
-              else        return "Variáveis Compartilhadas";
-            case VhdlDocGen::VFILE:
-              if (single) return "Ficheiro";
-              else        return "Ficheiros";
-            case VhdlDocGen::GROUP:
-              if (single) return "Grupo";
-              else        return "Grupos";
-            case VhdlDocGen::INSTANTIATION:
-              if (single) return "Instância";
-              else        return "Instâncias";
-            case VhdlDocGen::ALIAS:
-              if (single) return "Apelido";
-              else        return "Apelidos";
-            case VhdlDocGen::CONFIG:
-              if (single) return "Configuração";
-              else        return "Configurações";
-            case VhdlDocGen::MISCELLANEOUS:
-              return "Outros"; // Is this correct for VHDL?
-            case VhdlDocGen::UCF_CONST:
-              return "Restrições";
-            default:
-              return "Classe";
-          }
-        }
-        virtual QCString trCustomReference(const char *name)
-        { return "Referência de " + QCString(name); }
+    /** VHDL design unit hierarchy */
+    virtual QCString trDesignUnitHierarchy()
+    { return "Hierarquia da Unidade de Design"; }
+    /** VHDL design unit list */
+    virtual QCString trDesignUnitList()
+    { return "Lista de Unidades de Design"; }
+    /** VHDL design unit members */
+    virtual QCString trDesignUnitMembers()
+    { return "Membros da Unidade de Design"; }
+    /** VHDL design unit list description */
+    virtual QCString trDesignUnitListDescription()
+    {
+        return "Esta é uma lista de todos os membros de unidades de design "
+        		"com ligações para as entidades às quais pertencem:";
+    }
+    /** VHDL design unit index */
+    virtual QCString trDesignUnitIndex()
+    { return "Índice de Unidades de Design"; }
+    /** VHDL design units */
+    virtual QCString trDesignUnits()
+    { return "Unidades de Design"; }
+    /** VHDL functions/procedures/processes */
+    virtual QCString trFunctionAndProc()
+    { return "Funções/Procedimentos/Processos"; }
+    /** VHDL type */
+    virtual QCString trVhdlType(uint64 type,bool single)
+    {
+      switch(type)
+      {
+        case VhdlDocGen::LIBRARY:
+          if (single) return "Biblioteca";
+          else        return "Bibliotecas";
+        case VhdlDocGen::PACKAGE:
+          if (single) return "Pacote";
+          else        return "Pacotes";
+        case VhdlDocGen::SIGNAL:
+          if (single) return "Sinal";
+          else        return "Sinais";
+        case VhdlDocGen::COMPONENT:
+          if (single) return "Componente";
+          else        return "Componentes";
+        case VhdlDocGen::CONSTANT:
+          if (single) return "Constante";
+          else        return "Constantes";
+        case VhdlDocGen::ENTITY:
+          if (single) return "Entidade";
+          else        return "Entidades";
+        case VhdlDocGen::TYPE:
+          if (single) return "Tipo";
+          else        return "Tipos";
+        case VhdlDocGen::SUBTYPE:
+          if (single) return "Subtipo";
+          else        return "Subtipos";
+        case VhdlDocGen::FUNCTION:
+          if (single) return "Função";
+          else        return "Funções";
+        case VhdlDocGen::RECORD:
+          if (single) return "Registro";
+          else        return "Registros";
+        case VhdlDocGen::PROCEDURE:
+          if (single) return "Procedimento";
+          else        return "Procedimentos";
+        case VhdlDocGen::ARCHITECTURE:
+          if (single) return "Arquitetura";
+          else        return "Arquiteturas";
+        case VhdlDocGen::ATTRIBUTE:
+          if (single) return "Atributo";
+          else        return "Atributos";
+        case VhdlDocGen::PROCESS:
+          if (single) return "Processo";
+          else        return "Processos";
+        case VhdlDocGen::PORT:
+          if (single) return "Porta";
+          else        return "Portas";
+        case VhdlDocGen::USE:
+          if (single) return "cláusula de uso";
+          else        return "cláusulas de uso";
+        case VhdlDocGen::GENERIC:
+          if (single) return "Generico";
+          else        return "Genericos";
+        case VhdlDocGen::PACKAGE_BODY:
+          return "Corpo do Pacote";
+        case VhdlDocGen::UNITS:
+          return "Unidades";
+        case VhdlDocGen::SHAREDVARIABLE:
+          if (single) return "Variável Compartilhada";
+          else        return "Variáveis Compartilhadas";
+        case VhdlDocGen::VFILE:
+          if (single) return "Ficheiro";
+          else        return "Ficheiros";
+        case VhdlDocGen::GROUP:
+          if (single) return "Grupo";
+          else        return "Grupos";
+        case VhdlDocGen::INSTANTIATION:
+          if (single) return "Instância";
+          else        return "Instâncias";
+        case VhdlDocGen::ALIAS:
+          if (single) return "Apelido";
+          else        return "Apelidos";
+        case VhdlDocGen::CONFIG:
+          if (single) return "Configuração";
+          else        return "Configurações";
+        case VhdlDocGen::MISCELLANEOUS:
+          return "Outros"; // Is this correct for VHDL?
+        case VhdlDocGen::UCF_CONST:
+          return "Restrições";
+        default:
+          return "Classe";
+      }
+    }
+    virtual QCString trCustomReference(const char *name)
+    { return "Referência de " + QCString(name); }
+
+    /* Slice */
+    virtual QCString trConstants()
+    {
+        return "Constantes";
+    }
+    virtual QCString trConstantDocumentation()
+    {
+        return "Constantes";
+    }
+    virtual QCString trSequences()
+    {
+        return "Sequências";
+    }
+    virtual QCString trSequenceDocumentation()
+    {
+        return "Sequências";
+    }
+    virtual QCString trDictionaries()
+    {
+        return "Dicionários";
+    }
+    virtual QCString trDictionaryDocumentation()
+    {
+        return "Dicionários";
+    }
+    virtual QCString trSliceInterfaces()
+    {
+        return "Interfaces";
+    }
+    virtual QCString trInterfaceIndex()
+    {
+        return "Índice de Interfaces";
+    }
+    virtual QCString trInterfaceList()
+    {
+        return "Lista de Interfaces";
+    }
+    virtual QCString trInterfaceListDescription()
+    {
+        return "Estas são as interfaces com suas respectivas descrições:";
+    }
+    virtual QCString trInterfaceHierarchy()
+    {
+        return "Hierarquia de Interfaces";
+    }
+    virtual QCString trInterfaceHierarchyDescription()
+    {
+        return "Esta é a lista parcialmente ordenadas de heranças:";
+    }
+    virtual QCString trInterfaceDocumentation()
+    {
+        return "Interfaces";
+    }
+    virtual QCString trStructs()
+    {
+        return "Estruturas";
+    }
+    virtual QCString trStructIndex()
+    {
+        return "Índice de Estruturas";
+    }
+    virtual QCString trStructList()
+    {
+        return "Lista de Estruturas";
+    }
+    virtual QCString trStructListDescription()
+    {
+        return "Estas são as estruturas com suas respectivas descrições:";
+    }
+    virtual QCString trStructDocumentation()
+    {
+        return "Estruturas";
+    }
+    virtual QCString trExceptionIndex()
+    {
+        return "Índice the Exceções";
+    }
+    virtual QCString trExceptionList()
+    {
+        return "Lista de Exceções";
+    }
+    virtual QCString trExceptionListDescription()
+    {
+        return "Estas são as exceções com suas respectivas descrições:";
+    }
+    virtual QCString trExceptionHierarchy()
+    {
+        return "Hierarquia de Exceções";
+    }
+    virtual QCString trExceptionHierarchyDescription()
+    {
+        return "Esta é a lista parcialmente ordenadas de heranças:";
+    }
+    virtual QCString trExceptionDocumentation()
+    {
+        return "Exceções";
+    }
+    virtual QCString trCompoundReferenceSlice(const char *clName, ClassDef::CompoundType compType, bool isLocal)
+    {
+      QCString result=(QCString)"Referência ";
+      switch(compType)
+      {
+        case ClassDef::Class:      result+="da Classe "; break;
+        case ClassDef::Struct:     result+="da Estrutura "; break;
+        case ClassDef::Union:      result+="da União "; break;
+        case ClassDef::Interface:  result+="da Interface "; break;
+        case ClassDef::Protocol:   result+="do Protocolo "; break;
+        case ClassDef::Category:   result+="da Categoria "; break;
+        case ClassDef::Exception:  result+="da Exceção "; break;
+        default: break;
+      }
+      if (isLocal) result+="Local ";
+      result+= clName;
+      return result;
+    }
+    virtual QCString trOperations()
+    {
+        return "Operações";
+    }
+    virtual QCString trOperationDocumentation()
+    {
+        return "Operações";
+    }
+    virtual QCString trDataMembers()
+    {
+        return "Dados Membros";
+    }
+    virtual QCString trDataMemberDocumentation()
+    {
+        return "Dados Membros";
+    }
+
+//////////////////////////////////////////////////////////////////////////
 
-        //////////////////////////////////////////////////////////////////////////
 };
 
 #endif