Uncategorized – websekolah.biz.id

rolex replica watches

ReplicaClone.is is an online store that creates and sells quality rolex replica watches at reasonable and affordable prices.

Hublot replica watches

Looking for high quality replica watches? Check out www.thecomedypub.co.uk. Experience the stylish design and craftsmanship of Hublot replica watches at a fraction of […]

Rolexreplicauk.me offers exquisite replica Siwss made rolex watches that are meticulously crafted with great attention to detail. Order Replica watches UK at http://www.gwyneddsands.co.uk/aboutus.htm. […]

Replica Watches Factory

Looking for the best Replica Rolex Watches site 2024 in the world? Buy now High-Quality rolex replica watches for the best price […]

hot sale Rolex replica watches

Best quality replica watches uk is fake swiss omega watches at replicaomega.io,sale 1:1 best replica omega watches, high-quality swiss movement. Buy […]

shop for gents and ladies

Newest Swiss rolex replica uk online shop for gents and ladies. Newest Swiss Rolex replica watches uk online shop for gents and ladies. Browse […]

Clean Factory

Welcome To Our Fake Luxury Rolex Watches Online Store, Where You Can Find All The Replica Rolex Yacht-Master Watches! Clean Factory Buy […]

Replica Cartier Cle De Cartier Watches

All Replica Cartier Cle De Cartier Watches are the best quality and the best price. Buy The Perfect Rolex, Omega, Breitling Replica […]

fake Omega watches

Our fake Omega watches bring you the high standards of quality and excellence at an affordable price. Day Date Replica watches with Free […]

Panerai replica

