PostgreSQL Source Code  git master
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
wparser_def.c File Reference
#include "postgres.h"
#include <limits.h>
#include "catalog/pg_collation.h"
#include "commands/defrem.h"
#include "miscadmin.h"
#include "tsearch/ts_locale.h"
#include "tsearch/ts_public.h"
#include "tsearch/ts_type.h"
#include "tsearch/ts_utils.h"
#include "utils/builtins.h"
Include dependency graph for wparser_def.c:

Go to the source code of this file.

Data Structures

struct  TParserStateActionItem
 
struct  TParserPosition
 
struct  TParser
 
struct  TParserStateAction
 
struct  CoverPos
 
struct  hlCheck
 

Macros

#define ASCIIWORD   1
 
#define WORD_T   2
 
#define NUMWORD   3
 
#define EMAIL   4
 
#define URL_T   5
 
#define HOST   6
 
#define SCIENTIFIC   7
 
#define VERSIONNUMBER   8
 
#define NUMPARTHWORD   9
 
#define PARTHWORD   10
 
#define ASCIIPARTHWORD   11
 
#define SPACE   12
 
#define TAG_T   13
 
#define PROTOCOL   14
 
#define NUMHWORD   15
 
#define ASCIIHWORD   16
 
#define HWORD   17
 
#define URLPATH   18
 
#define FILEPATH   19
 
#define DECIMAL_T   20
 
#define SIGNEDINT   21
 
#define UNSIGNEDINT   22
 
#define XMLENTITY   23
 
#define LASTNUM   23
 
#define A_NEXT   0x0000
 
#define A_BINGO   0x0001
 
#define A_POP   0x0002
 
#define A_PUSH   0x0004
 
#define A_RERUN   0x0008
 
#define A_CLEAR   0x0010
 
#define A_MERGE   0x0020
 
#define A_CLRALL   0x0040
 
#define p_iswhat(type, nonascii)
 
#define TPARSERSTATEACTION(state)    { CppConcat(action,state), state }
 
#define TS_IDIGNORE(x)   ( (x)==TAG_T || (x)==PROTOCOL || (x)==SPACE || (x)==XMLENTITY )
 
#define HLIDREPLACE(x)   ( (x)==TAG_T )
 
#define HLIDSKIP(x)   ( (x)==URL_T || (x)==NUMHWORD || (x)==ASCIIHWORD || (x)==HWORD )
 
#define XMLHLIDSKIP(x)   ( (x)==URL_T || (x)==NUMHWORD || (x)==ASCIIHWORD || (x)==HWORD )
 
#define NONWORDTOKEN(x)   ( (x)==SPACE || HLIDREPLACE(x) || HLIDSKIP(x) )
 
#define NOENDTOKEN(x)   ( NONWORDTOKEN(x) || (x)==SCIENTIFIC || (x)==VERSIONNUMBER || (x)==DECIMAL_T || (x)==SIGNEDINT || (x)==UNSIGNEDINT || TS_IDIGNORE(x) )
 
#define INTERESTINGWORD(j)    (prs->words[j].item && !prs->words[j].repeated)
 
#define BADENDPOINT(j)
 

Typedefs

typedef int(* TParserCharTest) (struct TParser *)
 
typedef void(* TParserSpecial) (struct TParser *)
 
typedef struct TParserPosition TParserPosition
 
typedef struct TParser TParser
 

Enumerations

enum  TParserState {
  TPS_Base = 0 , TPS_InNumWord , TPS_InAsciiWord , TPS_InWord ,
  TPS_InUnsignedInt , TPS_InSignedIntFirst , TPS_InSignedInt , TPS_InSpace ,
  TPS_InUDecimalFirst , TPS_InUDecimal , TPS_InDecimalFirst , TPS_InDecimal ,
  TPS_InVerVersion , TPS_InSVerVersion , TPS_InVersionFirst , TPS_InVersion ,
  TPS_InMantissaFirst , TPS_InMantissaSign , TPS_InMantissa , TPS_InXMLEntityFirst ,
  TPS_InXMLEntity , TPS_InXMLEntityNumFirst , TPS_InXMLEntityNum , TPS_InXMLEntityHexNumFirst ,
  TPS_InXMLEntityHexNum , TPS_InXMLEntityEnd , TPS_InTagFirst , TPS_InXMLBegin ,
  TPS_InTagCloseFirst , TPS_InTagName , TPS_InTagBeginEnd , TPS_InTag ,
  TPS_InTagEscapeK , TPS_InTagEscapeKK , TPS_InTagBackSleshed , TPS_InTagEnd ,
  TPS_InCommentFirst , TPS_InCommentLast , TPS_InComment , TPS_InCloseCommentFirst ,
  TPS_InCloseCommentLast , TPS_InCommentEnd , TPS_InHostFirstDomain , TPS_InHostDomainSecond ,
  TPS_InHostDomain , TPS_InPortFirst , TPS_InPort , TPS_InHostFirstAN ,
  TPS_InHost , TPS_InEmail , TPS_InFileFirst , TPS_InFileTwiddle ,
  TPS_InPathFirst , TPS_InPathFirstFirst , TPS_InPathSecond , TPS_InFile ,
  TPS_InFileNext , TPS_InURLPathFirst , TPS_InURLPathStart , TPS_InURLPath ,
  TPS_InFURL , TPS_InProtocolFirst , TPS_InProtocolSecond , TPS_InProtocolEnd ,
  TPS_InHyphenAsciiWordFirst , TPS_InHyphenAsciiWord , TPS_InHyphenWordFirst , TPS_InHyphenWord ,
  TPS_InHyphenNumWordFirst , TPS_InHyphenNumWord , TPS_InHyphenDigitLookahead , TPS_InParseHyphen ,
  TPS_InParseHyphenHyphen , TPS_InHyphenWordPart , TPS_InHyphenAsciiWordPart , TPS_InHyphenNumWordPart ,
  TPS_InHyphenUnsignedInt , TPS_Null
}
 

Functions

static bool TParserGet (TParser *prs)
 
static TParserPosition * newTParserPosition (TParserPosition *prev)
 
static TParser * TParserInit (char *str, int len)
 
static TParser * TParserCopyInit (const TParser *orig)
 
static void TParserClose (TParser *prs)
 
static void TParserCopyClose (TParser *prs)
 
 p_iswhat (alnum, 1)
 
static int p_isEOF (TParser *prs)
 
static int p_iseqC (TParser *prs)
 
static int p_isneC (TParser *prs)
 
static int p_isascii (TParser *prs)
 
static int p_isasclet (TParser *prs)
 
static int p_isurlchar (TParser *prs)
 
void _make_compiler_happy (void)
 
static void SpecialTags (TParser *prs)
 
static void SpecialFURL (TParser *prs)
 
static void SpecialHyphen (TParser *prs)
 
static void SpecialVerVersion (TParser *prs)
 
static int p_isstophost (TParser *prs)
 
static int p_isignore (TParser *prs)
 
static int p_ishost (TParser *prs)
 
static int p_isURLPath (TParser *prs)
 
static int p_isspecial (TParser *prs)
 
Datum prsd_lextype (PG_FUNCTION_ARGS)
 
Datum prsd_start (PG_FUNCTION_ARGS)
 
Datum prsd_nexttoken (PG_FUNCTION_ARGS)
 
Datum prsd_end (PG_FUNCTION_ARGS)
 
static TSTernaryValue checkcondition_HL (void *opaque, QueryOperand *val, ExecPhraseData *data)
 
static bool hlCover (HeadlineParsedText *prs, TSQuery query, List *locations, int *nextpos, int *p, int *q)
 
static void mark_fragment (HeadlineParsedText *prs, bool highlightall, int startpos, int endpos)
 
static void get_next_fragment (HeadlineParsedText *prs, int *startpos, int *endpos, int *curlen, int *poslen, int max_words)
 
static void mark_hl_fragments (HeadlineParsedText *prs, TSQuery query, List *locations, bool highlightall, int shortword, int min_words, int max_words, int max_fragments)
 
static void mark_hl_words (HeadlineParsedText *prs, TSQuery query, List *locations, bool highlightall, int shortword, int min_words, int max_words)
 
Datum prsd_headline (PG_FUNCTION_ARGS)
 

Variables

static const char *const tok_alias []
 
static const char *const lex_descr []
 
static const TParserStateActionItem actionTPS_Base []
 
static const TParserStateActionItem actionTPS_InNumWord []
 
static const TParserStateActionItem actionTPS_InAsciiWord []
 
static const TParserStateActionItem actionTPS_InWord []
 
static const TParserStateActionItem actionTPS_InUnsignedInt []
 
static const TParserStateActionItem actionTPS_InSignedIntFirst []
 
static const TParserStateActionItem actionTPS_InSignedInt []
 
static const TParserStateActionItem actionTPS_InSpace []
 
static const TParserStateActionItem actionTPS_InUDecimalFirst []
 
static const TParserStateActionItem actionTPS_InUDecimal []
 
static const TParserStateActionItem actionTPS_InDecimalFirst []
 
static const TParserStateActionItem actionTPS_InDecimal []
 
static const TParserStateActionItem actionTPS_InVerVersion []
 
static const TParserStateActionItem actionTPS_InSVerVersion []
 
static const TParserStateActionItem actionTPS_InVersionFirst []
 
static const TParserStateActionItem actionTPS_InVersion []
 
static const TParserStateActionItem actionTPS_InMantissaFirst []
 
static const TParserStateActionItem actionTPS_InMantissaSign []
 
static const TParserStateActionItem actionTPS_InMantissa []
 
static const TParserStateActionItem actionTPS_InXMLEntityFirst []
 
static const TParserStateActionItem actionTPS_InXMLEntity []
 
static const TParserStateActionItem actionTPS_InXMLEntityNumFirst []
 
static const TParserStateActionItem actionTPS_InXMLEntityHexNumFirst []
 
static const TParserStateActionItem actionTPS_InXMLEntityNum []
 
static const TParserStateActionItem actionTPS_InXMLEntityHexNum []
 
static const TParserStateActionItem actionTPS_InXMLEntityEnd []
 
static const TParserStateActionItem actionTPS_InTagFirst []
 
static const TParserStateActionItem actionTPS_InXMLBegin []
 
static const TParserStateActionItem actionTPS_InTagCloseFirst []
 
static const TParserStateActionItem actionTPS_InTagName []
 
static const TParserStateActionItem actionTPS_InTagBeginEnd []
 
static const TParserStateActionItem actionTPS_InTag []
 
static const TParserStateActionItem actionTPS_InTagEscapeK []
 
static const TParserStateActionItem actionTPS_InTagEscapeKK []
 
static const TParserStateActionItem actionTPS_InTagBackSleshed []
 
static const TParserStateActionItem actionTPS_InTagEnd []
 
static const TParserStateActionItem actionTPS_InCommentFirst []
 
static const TParserStateActionItem actionTPS_InCommentLast []
 
static const TParserStateActionItem actionTPS_InComment []
 
static const TParserStateActionItem actionTPS_InCloseCommentFirst []
 
static const TParserStateActionItem actionTPS_InCloseCommentLast []
 
static const TParserStateActionItem actionTPS_InCommentEnd []
 
static const TParserStateActionItem actionTPS_InHostFirstDomain []
 
static const TParserStateActionItem actionTPS_InHostDomainSecond []
 
static const TParserStateActionItem actionTPS_InHostDomain []
 
static const TParserStateActionItem actionTPS_InPortFirst []
 
static const TParserStateActionItem actionTPS_InPort []
 
static const TParserStateActionItem actionTPS_InHostFirstAN []
 
static const TParserStateActionItem actionTPS_InHost []
 
static const TParserStateActionItem actionTPS_InEmail []
 
static const TParserStateActionItem actionTPS_InFileFirst []
 
static const TParserStateActionItem actionTPS_InFileTwiddle []
 
static const TParserStateActionItem actionTPS_InPathFirst []
 
static const TParserStateActionItem actionTPS_InPathFirstFirst []
 
static const TParserStateActionItem actionTPS_InPathSecond []
 
static const TParserStateActionItem actionTPS_InFile []
 
static const TParserStateActionItem actionTPS_InFileNext []
 
static const TParserStateActionItem actionTPS_InURLPathFirst []
 
static const TParserStateActionItem actionTPS_InURLPathStart []
 
static const TParserStateActionItem actionTPS_InURLPath []
 
static const TParserStateActionItem actionTPS_InFURL []
 
static const TParserStateActionItem actionTPS_InProtocolFirst []
 
static const TParserStateActionItem actionTPS_InProtocolSecond []
 
static const TParserStateActionItem actionTPS_InProtocolEnd []
 
static const TParserStateActionItem actionTPS_InHyphenAsciiWordFirst []
 
static const TParserStateActionItem actionTPS_InHyphenAsciiWord []
 
static const TParserStateActionItem actionTPS_InHyphenWordFirst []
 
static const TParserStateActionItem actionTPS_InHyphenWord []
 
static const TParserStateActionItem actionTPS_InHyphenNumWordFirst []
 
static const TParserStateActionItem actionTPS_InHyphenNumWord []
 
static const TParserStateActionItem actionTPS_InHyphenDigitLookahead []
 
static const TParserStateActionItem actionTPS_InParseHyphen []
 
static const TParserStateActionItem actionTPS_InParseHyphenHyphen []
 
static const TParserStateActionItem actionTPS_InHyphenWordPart []
 
static const TParserStateActionItem actionTPS_InHyphenAsciiWordPart []
 
static const TParserStateActionItem actionTPS_InHyphenNumWordPart []
 
static const TParserStateActionItem actionTPS_InHyphenUnsignedInt []
 
static const TParserStateAction Actions []
 

Macro Definition Documentation

◆ A_BINGO

#define A_BINGO   0x0001

Definition at line 220 of file wparser_def.c.

◆ A_CLEAR

#define A_CLEAR   0x0010

Definition at line 224 of file wparser_def.c.

◆ A_CLRALL

#define A_CLRALL   0x0040

Definition at line 226 of file wparser_def.c.

◆ A_MERGE

#define A_MERGE   0x0020

Definition at line 225 of file wparser_def.c.

◆ A_NEXT

#define A_NEXT   0x0000

Definition at line 219 of file wparser_def.c.

◆ A_POP

#define A_POP   0x0002

Definition at line 221 of file wparser_def.c.

◆ A_PUSH

#define A_PUSH   0x0004

Definition at line 222 of file wparser_def.c.

◆ A_RERUN

#define A_RERUN   0x0008

Definition at line 223 of file wparser_def.c.

◆ ASCIIHWORD

#define ASCIIHWORD   16

Definition at line 50 of file wparser_def.c.

◆ ASCIIPARTHWORD

#define ASCIIPARTHWORD   11

Definition at line 45 of file wparser_def.c.

◆ ASCIIWORD

#define ASCIIWORD   1

Definition at line 35 of file wparser_def.c.

◆ BADENDPOINT

#define BADENDPOINT (   j)
Value:
((NOENDTOKEN(prs->words[j].type) || prs->words[j].len <= shortword) && \
!INTERESTINGWORD(j))
j
int j
Definition: isn.c:74
NOENDTOKEN
#define NOENDTOKEN(x)
Definition: wparser_def.c:1936
INTERESTINGWORD
#define INTERESTINGWORD(j)
Definition: wparser_def.c:1945

Definition at line 1949 of file wparser_def.c.

◆ DECIMAL_T

#define DECIMAL_T   20

Definition at line 54 of file wparser_def.c.

◆ EMAIL

#define EMAIL   4

Definition at line 38 of file wparser_def.c.

◆ FILEPATH

#define FILEPATH   19

Definition at line 53 of file wparser_def.c.

◆ HLIDREPLACE

#define HLIDREPLACE (   x)    ( (x)==TAG_T )

Definition at line 1932 of file wparser_def.c.

◆ HLIDSKIP

#define HLIDSKIP (   x)    ( (x)==URL_T || (x)==NUMHWORD || (x)==ASCIIHWORD || (x)==HWORD )

Definition at line 1933 of file wparser_def.c.

◆ HOST

#define HOST   6

Definition at line 40 of file wparser_def.c.

◆ HWORD

#define HWORD   17

Definition at line 51 of file wparser_def.c.

◆ INTERESTINGWORD

#define INTERESTINGWORD (   j)     (prs->words[j].item && !prs->words[j].repeated)

Definition at line 1945 of file wparser_def.c.

◆ LASTNUM

#define LASTNUM   23

Definition at line 59 of file wparser_def.c.

◆ NOENDTOKEN

#define NOENDTOKEN (   x)    ( NONWORDTOKEN(x) || (x)==SCIENTIFIC || (x)==VERSIONNUMBER || (x)==DECIMAL_T || (x)==SIGNEDINT || (x)==UNSIGNEDINT || TS_IDIGNORE(x) )

Definition at line 1936 of file wparser_def.c.

◆ NONWORDTOKEN

#define NONWORDTOKEN (   x)    ( (x)==SPACE || HLIDREPLACE(x) || HLIDSKIP(x) )

Definition at line 1935 of file wparser_def.c.

◆ NUMHWORD

#define NUMHWORD   15

Definition at line 49 of file wparser_def.c.

◆ NUMPARTHWORD

#define NUMPARTHWORD   9

Definition at line 43 of file wparser_def.c.

◆ NUMWORD

#define NUMWORD   3

Definition at line 37 of file wparser_def.c.

◆ p_iswhat

#define p_iswhat (   type,
  nonascii 
)
Value:
\
static int \
p_is##type(TParser *prs) \
{ \
Assert(prs->state); \
if (prs->usewide) \
{ \
if (prs->pgwstr) \
{ \
unsigned int c = *(prs->pgwstr + prs->state->poschar); \
if (c > 0x7f) \
return nonascii; \
return is##type(c); \
} \
return isw##type(*(prs->wstr + prs->state->poschar)); \
} \
return is##type(*(unsigned char *) (prs->str + prs->state->posbyte)); \
} \
\
static int \
p_isnot##type(TParser *prs) \
{ \
return !p_is##type(prs); \
}
c
char * c
Definition: preproc-cursor.c:31
type
const char * type
Definition: wait_event_funcs.c:27

Definition at line 423 of file wparser_def.c.

◆ PARTHWORD

#define PARTHWORD   10

Definition at line 44 of file wparser_def.c.

◆ PROTOCOL

#define PROTOCOL   14

Definition at line 48 of file wparser_def.c.

◆ SCIENTIFIC

#define SCIENTIFIC   7

Definition at line 41 of file wparser_def.c.

◆ SIGNEDINT

#define SIGNEDINT   21

Definition at line 55 of file wparser_def.c.

