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
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
|
/*
* Copyright (c) 2015 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
Copyright (c) 2001, 2002, 2003 Eliot Dresselhaus
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <vppinfra/format.h>
/* Call user's function to fill input buffer. */
uword
_unformat_fill_input (unformat_input_t * i)
{
uword l, first_mark;
if (i->index == UNFORMAT_END_OF_INPUT)
return i->index;
first_mark = l = vec_len (i->buffer);
if (vec_len (i->buffer_marks) > 0)
first_mark = i->buffer_marks[0];
/* Re-use buffer when no marks. */
if (first_mark > 0)
vec_delete (i->buffer, first_mark, 0);
i->index = vec_len (i->buffer);
for (l = 0; l < vec_len (i->buffer_marks); l++)
i->buffer_marks[l] -= first_mark;
/* Call user's function to fill the buffer. */
if (i->fill_buffer)
i->index = i->fill_buffer (i);
/* If input pointer is still beyond end of buffer even after
fill then we've run out of input. */
if (i->index >= vec_len (i->buffer))
i->index = UNFORMAT_END_OF_INPUT;
return i->index;
}
always_inline uword
is_white_space (uword c)
{
switch (c)
{
case ' ':
case '\t':
case '\n':
case '\r':
return 1;
default:
return 0;
}
}
/* Format function for dumping input stream. */
u8 *
format_unformat_error (u8 * s, va_list * va)
{
unformat_input_t *i = va_arg (*va, unformat_input_t *);
uword l = vec_len (i->buffer);
/* Only show so much of the input buffer (it could be really large). */
uword n_max = 30;
if (i->index < l)
{
uword n = l - i->index;
u8 *p, *p_end;
p = i->buffer + i->index;
p_end = p + (n > n_max ? n_max : n);
/* Skip white space at end. */
if (n <= n_max)
{
while (p_end > p && is_white_space (p_end[-1]))
p_end--;
}
while (p < p_end)
{
switch (*p)
{
case '\r':
vec_add (s, "\\r", 2);
break;
case '\n':
vec_add (s, "\\n", 2);
break;
case '\t':
vec_add (s, "\\t", 2);
break;
default:
vec_add1 (s, *p);
break;
}
p++;
}
if (n > n_max)
vec_add (s, "...", 3);
}
return s;
}
/* Print everything: not just error context. */
u8 *
format_unformat_input (u8 * s, va_list * va)
{
unformat_input_t *i = va_arg (*va, unformat_input_t *);
uword l, n;
if (i->index == UNFORMAT_END_OF_INPUT)
s = format (s, "{END_OF_INPUT}");
else
{
l = vec_len (i->buffer);
n = l - i->index;
if (n > 0)
vec_add (s, i->buffer + i->index, n);
}
return s;
}
#if CLIB_DEBUG > 0
void
di (unformat_input_t * i)
{
fformat (stderr, "%U\n", format_unformat_input, i);
}
#endif
/* Parse delimited vector string. If string starts with { then string
is delimited by balenced parenthesis. Other string is delimited by
white space. {} were chosen since they are special to the shell. */
static uword
unformat_string (unformat_input_t * input,
uword delimiter_character,
uword format_character, va_list * va)
{
u8 **string_return = va_arg (*va, u8 **);
u8 *s = 0;
word paren = 0;
word is_paren_delimited = 0;
word backslash = 0;
uword c;
switch (delimiter_character)
{
case '%':
case ' ':
case '\t':
delimiter_character = 0;
break;
}
while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
{
word add_to_vector;
/* Null return string means to skip over delimited input. */
add_to_vector = string_return != 0;
if (backslash)
backslash = 0;
else
switch (c)
{
case '\\':
backslash = 1;
add_to_vector = 0;
break;
case '{':
if (paren == 0 && vec_len (s) == 0)
{
is_paren_delimited = 1;
add_to_vector = 0;
}
paren++;
break;
case '}':
paren--;
if (is_paren_delimited && paren == 0)
goto done;
break;
case ' ':
case '\t':
case '\n':
case '\r':
if (!is_paren_delimited)
{
unformat_put_input (input);
goto done;
}
break;
default:
if (!is_paren_delimited && c == delimiter_character)
{
unformat_put_input (input);
goto done;
}
}
if (add_to_vector)
vec_add1 (s, c);
}
done:
if (string_return)
{
/* Match the string { END-OF-INPUT as a single brace. */
if (c == UNFORMAT_END_OF_INPUT && vec_len (s) == 0 && paren == 1)
vec_add1 (s, '{');
/* Don't match null string. */
if (c == UNFORMAT_END_OF_INPUT && vec_len (s) == 0)
return 0;
/* Null terminate C string. */
if (format_character == 's')
vec_add1 (s, 0);
*string_return = s;
}
else
vec_free (s); /* just to make sure */
return 1;
}
uword
unformat_hex_string (unformat_input_t * input, va_list * va)
{
u8 **hexstring_return = va_arg (*va, u8 **);
u8 *s;
uword n, d, c;
n = 0;
d = 0;
s = 0;
while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
{
if (c >= '0' && c <= '9')
d = 16 * d + c - '0';
else if (c >= 'a' && c <= 'f')
d = 16 * d + 10 + c - 'a';
else if (c >= 'A' && c <= 'F')
d = 16 * d + 10 + c - 'A';
else
{
unformat_put_input (input);
break;
}
n++;
if (n == 2)
{
vec_add1 (s, d);
n = d = 0;
}
}
/* Hex string must have even number of digits. */
if (n % 2)
{
vec_free (s);
return 0;
}
/* Make sure something was processed. */
else if (s == 0)
{
return 0;
}
*hexstring_return = s;
return 1;
}
/* unformat (input "foo%U", unformat_eof) matches terminal foo only */
uword
unformat_eof (unformat_input_t * input, va_list * va)
{
return unformat_check_input (input) == UNFORMAT_END_OF_INPUT;
}
/* Parse a token containing given set of characters. */
uword
unformat_token (unformat_input_t * input, va_list * va)
{
u8 *token_chars = va_arg (*va, u8 *);
u8 **string_return = va_arg (*va, u8 **);
u8 *s, map[256];
uword i, c;
if (!token_chars)
token_chars = (u8 *) "a-zA-Z0-9_";
memset (map, 0, sizeof (map));
for (s = token_chars; *s;)
{
/* Parse range. */
if (s[0] < s[2] && s[1] == '-')
{
for (i = s[0]; i <= s[2]; i++)
map[i] = 1;
s = s + 3;
}
else
{
map[s[0]] = 1;
s = s + 1;
}
}
s = 0;
while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
{
if (!map[c])
{
unformat_put_input (input);
break;
}
vec_add1 (s, c);
}
if (vec_len (s) == 0)
return 0;
*string_return = s;
return 1;
}
/* Unformat (parse) function which reads a %s string and converts it
to and unformat_input_t. */
uword
unformat_input (unformat_input_t * i, va_list * args)
{
unformat_input_t *sub_input = va_arg (*args, unformat_input_t *);
u8 *s;
if (unformat (i, "%v", &s))
{
unformat_init_vector (sub_input, s);
return 1;
}
return 0;
}
/* Parse a line ending with \n and return it. */
uword
unformat_line (unformat_input_t * i, va_list * va)
{
u8 *line = 0, **result = va_arg (*va, u8 **);
uword c;
while ((c = unformat_get_input (i)) != '\n' && c != UNFORMAT_END_OF_INPUT)
{
vec_add1 (line, c);
}
*result = line;
return vec_len (line);
}
/* Parse a line ending with \n and return it as an unformat_input_t. */
uword
unformat_line_input (unformat_input_t * i, va_list * va)
{
unformat_input_t *result = va_arg (*va, unformat_input_t *);
u8 *line;
if (!unformat_user (i, unformat_line, &line))
return 0;
unformat_init_vector (result, line);
return 1;
}
/* Values for is_signed. */
#define UNFORMAT_INTEGER_SIGNED 1
#define UNFORMAT_INTEGER_UNSIGNED 0
static uword
unformat_integer (unformat_input_t * input,
va_list * va, uword base, uword is_signed, uword data_bytes)
{
uword c, digit;
uword value = 0;
uword n_digits = 0;
uword n_input = 0;
uword sign = 0;
/* We only support bases <= 64. */
if (base < 2 || base > 64)
goto error;
while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
{
switch (c)
{
case '-':
if (n_input == 0)
{
if (is_signed)
{
sign = 1;
goto next_digit;
}
else
/* Leading sign for unsigned number. */
goto error;
}
/* Sign after input (e.g. 100-200). */
goto put_input_done;
case '+':
if (n_input > 0)
goto put_input_done;
sign = 0;
goto next_digit;
case '0' ... '9':
digit = c - '0';
break;
case 'a' ... 'z':
digit = 10 + (c - 'a');
break;
case 'A' ... 'Z':
digit = 10 + (base >= 36 ? 26 : 0) + (c - 'A');
break;
case '/':
digit = 62;
break;
case '?':
digit = 63;
break;
default:
goto put_input_done;
}
if (digit >= base)
{
put_input_done:
unformat_put_input (input);
goto done;
}
{
uword new_value = base * value + digit;
/* Check for overflow. */
if (new_value < value)
goto error;
value = new_value;
}
n_digits += 1;
next_digit:
n_input++;
}
done:
if (sign)
value = -value;
if (n_digits > 0)
{
void *v = va_arg (*va, void *);
if (data_bytes == ~0)
data_bytes = sizeof (int);
switch (data_bytes)
{
case 1:
*(u8 *) v = value;
break;
case 2:
*(u16 *) v = value;
break;
case 4:
*(u32 *) v = value;
break;
case 8:
*(u64 *) v = value;
break;
default:
goto error;
}
return 1;
}
error:
return 0;
}
/* Return x 10^n */
static f64
times_power_of_ten (f64 x, int n)
{
if (n >= 0)
{
static f64 t[8] = { 1e+0, 1e+1, 1e+2, 1e+3, 1e+4, 1e+5, 1e+6, 1e+7, };
while (n >= 8)
{
x *= 1e+8;
n -= 8;
}
return x * t[n];
}
else
{
static f64 t[8] = { 1e-0, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7, };
while (n <= -8)
{
x *= 1e-8;
n += 8;
}
return x * t[-n];
}
}
static uword
unformat_float (unformat_input_t * input, va_list * va)
{
uword c;
u64 values[3];
uword n_digits[3], value_index = 0;
uword signs[2], sign_index = 0;
uword n_input = 0;
memset (values, 0, sizeof (values));
memset (n_digits, 0, sizeof (n_digits));
memset (signs, 0, sizeof (signs));
while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
{
switch (c)
{
case '-':
if (value_index == 2 && n_digits[2] == 0)
/* sign of exponent: it's ok. */ ;
else if (value_index < 2 && n_digits[0] > 0)
{
/* 123- */
unformat_put_input (input);
goto done;
}
else if (n_input > 0)
goto error;
signs[sign_index++] = 1;
goto next_digit;
case '+':
if (value_index == 2 && n_digits[2] == 0)
/* sign of exponent: it's ok. */ ;
else if (value_index < 2 && n_digits[0] > 0)
{
/* 123+ */
unformat_put_input (input);
goto done;
}
else if (n_input > 0)
goto error;
signs[sign_index++] = 0;
goto next_digit;
case 'e':
case 'E':
if (n_input == 0)
goto error;
value_index = 2;
sign_index = 1;
break;
case '.':
if (value_index > 0)
goto error;
value_index = 1;
break;
case '0' ... '9':
{
u64 tmp;
tmp = values[value_index] * 10 + c - '0';
/* Check for overflow. */
if (tmp < values[value_index])
goto error;
values[value_index] = tmp;
n_digits[value_index] += 1;
}
break;
default:
unformat_put_input (input);
goto done;
}
next_digit:
n_input++;
}
done:
{
f64 f_values[2], *value_return;
word expon;
/* Must have either whole or fraction digits. */
if (n_digits[0] + n_digits[1] <= 0)
goto error;
f_values[0] = values[0];
if (signs[0])
f_values[0] = -f_values[0];
f_values[1] = values[1];
f_values[1] = times_power_of_ten (f_values[1], -n_digits[1]);
f_values[0] += f_values[1];
expon = values[2];
if (signs[1])
expon = -expon;
f_values[0] = times_power_of_ten (f_values[0], expon);
value_return = va_arg (*va, f64 *);
*value_return = f_values[0];
return 1;
}
error:
return 0;
}
static const char *
match_input_with_format (unformat_input_t * input, const char *f)
{
uword cf, ci;
ASSERT (*f != 0);
while (1)
{
cf = *f;
if (cf == 0 || cf == '%' || cf == ' ')
break;
f++;
ci = unformat_get_input (input);
if (cf != ci)
return 0;
}
return f;
}
static const char *
do_percent (unformat_input_t * input, va_list * va, const char *f)
{
uword cf, n, data_bytes = ~0;
cf = *f++;
switch (cf)
{
default:
break;
case 'w':
/* Word types. */
cf = *f++;
data_bytes = sizeof (uword);
break;
case 'l':
cf = *f++;
if (cf == 'l')
{
cf = *f++;
data_bytes = sizeof (long long);
}
else
{
data_bytes = sizeof (long);
}
break;
case 'L':
cf = *f++;
data_bytes = sizeof (long long);
break;
}
n = 0;
switch (cf)
{
case 'D':
data_bytes = va_arg (*va, int);
case 'd':
n = unformat_integer (input, va, 10,
UNFORMAT_INTEGER_SIGNED, data_bytes);
break;
case 'u':
n = unformat_integer (input, va, 10,
UNFORMAT_INTEGER_UNSIGNED, data_bytes);
break;
case 'b':
n = unformat_integer (input, va, 2,
UNFORMAT_INTEGER_UNSIGNED, data_bytes);
break;
case 'o':
n = unformat_integer (input, va, 8,
UNFORMAT_INTEGER_UNSIGNED, data_bytes);
break;
case 'X':
data_bytes = va_arg (*va, int);
case 'x':
n = unformat_integer (input, va, 16,
UNFORMAT_INTEGER_UNSIGNED, data_bytes);
break;
case 'f':
n = unformat_float (input, va);
break;
case 's':
case 'v':
n = unformat_string (input, f[0], cf, va);
break;
case 'U':
{
unformat_function_t *f = va_arg (*va, unformat_function_t *);
n = f (input, va);
}
break;
case '=':
case '|':
{
int *var = va_arg (*va, int *);
uword val = va_arg (*va, int);
if (cf == '|')
val |= *var;
*var = val;
n = 1;
}
break;
}
return n ? f : 0;
}
uword
unformat_skip_white_space (unformat_input_t * input)
{
uword n = 0;
uword c;
while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
{
if (!is_white_space (c))
{
unformat_put_input (input);
break;
}
n++;
}
return n;
}
uword
va_unformat (unformat_input_t * input, const char *fmt, va_list * va)
{
const char *f;
uword input_matches_format;
uword default_skip_input_white_space;
uword n_input_white_space_skipped;
uword last_non_white_space_match_percent;
uword last_non_white_space_match_format;
vec_add1_aligned (input->buffer_marks, input->index,
sizeof (input->buffer_marks[0]));
f = fmt;
default_skip_input_white_space = 1;
input_matches_format = 0;
last_non_white_space_match_percent = 0;
last_non_white_space_match_format = 0;
while (1)
{
char cf;
uword is_percent, skip_input_white_space;
cf = *f;
is_percent = 0;
/* Always skip input white space at start of format string.
Otherwise use default skip value which can be changed by %_
(see below). */
skip_input_white_space = f == fmt || default_skip_input_white_space;
/* Spaces in format request skipping input white space. */
if (is_white_space (cf))
{
skip_input_white_space = 1;
/* Multiple format spaces are equivalent to a single white
space. */
while (is_white_space (*++f))
;
}
else if (cf == '%')
{
/* %_ toggles whether or not to skip input white space. */
switch (*++f)
{
case '_':
default_skip_input_white_space =
!default_skip_input_white_space;
f++;
/* For transition from skip to no-skip in middle of format
string, skip input white space. For example, the following matches:
fmt = "%_%d.%d%_->%_%d.%d%_"
input "1.2 -> 3.4"
Without this the space after -> does not get skipped. */
if (!default_skip_input_white_space
&& !(f == fmt + 2 || *f == 0))
unformat_skip_white_space (input);
continue;
/* %% means match % */
case '%':
break;
/* % at end of format string. */
case 0:
goto parse_fail;
default:
is_percent = 1;
break;
}
}
n_input_white_space_skipped = 0;
if (skip_input_white_space)
n_input_white_space_skipped = unformat_skip_white_space (input);
/* End of format string. */
if (cf == 0)
{
/* Force parse error when format string ends and input is
not white or at end. As an example, this is to prevent
format "foo" from matching input "food".
The last_non_white_space_match_percent is to make
"foo %d" match input "foo 10,bletch" with %d matching 10. */
if (skip_input_white_space
&& !last_non_white_space_match_percent
&& !last_non_white_space_match_format
&& n_input_white_space_skipped == 0
&& input->index != UNFORMAT_END_OF_INPUT)
goto parse_fail;
break;
}
last_non_white_space_match_percent = is_percent;
last_non_white_space_match_format = 0;
/* Explicit spaces in format must match input white space. */
if (cf == ' ' && !default_skip_input_white_space)
{
if (n_input_white_space_skipped == 0)
goto parse_fail;
}
else if (is_percent)
{
if (!(f = do_percent (input, va, f)))
goto parse_fail;
}
else
{
const char *g = match_input_with_format (input, f);
if (!g)
goto parse_fail;
last_non_white_space_match_format = g > f;
f = g;
}
}
input_matches_format = 1;
parse_fail:
/* Rewind buffer marks. */
{
uword l = vec_len (input->buffer_marks);
/* If we did not match back up buffer to last mark. */
if (!input_matches_format)
input->index = input->buffer_marks[l - 1];
_vec_len (input->buffer_marks) = l - 1;
}
return input_matches_format;
}
uword
unformat (unformat_input_t * input, const char *fmt, ...)
{
va_list va;
uword result;
va_start (va, fmt);
result = va_unformat (input, fmt, &va);
va_end (va);
return result;
}
uword
unformat_user (unformat_input_t * input, unformat_function_t * func, ...)
{
va_list va;
uword result, l;
/* Save place in input buffer in case parse fails. */
l = vec_len (input->buffer_marks);
vec_add1_aligned (input->buffer_marks, input->index,
sizeof (input->buffer_marks[0]));
va_start (va, func);
result = func (input, &va);
va_end (va);
if (!result && input->index != UNFORMAT_END_OF_INPUT)
input->index = input->buffer_marks[l];
_vec_len (input->buffer_marks) = l;
return result;
}
/* Setup for unformat of Unix style command line. */
void
unformat_init_command_line (unformat_input_t * input, char *argv[])
{
uword i;
unformat_init (input, 0, 0);
/* Concatenate argument strings with space in between. */
for (i = 1; argv[i]; i++)
{
vec_add (input->buffer, argv[i], strlen (argv[i]));
if (argv[i + 1])
vec_add1 (input->buffer, ' ');
}
}
void
unformat_init_string (unformat_input_t * input, char *string, int string_len)
{
unformat_init (input, 0, 0);
if (string_len > 0)
vec_add (input->buffer, string, string_len);
}
void
unformat_init_vector (unformat_input_t * input, u8 * vector_string)
{
unformat_init (input, 0, 0);
input->buffer = vector_string;
}
#ifdef CLIB_UNIX
static uword
clib_file_fill_buffer (unformat_input_t * input)
{
int fd = pointer_to_uword (input->fill_buffer_arg);
uword l, n;
l = vec_len (input->buffer);
vec_resize (input->buffer, 4096);
n = read (fd, input->buffer + l, 4096);
if (n > 0)
_vec_len (input->buffer) = l + n;
if (n <= 0)
return UNFORMAT_END_OF_INPUT;
else
return input->index;
}
void
unformat_init_clib_file (unformat_input_t * input, int file_descriptor)
{
unformat_init (input, clib_file_fill_buffer,
uword_to_pointer (file_descriptor, void *));
}
/* Take input from Unix environment variable. */
uword
unformat_init_unix_env (unformat_input_t * input, char *var)
{
char *val = getenv (var);
if (val)
unformat_init_string (input, val, strlen (val));
return val != 0;
}
#endif /* CLIB_UNIX */
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "gnu")
* End:
*/
|