libm.so.6 __gmon_start__ _Jv_RegisterClasses sqrt exp log libc.so.6 _IO_stdin_used putchar_unlocked strcpy vasprintf exit readdir strsignal strncmp strrchr fflush_unlocked perror __isoc99_sscanf fileno_unlocked fputc_unlocked closedir ftell strncpy __stack_chk_fail unlink putchar fgets_unlocked realloc abort stdin memchr strpbrk getpid strspn strdup getc_unlocked sbrk strtol mmap calloc strlen ungetc fread_unlocked memset localeconv strstr strcspn __errno_location fseek memcmp getpagesize asctime __fprintf_chk stdout fputc getrusage fputs lseek memcpy freopen64 fclose strtoul malloc strcat strcasecmp realpath raise opendir getenv __ctype_b_loc stderr system munmap _obstack_newchunk __memset_chk setrlimit strncasecmp strncat _obstack_memory_used getcwd fwrite fread gettimeofday iconv_close atoi localtime ferror_unlocked strchr obstack_free iconv fdopen qsort iconv_open times bsearch __fsetlocking getrlimit memmove fopen64 _obstack_begin access setbuf fwrite_unlocked strcmp strerror __libc_start_main ferror vfprintf snprintf sysconf fputs_unlocked __environ __xstat __fxstat __xstat64 GLIBC_2.0 GLIBC_2.4 GLIBC_2.3 GLIBC_2.7 GLIBC_2.3.4 GLIBC_2.1 GLIBC_2.2
GNU C++ ` 8 ; < D 0 u @9 % m . ; [= 8 - { 0= 0 : e O < L 9 ~ -u & 2: . f f , , , Te e f of uh : c $ B /= . . Qf 0F H VH %I I 9? N? @ ? P@ M / ? E 6S IC C C D D 1D y . /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/cp-lang.c } B @ @ @ $ ^ k W 8 9 `| W K : @ @ @; b ` ` e s ` @U @X E T h2 f y h @ ` @ `x ` t ^ | ` i ` @_ } ` @i @ ` _ ~ W @ @ f `t @E U 2 cxx_dwarf_name /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/call.c __ extended initializer lists K P + y T T T T T T E E I h h Z Z Z Z Z Z \ \ x 9 9 x x x x x x \ %s %D(%T, %T, %T)
%s %D(%T, %T) %s %D(%T) %s %T %s %+#D %s %+#D candidates are: conversion from %qT to %qT is ambiguous invalid use of void expression no matching function for call to %<%D(%A)%> call of overloaded %<%D(%A)%> is ambiguous pointer-to-member function %E cannot be called without an object; consider using .* or ->* no match for call to %<(%T) (%A)%> call of %<(%T) (%A)%> is ambiguous %s for ternary % in %<%E ? %E : %E%> %s for % in %<%E%s%> %s for % in %<%E[%E]%> %s for %qs in %<%s %E%> %s for % in %<%E %s %E%> %s for % in %<%s%E%> ISO C++ forbids omitting the middle term of a ?: expression second operand to the conditional operator is of type %, but the third operand is neither a throw-expression nor of type % third operand to the conditional operator is of type %, but the second operand is neither a throw-expression nor of type % operands to ?: have different types %qT and %qT no match enumeral mismatch in conditional expression: %qT vs %qT enumeral and non-enumeral type in conditional expression conditional expression no %<%D(int)%> declared for postfix %qs, trying prefix operator instead ambiguous overload has_const_overload comparison between %q#T and %q#T unary * "+ )+ * )+ )+ * )+ )+ )+ )+ )+ "+ ) )+ )+ * )+ )+ )+ )+ )+ )+ ]* ]* ]* )+ ]* )+ )+ )+ ]* )+ )+ )+ )+ )+ )+ )+ * ]* ]* )+ ]* ]* )+ )+ ]* ]* ]* * >* >* >* >* )+ * ]* ]* ]* ]* ]* ]* )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ "+ )+ )+ )+ * * * * * * )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ * )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ )+ * no corresponding deallocation function for %qD no suitable % for %qT %q+#D is private %q+#D is protected %q+#D is inaccessible within this context passing NULL to non-pointer argument %P of %qD converting to non-pointer type %qT from NULL converting % to pointer type for argument %P of %qD converting % to pointer type too many braces around initializer for %qT invalid conversion from %qT to %qT initializing argument %P of %qD converting to %qT from initializer list would use explicit constructor %qD implicit conversion cannot bind bitfield %qE to %qT cannot bind packed field %qE to %qT cannot bind rvalue %qE to %qT 6 : : : : : : : 5 7 8 : ? !? 1? ? M? ? ; = ? ? ? ? B; cannot pass objects of non-POD type %q#T through %<...%>; call will abort at runtime cannot receive objects of non-POD type %q#T through %<...%>; call will abort at runtime the default argument for parameter %d of %qD has not yet been parsed recursive evaluation of default argument for %q#D default argument argument of function call might be a candidate for a format attribute type generic passing %qT as % argument of %q#D discards qualifiers %qT is not an accessible base of %qT deducing %qT as %qT in call to %q+D (you can disable this with -fno-deduce-init-list) _Jv_LookupInterfaceMethodIdx class$ could not find class$ field in java interface type %qT ~ operator call to non-function %qD no matching function for call to %<%T::%s(%A)%#V%> call of overloaded %<%s(%A)%> is ambiguous abstract virtual %q#D called from constructor abstract virtual %q#D called from destructor cannot call member function %qD without object passing %qT chooses %qT over %qT in call to %qD choosing %qD over %qD for conversion from %qT to %qT because conversion sequence for the argument is better default argument mismatch in overload resolution candidate 1: %q+#F candidate 2: %q+#F ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second: candidate 1: candidate 2: could not convert %qE to %qT invalid initialization of non-const reference of type %qT from a temporary of type %qT invalid initialization of reference of type %qT from expression of type %qT initializer_list ` < ` + |f+ initialize_reference joust source_type build_new_method_call build_special_member_call in_charge_arg_for_name build_over_call call_builtin_trap convert_like_real enforce_access build_op_delete_call build_new_op perform_overload_resolution build_user_type_conversion_1 merge_conversion_sequences add_builtin_candidate add_function_candidate direct_reference_binding build_call_a check_dtor_name label %q+D used but not defined /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/decl.c unused variable %q+D %qD was declared % and later % previous declaration of %q+D declaration of %qF throws different exceptions from previous declaration %q+F noinline function %q+D redeclared as inline previous declaration of %q+D with attribute noinline function %q+D redeclared with attribute noinline previous declaration of %q+D was inline built-in library shadowing %s function %q#D library function %q#D redeclared as non-function %q#D declaration of %q#D conflicts with built-in declaration %q#D FILE new declaration %q#D ambiguates built-in declaration %q#D %q#D redeclared as different kind of symbol previous declaration of %q+#D declaration of template %q#D conflicts with previous declaration %q+#D ambiguates old declaration %q+#D declaration of C function %q#D conflicts with previous declaration %q+#D here conflicting declaration %q#D %q+D has a previous declaration as %q#D declaration of namespace %qD conflicts with previous declaration of namespace %q+D here %q+#D previously defined here %q+#D previously declared here prototype for %q+#D %Jfollows non-prototype definition here previous declaration of %q+#D with %qL linkage conflicts with new declaration with %qL linkage default argument given for parameter %d of %q#D after previous specification in %q+#D redundant redeclaration of %qD in same scope deleted definition of %qD after previous declaration %q+D gnu_inline explicit specialization of %qD after first use %q+D: visibility attribute ignored because it %Jconflicts with previous declaration here redefinition of %q#D %qD conflicts with used function %q#D not declared in class %q+D redeclared inline with % attribute %q+D redeclared inline without % attribute redeclaration of friend %q#D may not have default template arguments thread-local declaration of %q#D follows non-thread-local declaration non-thread-local declaration of %q#D follows thread-local declaration redeclaration of %q#D label %qE referenced outside of any function jump to label %qD jump to case label %H from here exits OpenMP structured block crosses initialization of %q+#D enters scope of non-POD %q+#D enters try block enters catch block enters OpenMP structured block jump to label %q+D from here %J enters catch block skips initialization of %q+#D invalid exit from OpenMP structured block wchar_t label named wchar_t duplicate label %qD %qD is not a type %qD used without template parameters %q#T is not a class no class template named %q#T in %q#T no type named %q#T in %q#T % names %q#T, which is not a class template % names %q#T, which is not a type template parameters do not match template %q+D declared here __java_byte __java_short __java_int __java_long __java_float __java_double __java_char __java_boolean bool unknown type init list __vtbl_ptr_type __cxxabiv1 global type bad_alloc __cxa_pure_virtual builtin_ _chk %Jan anonymous struct cannot have function members %Jan anonymous union cannot have function members member %q+#D with constructor not allowed in anonymous aggregate member %q+#D with destructor not allowed in anonymous aggregate member %q+#D with copy assignment operator not allowed in anonymous aggregate multiple types in one declaration redeclaration of C++ built-in type %qT declaration does not declare anything missing type-name in typedef-declaration ISO C++ prohibits anonymous structs inline virtual %qs can only be specified for functions % can only be specified inside a class % can only be specified for constructors a storage class can only be specified for objects and functions qualifiers can only be specified for objects and functions % was ignored in this declaration attribute ignored in declaration of %q+#T attribute for %q+#T must follow the %qs keyword ignoring attributes applied to class type %qT outside of definition ignoring attributes applied to dependent type %qT without an associated declaration deprecated typedef %qD is initialized (use decltype instead) declaration of %q#D has % and is initialized definition of %q#D is marked % inline function %q+D given attribute noinline %q#D is not a static member of %q#T ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%> template header not allowed in member definition of explicitly specialized class duplicate initialization of %qD declaration of %q#D outside of class is not definition variable %q#D has initializer but incomplete type elements of array %q#D have incomplete type declaration of %q#D has no initializer aggregate %q#D has incomplete type and cannot be defined %qD declared as reference but not initialized initializer cannot initialize %qT from %qT name used in a GNU-style designated initializer for an array name %qD used in a GNU-style designated initializer for an array initializer fails to determine size of %qD array size missing in %qD zero-size array %qD storage size of %qD isn't known storage size of %qD isn't constant sorry: semantics of inline function static data %q+#D are wrong (you'll wind up with multiple copies) %J you can work around this by removing the initializer uninitialized const %qD invalid type %qT as initializer for a vector of type %qT initializer for %qT must be brace-enclosed %qT has no non-static data member named %qD braces around scalar initializer for type %qT extended initializer lists missing braces around initializer for %qT too many initializers for %qT elements of array %q#T have incomplete type variable-sized object %qD may not be initialized variable-sized compound literal %qD has incomplete type scalar object %qD requires one element in initializer in C++98 %qD must be initialized by constructor, not by %<{...}%> opaque vector types cannot be initialized array %qD initialized by parenthesized string literal %qE structure %qD with uninitialized const members structure %qD with uninitialized reference members assignment (not initialization) in declaration %qD cannot be defaulted shadowing previous type declaration of %q#D %qD cannot be thread-local because it has non-POD type %qT jclass Java object %qD not allocated with % %qD is thread-local and so cannot be dynamically initialized %qD cannot be initialized by a non-constant expression when being declared non-static data member %qD has Java class type function %q#D is initialized like a variable used __aeabi_atexit __cxa_atexit atexit __dso_handle __tcf_%d __cxa_guard_acquire __cxa_guard_release __cxa_guard_abort destructor for alien class %qT cannot be a member constructor for alien class %qT cannot be a member %qD declared as a % %s %qD declared as an % %s % and % function specifiers on %qD invalid in %s declaration %q+D declared as a friend %q+D declared with an exception specification definition of %qD is not in namespace enclosing %qT defining explicit specialization %qD in friend declaration invalid use of template-id %qD in declaration of primary template default arguments are not allowed in declaration of friend template specialization %qD % is not allowed in declaration of friend template specialization %qD cannot declare %<::main%> to be a template cannot declare %<::main%> to be inline cannot declare %<::main%> to be static non-local function %q#D uses anonymous type %q+#D does not refer to the unqualified type, so it is not used for linkage non-local function %q#D uses local type %qT static member function %qD cannot have cv-qualifier non-member function %qD cannot have cv-qualifier %<::main%> must return % definition of implicitly-declared %qD no %q#D member function declared in class %qT non-local variable %q#D uses anonymous type non-local variable %q#D uses local type %qT __ptrmemfunc_type invalid in-class initialization of static data member of non-integral type %qT ISO C++ forbids in-class initialization of non-const static member %qD ISO C++ forbids initialization of member constant %qD of non-integral type %qT size of array %qD has non-integral type %qT size of array has non-integral type %qT size of array %qD is negative size of array is negative ISO C++ forbids zero-size array %qD ISO C++ forbids zero-size array size of array %qD is not an integral constant-expression size of array is not an integral constant-expression ISO C++ forbids variable length array %qD ISO C++ forbids variable length array variable length array %qD is used variable length array is used overflow in array dimension array of void array of functions array of references array of function members declaration of %qD as %s creating %s declaration of %qD as multidimensional array must have bounds for all dimensions except the first multidimensional array must have bounds for all dimensions except the first return type specification for constructor invalid return type specification for destructor invalid return type specified for % unnamed variable or field declared void variable or field %qE declared void variable or field declared void invalid use of qualified-name %<::%D%> invalid use of qualified-name %<%T::%D%> invalid use of qualified-name %<%D::%D%> type %qT is not derived from type %qT declaration of %qD as non-function declaration of %qD as non-member declarator-id missing; using reserved word %qD function definition does not declare parameters parameter type name two or more data types in declaration of %qs conflicting specifiers in declaration of %qs ISO C++ forbids declaration of %qs with no type % or % invalid for %qs % and % specified together for %qs % invalid for %qs % invalid for %qs % invalid for %qs % or % invalid for %qs % or % specified with char for %qs % and % specified together for %qs % or % invalid for %qs long, short, signed or unsigned used invalidly for %qs complex invalid for %qs qualifiers are not allowed on declaration of % ignoring %qV qualifiers added to function type %qT member %qD cannot be declared both virtual and static %<%T::%D%> is not a valid declarator typedef declaration invalid in parameter declaration storage class specifiers invalid in parameter declarations parameter declared % % outside class declaration multiple storage classes in declaration of %qs storage class specified for %qs storage class specified for parameter %qs storage class specified for typename nested function %qs declared % top-level declaration of %qs specifies % function-scope %qs implicitly auto and declared %<__thread%> storage class specifiers invalid in friend function declarations type qualifiers ignored on function return type %qs declared as function returning a function %qs declared as function returning an array %qs function uses % type specifier without late return type %qs function with late return type has %qT as its type rather than plain % %qs function with late return type not declared with % type specifier destructor cannot be static member function constructor cannot be static member function destructors may not be cv-qualified constructors may not be cv-qualified constructors cannot be declared virtual can't initialize friend function %qs virtual functions cannot be friends friend declaration not in class definition can't define friend function %qs in a local class definition destructors may not have parameters cannot declare pointer to %q#T cannot declare reference to %q#T cannot declare pointer to %q#T member reference pointer cannot declare %s to qualified function type %qT cannot declare reference to %q#T, which is not a typedef or a template type argument template-id %qD used as a declarator member functions are implicitly friends of their class extra qualification %<%T::%> on member %qs cannot define member function %<%T::%s%> within %<%T%> cannot declare member function %<%T::%s%> within %<%T%> cannot declare member %<%T::%s%> within %qT non-parameter %qs cannot be a parameter pack size of array %qs is too large data member may not have variably modified type %qT parameter may not have variably modified type %qT only declarations of constructors can be % non-member %qs cannot be declared % non-object member %qs cannot be declared % function %qs cannot be declared % static %qs cannot be declared % const %qs cannot be declared % %Jtypedef name may not be a nested-name-specifier ISO C++ forbids nested type %qD with same name as enclosing class type qualified function types cannot be used to declare static member functions qualified function types cannot be used to declare free functions type qualifiers specified for friend class declaration % specified for friend class declaration template parameters cannot be friends friend declaration requires class-key, i.e. % friend declaration requires class-key, i.e. % trying to make class %qT a friend of global scope invalid qualifiers on non-member function type abstract declarator %qT used as declaration cannot use %<::%> in parameter declaration invalid use of %<::%> can't make %qD into a method -- not in a class function %qD declared virtual inside a union %qD cannot be declared virtual, since it is always static expected qualified name in friend declaration for destructor %qD declaration of %qD as member of %qT expected qualified name in friend declaration for constructor %qD field %qD has incomplete type name %qT has incomplete type in instantiation of template %qT %qE is neither function nor member function; cannot be declared friend ISO C++ forbids initialization of member %qD making %qD static field storage class % invalid for function %qs storage class % invalid for function %qs storage class %<__thread%> invalid for function %qs % specified invalid for function %qs declared out of global scope % specifier invalid for function %qs declared out of global scope %q#T is not a class or a namespace virtual non-class function %qs %qs defined in a non-class scope %qs declared in a non-class scope cannot declare member function %qD to have static linkage cannot declare static function inside another function variable % may not be used when defining (as opposed to declaring) a static data member static member %qD declared % cannot explicitly declare member %q#D to have extern linkage %qs initialized and declared % %qs has both % and initializer z z ~ ~ ~ ~ ~ b 8 k k k ~ default argument for %q#D has type %qT default argument for parameter of type %qT has type %qT default argument %qE uses local variable %qD parameter %qD has Java class type parameter %qD invalidly declared method type parameter %qD includes %s to array of unknown bound %qT parameter packs must be at the end of the parameter list invalid constructor; you probably meant %<%T (const %T&)%> %qD may not be declared within a namespace %qD may not be declared as static %qD must be a nonstatic member function %qD must be either a non-static member function or a non-member function %qD must have an argument of class or enumerated type void the same type a base class a reference to conversion to %s%s will never use a type conversion operator ISO C++ prohibits overloading operator ?: %qD must not have variable number of arguments postfix %qD must take % as its argument postfix %qD must take % as its second argument %qD must take either zero or one argument %qD must take either one or two arguments prefix %qD should return %qT postfix %qD should return %qT %qD must take % %qD must take exactly one argument %qD must take exactly two arguments user-defined %qD always evaluates both arguments %qD should return by value %qD cannot have default arguments struct class union enum typename [ 8 ? F M T using template type parameter %qT after %qs using typedef-name %qD after %qs %q+D has a previous declaration here %qT referred to as %qs %q+T has a previous declaration here %qT referred to as enum template argument required for %<%s %T%> %qD has the same name as the class in which it is declared reference to %qD is ambiguous use of enum %q#D without previous declaration redeclaration of %qT as a non-template previous declaration %q+D derived union %qT invalid Java class %qT cannot have multiple bases Java class %qT cannot have virtual bases base type %qT fails to be a struct or class type recursive type %qT undefined duplicate base type %qT invalid multiple definition of %q#T %Jprevious definition here underlying type %<%T%> of %<%T%> must be an integral type packed no integral type can represent all of the enumerator values for %qT enumerator value for %qD is not an integer constant overflow in enumeration values at %qD enumerator value %E is too large for underlying type %<%T%> return type %q#T is incomplete return type has Java class type %q#T % should return a reference to %<*this%> no previous declaration for %q+D invalid function declaration parameter %qD declared void no return statement in function returning non-void invalid member function declaration %qD is already defined in class %qT cleanup static member function %q#D declared with type qualifiers $` P+ x + ` < (` complete_vars maybe_register_incomplete_var finish_method finish_function save_function_data start_function start_preparsed_function lookup_enumerator start_enum xref_basetypes xref_tag tag_name grok_op_properties move_fn_p copy_fn_p grokdeclarator check_var_type check_special_function_return_type build_ptrmem_type grokvardecl grokfndecl check_class_member_definition_namespace expand_static_init register_dtor_fn cp_finish_decl initialize_artificial_var initialize_local_var make_rtl_for_nonlocal_decl check_initializer reshape_init reshape_init_r reshape_init_class reshape_init_vector reshape_init_array check_array_designated_initializer build_init_list_var_init start_decl_1 start_decl cxx_init_decl_processing C++ C Java __ct __base_ctor __comp_ctor __dt __comp_dtor __base_dtor __deleting_dtor __in_chrg nelts this __delta __pfn _vptr __vtt_parm :: std 1 1 1 1 1 1 1 1 + 1 8 1 I 1 S 1 Y 1 ^ 1 f 1 l 1 r 1 } 1 1 make_unbound_class_template make_typename_type define_label check_goto make_label_decl duplicate_decls poplevel /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/pt.c data member %qD cannot be a member template invalid member template declaration %qD explicit specialization in non-namespace scope %qD enclosing class templates are not explicitly specialized specialization of %qD in different namespace from definition of %q+#D explicit instantiation of %qD in namespace %qD (which does not enclose namespace %qD) name of class shadows template template parameter %qD specialization of %qT after instantiation specializing %q#T in different namespace specialization %qT after instantiation %qT explicit specialization of non-template %qT specialization of %qD after instantiation candidates are: %s %+#D %qD is not a function template template-id %qD for %q+D does not match any template declaration ambiguous template specialization %qD for %q+D template-id %qD in declaration of primary template template parameter list used in explicit instantiation definition provided for explicit instantiation too many template parameter lists in declaration of %qD too few template parameter lists in declaration of %qD explicit specialization of %qD must be introduced by %%> function template partial specialization %qD is not allowed default argument specified in explicit specialization %qD is not a template function %qD is not declared in %qD specialization of implicitly-declared special member function no member function %qD declared in %qT ;U U U U U TV #V U %i %s#%i base initializer expansion %<%T%> contains no parameter packs expansion pattern %<%T%> contains no argument packs expansion pattern %<%E%> contains no argument packs parameter packs not expanded with %<...%>: %qD declaration of %q+#D shadows template parm %q+#D template parameters not used in partial specialization: partial specialization %qT does not specialize any template arguments parameter pack argument %qE must be at the end of the template argument list parameter pack argument %qT must be at the end of the template argument list template argument %qE involves template parameter(s) type %qT of template argument %qE depends on template parameter(s) no default argument for %qD parameter pack %qE must be at the end of the template parameter list parameter pack %qT must be at the end of the template parameter list default template arguments may not be used in function template friend re-declaration default template arguments may not be used in function template friend declarations default template arguments may not be used in function templates without -std=c++0x or -std=gnu++0x default template arguments may not be used in partial specializations default argument for template parameter for class enclosing %qD template class without a name destructor %qD declared as member template invalid template declaration of %qD template declaration of %q#D template definition of non-template %q#D expected %d levels of template parms for %q#D, got %d got %d template parameters for %q#D got %d template parameters for %q#T but %d required template arguments to %qD do not match original template %qD use template<> for an explicit specialization %qT is not a template type template specifiers not specified in declaration of %qD redeclared with %d template parameter(s) previous declaration %q+D used %d template parameter(s) template parameter %q+#D redeclared here as %q#D redefinition of default argument for %q#D %Joriginal definition appeared here %qE is not a valid template argument for type %qT because function %qD has not external linkage %qE is not a valid template argument for type %qT it must be a pointer-to-member of the form `&X::Y' %qE is not a valid template argument for type %qT because string literals can never be used in this context %qE is not a valid template argument for type %qT because it is a non-constant expression %qD is not a valid template argument because %qD is a variable, not the address of a variable %qE is not a valid template argument of type %qT because %qE is not a variable %qE is not a valid template argument of type %qT because %qD does not have external linkage %qE is not a valid template argument for type %qT because of conflicts in cv-qualification %qE is not a valid template argument for type %qT because it is not an lvalue %qE is not a valid template argument for type %qT because object %qD has not external linkage it must be the address of a function with external linkage %qE is not a valid template argument for type %qT because it is a pointer try using %qE instead %qE is not a valid template argument for type %qT because it is of type %qT standard conversions are not allowed in this context to refer to a type member of a template parameter, use % type/value mismatch at argument %d in template parameter list for %qD expected a constant of type %qT, got %qT expected a class template, got %qE expected a type, got %qE expected a type, got %qT expected a class template, got %qT expected a template of type %qD, got %qT type mismatch in nontype parameter pack could not convert template argument %qE to %qT wrong number of template arguments (%d, should be %d) or more wrong number of template arguments (%d, should be %d%s) provided for %q+D cannot expand %<%E%> into a fixed-length argument list cannot expand %<%T%> into a fixed-length argument list template argument %d is invalid %qT is not a template non-template type %qT used as a template for template declaration %q+D template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating %qD mismatched argument pack lengths while expanding %<%T%> mismatched argument pack lengths while expanding %<%E%> visibility instantiation of %q+D as type %qT variable %qD has function type invalid parameter type %qT in declaration %q+D function returning an array function returning a function creating pointer to member function of non-class type %qT array bound is not an integer constant creating array with negative size (%qE) forming reference to void pointer reference forming %s to reference type %qT creating pointer to member of non-class type %qT creating pointer to member reference type %qT creating pointer to member of type void creating array of %qT creating array of %qT, which is an abstract class type %qT is not a class, struct, or union type %qT resolves to %qT, which is not an enumeration type %qT resolves to %qT, which is is not a class type use of %qs in template I- I- M5 6 TD 8 - I- Q- I- 6 TD 6 I- I- n; - - TD I- : : TD I- I- TD TD TD I- TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD @ TD TD A TD TD TD TD TD TD TD TD TD TD TD TD @ TD TD TD < < TD TD TD TD TD TD TD TD TD TD TD TD TD TD G= TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD G= TD TD TD @ TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD 6 TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD A TD TD TD TD TD TD TD R/ R/ R/ = nB R/ 6@ TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD TD C C TD TD TD TD B dependent-name %qE is parsed as a non-type, but instantiation yields a type say % if a type is meant using invalid field %qD invalid use of pack expansion expression use %<...%> to expand argument pack \Y IX +W \Y \Y $X $X \Y $X \Y $X \Y $X \Y \Y $X $X $X \Y \Y $X $X \Y \Y \Y \Y \Y \Y \Y L \Y 2L L J J $X \Y \Y \Y \Y \Y \Y \Y Q \Y P \Y \Y S \Y \Y \Y \Y X R \Y \Y \Y T \Y \Y *T \Y Y \Y R R R \Y R R R R R \Y R \Y \Y R \Y \Y P R R \Y R R R R R R R P R R R R \Y P R R R R R R \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y N \Y \Y \Y P \Y \Y \Y P P R R R R X \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y #Y \Y OU \Y V \Y DS R \Y \Y P \Y MM ~M $X $X $X $X $X $X $X \Y \Y \Y V \Y T T N N N N N R P \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y \Y CO P P \Y P \Y \Y IY \Y 6Y \Y \Y $X iteration variable %qD should not be firstprivate iteration variable %qD should not be reduction ul >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y g n 0n 'f >y >y >y m >y n >y >y >y >y >y >y >y de >y >y >y >y >y ;r r Ds Yw Yw w w w w ^x >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y >y f >y >y >y >y >y >y >y >y >y >y >y >y >y f o >y q >y >y k |i j k m m "m bf q >y >y >y >y >y >y q >y +y >y y unary * a cast to a type other than an integral or enumeration type cannot appear in a constant-expression %qT is not a class or namespace %qD is not a class or namespace z ) | i 7 | | | | | | | | | | ? | | ? | | | | | | | ? | | | | ? | | | | | | } ? ? ? ? ~ ~ b g | & z { n B } } } } } | & n V ? ? C~ a~ ~ ~ ~ %qT is/uses anonymous type template argument for %qD uses local type %qT %qT is a variably modified type integral expression %qE is not constant trying to instantiate %qD { w $ 9 / P ! ! ambiguous class template instantiation for %q#T %s %+#T explicit instantiation of non-template %q#D %qD is not a static data member of a class template no matching template for %qD found type %qT for explicit instantiation %qD does not match declared type %qT explicit instantiation of %q#D duplicate explicit instantiation of %q#D ISO C++ 1998 forbids the use of % on explicit instantiations storage class %qD applied to template instantiation explicit instantiation of non-template type %qT explicit instantiation of %q#T before definition of template ISO C++ forbids the use of %qE on explicit instantiations duplicate explicit instantiation of %q#T explicit instantiation of %qD but no definition available template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth-NN to increase the maximum) %q#T is not a valid type for a template constant parameter auto initializer_list deducing from brace-enclosed initializer list requires #include unable to deduce %qT from %qE X` + |f+ L` < H` 8 @` < 8` * , 4` + v, 0` + - ,` + - build_non_dependent_expr resolve_typename_type type_dependent_expression_p value_dependent_expression_p dependent_scope_ref_p dependent_type_p get_mostly_instantiated_function_type instantiate_decl template_for_substitution regenerate_decl_from_template unify unify_pack_expansion template_decl_level get_template_base type_unification_real maybe_adjust_types_for_deduction fn_type_unification instantiate_template tsubst_copy_and_build tsubst_expr tsubst_omp_for_iterator tsubst_omp_clauses tsubst_copy tsubst_qualified_id tsubst tsubst_exception_specification tsubst_function_type tsubst_decl tsubst_pack_expansion instantiate_class_template parameter_of_template_p uses_template_parms lookup_template_class lookup_template_function coerce_template_template_parms coerce_template_template_parm convert_nontype_argument process_partial_specialization process_template_parm comp_template_parms check_explicit_specialization register_specialization is_specialization_of_friend is_specialization_of retrieve_specialization end_explicit_instantiation begin_explicit_instantiation strip_innermost_template_args get_innermost_template_args add_outermost_template_args push_inline_template_parms_recursive finish_member_template_decl push_access_scope type %qT is not a base type for type %qT %s of data-member %qD in read-only structure %s of read-only data-member %qD %s of constant field %qD %s of read-only variable %qD %s of read-only parameter %qD %s of read-only reference %qD %s of read-only named return value %qD %s of function %qD %s of read-only location %qE /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/typeck2.c cannot declare variable %q+D to be of abstract type %qT cannot declare parameter %q+D to be of abstract type %qT cannot declare field %q+D to be of abstract type %qT invalid abstract return type for member function %q+#D invalid abstract return type for function %q+#D invalid abstract type %qT for %qE invalid abstract type for %q+D cannot allocate an object of abstract type %qT %J because the following virtual functions are pure within %qT: %+#D %J since type %qT has pure virtual functions %q+D has incomplete type invalid use of incomplete type %q#T forward declaration of %q+#T declaration of %q+#T invalid use of %qT invalid use of array with unspecified bounds invalid use of member (did you forget the %<&%> ?) invalid use of % invalid use of template type parameter %qT invalid use of template template parameter %qT invalid use of dependent type %qT address of overloaded function with no contextual type information overloaded function with no contextual type information insufficient contextual information to determine type constructor syntax used, but no constructor declared for type %qT return value initializer cannot initialize arrays using this syntax initializer narrowing conversion of %qE from %qT to %qT inside { } char-array initialized from wide string int-array initialized from non-wide string int-array initialized from incompatible wide string initializer-string for array of chars is too long initialization cannot initialize aggregate of type %qT with a compound literal array must be initialized with a brace-enclosed initializer too many initializers for %qT non-trivial designated initializers not supported missing initializer for member %qD uninitialized const member %qD member %qD with uninitialized const fields member %qD is uninitialized reference no field %qD found in union being initialized index value instead of field name in union initializer circular pointer delegation detected base operand of %<->%> has non-pointer type %qT result of %()%> yields non-pointer result base operand of %<->%> is not a pointer %qE cannot be used as a member pointer, since it is of type %qT cannot apply member pointer %qE to %qE, which is of non-class type %qT pointer to member type %qT incompatible with object type %qT invalid value-initialization of reference types functional cast call to function %qD which throws incomplete type %q#T call to function which throws incomplete type %q#T l` d e add_exception_specifier process_init_constructor process_init_constructor_union process_init_constructor_record process_init_constructor_array digest_init_r store_init_value split_nonconstant_init_1 cxx_incomplete_type_diagnostic abstract_virtuals_error complete_type_check_abstract /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/class.c cannot convert from base %qT to derived type %qT via virtual base %qT Java class %qT cannot have a destructor Java class %qT cannot have an implicit non-trivial destructor repeated using declaration %q+D using declaration %q+D conflicts with a previous using declaration %q+#D cannot be overloaded with %q+#D conflicting access specifications for method %q+D, ignored conflicting access specifications for field %qE, ignored %q+D invalid in %q#T because of local method %q+#D with same name because of local member %q+#D with same name base class %q#T has a non-virtual destructor all member functions in class %qT are private %q#T only defines a private destructor and has no friends %q#T only defines private constructors and has no friends no unique final overrider for %qD in %qT %q+D was hidden by %q+D %q+#D invalid; an anonymous union can only have non-static data members %q+#D invalid; an anonymous struct can only have non-static data members private member %q+#D in anonymous union private member %q+#D in anonymous struct protected member %q+#D in anonymous union protected member %q+#D in anonymous struct bit-field %q+#D with non-integral type bit-field %q+D width not an integer constant negative width in bit-field %q+D zero width for bit-field %q+D width of %q+D exceeds its type %q+D is too small to hold all values of %q#T member %q+#D with constructor not allowed in union member %q+#D with destructor not allowed in union member %q+#D with copy assignment operator not allowed in union multiple fields in union %qT initialized %q+D may not be static because it is a member of a union %q+D may not have reference type %qT because it is a member of a union field %q+D invalidly declared function type field %q+D invalidly declared method type ignoring packed attribute because of unpacked non-POD field %q+#D field %q+#D with same name as class %q#T has pointer data members but does not override %<%T(const %T&)%> or % but does not override % offset of empty base %qT may not be ABI-compliant and maychange in a future version of GCC class %qT will be considered nearly empty in a future version of GCC initializer specified for non-virtual method %q+D non-static reference %q+#D in class without a constructor non-static const member %q+#D in class without a constructor offset of virtual base %qT is not ABI-compliant and may change in a future version of GCC direct base %qT inaccessible in %qT due to ambiguity virtual base %qT inaccessible in %qT due to ambiguity size assigned to %qT may not be ABI-compliant and may change in a future version of GCC the offset of %qD may not be ABI-compliant and may change in a future version of GCC offset of %q+D is not ABI-compliant and may change in a future version of GCC %q+D contains empty classes which may cause base classes to be placed at different locations in a future version of GCC layout of classes derived from empty class %qT may change in a future version of GCC redefinition of %q#T %q#T has virtual functions and accessible non-virtual destructor trying to finish struct, but kicked out due to previous parse errors R 7 7 X language string %<"%E"%> not recognized cannot resolve overloaded function %qD based on conversion to type %qT no matches converting function %qD to type %q#T converting overloaded function %qD to type %q#T is ambiguous assuming pointer to member %qD (a pointer to member can only be formed with %<&%E%>) not enough type information argument of type %qT does not match %qT _vptr.%s declaration of %q#D changes meaning of %qD from %q+#D %*s %s (0x%lx) alternative-path %ld empty nearly-empty virtual primary-for %s (0x%lx) lost-primary subvttidx=%s vptridx=%s vbaseoffset=%s vptr=%s Class %s size=%lu align=%lu base size=%lu base align=%lu %s: %s entries %-4ld %s Construction vtable Vtable %s for %s (0x%lx instance) in %s VTT for %s this-thunk covariant-thunk function %.*s%p %s %s fixed=%ld vcall=%ld vbase=%ld(%s) alias to %p has_const_overload ` < x` < build_rtti_vtbl_entries add_vcall_offset_vtbl_entries_1 build_vbase_offset_vtbl_entries build_vtbl_initializer accumulate_vtbl_inits build_ctor_vtbl_group dfs_build_secondary_vptr_vtt_inits build_vtt_inits get_vtbl_decl_for_binfo instantiate_type resolve_address_of_overloaded_function finish_struct_1 include_empty_classes type_requires_array_cookie adjust_clone_args clone_function_decl layout_empty_base check_bitfield_decl update_vtable_entry_for_fn get_vcall_index check_bases handle_using_decl alter_access build_secondary_vtable build_primary_vtable convert_to_base_statically build_simple_base_path build_base_path /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/decl2.c name missing for member function ambiguous conversion for array subscript invalid types %<%T[%T]%> for array subscript deleting array %q#D type %q#T argument given to %, expected pointer cannot delete a function. Only pointer-to-objects are valid arguments to % deleting %qT is undefined template declaration of %q#D Java method %qD has non-Java return type %qT Java method %qD has non-Java parameter type %qT template parameter lists provided don't match the template parameters of %qD prototype for %q#D does not match any in class %qT %+#D candidates are: %+#D candidate is: %+#D no %q#D member function declared in class %qT local class %q#T shall not have static data member %q#D initializer invalid for static member with constructor (an out of class initialization is required) typedef %qD is initialized (use __typeof__ instead) _vptr member %qD conflicts with virtual function table field name %qD is already defined in %qT %qD cannot be defaulted initializer specified for static member function %qD field initializer is not constant % specifiers are not permitted on non-static data members bit-field %qD with non-integral type cannot declare %qD to be a bit-field type cannot declare bit-field %qD with function type %qD is already defined in the class %qT static member %qD cannot be a bit-field weak visibility anonymous struct not inside named type %q+#D invalid; an anonymous union can only have non-static data members private member %q+#D in anonymous union protected member %q+#D in anonymous union namespace-scope anonymous aggregates must be static anonymous union with no members % must return type %qT the first parameter of % cannot have a default argument % takes type % (%qT) as first parameter % must return type %qT % takes type %qT as first parameter dllimport dllexport %qT has a field %qD whose type uses the anonymous namespace %qT declared with greater visibility than the type of its field %qD %qT has a base %qT whose type uses the anonymous namespace %qT declared with greater visibility than its base %qT %c%c%.5u %c __static_initialization_and_destruction %s_%u __initialize_p __priority _ZGA inline function %q+D used but never defined default argument missing for parameter %P of %q+#D deleted function %q+D used here ` + |f+ ` < ` < ` < ` + |f+ ` + |f+ parm_index possibly_inlined_p build_offset_ref_call_from_tree cp_process_pending_declarations build_java_method_aliases prune_vars_needing_no_initialization one_static_initialization_or_destruction fix_temporary_vars_context_r build_cleanup import_export_decl determine_visibility maybe_emit_vtables decl_needed_p import_export_class coerce_delete_type coerce_new_type save_template_attributes grokfield check_member_template grok_array_decl build_memfn_type class ... typename enum template __typeof__ decltype #%qs not supported by %s# 5 5 5 5 5 5 5 F P ? . 0 enum class union struct && %ld initializers destructors /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/error.c (static %s for %s) typedef vtable for operator using C < _ X v 0 static virtual with (deleting destructor) (base destructor) (base constructor) throw ? : new this + / % & * static_cast reinterpret_cast const_cast dynamic_cast sizeof __alignof__ ({...}) while (1) { if ( ) break; " ] | | K | K | ] ] ] ] ] ] ] K , P 4 } K K K f f f K K K K K K K K 6 $ 1 K K K K K K K K P , ] v ] K / / K K 3 K C C++ Java 'this' %d {unknown} NULL At global scope: In %s %qs inlined from %qs at %s:%d:%d inlined from %qs at %s:%d inlined from %qs static member function copy constructor constructor destructor member function function %s: In instantiation of %qs: %s:%d: instantiated from here %s:%d: instantiated from %qs s ) G s %s only available with -std=c++0x or -std=gnu++0x variadic templates cp_cpp_error cp_print_error_function language_to_string dump_expr dump_template_decl dump_decl dump_global_iord dump_type_suffix dump_type_prefix dump_type operator %s operator%s new nw new [] na delete dl delete [] da + ps - ng & ad * de ~ co ! nt ++ pp -- mm sizeof sz alignof az __imag__ v18__imag__ __real__ v18__real__ cv pl mi ml / dv % rm an | or ^ eo << ls >> rs == eq != ne < lt > gt <= le >= ge && aa || oo , cm ->* pm -> pt [] ix :: sr = aS += pL -= mI *= mL /= dV %= rM &= aN |= oR ^= eO <<= lS >>= rS ?: qu () cl ... sp (ceiling /) (floor /) (round /) (ceiling %) (floor %) (round %) abs strict && strict || (exact /=) (ceiling /=) (floor /=) (round /=) (ceiling %=) (floor %=) (round %=) vtable unit interface implementation GCC java_exceptions junk at end of #pragma %s invalid #pragma %s #pragma vtable no longer supported #pragma implementation for %qs appears after file is included junk at end of #pragma GCC java_exceptions %qD not defined %qD was not declared in this scope there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available (if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated) /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/lex.c retrofit_lang_decl /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/parser.c identifier %<%s%> will become a keyword in C++0x B C C C :C :C 0C :C :C :C :C :C :C :C C :C 'C WD WD WD ^D WD WD ^D WD ^D ^D WD WD ^D ^D WD ^D ^D ^D ^D ^D WD ^D ^D ^D ^D ^D ^D WD WD WD WD WD WD WD WD ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D WD ^D WD ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D WD WD WD ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D WD ^D ^D WD WD ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D ^D WD 2 3 C E I A B U V c e d f g h [ Z Y ] ^ %H%<#pragma%> is not allowed here %H%<%E::%E%> has not been declared %H%<::%E%> has not been declared %Hrequest for member %qE in non-class type %qT %H%<%T::%E%> has not been declared %H%qE has not been declared %H%<%E::%E%> %s %H%<::%E%> %s %H%qE %s %H% is too long for GCC ISO C++ 1998 does not support % %Hduplicate %qs %Hnew types may not be defined in a return type (perhaps a semicolon is missing after the definition of %qT) %H%qT is not a template %H%qE is not a template %Hinvalid template-id cannot appear in a constant-expression %Hinvalid use of template-name %qE without an argument list %Hinvalid use of destructor %qD as a type %Hinvalid combination of multiple type-specifiers %H%qE does not name a type (perhaps % was intended) %H%qE in namespace %qE does not name a type %H%qE in class %qT does not name a type W W X W BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX W W W BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX BX W X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X %<;%> Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y qY bY Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y end of line identifier expected string-literal %Hunsupported non-standard concatenation of string literals a wide string is invalid in this context expected declaration %Hfixed-point types not supported in C++ floating-point literal ISO C++ forbids braced-groups within expressions %Hstatement-expressions are not allowed outside functions nor in template-argument lists %<)%> %H% may not be used in this context % %<__FUNCTION__%> %<__PRETTY_FUNCTION__%> %<__func__%> %<(%> %<,%> % expected primary-expression %Hlocal variable %qD may not appear in this context Nd vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj vj h vj vj vj h vj c c c c c vj (d (d (d (d vj vj vj vj vj vj vj vj e h h f g g g g g g g g g g g g af af af g g g g g g g e g g e g g g h e g e g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g expected id-expression %Hscope %qT before %<~%> is not a class-name %Hdeclaration of %<~%T%> as member of %qT %Htypedef-name %qD used as destructor declarator expected unqualified-id %<::%> %H%qD used without template parameters %Hreference to %qD is ambiguous is not a class or namespace is not a class, namespace, or enumeration %qT is not a template %qD is not a template expected nested-name-specifier types may not be defined in casts %<<%> %<>%> a cast to a type other than an integral or enumeration type types may not be defined in a % expression % operator %<{%> %<}%> ISO C++ forbids compound-literals non-constant compound literals a function call an increment a decrement U ( y ( ( %<]%> an array reference %H%qE does not have class type %Hinvalid use of %qD %<->%> %<.%> extended initializer lists non-scalar type %<~%> the address of a label %<*%> unary * %<&%> %<++%> %<--%> E u u 5 % % %Harray bound forbidden after parenthesized type-id try removing the parentheses around the type-id types may not be defined in a new-type-id %<[%> %Hexpression in new-declarator must have integral or enumeration type % o o o o o o o o o o o o o o o o o o o o o o o o o o o o o v o o o o o o o use of old-style cast %H%<>>%> operator will be treated as two right angle brackets in C++0x suggest parentheses around %<>>%> expression calls to overloaded operators %<:%> an assignment w a comma operator & / 8 N E [ d m v expected statement Z t t t Z M M expected labeled-statement %Hcase label %qE not within a switch statement %Hcase label not within a switch statement %H% without a previous % selection-statement suggest braces around empty body in an % statement suggest braces around empty body in an % statement %Hsuggest explicit braces to avoid ambiguous % expected selection-statement types may not be defined in conditions %<=%> iteration-statement % expected iteration-statement jump-statement %Hbreak statement not within loop or switch %Hinvalid exit from OpenMP structured block %Hbreak statement used with OpenMP for loop %Hcontinue statement not within a loop ISO C++ forbids computed gotos expected jump-statement extra %<;%> %H%<__label__%> not at the beginning of a block %Hmixing declarations and function-definitions is forbidden expected %<,%> or %<;%> %H% used outside of class %H% will change meaning in C++0x; please remove it %Hclass definition may not be declared a friend " " " " " " k " " " " %Htemplates may not be % % invalid linkage-specification % % types may not be defined in % expressions % invalid use of % in conversion operator %Honly constructors take base initializers %Hcannot expand initializer for member %<%D%> anachronistic old-style base class initializer %Hkeyword % not allowed in this context (a qualified member initializer is implicitly a type) expected operator = 0 W J # 4 A e ' d q ~ N [ y o keyword % not implemented, and will be ignored %Htemplate parameter pack %qD cannot have a default argument %Htemplate parameter pack cannot have a default argument %, %, or % %Htemplate parameter packs cannot have default arguments % expected template-id expected %<<%> %<<::%> cannot begin a template-argument list %<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%> (if you use %<-fpermissive%> G++ will accept your code) %Hparse error in template argument list expected template-name %Hnon-template %qD used as template use %<%T::template %D%> to indicate that it is a template %Hexpected parameter pack before %<...%> expected template-argument invalid non-type template argument % %Htemplate specialization with C linkage expected type specifier S S S S S S S . C S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S C++0x auto expected template-id for type expected type-name h 5 ( [ N 4 A N is not a type scoped enums using % outside of template declaration %qD does not declare anything attributes ignored on uninstantiated type attributes ignored on template instantiation attributes ignored on elaborated-type-specifier that is not a forward declaration expected %<{%> comma at end of enumerator list %H%qD is not a namespace-name expected namespace-name % %H% definition is not allowed here % %Ha template-id may not appear in a using-declaration % a function-definition is not allowed here %Han asm-specification is not allowed on a function-definition %Hattributes are not allowed on a function-definition expected constructor, destructor, or type conversion expected initializer invalid type in declaration %Hinitializer provided for function attributes after parenthesized initializer ignored %Harray bound is not an integer constant %H%<%T::%E%> is not a type %Hinvalid use of constructor as a template use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name invalid declarator expected declarator %H%qD is a namespace expected ptr-operator %Hduplicate cv-qualifier invalid use of % expected type-specifier %<...%> expected %<,%> or %<...%> types may not be defined in parameter types %Hfile ends in default argument deprecated use of default argument for parameter of non-function %Hdefault arguments are only permitted for function parameters template %H%sparameter pack %qD cannot have a default argument %H%sparameter pack cannot have a default argument 9 9 9 k9 9 9 9 9 9 9 9 9 w9 9 9 9 9 9 9 8 e9 29 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 e9 29 e9 29 29 29 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 ISO C++ does not allow designated initializers expected class-name expected %<{%> or %<:%> global qualification of class name is invalid qualified name does not name a class %Hinvalid class name in declaration of %qD %Hdeclaration of %qD in namespace %qD which does not enclose %qD %Hdeclaration of %qD in %qD which does not enclose %qD %Hextra qualification not allowed %Han explicit specialization must be preceded by %%> %Hfunction template %qD redeclared as a class template could not resolve typename type %Hredefinition of %q#T %Hprevious definition of %q+#T class-key expected class-key %Ha class-key must be used when declaring a friend %Hfriend declaration does not name a class or function %Hpure-specifier on function-definition expected %<;%> defaulted and deleted functions invalid pure specifier (only %<= 0%> is allowed) a brace-enclosed initializer is not allowed here % specified more than once in base-specified more than one access specifier in base-specified %Hkeyword % not allowed outside of templates %Hkeyword % not allowed in this context (the base class is implicitly a type) types may not be defined in an exception-specification % % types may not be defined in exception-declarations % %<__label__%> %Htoo few template-parameter-lists %Htoo many template-parameter-lists %Hnamed return values are no longer supported %Hinvalid declaration of member template in local class %Htemplate with C linkage invalid explicit specialization typedef %Htemplate declaration of %qs %Hexplicit template specialization cannot have a storage class a call to a constructor %H%<>>%> should be %<> >%> within a nested template argument list %Hspurious %<>>%>, use %<>%> to terminate a template argument list expected %<,%> %> expressions types may not be defined in %< %Hinvalid use of %qD in linkage specification %H%<__thread%> before %qD expected ] i struct class union %qs tag used in naming %q#T %H%qD redeclared with different access %H% (as a disambiguator) is only allowed within templates %Hmisplaced %<@%D%> Objective-C++ construct %H%<@encode%> must specify a type as an argument expected %<:%> %Hinvalid Objective-C++ selector name and and_eq bitand bitor compl not not_eq or or_eq xor xor_eq & & & & & & & & W p & & % & & & & & & & & & & & & & & > %Hidentifier expected after %<@protocol%> { %<@try%> %<@synchronized%> %<@throw%> collapse copyin copyprivate firstprivate lastprivate nowait num_threads ordered reduction schedule shared untied i ( ( ( ( ( ( ( ( $ n ( ( ( %Htoo many %qs clauses %Hcollapse argument needs positive constant integer expression none expected % or % default if expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, or %<||%> dynamic guided runtime %Hschedule % does not take a % parameter %Hschedule % does not take a % parameter %<,%> or %<)%> invalid schedule kind private expected %<#pragma omp%> clause %H%qs is not valid for %qs j ; f 9 Z invalid operator for %<#pragma omp atomic%> for statement expected parenthesized initialization is not allowed in OpenMP % loop %Hiteration variable %qD should not be firstprivate %Hiteration variable %qD should not be reduction %Hnot enough collapsed for loops %Hcollapsed loops not perfectly nested #pragma omp for expected %<#pragma omp section%> or %<}%> #pragma omp sections #pragma omp parallel #pragma omp parallel for sections #pragma omp parallel sections #pragma omp single #pragma omp task " < V p %Hjunk at end of %<#pragma GCC pch_preprocess%> %Hexpected string literal %H%<#pragma GCC pch_preprocess%> must be first %H%<#pragma omp barrier%> may only be used in compound statements %H%<#pragma omp flush%> may only be used in compound statements %H%<#pragma omp taskwait%> may only be used in compound statements %H%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct expected declaration specifiers / w \e 9 a cp_parser_pragma cp_parser_omp_construct cp_parser_omp_parallel cp_parser_omp_for_loop cp_parser_set_storage_class cp_parser_late_parsing_for_member cp_parser_single_declaration cp_parser_check_declarator_template_parameters cp_parser_lookup_name cp_parser_late_parsing_attribute_arg_lists cp_parser_save_attribute_arg_list cp_parser_template_argument cp_lexer_token_position cp_parser_template_id cp_parser_type_parameter cp_parser_simple_declaration cp_parser_jump_statement cp_parser_trait_expr cp_parser_unary_expression cp_parser_postfix_expression cp_parser_unqualified_id cp_parser_primary_expression cp_parser_translation_unit cp_parser_make_indirect_declarator cp_parser_diagnose_invalid_type_name signed unsigned short long const volatile restrict inline virtual explicit friend __complex __thread % , 5 ; @ F O X _ g p w make_id_declarator cp_lexer_purge_tokens_after cp_lexer_purge_token cp_lexer_consume_token cp_lexer_peek_nth_token cp_lexer_new_from_tokens cp_lexer_new_main mutable pending-inline-info %p sorted-fields %p template-info %p index %d level %d orig_level %d throws ptrmemfunc fn type needs-constructor needs-destructor X() has-type-conversion X(constX&) X(X&) new new[] delete delete[] this=(X&) n_parents=%d no-binfo use_template=%d interface-only interface-unknown %s <%p> bindings local bindings label template functions binfo access_binfo function chain default type_info /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/rtti.c __cxa_bad_cast __cxa_bad_typeid cannot use typeid with -fno-rtti must #include before using typeid cannot create type information for type %qT because it involves types of variable size target is not pointer or reference to class target is not pointer or reference to complete type target is not pointer or reference source is not a pointer source is not a pointer to class source is a pointer to incomplete type source is not of class type source is of incomplete class type conversion casts away constness dynamic_cast of %q#D to %q#T can never succeed % not permitted with -fno-rtti __class_type_info __dynamic_cast source type is not polymorphic cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s) | | _pseudo %d __vmi_class_type_info q } __type_info_pseudo __fundamental_type_info __array_type_info __function_type_info __enum_type_info __si_class_type_info __base_class_type_info_pseudo __pointer_type_info __pointer_to_member_type_info le & ' emit_tinfo_decl 8 \ HW @W DW $ emit_support_tinfos create_tinfo_types get_pseudo_ti_init typeid_ok_p build_headof /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/typeck.c %s between distinct pointer types %qT and %qT lacks a cast ISO C++ forbids %s between pointer of type % and pointer-to-function %s between distinct pointer-to-member types %qT and %qT lacks a cast conversion invalid application of %qs to a member function invalid application of % to a bit-field ISO C++ forbids applying % to an expression of function type invalid application of %<__alignof%> to a bit-field ISO C++ forbids applying %<__alignof%> to an expression of function type invalid use of non-static member function void value not ignored as it ought to be invalid use of non-lvalue array deprecated conversion from string constant to %qT request for member %qD in %qE, which is of non-class type %qT invalid use of nonstatic data member %qE %qD is not a member of %qT invalid access to non-static data member %qD of NULL object (perhaps the % macro was used incorrectly) invalid access to non-static data member %qD of NULL object invalid use of %qD qualified type %qT does not match destructor name ~%qT object type %qT does not match destructor name ~%qT the type being destroyed is %qT, but the destructor refers to %qT %qD is not a template %<%D::%D%> is not a member of %qT %qT is not a base of %qT %qD has no member named %qE %qD is not a member template function %qT is not a pointer-to-object type invalid use of %qs on pointer to member invalid type argument of %qs invalid type argument subscript missing in array reference array subscript is not an integer ISO C++ forbids subscripting non-lvalue array subscripting array declared % subscripted value is neither array nor pointer array indexing object missing in use of %qE ISO C++ forbids calling %<::main%> from within program must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%> %qE cannot be used as a function constructor member function function too many arguments to %s %q+#D at this point in file too many arguments to function parameter %P of %qD has incomplete type %qT parameter %P has incomplete type %qT argument passing too few arguments to %s %q+#D too few arguments to function assuming cast to type %qT from overloaded function right shift count is negative right shift count >= width of type left shift count is negative left shift count >= width of type left rotate count is negative right rotate count is negative left rotate count >= width of type right rotate count >= width of type comparing floating point with == or != is unsafe comparison with string literal results in unspecified behaviour comparison the address of %qD will never be NULL ISO C++ forbids comparison between pointer and integer unordered comparison on non-floating point argument invalid operands of types %qT and %qT to binary %qO NULL used in arithmetic a d R d R d d d d d d d d d ] ] ] ] w w ISO C++ forbids using pointer of type % in subtraction ISO C++ forbids using pointer to a function in subtraction ISO C++ forbids using pointer to a method in subtraction invalid use of a pointer to an incomplete type in pointer arithmetic invalid use of %qE to form a pointer-to-member-function a qualified-id is required parentheses around %qE cannot be used to form a pointer-to-member-function taking address of temporary wrong type argument to unary minus wrong type argument to unary plus wrong type argument to bit-complement wrong type argument to abs wrong type argument to conjugation in argument to unary ! no pre-increment operator for type no post-increment operator for type no pre-decrement operator for type no post-decrement operator for type increment decrement ISO C++ forbids incrementing an enum ISO C++ forbids decrementing an enum cannot increment a pointer to incomplete type %qT cannot decrement a pointer to incomplete type %qT ISO C++ forbids incrementing a pointer of type %qT ISO C++ forbids decrementing a pointer of type %qT invalid use of Boolean expression as operand to % ISO C++ forbids taking address of function %<::main%> ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function. Say %<&%T::%D%> ISO C++ forbids taking the address of a bound member function to form a pointer to member function. Say %<&%T::%D%> ISO C++ forbids taking the address of a cast to a non-lvalue expression cannot create pointer to reference member %qD attempt to take address of bit-field structure member %qD %s cannot take the address of %, which is an rvalue expression address of explicit register variable %qD requested address requested for %qD, which is declared % p e e e e e %s expression list treated as compound expression left-hand operand of comma cast from type %qT to type %qT casts away constness static_cast from type %qT to type %qT casts away constness reinterpret_cast from type %qT to type %qT casts away constness invalid static_cast from type %qT to type %qT converting from %qT to %qT invalid cast of an rvalue expression of type %qT to type %qT casting %qT to %qT does not dereference pointer cast from %qT to %qT loses precision ISO C++ forbids casting between pointer-to-function and pointer-to-object invalid cast from type %qT to type %qT invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type invalid use of const_cast with type %qT, which is a pointer or reference to a function type invalid const_cast of an rvalue of type %qT to type %qT invalid const_cast from type %qT to type %qT ISO C++ forbids casting to an array type %qT invalid cast to function type %qT in evaluation of %<%Q(%#T, %#T)%> assignment incompatible types in assignment of %qT to %qT array used as initializer invalid array assignment initialization in pointer to member function conversion pointer to member conversion via virtual base %qT in pointer to member conversion invalid conversion to type %qT from type %qT cannot convert %qT to %qT for argument %qP to %qD cannot convert %qT to %qT in %s %s might be a candidate for a format attribute suggest parentheses around assignment used as truth value in passing argument %P of %q+D returning reference to temporary _.tmp_ reference to non-lvalue returned reference to local variable %q+D returned address of local variable %q+D returned function declared % has a % statement returning a value from a destructor cannot return from a handler of a function-try-block of a constructor returning a value from a constructor return-statement with no value, in function returning %qT return-statement with a value, in function returning 'void' % must not return NULL unless it is declared % (or -fcheck-new is in effect) % should return a reference to %<*this%> return ignoring %qV qualifiers added to function type %qT check_return_expr expand_ptrmemfunc_cst build_ptrmemfunc cp_build_modify_expr cp_build_c_cast build_const_cast_1 convert_member_func_to_ptr check_for_casting_away_constness cxx_mark_addressable cp_build_unary_op cp_build_binary_op convert_arguments get_member_function_from_ptrfunc build_ptrmemfunc_access_expr finish_class_member_access_expr build_class_member_access_expr rationalize_conditional_expr perform_integral_promotions cxx_sizeof_or_alignof_type structural_comptypes common_pointer_type merge_types type_after_usual_arithmetic_conversions cp_common_type can't convert from incomplete type %qT to %qT conversion of %qE from %qT to %qT is ambiguous cannot convert %qE from type %qT to type %qT invalid conversion from %qT to %qT /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/cvt.c initialization of volatile reference type %q#T from rvalue of type %qT conversion to volatile reference type %q#T from rvalue of type %qT initialization of non-const reference type %q#T from rvalue of type %qT conversion to non-const reference type %q#T from rvalue of type %qT conversion from %qT to %qT discards qualifiers casting %qT to %qT does not dereference pointer converting cannot convert type %qT to type %qT conversion from %q#T to %q#T the result of the conversion is unspecified because %qE is outside the range of type %qT %q#T used where a %qT was expected %q#T used where a floating point value was expected conversion from %qT to non-scalar type %qT requested pseudo-destructor is not called second operand of conditional third operand of conditional right-hand operand of comma void context object of incomplete type %qT will not be accessed in %s object of type %qT will not be accessed in %s value computed is not used object %qE of incomplete type %qT will not be accessed in %s void cast %s cannot resolve address of overloaded function %s is a reference, not call, to function %qE %s has no effect converting NULL to non-pointer type ambiguous default type conversion from %qT candidate conversions include %qD and %qD 8 8 8 8 9 9 9 9 I9 (9 9 9 9 9 (9 : : : : : : : : : ocp_convert convert_to_reference build_up_reference cp_convert_to_pointer terminate __cxa_call_unexpected __gxx_personality_v0 __cxa_end_cleanup __cxa_get_exception_ptr __cxa_begin_catch __cxa_end_catch type %qT is disallowed in Java % or % jthrowable call to Java % or % with % undefined type %qT is not derived from % __gcj_personality_v0 /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/except.c mixing C++ and Java catches in a single translation unit __cxa_allocate_exception __cxa_free_exception throwing NULL, which has integral, not pointer type _Jv_Throw %qD should never be overloaded __cxa_throw in thrown expression __cxa_rethrow expression %qE of abstract class type %qT cannot be used in throw-expression U bV LV 6V V V %Hexception of type %qT will be caught %H by earlier handler for %qT %H%<...%> handler must be the last handler for its try block ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~ wcsstr strstr cos towctrans memmove wcstol wcscoll wcstombs strtol strcoll wcslen time ctime strlen iswctype wmemchr wcsrchr ceil sin strrchr tan iscntrl acos wmemmove wcsrtombs wctrans wmemcmp pow atol wcsncmp memset free strncmp wmemset wcsspn wcstoul strspn strtoul asctime atan2 asin atan ferror iswalnum wcscat realloc strcat wcscpy memcpy strcpy tolower floor iswcntrl atoi clearerr swscanf wcsncat islower strncat btowc localtime wctomb isalnum isprint mblen wcstod log10 strtod wcrtomb abs setlocale wcschr mbrlen memchr strchr labs iswpunct exit sqrt swprintf wctype mbsrtowcs wcscspn getenv strcspn towlower atof wcstok localeconv strtok calloc malloc isalpha iswlower iswspace wcsxfrm signal strxfrm wcsftime feof strftime wcscmp fabs memcmp strcmp vsprintf fwide gmtime sprintf exp wmemcpy iswprint sscanf wcsncpy strncpy isspace toupper wctob div mbtowc ldiv log mktime isupper atexit modf mbstowcs mbrtowc ispunct iswalpha setvbuf rand srand frexp towupper mbsinit cosh vswprintf iswupper wcspbrk fmod strpbrk sinh tanh iswdigit clock longjmp ldexp setbuf fseek iswgraph difftime iswxdigit isdigit isxdigit isgraph ` g n r | " & + 3 : ? G O V ^ e m u { $ , 2 9 ? F N R \ c j q x } ' 0 5 > E J Q X a g n v z " + 3 8 B K S X ` e j s y Z _ 3 ] r m | % 1 & h - choose_personality_routine %qD is already a friend of class %qT invalid type %qT declared % partial specialization %qT declared % class %qT is implicitly friends with itself %qT is not a member of %qT %qT is not a member class template of %qT %q+D declared here %qT is not a nested class of %qT template parameter type %qT declared % %q#T is not a template %qD is already a friend of %qT %qT is already a friend of %qT /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/friend.c member %qD declared as friend before type %qT defined friend declaration %qD in local class without prior declaration friend declaration %q#D declares a non-template function (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) do_friend /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/init.c value-initialization of reference %J%qD should be initialized in the member initialization list %Jvalue-initialization of %q#D, which has reference type %Juninitialized member %qD with % type %qT %Juninitialized reference member %qD member initializer %q+D will be initialized after base %qT will be initialized after %q+#D base %qT %J when initialized here %Jmultiple initializations given for %qD %Jmultiple initializations given for base %qT %Jinitializations for multiple members of %qT %Jbase class %q#T should be explicitly initialized in the copy constructor class %qT does not have any field named %qD %q#D is a static data member; it can only be initialized at its definition %q#D is not a non-static data member of %qT unnamed initializer for %qT, which has no base classes unnamed initializer for %qT, which uses multiple inheritance %qD is both a direct base and an indirect virtual base type %qT is not a direct or virtual base of %qT type %qT is not a direct base of %qT bad array initializer %qT is not a class type incomplete type %qT does not have member %qD invalid pointer to bit-field %qD invalid use of non-static member function %qD invalid use of non-static data member %qD memory invalid type % for new uninitialized const in % of %q#T call to Java constructor with %qs undefined %qD should never be overloaded Java class %q#T object allocated using placement new no suitable %qD found in class %qT request for member %qD is ambiguous non-constant array size in new, unable to verify length of initializer-list ISO C++ forbids initialization in array new new initializer size in array new must have integral type new cannot be applied to a reference type new cannot be applied to a function type class$ jclass call to Java constructor, while % undefined can't find % in %qT initializer ends prematurely cannot initialize multi-dimensional array with initializer possible problem detected in invocation of delete operator: neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined. unknown array size in delete type to vector delete is neither pointer or array type build_delete build_dtor_call build_vec_init build_vec_delete_1 _Jv_AllocObject build_new_1 build_offset_ref expand_aggr_init_1 expand_default_init expand_virtual_init build_value_init_noctor build_zero_init finish_init_stmts /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/method.c LTHUNK *.%s%u generic thunk code fails for method %q#D which uses %<...%> _vptr. non-static const member %q#D, can't use default assignment operator non-static reference member %q#D, can't use default assignment operator synthesized method %qD first required here vtable layout for class %qT may not be ABI-compliantand may change in a future version of GCC due to implicit virtual destructor e implicitly_declare_fn locate_ctor use_thunk finish_thunk make_thunk /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/search.c %qT is an ambiguous base of %qT %qT is an inaccessible base of %qT request for member %qD is ambiguous deprecated covariant return type for %q+#D overriding %q+#D invalid covariant return type for %q+#D conflicting return type specified for %q+#D looser throw specifier for %q+#F overriding %q+#F conflicting type attributes specified for %q+#D deleted function %q+D overriding non-deleted function %q+D non-deleted function %q+D overriding deleted function %q+D %q+#D cannot be declared since %q+#D declared in base class no search statistics copied_binfo dfs_walk_once_accessible_r dfs_walk_once dfs_walk_once_r dfs_walk_all class_method_index_for_fn lookup_member build_baselink dfs_access_in_type lookup_field_1 lookup_base dfs_lookup_base /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/semantics.c suggest parentheses around assignment used as truth value statement suggest explicit braces around empty body in % statement 3rd expression in for switch quantity not an integer assignment (via 'asm' output) type of asm operand %qE could not be determined __label__ declarations are only allowed in function scopes invalid use of member %q+D in static member function invalid use of non-static data member %q+D from this location object missing in reference to %q+D arguments to destructor are not allowed % is unavailable for static member functions invalid use of % in non-member function invalid use of % at top level invalid qualifying scope in pseudo-destructor name qualified type %qT does not match destructor name ~%qT %qE is not of type %qT compound literal of non-object type %qT template type parameters must use the keyword % or % invalid use of type %qT as a default value for a template template-parameter invalid default argument for a template template parameter definition of %q#T inside template parameter list invalid definition of qualified type %qT invalid base-class specification %qT is not a class type base class %qT has cv qualifiers %Hincomplete type %qT used in nested name specifier %Hreference to %<%T::%D%> is ambiguous %H%qD is not a member of %qT %H%qD is not a member of %qD %H%<::%D%> has not been declared use of % variable from containing function use of parameter from containing function %q+#D declared here missing template arguments expected primary-expression template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type %qD cannot appear in a constant-expression use of namespace %qD as expression use of class template %qT as expression request for member %qD is ambiguous in multiple inheritance lattice type of %qE is unknown cannot apply % to destructor %<~%T%> cannot apply % to member function %qD shared private reduction copyprivate copyin %qD is not a variable in clause %qs %qE is not a variable in clause %qs %qD appears more than once in data clauses %qD is not a variable in clause % %qE is not a variable in clause % %qD is not a variable in clause % %qE is not a variable in clause % num_threads expression must be integral schedule chunk size expression must be integral firstprivate lastprivate %qE has invalid type for % %qE has invalid type for % %qE must be % for % %qE has reference type for %qs threadprivate %qE is predetermined %qs for %qs 6 * ! % 2 2 2 2 2 B 5 ( % %qD is not file, namespace or block scope variable %qE declared % after first use automatic variable %qE cannot be % % %qE has incomplete type % %qE directive not in %qT definition %Hinvalid controlling predicate %Hdifference between %qE and %qD does not have integer type %Hinvalid increment expression %Hexpected iteration declaration or initialization %Hmissing controlling predicate %Hmissing increment expression %Hinvalid type for iteration variable %qE static assertion failed: %E non-constant condition for static assertion argument to decltype must be an expression %qE refers to a set of overloaded functions unable to determine the declared type of expression %<%E%> ^ z [ 0 p $ f __is_convertible_to incomplete type %qT not allowed e e finish_trait_expr trait_expr_value finish_decltype_type finish_omp_for handle_omp_for_class_iterator finish_omp_clauses omp_clause_info_fndecl expand_or_defer_fn emit_associated_thunks simplify_aggr_init_expr note_decl_for_pch finish_member_declaration finish_template_template_parm finish_pseudo_destructor_expr finish_call_expr finish_stmt_expr finish_qualified_id_expr finish_non_static_data_member perform_or_defer_access_check /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/tree.c R " " I " " K 6 [ [ , 6 6 6 6 6 ? g w %qV qualifiers cannot be applied to %qT type "%s", offset = %ld vtable type: vtable decl "%s" no vtable decl yet virtuals: %s [%ld =? %ld] k k k g $ m @ e g # p 1 6 h java_interface com_interface init_priority O O O K %qE attribute can only be applied to Java class definitions %qE attribute can only be applied to class definitions %qE is obsolete; g++ vtables are now COM-compatible by default requested init_priority is not an integer constant can only use %qE attribute on file-scope definitions of objects of class type requested init_priority is out of range requested init_priority is reserved for internal use 0 /. . 3 / / 3 0 2 2 2 , y + B e ~ 4 Y " $ !& & /' ' i3 ( ) * i3 M+ + /, , - - R= ] [ [ ` y\ \ ` {] b_ _ L` o= = = &> > > U? ? @ z@ @ B )C F H pG D JJ oK L M nO kQ S S T =U ` U V 0X ` X Y Y ZZ Z 9[ Qj b } nj j j Hk k :l l m m n n o Yq t x v hs y R{ | ~ # E ) e P+ x + e P+ x + V + |f+ 1 + |f+ @3 < D3 v w^> H3 v w^> E < E v w^> E v w^> 1 < 2 + |f+ 1 < 1 < V ] 9 1 5 < @3 E stabilize_aggr_init stabilize_call stabilize_expr cxx_type_hash_eq cp_build_type_attribute_variant cp_tree_equal get_type_decl build_min_non_dep build_min build_min_nt verify_stmt_tree_r cxx_printable_name get_first_fn copy_binfo force_target_expr build_target_expr_with_type lvalue_p_1 COLLECT_GCC_OPTIONS -o -c -frepo must be used with -c .rpo r mysterious repository information in %s '-frandom-seed= w can't create repository information file %qs M %s D %s A %s '-frandom-seed=%s' %c %s /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/repo.c e < repo_emit_p prot accs priv pub new vecnew delete vecdelete pos neg addr deref not lnot preinc predec plusassign plus minusassign minus multassign mult divassign div modassign mod andassign and orassign or xorassign xor lshiftassign lshift rshiftassign rshift eq ne lt gt le ge land lor compound memref ref subs postinc postdec call assign Y P g X T ) A 7 q O lang operator note tynm ptrmem ptd cls bfld vfld spec base virt mutable static link member pure constructor destructor conversion global init global fini pseudo tmpl thunk this adjusting result adjusting fixd fn alis dcls rslt inst spcs prms crnt chan cleanup body hdlr raises clas mbr op 0 ctor %u decl parm nmsp expr cond then else init stmt } # \ x q C A ? K /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/optimize.c build_delete_destructor_body clone_body cahstijlmxy ++ substitutions ??? S%d_ = CV- %s (%s at %p) Sa Ss Sb Si So Sd St _Z *INTERNAL* /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/mangle.c cv %08lx C2 C1 D0 D2 D1 U8__vector Dp mangling typeof, use decltype instead Ds Di uint int %u DF mangling unknown fixed point type P ~ x fp st at sr dt mangling %C mangling new-expression omitted middle operand to % operand cannot be mangled the mangled name of %qD will change in a future version of GCC allocator basic_string char_traits basic_istream basic_ostream basic_iostream TI TS TV TT TC operator %lu _ZGV _ZGR f P+ x + f < @f + |f+ @f write_java_integer_type_codes write_template_param write_template_arg write_template_arg_literal write_method_parms write_builtin_type write_type write_special_name_destructor write_special_name_constructor 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ write_unqualified_name write_template_prefix write_unscoped_name /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/cp-objcp-common.c ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; f K M f + `+ ?MU f ?I+ " + cp_save_built_in_decl_post_parsing cmp_templ_arg cp_tree_size N _GLOBAL__N_1 /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/name-lookup.c declaration of %q#D conflicts with previous declaration %q+#D redeclaration of % as %qT invalid redeclaration of %q+D as %qD declaration of %q#D with C language linkage due to different exception specifications type mismatch with previous external decl of %q#D previous external decl of %q+#D extern declaration of %q#D doesn't match global declaration %q+#D declaration of %q#D shadows a parameter %Jshadowed declaration is here declaration of %qD shadows a member of 'this' declaration of %qD shadows a previous local declaration of %qD shadows a global declaration name lookup of %qD changed matches this %q+D under ISO standard rules matches this %q+D under old rules name lookup of %qD changed for ISO % scoping cannot use obsolete binding at %q+D because it has a destructor using obsolete binding at %q+D (if you use %<-fpermissive%> G++ will accept your code) %s %s(%E) %p %d %s %s %p %d z z z z z z z z z z z z blocks=%p more-cleanups-ok have-cleanups names: class-shadowed: %s type-shadowed: binding level %p current_binding_level=%p class_binding_level=%p NAMESPACE_LEVEL (global_namespace)=%p global: ._%d %q#D hides constructor for %q#T %q#D conflicts with previous using declaration %q#D previous non-function declaration %q+#D conflicts with function declaration %q#D %qT is not a namespace a using-declaration cannot specify a template-id. Try % namespace %qD not allowed in using-declaration %qD not declared %qD is already declared in this scope reference to %qD is ambiguous %qD has the same name as the class in which it is declared using-declaration for non-member at class scope %<%T::%D%> names destructor %<%T::%D%> names constructor %<%T::%D%> names constructor in %qT no members matching %<%T::%D%> in %q#T declaration of %qD not in a namespace surrounding %qD explicit qualification in declaration of %qD %qD should have been declared inside %qD visibility %qD attribute requires a single NTBS argument %qD attribute is meaningless since members of the anonymous namespace get local symbols %qD attribute directive ignored namespace alias %qD not allowed here, assuming %qD strong strong using only meaningful at namespace scope current namespace %qD does not enclose strongly used namespace %qD argument dependent lookup finds %q+D in call to %qD f < 1 < 1 < V < f f f f pushtag maybe_process_template_type_declaration arg_assoc_type lookup_type_current_level lookup_name_real ambiguous_decl do_using_directive add_using_namespace do_namespace_alias pop_namespace push_namespace push_class_level_binding set_inherited_value_binding_p poplevel_class is_ancestor do_nonmember_using_decl validate_nonmember_using_decl push_overloaded_decl push_using_decl lookup_extern_c_fun_binding_in_all_ns constructor_name_p set_identifier_type_value_with_scope resume_scope leave_scope begin_scope block-scope cleanup-scope try-scope catch-scope for-scope function-parameter-scope class-scope namespace-scope template-parameter-scope template-explicit-spec-scope add_decl_to_level pop_binding :: operator #%qs not supported by %s# template dynamic_cast static_cast reinterpret_cast const_cast new delete sizeof ... __alignof__ ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' o ' = += -= /= %= throw ; ; ; ; ; R i i R R ; ; ; ; ; ! R R R R R R ! ! R ; | ; virtual explicit typedef z typename decltype using namespace try catch if else switch while do for break continue finally ^0 / 8 8 8 8 8 8 8 8 8 8 8 8 8 / 0 8 1 8 Y7 2 5 )4 4 6 6 |3 -7 8 8 8 8 8 8 8 q8 class template-parameter- %ld static_assert typeid va_arg offsetof __has_nothrow_assign __has_trivial_assign __has_nothrow_constructor __has_trivial_constructor __has_nothrow_copy __has_trivial_copy __has_trivial_destructor __has_virtual_destructor __is_abstract __is_base_of __is_class __is_convertible_to __is_empty __is_enum __is_pod __is_polymorphic __is_union /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/cxx-pretty-print.c {B B B B B B C #C ;C SC kC C C C C C C pp_cxx_trait_expression pp_cxx_declaration pp_cxx_explicit_instantiation pp_cxx_explicit_specialization pp_cxx_template_parameter pp_cxx_ptr_operator pp_cxx_delete_expression pp_cxx_new_expression pp_cxx_unqualified_id /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/gimple.h /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/cp/cp-gimplify.c break statement not within loop or switch continue statement not within loop or switch statement with no effect %qE implicitly determined as % has reference type cp_genericize cp_genericize_r cp_gimplify_expr gimple_op finish_bc_block /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/gimple.h /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/tree-mudflap.c : %d ( anonymous fn ) GNU C++ %d:%d ) low high __mf_cache __mf_lookup_cache __mf_lc_shift __mf_lc_mask __mf_check __mf_register __mf_unregister __mf_init __mf_set_options __mf_lookup_shift_l __mf_lookup_mask_l __mf_elem __mf_base __mf_limit __mf_unlikely_cond mudflap checking not yet implemented for ARRAY_RANGE_REF mudflap cannot track %qs in stub function string literal constant -ignore-reads mudflap cannot track unknown size extern %qs mudflap1 mudflap2 ? A B 2 2 0 0 3 % 3 3 9 I Q \ : y 4 r 5 C ` a b c + d E e X f q g h i k j l m n o p 6 6 " 8 , K 3 7 : 7 C N [ d o x 1 1 0 @ D + ) L Z [ F \ , r * M & ] ) $ . 3 < C J N P V ' Z a . f # i p t y O P R H I G ^ - / q _ ! ( J ' S , T 2 U 7 V ; C W L X S 1 P Z " ` i Y o w | E % v w s t { | version_selector packed nocommon common noreturn noinline always_inline gnu_inline artificial flatten used unused externally_visible transparent_union constructor destructor mode section aligned weak alias weakref no_instrument_function malloc returns_twice no_stack_limit pure no vops deprecated vector_size visibility tls_model nonnull nothrow may_alias cleanup warn_unused_result sentinel type generic alloc_size cold hot warning error target optimize lockable scoped_lockable guarded_by point_to_guarded_by guarded point_to_guarded acquired_after acquired_before exclusive_lock shared_lock exclusive_trylock shared_trylock unlock exclusive_locks_required shared_locks_required locks_excluded lock_returned no_thread_safety_analysis ignore_reads_begin ignore_reads_end ignore_writes_begin ignore_writes_end unprotected_read ! G [ | [ m R Q & 9 z K ` W b g o w | d x A o + x 6 3 u < e I T Y ] e k r v { 2 @ o e e e e ' . G ] l B z format format_arg F top level "%s" %qD is not defined outside of function scope string length %qd is greater than the length %qd ISO C%d compilers are required to support overflow in constant expression integer overflow in expression floating point overflow in expression fixed-point overflow in expression vector overflow in expression complex integer overflow in expression complex floating point overflow in expression && || logical %<%s%> with non-zero constant will always evaluate as true type-punning to incomplete type might break strict-aliasing rules dereferencing type-punned pointer will break strict-aliasing rules dereferencing type-punned pointer might break strict-aliasing rules first argument of %q+D should be % second argument of %q+D should be % third argument of %q+D should probably be % %q+D takes only zero or two arguments use -flax-vector-conversions to permit conversions between vectors with differing element types or numbers of subparts conversion to %qT from boolean expression conversion to %qT from %qT may alter its value negative integer implicitly converted to unsigned type conversion of unsigned constant value to negative integer conversion to %qT alters %qT constant value conversion to %qT from %qT may change the sign of the result large integer implicitly truncated to unsigned type overflow in implicit constant conversion operation on %qE may be undefined case label does not reduce to an integer constant case label value is less than minimum value for type case label value exceeds maximum value for type lower value in case label range less than minimum value for type upper value in case label range exceeds maximum value for type GCC cannot support operators with integer types and fixed-point types that have too many integral and fractional bits together + - * max min == != <= >= < > << >> % / & | ^ /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/c-common.c invalid operands to binary %s (have %qT and %qT) Y e q % % % % % % % % % % } % % % % % % % % comparison is always false due to limited range of data type comparison is always true due to limited range of data type comparison of unsigned expression >= 0 is always true comparison of unsigned expression < 0 is always false pointer of type % used in arithmetic pointer to a function used in arithmetic pointer to member function used in arithmetic the address of %qD will always evaluate as % suggest parentheses around assignment used as truth value l d d d d d d d d d d d d d d d d d d d d d d t d d d L d d d d d d d d d d d d d d d d d d d d d d d d d & d d a d d d d d d d d d d d d d d d d d d d d d d d d d d d d d f f f f f f f f f f f f f f d d d d d d q d ; invalid use of % 5 5 5 5 5 5 5 5 # invalid application of % to a function type invalid application of %qs to a void type invalid application of %qs to incomplete type %qT %<__alignof%> applied to a bit-field __builtin_acos __builtin_acosf __builtin_acosh __builtin_acoshf __builtin_acoshl __builtin_acosl __builtin_asin __builtin_asinf __builtin_asinh __builtin_asinhf __builtin_asinhl __builtin_asinl __builtin_atan __builtin_atan2 __builtin_atan2f __builtin_atan2l __builtin_atanf __builtin_atanh __builtin_atanhf __builtin_atanhl __builtin_atanl __builtin_cbrt __builtin_cbrtf __builtin_cbrtl __builtin_ceil __builtin_ceilf __builtin_ceill __builtin_copysign __builtin_copysignf __builtin_copysignl __builtin_cos __builtin_cosf __builtin_cosh __builtin_coshf __builtin_coshl __builtin_cosl __builtin_drem __builtin_dremf __builtin_dreml __builtin_erf __builtin_erfc __builtin_erfcf __builtin_erfcl __builtin_erff __builtin_erfl __builtin_exp __builtin_exp10 __builtin_exp10f __builtin_exp10l __builtin_exp2 __builtin_exp2f __builtin_exp2l __builtin_expf __builtin_expl __builtin_expm1 __builtin_expm1f __builtin_expm1l __builtin_fabs __builtin_fabsf __builtin_fabsl __builtin_fdim __builtin_fdimf __builtin_fdiml __builtin_floor __builtin_floorf __builtin_floorl __builtin_fma __builtin_fmaf __builtin_fmal __builtin_fmax __builtin_fmaxf __builtin_fmaxl __builtin_fmin __builtin_fminf __builtin_fminl __builtin_fmod __builtin_fmodf __builtin_fmodl __builtin_frexp __builtin_frexpf __builtin_frexpl __builtin_gamma __builtin_gammaf __builtin_gammal __builtin_gamma_r __builtin_gammaf_r __builtin_gammal_r __builtin_huge_val __builtin_huge_valf __builtin_huge_vall __builtin_hypot __builtin_hypotf __builtin_hypotl __builtin_ilogb __builtin_ilogbf __builtin_ilogbl __builtin_inf __builtin_inff __builtin_infl __builtin_infd32 __builtin_infd64 __builtin_infd128 __builtin_j0 __builtin_j0f __builtin_j0l __builtin_j1 __builtin_j1f __builtin_j1l __builtin_jn __builtin_jnf __builtin_jnl __builtin_lceil __builtin_lceilf __builtin_lceill __builtin_ldexp __builtin_ldexpf __builtin_ldexpl __builtin_lfloor __builtin_lfloorf __builtin_lfloorl __builtin_lgamma __builtin_lgammaf __builtin_lgammal __builtin_lgamma_r __builtin_lgammaf_r __builtin_lgammal_r __builtin_llceil __builtin_llceilf __builtin_llceill __builtin_llfloor __builtin_llfloorf __builtin_llfloorl __builtin_llrint __builtin_llrintf __builtin_llrintl __builtin_llround __builtin_llroundf __builtin_llroundl __builtin_log __builtin_log10 __builtin_log10f __builtin_log10l __builtin_log1p __builtin_log1pf __builtin_log1pl __builtin_log2 __builtin_log2f __builtin_log2l __builtin_logb __builtin_logbf __builtin_logbl __builtin_logf __builtin_logl __builtin_lrint __builtin_lrintf __builtin_lrintl __builtin_lround __builtin_lroundf __builtin_lroundl __builtin_modf __builtin_modff __builtin_modfl __builtin_nan __builtin_nanf __builtin_nanl __builtin_nand32 __builtin_nand64 __builtin_nand128 __builtin_nans __builtin_nansf __builtin_nansl __builtin_nearbyint __builtin_nearbyintf __builtin_nearbyintl __builtin_nextafter __builtin_nextafterf __builtin_nextafterl __builtin_nexttoward __builtin_nexttowardf __builtin_nexttowardl __builtin_pow __builtin_pow10 __builtin_pow10f __builtin_pow10l __builtin_powf __builtin_powi __builtin_powif __builtin_powil __builtin_powl __builtin_remainder __builtin_remainderf __builtin_remainderl __builtin_remquo __builtin_remquof __builtin_remquol __builtin_rint __builtin_rintf __builtin_rintl __builtin_round __builtin_roundf __builtin_roundl __builtin_scalb __builtin_scalbf __builtin_scalbl __builtin_scalbln __builtin_scalblnf __builtin_scalblnl __builtin_scalbn __builtin_scalbnf __builtin_scalbnl __builtin_signbit __builtin_signbitf __builtin_signbitl __builtin_signbitd32 __builtin_signbitd64 __builtin_signbitd128 __builtin_significand __builtin_significandf __builtin_significandl __builtin_sin __builtin_sincos __builtin_sincosf __builtin_sincosl __builtin_sinf __builtin_sinh __builtin_sinhf __builtin_sinhl __builtin_sinl __builtin_sqrt __builtin_sqrtf __builtin_sqrtl __builtin_tan __builtin_tanf __builtin_tanh __builtin_tanhf __builtin_tanhl __builtin_tanl __builtin_tgamma __builtin_tgammaf __builtin_tgammal __builtin_trunc __builtin_truncf __builtin_truncl __builtin_y0 __builtin_y0f __builtin_y0l __builtin_y1 __builtin_y1f __builtin_y1l __builtin_yn __builtin_ynf __builtin_ynl __builtin_cabs __builtin_cabsf __builtin_cabsl __builtin_cacos __builtin_cacosf __builtin_cacosh __builtin_cacoshf __builtin_cacoshl __builtin_cacosl __builtin_carg __builtin_cargf __builtin_cargl __builtin_casin __builtin_casinf __builtin_casinh __builtin_casinhf __builtin_casinhl __builtin_casinl __builtin_catan __builtin_catanf __builtin_catanh __builtin_catanhf __builtin_catanhl __builtin_catanl __builtin_ccos __builtin_ccosf __builtin_ccosh __builtin_ccoshf __builtin_ccoshl __builtin_ccosl __builtin_cexp __builtin_cexpf __builtin_cexpl __builtin_cexpi __builtin_cexpif __builtin_cexpil __builtin_cimag __builtin_cimagf __builtin_cimagl __builtin_clog __builtin_clogf __builtin_clogl __builtin_clog10 __builtin_clog10f __builtin_clog10l __builtin_conj __builtin_conjf __builtin_conjl __builtin_cpow __builtin_cpowf __builtin_cpowl __builtin_cproj __builtin_cprojf __builtin_cprojl __builtin_creal __builtin_crealf __builtin_creall __builtin_csin __builtin_csinf __builtin_csinh __builtin_csinhf __builtin_csinhl __builtin_csinl __builtin_csqrt __builtin_csqrtf __builtin_csqrtl __builtin_ctan __builtin_ctanf __builtin_ctanh __builtin_ctanhf __builtin_ctanhl __builtin_ctanl __builtin_bcmp __builtin_bcopy __builtin_bzero __builtin_index __builtin_memchr __builtin_memcmp __builtin_memcpy __builtin_memmove __builtin_mempcpy __builtin_memset __builtin_rindex __builtin_stpcpy __builtin_stpncpy __builtin_strcasecmp __builtin_strcat __builtin_strchr __builtin_strcmp __builtin_strcpy __builtin_strcspn __builtin_strdup __builtin_strndup __builtin_strlen __builtin_strncasecmp __builtin_strncat __builtin_strncmp __builtin_strncpy __builtin_strpbrk __builtin_strrchr __builtin_strspn __builtin_strstr __builtin_fprintf __builtin_fprintf_unlocked __builtin_putc __builtin_putc_unlocked __builtin_fputc __builtin_fputc_unlocked __builtin_fputs __builtin_fputs_unlocked __builtin_fscanf __builtin_fwrite __builtin_fwrite_unlocked __builtin_printf __builtin_printf_unlocked __builtin_putchar __builtin_putchar_unlocked __builtin_puts __builtin_puts_unlocked __builtin_scanf __builtin_snprintf __builtin_sprintf __builtin_sscanf __builtin_vfprintf __builtin_vfscanf __builtin_vprintf __builtin_vscanf __builtin_vsnprintf __builtin_vsprintf __builtin_vsscanf __builtin_isalnum __builtin_isalpha __builtin_isascii __builtin_isblank __builtin_iscntrl __builtin_isdigit __builtin_isgraph __builtin_islower __builtin_isprint __builtin_ispunct __builtin_isspace __builtin_isupper __builtin_isxdigit __builtin_toascii __builtin_tolower __builtin_toupper __builtin_iswalnum __builtin_iswalpha __builtin_iswblank __builtin_iswcntrl __builtin_iswdigit __builtin_iswgraph __builtin_iswlower __builtin_iswprint __builtin_iswpunct __builtin_iswspace __builtin_iswupper __builtin_iswxdigit __builtin_towlower __builtin_towupper __builtin_abort __builtin_abs __builtin_aggregate_incoming_address __builtin_alloca __builtin_apply __builtin_apply_args __builtin_args_info __builtin_bswap32 __builtin_bswap64 __builtin___clear_cache __builtin_calloc __builtin_classify_type __builtin_clz __builtin_clzimax __builtin_clzl __builtin_clzll __builtin_constant_p __builtin_ctz __builtin_ctzimax __builtin_ctzl __builtin_ctzll __builtin_dcgettext __builtin_dgettext __builtin_dwarf_cfa __builtin_dwarf_sp_column __builtin_eh_return __builtin_eh_return_data_regno __builtin_execl __builtin_execlp __builtin_execle __builtin_execv __builtin_execvp __builtin_execve __builtin_exit __builtin_expect __builtin_extend_pointer __builtin_extract_return_addr __builtin_ffs __builtin_ffsimax __builtin_ffsl __builtin_ffsll __builtin_fork __builtin_frame_address __builtin_free __builtin_frob_return_addr __builtin_gettext __builtin_imaxabs __builtin_init_dwarf_reg_size_table __builtin_finite __builtin_finitef __builtin_finitel __builtin_finited32 __builtin_finited64 __builtin_finited128 __builtin_fpclassify __builtin_isfinite __builtin_isinf_sign __builtin_isinf __builtin_isinff __builtin_isinfl __builtin_isinfd32 __builtin_isinfd64 __builtin_isinfd128 __builtin_isnan __builtin_isnanf __builtin_isnanl __builtin_isnand32 __builtin_isnand64 __builtin_isnand128 __builtin_isnormal __builtin_isgreater __builtin_isgreaterequal __builtin_isless __builtin_islessequal __builtin_islessgreater __builtin_isunordered __builtin_labs __builtin_llabs __builtin_longjmp __builtin_malloc __builtin_next_arg __builtin_parity __builtin_parityimax __builtin_parityl __builtin_parityll __builtin_popcount __builtin_popcountimax __builtin_popcountl __builtin_popcountll __builtin_prefetch __builtin_realloc __builtin_return __builtin_return_address __builtin_saveregs __builtin_setjmp __builtin_strfmon __builtin_strftime __builtin_trap __builtin_unwind_init __builtin_update_setjmp_buf __builtin_va_copy __builtin_va_end __builtin_va_start __builtin_va_arg_pack __builtin_va_arg_pack_len __builtin__exit __builtin__Exit __builtin_object_size __builtin___memcpy_chk __builtin___memmove_chk __builtin___mempcpy_chk __builtin___memset_chk __builtin___stpcpy_chk __builtin___strcat_chk __builtin___strcpy_chk __builtin___strncat_chk __builtin___strncpy_chk __builtin___snprintf_chk __builtin___sprintf_chk __builtin___vsnprintf_chk __builtin___vsprintf_chk __builtin___fprintf_chk __builtin___printf_chk __builtin___vfprintf_chk __builtin___vprintf_chk __builtin_dispatch __sync_fetch_and_add __sync_fetch_and_add_1 __sync_fetch_and_add_2 __sync_fetch_and_add_4 __sync_fetch_and_add_8 __sync_fetch_and_add_16 __sync_fetch_and_sub __sync_fetch_and_sub_1 __sync_fetch_and_sub_2 __sync_fetch_and_sub_4 __sync_fetch_and_sub_8 __sync_fetch_and_sub_16 __sync_fetch_and_or __sync_fetch_and_or_1 __sync_fetch_and_or_2 __sync_fetch_and_or_4 __sync_fetch_and_or_8 __sync_fetch_and_or_16 __sync_fetch_and_and __sync_fetch_and_and_1 __sync_fetch_and_and_2 __sync_fetch_and_and_4 __sync_fetch_and_and_8 __sync_fetch_and_and_16 __sync_fetch_and_xor __sync_fetch_and_xor_1 __sync_fetch_and_xor_2 __sync_fetch_and_xor_4 __sync_fetch_and_xor_8 __sync_fetch_and_xor_16 __sync_fetch_and_nand __sync_fetch_and_nand_1 __sync_fetch_and_nand_2 __sync_fetch_and_nand_4 __sync_fetch_and_nand_8 __sync_fetch_and_nand_16 __sync_add_and_fetch __sync_add_and_fetch_1 __sync_add_and_fetch_2 __sync_add_and_fetch_4 __sync_add_and_fetch_8 __sync_add_and_fetch_16 __sync_sub_and_fetch __sync_sub_and_fetch_1 __sync_sub_and_fetch_2 __sync_sub_and_fetch_4 __sync_sub_and_fetch_8 __sync_sub_and_fetch_16 __sync_or_and_fetch __sync_or_and_fetch_1 __sync_or_and_fetch_2 __sync_or_and_fetch_4 __sync_or_and_fetch_8 __sync_or_and_fetch_16 __sync_and_and_fetch __sync_and_and_fetch_1 __sync_and_and_fetch_2 __sync_and_and_fetch_4 __sync_and_and_fetch_8 __sync_and_and_fetch_16 __sync_xor_and_fetch __sync_xor_and_fetch_1 __sync_xor_and_fetch_2 __sync_xor_and_fetch_4 __sync_xor_and_fetch_8 __sync_xor_and_fetch_16 __sync_nand_and_fetch __sync_nand_and_fetch_1 __sync_nand_and_fetch_2 __sync_nand_and_fetch_4 __sync_nand_and_fetch_8 __sync_nand_and_fetch_16 __sync_bool_compare_and_swap __sync_bool_compare_and_swap_1 __sync_bool_compare_and_swap_2 __sync_bool_compare_and_swap_4 __sync_bool_compare_and_swap_8 __sync_bool_compare_and_swap_16 __sync_val_compare_and_swap __sync_val_compare_and_swap_1 __sync_val_compare_and_swap_2 __sync_val_compare_and_swap_4 __sync_val_compare_and_swap_8 __sync_val_compare_and_swap_16 __sync_lock_test_and_set __sync_lock_test_and_set_1 __sync_lock_test_and_set_2 __sync_lock_test_and_set_4 __sync_lock_test_and_set_8 __sync_lock_test_and_set_16 __sync_lock_release __sync_lock_release_1 __sync_lock_release_2 __sync_lock_release_4 __sync_lock_release_8 __sync_lock_release_16 __sync_synchronize __builtin_omp_get_thread_num __builtin_omp_get_num_threads __builtin_GOMP_atomic_start __builtin_GOMP_atomic_end __builtin_GOMP_barrier __builtin_GOMP_taskwait __builtin_GOMP_critical_start __builtin_GOMP_critical_end __builtin_GOMP_critical_name_start __builtin_GOMP_critical_name_end __builtin_GOMP_loop_static_start __builtin_GOMP_loop_dynamic_start __builtin_GOMP_loop_guided_start __builtin_GOMP_loop_runtime_start __builtin_GOMP_loop_ordered_static_start __builtin_GOMP_loop_ordered_dynamic_start __builtin_GOMP_loop_ordered_guided_start __builtin_GOMP_loop_ordered_runtime_start __builtin_GOMP_loop_static_next __builtin_GOMP_loop_dynamic_next __builtin_GOMP_loop_guided_next __builtin_GOMP_loop_runtime_next __builtin_GOMP_loop_ordered_static_next __builtin_GOMP_loop_ordered_dynamic_next __builtin_GOMP_loop_ordered_guided_next __builtin_GOMP_loop_ordered_runtime_next __builtin_GOMP_loop_ull_static_start __builtin_GOMP_loop_ull_dynamic_start __builtin_GOMP_loop_ull_guided_start __builtin_GOMP_loop_ull_runtime_start __builtin_GOMP_loop_ull_ordered_static_start __builtin_GOMP_loop_ull_ordered_dynamic_start __builtin_GOMP_loop_ull_ordered_guided_start __builtin_GOMP_loop_ull_ordered_runtime_start __builtin_GOMP_loop_ull_static_next __builtin_GOMP_loop_ull_dynamic_next __builtin_GOMP_loop_ull_guided_next __builtin_GOMP_loop_ull_runtime_next __builtin_GOMP_loop_ull_ordered_static_next __builtin_GOMP_loop_ull_ordered_dynamic_next __builtin_GOMP_loop_ull_ordered_guided_next __builtin_GOMP_loop_ull_ordered_runtime_next __builtin_GOMP_parallel_loop_static_start __builtin_GOMP_parallel_loop_dynamic_start __builtin_GOMP_parallel_loop_guided_start __builtin_GOMP_parallel_loop_runtime_start __builtin_GOMP_loop_end __builtin_GOMP_loop_end_nowait __builtin_GOMP_ordered_start __builtin_GOMP_ordered_end __builtin_GOMP_parallel_start __builtin_GOMP_parallel_end __builtin_GOMP_task __builtin_GOMP_sections_start __builtin_GOMP_sections_next __builtin_GOMP_parallel_sections_start __builtin_GOMP_sections_end __builtin_GOMP_sections_end_nowait __builtin_GOMP_single_start __builtin_GOMP_single_copy_start __builtin_GOMP_single_copy_end long int unsigned int long unsigned int unsigned long long long int long long unsigned int long long unsigned short int short unsigned int unsigned short signed char unsigned char long double short _Fract long _Fract long long _Fract unsigned short _Fract unsigned _Fract unsigned long _Fract unsigned long long _Fract _Sat short _Fract _Sat _Fract _Sat long _Fract _Sat long long _Fract _Sat unsigned short _Fract _Sat unsigned _Fract _Sat unsigned long _Fract _Sat unsigned long long _Fract short _Accum long _Accum long long _Accum unsigned short _Accum unsigned _Accum unsigned long _Accum unsigned long long _Accum _Sat short _Accum _Sat _Accum _Sat long _Accum _Sat long long _Accum _Sat unsigned short _Accum _Sat unsigned _Accum _Sat unsigned long _Accum _Sat unsigned long long _Accum complex int complex float complex double complex long double __builtin_va_list main memcpy memset memmove memcmp abort __compound_literal %s.%lu __builtin_ cannot disable built-in function %qs pointers are not permitted as case values range expressions in switch statements are non-standard empty range specified duplicate (or overlapping) case value %Jthis is the first entry overlapping that value duplicate case value %Jpreviously used here multiple default labels in one switch %Jthis is the first default label %lu -%lu 0x%lx%08lx %Jcase value %qs not in enumerated type %Jcase value %qs not in enumerated type %qT %Hswitch missing default case %Henumeration value %qE not handled in switch taking the address of a label is non-standard __SIZE_TYPE__ __PTRDIFF_TYPE__ __WCHAR_TYPE__ __WINT_TYPE__ __INTMAX_TYPE__ __UINTMAX_TYPE__ __CHAR16_TYPE__ __CHAR32_TYPE__ printf asm_fprintf gcc_diag gcc_cdiag gcc_cxxdiag scanf strfmon strftime %qE attribute ignored for field of type %qT %qE attribute ignored %s is a version_selector function %qE attribute conflicts with attribute %s %qE attribute have effect only on public objects destructor priorities from 0 to %d are reserved for the implementation constructor priorities from 0 to %d are reserved for the implementation destructor priorities must be integers from 0 to %d inclusive constructor priorities must be integers from 0 to %d inclusive byte word pointer libgcc_cmp_return libgcc_shift_count unwind_word unknown machine mode %qs specifying vector types with __attribute__ ((mode)) is deprecated use __attribute__ ((vector_size)) instead unable to emulate %qs invalid pointer mode %qs signness of type and machine mode %qs don't match no data type for mode %qs cannot use mode %qs for enumeral types mode %qs applied to inappropriate type %Jsection attribute cannot be specified for local variables section of %q+D conflicts with previous declaration section of %q+D cannot be overridden section attribute not allowed for %q+D %Jsection attributes are not supported for this target requested alignment is not a constant requested alignment is not a power of 2 requested alignment is too large alignment may not be specified for %q+D alignment for %q+D was previously specified as %d and may not be decreased alignment for %q+D must be at least %d inline function %q+D cannot be declared weak %q+D defined both normally and as an alias alias argument not a string %Jweakref attribute must appear before alias attribute %qE attribute ignored on non-class types %qE attribute ignored because %qT is already defined visibility argument not a string %qE attribute ignored on types internal hidden visibility argument must be one of "default", "hidden", "protected" or "internal" %qD redeclared with different visibility tls_model argument not a string local-exec initial-exec local-dynamic global-dynamic tls_model argument must be one of "local-exec", "initial-exec", "local-dynamic" or "global-dynamic" %J%qE attribute applies only to functions %Jcan%'t set %qE attribute after definition alloc_size parameter outside range %qE attribute ignored for %qE invalid vector type for attribute %qE vector size not an integral multiple of component size zero vector size number of components of the vector not a power of two nonnull attribute without arguments on a non-prototype nonnull argument has invalid operand number (argument %lu) nonnull argument with out-of-range operand number (argument %lu, operand %lu) nonnull argument references non-pointer operand (argument %lu, operand %lu) nonnull argument references 'this' pointer (argument %lu, operand %lu) not enough variable arguments to fit a sentinel missing sentinel in function call null argument where non-null required (argument %lu) cleanup argument not an identifier cleanup argument not a function %qE attribute requires prototypes with named arguments %qE attribute only applies to variadic functions requested position is not an integer constant requested position is less than zero -O%ld Bad option %s to optimize attribute. Bad option %s to pragma attribute %qE attribute should be applied to a type, not a type declaration (i.e. typedef) %qE attribute downgraded to '%s' due to the unsupported lock argument Unsupported argument of 'acquired_after' attribute ignored Unsupported argument of 'acquired_before' attribute ignored %qE attribute ignored for a non-lockable %qE attribute needs at least a lock argument %qE attribute takes a single argument for a scoped lockable type The first argument of the %qE attribute must be either a boolean or an integer value Parameter position (%i) specified in %qE attribute is not valid %qE attribute needs to specified a function parameter for a scoped lockable type Unsupported argument of %qE attribute ignored %qE attribute ignored for a non-function declaration Argument of %qE attribute ignored for a locking primitive of a lockable type Argument of %qE attribute ignored for an unlock method of a lockable type %qE attribute ignored due to the unsupported argument not enough arguments to function %qE too many arguments to function %qE non-floating-point argument in call to function %qE non-floating-point arguments in call to function %qE non-const integer argument %u in call to function %qE 0 G O O O O O at end of input L u U before %s'%c' before %s'\x%x' before string constant before numeric constant before %qE before %<#pragma%> before end of line before %qs token %Hignoring return value of %qD, declared with attribute warn_unused_result %Hignoring return value of function declared with attribute warn_unused_result 7 b z 7 7 7 cannot apply % to static data member %qD cannot apply % when % is overloaded cannot apply % to a non constant address attempt to take address of bit-field structure member %qD lvalue required as left operand of assignment lvalue required as increment operand lvalue required as decrement operand lvalue required as unary %<&%> operand lvalue required in asm statement size of array is too large too few arguments to function %qE incompatible type for argument %d of %qE array subscript has type % suggest parentheses around %<+%> inside %<<<%> suggest parentheses around %<-%> inside %<<<%> suggest parentheses around %<+%> inside %<>>%> suggest parentheses around %<-%> inside %<>>%> suggest parentheses around %<&&%> within %<||%> suggest parentheses around arithmetic in operand of %<|%> suggest parentheses around comparison in operand of %<|%> suggest parentheses around operand of % or change %<|%> to %<||%> or % to %<~%> suggest parentheses around arithmetic in operand of %<^%> suggest parentheses around comparison in operand of %<^%> suggest parentheses around %<+%> in operand of %<&%> suggest parentheses around %<-%> in operand of %<&%> suggest parentheses around comparison in operand of %<&%> suggest parentheses around operand of % or change %<&%> to %<&&%> or % to %<~%> suggest parentheses around comparison in operand of %<==%> suggest parentheses around comparison in operand of % comparisons like % do not have their mathematical meaning m [ Y label %q+D defined but not used label %q+D declared but not defined division by zero comparison between types %qT and %qT comparison between signed and unsigned integer expressions promoted ~unsigned is always non-zero comparison of promoted ~unsigned with constant comparison of promoted ~unsigned with unsigned %qE is assigned to itself @W < W 1 m h k < g P+ x + g < W m record_types_used_by_current_var_decl same_scalar_type_ignoring_signedness lvalue_error fold_offsetof_1 gimple_op gimple_call_fndecl check_function_arguments_recurse handle_acquired_order_attribute handle_type_generic_attribute nonnull_check_p handle_novops_attribute c_determine_visibility handle_version_selector_attribute boolean_increment c_expand_expr def_builtin_1 set_builtin_user_assembler_name c_sizeof_or_alignof_type c_type_hash c_common_truthvalue_conversion binary_op_error format string has invalid operand number function does not return string type format string argument not a string type /tmp/gcc32/toolchain-src/gcc/gcc-4.4.3/gcc/c-format.c unrecognized format specifier %qE is an unrecognized format function type %<...%> has invalid operand number format string argument follows the args to be formatted h hh l ll q L z Z t j H D DD w ( ( ' ' flag the ' ' printf flag '+' flag the '+' printf flag '#' flag the '#' printf flag '0' flag the '0' printf flag '-' flag the '-' printf flag ''' flag the ''' printf flag 'I' flag the 'I' printf flag field width field width in printf format precision precision in printf format length modifier length modifier in printf format p y + # 0 - ' I ' w ; G p d n L + 0 - 0 p i p y + # 0 - w ; G p d n L + 0 - 0 p i 'q' flag the 'q' diagnostic flag + q ` i p d n L + # q ` i p d n L assignment suppression the assignment suppression scanf feature 'a' flag the 'a' scanf flag 'm' flag the 'm' scanf flag field width in scanf format length modifier in scanf format the ''' scanf flag the 'I' scanf flag * a m w ; ) L H ' h I { * L a m '_' flag the '_' strftime flag the '-' strftime flag the '0' strftime flag '^' flag the '^' strftime flag the '#' strftime flag field width in strftime format 'E' modifier the 'E' strftime modifier 'O' modifier the 'O' strftime modifier the 'O' modifier _ - 0 ^ # w ; E / < O V c O o } E O _ - _ 0 - 0 ^ # fill character fill character in strfmon format the '^' strfmon flag the '+' strfmon flag '(' flag the '(' strfmon flag '!' flag the '!' strfmon flag the '-' strfmon flag field width in strfmon format left precision left precision in strfmon format right precision right precision in strfmon format length modifier in strfmon format = ^ 1 + F ( [ d ! y - w ; # p L 4 + ( di signed size_t ptrdiff_t intmax_t -wp0 +'I i oxX size_t unsigned ptrdiff_t uintmax_t -wp0# u -wp0'I fgG _Decimal32 _Decimal64 _Decimal128 -wp0 +#'I eE -wp0 +#I c wint_t -w s wchar_t -wp cR p n W F aA -wp0 +# C S R m XW L `W D \W dW D \W dW $ d h l , 6 7 $ d h l : 6 C E TW L 6 O Q HW Y ] ` 8 L C b XW L `W 6 d f $ d h l , 6 h $ k 6 s E TW L 6 u Q HW Y w y 8 Y 6 -wp0 + -wp0 O I U r @ X% _% C L 6 O Y ] d% 8 6 6 w 8 6 6 f% 8 6 6 8 6 6 h% 8 6 6 j% 6 6 l% 8 6 6 ox pq JK <>' 6 . 6 6 C 6 O . ] ` 8 C 8 6 . 8 6 . 8 6 6 y 8 6 DFJKTE q+ 6 . 6 6 C 6 O . ] ` 8 C 8 6 X5 8 _5 6 . 8 6 6 y 8 6 DEFJKT 6 . 6 6 C 6 O . ] ` 8 C 8 6 < 8 _5 6 . 8 6 6 y 8 6 ADEFJKTV q+# CLOPQ 6 . 6 6 C 6 O . ] ` 8 C 8 6 C 8 D 6 D 6 . 8 6 6 y 8 6 6 6 6 6 C 6 6 O 6 ] s 8 6 6 8 6 w *w'I *w efgEG *w' *mw cW *amw [ cW[ XW L `W P d D \W dW P d D \W dW P d P $ d h l P d C Q HW P P O Q HW P P P Q HW P P ` 8 P d b XW L `W 6 d f $ d h l P d h $ P d s Q HW P d u Q HW P d ABZab ^# cx E 3 HIMSUWdmw -_0Ow o # X y EO-_0w 4 Y -_0EOw % 2 eVu FRTnrt g O-_0w 2o G kls P Y Y 6 Y Y Y Z Z 6 Z Z ` Z 6 Z Y 6 Z Z Z !Z #Z Z *Z 6 6 s #Z Z 6 ,Z .Z Z 6 2Z 6 6 9Z ;Z AZ DZ Z Z Y 6 d% Z FZ Z 6 JZ 6 6 in =^+(!-w#p g $ g 6 gnu_printf +#0-'I asm_fprintf +#0- gcc_diag gcc_tdiag gcc_cdiag gcc_cxxdiag gcc_gfc gnu_scanf *'I gnu_strftime _-0^# EO gnu_strfmon =^+(!- h h Y w p L i @ % i A w p L i . _5 @ p L i 5 _5 @ p L (i < _5 @ p L 2i D D @ p L >i @ L 6 P Fi P Pi ` w * L m Ti `Z ai gi w ji g vi ` w # p L format function might be possible candidate for %qs format attribute missing $ operand number in format ISO C++ ISO C %s does not support %%n$ operand number formats operand number out of range in format format argument %d used more than once in %s format $ operand number used after format without operand number format argument %d unused before used argument %d in $-style format format not a string literal, format string not checked format not a string literal and no format arguments format not a string literal, argument types not checked too many arguments for format unused arguments in $-style format zero-length %s format string format is a wide character string unterminated format string format_wanted_type pool embedded %<\0%> in format spurious trailing %<%%%> in format repeated %s in format missing fill character at end of strfmon format too few arguments for format zero width in %s format empty left precision in %s format field precision empty precision in %s format ISO C90 %s does not support the %qs %s length modifier conversion lacks type at end of format unknown conversion type character %qc in format unknown conversion type character 0x%x in format %s does not support the %<%%%c%> %s format %s used with %<%%%c%> %s format %s does not support %s %s does not support %s with the %<%%%c%> %s format %s ignored with %s and %<%%%c%> %s format %s ignored with %s in %s format use of %s and %s together with %<%%%c%> %s format use of %s and %s together in %s format %<%%%c%> yields only last 2 digits of year in some locales %<%%%c%> yields only last 2 digits of year no closing %<]%> for %<%%[%> format use of %qs length modifier with %qc type character %s does not support the %<%%%s%c%> %s format operand number specified with suppressed assignment operand number specified for format taking no argument writing through null pointer (argument %d) reading through null pointer (argument %d) writing into constant object (argument %d) extra type qualifiers in format argument (argument %d) %s should have type %<%s%s%>, but argument %d has type %qT format %q.*s expects type %<%s%s%>, but argument %d has type %qT %s should have type %<%T%s%>, but argument %d has type %qT format %q.*s expects type %<%T%s%>, but argument %d has type %qT __gcc_host_wide_int__ %<__gcc_host_wide_int__%> is not defined as a type %<__gcc_host_wide_int__%> is not defined as % or %