ATM1.C

Go to the documentation of this file.

/* --
OpenFX version 1.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 OpenFX Development Team

This program 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.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You may contact the OpenFX development team via elecronic mail
at core@openfx.org, or visit our website at http://openfx.org for
further information and support details.
-- */

/* file ATM1.C   ATM descryption  */


/* decryption stuff */
static unsigned short chs_er, chs_cr;
static unsigned short c1 = 52845, c2 = 22719;
static char *key = "currentfile eexec\n";
static point PP[4];

/* local variables that must be initialized for each font reading */
static char *p_key = 0;
static int first_byte = 1;
static int is_pfa = 0;
static int is_pfb = 0;
static int pfb_remaining = 0;
static int reported = 0;
static int in_eexec = 0;
static int start = 1;
static int start_charstring = 0,in_charstring=0;
static int lenIV = 4;
static int in_EncodingArray = 0;
static int in_Subroutines = 0,n_Subroutines=0,i_Subroutine;
static int StandardEncoding = 0;
/* the program subroutines and the program itself */
static character_program *C_Subs,Cprogram;

static int eexec_scanner(char c){
/* This function looks for `currentfile eexec' string and returns 1 once found.
   If c == 0, then simply check the status. */
  if (!p_key)
    p_key = key;
  if (c && *p_key) {
    if (c == *p_key)
      ++p_key;
    else
      p_key = key;
  }
  return *p_key == '\0';
}

/* This function returns the value of a single hex digit. */

static int hexval(char c){
  if (c >= 'A' && c <= 'F')
    return c - 'A' + 10;
  else if (c >= 'a' && c <= 'f')
    return c - 'a' + 10;
  else if (c >= '0' && c <= '9')
    return c - '0';
  else
    return 0;
}

/* This function returns a single character at a time from a PFA or PFB file.
   This stream is mixed ASCII and binary bytes.  For PFB files, the section
   headers are removed, and \r is replaced by \n in ASCII sections.  For PFA
   files, the hexdecimal data is turned into binary bytes. */

static int bgetc(void){
  int c, val;
/* is_pfa == 1 means PFA initial ASCII section
   is_pfa == 2 means PFA hexadecimal section
   is_pfb == 1 means PFB ASCII section
   is_pfB == 2 means PFB binary section */
  c = fgetc(ifp);
  if (c == EOF)
    return EOF;
  if (first_byte) {
    /* Determine if this is a PFA or PFB file by looking at first byte. */
    if (c == 0x80) {
      is_pfb = 1;
      is_pfa = 0;
    } else {
      is_pfb = 0;
      is_pfa = 1;
    }
    first_byte = 0;
  }
  if (is_pfb) {
    /* PFB */
    if (pfb_remaining == 0) {
      /* beginning of block---we know c == 0x80 at this point */
      switch (fgetc(ifp)) {
      case 1:
        is_pfb = 1;
        break;
      case 2:
        is_pfb = 2;
        break;
      case 3:
        return EOF;
      default:
        PS_fail = 1;
        return EOF;
      }
      /* get block length */
      pfb_remaining = fgetc(ifp) & 0xff;
      pfb_remaining |= (fgetc(ifp) & 0xff) << 8;
      pfb_remaining |= (fgetc(ifp) & 0xff) << 16;
      pfb_remaining |= (fgetc(ifp) & 0xff) << 24;
      /* get character */
      c = fgetc(ifp);
      if (c == EOF)return EOF;
    }
    --pfb_remaining;
    /* in ASCII section change return to newline */
    if (is_pfb == 1 && c == '\r')
      c = '\n';
    (void)eexec_scanner(c);
    return c;
  } else {
    /* PFA */
    if (is_pfa == 1) {
      /* in initial ASCII */
      if (eexec_scanner(c))is_pfa = 2;
      return c;
    } else {
      /* in hexadecimal */
      while (isspace(c))c = fgetc(ifp);
      val = hexval((char)c) << 4;
      val |= hexval((char)(c = fgetc(ifp)));
      if (c == EOF)return EOF;
      return val;
    }
  }
}

/* Two separate decryption functions because eexec and charstring decryption
   must proceed in parallel. */

static byte edecrypt(byte cipher){
  byte plain;
  plain = (cipher ^ (chs_er >> 8));
  chs_er = (cipher + chs_er) * c1 + c2;
  return plain;
}

