#$@%#$%!

Ngiler SH3LL 360
: / usr / share / bison /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : variant.hh \| Size : 9.69 KB
# C++ skeleton for Bison # Copyright (C) 2002-2015 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/>. ## --------- ## ## variant. ## ## --------- ## # b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS]) # ------------------------------------------------ # Run some ACTION ("build", or "destroy") on YYVAL of symbol type # YYTYPE. m4_define([b4_symbol_variant], [m4_pushdef([b4_dollar_dollar], [$2.$3< $][3 > (m4_shift3($@))])dnl switch ($1) { b4_type_foreach([b4_type_action_])[]dnl default: break; } m4_popdef([b4_dollar_dollar])dnl ]) # _b4_char_sizeof_counter # ----------------------- # A counter used by _b4_char_sizeof_dummy to create fresh symbols. m4_define([_b4_char_sizeof_counter], [0]) # _b4_char_sizeof_dummy # --------------------- # At each call return a new C++ identifier. m4_define([_b4_char_sizeof_dummy], [m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl dummy[]_b4_char_sizeof_counter]) # b4_char_sizeof(SYMBOL-NUMS) # --------------------------- # To be mapped on the list of type names to produce: # # char dummy1[sizeof(type_name_1)]; # char dummy2[sizeof(type_name_2)]; # # for defined type names. m4_define([b4_char_sizeof], [b4_symbol_if([$1], [has_type], [ m4_map([ b4_symbol_tag_comment], [$@])dnl char _b4_char_sizeof_dummy@{sizeof(b4_symbol([$1], [type]))@}; ])]) # b4_variant_includes # ------------------- # The needed includes for variants support. m4_define([b4_variant_includes], [b4_parse_assert_if([[#include <typeinfo>]])[ #ifndef YYASSERT # include <cassert> # define YYASSERT assert #endif ]]) # b4_variant_define # ----------------- # Define "variant". m4_define([b4_variant_define], [[ /// A char[S] buffer to store and retrieve objects. /// /// Sort of a variant, but does not keep track of the nature /// of the stored data, since that knowledge is available /// via the current state. template <size_t S> struct variant { /// Type of this. typedef variant<S> self_type; /// Empty construction. variant ()]b4_parse_assert_if([ : yytypeid_ (YY_NULLPTR)])[ {} /// Construct and fill. template <typename T> variant (const T& t)]b4_parse_assert_if([ : yytypeid_ (&typeid (T))])[ { YYASSERT (sizeof (T) <= S); new (yyas_<T> ()) T (t); } /// Destruction, allowed only if empty. ~variant () {]b4_parse_assert_if([ YYASSERT (!yytypeid_); ])[} /// Instantiate an empty \a T in here. template <typename T> T& build () {]b4_parse_assert_if([ YYASSERT (!yytypeid_); YYASSERT (sizeof (T) <= S); yytypeid_ = & typeid (T);])[ return new (yyas_<T> ()) T; } /// Instantiate a \a T in here from \a t. template <typename T> T& build (const T& t) {]b4_parse_assert_if([ YYASSERT (!yytypeid_); YYASSERT (sizeof (T) <= S); yytypeid_ = & typeid (T);])[ return new (yyas_<T> ()) T (t); } /// Accessor to a built \a T. template <typename T> T& as () {]b4_parse_assert_if([ YYASSERT (yytypeid_ == typeid (T)); YYASSERT (sizeof (T) <= S);])[ return yyas_<T> (); } /// Const accessor to a built \a T (for %printer). template <typename T> const T& as () const {]b4_parse_assert_if([ YYASSERT (yytypeid_ == typeid (T)); YYASSERT (sizeof (T) <= S);])[ return yyas_<T> (); } /// Swap the content with \a other, of same type. /// /// Both variants must be built beforehand, because swapping the actual /// data requires reading it (with as()), and this is not possible on /// unconstructed variants: it would require some dynamic testing, which /// should not be the variant's responsability. /// Swapping between built and (possibly) non-built is done with /// variant::move (). template <typename T> void swap (self_type& other) {]b4_parse_assert_if([ YYASSERT (yytypeid_); YYASSERT (yytypeid_ == other.yytypeid_);])[ std::swap (as<T> (), other.as<T> ()); } /// Move the content of \a other to this. /// /// Destroys \a other. template <typename T> void move (self_type& other) { build<T> (); swap<T> (other); other.destroy<T> (); } /// Copy the content of \a other to this. template <typename T> void copy (const self_type& other) { build<T> (other.as<T> ()); } /// Destroy the stored \a T. template <typename T> void destroy () { as<T> ().~T ();]b4_parse_assert_if([ yytypeid_ = YY_NULLPTR;])[ } private: /// Prohibit blind copies. self_type& operator=(const self_type&); variant (const self_type&); /// Accessor to raw memory as \a T. template <typename T> T yyas_ () { void yyp = yybuffer_.yyraw; return static_cast<T> (yyp); } /// Const accessor to raw memory as \a T. template <typename T> const T* yyas_ () const { const void yyp = yybuffer_.yyraw; return static_cast<const T> (yyp); } union { /// Strongest alignment constraints. long double yyalign_me; /// A buffer large enough to store any of the semantic values. char yyraw[S]; } yybuffer_;]b4_parse_assert_if([ /// Whether the content is built: if defined, the name of the stored type. const std::type_info *yytypeid_;])[ }; ]]) ## -------------------------- ## ## Adjustments for variants. ## ## -------------------------- ## # b4_value_type_declare # --------------------- # Declare semantic_type. m4_define([b4_value_type_declare], [[ /// An auxiliary type to compute the largest semantic type. union union_type {]b4_type_foreach([b4_char_sizeof])[}; /// Symbol semantic values. typedef variant<sizeof(union_type)> semantic_type;][]dnl ]) # How the semantic value is extracted when using variants. # b4_symbol_value(VAL, [TYPE]) # ---------------------------- m4_define([b4_symbol_value], [m4_ifval([$2], [$1.as< $2 > ()], [$1])]) # b4_symbol_value_template(VAL, [TYPE]) # ------------------------------------- # Same as b4_symbol_value, but used in a template method. m4_define([b4_symbol_value_template], [m4_ifval([$2], [$1.template as< $2 > ()], [$1])]) ## ------------- ## ## make_SYMBOL. ## ## ------------- ## # b4_symbol_constructor_declare_(SYMBOL-NUMBER) # --------------------------------------------- # Declare the overloaded version of make_symbol for the (common) type of # these SYMBOL-NUMBERS. Use at class-level. m4_define([b4_symbol_constructor_declare_], [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id], [ static inline symbol_type make_[]b4_symbol_([$1], [id]) (dnl b4_join(b4_symbol_if([$1], [has_type], [const b4_symbol([$1], [type])& v]), b4_locations_if([const location_type& l]))); ])])]) # b4_symbol_constructor_declare # ----------------------------- # Declare symbol constructors for all the value types. # Use at class-level. m4_define([b4_symbol_constructor_declare], [ // Symbol constructors declarations. b4_symbol_foreach([b4_symbol_constructor_declare_])]) # b4_symbol_constructor_define_(SYMBOL-NUMBER) # -------------------------------------------- # Define symbol constructor for this SYMBOL-NUMBER. m4_define([b4_symbol_constructor_define_], [b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id], [ b4_parser_class_name::symbol_type b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl b4_join(b4_symbol_if([$1], [has_type], [const b4_symbol([$1], [type])& v]), b4_locations_if([const location_type& l]))) { return symbol_type (b4_join([token::b4_symbol([$1], [id])], b4_symbol_if([$1], [has_type], [v]), b4_locations_if([l]))); } ])])]) # b4_basic_symbol_constructor_declare # ----------------------------------- # Generate a constructor declaration for basic_symbol from given type. m4_define([b4_basic_symbol_constructor_declare], [[ basic_symbol (]b4_join( [typename Base::kind_type t], b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]), b4_locations_if([const location_type& l]))[); ]]) # b4_basic_symbol_constructor_define # ---------------------------------- # Generate a constructor implementation for basic_symbol from given type. m4_define([b4_basic_symbol_constructor_define], [[ template <typename Base> ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join( [typename Base::kind_type t], b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]), b4_locations_if([const location_type& l]))[) : Base (t) , value (]b4_symbol_if([$1], [has_type], [v])[)]b4_locations_if([ , location (l)])[ {} ]]) # b4_symbol_constructor_define # ---------------------------- # Define the overloaded versions of make_symbol for all the value types. m4_define([b4_symbol_constructor_define], [ // Implementation of make_symbol for each symbol type. b4_symbol_foreach([b4_symbol_constructor_define_])]) Back

