[Cflowd] building arts on hpux 11i

From: Alexander Serkin (als@cell.ru)
Date: Mon Jan 20 2003 - 03:49:51 PST

  • Next message: Mathias Gärtner: "[Cflowd] ARTS question"

    I'm building arts++-1-1-a2 on hpux 11i
    with egcs 1.1.2. Everything goes fine except artsdump.
    The following error makes my life difficult:

    gmake[2]: Entering directory `/usr/local/src/arts++-1-1-a2/apps/artsdump'
    c++ -g -O2 -c artsdump.cc -I../../classes/include
    In file included from /opt/egcs/include/g++/std/bastring.h:36,
                      from /opt/egcs/include/g++/string:6,
                      from artsdump.cc:47:
    /opt/egcs/include/g++/std/straits.h:59: type specifier omitted for parameter
    /opt/egcs/include/g++/std/straits.h:59: parse error before `)'
    /opt/egcs/include/g++/std/straits.h:69: parse error before `('
    /opt/egcs/include/g++/std/straits.h: In function `static int
    string_char_traits<charT>::compare(...)':
    /opt/egcs/include/g++/std/straits.h:61: parse error before `;'
    /opt/egcs/include/g++/std/straits.h: At top level:
    /opt/egcs/include/g++/std/straits.h:77: syntax error before `*'
    /opt/egcs/include/g++/std/straits.h:77: `char_type' was not declared in
    this scope
    /opt/egcs/include/g++/std/straits.h:77: `s1' was not declared in this scope
    /opt/egcs/include/g++/std/straits.h:77: parse error before `*'
    /opt/egcs/include/g++/std/straits.h: In function `int * copy(...)':
    /opt/egcs/include/g++/std/straits.h:79: `n' undeclared (first use this
    function)
    /opt/egcs/include/g++/std/straits.h:79: (Each undeclared identifier is
    reported only once
    /opt/egcs/include/g++/std/straits.h:79: for each function it appears in.)
    /opt/egcs/include/g++/std/straits.h:80: `s1' undeclared (first use this
    function)
    /opt/egcs/include/g++/std/straits.h:80: confused by earlier errors,
    bailing out
    gmake[2]: *** [artsdump.o] Error 1

    could anybody help me to find what is wrong?
    I've attached the file:
    /opt/egcs/include/g++/std/straits.h

    -- 
    Alexander
    

    // Character traits template for the -*- C++ -*- string classes.
    // Copyright (C) 1994 Free Software Foundation

    // This file is part of the GNU ANSI C++ Library. This library is free
    // software; you can redistribute it and/or modify it under the
    // terms of the GNU General Public License as published by the
    // Free Software Foundation; either version 2, or (at your option)
    // any later version.

    // This library is distributed in the hope that it will be useful,
    // but WITHOUT ANY WARRANTY; without even the implied warranty of
    // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    // GNU General Public License for more details.

    // You should have received a copy of the GNU General Public License
    // along with this library; see the file COPYING. If not, write to the Free
    // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

    // As a special exception, if you link this library with files
    // compiled with a GNU compiler to produce an executable, this does not cause
    // the resulting executable to be covered by the GNU General Public License.
    // This exception does not however invalidate any other reasons why
    // the executable file might be covered by the GNU General Public License.

    // Written by Jason Merrill based upon the specification by Takanori Adachi
    // in ANSI X3J16/94-0013R2.

    #ifndef __STRING_CHAR_TRAITS__
    #define __STRING_CHAR_TRAITS__

    #ifdef __GNUG__
    // For string_char_traits <char>
    #pragma interface "std/straits.h"
    #endif

    #include <cstddef>

    extern "C++" {
    template <class charT>
    struct string_char_traits {
      typedef charT char_type; // for users to acquire the basic character type

      // constraints

      static void assign (char_type& c1, const char_type& c2)
        { c1 = c2; }
      static bool eq (const char_type& c1, const char_type& c2)
        { return (c1 == c2); }
      static bool ne (const char_type& c1, const char_type& c2)
        { return !(c1 == c2); }
      static bool lt (const char_type& c1, const char_type& c2)
        { return (c1 < c2); }
      static char_type eos () { return char_type(); } // the null character
      static bool is_del(char_type a) { return 0; }
      // characteristic function for delimiters of charT
      
      // speed-up functions

      static int compare (const char_type* s1, const char_type* s2, size_t n)
        {
          size_t i;
          for (i = 0; i < n; ++i)
            if (ne (s1[i], s2[i]))
              return lt (s1[i], s2[i]) ? -1 : 1;

          return 0;
        }
        
      static int size_t length (const char_type* s)
        {
          size_t l = 0;
          while (ne (*s++, eos ()))
            ++l;
          return l;
        }

      static char_type* copy (char_type* s1, const char_type* s2, size_t n)
        {
          for (; n--; )
            assign (s1[n], s2[n]);
          return s1;
        }

      static char_type* move (char_type* s1, const char_type* s2, size_t n)
        {
          char_type a[n];
          size_t i;
          for (i = 0; i < n; ++i)
            assign (a[i], s2[i]);
          for (i = 0; i < n; ++i)
            assign (s1[i], a[i]);
          return s1;
        }

      static char_type* set (char_type* s1, const char_type& c, size_t n)
        {
          for (; n--; )
            assign (s1[n], c);
          return s1;
        }
    };

    class istream;
    class ostream;
    #include <cctype>
    #include <cstring>

    struct string_char_traits <char> {
      typedef char char_type;

      static void assign (char_type& c1, const char_type& c2)
        { c1 = c2; }
      static bool eq (const char_type & c1, const char_type& c2)
        { return (c1 == c2); }
      static bool ne (const char_type& c1, const char_type& c2)
        { return (c1 != c2); }
      static bool lt (const char_type& c1, const char_type& c2)
        { return (c1 < c2); }
      static char_type eos () { return 0; }
      static bool is_del(char_type a) { return isspace(a); }

      static int compare (const char_type* s1, const char_type* s2, size_t n)
        { return memcmp (s1, s2, n); }
      static size_t length (const char_type* s)
        { return strlen (s); }
      static char_type* copy (char_type* s1, const char_type* s2, size_t n)
        { return (char_type*) memcpy (s1, s2, n); }
      static char_type* move (char_type* s1, const char_type* s2, size_t n)
        { return (char_type*) memmove (s1, s2, n); }
      static char_type* set (char_type* s1, const char_type& c, size_t n)
        { return (char_type*) memset (s1, c, n); }
    };

    #if 0
    #include <cwctype>
    struct string_char_traits <wchar_t> {
      typedef wchar_t char_type;

      static void assign (char_type& c1, const char_type& c2)
        { c1 = c2; }
      static bool eq (const char_type & c1, const char_type& c2)
        { return (c1 == c2); }
      static bool ne (const char_type& c1, const char_type& c2)
        { return (c1 != c2); }
      static bool lt (const char_type& c1, const char_type& c2)
        { return (c1 < c2); }
      static char_type eos () { return 0; }
      static bool is_del(char_type a) { return iswspace(a); }

      static int compare (const char_type* s1, const char_type* s2, size_t n)
        { return wmemcmp (s1, s2, n); }
      static size_t length (const char_type* s)
        { return wcslen (s); }
      static char_type* copy (char_type* s1, const char_type* s2, size_t n)
        { return wmemcpy (s1, s2, n); }
      static char_type* set (char_type* s1, const char_type& c, size_t n)
        { return wmemset (s1, c, n); }
    };
    #endif
    } // extern "C++"
    #endif

    _______________________________________________
    Cflowd mailing list
    Cflowd@caida.org
    http://login.caida.org/mailman/listinfo/cflowd



    This archive was generated by hypermail 2.1.4 : Mon Jan 20 2003 - 04:00:02 PST