rock-qtbindings 4.8.6.5

data/ext/generator/parser/parser.h

@@ -0,0 +1,290 @@
+/* This file is part of KDevelop
+    Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+    Copyright 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License version 2 as published by the Free Software Foundation.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#ifndef PARSER_H
+#define PARSER_H
+
+#include "ast.h"
+#include "lexer.h"
+#include "commentparser.h"
+
+#include "cppparser_export.h"
+
+#include <QtCore/QQueue>
+#include <QtCore/QSet>
+#include <QtCore/QString>
+#include <QtCore/QHash>
+
+class TokenStream;
+class Control;
+
+/**
+The Parser.
+LL(k) parser for c++ code.
+*/
+class CPPPARSER_EXPORT Parser
+{
+public:
+  Parser(Control *control);
+  ~Parser();
+
+  /**Parses the @p contents of the buffer of given @p size using the
+  memory pool @p p to store tokens found.
+
+  Calls lexer to tokenize all contents buffer, skips the first token
+  (because the lexer provides Token_EOF as the first token,
+  creates and fills the AST and returns translation unit or 0
+  if nothing was parsed.
+
+  @sa pool for more information about the memory pool used.*/
+  TranslationUnitAST *parse(ParseSession* session);
+  /**
+
+   * Same as parse, except that it parses the content as a compound statement.
+   * This is useful for parsing independent expression-strings that appear for
+   * example within a function.
+   *
+   * parse(..) expects the content to be a valid translation-unit,
+   * while parseStatement can parse strings like "{a.b = 5;}" as if they
+   * appeared within a function.
+   *
+   * Note: The input must be a valid compound-statement, which means it must
+   * start at least with "{", and end with ";}"
+   **/
+  StatementAST *parseStatement(ParseSession* session);
+
+  /**
+   * Nearly the same as parseStatement, except that it parses the content as a type-id if possible,
+   * if that fails, as an expression. This is perfect for parsing template-arguements.
+   * The input can be as simple as "A" or "A::a+2"
+   * @param forceExpression If this is true, the text will not be considered to be a type-id, only an expression.
+   *                                         With this parameter, unlike during normal parsing, primary expressions may
+   *                                         have template parameters even without a function-call behind. That allows evaluating only partial expressions.
+   * */
+  AST *parseTypeOrExpression(ParseSession* session, bool forceExpression = false);
+  /**@return the problem count.*/
+  int problemCount() const { return _M_problem_count; }
+
+private:
+  /**Convenience method to report problems. Constructs the problem
+  using the information about the current line and column in the buffer
+  that is being parsed. Then stores the problem in the control object.*/
+  void reportError(const QString& msg);
+  /**Reports a syntax error about unexpected token. The token
+  reported is LA (look-ahead) from the stream.*/
+  void syntaxError();
+  /**Reports a syntax error about required token when LA is wrong.*/
+  void tokenRequiredError(int expected);
+
+public:
+  bool parseAbstractDeclarator(DeclaratorAST *&node);
+  bool parseAccessSpecifier(DeclarationAST *&node);
+  bool parseAdditiveExpression(ExpressionAST *&node);
+  bool parseAndExpression(ExpressionAST *&node, bool templArgs = false);
+  bool parseAsmDefinition(DeclarationAST *&node);
+  bool parseAssignmentExpression(ExpressionAST *&node);
+  bool parseBaseClause(BaseClauseAST *&node);
+  bool parseBaseSpecifier(BaseSpecifierAST *&node);
+  bool parseBlockDeclaration(DeclarationAST *&node);
+  bool parseCastExpression(ExpressionAST *&node);
+  bool parseClassSpecifier(TypeSpecifierAST *&node);
+  bool parseSignalSlotExpression(ExpressionAST *&node);
+  bool parseCommaExpression(ExpressionAST *&node);
+  bool parseCompoundStatement(StatementAST *&node);
+  bool parseCondition(ConditionAST *&node, bool initRequired = true);
+  bool parseConditionalExpression(ExpressionAST *&node);
+  bool parseConstantExpression(ExpressionAST *&node);
+  bool parseCtorInitializer(CtorInitializerAST *&node);
+  bool parseCvQualify(const ListNode<std::size_t> *&node);
+  bool parseDeclaration(DeclarationAST *&node);
+  bool parseDeclarationInternal(DeclarationAST *&node);
+  bool parseDeclarationStatement(StatementAST *&node);
+  bool parseDeclarator(DeclaratorAST *&node);
+  bool parseDeleteExpression(ExpressionAST *&node);
+  bool parseDoStatement(StatementAST *&node);
+  bool parseElaboratedTypeSpecifier(TypeSpecifierAST *&node);
+  bool parseEnumSpecifier(TypeSpecifierAST *&node);
+  bool parseEnumerator(EnumeratorAST *&node);
+  bool parseEqualityExpression(ExpressionAST *&node,
+			       bool templArgs = false);
+  bool parseExceptionSpecification(ExceptionSpecificationAST *&node);
+  bool parseExclusiveOrExpression(ExpressionAST *&node,
+				  bool templArgs = false);
+  bool parseExpression(ExpressionAST *&node);
+  bool parseExpressionOrDeclarationStatement(StatementAST *&node);
+  bool parseExpressionStatement(StatementAST *&node);
+  bool parseForInitStatement(StatementAST *&node);
+  bool parseForStatement(StatementAST *&node);
+  bool parseFunctionBody(StatementAST *&node);
+  bool parseFunctionSpecifier(const ListNode<std::size_t> *&node);
+  bool parseIfStatement(StatementAST *&node);
+  bool parseInclusiveOrExpression(ExpressionAST *&node,
+				  bool templArgs = false);
+  bool parseInitDeclarator(InitDeclaratorAST *&node);
+  bool parseInitDeclaratorList(const ListNode<InitDeclaratorAST*> *&node);
+  bool parseInitializer(InitializerAST *&node);
+  bool parseInitializerClause(InitializerClauseAST *&node);
+  bool parseInitializerList(const ListNode<InitializerClauseAST*> *&node);
+  bool parseJumpStatement(StatementAST *&node);
+  bool parseLabeledStatement(StatementAST *&node);
+  bool parseLinkageBody(LinkageBodyAST *&node);
+  bool parseLinkageSpecification(DeclarationAST *&node);
+  bool parseLogicalAndExpression(ExpressionAST *&node,
+				 bool templArgs = false);
+  bool parseLogicalOrExpression(ExpressionAST *&node,
+				bool templArgs = false);
+  bool parseMemInitializer(MemInitializerAST *&node);
+  bool parseMemInitializerList(const ListNode<MemInitializerAST*> *&node);
+  bool parseMemberSpecification(DeclarationAST *&node);
+  bool parseMultiplicativeExpression(ExpressionAST *&node);
+  
+  enum ParseNameAcceptTemplate {
+    DontAcceptTemplate = 0,
+    AcceptTemplate = 1,
+    //If this is given, template-parameters are only accepted if the name is followed by a function call
+    EventuallyAcceptTemplate = 2
+  };
+  bool parseName(NameAST *&node, ParseNameAcceptTemplate acceptTemplateId = DontAcceptTemplate);
+  bool parseNamespace(DeclarationAST *&node);
+  bool parseNamespaceAliasDefinition(DeclarationAST *&node);
+  bool parseNewDeclarator(NewDeclaratorAST *&node);
+  bool parseNewExpression(ExpressionAST *&node);
+  bool parseNewInitializer(NewInitializerAST *&node);
+  bool parseNewTypeId(NewTypeIdAST *&node);
+  bool parseOperator(OperatorAST *&node);
+  bool parseOperatorFunctionId(OperatorFunctionIdAST *&node);
+  bool parseParameterDeclaration(ParameterDeclarationAST *&node);
+  bool parseParameterDeclarationClause(ParameterDeclarationClauseAST *&node);
+  bool parseParameterDeclarationList(const ListNode<ParameterDeclarationAST*> *&node);
+  bool parsePmExpression(ExpressionAST *&node);
+  bool parsePostfixExpression(ExpressionAST *&node);
+  bool parsePostfixExpressionInternal(ExpressionAST *&node);
+  bool parsePrimaryExpression(ExpressionAST *&node);
+  bool parsePtrOperator(PtrOperatorAST *&node);
+  bool parsePtrToMember(PtrToMemberAST *&node);
+  bool parseRelationalExpression(ExpressionAST *&node,
+				 bool templArgs = false);
+  bool parseShiftExpression(ExpressionAST *&node);
+  bool parseSimpleTypeSpecifier(TypeSpecifierAST *&node,
+				bool onlyIntegral = false);
+  bool parseStatement(StatementAST *&node);
+  bool parseStorageClassSpecifier(const ListNode<std::size_t> *&node);
+  bool parseStringLiteral(StringLiteralAST *&node);
+  bool parseSwitchStatement(StatementAST *&node);
+  bool parseTemplateArgument(TemplateArgumentAST *&node);
+  bool parseTemplateArgumentList(const ListNode<TemplateArgumentAST*> *&node,
+				 bool reportError = true);
+  bool parseTemplateDeclaration(DeclarationAST *&node);
+  bool parseTemplateParameter(TemplateParameterAST *&node);
+  bool parseTemplateParameterList(const ListNode<TemplateParameterAST*> *&node);
+  bool parseThrowExpression(ExpressionAST *&node);
+  bool parseTranslationUnit(TranslationUnitAST *&node);
+  bool parseTryBlockStatement(StatementAST *&node);
+  bool parseTypeId(TypeIdAST *&node);
+  bool parseTypeIdList(const ListNode<TypeIdAST*> *&node);
+  bool parseTypeParameter(TypeParameterAST *&node);
+  bool parseTypeSpecifier(TypeSpecifierAST *&node);
+  bool parseTypeSpecifierOrClassSpec(TypeSpecifierAST *&node);
+  bool parseTypedef(DeclarationAST *&node);
+  bool parseUnaryExpression(ExpressionAST *&node);
+  bool parseUnqualifiedName(UnqualifiedNameAST *&node,
+			    bool parseTemplateId = true);
+  bool parseUsing(DeclarationAST *&node);
+  bool parseUsingDirective(DeclarationAST *&node);
+  bool parseWhileStatement(StatementAST *&node);
+  bool parseWinDeclSpec(WinDeclSpecAST *&node);
+
+  bool skipUntil(int token);
+  bool skipUntilDeclaration();
+  bool skipUntilStatement();
+  bool skip(int l, int r);
+
+  void addComment( CommentAST* ast, const Comment& comment );
+  //Moves all currently available comments to the given AST, removing them from the comment-store
+  void moveComments( CommentAST* ast );
+
+  void advance(bool skipComment = true);
+  void rewind(size_t position);
+  // private:
+  TokenStream* token_stream;
+
+// private:
+  Control *control;
+  Lexer lexer;
+private:
+  
+  enum TokenMarkers {
+    None = 0,
+    IsNoTemplateArgumentList = 1
+  };
+  
+  TokenMarkers tokenMarkers(size_t tokenNumber) const;
+  void addTokenMarkers(size_t tokenNumber, TokenMarkers markers);
+
+
+  int lineFromTokenNumber( size_t tokenNumber ) const;
+
+  void clear();
+  
+  ///parses all comments until the end of the line
+  Comment comment();
+  ///Preparses comments in the same line as given token-number
+  void preparseLineComments( int tokenNumber );
+  void processComment( int offset = 0, int line = -1 );
+  void clearComment( );
+
+  bool holdErrors(bool hold);
+  void reportPendingErrors();
+
+  Comment m_currentComment;
+  CommentStore m_commentStore;
+ 
+  QHash<size_t, TokenMarkers> m_tokenMarkers;
+  int _M_problem_count;
+  int _M_max_problem_count;
+  ParseSession* session;
+  bool _M_hold_errors;
+  size_t _M_last_valid_token; //Last encountered token that was not a comment
+  size_t _M_last_parsed_comment;
+  
+  bool _M_hadMismatchingCompoundTokens;
+  bool m_primaryExpressionWithTemplateParamsNeedsFunctionCall;
+
+  // keeps track of tokens where a syntax error has been found
+  // so that the same error is not reported twice for a token
+  QSet<std::size_t> m_syntaxErrorTokens;
+
+  // when _M_hold_errors is true, reported errors are held in m_pendingErrors
+  // rather than being reported to the Control immediately.
+  //
+  // this is used, for example, when parsing ambiguous statements.
+  struct PendingError
+  {
+   QString message;
+   std::size_t cursor;
+  };
+  QQueue<PendingError> m_pendingErrors;
+
+private:
+  Parser(const Parser& source);
+  void operator = (const Parser& source);
+};
+
+#endif
+

