zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Slice/Grammar.h

@@ -1,21 +1,22 @@
-/* A Bison parser, made by GNU Bison 2.7.  */
+/* A Bison parser, made by GNU Bison 3.8.2.  */
 
 /* Bison interface for Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
-   
+
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+   Inc.
+
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
 
 /* As a special exception, you may create a larger work that contains
    part or all of the Bison parser skeleton and distribute that work
@@ -26,93 +27,112 @@
    special exception, which will cause the skeleton and the resulting
    Bison output files to be licensed under the GNU General Public
    License without this special exception.
-   
+
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef YY_SLICE_SRC_SLICE_GRAMMAR_HPP_INCLUDED
-# define YY_SLICE_SRC_SLICE_GRAMMAR_HPP_INCLUDED
-/* Enabling traces.  */
+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
+   especially those whose name start with YY_ or yy_.  They are
+   private implementation details that can be changed or removed.  */
+
+#ifndef YY_SLICE_SRC_SLICE_GRAMMAR_H_INCLUDED
+# define YY_SLICE_SRC_SLICE_GRAMMAR_H_INCLUDED
+/* Debug traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
 #endif
 #if YYDEBUG
 extern int slice_debug;
 #endif
+/* "%code requires" blocks.  */
+#line 9 "src/Slice/Grammar.y"
+
+
+// Included first to get 'TokenContext' which we need to define YYLTYPE before flex does.
+#include "GrammarUtil.h"
+
+// I must set the initial stack depth to the maximum stack depth to
+// disable bison stack resizing. The bison stack resizing routines use
+// simple malloc/alloc/memcpy calls, which do not work for the
+// YYSTYPE, since YYSTYPE is a C++ type, with constructor, destructor,
+// assignment operator, etc.
+#define YYMAXDEPTH  10000      // 10000 should suffice. Bison default is 10000 as maximum.
+#define YYINITDEPTH YYMAXDEPTH // Initial depth is set to max depth, for the reasons described above.
+
+// Newer bison versions allow to disable stack resizing by defining yyoverflow.
+#define yyoverflow(a, b, c, d, e, f, g, h) yyerror(a)
 
