[geogram] Update to 1.6.5

Author: simogasp

CMakeLists.txt

@@ -39,7 +39,7 @@ include(cmake/geogram.cmake)
 
 set(VORPALINE_VERSION_MAJOR 1)
 set(VORPALINE_VERSION_MINOR 6)
-set(VORPALINE_VERSION_PATCH 4)
+set(VORPALINE_VERSION_PATCH 5)
 set(VORPALINE_VERSION ${VORPALINE_VERSION_MAJOR}.${VORPALINE_VERSION_MINOR}.${VORPALINE_VERSION_PATCH})
 
 set(VORPALINE_INCLUDE_SUBPATH geogram${VORPALINE_VERSION_MAJOR})

CMakeOptions.txt

@@ -45,6 +45,10 @@ endif()
 add_flags(CMAKE_CXX_FLAGS -frounding-math -ffp-contract=off)
 add_flags(CMAKE_C_FLAGS -frounding-math -ffp-contract=off)
 
+# Activate AVX2 instruction set
+#add_flags(CMAKE_CXX_FLAGS -mavx2)
+#add_flags(CMAKE_C_FLAGS -mavx2)
+
 # Activate c++ 2011
 add_flags(CMAKE_CXX_FLAGS -std=c++11)
 

cmake/platforms/Linux-gcc.cmake