data/ext/generator/parser/parsesession.cpp

@@ -0,0 +1,106 @@
+/* This file is part of KDevelop
+    Copyright 2006 Hamish Rodda <rodda@kde.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License version 2 as published by the Free Software Foundation.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#include "parsesession.h"
+
+#include "rpp/pp-location.h"
+#include "rpp/pp-environment.h"
+#include "lexer.h"
+#include "memorypool.h"
+#include "problem.h"
+#include "indexedstring.h"
+
+#include <cctype>
+
+ParseSession::ParseSession()
+  : mempool(new pool)
+  , token_stream(0)
+  , macros(0)
+  , m_locationTable(0)
+{
+}
+
+ParseSession::~ParseSession()
+{
+  delete mempool;
+  delete token_stream;
+  delete m_locationTable;
+  delete macros;
+}
+
+rpp::Anchor ParseSession::positionAt(std::size_t offset, bool collapseIfMacroExpansion) const
+{
+  Q_ASSERT(m_locationTable);
+
+  return m_locationTable->positionAt(offset, m_contents, collapseIfMacroExpansion).first;
+}
+
+QPair<rpp::Anchor, uint> ParseSession::positionAndSpaceAt(std::size_t offset, bool collapseIfMacroExpansion) const
+{
+  Q_ASSERT(m_locationTable);
+
+  return m_locationTable->positionAt(offset, m_contents, collapseIfMacroExpansion);
+}
+
+std::size_t ParseSession::size() const
+{
+  return m_contents.size() + 1;
+}
+
+ uint* ParseSession::contents()
+ {
+   return m_contents.data();
+ }
+
+const uint* ParseSession::contents() const
+ {
+   return m_contents.data();
+ }
+ 
+const PreprocessedContents& ParseSession::contentsVector() const
+{
+  return m_contents;
+}
+
+void ParseSession::setContents(const PreprocessedContents& contents, rpp::LocationTable* locationTable)
+{
+  m_contents = contents;
+  m_locationTable = locationTable;
+}
+
+void ParseSession::setContentsAndGenerateLocationTable(const PreprocessedContents& contents)
+{
+  m_contents = contents;
+  ///@todo We need this in the lexer, the problem is that we copy the vector when doing this
+  m_contents.append(0);
+  m_contents.append(0);
+  m_contents.append(0);
+  m_contents.append(0);
+  
+  m_locationTable = new rpp::LocationTable(m_contents);
+}
+
+void ParseSession::setUrl(const IndexedString& url)
+{
+  m_url = url;
+}
+
+const IndexedString& ParseSession::url() const
+{
+  return m_url;
+}

data/ext/generator/parser/parsesession.h

@@ -0,0 +1,87 @@
+/* This file is part of KDevelop
+    Copyright 2006 Hamish Rodda <rodda@kde.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License version 2 as published by the Free Software Foundation.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#ifndef PARSESESSION_H
+#define PARSESESSION_H
+
+#include <cstdlib>
+
+#include <QtCore/QString>
+#include <QtCore/QByteArray>
+#include <QtCore/QVector>
+#include <QtCore/QPair>
+
+#include "cppparser_export.h"
+#include "indexedstring.h"
+#include "rpp/anchor.h"
+
+namespace Cpp {
+  class EnvironmentFile;
+}
+
+class pool;
+class TokenStream;
+class Token;
+
+typedef QVector<unsigned int> PreprocessedContents;
+
+namespace rpp { class MacroBlock; class LocationTable; }
+
+/// Contains everything needed to keep an AST useful once the rest of the parser
+/// has gone away.
+class CPPPARSER_EXPORT ParseSession
+{
+public:
+  ParseSession();
+  ~ParseSession();
+
+  /**
+   * Return the position of the preprocessed source \a offset in the original source
+   * If the "collapsed" member of the returned anchor is true, the position is within a collapsed range.
+   @param collapseIfMacroExpansion @see LocationTable::positionForOffset
+   * \note the return line starts from 0, not 1.
+   */
+  rpp::Anchor positionAt(std::size_t offset, bool collapseIfMacroExpansion = false) const;
+  
+  QPair<rpp::Anchor, uint> positionAndSpaceAt(std::size_t offset, bool collapseIfMacroExpansion = false) const;
+
+  ///The contents must already be tokenized. Either by the preprocessor, or by tokenizeFromByteArray(..)
+  void setContents(const PreprocessedContents& contents, rpp::LocationTable* locationTable);
+
+  /// Unweildy name, but we want to be clear here, if there is already a location table, this would be the wrong setup function to call
+  void setContentsAndGenerateLocationTable(const PreprocessedContents& contents);
+
+  void setUrl(const IndexedString& url);
+  const IndexedString& url() const;
+
+  uint *contents();
+  const uint *contents() const;
+  const PreprocessedContents& contentsVector() const;
+  std::size_t size() const;
+  pool* mempool;
+  TokenStream* token_stream;
+
+  rpp::MacroBlock* macros;
+  IndexedString m_url; //Should contain the url from which the content was extracted, can also be empty.
+
+private:
+  PreprocessedContents m_contents;
+  rpp::LocationTable* m_locationTable;
+};
+
+#endif

