home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / GRAPHICS / PSCRIPT / EPSON2PS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-29  |  19.2 KB  |  691 lines
  1.  ________________________________________________________________
  2.  
  3.  Message: 2813624, 682 lines
  4.  Imported: 3:38am EST, Mon Mar 7/88
  5.  Subject: Epson to PS converter.
  6.  To: Info-postscript, info-postscript@sushi.stanford.edu
  7.  From: info-postscript-request%sushi.stanford.edu@sushi.stanford.edu
  8.  
  9.  
  10.          A few weeks ago I posted an espon to ps converter in the hopes it
  11.  would grow. Thanks to Mark Alexander the program has some more functionality.
  12.  Added is Italics, variable line spacing and Emphasized mode. Some bugs have
  13.  been fixed also. Well here it is, enjoy! BTW this program can also be used
  14.  as an ASCII listing filter.
  15.  
  16.  # This is a shell archive.  Remove anything before this line,
  17.  # then unpack it by saving it in a file and typing "sh file".
  18.  #
  19.  # Wrapped by rover!jonnyg on Fri Mar  4 14:19:31 EST 1988
  20.  # Contents:  makefile epson.c set.c set.h crlf.c
  21.  
  22.  echo x - makefile
  23.  sed 's/^@//' > "makefile" <<'@//E*O*F makefile//'
  24.  CC=cc
  25.  
  26.  all: epson crlf
  27.  
  28.  epson: epson.o set.o
  29.        $(CC) epson.o set.o -o epson
  30.  
  31.  epson.o: epson.c set.h
  32.        $(CC) -O -c epson.c
  33.  
  34.  set.o: set.c set.h
  35.        $(CC) -O -c set.c
  36.  
  37.  crlf: crlf.c
  38.        $(CC) -O crlf.c -o crlf
  39.  @//E*O*F makefile//
  40.  chmod u=rw,g=r,o=r makefile
  41.  
  42.  echo x - epson.c
  43.  sed 's/^@//' > "epson.c" <<'@//E*O*F epson.c//'
  44.  /*
  45.   *  Version 0.6
  46.   *
  47.   *  IBM Graphics printer to postscript translator.
  48.   *
  49.   *    Copyright (c) 1988, Jonathan Greenblatt,
  50.   *            <jonnyg@rover.umd.edu> (128.8.2.73)
  51.   *            <jonnyg@umd5.umd.edu> (128.8.10.5)
  52.   *            <pcproj@gymble.umd.edu> (128.8.128.16)
  53.   *      This program may be redistributed in source form,
  54.   *      provided no fee is charged and this copyright notice is preserved.
  55.   *
  56.   *  DESCRIPTION:
  57.   *    This program uses standard input and output to convert epson printer
  58.   *    codes to Postcript. This program is an execlent ASCII listing printer.
  59.   *    The crlf program is include to add PC crlf to end of lines for
  60.   *    printing UNIX listings. This program was written on an IBM RT running
  61.   *    4.3. The RT does not do crlf conversions by default so some changes
  62.   *    may have to be made on other systems. This is a working subset of
  63.   *    what I plan to complete. I am distributing this in hopes someone else
  64.   *    will take interest in this code.
  65.   *
  66.   *  SUPPORTS:
  67.   *    1: ASCII text.
  68.   *    2: Underlining.
  69.   *    3: Overstrike.
  70.   *    4: Double width.
  71.   *    5: Highlighting <Esc>G
  72.   *    6: Super/Subscript
  73.   *    7: 80x66 character on a page.
  74.   *    8: Variable line spacing in 1/72 inch units <Esc>A(n),<Esc>2
  75.   *    9: Italics
  76.   *    10: Emphasized <Esc>E
  77.   *
  78.   *  NEEDED:
  79.   *    1: Compressed mode.
  80.   *    2: Variable line spacing in 1/216 units <Esc>3(n)
  81.   *    3: Option for handling CRLF
  82.   *    4: Non ASCII characters.
  83.   *    5: Graphics escapes.
  84.   *    6: I make an assumption that the font has a 6/10 ration, there are
  85.   *       better ways of doing this.
  86.   *    7: Elite mode <Esc>M.
  87.   *
  88.   *  CONTRIBUTIONS:
  89.   *
  90.   *    The Following was contributed by:
  91.   *             Mark Alexander <uunet!amdahl!drivax!alexande@umd5.UMD.EDU>
  92.   *
  93.   *  - Added 1/72 line-spacing support (ESC-A).  This required changing
  94.   *    the scaling in the Y dimension to 792, so that we have 72 points
  95.   *    per inch in Y, instead of 36.
  96.   *  - Changed the BNDY definition to compute page breaks correctly
  97.   *    when we're right at the page break.
  98.   *  - If variable line spacing is being used to slew past the end
  99.   *    of page, don't reset cy to the top of page; instead, set it
  100.   *    to top of page + n, where n is the position it would have
  101.   *    been on continuous paper in an Epson.
  102.   *  - Allowed spaces to be underlined.
  103.   *  - Added support for emphasized mode.  It's treated exactly
  104.   *    the same way as doublestrike.
  105.   *  - Added support for italics.  Italics-bold hasn't been tested, though.
  106.   *  - Print unknown ESC codes on standard error.
  107.   *  - Allow an optional input filename to specified on the command line.
  108.   *  - Changed the indentation to make it more readable to me; you
  109.   *    may not like my style at all (sorry).
  110.   *
  111.   *
  112.   *
  113.   *  BUGS:
  114.   *    1: Seems to timeout the apple laserwriter when I send large prinouts
  115.   *       through the tty line using no special line control.
  116.   *    2: Underlining works, but the lines chop right through the descenders
  117.   *       on some lower case characters.  I haven't tried to fix this.
  118.   *
  119.   *
  120.   *  PORTABILITY:
  121.   *    I have not tried this anywhere else but it should be easily portable
  122.   *    to the IBM PC with turbo or Microsoft C.
  123.   *    (Note: it works fine with Datalight C 3.12.   --Mark Alexander).
  124.   * 
  125.   *
  126.   *  FILES:
  127.   *    crlf.c: Convert UNIX file to pc Carriage return linefeed format.
  128.   *    epson.c: Main program.
  129.   *    set.c: ASCII set functions, like pascal, will be used more as I write
  130.   *            more.
  131.   *    set.h: Include file for set handling code.
  132.   *    makefile: Unix makefile.
  133.   *
  134.   */
  135.  
  136.  #include      <stdio.h>
  137.  #include      "set.h" /* Set functions for characters */
  138.  
  139.  #define       DEBUG   1       /* Print bad things to stderr */
  140.  
  141.  #define       MAXX    480                     /* X scaled to 60 points per inch */
  142.  #define       MAXY    792                     /* Y scaled to 72 points per inch */
  143.  #define       XSTART  0
  144.  #define       YSTART  point_sizey
  145.  #define       YSTOP   MAXY
  146.  #define       XSTOP   MAXX
  147.  
  148.  #define       BNDX    (cx > (XSTOP - point_sizex))
  149.  #define       BNDY    (cy > YSTOP)
  150.  
  151.  #define       NUM_TABS        28
  152.  int tabs[NUM_TABS+1] = {8,16,32,40,48,56,64,72,80,88,96,104,112,124,
  153.                -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
  154.  
  155.  char *printables =
  156.  " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890`,./\\[]=-!@#$%^&*()_+|{}:\"<>?~;'";
  157.  char *needesc = "()\\";
  158.  
  159.  typedef enum {normal,bold,doublenorm,doublebold,italicnorm,italicbold}
  160.        _font_type;
  161.  
  162.  char *font_descr[] = {"Courier","Courier-Bold","Courier","Courier-Bold",
  163.        "Courier-Oblique", "Courier-BoldOblique"};
  164.  char *font_name[] = {"normalfont","boldfont","doublefont","doublebold",
  165.        "italicnorm","italicbold"};
  166.  
  167.  /* Size of the fonts (x,y) in characters per inch.
  168.   */
  169.  int font_size[][2] = {{10,6},{10,6},{5,6},{5,6},{10,6},{10,6}};
  170.  
  171.  char_set printable_set;
  172.  char_set needesc_set;
  173.  
  174.  _font_type font_type;
  175.  
  176.  int cx, cy;
  177.  int point_sizex, point_sizey, line_space;
  178.  
  179.  int underline = 0;
  180.  int subscript =  0;
  181.  int doublewidth = 0;
  182.  int highlight = 0;
  183.  int emphasize = 0;
  184.  int italic = 0;
  185.  
  186.  char *start_doc[] = {
  187.        "/saveobj1 save def",
  188.        "/mt {moveto} def",
  189.        "/s {show} def",
  190.        "clippath pathbbox",
  191.        "/ymax exch def /xmax exch def /ymin exch def /xmin exch def",
  192.        "xmin ymax translate",
  193.        "xmax xmin sub 480 div",
  194.        "ymin ymax sub 792 div",
  195.        "scale",
  196.        "newpath",
  197.        ".5 setlinewidth",
  198.        NULL};
  199.  
  200.  char *start_page[] = {
  201.        "/saveobj2 save def",
  202.        NULL};
  203.  
  204.  char *end_page[] = {
  205.        "showpage",
  206.        "saveobj2 restore",
  207.        NULL};
  208.  
  209.  char *end_doc[] = {
  210.        "saveobj1 restore",
  211.        "\004",
  212.        NULL};
  213.  
  214.  define_font(name,font,sizex,sizey)
  215.  char *name, *font;
  216.  {
  217.        printf("/%s {/%s findfont [%d 10 6 div mul 0 0 -%d 0 0] makefont setfont} def\n",name,font,sizex,sizey);
  218.  }
  219.  
  220.  new_page()
  221.  {
  222.        cx = XSTART;
  223.        cy = YSTART;
  224.        plist(start_page);
  225.        set_font();
  226.  }
  227.  
  228.  set_font()
  229.  {
  230.        int     boldface;
  231.  
  232.        boldface = highlight || emphasize;
  233.  
  234.        if (doublewidth)
  235.                font_type = boldface ? doublebold : doublenorm;
  236.        else if (italic)
  237.                font_type = boldface ? italicbold : italicnorm;
  238.        else
  239.                font_type = boldface ? bold: normal;
  240.  
  241.        point_sizex = get_pointx(font_size[(int)font_type][0]);
  242.        point_sizey = get_pointy(font_size[(int)font_type][1]);
  243.        printf("%s\n",font_name[(int)font_type]);
  244.  }
  245.  
  246.  eject_page()
  247.  {
  248.        plist(end_page);
  249.        new_page();
  250.  }
  251.  
  252.  /* Check if cy has gone past a page boundary, and skip to a new
  253.   * page if necessary.  Set the new y-position not to the top of
  254.   * page, but the point it would have been had this been a real
  255.   * Epson printer with continuous forms.
  256.   */
  257.  check_page()
  258.  {
  259.        int oldcy;
  260.  
  261.        if (BNDY)
  262.        {
  263.                oldcy = cy;
  264.                eject_page();
  265.                cy = oldcy - YSTOP;
  266.        }
  267.  }
  268.  
  269.  init_sets()
  270.  {
  271.        clear_set(printable_set);
  272.        clear_set(needesc_set);
  273.        str_add_set(printable_set,printables);
  274.        str_add_set(needesc_set,needesc);
  275.  }
  276.  
  277.  get_pointx(char_per_inch)
  278.  {
  279.        return(60/char_per_inch);
  280.  }
  281.  
  282.  get_pointy(char_per_inch)
  283.  {
  284.        return(72/char_per_inch);
  285.  }
  286.  
  287.  init_printer()
  288.  {
  289.        point_sizex = get_pointx(font_size[(int)normal][0]);
  290.        point_sizey = line_space = get_pointy(font_size[(int)normal][1]);
  291.        plist(start_doc);
  292.  
  293.        /* Define the normal-width fonts.
  294.         */
  295.        define_font(font_name[(int)normal],font_descr[(int)normal],point_sizex,point_sizey);
  296.        define_font(font_name[(int)bold],font_descr[(int)bold],point_sizex,point_sizey);
  297.        define_font(font_name[(int)italicnorm],font_descr[(int)italicnorm],point_sizex,point_sizey);
  298.        define_font(font_name[(int)italicbold],font_descr[(int)italicbold],point_sizex,point_sizey);
  299.  
  300.        /* Define the double-width fonts.
  301.         */
  302.        point_sizex = get_pointx(font_size[(int)doublenorm][0]);
  303.        point_sizey = get_pointy(font_size[(int)doublenorm][1]);
  304.        define_font(font_name[(int)doublenorm],font_descr[(int)doublenorm],point_sizex,point_sizey);
  305.        define_font(font_name[(int)doublebold],font_descr[(int)doublebold],point_sizex,point_sizey);
  306.        font_type = normal;
  307.        new_page();
  308.  }
  309.  
  310.  plist(l)
  311.  char **l;
  312.  {
  313.        while (*l != NULL)
  314.                puts(*l++);
  315.  }
  316.  
  317.  #define       LINE_SIZE       256
  318.  char pline[256];
  319.  int ptr = 0;
  320.  
  321.  char outline[258];
  322.  
  323.  putline()
  324.  {
  325.        char *s = pline;
  326.        int p;
  327.        int lx;
  328.  
  329.        check_page();
  330.  
  331.        /* Skip over leading spaces, unless underlining is enabled
  332.         * (we want to underline spaces)
  333.         */
  334.        if (underline == 0)
  335.        {
  336.                while (*s == ' ' && ptr > 0)
  337.                {
  338.                        s++;
  339.                        ptr--;
  340.                        if (BNDX)
  341.                        {
  342.                                cx = XSTART;
  343.                                newline();
  344.                        }
  345.                        cx += point_sizex;
  346.                }
  347.        }
  348.  
  349.        while (ptr > 0)
  350.        {
  351.                p = 0;
  352.                check_page();
  353.                if (BNDX)
  354.                {
  355.                        cx = XSTART;
  356.                        newline();
  357.                }
  358.                lx = cx;
  359.                while ((lx+point_sizex-1) < XSTOP && ptr > 0)
  360.                {
  361.                        if (in_set(needesc_set,*s))
  362.                                outline[p++] = '\\';
  363.                        outline[p++] = *s++;
  364.                        ptr--;
  365.                        lx += point_sizex;
  366.                }
  367.                outline[p] = 0;
  368.                if (p > 0)
  369.                {
  370.                        int i = strlen(outline);
  371.                        /* Forward slash won't work at the end of a string */
  372.                        if (outline[i-1] == '/')
  373.                        {
  374.                                outline[i] = ' ';
  375.                                outline[i+1] = '\0';
  376.                        }
  377.                        if (subscript)
  378.                        {
  379.                                if (subscript == 1) /* Subscript */
  380.                                        printf("%d %d mt gsave 1 .5 scale (%s) s grestore\n",cx,cy,outline);
  381.                                else /* Superscript */
  382.                                printf("%d %d mt gsave 1 .5 scale (%s) s grestore\n",cx,cy-(point_sizey>>1),outline);
  383.                        }
  384.                        else /* Normal printing */
  385.                                printf("%d %d mt (%s) s\n",cx,cy,outline);
  386.                        if (underline)
  387.                                printf("%d %d mt %d %d lineto stroke\n",cx,cy+1,lx-1,cy+1);
  388.                }
  389.                cx = lx;
  390.        }
  391.  }
  392.  
  393.  newline()
  394.  {
  395.        cy += line_space;
  396.        check_page();
  397.  }
  398.  
  399.  typedef enum {S_BASE,S_ESC,S_UNDERLINE,S_SUBSCRIPT,S_DOUBLE,S_LINESPACE} states;
  400.  
  401.  states state = S_BASE;
  402.  
  403.  dochar(c)
  404.  {
  405.        if (ptr >= LINE_SIZE) putline();
  406.        switch (state)
  407.        {
  408.        case S_UNDERLINE:
  409.                state = S_BASE;
  410.                if (c == '\0')  underline = 0;
  411.                else if (c == '\1') underline = 1;
  412.                break;
  413.        case S_DOUBLE:
  414.                state = S_BASE;
  415.                if (c == '\0')  doublewidth = 0;
  416.                else if (c == '\1') doublewidth = 1;
  417.                set_font();
  418.                break;
  419.        case S_SUBSCRIPT:
  420.                state = S_BASE;
  421.                if (c == '\0') subscript = 2;
  422.                else if (c == '\1') subscript = 1;
  423.                break;
  424.        case S_LINESPACE:
  425.                state = S_BASE;
  426.                line_space = c;
  427.                break;
  428.        case S_ESC:
  429.                state = S_BASE;
  430.                switch (c)
  431.                {
  432.                case '2':       /* set line spacing to 1/6 inch */
  433.                        line_space = 12;
  434.                        break;
  435.                case '4':
  436.                        italic = 1;
  437.                        set_font();
  438.                        break;
  439.                case '5':
  440.                        italic = 0;
  441.                        set_font();
  442.                        break;
  443.                case 'A':
  444.                        state = S_LINESPACE;
  445.                        break;
  446.                case 'E':
  447.                        emphasize = 1;
  448.                        set_font();
  449.                        break;
  450.                case 'F':
  451.                        emphasize = 0;
  452.                        set_font();
  453.                        break;
  454.                case 'G':
  455.                        highlight = 1;
  456.                        set_font();
  457.                        break;
  458.                case 'H':
  459.                        highlight = 0;
  460.                        set_font();
  461.                        break;
  462.                case '-':
  463.                        state = S_UNDERLINE;
  464.                        break;
  465.                case 'T':
  466.                        subscript = 0;
  467.                        break;
  468.                case 'S':
  469.                        state = S_SUBSCRIPT;
  470.                        break;
  471.                case 'W':
  472.                        state = S_DOUBLE;
  473.                        break;
  474.                default:
  475.  #ifdef        DEBUG
  476.                        fprintf(stderr,"Unknown sequence: ESC 0x%x\n",c);
  477.  #endif
  478.                        break;
  479.                }
  480.                break;
  481.           case S_BASE:
  482.                switch(c)
  483.                {
  484.                case '\011':
  485.                        {
  486.                                int i,l;
  487.  
  488.                                l = cx / point_sizex + ptr;
  489.                                for (i = 0; i < NUM_TABS && tabs[i] <= l; i++)
  490.                                        ;
  491.                                if (tabs[i] == -1) break;
  492.                                i = tabs[i] - l;
  493.                                while (i-- > 0) dochar(' ')
  494.                                        ;
  495.                        }
  496.                        break;
  497.                case '\033':
  498.                        putline();
  499.                        state = S_ESC;
  500.                        break;
  501.                case '\014':
  502.                        putline();
  503.                        eject_page();
  504.                        break;
  505.                case '\n':
  506.                        putline();
  507.                        newline();
  508.                        break;
  509.                case '\r':
  510.                        putline();
  511.                        cx = XSTART;
  512.                        break;
  513.                case 26:        /* CTRL-Z */
  514.                        break;
  515.                default:
  516.                        if (in_set(printable_set,c))
  517.                                pline[ptr++] = c;
  518.                        else
  519.                                pline[ptr++] = ' ';
  520.                        break;
  521.                }
  522.                break;
  523.        }
  524.  }
  525.  
  526.  main(argc,argv)
  527.  int argc;
  528.  char *argv[];
  529.  {
  530.        int n;
  531.        int file;
  532.        char *p;
  533.        static char istr[128];
  534.  
  535.        if (argc > 2)
  536.        {
  537.  #ifdef        DEBUG
  538.                fprintf(stderr,"Usage: epson [file]\n");
  539.  #endif
  540.                exit(1);
  541.        }
  542.        if (argc == 2)
  543.        {
  544.                if ((file = open(argv[1],0)) < 0)
  545.                {
  546.  #ifdef        DEBUG
  547.                        fprintf(stderr,"Unable to open %s\n",argv[1]);
  548.  #endif
  549.                        exit(2);
  550.                }
  551.        }
  552.        else
  553.                file = 0;               /* standard input       */
  554.  
  555.        init_sets();
  556.        init_printer();
  557.        while ((n = read(file,p = istr,128)) > 0)
  558.                while (n--) dochar(*p++)
  559.                        ;
  560.        if (cx > XSTART || cy > YSTART)
  561.                plist(end_page);
  562.        else
  563.                printf("saveobj2 restore\n");
  564.        plist(end_doc);
  565.        exit(0);
  566.  }
  567.  @//E*O*F epson.c//
  568.  chmod u=rw,g=r,o=r epson.c
  569.  
  570.  echo x - set.c
  571.  sed 's/^@//' > "set.c" <<'@//E*O*F set.c//'
  572.  #include "set.h"
  573.  
  574.  clear_set(set)
  575.  char_set set;
  576.        {
  577.        int i;
  578.        for (i = 0; i < INTS_IN_SET; i++) set[i] = 0;
  579.        }
  580.  
  581.  fill_set(set)
  582.  char_set set;
  583.        {
  584.        int i;
  585.        for (i = 0; i < INTS_IN_SET; i++) set[i] = 0xffff;
  586.        }
  587.  
  588.  not_set(set)
  589.  char_set set;
  590.        {
  591.        int i;
  592.        for (i = 0; i < INTS_IN_SET; i++) set[i] ^= 0xffff;
  593.        }
  594.  
  595.  and_set(set,set1)
  596.  char_set set, set1;
  597.        {
  598.        int i;
  599.        for (i = 0; i < INTS_IN_SET; i++) set[i] &= set1[i];
  600.        }
  601.  
  602.  or_set(set,set1)
  603.  char_set set,set1;
  604.        {
  605.        int i;
  606.        for (i = 0; i < INTS_IN_SET; i++) set[i] |= set1[i];
  607.        }
  608.  
  609.  add_set(set,c)
  610.  char_set set;
  611.  unsigned int c;
  612.        {
  613.        c &= 0xff;
  614.        set[c >> 4] |= 1 << (c & 15);
  615.        }
  616.  
  617.  del_set(set,c)
  618.  char_set set;
  619.  unsigned int c;
  620.        {
  621.        c &= 0xff;
  622.        set[c >> 4] &= ~(1 << (c & 15));
  623.        }
  624.  
  625.  in_set(set,c)
  626.  char_set set;
  627.  unsigned int c;
  628.        {
  629.        c &= 0xff;
  630.        return ((set[c >> 4] & (1 << (c & 15))) != 0);
  631.        }
  632.  
  633.  str_add_set(set,s)
  634.  char_set set;
  635.  char *s;
  636.        {
  637.        unsigned int c;
  638.        while (*s) {
  639.                c = *s++;
  640.                c &= 0xff;
  641.                set[c >> 4] |= 1 << (c & 15);
  642.                }
  643.        }
  644.  
  645.  str_del_set(set,s)
  646.  char_set set;
  647.  char *s;
  648.        {
  649.        unsigned int c;
  650.        while (*s) {
  651.                c = *s++;
  652.                c &= 0xff;
  653.                set[c >> 4] &= ~(1 << (c & 15));
  654.                }
  655.        }
  656.  @//E*O*F set.c//
  657.  chmod u=rw,g=r,o=r set.c
  658.  
  659.  echo x - set.h
  660.  sed 's/^@//' > "set.h" <<'@//E*O*F set.h//'
  661.  #define INTS_IN_SET   16
  662.  
  663.  typedef unsigned int char_set[INTS_IN_SET];
  664.  @//E*O*F set.h//
  665.  chmod u=rw,g=r,o=r set.h
  666.  
  667.  echo x - crlf.c
  668.  sed 's/^@//' > "crlf.c" <<'@//E*O*F crlf.c//'
  669.  main() {
  670.        char ibuff[512], *ip;
  671.        char obuff[1024];
  672.        int ic, oc;
  673.  
  674.        while ((ic = read(0,ip = ibuff,512)) > 0) {
  675.                oc = 0;
  676.                while (ic--)
  677.                        if (*ip == '\n')
  678.                                {
  679.                                ip++;
  680.                                obuff[oc++] = '\r';
  681.                                obuff[oc++] = '\n';
  682.                                }
  683.                        else    obuff[oc++] = *ip++;
  684.                write(1,obuff,oc);
  685.                }
  686.        }
  687.  @//E*O*F crlf.c//
  688.  chmod u=rw,g=r,o=r crlf.c
  689.  
  690.  exit 0
  691.