← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/libjpeg_turbo/yasm/source/patched-yasm/tools/re2c/re.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/libjpeg_turbo/yasm/source/patched-yasm/tools/re2c/re.h
1
 
#ifndef re2c_re_h
2
 
#define re2c_re_h
3
 
 
4
 
#include <stdio.h>
5
 
#include "tools/re2c/token.h"
6
 
#include "tools/re2c/ins.h"
7
 
 
8
 
typedef struct extop {
9
 
    char    op;
10
 
    int     minsize;
11
 
    int     maxsize;
12
 
} ExtOp;
13
 
 
14
 
typedef struct CharPtn {
15
 
    unsigned int        card;
16
 
    struct CharPtn      *fix;
17
 
    struct CharPtn      *nxt;
18
 
} CharPtn;
19
 
 
20
 
typedef struct CharSet {
21
 
    CharPtn     *fix;
22
 
    CharPtn     *freeHead, **freeTail;
23
 
    CharPtn     *rep[nChars];
24
 
    CharPtn     ptn[nChars];
25
 
} CharSet;
26
 
 
27
 
typedef struct Range {
28
 
    struct Range        *next;
29
 
    unsigned int        lb, ub;         /* [lb,ub) */
30
 
} Range;
31
 
 
32
 
static void
33
 
Range_init(Range *r, unsigned int l, unsigned int u)
34
 
{
35
 
    r->next = NULL;
36
 
    r->lb = l;
37
 
    r->ub = u;
38
 
}
39
 
 
40
 
static Range *
41
 
Range_new(unsigned int l, unsigned int u)
42
 
{
43
 
    Range *r = malloc(sizeof(Range));
44
 
    r->next = NULL;
45
 
    r->lb = l;
46
 
    r->ub = u;
47
 
    return r;
48
 
}
49
 
 
50
 
static void
51
 
Range_copy(Range *ro, const Range *r)
52
 
{
53
 
    ro->next = NULL;
54
 
    ro->lb = r->lb;
55
 
    ro->ub = r->ub;
56
 
}
57
 
 
58
 
static Range *
59
 
Range_new_copy(Range *r)
60
 
{
61
 
    Range *ro = malloc(sizeof(Range));
62
 
    ro->next = NULL;
63
 
    ro->lb = r->lb;
64
 
    ro->ub = r->ub;
65
 
    return ro;
66
 
}
67
 
 
68
 
void Range_out(FILE *, const Range *);
69
 
 
70
 
typedef enum {
71
 
        NULLOP = 1,
72
 
        MATCHOP,
73
 
        RULEOP,
74
 
        ALTOP,
75
 
        CATOP,
76
 
        CLOSEOP,
77
 
        CLOSEVOP
78
 
} RegExpType;
79
 
 
80
 
typedef struct RegExp {
81
 
    RegExpType  type;
82
 
    unsigned int        size;
83
 
    union {
84
 
        /* for MatchOp */
85
 
        Range   *match;
86
 
        /* for RuleOp */
87
 
        struct {
88
 
            struct RegExp       *exp;
89
 
            struct RegExp       *ctx;
90
 
            Ins         *ins;
91
 
            unsigned int        accept;
92
 
            Token       *code;
93
 
            unsigned int        line;
94
 
        } RuleOp;
95
 
        /* for AltOp and CatOp*/
96
 
        struct {
97
 
            struct RegExp       *exp1, *exp2;
98
 
        } AltCatOp;
99
 
        /* for CloseOp */
100
 
        struct RegExp   *exp;
101
 
        /* for CloseVOp*/
102
 
        struct {
103
 
            struct RegExp       *exp;
104
 
            int         min;
105
 
            int         max;
106
 
        } CloseVOp;
107
 
    } d;
108
 
} RegExp;
109
 
 
110
 
static RegExp *
111
 
RegExp_isA(RegExp *r, RegExpType t)
112
 
{
113
 
    return r->type == t ? r : NULL;
114
 
}
115
 
 
116
 
void RegExp_split(RegExp*, CharSet*);
117
 
void RegExp_calcSize(RegExp*, Char*);
118
 
unsigned int RegExp_fixedLength(RegExp*);
119
 
void RegExp_compile(RegExp*, Char*, Ins*);
120
 
void RegExp_display(RegExp*, FILE *);
121
 
 
122
 
static RegExp *
123
 
RegExp_new_NullOp(void)
124
 
{
125
 
    RegExp *r = malloc(sizeof(RegExp));
126
 
    r->type = NULLOP;
127
 
    return r;
128
 
}
129
 
 
130
 
static RegExp *
131
 
RegExp_new_MatchOp(Range *m)
132
 
{
133
 
    RegExp *r = malloc(sizeof(RegExp));
134
 
    r->type = MATCHOP;
135
 
    r->d.match = m;
136
 
    return r;
137
 
}
138
 
 
139
 
RegExp *RegExp_new_RuleOp(RegExp*, RegExp*, Token*, unsigned int);
140
 
 
141
 
static RegExp *
142
 
RegExp_new_AltOp(RegExp *e1, RegExp *e2)
143
 
{
144
 
    RegExp *r = malloc(sizeof(RegExp));
145
 
    r->type = ALTOP;
146
 
    r->d.AltCatOp.exp1 = e1;
147
 
    r->d.AltCatOp.exp2 = e2;
148
 
    return r;
149
 
}
150
 
 
151
 
static RegExp *
152
 
RegExp_new_CatOp(RegExp *e1, RegExp *e2)
153
 
{
154
 
    RegExp *r = malloc(sizeof(RegExp));
155
 
    r->type = CATOP;
156
 
    r->d.AltCatOp.exp1 = e1;
157
 
    r->d.AltCatOp.exp2 = e2;
158
 
    return r;
159
 
}
160
 
 
161
 
static RegExp *
162
 
RegExp_new_CloseOp(RegExp *e)
163
 
{
164
 
    RegExp *r = malloc(sizeof(RegExp));
165
 
    r->type = CLOSEOP;
166
 
    r->d.exp = e;
167
 
    return r;
168
 
}
169
 
 
170
 
static RegExp *
171
 
RegExp_new_CloseVOp(RegExp *e, int lb, int ub)
172
 
{
173
 
    RegExp *r = malloc(sizeof(RegExp));
174
 
    r->type = CLOSEVOP;
175
 
    r->d.CloseVOp.exp = e;
176
 
    r->d.CloseVOp.min = lb;
177
 
    r->d.CloseVOp.max = ub;
178
 
    return r;
179
 
}
180
 
 
181
 
extern void genCode(FILE *, RegExp*);
182
 
extern RegExp *mkDiff(RegExp*, RegExp*);
183
 
extern RegExp *mkDot(void);
184
 
extern RegExp *strToRE(SubStr);
185
 
extern RegExp *strToCaseInsensitiveRE(SubStr);
186
 
extern RegExp *ranToRE(SubStr);
187
 
extern RegExp *invToRE(SubStr);
188
 
 
189
 
extern RegExp *mkAlt(RegExp*, RegExp*);
190
 
 
191
 
#endif