Perldelta acknowledgements for 5.29.7.
[perl.git] / dquote.c
1 /*    dquote.c
2  *
3  * This file contains functions that are related to
4  * parsing double-quotish expressions.
5  *
6 */
7
8 #include "EXTERN.h"
9 #define PERL_IN_DQUOTE_C
10 #include "perl.h"
11 #include "dquote_inline.h"
12
13 /* XXX Add documentation after final interface and behavior is decided */
14 /* May want to show context for error, so would pass S_grok_bslash_c(pTHX_ const char* current, const char* start, const bool output_warning)
15     U8 source = *current;
16 */
17
18 char
19 Perl_grok_bslash_c(pTHX_ const char source, const bool output_warning)
20 {
21
22     U8 result;
23
24     if (! isPRINT_A(source)) {
25         Perl_croak(aTHX_ "%s",
26                         "Character following \"\\c\" must be printable ASCII");
27     }
28     else if (source == '{') {
29         const char control = toCTRL('{');
30         if (isPRINT_A(control)) {
31             /* diag_listed_as: Use "%s" instead of "%s" */
32             Perl_croak(aTHX_ "Use \"%c\" instead of \"\\c{\"", control);
33         }
34         else {
35             Perl_croak(aTHX_ "Sequence \"\\c{\" invalid");
36         }
37     }
38
39     result = toCTRL(source);
40     if (output_warning && isPRINT_A(result)) {
41         U8 clearer[3];
42         U8 i = 0;
43         if (! isWORDCHAR(result)) {
44             clearer[i++] = '\\';
45         }
46         clearer[i++] = result;
47         clearer[i++] = '\0';
48
49         Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX),
50                         "\"\\c%c\" is more clearly written simply as \"%s\"",
51                         source,
52                         clearer);
53     }
54
55     return result;
56 }
57
58 bool
59 Perl_grok_bslash_o(pTHX_ char **s, const char * const send, UV *uv,
60                       const char** error_msg,
61                       const bool output_warning, const bool strict,
62                       const bool silence_non_portable,
63                       const bool UTF)
64 {
65
66 /*  Documentation to be supplied when interface nailed down finally
67  *  This returns FALSE if there is an error which the caller need not recover
68  *  from; otherwise TRUE.  In either case the caller should look at *len [???].
69  *  It guarantees that the returned codepoint, *uv, when expressed as
70  *  utf8 bytes, would fit within the skipped "\o{...}" bytes.
71  *  On input:
72  *      s   is the address of a pointer to a string.  **s is 'o', and the
73  *          previous character was a backslash.  At exit, *s will be advanced
74  *          to the byte just after those absorbed by this function.  Hence the
75  *          caller can continue parsing from there.  In the case of an error,
76  *          this routine has generally positioned *s to point just to the right
77  *          of the first bad spot, so that a message that has a "<--" to mark
78  *          the spot will be correctly positioned.
79  *      send - 1  gives a limit in *s that this function is not permitted to
80  *          look beyond.  That is, the function may look at bytes only in the
81  *          range *s..send-1
82  *      uv  points to a UV that will hold the output value, valid only if the
83  *          return from the function is TRUE
84  *      error_msg is a pointer that will be set to an internal buffer giving an
85  *          error message upon failure (the return is FALSE).  Untouched if
86  *          function succeeds
87  *      output_warning says whether to output any warning messages, or suppress
88  *          them
89  *      strict is true if this should fail instead of warn if there are
90  *          non-octal digits within the braces
91  *      silence_non_portable is true if to suppress warnings about the code
92  *          point returned being too large to fit on all platforms.
93  *      UTF is true iff the string *s is encoded in UTF-8.
94  */
95     char* e;
96     STRLEN numbers_len;
97     I32 flags = PERL_SCAN_ALLOW_UNDERSCORES
98                 | PERL_SCAN_DISALLOW_PREFIX
99                 /* XXX Until the message is improved in grok_oct, handle errors
100                  * ourselves */
101                 | PERL_SCAN_SILENT_ILLDIGIT;
102
103     PERL_ARGS_ASSERT_GROK_BSLASH_O;
104
105     assert(*(*s - 1) == '\\');
106     assert(* *s       == 'o');
107     (*s)++;
108
109     if (**s != '{') {
110         *error_msg = "Missing braces on \\o{}";
111         return FALSE;
112     }
113
114     e = (char *) memchr(*s, '}', send - *s);
115     if (!e) {
116         (*s)++;  /* Move past the '{' */
117         while (isOCTAL(**s)) { /* Position beyond the legal digits */
118             (*s)++;
119         }
120         *error_msg = "Missing right brace on \\o{";
121         return FALSE;
122     }
123
124     (*s)++;    /* Point to expected first digit (could be first byte of utf8
125                   sequence if not a digit) */
126     numbers_len = e - *s;
127     if (numbers_len == 0) {
128         (*s)++;    /* Move past the } */
129         *error_msg = "Number with no digits";
130         return FALSE;
131     }
132
133     if (silence_non_portable) {
134         flags |= PERL_SCAN_SILENT_NON_PORTABLE;
135     }
136
137     *uv = grok_oct(*s, &numbers_len, &flags, NULL);
138     /* Note that if has non-octal, will ignore everything starting with that up
139      * to the '}' */
140
141     if (numbers_len != (STRLEN) (e - *s)) {
142         if (strict) {
143             *s += numbers_len;
144             *s += (UTF) ? UTF8SKIP(*s) : (STRLEN) 1;
145             *error_msg = "Non-octal character";
146             return FALSE;
147         }
148         else if (output_warning) {
149             Perl_ck_warner(aTHX_ packWARN(WARN_DIGIT),
150             /* diag_listed_as: Non-octal character '%c'.  Resolved as "%s" */
151                         "Non-octal character '%c'.  Resolved as \"\\o{%.*s}\"",
152                         *(*s + numbers_len),
153                         (int) numbers_len,
154                         *s);
155         }
156     }
157
158     /* Return past the '}' */
159     *s = e + 1;
160
161     return TRUE;
162 }
163
164 bool
165 Perl_grok_bslash_x(pTHX_ char **s, const char * const send, UV *uv,
166                       const char** error_msg,
167                       const bool output_warning, const bool strict,
168                       const bool silence_non_portable,
169                       const bool UTF)
170 {
171
172 /*  Documentation to be supplied when interface nailed down finally
173  *  This returns FALSE if there is an error which the caller need not recover
174  *  from; otherwise TRUE.
175  *  It guarantees that the returned codepoint, *uv, when expressed as
176  *  utf8 bytes, would fit within the skipped "\x{...}" bytes.
177  *
178  *  On input:
179  *      s   is the address of a pointer to a string.  **s is 'x', and the
180  *          previous character was a backslash.  At exit, *s will be advanced
181  *          to the byte just after those absorbed by this function.  Hence the
182  *          caller can continue parsing from there.  In the case of an error,
183  *          this routine has generally positioned *s to point just to the right
184  *          of the first bad spot, so that a message that has a "<--" to mark
185  *          the spot will be correctly positioned.
186  *      send - 1  gives a limit in *s that this function is not permitted to
187  *          look beyond.  That is, the function may look at bytes only in the
188  *          range *s..send-1
189  *      uv  points to a UV that will hold the output value, valid only if the
190  *          return from the function is TRUE
191  *      error_msg is a pointer that will be set to an internal buffer giving an
192  *          error message upon failure (the return is FALSE).  Untouched if
193  *          function succeeds
194  *      output_warning says whether to output any warning messages, or suppress
195  *          them
196  *      strict is true if anything out of the ordinary should cause this to
197  *          fail instead of warn or be silent.  For example, it requires
198  *          exactly 2 digits following the \x (when there are no braces).
199  *          3 digits could be a mistake, so is forbidden in this mode.
200  *      silence_non_portable is true if to suppress warnings about the code
201  *          point returned being too large to fit on all platforms.
202  *      UTF is true iff the string *s is encoded in UTF-8.
203  */
204     char* e;
205     STRLEN numbers_len;
206     I32 flags = PERL_SCAN_DISALLOW_PREFIX;
207
208
209     PERL_ARGS_ASSERT_GROK_BSLASH_X;
210
211     assert(*(*s - 1) == '\\');
212     assert(* *s      == 'x');
213     (*s)++;
214
215     if (strict || ! output_warning) {
216         flags |= PERL_SCAN_SILENT_ILLDIGIT;
217     }
218
219     if (**s != '{') {
220         STRLEN len = (strict) ? 3 : 2;
221
222         *uv = grok_hex(*s, &len, &flags, NULL);
223         *s += len;
224         if (strict && len != 2) {
225             if (len < 2) {
226                 *s += (UTF) ? UTF8SKIP(*s) : 1;
227                 *error_msg = "Non-hex character";
228             }
229             else {
230                 *error_msg = "Use \\x{...} for more than two hex characters";
231             }
232             return FALSE;
233         }
234         return TRUE;
235     }
236
237     e = (char *) memchr(*s, '}', send - *s);
238     if (!e) {
239         (*s)++;  /* Move past the '{' */
240         while (isXDIGIT(**s)) { /* Position beyond the legal digits */
241             (*s)++;
242         }
243         /* XXX The corresponding message above for \o is just '\\o{'; other
244          * messages for other constructs include the '}', so are inconsistent.
245          */
246         *error_msg = "Missing right brace on \\x{}";
247         return FALSE;
248     }
249
250     (*s)++;    /* Point to expected first digit (could be first byte of utf8
251                   sequence if not a digit) */
252     numbers_len = e - *s;
253     if (numbers_len == 0) {
254         if (strict) {
255             (*s)++;    /* Move past the } */
256             *error_msg = "Number with no digits";
257             return FALSE;
258         }
259         *s = e + 1;
260         *uv = 0;
261         return TRUE;
262     }
263
264     flags |= PERL_SCAN_ALLOW_UNDERSCORES;
265     if (silence_non_portable) {
266         flags |= PERL_SCAN_SILENT_NON_PORTABLE;
267     }
268
269     *uv = grok_hex(*s, &numbers_len, &flags, NULL);
270     /* Note that if has non-hex, will ignore everything starting with that up
271      * to the '}' */
272
273     if (strict && numbers_len != (STRLEN) (e - *s)) {
274         *s += numbers_len;
275         *s += (UTF) ? UTF8SKIP(*s) : 1;
276         *error_msg = "Non-hex character";
277         return FALSE;
278     }
279
280     /* Return past the '}' */
281     *s = e + 1;
282
283     return TRUE;
284 }
285
286 /*
287  * ex: set ts=8 sts=4 sw=4 et:
288  */