home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume18 / X11R5-fix13 / part02 < prev    next >
Encoding:
Internet Message Format  |  1992-07-22  |  50.4 KB
  1. Path: uunet!dtix!darwin.sura.net!mips!msi!dcmartin
  2. From: gildea@EXPO.LCS.MIT.EDU (Stephen Gildea)
  3. Newsgroups: comp.sources.x
  4. Subject: v18i043: X11R5 public fix #13, Part02/05
  5. Message-ID: <1992Jul22.150635.18675@msi.com>
  6. Date: 22 Jul 92 15:06:35 GMT
  7. References: <csx-18i042-X11R5-fix13@uunet.UU.NET>
  8. Sender: dcmartin@msi.com (David C. Martin - Moderator)
  9. Organization: Molecular Simulations, Inc.
  10. Lines: 1861
  11. Approved: dcmartin@msi.com
  12. Originator: dcmartin@fascet
  13.  
  14. Submitted-by: gildea@EXPO.LCS.MIT.EDU (Stephen Gildea)
  15. Posting-number: Volume 18, Issue 43
  16. Archive-name: X11R5-fix13/part02
  17.  
  18. #!/bin/sh
  19. # this is part.02 (part 2 of a multipart archive)
  20. # do not concatenate these parts, unpack them in order with /bin/sh
  21. # file fix-13 continued
  22. #
  23. if test ! -r _shar_seq_.tmp; then
  24.     echo 'Please unpack part 1 first!'
  25.     exit 1
  26. fi
  27. (read Scheck
  28.  if test "$Scheck" != 2; then
  29.     echo Please unpack part "$Scheck" next!
  30.     exit 1
  31.  else
  32.     exit 0
  33.  fi
  34. ) < _shar_seq_.tmp || exit 1
  35. if test ! -f _shar_wnt_.tmp; then
  36.     echo 'x - still skipping fix-13'
  37. else
  38. echo 'x - continuing file fix-13'
  39. sed 's/^X//' << 'SHAR_EOF' >> 'fix-13' &&
  40. + 
  41. X  extern int  errno;
  42. X  
  43. X  
  44. ***************
  45. *** 61,67 ****
  46. X  static int  fs_font_type;
  47. X  extern unsigned long fs_fd_mask[];
  48. X  
  49. ! static int  fs_block_handler();
  50. X  static int  fs_wakeup();
  51. X  
  52. X  static FSFpePtr awaiting_reconnect;
  53. --- 66,72 ----
  54. X  static int  fs_font_type;
  55. X  extern unsigned long fs_fd_mask[];
  56. X  
  57. ! static void fs_block_handler();
  58. X  static int  fs_wakeup();
  59. X  
  60. X  static FSFpePtr awaiting_reconnect;
  61. ***************
  62. *** 117,123 ****
  63. X  fs_name_check(name)
  64. X      char       *name;
  65. X  {
  66. !     return (!strncmp(name, "tcp/", MIN(4, strlen(name))));
  67. X  }
  68. X  
  69. X  /*
  70. --- 122,128 ----
  71. X  fs_name_check(name)
  72. X      char       *name;
  73. X  {
  74. !     return (!strncmp(name, "tcp/", MIN(4, (int) strlen(name))));
  75. X  }
  76. X  
  77. X  /*
  78. ***************
  79. *** 254,259 ****
  80. --- 259,287 ----
  81. X      return err;
  82. X  }
  83. X  
  84. + /* 
  85. +  * close font server and remove any state associated with
  86. +  * this connection - this includes any client records.
  87. +  */
  88. + 
  89. + static void
  90. + fs_close_conn(conn)
  91. +     FSFpePtr    conn;
  92. + {
  93. +     FSClientPtr    client, nclient;
  94. + 
  95. +     (void) close(conn->fs_fd);
  96. + 
  97. +     _fs_bit_clear(fs_fd_mask, conn->fs_fd);
  98. + 
  99. +     for (client = conn->clients; client; client = nclient) 
  100. +     {
  101. +     nclient = client->next;
  102. +     xfree (client);
  103. +     }
  104. +     conn->clients = NULL;
  105. + }
  106. + 
  107. X  /*
  108. X   * the wakeup handlers have to be set when the FPE is open, and not
  109. X   * removed until it is freed, in order to handle unexpected data, like
  110. ***************
  111. *** 285,294 ****
  112. X      fpe->private = (pointer) conn;
  113. X      err = fs_send_init_packets(conn);
  114. X      if (err != Successful) {
  115. !         (void) close(conn->fs_fd);
  116. !         xfree(conn->servername);
  117. !         xfree(conn->alts);
  118. !         xfree(conn);
  119. X          return err;
  120. X      }
  121. X      if (init_fs_handlers(fpe, fs_block_handler) != Successful)
  122. --- 313,322 ----
  123. X      fpe->private = (pointer) conn;
  124. X      err = fs_send_init_packets(conn);
  125. X      if (err != Successful) {
  126. !         fs_close_conn(conn);
  127. !             xfree(conn->servername);
  128. !             xfree(conn->alts);
  129. !             xfree(conn);
  130. X          return err;
  131. X      }
  132. X      if (init_fs_handlers(fpe, fs_block_handler) != Successful)
  133. ***************
  134. *** 335,343 ****
  135. X      FSFpePtr    conn = (FSFpePtr) fpe->private;
  136. X      FSFpePtr    recon,
  137. X                 *prev;
  138. - 
  139. X      prev = &awaiting_reconnect;
  140. !     while (recon = *prev) {
  141. X      if (conn == recon) {
  142. X          *prev = recon->next_reconnect;
  143. X          break;
  144. --- 363,371 ----
  145. X      FSFpePtr    conn = (FSFpePtr) fpe->private;
  146. X      FSFpePtr    recon,
  147. X                 *prev;
  148. X      prev = &awaiting_reconnect;
  149. !     while (*prev) {
  150. !     recon = *prev;
  151. X      if (conn == recon) {
  152. X          *prev = recon->next_reconnect;
  153. X          break;
  154. ***************
  155. *** 345,355 ****
  156. X      prev = &recon->next_reconnect;
  157. X      }
  158. X  
  159. !     /* close font server */
  160. !     (void) close(conn->fs_fd);
  161. X  
  162. !     _fs_bit_clear(fs_fd_mask, conn->fs_fd);
  163. !     remove_fs_handlers(fpe, fs_block_handler, !_fs_any_bit_set(fs_fd_mask));
  164. X  
  165. X      xfree(conn->alts);
  166. X      xfree(conn->servername);
  167. --- 373,382 ----
  168. X      prev = &recon->next_reconnect;
  169. X      }
  170. X  
  171. !     fs_close_conn(conn);
  172. X  
  173. !     remove_fs_handlers(fpe, fs_block_handler,
  174. !                !_fs_any_bit_set(fs_fd_mask) && !awaiting_reconnect);
  175. X  
  176. X      xfree(conn->alts);
  177. X      xfree(conn->servername);
  178. ***************
  179. *** 578,584 ****
  180. X      return StillWorking;
  181. X      }
  182. X      /* move the data over */
  183. !     (void) fs_convert_header(&rep.header, &bfont->pfont->info);
  184. X      if (bfont->pfont->info.terminalFont)
  185. X      {
  186. X      bfont->format =
  187. --- 605,611 ----
  188. X      return StillWorking;
  189. X      }
  190. X      /* move the data over */
  191. !     (void) fs_convert_header(conn, &rep.header, &bfont->pfont->info);
  192. X      if (bfont->pfont->info.terminalFont)
  193. X      {
  194. X      bfont->format =
  195. ***************
  196. *** 609,615 ****
  197. X      fs_free_font(bfont);
  198. X      return StillWorking;
  199. X      }
  200. !     (void) fs_convert_props(&pi, po, pd, &bfont->pfont->info);
  201. X      xfree(po);
  202. X      xfree(pd);
  203. X  
  204. --- 636,648 ----
  205. X      fs_free_font(bfont);
  206. X      return StillWorking;
  207. X      }
  208. !     if (fs_convert_props(&pi, po, pd, &bfont->pfont->info) == -1)
  209. !     {
  210. !         xfree(po);
  211. !         xfree(pd);
  212. !     (void) fs_cleanup_font(bfont);
  213. !     return AllocError;
  214. !     }
  215. X      xfree(po);
  216. X      xfree(pd);
  217. X  
  218. ***************
  219. *** 628,633 ****
  220. --- 661,668 ----
  221. X      FSFpePtr    conn = (FSFpePtr) fpe->private;
  222. X      fsQueryXExtents8Reply rep;
  223. X      int         i;
  224. +     int        numInfos;
  225. +     Bool    haveInk = FALSE; /* need separate ink metrics? */
  226. X      CharInfoPtr ci,
  227. X                  pCI;
  228. X      FSFontPtr   fsfont = (FSFontPtr) bfont->pfont->fontPrivate;
  229. ***************
  230. *** 642,648 ****
  231. X      return StillWorking;
  232. X      }
  233. X      /* move the data over */
  234. !     ci = pCI = (CharInfoPtr) xalloc(sizeof(CharInfoRec) * rep.num_extents);
  235. X  /* XXX this could be done with an ALLOCATE_LOCAL */
  236. X      fsci = (fsCharInfo *) xalloc(sizeof(fsCharInfo) * rep.num_extents);
  237. X      if (!pCI || !fsci) {
  238. --- 677,690 ----
  239. X      return StillWorking;
  240. X      }
  241. X      /* move the data over */
  242. !     /* need separate inkMetrics for fixed font server protocol version */
  243. !     numInfos =  rep.num_extents;
  244. !     if (bfont->pfont->info.terminalFont && conn->fsMajorVersion > 1)
  245. !     {
  246. !     numInfos *= 2;
  247. !     haveInk = TRUE;
  248. !     }
  249. !     ci = pCI = (CharInfoPtr) xalloc(sizeof(CharInfoRec) * numInfos);
  250. X  /* XXX this could be done with an ALLOCATE_LOCAL */
  251. X      fsci = (fsCharInfo *) xalloc(sizeof(fsCharInfo) * rep.num_extents);
  252. X      if (!pCI || !fsci) {
  253. ***************
  254. *** 654,661 ****
  255. X      return AllocError;
  256. X      }
  257. X      fsfont->encoding = pCI;
  258. ! /* XXX - hack - use real default char */
  259. !     fsfont->pDefault = &pCI[0];
  260. X  
  261. X      if (_fs_read_pad(conn, (char *) fsci,
  262. X               sizeof(fsCharInfo) * rep.num_extents) == -1) {
  263. --- 696,705 ----
  264. X      return AllocError;
  265. X      }
  266. X      fsfont->encoding = pCI;
  267. !     if (haveInk)
  268. !     fsfont->inkMetrics = pCI + rep.num_extents;
  269. !     else
  270. !         fsfont->inkMetrics = pCI;
  271. X  
  272. X      if (_fs_read_pad(conn, (char *) fsci,
  273. X               sizeof(fsCharInfo) * rep.num_extents) == -1) {
  274. ***************
  275. *** 662,672 ****
  276. --- 706,767 ----
  277. X      fs_free_font(bfont);
  278. X      return StillWorking;
  279. X      }
  280. +     ci = fsfont->inkMetrics;
  281. X      for (i = 0, fscip = fsci; i < rep.num_extents; i++, ci++, fscip++) {
  282. X      fs_convert_char_info(fscip, ci);
  283. X      }
  284. X  
  285. X      xfree(fsci);
  286. + 
  287. +     /* build bitmap metrics, ImageRectMax style */
  288. +     if (haveInk)
  289. +     {
  290. +     FontInfoRec *fi = &bfont->pfont->info;
  291. +     CharInfoPtr ii;
  292. + 
  293. +     ci = fsfont->encoding;
  294. +     ii = fsfont->inkMetrics;
  295. +     for (i = 0; i < rep.num_extents; i++, ci++, ii++)
  296. +     {
  297. +         if (NONZEROMETRICS(&ii->metrics))
  298. +         {
  299. +         ci->metrics.leftSideBearing = FONT_MIN_LEFT(fi);
  300. +         ci->metrics.rightSideBearing = FONT_MAX_RIGHT(fi);
  301. +         ci->metrics.ascent = FONT_MAX_ASCENT(fi);
  302. +         ci->metrics.descent = FONT_MAX_DESCENT(fi);
  303. +         ci->metrics.characterWidth = FONT_MAX_WIDTH(fi);
  304. +         ci->metrics.attributes = ii->metrics.attributes;
  305. +         }
  306. +         else
  307. +         {
  308. +         ci->metrics = ii->metrics;
  309. +         }
  310. +     }
  311. +     }
  312. +     {
  313. +     unsigned int r, c, numCols, firstCol;
  314. + 
  315. +     firstCol = bfont->pfont->info.firstCol;
  316. +     numCols = bfont->pfont->info.lastCol - firstCol + 1;
  317. +     c = bfont->pfont->info.defaultCh;
  318. +     fsfont->pDefault = 0;
  319. +     if (bfont->pfont->info.lastRow)
  320. +     {
  321. +         r = c >> 8;
  322. +         r -= bfont->pfont->info.firstRow;
  323. +         c &= 0xff;
  324. +         c -= firstCol;
  325. +         if (r < bfont->pfont->info.lastRow-bfont->pfont->info.firstRow+1 &&
  326. +         c < numCols)
  327. +         fsfont->pDefault = &pCI[r * numCols + c];
  328. +     }
  329. +     else
  330. +     {
  331. +         c -= firstCol;
  332. +         if (c < numCols)
  333. +         fsfont->pDefault = &pCI[c];
  334. +     }
  335. +     }
  336. X      bfont->state = FS_GLYPHS_REPLY;
  337. X  
  338. X      if (bfont->flags & FontLoadBitmaps) {
  339. ***************
  340. *** 787,793 ****
  341. X  }
  342. X  
  343. X  /* ARGSUSED */
  344. ! static int
  345. X  fs_block_handler(data, wt, LastSelectMask)
  346. X      pointer     data;
  347. X      struct timeval **wt;
  348. --- 882,888 ----
  349. X  }
  350. X  
  351. X  /* ARGSUSED */
  352. ! static void
  353. X  fs_block_handler(data, wt, LastSelectMask)
  354. X      pointer     data;
  355. X      struct timeval **wt;
  356. ***************
  357. *** 817,823 ****
  358. X          **wt = recon_timeout;
  359. X      }
  360. X      }
  361. -     return Successful;
  362. X  }
  363. X  
  364. X  static void
  365. --- 912,917 ----
  366. ***************
  367. *** 932,939 ****
  368. X      if (!conn->attemptReconnect)
  369. X      return;
  370. X      conn->attemptReconnect = FALSE;
  371. !     _fs_bit_clear(fs_fd_mask, conn->fs_fd);
  372. !     close(conn->fs_fd);
  373. X      conn->time_to_try = time((long *) 0) + FS_RECONNECT_WAIT;
  374. X      conn->reconnect_delay = FS_RECONNECT_WAIT;
  375. X      conn->fs_fd = -1;
  376. --- 1026,1032 ----
  377. X      if (!conn->attemptReconnect)
  378. X      return;
  379. X      conn->attemptReconnect = FALSE;
  380. !     fs_close_conn(conn);
  381. X      conn->time_to_try = time((long *) 0) + FS_RECONNECT_WAIT;
  382. X      conn->reconnect_delay = FS_RECONNECT_WAIT;
  383. X      conn->fs_fd = -1;
  384. ***************
  385. *** 1318,1328 ****
  386. X      }
  387. X      /* adjust them */
  388. X      for (i = 0; i < rep.num_chars; i++) {
  389. !     if (ppbits[i].length)
  390. X          bits = (char *) pbitmaps + ppbits[i].position;
  391. X      else
  392. X          bits = 0;
  393. X      fsdata->encoding[i].bits = bits;
  394. X      }
  395. X  
  396. X      /* read glyphs according to the range */
  397. --- 1411,1423 ----
  398. X      }
  399. X      /* adjust them */
  400. X      for (i = 0; i < rep.num_chars; i++) {
  401. !     if (ppbits[i].length || NONZEROMETRICS(&fsdata->encoding[i].metrics))
  402. X          bits = (char *) pbitmaps + ppbits[i].position;
  403. X      else
  404. X          bits = 0;
  405. X      fsdata->encoding[i].bits = bits;
  406. +     /* copy the pointer into inkMetrics so _fs_get_metrics can use it */
  407. +     fsdata->inkMetrics[i].bits = bits;
  408. X      }
  409. X  
  410. X      /* read glyphs according to the range */
  411. ***************
  412. *** 1376,1381 ****
  413. --- 1471,1477 ----
  414. X      blockedglyph = (FSBlockedGlyphPtr) blockrec->data;
  415. X      blockedglyph->pfont = pfont;
  416. X      blockedglyph->expected_range = range;
  417. +     blockedglyph->done = FALSE;
  418. X  
  419. X      /* send the request */
  420. X      req.reqType = FS_QueryXBitmaps8;
  421. ***************
  422. *** 1474,1562 ****
  423. X      return Successful;
  424. X  }
  425. X  
  426. - static int
  427. - fs_send_load_extents(client, pfont, flags, nranges, range)
  428. -     pointer     client;
  429. -     FontPtr     pfont;
  430. -     int         nranges;
  431. -     fsRange    *range;
  432. - {
  433. -     FSBlockDataPtr blockrec;
  434. -     FSBlockedExtentPtr blockedextent;
  435. -     int         res;
  436. -     fsQueryXBitmaps8Req req;
  437. -     FSFontDataPtr fsd = (FSFontDataPtr) (pfont->fpePrivate);
  438. -     FontPathElementPtr fpe = fsd->fpe;
  439. -     FSFpePtr    conn = (FSFpePtr) fpe->private;
  440. X  
  441. -     /* make a new block record, and add it to the end of the list */
  442. -     blockrec = fs_new_block_rec(fpe, client, FS_LOAD_EXTENTS);
  443. -     if (!blockrec)
  444. -     return AllocError;
  445. -     blockedextent = (FSBlockedExtentPtr) blockrec->data;
  446. -     blockedextent->pfont = pfont;
  447. -     blockedextent->expected_ranges = range;
  448. -     blockedextent->nranges = nranges;
  449. - 
  450. -     /*
  451. -      * see if the desired extents already exist, and return Successful if they
  452. -      * do, otherwise build up character range/character string
  453. -      */
  454. -     res = fs_check_extents(pfont, flags, nranges, range, blockrec);
  455. -     if (res == AccessDone)
  456. -     return Successful;
  457. - 
  458. -     /* send the request */
  459. -     req.reqType = FS_QueryXExtents8;
  460. -     req.fid = ((FSFontDataPtr) pfont->fpePrivate)->fontid;
  461. -     req.range = TRUE;
  462. -     req.length = (sizeof(fsQueryXExtents8Req) + sizeof(fsRange) * nranges) >> 2;
  463. -     req.num_ranges = nranges;
  464. -     _fs_add_req_log(conn, FS_QueryXExtents8);
  465. -     _fs_write(conn, (char *) &req, sizeof(fsQueryXExtents8Req));
  466. -     if (nranges)
  467. -     _fs_write(conn, (char *) range, sizeof(fsRange) * nranges);
  468. - 
  469. -     return Suspended;
  470. - }
  471. - 
  472. - int
  473. - fs_load_extents(client, pfont, flags, nranges, range,
  474. -         nextents, extents)
  475. -     pointer     client;
  476. -     FontPtr     pfont;
  477. -     int         nranges;
  478. -     fsRange    *range;
  479. -     unsigned long *nextents;
  480. -     fsCharInfo **extents;
  481. - {
  482. -     FSBlockDataPtr blockrec;
  483. -     FSBlockedExtentPtr blockedextent;
  484. -     FSFpePtr    conn = (FSFpePtr) pfont->fpe->private;
  485. - 
  486. -     /* see if the result is already there */
  487. -     blockrec = (FSBlockDataPtr) conn->blocked_requests;
  488. -     while (blockrec) {
  489. -     if (blockrec->type == FS_LOAD_EXTENTS && blockrec->client == client) {
  490. -         blockedextent = (FSBlockedExtentPtr) blockrec->data;
  491. -         if (blockedextent->pfont == pfont && blockedextent->done) {
  492. - 
  493. -         /* copy the data */
  494. -         *nextents = blockedextent->nextents;
  495. -         *extents = blockedextent->extents;
  496. - 
  497. -         fs_remove_blockrec(conn, blockrec);
  498. -         return Successful;
  499. -         }
  500. -     }
  501. -     blockrec = blockrec->next;
  502. -     }
  503. - 
  504. -     /* didn't find waiting record, so send a new one */
  505. -     return fs_send_load_extents(client, pfont, flags, nranges, range);
  506. - }
  507. - 
  508. - 
  509. X  /*
  510. X   * almost identical to the above, but meant for FS chaining
  511. X   */
  512. --- 1570,1576 ----
  513. ***************
  514. *** 1619,1712 ****
  515. X  }
  516. X  
  517. X  static int
  518. - fs_send_load_bitmaps(client, pfont, format, flags, nranges, range)
  519. -     pointer     client;
  520. -     FontPtr     pfont;
  521. -     fsBitmapFormat format;
  522. -     int         nranges;
  523. -     fsRange    *range;
  524. - {
  525. -     FSBlockDataPtr blockrec;
  526. -     FSBlockedBitmapPtr blockedbitmap;
  527. -     int         res;
  528. -     fsQueryXBitmaps8Req req;
  529. -     FSFontDataPtr fsd = (FSFontDataPtr) (pfont->fpePrivate);
  530. -     FontPathElementPtr fpe = fsd->fpe;
  531. -     FSFpePtr    conn = (FSFpePtr) fpe->private;
  532. - 
  533. -     /* make a new block record, and add it to the end of the list */
  534. -     blockrec = fs_new_block_rec(fpe, client, FS_LOAD_BITMAPS);
  535. -     if (!blockrec)
  536. -     return AllocError;
  537. -     blockedbitmap = (FSBlockedBitmapPtr) blockrec->data;
  538. -     blockedbitmap->pfont = pfont;
  539. -     blockedbitmap->expected_ranges = range;
  540. -     blockedbitmap->nranges = nranges;
  541. - 
  542. -     /*
  543. -      * see if the desired glyphs already exist, and return Successful if they
  544. -      * do, otherwise build up character range/character string
  545. -      */
  546. -     res = fs_check_bitmaps(pfont, format, flags, nranges, range, blockrec);
  547. -     if (res == AccessDone)
  548. -     return Successful;
  549. - 
  550. -     /* send the request */
  551. -     req.reqType = FS_QueryXBitmaps8;
  552. -     req.fid = ((FSFontDataPtr) pfont->fpePrivate)->fontid;
  553. -     req.format = format;
  554. -     req.range = TRUE;
  555. -     req.length = (sizeof(fsQueryXBitmaps8Req) + sizeof(fsRange) * nranges) >> 2;
  556. -     req.num_ranges = nranges;
  557. -     _fs_add_req_log(conn, FS_QueryXBitmaps8);
  558. -     _fs_write(conn, (char *) &req, sizeof(fsQueryXBitmaps8Req));
  559. -     _fs_write(conn, (char *) range, sizeof(fsRange) * nranges);
  560. - 
  561. -     return Suspended;
  562. - }
  563. - 
  564. - int
  565. - fs_load_bitmaps(client, pfont, format, flags, nranges, range,
  566. -         size, nglyphs, offsets, gdata)
  567. -     pointer     client;
  568. -     FontPtr     pfont;
  569. -     fsBitmapFormat format;
  570. -     int         nranges;
  571. -     fsRange    *range;
  572. -     unsigned long *size;
  573. -     unsigned long *nglyphs;
  574. -     fsOffset  **offsets;
  575. -     pointer    *gdata;
  576. - {
  577. -     FSBlockDataPtr blockrec;
  578. -     FSBlockedBitmapPtr blockedbitmap;
  579. -     FSFpePtr    conn = (FSFpePtr) pfont->fpe->private;
  580. - 
  581. -     /* see if the result is already there */
  582. -     blockrec = (FSBlockDataPtr) conn->blocked_requests;
  583. -     while (blockrec) {
  584. -     if (blockrec->type == FS_LOAD_BITMAPS && blockrec->client == client) {
  585. -         blockedbitmap = (FSBlockedBitmapPtr) blockrec->data;
  586. -         if (blockedbitmap->pfont == pfont && blockedbitmap->done) {
  587. - 
  588. -         /* copy the data */
  589. -         *size = blockedbitmap->size;
  590. -         *nglyphs = blockedbitmap->nglyphs;
  591. -         *offsets = blockedbitmap->offsets;
  592. -         *gdata = blockedbitmap->gdata;
  593. - 
  594. -         fs_remove_blockrec(conn, blockrec);
  595. -         return Successful;
  596. -         }
  597. -     }
  598. -     blockrec = blockrec->next;
  599. -     }
  600. - 
  601. -     /* didn't find waiting record, so send a new one */
  602. -     return fs_send_load_bitmaps(client, pfont, format, flags, nranges, range);
  603. - }
  604. - 
  605. - static int
  606. X  fs_read_list(fpe, blockrec)
  607. X      FontPathElementPtr fpe;
  608. X      FSBlockDataPtr blockrec;
  609. --- 1633,1638 ----
  610. ***************
  611. *** 1840,1845 ****
  612. --- 1766,1773 ----
  613. X      return fs_send_list_fonts(client, fpe, pattern, patlen, maxnames, newnames);
  614. X  }
  615. X  
  616. + static int  padlength[4] = {0, 3, 2, 1};
  617. + 
  618. X  static int
  619. X  fs_read_list_info(fpe, blockrec)
  620. X      FontPathElementPtr fpe;
  621. ***************
  622. *** 1852,1863 ****
  623. X      fsPropOffset *po;
  624. X      char       *name;
  625. X      pointer     pd;
  626. X  
  627. X      /* clean up anything from the last trip */
  628. !     if (binfo->pfi) {
  629. X      xfree(binfo->name);
  630. X      xfree(binfo->pfi->isStringProp);
  631. X      xfree(binfo->pfi->props);
  632. X      }
  633. X      /* get reply header */
  634. X      bcopy((char *) &blockrec->header, (char *) &rep, sizeof(fsReplyHeader));
  635. --- 1780,1798 ----
  636. X      fsPropOffset *po;
  637. X      char       *name;
  638. X      pointer     pd;
  639. +     int        err;
  640. X  
  641. X      /* clean up anything from the last trip */
  642. !     if (binfo->name)
  643. !     {
  644. X      xfree(binfo->name);
  645. +     binfo->name = NULL;
  646. +     }
  647. +     if (binfo->pfi) {
  648. X      xfree(binfo->pfi->isStringProp);
  649. X      xfree(binfo->pfi->props);
  650. +     xfree(binfo->pfi);
  651. +     binfo->pfi = NULL;
  652. X      }
  653. X      /* get reply header */
  654. X      bcopy((char *) &blockrec->header, (char *) &rep, sizeof(fsReplyHeader));
  655. ***************
  656. *** 1867,1872 ****
  657. --- 1802,1811 ----
  658. X      binfo->errcode = AllocError;
  659. X      return AllocError;
  660. X      }
  661. +     if (conn->fsMajorVersion > 1)
  662. +     if (rep.nameLength == 0)
  663. +         goto done;
  664. +     /* old protocol sent a full-length reply even for the last one */
  665. X      if (_fs_read(conn, (char *) &rep + sizeof(fsReplyHeader),
  666. X        sizeof(fsListFontsWithXInfoReply) - sizeof(fsReplyHeader)) == -1) {
  667. X      goto done;
  668. ***************
  669. *** 1880,1885 ****
  670. --- 1819,1825 ----
  671. X      if (!name || !binfo->pfi) {
  672. X      xfree(name);
  673. X      xfree(binfo->pfi);
  674. +     binfo->pfi = NULL;
  675. X      _fs_drain_bytes(conn,
  676. X              rep.length - (sizeof(fsListFontsWithXInfoReply) -
  677. X                        sizeof(fsReplyHeader)));
  678. ***************
  679. *** 1886,1895 ****
  680. X      binfo->errcode = AllocError;
  681. X      return AllocError;
  682. X      }
  683. !     if (_fs_read_pad(conn, name, rep.nameLength) == -1 ||
  684. !         _fs_read_pad(conn, (char *) &pi, sizeof(fsPropInfo)) == -1) {
  685. !     goto done;
  686. !     }
  687. X      po = (fsPropOffset *) xalloc(sizeof(fsPropOffset) * pi.num_offsets);
  688. X      pd = (pointer) xalloc(pi.data_len);
  689. X      if (!po || !pd) {
  690. --- 1826,1837 ----
  691. X      binfo->errcode = AllocError;
  692. X      return AllocError;
  693. X      }
  694. !     if (conn->fsMajorVersion == 1)
  695. !     if (_fs_read_pad(conn, name, rep.nameLength) == -1)
  696. !         goto done;
  697. !     if (_fs_read_pad(conn, (char *) &pi, sizeof(fsPropInfo)) == -1)
  698. !         goto done;
  699. ! 
  700. X      po = (fsPropOffset *) xalloc(sizeof(fsPropOffset) * pi.num_offsets);
  701. X      pd = (pointer) xalloc(pi.data_len);
  702. X      if (!po || !pd) {
  703. ***************
  704. *** 1896,1913 ****
  705. X      xfree(name);
  706. X      xfree(po);
  707. X      xfree(pd);
  708. X      binfo->errcode = AllocError;
  709. X      return AllocError;
  710. X      }
  711. !     if (_fs_read_pad(conn, (char *) po,
  712. !              (pi.num_offsets * sizeof(fsPropOffset))) == -1 ||
  713. !         _fs_read_pad(conn, (char *) pd, pi.data_len) == -1) {
  714. X      xfree(name);
  715. X      xfree(po);
  716. X      xfree(pd);
  717. X      goto done;
  718. X      }
  719. !     fs_convert_lfwi_reply(binfo->pfi, &rep, &pi, po, pd);
  720. X      xfree(po);
  721. X      xfree(pd);
  722. X      binfo->name = name;
  723. --- 1838,1882 ----
  724. X      xfree(name);
  725. X      xfree(po);
  726. X      xfree(pd);
  727. +     xfree (binfo->pfi);
  728. +     binfo->pfi = NULL;
  729. X      binfo->errcode = AllocError;
  730. X      return AllocError;
  731. X      }
  732. !     err = _fs_read_pad(conn, (char *) po,
  733. !                (pi.num_offsets * sizeof(fsPropOffset)));
  734. !     if (err != -1)
  735. !     {
  736. !     if (conn->fsMajorVersion > 1)
  737. !         err = _fs_read(conn, (char *) pd, pi.data_len);
  738. !     else
  739. !         err = _fs_read_pad(conn, (char *) pd, pi.data_len);
  740. !     }
  741. !     if (err != -1  &&  conn->fsMajorVersion != 1)
  742. !     {
  743. !     err = _fs_read(conn, name, rep.nameLength);
  744. !     if (err != -1)
  745. !         err = _fs_drain_bytes(conn, padlength[(pi.data_len+rep.nameLength)&3]);
  746. !     }
  747. ! 
  748. !     if (err == -1) {
  749. X      xfree(name);
  750. X      xfree(po);
  751. X      xfree(pd);
  752. +     xfree (binfo->pfi);
  753. +     binfo->pfi = NULL;
  754. X      goto done;
  755. X      }
  756. ! 
  757. !     if (fs_convert_lfwi_reply(conn, binfo->pfi, &rep, &pi, po, pd) != Successful)
  758. !     {
  759. !     xfree(name);
  760. !     xfree(po);
  761. !     xfree(pd);
  762. !     xfree (binfo->pfi);
  763. !     binfo->pfi = NULL;
  764. !     goto done;
  765. !     }
  766. X      xfree(po);
  767. X      xfree(pd);
  768. X      binfo->name = name;
  769. ***************
  770. *** 2067,2076 ****
  771. X      return;
  772. X      if (blockrec->type == FS_LIST_WITH_INFO)
  773. X      {
  774. !     FSBlockedListInfoPtr blockedinfo;
  775. !     blockedinfo = (FSBlockedListInfoPtr) blockrec->data;
  776. !     if (blockedinfo->status == FS_LFWI_REPLY)
  777. X          _fs_set_bit(fs_fd_mask, conn->fs_fd);
  778. X      }
  779. X      /* replace the client pointers in this block rec with the chained one */
  780. X      if (depending = blockrec->depending) {
  781. --- 2036,2057 ----
  782. X      return;
  783. X      if (blockrec->type == FS_LIST_WITH_INFO)
  784. X      {
  785. !     FSBlockedListInfoPtr binfo;
  786. !     binfo = (FSBlockedListInfoPtr) blockrec->data;
  787. !     if (binfo->status == FS_LFWI_REPLY)
  788. X          _fs_set_bit(fs_fd_mask, conn->fs_fd);
  789. +         if (binfo->name)
  790. +     {
  791. +         xfree(binfo->name);
  792. +         binfo->name = NULL;
  793. +     }
  794. +         if (binfo->pfi) 
  795. +     {
  796. +         xfree(binfo->pfi->isStringProp);
  797. +         xfree(binfo->pfi->props);
  798. +         xfree(binfo->pfi);
  799. +         binfo->pfi = NULL;
  800. +         }
  801. X      }
  802. X      /* replace the client pointers in this block rec with the chained one */
  803. X      if (depending = blockrec->depending) {
  804. *** /tmp/da26726    Tue Jul 14 18:05:08 1992
  805. --- mit/fonts/lib/font/fc/fsconvert.c    Tue Jul 14 18:05:08 1992
  806. ***************
  807. *** 1,4 ****
  808. ! /* $XConsortium: fsconvert.c,v 1.7 91/07/16 20:17:05 keith Exp $ */
  809. X  /*
  810. X   * Copyright 1990 Network Computing Devices
  811. X   *
  812. --- 1,4 ----
  813. ! /* $XConsortium: fsconvert.c,v 1.9 92/05/12 18:07:31 gildea Exp $ */
  814. X  /*
  815. X   * Copyright 1990 Network Computing Devices
  816. X   *
  817. ***************
  818. *** 22,32 ****
  819. X   * OR PERFORMANCE OF THIS SOFTWARE.
  820. X   *
  821. X   * Author:      Dave Lemke, Network Computing Devices, Inc
  822. -  *
  823. -  *    @(#)fsconvert.c    4.2    91/05/14
  824. -  *
  825. -  * $NCDId: @(#)fsconvert.c,v 1.3 1991/06/10 13:21:52 lemke Exp $
  826. -  *
  827. X   */
  828. X  /*
  829. X   * FS data conversion
  830. --- 22,27 ----
  831. ***************
  832. *** 59,65 ****
  833. X  }
  834. X  
  835. X  int
  836. ! fs_convert_header(hdr, pfi)
  837. X      fsFontHeader *hdr;
  838. X      FontInfoPtr pfi;
  839. X  {
  840. --- 54,61 ----
  841. X  }
  842. X  
  843. X  int
  844. ! fs_convert_header(conn, hdr, pfi)
  845. !     FSFpePtr    conn;
  846. X      fsFontHeader *hdr;
  847. X      FontInfoPtr pfi;
  848. X  {
  849. ***************
  850. *** 69,80 ****
  851. X      pfi->drawDirection = (hdr->draw_direction == LeftToRightDrawDirection) ?
  852. X      LeftToRight : RightToLeft;
  853. X      pfi->inkInside = (hdr->flags & FontInfoInkInside) != 0;
  854. -     pfi->firstCol = hdr->char_range.min_char.low;
  855. -     pfi->firstRow = hdr->char_range.min_char.high;
  856. -     pfi->lastCol = hdr->char_range.max_char.low;
  857. -     pfi->lastRow = hdr->char_range.max_char.high;
  858. X  
  859. !     pfi->defaultCh = hdr->default_char.low + (hdr->default_char.high << 8);
  860. X  
  861. X      pfi->fontDescent = hdr->font_descent;
  862. X      pfi->fontAscent = hdr->font_ascent;
  863. --- 65,84 ----
  864. X      pfi->drawDirection = (hdr->draw_direction == LeftToRightDrawDirection) ?
  865. X      LeftToRight : RightToLeft;
  866. X      pfi->inkInside = (hdr->flags & FontInfoInkInside) != 0;
  867. X  
  868. !     if (conn->fsMajorVersion > 1) {
  869. !     pfi->firstCol = hdr->char_range.min_char.low;
  870. !     pfi->firstRow = hdr->char_range.min_char.high;
  871. !     pfi->lastCol = hdr->char_range.max_char.low;
  872. !     pfi->lastRow = hdr->char_range.max_char.high;
  873. !     pfi->defaultCh = hdr->default_char.low + (hdr->default_char.high << 8);
  874. !     } else {
  875. !     pfi->firstCol = hdr->char_range.min_char.high;
  876. !     pfi->firstRow = hdr->char_range.min_char.low;
  877. !     pfi->lastCol = hdr->char_range.max_char.high;
  878. !     pfi->lastRow = hdr->char_range.max_char.low;
  879. !     pfi->defaultCh = hdr->default_char.high + (hdr->default_char.low << 8);
  880. !     }
  881. X  
  882. X      pfi->fontDescent = hdr->font_descent;
  883. X      pfi->fontAscent = hdr->font_ascent;
  884. ***************
  885. *** 112,117 ****
  886. --- 116,124 ----
  887. X                  nprops;
  888. X      char       *is_str;
  889. X  
  890. + /* stolen from server/include/resource.h */
  891. + #define BAD_RESOURCE 0xe0000000
  892. + 
  893. X      nprops = pfi->nprops = pi->num_offsets;
  894. X  
  895. X      dprop = (FontPropPtr) xalloc(sizeof(FontPropRec) * nprops);
  896. ***************
  897. *** 133,138 ****
  898. --- 140,153 ----
  899. X          *is_str = TRUE;
  900. X          dprop->value = (INT32) MakeAtom(&pd[po->value.position],
  901. X                          po->value.length, 1);
  902. +         if (dprop->value == BAD_RESOURCE)
  903. +         {
  904. +         xfree (pfi->props);
  905. +         xfree (pfi->isStringProp);
  906. +         pfi->props = 0;
  907. +         pfi->isStringProp = 0;
  908. +         return -1;
  909. +         }
  910. X      }
  911. X      }
  912. X  
  913. ***************
  914. *** 140,146 ****
  915. X  }
  916. X  
  917. X  int
  918. ! fs_convert_lfwi_reply(pfi, fsrep, pi, po, pd)
  919. X      FontInfoPtr pfi;
  920. X      fsListFontsWithXInfoReply *fsrep;
  921. X      fsPropInfo *pi;
  922. --- 155,162 ----
  923. X  }
  924. X  
  925. X  int
  926. ! fs_convert_lfwi_reply(conn, pfi, fsrep, pi, po, pd)
  927. !     FSFpePtr    conn;
  928. X      FontInfoPtr pfi;
  929. X      fsListFontsWithXInfoReply *fsrep;
  930. X      fsPropInfo *pi;
  931. ***************
  932. *** 149,156 ****
  933. X  {
  934. X      fsFontHeader *hdr = &fsrep->header;
  935. X  
  936. !     fs_convert_header(hdr, pfi);
  937. !     fs_convert_props(pi, po, pd, pfi);
  938. X  
  939. X      return Successful;
  940. X  }
  941. --- 165,173 ----
  942. X  {
  943. X      fsFontHeader *hdr = &fsrep->header;
  944. X  
  945. !     fs_convert_header(conn, hdr, pfi);
  946. !     if (fs_convert_props(pi, po, pd, pfi) == -1)
  947. !     return AllocError;
  948. X  
  949. X      return Successful;
  950. X  }
  951. ***************
  952. *** 325,331 ****
  953. X      return Successful;
  954. X  }
  955. X  
  956. ! CharInfoRec junkDefault;
  957. X  
  958. X  static int
  959. X  _fs_get_metrics(pFont, count, chars, charEncoding, glyphCount, glyphs)
  960. --- 342,348 ----
  961. X      return Successful;
  962. X  }
  963. X  
  964. ! static CharInfoRec junkDefault;
  965. X  
  966. X  static int
  967. X  _fs_get_metrics(pFont, count, chars, charEncoding, glyphCount, glyphs)
  968. ***************
  969. *** 339,350 ****
  970. X      int         ret;
  971. X      FSFontPtr   fsfont;
  972. X      int         i;
  973. ! 
  974. X      fsfont = (FSFontPtr) pFont->fontPrivate;
  975. X      if (!fsfont->pDefault)
  976. X      fsfont->pDefault = &junkDefault;
  977. X      ret = _fs_get_glyphs(pFont, count, chars, charEncoding,
  978. X               glyphCount, (CharInfoPtr *) glyphs);
  979. X  
  980. X      if (ret == Successful) {
  981. X      if (fsfont->pDefault == &junkDefault) {
  982. --- 356,373 ----
  983. X      int         ret;
  984. X      FSFontPtr   fsfont;
  985. X      int         i;
  986. !     CharInfoPtr encoding;
  987. !     
  988. X      fsfont = (FSFontPtr) pFont->fontPrivate;
  989. X      if (!fsfont->pDefault)
  990. X      fsfont->pDefault = &junkDefault;
  991. + 
  992. +     /* sleeze - smash the encoding so we get ink metrics */
  993. +     encoding = fsfont->encoding;
  994. +     fsfont->encoding = fsfont->inkMetrics;
  995. X      ret = _fs_get_glyphs(pFont, count, chars, charEncoding,
  996. X               glyphCount, (CharInfoPtr *) glyphs);
  997. +     fsfont->encoding = encoding;
  998. X  
  999. X      if (ret == Successful) {
  1000. X      if (fsfont->pDefault == &junkDefault) {
  1001. ***************
  1002. *** 377,388 ****
  1003. X      FontPtr     pfont;
  1004. X  {
  1005. X      /* set font function pointers */
  1006. -     extern int  fs_load_bitmaps();
  1007. -     extern int  fs_load_extents();
  1008. - 
  1009. X      pfont->get_glyphs = _fs_get_glyphs;
  1010. X      pfont->get_metrics = _fs_get_metrics;
  1011. -     pfont->get_bitmaps = fs_load_bitmaps;
  1012. -     pfont->get_extents = fs_load_extents;
  1013. X      pfont->unload_font = fs_unload_font;
  1014. X  }
  1015. --- 400,406 ----
  1016. *** /tmp/da26769    Tue Jul 14 18:05:13 1992
  1017. --- mit/fonts/lib/font/fc/fsio.c    Tue Jul 14 18:05:12 1992
  1018. ***************
  1019. *** 1,6 ****
  1020. ! /* $XConsortium: fsio.c,v 1.21 91/07/19 20:55:30 rws Exp $ */
  1021. X  /*
  1022. -  *
  1023. X   * Copyright 1990 Network Computing Devices
  1024. X   *
  1025. X   * Permission to use, copy, modify, distribute, and sell this software and its
  1026. --- 1,5 ----
  1027. ! /* $XConsortium: fsio.c,v 1.23 92/05/14 16:52:27 gildea Exp $ */
  1028. X  /*
  1029. X   * Copyright 1990 Network Computing Devices
  1030. X   *
  1031. X   * Permission to use, copy, modify, distribute, and sell this software and its
  1032. ***************
  1033. *** 23,30 ****
  1034. X   * OR PERFORMANCE OF THIS SOFTWARE.
  1035. X   *
  1036. X   * Author:      Dave Lemke, Network Computing Devices, Inc
  1037. -  *
  1038. -  * $NCDId: @(#)fsio.c,v 1.7 1991/07/02 13:13:43 lemke Exp $
  1039. X   */
  1040. X  /*
  1041. X   * font server i/o routines
  1042. --- 22,27 ----
  1043. ***************
  1044. *** 213,220 ****
  1045. X      conn->fs_fd = _fs_connect(servername, 5);
  1046. X      if (conn->fs_fd < 0)
  1047. X      return FALSE;
  1048. -     conn->servername = (char *) xalloc(strlen(servername) + 1);
  1049. -     strcpy(conn->servername, servername);
  1050. X  
  1051. X      conn->generation = ++generationCount;
  1052. X  
  1053. --- 210,215 ----
  1054. ***************
  1055. *** 239,244 ****
  1056. --- 234,243 ----
  1057. X      if (_fs_read(conn, (char *) &rep, sizeof(fsConnSetup)) == -1)
  1058. X      return FALSE;
  1059. X  
  1060. +     conn->fsMajorVersion = rep.major_version;
  1061. +     if (rep.major_version > FS_PROTOCOL)
  1062. +     return FALSE;
  1063. + 
  1064. X      alts = 0;
  1065. X      /* parse alternate list */
  1066. X      if (nalts = rep.num_alternates) {
  1067. ***************
  1068. *** 308,313 ****
  1069. --- 307,317 ----
  1070. X      xfree(auth_data);
  1071. X      xfree(vendor_string);
  1072. X  
  1073. +     conn->servername = (char *) xalloc(strlen(servername) + 1);
  1074. +     if (conn->servername == NULL)
  1075. +     return FALSE;
  1076. +     strcpy(conn->servername, servername);
  1077. + 
  1078. X      return TRUE;
  1079. X  }
  1080. X  
  1081. ***************
  1082. *** 392,397 ****
  1083. --- 396,402 ----
  1084. X          errno = EPIPE;
  1085. X          return -1;
  1086. X          }
  1087. +         errno = 0;
  1088. X      } else if (errno == EINTR) {
  1089. X          continue;
  1090. X      } else {        /* something bad happened */
  1091. *** /tmp/da26791    Tue Jul 14 18:05:15 1992
  1092. --- mit/fonts/lib/font/fc/fservestr.h    Tue Jul 14 18:05:14 1992
  1093. ***************
  1094. *** 1,10 ****
  1095. ! /* $XConsortium: fservestr.h,v 1.6 91/06/21 18:15:45 keith Exp $ */
  1096. X  /*
  1097. X   * Copyright 1990 Network Computing Devices
  1098. X   *
  1099. !  * Permission to use, copy, modify, distribute, and sell this software and its
  1100. !  * documentation for any purpose is hereby granted without fee, provided that
  1101. !  * the above copyright notice appear in all copies and that both that
  1102. X   * copyright notice and this permission notice appear in supporting
  1103. X   * documentation, and that the name of Network Computing Devices not be
  1104. X   * used in advertising or publicity pertaining to distribution of the
  1105. --- 1,10 ----
  1106. ! /* $XConsortium: fservestr.h,v 1.8 92/07/09 16:11:10 gildea Exp $ */
  1107. X  /*
  1108. X   * Copyright 1990 Network Computing Devices
  1109. X   *
  1110. !  * Permission to use, copy, modify, distribute, and sell this software and
  1111. !  * its documentation for any purpose is hereby granted without fee, provided
  1112. !  * that the above copyright notice appear in all copies and that both that
  1113. X   * copyright notice and this permission notice appear in supporting
  1114. X   * documentation, and that the name of Network Computing Devices not be
  1115. X   * used in advertising or publicity pertaining to distribution of the
  1116. ***************
  1117. *** 22,29 ****
  1118. X   * OR PERFORMANCE OF THIS SOFTWARE.
  1119. X   *
  1120. X   * Author:      Dave Lemke, Network Computing Devices, Inc
  1121. -  *
  1122. -  * $NCDId: @(#)fservestr.h,v 1.2 1991/05/24 15:03:06 lemke Exp $
  1123. X   */
  1124. X  
  1125. X  #ifndef _FSERVESTR_H_
  1126. --- 22,27 ----
  1127. ***************
  1128. *** 48,53 ****
  1129. --- 46,52 ----
  1130. X  typedef struct _fs_font {
  1131. X      CharInfoPtr pDefault;
  1132. X      CharInfoPtr encoding;
  1133. +     CharInfoPtr inkMetrics;
  1134. X      pointer     bitmaps;
  1135. X  }           FSFontRec, *FSFontPtr;
  1136. X  
  1137. *** /tmp/da26813    Tue Jul 14 18:05:17 1992
  1138. --- mit/fonts/lib/font/fc/fsio.h    Tue Jul 14 18:05:16 1992
  1139. ***************
  1140. *** 1,4 ****
  1141. ! /* $XConsortium: fsio.h,v 1.9 91/07/18 22:40:50 keith Exp $ */
  1142. X  /*
  1143. X   * Copyright 1990 Network Computing Devices
  1144. X   *
  1145. --- 1,4 ----
  1146. ! /* $XConsortium: fsio.h,v 1.10 92/05/12 18:07:38 gildea Exp $ */
  1147. X  /*
  1148. X   * Copyright 1990 Network Computing Devices
  1149. X   *
  1150. ***************
  1151. *** 22,29 ****
  1152. X   * OR PERFORMANCE OF THIS SOFTWARE.
  1153. X   *
  1154. X   * Author:      Dave Lemke, Network Computing Devices, Inc
  1155. -  *
  1156. -  * $NCDId: @(#)fsio.h,v 1.4 1991/07/03 17:52:30 lemke Exp $
  1157. X   */
  1158. X  
  1159. X  #ifndef    _FSIO_H_
  1160. --- 22,27 ----
  1161. ***************
  1162. *** 56,61 ****
  1163. --- 54,60 ----
  1164. X  
  1165. X      int         generation;
  1166. X      int         numAlts;
  1167. +     int        fsMajorVersion; /* font server major version number */
  1168. X      FSFpeAltPtr alts;
  1169. X  
  1170. X      FSClientPtr    clients;
  1171. *** /tmp/da11492    Mon Jul 20 16:43:04 1992
  1172. --- mit/fonts/lib/font/Speedo/spfont.c    Mon Jul 20 16:43:03 1992
  1173. ***************
  1174. *** 1,4 ****
  1175. ! /* $XConsortium: spfont.c,v 1.13 91/09/16 11:42:28 keith Exp $ */
  1176. X  /*
  1177. X   * Copyright 1990, 1991 Network Computing Devices;
  1178. X   * Portions Copyright 1987 by Digital Equipment Corporation and the
  1179. --- 1,4 ----
  1180. ! /* $XConsortium: spfont.c,v 1.16 92/05/12 18:07:52 gildea Exp $ */
  1181. X  /*
  1182. X   * Copyright 1990, 1991 Network Computing Devices;
  1183. X   * Portions Copyright 1987 by Digital Equipment Corporation and the
  1184. ***************
  1185. *** 22,30 ****
  1186. X   * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  1187. X   *
  1188. X   * Author: Dave Lemke, Network Computing Devices Inc
  1189. -  *
  1190. -  * $NCDId: @(#)spfont.c,v 4.9 1991/07/02 17:01:30 lemke Exp $
  1191. -  *
  1192. X   */
  1193. X  
  1194. X  /*
  1195. --- 22,27 ----
  1196. ***************
  1197. *** 47,55 ****
  1198. X  
  1199. X  extern void SpeedoCloseFont();
  1200. X  static int  get_sp_glyphs(),
  1201. !             get_sp_bitmaps(),
  1202. !             get_sp_metrics(),
  1203. !             get_sp_extents();
  1204. X  static int load_sp_font();
  1205. X  
  1206. X  static CharInfoRec junkDefault;
  1207. --- 44,50 ----
  1208. X  
  1209. X  extern void SpeedoCloseFont();
  1210. X  static int  get_sp_glyphs(),
  1211. !             get_sp_metrics();
  1212. X  static int load_sp_font();
  1213. X  
  1214. X  static CharInfoRec junkDefault;
  1215. ***************
  1216. *** 69,455 ****
  1217. X      dst->attributes = 0;
  1218. X  }
  1219. X  
  1220. - /* XXX -- may have to add in some work for setting default metrics values */
  1221. - 
  1222. - /* ARGSUSED */
  1223. X  static int
  1224. - get_sp_extents(client, pfont, flags, num_ranges, range, num_extents, data)
  1225. -     pointer     client;
  1226. -     FontPtr     pfont;
  1227. -     Mask        flags;
  1228. -     unsigned long num_ranges;
  1229. -     fsRange    *range;
  1230. -     unsigned long *num_extents;
  1231. -     fsCharInfo **data;
  1232. - {
  1233. -     int         start,
  1234. -                 end,
  1235. -                 i,
  1236. -                 j;
  1237. -     unsigned long size;
  1238. -     fsCharInfo *ci,
  1239. -                *pci;
  1240. -     fsRange    *rp;
  1241. -     FontInfoPtr pinfo;
  1242. -     SpeedoFontPtr spf;
  1243. -     SpeedoMasterFontPtr master;
  1244. -     CharInfoRec src;
  1245. -     int        firstChar;
  1246. - 
  1247. -     assert(pfont);
  1248. -     pinfo = &pfont->info;
  1249. -     spf = (SpeedoFontPtr) pfont->fontPrivate;
  1250. -     master = spf->master;
  1251. - 
  1252. -     firstChar = master->first_char_id;
  1253. -     if (flags & LoadAll) {
  1254. -     start = master->first_char_id;
  1255. -     end = master->max_id;
  1256. - 
  1257. -     *num_extents = end - start + 1;
  1258. -     size = sizeof(fsCharInfo) * (*num_extents);
  1259. -     pci = ci = (fsCharInfo *) xalloc(size);
  1260. -     if (!ci)
  1261. -         return AllocError;
  1262. - 
  1263. -     /* copy all the extents */
  1264. -     for (i = start; i <= end; i++) {
  1265. -         src = spf->encoding[i - firstChar];
  1266. -         CopyCharInfo(&src, pci);
  1267. -         pci++;
  1268. -     }
  1269. - 
  1270. -     /* make sure it didn't go off the end */
  1271. -     assert(pci == (fsCharInfo *) ((char *) ci + size));
  1272. -     assert(pci == (ci + (end - start + 1)));
  1273. - 
  1274. -     *data = ci;
  1275. -     return Successful;
  1276. -     }
  1277. -     /* normal case */
  1278. -     /* figure out how big everything has to be */
  1279. -     *num_extents = 0;
  1280. -     for (i = 0, rp = range; i < num_ranges; i++, rp++) {
  1281. -     start = (rp->min_char.high << 8) + rp->min_char.low;
  1282. -     end = (rp->max_char.high << 8) + rp->max_char.low;
  1283. - 
  1284. -     /* range check */
  1285. -     if (end < start ||
  1286. -         (end > (pinfo->lastRow << 8) + pinfo->lastCol)
  1287. -         || (end < (pinfo->firstRow << 8) + pinfo->firstCol)
  1288. -         || (start > (pinfo->lastRow << 8) + pinfo->lastCol)
  1289. -         || (start < (pinfo->firstRow << 8) + pinfo->firstCol))
  1290. -         return BadCharRange;
  1291. - 
  1292. -     *num_extents += end - start + 1;
  1293. -     }
  1294. - 
  1295. -     size = sizeof(fsCharInfo) * (*num_extents);
  1296. -     pci = ci = (fsCharInfo *) xalloc(size);
  1297. -     if (!ci)
  1298. -     return AllocError;
  1299. - 
  1300. -     /* copy all the extents */
  1301. -     for (i = 0, rp = range; i < num_ranges; i++, rp++) {
  1302. -     start = (rp->min_char.high << 8) + rp->min_char.low;
  1303. -     end = (rp->max_char.high << 8) + rp->max_char.low;
  1304. - 
  1305. -     /* copy all the extents */
  1306. -     for (j = start; j <= end; j++) {
  1307. -         src = spf->encoding[j - firstChar];
  1308. -         CopyCharInfo(&src, pci);
  1309. -         pci++;
  1310. -     }
  1311. - 
  1312. -     /* make sure it didn't go off the end */
  1313. -     assert(pci == (fsCharInfo *) ((char *) ci + size));
  1314. -     assert(pci == (ci + (end - start + 1)));
  1315. -     }
  1316. - 
  1317. -     *data = ci;
  1318. - 
  1319. -     return Successful;
  1320. - }
  1321. - 
  1322. - /*
  1323. -  * packs up the glyphs as requested by the format
  1324. -  */
  1325. - 
  1326. - static int
  1327. - pack_sp_glyphs(pfont, format, flags, num_ranges, range, tsize, num_glyphs,
  1328. -            offsets, data, freeData)
  1329. -     FontPtr     pfont;
  1330. -     int         format;
  1331. -     Mask        flags;
  1332. -     unsigned long num_ranges;
  1333. -     fsRange    *range;
  1334. -     unsigned long *tsize;
  1335. -     unsigned long *num_glyphs;
  1336. -     fsOffset  **offsets;
  1337. -     pointer    *data;
  1338. -     int        *freeData;
  1339. - {
  1340. -     unsigned long start,
  1341. -                 end;
  1342. -     int         i;
  1343. -     fsOffset   *lengths = (fsOffset *) 0,
  1344. -                *l;
  1345. -     unsigned long size = 0;
  1346. -     pointer     gdata,
  1347. -                 gd;
  1348. -     unsigned long ch;
  1349. -     int         bitorder,
  1350. -                 byteorder,
  1351. -                 scanlinepad,
  1352. -                 scanlineunit,
  1353. -                 mappad;
  1354. -     int         bpr,
  1355. -                 skiprows = 0;
  1356. -     fsRange    *rp;
  1357. -     FontInfoPtr pinfo = &pfont->info;
  1358. -     SpeedoFontPtr spf = (SpeedoFontPtr) pfont->fontPrivate;
  1359. -     SpeedoMasterFontPtr master = spf->master;
  1360. -     int         err;
  1361. -     int         src_glyph_pad;
  1362. -     int         src_bit_order;
  1363. -     int         src_byte_order;
  1364. -     int        firstChar;
  1365. -     int         max_ascent, max_descent;
  1366. -     int         min_left, max_right;
  1367. -     
  1368. -     err = CheckFSFormat(format, (fsBitmapFormatMask) ~ 0,
  1369. -         &bitorder, &byteorder, &scanlineunit, &scanlinepad, &mappad);
  1370. -     if (err != Successful)
  1371. -     return err;
  1372. -     (void) CheckFSFormat(pfont->format, (fsBitmapFormatMask) ~ 0,
  1373. -         &src_bit_order, &src_byte_order, &err, &src_glyph_pad, &err);
  1374. - 
  1375. -     if (!spf->pDefault)
  1376. -     spf->pDefault = &junkDefault;
  1377. - 
  1378. -     *freeData = TRUE;
  1379. -     firstChar = master->first_char_id;
  1380. -     /* special case for all glyphs first */
  1381. -     if (flags & LoadAll) {
  1382. -     start = master->first_char_id;
  1383. -     end = master->max_id;
  1384. -     *num_glyphs = end - start + 1;
  1385. -     size = compute_sp_data_size(pfont, mappad, scanlinepad, start, end);;
  1386. -     num_ranges = 1;
  1387. -     } else {
  1388. -     *num_glyphs = 0;
  1389. -     for (i = 0, rp = range; i < num_ranges; i++, rp++) {
  1390. -         start = (rp->min_char.high << 8) + rp->min_char.low;
  1391. -         end = (rp->max_char.high << 8) + rp->max_char.low;
  1392. - 
  1393. -         /* range check */
  1394. -         if (end < start ||
  1395. -             (end > (pinfo->lastRow << 8) + pinfo->lastCol)
  1396. -             || (end < (pinfo->firstRow << 8) + pinfo->firstCol)
  1397. -             || (start > (pinfo->lastRow << 8) + pinfo->lastCol)
  1398. -             || (start < (pinfo->firstRow << 8) + pinfo->firstCol))
  1399. -         return BadCharRange;
  1400. - 
  1401. -         *num_glyphs += end - start + 1;
  1402. -         size += compute_sp_data_size(pfont, mappad, scanlinepad, start, end);
  1403. -     }
  1404. -     }
  1405. - 
  1406. -     gd = gdata = (pointer) xalloc(size);
  1407. -     if (!gdata)
  1408. -     return AllocError;
  1409. -     if (mappad == BitmapFormatImageRectMax)
  1410. -     bzero((char *) gdata, size);
  1411. - 
  1412. -     /* get space for glyph offsets */
  1413. -     l = lengths = (fsOffset *) xalloc(sizeof(fsOffset) *
  1414. -                       *num_glyphs);
  1415. -     if (!lengths) {
  1416. -     xfree((char *) gdata);
  1417. -     return AllocError;
  1418. -     }
  1419. -     /* compute bpr for padded out fonts */
  1420. -     switch (mappad)
  1421. -     {
  1422. -     case BitmapFormatImageRectMax:
  1423. -     max_ascent = FONT_MAX_ASCENT(pinfo);
  1424. -     max_descent = FONT_MAX_DESCENT(pinfo);
  1425. -     /* fall through */
  1426. -     case BitmapFormatImageRectMaxWidth:
  1427. -     min_left = FONT_MIN_LEFT(pinfo);
  1428. -     max_right = FONT_MAX_RIGHT(pinfo);
  1429. -     bpr = GLWIDTHBYTESPADDED(max_right - min_left, scanlinepad);
  1430. -     break;
  1431. -     case BitmapFormatImageRectMin:
  1432. -     break;
  1433. -     }
  1434. -     /* finally do the work */
  1435. -     for (i = 0, rp = range; i < num_ranges; i++, rp++) {
  1436. -     /*
  1437. -      * compute start & end.  if all_glyphs is set, we still have them
  1438. -      * laying around
  1439. -      */
  1440. -     if (!(flags & LoadAll)) {
  1441. -         start = (rp->min_char.high << 8) + rp->min_char.low;
  1442. -         end = (rp->max_char.high << 8) + rp->max_char.low;
  1443. -     }
  1444. -     for (ch = start; ch <= end; ch++) {
  1445. -         CharInfoPtr ci;
  1446. -         xCharInfo  *cim;
  1447. -         int         srcbpr;
  1448. -         unsigned char    *src, *dst;
  1449. -         unsigned int    bits1, bits2;
  1450. -         int         r,
  1451. -             lshift = 0,
  1452. -             rshift = 0,
  1453. -             width,
  1454. -             w,
  1455. -             src_extra,
  1456. -             dst_extra;
  1457. - 
  1458. -         l->position = gd - gdata;
  1459. -         ci = &spf->encoding[ch - firstChar];
  1460. - 
  1461. -         /* ignore missing chars */
  1462. -         if (!ci) 
  1463. -         {
  1464. -         l->length = 0;
  1465. -         l++;
  1466. -         continue;
  1467. -         }
  1468. - 
  1469. -         cim = &ci->metrics;
  1470. - 
  1471. -         /* sanity check */
  1472. -         assert((cim->rightSideBearing - cim->leftSideBearing) <= (pinfo->maxbounds.rightSideBearing - pinfo->minbounds.leftSideBearing));
  1473. - 
  1474. -         srcbpr = GLWIDTHBYTESPADDED(cim->rightSideBearing -
  1475. -                     cim->leftSideBearing, src_glyph_pad);
  1476. - 
  1477. - 
  1478. -         /*
  1479. -          * caculate bytes-per-row for PadNone (others done in allocation
  1480. -          * phase), what (if anything) to ignore or add as padding
  1481. -          */
  1482. -         switch (mappad) {
  1483. -         case BitmapFormatImageRectMin:
  1484. -         bpr = GLYPH_SIZE(ci, scanlinepad);
  1485. -         break;
  1486. -         case BitmapFormatImageRectMax:
  1487. -         /* leave the first padded rows blank */
  1488. -         gd += bpr * (max_ascent - cim->ascent);
  1489. -         skiprows = bpr * (max_descent - cim->descent);
  1490. -         /* fall thru */
  1491. -         case BitmapFormatImageRectMaxWidth:
  1492. -         rshift = cim->leftSideBearing - min_left;
  1493. -         lshift = 8 - lshift;
  1494. -         break;
  1495. -         }
  1496. -         src = (unsigned char *) ci->bits;
  1497. -         dst = gd;
  1498. - 
  1499. -         width = srcbpr;
  1500. -         if (srcbpr > bpr)
  1501. -         width = bpr;
  1502. -         src_extra = srcbpr - width;
  1503. -         dst_extra = bpr - width;
  1504. - 
  1505. - #if (DEFAULTBITORDER == MSBFirst)
  1506. - #define BitLeft(b,c)    ((b) << (c))
  1507. - #define BitRight(b,c)    ((b) >> (c))
  1508. - #else
  1509. - #define BitLeft(b,c)    ((b) >> (c))
  1510. - #define BitRight(b,c)    ((b) << (c))
  1511. - #endif
  1512. - 
  1513. -         if (!rshift)
  1514. -         {
  1515. -         if (srcbpr == bpr)
  1516. -         {
  1517. -             r = (cim->ascent + cim->descent) * width;
  1518. -             bcopy (src, dst, r);
  1519. -             dst += r;
  1520. -         }
  1521. -         else
  1522. -         {
  1523. -             for (r = cim->ascent + cim->descent; r; r--)
  1524. -             {
  1525. -             for (w = width; w; w--)
  1526. -                 *dst++ = *src++;
  1527. -             dst += dst_extra;
  1528. -             src += src_extra;
  1529. -             }
  1530. -         }
  1531. -         }
  1532. -         else
  1533. -         {
  1534. -         for (r = cim->ascent + cim->descent; r; r--)
  1535. -         {
  1536. -             bits2 = 0;
  1537. -             for (w = width; w; w--)
  1538. -             {
  1539. -             bits1 = *src++;
  1540. -             *dst++ = BitRight(bits1, rshift) |
  1541. -                  BitLeft (bits2, lshift);
  1542. -             bits2 = bits1;
  1543. -             }
  1544. -             dst += dst_extra;
  1545. -             src += src_extra;
  1546. -         }
  1547. -         }
  1548. -         dst += skiprows;
  1549. -         l->length = dst - gd;
  1550. -         gd = dst;
  1551. -         l++;
  1552. -     }
  1553. -     }
  1554. - 
  1555. - 
  1556. -     bitorder = (bitorder == BitmapFormatBitOrderLSB) ?
  1557. -     LSBFirst : MSBFirst;
  1558. -     byteorder = (byteorder == BitmapFormatByteOrderLSB) ?
  1559. -     LSBFirst : MSBFirst;
  1560. - 
  1561. -     /* now do the bit, byte, word swapping */
  1562. -     if (bitorder != src_bit_order)
  1563. -     BitOrderInvert(gdata, size);
  1564. -     if (byteorder != src_byte_order) {
  1565. -     if (scanlineunit == 2)
  1566. -         TwoByteSwap(gdata, size);
  1567. -     else if (scanlineunit == 4)
  1568. -         FourByteSwap(gdata, size);
  1569. -     }
  1570. -     *data = gdata;
  1571. -     *tsize = size;
  1572. -     *offsets = lengths;
  1573. - 
  1574. -     return Successful;
  1575. - }
  1576. - 
  1577. - /* ARGSUSED */
  1578. - static int
  1579. - get_sp_bitmaps(client, pfont, format, flags, num_ranges, range,
  1580. -            size, num_glyphs, offsets, data, freeData)
  1581. -     pointer     client;
  1582. -     FontPtr     pfont;
  1583. -     fsBitmapFormat format;
  1584. -     Mask        flags;
  1585. -     unsigned long num_ranges;
  1586. -     fsRange    *range;
  1587. -     unsigned long *size;
  1588. -     unsigned long *num_glyphs;
  1589. -     fsOffset  **offsets;
  1590. -     pointer    *data;
  1591. -     int        *freeData;
  1592. - {
  1593. -     *size = 0;
  1594. -     *data = (pointer) 0;
  1595. -     *num_glyphs = 0;
  1596. -     return pack_sp_glyphs(pfont, format, flags,
  1597. -           num_ranges, range, size, num_glyphs, offsets, data, freeData);
  1598. - }
  1599. - 
  1600. - static int
  1601. X  get_sp_glyphs(pFont, count, chars, charEncoding, glyphCount, glyphs)
  1602. X      FontPtr     pFont;
  1603. X      unsigned long count;
  1604. --- 64,70 ----
  1605. ***************
  1606. *** 626,632 ****
  1607. X  {
  1608. X      SpeedoFontPtr spf;
  1609. X      SpeedoMasterFontPtr spmf;
  1610. -     FontPtr     mpfont;
  1611. X      int         ret;
  1612. X      char        tmpname[MAXFONTNAMELEN];
  1613. X      specs_t     specs;
  1614. --- 241,246 ----
  1615. ***************
  1616. *** 633,660 ****
  1617. X      FontScalableRec vals;
  1618. X      double      pointsize;
  1619. X  
  1620. !     /* make a master if we don't have one */
  1621. !     if (entry) {
  1622. !     mpfont = (FontPtr) entry->u.scalable.extra->private;
  1623. !     if (!mpfont) {
  1624. !         mpfont = (FontPtr) xalloc(sizeof(FontRec));
  1625. !         if (!mpfont)
  1626. !         return AllocError;
  1627. !         flags |= FontLoadBitmaps;    /* make sure a master is all there */
  1628. !         ret = load_sp_font(entry->name.name, filename, (FontEntryPtr) 0,
  1629. !                    format, fmask, mpfont, flags);
  1630. !         if (ret != Successful) {
  1631. !         xfree(mpfont);
  1632. !         return ret;
  1633. !         }
  1634. !         entry->u.scalable.extra->private = (pointer) mpfont;
  1635. !     }
  1636. !     spf = (SpeedoFontPtr) mpfont->fontPrivate;
  1637. !     spmf = spf->master;
  1638. !     } else {
  1639. X      ret = open_master(filename, &spmf);
  1640. X      if (ret != Successful)
  1641. X          return ret;
  1642. X      }
  1643. X  
  1644. X      spf = (SpeedoFontPtr) xalloc(sizeof(SpeedoFontRec));
  1645. --- 247,261 ----
  1646. X      FontScalableRec vals;
  1647. X      double      pointsize;
  1648. X  
  1649. !     /* find a master (create it if necessary) */
  1650. !     spmf = (SpeedoMasterFontPtr) entry->u.scalable.extra->private;
  1651. !     if (!spmf)
  1652. !     {
  1653. X      ret = open_master(filename, &spmf);
  1654. X      if (ret != Successful)
  1655. X          return ret;
  1656. +     entry->u.scalable.extra->private = (pointer) spmf;
  1657. +     spmf->entry = entry;
  1658. X      }
  1659. X  
  1660. X      spf = (SpeedoFontPtr) xalloc(sizeof(SpeedoFontRec));
  1661. ***************
  1662. *** 663,675 ****
  1663. --- 264,281 ----
  1664. X      bzero((char *) spf, sizeof(SpeedoFontRec));
  1665. X  
  1666. X      spf->master = spmf;
  1667. +     spf->entry = entry;
  1668. X      spmf->refcount++;
  1669. X      sp_reset_master(spmf);
  1670. +     /* now we've done enough that if we bail out we must call close_sp_font */
  1671. X  
  1672. X      /* tear apart name to get sizes */
  1673. X      strcpy(tmpname, fontname);
  1674. X      if (!FontParseXLFDName(tmpname, &vals, FONT_XLFD_REPLACE_NONE))
  1675. +     {
  1676. +     close_sp_font(spf);
  1677. X      return BadFontName;
  1678. +     }
  1679. X  
  1680. X      fixup_vals(&vals);
  1681. X      if (vals.point > 0)
  1682. ***************
  1683. *** 697,709 ****
  1684. X      specs.flags = MODE_SCREEN;
  1685. X      specs.out_info = NULL;
  1686. X  
  1687. X      if (!sp_set_specs(&specs))
  1688. X      return BadFontName;
  1689. X  
  1690. X      spf->specs = specs;
  1691. X  
  1692. X      *spfont = spf;
  1693. - 
  1694. X      return Successful;
  1695. X  }
  1696. X  
  1697. --- 303,334 ----
  1698. X      specs.flags = MODE_SCREEN;
  1699. X      specs.out_info = NULL;
  1700. X  
  1701. +     /* When Speedo tries to generate a very small font bitmap, it
  1702. +        often crashes or goes into an infinite loop.
  1703. +        Don't know why this is so, but until we can fix it properly,
  1704. +        return BadFontName for anything smaller than 4 pixels.
  1705. +        */
  1706. + #define TINY_FACTOR (4 << 16)
  1707. +     /* XXX may have to do more tweaking for ROTATED_TEXT */
  1708. +     if (specs.xxmult < TINY_FACTOR  ||  specs.yymult < TINY_FACTOR)
  1709. +     {
  1710. +     close_sp_font(spf);
  1711. +     return BadFontName;
  1712. +     }
  1713. + 
  1714. +     /* clobber global state to avoid wrecking future obliqued fonts */
  1715. +     bzero ((char *) &sp_globals, sizeof(sp_globals));
  1716. + 
  1717. X      if (!sp_set_specs(&specs))
  1718. +     {
  1719. +     close_sp_font(spf);
  1720. X      return BadFontName;
  1721. +     }
  1722. X  
  1723. X      spf->specs = specs;
  1724. +     spf->master = spmf;
  1725. X  
  1726. X      *spfont = spf;
  1727. X      return Successful;
  1728. X  }
  1729. X  
  1730. ***************
  1731. *** 724,729 ****
  1732. --- 349,357 ----
  1733. X  
  1734. X      ret = open_sp_font(fontname, filename, entry, format, fmask, flags, &spf);
  1735. X  
  1736. +     if (ret != Successful)
  1737. +     return ret;
  1738. + 
  1739. X      spmf = spf->master;
  1740. X      sp_reset_master(spmf);
  1741. X      esize = sizeof(CharInfoRec) * (spmf->max_id - spmf->first_char_id + 1);
  1742. ***************
  1743. *** 759,773 ****
  1744. X  
  1745. X      pfont->format = format;
  1746. X  
  1747. -     pfont->get_bitmaps = get_sp_bitmaps;
  1748. X      pfont->get_metrics = get_sp_metrics;
  1749. X      pfont->get_glyphs = get_sp_glyphs;
  1750. -     pfont->get_extents = get_sp_extents;
  1751. X      pfont->unload_font = SpeedoCloseFont;
  1752. X      pfont->refcnt = 0;
  1753. X      pfont->maxPrivate = -1;
  1754. X      pfont->devPrivates = (pointer *) 0;
  1755. X  
  1756. X      close_master_file(spmf);
  1757. X  
  1758. X      return ret;
  1759. --- 387,400 ----
  1760. X  
  1761. X      pfont->format = format;
  1762. X  
  1763. X      pfont->get_metrics = get_sp_metrics;
  1764. X      pfont->get_glyphs = get_sp_glyphs;
  1765. X      pfont->unload_font = SpeedoCloseFont;
  1766. X      pfont->refcnt = 0;
  1767. X      pfont->maxPrivate = -1;
  1768. X      pfont->devPrivates = (pointer *) 0;
  1769. X  
  1770. +     /* have to hold on to master for min/max id */
  1771. X      close_master_file(spmf);
  1772. X  
  1773. X      return ret;
  1774. ***************
  1775. *** 794,800 ****
  1776. X  
  1777. X      if (ret == Successful)
  1778. X      *ppfont = pfont;
  1779. ! 
  1780. X      return ret;
  1781. X  }
  1782. X  
  1783. --- 421,429 ----
  1784. X  
  1785. X      if (ret == Successful)
  1786. X      *ppfont = pfont;
  1787. !     else
  1788. !     xfree (pfont);
  1789. !     
  1790. X      return ret;
  1791. X  }
  1792. X  
  1793. ***************
  1794. *** 805,817 ****
  1795. X      SpeedoMasterFontPtr spmf;
  1796. X  
  1797. X      spmf = spf->master;
  1798. !     if (--spmf->refcount == 0) {
  1799. !     if (spmf->state & MasterFileOpen) {
  1800. !         (void) fclose(spmf->fp);
  1801. !         xfree(spmf->f_buffer);
  1802. !         xfree(spmf->c_buffer);
  1803. !     }
  1804. !     }
  1805. X      xfree(spf->encoding);
  1806. X      xfree(spf->bitmaps);
  1807. X      xfree(spf);
  1808. --- 434,442 ----
  1809. X      SpeedoMasterFontPtr spmf;
  1810. X  
  1811. X      spmf = spf->master;
  1812. !     --spmf->refcount;
  1813. !     if (spmf->refcount == 0)
  1814. !     close_master_font (spmf);
  1815. X      xfree(spf->encoding);
  1816. X      xfree(spf->bitmaps);
  1817. X      xfree(spf);
  1818. *** /tmp/da11514    Mon Jul 20 16:43:06 1992
  1819. --- mit/fonts/lib/font/Speedo/spfuncs.c    Mon Jul 20 16:43:06 1992
  1820. ***************
  1821. *** 1,4 ****
  1822. ! /* $XConsortium: spfuncs.c,v 1.5 91/09/16 11:42:30 keith Exp $ */
  1823. X  /*
  1824. X   * Copyright 1990, 1991 Network Computing Devices;
  1825. X   * Portions Copyright 1987 by Digital Equipment Corporation and the
  1826. --- 1,4 ----
  1827. ! /* $XConsortium: spfuncs.c,v 1.7 92/04/15 14:35:48 gildea Exp $ */
  1828. X  /*
  1829. X   * Copyright 1990, 1991 Network Computing Devices;
  1830. X   * Portions Copyright 1987 by Digital Equipment Corporation and the
  1831. ***************
  1832. *** 22,30 ****
  1833. X   * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  1834. X   *
  1835. X   * Author: Dave Lemke, Network Computing Devices, Inc
  1836. -  *
  1837. -  * $NCDId: @(#)spfuncs.c,v 4.8 1991/07/02 17:01:44 lemke Exp $
  1838. -  *
  1839. X   */
  1840. X  
  1841. X  #include    <X11/Xos.h>
  1842. --- 22,27 ----
  1843. ***************
  1844. *** 72,79 ****
  1845. X  
  1846. X      err = open_sp_font(fontname, filename, entry,
  1847. X             (fsBitmapFormat) 0, (fsBitmapFormatMask) 0, (unsigned long) 0,
  1848. !                spfont);
  1849. !     spf = *spfont;
  1850. X  
  1851. X      if (err != Successful)
  1852. X      return err;
  1853. --- 69,75 ----
  1854. X  
  1855. X      err = open_sp_font(fontname, filename, entry,
  1856. X             (fsBitmapFormat) 0, (fsBitmapFormatMask) 0, (unsigned long) 0,
  1857. !                &spf);
  1858. X  
  1859. X      if (err != Successful)
  1860. X      return err;
  1861. ***************
  1862. *** 90,95 ****
  1863. SHAR_EOF
  1864. true || echo 'restore of fix-13 failed'
  1865. fi
  1866. echo 'End of  part 2'
  1867. echo 'File fix-13 is continued in part 3'
  1868. echo 3 > _shar_seq_.tmp
  1869. exit 0
  1870. -- 
  1871. ---
  1872. Senior Systems Scientist        mail: dcmartin@msi.com
  1873. Molecular Simulations, Inc.        uucp: uunet!dcmartin
  1874. 796 North Pastoria Avenue        at&t: 408/522-9236
  1875.