-/* Tokens.  */
+
+#line 67 "src/Slice/Grammar.h"
+
+/* Token kinds.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     ICE_MODULE = 258,
-     ICE_CLASS = 259,
-     ICE_INTERFACE = 260,
-     ICE_EXCEPTION = 261,
-     ICE_STRUCT = 262,
-     ICE_SEQUENCE = 263,
-     ICE_DICTIONARY = 264,
-     ICE_ENUM = 265,
-     ICE_OUT = 266,
-     ICE_EXTENDS = 267,
-     ICE_IMPLEMENTS = 268,
-     ICE_THROWS = 269,
-     ICE_VOID = 270,
-     ICE_BYTE = 271,
-     ICE_BOOL = 272,
-     ICE_SHORT = 273,
-     ICE_INT = 274,
-     ICE_LONG = 275,
-     ICE_FLOAT = 276,
-     ICE_DOUBLE = 277,
-     ICE_STRING = 278,
-     ICE_OBJECT = 279,
-     ICE_LOCAL_OBJECT = 280,
-     ICE_LOCAL = 281,
-     ICE_CONST = 282,
-     ICE_FALSE = 283,
-     ICE_TRUE = 284,
-     ICE_IDEMPOTENT = 285,
-     ICE_OPTIONAL = 286,
-     ICE_VALUE = 287,
-     ICE_IDENTIFIER = 288,
-     ICE_SCOPED_IDENTIFIER = 289,
-     ICE_STRING_LITERAL = 290,
-     ICE_INTEGER_LITERAL = 291,
-     ICE_FLOATING_POINT_LITERAL = 292,
-     ICE_IDENT_OP = 293,
-     ICE_KEYWORD_OP = 294,
-     ICE_OPTIONAL_OP = 295,
-     ICE_METADATA_OPEN = 296,
-     ICE_METADATA_CLOSE = 297,
-     ICE_GLOBAL_METADATA_OPEN = 298,
-     ICE_GLOBAL_METADATA_CLOSE = 299,
-     BAD_CHAR = 300
-   };
+  enum yytokentype
+  {
+    YYEMPTY = -2,
+    YYEOF = 0,                     /* "end of file"  */
+    YYerror = 256,                 /* error  */
+    YYUNDEF = 257,                 /* "invalid token"  */
+    ICE_MODULE = 258,              /* "module keyword"  */
+    ICE_CLASS = 259,               /* "class keyword"  */
+    ICE_INTERFACE = 260,           /* "interface keyword"  */
+    ICE_EXCEPTION = 261,           /* "exception keyword"  */
+    ICE_STRUCT = 262,              /* "struct keyword"  */
+    ICE_SEQUENCE = 263,            /* "sequence keyword"  */
+    ICE_DICTIONARY = 264,          /* "dictionary keyword"  */
+    ICE_ENUM = 265,                /* "enum keyword"  */
+    ICE_OUT = 266,                 /* "out keyword"  */
+    ICE_EXTENDS = 267,             /* "extends keyword"  */
+    ICE_THROWS = 268,              /* "throws keyword"  */
+    ICE_VOID = 269,                /* "void keyword"  */
+    ICE_BOOL = 270,                /* "bool keyword"  */
+    ICE_BYTE = 271,                /* "byte keyword"  */
+    ICE_SHORT = 272,               /* "short keyword"  */
+    ICE_INT = 273,                 /* "int keyword"  */
+    ICE_LONG = 274,                /* "long keyword"  */
+    ICE_FLOAT = 275,               /* "float keyword"  */
+    ICE_DOUBLE = 276,              /* "double keyword"  */
+    ICE_STRING = 277,              /* "string keyword"  */
+    ICE_OBJECT = 278,              /* "Object keyword"  */
+    ICE_CONST = 279,               /* "const keyword"  */
+    ICE_FALSE = 280,               /* "false keyword"  */
+    ICE_TRUE = 281,                /* "true keyword"  */
+    ICE_IDEMPOTENT = 282,          /* "idempotent keyword"  */
+    ICE_OPTIONAL = 283,            /* "optional keyword"  */
+    ICE_VALUE = 284,               /* "Value keyword"  */
+    ICE_STRING_LITERAL = 285,      /* "string literal"  */
+    ICE_INTEGER_LITERAL = 286,     /* "integer literal"  */
+    ICE_FLOATING_POINT_LITERAL = 287, /* "floating-point literal"  */
+    ICE_IDENTIFIER = 288,          /* "identifier"  */
+    ICE_SCOPED_IDENTIFIER = 289,   /* "scoped identifier"  */
+    ICE_METADATA_OPEN = 290,       /* "["  */
+    ICE_METADATA_CLOSE = 291,      /* "]"  */
+    ICE_FILE_METADATA_OPEN = 292,  /* "[["  */
+    ICE_FILE_METADATA_CLOSE = 293, /* "]]"  */
+    ICE_IDENT_OPEN = 294,          /* "identifier("  */
+    ICE_KEYWORD_OPEN = 295,        /* "keyword("  */
+    ICE_OPTIONAL_OPEN = 296,       /* "optional("  */
+    BAD_TOKEN = 297,               /* "invalid character"  */
+    EMPTY_PREC = 298               /* EMPTY_PREC  */
+  };
+  typedef enum yytokentype yytoken_kind_t;
 #endif
 
-
+/* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef int YYSTYPE;
+typedef Slice::GrammarBasePtr YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 #endif
 
+/* Location type.  */
+typedef Slice::TokenContext YYLTYPE;
+
+
+
 
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int slice_parse (void *YYPARSE_PARAM);
-#else
-int slice_parse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
 int slice_parse (void);
-#else
-int slice_parse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
 
-#endif /* !YY_SLICE_SRC_SLICE_GRAMMAR_HPP_INCLUDED  */
+
+#endif /* !YY_SLICE_SRC_SLICE_GRAMMAR_H_INCLUDED  */

data/dist/ice/cpp/src/Slice/GrammarUtil.h

@@ -1,228 +1,128 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef SLICE_GRAMMAR_UTIL_H
 #define SLICE_GRAMMAR_UTIL_H
 
