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())