regular expression regexp.h

[gomugomuno]

ide  olarak code:blocks ve netbeans kullanıyorum.Regular expression(Düzenli İfadeler) için regexp.h başlığını kullanman gerek ancak sadece başlığı ekleyip inşa et dediğimde  aşağıdaki hatayı alıyorum.
Hatalar regexp.h başlığından kaynaklanıyor.Neden olmuş olabilir ve nasıl çözebilirim ?

Kod Seç Genişlet


-------------- Build: Debug in RegularExpression ---------------

Compiling: main.cpp
In file included from /home/alikoyuncu/Code::Blogs/RegularExpression/main.cpp:2:
/usr/include/regexp.h: In function 'char* compile(char*, char*, const char*, int)':
/usr/include/regexp.h:111: error: 'INIT' was not declared in this scope
/usr/include/regexp.h:116: error: expected ';' before 'regex_t'
/usr/include/regexp.h:128: error: 'ERROR' was not declared in this scope
/usr/include/regexp.h:130: error: '__expr_ptr' was not declared in this scope
/usr/include/regexp.h:137: error: 'GETC' was not declared in this scope
/usr/include/regexp.h:141: error: 'UNGETC' was not declared in this scope
/usr/include/regexp.h:187: error: 'RETURN' was not declared in this scope
/usr/include/regexp.h:202: error: 'ERROR' was not declared in this scope
/usr/include/regexp.h:207: error: 'RETURN' was not declared in this scope
Process terminated with status 1 (0 minutes, 0 seconds)
9 errors, 0 warnings

regex.h headerinin içi:

Kod Seç Genişlet

/* Copyright (C) 1996, 1997, 1998, 1999, 2004, 2008
   Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#ifndef _REGEXP_H
#define _REGEXP_H 1

/* The contents of this header file was first standardized in X/Open
   System Interface and Headers Issue 2, originally coming from SysV.
   In issue 4, version 2, it is marked as TO BE WITDRAWN, and it has
   been withdrawn in SUSv3.

   This code shouldn't be used in any newly written code.  It is
   included only for compatibility reasons.  Use the POSIX definition
   in <regex.h> for portable applications and a reasonable interface.  */

#include <features.h>
#include <alloca.h>
#include <regex.h>
#include <stdlib.h>
#include <string.h>

/* The implementation provided here emulates the needed functionality
   by mapping to the POSIX regular expression matcher.  The interface
   for the here included function is weird (this really is a harmless
   word).

   The user has to provide six macros before this header file can be
   included:

   INIT Declarations vor variables which can be used by the
other macros.

   GETC() Return the value of the next character in the regular
expression pattern.  Successive calls should return
successive characters.

   PEEKC() Return the value of the next character in the regular
expression pattern.  Immediately successive calls to
PEEKC() should return the same character which should
also be the next character returned by GETC().

   UNGETC(c) Cause `c' to be returned by the next call to GETC() and
PEEKC().

   RETURN(ptr) Used for normal exit of the `compile' function.  `ptr'
is a pointer to the character after the last character of
the compiled regular expression.

   ERROR(val) Used for abnormal return from `compile'.  `val' is the
error number.  The error codes are:
11 Range endpoint too large.
16 Bad number.
25 \digit out of range.
36 Illegal or missing delimiter.
41 No remembered search string.
42 \( \) imbalance.
43 Too many \(.
44 More tan two numbers given in \{ \}.
45 } expected after \.
46 First number exceeds second in \{ \}.
49 [ ] imbalance.
50 Regular expression overflow.

  */

__BEGIN_DECLS

/* Interface variables.  They contain the results of the successful
   calls to `setp' and `advance'.  */
extern char *loc1;
extern char *loc2;

/* The use of this variable in the `advance' function is not
   supported.  */
extern char *locs;


#ifndef __DO_NOT_DEFINE_COMPILE
/* Get and compile the user supplied pattern up to end of line or
   string or until EOF is seen, whatever happens first.  The result is
   placed in the buffer starting at EXPBUF and delimited by ENDBUF.

   This function cannot be defined in the libc itself since it depends
   on the macros.  */
