File indexing completed on 2024-05-12 04:34:00

 // -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; c-brace-offset: 0; -*-
 /*
  * SPDX-FileCopyrightText: 1994 Paul Vojta. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <config.h>
 
 #include "debug_dvi.h"
 #include "dvi.h"
 #include "dviRenderer.h"
 #include "xdvi.h"
 
 #include <KLocalizedString>
 
 #include <cstdlib>
 #include <cstring>
 
 extern void oops(const QString &message);
 
 /***
  ***   VF font reading routines.
  ***   Public routine is read_index---because virtual characters are presumed
  ***   to be short, we read the whole virtual font in at once, instead of
  ***   faulting in characters as needed.
  ***/
 
 #define LONG_CHAR 242
 
 /*
  *  These are parameters which determine whether macros are combined for
  *  storage allocation purposes.  Small macros ( <= VF_PARM_1 bytes) are
  *  combined into chunks of size VF_PARM_2.
  */
 
 #ifndef VF_PARM_1
 #define VF_PARM_1 20
 #endif
 #ifndef VF_PARM_2
 #define VF_PARM_2 256
 #endif
 
 /*
  *  The main routine
  */
 
 void TeXFontDefinition::read_VF_index()
 {
 #ifdef DEBUG_FONTS
     qCDebug(OkularDviDebug) << "font::read_VF_index()";
 #endif
     FILE *VF_file = file;
     unsigned char cmnd;
     // available space for macros
     unsigned char *avail, *availend;
 
     flags |= FONT_VIRTUAL;
     set_char_p = &dviRenderer::set_vf_char;
 #ifdef DEBUG_FONTS
     qCDebug(OkularDviDebug) << "TeXFontDefinition::read_VF_index: reading VF pixel file " << filename;
 #endif
     // Read preamble.
     fseek(VF_file, (long)one(VF_file), 1); /* skip comment */
     quint32 const file_checksum = four(VF_file);
 
     if (file_checksum && checksum && file_checksum != checksum) {
         qCCritical(OkularDviDebug) << "Checksum mismatch dvi = " << checksum << "u, vf = " << file_checksum << "u) in font file" << filename;
     }
     (void)four(VF_file); /* skip design size */
 
     // Read the fonts.
     first_font = nullptr;
     while ((cmnd = one(VF_file)) >= FNTDEF1 && cmnd <= FNTDEF4) {
         int TeXnumber = num(VF_file, (int)cmnd - FNTDEF1 + 1);
         quint32 checksum = four(VF_file);
         quint32 scale = four(VF_file);
         quint32 design = four(VF_file);
         Q_UNUSED(design);
         quint16 len = one(VF_file) + one(VF_file); /* sequence point in the middle */
         char *fontname = new char[len + 1];
         fread(fontname, sizeof(char), len, VF_file);
         fontname[len] = '\0';
 
 #ifdef DEBUG_FONTS
         qCDebug(OkularDviDebug) << "Virtual font defines subfont \"" << fontname << "\" scale=" << scale << " design=" << design;
 #endif
 
         // According to Knuth's documentation found in the web source code
         // of the "vftovp" program (which seems to be the standard
         // definition of virtual fonts), the "scale" is a fixed point
         // number which describes extra enlargement that the virtual font
         // imposes. One obtains the enlargement by dividing 2^20.
         double enlargement_factor = double(scale) / (1 << 20) * enlargement;
 
         //    TeXFontDefinition *newfontp = font_pool->appendx(fontname, checksum, (quint32)(scaled_size_in_DVI_units*enlargement_factor), enlargement_factor);
         TeXFontDefinition *newfontp = font_pool->appendx(QString::fromLocal8Bit(fontname), checksum, (quint32)((double(scale) / (1 << 20)) * scaled_size_in_DVI_units), enlargement_factor);
 
         // Insert font in dictionary and make sure the dictionary is big
         // enough.
         if (vf_table.capacity() - 2 <= vf_table.count()) {
             // Not quite optimal. The size of the dictionary should be a
             // prime. I don't care.
             vf_table.reserve(vf_table.capacity() * 2);
         }
         vf_table.insert(TeXnumber, newfontp);
 
         if (first_font == nullptr) {
             first_font = newfontp;
         }
     }
 
     // Prepare macro array.
     macrotable = new macro[max_num_of_chars_in_font];
     if (macrotable == nullptr) {
         qCCritical(OkularDviDebug) << "Could not allocate memory for a macro table.";
         exit(0);
     }
 
     // Read macros.
     avail = availend = nullptr;
     for (; cmnd <= LONG_CHAR; cmnd = one(VF_file)) {
         macro *m;
         int len;
         unsigned long cc;
         long width;
 
         if (cmnd == LONG_CHAR) { /* long form packet */
             len = four(VF_file);
             cc = four(VF_file);
             width = four(VF_file);
             if (cc >= 256) {
                 qCCritical(OkularDviDebug) << "Virtual character" << cc << "in font" << fontname << "ignored.";
                 fseek(VF_file, (long)len, 1);
                 continue;
             }
         } else { /* short form packet */
             len = cmnd;
             cc = one(VF_file);
             width = num(VF_file, 3);
         }
         m = &macrotable[cc];
 
         m->dvi_advance_in_units_of_design_size_by_2e20 = width;
         if (len > 0) {
             if (len <= availend - avail) {
                 m->pos = avail;
                 avail += len;
             } else {
                 m->free_me = true;
                 if (len <= VF_PARM_1) {
                     m->pos = avail = new unsigned char[VF_PARM_2];
                     availend = avail + VF_PARM_2;
                     avail += len;
                 } else {
                     m->pos = new unsigned char[len];
                 }
             }
             fread((char *)m->pos, 1, len, VF_file);
             m->end = m->pos + len;
         }
     }
     if (cmnd != POST) {
         oops(i18n("Wrong command byte found in VF macro list: %1", cmnd));
     }
 
     fclose(VF_file);
     file = nullptr;
 }