| blob | 5033dd492148a9c4696ff593404f699c79e5bcfa |
1 /*
2 * subst.c - various substitutions
3 *
4 * This file is part of zsh, the Z shell.
5 *
6 * Copyright (c) 1992-1997 Paul Falstad
7 * All rights reserved.
8 *
9 * Permission is hereby granted, without written agreement and without
10 * license or royalty fees, to use, copy, modify, and distribute this
11 * software and to distribute modified versions of this software for any
12 * purpose, provided that the above copyright notice and the following
13 * two paragraphs appear in all copies of this software.
14 *
15 * In no event shall Paul Falstad or the Zsh Development Group be liable
16 * to any party for direct, indirect, special, incidental, or consequential
17 * damages arising out of the use of this software and its documentation,
18 * even if Paul Falstad and the Zsh Development Group have been advised of
19 * the possibility of such damage.
20 *
21 * Paul Falstad and the Zsh Development Group specifically disclaim any
22 * warranties, including, but not limited to, the implied warranties of
23 * merchantability and fitness for a particular purpose. The software
24 * provided hereunder is on an "as is" basis, and Paul Falstad and the
25 * Zsh Development Group have no obligation to provide maintenance,
26 * support, updates, enhancements, or modifications.
27 *
28 */
33 #define LF_ARRAY 1
35 /**/
38 /* Do substitutions before fork. These are:
39 * - Process substitution: <(...), >(...), =(...)
40 * - Parameter substitution
41 * - Command substitution
42 * Followed by
43 * - Quote removal
44 * - Brace expansion
45 * - Tilde and equals substitution
46 *
47 * PF_* flags are defined in zsh.h
48 */
50 /**/
51 mod_export void
53 {
60 /*
61 * Here and below we avoid taking the address
62 * of a void * and then pretending it's a char **
63 * instead of a void ** by a little inefficiency.
64 * This could be avoided with some extra linked list
65 * machinery, but that would need quite a lot of work
66 * to ensure consistency. What we really need is
67 * templates...
68 */
71 /*
72 * The assignment is so simple it's not worth
73 * testing if cptr changed...
74 */
76 }
80 }
81 }
93 }
94 }
99 }
105 }
106 }
108 }
110 /*
111 * Perform $'...' quoting. The arguments are
112 * strstart The start of the string
113 * pstrdpos Initially, *pstrdpos is the position where the $ of the $'
114 * occurs. It will be updated to the next character after the
115 * last ' of the $'...'.
116 * The return value is the entire allocated string from strstart on the heap.
117 * Note the original string may be modified in the process.
118 */
119 /**/
122 {
134 else
138 else
144 }
146 /**/
147 static LinkNode
149 {
163 else
174 }
178 }
186 str++;
187 }
195 str++;
198 /* $[...] */
200 str2++;
204 }
219 }
221 comsub: {
222 LinkList pl;
230 #ifdef DEBUG
233 #else
235 #endif
236 str--;
243 }
246 /* Math substitution of the form $((...)) */
251 }
253 /* It is a command substitution, which will be parsed again *
254 * by the lexer, so we untokenize it first, but we cannot use *
255 * untokenize() since in the case of `...` some Bnulls should *
256 * be left unchanged. Note that the lexer doesn't tokenize *
257 * the body of a command substitution so if there are some *
258 * tokens here they are from a ${(e)~...} substitution. */
265 str++;
269 }
271 str2--;
275 }
290 }
300 /*
301 * We are in a normal argument which looks like an assignment
302 * and is to be treated like one, with no word splitting.
303 */
305 }
306 str++;
307 }
309 }
311 /*
312 * Simplified version of the prefork/singsub processing where
313 * we only do substitutions appropriate to quoting. Currently
314 * this means only the expansions in $'....'. This is used
315 * for the end tag for here documents. As we are not doing
316 * `...` expansions, we just use those for quoting. However,
317 * they stay in the text. This is weird, but that's not
318 * my fault.
319 *
320 * The remnulargs() makes this consistent with the other forms
321 * of substitution, indicating that quotes have been fully
322 * processed.
323 *
324 * The fully processed string is returned.
325 */
327 /**/
330 {
337 s++;
338 }
339 }
342 }
344 /**/
345 mod_export void
347 {
354 }
357 }
359 /* perform substitution on a single word */
361 /**/
362 mod_export void
364 {
374 }
376 /* Perform substitution on a single word, *s. Unlike with singsub(), the
377 * result can be more than one word. If split is non-zero, the string is
378 * first word-split using IFS, but only for non-quoted "whitespace" (as
379 * indicated by Dnull, Snull, Tick, Bnull, Inpar, and Outpar).
380 *
381 * If arg "a" was non-NULL and we got an array as a result of the parsing,
382 * the strings are stored in *a (even for a 1-element array) and *isarr is
383 * set to 1. Otherwise, *isarr is set to 0, and the result is put into *s,
384 * with any necessary joining of multiple elements using sep (which can be
385 * NULL to use IFS). The return value is true iff the expansion resulted
386 * in an empty list. */
388 /**/
389 static int
391 {
397 /*
398 * This doesn't handle multibyte characters, but we're
399 * looking for whitespace separators which must be ASCII.
400 */
403 l++;
406 }
407 }
417 convchar_t c;
419 /* token, can't be separator, must be single byte */
428 /* as above */
432 }
436 }
440 }
441 }
446 /* These always occur in unnested pairs. */
450 inp++;
453 inp--;
457 /* The parser verified the following char's existence. */
461 }
462 }
463 }
470 }
477 /* We need a way to figure out if a one-item result was a scalar
478 * or a single-item array. The parser will have set LF_ARRAY
479 * in the latter case, allowing us to return it as an array to
480 * our caller (if they provided for that result). */
485 }
490 }
493 else
498 }
500 /*
501 * ~, = subs: assign & PF_TYPESET => typeset or magic equals
502 * assign & PF_ASSIGN => normal assignment
503 */
505 /**/
506 mod_export void
508 {
523 }
526 }
537 }
539 }
540 }
542 /**/
543 mod_export int
545 {
551 Shfunc dirfunc;
576 }
603 }
607 }
612 ;
620 }
625 }
627 #undef isend
628 #undef isend2
629 }
631 /**/
635 {
653 }
655 }
657 /*
658 * Pad the string str, returning a result from the heap (or str itself,
659 * if it didn't need padding). If str is too large, it will be truncated.
660 * Calculations are in terms of width if MULTIBYTE is in effect and
661 * multi_width is non-zero, else characters.
662 *
663 * prenum and postnum are the width to which the string needs padding
664 * on the left and right.
665 *
666 * preone and postone are string to insert once only before and after
667 * str. They will be truncated on the left or right, respectively,
668 * if necessary to fit the width. Either or both may be NULL in which
669 * case they will not be used.
670 *
671 * premul and postmul are the padding strings to be repeated before
672 * on the left (if prenum is non-zero) and right (if postnum is non-zero). If
673 * NULL the first character of IFS (typically but not necessarily a space)
674 * will be used.
675 */
680 #ifdef MULTIBYTE_SUPPORT
682 #endif
683 )
684 {
685 #ifdef MULTIBYTE_SUPPORT
686 #define WCPADWIDTH(cchar) (multi_width ? WCWIDTH(cchar) : 1)
687 #else
688 #define WCPADWIDTH(cchar) (1)
689 #endif
693 convchar_t cchar;
698 else
718 /*
719 * Try to be careful with allocated lengths. The following
720 * is a maximum, in case we need the entire repeated string
721 * for each repetition. We probably don't, but in case the user
722 * has given us something pathological which doesn't convert
723 * easily into a width we'd better be safe.
724 */
726 /*
727 * Same logic for preone and postone, except those may be NULL.
728 */
736 /*
737 * Pad on the left.
738 */
740 /*
741 * Pad on both right and left.
742 * The strategy is to divide the string into two halves.
743 * The first half is dealt with by the left hand padding
744 * code, the second by the right hand.
745 */
748 /* The width left to pad for the first half. */
751 /* First half doesn't fit. Skip the first -f width. */
757 }
758 /* Now finish the first half. */
764 }
768 /*
769 * The unrepeated string doesn't fit.
770 */
772 /* The width we need to skip */
774 /* So skip. */
778 }
779 /* Then copy the entire remainder. */
782 }
787 /*
788 * Left over fraction of repeated string.
789 */
791 /* Skip this much. */
796 }
797 /* Output the rest. */
800 }
802 /* Repeat the repeated string */
809 }
810 }
811 }
813 /* Output the full unrepeated string */
816 }
817 }
818 /* Output the first half width of the original string. */
824 }
825 }
826 /* Other half. In case the string had an odd length... */
828 /* Width that needs padding... */
831 /* ...is negative, truncate original string */
838 }
840 /* Rest of original string fits, output it complete */
845 /* Can't fit unrepeated string, truncate it */
851 }
852 }
856 /* Output entire unrepeated string */
859 }
862 /* Begin the beguine */
865 }
867 /* Fill leftovers with chunk of repeated string */
874 }
875 }
876 }
877 }
878 }
880 /*
881 * Pad only on the left.
882 */
885 /*
886 * Original string is at least as wide as padding.
887 * Truncate original string to width.
888 * Truncate on left, so skip the characters we
889 * don't need.
890 */
896 }
897 /* Copy the rest of the original string */
903 }
905 /*
906 * We can fit the entire string...
907 */
910 /*
911 * ...with some fraction of the unrepeated string.
912 */
913 /* We need this width of characters. */
915 /*
916 * We therefore need to skip this width of
917 * characters.
918 */
924 }
925 /* Copy the rest of preone */
928 }
930 /*
931 * We can fit the whole of preone, needing this width
932 * first
933 */
937 /*
938 * Some fraction of the repeated string needed.
939 */
940 /* Need this much... */
942 /* ...skipping this much first. */
948 }
949 /* Now the rest of the repeated string. */
955 }
956 }
958 /*
959 * Repeat the repeated string.
960 */
967 }
968 }
969 }
971 /*
972 * Now the entire unrepeated string. Don't
973 * count the width, just dump it. This is
974 * significant if there are special characters
975 * in this string. It's sort of a historical
976 * accident that this worked, but there's nothing
977 * to stop us just dumping the thing out and assuming
978 * the user knows what they're doing.
979 */
982 }
983 }
984 /* Now the string being padded */
987 }
988 }
990 /*
991 * Pad on the right.
992 */
996 /*
997 * Original string is at least as wide as padding.
998 * Truncate original string to width.
999 */
1005 }
1007 /*
1008 * There's some space to fill. First copy the original
1009 * string, counting the width. Make sure we copy the
1010 * entire string.
1011 */
1017 }
1021 /*
1022 * Not enough or only just enough space to fit
1023 * the unrepeated string. Truncate as necessary.
1024 */
1030 }
1031 }
1035 /* Copy the entire unrepeated string */
1041 }
1042 }
1044 /* Repeat the repeated string */
1052 }
1053 }
1054 /*
1055 * See if there's any fraction of the repeated
1056 * string needed to fill up the remaining space.
1057 */
1065 }
1066 }
1067 }
1068 }
1069 }
1070 }
1074 }
1077 /*
1078 * Look for a delimited portion of a string. The first (possibly
1079 * multibyte) character at s is the delimiter. Various forms
1080 * of brackets are treated separately, as documented.
1081 *
1082 * Returns a pointer to the final delimiter. Sets *len to the
1083 * length of the final delimiter; a NULL causes *len to be set
1084 * to zero since we shouldn't advance past it. (The string is
1085 * tokenized, so a NULL is a real end of string.)
1086 */
1088 /**/
1091 {
1092 convchar_t del;
1101 }
1103 #ifdef MULTIBYTE_SUPPORT
1106 #endif
1133 }
1136 /*
1137 * Looking for a matching token; we want the literal byte,
1138 * not a decoded multibyte character, so search specially.
1139 */
1141 s++;
1143 convchar_t del2;
1147 #ifdef MULTIBYTE_SUPPORT
1150 #endif
1154 }
1155 }
1159 }
1161 /*
1162 * Get an integer argument; update *s to the end of the
1163 * final delimiter. *delmatchp is set to the length of the
1164 * matched delimiter if we have matching, delimiters and there was no error in
1165 * the evaluation, else 0.
1166 */
1168 /**/
1169 static int
1171 {
1175 zlong ret;
1197 }
1199 /* Parsing for the (e) flag. */
1201 static int
1203 {
1220 }
1222 }
1224 }
1226 /* Evaluation for (#) flag */
1230 {
1236 #ifdef MULTIBYTE_SUPPORT
1238 /* '\\' + 'U' + 8 bytes of character + '\0' */
1241 /* inefficient: should separate out \U handling from getkeystring */
1244 }
1246 #endif
1247 {
1251 }
1253 }
1255 /*
1256 * Helper function for arguments to parameter flags which
1257 * handles the (p) and (~) flags as escapes and tok_arg respectively.
1258 */
1262 {
1270 }
1274 }
1276 /* parameter substitution */
1281 /*
1282 * Given a linked list l with node n, perform parameter substitution
1283 * starting from *str. Return the node with the substitutuion performed
1284 * or NULL if it failed.
1285 *
1286 * If qt is true, the `$' was quoted. TODO: why can't we just look
1287 * to see if the first character was String or Qstring?
1288 *
1289 * If ssub is true, we are being called via singsubst(), which means
1290 * the result will be a single word. TODO: can we generate the
1291 * single word at the end? TODO: if not, or maybe in any case,
1292 * can we pass down the ssub flag from prefork with the other flags
1293 * instead of pushing it into different arguments? (How exactly
1294 * to qt and ssub differ? Are both necessary, if so is there some
1295 * better way of separating the two?)
1296 */
1298 /**/
1299 static LinkNode
1301 {
1305 /*
1306 * There are far too many flags. They need to be grouped
1307 * together into some structure which ties them to where they
1308 * came from.
1309 *
1310 * Some flags have a an obscure relationship to their effect which
1311 * depends on incrementing them to particular values in particular
1312 * ways.
1313 */
1314 /*
1315 * Whether the value is an array (in aval) or not (in val). There's
1316 * a movement from storing the value in the stuff read from the
1317 * parameter (the value v) to storing them in val and aval.
1318 * However, sometimes you find v reappearing temporarily.
1319 *
1320 * The values -1 and 2 are special to isarr. The value -1 is used
1321 * to force us to keep an empty array. It's tested in the YUK chunk
1322 * (I mean the one explicitly marked as such). The value 2
1323 * indicates an array has come from splitting a scalar. We use
1324 * that to override the usual rule that in double quotes we don't
1325 * remove empty elements (so "${(s.:):-foo::bar}" produces two
1326 * words). This seems to me to be quite the wrong thing to do,
1327 * but it looks like code may be relying on it. So we require (@)
1328 * as well before we keep the empty fields (look for assignments
1329 * like "isarr = nojoin ? 1 : 2").
1330 */
1332 /*
1333 * This is just the setting of the option except we need to
1334 * take account of ^ and ^^.
1335 */
1337 /*
1338 * Likwise, but with ~ and ~~. Also, we turn it off later
1339 * on if qt is passed down.
1340 */
1342 /*
1343 * Indicates ${(#)...}.
1344 */
1346 /*
1347 * Indicates ${#pm}, massaged by whichlen which is set by
1348 * the (c), (w), and (W) flags to indicate how we take the length.
1349 */
1352 /*
1353 * Indicates ${+pm}: a simple boolean for once.
1354 */
1356 /*
1357 * Indicates we have tried to get a value in v but that was
1358 * unset. I don't quite understand why (v == NULL) isn't
1359 * good enough, but there are places where we seem to need
1360 * to second guess whether a value is a real value or not.
1361 */
1363 /*
1364 * Indicates (t) flag, i.e. print out types. The code for
1365 * this actually isn't too horrifically inbred compared with
1366 * that for (P).
1367 */
1369 /*
1370 * Indicates spliting a string into an array. There aren't
1371 * actually that many special cases for this --- which may
1372 * be why it doesn't work properly; we split in some cases
1373 * where we shouldn't, in particular on the multsubs for
1374 * handling embedded values for ${...=...} and the like.
1375 */
1377 /* Scalar and array value, see isarr above */
1379 /*
1380 * vbuf and v are both used to retrieve parameter values; this
1381 * is a kludge, we pass down vbuf and it may or may not return v.
1382 */
1385 /*
1386 * This expressive name refers to the set of flags which
1387 * is applied to matching for #, %, / and their doubled variants:
1388 * (M), (R), (B), (E), (N), (S).
1389 */
1391 /* Value from (I) flag, used for ditto. */
1393 /*
1394 * sortit is to be passed to strmetasort().
1395 * indord is the (a) flag, which for consistency doesn't get
1396 * combined into sortit.
1397 */
1399 /* (u): straightforward. */
1401 /* combination of (L), (U) and (C) flags. */
1403 /*
1404 * quotemod says we are doing either (q) (positive), (Q) (negative)
1405 * or not (0). quotetype counts the q's for the first case.
1406 * quoterr is simply (X) but gets passed around a lot because the
1407 * combination (eX) needs it.
1408 */
1410 /*
1411 * (V) flag: fairly straightforward, except that as with so
1412 * many flags it's not easy to decide where to put it in the order.
1413 */
1415 /*
1416 * The (z) flag, nothing to do with SH_WORD_SPLIT which is tied
1417 * spbreak, see above; fairly straighforward in use but c.f.
1418 * the comment for visiblemod.
1419 */
1421 /*
1422 * The separator from (j) and (s) respectively, or (F) and (f)
1423 * respectively (hardwired to "\n" in that case). Slightly
1424 * confusingly also used for ${#pm}, thought that's at least
1425 * documented in the manual
1426 */
1428 /*
1429 * Padding strings. The left and right padding strings which
1430 * are repeated, then the ones which only occur once, for
1431 * the (l) and (r) flags.
1432 */
1434 /* Replacement string for /orig/repl and //orig/repl */
1436 /* The numbers for (l) and (r) */
1438 #ifdef MULTIBYTE_SUPPORT
1439 /* The (m) flag: use width of multibyte characters */
1441 #endif
1442 /*
1443 * Whether the value has been copied. Optimisation: if we
1444 * are modifying an expression, we only need to copy it the
1445 * first time, and if we don't modify it we can just use the
1446 * value from the parameter or input.
1447 */
1449 /*
1450 * The (A) flag for array assignment, with consequences for
1451 * splitting and joining; (AA) gives arrasg == 2 for associative
1452 * arrays.
1453 */
1455 /*
1456 * The (e) flag. As we need to do extra work not quite
1457 * at the end, the effect of this is kludged in in several places.
1458 */
1460 /*
1461 * The (P) flag. This interacts a bit obscurely with whether
1462 * or not we are dealing with a sub expression (subexp).
1463 */
1465 /*
1466 * The (%) flag, c.f. visiblemod again.
1467 */
1469 /*
1470 * The (@) flag; interacts obscurely with qt and isarr.
1471 * This is one of the things that decides whether multsub
1472 * will produce an array, but in an extremely indirect fashion.
1473 */
1475 /*
1476 * != 0 means ${...}, otherwise $... What works without braces
1477 * is largely a historical artefact (everything works with braces,
1478 * I sincerely hope).
1479 */
1481 /*
1482 * Use for the (k) flag. Goes down into the parameter code,
1483 * sometimes.
1484 */
1486 /*
1487 * Used for the (v) flag, ditto. Not quite sure why they're
1488 * separate, but the tradition seems to be that things only
1489 * get combined when that makes the result more obscure rather
1490 * than less.
1491 */
1493 /*
1494 * Whether we had to evaluate a subexpression, i.e. an
1495 * internal ${...} or $(...) or plain $pm. We almost don't
1496 * need to remember this (which would be neater), but the (P)
1497 * flag means the subexp and !subexp code is obscurely combined,
1498 * and the argument passing to fetchvalue has another kludge.
1499 */
1503 /*
1504 * Nothing to do unless the character following the $ is
1505 * something we recognise.
1506 *
1507 * Shouldn't this be a table or something? We test for all
1508 * these later on, too.
1509 */
1520 }
1522 /*
1523 * Extra processing if there is an opening brace: mostly
1524 * flags in parentheses, but also one ksh hack.
1525 */
1528 s++;
1529 /*
1530 * In ksh emulation a leading `!' is a special flag working
1531 * sort of like our (k).
1532 * TODO: this is one of very few cases tied directly to
1533 * the emulation mode rather than an option. Since ksh
1534 * doesn't have parameter flags it might be neater to
1535 * handle this with the ^, =, ~ stuff, below.
1536 */
1539 s++;
1543 zlong num;
1544 /*
1545 * The (p) flag is only remembered within
1546 * this block. It says we do print-style handling
1547 * on the values for flags, but only on those.
1548 */
1550 /*
1551 * '~' in parentheses caused tokenization of string arg:
1552 * similar to (p).
1553 */
1594 s++;
1598 s--;
1630 visiblemod++;
1637 quotemod--;
1676 /* fall through */
1685 else
1696 /* fall through */
1698 s++;
1699 /* delimiter position */
1706 else
1708 /* must have same delimiter if more arguments */
1710 /* decrement since loop will increment */
1711 s--;
1713 }
1721 tok_arg);
1722 else
1724 tok_arg);
1728 /* again, continue only if another start delimiter */
1730 /* decrement since loop will increment */
1731 s--;
1733 }
1742 else
1746 /* -1 since loop will increment */
1751 #ifdef MULTIBYTE_SUPPORT
1753 #endif
1772 presc++;
1789 flagerr:
1792 }
1793 }
1794 s++;
1795 }
1796 }
1798 /*
1799 * premul, postmul specify the padding character to be used
1800 * multiple times with the (l) and (r) flags respectively.
1801 */
1807 /*
1808 * Look for special unparenthesised flags.
1809 * TODO: could make these able to appear inside parentheses, too,
1810 * i.e. ${(^)...} etc.
1811 */
1814 /* RC_EXPAND_PARAM on or off (doubled )*/
1817 s++;
1821 /* SH_WORD_SPLIT on or off (doubled). spbreak = 2 means force */
1824 s++;
1833 /*
1834 * Return the length of the parameter.
1835 * getlen can be more than 1 to indicate characters (2),
1836 * words ignoring multiple delimiters (3), words taking
1837 * account of multiple delimiters. delimiter is in
1838 * spsep, NULL means $IFS.
1839 */
1841 /* GLOB_SUBST on or off (doubled) */
1844 s++;
1848 /*
1849 * Return whether indicated parameter is set.
1850 * Try to handle this when parameter is named
1851 * by (P) (second part of test).
1852 */
1857 /* Special case for `$+' on its own --- leave unmodified */
1864 }
1866 /*
1867 * Handles things like ${(f)"$(<file)"} by skipping
1868 * the double quotes. We don't need to know what was
1869 * actually there; the presence of a String or Qstring
1870 * is good enough.
1871 */
1872 s++;
1875 }
1876 /* Don't activate special pattern characters if inside quotes */
1879 /*
1880 * At this point, we usually expect a parameter name.
1881 * However, there may be a nested ${...} or $(...).
1882 * These say that the parameter itself is somewhere inside,
1883 * or that there isn't a parameter and we will get the values
1884 * from a command substitution itself. In either case,
1885 * the current instance of paramsubst() doesn't fetch a value,
1886 * it just operates on what gets passed up.
1887 * (The first ought to have been {...}, reserving ${...}
1888 * for substituting a value at that point, but it's too late now.)
1889 */
1900 /*
1901 * This handles arrays. TODO: this is not the most obscure call to
1902 * multsub() (see below) but even so it would be nicer to pass down
1903 * and back the arrayness more rationally. In that case, we should
1904 * remove the aspar test and extract a value from an array, if
1905 * necessary, when we handle (P) lower down.
1906 */
1908 /* Empty quoted string --- treat as null string, not elided */
1915 /*
1916 * This tests for the second double quote in an expression
1917 * like ${(f)"$(<file)"}, compare above.
1918 */
1920 s++;
1923 /*
1924 * No subexpression, but in any case the value is going
1925 * to give us the name of a parameter on which we do
1926 * our remaining processing. In other words, this
1927 * makes ${(P)param} work like ${(P)${param}}. (Probably
1928 * better looked at, this is the basic code for ${(P)param}
1929 * and it's been kludged into the subexp code because no
1930 * opportunity for a kludge has been neglected.)
1931 */
1937 }
1938 /*
1939 * We need to retrieve a value either if we haven't already
1940 * got it from a subexpression, or if the processing so
1941 * far has just yielded us a parameter name to be processed
1942 * with (P).
1943 */
1947 /*
1948 * Second argument: decide whether to use the subexpression or
1949 * the string next on the line as the parameter name.
1950 * Third argument: decide how processing for brackets
1951 * 1 means full processing
1952 * -1 appears to mean something along the lines of
1953 * only handle single digits and don't handle brackets.
1954 * I *think* (but it's really only a guess) that this
1955 * is used by the test below the wantt handling, so
1956 * that in certain cases we handle brackets there.
1957 * 0 would apparently mean something like we know we
1958 * should have the name of a scalar and we get cross
1959 * if there's anything present which disagrees with that
1960 * but you will search fetchvalue() in vain for comments on this.
1961 * Fourth argument gives flags to do with keys, values, quoting,
1962 * assigning depending on context and parameter flags.
1963 *
1964 * This is the last mention of subexp, so presumably this
1965 * is what the code which makes sure subexp is set if aspar (the
1966 * (P) flag) is set. I *think* what's going on here is the
1967 * second argument is for both input and output: with
1968 * subexp, we only want the input effect, whereas normally
1969 * we let fetchvalue set the main string pointer s to
1970 * the end of the bit it's fetched.
1971 */
1983 /*
1984 * Handle the (t) flag: value now becomes the type
1985 * information for the parameter.
1986 */
1997 }
2031 }
2032 }
2033 /*
2034 * We get in here two ways; either we need to convert v into
2035 * the local value system, or we need to get rid of brackets
2036 * even if there isn't a v.
2037 */
2040 /*
2041 * Index applied to non-existent parameter; we may or may
2042 * not have a value to index, however. Create a temporary
2043 * empty parameter as a trick, and index on that. This
2044 * usually happens the second time around the loop when
2045 * we've used up the original parameter value and want to
2046 * apply a subscript to what's left. However, it's also
2047 * possible it's got something to do with some of that murky
2048 * passing of -1's as the third argument to fetchvalue() to
2049 * inhibit bracket parsing at that stage.
2050 */
2051 Param pm;
2059 }
2064 else
2072 }
2073 /*
2074 * This is where we extract a value (we know now we have
2075 * one) into the local parameters for a scalar (val) or
2076 * array (aval) value. TODO: move val and aval into
2077 * a structure with a discriminator. Hope we can make
2078 * more things array values at this point and dearrayify later.
2079 * v->isarr tells us whether the stuff from down below looks
2080 * like an array.
2081 *
2082 * I think we get to discard the existing value of isarr
2083 * here because it's already been taken account of, either
2084 * in the subexp stuff or immediately above.
2085 */
2087 /*
2088 * No way to get here with v->flags & VALFLAG_INV, so
2089 * getvaluearr() is called by getarrvalue(); needn't test
2090 * PM_HASHED.
2091 */
2098 /* Value retrieved from parameter/subexpression is scalar */
2100 /*
2101 * Although the value is a scalar, the parameter
2102 * itself is an array. Presumably this is due to
2103 * being quoted, or doing single substitution or something,
2104 * TODO: we're about to do some definitely stringy
2105 * stuff, so something like this bit is probably
2106 * necessary. However, I'd like to leave any
2107 * necessary joining of arrays until this point
2108 * to avoid the multsub() horror.
2109 */
2117 }
2119 /*
2120 * There really is a value. Padding and case
2121 * transformations used to be handled here, but
2122 * are now handled in getstrvalue() for greater
2123 * consistency. However, we get unexpected effects
2124 * if we allow them to applied on every call, so
2125 * set the flag that allows them to be substituted.
2126 */
2129 }
2130 }
2131 /*
2132 * Finished with the original parameter and its indices;
2133 * carry on looping to see if we need to do more indexing.
2134 * This means we final get rid of v in favour of val and
2135 * aval. We could do with somehow encapsulating the bit
2136 * where we need v.
2137 */
2141 }
2142 /*
2143 * We're now past the name or subexpression; the only things
2144 * which can happen now are a closing brace, one of the standard
2145 * parameter postmodifiers, or a history-style colon-modifier.
2146 *
2147 * Again, this duplicates tests for characters we're about to
2148 * examine properly later on.
2149 */
2158 }
2159 /*
2160 * Join arrays up if we're in quotes and there isn't some
2161 * override such as (@).
2162 * TODO: hmm, if we're called as part of some recursive
2163 * substitution do we want to delay this until we get back to
2164 * the top level? Or is if there's a qt (i.e. this parameter
2165 * substitution is in quotes) always good enough? Potentially
2166 * we may be OK by now --- all potential `@'s and subexpressions
2167 * have been handled, including any [@] index which comes up
2168 * by virture of v->isarr being set to SCANPM_ISVAR_AT which
2169 * is now in isarr.
2170 *
2171 * However, if we are replacing multsub() with something that
2172 * doesn't mangle arrays, we may need to delay this step until after
2173 * the foo:- or foo:= or whatever that causes that. Note the value
2174 * (string or array) at this point is irrelevant if we are going to
2175 * be doing that. This would mean // and stuff get applied
2176 * arraywise even if quoted. That's probably wrong, so maybe
2177 * this just stays.
2178 *
2179 * We do a separate stage of dearrayification in the YUK chunk,
2180 * I think mostly because of the way we make array or scalar
2181 * values appear to the caller.
2182 */
2189 }
2190 }
2194 /*
2195 * This is to match a closing double quote in case
2196 * we didn't have a subexpression, e.g. ${"foo"}.
2197 * This form is pointless, but logically it ought to work.
2198 */
2200 s++;
2201 }
2202 /*
2203 * We don't yet know whether a `:' introduces a history-style
2204 * colon modifier or qualifies something like ${...:=...}.
2205 * But if we remember the colon here it's easy to check later.
2206 */
2208 s++;
2211 /* fstr is to be the text following the substitution. If we have *
2212 * braces, we look for it here, else we infer it later on. */
2218 bct++;
2221 }
2224 noclosebrace:
2227 }
2230 }
2232 /* Check for ${..?..} or ${..=..} or one of those. *
2233 * Only works if the name is in braces. */
2244 /*
2245 * Default index is 1 if no (I) or (I) gave zero. But
2246 * why don't we set the default explicitly at the start
2247 * and massage any passed index where we set flnum anyway?
2248 */
2250 flnum++;
2254 /* Check for ${..%%..} or ${..##..} */
2256 s++;
2257 /* we have %%, not %, or ##, not # */
2259 }
2260 s++;
2263 /*
2264 * previous flags are irrelevant, except for (S) which
2265 * indicates shortest substring; else look for longest.
2266 */
2269 /* doubled, so replace all occurrences */
2272 }
2273 /* Check for anchored substitution */
2275 /*
2276 * anchor at head: this is the `normal' case in
2277 * getmatch and we only require the flag if SUB_END
2278 * is also present.
2279 */
2281 s++;
2282 }
2284 /* anchor at tail */
2286 s++;
2287 }
2289 /* No anchor, so substring */
2291 }
2292 /*
2293 * Find the / marking the end of the search pattern.
2294 * If there isn't one, we're just going to delete that,
2295 * i.e. replace it with an empty string.
2296 *
2297 * We used to use double backslashes to quote slashes,
2298 * but actually that was buggy and using a single backslash
2299 * is easier and more obvious.
2300 */
2302 {
2304 {
2307 else
2308 ptr++;
2309 }
2310 }
2313 }
2315 /* See if this was ${...:-...}, ${...:=...}, etc. */
2318 /*
2319 * With no special flags, i.e. just a # or % or whatever,
2320 * the matched portion is removed and we keep the rest.
2321 * We also want the rest when we're doing a substitution.
2322 */
2336 }
2338 /* Fall Through! */
2343 /* If word-splitting is enabled, we ask multsub() to split
2344 * the substituted string at unquoted whitespace. Then, we
2345 * turn off spbreak so that no further splitting occurs.
2346 * This allows a construct such as ${1+"$@"} to correctly
2347 * keep its array splits, and weird constructs such as
2348 * ${str+"one two" "3 2 1" foo "$str"} to only be split
2349 * at the unquoted spaces. */
2355 }
2358 /* this must be `::=', unconditional assignment */
2362 s++;
2363 /* Fall through */
2380 }
2383 /* This is an array assignment. */
2390 l--;
2393 else
2403 }
2411 }
2422 }
2431 }
2434 }
2435 }
2444 /*
2445 * paranoia: don't check for jobs, but there shouldn't
2446 * be any if not interactive.
2447 */
2452 }
2454 }
2460 /* This once was executed only `if (qt) ...'. But with that
2461 * patterns in a expansion resulting from a ${(e)...} aren't
2462 * tokenized even though this function thinks they are (it thinks
2463 * they are because parse_subst_str() turns Qstring tokens
2464 * into String tokens and for unquoted parameter expansions the
2465 * lexer normally does tokenize patterns inside parameter
2466 * expansions). */
2467 {
2481 }
2482 }
2483 {
2484 #if 0
2485 /*
2486 * This allows # and % to be at the start of
2487 * a parameter in the substitution, which is
2488 * a bit nasty, and can be done (although
2489 * less efficiently) with anchors.
2490 */
2501 s++;
2503 s++;
2504 }
2505 }
2506 #else
2508 #endif
2509 }
2511 /*
2512 * Either loop over an array doing replacements or
2513 * do the replacment on a string.
2514 *
2515 * We need an untokenized value for matching.
2516 */
2522 }
2525 }
2534 }
2536 }
2538 }
2540 /*
2541 * Handler ${+...}. TODO: strange, why do we handle this only
2542 * if there isn't a trailing modifier? Why don't we do this
2543 * e.g. when we handle the ${(t)...} flag?
2544 */
2553 }
2555 }
2557 /*
2558 * History style colon modifiers. May need to apply
2559 * on multiple elements of an array.
2560 */
2561 s--;
2574 }
2579 }
2581 }
2586 else
2589 }
2590 }
2591 }
2594 }
2602 /*
2603 * Evaluate the value numerically and output the result as
2604 * a character.
2605 */
2612 {
2613 /* When noerrs = 1, the only error is out-of-memory */
2617 }
2618 }
2622 /* When noerrs = 1, the only error is out-of-memory */
2625 }
2631 }
2632 /*
2633 * This handles taking a length with ${#foo} and variations.
2634 * TODO: again. one might naively have thought this had the
2635 * same sort of effect as the ${(t)...} flag and the ${+...}
2636 * test, although in this case we do need the value rather
2637 * the the parameter, so maybe it's a bit different.
2638 */
2654 }
2655 else
2662 else
2664 }
2669 }
2670 /* At this point we make sure that our arrayness has affected the
2671 * arrayness of the linked list. Then, we can turn our value into
2672 * a scalar for convenience sake without affecting the arrayness
2673 * of the resulting value. */
2676 else
2682 /* treat a one-element array as a scalar for purposes of *
2683 * concatenation with surrounding text (some${param}thing) *
2684 * and rc_expand_param handling. Note: LF_ARRAY (above) *
2685 * propagates the true array type from nested expansions. */
2688 }
2689 /* This is where we may join arrays together, e.g. (j:,:) sets "sep", and
2690 * (afterward) may split the joined value (e.g. (s:-:) sets "spsep"). One
2691 * exception is that ${name:-word} and ${name:+word} will have already
2692 * done any requested splitting of the word value with quoting preserved.
2693 * "ssub" is true when we are called from singsub (via prefork):
2694 * it means that we must join arrays and should not split words. */
2699 }
2706 else
2708 }
2711 else
2713 }
2714 /*
2715 * Perform case modififications.
2716 */
2730 }
2731 }
2732 /*
2733 * Perform prompt-style modifications.
2734 */
2742 }
2743 /*
2744 * TODO: It would be really quite nice to abstract the
2745 * isarr and !issarr code into a function which gets
2746 * passed a pointer to a function with the effect of
2747 * the promptexpand bit. Then we could use this for
2748 * a lot of stuff and bury val/aval/isarr inside a structure
2749 * which gets passed to it.
2750 */
2763 }
2772 }
2776 }
2777 /*
2778 * One of the possible set of quotes to apply, depending on
2779 * the repetitions of the (q) flag.
2780 */
2807 }
2820 }
2827 }
2828 }
2860 }
2863 }
2864 }
2865 }
2866 /*
2867 * Transform special characters in the string to make them
2868 * printable.
2869 */
2881 }
2882 }
2883 /*
2884 * Nothing particularly to do with SH_WORD_SPLIT --- this
2885 * performs lexical splitting on a string as specified by
2886 * the (z) flag.
2887 */
2907 }
2909 }
2910 /*
2911 * TODO: hmm. At this point we have to be on our toes about
2912 * whether we're putting stuff into a line or not, i.e.
2913 * we don't want to do this from a recursive call.
2914 * Rather than passing back flags in a non-trivial way, maybe
2915 * we could decide on the basis of flags passed down to us.
2916 *
2917 * This is the ideal place to do any last-minute conversion from
2918 * array to strings. However, given all the transformations we've
2919 * already done, probably if it's going to be done it will already
2920 * have been. (I'd really like to keep everying in aval or
2921 * equivalent and only locally decide if we need to treat it
2922 * as a scalar.)
2923 */
2931 /* Handle the (u) flag; we need this before the next test */
2939 }
2941 /*
2942 * Empty array or single element. Currently you only
2943 * get a single element array at this point from the
2944 * unique expansion above. but we can potentially
2945 * have other reasons.
2946 *
2947 * The following test removes the markers
2948 * from surrounding double quotes, but I don't know why
2949 * that's necessary.
2950 */
2960 {
2963 }
2967 }
2968 /* Handle (o) and (O) and their variants */
2977 /* reverse the array */
2982 }
2983 }
2985 /*
2986 * HERE: we tested if the last element of the array
2987 * was not a NULL string. Why the last element?
2988 * Why didn't we expect NULL strings to work?
2989 * Was it just a clumsy way of testing whether there
2990 * was enough in the array to sort?
2991 */
2993 }
2994 }
2996 /* Handle RC_EXPAND_PARAM */
2997 LinkNode tn;
3009 premul, postmul
3010 #ifdef MULTIBYTE_SUPPORT
3011 , multi_width
3012 #endif
3013 );
3021 copied);
3026 else
3028 }
3029 }
3038 else
3040 }
3044 }
3046 /*
3047 * Not RC_EXPAND_PARAM: simply join the first and
3048 * last values.
3049 * TODO: how about removing the restriction that
3050 * aval[1] is non-NULL to promote consistency?, or
3051 * simply changing the test so that we drop into
3052 * the scalar branch, instead of tricking isarr?
3053 */
3057 premul, postmul
3058 #ifdef MULTIBYTE_SUPPORT
3059 , multi_width
3060 #endif
3061 );
3071 /* aval[1] is non-null here */
3076 premul, postmul
3077 #ifdef MULTIBYTE_SUPPORT
3078 , multi_width
3079 #endif
3080 );
3089 }
3091 }
3096 premul, postmul
3097 #ifdef MULTIBYTE_SUPPORT
3098 , multi_width
3099 #endif
3100 );
3108 }
3112 /*
3113 * Scalar value. Handle last minute transformations
3114 * such as left- or right-padding and the (e) flag to
3115 * revaluate the result.
3116 */
3124 premul, postmul
3125 #ifdef MULTIBYTE_SUPPORT
3126 , multi_width
3127 #endif
3128 );
3136 }
3141 }
3143 /*
3144 * Arithmetic substitution: `a' is the string to be evaluated, `bptr'
3145 * points to the beginning of the string containing it. The tail of
3146 * the string is given by `rest'. *bptr is modified with the substituted
3147 * string. The function returns a pointer to the tail in the substituted
3148 * string.
3149 */
3151 /**/
3154 {
3157 mnumber v;
3167 }
3170 t--;
3172 t--;
3176 }
3178 /**/
3179 void
3181 {
3185 convchar_t del;
3221 #ifdef MULTIBYTE_SUPPORT
3224 #endif
3227 convchar_t del2;
3229 #ifdef MULTIBYTE_SUPPORT
3233 #endif
3236 }
3240 }
3246 convchar_t del3;
3248 #ifdef MULTIBYTE_SUPPORT
3252 #endif
3255 }
3261 }
3265 }
3279 /* Final terminator is optional. */
3281 }
3321 }
3322 }
3327 }
3374 {
3383 }
3385 }
3402 }
3439 {
3448 }
3450 }
3451 }
3455 else
3457 }
3458 }
3459 }
3460 }
3462 /* get a directory stack entry */
3464 /**/
3467 {
3476 else
3484 }
3486 }