-#include <Slice/Parser.h>
+#include "Parser.h"
+#include "Util.h"
+#include <cassert>
+#include <memory>
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wshadow-field-in-constructor"
+#elif defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wshadow"
+#endif
 
 namespace Slice
 {
-
-class StringTok;
-class StringListTok;
-class TypeStringTok;
-class TypeStringListTok;
-class BoolTok;
-class IntegerTok;
-class FloatingTok;
-class ExceptionListTok;
-class ClassListTok;
-class EnumeratorListTok;
-class ConstDefTok;
-class OptionalDefTok;
-class OptionalTypeDefTok;
-class ClassIdTok;
-
-typedef ::IceUtil::Handle<StringTok> StringTokPtr;
-typedef ::IceUtil::Handle<StringListTok> StringListTokPtr;
-typedef ::IceUtil::Handle<TypeStringTok> TypeStringTokPtr;
-typedef ::IceUtil::Handle<TypeStringListTok> TypeStringListTokPtr;
-typedef ::IceUtil::Handle<BoolTok> BoolTokPtr;
-typedef ::IceUtil::Handle<IntegerTok> IntegerTokPtr;
-typedef ::IceUtil::Handle<FloatingTok> FloatingTokPtr;
-typedef ::IceUtil::Handle<ExceptionListTok> ExceptionListTokPtr;
-typedef ::IceUtil::Handle<ClassListTok> ClassListTokPtr;
-typedef ::IceUtil::Handle<EnumeratorListTok> EnumeratorListTokPtr;
-typedef ::IceUtil::Handle<ConstDefTok> ConstDefTokPtr;
-typedef ::IceUtil::Handle<OptionalDefTok> OptionalDefTokPtr;
-typedef ::IceUtil::Handle<ClassIdTok> ClassIdTokPtr;
-
-// ----------------------------------------------------------------------
-// StringTok
-// ----------------------------------------------------------------------
-
-class StringTok : public GrammarBase
-{
-public:
-
-    StringTok() { }
-    std::string v;
-    std::string literal;
-};
-
-// ----------------------------------------------------------------------
-// StringListTok
-// ----------------------------------------------------------------------
-
-class StringListTok : public GrammarBase
-{
-public:
-
-    StringListTok() { }
-    StringList v;
-};
-
-// ----------------------------------------------------------------------
-// TypeStringTok
-// ----------------------------------------------------------------------
-
-class TypeStringTok : public GrammarBase
-{
-public:
-
-    TypeStringTok() { }
-    TypeString v;
-};
-
-// ----------------------------------------------------------------------
-// TypeStringListTok
-// ----------------------------------------------------------------------
-
-class TypeStringListTok : public GrammarBase
-{
-public:
-
-    TypeStringListTok() { }
-    TypeStringList v;
-};
-
-// ----------------------------------------------------------------------
-// IntegerTok
-// ----------------------------------------------------------------------
-
-class IntegerTok : public GrammarBase
-{
-public:
-
-    IntegerTok() { }
-    IceUtil::Int64 v;
-    std::string literal;
-};
-
-// ----------------------------------------------------------------------
-// FloatingTok
-// ----------------------------------------------------------------------
-
-class FloatingTok : public GrammarBase
-{
-public:
-
-    FloatingTok() { }
-    double v;
-    std::string literal;
-};
-
-// ----------------------------------------------------------------------
-// BoolTok
-// ----------------------------------------------------------------------
-
-class BoolTok : public GrammarBase
-{
-public:
-
-    BoolTok() { }
-    bool v;
-};
-
-// ----------------------------------------------------------------------
-// ExceptionListTok
-// ----------------------------------------------------------------------
-
-class ExceptionListTok : public GrammarBase
-{
-public:
-
-    ExceptionListTok() { }
-    ExceptionList v;
-};
-
-// ----------------------------------------------------------------------
-// ClassListTok
-// ----------------------------------------------------------------------
-
-class ClassListTok : public GrammarBase
-{
-public:
-
-    ClassListTok() { }
-    ClassList v;
-};
-
-// ----------------------------------------------------------------------
-// EnumeratorListTok
-// ----------------------------------------------------------------------
-
-class EnumeratorListTok : public GrammarBase
-{
-public:
-
-    EnumeratorListTok() { }
-    EnumeratorList v;
-};
-
-// ----------------------------------------------------------------------
-// ConstDefTok
-// ----------------------------------------------------------------------
-
-class ConstDefTok : public GrammarBase
-{
-public:
-
-    ConstDefTok() { }
-    ConstDef v;
-};
-
-// ----------------------------------------------------------------------
-// OptionalDefTok
-// ----------------------------------------------------------------------
-
-class OptionalDefTok : public GrammarBase
-{
-public:
-
-    OptionalDefTok() { }
-    OptionalDef v;
-};
-
-// ----------------------------------------------------------------------
-// ClassIdTok
-// ----------------------------------------------------------------------
-
-class ClassIdTok : public GrammarBase
-{
-public:
-
-    ClassIdTok() { }
-    std::string v;
-    int t;
-};
-
+    struct StringTok final : public GrammarBase
+    {
+        std::string v;
+        std::string literal;
+    };
+
+    struct MetadataListTok final : public GrammarBase
+    {
+        MetadataList v;
+    };
+
+    struct TypeStringTok final : public GrammarBase
+    {
+        TypeStringTok(TypePtr type, std::string name) : type(std::move(type)), name(std::move(name)) {}
+
+        const TypePtr type;
+        const std::string name;
+    };
+
+    struct IntegerTok final : public GrammarBase
+    {
+        std::int64_t v{0};
+        std::string literal;
+    };
+
+    struct FloatingTok final : public GrammarBase
+    {
+        double v{0};
+        std::string literal;
+    };
+
+    struct BoolTok final : public GrammarBase
+    {
+        BoolTok(bool value) : v(value) {}
+
+        bool v{false};
+    };
+
+    struct ExceptionListTok final : public GrammarBase
+    {
+        ExceptionList v;
+    };
+
+    struct InterfaceListTok final : public GrammarBase
+    {
+        InterfaceList v;
+    };
+
+    struct EnumeratorListTok final : public GrammarBase
+    {
+        EnumeratorList v;
+    };
+
+    struct ConstDefTok final : public GrammarBase
+    {
+        ConstDefTok() = default; // invalid constant
+
+        ConstDefTok(SyntaxTreeBasePtr value, std::string stringValue)
+            : v(std::move(value)),
+              valueAsString(std::move(stringValue))
+        {
+            // Occasionally, v is nullptr but valueAsString is not empty and represents an enumerator.
+            // The Parser looks up the enumerator by name later in validateConstant().
+            assert(v || !valueAsString.empty());
+        }
+
+        const SyntaxTreeBasePtr v;
+        const std::string valueAsString;
+    };
+
+    struct OptionalDefTok final : public GrammarBase
+    {
+        explicit OptionalDefTok(int t) : isOptional(t >= 0), tag(t) {}
+
+        TypePtr type;
+        std::string name;
+        const bool isOptional{false};
+        const std::int32_t tag{0};
+    };
+
+    struct ClassIdTok final : public GrammarBase
+    {
+        std::string v;
+        std::int32_t t{0};
+    };
+
+    struct TokenContext
+    {
+        int firstLine;
+        int lastLine;
+        int firstColumn;
+        int lastColumn;
+        std::string filename;
+    };
+
+    using StringTokPtr = std::shared_ptr<StringTok>;
+    using IntegerTokPtr = std::shared_ptr<IntegerTok>;
+    using FloatingTokPtr = std::shared_ptr<FloatingTok>;
+    using ConstDefTokPtr = std::shared_ptr<ConstDefTok>;
 }
 
-//
-// Stuff for flex and bison
-//
-
-#define YYSTYPE Slice::GrammarBasePtr
-#define YY_DECL int slice_lex(YYSTYPE* yylvalp)
-YY_DECL;
-
-//
-// I must set the initial stack depth to the maximum stack depth to
-// disable bison stack resizing. The bison stack resizing routines use
-// simple malloc/alloc/memcpy calls, which do not work for the
-// YYSTYPE, since YYSTYPE is a C++ type, with constructor, destructor,
-// assignment operator, etc.
-//
-#define YYMAXDEPTH  10000
-#define YYINITDEPTH YYMAXDEPTH // Initial depth is set to max depth, for the reasons described above.
-
-//
-// Newer bison versions allow to disable stack resizing by defining
-// yyoverflow.
-//
-#define yyoverflow(a, b, c, d, e, f) yyerror(a)
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
 
 #endif