| 1 | /* Copyright (c) 1979 Regents of the University of California */ |
| 2 | #include "ex.h" |
| 3 | #include "ex_re.h" |
| 4 | |
| 5 | /* |
| 6 | * Routines for address parsing and assignment and checking of address bounds |
| 7 | * in command mode. The routine address is called from ex_cmds.c |
| 8 | * to parse each component of a command (terminated by , ; or the beginning |
| 9 | * of the command itself. It is also called by the scanning routine |
| 10 | * in ex_voperate.c from within open/visual. |
| 11 | * |
| 12 | * Other routines here manipulate the externals addr1 and addr2. |
| 13 | * These are the first and last lines for the current command. |
| 14 | * |
| 15 | * The variable bigmove remembers whether a non-local glitch of . was |
| 16 | * involved in an address expression, so we can set the previous context |
| 17 | * mark '' when such a motion occurs. |
| 18 | */ |
| 19 | |
| 20 | static bool bigmove; |
| 21 | |
| 22 | /* |
| 23 | * Set up addr1 and addr2 for commands whose default address is dot. |
| 24 | */ |
| 25 | setdot() |
| 26 | { |
| 27 | |
| 28 | setdot1(); |
| 29 | if (bigmove) |
| 30 | markDOT(); |
| 31 | } |
| 32 | |
| 33 | /* |
| 34 | * Call setdot1 to set up default addresses without ever |
| 35 | * setting the previous context mark. |
| 36 | */ |
| 37 | setdot1() |
| 38 | { |
| 39 | |
| 40 | if (addr2 == 0) |
| 41 | addr1 = addr2 = dot; |
| 42 | if (addr1 > addr2) { |
| 43 | notempty(); |
| 44 | error("Addr1 > addr2|First address exceeds second"); |
| 45 | } |
| 46 | } |
| 47 | |
| 48 | /* |
| 49 | * Ex allows you to say |
| 50 | * delete 5 |
| 51 | * to delete 5 lines, etc. |
| 52 | * Such nonsense is implemented by setcount. |
| 53 | */ |
| 54 | setcount() |
| 55 | { |
| 56 | register int cnt; |
| 57 | |
| 58 | pastwh(); |
| 59 | if (!isdigit(peekchar())) { |
| 60 | setdot(); |
| 61 | return; |
| 62 | } |
| 63 | addr1 = addr2; |
| 64 | setdot(); |
| 65 | cnt = getnum(); |
| 66 | if (cnt <= 0) |
| 67 | error("Bad count|Nonzero count required"); |
| 68 | addr2 += cnt - 1; |
| 69 | if (addr2 > dol) |
| 70 | addr2 = dol; |
| 71 | nonzero(); |
| 72 | } |
| 73 | |
| 74 | /* |
| 75 | * Parse a number out of the command input stream. |
| 76 | */ |
| 77 | getnum() |
| 78 | { |
| 79 | register int cnt; |
| 80 | |
| 81 | for (cnt = 0; isdigit(peekcd());) |
| 82 | cnt = cnt * 10 + getchar() - '0'; |
| 83 | return (cnt); |
| 84 | } |
| 85 | |
| 86 | /* |
| 87 | * Set the default addresses for commands which use the whole |
| 88 | * buffer as default, notably write. |
| 89 | */ |
| 90 | setall() |
| 91 | { |
| 92 | |
| 93 | if (addr2 == 0) { |
| 94 | addr1 = one; |
| 95 | addr2 = dol; |
| 96 | if (dol == zero) { |
| 97 | dot = zero; |
| 98 | return; |
| 99 | } |
| 100 | } |
| 101 | /* |
| 102 | * Don't want to set previous context mark so use setdot1(). |
| 103 | */ |
| 104 | setdot1(); |
| 105 | } |
| 106 | |
| 107 | /* |
| 108 | * No address allowed on, e.g. the file command. |
| 109 | */ |
| 110 | setnoaddr() |
| 111 | { |
| 112 | |
| 113 | if (addr2 != 0) |
| 114 | error("No address allowed@on this command"); |
| 115 | } |
| 116 | |
| 117 | /* |
| 118 | * Parse an address. |
| 119 | * Just about any sequence of address characters is legal. |
| 120 | * |
| 121 | * If you are tricky you can use this routine and the = command |
| 122 | * to do simple addition and subtraction of cardinals less |
| 123 | * than the number of lines in the file. |
| 124 | */ |
| 125 | line * |
| 126 | address(inline) |
| 127 | char *inline; |
| 128 | { |
| 129 | register line *addr; |
| 130 | register int offset, c; |
| 131 | short lastsign; |
| 132 | |
| 133 | bigmove = 0; |
| 134 | lastsign = 0; |
| 135 | offset = 0; |
| 136 | addr = 0; |
| 137 | for (;;) { |
| 138 | if (isdigit(peekcd())) { |
| 139 | if (addr == 0) { |
| 140 | addr = zero; |
| 141 | bigmove = 1; |
| 142 | } |
| 143 | loc1 = 0; |
| 144 | addr += offset; |
| 145 | offset = getnum(); |
| 146 | if (lastsign >= 0) |
| 147 | addr += offset; |
| 148 | else |
| 149 | addr -= offset; |
| 150 | lastsign = 0; |
| 151 | offset = 0; |
| 152 | } |
| 153 | switch (c = getcd()) { |
| 154 | |
| 155 | case '?': |
| 156 | case '/': |
| 157 | case '$': |
| 158 | case '\'': |
| 159 | case '\\': |
| 160 | bigmove++; |
| 161 | case '.': |
| 162 | if (addr || offset) |
| 163 | error("Badly formed address"); |
| 164 | } |
| 165 | offset += lastsign; |
| 166 | lastsign = 0; |
| 167 | switch (c) { |
| 168 | |
| 169 | case ' ': |
| 170 | case '\t': |
| 171 | continue; |
| 172 | |
| 173 | case '+': |
| 174 | lastsign = 1; |
| 175 | if (addr == 0) |
| 176 | addr = dot; |
| 177 | continue; |
| 178 | |
| 179 | case '^': |
| 180 | case '-': |
| 181 | lastsign = -1; |
| 182 | if (addr == 0) |
| 183 | addr = dot; |
| 184 | continue; |
| 185 | |
| 186 | case '\\': |
| 187 | case '?': |
| 188 | case '/': |
| 189 | c = compile(c, 1); |
| 190 | notempty(); |
| 191 | savere(scanre); |
| 192 | addr = dot; |
| 193 | if (inline && execute(0, dot)) { |
| 194 | if (c == '/') { |
| 195 | while (loc1 <= inline) |
| 196 | if (!execute(1)) |
| 197 | goto nope; |
| 198 | break; |
| 199 | } else if (loc1 < inline) { |
| 200 | char *last; |
| 201 | doques: |
| 202 | |
| 203 | do { |
| 204 | last = loc1; |
| 205 | if (!execute(1)) |
| 206 | break; |
| 207 | } while (loc1 < inline); |
| 208 | loc1 = last; |
| 209 | break; |
| 210 | } |
| 211 | } |
| 212 | nope: |
| 213 | for (;;) { |
| 214 | if (c == '/') { |
| 215 | addr++; |
| 216 | if (addr > dol) { |
| 217 | if (value(WRAPSCAN) == 0) |
| 218 | error("No match to BOTTOM|Address search hit BOTTOM without matching pattern"); |
| 219 | addr = zero; |
| 220 | } |
| 221 | } else { |
| 222 | addr--; |
| 223 | if (addr < zero) { |
| 224 | if (value(WRAPSCAN) == 0) |
| 225 | error("No match to TOP|Address search hit TOP without matching pattern"); |
| 226 | addr = dol; |
| 227 | } |
| 228 | } |
| 229 | if (execute(0, addr)) { |
| 230 | if (inline && c == '?') { |
| 231 | inline = &linebuf[LBSIZE]; |
| 232 | goto doques; |
| 233 | } |
| 234 | break; |
| 235 | } |
| 236 | if (addr == dot) |
| 237 | error("Fail|Pattern not found"); |
| 238 | } |
| 239 | continue; |
| 240 | |
| 241 | case '$': |
| 242 | addr = dol; |
| 243 | continue; |
| 244 | |
| 245 | case '.': |
| 246 | addr = dot; |
| 247 | continue; |
| 248 | |
| 249 | case '\'': |
| 250 | c = markreg(getchar()); |
| 251 | if (c == 0) |
| 252 | error("Marks are ' and a-z"); |
| 253 | addr = getmark(c); |
| 254 | if (addr == 0) |
| 255 | error("Undefined mark@referenced"); |
| 256 | break; |
| 257 | |
| 258 | default: |
| 259 | ungetchar(c); |
| 260 | if (offset) { |
| 261 | if (addr == 0) |
| 262 | addr = dot; |
| 263 | addr += offset; |
| 264 | loc1 = 0; |
| 265 | } |
| 266 | if (addr == 0) { |
| 267 | bigmove = 0; |
| 268 | return (0); |
| 269 | } |
| 270 | if (addr != zero) |
| 271 | notempty(); |
| 272 | addr += lastsign; |
| 273 | if (addr < zero) |
| 274 | error("Negative address@- first buffer line is 1"); |
| 275 | if (addr > dol) |
| 276 | error("Not that many lines@in buffer"); |
| 277 | return (addr); |
| 278 | } |
| 279 | } |
| 280 | } |
| 281 | |
| 282 | /* |
| 283 | * Abbreviations to make code smaller |
| 284 | * Left over from squashing ex version 1.1 into |
| 285 | * 11/34's and 11/40's. |
| 286 | */ |
| 287 | setCNL() |
| 288 | { |
| 289 | |
| 290 | setcount(); |
| 291 | newline(); |
| 292 | } |
| 293 | |
| 294 | setNAEOL() |
| 295 | { |
| 296 | |
| 297 | setnoaddr(); |
| 298 | eol(); |
| 299 | } |