static byte cdecrypt(byte cipher){
  byte plain;
  plain = (cipher ^ (chs_cr >> 8));
  chs_cr = (cipher + chs_cr) * c1 + c2;
  return plain;
}

/* This function returns 1 the first time the eexec_scanner returns 1. */

static int immediate_eexec(void){
  if (!reported && eexec_scanner(0)) {
    reported = 1;
    return 1;
  } else {
    return 0;
  }
}

/* This function returns a single byte at a time through (possible) eexec
   decryption.  When immediate_eexec returns 1 it fires up the eexec decryption
   machinery. */

static int egetc(void){
  int c;
  if ((c = bgetc()) == EOF)return EOF;
  if (!in_eexec) {
    if (immediate_eexec()) {
      /* start eexec decryption */
      in_eexec = 1;
      chs_er = 55665;
      /* toss out four random bytes */
      (void) edecrypt(bgetc());
      (void) edecrypt(bgetc());
      (void) edecrypt(bgetc());
      (void) edecrypt(bgetc());
    }
    return c;
  } else {
    return edecrypt(c);
  }
}

/* This function returns a line of eexec decrypted characters.  A line is
   terminated by length (including terminating null) greater than LINESIZE, a
   newline \n, or one of the special charstring start sequences ` -| ' or
   ` RD '.  The line, including the terminating newline or charstring start
   sequence is put into load_line[].  If terminated by a charstring start sequence,
   the flag start_charstring is set to 1. */

static void egetline(void){
  int c;
  char *p = load_line;
  start_charstring = 0;
  while (p < load_line + LINESIZE) {
    c = egetc();
    if (c == EOF)
      break;
    *p++ = (char) c;
    if (p >= load_line + 4 && (strncmp(p - 4, " -| ", 4) == 0 ||
             strncmp(p - 4, " RD ", 4) == 0)) {
      p -= 4;
      start_charstring = 1;
      break;
    }
    if(!in_eexec){ /* in ASCII part check for Encoding names */
      if (p >= load_line + 5 && (strncmp(p-5," put ",5) == 0 )){
        p[-1]='\n';
        break;
      }
    }
    if (c == '\r') {      /* map \r to \n */
      p[-1] = '\n';
      break;
    }
    if (c == '\n')
      break;
  }
  *p = '\0';
}

/* If the line contains an entry of the form `/lenIV <num>' then set the global
   lenIV to <num>.  This indicates the number of random bytes at the beginning
   of each charstring. */

static void set_lenIV(void){
  char *p = strstr(load_line, "/lenIV ");
  if (p && isdigit(p[7])) {
    lenIV = atoi(p + 7);
  }
}

static void output_token(char *token){
#if 0
  if(in_Subroutines)return;
  if (strcmp(token, "\n") == 0) {
    fprintf(debug, "\n");
    start = 1;
  } else {
    fprintf(debug, "%s%s", start ? "\t" : " ", token);
    start = 0;
  }
#endif
}

static short add_build_command(int b, int com){ /* com = 1 for command */
  int i,j;
  two_integers *ip;
  if(in_Subroutines){
    if((i=i_Subroutine) < 0 || i >= n_Subroutines)return MEMFAIL;
    if(C_Subs[i].p == NULL){
      if((ip = (two_integers *)X__Malloc((C_Subs[i].n+1)*
               sizeof(two_integers))) == NULL)
        return MEMFAIL;
    }
    else{
      if((ip = (two_integers *)X__Realloc(C_Subs[i].p,(C_Subs[i].n+1)*
               sizeof(two_integers))) == NULL)
        return MEMFAIL;
    }
    j=C_Subs[i].n;
    ip[j].i=(short)b; ip[j].com=(short)com;
    C_Subs[i].n++;
    C_Subs[i].p=ip;
  }
  else{
    if(Cprogram.p == NULL){
      if((ip = (two_integers *)X__Malloc((Cprogram.n+1)*
               sizeof(two_integers))) == NULL)
        return MEMFAIL;
    }
    else{
      if((ip = (two_integers *)X__Realloc(Cprogram.p,(Cprogram.n+1)*
               sizeof(two_integers))) == NULL)
        return MEMFAIL;
    }
    j=Cprogram.n;
    ip[j].i=(short)b; ip[j].com=(short)com;
    Cprogram.n++;
    Cprogram.p=ip;
  }
  return OK;
}

