Update of /cvsroot/fink/experimental/beren12/finkinfo/utils
In directory usw-pr-cvs1:/tmp/cvs-serv32168
Modified Files:
menu-2.1.5-1.info menu-2.1.5-1.patch
Log Message:
almost there...need to adapt regex stuff :-/
Index: menu-2.1.5-1.info
===================================================================
RCS file: /cvsroot/fink/experimental/beren12/finkinfo/utils/menu-2.1.5-1.info,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- menu-2.1.5-1.info 20 Aug 2002 20:56:19 -0000 1.2
+++ menu-2.1.5-1.info 28 Oct 2002 16:49:05 -0000 1.3
@@ -1,12 +1,13 @@
Package: menu
Version: 2.1.5
Revision: 1
-Source: mirror:debian:pool/main/m/%n/%n_2.1.5-10.2.tar.gz
-SourceRename: %n-%v.tar.gz
+Source: mirror:debian:pool/main/m/%n/%n_2.1.5-14.tar.gz
+SourceRename: %n-%v-14.tar.gz
SourceDirectory: %n-%v
-Source-MD5: 708f19c5941d23d8ee13d8fea3c10e99
+Source-MD5: d73de79a98b47165f1908131ff5d88ae
Patch: %f.patch
Conflicts: pdmenu (<=0.5.9)
+SetLIBS: -lintl
ConfigureParams: --mandir='${prefix}/share/man'
DocFiles: COPYING README AUTHORS ChangeLog NEWS
Description: Provides update-menus functions for some applications
Index: menu-2.1.5-1.patch
===================================================================
RCS file: /cvsroot/fink/experimental/beren12/finkinfo/utils/menu-2.1.5-1.patch,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- menu-2.1.5-1.patch 20 Aug 2002 21:13:05 -0000 1.2
+++ menu-2.1.5-1.patch 28 Oct 2002 16:49:05 -0000 1.3
@@ -1,211 +1,23 @@
-diff -ruN menu-2.1.5/install-menu/hints.cc menu-2.1.5.new/install-menu/hints.cc
---- menu-2.1.5/install-menu/hints.cc Mon Jul 5 16:12:49 1999
-+++ menu-2.1.5.new/install-menu/hints.cc Tue Aug 20 16:45:11 2002
-@@ -124,8 +124,8 @@
- // raw_input_count[i]: records frequency of hint_input[i].
-
- unsigned int i,j;
-- vector <const StrVec>::iterator k;
-- cStrVec::iterator m,l;
-+ vector <StrVec>::const_iterator k;
-+ StrVec::const_iterator m,l;
- map <String, int, less<String> >::iterator hi;
- multimap <int, String, more<int> > fh;
- multimap <int, String, more<int> >::iterator fhi;
-@@ -253,7 +253,7 @@
- }
- }
- ostream& operator<<(ostream &o, const StrVec &s){
-- vector <const String>::iterator i;
-+ vector <String>::const_iterator i;
-
- for(i=s.begin(); i!=s.end(); i++)
- o<<"["<<(*i)<<"]";
-@@ -293,7 +293,7 @@
- void hints::calc_tree(const vector <StrVec > &hint_input,
- vector <StrVec > &hint_output){
-
-- vector <const vector<String> >::iterator i;
-+ vector <vector<String> >::const_iterator i;
-
- raw_count=vector <int> (hint_input.size(), 1);
- hint_list=hint_input;
-@@ -395,7 +395,7 @@
- d.push_back(t);
- }
- if(debugopt){
-- vector<const unsigned int>::iterator j;
-+ vector<unsigned int>::const_iterator j;
- DEBUGGING(cout<<"itt="<<itteration<<" ";)
- cout<<"Adding Division h, p="<<penalty<<" dl.s()= "
- <<division_list.size()<<", h=";
-@@ -545,7 +545,7 @@
- int already_used){
- //try with heuristics to reduce the thinking time
- int raw_total;
-- vector <const int>::iterator i;
-+ vector <int>::const_iterator i;
-
- raw_total=0;
- for(i=raw_input_count.begin(); i!=raw_input_count.end(); i++)
-@@ -648,10 +648,10 @@
- // to (recursively) make a tree from that.
- for(j=0; j<hint_input.size(); j++)
- if(!stored[j]){
-- cStrVec::iterator
-+ StrVec::const_iterator
- b=hint_input[j].begin(),
- e=hint_input[j].end(),
-- f=NULL;
-+ f=e;
- f=find(b, e, key);
- if(f!=e){
- StrVec tmphint;
-@@ -696,7 +696,7 @@
- void hints::search_hint(hint_tree &t,
- const StrVec &hint_in,
- StrVec &hint_out){
-- vector <const String>::iterator j, e,b;
-+ vector <String>::const_iterator j, e,b;
- vector <hint_tree>::iterator c;
- DEBUGGING(bool found=false;)
-
-diff -ruN menu-2.1.5/install-menu/hints.h menu-2.1.5.new/install-menu/hints.h
---- menu-2.1.5/install-menu/hints.h Thu Oct 7 16:50:05 1999
-+++ menu-2.1.5.new/install-menu/hints.h Tue Aug 20 16:45:11 2002
-@@ -15,6 +15,8 @@
- #define DEBUGGING(a) a
- #define CDEBUGGING(a) ,a
-
-+using std::set;
-+using std::map;
-
- extern bool operator< (const set<String> &left,
- const set<String> &right);
-diff -ruN menu-2.1.5/install-menu/menu-tree.cc
menu-2.1.5.new/install-menu/menu-tree.cc
---- menu-2.1.5/install-menu/menu-tree.cc Fri Jul 28 17:53:45 2000
-+++ menu-2.1.5.new/install-menu/menu-tree.cc Tue Aug 20 16:45:11 2002
-@@ -5,8 +5,10 @@
- #include <list>
- #include <set>
-
-+using namespace std;
-+
- bool operator< (const StrVec &left, const StrVec &right){
-- cStrVec::iterator i,j;
-+ StrVec::const_iterator i,j;
-
- for(i=left.begin(), j=right.begin();
- (i!=left.end()) && (j!=right.end());
-@@ -43,7 +45,7 @@
- map <String, String, less<String> >::iterator vj;
- StrVec subs;
- StrVec firstsec;
-- cStrVec::iterator i;
-+ StrVec::iterator i;
- bool use_forced=false;
-
- //there are two ways to store the menuentries in the `tree'
-@@ -121,7 +123,7 @@
- menuentry *m){
- submenu_container::iterator f;
- StrVec subs,firstsec;
-- cStrVec::iterator i;
-+ StrVec::iterator i;
-
- if(s.size()>1){
- for(i=s.begin()+1;i!=s.end(); i++)
-@@ -207,7 +209,7 @@
- that one.
- */
- submenu_container::iterator i,j;
-- cStrVec::iterator k;
-+ StrVec::iterator k;
- unsigned int l;
-
- // Make sure menuhints are empty:
-@@ -239,8 +241,8 @@
-
- void menuentry::process_hints(const StrVec &pref){
- vector <StrVec> hint_list, hint_out;
-- vector <const StrVec>::iterator k,m;
-- cStrVec::iterator l;
-+ vector <StrVec>::iterator k,m;
-+ StrVec::const_iterator l;
- submenu_container::iterator i;
- submenu_container oldsubmenus;
- hints h;
-@@ -249,7 +251,7 @@
- for(i=submenus.begin(); i!=submenus.end(); i++){
- if(((*i).second->vars[COMMAND_VAR]).size()==0){
- StrVec v(pref);
-- cStrVec::iterator j;
-+ StrVec::const_iterator j;
- for(j=(*i).first.begin(); j!=(*i).first.end(); j++)
- v.push_back((*j));
- (*i).second->process_hints(v);
-@@ -325,7 +327,7 @@
- i!=submenus.end();
- index++){
- String title;
-- cStrVec::iterator j;
-+ StrVec::const_iterator j;
-
- i_next=i;
- i_next++;
-diff -ruN menu-2.1.5/update-menus/adstring.cc menu-2.1.5.new/update-menus/adstring.cc
---- menu-2.1.5/update-menus/adstring.cc Mon Apr 3 06:18:52 2000
-+++ menu-2.1.5.new/update-menus/adstring.cc Tue Aug 20 16:45:11 2002
-@@ -251,7 +251,7 @@
- if(pos){
- pos--;
- // buffer.at(pos,1)=String(c);
-- buffer.replace(pos,1,c);
-+ buffer.replace(pos,1,1,c);
- } else
- buffer=c+buffer;
-
-@@ -524,7 +524,7 @@
- string::size_type i;
- for(i=0;i!=s.length();i++)
- if(s[i]==match)
-- s.replace(i,i+1,replace);
-+ s.replace(i,i+1,1,replace);
- return s;
- }
- String sort_hotkey(String str){
-diff -ruN menu-2.1.5/update-menus/adstring.h menu-2.1.5.new/update-menus/adstring.h
---- menu-2.1.5/update-menus/adstring.h Fri Jul 28 17:54:15 2000
-+++ menu-2.1.5.new/update-menus/adstring.h Tue Aug 20 16:45:11 2002
-@@ -19,6 +19,7 @@
-
- #define MAX_LINE 10240
-
-+using std::string;
-
- // ************* String.h replacement code:
- class Regex;
diff -ruN menu-2.1.5/update-menus/lprocbuf.cc menu-2.1.5.new/update-menus/lprocbuf.cc
--- menu-2.1.5/update-menus/lprocbuf.cc Wed Dec 31 19:00:00 1969
-+++ menu-2.1.5.new/update-menus/lprocbuf.cc Tue Aug 20 16:45:11 2002
-@@ -0,0 +1,13 @@
++++ menu-2.1.5.new/update-menus/lprocbuf.cc Mon Oct 28 11:09:59 2002
+@@ -0,0 +1,12 @@
+#include "lprocbuf.h"
+#include <stdio.h>
+
+lprocbuf::lprocbuf(const char *command, std::ios::openmode mode)
-+ : std::filebuf((fp = popen(command, (mode & std::ios::in) ? "r" : "w")), mode)
++ : std::filebuf((fp = popen(command, (mode & std::ios::in) ? "r" : "w"))$
+{
+}
+
+void lprocbuf::close()
-+{
-+ pclose(fp);
++{
++ pclose(fp);
+}
-+
diff -ruN menu-2.1.5/update-menus/lprocbuf.h menu-2.1.5.new/update-menus/lprocbuf.h
--- menu-2.1.5/update-menus/lprocbuf.h Wed Dec 31 19:00:00 1969
-+++ menu-2.1.5.new/update-menus/lprocbuf.h Tue Aug 20 16:45:11 2002
-@@ -0,0 +1,20 @@
++++ menu-2.1.5.new/update-menus/lprocbuf.h Mon Oct 28 11:12:02 2002
+@@ -0,0 +1,21 @@
+#ifndef _LPROCBUF_H
+#define _LPROCBUF_H
+
@@ -223,12 +35,13 @@
+ void close();
+ virtual ~lprocbuf() { close(); }
+};
++
+} // extern "C++"
+
+#endif /* !_LPROCBUF_H */
diff -ruN menu-2.1.5/update-menus/procbuf.h menu-2.1.5.new/update-menus/procbuf.h
--- menu-2.1.5/update-menus/procbuf.h Wed Dec 31 19:00:00 1969
-+++ menu-2.1.5.new/update-menus/procbuf.h Tue Aug 20 16:45:11 2002
++++ menu-2.1.5.new/update-menus/procbuf.h Mon Oct 28 11:13:10 2002
@@ -0,0 +1,14 @@
+#ifndef MENU_PROCBUF_H
+#define MENU_PROCBUF_H
@@ -237,91 +50,592 @@
+
+class procbuf : public std::streambuf {
+public:
-+ void open(const char *, ios::openmode);
-+ void close();
++ void open(const char *, ios::openmode);
++ void close();
++
++
++};
++
++#endif
+diff -ruN menu-2.1.5/update-menus/regex.h menu-2.1.5.new/update-menus/regex.h
+--- menu-2.1.5/update-menus/regex.h Wed Dec 31 19:00:00 1969
++++ menu-2.1.5.new/update-menus/regex.h Mon Oct 28 11:29:36 2002
+@@ -0,0 +1,565 @@
++/* Definitions for data structures and routines for the regular
++ expression library, version 0.12.
++ Copyright (C) 1985,1989-1993,1995-1998, 2000 Free Software Foundation, Inc.
++ This file is part of the GNU C Library. Its master source is NOT part of
++ the C library, however. The master source lives in /gd/gnu/lib.
++
++ 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 _REGEX_H
++#define _REGEX_H 1
++
++/* Allow the use in C++ code. */
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/* POSIX says that <sys/types.h> must be included (by the caller) before
++ <regex.h>. */
++
++#if !defined _POSIX_C_SOURCE && !defined _POSIX_SOURCE && defined VMS
++/* VMS doesn't have `size_t' in <sys/types.h>, even though POSIX says it
++ should be there. */
++# include <stddef.h>
++#endif
++
++/* The following two types have to be signed and unsigned integer type
++ wide enough to hold a value of a pointer. For most ANSI compilers
++ ptrdiff_t and size_t should be likely OK. Still size of these two
++ types is 2 for Microsoft C. Ugh... */
++typedef long int s_reg_t;
++typedef unsigned long int active_reg_t;
++
++/* The following bits are used to determine the regexp syntax we
++ recognize. The set/not-set meanings are chosen so that Emacs syntax
++ remains the value 0. The bits are given in alphabetical order, and
++ the definitions shifted by one from the previous bit; thus, when we
++ add or remove a bit, only one other definition need change. */
++typedef unsigned long int reg_syntax_t;
++
++/* If this bit is not set, then \ inside a bracket expression is literal.
++ If set, then such a \ quotes the following character. */
++#define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1)
++
++/* If this bit is not set, then + and ? are operators, and \+ and \? are
++ literals.
++ If set, then \+ and \? are operators and + and ? are literals. */
++#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)
++
++/* If this bit is set, then character classes are supported. They are:
++ [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:],
++ [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
++ If not set, then character classes are not supported. */
++#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)
++
++/* If this bit is set, then ^ and $ are always anchors (outside bracket
++ expressions, of course).
++ If this bit is not set, then it depends:
++ ^ is an anchor if it is at the beginning of a regular
++ expression or after an open-group or an alternation operator;
++ $ is an anchor if it is at the end of a regular expression, or
++ before a close-group or an alternation operator.
++
++ This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
++ POSIX draft 11.2 says that * etc. in leading positions is undefined.
++ We already implemented a previous draft which made those constructs
++ invalid, though, so we haven't changed the code back. */
++#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)
++
++/* If this bit is set, then special characters are always special
++ regardless of where they are in the pattern.
++ If this bit is not set, then special characters are special only in
++ some contexts; otherwise they are ordinary. Specifically,
++ * + ? and intervals are only special when not after the beginning,
++ open-group, or alternation operator. */
++#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)
++
++/* If this bit is set, then *, +, ?, and { cannot be first in an re or
++ immediately after an alternation or begin-group operator. */
++#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)
++
++/* If this bit is set, then . matches newline.
++ If not set, then it doesn't. */
++#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)
++
++/* If this bit is set, then . doesn't match NUL.
++ If not set, then it does. */
++#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)
++
++/* If this bit is set, nonmatching lists [^...] do not match newline.
++ If not set, they do. */
++#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)
++
++/* If this bit is set, either \{...\} or {...} defines an
++ interval, depending on RE_NO_BK_BRACES.
++ If not set, \{, \}, {, and } are literals. */
++#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)
++
++/* If this bit is set, +, ? and | aren't recognized as operators.
++ If not set, they are. */
++#define RE_LIMITED_OPS (RE_INTERVALS << 1)
++
++/* If this bit is set, newline is an alternation operator.
++ If not set, newline is literal. */
++#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)
++
++/* If this bit is set, then `{...}' defines an interval, and \{ and \}
++ are literals.
++ If not set, then `\{...\}' defines an interval. */
++#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)
++
++/* If this bit is set, (...) defines a group, and \( and \) are literals.
++ If not set, \(...\) defines a group, and ( and ) are literals. */
++#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)
++
++/* If this bit is set, then \<digit> matches <digit>.
++ If not set, then \<digit> is a back-reference. */
++#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)
++
++/* If this bit is set, then | is an alternation operator, and \| is literal.
++ If not set, then \| is an alternation operator, and | is literal. */
++#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)
++
++/* If this bit is set, then an ending range point collating higher
++ than the starting range point, as in [z-a], is invalid.
++ If not set, then when ending range point collates higher than the
++ starting range point, the range is ignored. */
++#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)
++
++/* If this bit is set, then an unmatched ) is ordinary.
++ If not set, then an unmatched ) is invalid. */
++#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)
++
++/* If this bit is set, succeed as soon as we match the whole pattern,
++ without further backtracking. */
++#define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1)
++
++/* If this bit is set, do not process the GNU regex operators.
++ If not set, then the GNU regex operators are recognized. */
++#define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1)
++
++/* If this bit is set, turn on internal regex debugging.
++ If not set, and debugging was on, turn it off.
++ This only works if regex.c is compiled -DDEBUG.
++ We define this bit always, so that all that's needed to turn on
++ debugging is to recompile regex.c; the calling code can always have
++ this bit set, and it won't affect anything in the normal case. */
++#define RE_DEBUG (RE_NO_GNU_OPS << 1)
++
++/* If this bit is set, a syntactically invalid interval is treated as
++ a string of ordinary characters. For example, the ERE 'a{1' is
++ treated as 'a\{1'. */
++#define RE_INVALID_INTERVAL_ORD (RE_DEBUG << 1)
++
++/* This global variable defines the particular regexp syntax to use (for
++ some interfaces). When a regexp is compiled, the syntax used is
++ stored in the pattern buffer, so changing this does not affect
++ already-compiled regexps. */
++extern reg_syntax_t re_syntax_options;
++
++/* Define combinations of the above bits for the standard possibilities.
++ (The [[[ comments delimit what gets put into the Texinfo file, so
++ don't delete them!) */
++/* [[[begin syntaxes]]] */
++#define RE_SYNTAX_EMACS 0
++
++#define RE_SYNTAX_AWK \
++ (RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \
++ | RE_NO_BK_PARENS | RE_NO_BK_REFS \
++ | RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \
++ | RE_DOT_NEWLINE | RE_CONTEXT_INDEP_ANCHORS \
++ | RE_UNMATCHED_RIGHT_PAREN_ORD | RE_NO_GNU_OPS)
++
++#define RE_SYNTAX_GNU_AWK \
++ ((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DEBUG) \
++ & ~(RE_DOT_NOT_NULL | RE_INTERVALS | RE_CONTEXT_INDEP_OPS))
++
++#define RE_SYNTAX_POSIX_AWK \
++ (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS \
++ | RE_INTERVALS | RE_NO_GNU_OPS)
++
++#define RE_SYNTAX_GREP \
++ (RE_BK_PLUS_QM | RE_CHAR_CLASSES \
++ | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \
++ | RE_NEWLINE_ALT)
++
++#define RE_SYNTAX_EGREP \
++ (RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \
++ | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \
++ | RE_NEWLINE_ALT | RE_NO_BK_PARENS \
++ | RE_NO_BK_VBAR)
++
++#define RE_SYNTAX_POSIX_EGREP \
++ (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES \
++ | RE_INVALID_INTERVAL_ORD)
++
++/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */
++#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC
++
++#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC
++
++/* Syntax bits common to both basic and extended POSIX regex syntax. */
++#define _RE_SYNTAX_POSIX_COMMON \
++ (RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \
++ | RE_INTERVALS | RE_NO_EMPTY_RANGES)
++
++#define RE_SYNTAX_POSIX_BASIC \
++ (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM)
++
++/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes
++ RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this
++ isn't minimal, since other operators, such as \`, aren't disabled. */
++#define RE_SYNTAX_POSIX_MINIMAL_BASIC \
++ (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS)
++
++#define RE_SYNTAX_POSIX_EXTENDED \
++ (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \
++ | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \
++ | RE_NO_BK_PARENS | RE_NO_BK_VBAR \
++ | RE_CONTEXT_INVALID_OPS | RE_UNMATCHED_RIGHT_PAREN_ORD)
++
++/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INDEP_OPS is
++ removed and RE_NO_BK_REFS is added. */
++#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \
++ (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \
++ | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \
++ | RE_NO_BK_PARENS | RE_NO_BK_REFS \
++ | RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD)
++/* [[[end syntaxes]]] */
++
++/* Maximum number of duplicates an interval can allow. Some systems
++ (erroneously) define this in other header files, but we want our
++ value, so remove any previous define. */
++#ifdef RE_DUP_MAX
++# undef RE_DUP_MAX
++#endif
++/* If sizeof(int) == 2, then ((1 << 15) - 1) overflows. */
++#define RE_DUP_MAX (0x7fff)
++
++
++/* POSIX `cflags' bits (i.e., information for `regcomp'). */
++
++/* If this bit is set, then use extended regular expression syntax.
++ If not set, then use basic regular expression syntax. */
++#define REG_EXTENDED 1
++
++/* If this bit is set, then ignore case when matching.
++ If not set, then case is significant. */
++#define REG_ICASE (REG_EXTENDED << 1)
++
++/* If this bit is set, then anchors do not match at newline
++ characters in the string.
++ If not set, then anchors do match at newlines. */
++#define REG_NEWLINE (REG_ICASE << 1)
++
++/* If this bit is set, then report only success or fail in regexec.
++ If not set, then returns differ between not matching and errors. */
++#define REG_NOSUB (REG_NEWLINE << 1)
++
++
++/* POSIX `eflags' bits (i.e., information for regexec). */
++
++/* If this bit is set, then the beginning-of-line operator doesn't match
++ the beginning of the string (presumably because it's not the
++ beginning of a line).
++ If not set, then the beginning-of-line operator does match the
++ beginning of the string. */
++#define REG_NOTBOL 1
+
++/* Like REG_NOTBOL, except for the end-of-line. */
++#define REG_NOTEOL (1 << 1)
+
++
++/* If any error codes are removed, changed, or added, update the
++ `re_error_msg' table in regex.c. */
++typedef enum
++{
++#ifdef _XOPEN_SOURCE
++ REG_ENOSYS = -1, /* This will never happen for this implementation. */
++#endif
++
++ REG_NOERROR = 0, /* Success. */
++ REG_NOMATCH, /* Didn't find a match (for regexec). */
++
++ /* POSIX regcomp return error codes. (In the order listed in the
++ standard.) */
++ REG_BADPAT, /* Invalid pattern. */
++ REG_ECOLLATE, /* Not implemented. */
++ REG_ECTYPE, /* Invalid character class name. */
++ REG_EESCAPE, /* Trailing backslash. */
++ REG_ESUBREG, /* Invalid back reference. */
++ REG_EBRACK, /* Unmatched left bracket. */
++ REG_EPAREN, /* Parenthesis imbalance. */
++ REG_EBRACE, /* Unmatched \{. */
++ REG_BADBR, /* Invalid contents of \{\}. */
++ REG_ERANGE, /* Invalid range end. */
++ REG_ESPACE, /* Ran out of memory. */
++ REG_BADRPT, /* No preceding re for repetition op. */
++
++ /* Error codes we've added. */
++ REG_EEND, /* Premature end. */
++ REG_ESIZE, /* Compiled pattern bigger than 2^16 bytes. */
++ REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */
++} reg_errcode_t;
++
++/* This data structure represents a compiled pattern. Before calling
++ the pattern compiler, the fields `buffer', `allocated', `fastmap',
++ `translate', and `no_sub' can be set. After the pattern has been
++ compiled, the `re_nsub' field is available. All other fields are
++ private to the regex routines. */
++
++#ifndef RE_TRANSLATE_TYPE
++# define RE_TRANSLATE_TYPE char *
++#endif
++
++struct re_pattern_buffer
++{
++/* [[[begin pattern_buffer]]] */
++ /* Space that holds the compiled pattern. It is declared as
++ `unsigned char *' because its elements are
++ sometimes used as array indexes. */
++ unsigned char *buffer;
++
++ /* Number of bytes to which `buffer' points. */
++ unsigned long int allocated;
++
++ /* Number of bytes actually used in `buffer'. */
++ unsigned long int used;
++
++ /* Syntax setting with which the pattern was compiled. */
++ reg_syntax_t syntax;
++
++ /* Pointer to a fastmap, if any, otherwise zero. re_search uses
++ the fastmap, if there is one, to skip over impossible
++ starting points for matches. */
++ char *fastmap;
++
++ /* Either a translate table to apply to all characters before
++ comparing them, or zero for no translation. The translation
++ is applied to a pattern when it is compiled and to a string
++ when it is matched. */
++ RE_TRANSLATE_TYPE translate;
++
++ /* Number of subexpressions found by the compiler. */
++ size_t re_nsub;
++
++ /* Zero if this pattern cannot match the empty string, one else.
++ Well, in truth it's used only in `re_search_2', to see
++ whether or not we should use the fastmap, so we don't set
++ this absolutely perfectly; see `re_compile_fastmap' (the
++ `duplicate' case). */
++ unsigned can_be_null : 1;
++
++ /* If REGS_UNALLOCATED, allocate space in the `regs' structure
++ for `max (RE_NREGS, re_nsub + 1)' groups.
++ If REGS_REALLOCATE, reallocate space if necessary.
++ If REGS_FIXED, use what's there. */
++#define REGS_UNALLOCATED 0
++#define REGS_REALLOCATE 1
++#define REGS_FIXED 2
++ unsigned regs_allocated : 2;
++
++ /* Set to zero when `regex_compile' compiles a pattern; set to one
++ by `re_compile_fastmap' if it updates the fastmap. */
++ unsigned fastmap_accurate : 1;
++
++ /* If set, `re_match_2' does not return information about
++ subexpressions. */
++ unsigned no_sub : 1;
++
++ /* If set, a beginning-of-line anchor doesn't match at the
++ beginning of the string. */
++ unsigned not_bol : 1;
++
++ /* Similarly for an end-of-line anchor. */
++ unsigned not_eol : 1;
++
++ /* If true, an anchor at a newline matches. */
++ unsigned newline_anchor : 1;
++
++/* [[[end pattern_buffer]]] */
++};
++
++typedef struct re_pattern_buffer regex_t;
++
++/* Type for byte offsets within the string. POSIX mandates this. */
++typedef int regoff_t;
++
++
++/* This is the structure we store register match data in. See
++ regex.texinfo for a full description of what registers match. */
++struct re_registers
++{
++ unsigned num_regs;
++ regoff_t *start;
++ regoff_t *end;
+};
+
++
++/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
++ `re_match_2' returns information about at least this many registers
++ the first time a `regs' structure is passed. */
++#ifndef RE_NREGS
++# define RE_NREGS 30
+#endif
++
++
++/* POSIX specification for registers. Aside from the different names than
++ `re_registers', POSIX uses an array of structures, instead of a
++ structure of arrays. */
++typedef struct
++{
++ regoff_t rm_so; /* Byte offset from string's start to substring's start. */
++ regoff_t rm_eo; /* Byte offset from string's start to substring's end. */
++} regmatch_t;
++
++/* Declarations for routines. */
++
++/* To avoid duplicating every routine declaration -- once with a
++ prototype (if we are ANSI), and once without (if we aren't) -- we
++ use the following macro to declare argument types. This
++ unfortunately clutters up the declarations a bit, but I think it's
++ worth it. */
++
++#if __STDC__
++
++# define _RE_ARGS(args) args
++
++#else /* not __STDC__ */
++
++# define _RE_ARGS(args) ()
++
++#endif /* not __STDC__ */
++
++/* Sets the current default syntax to SYNTAX, and return the old syntax.
++ You can also simply assign to the `re_syntax_options' variable. */
++extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax));
++
++/* Compile the regular expression PATTERN, with length LENGTH
++ and syntax given by the global `re_syntax_options', into the buffer
++ BUFFER. Return NULL if successful, and an error string if not. */
++extern const char *re_compile_pattern
++ _RE_ARGS ((const char *pattern, size_t length,
++ struct re_pattern_buffer *buffer));
++
++
++/* Compile a fastmap for the compiled pattern in BUFFER; used to
++ accelerate searches. Return 0 if successful and -2 if was an
++ internal error. */
++extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
++
++
++/* Search in the string STRING (with length LENGTH) for the pattern
++ compiled into BUFFER. Start searching at position START, for RANGE
++ characters. Return the starting position of the match, -1 for no
++ match, or -2 for an internal error. Also return register
++ information in REGS (if REGS and BUFFER->no_sub are nonzero). */
++extern int re_search
++ _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
++ int length, int start, int range, struct re_registers *regs));
++
++
++/* Like `re_search', but search in the concatenation of STRING1 and
++ STRING2. Also, stop searching at index START + STOP. */
++extern int re_search_2
++ _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
++ int length1, const char *string2, int length2,
++ int start, int range, struct re_registers *regs, int stop));
++
++
++/* Like `re_search', but return how many characters in STRING the regexp
++ in BUFFER matched, starting at position START. */
++extern int re_match
++ _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
++ int length, int start, struct re_registers *regs));
++
++
++/* Relates to `re_match' as `re_search_2' relates to `re_search'. */
++extern int re_match_2
++ _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
++ int length1, const char *string2, int length2,
++ int start, struct re_registers *regs, int stop));
++
++
++/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
++ ENDS. Subsequent matches using BUFFER and REGS will use this memory
++ for recording register information. STARTS and ENDS must be
++ allocated with malloc, and must each be at least `NUM_REGS * sizeof
++ (regoff_t)' bytes long.
++
++ If NUM_REGS == 0, then subsequent matches should allocate their own
++ register data.
++
++ Unless this function is called, the first search or match using
++ PATTERN_BUFFER will allocate its own register data, without
++ freeing the old data. */
++extern void re_set_registers
++ _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
++ unsigned num_regs, regoff_t *starts, regoff_t *ends));
++
++#if defined _REGEX_RE_COMP || defined _LIBC
++# ifndef _CRAY
++/* 4.2 bsd compatibility. */
++extern char *re_comp _RE_ARGS ((const char *));
++extern int re_exec _RE_ARGS ((const char *));
++# endif
++#endif
++
++/* GCC 2.95 and later have "__restrict"; C99 compilers have
++ "restrict", and "configure" may have defined "restrict". */
++#ifndef __restrict
++# if ! (2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__))
++# if defined restrict || 199901L <= __STDC_VERSION__
++# define __restrict restrict
++# else
++# define __restrict
++# endif
++# endif
++#endif
++/* For now unconditionally define __restrict_arr to expand to nothing.
++ Ideally we would have a test for the compiler which allows defining
++ it to restrict. */
++#define __restrict_arr
++
++/* POSIX compatibility. */
++extern int regcomp _RE_ARGS ((regex_t *__restrict __preg,
++ const char *__restrict __pattern,
++ int __cflags));
++
++extern int regexec _RE_ARGS ((const regex_t *__restrict __preg,
++ const char *__restrict __string, size_t __nmatch,
++ regmatch_t __pmatch[__restrict_arr],
++ int __eflags));
++
++extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
++ char *__errbuf, size_t __errbuf_size));
++
++extern void regfree _RE_ARGS ((regex_t *__preg));
++
++
++#ifdef __cplusplus
++}
++#endif /* C++ */
++
++#endif /* regex.h */
++
++/*
++Local variables:
++make-backup-files: t
++version-control: t
++trim-versions-without-asking: nil
++End:
++*/
diff -ruN menu-2.1.5/update-menus/update-menus.cc
menu-2.1.5.new/update-menus/update-menus.cc
---- menu-2.1.5/update-menus/update-menus.cc Sun Jul 29 09:32:08 2001
-+++ menu-2.1.5.new/update-menus/update-menus.cc Tue Aug 20 17:07:46 2002
-@@ -21,7 +21,13 @@
- #include <signal.h>
+--- menu-2.1.5/update-menus/update-menus.cc Fri Sep 6 12:07:46 2002
++++ menu-2.1.5.new/update-menus/update-menus.cc Mon Oct 28 11:14:41 2002
+@@ -22,6 +22,9 @@
#include <syslog.h>
#include <errno.h>
--#include <procbuf.h>
-+#include "lprocbuf.h"
-+
+
+#ifndef O_SYNC
+#define O_SYNC O_FSYNC
+#endif
-+
-+using namespace std;
-
- int debug=0, verbose=0;
- set <String, less<String> > installed_packages;
-@@ -475,7 +481,6 @@
- vector<String> &menudata){
- bool wrote_filename=false;
- parsestream *i;
-- procbuf pr;
- istream *pipe_istr=NULL;
- int linenr=1;
-
-@@ -483,7 +488,7 @@
- configinfo::report_debug);
- try{
- if(executable(filename)){
-- pr.open(filename.c_str(),ios::in);
-+ lprocbuf pr(filename.c_str(),ios::in);
- pipe_istr=new istream(&pr);
- try{
- i=new parsestream(*pipe_istr);
-@@ -529,7 +534,6 @@
- if(executable(filename)){
- if(pipe_istr)
- delete pipe_istr;
-- pr.close();
- }
- delete i;
- }
-@@ -543,7 +547,7 @@
- int r;
- String name;
- String dummy;
-- cStrVec::iterator method_i;
-+ StrVec::iterator method_i;
- String dirname;
-
- for(method_i=config.menufilesdir.begin();
-@@ -680,6 +684,7 @@
- int create_lock(){
- // return lock fd if succesful, false if unsuccesfull.
- int fd=true;
-+ char pid[20];
-
- if(!getuid()){
- fd=open(UPMEN_LOCKFILE,O_WRONLY|O_CREAT,00644);
-@@ -698,15 +703,17 @@
-
- }
-- ofstream of(fd);
-- of<<getpid();
-- if(!of.good()){
-+ snprintf(pid, sizeof(pid), "%lu", (unsigned long)getpid());
-+
-+ if (0 > write(fd, pid, strlen(pid))) {
-+ close(fd);
- config.report("cannot write to lockfile "
- UPMEN_LOCKFILE". Aborting.",
- configinfo::report_quiet);
- return false;
- }
- }
-+ close(fd);
- return fd;
- }
+ using namespace std;
-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf
_______________________________________________
Fink-commits mailing list
[EMAIL PROTECTED]
https://lists.sourceforge.net/lists/listinfo/fink-commits
