interp.c

ttfdump源代码

/* interp.c -- Instruction Interpreter
 * Copyright (C) 1996 Li-Da Lho, All right reserved.
 */
#include "config.h"
#include "ttf.h"
#include "ttfutil.h"

#ifdef MEMCHECK
#include <dmalloc.h>
#endif

/* 	$Id: interp.c,v 1.1.1.1 1998/06/05 07:47:52 robert Exp $	 */

#ifndef lint
static char vcid[] = "$Id: interp.c,v 1.1.1.1 1998/06/05 07:47:52 robert Exp $";
#endif /* lint */

/* A bit about error checking: The execution of a TrueType instruction is 
 * "atomic" which mean that we don't process the error until a single
 * instruction is fully decoded and exectued */

/* Pushing data onto the interpreter stack */

void Interp_NPUSHB (VirtualMachine *vm)
{
    BYTE i,n;
    ULONG l;

    n = GetBYTE(vm);

    for (i=1;i<=n;i++)
	{
	    /* unsigned extension to four bytes */
	    l = (ULONG) GetBYTE(vm);
	    Push(vm, l);
	}
}

void Interp_NPUSHW(VirtualMachine *vm)
{
    BYTE i,n;
    LONG l;

    n = GetBYTE(vm);

    for (i=1;i<=n;i++)
	{
	    /* signed extension to four bytes */
	    l = (LONG) GetSHORT(vm);
	    Push(vm, l);
	}

}

void Interp_PUSHB(VirtualMachine *vm)
{
    BYTE opcode,n,i;
    ULONG l;

    opcode = (vm->iStream)[vm->ip];
    n = opcode - 0xB0;

    for (i=0;i<=n;i++)
	{
	    l = (ULONG) GetBYTE(vm);
	    Push(vm, l);
	}
}
/* PUSHW[abc] Push Words 
 * Code Range 0xB8 - 0x0BF
 * From IS    w0,w1,...wn
 * Pushes     w0,w1,...wn */
void Interp_PUSHW(VirtualMachine *vm)
{
    BYTE opcode,n,i;
    LONG l;

    opcode = (vm->iStream)[vm->ip];
    n = opcode - 0xB8;

    for (i=0;i<=n;i++)
	{
	    l = (LONG) GetSHORT(vm);
	    Push(vm,l);
	}
}

/* Managing the Storage Area */

/* RS[]   Read Store
 * Code Range 0x43
 * Pops   location: Storage Area location (ULONG)
 * Pushes value: Storage Area value (ULONG)
 * Gets   Storage Area value */
void Interp_RS(VirtualMachine *vm)
{
    ULONG location,value;

    location = Pop(vm);    
    value = (vm->StorageArea)[location];
    Push(vm,value);
}
/* WS[]    Write Store
 * Code Range 0x42
 * Pops    value: Storage Area value (ULONG)
 *         location: Storage Area location (ULONG)
 * Pushes  -
 * Sets    Storage Area */
void Interp_WS(VirtualMachine *vm)
{
    ULONG location,value;
    
    value = Pop(vm);
    location = Pop(vm);
    (vm->StorageArea)[location] = value;
}

/* Managing the Control Value Table */

/* WCVTP[] Write control Value Table in Pixel units
 * Code Range 0x44
 * Pops    value: number in pixels (F26Dot6)
 *         location: Control Value Table location (ULONG)
 * Pushes  -
 * Sets    Control Value Table entry */
void Interp_WCVTP(VirtualMachine *vm)
{
    F26Dot6 value;
    ULONG location;

    value = Pop(vm);
    location = Pop(vm);

    (vm->cvt)[location] = value;
}
/* WCVTF[] Write Control Value Table in FUnits 
 * Code Range 0x70
 * Pops    value: number in FUnits (ULONG) (LONG actually,i think)
 *         location: Control Value (ULONG)
 * Pushes  -
 * Sets    Control Value Table entry
 */
void Interp_WCVTF(VirtualMachine *vm)
{
    ULONG location;
    LONG value;

    value = Pop(vm);
    location = Pop(vm);

    value = ScaleToPoints(vm,value);
    (vm->cvt)[location] = value;
}
/* RCVT[]  Read Control Value Table
 * Code Range 0x45
 * Pops    location: CVT entry number (ULONG)
 * Pushes  value: CVT value (F26Dot6)
 * Gets    Control Value Table entry
 */
