link.c

   1 /* lot's of code c&p-ed directly from mupdf */
   2 #ifdef _WIN32
   3 #define WIN32_LEAN_AND_MEAN
   4 #include <windows.h>
   5 #include <winsock2.h>
   6 #define ssize_t int
   7 #pragma warning (disable:4244)
   8 #pragma warning (disable:4996)
   9 #pragma warning (disable:4995)
  10 #endif
  11
  12 #ifdef _MSC_VER
  13 #include <errno.h>
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include <stdlib.h>
  17 static void __declspec (noreturn) err (int exitcode, const char *fmt, ...)
  18 {
  19     va_list ap;
  20     int errcode;
  21
  22     errcode = errno;
  23     va_start (ap, fmt);
  24     vfprintf (stderr, fmt, ap);
  25     va_end (ap);
  26     fprintf (stderr, ": %s\n", strerror (errno));
  27     exit (exitcode);
  28 }
  29 static void __declspec (noreturn) errx (int exitcode, const char *fmt, ...)
  30 {
  31     va_list ap;
  32     int errcode;
  33
  34     errcode = errno;
  35     va_start (ap, fmt);
  36     vfprintf (stderr, fmt, ap);
  37     va_end (ap);
  38     fputc ('\n', stderr);
  39     exit (exitcode);
  40 }
  41 static void __declspec (noreturn) sockerr (int exitcode, const char *fmt, ...)
  42 {
  43     va_list ap;
  44     int errcode;
  45
  46     errcode = errno;
  47     va_start (ap, fmt);
  48     vfprintf (stderr, fmt, ap);
  49     va_end (ap);
  50     fprintf (stderr, ": wsaerror %lx\n", WSAGetLastError ());
  51     exit (exitcode);
  52 }
  53 #else
  54 #define _GNU_SOURCE
  55 #include <err.h>
  56 #define sockerr err
  57 #endif
  58 #include <regex.h>
  59 #include <errno.h>
  60 #include <ctype.h>
  61 #include <stdio.h>
  62 #include <stdarg.h>
  63 #include <stdlib.h>
  64 #include <string.h>
  65 #ifndef _WIN32
  66 #include <pthread.h>
  67 #include <sys/time.h>
  68 #include <sys/types.h>
  69 #include <sys/socket.h>
  70 #include <sys/select.h>
  71 #endif
  72
  73 #ifdef __APPLE__
  74 #include <OpenGL/gl.h>
  75 #else
  76 #include <GL/gl.h>
  77 #endif
  78
  79 #ifndef GL_TEXTURE_RECTANGLE_ARB
  80 #define GL_TEXTURE_RECTANGLE_ARB          0x84F5
  81 #endif
  82
  83 #include <caml/fail.h>
  84 #include <caml/alloc.h>
  85 #include <caml/memory.h>
  86 #include <caml/unixsupport.h>
  87
  88 #include <fitz.h>
  89 #include <mupdf.h>
  90
  91 #if 0
  92 #define lprintf printf
  93 #else
  94 #define lprintf(...)
  95 #endif
  96
  97 #define ARSERT(cond) for (;;) {                         \
  98     if (!(cond)) {                                      \
  99         errx (1, "%s:%d " #cond, __FILE__, __LINE__);   \
 100     }                                                   \
 101     break;                                              \
 102 }
 103
 104 struct slice {
 105     int texindex;
 106     int w, h;
 107 };
 108
 109 struct page {
 110     int pageno;
 111     int slicecount;
 112     fz_textspan *text;
 113     fz_pixmap *pixmap;
 114     pdf_page *drawpage;
 115     struct pagedim *pagedim;
 116     struct page *prev;
 117     struct slice slices[];
 118 };
 119
 120 struct pagedim {
 121     int pageno;
 122     int rotate;
 123     fz_rect box;
 124     fz_bbox bbox;
 125     fz_matrix ctm;
 126 };
 127
 128 struct {
 129     int sock;
 130     int sliceheight;
 131     struct page *pages;
 132     struct pagedim *pagedims;
 133     int pagecount;
 134     int pagedimcount;
 135     pdf_xref *xref;
 136     fz_glyphcache *cache;
 137     int w, h;
 138
 139     int texindex;
 140     int texcount;
 141     GLuint *texids;
 142
 143     GLenum texform;
 144     GLenum texty;
 145
 146     int lotsamemory;
 147
 148     int *pagetbl;
 149     struct {
 150         int w, h;
 151         struct slice *slice;
 152     } *texowners;
 153
 154     int rotate;
 155
 156 #ifdef _WIN32
 157     HANDLE thread;
 158 #else
 159     pthread_t thread;
 160 #endif
 161 } state;
 162
 163 #ifdef _WIN32
 164 static CRITICAL_SECTION critsec;
 165
 166 static void lock (void *unused)
 167 {
 168     (void) unused;
 169     EnterCriticalSection (&critsec);
 170 }
 171
 172 static void unlock (void *unused)
 173 {
 174     (void) unused;
 175     LeaveCriticalSection (&critsec);
 176 }
 177
 178 static int trylock (void *unused)
 179 {
 180     return TryEnterCriticalSection (&critsec) == 0;
 181 }
 182 #else
 183 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 184
 185 static void lock (const char *cap)
 186 {
 187     int ret = pthread_mutex_lock (&mutex);
 188     if (ret) {
 189         errx (1, "%s: pthread_mutex_lock: %s", cap, strerror (ret));
 190     }
 191 }
 192
 193 static void unlock (const char *cap)
 194 {
 195     int ret = pthread_mutex_unlock (&mutex);
 196     if (ret) {
 197         errx (1, "%s: pthread_mutex_unlock: %s", cap, strerror (ret));
 198     }
 199 }
 200
 201 static int trylock (const char *cap)
 202 {
 203     int ret = pthread_mutex_trylock (&mutex);
 204
 205     if (ret && ret != EBUSY) {
 206         errx (1, "%s: pthread_mutex_trylock: %s", cap, strerror (ret));
 207     }
 208     return ret == EBUSY;
 209 }
 210 #endif
 211
 212 static void *parse_pointer (const char *cap, const char *s)
 213 {
 214     int ret;
 215     void *ptr;
 216
 217     ret = sscanf (s, "%p", &ptr);
 218     if (ret != 1) {
 219         errx (1, "%s: cannot parse pointer in `%s'", cap, s);
 220     }
 221     return ptr;
 222 }
 223
 224 static int hasdata (int sock)
 225 {
 226     int n;
 227     fd_set s;
 228     struct timeval tv;
 229     FD_ZERO (&s);
 230     FD_SET (sock, &s);
 231     tv.tv_sec = 0;
 232     tv.tv_usec = 0;
 233     n = select (sock + 1, &s, NULL, NULL, &tv);
 234     if (n == 0) return 0;
 235     if (n == 1) return 1;
 236     sockerr (1, "hasdata: select error ret=%d", n);
 237 }
 238
 239 static double now (void)
 240 {
 241     struct timeval tv;
 242
 243     if (gettimeofday (&tv, NULL)) {
 244         err (1, "gettimeofday");
 245     }
 246     return tv.tv_sec + tv.tv_usec*1e-6;
 247 }
 248
 249 static void readdata (int fd, char *p, int size)
 250 {
 251     ssize_t n;
 252
 253     n = recv (fd, p, size, 0);
 254     if (n - size) {
 255         if (!n) errx (1, "EOF while reading");
 256         sockerr (1, "recv (req %d, ret %zd)", size, n);
 257     }
 258 }
 259
 260 static void writedata (int fd, char *p, int size)
 261 {
 262     char buf[4];
 263     ssize_t n;
 264
 265     buf[0] = (size >> 24) & 0xff;
 266     buf[1] = (size >> 16) & 0xff;
 267     buf[2] = (size >>  8) & 0xff;
 268     buf[3] = (size >>  0) & 0xff;
 269
 270     n = send (fd, buf, 4, 0);
 271     if (n != 4) {
 272         if (!n) errx (1, "EOF while writing length");
 273         sockerr (1, "send %zd", n);
 274     }
 275
 276     n = send (fd, p, size, 0);
 277     if (n - size) {
 278         if (!n) errx (1, "EOF while writing data");
 279         sockerr (1, "send (req %d, ret %zd)", size, n);
 280     }
 281 }
 282
 283 static void
 284 #ifdef __GNUC__
 285 __attribute__ ((format (printf, 2, 3)))
 286 #endif
 287     printd (int fd, const char *fmt, ...)
 288 {
 289     int len;
 290     va_list ap;
 291     char buf[200];
 292
 293     va_start (ap, fmt);
 294     len = vsnprintf (buf, sizeof (buf), fmt, ap);
 295     va_end (ap);
 296     writedata (fd, buf, len);
 297 }
 298
 299 static void die (fz_error error)
 300 {
 301     fz_catch (error, "aborting");
 302     if (state.xref)
 303        pdf_closexref (state.xref);
 304     exit (1);
 305 }
 306
 307 static void openxref (char *filename)
 308 {
 309     int fd;
 310     fz_error error;
 311     fz_stream *file;
 312
 313     fd = open (filename, O_BINARY | O_RDONLY, 0666);
 314     if (fd < 0)
 315         die (fz_throw ("cannot open file '%s'", filename));
 316
 317     file = fz_openfile (fd);
 318     state.xref = pdf_openxref (file);
 319     if (!state.xref)
 320         die (fz_throw ("cannot open PDF file '%s'", filename));
 321     fz_dropstream (file);
 322
 323     if (pdf_needspassword (state.xref)) {
 324         die (fz_throw ("password protected"));
 325     }
 326
 327     error = pdf_loadpagetree (state.xref);
 328     if (error) {
 329         die (fz_throw ("cannot load page tree"));
 330     }
 331
 332     state.pagecount = pdf_getpagecount (state.xref);
 333     state.pagetbl = stat_alloc (state.pagecount * sizeof (*state.pagetbl));
 334 }
 335
 336 static int readlen (int fd)
 337 {
 338     ssize_t n;
 339     char p[4];
 340
 341     n = recv (fd, p, 4, 0);
 342     if (n != 4) {
 343         if (!n) errx (1, "EOF while reading length");
 344         sockerr (1, "recv %zd", n);
 345     }
 346
 347     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 348 }
 349
 350 static void freepage (struct page *page)
 351 {
 352     int i;
 353     struct page *p;
 354
 355     fz_droppixmap (page->pixmap);
 356     for (p = state.pages; p; p = p->prev) {
 357         if (p->prev == page) {
 358             p->prev = page->prev;
 359             break;
 360         }
 361     }
 362     for (i = 0; i < page->slicecount; ++i) {
 363         struct slice *s = &page->slices[i];
 364         if (s->texindex != -1) {
 365             if (state.texowners[s->texindex].slice == s) {
 366                 state.texowners[s->texindex].slice = NULL;
 367                 ARSERT (state.texowners[s->texindex].w == s->w);
 368                 ARSERT (state.texowners[s->texindex].h >= s->h);
 369             }
 370         }
 371     }
 372     if (page->text) {
 373         fz_freetextspan (page->text);
 374     }
 375     if (page->drawpage) {
 376         pdf_freepage (page->drawpage);
 377     }
 378
 379     free (page);
 380 }
 381
 382 static void subdivide (struct page *p)
 383 {
 384     int i;
 385     int h = p->pixmap->h;
 386     int th = MIN (h, state.sliceheight);
 387
 388     for (i = 0; i < p->slicecount; ++i) {
 389         struct slice *s = &p->slices[i];
 390         s->texindex = -1;
 391         s->h = MIN (th, h);
 392         s->w = p->pixmap->w;
 393         h -= th;
 394     }
 395 }
 396
 397 static void *render (int pageno, int pindex)
 398 {
 399     fz_error error;
 400     int slicecount;
 401     fz_obj *pageobj;
 402     struct page *page;
 403     double start, end;
 404     pdf_page *drawpage;
 405     fz_device *idev;
 406     struct pagedim *pagedim;
 407
 408     start = now ();
 409     printd (state.sock, "V rendering %d", pageno);
 410     pdf_flushxref (state.xref, 0);
 411
 412     pagedim = &state.pagedims[pindex];
 413     slicecount = (pagedim->bbox.y1 - pagedim->bbox.y0
 414                   + state.sliceheight - 1) / state.sliceheight;
 415     slicecount += slicecount == 0;
 416
 417     page = calloc (sizeof (*page)
 418                    + (slicecount * sizeof (struct slice)), 1);
 419     if (!page) {
 420         err (1, "calloc page %d\n", pageno);
 421     }
 422     page->slicecount = slicecount;
 423     page->prev = state.pages;
 424     state.pages = page;
 425
 426     pageobj = pdf_getpageobject (state.xref, pageno);
 427     if (!pageobj)
 428         die (fz_throw ("cannot retrieve info from page %d", pageno));
 429
 430     error = pdf_loadpage (&drawpage, state.xref, pageobj);
 431     if (error)
 432         die (error);
 433
 434     page->pixmap = fz_newpixmapwithrect (pdf_devicergb, pagedim->bbox);
 435     fz_clearpixmap (page->pixmap, 0xFF);
 436
 437     idev = fz_newdrawdevice (state.cache, page->pixmap);
 438     if (!idev)
 439         die (fz_throw ("fz_newdrawdevice failed"));
 440     error = pdf_runcontentstream (idev, pagedim->ctm, state.xref,
 441                                   drawpage->resources,
 442                                   drawpage->contents);
 443     fz_freedevice (idev);
 444
 445     page->drawpage = drawpage;
 446     page->pagedim = pagedim;
 447     page->pageno = pageno;
 448     subdivide (page);
 449     end = now ();
 450
 451     if (!state.lotsamemory) {
 452         pdf_agestoreditems (state.xref->store);
 453         pdf_evictageditems (state.xref->store);
 454     }
 455
 456     printd (state.sock, "V rendering %d took %f sec", pageno, end - start);
 457     return page;
 458 }
 459
 460 static void initpdims (void)
 461 {
 462     int pageno;
 463     double start, end;
 464
 465     start = now ();
 466     for (pageno = 0; pageno < state.pagecount; ++pageno) {
 467         int rotate;
 468         fz_rect box;
 469         struct pagedim *p;
 470         fz_obj *obj, *pageobj;
 471
 472         pageobj = pdf_getpageobject (state.xref, pageno + 1);
 473
 474         obj = fz_dictgets (pageobj, "CropBox");
 475         if (!fz_isarray (obj)) {
 476             obj = fz_dictgets (pageobj, "MediaBox");
 477             if (!fz_isarray (obj)) {
 478                 die (fz_throw ("cannot find page bounds %d (%d Rd)",
 479                                fz_tonum (pageobj), fz_togen (pageobj)));
 480             }
 481         }
 482         box = pdf_torect (obj);
 483
 484         obj = fz_dictgets (pageobj, "Rotate");
 485         if (fz_isint (obj)) {
 486             rotate = fz_toint (obj);
 487         }
 488         else  {
 489             rotate = 0;
 490         }
 491         rotate += state.rotate;
 492
 493         state.pagetbl[pageno] = fz_tonum (state.xref->pagerefs[pageno]);
 494         p = &state.pagedims[state.pagedimcount - 1];
 495         if ((state.pagedimcount == 0)
 496             || (p->rotate != rotate || memcmp (&p->box, &box, sizeof (box)))) {
 497             size_t size;
 498
 499             size = (state.pagedimcount + 1) * sizeof (*state.pagedims);
 500             state.pagedims = realloc (state.pagedims, size);
 501             if (!state.pagedims) {
 502                 err (1, "realloc pagedims to %zu (%d elems)",
 503                      size, state.pagedimcount + 1);
 504             }
 505             p = &state.pagedims[state.pagedimcount++];
 506             p->rotate = rotate;
 507             p->box = box;
 508             p->pageno = pageno;
 509         }
 510     }
 511     end = now ();
 512     printd (state.sock, "T Processed %d pages in %f seconds",
 513             state.pagecount, end - start);
 514 }
 515
 516 static void layout (void)
 517 {
 518     int pindex;
 519     fz_matrix ctm;
 520     fz_rect box, box2;
 521     double zoom, w;
 522     struct pagedim *p = state.pagedims;
 523
 524     pindex = 0;
 525     for (pindex = 0; pindex < state.pagedimcount; ++pindex, ++p) {
 526         box.x0 = MIN (p->box.x0, p->box.x1);
 527         box.y0 = MIN (p->box.y0, p->box.y1);
 528         box.x1 = MAX (p->box.x0, p->box.x1);
 529         box.y1 = MAX (p->box.y0, p->box.y1);
 530
 531         ctm = fz_identity ();
 532         ctm = fz_concat (ctm, fz_translate (0, -box.y1));
 533         ctm = fz_concat (ctm, fz_rotate (p->rotate));
 534         box2 = fz_transformrect (ctm, box);
 535         w = box2.x1 - box2.x0;
 536
 537         zoom = (state.w / w);
 538         ctm = fz_identity ();
 539         ctm = fz_concat (ctm, fz_translate (0, -box.y1));
 540         ctm = fz_concat (ctm, fz_scale (zoom, -zoom));
 541         ctm = fz_concat (ctm, fz_rotate (p->rotate));
 542         p->bbox = fz_roundrect (fz_transformrect (ctm, box));
 543         memcpy (&p->ctm, &ctm, sizeof (ctm));
 544     }
 545
 546     while (p-- != state.pagedims)  {
 547         printd (state.sock, "l %d %d %d",
 548                 p->pageno, p->bbox.x1 - p->bbox.x0, p->bbox.y1 - p->bbox.y0);
 549     }
 550 }
 551
 552 static void recurse_outline (pdf_outline *outline, int level)
 553 {
 554     while (outline) {
 555         int i, num;
 556         fz_obj *obj;
 557         int top = 0;
 558         int pageno = -1;
 559
 560         if (!outline->link) goto next;
 561
 562         obj = outline->link->dest;
 563         if (fz_isindirect (obj)) {
 564             num = fz_tonum (obj);
 565
 566             for (i = 0; i < state.pagecount; ++i)  {
 567                 if (state.pagetbl[i] == num) {
 568                     pageno = i;
 569                     break;
 570                 }
 571             }
 572         }
 573         else if (fz_isarray (obj)) {
 574             fz_obj *obj2;
 575
 576             obj2 = fz_arrayget (obj, 0);
 577             if (fz_isint (obj2)) {
 578                 pageno = fz_toint (obj2);
 579             }
 580             else {
 581                 num = fz_tonum (obj2);
 582                 for (i = 0; i < state.pagecount; ++i)  {
 583                     if (state.pagetbl[i] == num) {
 584                         pageno = i;
 585                         break;
 586                     }
 587                 }
 588             }
 589
 590             if (fz_arraylen (obj) > 3) {
 591                 fz_point p;
 592                 struct pagedim *pagedim = state.pagedims;
 593
 594                 for (i = 0; i < state.pagedimcount; ++i) {
 595                     if (state.pagedims[i].pageno > pageno)
 596                         break;
 597                     pagedim = &state.pagedims[i];
 598                 }
 599
 600                 p.x = fz_toint (fz_arrayget (obj, 2));
 601                 p.y = fz_toint (fz_arrayget (obj, 3));
 602                 p = fz_transformpoint (pagedim->ctm, p);
 603                 top = p.y;
 604             }
 605         }
 606
 607         lprintf ("%*c%s %d\n", level, ' ', outline->title, pageno);
 608         printd (state.sock, "o %d %d %d %s",
 609                 level, pageno, top, outline->title);
 610     next:
 611         if (outline->child) {
 612             recurse_outline (outline->child, level + 1);
 613         }
 614         outline = outline->next;
 615     }
 616 }
 617
 618 static void process_outline (void)
 619 {
 620     pdf_outline *outline;
 621
 622     outline = pdf_loadoutline (state.xref);
 623     if (outline) {
 624         recurse_outline (outline, 0);
 625         pdf_freeoutline (outline);
 626     }
 627 }
 628
 629 static int comparespans (const void *l, const void *r)
 630 {
 631     fz_textspan const *const*ls = l;
 632     fz_textspan const *const*rs = r;
 633     return (*ls)->text->bbox.y0 - (*rs)->text->bbox.y0;
 634 }
 635
 636 /* wishful thinking function */
 637 static void search (regex_t *re, int pageno, int y, int forward)
 638 {
 639     int i, j;
 640     int ret;
 641     char *p;
 642     char buf[256];
 643     fz_error error;
 644     fz_obj *pageobj;
 645     fz_device *tdev;
 646     pdf_page *drawpage;
 647     fz_textspan *text, *span, **pspan;
 648     struct pagedim *pdim, *pdimprev;
 649     int stop = 0;
 650     int niters = 0;
 651     int nspans;
 652     double start, end;
 653
 654     start = now ();
 655     while (pageno >= 0 && pageno < state.pagecount && !stop) {
 656         if (niters++ == 5) {
 657             if (!state.lotsamemory) {
 658                 pdf_agestoreditems (state.xref->store);
 659                 pdf_evictageditems (state.xref->store);
 660             }
 661             niters = 0;
 662             if (hasdata (state.sock)) {
 663                 printd (state.sock, "T attention requested aborting search at %d",
 664                         pageno);
 665                 stop = 1;
 666             }
 667             else {
 668                 printd (state.sock, "T searching in page %d", pageno);
 669             }
 670         }
 671         pdimprev = NULL;
 672         for (i = 0; i < state.pagedimcount; ++i) {
 673             pdim = &state.pagedims[i];
 674             if (pdim->pageno == pageno)  {
 675                 goto found;
 676             }
 677             if (pdim->pageno > pageno) {
 678                 pdim = pdimprev;
 679                 goto found;
 680             }
 681             pdimprev = pdim;
 682         }
 683         pdim = pdimprev;
 684     found:
 685
 686         pageobj = pdf_getpageobject (state.xref, pageno + 1);
 687         if (!pageobj)
 688             die (fz_throw ("cannot retrieve info from page %d", pageno));
 689
 690         error = pdf_loadpage (&drawpage, state.xref, pageobj);
 691         if (error)
 692             die (error);
 693
 694         text = fz_newtextspan ();
 695         tdev = fz_newtextdevice (text);
 696         error = pdf_runcontentstream (tdev, pdim->ctm, state.xref,
 697                                       drawpage->resources,
 698                                       drawpage->contents);
 699         if (error) die (error);
 700         fz_freedevice (tdev);
 701
 702         nspans = 0;
 703         for (span = text; span; span = span->next) {
 704             nspans++;
 705         }
 706         pspan = malloc (sizeof (void *) * nspans);
 707         if (!pspan) {
 708             err (1, "malloc span pointers %zu", sizeof (void *) * nspans);
 709         }
 710         for (i = 0, span = text; span; span = span->next, ++i) {
 711             pspan[i] = span;
 712         }
 713         qsort (pspan, nspans, sizeof (fz_textspan *), comparespans);
 714
 715         j = forward ? 0 : nspans - 1;
 716         while (nspans--) {
 717             regmatch_t rm;
 718
 719             span = pspan[j];
 720             j += forward ? 1 : -1;
 721             p = buf;
 722             for (i = 0; i < MIN (span->len, (int) sizeof (buf) - 1); ++i) {
 723                 if (forward) {
 724                     if (span->text[i].bbox.y0 < y + 1) {
 725                         continue;
 726                     }
 727                 }
 728                 else {
 729                     if (span->text[i].bbox.y0 > y - 1) {
 730                         continue;
 731                     }
 732                 }
 733                 if (span->text[i].c < 256) {
 734                     *p++ = span->text[i].c;
 735                 }
 736                 else  {
 737                     *p++ = '?';
 738                 }
 739             }
 740             if (p == buf) {
 741                 continue;
 742             }
 743             *p++ = 0;
 744
 745             ret = regexec (re, buf, 1, &rm, 0);
 746             if (ret)  {
 747                 if (ret != REG_NOMATCH) {
 748                     size_t size;
 749                     char errbuf[80];
 750                     size = regerror (ret, re, errbuf, sizeof (errbuf));
 751                     printd (state.sock,
 752                             "T regexec error `%.*s'",
 753                             (int) size, errbuf);
 754                     fz_freetextspan (text);
 755                     pdf_freepage (drawpage);
 756                     free (pspan);
 757                     return;
 758                 }
 759             }
 760             else  {
 761                 fz_rect r;
 762
 763                 r.x0 = span->text[rm.rm_so].bbox.x0 - pdim->bbox.x0;
 764                 r.y0 = span->text[rm.rm_so].bbox.y0;
 765                 r.x1 = span->text[rm.rm_eo - 1].bbox.x1 - pdim->bbox.x0;
 766                 r.y1 = span->text[rm.rm_eo - 1].bbox.y1;
 767
 768                 if (!stop) {
 769                     printd (state.sock, "F %d %d %f %f %f %f",
 770                             pageno, 1,
 771                             r.x0, r.y0,
 772                             r.x1, r.y1);
 773
 774                     printd (state.sock, "T found at %d `%.*s' %f in %f sec",
 775                             pageno, rm.rm_eo - rm.rm_so, &buf[rm.rm_so],
 776                             span->text[0].bbox.y0 - drawpage->mediabox.y0,
 777                             now () - start);
 778                 }
 779                 else  {
 780                     printd (state.sock, "R %d %d %f %f %f %f",
 781                             pageno, 2,
 782                             r.x0, r.y0,
 783                             r.x1, r.y1);
 784                 }
 785                 stop = 1;
 786             }
 787         }
 788         if (forward) {
 789             pageno += 1;
 790             y = 0;
 791         }
 792         else {
 793             pageno -= 1;
 794             y = INT_MAX;
 795         }
 796         fz_freetextspan (text);
 797         pdf_freepage (drawpage);
 798         free (pspan);
 799     }
 800     end = now ();
 801     if (!stop)  {
 802         printd (state.sock, "T no matches %f sec", end - start);
 803     }
 804     printd (state.sock, "D");
 805 }
 806
 807 static
 808 #ifdef _WIN32
 809 DWORD _stdcall
 810 #else
 811 void *
 812 #endif
 813 mainloop (void *unused)
 814 {
 815     char *p = NULL;
 816     int len, ret, oldlen = 0;
 817
 818     for (;;) {
 819         len = readlen (state.sock);
 820         if (len == 0) {
 821             errx (1, "readlen returned 0");
 822         }
 823
 824         if (oldlen < len + 1) {
 825             p = realloc (p, len + 1);
 826             if (!p) {
 827                 err (1, "realloc %d failed", len + 1);
 828             }
 829             oldlen = len + 1;
 830         }
 831         readdata (state.sock, p, len);
 832         p[len] = 0;
 833
 834         if (!strncmp ("open", p, 4)) {
 835             fz_obj *obj;
 836             char *filename = p + 5;
 837
 838             openxref (filename);
 839             initpdims ();
 840
 841             obj = fz_dictgets (state.xref->trailer, "Info");
 842             if (obj) {
 843                 obj = fz_dictgets (obj, "Title");
 844                 if (obj) {
 845                     printd (state.sock, "t %s", pdf_toutf8 (obj));
 846                 }
 847             }
 848         }
 849         else if (!strncmp ("free", p, 4)) {
 850             void *ptr;
 851
 852             ret = sscanf (p + 4, " %p", &ptr);
 853             if (ret != 1) {
 854                 errx (1, "malformed free `%.*s' ret=%d", len, p, ret);
 855             }
 856             lock ("free");
 857             freepage (ptr);
 858             unlock ("free");
 859             printd (state.sock, "d");
 860         }
 861         else if (!strncmp ("search", p, 6)) {
 862             int icase, pageno, y, ret, len2, forward;
 863             char *pattern;
 864             regex_t re;
 865
 866             ret = sscanf (p + 6, " %d %d %d %d,%n",
 867                           &icase, &pageno, &y, &forward, &len2);
 868             if (ret != 4) {
 869                 errx (1, "malformed search `%s' ret=%d", p, ret);
 870             }
 871
 872             pattern = p + 6 + len2;
 873             ret = regcomp (&re, pattern,
 874                            REG_EXTENDED | (icase ? REG_ICASE : 0));
 875             if (ret) {
 876                 char errbuf[80];
 877                 size_t size;
 878
 879                 size = regerror (ret, &re, errbuf, sizeof (errbuf));
 880                 printd (state.sock, "T regcomp failed `%.*s'",
 881                         (int) size, errbuf);
 882             }
 883             else  {
 884                 search (&re, pageno, y, forward);
 885                 regfree (&re);
 886             }
 887         }
 888         else if (!strncmp ("geometry", p, 8)) {
 889             int w, h;
 890
 891             printd (state.sock, "c");
 892             ret = sscanf (p + 8, " %d %d", &w, &h);
 893             if (ret != 2) {
 894                 errx (1, "malformed geometry `%.*s' ret=%d", len, p, ret);
 895             }
 896             state.h = h;
 897             if (w != state.w) {
 898                 int i;
 899                 state.w = w;
 900                 for (i = 0; i < state.texcount; ++i)  {
 901                     state.texowners[i].slice = NULL;
 902                 }
 903             }
 904             lock ("geometry");
 905             layout ();
 906             process_outline ();
 907             unlock ("geometry");
 908             printd (state.sock, "C %d", state.pagecount);
 909         }
 910         else if (!strncmp ("rotate", p, 6)) {
 911             float rotate;
 912
 913             printd (state.sock, "c");
 914             ret = sscanf (p + 6, " %f", &rotate);
 915             if (ret != 1) {
 916                 errx (1, "bad rotate line `%.*s' ret=%d", len, p, ret);
 917             }
 918             state.rotate = rotate;
 919             lock ("rotate");
 920             state.pagedimcount = 0;
 921             free (state.pagedims);
 922             state.pagedims = NULL;
 923             initpdims ();
 924             layout ();
 925             process_outline ();
 926             unlock ("rotate");
 927             printd (state.sock, "C %d", state.pagecount);
 928         }
 929         else if (!strncmp ("render", p, 6)) {
 930             int pageno, pindex, w, h, ret;
 931             struct page *page;
 932
 933             ret = sscanf (p + 6, " %d %d %d %d", &pageno, &pindex, &w, &h);
 934             if (ret != 4) {
 935                 errx (1, "bad render line `%.*s' ret=%d", len, p, ret);
 936             }
 937
 938             page = render (pageno, pindex);
 939             printd (state.sock, "r %d %d %d %d %p\n",
 940                     pageno,
 941                     state.w,
 942                     state.h,
 943                     state.rotate,
 944                     page);
 945         }
 946         else if (!strncmp ("interrupt", p, 8)) {
 947             printd (state.sock, "V interrupted");
 948         }
 949         else {
 950             errx (1, "unknown command %.*s", len, p);
 951         }
 952     }
 953     return 0;
 954 }
 955
 956 static void upload2 (struct page *page, int slicenum, const char *cap)
 957 {
 958     int i;
 959     int w, h;
 960     double start, end;
 961     struct slice *slice = &page->slices[slicenum];
 962
 963     w = page->pixmap->w;
 964     h = page->pixmap->h;
 965
 966     ARSERT (w == slice->w);
 967     if (slice->texindex != -1
 968         && state.texowners[slice->texindex].slice == slice) {
 969         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
 970     }
 971     else  {
 972         int subimage = 0;
 973         int index = (state.texindex++ % state.texcount);
 974         size_t offset = 0;
 975
 976         for (i = 0; i < slicenum; ++i) {
 977             offset += w * page->slices[i].h * 4;
 978         }
 979
 980         if (state.texowners[index].w == slice->w) {
 981             if (state.texowners[index].h >= slice->h ) {
 982                 subimage = 1;
 983             }
 984             else {
 985                 state.texowners[index].h = slice->h;
 986             }
 987         }
 988         else  {
 989             state.texowners[index].h = slice->h;
 990         }
 991
 992         state.texowners[index].slice = slice;
 993         state.texowners[index].w = slice->w;
 994         slice->texindex = index;
 995
 996         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
 997         start = now ();
 998         if (subimage) {
 999             {
1000                 GLenum err = glGetError ();
1001                 if (err != GL_NO_ERROR) {
1002                     printf ("\033[0;31mERROR1 %d %d %#x\033[0m\n", w, slice->h, err);
1003                     abort ();
1004                 }
1005             }
1006             glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB,
1007                              0,
1008                              0,
1009                              0,
1010                              w,
1011                              slice->h,
1012                              state.texform,
1013                              state.texty,
1014                              page->pixmap->samples + offset
1015                 );
1016             {
1017                 GLenum err = glGetError ();
1018                 if (err != GL_NO_ERROR) {
1019                     printf ("\033[0;31mERROR %d %d %#x\033[0m\n", w, slice->h, err);
1020                     abort ();
1021                 }
1022             }
1023         }
1024         else {
1025             glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
1026                           0,
1027                           GL_RGBA8,
1028                           w,
1029                           slice->h,
1030                           0,
1031                           state.texform,
1032                           state.texty,
1033                           page->pixmap->samples + offset
1034                 );
1035         }
1036
1037         end = now ();
1038         lprintf ("%s[%d] slice=%d(%d,%d) texid=%d %f sec\n",
1039                  subimage ? "sub" : "img",
1040                  page->pageno, slicenum,
1041                  slice->w, slice->h,
1042                  state.texids[slice->texindex],
1043                  end - start);
1044     }
1045 }
1046
1047 CAMLprim value ml_draw (value dispy_v, value w_v, value h_v,
1048                         value py_v, value ptr_v)
1049 {
1050     CAMLparam5 (dispy_v, w_v, h_v, py_v, ptr_v);
1051     int dispy = Int_val (dispy_v);
1052     int w = Int_val (w_v);
1053     int h = Int_val (h_v);
1054     int py = Int_val (py_v);
1055     char *s = String_val (ptr_v);
1056     int ret;
1057     void *ptr;
1058     struct page *page;
1059     int slicenum = 0;
1060
1061     if (trylock ("ml_draw")) {
1062         goto done;
1063     }
1064
1065     ret = sscanf (s, "%p", &ptr);
1066     if (ret != 1) {
1067         errx (1, "cannot parse pointer `%s'", s);
1068     }
1069     page = ptr;
1070
1071     w = page->pixmap->w;
1072
1073     ARSERT (h >= 0 && "ml_draw wrong h");
1074
1075     glEnable (GL_TEXTURE_RECTANGLE_ARB);
1076
1077     for (slicenum = 0; slicenum < page->slicecount; ++slicenum) {
1078         struct slice *slice = &page->slices[slicenum];
1079         if (slice->h > py) {
1080             break;
1081         }
1082         py -= slice->h;
1083     }
1084
1085     h = MIN (state.h, h);
1086     while (h) {
1087         int th;
1088         struct slice *slice = &page->slices[slicenum];
1089
1090         ARSERT (slicenum < page->slicecount && "ml_draw wrong slicenum");
1091
1092         th = MIN (h, slice->h - py);
1093         upload2 (page, slicenum, "upload");
1094
1095         glBegin (GL_QUADS);
1096         {
1097             glTexCoord2i (0, py);
1098             glVertex2i (0, dispy);
1099
1100             glTexCoord2i (w, py);
1101             glVertex2i (w, dispy);
1102
1103             glTexCoord2i (w, py+th);
1104             glVertex2i (w, dispy + th);
1105
1106             glTexCoord2i (0, py+th);
1107             glVertex2i (0, dispy + th);
1108         }
1109         glEnd ();
1110
1111         h -= th;
1112         py = 0;
1113         dispy += th;
1114         slicenum += 1;
1115     }
1116
1117     glDisable (GL_TEXTURE_RECTANGLE_ARB);
1118
1119     unlock ("ml_draw");
1120  done:
1121     CAMLreturn (Val_unit);
1122 }
1123
1124 static pdf_link *getlink (struct page *page, int x, int y)
1125 {
1126     fz_point p;
1127     fz_matrix ctm;
1128     pdf_link *link;
1129
1130     p.x = x + page->pixmap->x;
1131     p.y = y + page->pixmap->y;
1132
1133     ctm = fz_invertmatrix (page->pagedim->ctm);
1134     p = fz_transformpoint (ctm, p);
1135
1136     for (link = page->drawpage->links; link; link = link->next) {
1137         if (p.x >= link->rect.x0 && p.x <= link->rect.x1) {
1138             if (p.y >= link->rect.y0 && p.y <= link->rect.y1) {
1139                 if (link->kind == PDF_LGOTO) {
1140                     return link;
1141                 }
1142             }
1143         }
1144     }
1145     return NULL;
1146 }
1147
1148 CAMLprim value ml_highlightlinks (value ptr_v, value yoff_v)
1149 {
1150     CAMLparam2 (ptr_v, yoff_v);
1151     pdf_link *link;
1152     struct page *page;
1153     int xoff, yoff = Int_val (yoff_v);
1154     const char *s = String_val (ptr_v);
1155
1156     if (trylock ("ml_highlightlinks")) {
1157         goto done;
1158     }
1159
1160     page = parse_pointer ("ml_highlightlinks", s);
1161
1162     glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1163     glEnable (GL_LINE_STIPPLE);
1164     glLineStipple (0.5, 0xcccc);
1165     glColor3ub (255, 0, 0);
1166
1167     xoff = -page->pixmap->x;
1168     yoff -= page->pixmap->y;
1169
1170     glBegin (GL_QUADS);
1171     for (link = page->drawpage->links; link; link = link->next) {
1172         if (link->kind == PDF_LGOTO) {
1173             fz_point p1, p2, p3, p4;
1174             fz_matrix ctm = page->pagedim->ctm;
1175
1176             p1.x = link->rect.x0;
1177             p1.y = link->rect.y0;
1178
1179             p2.x = link->rect.x1;
1180             p2.y = link->rect.y0;
1181
1182             p3.x = link->rect.x1;
1183             p3.y = link->rect.y1;
1184
1185             p4.x = link->rect.x0;
1186             p4.y = link->rect.y1;
1187
1188             p1 = fz_transformpoint (ctm, p1);
1189             p2 = fz_transformpoint (ctm, p2);
1190             p3 = fz_transformpoint (ctm, p3);
1191             p4 = fz_transformpoint (ctm, p4);
1192
1193             glVertex2f (p1.x + xoff, p1.y + yoff);
1194             glVertex2f (p2.x + xoff, p2.y + yoff);
1195             glVertex2f (p3.x + xoff, p3.y + yoff);
1196             glVertex2f (p4.x + xoff, p4.y + yoff);
1197         }
1198     }
1199     glEnd ();
1200
1201     glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1202     glDisable (GL_LINE_STIPPLE);
1203     unlock ("ml_highlightlinks");
1204
1205  done:
1206     CAMLreturn (Val_unit);
1207 }
1208
1209 CAMLprim value ml_checklink (value ptr_v, value x_v, value y_v)
1210 {
1211     CAMLparam3 (ptr_v, x_v, y_v);
1212     char *s = String_val (ptr_v);
1213     int ret;
1214
1215     if (trylock ("ml_checklink")) {
1216         ret = 0;
1217     }
1218     else {
1219         ret = NULL != getlink (parse_pointer ("ml_checklink", s),
1220                                Int_val (x_v), Int_val (y_v));
1221         unlock ("ml_checklink");
1222     }
1223     CAMLreturn (Val_bool (ret));
1224 }
1225
1226 CAMLprim value ml_getlink (value ptr_v, value x_v, value y_v)
1227 {
1228     CAMLparam3 (ptr_v, x_v, y_v);
1229     CAMLlocal2 (ret_v, tup_v);
1230     pdf_link *link;
1231     struct page *page;
1232     char *s = String_val (ptr_v);
1233
1234     if (trylock ("ml_getlink")) {
1235         ret_v = Val_int (0);
1236         goto done;
1237     }
1238
1239     page = parse_pointer ("ml_getlink", s);
1240
1241     link = getlink (page, Int_val (x_v), Int_val (y_v));
1242     if (link) {
1243         int pageno;
1244         fz_point p;
1245         fz_obj *obj;
1246
1247         pageno = -1;
1248         obj = fz_arrayget (link->dest, 0);
1249         if (fz_isindirect (obj)) {
1250             pageno = pdf_findpageobject (state.xref, obj) - 1;
1251         }
1252         else if (fz_isint (obj)) {
1253             pageno = fz_toint (obj);
1254         }
1255
1256         if (fz_arraylen (link->dest) > 3) {
1257             p.x = fz_toint (fz_arrayget (link->dest, 2));
1258             p.y = fz_toint (fz_arrayget (link->dest, 3));
1259             p = fz_transformpoint (page->pagedim->ctm, p);
1260         }
1261         else  {
1262             p.x = 0.0;
1263             p.y = 0.0;
1264         }
1265
1266         tup_v = caml_alloc_tuple (2);
1267         ret_v = caml_alloc_small (1, 1);
1268         Field (tup_v, 0) = Val_int (pageno);
1269         Field (tup_v, 1) = Val_int (p.y);
1270         Field (ret_v, 0) = tup_v;
1271     }
1272     else {
1273         ret_v = Val_int (0);
1274     }
1275     unlock ("ml_getlink");
1276
1277  done:
1278     CAMLreturn (ret_v);
1279 }
1280
1281 CAMLprim value ml_gettext (value ptr_v, value rect_v, value oy_v, value rectsel_v)
1282 {
1283     CAMLparam4 (ptr_v, rect_v, oy_v, rect_v);
1284     fz_matrix ctm;
1285     fz_point p1, p2;
1286     struct page *page;
1287     fz_textspan *span;
1288     char *s = String_val (ptr_v);
1289     int rectsel = Bool_val (rectsel_v);
1290     int i, bx0, bx1, by0, by1, x0, x1, y0, y1, oy;
1291
1292     /* stop GCC from complaining about uninitialized variables */
1293 #ifdef __GNUC__
1294     int rx0 = rx0, rx1 = rx1, ry0 = ry0, ry1 = ry1;
1295 #else
1296     int rx0, rx1, ry0, ry1;
1297 #endif
1298
1299     if (trylock ("ml_gettext")) {
1300         goto done;
1301     }
1302
1303     page = parse_pointer ("ml_gettext", s);
1304
1305     oy = Int_val (oy_v);
1306     p1.x = Int_val (Field (rect_v, 0));
1307     p1.y = Int_val (Field (rect_v, 1));
1308     p2.x = Int_val (Field (rect_v, 2));
1309     p2.y = Int_val (Field (rect_v, 3));
1310
1311     if (0) {
1312         glEnable (GL_BLEND);
1313         glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1314         glBlendFunc (GL_DST_ALPHA, GL_SRC_ALPHA);
1315         glColor4f (0.0f, 0.0f, 0.0f, 0.2f);
1316         glRecti (p1.x, p1.y, p2.x, p2.y);
1317         glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1318         glDisable (GL_BLEND);
1319     }
1320
1321     ctm = page->pagedim->ctm;
1322     if (!page->text) {
1323         fz_error error;
1324         fz_device *tdev;
1325
1326         page->text = fz_newtextspan ();
1327         tdev = fz_newtextdevice (page->text);
1328         error = pdf_runcontentstream (tdev, page->pagedim->ctm, state.xref,
1329                                       page->drawpage->resources,
1330                                       page->drawpage->contents);
1331         if (error) die (error);
1332         fz_freedevice (tdev);
1333     }
1334
1335     printf ("\033c");
1336
1337     printf ("BBox %f %f %f %f\n", p1.x, p1.y, p2.x, p2.y);
1338     p1.x += page->pixmap->x;
1339     p1.y += page->pixmap->y;
1340     p2.x += page->pixmap->x;
1341     p2.y += page->pixmap->y;
1342     x0 = p1.x;
1343     y0 = p1.y;
1344     x1 = p2.x;
1345     y1 = p2.y;
1346     printf ("BBox %d %d %d %d %d %d\n", x0, y0, x1, y1, oy, page->pageno);
1347
1348     for (span = page->text; span; span = span->next) {
1349         int seen = 0;
1350
1351         /* fz_debugtextspanxml (span); */
1352         for (i = 0; i < span->len; ++i) {
1353             long c;
1354
1355             bx0 = span->text[i].bbox.x0;
1356             bx1 = span->text[i].bbox.x1;
1357             by0 = span->text[i].bbox.y0 + oy;
1358             by1 = span->text[i].bbox.y1 + oy;
1359
1360             if ((bx1 >= x0 && bx0 <= x1 && by1 >= y0 && by0 <= y1)) {
1361                 if (!seen) {
1362                     rx0 = bx0 - page->pixmap->x;
1363                     rx1 = bx1 - page->pixmap->x;
1364                     ry0 = by0;
1365                     ry1 = by1;
1366                 }
1367
1368                 seen = 1;
1369                 c = span->text[i].c;
1370                 if (c < 256) {
1371                     if ((isprint (c) && !isspace (c))) {
1372                         if (!rectsel) {
1373                             bx0 -= page->pixmap->x;
1374                             bx1 -= page->pixmap->x;
1375                             glEnable (GL_BLEND);
1376                             glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1377                             glBlendFunc (GL_DST_ALPHA, GL_SRC_ALPHA);
1378                             glColor4f (0.5f, 0.5f, 0.0f, 0.6f);
1379                             glRecti (bx0, by0, bx1, by1);
1380                             glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1381                             glDisable (GL_BLEND);
1382                         }
1383                         if (isprint (c) || c ==' ') {
1384                             rx1 = bx1;
1385                             ry1 = by1;
1386                         }
1387                     }
1388                     putc (c, stdout);
1389                 }
1390                 else  {
1391                     putc ('?', stdout);
1392                 }
1393             }
1394         }
1395
1396         if (rectsel) {
1397             if (seen) {
1398                 glEnable (GL_BLEND);
1399                 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1400                 glBlendFunc (GL_DST_ALPHA, GL_SRC_ALPHA);
1401                 glColor4f (0.5f, 0.5f, 0.0f, 0.6f);
1402                 glRecti (rx0, ry0, rx1, ry1);
1403                 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1404                 glDisable (GL_BLEND);
1405             }
1406         }
1407
1408         if (seen && span->eol) {
1409             x0 = page->pixmap->x;
1410             putc ('\n', stdout);
1411         }
1412     }
1413     unlock ("ml_gettext");
1414
1415  done:
1416     CAMLreturn (Val_unit);
1417 }
1418
1419 CAMLprim value ml_getpagewh (value pagedimno_v)
1420 {
1421     CAMLparam1 (pagedimno_v);
1422     CAMLlocal1 (ret_v);
1423     int pagedimno = Int_val (pagedimno_v);
1424
1425     ret_v = caml_alloc_small (4 * Double_wosize, Double_array_tag);
1426     Store_double_field (ret_v, 0, state.pagedims[pagedimno].box.x0);
1427     Store_double_field (ret_v, 1, state.pagedims[pagedimno].box.x1);
1428     Store_double_field (ret_v, 2, state.pagedims[pagedimno].box.y0);
1429     Store_double_field (ret_v, 3, state.pagedims[pagedimno].box.y1);
1430     CAMLreturn (ret_v);
1431 }
1432
1433 CAMLprim value ml_init (value sock_v)
1434 {
1435 #ifndef _WIN32
1436     int ret;
1437 #endif
1438     CAMLparam1 (sock_v);
1439
1440     state.texcount = 256;
1441     state.sliceheight = 24;
1442     state.texform = GL_RGBA;
1443     state.texty = GL_UNSIGNED_BYTE;
1444
1445     state.texids = calloc (state.texcount * sizeof (*state.texids), 1);
1446     if (!state.texids) {
1447         err (1, "calloc texids %zu", state.texcount * sizeof (*state.texids));
1448     }
1449
1450     state.texowners = calloc (state.texcount * sizeof (*state.texowners), 1);
1451     if (!state.texowners) {
1452         err (1, "calloc texowners %zu",
1453              state.texcount * sizeof (*state.texowners));
1454     }
1455
1456     glGenTextures (state.texcount, state.texids);
1457
1458 #ifdef _WIN32
1459     state.sock = Socket_val (sock_v);
1460 #else
1461     state.sock = Int_val (sock_v);
1462 #endif
1463
1464     state.cache = fz_newglyphcache ();
1465     if (!state.cache) {
1466         errx (1, "fz_newglyphcache failed");
1467     }
1468
1469 #ifdef _WIN32
1470     InitializeCriticalSection (&critsec);
1471     state.thread = CreateThread (NULL, 0, mainloop, NULL, 0, NULL);
1472     if (state.thread == INVALID_HANDLE_VALUE) {
1473         errx (1, "CreateThread failed: %lx", GetLastError ());
1474     }
1475 #else
1476     ret = pthread_create (&state.thread, NULL, mainloop, NULL);
1477     if (ret) {
1478         errx (1, "pthread_create: %s", strerror (errno));
1479     }
1480 #endif
1481
1482     CAMLreturn (Val_unit);
1483 }