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
def __init__(self, grammar, **options):
if isinstance(grammar, file):
# PLY turns "a.b" into "b", so gotta get rid of the dot.
tab_filename = "parsetab_%s" % os.path.split(grammar.name)[1].replace('.', '_')
source = grammar.name
grammar = grammar.read()
else:
assert isinstance(grammar, str)
tab_filename = "parsetab_%s" % str(hash(grammar)%(2L**32))
source = '<string>'
grammar_tree = grammar_parser.parse(grammar)
if not grammar_tree:
raise GrammarException("Parse Error: Could not create grammar")
self._grammar = _Grammar(grammar_tree, source, tab_filename, **options)
#!/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())
#!/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 = './cs164c.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)
#!/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 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, parser_generator, grammar_parser, os, prolog2lua
if __name__ == '__main__':
if len(sys.argv) != 2:
print "Please give one argument (the input filename)."
sys.exit(1)
prolog_grammar = 'tests/prolog/grammar.grm'
cs164_grammar = './cs164b.grm'
prolog_ast_file = 'prolog_ast.lua'
prolog_interpreter = 'prolog.lua'
# Generate parser
prolog_parser = parser_generator.makeParser(
grammar_parser.parse(open(prolog_grammar).read()))
# Load prolog AST
prolog_ast = prolog_parser.parse(open(sys.argv[1]).read())
with open(prolog_ast_file, 'w+') as out:
prolog2lua.prettyPrint(prolog_ast, out)
os.system('lua ' + prolog_interpreter)
#!/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)
#!/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)
recognizer = parser_generator.makeRecognizer(grammar_parser.parse(open(\
sys.argv[1]).read()))
try:
if recognizer.recognize(open(sys.argv[2]).read()):
print 'Yes'
else:
print 'No'
except Ambiguous, e:
print e.value
