Skip to content

C
core
Kaydet (Commit) 31e7820f authored tarafından Matúš Kukan's avatar Matúš Kukan
Dosyalara gözat
Seçenekler

remove unused header and clean d.lst which should be empty

üst ed73eb56
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 389 deletions
regexp/prj/d.lst
Dosyayı görüntüle @ 31e7820f
..\%__SRC%\lib\libi18nregexp*.dll.a %_DEST%\lib\libi18nregexp*.dll.a
regexp/source/reclass.hxx deleted 100644 → 0
Dosyayı görüntüle @ ed73eb56
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* Definitions for data structures and routines for the regular
expression library, version 0.12.
Copyright (C) 1985,89,90,91,92,93,95,96,97,98 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 Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/*
Modified for OpenOffice.org to use sal_Unicode and Transliteration service.
*/
#ifndef INCLUDED_REGEXP_RECLASS_HXX
#define INCLUDED_REGEXP_RECLASS_HXX
#include <i18nutil/unicode.hxx>
#include <com/sun/star/util/SearchFlags.hpp>
#include <com/sun/star/util/SearchOptions.hpp>
#include <sal/types.h>
#include <com/sun/star/i18n/XExtendedTransliteration.hpp>
/* 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',
can be set. After the pattern has been
compiled, the `re_nsub' field is available. All other fields are
private to the regex routines. */
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. */
sal_Unicode *buffer;
/* Number of bytes to which `buffer' points. */
sal_uInt32 allocated;
/* Number of bytes actually used in `buffer'. */
sal_uInt32 used;
/* 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. */
sal_Unicode *fastmap;
/* 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_search2', 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;
/* 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, 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]]] */
};
/* These are the command codes that appear in compiled regular
expressions. Some opcodes are followed by argument bytes. A
command code can specify any interpretation whatsoever for its
arguments. Zero bytes may appear in the compiled regular expression. */
typedef enum
{
no_op = 0,
/* Succeed right away--no more backtracking. */
succeed,
/* Followed by one byte giving n, then by n literal bytes. */
exactn,
/* Matches any (more or less) character. */
anychar,
/* Matches any one char belonging to specified set. First
following byte is number of bitmap bytes. Then come bytes
for a bitmap saying which chars are in. Bits in each byte
are ordered low-bit-first. A character is in the set if its
bit is 1. A character too large to have a bit in the map is
automatically not in the set. */
charset,
/* Same parameters as charset, but match any character that is
not one of those specified. */
charset_not,
/* Start remembering the text that is matched, for storing in a
register. Followed by one byte with the register number, in
the range 0 to one less than the pattern buffer's re_nsub
field. Then followed by one byte with the number of groups
inner to this one. (This last has to be part of the
start_memory only because we need it in the on_failure_jump
of re_match2.) */
start_memory,
/* Stop remembering the text that is matched and store it in a
memory register. Followed by one byte with the register
number, in the range 0 to one less than `re_nsub' in the
pattern buffer, and one byte with the number of inner groups,
just like `start_memory'. (We need the number of inner
groups here because we don't have any easy way of finding the
corresponding start_memory when we're at a stop_memory.) */
stop_memory,
/* Match a duplicate of something remembered. Followed by one
byte containing the register number. */
duplicate,
/* Fail unless at beginning of line. */
begline,
/* Fail unless at end of line. */
endline,
/* Succeeds if at beginning of buffer (if emacs) or at beginning
of string to be matched (if not). */
begbuf,
/* Analogously, for end of buffer/string. */
endbuf,
/* Followed by two byte relative address to which to jump. */
jump,
/* Same as jump, but marks the end of an alternative. */
jump_past_alt,
/* Followed by two-byte relative address of place to resume at
in case of failure. */
on_failure_jump,
/* Like on_failure_jump, but pushes a placeholder instead of the
current string position when executed. */
on_failure_keep_string_jump,
/* Throw away latest failure point and then jump to following
two-byte relative address. */
pop_failure_jump,
/* Change to pop_failure_jump if know won't have to backtrack to
match; otherwise change to jump. This is used to jump
back to the beginning of a repeat. If what follows this jump
clearly won't match what the repeat does, such that we can be
sure that there is no use backtracking out of repetitions
already matched, then we change it to a pop_failure_jump.
Followed by two-byte address. */
maybe_pop_jump,
/* Jump to following two-byte address, and push a dummy failure
point. This failure point will be thrown away if an attempt
is made to use it for a failure. A `+' construct makes this
before the first repeat. Also used as an intermediary kind
of jump when compiling an alternative. */
dummy_failure_jump,
/* Push a dummy failure point and continue. Used at the end of
alternatives. */
push_dummy_failure,
/* Followed by two-byte relative address and two-byte number n.
After matching N times, jump to the address upon failure. */
succeed_n,
/* Followed by two-byte relative address, and two-byte number n.
Jump to the address N times, then fail. */
jump_n,
/* Set the following two-byte relative address to the
subsequent two-byte number. The address *includes* the two
bytes of number. */
set_number_at,
wordbeg, /* Succeeds if at word beginning. */
wordend /* Succeeds if at word end. */
} re_opcode_t;
typedef struct re_pattern_buffer regex_t;
/* Type for byte offsets within the string. POSIX mandates this. */
typedef sal_Int32 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
{
sal_uInt32 num_regs;
sal_Int32 *start;
sal_Int32 *end;
sal_Int32 num_of_match;
};
typedef struct {
sal_Int32 begalt_offset;
sal_Int32 fixup_alt_jump;
sal_Int32 inner_group_offset;
sal_Int32 laststart_offset;
sal_uInt32 regnum;
} compile_stack_elt_t;
typedef struct {
compile_stack_elt_t *stack;
sal_uInt32 size;
sal_uInt32 avail;
} compile_stack_type;
union fail_stack_elt
{
sal_Unicode *pointer;
sal_Int32 integer;
};
typedef union fail_stack_elt fail_stack_elt_t;
typedef struct
{
fail_stack_elt_t *stack;
sal_uInt32 size;
sal_uInt32 avail; /* Offset of next open position. */
} fail_stack_type;
typedef union
{
fail_stack_elt_t word;
struct
{
/* This field is one if this group can match the empty string,
zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */
#define MATCH_NULL_UNSET_VALUE 3
unsigned match_null_string_p : 2;
unsigned is_active : 1;
unsigned matched_something : 1;
unsigned ever_matched_something : 1;
} bits;
} register_info_type;
class Regexpr
{
::com::sun::star::uno::Reference<
::com::sun::star::i18n::XExtendedTransliteration > translit;
const sal_Unicode *line; // line to search in
sal_Int32 linelen; // length of search string
sal_Unicode *pattern; // RE pattern to match
sal_Int32 patsize; // Length of pattern
struct re_pattern_buffer *bufp;
sal_Bool isIgnoreCase;
/* 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. */
int translate;
sal_uInt32 failure_id;
sal_uInt32 nfailure_points_pushed;
sal_uInt32 nfailure_points_popped;
/* Counts the total number of registers pushed. */
sal_uInt32 num_regs_pushed;
sal_uInt32 re_max_failures;
/* Registers are set to a sentinel when they haven't yet matched. */
sal_Unicode reg_unset_dummy;
// private instance functions
inline void store_number( sal_Unicode * destination, sal_Int32 number );
inline void store_number_and_incr( sal_Unicode *& destination, sal_Int32 number );
inline void extract_number(sal_Int32 & dest, sal_Unicode *source);
inline void extract_number_and_incr(sal_Int32 & destination, sal_Unicode *& source);
sal_Bool group_match_null_string_p(sal_Unicode **p, sal_Unicode *end,
register_info_type *reg_info);
sal_Bool alt_match_null_string_p(sal_Unicode *p, sal_Unicode *end,
register_info_type *reg_info);
sal_Bool common_op_match_null_string_p(sal_Unicode **p, sal_Unicode *end,
register_info_type *reg_info);
sal_Int32 bcmp_translate(const sal_Unicode *s1,
const sal_Unicode *s2, sal_Int32 len);
sal_Int32 regcomp(void);
sal_Int32 regex_compile(void);
inline void store_op1(re_opcode_t op, sal_Unicode *loc, sal_Int32 arg);
inline void store_op2(re_opcode_t op, sal_Unicode *loc, sal_Int32 arg1, sal_Int32 arg2);
void insert_op1(re_opcode_t op, sal_Unicode *loc, sal_Int32 arg,
sal_Unicode *end);
void insert_op2(re_opcode_t op, sal_Unicode *loc, sal_Int32 arg1,
sal_Int32 arg2, sal_Unicode *end);
sal_Bool at_begline_loc_p(const sal_Unicode *local_pattern,
const sal_Unicode *p);
sal_Bool at_endline_loc_p(const sal_Unicode *p, const sal_Unicode *pend);
reg_errcode_t compile_range(sal_Unicode range_begin, sal_Unicode range_end, sal_Unicode *b);
sal_Bool group_in_compile_stack(compile_stack_type compile_stack,
sal_uInt32 regnum);
sal_Int32 re_match2(struct re_registers *regs, sal_Int32 pos, sal_Int32 range);
sal_Bool iswordbegin(const sal_Unicode *d, sal_Unicode *string, sal_Int32 ssize);
sal_Bool iswordend(const sal_Unicode *d, sal_Unicode *string, sal_Int32 ssize);
void set_list_bit(sal_Unicode c, sal_Unicode *b);
public:
// constructors
Regexpr( const ::com::sun::star::util::SearchOptions & rOptions,
::com::sun::star::uno::Reference<
::com::sun::star::i18n::XExtendedTransliteration > XTrans );
// destructor
~Regexpr();
void set_line( const sal_Unicode *line, sal_Int32 len );
// function returning pointers to occurrences in regs
sal_Int32 re_search(struct re_registers *regs, sal_Int32 pOffset); // find pattern in line
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment