diff options
Diffstat (limited to 'Build/source/texk/web2c/omegafonts/header_routines.c')
-rw-r--r-- | Build/source/texk/web2c/omegafonts/header_routines.c | 651 |
1 files changed, 651 insertions, 0 deletions
diff --git a/Build/source/texk/web2c/omegafonts/header_routines.c b/Build/source/texk/web2c/omegafonts/header_routines.c new file mode 100644 index 00000000000..48e3ef00ec6 --- /dev/null +++ b/Build/source/texk/web2c/omegafonts/header_routines.c @@ -0,0 +1,651 @@ +/* header_routines.c: Headers of font metric files. + +This file is part of Omega, +which is based on the web2c distribution of TeX, + +Copyright (c) 1994--2001 John Plaice and Yannis Haralambous + +Omega is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +Omega is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with Omega; if not, write to the Free Software Foundation, Inc., +59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + +*/ + +#include "cpascal.h" +#include "list_routines.h" +#include "manifests.h" +#include "header_routines.h" +#include "print_routines.h" +#include "error_routines.h" +#include "out_ofm.h" +#include "omfonts.h" + +#define LOC_CHECK_SUM 0 +#define LOC_DESIGN_SIZE 4 +#define LOC_CODING_SCHEME 8 +#define LOC_FAMILY (LOC_CODING_SCHEME+LEN_CODING_SCHEME+1) +#define LOC_SEVEN_FLAG (LOC_FAMILY+LEN_FAMILY+1) +#define LOC_FACE (LOC_SEVEN_FLAG+3) + +#define HEADER_MIN 18 +#define HEADER_MAX 255 + + +string header; +av_list header_list = NULL; +unsigned header_max = HEADER_MIN-1; + +unsigned check_sum; +boolean check_sum_specified; + +fix design_size; +boolean design_size_specified; + +fix design_units; +boolean design_units_specified; + +string coding_scheme; +boolean coding_scheme_specified; + +string family; +boolean family_specified; + +unsigned face; +boolean face_specified; + +unsigned ofm_level; +boolean ofm_level_specified; + +unsigned font_dir; +boolean font_dir_specified; + +boolean seven_bit; +boolean seven_bit_specified; +boolean seven_bit_calculated; + +unsigned font_type = FT_VANILLA; + +unsigned lh; + +void +store_header_int(unsigned loc, unsigned val) +{ + header[loc] = 0xff & (val >> 24) ; + header[loc+1] = 0xff & (val >> 16) ; + header[loc+2] = 0xff & (val >> 8) ; + header[loc+3] = 0xff & val ; +} + +void +store_header_byte(unsigned loc, unsigned val) +{ + header[loc] = 0xff & val ; +} + +void +retrieve_header_int(unsigned loc, unsigned *where) +{ + string ptr = header+loc; + + *where = ((* ptr & 0xff) << 24) | + ((*(ptr+1) & 0xff) << 16) | + ((*(ptr+2) & 0xff) << 8) | + (*(ptr+3) & 0xff) ; + +} + +void +retrieve_header_byte(unsigned loc, unsigned char *where) +{ + *where = header[loc]; +} + +/* HEADER */ + +void +init_header_word() +{ +header_list = NULL; +header_max = HEADER_MIN-1; +font_type = FT_VANILLA; +} + +void +set_header_word(unsigned index, unsigned val) +{ + av_list L1, L2; + + if (index > HEADER_MAX) { + warning_0("HEADER index must be at most 255; ignored"); + return; + } + if (index < HEADER_MIN) { + warning_0("HEADER index must be at least 18; ignored"); + return; + } + L1 = header_list; + if (L1 == NULL) { + header_list = av_list1(index, val); + header_max = index; + } else { + L2 = L1->ptr; + while ((L2 != NULL) && (lattr(L2) <= index)) { + L1 = L2; + L2 = L2->ptr; + } + if (index < lattr(L1)) { + header_list = av_list1(index, val); + header_list->ptr = L1; + } else if (index == lattr(L1)) { + warning_1("HEADER index (%d) previously defined; " + "old value ignored", index); + lval(L1) = val; + } else { + L2 = av_list1(index, val); + L2->ptr = L1->ptr; + if (L1->ptr==NULL) header_max = index; + L1->ptr = L2; + } + } +} + +void +store_header_word() +{ + av_list L = header_list; + unsigned ctr = HEADER_MIN; + + header = (string) xmalloc(4*(header_max+1)); + while (L != NULL) { + while (ctr<lattr(L)) { + store_header_int(ctr*4,0); + ctr++; + } + store_header_int(ctr*4,lval(L)); + ctr++; L = L->ptr; + } +} + +void +retrieve_header_word() +{ + unsigned j = HEADER_MIN, value, header_no=lh; + + header_list = NULL; + while (j <= header_no) { + retrieve_header_int(j*4, &value); + if (value != 0) { + set_header_word(j, value); + } + j++; + } +} + +void +print_header(void) +{ + av_list L = header_list; + + print_check_sum(); + print_design_size(); + print_coding_scheme(); + print_family(); + print_face(); + print_seven_bit_safe_flag(); + while (L!=NULL) { + print_header_word(lattr(L),lval(L)); + L = L->ptr; + } +} + +/* CHECKSUM */ + +void +init_check_sum(void) +{ + check_sum = 0; + check_sum_specified = FALSE; +} + +void +set_check_sum(unsigned cs) +{ + check_sum = cs; + check_sum_specified = TRUE; +} + +void +store_check_sum(void) +{ + + calculate_check_sum(); + store_header_int(LOC_CHECK_SUM, check_sum); +} + +void +retrieve_check_sum(void) +{ + retrieve_header_int(LOC_CHECK_SUM, &check_sum); +} + +void +calculate_check_sum(void) +{ +/* + if (check_sum_specified == FALSE) { + not_yet_done("checksum calculation"); + } +*/ +} + + +/* DESIGNSIZE */ + +void +init_design_size() +{ + design_size = 10*UNITY; + design_size_specified = FALSE; +} + +void +set_design_size(fix ds) +{ + if (design_size_specified==TRUE) + warning_0("DESIGNSIZE previously defined; old value ignored"); + if (ds<1) { + warning_0("DESIGNSIZE value must be at least 1; set to 10"); + design_size = 10*UNITY; + } else { + design_size = ds; + } + design_size_specified = TRUE; +} + +void +store_design_size(void) +{ + store_header_int(LOC_DESIGN_SIZE, design_size); +} + +void +retrieve_design_size(void) +{ + retrieve_header_int(LOC_DESIGN_SIZE, (unsigned *) &design_size); +} + + +/* DESIGNUNITS */ + +void +init_design_units(void) +{ + design_units = UNITY; + design_units_specified = FALSE; +} + +void +set_design_units(fix du) +{ + if (design_units_specified==TRUE) + warning_0("DESIGNUNITS previously defined; old value ignored"); + if (du<=0) { + warning_0("DESIGNUNITS value must be positive; set to 1"); + design_units = UNITY; + } else { + design_units = du; + } + design_units_specified = TRUE; +} + + +/* CODINGSCHEME */ + +void +init_coding_scheme(void) +{ + coding_scheme = "UNSPECIFIED"; + coding_scheme_specified = FALSE; +} + +void +set_coding_scheme(string sval) +{ + if (coding_scheme_specified==TRUE) { + warning_0("CODINGSCHEME previously defined; old value ignored"); + free(coding_scheme); coding_scheme=NULL; + } + coding_scheme = sval; + + if (!strncmp(coding_scheme, "TEX MATH SY", 11) || + !strncmp(coding_scheme, "TeX math sy", 11)) + font_type = FT_MATHSY; + else if (!strncmp(coding_scheme, "TEX MATH EX", 11) || + !strncmp(coding_scheme, "TeX math ex", 11)) + font_type = FT_MATHEX; + else font_type = FT_VANILLA; + + coding_scheme_specified = TRUE; +} + +void +store_coding_scheme(void) +{ + register unsigned i=0, j=LOC_CODING_SCHEME, len=strlen(coding_scheme); + + header[j] = len; + for (j++; i<len; i++,j++) header[j] = coding_scheme[i]; + for (; j<(LOC_CODING_SCHEME+LEN_CODING_SCHEME); j++) + header[j] = '\0';; +} + + +void +retrieve_coding_scheme(void) +{ + register unsigned i=0, j=LOC_CODING_SCHEME, len=header[LOC_CODING_SCHEME]; + + coding_scheme = (string) xmalloc(len+1); + for (j++; i<len; i++,j++) { + coding_scheme[i] = header[j]; + if ((text_format == TEXT_CODE_UPPER) && + (coding_scheme[i] >= 'a') && + (coding_scheme[i] <= 'z')) { + coding_scheme[i] += 'A' - 'a'; + } + } + coding_scheme[i] = '\0'; + if (!strncmp(coding_scheme, "TEX MATH SY", 11) || + !strncmp(coding_scheme, "TeX math sy", 11)) + font_type = FT_MATHSY; + else if (!strncmp(coding_scheme, "TEX MATH EX", 11) || + !strncmp(coding_scheme, "TeX math ex", 11)) + font_type = FT_MATHEX; + else font_type = FT_VANILLA; +} + +/* FAMILY */ + +void +init_family(void) +{ + family = "UNSPECIFIED"; + family_specified = FALSE; +} + +void +set_family(string sval) +{ + if (family_specified==TRUE) { + warning_0("FAMILY previously defined; old value ignored"); + free(family); family=NULL; + } + family = sval; + family_specified = TRUE; +} + +void +store_family(void) +{ + register unsigned i=0, j=LOC_FAMILY, len=strlen(family); + + if (len>LEN_FAMILY) internal_error_1("store_family (len=%d)", len); + header[j] = len; + for (j++; i<len; i++,j++) header[j] = family[i]; + for (; j<=(LOC_FAMILY+LEN_FAMILY); j++) + header[j] = '\0';; +} + + +void +retrieve_family(void) +{ + register unsigned i=0, j=LOC_FAMILY, len=header[LOC_FAMILY]; + + family = (string) xmalloc(len+1); + for (j++; i<len; i++,j++) { + family[i] = header[j]; + if ((text_format == TEXT_CODE_UPPER) && + (family[i] >= 'a') && + (family[i] <= 'z')) { + family[i] += 'A' - 'a'; + } + } + family[i] = '\0'; +} + +/* FACE */ + +void +init_face() +{ + face = 0; + face_specified = FALSE; +} + +void +set_face(unsigned f) +{ + if (face_specified==TRUE) + warning_0("FACE previously defined; old value ignored"); + if (face>255) { + warning_0("FACE value must be less than 256"); + } else { + face = f; + } + face_specified = TRUE; +} + +void +store_face(void) +{ + store_header_byte(LOC_FACE, face); +} + +void +retrieve_face(void) +{ + unsigned char face_byte; + retrieve_header_byte(LOC_FACE, &face_byte); + face = face_byte; +} + +/* OFMLEVEL */ + +void +init_ofm_level() +{ + ofm_level = OFM_TFM; + ofm_level_specified = FALSE; +} + +void +set_ofm_level(unsigned level) +{ + if (ofm_level_specified==TRUE) + warning_0("OFMLEVEL previously defined; old value ignored"); + /* Fix from Joel Riou <joel.riou@normalesup.org> */ + if ((level != 0) && (level != 1)) { + warning_0("OFMLEVEL value must be D 0 or D 1"); + } else { + ofm_level = level ? OFM_LEVEL1 : OFM_LEVEL0; + } + ofm_level_specified = TRUE; +} + +/* FONTDIR */ + +void +init_font_dir() +{ + font_dir = DIR_ORD+DIR_TL; + font_dir_specified = FALSE; +} + +void +set_font_dir(unsigned direction) +{ + if (font_dir_specified==TRUE) + warning_0("FONTDIR previously defined; old value ignored"); + if ((direction < DIR_MIN) || (direction > DIR_MAX)) { + warning_0("bad FONTDIR value; ignored"); + } else { + font_dir = direction; + } + font_dir_specified = TRUE; +} + +/* SEVENBITSAFEFLAG */ + +void +init_seven_bit_safe_flag() +{ + seven_bit = 0; + seven_bit_calculated = 1; + seven_bit_specified = FALSE; +} + +void +set_seven_bit_safe_flag(unsigned f) +{ + if (seven_bit_specified==TRUE) + warning_0("SEVENBITSAFEFLAG previously defined; " + "old value ignored"); + if ((f!=FALSE) && (f!=TRUE)) { + internal_error_1("set_seven_bit_safe_flag (f=%d)", f); + } + seven_bit = f; + seven_bit_specified = TRUE; +} + +void +store_seven_bit_safe_flag(void) +{ + store_header_byte(LOC_SEVEN_FLAG, seven_bit); +} + +void +retrieve_seven_bit_safe_flag(void) +{ + unsigned char seven_bit_byte; + retrieve_header_byte(LOC_SEVEN_FLAG, &seven_bit_byte); + seven_bit = (seven_bit_byte != 0); +} + +void +calculate_seven_bit_safe_flag(void) +{ + if ((seven_bit_specified == TRUE) && (seven_bit == 1) && + (seven_bit_calculated == 0)) { + warning_0("SEVENBITSAFEFLAG value specified TRUE; " + "really FALSE"); + } + seven_bit = seven_bit_calculated; +} + +void +init_header(void) +{ + init_header_word(); + init_check_sum(); + init_design_size(); + init_design_units(); + init_coding_scheme(); + init_family(); + init_face(); + init_seven_bit_safe_flag(); +} + +void +store_header(void) +{ + + store_header_word(); + store_check_sum(); + store_design_size(); + store_coding_scheme(); + store_family(); + store_face(); + store_seven_bit_safe_flag(); + +/* + { int i; + for (i=0; i<(4*(header_max+1)); i++) { + if (!(i%4)) fprintf(stdout, "\n"); + fprintf(stdout, "%d: %c (%d, %2x) ", + i, header[i], header[i], header[i]); + } + fprintf(stdout, "\n"); +*/ + if (header_list!=NULL) { + av_list L1 = header_list, L2; + while (L1 != NULL) { + L2 = L1->ptr; + free(L1); + L1 = L2; + } + } + lh = header_max; + header_list = NULL; + header_max = HEADER_MIN-1; + + retrieve_header(); +} + +void +retrieve_header(void) +{ + retrieve_header_word(); + retrieve_check_sum(); + retrieve_design_size(); + retrieve_coding_scheme(); + retrieve_family(); + retrieve_face(); + retrieve_seven_bit_safe_flag(); +} + +void +output_ofm_header(void) +{ + unsigned i=0, j, k1, k2; + + av_list L = header_list; + + out_ofm_4(check_sum); i++; + out_ofm_4(design_size); i++; + k1 = strlen(coding_scheme); + out_ofm(k1); + for (j=0; j<k1; j++) out_ofm(coding_scheme[j]); + for (j=k1; j<LEN_CODING_SCHEME; j++) out_ofm(0); + k2 = strlen(family); + out_ofm(k2); + for (j=0; j<k2; j++) out_ofm(family[j]); + for (j=k2; j<LEN_FAMILY; j++) out_ofm(0); + if ((ofm_level==OFM_TFM) && (seven_bit_specified==TRUE)) + out_ofm(seven_bit); + else + out_ofm(0); + out_ofm(0); out_ofm(0); out_ofm(face); + i = 1 + LOC_SEVEN_FLAG / 4; + lh = header_max + 1; + while(L != NULL) { + j=lattr(L); + while (i<j) { + out_ofm_4(0); + i++; + } + out_ofm_4(lval(L)); + L = L->ptr; i++; + } + while (i<lh) {out_ofm_4(0); i++;} +} |