◆ SPACE

#define SPACE   12

Definition at line 46 of file wparser_def.c.

◆ TAG_T

#define TAG_T   13

Definition at line 47 of file wparser_def.c.

◆ TPARSERSTATEACTION

#define TPARSERSTATEACTION (   state)     { CppConcat(action,state), state }

Definition at line 1619 of file wparser_def.c.

◆ TS_IDIGNORE

#define TS_IDIGNORE (   x)    ( (x)==TAG_T || (x)==PROTOCOL || (x)==SPACE || (x)==XMLENTITY )

Definition at line 1931 of file wparser_def.c.

◆ UNSIGNEDINT

#define UNSIGNEDINT   22

Definition at line 56 of file wparser_def.c.

◆ URL_T

#define URL_T   5

Definition at line 39 of file wparser_def.c.

◆ URLPATH

#define URLPATH   18

Definition at line 52 of file wparser_def.c.

◆ VERSIONNUMBER

#define VERSIONNUMBER   8

Definition at line 42 of file wparser_def.c.

◆ WORD_T

#define WORD_T   2

Definition at line 36 of file wparser_def.c.

◆ XMLENTITY

#define XMLENTITY   23

Definition at line 57 of file wparser_def.c.

◆ XMLHLIDSKIP

#define XMLHLIDSKIP (   x)    ( (x)==URL_T || (x)==NUMHWORD || (x)==ASCIIHWORD || (x)==HWORD )

Definition at line 1934 of file wparser_def.c.

Typedef Documentation

◆ TParser

typedef struct TParser TParser

◆ TParserCharTest

typedef int(* TParserCharTest) (struct TParser *)

Definition at line 203 of file wparser_def.c.

◆ TParserPosition

typedef struct TParserPosition TParserPosition

◆ TParserSpecial

typedef void(* TParserSpecial) (struct TParser *)

Definition at line 205 of file wparser_def.c.

Enumeration Type Documentation

◆ TParserState

enum TParserState
Enumerator
TPS_Base 
TPS_InNumWord 
TPS_InAsciiWord 
TPS_InWord 
TPS_InUnsignedInt 
TPS_InSignedIntFirst 
TPS_InSignedInt 
TPS_InSpace 
TPS_InUDecimalFirst 
TPS_InUDecimal 
TPS_InDecimalFirst 
TPS_InDecimal 
TPS_InVerVersion 
TPS_InSVerVersion 
TPS_InVersionFirst 
TPS_InVersion 
TPS_InMantissaFirst 
TPS_InMantissaSign 
TPS_InMantissa 
TPS_InXMLEntityFirst 
TPS_InXMLEntity 
TPS_InXMLEntityNumFirst 
TPS_InXMLEntityNum 
TPS_InXMLEntityHexNumFirst 
TPS_InXMLEntityHexNum 
TPS_InXMLEntityEnd 
TPS_InTagFirst 
TPS_InXMLBegin 
TPS_InTagCloseFirst 
TPS_InTagName 
TPS_InTagBeginEnd 
TPS_InTag 
TPS_InTagEscapeK 
TPS_InTagEscapeKK 
TPS_InTagBackSleshed 
TPS_InTagEnd 
TPS_InCommentFirst 
TPS_InCommentLast 
TPS_InComment 
TPS_InCloseCommentFirst 
TPS_InCloseCommentLast 
TPS_InCommentEnd 
TPS_InHostFirstDomain 
TPS_InHostDomainSecond 
TPS_InHostDomain 
TPS_InPortFirst 
TPS_InPort 
TPS_InHostFirstAN 
TPS_InHost 
TPS_InEmail 
TPS_InFileFirst 
TPS_InFileTwiddle 
TPS_InPathFirst 
TPS_InPathFirstFirst 
TPS_InPathSecond 
TPS_InFile 
TPS_InFileNext 
TPS_InURLPathFirst 
TPS_InURLPathStart 
TPS_InURLPath 
TPS_InFURL 
TPS_InProtocolFirst 
TPS_InProtocolSecond 
TPS_InProtocolEnd 
TPS_InHyphenAsciiWordFirst 
TPS_InHyphenAsciiWord 
TPS_InHyphenWordFirst 
TPS_InHyphenWord 
TPS_InHyphenNumWordFirst 
TPS_InHyphenNumWord 
TPS_InHyphenDigitLookahead 
TPS_InParseHyphen 
TPS_InParseHyphenHyphen 
TPS_InHyphenWordPart 
TPS_InHyphenAsciiWordPart 
TPS_InHyphenNumWordPart 
TPS_InHyphenUnsignedInt 
TPS_Null 

Definition at line 118 of file wparser_def.c.

119 {
120  TPS_Base = 0,
121  TPS_InNumWord,
122  TPS_InAsciiWord,
123  TPS_InWord,
124  TPS_InUnsignedInt,
125  TPS_InSignedIntFirst,
126  TPS_InSignedInt,
127  TPS_InSpace,
128  TPS_InUDecimalFirst,
129  TPS_InUDecimal,
130  TPS_InDecimalFirst,
131  TPS_InDecimal,
132  TPS_InVerVersion,
133  TPS_InSVerVersion,
134  TPS_InVersionFirst,
135  TPS_InVersion,
136  TPS_InMantissaFirst,
137  TPS_InMantissaSign,
138  TPS_InMantissa,
139  TPS_InXMLEntityFirst,
140  TPS_InXMLEntity,
141  TPS_InXMLEntityNumFirst,
142  TPS_InXMLEntityNum,
143  TPS_InXMLEntityHexNumFirst,
144  TPS_InXMLEntityHexNum,
145  TPS_InXMLEntityEnd,
146  TPS_InTagFirst,
147  TPS_InXMLBegin,
148  TPS_InTagCloseFirst,
149  TPS_InTagName,
150  TPS_InTagBeginEnd,
151  TPS_InTag,
152  TPS_InTagEscapeK,
153  TPS_InTagEscapeKK,
154  TPS_InTagBackSleshed,
155  TPS_InTagEnd,
156  TPS_InCommentFirst,
157  TPS_InCommentLast,
158  TPS_InComment,
159  TPS_InCloseCommentFirst,
160  TPS_InCloseCommentLast,
161  TPS_InCommentEnd,
162  TPS_InHostFirstDomain,
163  TPS_InHostDomainSecond,
164  TPS_InHostDomain,
165  TPS_InPortFirst,
166  TPS_InPort,
167  TPS_InHostFirstAN,
168  TPS_InHost,
169  TPS_InEmail,
170  TPS_InFileFirst,
171  TPS_InFileTwiddle,
172  TPS_InPathFirst,
173  TPS_InPathFirstFirst,
174  TPS_InPathSecond,
175  TPS_InFile,
176  TPS_InFileNext,
177  TPS_InURLPathFirst,
178  TPS_InURLPathStart,
179  TPS_InURLPath,
180  TPS_InFURL,
181  TPS_InProtocolFirst,
182  TPS_InProtocolSecond,
183  TPS_InProtocolEnd,
184  TPS_InHyphenAsciiWordFirst,
185  TPS_InHyphenAsciiWord,
186  TPS_InHyphenWordFirst,
187  TPS_InHyphenWord,
188  TPS_InHyphenNumWordFirst,
189  TPS_InHyphenNumWord,
190  TPS_InHyphenDigitLookahead,
191  TPS_InParseHyphen,
192  TPS_InParseHyphenHyphen,
193  TPS_InHyphenWordPart,
194  TPS_InHyphenAsciiWordPart,
195  TPS_InHyphenNumWordPart,
196  TPS_InHyphenUnsignedInt,
197  TPS_Null /* last state (fake value) */
198 } TParserState;
TParserState
TParserState
Definition: wparser_def.c:119
TPS_InXMLEntityHexNumFirst
@ TPS_InXMLEntityHexNumFirst
Definition: wparser_def.c:143
TPS_InPort
@ TPS_InPort
Definition: wparser_def.c:166
TPS_InXMLEntityHexNum
@ TPS_InXMLEntityHexNum
Definition: wparser_def.c:144
TPS_InHostDomainSecond
@ TPS_InHostDomainSecond
Definition: wparser_def.c:163
TPS_InMantissaFirst
@ TPS_InMantissaFirst
Definition: wparser_def.c:136
TPS_InTagName
@ TPS_InTagName
Definition: wparser_def.c:149
TPS_InHyphenAsciiWordFirst
@ TPS_InHyphenAsciiWordFirst
Definition: wparser_def.c:184
TPS_Null
@ TPS_Null
Definition: wparser_def.c:197
TPS_InPathFirstFirst
@ TPS_InPathFirstFirst
Definition: wparser_def.c:173
TPS_InSignedIntFirst
@ TPS_InSignedIntFirst
Definition: wparser_def.c:125
TPS_InSignedInt
@ TPS_InSignedInt
Definition: wparser_def.c:126
TPS_InUnsignedInt
@ TPS_InUnsignedInt
Definition: wparser_def.c:124
TPS_InMantissa
@ TPS_InMantissa
Definition: wparser_def.c:138
TPS_InProtocolFirst
@ TPS_InProtocolFirst
Definition: wparser_def.c:181
TPS_InFURL
@ TPS_InFURL
Definition: wparser_def.c:180
TPS_InMantissaSign
@ TPS_InMantissaSign
Definition: wparser_def.c:137
TPS_InXMLBegin
@ TPS_InXMLBegin
Definition: wparser_def.c:147
TPS_InCommentEnd
@ TPS_InCommentEnd
Definition: wparser_def.c:161
TPS_InHyphenWordFirst
@ TPS_InHyphenWordFirst
Definition: wparser_def.c:186
TPS_InHyphenNumWordPart
@ TPS_InHyphenNumWordPart
Definition: wparser_def.c:195
TPS_InPortFirst
@ TPS_InPortFirst
Definition: wparser_def.c:165
TPS_InProtocolEnd
@ TPS_InProtocolEnd
Definition: wparser_def.c:183
TPS_InXMLEntityFirst
@ TPS_InXMLEntityFirst
Definition: wparser_def.c:139
TPS_InHyphenNumWordFirst
@ TPS_InHyphenNumWordFirst
Definition: wparser_def.c:188
TPS_InCommentLast
@ TPS_InCommentLast
Definition: wparser_def.c:157
TPS_InFileTwiddle
@ TPS_InFileTwiddle
Definition: wparser_def.c:171
TPS_InURLPathStart
@ TPS_InURLPathStart
Definition: wparser_def.c:178
TPS_InURLPathFirst
@ TPS_InURLPathFirst
Definition: wparser_def.c:177
TPS_InPathFirst
@ TPS_InPathFirst
Definition: wparser_def.c:172
TPS_InPathSecond
@ TPS_InPathSecond
Definition: wparser_def.c:174
TPS_InHyphenUnsignedInt
@ TPS_InHyphenUnsignedInt
Definition: wparser_def.c:196
TPS_InFileFirst
@ TPS_InFileFirst
Definition: wparser_def.c:170
TPS_InXMLEntityNumFirst
@ TPS_InXMLEntityNumFirst
Definition: wparser_def.c:141
TPS_InHyphenWordPart
@ TPS_InHyphenWordPart
Definition: wparser_def.c:193
TPS_InNumWord
@ TPS_InNumWord
Definition: wparser_def.c:121
TPS_InAsciiWord
@ TPS_InAsciiWord
Definition: wparser_def.c:122
TPS_InVersion
@ TPS_InVersion
Definition: wparser_def.c:135
TPS_InHost
@ TPS_InHost
Definition: wparser_def.c:168
TPS_InFile
@ TPS_InFile
Definition: wparser_def.c:175
TPS_InProtocolSecond
@ TPS_InProtocolSecond
Definition: wparser_def.c:182
TPS_InCloseCommentFirst
@ TPS_InCloseCommentFirst
Definition: wparser_def.c:159
TPS_InTagEscapeK
@ TPS_InTagEscapeK
Definition: wparser_def.c:152
TPS_InParseHyphenHyphen
@ TPS_InParseHyphenHyphen
Definition: wparser_def.c:192
TPS_InTagBackSleshed
@ TPS_InTagBackSleshed
Definition: wparser_def.c:154
TPS_InTagFirst
@ TPS_InTagFirst
Definition: wparser_def.c:146
TPS_InTagEnd
@ TPS_InTagEnd
Definition: wparser_def.c:155
TPS_InComment
@ TPS_InComment
Definition: wparser_def.c:158
TPS_InHyphenWord
@ TPS_InHyphenWord
Definition: wparser_def.c:187
TPS_InHyphenAsciiWord
@ TPS_InHyphenAsciiWord
Definition: wparser_def.c:185
TPS_InWord
@ TPS_InWord
Definition: wparser_def.c:123
TPS_InXMLEntityEnd
@ TPS_InXMLEntityEnd
Definition: wparser_def.c:145
TPS_InTagEscapeKK
@ TPS_InTagEscapeKK
Definition: wparser_def.c:153
TPS_InSpace
@ TPS_InSpace
Definition: wparser_def.c:127
TPS_InFileNext
@ TPS_InFileNext
Definition: wparser_def.c:176
TPS_InURLPath
@ TPS_InURLPath
Definition: wparser_def.c:179
TPS_Base
@ TPS_Base
Definition: wparser_def.c:120
TPS_InUDecimal
@ TPS_InUDecimal
Definition: wparser_def.c:129
TPS_InParseHyphen
@ TPS_InParseHyphen
Definition: wparser_def.c:191
TPS_InHostFirstAN
@ TPS_InHostFirstAN
Definition: wparser_def.c:167
TPS_InEmail
@ TPS_InEmail
Definition: wparser_def.c:169
TPS_InDecimalFirst
@ TPS_InDecimalFirst
Definition: wparser_def.c:130
TPS_InVersionFirst
@ TPS_InVersionFirst
Definition: wparser_def.c:134
TPS_InCloseCommentLast
@ TPS_InCloseCommentLast
Definition: wparser_def.c:160
TPS_InSVerVersion
@ TPS_InSVerVersion
Definition: wparser_def.c:133
TPS_InHyphenAsciiWordPart
@ TPS_InHyphenAsciiWordPart
Definition: wparser_def.c:194
TPS_InCommentFirst
@ TPS_InCommentFirst
Definition: wparser_def.c:156
TPS_InUDecimalFirst
@ TPS_InUDecimalFirst
Definition: wparser_def.c:128
TPS_InHostFirstDomain
@ TPS_InHostFirstDomain
Definition: wparser_def.c:162
TPS_InHostDomain
@ TPS_InHostDomain
Definition: wparser_def.c:164
TPS_InHyphenDigitLookahead
@ TPS_InHyphenDigitLookahead
Definition: wparser_def.c:190
TPS_InVerVersion
@ TPS_InVerVersion
Definition: wparser_def.c:132
TPS_InXMLEntityNum
@ TPS_InXMLEntityNum
Definition: wparser_def.c:142
TPS_InTag
@ TPS_InTag
Definition: wparser_def.c:151
TPS_InDecimal
@ TPS_InDecimal
Definition: wparser_def.c:131
TPS_InTagCloseFirst
@ TPS_InTagCloseFirst
Definition: wparser_def.c:148
TPS_InXMLEntity
@ TPS_InXMLEntity
Definition: wparser_def.c:140
TPS_InHyphenNumWord
@ TPS_InHyphenNumWord
Definition: wparser_def.c:189
TPS_InTagBeginEnd
@ TPS_InTagBeginEnd
Definition: wparser_def.c:150

Function Documentation

◆ _make_compiler_happy()

void _make_compiler_happy ( void  )

Definition at line 536 of file wparser_def.c.

537 {
538  p_isalnum(NULL);
539  p_isnotalnum(NULL);
540  p_isalpha(NULL);
541  p_isnotalpha(NULL);
542  p_isdigit(NULL);
543  p_isnotdigit(NULL);
544  p_islower(NULL);
545  p_isnotlower(NULL);
546  p_isprint(NULL);
547  p_isnotprint(NULL);
548  p_ispunct(NULL);
549  p_isnotpunct(NULL);
550  p_isspace(NULL);
551  p_isnotspace(NULL);
552  p_isupper(NULL);
553  p_isnotupper(NULL);
554  p_isxdigit(NULL);
555  p_isnotxdigit(NULL);
556  p_isEOF(NULL);
557  p_iseqC(NULL);
558  p_isneC(NULL);
559 }
p_iseqC
static int p_iseqC(TParser *prs)
Definition: wparser_def.c:480
p_isneC
static int p_isneC(TParser *prs)
Definition: wparser_def.c:486
p_isEOF
static int p_isEOF(TParser *prs)
Definition: wparser_def.c:473

References p_isEOF(), p_iseqC(), and p_isneC().

◆ checkcondition_HL()

static TSTernaryValue checkcondition_HL ( void *  opaque,
QueryOperand *  val,
ExecPhraseData *  data 
)
static

Definition at line 1980 of file wparser_def.c.

1981 {
1982  hlCheck *checkval = (hlCheck *) opaque;
1983  int i;
1984 
1985  /* scan words array for matching items */
1986  for (i = 0; i < checkval->len; i++)
1987  {
1988  if (checkval->words[i].item == val)
1989  {
1990  /* if data == NULL, don't need to report positions */
1991  if (!data)
1992  return TS_YES;
1993 
1994  if (!data->pos)
1995  {
1996  data->pos = palloc(sizeof(WordEntryPos) * checkval->len);
1997  data->allocated = true;
1998  data->npos = 1;
1999  data->pos[0] = checkval->words[i].pos;
2000  }
2001  else if (data->pos[data->npos - 1] < checkval->words[i].pos)
2002  {
2003  data->pos[data->npos++] = checkval->words[i].pos;
2004  }
2005  }
2006  }
2007 
2008  if (data && data->npos > 0)
2009  return TS_YES;
2010 
2011  return TS_NO;
2012 }
val
long val
Definition: informix.c:664
i
int i
Definition: isn.c:73
palloc
void * palloc(Size size)
Definition: mcxt.c:1226
data
const void * data
Definition: pg_crc32c_sse42.c:23
HeadlineWordEntry::pos
WordEntryPos pos
Definition: ts_public.h:68
HeadlineWordEntry::item
QueryOperand * item
Definition: ts_public.h:70
hlCheck::words
HeadlineWordEntry * words
Definition: wparser_def.c:1967
WordEntryPos
uint16 WordEntryPos
Definition: ts_type.h:63
TS_NO
@ TS_NO
Definition: ts_utils.h:134
TS_YES
@ TS_YES
Definition: ts_utils.h:135

