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)