@@ -19,11 +19,11 @@ namespace AST {
 
 // be careful with order of global initialization, AST::Node depends on current_location!
 Location current_location;
-std::ostream*     Node::os = NULL;
+std::ostream*     Node::os = nullptr;
 std::string       Node::context;
 //SymbolEnvironment Node::symbol_env;
 
-Type *return_type = NULL;
+Type *return_type = nullptr;
 
 LiteralExpression *literal_one  = new LiteralExpression( 1 );
 LiteralExpression *literal_zero = new LiteralExpression( 0 );
@@ -50,7 +50,7 @@ struct Clone_postprocessing : public Generic_visitor {
 
 Node*
 clone_prime( Node* n, Clone_context *context ) {
-    if( context == NULL )
+    if( context == nullptr )
         context = new Clone_context;
     // store n ... we need to do postprocessing on it
     n = n->clone( context );
@@ -150,16 +150,16 @@ ConditionalStatement::ConditionalStatement(
 )   : cond(cond), then_branch(then_branch), else_branch(else_branch)
 {
     CompoundStatement *compound = dynamic_cast<CompoundStatement*>( then_branch );
-    if( compound == NULL ) {
+    if( compound == nullptr ) {
         StatementList *slist = new StatementList();
         slist->add( then_branch );
         this->then_branch = new CompoundStatement( slist );
     } else
         this->then_branch = compound;
 
-    if( else_branch != NULL ) {
+    if( else_branch != nullptr ) {
         compound = dynamic_cast<CompoundStatement*>( else_branch );
-        if( compound == NULL )
+        if( compound == nullptr )
         {
             StatementList *slist = new StatementList();
             slist->add( else_branch );
@@ -223,7 +223,7 @@ TranslationUnit::add( FunctionDefinition *fun_def ) {
 // visitor
 
 #define ACCEPT(CLASSNAME) \
-void CLASSNAME ::accept( Visitor *visitor ) { assert( visitor != NULL ); visitor->visit( this ); }
+void CLASSNAME ::accept( Visitor *visitor ) { assert( visitor != nullptr ); visitor->visit( this ); }
 
 //ACCEPT(CastExpression)
 ACCEPT(LiteralExpression)
@@ -337,8 +337,8 @@ ExpressionStatement::clone( Clone_context *context ) {
 
 ConditionalStatement*
 ConditionalStatement::clone( Clone_context *context ) {
-    Statement *new_else_branch = NULL;
-    if( else_branch != NULL )
+    Statement *new_else_branch = nullptr;
+    if( else_branch != nullptr )
         new_else_branch = else_branch->clone( context );
     return update_location( this, new ConditionalStatement( cond->clone( context ), then_branch->clone( context ), new_else_branch ) );
 }
@@ -362,7 +362,7 @@ StatementList::clone( Clone_context *context ) {
 VariableDeclaration*
 VariableDeclaration::clone( Clone_context *context ) {
     MSG("mapping var " << (unsigned int)var<< " to var " << (unsigned int)new_var )
-    Variable *new_var = NULL;
+    Variable *new_var = nullptr;
     if( context->var_map.find( var ) == context->var_map.end() ) {
         new_var = new Variable( var->id, var->type );
         context->var_map [ var ] = new_var;
@@ -382,7 +382,7 @@ CompoundStatement::clone( Clone_context *context ) {
 // only creates _one_ single new fundef
 FunctionDefinition*
 FunctionDefinition::clone( Clone_context *context ) {
-    assert( context != NULL );
+    assert( context != nullptr );
     // NOTE: not yet inserted in symbol_env!
     FunctionType *new_type = new FunctionType( *type );
 

src/bin/fpg/AST.cpp

@@ -85,7 +85,7 @@ AssignmentExpression::dump( int level ) {
 void
 FunctionCall::dump( int level ) {
     dumpPrefix( level );
-    assert( fun_type != NULL );
+    assert( fun_type != nullptr );
     std::cout << "funcall " << fun_type->id << std::endl;
     FOREACH_ARG
        (*it)->dump( level + 3 );
@@ -111,7 +111,7 @@ ConditionalStatement::dump( int level ) {
     dumpPrefix( level + 3);
     std::cout << "else" << std::endl;
     cond->dump( level + 3 );
-    if( else_branch != NULL )
+    if( else_branch != nullptr )
         else_branch->dump( level +3 );
 }
 

src/bin/fpg/ASTdump.cpp

@@ -192,7 +192,7 @@ Type*
 StatementList::computeType() {
     FOREACH_STATEMENT {
         Statement *stmt = *it;
-        assert( stmt != NULL );
+        assert( stmt != nullptr );
         stmt->getType();
     }
     return type_void;
@@ -203,7 +203,7 @@ Type*
 FunctionDefinition::computeType() {
     return_type = type->return_type;
     body->getType();
-    return_type = NULL;
+    return_type = nullptr;
     return type_void;
 }
 

src/bin/fpg/ASTtype.cpp

@@ -15,7 +15,7 @@
 #include <FPG/MSG.h>
 
 Abstract_interpretation_visitor::Abstract_interpretation_visitor( Abstract_value* initial_value )
- : expression_value( NULL ), initial_value( initial_value )
+ : expression_value( nullptr ), initial_value( initial_value )
 {}
 
 void
@@ -52,7 +52,7 @@ void
 Abstract_interpretation_visitor::visit( AST::UnaryExpression* uexp ) {
     MSG( "" )
     analyze( uexp->e );
-    //expression_value = NULL;
+    //expression_value = nullptr;
 }
 
 void
@@ -65,8 +65,8 @@ Abstract_interpretation_visitor::visit( AST::BinaryExpression* bexp) {
         expression_value = new_abstract_value();
         return;
     }
-    assert( value1 != NULL );
-    assert( value2 != NULL );
+    assert( value1 != nullptr );
+    assert( value2 != nullptr );
     switch( bexp->kind ) {
     case AST::BinaryExpression::ADD:
         expression_value = value1->add( value2, bexp );
@@ -119,7 +119,7 @@ void
 Abstract_interpretation_visitor::visit( AST::AssignmentExpression* aexp ) {
     // expression_value is passed upwards unchanged
     AST::IdentifierExpression *id_expr = dynamic_cast< AST::IdentifierExpression* >( aexp->e1 );
-    if( id_expr != NULL ) {
+    if( id_expr != nullptr ) {
         Variable *var = id_expr->var;
         Abstract_value *val = analyze( aexp->e2 );
         if( is_float(var->type) ) {
@@ -160,7 +160,7 @@ Abstract_interpretation_visitor::visit( AST::FunctionCall* funcall ) {
     // for non-external functions:
     if( !funcall->fun_type->is_extern ) {
         AST::FunctionDefinition *fun_def = funcall->called_function;
-        assert( fun_def != NULL );
+        assert( fun_def != nullptr );
         // now it's safe to create the new environment:
         value_env_stack.push( Value_environment() );
         std::vector< Abstract_value * >::iterator abs_arg_iter = abstract_arguments.begin();
@@ -176,7 +176,7 @@ Abstract_interpretation_visitor::visit( AST::FunctionCall* funcall ) {
                 ++abs_arg_iter;
             }
         }
-        return_values.push( NULL );
+        return_values.push( nullptr );
         analyze( fun_def->body );
 #if 0
         // NOTE: this is an ugly hack! in particular, if there was an assignment to one of the
@@ -201,7 +201,7 @@ Abstract_interpretation_visitor::visit( AST::FunctionCall* funcall ) {
         expression_value = return_values.top();
         return_values.pop();
         if( funcall->fun_type->getReturnType() != type_void ) {
-            assert( expression_value != NULL );
+            assert( expression_value != nullptr );
             MSG( "return value=" << expression_value )
         }
     } else
@@ -227,13 +227,13 @@ Abstract_interpretation_visitor::visit( AST::UnaryFunction* uf ) {
 void
 Abstract_interpretation_visitor::visit( AST::EmptyStatement* ) {
     // an emptystatement does not depend on anything
-    assert( expression_value == NULL );
+    assert( expression_value == nullptr );
 }
 
 void
 Abstract_interpretation_visitor::visit( AST::ExpressionStatement* expr_stmt ) {
     analyze( expr_stmt->e );
-    expression_value = NULL;
+    expression_value = nullptr;
 }
 
 void
@@ -275,7 +275,7 @@ Abstract_interpretation_visitor::visit( AST::Return* ret) {
     if( ret->e ) {
         analyze(ret->e);
         assert( return_values.size() > 0 );
-        if( return_values.top() == NULL ) {
+        if( return_values.top() == nullptr ) {
             MSG( "setting retval=" << expression_value )
             return_values.top() = expression_value;
         } else  if( is_float( ret->e->getType() ) && return_values.top() != expression_value ) {
@@ -284,7 +284,7 @@ Abstract_interpretation_visitor::visit( AST::Return* ret) {
             MSG( "result: " << return_values.top() )
         }
     }
-    expression_value = NULL;
+    expression_value = nullptr;
 }
 
 void
@@ -293,7 +293,7 @@ Abstract_interpretation_visitor::visit( AST::StatementList* slist ) {
         AST::Statement *stmt = *it;
         analyze(stmt);
         // statements have no expression value
-        assert( expression_value == NULL );
+        assert( expression_value == nullptr );
     }
 }
 
@@ -306,7 +306,7 @@ void
 Abstract_interpretation_visitor::visit( AST::FunctionDefinition* fundef ) {
     MSG( fundef->type->id )
     value_env_stack.push( Value_environment() );
-    return_values.push( NULL );
+    return_values.push( nullptr );
     FunctionType::ParameterList::iterator it;
     for( it = fundef->type->parameters.begin(); it != fundef->type->parameters.end(); ++it ) {
         Variable *var = *it;
@@ -327,7 +327,7 @@ Abstract_interpretation_visitor::visit( AST::FunctionDefinition* fundef ) {
     // toplevel return values are ignored, they are most probably of integer type anyway.
     return_values.pop();
     assert( return_values.size() == 0 );
-    assert( expression_value == NULL );
+    assert( expression_value == nullptr );
 }
 
 void
@@ -349,7 +349,7 @@ Abstract_interpretation_visitor::get_analysis_result( AST::Expression *e ) {
         }*/
         assert( analysis_result.find(e) != analysis_result.end() );
         Abstract_value *val = analysis_result[ e ];
-        assert( val != NULL );
+        assert( val != nullptr );
         return val;
     } else if( is_int(e->getType()) )
         return new_abstract_value();
@@ -360,8 +360,8 @@ Abstract_interpretation_visitor::get_analysis_result( AST::Expression *e ) {
 
 void
 Abstract_interpretation_visitor::update( AST::Expression *old_e, AST::Expression *new_e ) {
-    assert( old_e != NULL );
-    assert( new_e != NULL );
+    assert( old_e != nullptr );
+    assert( new_e != nullptr );
     if( is_float(old_e->getType()) ) {
         assert( is_float(new_e->getType()) );
         //old_e->dump(0);
@@ -419,18 +419,18 @@ Abstract_interpretation_visitor::is_defined_in_env( Variable* var ) {
 
 Abstract_value*
 Abstract_interpretation_visitor::analyze( AST::Node* n ) {
-    expression_value = NULL;
+    expression_value = nullptr;
     //std::cout << "xxxxxx analyze " << (unsigned int)n << std::endl;
     if( !is_bound( n->getType() ) ) {
         //std::cout << "xxxxxx accept " << (unsigned int)n << std::endl;
         n->accept( this );
-        if( is_float(n->getType()) && expression_value != NULL ) {
+        if( is_float(n->getType()) && expression_value != nullptr ) {
             AST::Expression *e = dynamic_cast<AST::Expression*>(n);
             assert( e );
             //std::cout << "xxxxxx create " << (unsigned int)e << std::endl;
             analysis_result[ e ] = expression_value;
         }
     }
-    return expression_value != NULL ? expression_value
+    return expression_value != nullptr ? expression_value
                                     : new_abstract_value();
 }

src/bin/fpg/Abstract_interpretation_visitor.cpp

@@ -11,7 +11,7 @@ IdentifierDeclarator::declare( Type *base_type, std::string &id ) const {
 Type*
 FunctionDeclarator::declare( Type *base_type, std::string &id ) const {
     // decl should be some form of IdentifierDeclarator. type not needed.
-    decl->declare( NULL, id );
+    decl->declare( nullptr, id );
 
     // prepare function type
     FunctionType *fun = new FunctionType( id, base_type );

src/bin/fpg/Declarator.cpp

@@ -21,7 +21,7 @@ Error_bound_value::get_initial_value( Variable *var ) {
 Error_bound_value*
 Error_bound_value::downcast( Abstract_value* value ) {
     Error_bound_value *bound = dynamic_cast<Error_bound_value*>( value );
-    assert( bound != NULL );
+    assert( bound != nullptr );
     return bound;
 }
 

src/bin/fpg/Error_bound_value.cpp

@@ -34,7 +34,7 @@ struct Clone_context {
 
 struct Node {
     friend class ::Visitor;
-    Node() : location(current_location), type(NULL) {}
+    Node() : location(current_location), type(nullptr) {}
     virtual ~Node() {}
     static std::string       context;
 
@@ -215,7 +215,7 @@ struct AssignmentExpression : public Expression {
 typedef std::list< Expression* > ExpressionList;
 
 struct FunctionCall : public Expression {
-    FunctionCall( FunctionType *fun_type, ExpressionList *exp_list, FunctionDefinition *called_function = NULL )
+    FunctionCall( FunctionType *fun_type, ExpressionList *exp_list, FunctionDefinition *called_function = nullptr )
        : fun_type( fun_type ),
          exp_list( exp_list ),
          called_function( called_function )
@@ -273,7 +273,7 @@ struct ExpressionStatement : public Statement {
     virtual void accept( Visitor *visitor );
     virtual ExpressionStatement* clone( Clone_context *context );
 
-    Expression *e; // can be NULL
+    Expression *e; // can be nullptr
 };
 
 typedef std::list< Statement*> StatementContainer;
@@ -311,7 +311,7 @@ struct CompoundStatement : public Statement {
 struct ConditionalStatement : public Statement {
     ConditionalStatement( Expression *cond,
                           Statement *then_branch,
-                          Statement *else_branch = NULL );
+                          Statement *else_branch = nullptr );
     void dump( int level );
     virtual Type* computeType();
     bool hasBreakOrReturnOnExit();
@@ -342,14 +342,14 @@ struct Declaration : public Statement {
 };
 
 struct VariableDeclaration : public Declaration {
-    VariableDeclaration( Variable *var ) : var( var ), initializer(NULL) {}
+    VariableDeclaration( Variable *var ) : var( var ), initializer(nullptr) {}
     void dump( int level );
     bool hasToplevelVariableDeclaration() { return true; }
     virtual void accept( Visitor *visitor );
     virtual VariableDeclaration* clone( Clone_context *context );
 
     Variable *var;
-    Expression *initializer; // only non-null after beautifying!
+    Expression *initializer; // only non-nullptr after beautifying!
 };
 
 
@@ -419,10 +419,10 @@ extern Node* clone_prime( Node*, Clone_context *context );
 
 template< class ASTElement >
 ASTElement*
-clone( ASTElement *e, Clone_context *context = NULL ) {
+clone( ASTElement *e, Clone_context *context = nullptr ) {
     AST::Node *n = clone_prime( e, context );
     e = dynamic_cast<ASTElement*>(n);
-    assert(e != NULL);
+    assert(e != nullptr);
     return e;
 }