References data, i, HeadlineWordEntry::item, hlCheck::len, palloc(), HeadlineWordEntry::pos, TS_NO, TS_YES, val, and hlCheck::words.

Referenced by hlCover(), and prsd_headline().

◆ get_next_fragment()

static void get_next_fragment ( HeadlineParsedText *  prs,
int *  startpos,
int *  endpos,
int *  curlen,
int *  poslen,
int  max_words 
)
static

Definition at line 2219 of file wparser_def.c.

2221 {
2222  int i;
2223 
2224  /*
2225  * Objective: select a fragment of words between startpos and endpos such
2226  * that it has at most max_words and both ends have query words. If the
2227  * startpos and endpos are the endpoints of the cover and the cover has
2228  * fewer words than max_words, then this function should just return the
2229  * cover
2230  */
2231  /* first move startpos to an item */
2232  for (i = *startpos; i <= *endpos; i++)
2233  {
2234  *startpos = i;
2235  if (INTERESTINGWORD(i))
2236  break;
2237  }
2238  /* cut endpos to have only max_words */
2239  *curlen = 0;
2240  *poslen = 0;
2241  for (i = *startpos; i <= *endpos && *curlen < max_words; i++)
2242  {
2243  if (!NONWORDTOKEN(prs->words[i].type))
2244  *curlen += 1;
2245  if (INTERESTINGWORD(i))
2246  *poslen += 1;
2247  }
2248  /* if the cover was cut then move back endpos to a query item */
2249  if (*endpos > i)
2250  {
2251  *endpos = i;
2252  for (i = *endpos; i >= *startpos; i--)
2253  {
2254  *endpos = i;
2255  if (INTERESTINGWORD(i))
2256  break;
2257  if (!NONWORDTOKEN(prs->words[i].type))
2258  *curlen -= 1;
2259  }
2260  }
2261 }
endpos
static XLogRecPtr endpos
Definition: pg_receivewal.c:56
startpos
static XLogRecPtr startpos
Definition: pg_recvlogical.c:50
HeadlineParsedText::words
HeadlineWordEntry * words
Definition: ts_public.h:76
NONWORDTOKEN
#define NONWORDTOKEN(x)
Definition: wparser_def.c:1935

References endpos, i, INTERESTINGWORD, NONWORDTOKEN, startpos, HeadlineWordEntry::type, and HeadlineParsedText::words.

Referenced by mark_hl_fragments().

◆ hlCover()

static bool hlCover ( HeadlineParsedText *  prs,
TSQuery  query,
List *  locations,
int *  nextpos,
int *  p,
int *  q 
)
static

Definition at line 2031 of file wparser_def.c.

2033 {
2034  int pos = *nextpos;
2035 
2036  /* This loop repeats when our selected word-range fails the query */
2037  for (;;)
2038  {
2039  int posb,
2040  pose;
2041  ListCell *lc;
2042 
2043  /*
2044  * For each AND'ed query term or phrase, find its first occurrence at
2045  * or after pos; set pose to the maximum of those positions.
2046  *
2047  * We need not consider ORs or NOTs here; see the comments for
2048  * TS_execute_locations(). Rechecking the match with TS_execute(),
2049  * below, will deal with any ensuing imprecision.
2050  */
2051  pose = -1;
2052  foreach(lc, locations)
2053  {
2054  ExecPhraseData *pdata = (ExecPhraseData *) lfirst(lc);
2055  int first = -1;
2056 
2057  for (int i = 0; i < pdata->npos; i++)
2058  {
2059  /* For phrase matches, use the ending lexeme */
2060  int endp = pdata->pos[i];
2061 
2062  if (endp >= pos)
2063  {
2064  first = endp;
2065  break;
2066  }
2067  }
2068  if (first < 0)
2069  return false; /* no more matches for this term */
2070  if (first > pose)
2071  pose = first;
2072  }
2073 
2074  if (pose < 0)
2075  return false; /* we only get here if empty list */
2076 
2077  /*
2078  * Now, for each AND'ed query term or phrase, find its last occurrence
2079  * at or before pose; set posb to the minimum of those positions.
2080  *
2081  * We start posb at INT_MAX - 1 to guarantee no overflow if we compute
2082  * posb + 1 below.
2083  */
2084  posb = INT_MAX - 1;
2085  foreach(lc, locations)
2086  {
2087  ExecPhraseData *pdata = (ExecPhraseData *) lfirst(lc);
2088  int last = -1;
2089 
2090  for (int i = pdata->npos - 1; i >= 0; i--)
2091  {
2092  /* For phrase matches, use the starting lexeme */
2093  int startp = pdata->pos[i] - pdata->width;
2094 
2095  if (startp <= pose)
2096  {
2097  last = startp;
2098  break;
2099  }
2100  }
2101  if (last < posb)
2102  posb = last;
2103  }
2104 
2105  /*
2106  * We could end up with posb to the left of pos, in case some phrase
2107  * match crosses pos. Try the match starting at pos anyway, since the
2108  * result of TS_execute_locations is imprecise for phrase matches OR'd
2109  * with plain matches; that is, if the query is "(A <-> B) | C" then C
2110  * could match at pos even though the phrase match would have to
2111  * extend to the left of pos.
2112  */
2113  posb = Max(posb, pos);
2114 
2115  /* This test probably always succeeds, but be paranoid */
2116  if (posb <= pose)
2117  {
2118  /*
2119  * posb .. pose is now the shortest, earliest-after-pos range of
2120  * lexeme positions containing all the query terms. It will
2121  * contain all phrase matches, too, except in the corner case
2122  * described just above.
2123  *
2124  * Now convert these lexeme positions to indexes in prs->words[].
2125  */
2126  int idxb = -1;
2127  int idxe = -1;
2128 
2129  for (int i = 0; i < prs->curwords; i++)
2130  {
2131  if (prs->words[i].item == NULL)
2132  continue;
2133  if (idxb < 0 && prs->words[i].pos >= posb)
2134  idxb = i;
2135  if (prs->words[i].pos <= pose)
2136  idxe = i;
2137  else
2138  break;
2139  }
2140 
2141  /* This test probably always succeeds, but be paranoid */
2142  if (idxb >= 0 && idxe >= idxb)
2143  {
2144  /*
2145  * Finally, check that the selected range satisfies the query.
2146  * This should succeed in all simple cases; but odd cases
2147  * involving non-top-level NOT conditions or phrase matches
2148  * OR'd with other things could fail, since the result of
2149  * TS_execute_locations doesn't fully represent such things.
2150  */
2151  hlCheck ch;
2152 
2153  ch.words = &(prs->words[idxb]);
2154  ch.len = idxe - idxb + 1;
2155  if (TS_execute(GETQUERY(query), &ch,
2156  TS_EXEC_EMPTY, checkcondition_HL))
2157  {
2158  /* Match! Advance *nextpos and return the word range. */
2159  *nextpos = posb + 1;
2160  *p = idxb;
2161  *q = idxe;
2162  return true;
2163  }
2164  }
2165  }
2166 
2167  /*
2168  * Advance pos and try again. Any later workable match must start
2169  * beyond posb.
2170  */
2171  pos = posb + 1;
2172  }
2173  /* Can't get here, but stupider compilers complain if we leave it off */
2174  return false;
2175 }
GETQUERY
#define GETQUERY(x)
Definition: _int.h:157
Max
#define Max(x, y)
Definition: c.h:987
lfirst
#define lfirst(lc)
Definition: pg_list.h:172
ExecPhraseData::pos
WordEntryPos * pos
Definition: ts_utils.h:166
TS_EXEC_EMPTY
#define TS_EXEC_EMPTY
Definition: ts_utils.h:188
TS_execute
bool TS_execute(QueryItem *curitem, void *arg, uint32 flags, TSExecuteCallback chkcond)
Definition: tsvector_op.c:1856
checkcondition_HL
static TSTernaryValue checkcondition_HL(void *opaque, QueryOperand *val, ExecPhraseData *data)
Definition: wparser_def.c:1980

References checkcondition_HL(), HeadlineParsedText::curwords, GETQUERY, i, HeadlineWordEntry::item, hlCheck::len, lfirst, Max, ExecPhraseData::npos, HeadlineWordEntry::pos, ExecPhraseData::pos, TS_EXEC_EMPTY, TS_execute(), ExecPhraseData::width, hlCheck::words, and HeadlineParsedText::words.

Referenced by mark_hl_fragments(), and mark_hl_words().

◆ mark_fragment()

static void mark_fragment ( HeadlineParsedText *  prs,
bool  highlightall,
int  startpos,
int  endpos 
)
static

Definition at line 2183 of file wparser_def.c.

2185 {
2186  int i;
2187 
2188  for (i = startpos; i <= endpos; i++)
2189  {
2190  if (prs->words[i].item)
2191  prs->words[i].selected = 1;
2192  if (!highlightall)
2193  {
2194  if (HLIDREPLACE(prs->words[i].type))
2195  prs->words[i].replace = 1;
2196  else if (HLIDSKIP(prs->words[i].type))
2197  prs->words[i].skip = 1;
2198  }
2199  else
2200  {
2201  if (XMLHLIDSKIP(prs->words[i].type))
2202  prs->words[i].skip = 1;
2203  }
2204 
2205  prs->words[i].in = (prs->words[i].repeated) ? 0 : 1;
2206  }
2207 }
XMLHLIDSKIP
#define XMLHLIDSKIP(x)
Definition: wparser_def.c:1934
HLIDSKIP
#define HLIDSKIP(x)
Definition: wparser_def.c:1933
HLIDREPLACE
#define HLIDREPLACE(x)
Definition: wparser_def.c:1932

References endpos, HLIDREPLACE, HLIDSKIP, i, HeadlineWordEntry::in, HeadlineWordEntry::item, HeadlineWordEntry::repeated, HeadlineWordEntry::replace, HeadlineWordEntry::selected, HeadlineWordEntry::skip, startpos, HeadlineWordEntry::type, HeadlineParsedText::words, and XMLHLIDSKIP.

Referenced by mark_hl_fragments(), and mark_hl_words().

◆ mark_hl_fragments()

static void mark_hl_fragments ( HeadlineParsedText *  prs,
TSQuery  query,
List *  locations,
bool  highlightall,
int  shortword,
int  min_words,
int  max_words,
int  max_fragments 
)
static

Definition at line 2270 of file wparser_def.c.

2274 {
2275  int32 poslen,
2276  curlen,
2277  i,
2278  f,
2279  num_f = 0;
2280  int32 stretch,
2281  maxstretch,
2282  posmarker;
2283 
2284  int32 startpos = 0,
2285  endpos = 0,
2286  nextpos = 0,
2287  p = 0,
2288  q = 0;
2289 
2290  int32 numcovers = 0,
2291  maxcovers = 32;
2292 
2293  int32 minI,
2294  minwords,
2295  maxitems;
2296  CoverPos *covers;
2297 
2298  covers = palloc(maxcovers * sizeof(CoverPos));
2299 
2300  /* get all covers */
2301  while (hlCover(prs, query, locations, &nextpos, &p, &q))
2302  {
2303  startpos = p;
2304  endpos = q;
2305 
2306  /*
2307  * Break the cover into smaller fragments such that each fragment has
2308  * at most max_words. Also ensure that each end of each fragment is a
2309  * query word. This will allow us to stretch the fragment in either
2310  * direction
2311  */
2312 
2313  while (startpos <= endpos)
2314  {
2315  get_next_fragment(prs, &startpos, &endpos, &curlen, &poslen, max_words);
2316  if (numcovers >= maxcovers)
2317  {
2318  maxcovers *= 2;
2319  covers = repalloc(covers, sizeof(CoverPos) * maxcovers);
2320  }
2321  covers[numcovers].startpos = startpos;
2322  covers[numcovers].endpos = endpos;
2323  covers[numcovers].curlen = curlen;
2324  covers[numcovers].poslen = poslen;
2325  covers[numcovers].chosen = false;
2326  covers[numcovers].excluded = false;
2327  numcovers++;
2328  startpos = endpos + 1;
2329  endpos = q;
2330  }
2331  }
2332 
2333  /* choose best covers */
2334  for (f = 0; f < max_fragments; f++)
2335  {
2336  maxitems = 0;
2337  minwords = PG_INT32_MAX;
2338  minI = -1;
2339 
2340  /*
2341  * Choose the cover that contains max items. In case of tie choose the
2342  * one with smaller number of words.
2343  */
2344  for (i = 0; i < numcovers; i++)
2345  {
2346  if (!covers[i].chosen && !covers[i].excluded &&
2347  (maxitems < covers[i].poslen ||
2348  (maxitems == covers[i].poslen &&
2349  minwords > covers[i].curlen)))
2350  {
2351  maxitems = covers[i].poslen;
2352  minwords = covers[i].curlen;
2353  minI = i;
2354  }
2355  }
2356  /* if a cover was found mark it */
2357  if (minI >= 0)
2358  {
2359  covers[minI].chosen = true;
2360  /* adjust the size of cover */
2361  startpos = covers[minI].startpos;
2362  endpos = covers[minI].endpos;
2363  curlen = covers[minI].curlen;
2364  /* stretch the cover if cover size is lower than max_words */
2365  if (curlen < max_words)
2366  {
2367  /* divide the stretch on both sides of cover */
2368  maxstretch = (max_words - curlen) / 2;
2369 
2370  /*
2371  * first stretch the startpos stop stretching if 1. we hit the
2372  * beginning of document 2. exceed maxstretch 3. we hit an
2373  * already marked fragment
2374  */
2375  stretch = 0;
2376  posmarker = startpos;
2377  for (i = startpos - 1; i >= 0 && stretch < maxstretch && !prs->words[i].in; i--)
2378  {
2379  if (!NONWORDTOKEN(prs->words[i].type))
2380  {
2381  curlen++;
2382  stretch++;
2383  }
2384  posmarker = i;
2385  }
2386  /* cut back startpos till we find a good endpoint */
2387  for (i = posmarker; i < startpos && BADENDPOINT(i); i++)
2388  {
2389  if (!NONWORDTOKEN(prs->words[i].type))
2390  curlen--;
2391  }
2392  startpos = i;
2393  /* now stretch the endpos as much as possible */
2394  posmarker = endpos;
2395  for (i = endpos + 1; i < prs->curwords && curlen < max_words && !prs->words[i].in; i++)
2396  {
2397  if (!NONWORDTOKEN(prs->words[i].type))
2398  curlen++;
2399  posmarker = i;
2400  }
2401  /* cut back endpos till we find a good endpoint */
2402  for (i = posmarker; i > endpos && BADENDPOINT(i); i--)
2403  {
2404  if (!NONWORDTOKEN(prs->words[i].type))
2405  curlen--;
2406  }
2407  endpos = i;
2408  }
2409  covers[minI].startpos = startpos;
2410  covers[minI].endpos = endpos;
2411  covers[minI].curlen = curlen;
2412  /* Mark the chosen fragments (covers) */
2413  mark_fragment(prs, highlightall, startpos, endpos);
2414  num_f++;
2415  /* Exclude covers overlapping this one from future consideration */
2416  for (i = 0; i < numcovers; i++)
2417  {
2418  if (i != minI &&
2419  ((covers[i].startpos >= startpos &&
2420  covers[i].startpos <= endpos) ||
2421  (covers[i].endpos >= startpos &&
2422  covers[i].endpos <= endpos) ||
2423  (covers[i].startpos < startpos &&
2424  covers[i].endpos > endpos)))
2425  covers[i].excluded = true;
2426  }
2427  }
2428  else
2429  break; /* no selectable covers remain */
2430  }
2431 
2432  /* show the first min_words words if we have not marked anything */
2433  if (num_f <= 0)
2434  {
2435  startpos = curlen = 0;
2436  endpos = -1;
2437  for (i = 0; i < prs->curwords && curlen < min_words; i++)
2438  {
2439  if (!NONWORDTOKEN(prs->words[i].type))
2440  curlen++;
2441  endpos = i;
2442  }
2443  mark_fragment(prs, highlightall, startpos, endpos);
2444  }
2445 
2446  pfree(covers);
2447 }
PG_INT32_MAX
#define PG_INT32_MAX
Definition: c.h:578
int32
signed int int32
Definition: c.h:483
pfree
void pfree(void *pointer)
Definition: mcxt.c:1456
repalloc
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1476
CoverPos::chosen
bool chosen
Definition: wparser_def.c:1960
CoverPos::endpos
int32 endpos
Definition: wparser_def.c:1957
CoverPos::curlen
int32 curlen
Definition: wparser_def.c:1959
CoverPos::startpos
int32 startpos
Definition: wparser_def.c:1956
CoverPos::excluded
bool excluded
Definition: wparser_def.c:1961
CoverPos::poslen
int32 poslen
Definition: wparser_def.c:1958
BADENDPOINT
#define BADENDPOINT(j)
Definition: wparser_def.c:1949
mark_fragment
static void mark_fragment(HeadlineParsedText *prs, bool highlightall, int startpos, int endpos)
Definition: wparser_def.c:2183
hlCover
static bool hlCover(HeadlineParsedText *prs, TSQuery query, List *locations, int *nextpos, int *p, int *q)
Definition: wparser_def.c:2031
get_next_fragment
static void get_next_fragment(HeadlineParsedText *prs, int *startpos, int *endpos, int *curlen, int *poslen, int max_words)
Definition: wparser_def.c:2219

References BADENDPOINT, CoverPos::chosen, CoverPos::curlen, HeadlineParsedText::curwords, CoverPos::endpos, endpos, CoverPos::excluded, get_next_fragment(), hlCover(), i, HeadlineWordEntry::in, mark_fragment(), NONWORDTOKEN, palloc(), pfree(), PG_INT32_MAX, CoverPos::poslen, repalloc(), CoverPos::startpos, startpos, HeadlineWordEntry::type, and HeadlineParsedText::words.

Referenced by prsd_headline().

◆ mark_hl_words()

static void mark_hl_words ( HeadlineParsedText *  prs,
TSQuery  query,
List *  locations,
bool  highlightall,
int  shortword,
int  min_words,
int  max_words 
)
static

Definition at line 2453 of file wparser_def.c.

