_accessstrings = {0: "", 1: "readonly", 2: "executeonly", 3: "noaccess"}
class ps_object:
literal = 1
access = 0
value = None
def __init__(self, value):
self.value = value
self.type = self.__class__.__name__[3:] + "type"
def __repr__(self):
return "<%s %s>" % (self.__class__.__name__[3:], repr(self.value))
class ps_operator(ps_object):
literal = 0
def __init__(self, name, function):
self.name = name
self.function = function
self.type = self.__class__.__name__[3:] + "type"
def __repr__(self):
return "<operator %s>" % self.name
class ps_procedure(ps_object):
literal = 0
def __repr__(self):
return "<procedure>"
def __str__(self):
psstring = '{'
for i in range(len(self.value)):
if i:
psstring = psstring + ' ' + str(self.value[i])
else:
psstring = psstring + str(self.value[i])
return psstring + '}'
class ps_name(ps_object):
literal = 0
def __str__(self):
if self.literal:
return '/' + self.value
else:
return self.value
class ps_literal(ps_object):
def __str__(self):
return '/' + self.value
class ps_array(ps_object):
def __str__(self):
psstring = '['
for i in range(len(self.value)):
item = self.value[i]
access = _accessstrings[item.access]
if access:
access = ' ' + access
if i:
psstring = psstring + ' ' + str(item) + access
else:
psstring = psstring + str(item) + access
return psstring + ']'
def __repr__(self):
return "<array>"
_type1_pre_eexec_order = [
"FontInfo",
"FontName",
"Encoding",
"PaintType",
"FontType",
"FontMatrix",
"FontBBox",
"UniqueID",
"Metrics",
"StrokeWidth"
]
_type1_fontinfo_order = [
"version",
"Notice",
"FullName",
"FamilyName",
"Weight",
"ItalicAngle",
"isFixedPitch",
"UnderlinePosition",
"UnderlineThickness"
]
_type1_post_eexec_order = [
"Private",
"CharStrings",
"FID"
]
def _type1_item_repr(key, value):
psstring = ""
access = _accessstrings[value.access]
if access:
access = access + ' '
if key == 'CharStrings':
psstring = psstring + "/%s %s def\n" % (key, _type1_CharString_repr(value.value))
elif key == 'Encoding':
psstring = psstring + _type1_Encoding_repr(value, access)
else:
psstring = psstring + "/%s %s %sdef\n" % (str(key), str(value), access)
return psstring
def _type1_Encoding_repr(encoding, access):
encoding = encoding.value
psstring = "/Encoding 256 array\n0 1 255 {1 index exch /.notdef put} for\n"
for i in range(256):
name = encoding[i].value
if name <> '.notdef':
psstring = psstring + "dup %d /%s put\n" % (i, name)
return psstring + access + "def\n"
def _type1_CharString_repr(charstrings):
items = charstrings.items()
items.sort()
return 'xxx'
class ps_font(ps_object):
def __str__(self):
psstring = "%d dict dup begin\n" % len(self.value)
for key in _type1_pre_eexec_order:
try:
value = self.value[key]
except KeyError:
pass
else:
psstring = psstring + _type1_item_repr(key, value)
items = self.value.items()
items.sort()
for key, value in items:
if key not in _type1_pre_eexec_order + _type1_post_eexec_order:
psstring = psstring + _type1_item_repr(key, value)
psstring = psstring + "currentdict end\ncurrentfile eexec\ndup "
for key in _type1_post_eexec_order:
try:
value = self.value[key]
except KeyError:
pass
else:
psstring = psstring + _type1_item_repr(key, value)
return psstring + 'dup/FontName get exch definefont pop\nmark currentfile closefile\n' + \
8 * (64 * '0' + '\n') + 'cleartomark' + '\n'
def __repr__(self):
return '<font>'
class ps_file(ps_object):
pass
class ps_dict(ps_object):
def __str__(self):
psstring = "%d dict dup begin\n" % len(self.value)
items = self.value.items()
items.sort()
dictrepr = "%d dict dup begin\n" % len(items)
for key, value in items:
access = _accessstrings[value.access]
if access:
access = access + ' '
psstring = psstring + "/%s %s %sdef\n" % (str(key), str(value), access)
return psstring + 'end '
def __repr__(self):
return "<dict>"
class ps_mark(ps_object):
def __init__(self):
self.value = 'mark'
self.type = self.__class__.__name__[3:] + "type"
class ps_procmark(ps_object):
def __init__(self):
self.value = 'procmark'
self.type = self.__class__.__name__[3:] + "type"
class ps_null(ps_object):
def __init__(self):
self.type = self.__class__.__name__[3:] + "type"
class ps_boolean(ps_object):
def __str__(self):
if self.value:
return 'true'
else:
return 'false'
class ps_string(ps_object):
def __str__(self):
return "(%s)" % `self.value`[1:-1]
class ps_integer(ps_object):
def __str__(self):
return `self.value`
class ps_real(ps_object):
def __str__(self):
return `self.value`
class PSOperators:
def ps_def(self):
object = self.pop()
name = self.pop()
self.dictstack[-1][name.value] = object
def ps_bind(self):
proc = self.pop('proceduretype')
self.proc_bind(proc)
self.push(proc)
def proc_bind(self, proc):
for i in range(len(proc.value)):
item = proc.value[i]
if item.type == 'proceduretype':
self.proc_bind(item)
else:
if not item.literal:
try:
object = self.resolve_name(item.value)
except:
pass
else:
if object.type == 'operatortype':
proc.value[i] = object
def ps_exch(self):
if len(self.stack) < 2:
raise RuntimeError, 'stack underflow'
obj1 = self.pop()
obj2 = self.pop()
self.push(obj1)
self.push(obj2)
def ps_dup(self):
if not self.stack:
raise RuntimeError, 'stack underflow'
self.push(self.stack[-1])
def ps_exec(self):
object = self.pop()
if object.type == 'proceduretype':
self.call_procedure(object)
else:
self.handle_object(object)
def ps_count(self):
self.push(ps_integer(len(self.stack)))
def ps_eq(self):
any1 = self.pop()
any2 = self.pop()
self.push(ps_boolean(any1.value == any2.value))
def ps_ne(self):
any1 = self.pop()
any2 = self.pop()
self.push(ps_boolean(any1.value <> any2.value))
def ps_cvx(self):
obj = self.pop()
obj.literal = 0
self.push(obj)
def ps_matrix(self):
matrix = [ps_real(1.0), ps_integer(0), ps_integer(0), ps_real(1.0), ps_integer(0), ps_integer(0)]
self.push(ps_array(matrix))
def ps_string(self):
num = self.pop('integertype').value
self.push(ps_string('\0' * num))
def ps_type(self):
obj = self.pop()
self.push(ps_string(obj.type))
def ps_store(self):
value = self.pop()
key = self.pop()
name = key.value
for i in range(len(self.dictstack)-1, -1, -1):
if self.dictstack[i].has_key(name):
self.dictstack[i][name] = value
break
self.dictstack[-1][name] = value
def ps_where(self):
name = self.pop()
# XXX
self.push(ps_boolean(0))
def ps_systemdict(self):
self.push(ps_dict(self.dictstack[0]))
def ps_userdict(self):
self.push(ps_dict(self.dictstack[1]))
def ps_currentdict(self):
self.push(ps_dict(self.dictstack[-1]))
def ps_currentfile(self):
self.push(ps_file(self.tokenizer))
def ps_eexec(self):
file = self.pop('filetype').value
file.starteexec()
def ps_closefile(self):
file = self.pop('filetype').value
file.skipwhite()
file.stopeexec()
def ps_cleartomark(self):
obj = self.pop()
while obj <> self.mark:
obj = self.pop()
def ps_readstring(self,
ps_boolean = ps_boolean,
len = len):
s = self.pop('stringtype')
oldstr = s.value
file = self.pop('filetype')
#pad = file.value.read(1)
# for StringIO, this is faster
file.value.pos = file.value.pos + 1
newstr = file.value.read(len(oldstr))
s.value = newstr
self.push(s)
self.push(ps_boolean(len(oldstr) == len(newstr)))
def ps_known(self):
key = self.pop()
dict = self.pop('dicttype', 'fonttype')
self.push(ps_boolean(dict.value.has_key(key.value)))
def ps_if(self):
proc = self.pop('proceduretype')
bool = self.pop('booleantype')
if bool.value:
self.call_procedure(proc)
def ps_ifelse(self):
proc2 = self.pop('proceduretype')
proc1 = self.pop('proceduretype')
bool = self.pop('booleantype')
if bool.value:
self.call_procedure(proc1)
else:
self.call_procedure(proc2)
def ps_readonly(self):
obj = self.pop()
if obj.access < 1:
obj.access = 1
self.push(obj)
def ps_executeonly(self):
obj = self.pop()
if obj.access < 2:
obj.access = 2
self.push(obj)
def ps_noaccess(self):
obj = self.pop()
if obj.access < 3:
obj.access = 3
self.push(obj)
def ps_not(self):
obj = self.pop('booleantype', 'integertype')
if obj.type == 'booleantype':
self.push(ps_boolean(not obj.value))
else:
self.push(ps_integer(~obj.value))
def ps_print(self):
str = self.pop('stringtype')
print 'PS output --->', str.value
def ps_anchorsearch(self):
seek = self.pop('stringtype')
s = self.pop('stringtype')
seeklen = len(seek.value)
if s.value[:seeklen] == seek.value:
self.push(ps_string(s.value[seeklen:]))
self.push(seek)
self.push(ps_boolean(1))
else:
self.push(s)
self.push(ps_boolean(0))
def ps_array(self):
num = self.pop('integertype')
array = ps_array([None] * num.value)
self.push(array)
def ps_astore(self):
array = self.pop('arraytype')
for i in range(len(array.value)-1, -1, -1):
array.value[i] = self.pop()
self.push(array)
def ps_load(self):
name = self.pop()
object = self.resolve_name(name.value)
self.push(object)
def ps_put(self):
obj1 = self.pop()
obj2 = self.pop()
obj3 = self.pop('arraytype', 'dicttype', 'stringtype', 'proceduretype')
tp = obj3.type
if tp == 'arraytype' or tp == 'proceduretype':
obj3.value[obj2.value] = obj1
elif tp == 'dicttype':
obj3.value[obj2.value] = obj1
elif tp == 'stringtype':
index = obj2.value
obj3.value = obj3.value[:index] + chr(obj1.value) + obj3.value[index+1:]
def ps_get(self):
obj1 = self.pop()
if obj1.value == "Encoding":
pass
obj2 = self.pop('arraytype', 'dicttype', 'stringtype', 'proceduretype', 'fonttype')
tp = obj2.type
if tp in ('arraytype', 'proceduretype'):
self.push(obj2.value[obj1.value])
elif tp in ('dicttype', 'fonttype'):
self.push(obj2.value[obj1.value])
elif tp == 'stringtype':
self.push(ps_integer(ord(obj2.value[obj1.value])))
else:
assert 0, "shouldn't get here"
def ps_getinterval(self):
obj1 = self.pop('integertype')
obj2 = self.pop('integertype')
obj3 = self.pop('arraytype', 'stringtype')
tp = obj3.type
if tp == 'arraytype':
self.push(ps_array(obj3.value[obj2.value:obj2.value + obj1.value]))
elif tp == 'stringtype':
self.push(ps_string(obj3.value[obj2.value:obj2.value + obj1.value]))
def ps_putinterval(self):
obj1 = self.pop('arraytype', 'stringtype')
obj2 = self.pop('integertype')
obj3 = self.pop('arraytype', 'stringtype')
tp = obj3.type
if tp == 'arraytype':
obj3.value[obj2.value:obj2.value + len(obj1.value)] = obj1.value
elif tp == 'stringtype':
newstr = obj3.value[:obj2.value]
newstr = newstr + obj1.value
newstr = newstr + obj3.value[obj2.value + len(obj1.value):]
obj3.value = newstr
def ps_cvn(self):
str = self.pop('stringtype')
self.push(ps_name(str.value))
def ps_index(self):
n = self.pop('integertype').value
if n < 0:
raise RuntimeError, 'index may not be negative'
self.push(self.stack[-1-n])
def ps_for(self):
proc = self.pop('proceduretype')
limit = self.pop('integertype', 'realtype').value
increment = self.pop('integertype', 'realtype').value
i = self.pop('integertype', 'realtype').value
while 1:
if increment > 0:
if i > limit:
break
else:
if i < limit:
break
if type(i) == type(0.0):
self.push(ps_real(i))
else:
self.push(ps_integer(i))
self.call_procedure(proc)
i = i + increment
def ps_forall(self):
proc = self.pop('proceduretype')
obj = self.pop('arraytype', 'stringtype', 'dicttype')
tp = obj.type
if tp == 'arraytype':
for item in obj.value:
self.push(item)
self.call_procedure(proc)
elif tp == 'stringtype':
for item in obj.value:
self.push(ps_integer(ord(item)))
self.call_procedure(proc)
elif tp == 'dicttype':
for key, value in obj.value.items():
self.push(ps_name(key))
self.push(value)
self.call_procedure(proc)
def ps_definefont(self):
font = self.pop('dicttype')
name = self.pop()
font = ps_font(font.value)
self.dictstack[0]['FontDirectory'].value[name.value] = font
self.push(font)
def ps_findfont(self):
name = self.pop()
font = self.dictstack[0]['FontDirectory'].value[name.value]
self.push(font)
def ps_pop(self):
self.pop()
def ps_dict(self):
num = self.pop('integertype')
dict = ps_dict({})
self.push(dict)
def ps_begin(self):
dict = self.pop('dicttype')
self.dictstack.append(dict.value)
def ps_end(self):
if len(self.dictstack) > 2:
del self.dictstack[-1]
else:
raise RuntimeError, 'dictstack underflow'
notdef = '.notdef'
from fontTools.encodings.StandardEncoding import StandardEncoding
ps_StandardEncoding = map(ps_name, StandardEncoding)
|