1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
/*-
* BSD LICENSE
*
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the University of California, Berkeley nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _CMDLINE_PARSE_H_
#define _CMDLINE_PARSE_H_
#ifdef __cplusplus
extern "C" {
#endif
#ifndef offsetof
#define offsetof(type, field) ((size_t) &( ((type *)0)->field) )
#endif
/* return status for parsing */
#define CMDLINE_PARSE_SUCCESS 0
#define CMDLINE_PARSE_AMBIGUOUS -1
#define CMDLINE_PARSE_NOMATCH -2
#define CMDLINE_PARSE_BAD_ARGS -3
/* return status for completion */
#define CMDLINE_PARSE_COMPLETE_FINISHED 0
#define CMDLINE_PARSE_COMPLETE_AGAIN 1
#define CMDLINE_PARSE_COMPLETED_BUFFER 2
/* maximum buffer size for parsed result */
#define CMDLINE_PARSE_RESULT_BUFSIZE 8192
/**
* Stores a pointer to the ops struct, and the offset: the place to
* write the parsed result in the destination structure.
*/
struct cmdline_token_hdr {
struct cmdline_token_ops *ops;
unsigned int offset;
};
typedef struct cmdline_token_hdr cmdline_parse_token_hdr_t;
/**
* A token is defined by this structure.
*
* parse() takes the token as first argument, then the source buffer
* starting at the token we want to parse. The 3rd arg is a pointer
* where we store the parsed data (as binary). It returns the number of
* parsed chars on success and a negative value on error.
*
* complete_get_nb() returns the number of possible values for this
* token if completion is possible. If it is NULL or if it returns 0,
* no completion is possible.
*
* complete_get_elt() copy in dstbuf (the size is specified in the
* parameter) the i-th possible completion for this token. returns 0
* on success or and a negative value on error.
*
* get_help() fills the dstbuf with the help for the token. It returns
* -1 on error and 0 on success.
*/
struct cmdline_token_ops {
/** parse(token ptr, buf, res pts, buf len) */
int (*parse)(cmdline_parse_token_hdr_t *, const char *, void *,
unsigned int);
/** return the num of possible choices for this token */
int (*complete_get_nb)(cmdline_parse_token_hdr_t *);
/** return the elt x for this token (token, idx, dstbuf, size) */
int (*complete_get_elt)(cmdline_parse_token_hdr_t *, int, char *,
unsigned int);
/** get help for this token (token, dstbuf, size) */
int (*get_help)(cmdline_parse_token_hdr_t *, char *, unsigned int);
};
struct cmdline;
/**
* Store a instruction, which is a pointer to a callback function and
* its parameter that is called when the instruction is parsed, a help
* string, and a list of token composing this instruction.
*
* When no tokens are defined (tokens[0] == NULL), they are retrieved
* dynamically by calling f() as follows:
*
* @code
*
* f((struct cmdline_token_hdr **)&token_p,
* NULL,
* (struct cmdline_token_hdr **)&inst->tokens[num]);
*
* @endcode
*
* The address of the resulting token is expected at the location pointed by
* the first argument. Can be set to NULL to end the list.
*
* The cmdline argument (struct cmdline *) is always NULL.
*
* The last argument points to the inst->tokens[] entry to retrieve, which
* is not necessarily inside allocated memory and should neither be read nor
* written. Its sole purpose is to deduce the token entry index of interest
* as described in the example below.
*
* Note about constraints:
*
* - Only the address of these tokens is dynamic, their storage should be
* static like normal tokens.
* - Dynamic token lists that need to maintain an internal context (e.g. in
* order to determine the next token) must store it statically also. This
* context must be reinitialized when the first token is requested, that
* is, when &inst->tokens[0] is provided as the third argument.
* - Dynamic token lists must be NULL-terminated to generate usable
* commands.
*
* @code
*
* // Assuming first and third arguments are respectively named "token_p"
* // and "token":
*
* int index = token - inst->tokens;
*
* if (!index) {
* [...] // Clean up internal context if any.
* }
* [...] // Then set up dyn_token according to index.
*
* if (no_more_tokens)
* *token_p = NULL;
* else
* *token_p = &dyn_token;
*
* @endcode
*/
struct cmdline_inst {
/* f(parsed_struct, data) */
void (*f)(void *, struct cmdline *, void *);
void *data;
const char *help_str;
cmdline_parse_token_hdr_t *tokens[];
};
typedef struct cmdline_inst cmdline_parse_inst_t;
/**
* A context is identified by its name, and contains a list of
* instruction
*
*/
typedef cmdline_parse_inst_t *cmdline_parse_ctx_t;
/**
* Try to parse a buffer according to the specified context. The
* argument buf must ends with "\n\0". The function returns
* CMDLINE_PARSE_AMBIGUOUS, CMDLINE_PARSE_NOMATCH or
* CMDLINE_PARSE_BAD_ARGS on error. Else it calls the associated
* function (defined in the context) and returns 0
* (CMDLINE_PARSE_SUCCESS).
*/
int cmdline_parse(struct cmdline *cl, const char *buf);
/**
* complete() must be called with *state==0 (try to complete) or
* with *state==-1 (just display choices), then called without
* modifying *state until it returns CMDLINE_PARSE_COMPLETED_BUFFER or
* CMDLINE_PARSE_COMPLETED_BUFFER.
*
* It returns < 0 on error.
*
* Else it returns:
* - CMDLINE_PARSE_COMPLETED_BUFFER on completion (one possible
* choice). In this case, the chars are appended in dst buffer.
* - CMDLINE_PARSE_COMPLETE_AGAIN if there is several possible
* choices. In this case, you must call the function again,
* keeping the value of state intact.
* - CMDLINE_PARSE_COMPLETED_BUFFER when the iteration is
* finished. The dst is not valid for this last call.
*
* The returned dst buf ends with \0.
*/
int cmdline_complete(struct cmdline *cl, const char *buf, int *state,
char *dst, unsigned int size);
/* return true if(!c || iscomment(c) || isblank(c) ||
* isendofline(c)) */
int cmdline_isendoftoken(char c);
/* return true if(!c || iscomment(c) || isendofline(c)) */
int cmdline_isendofcommand(char c);
#ifdef __cplusplus
}
#endif
#endif /* _CMDLINE_PARSE_H_ */
|