2456 {
2457  int nextpos = 0,
2458  p = 0,
2459  q = 0;
2460  int bestb = -1,
2461  beste = -1;
2462  int bestlen = -1;
2463  bool bestcover = false;
2464  int pose,
2465  posb,
2466  poslen,
2467  curlen;
2468  bool poscover;
2469  int i;
2470 
2471  if (!highlightall)
2472  {
2473  /* examine all covers, select a headline using the best one */
2474  while (hlCover(prs, query, locations, &nextpos, &p, &q))
2475  {
2476  /*
2477  * Count words (curlen) and interesting words (poslen) within
2478  * cover, but stop once we reach max_words. This step doesn't
2479  * consider whether that's a good stopping point. posb and pose
2480  * are set to the start and end indexes of the possible headline.
2481  */
2482  curlen = 0;
2483  poslen = 0;
2484  posb = pose = p;
2485  for (i = p; i <= q && curlen < max_words; i++)
2486  {
2487  if (!NONWORDTOKEN(prs->words[i].type))
2488  curlen++;
2489  if (INTERESTINGWORD(i))
2490  poslen++;
2491  pose = i;
2492  }
2493 
2494  if (curlen < max_words)
2495  {
2496  /*
2497  * We have room to lengthen the headline, so search forward
2498  * until it's full or we find a good stopping point. We'll
2499  * reconsider the word at "q", then move forward.
2500  */
2501  for (i = i - 1; i < prs->curwords && curlen < max_words; i++)
2502  {
2503  if (i > q)
2504  {
2505  if (!NONWORDTOKEN(prs->words[i].type))
2506  curlen++;
2507  if (INTERESTINGWORD(i))
2508  poslen++;
2509  }
2510  pose = i;
2511  if (BADENDPOINT(i))
2512  continue;
2513  if (curlen >= min_words)
2514  break;
2515  }
2516  if (curlen < min_words)
2517  {
2518  /*
2519  * Reached end of text and our headline is still shorter
2520  * than min_words, so try to extend it to the left.
2521  */
2522  for (i = p - 1; i >= 0; i--)
2523  {
2524  if (!NONWORDTOKEN(prs->words[i].type))
2525  curlen++;
2526  if (INTERESTINGWORD(i))
2527  poslen++;
2528  if (curlen >= max_words)
2529  break;
2530  if (BADENDPOINT(i))
2531  continue;
2532  if (curlen >= min_words)
2533  break;
2534  }
2535  posb = (i >= 0) ? i : 0;
2536  }
2537  }
2538  else
2539  {
2540  /*
2541  * Can't make headline longer, so consider making it shorter
2542  * if needed to avoid a bad endpoint.
2543  */
2544  if (i > q)
2545  i = q;
2546  for (; curlen > min_words; i--)
2547  {
2548  if (!BADENDPOINT(i))
2549  break;
2550  if (!NONWORDTOKEN(prs->words[i].type))
2551  curlen--;
2552  if (INTERESTINGWORD(i))
2553  poslen--;
2554  pose = i - 1;
2555  }
2556  }
2557 
2558  /*
2559  * Check whether the proposed headline includes the original
2560  * cover; it might not if we trimmed it due to max_words.
2561  */
2562  poscover = (posb <= p && pose >= q);
2563 
2564  /*
2565  * Adopt this headline if it's better than the last one, giving
2566  * highest priority to headlines including the cover, then to
2567  * headlines with more interesting words, then to headlines with
2568  * good stopping points. (Since bestlen is initially -1, we will
2569  * certainly adopt the first headline.)
2570  */
2571  if (poscover > bestcover ||
2572  (poscover == bestcover && poslen > bestlen) ||
2573  (poscover == bestcover && poslen == bestlen &&
2574  !BADENDPOINT(pose) && BADENDPOINT(beste)))
2575  {
2576  bestb = posb;
2577  beste = pose;
2578  bestlen = poslen;
2579  bestcover = poscover;
2580  }
2581  }
2582 
2583  /*
2584  * If we found nothing acceptable, select min_words words starting at
2585  * the beginning.
2586  */
2587  if (bestlen < 0)
2588  {
2589  curlen = 0;
2590  pose = -1;
2591  for (i = 0; i < prs->curwords && curlen < min_words; i++)
2592  {
2593  if (!NONWORDTOKEN(prs->words[i].type))
2594  curlen++;
2595  pose = i;
2596  }
2597  bestb = 0;
2598  beste = pose;
2599  }
2600  }
2601  else
2602  {
2603  /* highlightall mode: headline is whole document */
2604  bestb = 0;
2605  beste = prs->curwords - 1;
2606  }
2607 
2608  mark_fragment(prs, highlightall, bestb, beste);
2609 }

References BADENDPOINT, HeadlineParsedText::curwords, hlCover(), i, INTERESTINGWORD, mark_fragment(), NONWORDTOKEN, HeadlineWordEntry::type, and HeadlineParsedText::words.

Referenced by prsd_headline().

◆ newTParserPosition()

static TParserPosition* newTParserPosition ( TParserPosition *  prev)
static

Definition at line 271 of file wparser_def.c.

272 {
273  TParserPosition *res = (TParserPosition *) palloc(sizeof(TParserPosition));
274 
275  if (prev)
276  memcpy(res, prev, sizeof(TParserPosition));
277  else
278  memset(res, 0, sizeof(TParserPosition));
279 
280  res->prev = prev;
281 
282  res->pushedAtAction = NULL;
283 
284  return res;
285 }

References palloc(), and res.

Referenced by p_isURLPath(), TParserCopyInit(), TParserGet(), and TParserInit().

◆ p_isascii()

static int p_isascii ( TParser *  prs)
static

Definition at line 492 of file wparser_def.c.

493 {
494  return (prs->state->charlen == 1 && isascii((unsigned char) *(prs->str + prs->state->posbyte))) ? 1 : 0;
495 }
TParser::str
char * str
Definition: wparser_def.c:243
TParser::state
TParserPosition * state
Definition: wparser_def.c:251

References TParserPosition::charlen, TParserPosition::posbyte, TParser::state, and TParser::str.

Referenced by p_isasclet().

◆ p_isasclet()

static int p_isasclet ( TParser *  prs)
static

Definition at line 498 of file wparser_def.c.

499 {
500  return (p_isascii(prs) && p_isalpha(prs)) ? 1 : 0;
501 }
p_isascii
static int p_isascii(TParser *prs)
Definition: wparser_def.c:492

References p_isascii().

◆ p_isEOF()

static int p_isEOF ( TParser *  prs)
static

Definition at line 473 of file wparser_def.c.

474 {
475  Assert(prs->state);
476  return (prs->state->posbyte == prs->lenstr || prs->state->charlen == 0) ? 1 : 0;
477 }
Assert
Assert(fmt[strlen(fmt) - 1] !='\n')
TParser::lenstr
int lenstr
Definition: wparser_def.c:244

References Assert(), TParserPosition::charlen, TParser::lenstr, TParserPosition::posbyte, and TParser::state.

Referenced by _make_compiler_happy().

◆ p_iseqC()

static int p_iseqC ( TParser *  prs)
static

Definition at line 480 of file wparser_def.c.

481 {
482  return p_iseq(prs, prs->c);
483 }
TParser::c
char c
Definition: wparser_def.c:256

References TParser::c.

Referenced by _make_compiler_happy().

◆ p_ishost()

static int p_ishost ( TParser *  prs)
static

Definition at line 628 of file wparser_def.c.

629 {
630  TParser *tmpprs = TParserCopyInit(prs);
631  int res = 0;
632 
633  tmpprs->wanthost = true;
634 
635  /*
636  * Check stack depth before recursing. (Since TParserGet() doesn't
637  * normally recurse, we put the cost of checking here not there.)
638  */
639  check_stack_depth();
640 
641  if (TParserGet(tmpprs) && tmpprs->type == HOST)
642  {
643  prs->state->posbyte += tmpprs->lenbytetoken;
644  prs->state->poschar += tmpprs->lenchartoken;
645  prs->state->lenbytetoken += tmpprs->lenbytetoken;
646  prs->state->lenchartoken += tmpprs->lenchartoken;
647  prs->state->charlen = tmpprs->state->charlen;
648  res = 1;
649  }
650  TParserCopyClose(tmpprs);
651 
652  return res;
653 }
check_stack_depth
void check_stack_depth(void)
Definition: postgres.c:3520
TParser::type
int type
Definition: wparser_def.c:262
TParser::wanthost
bool wanthost
Definition: wparser_def.c:253
TParser::lenbytetoken
int lenbytetoken
Definition: wparser_def.c:260
TParser::lenchartoken
int lenchartoken
Definition: wparser_def.c:261
TParserCopyInit
static TParser * TParserCopyInit(const TParser *orig)
Definition: wparser_def.c:345
HOST
#define HOST
Definition: wparser_def.c:40
TParserGet
static bool TParserGet(TParser *prs)
Definition: wparser_def.c:1709
TParserCopyClose
static void TParserCopyClose(TParser *prs)
Definition: wparser_def.c:396

References TParserPosition::charlen, check_stack_depth(), HOST, TParserPosition::lenbytetoken, TParser::lenbytetoken, TParserPosition::lenchartoken, TParser::lenchartoken, TParserPosition::posbyte, TParserPosition::poschar, res, TParser::state, TParserCopyClose(), TParserCopyInit(), TParserGet(), TParser::type, and TParser::wanthost.

◆ p_isignore()

static int p_isignore ( TParser *  prs)
static

Definition at line 622 of file wparser_def.c.

623 {
624  return (prs->ignore) ? 1 : 0;
625 }
TParser::ignore
bool ignore
Definition: wparser_def.c:252

References TParser::ignore.

◆ p_isneC()

static int p_isneC ( TParser *  prs)
static

Definition at line 486 of file wparser_def.c.

487 {
488  return !p_iseq(prs, prs->c);
489 }

References TParser::c.

Referenced by _make_compiler_happy().

◆ p_isspecial()

static int p_isspecial ( TParser *  prs)
static

Definition at line 691 of file wparser_def.c.