Edit File : variant.hh | Size : 9.69 KB

# C++ skeleton for Bison

# 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/>.

## --------- ##
## variant.  ##
## --------- ##

# b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS])
# ------------------------------------------------
# Run some ACTION ("build", or "destroy") on YYVAL of symbol type
# YYTYPE.
m4_define([b4_symbol_variant],
[m4_pushdef([b4_dollar_dollar],
            [$2.$3< $][3 > (m4_shift3($@))])dnl
  switch ($1)
    {
b4_type_foreach([b4_type_action_])[]dnl
      default:
        break;
    }
m4_popdef([b4_dollar_dollar])dnl
])

# _b4_char_sizeof_counter
# -----------------------
# A counter used by _b4_char_sizeof_dummy to create fresh symbols.
m4_define([_b4_char_sizeof_counter],
[0])

# _b4_char_sizeof_dummy
# ---------------------
# At each call return a new C++ identifier.
m4_define([_b4_char_sizeof_dummy],
[m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl
dummy[]_b4_char_sizeof_counter])

# b4_char_sizeof(SYMBOL-NUMS)
# ---------------------------
# To be mapped on the list of type names to produce:
#
#    char dummy1[sizeof(type_name_1)];
#    char dummy2[sizeof(type_name_2)];
#
# for defined type names.
m4_define([b4_char_sizeof],
[b4_symbol_if([$1], [has_type],
[
m4_map([      b4_symbol_tag_comment], [$@])dnl
      char _b4_char_sizeof_dummy@{sizeof(b4_symbol([$1], [type]))@};
])])

# b4_variant_includes
# -------------------
# The needed includes for variants support.
m4_define([b4_variant_includes],
[b4_parse_assert_if([[#include <typeinfo>]])[
#ifndef YYASSERT
# include <cassert>
# define YYASSERT assert
#endif
]])

# b4_variant_define
# -----------------
# Define "variant".
m4_define([b4_variant_define],
[[  /// A char[S] buffer to store and retrieve objects.
  ///
  /// Sort of a variant, but does not keep track of the nature
  /// of the stored data, since that knowledge is available
  /// via the current state.
  template <size_t S>
  struct variant
  {
    /// Type of *this.
    typedef variant<S> self_type;

/// Empty construction.
    variant ()]b4_parse_assert_if([
      : yytypeid_ (YY_NULLPTR)])[
    {}

/// Construct and fill.
    template <typename T>
    variant (const T& t)]b4_parse_assert_if([
      : yytypeid_ (&typeid (T))])[
    {
      YYASSERT (sizeof (T) <= S);
      new (yyas_<T> ()) T (t);
    }

/// Destruction, allowed only if empty.
    ~variant ()
    {]b4_parse_assert_if([
      YYASSERT (!yytypeid_);
    ])[}

/// Instantiate an empty \a T in here.
    template <typename T>
    T&
    build ()
    {]b4_parse_assert_if([
      YYASSERT (!yytypeid_);
      YYASSERT (sizeof (T) <= S);
      yytypeid_ = & typeid (T);])[
      return *new (yyas_<T> ()) T;
    }

/// Instantiate a \a T in here from \a t.
    template <typename T>
    T&
    build (const T& t)
    {]b4_parse_assert_if([
      YYASSERT (!yytypeid_);
      YYASSERT (sizeof (T) <= S);
      yytypeid_ = & typeid (T);])[
      return *new (yyas_<T> ()) T (t);
    }

/// Accessor to a built \a T.
    template <typename T>
    T&
    as ()
    {]b4_parse_assert_if([
      YYASSERT (*yytypeid_ == typeid (T));
      YYASSERT (sizeof (T) <= S);])[
      return *yyas_<T> ();
    }

/// Const accessor to a built \a T (for %printer).
    template <typename T>
    const T&
    as () const
    {]b4_parse_assert_if([
      YYASSERT (*yytypeid_ == typeid (T));
      YYASSERT (sizeof (T) <= S);])[
      return *yyas_<T> ();
    }

/// Swap the content with \a other, of same type.
    ///
    /// Both variants must be built beforehand, because swapping the actual
    /// data requires reading it (with as()), and this is not possible on
    /// unconstructed variants: it would require some dynamic testing, which
    /// should not be the variant's responsability.
    /// Swapping between built and (possibly) non-built is done with
    /// variant::move ().
    template <typename T>
    void
    swap (self_type& other)
    {]b4_parse_assert_if([
      YYASSERT (yytypeid_);
      YYASSERT (*yytypeid_ == *other.yytypeid_);])[
      std::swap (as<T> (), other.as<T> ());
    }

/// Move the content of \a other to this.
    ///
    /// Destroys \a other.
    template <typename T>
    void
    move (self_type& other)
    {
      build<T> ();
      swap<T> (other);
      other.destroy<T> ();
    }

/// Copy the content of \a other to this.
    template <typename T>
    void
    copy (const self_type& other)
    {
      build<T> (other.as<T> ());
    }

/// Destroy the stored \a T.
    template <typename T>
    void
    destroy ()
    {
      as<T> ().~T ();]b4_parse_assert_if([
      yytypeid_ = YY_NULLPTR;])[
    }

private:
    /// Prohibit blind copies.
    self_type& operator=(const self_type&);
    variant (const self_type&);

/// Accessor to raw memory as \a T.
    template <typename T>
    T*
    yyas_ ()
    {
      void *yyp = yybuffer_.yyraw;
      return static_cast<T*> (yyp);
     }

/// Const accessor to raw memory as \a T.
    template <typename T>
    const T*
    yyas_ () const
    {
      const void *yyp = yybuffer_.yyraw;
      return static_cast<const T*> (yyp);
     }

union
    {
      /// Strongest alignment constraints.
      long double yyalign_me;
      /// A buffer large enough to store any of the semantic values.
      char yyraw[S];
    } yybuffer_;]b4_parse_assert_if([

/// Whether the content is built: if defined, the name of the stored type.
    const std::type_info *yytypeid_;])[
  };
]])

## -------------------------- ##
## Adjustments for variants.  ##
## -------------------------- ##

# b4_value_type_declare
# ---------------------
# Declare semantic_type.
m4_define([b4_value_type_declare],
[[    /// An auxiliary type to compute the largest semantic type.
    union union_type
    {]b4_type_foreach([b4_char_sizeof])[};

/// Symbol semantic values.
    typedef variant<sizeof(union_type)> semantic_type;][]dnl
])

# How the semantic value is extracted when using variants.

# b4_symbol_value(VAL, [TYPE])
# ----------------------------
m4_define([b4_symbol_value],
[m4_ifval([$2],
          [$1.as< $2 > ()],
          [$1])])

# b4_symbol_value_template(VAL, [TYPE])
# -------------------------------------
# Same as b4_symbol_value, but used in a template method.
m4_define([b4_symbol_value_template],
[m4_ifval([$2],
          [$1.template as< $2 > ()],
          [$1])])

## ------------- ##
## make_SYMBOL.  ##
## ------------- ##

# b4_symbol_constructor_declare_(SYMBOL-NUMBER)
# ---------------------------------------------
# Declare the overloaded version of make_symbol for the (common) type of
# these SYMBOL-NUMBERS.  Use at class-level.
m4_define([b4_symbol_constructor_declare_],
[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
[    static inline
    symbol_type
    make_[]b4_symbol_([$1], [id]) (dnl
b4_join(b4_symbol_if([$1], [has_type],
                     [const b4_symbol([$1], [type])& v]),
        b4_locations_if([const location_type& l])));

])])])