/* Subroutine to decrypt and ASCII-ify tokens in charstring data.  First, the
   length (in bytes) of the charstring is determined from load_line[].  Then the
   charstring decryption machinery is fired up, skipping the first lenIV bytes.
   Finally, the decrypted tokens are expanded into human-readable form. */

static short do_charstring(void){
  int l = strlen(load_line);
  char *p = load_line + l - 1;
  int cs_len;
  int i;
  int b, val;
  char buf[20];
  while (p >= load_line && *p != ' ' && *p != '\t') --p;
  cs_len = atoi(p);
  /* skip this character if it is not the one we want */
  /* or is not in the charstring or subroutine */
  /* this hopefully fixes a problem wit COO font which has 2 sets of
     subroutines - it does it by only trying to find the character
     once in_charstrings is TRUE */
  if((in_charstring && strcmp(this_character,character_name) != 0) ||
     (!in_charstring && !in_Subroutines)){
    while (cs_len > 0) { --cs_len; b = cgetc(); }
    return 0;
  }
  *p = '\0';
  chs_cr = 4330;
  for (i = 0; i < lenIV; i++, cs_len--) (void) cgetc();
  while (cs_len > 0) {
    --cs_len;
    b = cgetc();
    if (b >= 32) {
      if (b >= 32 && b <= 246) {
        val = b - 139;
      } else if (b >= 247 && b <= 250) {
        --cs_len;
        val = (b - 247)*256 + 108 + cgetc();
      } else if (b >= 251 && b <= 254) {
        --cs_len;
        val = -(b - 251)*256 - 108 - cgetc();
      } else if (b == 255) {
        cs_len -= 4;
        val =  (cgetc() & 0xff) << 24;
        val |= (cgetc() & 0xff) << 16;
        val |= (cgetc() & 0xff) <<  8;
        val |= (cgetc() & 0xff) <<  0;
        /* in case an int is larger than four bytes---sign extend */
        if (sizeof(int) > 4 && val & (1U << 31))
          for (i = 4; i < sizeof(int); i++)
          val |= 0xff << (i * 8);
      }
      if(add_build_command(val,0) != OK)return MEMFAIL;
      sprintf(buf, "%d", val); output_token(buf);
    }
    else {
      if(add_build_command(b,1) != OK)return MEMFAIL;
      switch (b) {
        case 1: output_token("hstem"); break;
        case 3: output_token("vstem"); break;
        case 4: output_token("vmoveto"); break;
        case 5: output_token("rlineto"); break;
        case 6: output_token("hlineto"); break;
        case 7: output_token("vlineto"); break;
        case 8: output_token("rrcurveto"); break;
        case 9: output_token("closepath"); break;
        case 10: output_token("callsubr"); break;
        case 11: output_token("return"); break;
        case 13: output_token("hsbw"); break;
        case 14: output_token("endchar"); break;
        case 21: output_token("rmoveto"); break;
        case 22: output_token("hmoveto"); break;
        case 30: output_token("vhcurveto"); break;
        case 31: output_token("hvcurveto"); break;
        case 12:
          --cs_len;
          b = cgetc();
          if(add_build_command(b,1) != OK)return MEMFAIL;
          switch (b) {
            case 0: output_token("dotsection"); break;
            case 1: output_token("vstem3"); break;
            case 2: output_token("hstem3"); break;
            case 6: output_token("seac"); break;
            case 7: output_token("sbw"); break;
            case 12: output_token("div"); break;
            case 16: output_token("callothersubr"); break;
            case 17: output_token("pop"); break;
            case 33: output_token("setcurrentpoint"); break;
            default:
              sprintf(buf, "UNKNOWN_12_%d", b);
              output_token(buf);
              break;
          }
          break;
        default:
          sprintf(buf, "UNKNOWN_%d", b);
          output_token(buf);
          break;
      }
      output_token("\n");
    }
  }
  if(!in_Subroutines){  /* ready to process the character now */
    return 1;
  }
  return 0;
}

static int get_Subroutines(void){
  char *p,temp_line[LINESIZE];
  strcpy(temp_line,load_line);
  if((p=strstr(temp_line,"/Subrs")) != NULL){
    p=strtok(p,"\n\t ");
    p=strtok(NULL,"\n\t ");
    return atoi(p);
  }
  return 0;
}