692 {
693  /*
694  * pg_dsplen could return -1 which means error or control character
695  */
696  if (pg_dsplen(prs->str + prs->state->posbyte) == 0)
697  return 1;
698 
699  /*
700  * Unicode Characters in the 'Mark, Spacing Combining' Category That
701  * characters are not alpha although they are not breakers of word too.
702  * Check that only in utf encoding, because other encodings aren't
703  * supported by postgres or even exists.
704  */
705  if (GetDatabaseEncoding() == PG_UTF8 && prs->usewide)
706  {
707  static const pg_wchar strange_letter[] = {
708  /*
709  * use binary search, so elements should be ordered
710  */
711  0x0903, /* DEVANAGARI SIGN VISARGA */
712  0x093E, /* DEVANAGARI VOWEL SIGN AA */
713  0x093F, /* DEVANAGARI VOWEL SIGN I */
714  0x0940, /* DEVANAGARI VOWEL SIGN II */
715  0x0949, /* DEVANAGARI VOWEL SIGN CANDRA O */
716  0x094A, /* DEVANAGARI VOWEL SIGN SHORT O */
717  0x094B, /* DEVANAGARI VOWEL SIGN O */
718  0x094C, /* DEVANAGARI VOWEL SIGN AU */
719  0x0982, /* BENGALI SIGN ANUSVARA */
720  0x0983, /* BENGALI SIGN VISARGA */
721  0x09BE, /* BENGALI VOWEL SIGN AA */
722  0x09BF, /* BENGALI VOWEL SIGN I */
723  0x09C0, /* BENGALI VOWEL SIGN II */
724  0x09C7, /* BENGALI VOWEL SIGN E */
725  0x09C8, /* BENGALI VOWEL SIGN AI */
726  0x09CB, /* BENGALI VOWEL SIGN O */
727  0x09CC, /* BENGALI VOWEL SIGN AU */
728  0x09D7, /* BENGALI AU LENGTH MARK */
729  0x0A03, /* GURMUKHI SIGN VISARGA */
730  0x0A3E, /* GURMUKHI VOWEL SIGN AA */
731  0x0A3F, /* GURMUKHI VOWEL SIGN I */
732  0x0A40, /* GURMUKHI VOWEL SIGN II */
733  0x0A83, /* GUJARATI SIGN VISARGA */
734  0x0ABE, /* GUJARATI VOWEL SIGN AA */
735  0x0ABF, /* GUJARATI VOWEL SIGN I */
736  0x0AC0, /* GUJARATI VOWEL SIGN II */
737  0x0AC9, /* GUJARATI VOWEL SIGN CANDRA O */
738  0x0ACB, /* GUJARATI VOWEL SIGN O */
739  0x0ACC, /* GUJARATI VOWEL SIGN AU */
740  0x0B02, /* ORIYA SIGN ANUSVARA */
741  0x0B03, /* ORIYA SIGN VISARGA */
742  0x0B3E, /* ORIYA VOWEL SIGN AA */
743  0x0B40, /* ORIYA VOWEL SIGN II */
744  0x0B47, /* ORIYA VOWEL SIGN E */
745  0x0B48, /* ORIYA VOWEL SIGN AI */
746  0x0B4B, /* ORIYA VOWEL SIGN O */
747  0x0B4C, /* ORIYA VOWEL SIGN AU */
748  0x0B57, /* ORIYA AU LENGTH MARK */
749  0x0BBE, /* TAMIL VOWEL SIGN AA */
750  0x0BBF, /* TAMIL VOWEL SIGN I */
751  0x0BC1, /* TAMIL VOWEL SIGN U */
752  0x0BC2, /* TAMIL VOWEL SIGN UU */
753  0x0BC6, /* TAMIL VOWEL SIGN E */
754  0x0BC7, /* TAMIL VOWEL SIGN EE */
755  0x0BC8, /* TAMIL VOWEL SIGN AI */
756  0x0BCA, /* TAMIL VOWEL SIGN O */
757  0x0BCB, /* TAMIL VOWEL SIGN OO */
758  0x0BCC, /* TAMIL VOWEL SIGN AU */
759  0x0BD7, /* TAMIL AU LENGTH MARK */
760  0x0C01, /* TELUGU SIGN CANDRABINDU */
761  0x0C02, /* TELUGU SIGN ANUSVARA */
762  0x0C03, /* TELUGU SIGN VISARGA */
763  0x0C41, /* TELUGU VOWEL SIGN U */
764  0x0C42, /* TELUGU VOWEL SIGN UU */
765  0x0C43, /* TELUGU VOWEL SIGN VOCALIC R */
766  0x0C44, /* TELUGU VOWEL SIGN VOCALIC RR */
767  0x0C82, /* KANNADA SIGN ANUSVARA */
768  0x0C83, /* KANNADA SIGN VISARGA */
769  0x0CBE, /* KANNADA VOWEL SIGN AA */
770  0x0CC0, /* KANNADA VOWEL SIGN II */
771  0x0CC1, /* KANNADA VOWEL SIGN U */
772  0x0CC2, /* KANNADA VOWEL SIGN UU */
773  0x0CC3, /* KANNADA VOWEL SIGN VOCALIC R */
774  0x0CC4, /* KANNADA VOWEL SIGN VOCALIC RR */
775  0x0CC7, /* KANNADA VOWEL SIGN EE */
776  0x0CC8, /* KANNADA VOWEL SIGN AI */
777  0x0CCA, /* KANNADA VOWEL SIGN O */
778  0x0CCB, /* KANNADA VOWEL SIGN OO */
779  0x0CD5, /* KANNADA LENGTH MARK */
780  0x0CD6, /* KANNADA AI LENGTH MARK */
781  0x0D02, /* MALAYALAM SIGN ANUSVARA */
782  0x0D03, /* MALAYALAM SIGN VISARGA */
783  0x0D3E, /* MALAYALAM VOWEL SIGN AA */
784  0x0D3F, /* MALAYALAM VOWEL SIGN I */
785  0x0D40, /* MALAYALAM VOWEL SIGN II */
786  0x0D46, /* MALAYALAM VOWEL SIGN E */
787  0x0D47, /* MALAYALAM VOWEL SIGN EE */
788  0x0D48, /* MALAYALAM VOWEL SIGN AI */
789  0x0D4A, /* MALAYALAM VOWEL SIGN O */
790  0x0D4B, /* MALAYALAM VOWEL SIGN OO */
791  0x0D4C, /* MALAYALAM VOWEL SIGN AU */
792  0x0D57, /* MALAYALAM AU LENGTH MARK */
793  0x0D82, /* SINHALA SIGN ANUSVARAYA */
794  0x0D83, /* SINHALA SIGN VISARGAYA */
795  0x0DCF, /* SINHALA VOWEL SIGN AELA-PILLA */
796  0x0DD0, /* SINHALA VOWEL SIGN KETTI AEDA-PILLA */
797  0x0DD1, /* SINHALA VOWEL SIGN DIGA AEDA-PILLA */
798  0x0DD8, /* SINHALA VOWEL SIGN GAETTA-PILLA */
799  0x0DD9, /* SINHALA VOWEL SIGN KOMBUVA */
800  0x0DDA, /* SINHALA VOWEL SIGN DIGA KOMBUVA */
801  0x0DDB, /* SINHALA VOWEL SIGN KOMBU DEKA */
802  0x0DDC, /* SINHALA VOWEL SIGN KOMBUVA HAA AELA-PILLA */
803  0x0DDD, /* SINHALA VOWEL SIGN KOMBUVA HAA DIGA
804  * AELA-PILLA */
805  0x0DDE, /* SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA */
806  0x0DDF, /* SINHALA VOWEL SIGN GAYANUKITTA */
807  0x0DF2, /* SINHALA VOWEL SIGN DIGA GAETTA-PILLA */
808  0x0DF3, /* SINHALA VOWEL SIGN DIGA GAYANUKITTA */
809  0x0F3E, /* TIBETAN SIGN YAR TSHES */
810  0x0F3F, /* TIBETAN SIGN MAR TSHES */
811  0x0F7F, /* TIBETAN SIGN RNAM BCAD */
812  0x102B, /* MYANMAR VOWEL SIGN TALL AA */
813  0x102C, /* MYANMAR VOWEL SIGN AA */
814  0x1031, /* MYANMAR VOWEL SIGN E */
815  0x1038, /* MYANMAR SIGN VISARGA */
816  0x103B, /* MYANMAR CONSONANT SIGN MEDIAL YA */
817  0x103C, /* MYANMAR CONSONANT SIGN MEDIAL RA */
818  0x1056, /* MYANMAR VOWEL SIGN VOCALIC R */
819  0x1057, /* MYANMAR VOWEL SIGN VOCALIC RR */
820  0x1062, /* MYANMAR VOWEL SIGN SGAW KAREN EU */
821  0x1063, /* MYANMAR TONE MARK SGAW KAREN HATHI */
822  0x1064, /* MYANMAR TONE MARK SGAW KAREN KE PHO */
823  0x1067, /* MYANMAR VOWEL SIGN WESTERN PWO KAREN EU */
824  0x1068, /* MYANMAR VOWEL SIGN WESTERN PWO KAREN UE */
825  0x1069, /* MYANMAR SIGN WESTERN PWO KAREN TONE-1 */
826  0x106A, /* MYANMAR SIGN WESTERN PWO KAREN TONE-2 */
827  0x106B, /* MYANMAR SIGN WESTERN PWO KAREN TONE-3 */
828  0x106C, /* MYANMAR SIGN WESTERN PWO KAREN TONE-4 */
829  0x106D, /* MYANMAR SIGN WESTERN PWO KAREN TONE-5 */
830  0x1083, /* MYANMAR VOWEL SIGN SHAN AA */
831  0x1084, /* MYANMAR VOWEL SIGN SHAN E */
832  0x1087, /* MYANMAR SIGN SHAN TONE-2 */
833  0x1088, /* MYANMAR SIGN SHAN TONE-3 */
834  0x1089, /* MYANMAR SIGN SHAN TONE-5 */
835  0x108A, /* MYANMAR SIGN SHAN TONE-6 */
836  0x108B, /* MYANMAR SIGN SHAN COUNCIL TONE-2 */
837  0x108C, /* MYANMAR SIGN SHAN COUNCIL TONE-3 */
838  0x108F, /* MYANMAR SIGN RUMAI PALAUNG TONE-5 */
839  0x17B6, /* KHMER VOWEL SIGN AA */
840  0x17BE, /* KHMER VOWEL SIGN OE */
841  0x17BF, /* KHMER VOWEL SIGN YA */
842  0x17C0, /* KHMER VOWEL SIGN IE */
843  0x17C1, /* KHMER VOWEL SIGN E */
844  0x17C2, /* KHMER VOWEL SIGN AE */
845  0x17C3, /* KHMER VOWEL SIGN AI */
846  0x17C4, /* KHMER VOWEL SIGN OO */
847  0x17C5, /* KHMER VOWEL SIGN AU */
848  0x17C7, /* KHMER SIGN REAHMUK */
849  0x17C8, /* KHMER SIGN YUUKALEAPINTU */
850  0x1923, /* LIMBU VOWEL SIGN EE */
851  0x1924, /* LIMBU VOWEL SIGN AI */
852  0x1925, /* LIMBU VOWEL SIGN OO */
853  0x1926, /* LIMBU VOWEL SIGN AU */
854  0x1929, /* LIMBU SUBJOINED LETTER YA */
855  0x192A, /* LIMBU SUBJOINED LETTER RA */
856  0x192B, /* LIMBU SUBJOINED LETTER WA */
857  0x1930, /* LIMBU SMALL LETTER KA */
858  0x1931, /* LIMBU SMALL LETTER NGA */
859  0x1933, /* LIMBU SMALL LETTER TA */
860  0x1934, /* LIMBU SMALL LETTER NA */
861  0x1935, /* LIMBU SMALL LETTER PA */
862  0x1936, /* LIMBU SMALL LETTER MA */
863  0x1937, /* LIMBU SMALL LETTER RA */
864  0x1938, /* LIMBU SMALL LETTER LA */
865  0x19B0, /* NEW TAI LUE VOWEL SIGN VOWEL SHORTENER */
866  0x19B1, /* NEW TAI LUE VOWEL SIGN AA */
867  0x19B2, /* NEW TAI LUE VOWEL SIGN II */
868  0x19B3, /* NEW TAI LUE VOWEL SIGN U */
869  0x19B4, /* NEW TAI LUE VOWEL SIGN UU */
870  0x19B5, /* NEW TAI LUE VOWEL SIGN E */
871  0x19B6, /* NEW TAI LUE VOWEL SIGN AE */
872  0x19B7, /* NEW TAI LUE VOWEL SIGN O */
873  0x19B8, /* NEW TAI LUE VOWEL SIGN OA */
874  0x19B9, /* NEW TAI LUE VOWEL SIGN UE */
875  0x19BA, /* NEW TAI LUE VOWEL SIGN AY */
876  0x19BB, /* NEW TAI LUE VOWEL SIGN AAY */
877  0x19BC, /* NEW TAI LUE VOWEL SIGN UY */
878  0x19BD, /* NEW TAI LUE VOWEL SIGN OY */
879  0x19BE, /* NEW TAI LUE VOWEL SIGN OAY */
880  0x19BF, /* NEW TAI LUE VOWEL SIGN UEY */
881  0x19C0, /* NEW TAI LUE VOWEL SIGN IY */
882  0x19C8, /* NEW TAI LUE TONE MARK-1 */
883  0x19C9, /* NEW TAI LUE TONE MARK-2 */
884  0x1A19, /* BUGINESE VOWEL SIGN E */
885  0x1A1A, /* BUGINESE VOWEL SIGN O */
886  0x1A1B, /* BUGINESE VOWEL SIGN AE */
887  0x1B04, /* BALINESE SIGN BISAH */
888  0x1B35, /* BALINESE VOWEL SIGN TEDUNG */
889  0x1B3B, /* BALINESE VOWEL SIGN RA REPA TEDUNG */
890  0x1B3D, /* BALINESE VOWEL SIGN LA LENGA TEDUNG */
891  0x1B3E, /* BALINESE VOWEL SIGN TALING */
892  0x1B3F, /* BALINESE VOWEL SIGN TALING REPA */
893  0x1B40, /* BALINESE VOWEL SIGN TALING TEDUNG */
894  0x1B41, /* BALINESE VOWEL SIGN TALING REPA TEDUNG */
895  0x1B43, /* BALINESE VOWEL SIGN PEPET TEDUNG */
896  0x1B44, /* BALINESE ADEG ADEG */
897  0x1B82, /* SUNDANESE SIGN PANGWISAD */
898  0x1BA1, /* SUNDANESE CONSONANT SIGN PAMINGKAL */
899  0x1BA6, /* SUNDANESE VOWEL SIGN PANAELAENG */
900  0x1BA7, /* SUNDANESE VOWEL SIGN PANOLONG */
901  0x1BAA, /* SUNDANESE SIGN PAMAAEH */
902  0x1C24, /* LEPCHA SUBJOINED LETTER YA */
903  0x1C25, /* LEPCHA SUBJOINED LETTER RA */
904  0x1C26, /* LEPCHA VOWEL SIGN AA */
905  0x1C27, /* LEPCHA VOWEL SIGN I */
906  0x1C28, /* LEPCHA VOWEL SIGN O */
907  0x1C29, /* LEPCHA VOWEL SIGN OO */
908  0x1C2A, /* LEPCHA VOWEL SIGN U */
909  0x1C2B, /* LEPCHA VOWEL SIGN UU */
910  0x1C34, /* LEPCHA CONSONANT SIGN NYIN-DO */
911  0x1C35, /* LEPCHA CONSONANT SIGN KANG */
912  0xA823, /* SYLOTI NAGRI VOWEL SIGN A */
913  0xA824, /* SYLOTI NAGRI VOWEL SIGN I */
914  0xA827, /* SYLOTI NAGRI VOWEL SIGN OO */
915  0xA880, /* SAURASHTRA SIGN ANUSVARA */
916  0xA881, /* SAURASHTRA SIGN VISARGA */
917  0xA8B4, /* SAURASHTRA CONSONANT SIGN HAARU */
918  0xA8B5, /* SAURASHTRA VOWEL SIGN AA */
919  0xA8B6, /* SAURASHTRA VOWEL SIGN I */
920  0xA8B7, /* SAURASHTRA VOWEL SIGN II */
921  0xA8B8, /* SAURASHTRA VOWEL SIGN U */
922  0xA8B9, /* SAURASHTRA VOWEL SIGN UU */
923  0xA8BA, /* SAURASHTRA VOWEL SIGN VOCALIC R */
924  0xA8BB, /* SAURASHTRA VOWEL SIGN VOCALIC RR */
925  0xA8BC, /* SAURASHTRA VOWEL SIGN VOCALIC L */
926  0xA8BD, /* SAURASHTRA VOWEL SIGN VOCALIC LL */
927  0xA8BE, /* SAURASHTRA VOWEL SIGN E */
928  0xA8BF, /* SAURASHTRA VOWEL SIGN EE */
929  0xA8C0, /* SAURASHTRA VOWEL SIGN AI */
930  0xA8C1, /* SAURASHTRA VOWEL SIGN O */
931  0xA8C2, /* SAURASHTRA VOWEL SIGN OO */
932  0xA8C3, /* SAURASHTRA VOWEL SIGN AU */
933  0xA952, /* REJANG CONSONANT SIGN H */
934  0xA953, /* REJANG VIRAMA */
935  0xAA2F, /* CHAM VOWEL SIGN O */
936  0xAA30, /* CHAM VOWEL SIGN AI */
937  0xAA33, /* CHAM CONSONANT SIGN YA */
938  0xAA34, /* CHAM CONSONANT SIGN RA */
939  0xAA4D /* CHAM CONSONANT SIGN FINAL H */
940  };
941  const pg_wchar *StopLow = strange_letter,
942  *StopHigh = strange_letter + lengthof(strange_letter),
943  *StopMiddle;
944  pg_wchar c;
945 
946  if (prs->pgwstr)
947  c = *(prs->pgwstr + prs->state->poschar);
948  else
949  c = (pg_wchar) *(prs->wstr + prs->state->poschar);
950 
951  while (StopLow < StopHigh)
952  {
953  StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
954  if (*StopMiddle == c)
955  return 1;
956  else if (*StopMiddle < c)
957  StopLow = StopMiddle + 1;
958  else
959  StopHigh = StopMiddle;
960  }
961  }
962 
963  return 0;
964 }
lengthof
#define lengthof(array)
Definition: c.h:777
pg_wchar
unsigned int pg_wchar
Definition: mbprint.c:31
GetDatabaseEncoding
int GetDatabaseEncoding(void)
Definition: mbutils.c:1268
pg_dsplen
int pg_dsplen(const char *mbstr)
Definition: mbutils.c:1031
PG_UTF8
@ PG_UTF8
Definition: pg_wchar.h:235
TParser::pgwstr
pg_wchar * pgwstr
Definition: wparser_def.c:246
TParser::wstr
wchar_t * wstr
Definition: wparser_def.c:245
TParser::usewide
bool usewide
Definition: wparser_def.c:247

References GetDatabaseEncoding(), lengthof, pg_dsplen(), PG_UTF8, TParser::pgwstr, TParserPosition::posbyte, TParserPosition::poschar, TParser::state, TParser::str, TParser::usewide, and TParser::wstr.

◆ p_isstophost()

static int p_isstophost ( TParser *  prs)
static

Definition at line 611 of file wparser_def.c.

612 {
613  if (prs->wanthost)
614  {
615  prs->wanthost = false;
616  return 1;
617  }
618  return 0;
619 }

References TParser::wanthost.

◆ p_isurlchar()

static int p_isurlchar ( TParser *  prs)
static

Definition at line 504 of file wparser_def.c.

505 {
506  char ch;
507 
508  /* no non-ASCII need apply */
509  if (prs->state->charlen != 1)
510  return 0;
511  ch = *(prs->str + prs->state->posbyte);
512  /* no spaces or control characters */
513  if (ch <= 0x20 || ch >= 0x7F)
514  return 0;
515  /* reject characters disallowed by RFC 3986 */
516  switch (ch)
517  {
518  case '"':
519  case '<':
520  case '>':
521  case '\\':
522  case '^':
523  case '`':
524  case '{':
525  case '|':
526  case '}':
527  return 0;
528  }
529  return 1;
530 }

References TParserPosition::charlen, TParserPosition::posbyte, TParser::state, and TParser::str.

◆ p_isURLPath()

static int p_isURLPath ( TParser *  prs)
static

Definition at line 656 of file wparser_def.c.

657 {
658  TParser *tmpprs = TParserCopyInit(prs);
659  int res = 0;
660 
661  tmpprs->state = newTParserPosition(tmpprs->state);
662  tmpprs->state->state = TPS_InURLPathFirst;
663 
664  /*
665  * Check stack depth before recursing. (Since TParserGet() doesn't
666  * normally recurse, we put the cost of checking here not there.)
667  */
668  check_stack_depth();
669 
670  if (TParserGet(tmpprs) && tmpprs->type == URLPATH)
671  {
672  prs->state->posbyte += tmpprs->lenbytetoken;
673  prs->state->poschar += tmpprs->lenchartoken;
674  prs->state->lenbytetoken += tmpprs->lenbytetoken;
675  prs->state->lenchartoken += tmpprs->lenchartoken;
676  prs->state->charlen = tmpprs->state->charlen;
677  res = 1;
678  }
679  TParserCopyClose(tmpprs);
680 
681  return res;
682 }
TParserPosition::state
TParserState state
Definition: wparser_def.c:235
newTParserPosition
static TParserPosition * newTParserPosition(TParserPosition *prev)
Definition: wparser_def.c:271
URLPATH
#define URLPATH
Definition: wparser_def.c:52

References TParserPosition::charlen, check_stack_depth(), TParserPosition::lenbytetoken, TParser::lenbytetoken, TParserPosition::lenchartoken, TParser::lenchartoken, newTParserPosition(), TParserPosition::posbyte, TParserPosition::poschar, res, TParserPosition::state, TParser::state, TParserCopyClose(), TParserCopyInit(), TParserGet(), TPS_InURLPathFirst, TParser::type, and URLPATH.

◆ p_iswhat()

p_iswhat ( alnum  ,
1   
)

Definition at line 453 of file wparser_def.c.

467 {
468  Assert(prs->state);
469  return ((prs->state->charlen == 1 && *(prs->str + prs->state->posbyte) == c)) ? 1 : 0;
470 }

References Assert().

◆ prsd_end()

Datum prsd_end ( PG_FUNCTION_ARGS  )

Definition at line 1917 of file wparser_def.c.

1918 {
1919  TParser *p = (TParser *) PG_GETARG_POINTER(0);
1920 
1921  TParserClose(p);
1922  PG_RETURN_VOID();
1923 }
PG_RETURN_VOID
#define PG_RETURN_VOID()
Definition: fmgr.h:349
PG_GETARG_POINTER
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
TParserClose
static void TParserClose(TParser *prs)
Definition: wparser_def.c:371

References PG_GETARG_POINTER, PG_RETURN_VOID, and TParserClose().

◆ prsd_headline()

Datum prsd_headline ( PG_FUNCTION_ARGS  )

Definition at line 2615 of file wparser_def.c.

2616 {
2617  HeadlineParsedText *prs = (HeadlineParsedText *) PG_GETARG_POINTER(0);
2618  List *prsoptions = (List *) PG_GETARG_POINTER(1);
2619  TSQuery query = PG_GETARG_TSQUERY(2);
2620  List *locations;
2621 
2622  /* default option values: */
2623  int min_words = 15;
2624  int max_words = 35;
2625  int shortword = 3;
2626  int max_fragments = 0;
2627  bool highlightall = false;
2628  ListCell *l;
2629 
2630  /* Extract configuration option values */
2631  prs->startsel = NULL;
2632  prs->stopsel = NULL;
2633  prs->fragdelim = NULL;
2634  foreach(l, prsoptions)
2635  {
2636  DefElem *defel = (DefElem *) lfirst(l);
2637  char *val = defGetString(defel);
2638 
2639  if (pg_strcasecmp(defel->defname, "MaxWords") == 0)
2640  max_words = pg_strtoint32(val);
2641  else if (pg_strcasecmp(defel->defname, "MinWords") == 0)
2642  min_words = pg_strtoint32(val);
2643  else if (pg_strcasecmp(defel->defname, "ShortWord") == 0)
2644  shortword = pg_strtoint32(val);
2645  else if (pg_strcasecmp(defel->defname, "MaxFragments") == 0)
2646  max_fragments = pg_strtoint32(val);
2647  else if (pg_strcasecmp(defel->defname, "StartSel") == 0)
2648  prs->startsel = pstrdup(val);
2649  else if (pg_strcasecmp(defel->defname, "StopSel") == 0)
2650  prs->stopsel = pstrdup(val);
2651  else if (pg_strcasecmp(defel->defname, "FragmentDelimiter") == 0)
2652  prs->fragdelim = pstrdup(val);
2653  else if (pg_strcasecmp(defel->defname, "HighlightAll") == 0)
2654  highlightall = (pg_strcasecmp(val, "1") == 0 ||
2655  pg_strcasecmp(val, "on") == 0 ||
2656  pg_strcasecmp(val, "true") == 0 ||
2657  pg_strcasecmp(val, "t") == 0 ||
2658  pg_strcasecmp(val, "y") == 0 ||
2659  pg_strcasecmp(val, "yes") == 0);
2660  else
2661  ereport(ERROR,
2662  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2663  errmsg("unrecognized headline parameter: \"%s\"",
2664  defel->defname)));
2665  }
2666 
2667  /* in HighlightAll mode these parameters are ignored */
2668  if (!highlightall)
2669  {
2670  if (min_words >= max_words)
2671  ereport(ERROR,
2672  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2673  errmsg("MinWords should be less than MaxWords")));
2674  if (min_words <= 0)
2675  ereport(ERROR,
2676  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2677  errmsg("MinWords should be positive")));
2678  if (shortword < 0)
2679  ereport(ERROR,
2680  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2681  errmsg("ShortWord should be >= 0")));
2682  if (max_fragments < 0)
2683  ereport(ERROR,
2684  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2685  errmsg("MaxFragments should be >= 0")));
2686  }
2687 
2688  /* Locate words and phrases matching the query */
2689  if (query->size > 0)
2690  {
2691  hlCheck ch;
2692 
2693  ch.words = prs->words;
2694  ch.len = prs->curwords;
2695  locations = TS_execute_locations(GETQUERY(query), &ch, TS_EXEC_EMPTY,
2696  checkcondition_HL);
2697  }
2698  else
2699  locations = NIL; /* empty query matches nothing */
2700 
2701  /* Apply appropriate headline selector */
2702  if (max_fragments == 0)
2703  mark_hl_words(prs, query, locations, highlightall, shortword,
2704  min_words, max_words);
2705  else
2706  mark_hl_fragments(prs, query, locations, highlightall, shortword,
2707  min_words, max_words, max_fragments);
2708 
2709  /* Fill in default values for string options */
2710  if (!prs->startsel)
2711  prs->startsel = pstrdup("<b>");
2712  if (!prs->stopsel)
2713  prs->stopsel = pstrdup("</b>");
2714  if (!prs->fragdelim)
2715  prs->fragdelim = pstrdup(" ... ");
2716 
2717  /* Caller will need these lengths, too */
2718  prs->startsellen = strlen(prs->startsel);
2719  prs->stopsellen = strlen(prs->stopsel);
2720  prs->fragdelimlen = strlen(prs->fragdelim);
2721 
2722  PG_RETURN_POINTER(prs);
2723 }
defGetString
char * defGetString(DefElem *def)
Definition: define.c:49
errcode
int errcode(int sqlerrcode)
Definition: elog.c:858
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:1069
ERROR
#define ERROR
Definition: elog.h:39
ereport
#define ereport(elevel,...)
Definition: elog.h:149
PG_RETURN_POINTER
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:361
pstrdup
char * pstrdup(const char *in)
Definition: mcxt.c:1644
pg_strtoint32
int32 pg_strtoint32(const char *s)
Definition: numutils.c:384
NIL
#define NIL
Definition: pg_list.h:68
pg_strcasecmp
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
DefElem::defname
char * defname
Definition: parsenodes.h:802
List
Definition: pg_list.h:54
TSQueryData::size
int32 size
Definition: ts_type.h:221
PG_GETARG_TSQUERY
#define PG_GETARG_TSQUERY(n)
Definition: ts_type.h:266
TS_execute_locations
List * TS_execute_locations(QueryItem *curitem, void *arg, uint32 flags, TSExecuteCallback chkcond)
Definition: tsvector_op.c:2009
mark_hl_fragments
static void mark_hl_fragments(HeadlineParsedText *prs, TSQuery query, List *locations, bool highlightall, int shortword, int min_words, int max_words, int max_fragments)
Definition: wparser_def.c:2270
mark_hl_words
static void mark_hl_words(HeadlineParsedText *prs, TSQuery query, List *locations, bool highlightall, int shortword, int min_words, int max_words)
Definition: wparser_def.c:2453