# C++ GLR 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/>. # This skeleton produces a C++ class that encapsulates a C glr parser. # This is in order to reduce the maintenance burden. The glr.c # skeleton is clean and pure enough so that there are no real # problems. The C++ interface is the same as that of lalr1.cc. In # fact, glr.c can replace yacc.c without the user noticing any # difference, and similarly for glr.cc replacing lalr1.cc. # # The passing of parse-params # # The additional arguments are stored as members of the parser # object, yyparser. The C routines need to carry yyparser # throughout the C parser; that's easy: make yyparser an # additional parse-param. But because the C++ skeleton needs to # know the "real" original parse-param, we save them # (b4_parse_param_orig). Note that b4_parse_param is overquoted # (and c.m4 strips one level of quotes). This is a PITA, and # explains why there are so many levels of quotes. # # The locations # # We use location.cc just like lalr1.cc, but because glr.c stores # the locations in a union, the position and location classes # must not have a constructor. Therefore, contrary to lalr1.cc, we # must not define "b4_location_constructors". As a consequence the # user must initialize the first positions (in particular the # filename member). # We require a pure interface. m4_define([b4_pure_flag], [1]) m4_include(b4_pkgdatadir/[c++.m4]) b4_bison_locations_if([m4_include(b4_pkgdatadir/[location.cc])]) m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])]) # Save the parse parameters. m4_define([b4_parse_param_orig], m4_defn([b4_parse_param])) # b4_parse_param_wrap # ------------------- # New ones. m4_ifset([b4_parse_param], [m4_define([b4_parse_param_wrap], [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]],] m4_defn([b4_parse_param]))], [m4_define([b4_parse_param_wrap], [[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]]]) ]) # b4_yy_symbol_print_define # ------------------------- # Bypass the default implementation to generate the "yy_symbol_print" # and "yy_symbol_value_print" functions. m4_define([b4_yy_symbol_print_define], [[ /*--------------------. | Print this symbol. | `--------------------*/ ]b4_function_define([yy_symbol_print], [static void], [[FILE *], []], [[int yytype], [yytype]], [[const ]b4_namespace_ref::b4_parser_class_name[::semantic_type *yyvaluep], [yyvaluep]][]dnl b4_locations_if([, [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], [yylocationp]]]), b4_parse_param)[ { ]b4_parse_param_use[]dnl [ yyparser.yy_symbol_print_ (yytype, yyvaluep]b4_locations_if([, yylocationp])[); } ]])[ # Hijack the initial action to initialize the locations. ]b4_bison_locations_if([m4_define([b4_initial_action], [yylloc.initialize ();]m4_ifdef([b4_initial_action], [ m4_defn([b4_initial_action])]))])[ # Hijack the post prologue to insert early definition of YYLLOC_DEFAULT # and declaration of yyerror. ]m4_append([b4_post_prologue], [b4_syncline([@oline@], [@ofile@])[ ]b4_yylloc_default_define[ #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) ]b4_function_declare([yyerror], [static void],b4_locations_if([ [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], [yylocationp]],]) b4_parse_param, [[const char* msg], [msg]])]) #undef yynerrs #undef yychar #undef yylval]b4_locations_if([ #undef yylloc]) m4_if(b4_prefix, [yy], [], [[/* Substitute the variable and function names. */ #define yyparse ]b4_prefix[parse #define yylex ]b4_prefix[lex #define yyerror ]b4_prefix[error #define yydebug ]b4_prefix[debug ]]b4_pure_if([], [[ #define yylval ]b4_prefix[lval #define yychar ]b4_prefix[char #define yynerrs ]b4_prefix[nerrs]b4_locations_if([[ #define yylloc ]b4_prefix[lloc]])])) # Hijack the epilogue to define implementations (yyerror, parser member # functions etc.). m4_append([b4_epilogue], [b4_syncline([@oline@], [@ofile@])[ /*------------------. | Report an error. | `------------------*/ ]b4_function_define([yyerror], [static void],b4_locations_if([ [[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp], [yylocationp]],]) b4_parse_param, [[const char* msg], [msg]])[ { ]b4_parse_param_use[]dnl [ yyparser.error (]b4_locations_if([[*yylocationp, ]])[msg); } ]b4_namespace_open[ ]dnl In this section, the parse params are the original parse_params. m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl [ /// Build a parser object. ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [ :])[ #if ]b4_api_PREFIX[DEBUG ]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[ #endif]b4_parse_param_cons[ { } ]b4_parser_class_name::~b4_parser_class_name[ () { } int ]b4_parser_class_name[::parse () { return ::yyparse (*this]b4_user_args[); } #if ]b4_api_PREFIX[DEBUG /*--------------------. | Print this symbol. | `--------------------*/ inline void ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, const semantic_type* yyvaluep]b4_locations_if([[, const location_type* yylocationp]])[) {]b4_locations_if([[ YYUSE (yylocationp);]])[ YYUSE (yyvaluep); std::ostream& yyoutput = debug_stream (); std::ostream& yyo = yyoutput; YYUSE (yyo); ]b4_symbol_actions([printer])[ } void ]b4_parser_class_name[::yy_symbol_print_ (int yytype, const semantic_type* yyvaluep]b4_locations_if([[, const location_type* yylocationp]])[) { *yycdebug_ << (yytype < YYNTOKENS ? "token" : "nterm") << ' ' << yytname[yytype] << " ("]b4_locations_if([[ << *yylocationp << ": "]])[; yy_symbol_value_print_ (yytype, yyvaluep]b4_locations_if([[, yylocationp]])[); *yycdebug_ << ')'; } std::ostream& ]b4_parser_class_name[::debug_stream () const { return *yycdebug_; } void ]b4_parser_class_name[::set_debug_stream (std::ostream& o) { yycdebug_ = &o; } ]b4_parser_class_name[::debug_level_type ]b4_parser_class_name[::debug_level () const { return yydebug; } void ]b4_parser_class_name[::set_debug_level (debug_level_type l) { // Actually, it is yydebug which is really used. yydebug = l; } #endif ]m4_popdef([b4_parse_param])dnl b4_namespace_close ]) # b4_shared_declarations # ---------------------- # Declaration that might either go into the header (if --defines) # or open coded in the parser body. m4_define([b4_shared_declarations], [m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl b4_percent_code_get([[requires]])[ #include <stdexcept> #include <string> #include <iostream>]b4_defines_if([ b4_bison_locations_if([[#include "location.hh"]])])[ ]b4_YYDEBUG_define[ ]b4_namespace_open[ ]b4_defines_if([], [b4_bison_locations_if([b4_position_define b4_location_define])])[ /// A Bison parser. class ]b4_parser_class_name[ { public: ]b4_public_types_declare[ /// Build a parser object. ]b4_parser_class_name[ (]b4_parse_param_decl[); virtual ~]b4_parser_class_name[ (); /// Parse. /// \returns 0 iff parsing succeeded. virtual int parse (); /// The current debugging stream. std::ostream& debug_stream () const; /// Set the current debugging stream. void set_debug_stream (std::ostream &); /// Type for debugging levels. typedef int debug_level_type; /// The current debugging level. debug_level_type debug_level () const; /// Set the current debugging level. void set_debug_level (debug_level_type l); public: /// Report a syntax error.]b4_locations_if([[ /// \param loc where the syntax error is found.]])[ /// \param msg a description of the syntax error. virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg); # if ]b4_api_PREFIX[DEBUG public: /// \brief Report a symbol value on the debug stream. /// \param yytype The token type. /// \param yyvaluep Its semantic value.]b4_locations_if([[ /// \param yylocationp Its location.]])[ virtual void yy_symbol_value_print_ (int yytype, const semantic_type* yyvaluep]b4_locations_if([[, const location_type* yylocationp]])[); /// \brief Report a symbol on the debug stream. /// \param yytype The token type. /// \param yyvaluep Its semantic value.]b4_locations_if([[ /// \param yylocationp Its location.]])[ virtual void yy_symbol_print_ (int yytype, const semantic_type* yyvaluep]b4_locations_if([[, const location_type* yylocationp]])[); private: // Debugging. std::ostream* yycdebug_; #endif ]b4_parse_param_vars[ }; ]dnl Redirections for glr.c. b4_percent_define_flag_if([[global_tokens_and_yystype]], [b4_token_defines]) [ #ifndef ]b4_api_PREFIX[STYPE # define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type #endif #ifndef ]b4_api_PREFIX[LTYPE # define ]b4_api_PREFIX[LTYPE ]b4_namespace_ref[::]b4_parser_class_name[::location_type #endif ]b4_namespace_close[ ]b4_percent_code_get([[provides]])[ ]m4_popdef([b4_parse_param])dnl ]) b4_defines_if( [b4_output_begin([b4_spec_defines_file]) b4_copyright([Skeleton interface for Bison GLR parsers in C++], [2002-2015])[ // C++ GLR parser skeleton written by Akim Demaille. ]b4_cpp_guard_open([b4_spec_defines_file])[ ]b4_shared_declarations[ ]b4_cpp_guard_close([b4_spec_defines_file])[ ]b4_output_end()]) # Let glr.c (and b4_shared_declarations) believe that the user # arguments include the parser itself. m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_wrap])) m4_include(b4_pkgdatadir/[glr.c]) m4_popdef([b4_parse_param])

Kategori: Uncategorized