# b4_symbol_constructor_declare
# -----------------------------
# Declare symbol constructors for all the value types.
# Use at class-level.
m4_define([b4_symbol_constructor_declare],
[    // Symbol constructors declarations.
b4_symbol_foreach([b4_symbol_constructor_declare_])])

# b4_symbol_constructor_define_(SYMBOL-NUMBER)
# --------------------------------------------
# Define symbol constructor for this SYMBOL-NUMBER.
m4_define([b4_symbol_constructor_define_],
[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
[  b4_parser_class_name::symbol_type
  b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl
b4_join(b4_symbol_if([$1], [has_type],
                     [const b4_symbol([$1], [type])& v]),
        b4_locations_if([const location_type& l])))
  {
    return symbol_type (b4_join([token::b4_symbol([$1], [id])],
                                b4_symbol_if([$1], [has_type], [v]),
                                b4_locations_if([l])));
  }

])])])

# b4_basic_symbol_constructor_declare
# -----------------------------------
# Generate a constructor declaration for basic_symbol from given type.
m4_define([b4_basic_symbol_constructor_declare],
[[
  basic_symbol (]b4_join(
          [typename Base::kind_type t],
          b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
          b4_locations_if([const location_type& l]))[);
]])

# b4_basic_symbol_constructor_define
# ----------------------------------
# Generate a constructor implementation for basic_symbol from given type.
m4_define([b4_basic_symbol_constructor_define],
[[
  template <typename Base>
  ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
          [typename Base::kind_type t],
          b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
          b4_locations_if([const location_type& l]))[)
    : Base (t)
    , value (]b4_symbol_if([$1], [has_type], [v])[)]b4_locations_if([
    , location (l)])[
  {}
]])

# b4_symbol_constructor_define
# ----------------------------
# Define the overloaded versions of make_symbol for all the value types.
m4_define([b4_symbol_constructor_define],
[  // Implementation of make_symbol for each symbol type.
b4_symbol_foreach([b4_symbol_constructor_define_])])

Back