References checkcondition_HL(), HeadlineParsedText::curwords, defGetString(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, HeadlineParsedText::fragdelim, HeadlineParsedText::fragdelimlen, GETQUERY, hlCheck::len, lfirst, mark_hl_fragments(), mark_hl_words(), NIL, PG_GETARG_POINTER, PG_GETARG_TSQUERY, PG_RETURN_POINTER, pg_strcasecmp(), pg_strtoint32(), pstrdup(), TSQueryData::size, HeadlineParsedText::startsel, HeadlineParsedText::startsellen, HeadlineParsedText::stopsel, HeadlineParsedText::stopsellen, TS_EXEC_EMPTY, TS_execute_locations(), val, hlCheck::words, and HeadlineParsedText::words.

◆ prsd_lextype()

Datum prsd_lextype ( PG_FUNCTION_ARGS  )

Definition at line 1877 of file wparser_def.c.

1878 {
1879  LexDescr *descr = (LexDescr *) palloc(sizeof(LexDescr) * (LASTNUM + 1));
1880  int i;
1881 
1882  for (i = 1; i <= LASTNUM; i++)
1883  {
1884  descr[i - 1].lexid = i;
1885  descr[i - 1].alias = pstrdup(tok_alias[i]);
1886  descr[i - 1].descr = pstrdup(lex_descr[i]);
1887  }
1888 
1889  descr[LASTNUM].lexid = 0;
1890 
1891  PG_RETURN_POINTER(descr);
1892 }
LexDescr::alias
char * alias
Definition: ts_public.h:28
LexDescr::lexid
int lexid
Definition: ts_public.h:27
LexDescr::descr
char * descr
Definition: ts_public.h:29
LASTNUM
#define LASTNUM
Definition: wparser_def.c:59
tok_alias
static const char *const tok_alias[]
Definition: wparser_def.c:61
lex_descr
static const char *const lex_descr[]
Definition: wparser_def.c:88

References LexDescr::alias, LexDescr::descr, i, LASTNUM, lex_descr, LexDescr::lexid, palloc(), PG_RETURN_POINTER, pstrdup(), and tok_alias.

◆ prsd_nexttoken()

Datum prsd_nexttoken ( PG_FUNCTION_ARGS  )

Definition at line 1901 of file wparser_def.c.

1902 {
1903  TParser *p = (TParser *) PG_GETARG_POINTER(0);
1904  char **t = (char **) PG_GETARG_POINTER(1);
1905  int *tlen = (int *) PG_GETARG_POINTER(2);
1906 
1907  if (!TParserGet(p))
1908  PG_RETURN_INT32(0);
1909 
1910  *t = p->token;
1911  *tlen = p->lenbytetoken;
1912 
1913  PG_RETURN_INT32(p->type);
1914 }
PG_RETURN_INT32
#define PG_RETURN_INT32(x)
Definition: fmgr.h:354
TParser::token
char * token
Definition: wparser_def.c:259

References TParser::lenbytetoken, PG_GETARG_POINTER, PG_RETURN_INT32, TParser::token, TParserGet(), and TParser::type.

◆ prsd_start()

Datum prsd_start ( PG_FUNCTION_ARGS  )

Definition at line 1895 of file wparser_def.c.

1896 {
1897  PG_RETURN_POINTER(TParserInit((char *) PG_GETARG_POINTER(0), PG_GETARG_INT32(1)));
1898 }
PG_GETARG_INT32
#define PG_GETARG_INT32(n)
Definition: fmgr.h:269
TParserInit
static TParser * TParserInit(char *str, int len)
Definition: wparser_def.c:288

References PG_GETARG_INT32, PG_GETARG_POINTER, PG_RETURN_POINTER, and TParserInit().

◆ SpecialFURL()

static void SpecialFURL ( TParser *  prs)
static

Definition at line 587 of file wparser_def.c.

588 {
589  prs->wanthost = true;
590  prs->state->posbyte -= prs->state->lenbytetoken;
591  prs->state->poschar -= prs->state->lenchartoken;
592 }

References TParserPosition::lenbytetoken, TParserPosition::lenchartoken, TParserPosition::posbyte, TParserPosition::poschar, TParser::state, and TParser::wanthost.

◆ SpecialHyphen()

static void SpecialHyphen ( TParser *  prs)
static

Definition at line 595 of file wparser_def.c.

596 {
597  prs->state->posbyte -= prs->state->lenbytetoken;
598  prs->state->poschar -= prs->state->lenchartoken;
599 }

References TParserPosition::lenbytetoken, TParserPosition::lenchartoken, TParserPosition::posbyte, TParserPosition::poschar, and TParser::state.

◆ SpecialTags()

static void SpecialTags ( TParser *  prs)
static

Definition at line 563 of file wparser_def.c.

564 {
565  switch (prs->state->lenchartoken)
566  {
567  case 8: /* </script */
568  if (pg_strncasecmp(prs->token, "</script", 8) == 0)
569  prs->ignore = false;
570  break;
571  case 7: /* <script || </style */
572  if (pg_strncasecmp(prs->token, "</style", 7) == 0)
573  prs->ignore = false;
574  else if (pg_strncasecmp(prs->token, "<script", 7) == 0)
575  prs->ignore = true;
576  break;
577  case 6: /* <style */
578  if (pg_strncasecmp(prs->token, "<style", 6) == 0)
579  prs->ignore = true;
580  break;
581  default:
582  break;
583  }
584 }
pg_strncasecmp
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
Definition: pgstrcasecmp.c:69

References TParser::ignore, TParserPosition::lenchartoken, pg_strncasecmp(), TParser::state, and TParser::token.

◆ SpecialVerVersion()

static void SpecialVerVersion ( TParser *  prs)
static

Definition at line 602 of file wparser_def.c.

603 {
604  prs->state->posbyte -= prs->state->lenbytetoken;
605  prs->state->poschar -= prs->state->lenchartoken;
606  prs->state->lenbytetoken = 0;
607  prs->state->lenchartoken = 0;
608 }

References TParserPosition::lenbytetoken, TParserPosition::lenchartoken, TParserPosition::posbyte, TParserPosition::poschar, and TParser::state.

◆ TParserClose()

static void TParserClose ( TParser *  prs)
static

Definition at line 371 of file wparser_def.c.

372 {
373  while (prs->state)
374  {
375  TParserPosition *ptr = prs->state->prev;
376 
377  pfree(prs->state);
378  prs->state = ptr;
379  }
380 
381  if (prs->wstr)
382  pfree(prs->wstr);
383  if (prs->pgwstr)
384  pfree(prs->pgwstr);
385 
386 #ifdef WPARSER_TRACE
387  fprintf(stderr, "closing parser\n");
388 #endif
389  pfree(prs);
390 }
fprintf
#define fprintf
Definition: port.h:242
TParserPosition::prev
struct TParserPosition * prev
Definition: wparser_def.c:236

References fprintf, pfree(), TParser::pgwstr, TParserPosition::prev, TParser::state, and TParser::wstr.

Referenced by prsd_end().

◆ TParserCopyClose()

static void TParserCopyClose ( TParser *  prs)
static

Definition at line 396 of file wparser_def.c.

397 {
398  while (prs->state)
399  {
400  TParserPosition *ptr = prs->state->prev;
401 
402  pfree(prs->state);
403  prs->state = ptr;
404  }
405 
406 #ifdef WPARSER_TRACE
407  fprintf(stderr, "closing parser copy\n");
408 #endif
409  pfree(prs);
410 }

References fprintf, pfree(), TParserPosition::prev, and TParser::state.

Referenced by p_ishost(), and p_isURLPath().

◆ TParserCopyInit()

static TParser* TParserCopyInit ( const TParser *  orig)
static

Definition at line 345 of file wparser_def.c.

346 {
347  TParser *prs = (TParser *) palloc0(sizeof(TParser));
348 
349  prs->charmaxlen = orig->charmaxlen;
350  prs->str = orig->str + orig->state->posbyte;
351  prs->lenstr = orig->lenstr - orig->state->posbyte;
352  prs->usewide = orig->usewide;
353 
354  if (orig->pgwstr)
355  prs->pgwstr = orig->pgwstr + orig->state->poschar;
356  if (orig->wstr)
357  prs->wstr = orig->wstr + orig->state->poschar;
358 
359  prs->state = newTParserPosition(NULL);
360  prs->state->state = TPS_Base;
361 
362 #ifdef WPARSER_TRACE
363  fprintf(stderr, "parsing copy of \"%.*s\"\n", prs->lenstr, prs->str);
364 #endif
365 
366  return prs;
367 }
palloc0
void * palloc0(Size size)
Definition: mcxt.c:1257
TParser::charmaxlen
int charmaxlen
Definition: wparser_def.c:250

References TParser::charmaxlen, fprintf, TParser::lenstr, newTParserPosition(), palloc0(), TParser::pgwstr, TParserPosition::posbyte, TParserPosition::poschar, TParserPosition::state, TParser::state, TParser::str, TPS_Base, TParser::usewide, and TParser::wstr.

Referenced by p_ishost(), and p_isURLPath().

◆ TParserGet()

static bool TParserGet ( TParser *  prs)
static

Definition at line 1709 of file wparser_def.c.

1710 {
1711  const TParserStateActionItem *item = NULL;
1712 
1713  CHECK_FOR_INTERRUPTS();
1714 
1715  Assert(prs->state);
1716 
1717  if (prs->state->posbyte >= prs->lenstr)
1718  return false;
1719 
1720  prs->token = prs->str + prs->state->posbyte;
1721  prs->state->pushedAtAction = NULL;
1722 
1723  /* look at string */
1724  while (prs->state->posbyte <= prs->lenstr)
1725  {
1726  if (prs->state->posbyte == prs->lenstr)
1727  prs->state->charlen = 0;
1728  else
1729  prs->state->charlen = (prs->charmaxlen == 1) ? prs->charmaxlen :
1730  pg_mblen(prs->str + prs->state->posbyte);
1731 
1732  Assert(prs->state->posbyte + prs->state->charlen <= prs->lenstr);
1733  Assert(prs->state->state >= TPS_Base && prs->state->state < TPS_Null);
1734  Assert(Actions[prs->state->state].state == prs->state->state);
1735 
1736  if (prs->state->pushedAtAction)
1737  {
1738  /* After a POP, pick up at the next test */
1739  item = prs->state->pushedAtAction + 1;
1740  prs->state->pushedAtAction = NULL;
1741  }
1742  else
1743  {
1744  item = Actions[prs->state->state].action;
1745  Assert(item != NULL);
1746  }
1747 
1748  /* find action by character class */
1749  while (item->isclass)
1750  {
1751  prs->c = item->c;
1752  if (item->isclass(prs) != 0)
1753  break;
1754  item++;
1755  }
1756 
1757 #ifdef WPARSER_TRACE
1758  {
1759  TParserPosition *ptr;
1760 
1761  fprintf(stderr, "state ");
1762  /* indent according to stack depth */
1763  for (ptr = prs->state->prev; ptr; ptr = ptr->prev)
1764  fprintf(stderr, " ");
1765  fprintf(stderr, "%s ", Actions[prs->state->state].state_name);
1766  if (prs->state->posbyte < prs->lenstr)
1767  fprintf(stderr, "at %c", *(prs->str + prs->state->posbyte));
1768  else
1769  fprintf(stderr, "at EOF");
1770  fprintf(stderr, " matched rule %d flags%s%s%s%s%s%s%s%s%s%s%s\n",
1771  (int) (item - Actions[prs->state->state].action),
1772  (item->flags & A_BINGO) ? " BINGO" : "",
1773  (item->flags & A_POP) ? " POP" : "",
1774  (item->flags & A_PUSH) ? " PUSH" : "",
1775  (item->flags & A_RERUN) ? " RERUN" : "",
1776  (item->flags & A_CLEAR) ? " CLEAR" : "",
1777  (item->flags & A_MERGE) ? " MERGE" : "",
1778  (item->flags & A_CLRALL) ? " CLRALL" : "",
1779  (item->tostate != TPS_Null) ? " tostate " : "",
1780  (item->tostate != TPS_Null) ? Actions[item->tostate].state_name : "",
1781  (item->type > 0) ? " type " : "",
1782  tok_alias[item->type]);
1783  }
1784 #endif
1785 
1786  /* call special handler if exists */
1787  if (item->special)
1788  item->special(prs);
1789 
1790  /* BINGO, token is found */
1791  if (item->flags & A_BINGO)
1792  {
1793  Assert(item->type > 0);
1794  prs->lenbytetoken = prs->state->lenbytetoken;
1795  prs->lenchartoken = prs->state->lenchartoken;
1796  prs->state->lenbytetoken = prs->state->lenchartoken = 0;
1797  prs->type = item->type;
1798  }
1799 
1800  /* do various actions by flags */
1801  if (item->flags & A_POP)
1802  { /* pop stored state in stack */
1803  TParserPosition *ptr = prs->state->prev;
1804 
1805  pfree(prs->state);
1806  prs->state = ptr;
1807  Assert(prs->state);
1808  }
1809  else if (item->flags & A_PUSH)
1810  { /* push (store) state in stack */
1811  prs->state->pushedAtAction = item; /* remember where we push */
1812  prs->state = newTParserPosition(prs->state);
1813  }
1814  else if (item->flags & A_CLEAR)
1815  { /* clear previous pushed state */
1816  TParserPosition *ptr;
1817 
1818  Assert(prs->state->prev);
1819  ptr = prs->state->prev->prev;
1820  pfree(prs->state->prev);
1821  prs->state->prev = ptr;
1822  }
1823  else if (item->flags & A_CLRALL)
1824  { /* clear all previous pushed state */
1825  TParserPosition *ptr;
1826 
1827  while (prs->state->prev)
1828  {
1829  ptr = prs->state->prev->prev;
1830  pfree(prs->state->prev);
1831  prs->state->prev = ptr;
1832  }
1833  }
1834  else if (item->flags & A_MERGE)
1835  { /* merge posinfo with current and pushed state */
1836  TParserPosition *ptr = prs->state;
1837 
1838  Assert(prs->state->prev);
1839  prs->state = prs->state->prev;
1840 
1841  prs->state->posbyte = ptr->posbyte;
1842  prs->state->poschar = ptr->poschar;
1843  prs->state->charlen = ptr->charlen;
1844  prs->state->lenbytetoken = ptr->lenbytetoken;
1845  prs->state->lenchartoken = ptr->lenchartoken;
1846  pfree(ptr);
1847  }
1848 
1849  /* set new state if pointed */
1850  if (item->tostate != TPS_Null)
1851  prs->state->state = item->tostate;
1852 
1853  /* check for go away */
1854  if ((item->flags & A_BINGO) ||
1855  (prs->state->posbyte >= prs->lenstr &&
1856  (item->flags & A_RERUN) == 0))
1857  break;
1858 
1859  /* go to beginning of loop if we should rerun or we just restore state */
1860  if (item->flags & (A_RERUN | A_POP))
1861  continue;
1862 
1863  /* move forward */
1864  if (prs->state->charlen)
1865  {
1866  prs->state->posbyte += prs->state->charlen;
1867  prs->state->lenbytetoken += prs->state->charlen;
1868  prs->state->poschar++;
1869  prs->state->lenchartoken++;
1870  }
1871  }
1872 
1873  return (item && (item->flags & A_BINGO));
1874 }
pg_mblen
int pg_mblen(const char *mbstr)
Definition: mbutils.c:1024
CHECK_FOR_INTERRUPTS
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:121
TParserPosition::pushedAtAction
const TParserStateActionItem * pushedAtAction
Definition: wparser_def.c:237
TParserStateActionItem::isclass
TParserCharTest isclass
Definition: wparser_def.c:210
TParserStateActionItem::tostate
TParserState tostate
Definition: wparser_def.c:213
TParserStateActionItem::special
TParserSpecial special
Definition: wparser_def.c:215
TParserStateAction::action
const TParserStateActionItem * action
Definition: wparser_def.c:1608
TParserStateAction::state
TParserState state
Definition: wparser_def.c:1609
A_POP
#define A_POP
Definition: wparser_def.c:221
A_RERUN
#define A_RERUN
Definition: wparser_def.c:223
Actions
static const TParserStateAction Actions[]
Definition: wparser_def.c:1627
A_MERGE
#define A_MERGE
Definition: wparser_def.c:225
A_BINGO
#define A_BINGO
Definition: wparser_def.c:220
A_CLRALL
#define A_CLRALL
Definition: wparser_def.c:226
A_CLEAR
#define A_CLEAR
Definition: wparser_def.c:224
A_PUSH
#define A_PUSH
Definition: wparser_def.c:222

References A_BINGO, A_CLEAR, A_CLRALL, A_MERGE, A_POP, A_PUSH, A_RERUN, TParserStateAction::action, Actions, Assert(), TParserStateActionItem::c, TParser::c, TParserPosition::charlen, TParser::charmaxlen, CHECK_FOR_INTERRUPTS, TParserStateActionItem::flags, fprintf, TParserStateActionItem::isclass, TParserPosition::lenbytetoken, TParser::lenbytetoken, TParserPosition::lenchartoken, TParser::lenchartoken, TParser::lenstr, newTParserPosition(), pfree(), pg_mblen(), TParserPosition::posbyte, TParserPosition::poschar, TParserPosition::prev, TParserPosition::pushedAtAction, TParserStateActionItem::special, TParserPosition::state, TParser::state, TParserStateAction::state, TParser::str, tok_alias, TParser::token, TParserStateActionItem::tostate, TPS_Base, TPS_Null, TParserStateActionItem::type, and TParser::type.

Referenced by p_ishost(), p_isURLPath(), and prsd_nexttoken().

◆ TParserInit()

static TParser* TParserInit ( char *  str,
int  len 
)
static

Definition at line 288 of file wparser_def.c.

289 {
290  TParser *prs = (TParser *) palloc0(sizeof(TParser));
291 
292  prs->charmaxlen = pg_database_encoding_max_length();
293  prs->str = str;
294  prs->lenstr = len;
295 
296  /*
297  * Use wide char code only when max encoding length > 1.
298  */
299  if (prs->charmaxlen > 1)
300  {
301  pg_locale_t mylocale = 0; /* TODO */
302 
303  prs->usewide = true;
304  if (database_ctype_is_c)
305  {
306  /*
307  * char2wchar doesn't work for C-locale and sizeof(pg_wchar) could
308  * be different from sizeof(wchar_t)
309  */
310  prs->pgwstr = (pg_wchar *) palloc(sizeof(pg_wchar) * (prs->lenstr + 1));
311  pg_mb2wchar_with_len(prs->str, prs->pgwstr, prs->lenstr);
312  }
313  else
314  {
315  prs->wstr = (wchar_t *) palloc(sizeof(wchar_t) * (prs->lenstr + 1));
316  char2wchar(prs->wstr, prs->lenstr + 1, prs->str, prs->lenstr,
317  mylocale);
318  }
319  }
320  else
321  prs->usewide = false;
322 
323  prs->state = newTParserPosition(NULL);
324  prs->state->state = TPS_Base;
325 
326 #ifdef WPARSER_TRACE
327  fprintf(stderr, "parsing \"%.*s\"\n", len, str);
328 #endif
329 
330  return prs;
331 }
pg_database_encoding_max_length
int pg_database_encoding_max_length(void)
Definition: mbutils.c:1553
pg_mb2wchar_with_len
int pg_mb2wchar_with_len(const char *from, pg_wchar *to, int len)
Definition: mbutils.c:987
generate_unaccent_rules.str
str
Definition: generate_unaccent_rules.py:280
len
const void size_t len
Definition: pg_crc32c_sse42.c:24
database_ctype_is_c
bool database_ctype_is_c
Definition: pg_locale.c:118
char2wchar
size_t char2wchar(wchar_t *to, size_t tolen, const char *from, size_t fromlen, pg_locale_t locale)
Definition: pg_locale.c:2990
pg_locale_struct
Definition: pg_locale.h:74

References char2wchar(), TParser::charmaxlen, database_ctype_is_c, fprintf, len, TParser::lenstr, newTParserPosition(), palloc(), palloc0(), pg_database_encoding_max_length(), pg_mb2wchar_with_len(), TParser::pgwstr, TParserPosition::state, TParser::state, generate_unaccent_rules::str, TParser::str, TPS_Base, TParser::usewide, and TParser::wstr.

Referenced by prsd_start().

Variable Documentation

◆ Actions

const TParserStateAction Actions[]
static

Definition at line 1627 of file wparser_def.c.

Referenced by TParserGet().

◆ actionTPS_Base

const TParserStateActionItem actionTPS_Base[]
static
Initial value:
= {
{p_isEOF, 0, A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '<', A_PUSH, TPS_InTagFirst, 0, NULL},
{p_isignore, 0, A_NEXT, TPS_InSpace, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InAsciiWord, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InWord, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InUnsignedInt, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InSignedIntFirst, 0, NULL},
{p_iseqC, '+', A_PUSH, TPS_InSignedIntFirst, 0, NULL},
{p_iseqC, '&', A_PUSH, TPS_InXMLEntityFirst, 0, NULL},
{p_iseqC, '~', A_PUSH, TPS_InFileTwiddle, 0, NULL},
{p_iseqC, '/', A_PUSH, TPS_InFileFirst, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InPathFirstFirst, 0, NULL},
{NULL, 0, A_NEXT, TPS_InSpace, 0, NULL}
}
p_isasclet
static int p_isasclet(TParser *prs)
Definition: wparser_def.c:498
p_isignore
static int p_isignore(TParser *prs)
Definition: wparser_def.c:622
A_NEXT
#define A_NEXT
Definition: wparser_def.c:219

Definition at line 970 of file wparser_def.c.

◆ actionTPS_InAsciiWord

const TParserStateActionItem actionTPS_InAsciiWord[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, ASCIIWORD, NULL},
{p_isasclet, 0, A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InHostFirstDomain, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InFileNext, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHyphenAsciiWordFirst, 0, NULL},
{p_iseqC, '_', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{p_iseqC, '@', A_PUSH, TPS_InEmail, 0, NULL},
{p_iseqC, ':', A_PUSH, TPS_InProtocolFirst, 0, NULL},
{p_iseqC, '/', A_PUSH, TPS_InFileFirst, 0, NULL},
{p_isdigit, 0, A_PUSH, TPS_InHost, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InNumWord, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InWord, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InWord, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, ASCIIWORD, NULL}
}
ASCIIWORD
#define ASCIIWORD
Definition: wparser_def.c:35
p_isspecial
static int p_isspecial(TParser *prs)
Definition: wparser_def.c:691

Definition at line 998 of file wparser_def.c.

◆ actionTPS_InCloseCommentFirst

const TParserStateActionItem actionTPS_InCloseCommentFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_InCloseCommentLast, 0, NULL},
{NULL, 0, A_NEXT, TPS_InComment, 0, NULL}
}

