zeroc-ice 3.8.0 → 3.8.2

data/dist/ice/cpp/src/Slice/Parser.cpp

@@ -11,7 +11,6 @@
 #include <cassert>
 #include <cstring>
 #include <iterator>
-#include <limits>
 
 using namespace std;
 using namespace Slice;
@@ -49,7 +48,7 @@ namespace
     DataMemberList filterOrderedOptionalDataMembers(const DataMemberList& members)
     {
         DataMemberList result;
-        copy_if(members.begin(), members.end(), back_inserter(result), [](const auto& p) { return p->optional(); });
+        copy_if(members.begin(), members.end(), back_inserter(result), [](const auto& p) { return p->isOptional(); });
         result.sort(compareTag<DataMemberPtr>);
         return result;
     }
@@ -112,6 +111,58 @@ namespace
         }
         return true;
     }
+
+    /// Checks an identifier for illegal syntax and reports any errors that are present.
+    bool reportIllegalSuffixOrUnderscore(const string& identifier)
+    {
+        // check whether the identifier is scoped
+        size_t scopeIndex = identifier.rfind("::");
+        bool isScoped = scopeIndex != string::npos;
+        string name;
+        if (isScoped)
+        {
+            name = identifier.substr(scopeIndex + 2); // Only check the unscoped identifier for syntax
+        }
+        else
+        {
+            name = identifier;
+        }
+
+        assert(!name.empty());
+        bool isValid = true;
+
+        // check the identifier for reserved suffixes
+        static const string suffixBlacklist[] = {"Helper", "Holder", "Prx", "Ptr"};
+        for (const auto& i : suffixBlacklist)
+        {
+            if (name.find(i, name.size() - i.size()) != string::npos)
+            {
+                currentUnit->error("illegal identifier '" + name + "': '" + i + "' suffix is reserved");
+                isValid = false;
+                break;
+            }
+        }
+
+        // check the identifier for illegal underscores
+        size_t index = name.find('_');
+        if (index == 0)
+        {
+            currentUnit->error("illegal leading underscore in identifier '" + name + "'");
+            isValid = false;
+        }
+        else if (name.rfind('_') == (name.size() - 1))
+        {
+            currentUnit->error("illegal trailing underscore in identifier '" + name + "'");
+            isValid = false;
+        }
+        else if (name.find("__") != string::npos)
+        {
+            currentUnit->error("illegal double underscore in identifier '" + name + "'");
+            isValid = false;
+        }
+
+        return isValid;
+    }
 }
 
 namespace Slice
@@ -564,7 +615,7 @@ Slice::Builtin::kindAsString() const
     return builtinTable[_kind];
 }
 
-optional<Slice::Builtin::Kind>
+optional<Builtin::Kind>
 Slice::Builtin::kindFromString(string_view str)
 {
     // Object is an alias for Value that we don't put in the builtinTable.
@@ -640,15 +691,13 @@ Slice::Contained::scope() const
 string
 Slice::Contained::mappedName() const
 {
-    // First check if any 'xxx:identifier' has been applied to this element.
-    // If so, we return that instead of the element's Slice identifier.
-    const string metadata = unit()->languageName() + ":identifier";
-    if (auto customName = getMetadataArgs(metadata))
-    {
-        return *customName;
-    }
+    return customMappedName().value_or(unit()->defaultMappedName(*this));
+}
 
-    return _name;
+optional<string>
+Slice::Contained::customMappedName() const
+{
+    return getMetadataArgs(unit()->languageName() + ":identifier");
 }
 
 string
@@ -752,7 +801,7 @@ Slice::Contained::getMetadataArgs(string_view directive) const
     return nullopt;
 }
 
-std::optional<FormatType>
+optional<FormatType>
 Slice::Contained::parseFormatMetadata() const
 {
     if (auto metadata = getMetadataArgs("format"))
@@ -784,6 +833,8 @@ Slice::Contained::isDeprecated() const
 optional<string>
 Slice::Contained::getDeprecationReason() const
 {
+    // The compiler doesn't allow both 'deprecate' and 'deprecated' to be applied to the same element.
+    // If both are present, 'deprecated' will be kept, and 'deprecate' will be thrown away.
     string reasonMessage;
     if (auto reason = getMetadataArgs("deprecate"))
     {
@@ -1419,7 +1470,7 @@ Slice::Container::createConst(
     return p;
 }
 
-TypeList
+TypePtr
 Slice::Container::lookupType(const string& identifier)
 {
     // Remove whitespace.
@@ -1434,14 +1485,14 @@ Slice::Container::lookupType(const string& identifier)
     auto kind = Builtin::kindFromString(sc);
     if (kind)
     {
-        return {unit()->createBuiltin(*kind)};
+        return unit()->createBuiltin(*kind);
     }
 
     // Not a builtin type, try to look up a user-defined type.
     return lookupTypeNoBuiltin(identifier, true);
 }
 
-TypeList
+TypePtr
 Slice::Container::lookupTypeNoBuiltin(const string& identifier, bool emitErrors, bool ignoreUndefined)
 {
     // Remove whitespace.
@@ -1458,7 +1509,7 @@ Slice::Container::lookupTypeNoBuiltin(const string& identifier, bool emitErrors,
         return unit()->lookupTypeNoBuiltin(sc.substr(2), emitErrors);
     }
 
-    TypeList results;
+    optional<TypePtr> resolvedType;
     bool typeError = false;
     vector<string> errors;
 
@@ -1470,70 +1521,66 @@ Slice::Container::lookupTypeNoBuiltin(const string& identifier, bool emitErrors,
             continue; // Ignore interface and class definitions.
         }
 
-        if (emitErrors && matches.front()->scoped() != (thisScope() + sc))
+        if (p->scoped() != (thisScope() + sc))
         {
             ostringstream os;
             os << p->kindOf() << " name '" << identifier << "' is capitalized inconsistently with its previous name: '"
-               << matches.front()->scoped() << "'";
+               << p->scoped() << "'";
             errors.push_back(os.str());
         }
 
-        ExceptionPtr ex = dynamic_pointer_cast<Exception>(p);
-        if (ex)
+        if (TypePtr type = dynamic_pointer_cast<Type>(p))
         {
-            if (emitErrors)
-            {
-                ostringstream os;
-                os << "'" << sc << "' is an exception, which cannot be used as a type";
-                unit()->error(os.str());
-            }
-            return {};
+            resolvedType = type;
         }
+        else if (ExceptionPtr ex = dynamic_pointer_cast<Exception>(p))
+        {
+            resolvedType = nullptr;
 
-        TypePtr type = dynamic_pointer_cast<Type>(p);
-        if (!type)
+            ostringstream os;
+            os << "'" << sc << "' is an exception, which cannot be used as a type";
+            errors.push_back(os.str());
+        }
+        else
         {
             typeError = true;
-            if (emitErrors)
-            {
-                ostringstream os;
-                os << "'" << sc << "' is not a type";
-                errors.push_back(os.str());
-            }
-            break; // Possible that correct match is higher in scope
+
+            ostringstream os;
+            os << "'" << sc << "' is not a type";
+            errors.push_back(os.str());
         }
-        results.push_back(type);
+        break;
     }
 
-    if (results.empty())
+    if (!resolvedType.has_value())
     {
         ContainedPtr contained = dynamic_pointer_cast<Contained>(shared_from_this());
         if (contained)
         {
-            results = contained->container()->lookupTypeNoBuiltin(sc, emitErrors, typeError || ignoreUndefined);
-        }
-        else if (!typeError)
-        {
-            if (emitErrors && !ignoreUndefined)
+            TypePtr parent = contained->container()->lookupTypeNoBuiltin(sc, emitErrors, typeError || ignoreUndefined);
+            if (parent)
             {
-                ostringstream os;
-                os << "'" << sc << "' is not defined";
-                unit()->error(os.str());
+                resolvedType = parent;
             }
-            return {};
+        }
+        else if (!typeError && !ignoreUndefined)
+        {
+            ostringstream os;
+            os << "'" << sc << "' is not defined";
+            errors.push_back(os.str());
         }
     }
 
     // Do not emit errors if there was a type error but a match was found in a higher scope.
-    // TODO The second part of this check looks funny to me.
-    if (emitErrors && !(typeError && !results.empty()))
+    if (emitErrors && (!typeError || !resolvedType.has_value()))
     {
         for (const auto& error : errors)
         {
             unit()->error(error);
         }
     }
-    return results;
+
+    return resolvedType.value_or(nullptr);
 }
 
 ContainedList
@@ -1597,32 +1644,24 @@ Slice::Container::lookupContained(const string& identifier, bool emitErrors)
 InterfaceDefPtr
 Slice::Container::lookupInterfaceDef(const string& identifier, bool emitErrors)
 {
-    TypeList types = lookupType(identifier);
-    if (!types.empty())
+    TypePtr resolvedType = lookupType(identifier);
+    if (resolvedType)
     {
-        auto interface = dynamic_pointer_cast<InterfaceDecl>(types.front());
-        if (!interface)
+        if (auto interfaceDecl = dynamic_pointer_cast<InterfaceDecl>(resolvedType))
         {
-            if (emitErrors)
+            if (InterfaceDefPtr def = interfaceDecl->definition())
             {
-                unit()->error("'" + identifier + "' is not an interface");
-            }
-        }
-        else
-        {
-            InterfaceDefPtr def = interface->definition();
-            if (!def)
-            {
-                if (emitErrors)
-                {
-                    unit()->error("'" + identifier + "' has been declared but not defined");
-                }
+                return def;
             }
-            else
+            else if (emitErrors)
             {
-                return def;
+                unit()->error("'" + identifier + "' has been declared but not defined");
             }
         }
+        else if (emitErrors)
+        {
+            unit()->error("'" + identifier + "' is not an interface");
+        }
     }
 
     // If we failed to find a valid interface with the specified name.
@@ -2160,13 +2199,13 @@ Slice::Module::getTopLevelModule() const
         return parent->getTopLevelModule();
     }
     // Reaching here means that this module is at the top-level! We return it.
-    return dynamic_pointer_cast<Module>(const_pointer_cast<Container>(shared_from_this()));
+    return static_pointer_cast<Module>(const_pointer_cast<Container>(shared_from_this()));
 }
 
 void
 Slice::Module::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<Module>(shared_from_this());
+    auto self = static_pointer_cast<Module>(shared_from_this());
     if (visitor->visitModuleStart(self))
     {
         visitContents(visitor);
@@ -2211,7 +2250,7 @@ Slice::ClassDecl::isClassType() const
 size_t
 Slice::ClassDecl::minWireSize() const
 {
-    return 1; // At least four bytes for an instance, if the instance is marshaled as an index.
+    return 1; // A class can be marshaled as an index, which uses the size encoding, which uses either 1 or 5 bytes.
 }
 
 string
@@ -2323,7 +2362,7 @@ Slice::ClassDef::createDataMember(
         // Validate the tag.
         for (const auto& q : dataMembers())
         {
-            if (q->optional() && tag == q->tag())
+            if (q->isOptional() && tag == q->tag())
             {
                 unit()->error("tag for optional data member '" + name + "' is already in use");
                 break;
@@ -2441,7 +2480,7 @@ Slice::ClassDef::kindOf() const
 void
 Slice::ClassDef::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<ClassDef>(shared_from_this());
+    auto self = static_pointer_cast<ClassDef>(shared_from_this());
     if (visitor->visitClassDefStart(self))
     {
         visitContents(visitor);
@@ -2628,7 +2667,7 @@ Slice::InterfaceDecl::addPartition(
 // list of lists, with each member list containing the operation
 // names defined by the interfaces in each partition.
 //
-Slice::InterfaceDecl::StringPartitionList
+InterfaceDecl::StringPartitionList
 Slice::InterfaceDecl::toStringPartitionList(const GraphPartitionList& partitions)
 {
     StringPartitionList spl;
@@ -2751,8 +2790,9 @@ Slice::InterfaceDef::createOperation(
                 break;
             }
         }
-        // Check the operations of the Object pseudo-interface.
-        if (!checkBaseOperationNames(name, {"ice_id", "ice_ids", "ice_ping", "ice_isA"}))
+
+        // Check the operations of the Object pseudo-interface unless we're generating code for Object itself.
+        if (scoped() != "::Ice::Object" && !checkBaseOperationNames(name, {"ice_id", "ice_ids", "ice_ping", "ice_isA"}))
         {
             hasConflictingIdentifier = true;
         }
@@ -2840,6 +2880,24 @@ Slice::InterfaceDef::operations() const
 
 OperationList
 Slice::InterfaceDef::allOperations() const
+{
+    OperationList result = allInheritedOperations();
+
+    for (const auto& q : operations())
+    {
+        if (none_of(
+                result.begin(),
+                result.end(),
+                [name = q->name()](const auto& other) { return other->name() == name; }))
+        {
+            result.push_back(q);
+        }
+    }
+    return result;
+}
+
+OperationList
+Slice::InterfaceDef::allInheritedOperations() const
 {
     OperationList result;
     for (const auto& p : _bases)
@@ -2855,17 +2913,6 @@ Slice::InterfaceDef::allOperations() const
             }
         }
     }
-
-    for (const auto& q : operations())
-    {
-        if (none_of(
-                result.begin(),
-                result.end(),
-                [name = q->name()](const auto& other) { return other->name() == name; }))
-        {
-            result.push_back(q);
-        }
-    }
     return result;
 }
 
@@ -2878,7 +2925,7 @@ Slice::InterfaceDef::kindOf() const
 void
 Slice::InterfaceDef::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<InterfaceDef>(shared_from_this());
+    auto self = static_pointer_cast<InterfaceDef>(shared_from_this());
     if (visitor->visitInterfaceDefStart(self))
     {
         visitContents(visitor);
@@ -2928,7 +2975,7 @@ Slice::InterfaceDef::InterfaceDef(const ContainerPtr& container, const string& n
 // ----------------------------------------------------------------------
 
 InterfaceDefPtr
-Slice::Operation::interface() const
+Slice::Operation::parentInterface() const
 {
     return dynamic_pointer_cast<InterfaceDef>(_container);
 }
@@ -2960,7 +3007,7 @@ Slice::Operation::mode() const
 bool
 Slice::Operation::hasMarshaledResult() const
 {
-    InterfaceDefPtr intf = interface();
+    InterfaceDefPtr intf = parentInterface();
     assert(intf);
     if (intf->hasMetadata("marshaled-result") || hasMetadata("marshaled-result"))
     {
@@ -2969,10 +3016,9 @@ Slice::Operation::hasMarshaledResult() const
             return true;
         }
 
-        for (const auto& p : _contents)
+        for (const auto& p : outParameters())
         {
-            ParameterPtr q = dynamic_pointer_cast<Parameter>(p);
-            if (q->isOutParam() && isMutableAfterReturnType(q->type()))
+            if (isMutableAfterReturnType(p->type()))
             {
                 return true;
             }
@@ -3010,7 +3056,7 @@ Slice::Operation::createParameter(const string& name, const TypePtr& type, bool
         {
             for (const auto& param : parameters())
             {
-                if (param->optional() && param->tag() == tag)
+                if (param->isOptional() && param->tag() == tag)
                 {
                     unit()->error(msg);
                     break;
@@ -3042,12 +3088,11 @@ ParameterList
 Slice::Operation::inParameters() const
 {
     ParameterList result;
-    for (const auto& p : _contents)
+    for (const auto& p : parameters())
     {
-        ParameterPtr q = dynamic_pointer_cast<Parameter>(p);
-        if (q && !q->isOutParam())
+        if (!p->isOutParam())
         {
-            result.push_back(q);
+            result.push_back(p);
         }
     }
     return result;
@@ -3060,7 +3105,7 @@ Slice::Operation::sortedInParameters() const
     ParameterList required, optional;
     for (const auto& param : inParameters())
     {
-        if (param->optional())
+        if (param->isOptional())
         {
             optional.push_back(param);
         }
@@ -3082,13 +3127,11 @@ ParameterList
 Slice::Operation::outParameters() const
 {
     ParameterList result;
-
-    for (const auto& p : _contents)
+    for (const auto& p : parameters())
     {
-        ParameterPtr q = dynamic_pointer_cast<Parameter>(p);
-        if (q && q->isOutParam())
+        if (p->isOutParam())
         {
-            result.push_back(q);
+            result.push_back(p);
         }
     }
     return result;
@@ -3137,7 +3180,7 @@ Slice::Operation::sortedReturnAndOutParameters(const string& returnName)
     // First sort each parameter into either 'required' or 'optional'.
     for (auto i = required.begin(); i != required.end();)
     {
-        if ((*i)->optional())
+        if ((*i)->isOptional())
         {
             optional.push_back(*i);
             i = required.erase(i);
@@ -3208,9 +3251,9 @@ Slice::Operation::setExceptionList(const ExceptionList& exceptions)
 bool
 Slice::Operation::sendsClasses() const
 {
-    for (const auto& i : parameters())
+    for (const auto& i : inParameters())
     {
-        if (!i->isOutParam() && i->type()->usesClasses())
+        if (i->type()->usesClasses())
         {
             return true;
         }
@@ -3227,9 +3270,9 @@ Slice::Operation::returnsClasses() const
         return true;
     }
 
-    for (const auto& i : parameters())
+    for (const auto& i : outParameters())
     {
-        if (i->isOutParam() && i->type()->usesClasses())
+        if (i->type()->usesClasses())
         {
             return true;
         }
@@ -3240,25 +3283,7 @@ Slice::Operation::returnsClasses() const
 bool
 Slice::Operation::returnsData() const
 {
-    TypePtr t = returnType();
-    if (t)
-    {
-        return true;
-    }
-
-    for (const auto& i : parameters())
-    {
-        if (i->isOutParam())
-        {
-            return true;
-        }
-    }
-
-    if (!throws().empty())
-    {
-        return true;
-    }
-    return false;
+    return returnsAnyValues() || !throws().empty();
 }
 
 bool
@@ -3285,7 +3310,7 @@ Slice::Operation::sendsOptionals() const
 {
     for (const auto& i : inParameters())
     {
-        if (i->optional())
+        if (i->isOptional())
         {
             return true;
         }
@@ -3298,7 +3323,7 @@ Slice::Operation::receivesOptionals() const
 {
     for (const auto& i : outParameters())
     {
-        if (i->optional())
+        if (i->isOptional())
         {
             return true;
         }
@@ -3306,10 +3331,10 @@ Slice::Operation::receivesOptionals() const
     return returnIsOptional();
 }
 
-std::optional<FormatType>
+optional<FormatType>
 Slice::Operation::format() const
 {
-    std::optional<FormatType> format = parseFormatMetadata();
+    optional<FormatType> format = parseFormatMetadata();
     if (!format)
     {
         ContainedPtr cont = dynamic_pointer_cast<Contained>(container());
@@ -3328,7 +3353,7 @@ Slice::Operation::kindOf() const
 void
 Slice::Operation::visit(ParserVisitor* visitor)
 {
-    visitor->visitOperation(dynamic_pointer_cast<Operation>(shared_from_this()));
+    visitor->visitOperation(static_pointer_cast<Operation>(shared_from_this()));
 }
 
 void
@@ -3434,7 +3459,7 @@ Slice::Exception::createDataMember(
         // Validate the tag.
         for (const auto& q : dataMembers())
         {
-            if (q->optional() && tag == q->tag())
+            if (q->isOptional() && tag == q->tag())
             {
                 unit()->error("tag for optional data member '" + name + "' is already in use");
                 break;
@@ -3564,7 +3589,7 @@ Slice::Exception::kindOf() const
 void
 Slice::Exception::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<Exception>(shared_from_this());
+    auto self = static_pointer_cast<Exception>(shared_from_this());
     if (visitor->visitExceptionStart(self))
     {
         visitContents(visitor);
@@ -3719,7 +3744,7 @@ Slice::Struct::kindOf() const
 void
 Slice::Struct::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<Struct>(shared_from_this());
+    auto self = static_pointer_cast<Struct>(shared_from_this());
     if (visitor->visitStructStart(self))
     {
         visitContents(visitor);
@@ -4053,7 +4078,7 @@ Slice::Enum::kindOf() const
 void
 Slice::Enum::visit(ParserVisitor* visitor)
 {
-    visitor->visitEnum(dynamic_pointer_cast<Enum>(shared_from_this()));
+    visitor->visitEnum(static_pointer_cast<Enum>(shared_from_this()));
 }
 
 void
@@ -4062,11 +4087,7 @@ Slice::Enum::destroy()
     destroyContents();
 }
 
-Slice::Enum::Enum(const ContainerPtr& container, const string& name)
-    : Contained(container, name),
-      _minValue(numeric_limits<int32_t>::max())
-{
-}
+Slice::Enum::Enum(const ContainerPtr& container, const string& name) : Contained(container, name) {}
 
 // ----------------------------------------------------------------------
 // Enumerator
@@ -4198,7 +4219,7 @@ Slice::Parameter::setIsOutParam()
 }
 
 bool
-Slice::Parameter::optional() const
+Slice::Parameter::isOptional() const
 {
     return _optional;
 }
@@ -4245,7 +4266,7 @@ Slice::DataMember::type() const
 }
 
 bool
-Slice::DataMember::optional() const
+Slice::DataMember::isOptional() const
 {
     return _optional;
 }
@@ -4287,7 +4308,7 @@ Slice::DataMember::DataMember(
     bool isOptional,
     int32_t tag,
     SyntaxTreeBasePtr defaultValueType,
-    std::optional<string> defaultValueString)
+    optional<string> defaultValueString)
     : Contained(container, name),
       _type(std::move(type)),
       _optional(isOptional),
@@ -4304,9 +4325,9 @@ Slice::DataMember::DataMember(
 // ----------------------------------------------------------------------
 
 UnitPtr
-Slice::Unit::createUnit(string languageName, bool all)
+Slice::Unit::createUnit(string languageName, UnitOptions options)
 {
-    return make_shared<Unit>(std::move(languageName), all);
+    return make_shared<Unit>(std::move(languageName), std::move(options));
 }
 
 string
@@ -4315,6 +4336,19 @@ Slice::Unit::languageName() const
     return _languageName;
 }
 
+string
+Slice::Unit::defaultMappedName(const Contained& contained) const
+{
+    if (_defaultMappedName)
+    {
+        return _defaultMappedName(contained);
+    }
+    else
+    {
+        return contained.name();
+    }
+}
+
 void
 Slice::Unit::setDocComment(const string& comment)
 {
@@ -4409,7 +4443,7 @@ Slice::Unit::currentLine() const
 }
 
 int
-Slice::Unit::setCurrentFile(std::string currentFile, int lineNumber)
+Slice::Unit::setCurrentFile(string currentFile, int lineNumber)
 {
     assert(!currentFile.empty());
 
@@ -4695,12 +4729,12 @@ Slice::Unit::findContents(const string& scopedName) const
 }
 
 void
-Slice::Unit::addTypeId(int32_t compactId, const std::string& typeId)
+Slice::Unit::addTypeId(int32_t compactId, const string& typeId)
 {
     _typeIds.insert(make_pair(compactId, typeId));
 }
 
-std::string
+string
 Slice::Unit::getTypeId(int32_t compactId) const
 {
     auto p = _typeIds.find(compactId);
@@ -4790,7 +4824,7 @@ Slice::Unit::destroy()
 void
 Slice::Unit::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<Unit>(shared_from_this());
+    auto self = static_pointer_cast<Unit>(shared_from_this());
     if (visitor->visitUnitStart(self))
     {
         visitContents(visitor);
@@ -4819,7 +4853,7 @@ Slice::Unit::createBuiltin(Builtin::Kind kind)
     {
         return p->second;
     }
-    auto builtin = make_shared<Builtin>(dynamic_pointer_cast<Unit>(shared_from_this()), kind);
+    auto builtin = make_shared<Builtin>(static_pointer_cast<Unit>(shared_from_this()), kind);
     _builtins.insert(make_pair(kind, builtin));
     return builtin;
 }
@@ -4854,9 +4888,12 @@ Slice::Unit::getTopLevelModules(const string& file) const
     }
 }
 
-Slice::Unit::Unit(string languageName, bool all) : _languageName(std::move(languageName)), _all(all)
+Slice::Unit::Unit(string languageName, UnitOptions options)
+    : _languageName(std::move(languageName)),
+      _all(options.all),
+      _defaultMappedName(std::move(options.defaultMappedName))
 {
-    if (!languageName.empty())
+    if (!_languageName.empty())
     {
         assert(binary_search(&languages[0], &languages[sizeof(languages) / sizeof(*languages)], _languageName));
     }