static int get_subroutine_number(void){
  char *p,temp_line[LINESIZE];
  strcpy(temp_line,load_line);
  if((p=strstr(temp_line,"dup")) != NULL){
    p=strtok(p,"\n\t ");
    p=strtok(NULL,"\n\t ");
    return atoi(p);
  }
  return -1;
}

static int get_character_name(void){ /* and posibly encoding number */
  char *p1,*p2,*p3,*pend;
  p2=character_name;
  if((p1=strstr(load_line,"/")) != NULL){
    pend=(load_line+strlen(load_line));
    p3=p1; while(*p1 != ' ' && *p1 != '\t' && p1 < pend)*p2++ = *p1++;
    *p2 = 0;
    if(p3 == load_line)return -1;
    p3--;
    while (p3 != load_line && (*p3 == ' ' || *p3 == '\t')) --p3;
    if(p3 == load_line)return -1;
    while (p3 != load_line && *p3 != ' ' && *p3 != '\t') --p3;
    return atoi(p3);
  }
  *p2=0;
  return -1;
}

static short decode_build_type1(int tc, char *PSfile){
  char encoding_file[255];
  short ic,character_found;
  int wc,i;
  FILE *ef;
  sprintf(encoding_file,"%smodeler.atm",szRoot);
//  MessageBox(hwndParent,encoding_file,"ATM",MB_OK);
  if((ef=fopen(encoding_file,"rb")) == NULL)return FAIL;
  fseek(ef,tc*64,SEEK_SET);
  if(fread(this_character,1,64,ef) != 64){
    fclose(ef); return FAIL;
  }
  fclose(ef);
  if((ifp = fopen(PSfile,"rb")) == NULL)return FAIL;
  p_key = 0; first_byte = 1; is_pfa = 0; is_pfb = 0;  pfb_remaining = 0;
  reported = 0; in_eexec = 0; start = 1; start_charstring = 0; lenIV = 4;
  in_EncodingArray = 0; in_Subroutines = 0;  in_charstring = 0; PS_fail=0;
  StandardEncoding=0;
  /* main loop---normally done when reach `mark currentfile closefile' on
     output (rest is garbage). */
  for (;;) {
    egetline();
    if (load_line[0] == '\0') break;
    set_lenIV();
    if(!in_eexec){
      if      (!in_EncodingArray && strstr(load_line,"/Encoding"))
        in_EncodingArray=1;
      else if ( in_EncodingArray){
        if(strstr(load_line,"readonly def"))in_EncodingArray=0;
        else{
          wc=get_character_name();
          if(wc == tc){
            strcpy(this_character,character_name);
            character_found=1;
          }
        }
      }
    }
    else {
      if(!in_charstring){
        if(strstr(load_line,"/CharStrings")){
          in_charstring=1; in_Subroutines=0; /* in_Su.. needed to get first */
          if( ! character_found){            /* in some fonts               */
            StandardEncoding=1;
          }
        }
      }
      if(n_Subroutines == 0 && ! in_Subroutines){
        n_Subroutines=get_Subroutines();
        if(n_Subroutines > 0){
          in_Subroutines=1;
          if((C_Subs=(character_program *)X__Malloc((long)n_Subroutines *
             (long)sizeof(character_program))) == NULL)return MEMFAIL;
          for(i=0;i<n_Subroutines;i++){C_Subs[i].n=0; C_Subs[i].p=NULL;}
        }
      }
      else if(in_Subroutines &&
        (strstr(load_line," ND") || strstr(load_line,"|-")))
        in_Subroutines=0;

    }
    if (start_charstring){
      if(!in_Subroutines){
        (void)get_character_name();
      }
      else{
        i_Subroutine=get_subroutine_number();
      }
      ic=do_charstring();
      if(ic == 1)break; /* found the character break out */
      else if(ic == MEMFAIL){ /* out of memory some where */
        fclose(ifp);
        return MEMFAIL;
      }
    }
    if (strcmp(load_line, "mark currentfile closefile\n") == 0){
      MessageBox(NULL,"No character in font","ATM",MB_OK);
      break;
    }
  }
  fclose(ifp);
  return OK;
}