data/ext/generator/parser/problem.h

@@ -0,0 +1,21 @@
+#ifndef PROBLEM_H
+#define PROBLEM_H
+
+#include "cppparser_export.h"
+#include "simplecursor.h"
+
+struct CPPPARSER_EXPORT Problem {
+    enum Source {
+        Source_Preprocessor,
+        Source_Lexer,
+        Source_Parser
+    };
+    
+    Source source;
+    QString description;
+    QString explanation;
+    QString file;
+    SimpleCursor position;
+};
+
+#endif

data/ext/generator/parser/rpp/CMakeLists.txt

@@ -0,0 +1,45 @@
+
+add_subdirectory( tests )
+
+########### next target ###############
+
+set(kdevcpprpp_LIB_SRCS
+    pp-stream.cpp
+    pp-macro-expander.cpp
+    pp-scanner.cpp
+    pp-macro.cpp
+    pp-engine.cpp
+    pp-internal.cpp
+    pp-environment.cpp
+    pp-location.cpp
+    preprocessor.cpp
+    chartools.cpp
+    macrorepository.cpp
+)
+
+# Note: This library doesn't follow API/ABI/BC rules and shouldn't have a SOVERSION
+#       Its only purpose is to support the plugin without needing to add all source files
+#       to the plugin target
+kde4_add_library(kdev4cpprpp SHARED ${kdevcpprpp_LIB_SRCS})
+target_link_libraries(kdev4cpprpp ${KDE4_KDECORE_LIBS} ${KDEVPLATFORM_LANGUAGE_LIBRARY} ${KDE4_KTEXTEDITOR_LIBS} )
+
+if (WIN32)
+	# Realign the stack, for compatibility with an older ABI.
+	set_target_properties (kdev4cpprpp PROPERTIES COMPILE_FLAGS -mstackrealign)
+endif (WIN32)
+
+install(TARGETS kdev4cpprpp ${INSTALL_TARGETS_DEFAULT_ARGS} )
+
+########### install files ###############
+
+# install(FILES
+#     pp-engine.h
+#     pp-internal.h
+#     pp-macro-expander.h
+#     pp-macro.h
+#     pp-scanner.h
+#     pp-stream.h
+#     pp-environment.h
+#     preprocessor.h
+#     DESTINATION ${INCLUDE_INSTALL_DIR}/kdevelop/rpp
+# )

