def testPackageManager_import(self): # PackageManager.import_ imports symbol to symbol container of the specific package. # The package_name argument is omitted, # the method imports symbol to PackageManager.current_package.symbol_container. # IMPORT is interned to PakageManager.package_container['COMMON-LISP-USER']. PackageManager.intern(symbol_designator=String('IMPORT'), package_designator=String('COMMON-LISP-USER')) # Add value to the variable space. PackageManager.package_container['COMMON-LISP-USER'].env['VARIABLE']['IMPORT'] = String('VALUE') PackageManager.import_(symbol_designator=Symbol('COMMON-LISP-USER::IMPORT')) symbol, status = PackageManager.find_symbol(symbol_designator=String('IMPORT')) self.assertTrue(symbol is Symbol('IMPORT')) self.assertTrue(status is Keyword(':INTERNAL')) self.assertTrue(PackageManager.current_package.env['VARIABLE']['IMPORT'] is String('VALUE')) # The package_designator argument is supplied to the specified package. # IMPORT-WITH-PACKAGE is interned to COMMON-LISP package. PackageManager.intern(symbol_designator=String('IMPORT-WITH-PACKAGE'), package_designator=String('COMMON-LISP')) # Add value to the variable space. PackageManager.package_container['COMMON-LISP'].env['VARIABLE']['IMPORT-WITH-PACKAGE'] = String('VALUE') PackageManager.import_(symbol_designator=Symbol('COMMON-LISP::IMPORT-WITH-PACKAGE'), package_designator=Symbol('COMMON-LISP-USER')) symbol, status = PackageManager.find_symbol(symbol_designator=String('IMPORT-WITH-PACKAGE'), package_designator=String('COMMON-LISP-USER')) self.assertTrue(symbol is Symbol('IMPORT-WITH-PACKAGE')) self.assertTrue(status is Keyword(':INTERNAL')) self.assertTrue(PackageManager.package_container['COMMON-LISP-USER'].env['VARIABLE']['IMPORT-WITH-PACKAGE'] is String('VALUE'))
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of ImportModuleObjectManipulation. """ while forms is not Null(): symbol, module_name, forms = forms.car, forms.cdr.car, forms.cdr.cdr symbol_name = symbol.value module = PyObject(import_module(module_name.value)) # Interns symbol that represents module name into current package. PackageManager.intern(String(symbol_name)) # import-moduel may be used for assignment of both lexical and dynamic variables. try: var_env.find(symbol_name)[symbol_name] = module except LookupError: try: # package_name=None means finding an environment from current package. PackageManager.find( symbol_name, package_name=None, status_check=False)[symbol_name] = module except LookupError: PackageManager.current_package.env['VARIABLE'][ symbol_name] = module # the primary value of the last form return symbol
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of UsePackageSystemFunction. """ args = self.eval_forms(forms, var_env, func_env, macro_env) package_designator_to_use = args.car package_designator = args.cdr.car # Checks package_designator whether it is given or not. if package_designator is Null(): package_designator = None if isinstance(package_designator_to_use, Cons): # If package_designator_to_use is symbol list, exports all symbols. while package_designator_to_use.cdr is not Null(): PackageManager.use_package( package_designator_to_use=package_designator_to_use.car, package_designator=package_designator ) package_designator_to_use = package_designator_to_use.cdr # The last package_dexignator_to_use. return PackageManager.use_package( package_designator_to_use=package_designator_to_use.car, package_designator=package_designator ) else: return PackageManager.use_package( package_designator_to_use=package_designator_to_use, package_designator=package_designator )
def eval(cls, forms, var_env, func_env, macro_env): if isinstance(forms, Null): # Returns nil. return forms elif isinstance(forms, Symbol): # Gets symbol_name, package_name, and status_check. symbol_name, package_name, status_check = PackageManager.split_symbol_name( forms.value) # Gets the value binded by the symbol. # When package_name is None, the package becomes PackageManager.current_package. try: # Tries to get the value from lexical environment in current package. return var_env.find(symbol_name)[symbol_name] except LookupError: # Tries to get the value from another package. return PackageManager.find(symbol_name, package_name, status_check, env='VARIABLE')[symbol_name] finally: # If package_name is 'KEYWORD', sets keyword represented by symbol_name. if package_name == 'KEYWORD': assign_helper(symbol_name, Keyword(symbol_name), package_name, 'VARIABLE', ':EXTERNAL') return PackageManager.find(symbol_name, package_name, status_check, env='VARIABLE')[symbol_name] elif not isinstance(forms, Cons): # If an atom is given, returns itself. return forms else: # Binds function object. if isinstance(forms.car, Cons): # If lambda expression is given, it is bound as an anonymous function. # Other than that, it is bound from predefined functions involving special func = cls.eval(forms.car, var_env, func_env, macro_env) else: # Gets symbol_name, package_name, and status_check. func_name, package_name, status_check = PackageManager.split_symbol_name( forms.car.value) # Gets the function binded by the symbol. # When package_name is None, the package becomes PackageManager.current_package. try: # Tries to get the function from lexical environment in current package. func = func_env.find(func_name)[func_name] except LookupError: # Tries to get the function from another package. func = PackageManager.find(func_name, package_name, status_check, env='FUNCTION')[func_name] return func(forms.cdr, var_env, func_env, macro_env)
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of FletSpecialOperator. """ from clispy.evaluator import Evaluator bindings, body = forms.car, forms.cdr.car funcs = [] exps = [] while bindings is not Null(): func, exp = bindings.car.car, bindings.car.cdr # Interns symbol that represents function name into current package. PackageManager.intern(String(func.value)) funcs.append(func.value) exp = Cons(Symbol('LAMBDA'), exp) # The scope of the name bindings dose not encompasse the function definitions. exps.append(Evaluator.eval(exp, var_env, func_env, macro_env)) bindings = bindings.cdr # The bindings are in parallel. func_env = func_env.extend(params=funcs, args=exps) return Evaluator.eval(body, var_env, func_env, macro_env)
def testPackageManager_find(self): # PackageManger.find results an environment that have value assigned by symbol. # The package that have the environment is shown by package_name. # symbol_name, package_name, status_check is given by PackageManger.split_symbol. # Checks an environment using *PACKAGE* in current package. symbol_name, package_name, status_check = PackageManager.split_symbol_name('COMMON-LISP::*PACKAGE*') env = PackageManager.find(symbol_name, package_name, status_check) self.assertIsInstance(env, Environment) self.assertTrue('*PACKAGE*' in env) symbol_name, package_name, status_check = PackageManager.split_symbol_name('COMMON-LISP:*PACKAGE*') env = PackageManager.find(symbol_name, package_name, status_check) self.assertIsInstance(env, Environment) self.assertTrue('*PACKAGE*' in env) symbol_name, package_name, status_check = PackageManager.split_symbol_name('*PACKAGE*') env = PackageManager.find(symbol_name, package_name, status_check) self.assertIsInstance(env, Environment) self.assertTrue('*PACKAGE*' in env) # Checks an environment using *PACKAGE* in another package. symbol_name, package_name, status_check = PackageManager.split_symbol_name('COMMON-LISP-USER::*PACKAGE*') env = PackageManager.find(symbol_name, package_name, status_check) self.assertIsInstance(env, Environment) self.assertTrue('*PACKAGE*' in env) symbol_name, package_name, status_check = PackageManager.split_symbol_name('COMMON-LISP-USER:*PACKAGE*') env = PackageManager.find(symbol_name, package_name, status_check) self.assertIsInstance(env, Environment) self.assertTrue('*PACKAGE*' in env)
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of FletSpecialOperator. """ from clispy.evaluator import Evaluator bindings, body = forms.car, forms.cdr.car funcs = [] exps = [] # For encompassing the function definitions themselves, # a function environment is extended in advance. local_func_env = func_env.extend() while bindings is not Null(): func, exp = bindings.car.car, bindings.car.cdr # Interns symbol that represents function name into current package. PackageManager.intern(String(func.value)) funcs.append(func.value) exp = Cons(Symbol('LAMBDA'), exp) # The scope of the name bindings encompasses the function definitions # themselves as well as the body. exps.append(Evaluator.eval(exp, var_env, local_func_env, macro_env)) bindings = bindings.cdr # The bindings are in parallel. local_func_env.update(zip(funcs, exps)) return Evaluator.eval(body, var_env, local_func_env, macro_env)
def expand(cls, forms, var_env, func_env, macro_env): if not isinstance(forms, Cons): # If an atom is given, returns itself. return forms elif isinstance(forms.car, Symbol): # and forms.car.value in macro_env: # Gets symbol_name, package_name, and status_check. macro_name, package_name, status_check = PackageManager.split_symbol_name( forms.car.value) # Gets the macro binded by the symbol. # When package_name is None, the package becomes PackageManager.current_package. try: # Tries to get the function from lexical environment in current package. macro = macro_env.find(macro_name)[macro_name] except LookupError: try: macro = PackageManager.find(macro_name, package_name, status_check, env='MACRO')[macro_name] except LookupError: return Cons( forms.car, cls.recusive_expand(forms.cdr, var_env, func_env, macro_env)) return macro(forms.cdr, var_env, func_env, macro_env) else: return Cons(cls.expand(forms.car, var_env, func_env, macro_env), cls.expand(forms.cdr, var_env, func_env, macro_env))
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of SetqSpecialOperator. """ from clispy.evaluator import Evaluator while forms is not Null(): symbol, value, forms = forms.car, forms.cdr.car, forms.cdr.cdr symbol_name = symbol.value value = Evaluator.eval(value, var_env, func_env, macro_env) # Interns symbol that represents function name into current package. PackageManager.intern(String(symbol_name)) # setq may be used for assignment of both lexical and dynamic variables. try: var_env.find(symbol_name)[symbol_name] = value except LookupError: try: # package_name=None means finding an environment from current package. PackageManager.find( symbol_name, package_name=None, status_check=False)[symbol_name] = value except LookupError: PackageManager.current_package.env['VARIABLE'][ symbol_name] = value # the primary value of the last form return value
def testPackageManager_get_package_name(self): # PackageManager.get_package_name returns package name represented by package_designator. # IF package_designator is None, it returns None. self.assertTrue(PackageManager.get_package_name(package_designator=None) is None) # Then package_designator is String or Symbol, it returns package name. self.assertTrue(PackageManager.get_package_name(String('COMMON-LISP')) is 'COMMON-LISP') self.assertTrue(PackageManager.get_package_name(Symbol('COMMON-LISP')) is 'COMMON-LISP')
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of FindSymbolSystemFunction. """ args = self.eval_forms(forms, var_env, func_env, macro_env) symbol_designator = args.car package_designator = args.cdr.car if package_designator is Null(): return PackageManager.find_symbol(symbol_designator=symbol_designator) else: return PackageManager.find_symbol(symbol_designator=symbol_designator, package_designator=package_designator)
def testPackageManager_in_package(self): # PackageManager.in_package changes PackageManager.current_package to package_designator. # PackageManager.current_package is chenged to COMMON-LISP-USER. PackageManager.in_package(package_designator=Symbol('COMMON-LISP-USER')) # Check PackageManager.current_package and *PACKAGE* variable in COMMON-LISP package. self.assertTrue(PackageManager.current_package is PackageManager.package_container['COMMON-LISP-USER']) self.assertTrue(PackageManager.package_container['COMMON-LISP'].env['VARIABLE']['*PACKAGE*'] is PackageManager.current_package) # PackageManager.current_package is chenged to COMMON-LISP as default for other tests. PackageManager.in_package(package_designator=Symbol('COMMON-LISP'))
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of InternSystemFunction. """ args = self.eval_forms(forms, var_env, func_env, macro_env) symbol_designator = args.car package_designator = args.cdr.car # Checks package_designator whether it is given or not. if package_designator is Null(): return PackageManager.intern(symbol_designator=symbol_designator) else: return PackageManager.intern(symbol_designator=symbol_designator, package_designator=package_designator)
def testPackageManager_find_symbol(self): # PackageManager.find_symbol returns symbol represented by symbol_designator and status. # The package_designator argument is omitted, # PackageManager.current_package.symbol_container is checked. # FIND-SYMBOL is interned to PackageManager.current_package in advance. PackageManager.intern(symbol_designator=String('FIND-SYMBOL')) symbol, status = PackageManager.find_symbol(symbol_designator=String('FIND-SYMBOL')) self.assertTrue(symbol is Symbol('FIND-SYMBOL')) self.assertTrue(status, Keyword(':INTERNAL')) # If symbol_designator dose not exist in PackageManager.current_package, # it must return Null object as symbol and status. symbol, status = PackageManager.find_symbol(symbol_designator=String('FIND-SYMBOL-NOT-EXIST')) self.assertTrue(symbol is Null()) self.assertTrue(status is Null()) # The package_designator argument is supplied to the specified package. # FIND-SYMBOL-WITH-PACKAGE is interned to COMMON-LISP-USER package in advance. PackageManager.intern(symbol_designator=String('FIND-SYMBOL-WITH-PACKAGE'), package_designator=String('COMMON-LISP-USER')) symbol, status = PackageManager.find_symbol(symbol_designator=String('FIND-SYMBOL-WITH-PACKAGE'), package_designator=String('COMMON-LISP-USER')) self.assertTrue(symbol is Symbol('FIND-SYMBOL-WITH-PACKAGE')) self.assertTrue(status is Keyword(':INTERNAL')) # If symbol_designator dose not exist in the specified package, # it must return Null object as symbol and status. symbol, status = PackageManager.find_symbol(symbol_designator=String('FIND-SYMBOL-WITH-PACKAGE-NOT-EXIST'), package_designator=String('COMMON-LISP-USER')) self.assertTrue(symbol is Null()) self.assertTrue(status is Null())
def testPackageManager_get_package(self): # PackageManager.get_package returns package represented by package_name. # If package_name is None, it returns PackageManager.current_package. self.assertTrue(PackageManager.get_package(package_name=None) is PackageManager.current_package) # Check four packages included in PackageManager.package_container as defualt. self.assertTrue(PackageManager.get_package(package_name='COMMON-LISP') is PackageManager.package_container['COMMON-LISP']) self.assertTrue(PackageManager.get_package(package_name='KEYWORD') is PackageManager.package_container['KEYWORD']) self.assertTrue(PackageManager.get_package(package_name='COMMON-LISP-USER') is PackageManager.package_container['COMMON-LISP-USER']) self.assertTrue(PackageManager.get_package(package_name='PYTHON') is PackageManager.package_container['PYTHON']) # Raise an exception of KeyError if package_name dose not exist in keys of # PackageMnager.package_container. self.assertRaises(KeyError, PackageManager.get_package, 'NOT-EXIST')
def testPackageManager_intern(self): # PackageManager.intern interns symbol_designator to Package.symbol_container. # The package_designator argument is omitted, # symbol_designator is interned to PackageManager.current_package.symbol_container. symbol, status = PackageManager.intern(symbol_designator=String('TEST-INTERN')) self.assertTrue(symbol is Symbol('TEST-INTERN')) self.assertTrue(status is Null()) self.assertTrue('TEST-INTERN' in PackageManager.current_package.symbol_container.keys()) self.assertEqual(PackageManager.current_package.symbol_container['TEST-INTERN'], [Symbol('TEST-INTERN'), Keyword(':INTERNAL'), None]) # The package_designator argument is supplied to the specified package. symbol, status = PackageManager.intern(symbol_designator=String('INTERN-WITH-PACKAGE'), package_designator=String('COMMON-LISP-USER')) self.assertTrue(symbol is Symbol('INTERN-WITH-PACKAGE')) self.assertTrue(status is Null()) self.assertTrue('INTERN-WITH-PACKAGE' in PackageManager.package_container['COMMON-LISP-USER'].symbol_container.keys()) self.assertEqual(PackageManager.package_container['COMMON-LISP-USER'].symbol_container['INTERN-WITH-PACKAGE'], [Symbol('INTERN-WITH-PACKAGE'), Keyword(':INTERNAL'), None])
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of FunctionSpecialOperator. """ if isinstance(forms.car, Cons) and forms.car.car is Symbol('LAMBDA'): return Lambda(forms.car.cdr, var_env, func_env, macro_env) else: # Gets symbol_name, package_name, and status_check. func_name, package_name, status_check = PackageManager.split_symbol_name( forms.car.value) # Gets the function binded by the symbol. try: # First, tries to get the value from lexical environment. return func_env.find(func_name)[func_name] except LookupError: # If LookupError is raised, tries to get from another package. return PackageManager.find(func_name, package_name, status_check, env='FUNCTION')[func_name]
def testPackageManager_export(self): # PackageManager.export changes symbol status in symbol container to :EXTERNAL. # The package_designator argument is omitted, # status in PackageManager.current_package.symbol_container is changed. # EXPORT is interned to PackageManager.current_package in advance. PackageManager.intern(symbol_designator=String('EXPORT')) PackageManager.export(symbol_designator=Symbol('EXPORT')) symbol, status = PackageManager.find_symbol(symbol_designator=String('EXPORT')) self.assertTrue(symbol is Symbol('EXPORT')) self.assertTrue(status is Keyword(':EXTERNAL')) # The package_designator argument is supplied to the specified package. # EXPORT-WITH-PACKAGE is interned to COMMON-LISP-USER pacakge in advance. PackageManager.intern(symbol_designator=String('EXPORT-WITH-PACKAGE'), package_designator=String('COMMON-LISP-USER')) PackageManager.export(symbol_designator=Symbol('EXPORT-WITH-PACKAGE'), package_designator=Symbol('COMMON-LISP-USER')) symbol, status = PackageManager.find_symbol(symbol_designator=String('EXPORT-WITH-PACKAGE'), package_designator=String('COMMON-LISP-USER')) self.assertTrue(symbol is Symbol('EXPORT-WITH-PACKAGE')) self.assertTrue(status is Keyword(':EXTERNAL'))
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of DefmacroSystemFunction. """ macro_symbol = forms.car macro_name = macro_symbol.value lambda_forms = forms # Lambda function. macro = Lambda(lambda_forms.cdr, var_env, func_env, macro_env) # Interns symbol that represents macro name into current package. PackageManager.intern(String(macro_name)) # Binds value to symbol into the global environment. try: # package_name=None means finding an environment from current package. PackageManager.find(macro_name, package_name=None, status_check=False, env='MACRO')[macro_name] = macro except LookupError: PackageManager.current_package.env['MACRO'][macro_name] = macro return macro_symbol
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of LetAsterSpecialOperator. """ from clispy.evaluator import Evaluator bindings, body = forms.car, forms.cdr.car while bindings is not Null(): var, val = bindings.car.car, bindings.car.cdr.car # Interns symbol that represents function name into current package. PackageManager.intern(String(var.value)) var = var.value val = Evaluator.eval(val, var_env, func_env, macro_env) # The bindings are in sequence. var_env = var_env.extend(params=[var], args=[val]) bindings = bindings.cdr return Evaluator.eval(body, var_env, func_env, macro_env)
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of DefunSystemFunction. """ func_symbol = forms.car func_name = func_symbol.value lambda_forms = forms # Lambda function. func = Lambda(lambda_forms.cdr, var_env, func_env, macro_env) # Interns symbol that represents function name into current package. PackageManager.intern(String(func_name)) # Binds value to symbol into the global environment. try: # package_name=None means finding an environment from current package. PackageManager.find(func_name, package_name=None, status_check=False, env='FUNCTION')[func_name] = func except LookupError: PackageManager.current_package.env['FUNCTION'][func_name] = func return func_symbol
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of LetSpecialOperator. """ from clispy.evaluator import Evaluator bindings, body = forms.car, forms.cdr.car vars, vals = [], [] while bindings is not Null(): var, val = bindings.car.car, bindings.car.cdr.car # Interns symbol that represents function name into current package. PackageManager.intern(String(var.value)) vars.append(var.value) vals.append(Evaluator.eval(val, var_env, func_env, macro_env)) bindings = bindings.cdr # The bindings are in parallel. var_env = var_env.extend(params=vars, args=vals) return Evaluator.eval(body, var_env, func_env, macro_env)
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of ExportSystemFunction. """ args = self.eval_forms(forms, var_env, func_env, macro_env) symbol_designator = args.car package_designator = args.cdr.car # Checks package_designator whether it is given or not. if package_designator is Null(): package_designator = None if isinstance(symbol_designator, Cons): # If symbol_designator is symbol list, exports all symbols. while symbol_designator.cdr is not Null(): PackageManager.export(symbol_designator=symbol_designator.car, package_designator=package_designator) symbol_designator = symbol_designator.cdr # The last symbol. return PackageManager.export(symbol_designator=symbol_designator.car, package_designator=package_designator) else: return PackageManager.export(symbol_designator=symbol_designator, package_designator=package_designator)
def testDefunSytemFunction_call(self): # Makes an instance of DefunSystemFunction. defun = DefunSystemFunction() # Calls defun. forms = Parser.parse('(func (x) (* x x x))') retval = defun(forms, PackageManager.current_package.env['VARIABLE'], PackageManager.current_package.env['FUNCTION'], PackageManager.current_package.env['MACRO']) # Checks retval. self.assertEqual(retval, Symbol('FUNC')) # Gets function object. func = PackageManager.find('FUNC', package_name=None, status_check=False, env='FUNCTION')['FUNC'] # Checks type. self.assertIsInstance(func, Lambda)
def testDefmacroSystemFunction_call(self): # Makes an instance of DefmacroSystemFunction. defmacro = DefmacroSystemFunction() # Calls defmacro. forms = Parser.parse('(mac (x) `(* ,x ,x ,x))') retval = defmacro(forms, PackageManager.current_package.env['VARIABLE'], PackageManager.current_package.env['FUNCTION'], PackageManager.current_package.env['MACRO']) # Checks retval. self.assertTrue(retval, Symbol('MACRO')) # Gets macro object. mac = PackageManager.find('MAC', package_name=None, status_check=False, env='MACRO')['MAC'] # Checks type. self.assertIsInstance(mac, Lambda)
def testPackageManager_split_symbol_name(self): # PackageManager.split_symbol_name splits symbol_name including package_name # and returns status_check indicating whether it needs status check or not. # When symbol_name is not KEYWORD, symbol_name, package_name, status_check = PackageManager.split_symbol_name('COMMON-LISP::CAR') self.assertEqual(symbol_name, 'CAR') self.assertEqual(package_name, 'COMMON-LISP') self.assertFalse(status_check) symbol_name, package_name, status_check = PackageManager.split_symbol_name('COMMON-LISP:CAR') self.assertEqual(symbol_name, 'CAR') self.assertEqual(package_name, 'COMMON-LISP') self.assertTrue(status_check) symbol_name, package_name, status_check = PackageManager.split_symbol_name('CAR') self.assertEqual(symbol_name, 'CAR') self.assertEqual(package_name, None) self.assertFalse(status_check) # When symbol_name is KEYWORD, sybmol_name, package_name, status_check = PackageManager.split_symbol_name('KEYWORD::EXTERNAL') self.assertEqual(sybmol_name, ':EXTERNAL') self.assertEqual(package_name, 'KEYWORD') self.assertFalse(status_check) sybmol_name, package_name, status_check = PackageManager.split_symbol_name('KEYWORD:EXTERNAL') self.assertEqual(sybmol_name, ':EXTERNAL') self.assertEqual(package_name, 'KEYWORD') self.assertFalse(status_check) sybmol_name, package_name, status_check = PackageManager.split_symbol_name(':EXTERNAL') self.assertEqual(sybmol_name, ':EXTERNAL') self.assertEqual(package_name, 'KEYWORD') self.assertFalse(status_check)
def testPackageManager_use_package(self): # PackageManager.use_package inherited symbol in package_designator_to_use. # The package_designator argument is omitted, # symbol is inherited, and interned to PackageManager.current_package.symbol_container. # USE-PACKAGE-INTERNAL and USE-PACKAGE-EXTERNAL are interned to COMMON-LISP-USER. PackageManager.intern(symbol_designator=String('USE-PACKAGE-INTERNAL'), package_designator=String('COMMON-LISP-USER')) PackageManager.intern(symbol_designator=String('USE-PACKAGE-EXTERNAL'), package_designator=String('COMMON-LISP-USER')) # Only status of USE-PACKAGE-EXTERNAL is changed to :EXTERNAL. PackageManager.export(symbol_designator=Symbol('USE-PACKAGE-EXTERNAL'), package_designator=Symbol('COMMON-LISP-USER')) PackageManager.use_package(package_designator_to_use=Symbol('COMMON-LISP-USER')) # When status is :EXTERNAL, the symbol is inherited. symbol, status = PackageManager.find_symbol(symbol_designator=String('USE-PACKAGE-EXTERNAL')) self.assertTrue(symbol is Symbol('USE-PACKAGE-EXTERNAL')) self.assertTrue(status is Keyword(':INHERITED')) # When statis is not :EXTERNAL, the symbol is not inherited. symbol, status = PackageManager.find_symbol(symbol_designator=String('USE-PACKAGE-INTERNAL')) self.assertTrue(symbol is Null()) self.assertTrue(status is Null()) # The package_designator argument is supplied to the specified package. # USE-PACKAGE-INTERNAL-WITH-PACKAGE and USE-PACKAGE-EXTERNAL-WITH-PACKAGE are interned to COMMON-LISP. PackageManager.intern(String('USE-PACKAGE-INTERNAL-WITH-PACKAGE')) PackageManager.intern(String('USE-PACKAGE-EXTERNAL-WITH-PACKAGE')) # Only status of USE-PACKAGE-EXTERNAL-WITH-PACKAGE is changed to :EXTERNAL. PackageManager.export(Symbol('USE-PACKAGE-EXTERNAL-WITH-PACKAGE')) PackageManager.use_package(package_designator_to_use=Symbol('COMMON-LISP'), package_designator=Symbol('COMMON-LISP-USER')) # When status is :EXTERNAL, the symbol is inherited. symbol, status = PackageManager.find_symbol(symbol_designator=String('USE-PACKAGE-EXTERNAL-WITH-PACKAGE'), package_designator=String('COMMON-LISP-USER')) self.assertTrue(symbol is Symbol('USE-PACKAGE-EXTERNAL-WITH-PACKAGE')) self.assertTrue(status is Keyword(':INHERITED')) # When statis is not :EXTERNAL, the symbol is not inherited. symbol, status = PackageManager.find_symbol(symbol_designator=String('USE-PACKAGE-INTERNAL-WITH-PACKAGE'), package_designator=String('COMMON-LISP-USER')) self.assertTrue(symbol is Null()) self.assertTrue(status is Null())
def repl(cls, prompt='=>', inport=InPort(sys.stdin), out=sys.stdout, zen=True): PackageManager.in_package(String("COMMON-LISP-USER")) while True: try: if prompt is not None: # Set prompt. try: prompt = PackageManager.current_package.package_nicknames[ 0] + '=>' except IndexError: prompt = PackageManager.current_package.package_name + '=>' # Wait input. print(prompt, end=' ', file=out, flush=True) # Parse inport. forms = Parser.parse(inport) # Check eof. if forms is Symbol('#<EOF-OJBECT>'): return # Expand token. forms = Expander.expand( forms, var_env=PackageManager.current_package.env['VARIABLE'], func_env=PackageManager.current_package.env['FUNCTION'], macro_env=PackageManager.current_package.env['MACRO']) # Evaluate expression. retval = Evaluator.eval( forms, var_env=PackageManager.current_package.env['VARIABLE'], func_env=PackageManager.current_package.env['FUNCTION'], macro_env=PackageManager.current_package.env['MACRO']) # Print return value. if out is not None: print(retval, end="\n\n", file=out, flush=True) except Interrupt: if zen: # Print the zen of python at random. print(random.choices(cls.the_zen_of_python)[0], end="\n\n", file=out, flush=True) return except Exception as e: print( "------------------------------------------------------------" ) print("{}: {}".format(type(e).__name__, e), end="\n\n", file=out, flush=True)
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of Lambda. """ from clispy.evaluator import Evaluator from clispy.expander import Expander # # Expands and evaluates arguments. tmp_args = [] while forms is not Null(): exp = Expander.expand(forms.car, var_env, func_env, macro_env) tmp_args.append(Evaluator.eval(exp, var_env, func_env, macro_env)) forms = forms.cdr args = tmp_args ################################################## # Accesser parameters ################################################## # Optional parameters. if '&OPTIONAL' in self.accessor_index: args = tmp_args[:self.accessor_index['&OPTIONAL']] optional_args = tmp_args[self.accessor_index['&OPTIONAL']:] for i, _ in enumerate( self.params[self.accessor_index['&OPTIONAL']:]): try: args.append(optional_args[i]) except IndexError: args.append(self.default_optional_args[i]) # Rest parameters. if '&REST' in self.accessor_index: if len(args) > self.accessor_index['&REST']: args[self.accessor_index['&REST']] = args[ self.accessor_index['&REST']:] args = args[:self.accessor_index['&REST'] + 1] else: args.append(Null()) # Keyword parameters if '&KEY' in self.accessor_index: args = tmp_args[:self.accessor_index['&KEY']] keyword_args = tmp_args[self.accessor_index['&KEY']:] kargs = {} for i, karg in enumerate(keyword_args): if isinstance(karg, Keyword): # A value of Keyword has ':' at the first character. kargs[karg.value[1:]] = keyword_args[i + 1] for param in self.params[self.accessor_index['&KEY']:]: args.append( kargs.get(param, self.default_keyword_args.get(param))) # Interns symbol names of params to lexical scope. for symbol_name in self.params: PackageManager.intern(String(symbol_name)) # Binds args to lexical scope. local_var_env = self.var_env.extend(params=self.params, args=args) local_func_env = self.func_env.extend() local_macro_env = self.macro_env.extend() # Expands and evaluates lambda expression. exp = Expander.expand(self.forms, local_var_env, local_func_env, local_macro_env) retval = Evaluator.eval(exp, local_var_env, local_func_env, local_macro_env) return retval
def __call__(self, forms, var_env, func_env, macro_env): """Behavior of InPackageSystemFunction. """ args = self.eval_forms(forms, var_env, func_env, macro_env) return PackageManager.in_package(package_designator=args.car)