void Interp_RCVT(VirtualMachine *vm)
{
    ULONG location;
    F26Dot6 value;

    location = Pop(vm);
    value = (vm->cvt)[location];
    Push(vm,value);
}

/* Managing Graphics State */

/* SVTCA[a] Set freedom and projection vector to Coordinate Axia
 * Code Range 0x00 - 0x01
 * a        0: set to y axis
 *          1: set to x axis
 * Pops     -
 * Pushes   -
 * Sets     projection_vector
 *          freedom_vector
 */
void Interp_SVTCA(VirtualMachine *vm)
{
    BYTE opcode;
    TTFUnitVector vect;

    opcode = (vm->iStream)[vm->ip];
    switch (opcode)
	{
	case 0x00:
	    vect.x = 0;
	    vect.y = F2Dot14_ONE;
	    break;
	case 0x01:
	    vect.x = F2Dot14_ONE;
	    vect.y = 0;
	    break;
	}
    vm->gstate.projection_vector = vm->gstate.freedom_vector = vect;
}
/* SPVCA[a] Set projection vector to coordinate axis 
 * Code Range 0x02 - 0x03
 * a        0: set to y axis
 *          1: set to x axis
 * Pops     -
 * Pushes   -
 * Sets     projection vector
 */
void Interp_SPVTCA(VirtualMachine *vm)
{
    BYTE opcode;
    TTFUnitVector vect;

    opcode = (vm->iStream)[vm->ip];
    switch (opcode)
	{
	case 0x02:
	    vect.x = 0;
	    vect.y = F2Dot14_ONE;
	    break;
	case 0x03:
	    vect.x = F2Dot14_ONE;
	    vect.y = 0;
	    break;
	}
    vm->gstate.projection_vector = vect;
}
/* SFVTCA[a] Set freedom vector to coordinate axis
 * Code Range 0x04 - 0x05
 * a        0: set to y axis
 *          1: set to x axis
 * Pops     -
 * Pushes   -
 * Sets     freedom vector
 */
void Interp_SFVTCA(VirtualMachine *vm)
{
    BYTE opcode;
    TTFUnitVector vect;

    opcode = (vm->iStream)[vm->ip];
    switch (opcode)
	{
	case 0x04:
	    vect.x = 0;
	    vect.y = F2Dot14_ONE;
	    break;
	case 0x05:
	    vect.x = F2Dot14_ONE;
	    vect.y = 0;
	    break;
	}
    vm->gstate.freedom_vector = vect;
}
/* SPVTL[a] Set projection vector to line
 * Code Range 0x06 - 0x07
 * a        0: set projection_vector to be parallel to line segment from p1 
 *             to p2
 *          1: set projection_vector to be perpendicular to line segment from 
 *             p1 to p2; the vector is retated counter clockwise 90 degrees
 * Pops     p1: point number (ULONG)
 *          p2: point number (ULONG)
 * Pushes   -
 * Uses     point p1 in the zone pointed at by zp2
 *          point p2 in the zone pointed at by zp1
 * Sets     projection vector
 */
void Interp_SPVTL(VirtualMachine *vm)
{
    ULONG p1,p2;
    BYTE opcode;
    TTFUnitVector vect;

    opcode = (vm->iStream)[vm->ip];
    p1 = Pop(vm);
    p2 = Pop(vm);

    switch (opcode)
	{
	    /* not finished yet */
	case 0x06:
	    break;
	case 0x07:
	    break;
	}
    vm->gstate.projection_vector = vect;
}
/* SFVTL[a] Set freedom vector to line
 * Code Range 0x08 - 0x09
 * a        0: set freedom_vector to be parallel to line segment from p1 
 *             to p2
 *          1: set freedom_vector to be perpendicular to line segment from 
 *             p1 to p2; the vector is retated counter clockwise 90 degrees
 * Pops     p1: point number (ULONG)
 *          p2: point number (ULONG)
 * Pushes   -
 * Uses     point p1 in the zone pointed at by zp2
 *          point p2 in the zone pointed at by zp1
 * Sets     freedom vector
 */