char *
compile (char *__restrict instring, char *__restrict expbuf,
__const char *__restrict endbuf, int eof)
{
  char *__input_buffer = NULL;
  size_t __input_size = 0;
  size_t __current_size = 0;
  int __ch;
  int __error;
  INIT

  /* Align the expression buffer according to the needs for an object
     of type `regex_t'.  Then check for minimum size of the buffer for
     the compiled regular expression.  */
  regex_t *__expr_ptr;
# if defined __GNUC__ && __GNUC__ >= 2
  const size_t __req = __alignof__ (regex_t *);
# else
  /* How shall we find out?  We simply guess it and can change it is
     this really proofs to be wrong.  */
  const size_t __req = 8;
# endif
  expbuf += __req;
  expbuf -= (expbuf - ((char *) 0)) % __req;
  if (endbuf < expbuf + sizeof (regex_t))
    {
      ERROR (50);
    }
  __expr_ptr = (regex_t *) expbuf;
  /* The remaining space in the buffer can be used for the compiled
     pattern.  */
  __expr_ptr->__REPB_PREFIX (buffer) = expbuf + sizeof (regex_t);
  __expr_ptr->__REPB_PREFIX (allocated)
    = endbuf - (char *) __expr_ptr->__REPB_PREFIX (buffer);

  while ((__ch = (GETC ())) != eof)
    {
      if (__ch == '\0' || __ch == '\n')
{
  UNGETC (__ch);
  break;
}

      if (__current_size + 1 >= __input_size)
{
  size_t __new_size = __input_size ? 2 * __input_size : 128;
  char *__new_room = (char *) alloca (__new_size);
  /* See whether we can use the old buffer.  */
  if (__new_room + __new_size == __input_buffer)
    {
      __input_size += __new_size;
      __input_buffer = (char *) memcpy (__new_room, __input_buffer,
       __current_size);
    }
  else if (__input_buffer + __input_size == __new_room)
    __input_size += __new_size;
  else
    {
      __input_size = __new_size;
      __input_buffer = (char *) memcpy (__new_room, __input_buffer,
__current_size);
    }
}
      __input_buffer[__current_size++] = __ch;
    }
  if (__current_size)
    __input_buffer[__current_size++] = '\0';
  else
    __input_buffer = "";

  /* Now compile the pattern.  */
  __error = regcomp (__expr_ptr, __input_buffer, REG_NEWLINE);
  if (__error != 0)
    /* Oh well, we have to translate POSIX error codes.  */
    switch (__error)
      {
      case REG_BADPAT:
      case REG_ECOLLATE:
      case REG_ECTYPE:
      case REG_EESCAPE:
      case REG_BADRPT:
      case REG_EEND:
      case REG_ERPAREN:
      default:
/* There is no matching error code.  */
RETURN (36);
      case REG_ESUBREG:
RETURN (25);
      case REG_EBRACK:
RETURN (49);
      case REG_EPAREN:
RETURN (42);
      case REG_EBRACE:
RETURN (44);
      case REG_BADBR:
RETURN (46);
      case REG_ERANGE:
RETURN (11);
      case REG_ESPACE:
      case REG_ESIZE:
ERROR (50);
      }

  /* Everything is ok.  */
  RETURN ((char *) (__expr_ptr->__REPB_PREFIX (buffer)
    + __expr_ptr->__REPB_PREFIX (used)));
}
#endif


/* Find the next match in STRING.  The compiled regular expression is
   found in the buffer starting at EXPBUF.  `loc1' will return the
   first character matched and `loc2' points to the next unmatched
   character.  */
extern int step (__const char *__restrict __string,
__const char *__restrict __expbuf) __THROW;

/* Match the beginning of STRING with the compiled regular expression
   in EXPBUF.  If the match is successful `loc2' will contain the
   position of the first unmatched character.  */
extern int advance (__const char *__restrict __string,
    __const char *__restrict __expbuf) __THROW;


__END_DECLS

#endif /* regexp.h */

[guestwho]

    44. satırdan itibaren bu "header" dosyasını geliştirmekte olduğun programa dahil etmeden önce elle tanımlaman gereken makro fonksiyonlarına değinilmiş:

