page_max: return False # "Unfortunately RELOCAT can't put it at &%X even with PAGE changes." % reloc_addr
+ return " Please run RELOCAT with PAGE in the range of &%X to &%X for this relocation to work.%s" % (newpage,page_max,extra)
+ if noSRAM_default_addr+noSRAM_lex_offset+size > noSRAM_himem:
+ reloc_addr = noSRAM_himem-noSRAM_lex_offset-size
+ reloc_addr -= (reloc_addr%256)
+ if reloc_addr >= noSRAM_min_addr:
+ instr = special_relocate_instructions(reloc_addr)
+ if instr==False: print ("This lexicon is too big for Speech in main RAM even with relocation, unless RELOCAT is rewritten to work from files.")
+ else:
+ bbcStart = reloc_addr+noSRAM_lex_offset
+ reloc_call = reloc_addr + 0xB00
+ print ("This lexicon is too big for Speech at its default address of &%X, but you could use RELOCAT to put a version at &%X and then initialise it with CALL %s (or do the suggested *SAVE, reset, and run *SP). Be sure to set HIMEM=&%X. Then *LOAD %s %X or change the relocated SP file from offset &%X.%s" % (noSRAM_default_addr,reloc_addr,bbcshortest(reloc_call),reloc_addr,fname,bbcStart,noSRAM_lex_offset,instr))
+ else: print ("This lexicon is too big for Speech in main RAM even with relocation.")
+ else: # fits at default location - no relocation needed
+ bbcStart = noSRAM_default_addr+noSRAM_lex_offset
+ print ("You can load this lexicon by *LOAD %s %X or change the SPEECH file from offset &%X. Suggest you also set HIMEM=&%X for safety." % (fname,bbcStart,noSRAM_lex_offset,noSRAM_default_addr))
+ if bbcStart: # we managed to fit it into main RAM
+ f = open(fname)
+ keys = bbcKeystrokes(getBuf(f).read(),bbcStart)
+ f = open(fname+".key","w")
+ getBuf(f).write(keys)
+ del f
+ print ("For ease of transfer to emulators etc, a self-contained keystroke file for putting %s data at &%X has been written to %s.key" % (fname,bbcStart,fname))
+ if len(keys) > 32767: print ("(This file looks too big for BeebEm to paste though)") # see comments elsewhere
+ # Instructions for replacing lex in SRAM:
+ if size > SRAM_max-SRAM_lex_offset: print ("This lexicon is too big for Speech in Sideways RAM.") # unless you can patch Speech to run in SRAM but read its lexicon from main RAM, or run in main RAM but page in multiple banks of SRAM for the lexicon (but even then there'll be a limit)
+ else: print ("You can load this lexicon into Sideways RAM by *SRLOAD %s %X 7 (or whichever bank number you're using), or change the SP8000 file from offset &%X." % (fname,SRAM_lex_offset+0x8000,SRAM_lex_offset))
+ if not os.environ.get("SPEECH_DISK",""): print ("If you want to append the default lexicon to this one, set SPEECH_DISK to the image of the original Speech disk before running lexconvert, e.g. export SPEECH_DISK=/usr/local/BeebEm3/diskimg/Speech.ssd")
+ if size <= SRAM_max-SRAM_lex_offset: print ("You can also set MAKE_SPEECH_ROM=1 (along with SPEECH_DISK) to create a SPEECH.ROM file instead")
+ print ("If you get 'Mistake in speech' when testing some words, try starting with '*SAY, ' (this seems to be a Speech bug)") # - can't track down which words it does and doesn't apply to
+ print ("It might be better to load your lexicon into eSpeak and use lexconvert's --phones option to drive the BBC with phonemes.")
+
+def mainopt_version(i):
+ # TODO: doc string for the help? (or would this option clutter it needlessly) - just print lexconvert's version number and nothing else
+ print (__doc__.split("\n")[0].split(" - ")[0])
+
+def main():
+ """Introspect the module to find the mainopt_ functions, and either call one of them or print the help. Returns the error code to send back to the OS."""
+ def funcToOpt(n): return "--"+n[n.index("_")+1:].replace("_","-")
+ for k,v in globals().items():
+ if k.startswith('mainopt_') and funcToOpt(k) in sys.argv:
+ try: msg = v(sys.argv.index(funcToOpt(k)))
+ except Message:
+ # Python 2.6+ can have "except Message as e",
+ # but Python 2.5 has to have "except Message,e"
+ # which is disallowed in Python 3, so
+ msg=sys.exc_info()[1].message
+ if msg:
+ sys.stdout.flush()
+ sys.stderr.write(msg+"\n") ; return 1
+ else: return 0
+ html = ('--htmlhelp' in sys.argv) # (undocumented option used for my website, don't rely on it staying)
+ def htmlify(h): return re.sub('(--[2A-Za-z-]*)',r'\1',h.replace('&','&').replace('<','<').replace('>','>').replace('\n','
'))
+ if not html: htmlify = lambda x:x
+ print (htmlify(__doc__))
+ if html: missALine = ""
+ else: missALine = ""
+ print (missALine)
+ if '--formats' in sys.argv: # non-HTML mode only (format descriptions are included in HTML anyway, and don't worry about the capability summary)
+ print ("Available pronunciation formats (and support levels):")
+ keys=list(lexFormats.keys()) ; keys.sort()
+ for k in keys:
+ types = []
+ if not k=="example": types.append("phones")
+ if k=="mac-uk": types.append("speaking")
+ else:
+ if checkSetting(k,"lex_read_function"): types.append("lex-read")
+ if checkSetting(k,"lex_filename") and checkSetting(k,"lex_entry_format"):
+ ltype = checkSetting(k,"lex_type")
+ if ltype: ltype=" as "+ltype
+ types.append("lex-write"+ltype)
+ print ("\n"+k+" ("+", ".join(types)+")")
+ print (getSetting(k,"doc"))
+ return 0
+ elif html:
+ print ("Available pronunciation formats:")
+ if html: print ('
")
+ else: print ("Available pronunciation formats: "+", ".join(sorted(list(lexFormats.keys())))+"\n(Use --formats to see their descriptions)")
+ print (missALine)
+ print ("Program options:")
+ print (missALine)
+ if html: print ("")
+ for _,opt,desc in sorted([(not not v.__doc__ and not v.__doc__.startswith('*'),k,v.__doc__) for k,v in globals().items()]):
+ if not opt.startswith("mainopt_"): continue
+ opt = funcToOpt(opt)
+ if not desc: continue # undocumented option
+ params,rest = desc.split("\n",1)
+ if params.startswith('*'): params=params[1:]
+ if params: opt += (' '+params)
+ if html: print ("- "+htmlify(opt)+"
- "+htmlify(rest)+"
")
+ else: print (opt+"\n"+rest+"\n")
+ if html: print ("
")
+ return 0
+
+catchingSigs = inSigHandler = False
+def catchSignals():
+ "We had better try to catch all signals if using MacBritish_System_Lexicon so we can safely clean it up. We raise KeyboardInterrupt instead (need to catch this). Might not work with multithreaded code."
+ global catchingSigs
+ if catchingSigs: return
+ catchingSigs = True
+ import signal
+ def f(sigNo,*args):
+ global inSigHandler
+ if inSigHandler: return
+ inSigHandler = True
+ os.killpg(os.getpgrp(),sigNo)
+ sys.stderr.write("\nCaught signal %d\n" % sigNo)
+ raise KeyboardInterrupt
+ for n in xrange(1,signal.NSIG):
+ if not n in [
+ signal.SIGCHLD, # sent on subprocess completion
+ signal.SIGTSTP,signal.SIGCONT, # Ctrl-Z / fg
+ signal.SIGWINCH, # window-size change
+ ] and not signal.getsignal(n)==signal.SIG_IGN:
+ try: signal.signal(n,f)
+ except: pass
+class MacBritish_System_Lexicon(object):
+ """Overwrites some of the pronunciations in the system
+ lexicon (after backing up the original). Cannot
+ change the actual words in the system lexicon, so just
+ alters pronunciations of words you don't intend to use
+ so you can substitute these into your texts.
+ Restores the lexicon on close()."""
+ instances = {}
+ def __init__(self,text="",voice="Daniel"):
+ """text is the text you want to speak (so that any
+ words used in it that are not mentioned in your
+ lexicon are unchanged in the system lexicon);
+ text="" means you just want to speak phonemes.
+ Special value of text=False means lexicon read only.
+ voice can be Daniel, Emily or Serena."""
+ self.voice = False
+ if not text==False:
+ assert not voice in MacBritish_System_Lexicon.instances, "There is already another instance of MacBritish_System_Lexicon for the "+voice+" voice"
+ assert not os.system("lockfile -1 -r 10 /tmp/"+voice+".PCMWave.lock") # in case some other process has it (note: if you run with python -O, this check won't happen!)
+ self.voice = voice # (don't set this if text==False, since we won't need cleanup on __del__)
+ self.filename = "/System/Library/Speech/Voices/"+voice+".SpeechVoice/Contents/Resources/PCMWave"
+ assert not (not os.path.exists(self.filename) and os.path.exists("/System/Library/Speech/Voices/"+voice+"Compact.SpeechVoice/Contents/Resources/PCMWave")), "The only installation of "+voice+" found on this system was the Compact one, which lexconvert does not yet support" # TODO: could try self.wordIndexStart = findW("Abiquiu"),self.phIndexStart = findW("'@b.Ik.ju"),self.wordIndexEnd = findW("www.youtube.com",1),self.phIndexEnd = findW("'d^b.l.ju.'d^b.l.ju.'d^b.l.ju.dA+t.'ju.'tjub.dA+t.kA+m",1), but "t" in phones should be ignored, "activesync" and "afterlife" have no phones, "aqua" has TWO sets of phonemes (aquarium ok) and there are other synchronization issues.
+ # TODO: some sync issues persist even on the NON-Compact version in newer versions of macOS (e.g. 10.12). This currently leads to exceptions in findW on such systems (which do say it could be due to wrong version of the voice); fixing would need looking at more sync issues as above
+ assert os.path.exists(self.filename),"Cannot find an installation of '"+voice+"' on this system"
+ if os.path.exists(self.filename+"0"):
+ if text==False: self.filename += "0" # (use the backup file for read-only, if we created one before; this means we don't have to worry about locks)
+ elif not text==False: # create a backup
+ sys.stderr.write("Backing up "+self.filename+" to "+self.filename+"0...\n") # (you'll need a password if you're not running as root)
+ err = os.system("sudo mv \""+self.filename+"\" \""+self.filename+"0\"; sudo cp \""+self.filename+"0\" \""+self.filename+"\"; sudo chown "+str(os.getuid())+" \""+self.filename+"\"")
+ assert not err, "Error creating backup"
+ lexFile = self.filename+".lexdir"
+ if not os.path.exists(lexFile) and not text==False:
+ sys.stderr.write("Creating lexdir file...\n")
+ err = os.system("sudo touch \""+lexFile+"\" ; sudo chown "+str(os.getuid())+" \""+lexFile+"\"")
+ assert not err, "Error creating lexdir"
+ compat_err = "\nThis probably means your Mac has a new version of the voice that is no longer compatible with this system-lexicon patch."
+ import cPickle
+ if os.path.exists(lexFile) and os.stat(lexFile).st_size: self.wordIndexStart,self.wordIndexEnd,self.phIndexStart,self.phIndexEnd = cPickle.Unpickler(open(lexFile)).load()
+ else:
+ f = open(self.filename)
+ dat = getBuf(f).read()
+ def findW(word,rtnPastEnd=0):
+ i = re.finditer(re.escape(word+chr(0)),dat)
+ try: n = i.next()
+ except StopIteration: raise Exception(word+" not found in voice file"+compat_err)
+ try:
+ n2 = i.next()
+ raise Exception("%s does not uniquely identify a byte position (has at least %d and %d)%s" % (word,n.start(),n2.start(),compat_err))
+ except StopIteration: pass
+ if rtnPastEnd: return n.end()
+ else: return n.start()
+ self.wordIndexStart = findW("808s")
+ self.phIndexStart = findW("'e&It.o&U.e&Its")
+ self.wordIndexEnd = findW("zombie",1)
+ self.phIndexEnd = findW("'zA+m.bI",1)
+ if not text==False: cPickle.Pickler(open(lexFile,"w")).dump((self.wordIndexStart,self.wordIndexEnd,self.phIndexStart,self.phIndexEnd))
+ if text==False: self.dFile = open(self.filename)
+ else: self.dFile = open(self.filename,'r+')
+ assert len(self.allWords()) == len(self.allPh()), str(len(self.allWords()))+" words but "+str(len(self.allPh()))+" phonemes"+compat_err
+ self.textToAvoid = u""
+ if text==False: return
+ MacBritish_System_Lexicon.instances[voice] = self
+ self.textToAvoid = text.decode('utf-8').replace(unichr(160),' ') ; self.restoreDic = {}
+ catchSignals()
+ def allWords(self):
+ "Returns a list of words that are defined in the system lexicon (which won't be changed, but see allPh)"
+ self.dFile.seek(self.wordIndexStart)
+ return [x for x in getBuf(self.dFile).read(self.wordIndexEnd-self.wordIndexStart).split(chr(0)) if x]
+ def allPh(self):
+ "Returns a list of (file position, phoneme string) for each of the primary phoneme entries from the system lexicon. These entries can be changed in-place by writing to the said file position, and then spoken by giving the voice the corresponding word from allWords (but see also usable_words)."
+ self.dFile.seek(self.phIndexStart)
+ def f(l):
+ last = None ; r = [] ; pos = self.phIndexStart
+ for i in l:
+ if re.search(r'[ -~]',i) and not i in ["'a&I.'fo&Un","'lI.@n","'so&Un.j$"] and not (i==last and i in ["'tR+e&I.si"]): r.append((pos,i)) # (the listed pronunciations are secondary ones that for some reason are in the list)
+ if re.search(r'[ -~]',i): last = i
+ pos += (len(i)+1) # +1 for the \x00
+ assert pos==self.phIndexEnd+1 # +1 because the last \00 will result in a "" item after; the above +1 will be incorrect for that item
+ return r
+ return f([x for x in getBuf(self.dFile).read(self.phIndexEnd-self.phIndexStart).split(chr(0))])
+ def usable_words(self,words_ok_to_redefine=[]):
+ "Returns a list of (word,phoneme_file_position,original_phonemes) by combining allWords with allPh, but omitting any words that don't seem 'usable' (for example words that contain spaces, since these lexicon entries don't seem to be actually used by the voice). Words that occur in self.textToAvoid are also considered non-usable, unless they also occur in words_ok_to_redefine (user lexicon)."
+ for word,(pos,phonemes) in zip(self.allWords(),self.allPh()):
+ if not re.match("^[a-z0-9]*$",word): continue # it seems words not matching this regexp are NOT used by the engine
+ if not (phonemes and 32