void Interp_SFVTL(VirtualMachine *vm)
{
    ULONG p1,p2;
    BYTE opcode;
    TTFUnitVector vect;

    opcode = (vm->iStream)[vm->ip];
    p1 = Pop(vm);
    p2 = Pop(vm);
    switch (opcode)
	{
	    /* not finished yet */
	case 0x08:
	    break;
	case 0x09:
	    break;
	}
    vm->gstate.freedom_vector = vect;
}
/* SFVTPV[] Set freedom vector to projection vector
 * Code Range 0x0E
 * Pops     -
 * Pushes   -
 * Sets     freedom vector
 */
void Interp_SFVTPV(VirtualMachine *vm)
{
    vm->gstate.freedom_vector = vm->gstate.projection_vector;
}
/* SDPVTL[a] Set dual projection vector to line
 * Code Range 0x86 - 0x87
 * a         0: vectors are parallel to line 
 *           1: vectors are perpendicular to line
 * Pops      p1: first point number (ULONG)
 *           p2: second point number (ULONG)
 * Pushes    -
 * Sets      dual_projection_vector and projection_vector
 * Uses      point p1 in the zone pointed by zp2
 *           point p2 in the zone pointed by zp1
 */
void Interp_SDPVTL(VirtualMachine *vm)
{
    ULONG p1,p2;
    BYTE opcode;
    TTFUnitVector vect;

    opcode = (vm->iStream)[vm->ip];
    p1 = Pop(vm);
    p2 = Pop(vm);
    switch (opcode)
	{
	    /* not finished yet */
	case 0x86:
	    break;
	case 0x87:
	    break;
	}
    vm->gstate.dual_projection_vector = vm->gstate.projection_vector = vect;
}
/* SPVFS[] Set projection vector from stack
 * Code Range 0x0A
 * Pops    y: y component of projection vector (2.14 padded with zeros)
 *         x: x component of projection vector (2.14 padded with zeros)
 * Pushes  -
 * Sets    projection_vector
 */
void Inpterp_SPVFS(VirtualMachine *vm)
{
    F2Dot14 x,y;

    x = Pop(vm);
    y = Pop(vm);

    vm->gstate.projection_vector.x = x;
    vm->gstate.projection_vector.y = y;
    /* vm->gstate.projection = Normalize(vm->gstate.projection); ?? */
}
/* SFVFS[] Set freedom vector form stack
 * Code Range 0x0B
 * Pops    y: y component of freedom vector (2.14 padded with zeros)
 *         x: x component of freedom vector (2.14 padded with zeros)
 * Pushes  -
 * Sets    freedom_vector
 */
void Inpterp_SFVFS(VirtualMachine *vm)
{
    F2Dot14 x,y;

    x = Pop(vm);
    y = Pop(vm);

    vm->gstate.freedom_vector.x = x;
    vm->gstate.freedom_vector.y = y;
    /* vm->gstate.freedom = Normalize(vm->gstate.freedom); ?? */
}
/* GPV[]   Get projection vector
 * Code Range 0x0C
 * Pops    -
 * Pushes  x: x component of projection vector (2.14 padded with zeros)
 *         y: y component of projection vector (2.14 padded with zeros)
 * Gets    projection vector
 */
void Interp_GPV(VirtualMachine *vm)
{
    ULONG l;

    l = (ULONG) vm->gstate.projection_vector.x;
    Push(vm,l);
    l = (ULONG) vm->gstate.projection_vector.y;
    Push(vm,l);
}
/* GFV[] Get freedom vector 
 * Code Range 0x0D
 * Pops    -
 * Pushes  x: x component of freedom vector (2.14 padded with zeros)
 *         y: y component of freedom vector (2.14 padded with zeros)
 * Gets    freedom vector
 */
void Interp_GFV(VirtualMachine *vm)
{
    ULONG l;

    l = (ULONG) vm->gstate.freedom_vector.x;
    Push(vm,l);
    l = (ULONG) vm->gstate.freedom_vector.y;
    Push(vm,l);
}
/* SRP0[]  Set reference point 0
 * Code Range 0x10
 * Pops    p: point number (ULONG)
 * Pushes  -
 * Sets    rp0