def initialize():
global _browser
# Initialize reusable parts of the browser infrastructure.
tmlParser = parser_generator.makeParser(grammar_parser.parseFile(tmlGrm))
print >> sys.stderr, 'TML parser loaded.'
cs164Parser = parser_generator.makeParser(
grammar_parser.parseFile(cs164Grm))
print >> sys.stderr, 'CS164 parser loaded.'
# TODO: Currently, the interpreter "object" is the module itself. Later,
# expose an API for constructing interpreters.
renderer = Renderer(interpreter)
print >> sys.stderr, 'Renderer initialized.'
_browser = Browser(tmlParser, cs164Parser, interpreter, renderer)
interpreter.ExecGlobal(cs164Parser.parse(open(cs164Lib).read()))
print >> sys.stderr, 'Browser initialized.'
print >> sys.stderr, 'Loading the layout engine modules...'
# Load the layout engine, which is implemented in 164.
dependencies = [
'object', 'node', 'window', 'box', 'hbox', 'vbox', 'link', 'word',
'img', 'script', 'rx', 'bquery', 'layout', 'browser'
]
for dependency in dependencies:
print >> sys.stderr, '\tloading ' + dependency
ast = cs164Parser.parse(
open('./browser/{0}.164'.format(dependency)).read())
interpreter.ExecGlobal(ast)
print >> sys.stderr, 'Done.'
def initialize():
global _browser
# Initialize reusable parts of the browser infrastructure.
tmlParser = parser_generator.makeParser(grammar_parser.parseFile(tmlGrm))
print >> sys.stderr, 'TML parser loaded.'
cs164Parser = parser_generator.makeParser(grammar_parser.parseFile(cs164Grm))
print >> sys.stderr, 'CS164 parser loaded.'
# TODO: Currently, the interpreter "object" is the module itself. Later,
# expose an API for constructing interpreters.
renderer = Renderer(interpreter)
print >> sys.stderr, 'Renderer initialized.'
_browser = Browser(tmlParser, cs164Parser, interpreter, renderer)
interpreter.ExecGlobal(cs164Parser.parse(open(cs164Lib).read()))
print >> sys.stderr, 'Browser initialized.'
print >> sys.stderr, 'Loading the layout engine modules...'
# Load the layout engine, which is implemented in 164.
dependencies = ['object', 'node', 'window', 'box',
'hbox', 'vbox', 'link', 'word', 'img', 'script',
'bquery', 'rx',
#TODO: Uncomment for PA8 'pbar', 'ibox'
#TODO: Uncomment for PA9 'rx',
'layout', 'browser']
for dependency in dependencies:
print >> sys.stderr, '\tloading ' + dependency
ast = cs164Parser.parse(open('./browser/{0}.164'.format(dependency)).read())
interpreter.ExecGlobal(ast)
print >> sys.stderr, 'Done.'
def GET(self):
i = web.input()
code = i.code
parser = parser_generator.makeParser(grammar_parser.parse(open('./galaC.grm').read()))
ast = parser.parse(code)
desugaredE = bytecode_compiler.desugar(ast)
return json.dumps(desugaredE)
def GET(self):
i = web.input()
code = i.code
parser = parser_generator.makeParser(
grammar_parser.parse(open('./galaC.grm').read()))
ast = parser.parse(code)
desugaredE = bytecode_compiler.desugar(ast)
return json.dumps(desugaredE)
def POST(self):
i = web.input()
code = i.code
callback = i.callback
parser = parser_generator.makeParser(grammar_parser.parse(open('./galaC.grm').read()))
ast = parser.parse(code)
desugaredE = bytecode_compiler.desugar(ast)
web.header('Content-Type', 'application/javascript')
return "%s(%s)" % (callback, json.dumps(desugaredE))
def ExecString(code, args):
""" Execute code snippet with the given arguments """
global cs164parser
if not cs164parser:
cs164grammarFile = './cs164b.grm'
cs164parser = parser_generator.makeParser(grammar_parser.parse(open(cs164grammarFile).read()))
env = args
env['__up__'] = globEnv
bc = bytecode(desugar(cs164parser.parse(code)))
Resume(bc[1], env)
def ExecString(code, args):
""" Execute code snippet with the given arguments """
global cs164parser
if not cs164parser:
cs164grammarFile = './cs164b.grm'
cs164parser = parser_generator.makeParser(
grammar_parser.parse(open(cs164grammarFile).read()))
env = args
env['__up__'] = globEnv
bc = bytecode(desugar(cs164parser.parse(code)))
Resume(bc[1], env)
def GET(self):
i = web.input()
code = i.code
callback = i.jsoncallback
print callback
print code
parser = parser_generator.makeParser(
grammar_parser.parse(open('./tst.grm').read()))
ast = parser.parse(code)
desugaredE = bytecode_compiler.desugar(ast)
web.header('Content-Type', 'application/javascript')
return "%s(%s)" % (callback, json.dumps(desugaredE))
def ExecScript(cs164_input_file, outputfilepath = None):
cs164_grammar_file = ReadFile("fortissimo/fortissimo.grm")
cs164parser = parser_generator.makeParser(grammar_parser.parse(cs164_grammar_file))
# Load program into the cs164interpreter
input_ast = cs164parser.parse(open(cs164_input_file).read())
# pprint.pprint(input_ast)
if input_ast == None:
print "Could not parse input file."
exit(-1)
interpretr = interpreter.Interpreter(False)
evaled = interpretr.evalStmt(input_ast, interpretr.global_env)
#evaled = interpreter.Exec(input_ast)
EvalNotes(evaled["_notes"], outputfilepath)
def GET(self):
i = web.input()
code = i.code
callback = i.jsoncallback
print code
parser = parser_generator.makeParser(grammar_parser.parse(open('./spacescript.grm').read()))
library = parser.parse(open('./library.164').read())
ast = parser.parse(code)
#print desugarer.desugar(ast)
#desugaredE = desugarer.desugar( library + ast)
desugaredE = bytecode_compiler.desugar(library + ast)
web.header('Content-Type', 'application/javascript')
return "%s(%s)" % (callback, json.dumps(desugaredE))
def __init__(self):
#initialize parser
cs164grammarFile = './cs164b.grm'
self.cs164bparser = parser_generator.makeParser(
grammar_parser.parse(open(cs164grammarFile).read()))
# vars for file saving
self.history = [] # history of succesfully executed lines
self.currLine = "" # and the current line, which may yet succeed
self.exec_fail = False # otherwise, how would we know if it succeeded?
# collect token information for later
self.terminals = self.cs164bparser.terminals
self.id_tkn = self.cs164bparser.tokenize('a')[0]
self.dot_tkn = self.cs164bparser.tokenize('.')[0]
self.colon_tkn = self.cs164bparser.tokenize(':')[0]
self.comma_tkn = self.cs164bparser.tokenize(',')[0]
self.open_tkn = self.cs164bparser.tokenize('(')[0]
self.close_tkn = self.cs164bparser.tokenize(')')[0]
# initialize a parser for future use
self.parser = self.cs164bparser.parse()
self.parser.next()
self.colorMap = {}
#initialize curses
self.screen = curses.initscr()
curses.start_color()
self.init_colors()
curses.noecho()
self.screen.keypad(1)
curses.curs_set(1)
curses.cbreak()
self.screen.clear()
self.screen.leaveok(False)
self.screen.scrollok(True)
self.infoBox = 0
#tab-complete specific vars
self.inTab = False
self.currentSuggestions = []
self.suggestionsIndex = 0
self.suggestedLine = ""
self.fragmentIndex = 0
#print the greeting and adjust the current line accordingly
for i in range(len(greetings)):
self.screen.addstr(i, 0, greetings[i])
self.curLineNumber = len(greetings) - 1
self.cursorx = 0
def __init__(self):
#initialize parser
cs164grammarFile = './cs164b.grm'
self.cs164bparser = parser_generator.makeParser(grammar_parser.parse(open(cs164grammarFile).read()))
# vars for file saving
self.history = [] # history of succesfully executed lines
self.currLine = "" # and the current line, which may yet succeed
self.exec_fail = False # otherwise, how would we know if it succeeded?
# collect token information for later
self.terminals = self.cs164bparser.terminals
self.id_tkn = self.cs164bparser.tokenize('a')[0]
self.dot_tkn = self.cs164bparser.tokenize('.')[0]
self.colon_tkn = self.cs164bparser.tokenize(':')[0]
self.comma_tkn = self.cs164bparser.tokenize(',')[0]
self.open_tkn = self.cs164bparser.tokenize('(')[0]
self.close_tkn = self.cs164bparser.tokenize(')')[0]
# initialize a parser for future use
self.parser = self.cs164bparser.parse()
self.parser.next()
self.colorMap = {}
#initialize curses
self.screen = curses.initscr()
curses.start_color()
self.init_colors()
curses.noecho()
self.screen.keypad(1)
curses.curs_set(1)
curses.cbreak()
self.screen.clear()
self.screen.leaveok(False)
self.screen.scrollok(True)
self.infoBox = 0
#tab-complete specific vars
self.inTab = False
self.currentSuggestions = []
self.suggestionsIndex = 0
self.suggestedLine = ""
self.fragmentIndex = 0
#print the greeting and adjust the current line accordingly
for i in range(len(greetings)):
self.screen.addstr(i,0, greetings[i])
self.curLineNumber = len(greetings)-1
self.cursorx = 0
#!/usr/bin/env python
import sys
import getopt, parser_generator, grammar_parser, interpreter
if __name__ == '__main__':
if len(sys.argv) != 2:
print "Please give one argument, the input filename."
sys.exit(1)
cs164_grammar_file = './NLP.grm'
cs164_input_file = sys.argv[1]
cs164_library_file = './library.164'
cs164parser = parser_generator.makeParser(grammar_parser.parse(open(cs164_grammar_file).read()))
# Load library into the cs164interpreter
library_ast = cs164parser.parse(open(cs164_library_file).read())
interpreter.ExecGlobal(library_ast)
# Load program into the cs164interpreter
input_ast = cs164parser.parse(open(cs164_input_file).read())
interpreter.ExecGlobal(input_ast)
def rep_loop():
ot.startOvertone()
recognizer_grm = ReadFile('fortissimo/fortissimo_repl.grm')
parser_grm = ReadFile('fortissimo/fortissimo.grm')
interp = interpreter.Interpreter()
recognizer = parser_generator.makeParser(grammar_parser.parse(recognizer_grm))
parser = parser_generator.makeParser(grammar_parser.parse(parser_grm))
line = ""
depth, num_phrases = 0, 0
phrase_list = [""]
prompt = "ff > "
while(True):
line = raw_input(prompt)
if not line.strip():
continue
try:
ast = recognizer.parse(line)
s = ast[0]
except:
print ": command not recognized"
continue
if s[0] == "quit" or s[0] == "exit":
sys.exit()
elif s[0] == "save": #REDO
f = open("saved_phrases", "w")
try:
for x in phrase_list:
f.write(x + "\n")
except:
print "Could not save phrases."
elif s[0] == "load": #REDO
f = open("saved_phrases", "r")
s = parser.parse(f.read())
try:
interp.evalStmt(ast, interp.global_env)
except:
print "Could not load."
continue
elif line == "print env": #DEBUG ONLY REMOVE LATER
pprint.pprint(interp.global_env)
elif s[0] == "print": #REDO
if len(phrase_list) == 1:
print "No phrases created"
else:
for x in phrase_list[:-1]:
print "Printing phrase: ",phrase_list.index(x) + 1
print x
elif s[0] == "phrase-end":
if depth == 0:
print "Cannot end phrase here"
elif depth == 1:
prompt = "ff > "
phrase_list[num_phrases] += line
phrase_ast = parser.parse(phrase_list[num_phrases])
try:
interp.evalStmt(phrase_ast, interp.global_env)
depth -= 1
num_phrases += 1
phrase_list.append("")
except:
pass
else:
phrase_list[num_phrases] += line + " "
depth -= 1
elif s[0] == "phrase-start":
# Starts a phrase declaration
prompt = "... "
depth += 1
phrase_list[num_phrases] += line + " "
elif s[0] == "play" and depth == 0:
# plays the notes
try:
play_env = interp.evalStmt(ast, interp.global_env)
phrases = play_env["_notes"]
interp.resetNotes()
EvalNotes(phrases)
except:
print "Could not play phrase."
elif s[0] == "loop" and depth == 0:
# Looks the input 4 times
try:
play_env = interp.evalStmt(ast, interp.global_env)
phrases = play_env["_notes"]
interp.resetNotes()
EvalNotes(phrases)
except:
print "Could not loop phrase."
elif s[0] == "record" and depth == 0:
ot.startRecording("./ff-out.wav")
elif s[0] == "stop-record" and depth == 0:
ot.stopRecording()
elif s[0] == "record-phrase" and depth == 0:
'''
Start recording a specific phrase
'''
try:
ot.startRecording()
play_env = interp.evalStmt(ast, interp.global_env)
phrases = play_env["_notes"]
interp.resetNotes()
EvalNotes(phrases, "./ff-out.wav")
except:
print "Could not record phrase."
elif s[0] == "help" and depth == 0:
help_message = """
Fortissimo Usage
================
REPL-Only Commands:
record -- starts recording to ff-out.wav
stop recording -- stops recording
record <Phrase Name> -- starts recording a phrase
help -- print this help message
exit/quit -- quit the Fortissimo REPL
Language Usage
==============
Phrase Definition:
| <Phrase Name>
<Statements>
||
Statements:
Add a list of notes -- notes <list of notes>
Set the current scale -- key of <Letter> <Scale Name>
Set the current tempo -- tempo of <Tempo>
Set the current meter -- meter of <Notes per Measure>/<Note Getting Beat>
Set the current instrument playing -- playing <Instrument Name> (with <Optional List of Arguments>)
Play a phrase -- play <Phrase Name>
Play a phrase and set the phrases attributes -- play <Phrase Name> with
-- Parameters
-- key <Key>
-- meter <Meter>
-- octave <Octave>
-- instrument <Instrument Name>
-- tempo <Tempo>
Declare an instrument -- <Instrument Name> is <Instrument>
Note Types:
Scale Number Note
-- Corresponds to number in scale
-- Form of <Scale Number>(Optional Duration)
-- e.g. 4q
Scientific Notation
-- The absolute name of a note
-- Form of <Letter><Octave>(Optional Duration)
-- e.g. c4w
Chords
-- Plays a group of notes concurrently
-- Form of (<List of Notes>)
-- e.g. (c4q e4q g4q)
Valid Durations:
w -- whole
h -- half
q -- quarter
e -- eighth
s -- sixteenth
t -- thirty-second
Available Instruments
-- Piano
-- Guitar
-- SawWave
-- Synth
-- Overpad
-- Bass
-- Ping
Available Scales
-- major
-- minor
-- melodicminor
-- harmonicminor
-- pentatonicmajor
-- bluesmajor
-- pentatonicminor
-- bluesminor
-- augmented
-- diminished
-- chromatic
-- wholehalf
-- halfwhole
-- wholetone
-- augmentedfifth
-- japanese
-- oriental
-- ionian
-- dorian
-- phrygian
-- lydian
-- mixolydian
-- aeolian
-- locrian
"""
print help_message
else:
if depth == 0:
try:
interp.evalStmt(ast, interp.global_env)
except Exception:
print "Could not execute statement."
else:
phrase_list[num_phrases] += line + " "
#!/usr/bin/env python
import sys
import getopt, parser_generator, grammar_parser, interpreter
if __name__ == '__main__':
if len(sys.argv) != 2:
print "Please give one argument, the input filename."
sys.exit(1)
cs164_grammar_file = './cs164b.grm'
cs164_input_file = sys.argv[1]
cs164_library_file = './library.164'
cs164parser = parser_generator.makeParser(
grammar_parser.parse(open(cs164_grammar_file).read()))
# Load library into the cs164interpreter
library_ast = cs164parser.parse(open(cs164_library_file).read())
interpreter.ExecGlobal(library_ast)
# Load program into the cs164interpreter
input_ast = cs164parser.parse(open(cs164_input_file).read())
interpreter.ExecGlobal(input_ast)
def evalStmt(self, stmts, env):
'''
Evaluates a list of statements in a given environment.
'''
def doCall(phrase, args):
'''
"Calls" a phrase. Essentially evaluates the phrase
and returns its environment, typically to retreive the notelist.
'''
new_env = {}
new_env['__up__'] = phrase.outer_env
new_env["_notes"] = [{}]
for i in range(len(args)):
new_env[phrase.args[i]] = args[i]
return self.evalStmt(phrase.body, new_env)
def doCall2(phrase, args):
'''
"Calls" a phrase. This uses the language construct we have to
specify the key, scale, instrument, etc to be used in the
Phrases.
'''
new_env = {}
new_env['__up__'] = phrase.outer_env
new_env["_notes"] = [{}]
for arg in args:
if arg[0] == "key":
new_env["_scale"] = key_engine(arg[1], arg[2])
elif arg[0] == "instr":
new_env[arg[1]] = arg[2]
else:
new_env["_" + arg[0]] = arg[1]
return self.evalStmt(phrase.body, new_env)
def update(name,env,val):
'''
Updates a binding in the environment to a given value.
'''
if not env:
sys.exit(1)
elif name in env:
env[name] = val
else:
update(name,env['__up__'],val)
# Evaluate the statements
for s in stmts:
if s[0] == 'phrase-def':
# Phrase definition, binds a phrase to a name in
# the environment
env[s[1]] = Phrase(s[1], s[3], s[2], env)
elif s[0] == "play":
# Play each phrase sequentially
for p in s[1]:
phrase = self.lookup(p, env)
val = doCall(phrase, phrase.args)
if self.recording == True:
env["_notes"] = val["_notes"]
else:
if env["_notes"][0] == {}:
env["_notes"] = val["_notes"]
else:
env["_notes"].extend(val["_notes"])
elif s[0] == 'play-with': # only one phrase can follow after
phrase = self.lookup(s[1], env)
val = doCall2(phrase, s[2])
if self.recording == True:
env["_notes"] = val["_notes"]
else:
if env["_notes"][0] == {}:
env["_notes"] = val["_notes"]
else:
env["_notes"].extend(val["_notes"])
elif s[0] == 'loop':
# Loops a set of phrases
self.evalStmt(s[1], env)
elif s[0] == "asgn":
# Assign a binding in the environment
env[s[1]] = s[2]
elif s[0] == "playing":
# Sets the current instrument to be played
if s[1] in env.keys():
env["_currInstr"] = env[s[1]]
else:
env["_currInstr"] = s[1]
elif s[0] == "playing-in":
# Sets the current instrument to be played and the
# octave it will be played in
if s[1] in env.keys():
env["_currInstr"] = env[s[1]]
else:
env["_currInstr"] = s[1]
if "_octave"in env.keys() and env["__up__"] is not None:
pass
else:
env["_octave"] = s[2]
elif s[0] == "key":
# Declare the key to be played
if "_scale" in env.keys() and env["__up__"] is not None:
print "passing"
pass
else:
# Calls the key engine to dynamically generate the
# notes in the scale
env["_scale"] = key_engine(s[1], s[2])
elif s[0] == "meter":
# Declare the meter
if "_meter" in env.keys() and env["__up__"] is not None:
pass
else:
env["_meter"] = s[1]
elif s[0] == "tempo":
# Declare the tempo
if "_tempo" in env.keys() and env["__up__"] is not None:
env["_tempo"] = s[1]
elif s[0] == "duration":
# Declare the default duration to be played
if "_duration" in env.keys() and env["__up__"] is not None:
pass
else:
env["_duration"] = s[1]
elif s[0] == 'import-instr':
# Imports an instrument that can be used in writing songs
filename = s[1]
ot.importInstrument(filename)
elif s[0] == 'include':
# Include phrases from another file
filename = s[1]
try:
# Parse and interpret the phrase to get the notelist and environment
fil = open(filename, "r")
text = fil.read()
fil.close()
grammar_file = ReadFile("fortissimo/fortissimo.grm")
parser = parser_generator.makeParser(grammar_parser.parse(cs164_grammar_file))
input_ast = parser.parse(text)
interpr = Intepreter(False)
new_env = interpr.evalStmt(input_ast, interpr.global_env)
self.global_env.update(new_env)
except:
print "Could not include file '" + filename + "'."
elif s[0] == "notes":
# Adds notes to the environments notelist
self.addNotesToQueue(s[1], env)
else:
raise SyntaxError("Illegal or Unimplemented AST node: " + str(s))
return env
#!/usr/bin/env python
import sys, parser_generator, grammar_parser
from util import Ambiguous
if __name__ == '__main__':
if len(sys.argv) != 3:
print "Please give two arguments, the grammar filename and the input filename."
sys.exit(1)
parser = parser_generator.makeParser(
grammar_parser.parse(open(sys.argv[1]).read()))
try:
ast = parser.parse(open(sys.argv[2]).read())
print ast
except SyntaxError, e:
print e
#!/usr/bin/env python
import sys, parser_generator
import grammar_parser
if __name__ == '__main__':
if len(sys.argv) != 2:
print "Please give one argument the input filename."
sys.exit(1)
grammar = 'tests/ucalc/grammar.grm'
parser = parser_generator.makeParser(
grammar_parser.parse(open(grammar).read()))
print parser.parse(open(sys.argv[1]).read())