The user has to provide six macros before this header file can be
   included:

   INIT   Declarations vor variables which can be used by the   other macros.

   GETC()   Return the value of the next character in the regular expression pattern.  Successive calls should return successive characters.

   PEEKC()   Return the value of the next character in the regular expression pattern.  Immediately successive calls to PEEKC() should return the same character which should also be the next character returned by GETC().

   UNGETC(c)   Cause `c' to be returned by the next call to GETC() and PEEKC().
...

    Aldığın hatalar da bu makro fonksiyonlarının henüz tanımlanmamış olmasından kaynaklanıyor zaten. Makro fonksiyonlarıyla ilgili bir anlatım:

http://www1.gantep.edu.tr/~bingul/c/index.php?ders=20

[gomugomuno]

makro fonksiyonları biliyorum ancak INIT ne diye tanımlayacağım.Ornek #define pi 3.14 dersin ancak #define INIT ? ne dieceğim..

[guestwho]

    "INIT" (adından da anlaşıldığı üzere) diğer makro fonksiyonlar tarafından kullanılacak olan değişken ön tanımlamalarını yapmanı sağlıyor. Sözgelimi:

Kod Seç Genişlet

#define INIT    char *sp = instring;
#define GETC()    (*sp++)
#define PEEKC()    (*sp)
#define UNGETC(c)    (--sp)

[gomugomuno]

Şimdide regexp.h başlığı içinde;

Kod Seç Genişlet

   __expr_ptr->__REPB_PREFIX (buffer) = expbuf + sizeof (regex_t);
satırında  /usr/include/regexp.h:133: error: invalid conversion from 'char*' to 'unsigned char*' hatasını veriyor.
Kütüphaneleri kullanmak bu kadar zor mu ubuntuda

[guestwho]

    Ne tür bir uygulama geliştirdiğini söylersen, ona göre düzenli ifadeler kütüphanesinden daha basit bir kütüphane önerisinde bulunabilirim.

[Erdem]

C++ kullanıyorsan Boost.Regex kütüphanesini tavsiye edebilirim.

Bir de kaynak kodu göremediğimiz için yorum yapmak güç 

[gomugomuno]

Belli bir uygulama değil aslında  sadece düzenli ifadeleri öğrenmek istiyorum , kütüphane hata vermeseydi bir uygulama düşünürdüm ancak olmadı kütüphane . Evet c++ kullanıyorum boost.regex e bakayım.

[guestwho]

    Amacın düzenli ifadeleri öğrenmekse, "Boost.Regex" kütüphanesine alternatif olarak Perl ile uyumlu "libpcre" kütüphanesine de göz atabilirsin.

[gomugomuno]

Bu kuphanenin kullanimini anlatan turkce kaynak yok mu ?(

[Erdem]

Hiç zannetmiyorum. Hatta diyebilirim ki ingilizce C++ öğrenmek için olmazsa olmazlardan biri maalesef  Burada tavsiye edilen C++ kitaplarının bir listesi var:

http://accu.org/index.php?module=bookreviews&func=search

Buradaki listeden hiç Türkçeye çevrilen var mı bilmiyorum.  Bu arada o listedeki kitapların 3-4 tanesini ve daha başka Türkçe çeviri C++ kitapları okumama rağmen hala C++ biliyorum diyemiyorum  Ama şunu söyleyebilirim ki o listenin çok tavsiye edilen -- highly recommended --  kısmından İngilizce bir C++ kitabı seçip okumaya başladığım zaman, Türkçe yazılmış ve çeviri bazı kitapların ne kadar yetersiz, hatalarla dolu olduğunu (C gibi C++ öğretmeye çalışan kitaplar vs..) görebildim.  Bu arada C++ öğrenmenin bir sonu yok

Boost'un graph kütüphanesini oyunlarda yapay zeka anlatan bir kitabı okurken kullanmıştım. Regex'i hiç kullanmadım. Hatta diyebilirim ki düzenli ifadeler sadece Lua öğrenirken karşıma çıkmıştı ve biraz karışık gelmişti 

[gomugomuno]

Sadece c++ için değil bilişim için ,bilim için ingilizce artık referans dil olmuş. C++ kendimce biraz biliyorum ancak benim sizden istediğim bu kütüphaneyi nasıl kullanacağım.

[guestwho]

    Şuradaki örnek uygulamalara göz atabilirsin:

http://www.boost.org/doc/libs/1_46_1/libs/regex/doc/html/boost_regex/background_information/examples.html

[Erdem]

Hımm aslında şunu ilave etmeyi unuttum sanırım. 1,5 senedir C++'yle uğraşmıyorum. Artık D öğrenmeye başladım 

Ayrıca gene de kıyısından köşesinden biraz kullanmışım sanırsam:

http://forum.ceviz.net/c-c/27568-gcc-boost-derleme-secenekleri.html
http://forum.ceviz.net/c-c/13803-boost-regex-kutuphanesi.html

(Bu arada ceviz'in c++ forumları gerçekten iyidir)

Boost örneklerini derlerken g++ dosya.cpp -o dosya -I /usr/include/boost şeklinde derlemek yeterli olur sanırım.

http://www.boost.org/doc/libs/1_33_1/libs/regex/doc/examples.html

Burada da boost'un kendi örnekleri var.

Bir de düzenli ifadeler D içinde kütüphane olanağı olarak var. D gerçekten yazımı güzel, güçlü bir sistem programlama dili. Aslında C++0x'i (C++'nin yeni standardı) çok yakından takip ettiğimi söyleyemem. Ama duyduğum kadarıyla pek heyecan verici yenilik getirmiyormuş. Ama D gerçekten çok yenilik getiren ve gelecek vadeden bir dil. Geliştiricileri arasında C++'nin şablon sihirbazı Andrei Alexandrescu da var. Örneğin Digital Mars'ın Google Summer of Code için düşündüğü projeler:

http://prowiki.org/wiki4d/wiki.cgi?GSOC_2011_Ideas

Benim tavsiyem D diline de bir denemenizdir. İkincisi şöyle bir avantajınız var. En basit seviyesinde temel seviyede Türkçe bir D programlama dili ile ilgili Türkçe bir kitap var. Bu kitap silikon vadisinde yazılım mühendisi olarak çalışan Ali Çehreli isimli bir arkadaş tarafından yazılıyor ve kullanıcı katkıları ile gelişiyor. D konusunda gene Andrei Alexandrescu'nun bir kitabı var ben sipariş ettim ama henüz elime ulaşmadı. Yalnız Amazon'dan incelediğim kadarıyla orta düzey bir kitap. Ama Türkçe olan kitap başlangıç seviyesi ve konuları gayet güzel anlatıyor bu bence büyük bir avantaj 

Benim uzak kaldığım süre içerisinde bu kitabı okuyan arkadaşlar çok ilginç projeler geliştirmişler. Deniz isimli bir veritabanı, Turna isimli bir web arayüzü (web framework) ve daha başka projeler.. Ben de sıfırdan ucundan kıyısından onlara yetişmeye çalışıyorum 

http://ddili.org