Definition at line 1308 of file wparser_def.c.

◆ actionTPS_InCloseCommentLast

const TParserStateActionItem actionTPS_InCloseCommentLast[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '>', A_NEXT, TPS_InCommentEnd, 0, NULL},
{NULL, 0, A_NEXT, TPS_InComment, 0, NULL}
}

Definition at line 1314 of file wparser_def.c.

◆ actionTPS_InComment

const TParserStateActionItem actionTPS_InComment[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_InCloseCommentFirst, 0, NULL},
{NULL, 0, A_NEXT, TPS_Null, 0, NULL}
}

Definition at line 1302 of file wparser_def.c.

◆ actionTPS_InCommentEnd

const TParserStateActionItem actionTPS_InCommentEnd[]
static
Initial value:
= {
{NULL, 0, A_BINGO | A_CLRALL, TPS_Base, TAG_T, NULL}
}
TAG_T
#define TAG_T
Definition: wparser_def.c:47

Definition at line 1321 of file wparser_def.c.

◆ actionTPS_InCommentFirst

const TParserStateActionItem actionTPS_InCommentFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_InCommentLast, 0, NULL},
{p_iseqC, 'D', A_NEXT, TPS_InTag, 0, NULL},
{p_iseqC, 'd', A_NEXT, TPS_InTag, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1287 of file wparser_def.c.

◆ actionTPS_InCommentLast

const TParserStateActionItem actionTPS_InCommentLast[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_InComment, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1296 of file wparser_def.c.

◆ actionTPS_InDecimal

const TParserStateActionItem actionTPS_InDecimal[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, DECIMAL_T, NULL},
{p_isdigit, 0, A_NEXT, TPS_InDecimal, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InVerVersion, 0, NULL},
{p_iseqC, 'e', A_PUSH, TPS_InMantissaFirst, 0, NULL},
{p_iseqC, 'E', A_PUSH, TPS_InMantissaFirst, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, DECIMAL_T, NULL}
}
DECIMAL_T
#define DECIMAL_T
Definition: wparser_def.c:54

Definition at line 1090 of file wparser_def.c.

◆ actionTPS_InDecimalFirst

const TParserStateActionItem actionTPS_InDecimalFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_CLEAR, TPS_InDecimal, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1084 of file wparser_def.c.

◆ actionTPS_InEmail

const TParserStateActionItem actionTPS_InEmail[]
static
Initial value:
= {
{p_isstophost, 0, A_POP, TPS_Null, 0, NULL},
{p_ishost, 0, A_BINGO | A_CLRALL, TPS_Base, EMAIL, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}
EMAIL
#define EMAIL
Definition: wparser_def.c:38
p_isstophost
static int p_isstophost(TParser *prs)
Definition: wparser_def.c:611
p_ishost
static int p_ishost(TParser *prs)
Definition: wparser_def.c:628

Definition at line 1390 of file wparser_def.c.

◆ actionTPS_InFile

const TParserStateActionItem actionTPS_InFile[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, FILEPATH, NULL},
{p_isasclet, 0, A_NEXT, TPS_InFile, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InFile, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InFileNext, 0, NULL},
{p_iseqC, '_', A_NEXT, TPS_InFile, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_InFile, 0, NULL},
{p_iseqC, '/', A_PUSH, TPS_InFileFirst, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, FILEPATH, NULL}
}
FILEPATH
#define FILEPATH
Definition: wparser_def.c:53

Definition at line 1440 of file wparser_def.c.

◆ actionTPS_InFileFirst

const TParserStateActionItem actionTPS_InFileFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InFile, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InFile, 0, NULL},
{p_iseqC, '.', A_NEXT, TPS_InPathFirst, 0, NULL},
{p_iseqC, '_', A_NEXT, TPS_InFile, 0, NULL},
{p_iseqC, '~', A_PUSH, TPS_InFileTwiddle, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1396 of file wparser_def.c.

◆ actionTPS_InFileNext

const TParserStateActionItem actionTPS_InFileNext[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isasclet, 0, A_CLEAR, TPS_InFile, 0, NULL},
{p_isdigit, 0, A_CLEAR, TPS_InFile, 0, NULL},
{p_iseqC, '_', A_CLEAR, TPS_InFile, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1451 of file wparser_def.c.

◆ actionTPS_InFileTwiddle

const TParserStateActionItem actionTPS_InFileTwiddle[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InFile, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InFile, 0, NULL},
{p_iseqC, '_', A_NEXT, TPS_InFile, 0, NULL},
{p_iseqC, '/', A_NEXT, TPS_InFileFirst, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1406 of file wparser_def.c.

◆ actionTPS_InFURL

const TParserStateActionItem actionTPS_InFURL[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isURLPath, 0, A_BINGO | A_CLRALL, TPS_Base, URL_T, SpecialFURL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}
SpecialFURL
static void SpecialFURL(TParser *prs)
Definition: wparser_def.c:587
p_isURLPath
static int p_isURLPath(TParser *prs)
Definition: wparser_def.c:656
URL_T
#define URL_T
Definition: wparser_def.c:39

Definition at line 1475 of file wparser_def.c.

◆ actionTPS_InHost

const TParserStateActionItem actionTPS_InHost[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHost, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InHost, 0, NULL},
{p_iseqC, '@', A_PUSH, TPS_InEmail, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InHostFirstDomain, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{p_iseqC, '_', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1379 of file wparser_def.c.

◆ actionTPS_InHostDomain

const TParserStateActionItem actionTPS_InHostDomain[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO | A_CLRALL, TPS_Base, HOST, NULL},
{p_isasclet, 0, A_NEXT, TPS_InHostDomain, 0, NULL},
{p_isdigit, 0, A_PUSH, TPS_InHost, 0, NULL},
{p_iseqC, ':', A_PUSH, TPS_InPortFirst, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{p_iseqC, '_', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InHostFirstDomain, 0, NULL},
{p_iseqC, '@', A_PUSH, TPS_InEmail, 0, NULL},
{p_isdigit, 0, A_POP, TPS_Null, 0, NULL},
{p_isstophost, 0, A_BINGO | A_CLRALL, TPS_InURLPathStart, HOST, NULL},
{p_iseqC, '/', A_PUSH, TPS_InFURL, 0, NULL},
{NULL, 0, A_BINGO | A_CLRALL, TPS_Base, HOST, NULL}
}

Definition at line 1343 of file wparser_def.c.

◆ actionTPS_InHostDomainSecond

const TParserStateActionItem actionTPS_InHostDomainSecond[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InHostDomain, 0, NULL},
{p_isdigit, 0, A_PUSH, TPS_InHost, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{p_iseqC, '_', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InHostFirstDomain, 0, NULL},
{p_iseqC, '@', A_PUSH, TPS_InEmail, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1332 of file wparser_def.c.

◆ actionTPS_InHostFirstAN

const TParserStateActionItem actionTPS_InHostFirstAN[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHost, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InHost, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1372 of file wparser_def.c.

◆ actionTPS_InHostFirstDomain

const TParserStateActionItem actionTPS_InHostFirstDomain[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InHostDomainSecond, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHost, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1325 of file wparser_def.c.

◆ actionTPS_InHyphenAsciiWord

const TParserStateActionItem actionTPS_InHyphenAsciiWord[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO | A_CLRALL, TPS_InParseHyphen, ASCIIHWORD, SpecialHyphen},
{p_isasclet, 0, A_NEXT, TPS_InHyphenAsciiWord, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InHyphenWord, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InHyphenWord, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHyphenNumWord, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHyphenAsciiWordFirst, 0, NULL},
{NULL, 0, A_BINGO | A_CLRALL, TPS_InParseHyphen, ASCIIHWORD, SpecialHyphen}
}
SpecialHyphen
static void SpecialHyphen(TParser *prs)
Definition: wparser_def.c:595
ASCIIHWORD
#define ASCIIHWORD
Definition: wparser_def.c:50

Definition at line 1505 of file wparser_def.c.

◆ actionTPS_InHyphenAsciiWordFirst

const TParserStateActionItem actionTPS_InHyphenAsciiWordFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InHyphenAsciiWord, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InHyphenWord, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHyphenDigitLookahead, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1497 of file wparser_def.c.

◆ actionTPS_InHyphenAsciiWordPart

const TParserStateActionItem actionTPS_InHyphenAsciiWordPart[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, ASCIIPARTHWORD, NULL},
{p_isasclet, 0, A_NEXT, TPS_InHyphenAsciiWordPart, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InHyphenWordPart, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InHyphenWordPart, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHyphenNumWordPart, 0, NULL},
{NULL, 0, A_BINGO, TPS_InParseHyphen, ASCIIPARTHWORD, NULL}
}
ASCIIPARTHWORD
#define ASCIIPARTHWORD
Definition: wparser_def.c:45

Definition at line 1578 of file wparser_def.c.

◆ actionTPS_InHyphenDigitLookahead

const TParserStateActionItem actionTPS_InHyphenDigitLookahead[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHyphenDigitLookahead, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InHyphenNumWord, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InHyphenNumWord, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1546 of file wparser_def.c.

◆ actionTPS_InHyphenNumWord

const TParserStateActionItem actionTPS_InHyphenNumWord[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO | A_CLRALL, TPS_InParseHyphen, NUMHWORD, SpecialHyphen},
{p_isalnum, 0, A_NEXT, TPS_InHyphenNumWord, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InHyphenNumWord, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHyphenNumWordFirst, 0, NULL},
{NULL, 0, A_BINGO | A_CLRALL, TPS_InParseHyphen, NUMHWORD, SpecialHyphen}
}
NUMHWORD
#define NUMHWORD
Definition: wparser_def.c:49

Definition at line 1538 of file wparser_def.c.

◆ actionTPS_InHyphenNumWordFirst

const TParserStateActionItem actionTPS_InHyphenNumWordFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InHyphenNumWord, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHyphenDigitLookahead, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1531 of file wparser_def.c.

◆ actionTPS_InHyphenNumWordPart

const TParserStateActionItem actionTPS_InHyphenNumWordPart[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, NUMPARTHWORD, NULL},
{p_isalnum, 0, A_NEXT, TPS_InHyphenNumWordPart, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InHyphenNumWordPart, 0, NULL},
{NULL, 0, A_BINGO, TPS_InParseHyphen, NUMPARTHWORD, NULL}
}
NUMPARTHWORD
#define NUMPARTHWORD
Definition: wparser_def.c:43

Definition at line 1587 of file wparser_def.c.

◆ actionTPS_InHyphenUnsignedInt

const TParserStateActionItem actionTPS_InHyphenUnsignedInt[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_Null, 0, NULL},
{p_isalpha, 0, A_CLEAR, TPS_InHyphenNumWordPart, 0, NULL},
{p_isspecial, 0, A_CLEAR, TPS_InHyphenNumWordPart, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1594 of file wparser_def.c.

◆ actionTPS_InHyphenWord

const TParserStateActionItem actionTPS_InHyphenWord[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO | A_CLRALL, TPS_InParseHyphen, HWORD, SpecialHyphen},
{p_isalpha, 0, A_NEXT, TPS_InHyphenWord, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InHyphenWord, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHyphenNumWord, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHyphenWordFirst, 0, NULL},
{NULL, 0, A_BINGO | A_CLRALL, TPS_InParseHyphen, HWORD, SpecialHyphen}
}
HWORD
#define HWORD
Definition: wparser_def.c:51

Definition at line 1522 of file wparser_def.c.

◆ actionTPS_InHyphenWordFirst

const TParserStateActionItem actionTPS_InHyphenWordFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InHyphenWord, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHyphenDigitLookahead, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1515 of file wparser_def.c.

◆ actionTPS_InHyphenWordPart

const TParserStateActionItem actionTPS_InHyphenWordPart[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, PARTHWORD, NULL},
{p_isalpha, 0, A_NEXT, TPS_InHyphenWordPart, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InHyphenWordPart, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InHyphenNumWordPart, 0, NULL},
{NULL, 0, A_BINGO, TPS_InParseHyphen, PARTHWORD, NULL}
}
PARTHWORD
#define PARTHWORD
Definition: wparser_def.c:44

Definition at line 1570 of file wparser_def.c.

◆ actionTPS_InMantissa

const TParserStateActionItem actionTPS_InMantissa[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, SCIENTIFIC, NULL},
{p_isdigit, 0, A_NEXT, TPS_InMantissa, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, SCIENTIFIC, NULL}
}
SCIENTIFIC
#define SCIENTIFIC
Definition: wparser_def.c:41

Definition at line 1139 of file wparser_def.c.

◆ actionTPS_InMantissaFirst

const TParserStateActionItem actionTPS_InMantissaFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_CLEAR, TPS_InMantissa, 0, NULL},
{p_iseqC, '+', A_NEXT, TPS_InMantissaSign, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_InMantissaSign, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1125 of file wparser_def.c.

◆ actionTPS_InMantissaSign

const TParserStateActionItem actionTPS_InMantissaSign[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_CLEAR, TPS_InMantissa, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1133 of file wparser_def.c.

◆ actionTPS_InNumWord

const TParserStateActionItem actionTPS_InNumWord[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, NUMWORD, NULL},
{p_isalnum, 0, A_NEXT, TPS_InNumWord, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InNumWord, 0, NULL},
{p_iseqC, '@', A_PUSH, TPS_InEmail, 0, NULL},
{p_iseqC, '/', A_PUSH, TPS_InFileFirst, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InFileNext, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHyphenNumWordFirst, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, NUMWORD, NULL}
}
NUMWORD
#define NUMWORD
Definition: wparser_def.c:37

Definition at line 987 of file wparser_def.c.

◆ actionTPS_InParseHyphen

const TParserStateActionItem actionTPS_InParseHyphen[]
static
Initial value:
= {
{p_isEOF, 0, A_RERUN, TPS_Base, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InHyphenAsciiWordPart, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InHyphenWordPart, 0, NULL},
{p_isdigit, 0, A_PUSH, TPS_InHyphenUnsignedInt, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InParseHyphenHyphen, 0, NULL},
{NULL, 0, A_RERUN, TPS_Base, 0, NULL}
}

Definition at line 1554 of file wparser_def.c.

◆ actionTPS_InParseHyphenHyphen

const TParserStateActionItem actionTPS_InParseHyphenHyphen[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isalnum, 0, A_BINGO | A_CLEAR, TPS_InParseHyphen, SPACE, NULL},
{p_isspecial, 0, A_BINGO | A_CLEAR, TPS_InParseHyphen, SPACE, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}
SPACE
#define SPACE
Definition: wparser_def.c:46

Definition at line 1563 of file wparser_def.c.

◆ actionTPS_InPathFirst

const TParserStateActionItem actionTPS_InPathFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InFile, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InFile, 0, NULL},
{p_iseqC, '_', A_NEXT, TPS_InFile, 0, NULL},
{p_iseqC, '.', A_NEXT, TPS_InPathSecond, 0, NULL},
{p_iseqC, '/', A_NEXT, TPS_InFileFirst, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1415 of file wparser_def.c.

◆ actionTPS_InPathFirstFirst

const TParserStateActionItem actionTPS_InPathFirstFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '.', A_NEXT, TPS_InPathSecond, 0, NULL},
{p_iseqC, '/', A_NEXT, TPS_InFileFirst, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1425 of file wparser_def.c.

◆ actionTPS_InPathSecond

const TParserStateActionItem actionTPS_InPathSecond[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO | A_CLEAR, TPS_Base, FILEPATH, NULL},
{p_iseqC, '/', A_NEXT | A_PUSH, TPS_InFileFirst, 0, NULL},
{p_iseqC, '/', A_BINGO | A_CLEAR, TPS_Base, FILEPATH, NULL},
{p_isspace, 0, A_BINGO | A_CLEAR, TPS_Base, FILEPATH, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1432 of file wparser_def.c.

◆ actionTPS_InPort

const TParserStateActionItem actionTPS_InPort[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO | A_CLRALL, TPS_Base, HOST, NULL},
{p_isdigit, 0, A_NEXT, TPS_InPort, 0, NULL},
{p_isstophost, 0, A_BINGO | A_CLRALL, TPS_InURLPathStart, HOST, NULL},
{p_iseqC, '/', A_PUSH, TPS_InFURL, 0, NULL},
{NULL, 0, A_BINGO | A_CLRALL, TPS_Base, HOST, NULL}
}

Definition at line 1364 of file wparser_def.c.

◆ actionTPS_InPortFirst

const TParserStateActionItem actionTPS_InPortFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InPort, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1358 of file wparser_def.c.

◆ actionTPS_InProtocolEnd

const TParserStateActionItem actionTPS_InProtocolEnd[]
static
Initial value:
= {
{NULL, 0, A_BINGO | A_CLRALL, TPS_Base, PROTOCOL, NULL}
}
PROTOCOL
#define PROTOCOL
Definition: wparser_def.c:48

Definition at line 1493 of file wparser_def.c.

◆ actionTPS_InProtocolFirst

const TParserStateActionItem actionTPS_InProtocolFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '/', A_NEXT, TPS_InProtocolSecond, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1481 of file wparser_def.c.

◆ actionTPS_InProtocolSecond

const TParserStateActionItem actionTPS_InProtocolSecond[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '/', A_NEXT, TPS_InProtocolEnd, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1487 of file wparser_def.c.

◆ actionTPS_InSignedInt

const TParserStateActionItem actionTPS_InSignedInt[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, SIGNEDINT, NULL},
{p_isdigit, 0, A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InDecimalFirst, 0, NULL},
{p_iseqC, 'e', A_PUSH, TPS_InMantissaFirst, 0, NULL},
{p_iseqC, 'E', A_PUSH, TPS_InMantissaFirst, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, SIGNEDINT, NULL}
}
SIGNEDINT
#define SIGNEDINT
Definition: wparser_def.c:55

Definition at line 1048 of file wparser_def.c.

◆ actionTPS_InSignedIntFirst

const TParserStateActionItem actionTPS_InSignedIntFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_NEXT | A_CLEAR, TPS_InSignedInt, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1042 of file wparser_def.c.

◆ actionTPS_InSpace

const TParserStateActionItem actionTPS_InSpace[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, SPACE, NULL},
{p_iseqC, '<', A_BINGO, TPS_Base, SPACE, NULL},
{p_isignore, 0, A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '-', A_BINGO, TPS_Base, SPACE, NULL},
{p_iseqC, '+', A_BINGO, TPS_Base, SPACE, NULL},
{p_iseqC, '&', A_BINGO, TPS_Base, SPACE, NULL},
{p_iseqC, '/', A_BINGO, TPS_Base, SPACE, NULL},
{p_isnotalnum, 0, A_NEXT, TPS_InSpace, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, SPACE, NULL}
}

Definition at line 1057 of file wparser_def.c.

◆ actionTPS_InSVerVersion

const TParserStateActionItem actionTPS_InSVerVersion[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_BINGO | A_CLRALL, TPS_InUnsignedInt, SPACE, NULL},
{NULL, 0, A_NEXT, TPS_Null, 0, NULL}
}

Definition at line 1105 of file wparser_def.c.

◆ actionTPS_InTag

const TParserStateActionItem actionTPS_InTag[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '>', A_NEXT, TPS_InTagEnd, 0, SpecialTags},
{p_iseqC, '\'', A_NEXT, TPS_InTagEscapeK, 0, NULL},
{p_iseqC, '"', A_NEXT, TPS_InTagEscapeKK, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_Null, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '=', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '_', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '#', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '/', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, ':', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '.', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '&', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '?', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '%', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '~', A_NEXT, TPS_Null, 0, NULL},
{p_isspace, 0, A_NEXT, TPS_Null, 0, SpecialTags},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}
SpecialTags
static void SpecialTags(TParser *prs)
Definition: wparser_def.c:563

Definition at line 1242 of file wparser_def.c.

◆ actionTPS_InTagBackSleshed

const TParserStateActionItem actionTPS_InTagBackSleshed[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{NULL, 0, A_MERGE, TPS_Null, 0, NULL}
}

Definition at line 1278 of file wparser_def.c.

◆ actionTPS_InTagBeginEnd

const TParserStateActionItem actionTPS_InTagBeginEnd[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '>', A_NEXT, TPS_InTagEnd, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1236 of file wparser_def.c.

◆ actionTPS_InTagCloseFirst

const TParserStateActionItem actionTPS_InTagCloseFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InTagName, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1216 of file wparser_def.c.

◆ actionTPS_InTagEnd

const TParserStateActionItem actionTPS_InTagEnd[]
static
Initial value:
= {
{NULL, 0, A_BINGO | A_CLRALL, TPS_Base, TAG_T, NULL}
}

Definition at line 1283 of file wparser_def.c.

◆ actionTPS_InTagEscapeK

const TParserStateActionItem actionTPS_InTagEscapeK[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '\\', A_PUSH, TPS_InTagBackSleshed, 0, NULL},
{p_iseqC, '\'', A_NEXT, TPS_InTag, 0, NULL},
{NULL, 0, A_NEXT, TPS_InTagEscapeK, 0, NULL}
}

Definition at line 1264 of file wparser_def.c.

◆ actionTPS_InTagEscapeKK

const TParserStateActionItem actionTPS_InTagEscapeKK[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '\\', A_PUSH, TPS_InTagBackSleshed, 0, NULL},
{p_iseqC, '"', A_NEXT, TPS_InTag, 0, NULL},
{NULL, 0, A_NEXT, TPS_InTagEscapeKK, 0, NULL}
}

