D'oh

After a decade (plus change) less prudent side finally won internal struggle.

malc committed 6 years ago

Commit bc370591 parent 42ce7f52 files · +86 −55Browse files

Unified · Split

2 files

link.c +49 −35
main.ml +37 −20

     CAMLreturn (ret_v);
 }
-static void * mainloop (void UNUSED_ATTR *unused)
+enum {
+    Copen, Ccs, Cfreepage, Cfreetile, Csearch, Cgeometry, Creqlayout,
+    Cpage, Ctile, Ctrimset, Csettrim, Csliceh, Cinterrupt
+};
+static void *mainloop (void UNUSED_ATTR *unused)
 {
     char *p = NULL;
     int len, ret, oldlen = 0;
         readdata (state.csock, p, len);
         p[len] = 0;
-#define CASE(n) else if (!strncmp (#n, p, sizeof (#n) - 1))
+        switch (p[len-1]) {
-        if (0) ;
+        case Copen: {
-        CASE (open) {
             int off, usedoccss, ok = 0, layouth;
             char *password;
             char *filename;
             size_t filenamelen;
             fz_var (ok);
-            ret = sscanf (p + 5, " %d %d %n", &usedoccss, &layouth, &off);
+            ret = sscanf (p, " %d %d %n", &usedoccss, &layouth, &off);
             if (ret != 2) {
                 errx (1, "malformed open `%.*s' ret=%d", len, p, ret);
             }
-            filename = p + 5 + off;
+            filename = p + off;
             filenamelen = strlen (filename);
             password = filename + filenamelen + 1;
             }
             unlock ("open");
             state.needoutline = ok;
+            break;
         }
-        CASE (cs) {
+        case Ccs: {
             int i, colorspace;
-            ret = sscanf (p + 2, " %d", &colorspace);
+            ret = sscanf (p, " %d", &colorspace);
             if (ret != 1) {
                 errx (1, "malformed cs `%.*s' ret=%d", len, p, ret);
             }
                 state.tex.owners[i].slice = NULL;
             }
             unlock ("cs");
+            break;
         }
-        CASE (freepage) {
+        case Cfreepage: {
             void *ptr;
-            ret = sscanf (p + 8, " %" SCNxPTR, (uintptr_t *) &ptr);
+            ret = sscanf (p, " %" SCNxPTR, (uintptr_t *) &ptr);
             if (ret != 1) {
                 errx (1, "malformed freepage `%.*s' ret=%d", len, p, ret);
             }
             lock ("freepage");
             freepage (ptr);
             unlock ("freepage");
+            break;
         }
-        CASE (freetile) {
+        case Cfreetile: {
             void *ptr;
-            ret = sscanf (p + 8, " %" SCNxPTR, (uintptr_t *) &ptr);
+            ret = sscanf (p, " %" SCNxPTR, (uintptr_t *) &ptr);
             if (ret != 1) {
                 errx (1, "malformed freetile `%.*s' ret=%d", len, p, ret);
             }
             lock ("freetile");
             freetile (ptr);
             unlock ("freetile");
+            break;
         }
-        CASE (search) {
+        case Csearch: {
             int icase, pageno, y, len2, forward;
             char *pattern;
             regex_t re;
-            ret = sscanf (p + 6, " %d %d %d %d,%n",
+            ret = sscanf (p, " %d %d %d %d,%n",
                           &icase, &pageno, &y, &forward, &len2);
             if (ret != 4) {
                 errx (1, "malformed search `%s' ret=%d", p, ret);
             }
-            pattern = p + 6 + len2;
+            pattern = p + len2;
             ret = regcomp (&re, pattern,
                            REG_EXTENDED | (icase ? REG_ICASE : 0));
             if (ret) {
                 unlock ("search");
                 regfree (&re);
             }
+            break;
         }
-        CASE (geometry) {
+        case Cgeometry: {
             int w, h, fitmodel;
             printd ("clear");
-            ret = sscanf (p + 8, " %d %d %d", &w, &h, &fitmodel);
+            ret = sscanf (p, " %d %d %d", &w, &h, &fitmodel);
             if (ret != 3) {
                 errx (1, "malformed geometry `%.*s' ret=%d", len, p, ret);
             }
             state.gen++;
             unlock ("geometry");
             printd ("continue %d", state.pagecount);
+            break;
         }
-        CASE (reqlayout) {
+        case Creqlayout: {
             char *nameddest;
             int rotate, off, h;
             int fitmodel;
             pdf_document *pdf;
             printd ("clear");
-            ret = sscanf (p + 9, " %d %d %d %n",
+            ret = sscanf (p, " %d %d %d %n", &rotate, &fitmodel, &h, &off);
-                          &rotate, &fitmodel, &h, &off);
             if (ret != 3) {
                 errx (1, "bad reqlayout line `%.*s' ret=%d", len, p, ret);
             }
             layout ();
             process_outline ();
-            nameddest = p + 9 + off;
+            nameddest = p + off;
             if (pdf && nameddest && *nameddest) {
                 fz_point xy;
                 struct pagedim *pdim;
             state.gen++;
             unlock ("reqlayout");
             printd ("continue %d", state.pagecount);
+            break;
         }
-        CASE (page) {
+        case Cpage: {
             double a, b;
             struct page *page;
             int pageno, pindex;
-            ret = sscanf (p + 4, " %d %d", &pageno, &pindex);
+            ret = sscanf (p, " %d %d", &pageno, &pindex);
             if (ret != 2) {
                 errx (1, "bad page line `%.*s' ret=%d", len, p, ret);
             }
             unlock ("page");
             printd ("page %" PRIxPTR " %f", (uintptr_t) page, b - a);
+            break;
         }
-        CASE (tile) {
+        case Ctile: {
             int x, y, w, h;
             struct page *page;
             struct tile *tile;
             double a, b;
             void *data;
-            ret = sscanf (p + 4, " %" SCNxPTR " %d %d %d %d %" SCNxPTR,
+            ret = sscanf (p, " %" SCNxPTR " %d %d %d %d %" SCNxPTR,
                           (uintptr_t *) &page, &x, &y, &w, &h,
                           (uintptr_t *) &data);
             if (ret != 6) {
                     x, y, (uintptr_t) (tile),
                     tile->w * tile->h * tile->pixmap->n,
                     b - a);
+            break;
         }
-        CASE (trimset) {
+        case Ctrimset: {
             fz_irect fuzz;
             int trimmargins;
-            ret = sscanf (p + 7, " %d %d %d %d %d",
+            ret = sscanf (p, " %d %d %d %d %d",
                           &trimmargins, &fuzz.x0, &fuzz.y0, &fuzz.x1, &fuzz.y1);
             if (ret != 5) {
                 errx (1, "malformed trimset `%.*s' ret=%d", len, p, ret);
                 state.trimfuzz = fuzz;
             }
             unlock ("trimset");
+            break;
         }
-        CASE (settrim) {
+        case Csettrim: {
             fz_irect fuzz;
             int trimmargins;
-            ret = sscanf (p + 7, " %d %d %d %d %d",
+            ret = sscanf (p, " %d %d %d %d %d",
                           &trimmargins, &fuzz.x0, &fuzz.y0, &fuzz.x1, &fuzz.y1);
             if (ret != 5) {
                 errx (1, "malformed settrim `%.*s' ret=%d", len, p, ret);
             process_outline ();
             unlock ("settrim");
             printd ("continue %d", state.pagecount);
+            break;
         }
-        CASE (sliceh) {
+        case Csliceh: {
             int h;
-            ret = sscanf (p + 6, " %d", &h);
+            ret = sscanf (p, " %d", &h);
             if (ret != 1) {
                 errx (1, "malformed sliceh `%.*s' ret=%d", len, p, ret);
             }
                     state.tex.owners[i].slice = NULL;
                 }
             }
+            break;
         }
-        CASE (interrupt) {
+        case Cinterrupt:
             printd ("vmsg interrupted");
-        }
+            break;
-#undef CASE
+        default:
-        else {
             errx (1, "unknown command %.*s", len, p);
         }
     }

main.ml+37−20

   TEcont text
 ;;
-let wcmd fmt =
+module C = struct
+  let dopen     = '\000';;
+  let cs        = '\001';;
+  let freepage  = '\002';;
+  let freetile  = '\003';;
+  let search    = '\004';;
+  let geometry  = '\005';;
+  let reqlayout = '\006';;
+  let page      = '\007';;
+  let tile      = '\008';;
+  let trimset   = '\009';;
+  let settrim   = '\010';;
+  let sliceh    = '\011';;
+  let interrupt = '\012';;
+end;;
+let wcmd cmd fmt =
   let b = Buffer.create 16 in
   Printf.kbprintf
     (fun b ->
+      Buffer.add_char b cmd;
       let b = Buffer.to_bytes b in
       Ffi.wcmd state.ss b @@ Bytes.length b
     ) b fmt
                   then Ffi.getpbo w h conf.colorspace
                   else ~< "0"
                 in
-                wcmd "tile %s %d %d %d %d %s" (~> p) x y w h (~> pbo);
+                wcmd C.tile "%s %d %d %d %d %s" (~> p) x y w h (~> pbo);
                 state.currently <-
                   Tiling (
                       l, p, conf.colorspace, conf.angle,
       | l :: rest ->
          begin match getopaque l.pageno with
          | None ->
-            wcmd "page %d %d" l.pageno l.pagedimno;
+            wcmd C.page "%d %d" l.pageno l.pagedimno;
             state.currently <- Loading (l, state.gen);
          | Some opaque ->
             tilepage l.pageno opaque pages;
 ;;
 let flushpages () =
-  Hashtbl.iter (fun _ opaque -> wcmd "freepage %s" (~> opaque)) state.pagemap;
+  Hashtbl.iter (fun _ opaque -> wcmd C.freepage "%s" (~> opaque)) state.pagemap;
   Hashtbl.clear state.pagemap;
 ;;
   if not (Queue.is_empty state.tilelru)
   then (
     Queue.iter (fun (k, p, s) ->
-        wcmd "freetile %s" (~> p);
+        wcmd C.freetile "%s" (~> p);
         state.memused <- state.memused - s;
         Hashtbl.remove state.tilemap k;
       ) state.tilelru;
     else state.origin
   in
   Wsi.settitle ("llpp " ^ mbtoutf8 (Filename.basename titlepath));
-  wcmd "open %d %d %s\000%s\000%s\000"
+  wcmd C.dopen "%d %d %s\000%s\000%s\000"
     (btod conf.usedoccss) !layouth
     path password conf.css;
   invalidate "reqlayout"
     (fun () ->
-      wcmd "reqlayout %d %d %d %s\000"
+      wcmd C.reqlayout " %d %d %d %s\000"
         conf.angle (FMTE.to_int conf.fitmodel)
         (stateh state.winh) state.nameddest
     );
         | Cmulti ((c, _, _), _) -> (w - (c-1)*conf.interpagespace) / c
         | Csplit (c, _) -> w * c
       in
-      wcmd "geometry %d %d %d" w (stateh h) (FMTE.to_int conf.fitmodel)
+      wcmd C.geometry "%d %d %d" w (stateh h) (FMTE.to_int conf.fitmodel)
     );
 ;;
         then Queue.push lruitem state.tilelru
         else (
           Ffi.freepbo p;
-          wcmd "freetile %s" (~> p);
+          wcmd C.freetile "%s" (~> p);
           state.memused <- state.memused - s;
           state.uioh#infochanged Memused;
           Hashtbl.remove state.tilemap k;
             Hashtbl.fold (fun ((pageno, _) as key) opaque accu ->
                 if not (IntSet.mem pageno set)
                 then (
-                  wcmd "freepage %s" (~> opaque);
+                  wcmd C.freepage "%s" (~> opaque);
                   key :: accu
                 )
                 else accu
         Ffi.unmappbo opaque;
         if tilew != conf.tilew || tileh != conf.tileh
         then (
-          wcmd "freetile %s" (~> opaque);
+          wcmd C.freetile "%s" (~> opaque);
           state.currently <- Idle;
           load state.layout;
         )
          | [] -> 0, 0
          | l :: _ -> l.pageno, (l.pagey + if forward then 0 else 0*l.pagevh)
        in
-       wcmd "search %d %d %d %d,%s\000"
+       wcmd C.search "%d %d %d %d,%s\000"
          (btod conf.icase) pn py (btod forward) pattern;
 ;;
   );
   conf.fitmodel <- fitmodel;
   invalidate "reqlayout"
-    (fun () -> wcmd "reqlayout %d %d %d"
+    (fun () -> wcmd C.reqlayout "%d %d %d"
                  conf.angle (FMTE.to_int conf.fitmodel) (stateh state.winh));
 ;;
   conf.trimfuzz <- trimfuzz;
   let x0, y0, x1, y1 = trimfuzz in
   invalidate "settrim"
-    (fun () -> wcmd "settrim %d %d %d %d %d"
+    (fun () -> wcmd C.settrim "%d %d %d %d %d"
                  (btod conf.trimmargins) x0 y0 x1 y1);
   flushpages ();
 ;;
   setconf conf c;
   Ffi.setdcf conf.dcf;
   let x0, y0, x1, y1 = conf.trimfuzz in
-  wcmd "trimset %d %d %d %d %d" (btod conf.trimmargins) x0 y0 x1 y1;
+  wcmd C.trimset "%d %d %d %d %d" (btod conf.trimmargins) x0 y0 x1 y1;
   Wsi.reshape c.cwinw c.cwinh;
   opendoc path origin;
   setzoom c.zoom;
         (fun () -> conf.sliceheight)
         (fun v ->
           conf.sliceheight <- v;
-          wcmd "sliceh %d" conf.sliceheight;
+          wcmd C.sliceh "%d" conf.sliceheight;
         );
       src#int "anti-aliasing level"
         (fun () -> conf.aalevel)
         (fun () -> CSTE.to_string conf.colorspace)
         (fun v ->
           conf.colorspace <- CSTE.of_int v;
-          wcmd "cs %d" v;
+          wcmd C.cs "%d" v;
           load state.layout;
         );
       src#paxmark "pax mark method"
              else split accu b (i+1)
          in
          let cleanup () =
-           wcmd "freepage %s" (~> opaque);
+           wcmd C.freepage "%s" (~> opaque);
            let keys =
              Hashtbl.fold (fun key opaque' accu ->
                  if opaque' = opaque'
 let keyboard key mask =
   if (key = Char.code 'g' && Wsi.withctrl mask) && not (istextentry state.mode)
-  then wcmd "interrupt"
+  then wcmd C.interrupt ""
   else state.uioh <- state.uioh#key key mask
 ;;
   | Some (opaque, n, ux, uy) ->
      let add text =
        Ffi.addannot opaque ux uy text;
-       wcmd "freepage %s" (~> opaque);
+       wcmd C.freepage "%s" (~> opaque);
        Hashtbl.remove state.pagemap (n, state.gen);
        flushtiles ();
        gotoxy state.x state.y

D'oh

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code