[Debian-med-packaging] Bug#835740: clustalo: FTBFS: util-C.h:54:26: error: 'float log2(float)' conflicts with a previous declaration

Lucas Nussbaum lucas at debian.org
Sun Aug 28 09:11:49 UTC 2016


Source: clustalo
Version: 1.2.2-1
Severity: serious
Tags: stretch sid
User: debian-qa at lists.debian.org
Usertags: qa-ftbfs-20160828 qa-ftbfs
Justification: FTBFS on amd64

Hi,

During a rebuild of all packages in sid, your package failed to build on
amd64.

Relevant part (hopefully):
> /bin/bash ../../libtool  --tag=CXX   --mode=compile g++ -DHAVE_CONFIG_H -I. -I../../src   -Wdate-time -D_FORTIFY_SOURCE=2 -fno-strict-aliasing -DCLUSTALO -DCLUSTALO_NOFILE -DDEFAULT_FILTER=90 -fopenmp  -O3  -g -O2 -fdebug-prefix-map=/<<PKGBUILDDIR>>=. -fPIE -fstack-protector-strong -Wformat -Werror=format-security -c -o hhalign.lo hhalign.cpp
> libtool: compile:  g++ -DHAVE_CONFIG_H -I. -I../../src -Wdate-time -D_FORTIFY_SOURCE=2 -fno-strict-aliasing -DCLUSTALO -DCLUSTALO_NOFILE -DDEFAULT_FILTER=90 -fopenmp -O3 -g -O2 -fdebug-prefix-map=/<<PKGBUILDDIR>>=. -fstack-protector-strong -Wformat -Werror=format-security -c hhalign.cpp  -fPIC -DPIC -o .libs/hhalign.o
> In file included from hhalign.cpp:56:0:
> util-C.h: In function 'float log2(float)':
> util-C.h:54:26: error: 'float log2(float)' conflicts with a previous declaration
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>                           ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1542:3: note: previous declaration 'constexpr float std::log2(float)'
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h: In function 'float log10(float)':
> util-C.h:55:27: error: 'float log10(float)' conflicts with a previous declaration
>  inline float log10(float x) {return (x<=0? (float)(-100000):0.434294481*log(x));}
>                            ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:380:3: note: previous declaration 'constexpr float std::log10(float)'
>    log10(float __x)
>    ^~~~~
> In file included from hhalign.cpp:56:0:
> util-C.h: In function 'char* sprintg(float, int)':
> util-C.h:246:35: error: call of overloaded 'log10(float)' is ambiguous
>    float log10val = log10(fabs(val));
>                                    ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:112:1: note: candidate: double log10(double)
>  __MATHCALL (log10,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:384:3: note: candidate: constexpr long double std::log10(long double)
>    log10(long double __x)
>    ^~~~~
> /usr/include/c++/6/cmath:380:3: note: candidate: constexpr float std::log10(float)
>    log10(float __x)
>    ^~~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:55:14: note: candidate: float log10(float)
>  inline float log10(float x) {return (x<=0? (float)(-100000):0.434294481*log(x));}
>               ^~~~~
> In file included from hhalign.cpp:62:0:
> hhutil-C.h: In function 'void ReadDefaultsFile(int&, char**)':
> hhutil-C.h:516:53: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      argv_conf[argc_conf]=new(char[strlen(c_first)+1]);
>                                                      ^
> hhutil-C.h:521:56: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         argv_conf[argc_conf]=new(char[strlen(c_first)+1]);
>                                                         ^
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h: In function 'void SetSubstitutionMatrix()':
> hhmatrices-C.h:433:35: error: call of overloaded 'log2(float)' is ambiguous
>        S[a][b] = log2(R[a][b]/pb[a]); // S[a][b] = log2(P(a,b)/P(a)/P(b))
>                                    ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h:443:56: error: call of overloaded 'log2(float&)' is ambiguous
>        for (a=0; a<20; ++a) entropy_pb-=pb[a]*log2(pb[a]);
>                                                         ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h:447:37: error: call of overloaded 'log2(float&)' is ambiguous
>         entropy-=P[a][b]*log2(R[a][b]);
>                                      ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h: In function 'void SetRnaSubstitutionMatrix()':
> hhmatrices-C.h:541:35: error: call of overloaded 'log2(float)' is ambiguous
>        S[a][b] = log2(R[a][b]/pb[a]); // S[a][b] = log2(P(a,b)/P(a)/P(b))
>                                    ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h:551:56: error: call of overloaded 'log2(float&)' is ambiguous
>        for (a=0; a<20; ++a) entropy_pb-=pb[a]*log2(pb[a]);
>                                                         ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h:555:37: error: call of overloaded 'log2(float&)' is ambiguous
>         entropy-=P[a][b]*log2(R[a][b]);
>                                      ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h: In function 'void SetDnaSubstitutionMatrix()':
> hhmatrices-C.h:649:35: error: call of overloaded 'log2(float)' is ambiguous
>        S[a][b] = log2(R[a][b]/pb[a]); // S[a][b] = log2(P(a,b)/P(a)/P(b))
>                                    ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h:659:56: error: call of overloaded 'log2(float&)' is ambiguous
>        for (a=0; a<20; ++a) entropy_pb-=pb[a]*log2(pb[a]);
>                                                         ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h:663:37: error: call of overloaded 'log2(float&)' is ambiguous
>         entropy-=P[a][b]*log2(R[a][b]);
>                                      ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h: In function 'void SetSecStrucSubstitutionMatrix()':
> hhmatrices-C.h:742:38: error: call of overloaded 'log2(float&)' is ambiguous
>     S73[A][B][cf] = log2(P73[A][B][cf]);
>                                       ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:63:0:
> hhmatrices-C.h:753:36: error: call of overloaded 'log2(float&)' is ambiguous
>       S33[B][cf][BB][ccf] = log2(sum);
>                                     ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:70:0:
> hhhmm-C.h: In member function 'HMM& HMM::operator=(HMM&)':
> hhhmm-C.h:189:44: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      sname[k]=new(char[strlen(q.sname[k])+1]);
>                                             ^
> hhhmm-C.h:194:40: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      seq[k]=new(char[strlen(q.seq[k])+1]);
>                                         ^
> hhhmm-C.h: In member function 'int HMM::Read(FILE*, char*)':
> hhhmm-C.h:330:48: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>          char *cur_seq = new(char[par.maxColCnt]); //Sequence currently read in
>                                                 ^
> hhhmm-C.h:361:43: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        seq[k-1]=new(char[strlen(cur_seq)+1]);
>                                            ^
> hhhmm-C.h:368:43: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      sname[k] = new (char[strlen(line+1)+1]); //+1 for terminating '\0'
>                                            ^
> hhhmm-C.h:464:40: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>       seq[k]=new(char[strlen(cur_seq)+1]);
>                                         ^
> hhhmm-C.h: In member function 'int HMM::ReadHMMer(FILE*, char*)':
> hhhmm-C.h:736:59: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         seq[nsa_dssp] = new(char[/*MAXRES*/par.maxResLen+2]);
>                                                            ^
> hhhmm-C.h:757:59: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         seq[nss_pred] = new(char[/*MAXRES*/par.maxResLen+2]);
>                                                            ^
> hhhmm-C.h:778:59: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         seq[nss_conf] = new(char[/*MAXRES*/par.maxResLen+2]);
>                                                            ^
> hhhmm-C.h:860:55: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     seq[nss_dssp] = new(char[/*MAXRES*/par.maxResLen+2]);
>                                                        ^
> hhhmm-C.h:1036:46: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        sname[k+1]=new(char[strlen(longname)+1]);
>                                               ^
> hhhmm-C.h:1038:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        seq[k]=new(char[L+2]);
>                            ^
> hhhmm-C.h:1041:29: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        seq[k+1]=new(char[L+2]);
>                              ^
> hhhmm-C.h:1059:44: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        sname[k]=new(char[strlen(longname)+1]);
>                                             ^
> hhhmm-C.h:1063:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        seq[k]=new(char[L+2]);
>                            ^
> hhhmm-C.h: In member function 'int HMM::ReadHMMer3(FILE*, char*)':
> hhhmm-C.h:1238:77: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                           seq[nsa_dssp] = new(char[/*MAXRES*/par.maxResLen+2]);
>                                                                              ^
> hhhmm-C.h:1259:77: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                           seq[nss_pred] = new(char[/*MAXRES*/par.maxResLen+2]);
>                                                                              ^
> hhhmm-C.h:1280:77: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                           seq[nss_conf] = new(char[/*MAXRES*/par.maxResLen+2]);
>                                                                              ^
> hhhmm-C.h:1336:74: error: call of overloaded 'log2(float)' is ambiguous
>                       tr[0][a] = log2((float) exp(-1.0*strflta(ptr,99999))); //store transition probabilites as log2 values
>                                                                           ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:70:0:
> hhhmm-C.h:1350:69: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                   seq[nss_dssp] = new(char[/*MAXRES*/par.maxResLen+2]);
>                                                                      ^
> hhhmm-C.h:1474:82: error: call of overloaded 'log2(float)' is ambiguous
>                               tr[i][a] = log2((float) exp(-1.0*strflta(ptr,99999))); //store transition prob's as log2-values
>                                                                                   ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:70:0:
> hhhmm-C.h:1530:49: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>           sname[k+1]=new(char[strlen(longname)+1]);
>                                                  ^
> hhhmm-C.h:1532:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>           seq[k]=new(char[L+2]);
>                               ^
> hhhmm-C.h:1535:32: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>           seq[k+1]=new(char[L+2]);
>                                 ^
> hhhmm-C.h:1553:47: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>           sname[k]=new(char[strlen(longname)+1]);
>                                                ^
> hhhmm-C.h:1555:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>           seq[k]=new(char[L+2]);
>                               ^
> hhhmm-C.h: In member function 'void HMM::InsertCalibration(char*)':
> hhhmm-C.h:2110:39: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    char** lines = new(char*[3*L+100000]);
>                                        ^
> hhhmm-C.h:2139:44: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        lines[nline]=new(char[strlen(line)+1]);
>                                             ^
> In file included from hhalign.cpp:71:0:
> hhalignment-C.h: In constructor 'Alignment::Alignment(int, int)':
> hhalignment-C.h:85:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    sname = new(char*[maxseq+2]); /* MR1 */
>                               ^
> hhalignment-C.h:86:28: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    seq = new(char*[maxseq+2]); /* MR1 */
>                             ^
> hhalignment-C.h:87:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    l = new(int[maxres]);
>                       ^
> hhalignment-C.h:88:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    X = new(char*[maxseq+2]);  /* MR1 */
>                           ^
> hhalignment-C.h:89:40: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    I = new(short unsigned int*[maxseq+2]); /* MR1 */
>                                         ^
> hhalignment-C.h:90:28: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    keep = new(char[maxseq+2]); /* MR1 */
>                             ^
> hhalignment-C.h:91:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    display = new(char[maxseq+2]); /* MR1 */
>                                ^
> hhalignment-C.h:92:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    wg = new(float[maxseq+2]); /* MR1 */
>                            ^
> hhalignment-C.h:93:28: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    nseqs = new(int[maxres+2]); /* MR1 */
>                             ^
> hhalignment-C.h: In member function 'void Alignment::Read(FILE*, char*, char*)':
> hhalignment-C.h:146:40: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    char *cur_seq=new(char[par.maxColCnt]);
>                                         ^
> hhalignment-C.h:188:61: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                            seq[k]=new(char[strlen(cur_seq)+2]);
>                                                              ^
> hhalignment-C.h:190:59: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                            X[k]=new(char[strlen(cur_seq)+2]);
>                                                            ^
> hhalignment-C.h:192:73: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                            I[k]=new(short unsigned int[strlen(cur_seq)+2]);
>                                                                          ^
> In file included from hhalign.cpp:71:0:
> hhalignment-C.h:241:58: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                    sname[k] = new(char[strlen(cur_name)+1]);
>                                                           ^
> hhalignment-C.h:356:45: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>            seq[k]=new(char[strlen(cur_seq)+2]);
>                                              ^
> hhalignment-C.h:358:43: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>            X[k]=new(char[strlen(cur_seq)+2]);
>                                            ^
> hhalignment-C.h:360:57: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>            I[k]=new(short unsigned int[strlen(cur_seq)+2]);
>                                                          ^
> hhalignment-C.h: In member function 'void Alignment::Compress(const char*)':
> hhalignment-C.h:428:43: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      h = new(/*short*/ unsigned int[N_in+2]); /* short -> overflow, FS, r235 -> r236 */
>                                            ^
> hhalignment-C.h:560:52: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              percent_gaps = new(float[par.maxColCnt]);
>                                                     ^
> hhalignment-C.h:566:47: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              if (nres==NULL) nres=new(int[N_in]);
>                                                ^
> hhalignment-C.h:804:50: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              match_state = new(char[par.maxColCnt]);
>                                                   ^
> hhalignment-C.h: In member function 'int Alignment::FilterForDisplay(int, int, int, float, int)':
> hhalignment-C.h:966:35: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      char *dummy = new(char[N_in+1]);
>                                    ^
> hhalignment-C.h: In member function 'int Alignment::Filter2(char*, int, int, float, int, int, int)':
> hhalignment-C.h:1029:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      char* in=new(char[N_in+1]); // in[k]=1: seq k has been accepted; in[k]=0: seq k has not yet been accepted at current seqid
>                               ^
> hhalignment-C.h:1030:32: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      char* inkk=new(char[N_in+1]); // inkk[k]=1 iff in[ksort[k]]=1 else 0;
>                                 ^
> hhalignment-C.h:1031:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      int* Nmax=new(int[L+2]); // position-dependent maximum-sequence-identity threshold for filtering /* MR1, used to be called idmax*/
>                            ^
> hhalignment-C.h:1032:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      int* idmaxwin=new(int[L+2]); // minimum value of idmax[i-WFIL,i+WFIL]
>                                ^
> hhalignment-C.h:1033:36: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      int* seqid_prev=new(int[N_in+1]); // maximum-sequence-identity threshold used in previous round of filtering (with lower seqid)
>                                     ^
> hhalignment-C.h:1034:24: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      int* N=new(int[L+2]); // N[i] number of already accepted sequences at position i
>                         ^
> hhalignment-C.h:1062:32: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              first=new(int[N_in]);// first non-gap position in sequence k
>                                 ^
> hhalignment-C.h:1063:32: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              last =new(int[N_in]);// last  non-gap position in sequence k
>                                 ^
> hhalignment-C.h:1078:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              nres=new(int[N_in]);
>                                ^
> hhalignment-C.h:1092:32: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              ksort=new(int[N_in]); // never reuse alignment object for new alignment with more sequences
>                                 ^
> hhalignment-C.h: In member function 'int Alignment::HomologyFilter(int, float, float)':
> hhalignment-C.h:1358:33: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      char* coreseq=new(char[N_in]); // coreseq[k]=1 if sequence belongs to core of alignment (i.e. it is very similar to query)
>                                  ^
> hhalignment-C.h: In member function 'int Alignment::FilterWithCoreHMM(char*, float, HMM&)':
> hhalignment-C.h:1409:36: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      float** logodds=new(float*[L+1]); // log-odds ratios for HMM qcore
>                                     ^
> hhalignment-C.h:1418:32: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              first=new(int[N_in]);// first non-gap position in sequence k
>                                 ^
> hhalignment-C.h:1419:32: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              last =new(int[N_in]);// last non-gap position in sequence k
>                                 ^
> hhalignment-C.h:1432:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              nres=new(int[N_in]);
>                                ^
> hhalignment-C.h: In member function 'void Alignment::FrequenciesAndTransitions(HMM&, char*)':
> hhalignment-C.h:1715:49: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                      q.seq[q.ncons]=new(char[L+2]);
>                                                  ^
> hhalignment-C.h:1722:64: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                      q.sname[q.nfirst]=new(char[strlen(name)+11]);
>                                                                 ^
> hhalignment-C.h:1726:50: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                      q.seq[q.nfirst]=new(char[L+2]);
>                                                   ^
> hhalignment-C.h:1784:61: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                      q.sname[nn]=new(char[strlen(sname[k])+1]);
>                                                              ^
> hhalignment-C.h:1787:57: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>                      q.seq[nn]=new(char[strlen(seq[k])+1]);
>                                                          ^
> hhalignment-C.h: In member function 'void Alignment::Amino_acid_frequencies_and_transitions_from_M_state(HMM&, char*)':
> hhalignment-C.h:1874:41: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    float *Neff = new(float[par.maxResLen]); // diversity of subalignment i
>                                          ^
> hhalignment-C.h:1881:25: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    wi = new(float[N_in+2]);
>                          ^
> hhalignment-C.h:1891:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    n = new(int*[L+2]);
>                     ^
> hhalignment-C.h:2050:41: error: call of overloaded 'log2(float)' is ambiguous
>        q.tr[i][M2M]=log2(q.tr[i][M2M]/sum);
>                                          ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:71:0:
> hhalignment-C.h:2051:41: error: call of overloaded 'log2(float)' is ambiguous
>        q.tr[i][M2I]=log2(q.tr[i][M2I]/sum);
>                                          ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:71:0:
> hhalignment-C.h:2052:41: error: call of overloaded 'log2(float)' is ambiguous
>        q.tr[i][M2D]=log2(q.tr[i][M2D]/sum);
>                                          ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:71:0:
> hhalignment-C.h: In member function 'void Alignment::Transitions_from_I_state(HMM&, char*)':
> hhalignment-C.h:2166:43: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      float *Neff = new(float[par.maxResLen]); // diversity of subalignment i
>                                            ^
> hhalignment-C.h:2174:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      wi = new(float[N_in+2]);
>                            ^
> hhalignment-C.h:2185:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      n = new(int*[L+2]);
>                       ^
> hhalignment-C.h:2312:47: error: call of overloaded 'log2(float)' is ambiguous
>              q.tr[i][I2M]=log2(q.tr[i][I2M]/sum);
>                                                ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:71:0:
> hhalignment-C.h:2313:47: error: call of overloaded 'log2(float)' is ambiguous
>              q.tr[i][I2I]=log2(q.tr[i][I2I]/sum);
>                                                ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:71:0:
> hhalignment-C.h: In member function 'void Alignment::Transitions_from_D_state(HMM&, char*)':
> hhalignment-C.h:2368:43: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      float *Neff = new(float[par.maxResLen]); // diversity of subalignment i
>                                            ^
> hhalignment-C.h:2377:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      wi = new(float[N_in+2]); /* FIXME: FS */
>                            ^
> hhalignment-C.h:2388:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      n = new(int*[L+2]);
>                       ^
> hhalignment-C.h:2571:43: error: call of overloaded 'log2(float)' is ambiguous
>          q.tr[i][D2M]=log2(q.tr[i][D2M]/sum);
>                                            ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:71:0:
> hhalignment-C.h:2572:43: error: call of overloaded 'log2(float)' is ambiguous
>          q.tr[i][D2D]=log2(q.tr[i][D2D]/sum);
>                                            ^
> In file included from /usr/include/features.h:364:0,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/os_defines.h:39,
>                  from /usr/include/x86_64-linux-gnu/c++/6/bits/c++config.h:495,
>                  from /usr/include/c++/6/iostream:38,
>                  from hhalign.cpp:34:
> /usr/include/x86_64-linux-gnu/bits/mathcalls.h:144:1: note: candidate: double log2(double)
>  __MATHCALL (log2,, (_Mdouble_ __x));
>  ^
> In file included from /usr/include/c++/6/math.h:36:0,
>                  from hhalign.cpp:39:
> /usr/include/c++/6/cmath:1546:3: note: candidate: constexpr long double std::log2(long double)
>    log2(long double __x)
>    ^~~~
> /usr/include/c++/6/cmath:1542:3: note: candidate: constexpr float std::log2(float)
>    log2(float __x)
>    ^~~~
> In file included from hhalign.cpp:56:0:
> util-C.h:54:14: note: candidate: float log2(float)
>  inline float log2(float x)  {return (x<=0? (float)(-100000):1.442695041*log(x));}
>               ^~~~
> In file included from hhalign.cpp:71:0:
> hhalignment-C.h: In member function 'void Alignment::MergeMasterSlave(Hit&, char*)':
> hhalignment-C.h:2699:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>   int* imatch=new(int[hit.j2+1]);
>                                ^
> hhalignment-C.h:2831:34: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>   char* new_seq=new(char[2*maxcol]);
>                                   ^
> hhalignment-C.h:2844:23: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>   seq[N_in]=new(char[h]);
>                        ^
> hhalignment-C.h:2847:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>   X[N_in]=new(char[h]);
>                      ^
> hhalignment-C.h:2849:35: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>   I[N_in]=new(short unsigned int[h]);
>                                    ^
> hhalignment-C.h:2851:47: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>   sname[N_in]=new(char[strlen(Tali.sname[k])+1]);
>                                                ^
> hhalignment-C.h: In member function 'void Alignment::AddSequence(char*, int*)':
> hhalignment-C.h:2882:23: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>   X[N_in]=new(char[L+2]);
>                        ^
> hhalignment-C.h: In member function 'void Alignment::GetPositionSpecificWeights(float**)':
> hhalignment-C.h:2932:19: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>   n = new(int*[L+2]);
>                    ^
> hhalignment-C.h: In member function 'void Alignment::Transfer(char**, int)':
> hhalignment-C.h:3049:59: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>          I[k] = new(short unsigned int[iLen+2+GOOD_MEASURE]);
>                                                            ^
> hhalignment-C.h:3050:45: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>          X[k] = new(char[iLen+2+GOOD_MEASURE]);
>                                              ^
> hhalignment-C.h:3051:47: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>          seq[k] = new(char[iLen+2+GOOD_MEASURE]);
>                                                ^
> In file included from hhalign.cpp:72:0:
> hhhit-C.h: In member function 'void Hit::AllocateBacktraceMatrix(int, int)':
> hhhit-C.h:180:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    bMM=new(char*[Nq]);
>                     ^
> hhhit-C.h:181:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    bMI=new(char*[Nq]);
>                     ^
> hhhit-C.h:182:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    bIM=new(char*[Nq]);
>                     ^
> hhhit-C.h:183:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    bDG=new(char*[Nq]);
>                     ^
> hhhit-C.h:184:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    bGD=new(char*[Nq]);
>                     ^
> hhhit-C.h:185:25: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    cell_off=new(char*[Nq]);
>                          ^
> hhhit-C.h:188:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        bMM[i]=new(char[Nt]);
>                           ^
> hhhit-C.h:189:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        bMI[i]=new(char[Nt]);
>                           ^
> hhhit-C.h:190:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        bIM[i]=new(char[Nt]);
>                           ^
> hhhit-C.h:191:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        bGD[i]=new(char[Nt]);
>                           ^
> hhhit-C.h:192:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        bDG[i]=new(char[Nt]);
>                           ^
> hhhit-C.h:193:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        cell_off[i]=new(char[Nt]);
>                                ^
> hhhit-C.h: In member function 'void Hit::AllocateForwardMatrix(int, int)':
> hhhit-C.h:240:23: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    F_MM=new(double*[Nq]);
>                        ^
> hhhit-C.h:241:23: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    F_MI=new(double*[Nq]);
>                        ^
> hhhit-C.h:242:23: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    F_DG=new(double*[Nq]);
>                        ^
> hhhit-C.h:243:23: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    F_IM=new(double*[Nq]);
>                        ^
> hhhit-C.h:244:23: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    F_GD=new(double*[Nq]);
>                        ^
> hhhit-C.h:245:25: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    scale=new(double[Nq+1]); // need Nq+3?
>                          ^
> hhhit-C.h:248:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        F_MM[i] = new(double[Nt]);
>                                ^
> hhhit-C.h:249:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        F_MI[i] = new(double[Nt]);
>                                ^
> hhhit-C.h:250:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        F_DG[i] = new(double[Nt]);
>                                ^
> hhhit-C.h:251:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        F_IM[i] = new(double[Nt]);
>                                ^
> hhhit-C.h:252:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        F_GD[i] = new(double[Nt]);
>                                ^
> hhhit-C.h: In member function 'void Hit::AllocateBackwardMatrix(int, int)':
> hhhit-C.h:297:23: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    B_MM=new(double*[Nq]);
>                        ^
> hhhit-C.h:304:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        B_MM[i] = new(double[Nt]);
>                                ^
> hhhit-C.h: In member function 'void Hit::Viterbi(HMM&, HMM&, float**)':
> hhhit-C.h:377:42: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      float *sMM = new(float[par.maxResLen]);   // sMM[i][j] = score of best alignment up to indices (i,j) ending in (Match,Match)
>                                           ^
> hhhit-C.h:378:42: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      float *sGD = new(float[par.maxResLen]);   // sGD[i][j] = score of best alignment up to indices (i,j) ending in (Gap,Delete)
>                                           ^
> hhhit-C.h:379:42: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      float *sDG = new(float[par.maxResLen]);   // sDG[i][j] = score of best alignment up to indices (i,j) ending in (Delete,Gap)
>                                           ^
> hhhit-C.h:380:42: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      float *sIM = new(float[par.maxResLen]);   // sIM[i][j] = score of best alignment up to indices (i,j) ending in (Ins,Match)
>                                           ^
> hhhit-C.h:381:42: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      float *sMI = new(float[par.maxResLen]);   // sMI[i][j] = score of best alignment up to indices (i,j) ending in (Match,Ins)
>                                           ^
> hhhit-C.h: In member function 'void Hit::Backtrace(HMM&, HMM&)':
> hhhit-C.h:1127:40: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    if (t.Xcons) Xcons = new( char[q.L+2]); // for template consensus sequence aligned to query
>                                         ^
> hhhit-C.h:1128:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    S    = new( float[nsteps+1]);
>                               ^
> hhhit-C.h:1129:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    S_ss = new( float[nsteps+1]);
>                               ^
> hhhit-C.h: In member function 'void Hit::StochasticBacktrace(HMM&, HMM&, char)':
> hhhit-C.h:1229:40: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    double* scale_cum = new(double[q.L+2]);
>                                         ^
> hhhit-C.h:1248:39: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        double* sumF=new(double[q.L+t.L]);
>                                        ^
> hhhit-C.h:1372:40: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    if (t.Xcons) Xcons = new( char[q.L+2]); // for template consensus sequence aligned to query
>                                         ^
> hhhit-C.h:1373:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    S    = new( float[nsteps+1]);
>                               ^
> hhhit-C.h:1374:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    S_ss = new( float[nsteps+1]);
>                               ^
> hhhit-C.h: In member function 'void Hit::BacktraceMAC(HMM&, HMM&)':
> hhhit-C.h:1476:40: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    if (t.Xcons) Xcons = new( char[q.L+2]); // for template consensus sequence aligned to query
>                                         ^
> hhhit-C.h:1477:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    S    = new( float[nsteps+1]);
>                               ^
> hhhit-C.h:1478:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    S_ss = new( float[nsteps+1]);
>                               ^
> hhhit-C.h:1479:37: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    P_posterior = new( float[nsteps+1]);
>                                      ^
> hhhit-C.h: In member function 'void Hit::InitializeBacktrace(HMM&, HMM&)':
> hhhit-C.h:1684:54: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              longname=new(char[strlen(t.longname)+1])();
>                                                       ^
> hhhit-C.h:1685:50: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              name    =new(char[strlen(t.name)+1])();
>                                                   ^
> hhhit-C.h:1686:50: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              file    =new(char[strlen(t.file)+1])();
>                                                   ^
> hhhit-C.h:1697:43: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              sname=new(char*[t.n_display])();   // Call Compare only once with irep=1
>                                            ^
> hhhit-C.h:1698:43: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>              seq  =new(char*[t.n_display])();   // Call Compare only once with irep=1
>                                            ^
> hhhit-C.h:1731:34: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      this->i = new( int[i2+j2+2])();
>                                   ^
> hhhit-C.h:1732:34: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      this->j = new( int[i2+j2+2])();
>                                   ^
> hhhit-C.h:1733:35: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>      states  = new( char[i2+j2+2])();
>                                    ^
> In file included from hhalign.cpp:73:0:
> hhhalfalignment-C.h: In constructor 'HalfAlignment::HalfAlignment(int)':
> hhhalfalignment-C.h:67:25: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    h = new(int[maxseqdis]);   //h[k] = next position of sequence k to be written
>                          ^
> hhhalfalignment-C.h:68:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    s = new(char*[maxseqdis]);  //s[k][h] = character in column h, sequence k of output alignment
>                            ^
> hhhalfalignment-C.h:69:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    l = new(int*[maxseqdis]);   //counts non-gap residues: l[k][i] = index of last residue AT OR BEFORE match state i in seq k
>                           ^
> hhhalfalignment-C.h:70:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    m = new(int*[maxseqdis]);   //counts positions:        m[k][i] = position of match state i in string seq[k]
>                           ^
> In file included from hhalign.cpp:74:0:
> hhfullalignment-C.h: In member function 'void FullAlignment::PrintHHR(FILE*, Hit&)':
> hhfullalignment-C.h:360:39: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    lq = new(short unsigned int[qa->n+2]);
>                                        ^
> hhfullalignment-C.h:361:39: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    lt = new(short unsigned int[ta->n+2]);
>                                        ^
> In file included from hhalign.cpp:75:0:
> hhhitlist-C.h: In member function 'void HitList::TransitiveScoring()':
> hhhitlist-C.h:1286:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Z = new(float*[N]);
>                     ^
> hhhitlist-C.h:1289:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        Z[k] = new(float[N]);
>                           ^
> hhhitlist-C.h:1294:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    C = new(float*[N]);
>                     ^
> hhhitlist-C.h:1297:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        C[k] = new(float[N]);
>                           ^
> hhhitlist-C.h:1304:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Zq = new(float[N]);
>                     ^
> hhhitlist-C.h:1305:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Ztq = new(float[N]);
>                      ^
> hhhitlist-C.h:1306:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Zrq = new(float[N]);
>                      ^
> hhhitlist-C.h:1307:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    fold = new(char*[N]);
>                       ^
> hhhitlist-C.h:1308:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    fam = new(char*[N]);
>                      ^
> hhhitlist-C.h:1309:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Prob = new(float[N]);
>                       ^
> hhhitlist-C.h:1310:18: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    ll = new(int[N]);
>                   ^
> hhhitlist-C.h:1311:19: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    w = new(float[N]);
>                    ^
> hhhitlist-C.h:1374:37: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        double** Csub = new(double*[M]);
>                                      ^
> hhhitlist-C.h:1375:37: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        double** Cinv = new(double*[M]);
>                                      ^
> hhhitlist-C.h:1378:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     Csub[m] = new(double[M]);
>                            ^
> hhhitlist-C.h:1379:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     Cinv[m] = new(double[M]);
>                            ^
> hhhitlist-C.h:1454:34: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     double** Csub = new(double*[M]);
>                                   ^
> hhhitlist-C.h:1457:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         Csub[m] = new(double[M]);
>                                ^
> hhhitlist-C.h:1471:38: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         double** Cinv = new(double*[M]);
>                                       ^
> hhhitlist-C.h:1472:51: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         for (m=0; m<M; m++) Cinv[m] = new(double[M]);
>                                                    ^
> hhhitlist-C.h: In member function 'void HitList::TransitiveScoring2()':
> hhhitlist-C.h:1651:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Z = new(float*[N]);
>                     ^
> hhhitlist-C.h:1654:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        Z[k] = new(float[N]);
>                           ^
> hhhitlist-C.h:1659:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    C = new(float*[N]);
>                     ^
> hhhitlist-C.h:1662:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        C[k] = new(float[N]);
>                           ^
> hhhitlist-C.h:1669:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Zq = new(float[N]);
>                     ^
> hhhitlist-C.h:1670:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Ztq = new(float[N]);
>                      ^
> hhhitlist-C.h:1671:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Zrq = new(float[N]);
>                      ^
> hhhitlist-C.h:1672:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    fold = new(char*[N]);
>                       ^
> hhhitlist-C.h:1673:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    fam = new(char*[N]);
>                      ^
> hhhitlist-C.h:1674:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Prob = new(float[N]);
>                       ^
> hhhitlist-C.h:1675:18: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    ll = new(int[N]);
>                   ^
> hhhitlist-C.h:1676:19: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    w = new(float[N]);
>                    ^
> hhhitlist-C.h:1740:37: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        double** Csub = new(double*[M]);
>                                      ^
> hhhitlist-C.h:1741:37: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        double** Cinv = new(double*[M]);
>                                      ^
> hhhitlist-C.h:1744:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     Csub[m] = new(double[M]);
>                            ^
> hhhitlist-C.h:1745:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     Cinv[m] = new(double[M]);
>                            ^
> hhhitlist-C.h:1822:34: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     double** Csub = new(double*[M]);
>                                   ^
> hhhitlist-C.h:1825:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         Csub[m] = new(double[M]);
>                                ^
> hhhitlist-C.h:1839:38: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         double** Cinv = new(double*[M]);
>                                       ^
> hhhitlist-C.h:1840:51: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         for (m=0; m<M; m++) Cinv[m] = new(double[M]);
>                                                    ^
> hhhitlist-C.h: In member function 'void HitList::TransitiveScoring3()':
> hhhitlist-C.h:2021:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Z = new(float*[N]);
>                     ^
> hhhitlist-C.h:2024:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        Z[k] = new(float[N]);
>                           ^
> hhhitlist-C.h:2029:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    C = new(float*[N]);
>                     ^
> hhhitlist-C.h:2032:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        C[k] = new(float[N]);
>                           ^
> hhhitlist-C.h:2039:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Zq = new(float[N]);
>                     ^
> hhhitlist-C.h:2040:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Ztq = new(float[N]);
>                      ^
> hhhitlist-C.h:2041:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Zrq = new(float[N]);
>                      ^
> hhhitlist-C.h:2042:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    fold = new(char*[N]);
>                       ^
> hhhitlist-C.h:2043:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    fam = new(char*[N]);
>                      ^
> hhhitlist-C.h:2044:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Prob = new(float[N]);
>                       ^
> hhhitlist-C.h:2045:18: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    ll = new(int[N]);
>                   ^
> hhhitlist-C.h:2046:19: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    w = new(float[N]);
>                    ^
> hhhitlist-C.h:2115:34: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     double** Csub = new(double*[M]);
>                                   ^
> hhhitlist-C.h:2116:34: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     double** Cinv = new(double*[M]);
>                                   ^
> hhhitlist-C.h:2119:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         Csub[m] = new(double[M]);
>                                ^
> hhhitlist-C.h:2120:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         Cinv[m] = new(double[M]);
>                                ^
> hhhitlist-C.h:2187:34: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     double** Csub = new(double*[M]);
>                                   ^
> hhhitlist-C.h:2190:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         Csub[m] = new(double[M]);
>                                ^
> hhhitlist-C.h:2204:38: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         double** Cinv = new(double*[M]);
>                                       ^
> hhhitlist-C.h:2205:51: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         for (m=0; m<M; m++) Cinv[m] = new(double[M]);
>                                                    ^
> hhhitlist-C.h: In member function 'void HitList::TransitiveScoring4()':
> hhhitlist-C.h:2386:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Z = new(float*[N]);
>                     ^
> hhhitlist-C.h:2389:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        Z[k] = new(float[N]);
>                           ^
> hhhitlist-C.h:2394:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    C = new(float*[N]);
>                     ^
> hhhitlist-C.h:2397:26: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        C[k] = new(float[N]);
>                           ^
> hhhitlist-C.h:2404:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Zq = new(float[N]);
>                     ^
> hhhitlist-C.h:2405:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Ztq = new(float[N]);
>                      ^
> hhhitlist-C.h:2406:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Zrq = new(float[N]);
>                      ^
> hhhitlist-C.h:2407:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    fold = new(char*[N]);
>                       ^
> hhhitlist-C.h:2408:21: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    fam = new(char*[N]);
>                      ^
> hhhitlist-C.h:2409:22: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    Prob = new(float[N]);
>                       ^
> hhhitlist-C.h:2410:18: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    ll = new(int[N]);
>                   ^
> hhhitlist-C.h:2411:19: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    w = new(float[N]);
>                    ^
> hhhitlist-C.h:2473:37: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>        double** Csub = new(double*[M]);
>                                      ^
> hhhitlist-C.h:2476:27: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     Csub[m] = new(double[M]);
>                            ^
> hhhitlist-C.h:2539:34: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>     double** Csub = new(double*[M]);
>                                   ^
> hhhitlist-C.h:2542:31: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>         Csub[m] = new(double[M]);
>                                ^
> hhhitlist-C.h: In member function 'void HitList::InvertMatrix(double**, double**, int)':
> hhhitlist-C.h:2841:30: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    double** V = new(double*[N]);
>                               ^
> hhhitlist-C.h:2842:29: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    double* s  = new(double[N]);
>                              ^
> hhhitlist-C.h:2843:43: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    for (k=0; k<N; k++) V[k] = new(double[N]);
>                                            ^
> hhhitlist-C.h: In member function 'void HitList::SVD(double**, int, double*, double**)':
> hhhitlist-C.h:2926:20: warning: non-constant array new length must be specified without parentheses around the type-id [-Wvla]
>    rv1=new(double[n]);
>                     ^
> Makefile:448: recipe for target 'hhalign.lo' failed
> make[4]: *** [hhalign.lo] Error 1

The full build log is available from:
   http://people.debian.org/~lucas/logs/2016/08/28/clustalo_1.2.2-1_unstable.log

A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!

About the archive rebuild: The rebuild was done on EC2 VM instances from
Amazon Web Services, using a clean, minimal and up-to-date chroot. Every
failed build was retried once to eliminate random failures.



More information about the Debian-med-packaging mailing list