Definition at line 1271 of file wparser_def.c.

◆ actionTPS_InTagFirst

const TParserStateActionItem actionTPS_InTagFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '/', A_PUSH, TPS_InTagCloseFirst, 0, NULL},
{p_iseqC, '!', A_PUSH, TPS_InCommentFirst, 0, NULL},
{p_iseqC, '?', A_PUSH, TPS_InXMLBegin, 0, NULL},
{p_isasclet, 0, A_PUSH, TPS_InTagName, 0, NULL},
{p_iseqC, ':', A_PUSH, TPS_InTagName, 0, NULL},
{p_iseqC, '_', A_PUSH, TPS_InTagName, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1197 of file wparser_def.c.

◆ actionTPS_InTagName

const TParserStateActionItem actionTPS_InTagName[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '/', A_NEXT, TPS_InTagBeginEnd, 0, NULL},
{p_iseqC, '>', A_NEXT, TPS_InTagEnd, 0, SpecialTags},
{p_isspace, 0, A_NEXT, TPS_InTag, 0, SpecialTags},
{p_isalnum, 0, A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, ':', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '_', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '.', A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_Null, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1222 of file wparser_def.c.

◆ actionTPS_InUDecimal

const TParserStateActionItem actionTPS_InUDecimal[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, DECIMAL_T, NULL},
{p_isdigit, 0, A_NEXT, TPS_InUDecimal, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InVersionFirst, 0, NULL},
{p_iseqC, 'e', A_PUSH, TPS_InMantissaFirst, 0, NULL},
{p_iseqC, 'E', A_PUSH, TPS_InMantissaFirst, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, DECIMAL_T, NULL}
}

Definition at line 1075 of file wparser_def.c.

◆ actionTPS_InUDecimalFirst

const TParserStateActionItem actionTPS_InUDecimalFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_CLEAR, TPS_InUDecimal, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1069 of file wparser_def.c.

◆ actionTPS_InUnsignedInt

const TParserStateActionItem actionTPS_InUnsignedInt[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, UNSIGNEDINT, NULL},
{p_isdigit, 0, A_NEXT, TPS_Null, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InHostFirstDomain, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InUDecimalFirst, 0, NULL},
{p_iseqC, 'e', A_PUSH, TPS_InMantissaFirst, 0, NULL},
{p_iseqC, 'E', A_PUSH, TPS_InMantissaFirst, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{p_iseqC, '_', A_PUSH, TPS_InHostFirstAN, 0, NULL},
{p_iseqC, '@', A_PUSH, TPS_InEmail, 0, NULL},
{p_isasclet, 0, A_PUSH, TPS_InHost, 0, NULL},
{p_isalpha, 0, A_NEXT, TPS_InNumWord, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_InNumWord, 0, NULL},
{p_iseqC, '/', A_PUSH, TPS_InFileFirst, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, UNSIGNEDINT, NULL}
}
UNSIGNEDINT
#define UNSIGNEDINT
Definition: wparser_def.c:56

Definition at line 1025 of file wparser_def.c.

◆ actionTPS_InURLPath

const TParserStateActionItem actionTPS_InURLPath[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, URLPATH, NULL},
{p_isurlchar, 0, A_NEXT, TPS_InURLPath, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, URLPATH, NULL}
}
p_isurlchar
static int p_isurlchar(TParser *prs)
Definition: wparser_def.c:504

Definition at line 1469 of file wparser_def.c.

◆ actionTPS_InURLPathFirst

const TParserStateActionItem actionTPS_InURLPathFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isurlchar, 0, A_NEXT, TPS_InURLPath, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL},
}

Definition at line 1459 of file wparser_def.c.

◆ actionTPS_InURLPathStart

const TParserStateActionItem actionTPS_InURLPathStart[]
static
Initial value:
= {
{NULL, 0, A_NEXT, TPS_InURLPath, 0, NULL}
}

Definition at line 1465 of file wparser_def.c.

◆ actionTPS_InVersion

const TParserStateActionItem actionTPS_InVersion[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, VERSIONNUMBER, NULL},
{p_isdigit, 0, A_NEXT, TPS_InVersion, 0, NULL},
{p_iseqC, '.', A_PUSH, TPS_InVersionFirst, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, VERSIONNUMBER, NULL}
}
VERSIONNUMBER
#define VERSIONNUMBER
Definition: wparser_def.c:42

Definition at line 1118 of file wparser_def.c.

◆ actionTPS_InVersionFirst

const TParserStateActionItem actionTPS_InVersionFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_CLEAR, TPS_InVersion, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1112 of file wparser_def.c.

◆ actionTPS_InVerVersion

const TParserStateActionItem actionTPS_InVerVersion[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_RERUN, TPS_InSVerVersion, 0, SpecialVerVersion},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}
SpecialVerVersion
static void SpecialVerVersion(TParser *prs)
Definition: wparser_def.c:602

Definition at line 1099 of file wparser_def.c.

◆ actionTPS_InWord

const TParserStateActionItem actionTPS_InWord[]
static
Initial value:
= {
{p_isEOF, 0, A_BINGO, TPS_Base, WORD_T, NULL},
{p_isalpha, 0, A_NEXT, TPS_Null, 0, NULL},
{p_isspecial, 0, A_NEXT, TPS_Null, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InNumWord, 0, NULL},
{p_iseqC, '-', A_PUSH, TPS_InHyphenWordFirst, 0, NULL},
{NULL, 0, A_BINGO, TPS_Base, WORD_T, NULL}
}
WORD_T
#define WORD_T
Definition: wparser_def.c:36

Definition at line 1016 of file wparser_def.c.

◆ actionTPS_InXMLBegin

const TParserStateActionItem actionTPS_InXMLBegin[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, 'x', A_NEXT, TPS_InTag, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1208 of file wparser_def.c.

◆ actionTPS_InXMLEntity

const TParserStateActionItem actionTPS_InXMLEntity[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isalnum, 0, A_NEXT, TPS_InXMLEntity, 0, NULL},
{p_iseqC, ':', A_NEXT, TPS_InXMLEntity, 0, NULL},
{p_iseqC, '_', A_NEXT, TPS_InXMLEntity, 0, NULL},
{p_iseqC, '.', A_NEXT, TPS_InXMLEntity, 0, NULL},
{p_iseqC, '-', A_NEXT, TPS_InXMLEntity, 0, NULL},
{p_iseqC, ';', A_NEXT, TPS_InXMLEntityEnd, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1154 of file wparser_def.c.

◆ actionTPS_InXMLEntityEnd

const TParserStateActionItem actionTPS_InXMLEntityEnd[]
static
Initial value:
= {
{NULL, 0, A_BINGO | A_CLEAR, TPS_Base, XMLENTITY, NULL}
}
XMLENTITY
#define XMLENTITY
Definition: wparser_def.c:57

Definition at line 1193 of file wparser_def.c.

◆ actionTPS_InXMLEntityFirst

const TParserStateActionItem actionTPS_InXMLEntityFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, '#', A_NEXT, TPS_InXMLEntityNumFirst, 0, NULL},
{p_isasclet, 0, A_NEXT, TPS_InXMLEntity, 0, NULL},
{p_iseqC, ':', A_NEXT, TPS_InXMLEntity, 0, NULL},
{p_iseqC, '_', A_NEXT, TPS_InXMLEntity, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1145 of file wparser_def.c.

◆ actionTPS_InXMLEntityHexNum

const TParserStateActionItem actionTPS_InXMLEntityHexNum[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isxdigit, 0, A_NEXT, TPS_InXMLEntityHexNum, 0, NULL},
{p_iseqC, ';', A_NEXT, TPS_InXMLEntityEnd, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1186 of file wparser_def.c.

◆ actionTPS_InXMLEntityHexNumFirst

const TParserStateActionItem actionTPS_InXMLEntityHexNumFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isxdigit, 0, A_NEXT, TPS_InXMLEntityHexNum, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1173 of file wparser_def.c.

◆ actionTPS_InXMLEntityNum

const TParserStateActionItem actionTPS_InXMLEntityNum[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InXMLEntityNum, 0, NULL},
{p_iseqC, ';', A_NEXT, TPS_InXMLEntityEnd, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1179 of file wparser_def.c.

◆ actionTPS_InXMLEntityNumFirst

const TParserStateActionItem actionTPS_InXMLEntityNumFirst[]
static
Initial value:
= {
{p_isEOF, 0, A_POP, TPS_Null, 0, NULL},
{p_iseqC, 'x', A_NEXT, TPS_InXMLEntityHexNumFirst, 0, NULL},
{p_iseqC, 'X', A_NEXT, TPS_InXMLEntityHexNumFirst, 0, NULL},
{p_isdigit, 0, A_NEXT, TPS_InXMLEntityNum, 0, NULL},
{NULL, 0, A_POP, TPS_Null, 0, NULL}
}

Definition at line 1165 of file wparser_def.c.

◆ lex_descr

const char* const lex_descr[]
static
Initial value:
= {
"",
"Word, all ASCII",
"Word, all letters",
"Word, letters and digits",
"Email address",
"URL",
"Host",
"Scientific notation",
"Version number",
"Hyphenated word part, letters and digits",
"Hyphenated word part, all letters",
"Hyphenated word part, all ASCII",
"Space symbols",
"XML tag",
"Protocol head",
"Hyphenated word, letters and digits",
"Hyphenated word, all ASCII",
"Hyphenated word, all letters",
"URL path",
"File or path name",
"Decimal notation",
"Signed integer",
"Unsigned integer",
"XML entity"
}

Definition at line 88 of file wparser_def.c.

Referenced by prsd_lextype().

◆ tok_alias

const char* const tok_alias[]
static
Initial value:
= {
"",
"asciiword",
"word",
"numword",
"email",
"url",
"host",
"sfloat",
"version",
"hword_numpart",
"hword_part",
"hword_asciipart",
"blank",
"tag",
"protocol",
"numhword",
"asciihword",
"hword",
"url_path",
"file",
"float",
"int",
"uint",
"entity"
}

Definition at line 61 of file wparser_def.c.

Referenced by prsd_lextype(), and TParserGet().