data/ext/generator/parser/rpp/Makefile.am

@@ -0,0 +1,13 @@
+INCLUDES = $(all_includes)
+
+METASOURCES = AUTO
+
+noinst_LTLIBRARIES = libkdevcpprpp.la
+
+libkdevcpprppla_SOURCES = preprocessor.cpp
+
+noinst_HEADERS = \
+
+
+
+libkdevcpprpp_la_SOURCES = preprocessor.cpp

data/ext/generator/parser/rpp/anchor.h

@@ -0,0 +1,51 @@
+/*
+  Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
+
+  Permission to use, copy, modify, distribute, and sell this software and its
+  documentation for any purpose is hereby granted without fee, provided that
+  the above copyright notice appear in all copies and that both that
+  copyright notice and this permission notice appear in supporting
+  documentation.
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+  KDEVELOP TEAM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+  AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef ANCHOR_H
+#define ANCHOR_H
+
+#include <QtCore/Qt>
+
+#include "../cppparser_export.h"
+#include "../simplecursor.h"
+
+namespace rpp {
+/**
+ * A SimpleCursor with additional boolean value whether the range opened by this anchor is collapsed.
+ * If that value is true, it means that Everything behind the anchor until the next one is collapsed to the exact position of this anchor.
+ * */
+class CPPPARSER_EXPORT Anchor : public SimpleCursor {
+public:
+  Anchor() : collapsed(false) {
+  }
+  
+  explicit Anchor(const SimpleCursor& cursor, bool _collapsed=false, SimpleCursor _macroExpansion=SimpleCursor::invalid()) : SimpleCursor(cursor), collapsed(_collapsed), macroExpansion(_macroExpansion) {
+  }
+  explicit Anchor(int line, int column, bool _collapsed=false, SimpleCursor _macroExpansion=SimpleCursor::invalid()) : SimpleCursor(line, column), collapsed(_collapsed), macroExpansion(_macroExpansion) {
+  }
+
+  bool collapsed;
+  
+  ///@todo create a sub-class that contains macroExpansion. It is only needed in the location-table and everything using not, not actually in the anchors.
+  SimpleCursor macroExpansion; //Zero if this position was not transformed through a macro-expansion, else a number that identifies the expansion
+};
+}
+
+#endif