1 /*-
2 * Copyright (c) 1992, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
6 *
7 * See the LICENSE file for redistribution information.
8 */
9
10 #include "config.h"
11
12 #include <sys/types.h>
13 #include <sys/queue.h>
14 #include <sys/stat.h>
15
16 #include <bitstring.h>
17 #include <errno.h>
18 #include <fcntl.h>
19 #include <libgen.h>
20 #include <limits.h>
21 #include <stdint.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "common.h"
27
28 /*
29 * The log consists of records, each containing a type byte and a variable
30 * length byte string, as follows:
31 *
32 * LOG_CURSOR_INIT MARK
33 * LOG_CURSOR_END MARK
34 * LOG_LINE_APPEND recno_t char *
35 * LOG_LINE_DELETE recno_t char *
36 * LOG_LINE_INSERT recno_t char *
37 * LOG_LINE_RESET_F recno_t char *
38 * LOG_LINE_RESET_B recno_t char *
39 * LOG_MARK LMARK
40 *
41 * We do before image physical logging. This means that the editor layer
42 * MAY NOT modify records in place, even if simply deleting or overwriting
43 * characters. Since the smallest unit of logging is a line, we're using
44 * up lots of space. This may eventually have to be reduced, probably by
45 * doing logical logging, which is a much cooler database phrase.
46 *
47 * The implementation of the historic vi 'u' command, using roll-forward and
48 * roll-back, is simple. Each set of changes has a LOG_CURSOR_INIT record,
49 * followed by a number of other records, followed by a LOG_CURSOR_END record.
50 * LOG_LINE_RESET records come in pairs. The first is a LOG_LINE_RESET_B
51 * record, and is the line before the change. The second is LOG_LINE_RESET_F,
52 * and is the line after the change. Roll-back is done by backing up to the
53 * first LOG_CURSOR_INIT record before a change. Roll-forward is done in a
54 * similar fashion.
55 *
56 * The 'U' command is implemented by rolling backward to a LOG_CURSOR_END
57 * record for a line different from the current one. It should be noted that
58 * this means that a subsequent 'u' command will make a change based on the
59 * new position of the log's cursor. This is okay, and, in fact, historic vi
60 * behaved that way.
61 */
62
63 static int log_cursor1(SCR *, int);
64 static void log_err(SCR *, char *, int);
65 #if defined(DEBUG) && 0
66 static void log_trace(SCR *, char *, recno_t, u_char *);
67 #endif
68 static int apply_with(int (*)(SCR *, recno_t, CHAR_T *, size_t),
69 SCR *, recno_t, u_char *, size_t);
70
71 /* Try and restart the log on failure, i.e. if we run out of memory. */
72 #define LOG_ERR { \
73 log_err(sp, __FILE__, __LINE__); \
74 return (1); \
75 }
76
77 /* offset of CHAR_T string in log needs to be aligned on some systems
78 * because it is passed to db_set as a string
79 */
80 typedef struct {
81 char data[sizeof(u_char) /* type */ + sizeof(recno_t)];
82 CHAR_T str[1];
83 } log_t;
84 #define CHAR_T_OFFSET ((char *)(((log_t*)0)->str) - (char *)0)
85
86 /*
87 * log_init --
88 * Initialize the logging subsystem.
89 *
90 * PUBLIC: int log_init(SCR *, EXF *);
91 */
92 int
log_init(SCR * sp,EXF * ep)93 log_init(SCR *sp, EXF *ep)
94 {
95 /*
96 * !!!
97 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
98 *
99 * Initialize the buffer. The logging subsystem has its own
100 * buffers because the global ones are almost by definition
101 * going to be in use when the log runs.
102 */
103 ep->l_lp = NULL;
104 ep->l_len = 0;
105 ep->l_cursor.lno = 1; /* XXX Any valid recno. */
106 ep->l_cursor.cno = 0;
107 ep->l_high = ep->l_cur = 1;
108
109 ep->log = dbopen(NULL, O_CREAT | O_NONBLOCK | O_RDWR,
110 S_IRUSR | S_IWUSR, DB_RECNO, NULL);
111 if (ep->log == NULL) {
112 msgq(sp, M_SYSERR, "009|Log file");
113 F_SET(ep, F_NOLOG);
114 return (1);
115 }
116
117 return (0);
118 }
119
120 /*
121 * log_end --
122 * Close the logging subsystem.
123 *
124 * PUBLIC: int log_end(SCR *, EXF *);
125 */
126 int
log_end(SCR * sp,EXF * ep)127 log_end(SCR *sp, EXF *ep)
128 {
129 /*
130 * !!!
131 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
132 */
133 if (ep->log != NULL) {
134 (void)(ep->log->close)(ep->log);
135 ep->log = NULL;
136 }
137 free(ep->l_lp);
138 ep->l_lp = NULL;
139 ep->l_len = 0;
140 ep->l_cursor.lno = 1; /* XXX Any valid recno. */
141 ep->l_cursor.cno = 0;
142 ep->l_high = ep->l_cur = 1;
143 return (0);
144 }
145
146 /*
147 * log_cursor --
148 * Log the current cursor position, starting an event.
149 *
150 * PUBLIC: int log_cursor(SCR *);
151 */
152 int
log_cursor(SCR * sp)153 log_cursor(SCR *sp)
154 {
155 EXF *ep;
156
157 ep = sp->ep;
158 if (F_ISSET(ep, F_NOLOG))
159 return (0);
160
161 /*
162 * If any changes were made since the last cursor init,
163 * put out the ending cursor record.
164 */
165 if (ep->l_cursor.lno == OOBLNO) {
166 ep->l_cursor.lno = sp->lno;
167 ep->l_cursor.cno = sp->cno;
168 return (log_cursor1(sp, LOG_CURSOR_END));
169 }
170 ep->l_cursor.lno = sp->lno;
171 ep->l_cursor.cno = sp->cno;
172 return (0);
173 }
174
175 /*
176 * log_cursor1 --
177 * Actually push a cursor record out.
178 */
179 static int
log_cursor1(SCR * sp,int type)180 log_cursor1(SCR *sp, int type)
181 {
182 DBT data, key;
183 EXF *ep;
184
185 ep = sp->ep;
186
187 BINC_RETC(sp, ep->l_lp, ep->l_len, sizeof(u_char) + sizeof(MARK));
188 ep->l_lp[0] = type;
189 memmove(ep->l_lp + sizeof(u_char), &ep->l_cursor, sizeof(MARK));
190
191 key.data = &ep->l_cur;
192 key.size = sizeof(recno_t);
193 data.data = ep->l_lp;
194 data.size = sizeof(u_char) + sizeof(MARK);
195 if (ep->log->put(ep->log, &key, &data, 0) == -1)
196 LOG_ERR;
197
198 #if defined(DEBUG) && 0
199 TRACE(sp, "%lu: %s: %u/%u\n", ep->l_cur,
200 type == LOG_CURSOR_INIT ? "log_cursor_init" : "log_cursor_end",
201 sp->lno, sp->cno);
202 #endif
203 /* Reset high water mark. */
204 ep->l_high = ++ep->l_cur;
205
206 return (0);
207 }
208
209 /*
210 * log_line --
211 * Log a line change.
212 *
213 * PUBLIC: int log_line(SCR *, recno_t, u_int);
214 */
215 int
log_line(SCR * sp,recno_t lno,u_int action)216 log_line(SCR *sp, recno_t lno, u_int action)
217 {
218 DBT data, key;
219 EXF *ep;
220 size_t len;
221 CHAR_T *lp;
222 recno_t lcur;
223
224 ep = sp->ep;
225 if (F_ISSET(ep, F_NOLOG))
226 return (0);
227
228 /*
229 * XXX
230 *
231 * Kluge for vi. Clear the EXF undo flag so that the
232 * next 'u' command does a roll-back, regardless.
233 */
234 F_CLR(ep, F_UNDO);
235
236 /* Put out one initial cursor record per set of changes. */
237 if (ep->l_cursor.lno != OOBLNO) {
238 if (log_cursor1(sp, LOG_CURSOR_INIT))
239 return (1);
240 ep->l_cursor.lno = OOBLNO;
241 }
242
243 /*
244 * Put out the changes. If it's a LOG_LINE_RESET_B call, it's a
245 * special case, avoid the caches. Also, if it fails and it's
246 * line 1, it just means that the user started with an empty file,
247 * so fake an empty length line.
248 */
249 if (action == LOG_LINE_RESET_B) {
250 if (db_get(sp, lno, DBG_NOCACHE, &lp, &len)) {
251 if (lno != 1) {
252 db_err(sp, lno);
253 return (1);
254 }
255 len = 0;
256 lp = L("");
257 }
258 } else
259 if (db_get(sp, lno, DBG_FATAL, &lp, &len))
260 return (1);
261 BINC_RETC(sp,
262 ep->l_lp, ep->l_len,
263 len * sizeof(CHAR_T) + CHAR_T_OFFSET);
264 ep->l_lp[0] = action;
265 memmove(ep->l_lp + sizeof(u_char), &lno, sizeof(recno_t));
266 memmove(ep->l_lp + CHAR_T_OFFSET, lp, len * sizeof(CHAR_T));
267
268 lcur = ep->l_cur;
269 key.data = &lcur;
270 key.size = sizeof(recno_t);
271 data.data = ep->l_lp;
272 data.size = len * sizeof(CHAR_T) + CHAR_T_OFFSET;
273 if (ep->log->put(ep->log, &key, &data, 0) == -1)
274 LOG_ERR;
275
276 #if defined(DEBUG) && 0
277 switch (action) {
278 case LOG_LINE_APPEND:
279 TRACE(sp, "%lu: log_line: append: %lu {%u}\n",
280 ep->l_cur, lno, len);
281 break;
282 case LOG_LINE_DELETE:
283 TRACE(sp, "%lu: log_line: delete: %lu {%u}\n",
284 ep->l_cur, lno, len);
285 break;
286 case LOG_LINE_INSERT:
287 TRACE(sp, "%lu: log_line: insert: %lu {%u}\n",
288 ep->l_cur, lno, len);
289 break;
290 case LOG_LINE_RESET_F:
291 TRACE(sp, "%lu: log_line: reset_f: %lu {%u}\n",
292 ep->l_cur, lno, len);
293 break;
294 case LOG_LINE_RESET_B:
295 TRACE(sp, "%lu: log_line: reset_b: %lu {%u}\n",
296 ep->l_cur, lno, len);
297 break;
298 }
299 #endif
300 /* Reset high water mark. */
301 ep->l_high = ++ep->l_cur;
302
303 return (0);
304 }
305
306 /*
307 * log_mark --
308 * Log a mark position. For the log to work, we assume that there
309 * aren't any operations that just put out a log record -- this
310 * would mean that undo operations would only reset marks, and not
311 * cause any other change.
312 *
313 * PUBLIC: int log_mark(SCR *, LMARK *);
314 */
315 int
log_mark(SCR * sp,LMARK * lmp)316 log_mark(SCR *sp, LMARK *lmp)
317 {
318 DBT data, key;
319 EXF *ep;
320
321 ep = sp->ep;
322 if (F_ISSET(ep, F_NOLOG))
323 return (0);
324
325 /* Put out one initial cursor record per set of changes. */
326 if (ep->l_cursor.lno != OOBLNO) {
327 if (log_cursor1(sp, LOG_CURSOR_INIT))
328 return (1);
329 ep->l_cursor.lno = OOBLNO;
330 }
331
332 BINC_RETC(sp, ep->l_lp,
333 ep->l_len, sizeof(u_char) + sizeof(LMARK));
334 ep->l_lp[0] = LOG_MARK;
335 memmove(ep->l_lp + sizeof(u_char), lmp, sizeof(LMARK));
336
337 key.data = &ep->l_cur;
338 key.size = sizeof(recno_t);
339 data.data = ep->l_lp;
340 data.size = sizeof(u_char) + sizeof(LMARK);
341 if (ep->log->put(ep->log, &key, &data, 0) == -1)
342 LOG_ERR;
343
344 #if defined(DEBUG) && 0
345 TRACE(sp, "%lu: mark %c: %lu/%u\n",
346 ep->l_cur, lmp->name, lmp->lno, lmp->cno);
347 #endif
348 /* Reset high water mark. */
349 ep->l_high = ++ep->l_cur;
350 return (0);
351 }
352
353 /*
354 * Log_backward --
355 * Roll the log backward one operation.
356 *
357 * PUBLIC: int log_backward(SCR *, MARK *);
358 */
359 int
log_backward(SCR * sp,MARK * rp)360 log_backward(SCR *sp, MARK *rp)
361 {
362 DBT key, data;
363 EXF *ep;
364 LMARK lm;
365 MARK m;
366 recno_t lno;
367 int didop;
368 u_char *p;
369
370 ep = sp->ep;
371 if (F_ISSET(ep, F_NOLOG)) {
372 msgq(sp, M_ERR,
373 "010|Logging not being performed, undo not possible");
374 return (1);
375 }
376
377 if (ep->l_cur == 1) {
378 msgq(sp, M_BERR, "011|No changes to undo");
379 return (1);
380 }
381
382 F_SET(ep, F_NOLOG); /* Turn off logging. */
383
384 key.data = &ep->l_cur; /* Initialize db request. */
385 key.size = sizeof(recno_t);
386 for (didop = 0;;) {
387 --ep->l_cur;
388 if (ep->log->get(ep->log, &key, &data, 0))
389 LOG_ERR;
390 #if defined(DEBUG) && 0
391 log_trace(sp, "log_backward", ep->l_cur, data.data);
392 #endif
393 switch (*(p = (u_char *)data.data)) {
394 case LOG_CURSOR_INIT:
395 if (didop) {
396 memmove(rp, p + sizeof(u_char), sizeof(MARK));
397 F_CLR(ep, F_NOLOG);
398 return (0);
399 }
400 break;
401 case LOG_CURSOR_END:
402 break;
403 case LOG_LINE_APPEND:
404 case LOG_LINE_INSERT:
405 didop = 1;
406 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
407 if (db_delete(sp, lno))
408 goto err;
409 ++sp->rptlines[L_DELETED];
410 break;
411 case LOG_LINE_DELETE:
412 didop = 1;
413 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
414 if (apply_with(db_insert, sp, lno,
415 p + CHAR_T_OFFSET, data.size - CHAR_T_OFFSET))
416 goto err;
417 ++sp->rptlines[L_ADDED];
418 break;
419 case LOG_LINE_RESET_F:
420 break;
421 case LOG_LINE_RESET_B:
422 didop = 1;
423 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
424 if (apply_with(db_set, sp, lno,
425 p + CHAR_T_OFFSET, data.size - CHAR_T_OFFSET))
426 goto err;
427 if (sp->rptlchange != lno) {
428 sp->rptlchange = lno;
429 ++sp->rptlines[L_CHANGED];
430 }
431 break;
432 case LOG_MARK:
433 didop = 1;
434 memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
435 m.lno = lm.lno;
436 m.cno = lm.cno;
437 if (mark_set(sp, lm.name, &m, 0))
438 goto err;
439 break;
440 default:
441 abort();
442 }
443 }
444
445 err: F_CLR(ep, F_NOLOG);
446 return (1);
447 }
448
449 /*
450 * Log_setline --
451 * Reset the line to its original appearance.
452 *
453 * XXX
454 * There's a bug in this code due to our not logging cursor movements
455 * unless a change was made. If you do a change, move off the line,
456 * then move back on and do a 'U', the line will be restored to the way
457 * it was before the original change.
458 *
459 * PUBLIC: int log_setline(SCR *);
460 */
461 int
log_setline(SCR * sp)462 log_setline(SCR *sp)
463 {
464 DBT key, data;
465 EXF *ep;
466 LMARK lm;
467 MARK m;
468 recno_t lno;
469 u_char *p;
470
471 ep = sp->ep;
472 if (F_ISSET(ep, F_NOLOG)) {
473 msgq(sp, M_ERR,
474 "012|Logging not being performed, undo not possible");
475 return (1);
476 }
477
478 if (ep->l_cur == 1)
479 return (1);
480
481 F_SET(ep, F_NOLOG); /* Turn off logging. */
482
483 key.data = &ep->l_cur; /* Initialize db request. */
484 key.size = sizeof(recno_t);
485 for (;;) {
486 --ep->l_cur;
487 if (ep->log->get(ep->log, &key, &data, 0))
488 LOG_ERR;
489 #if defined(DEBUG) && 0
490 log_trace(sp, "log_setline", ep->l_cur, data.data);
491 #endif
492 switch (*(p = (u_char *)data.data)) {
493 case LOG_CURSOR_INIT:
494 memmove(&m, p + sizeof(u_char), sizeof(MARK));
495 if (m.lno != sp->lno || ep->l_cur == 1) {
496 F_CLR(ep, F_NOLOG);
497 return (0);
498 }
499 break;
500 case LOG_CURSOR_END:
501 memmove(&m, p + sizeof(u_char), sizeof(MARK));
502 if (m.lno != sp->lno) {
503 ++ep->l_cur;
504 F_CLR(ep, F_NOLOG);
505 return (0);
506 }
507 break;
508 case LOG_LINE_APPEND:
509 case LOG_LINE_INSERT:
510 case LOG_LINE_DELETE:
511 case LOG_LINE_RESET_F:
512 break;
513 case LOG_LINE_RESET_B:
514 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
515 if (lno == sp->lno &&
516 apply_with(db_set, sp, lno,
517 p + CHAR_T_OFFSET, data.size - CHAR_T_OFFSET))
518 goto err;
519 if (sp->rptlchange != lno) {
520 sp->rptlchange = lno;
521 ++sp->rptlines[L_CHANGED];
522 }
523 case LOG_MARK:
524 memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
525 m.lno = lm.lno;
526 m.cno = lm.cno;
527 if (mark_set(sp, lm.name, &m, 0))
528 goto err;
529 break;
530 default:
531 abort();
532 }
533 }
534
535 err: F_CLR(ep, F_NOLOG);
536 return (1);
537 }
538
539 /*
540 * Log_forward --
541 * Roll the log forward one operation.
542 *
543 * PUBLIC: int log_forward(SCR *, MARK *);
544 */
545 int
log_forward(SCR * sp,MARK * rp)546 log_forward(SCR *sp, MARK *rp)
547 {
548 DBT key, data;
549 EXF *ep;
550 LMARK lm;
551 MARK m;
552 recno_t lno;
553 int didop;
554 u_char *p;
555
556 ep = sp->ep;
557 if (F_ISSET(ep, F_NOLOG)) {
558 msgq(sp, M_ERR,
559 "013|Logging not being performed, roll-forward not possible");
560 return (1);
561 }
562
563 if (ep->l_cur == ep->l_high) {
564 msgq(sp, M_BERR, "014|No changes to re-do");
565 return (1);
566 }
567
568 F_SET(ep, F_NOLOG); /* Turn off logging. */
569
570 key.data = &ep->l_cur; /* Initialize db request. */
571 key.size = sizeof(recno_t);
572 for (didop = 0;;) {
573 ++ep->l_cur;
574 if (ep->log->get(ep->log, &key, &data, 0))
575 LOG_ERR;
576 #if defined(DEBUG) && 0
577 log_trace(sp, "log_forward", ep->l_cur, data.data);
578 #endif
579 switch (*(p = (u_char *)data.data)) {
580 case LOG_CURSOR_END:
581 if (didop) {
582 ++ep->l_cur;
583 memmove(rp, p + sizeof(u_char), sizeof(MARK));
584 F_CLR(ep, F_NOLOG);
585 return (0);
586 }
587 break;
588 case LOG_CURSOR_INIT:
589 break;
590 case LOG_LINE_APPEND:
591 case LOG_LINE_INSERT:
592 didop = 1;
593 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
594 if (apply_with(db_insert, sp, lno,
595 p + CHAR_T_OFFSET, data.size - CHAR_T_OFFSET))
596 goto err;
597 ++sp->rptlines[L_ADDED];
598 break;
599 case LOG_LINE_DELETE:
600 didop = 1;
601 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
602 if (db_delete(sp, lno))
603 goto err;
604 ++sp->rptlines[L_DELETED];
605 break;
606 case LOG_LINE_RESET_B:
607 break;
608 case LOG_LINE_RESET_F:
609 didop = 1;
610 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
611 if (apply_with(db_set, sp, lno,
612 p + CHAR_T_OFFSET, data.size - CHAR_T_OFFSET))
613 goto err;
614 if (sp->rptlchange != lno) {
615 sp->rptlchange = lno;
616 ++sp->rptlines[L_CHANGED];
617 }
618 break;
619 case LOG_MARK:
620 didop = 1;
621 memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
622 m.lno = lm.lno;
623 m.cno = lm.cno;
624 if (mark_set(sp, lm.name, &m, 0))
625 goto err;
626 break;
627 default:
628 abort();
629 }
630 }
631
632 err: F_CLR(ep, F_NOLOG);
633 return (1);
634 }
635
636 /*
637 * log_err --
638 * Try and restart the log on failure, i.e. if we run out of memory.
639 */
640 static void
log_err(SCR * sp,char * file,int line)641 log_err(SCR *sp, char *file, int line)
642 {
643 EXF *ep;
644
645 msgq(sp, M_SYSERR, "015|%s/%d: log put error", basename(file), line);
646 ep = sp->ep;
647 (void)ep->log->close(ep->log);
648 if (!log_init(sp, ep))
649 msgq(sp, M_ERR, "267|Log restarted");
650 }
651
652 #if defined(DEBUG) && 0
653 static void
log_trace(SCR * sp,char * msg,recno_t rno,u_char * p)654 log_trace(SCR *sp, char *msg, recno_t rno, u_char *p)
655 {
656 LMARK lm;
657 MARK m;
658 recno_t lno;
659
660 switch (*p) {
661 case LOG_CURSOR_INIT:
662 memmove(&m, p + sizeof(u_char), sizeof(MARK));
663 TRACE(sp, "%lu: %s: C_INIT: %u/%u\n", rno, msg, m.lno, m.cno);
664 break;
665 case LOG_CURSOR_END:
666 memmove(&m, p + sizeof(u_char), sizeof(MARK));
667 TRACE(sp, "%lu: %s: C_END: %u/%u\n", rno, msg, m.lno, m.cno);
668 break;
669 case LOG_LINE_APPEND:
670 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
671 TRACE(sp, "%lu: %s: APPEND: %lu\n", rno, msg, lno);
672 break;
673 case LOG_LINE_INSERT:
674 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
675 TRACE(sp, "%lu: %s: INSERT: %lu\n", rno, msg, lno);
676 break;
677 case LOG_LINE_DELETE:
678 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
679 TRACE(sp, "%lu: %s: DELETE: %lu\n", rno, msg, lno);
680 break;
681 case LOG_LINE_RESET_F:
682 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
683 TRACE(sp, "%lu: %s: RESET_F: %lu\n", rno, msg, lno);
684 break;
685 case LOG_LINE_RESET_B:
686 memmove(&lno, p + sizeof(u_char), sizeof(recno_t));
687 TRACE(sp, "%lu: %s: RESET_B: %lu\n", rno, msg, lno);
688 break;
689 case LOG_MARK:
690 memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
691 TRACE(sp,
692 "%lu: %s: MARK: %u/%u\n", rno, msg, lm.lno, lm.cno);
693 break;
694 default:
695 abort();
696 }
697 }
698 #endif
699
700 /*
701 * apply_with --
702 * Apply a realigned line from the log db to the file db.
703 */
704 static int
apply_with(int (* db_func)(SCR *,recno_t,CHAR_T *,size_t),SCR * sp,recno_t lno,u_char * p,size_t len)705 apply_with(int (*db_func)(SCR *, recno_t, CHAR_T *, size_t), SCR *sp,
706 recno_t lno, u_char *p, size_t len)
707 {
708 #ifdef USE_WIDECHAR
709 typedef unsigned long nword;
710
711 static size_t blen;
712 static nword *bp;
713 nword *lp = (nword *)((uintptr_t)p / sizeof(nword) * sizeof(nword));
714
715 if (lp != (nword *)p) {
716 int offl = ((uintptr_t)p - (uintptr_t)lp) << 3;
717 int offr = (sizeof(nword) << 3) - offl;
718 size_t i, cnt = (len + sizeof(nword) / 2) / sizeof(nword);
719
720 if (len > blen) {
721 blen = p2roundup(MAX(len, 512));
722 REALLOC(sp, bp, nword *, blen);
723 if (bp == NULL)
724 return (1);
725 }
726 for (i = 0; i < cnt; ++i)
727 #if BYTE_ORDER == BIG_ENDIAN
728 bp[i] = (lp[i] << offl) ^ (lp[i+1] >> offr);
729 #else
730 bp[i] = (lp[i] >> offl) ^ (lp[i+1] << offr);
731 #endif
732 p = (u_char *)bp;
733 }
734 #endif
735 return db_func(sp, lno, (CHAR_T *)p, len / sizeof(CHAR_T));
736 }
737