From: Peter Alexander Date: Thu, 15 Oct 2009 07:47:42 +0000 (-0400) Subject: naming references changed from 'option' to 'directive' X-Git-Tag: 0.13.beta0~2^2~121^2~37 X-Git-Url: http://git.tremily.us/?a=commitdiff_plain;h=422a77f84b738a0cbc3146fd3caa6d9ff0fb77f7;p=cython.git naming references changed from 'option' to 'directive' --- diff --git a/Cython/Compiler/CmdLine.py b/Cython/Compiler/CmdLine.py index de431c04..67b3737b 100644 --- a/Cython/Compiler/CmdLine.py +++ b/Cython/Compiler/CmdLine.py @@ -126,7 +126,7 @@ def parse_command_line(args): options.emit_linenums = True elif option in ("-X", "--directive"): try: - options.compiler_directives = Options.parse_option_list(pop_arg()) + options.compiler_directives = Options.parse_directive_list(pop_arg()) except ValueError, e: sys.stderr.write("Error in compiler directive: %s\n" % e.message) sys.exit(1) diff --git a/Cython/Compiler/Options.py b/Cython/Compiler/Options.py index 3223f29f..c8aeda81 100644 --- a/Cython/Compiler/Options.py +++ b/Cython/Compiler/Options.py @@ -55,7 +55,7 @@ embed = False # Declare compiler directives -option_defaults = { +directive_defaults = { 'boundscheck' : True, 'nonecheck' : False, 'embedsignature' : False, @@ -77,35 +77,35 @@ option_defaults = { } # Override types possibilities above, if needed -option_types = {} +directive_types = {} -for key, val in option_defaults.items(): - if key not in option_types: - option_types[key] = type(val) +for key, val in directive_defaults.items(): + if key not in directive_types: + directive_types[key] = type(val) -option_scopes = { # defaults to available everywhere +directive_scopes = { # defaults to available everywhere # 'module', 'function', 'class', 'with statement' 'autotestdict' : ('module',), 'test_assert_path_exists' : ('function',), 'test_fail_if_path_exists' : ('function',), } -def parse_option_value(name, value): +def parse_directive_value(name, value): """ Parses value as an option value for the given name and returns the interpreted value. None is returned if the option does not exist. - >>> print parse_option_value('nonexisting', 'asdf asdfd') + >>> print parse_directive_value('nonexisting', 'asdf asdfd') None - >>> parse_option_value('boundscheck', 'True') + >>> parse_directive_value('boundscheck', 'True') True - >>> parse_option_value('boundscheck', 'true') + >>> parse_directive_value('boundscheck', 'true') Traceback (most recent call last): ... ValueError: boundscheck directive must be set to True or False """ - type = option_types.get(name) + type = directive_types.get(name) if not type: return None if type is bool: if value == "True": return True @@ -119,25 +119,25 @@ def parse_option_value(name, value): else: assert False -def parse_option_list(s): +def parse_directive_list(s): """ Parses a comma-seperated list of pragma options. Whitespace is not considered. - >>> parse_option_list(' ') + >>> parse_directive_list(' ') {} - >>> (parse_option_list('boundscheck=True') == + >>> (parse_directive_list('boundscheck=True') == ... {'boundscheck': True}) True - >>> parse_option_list(' asdf') + >>> parse_directive_list(' asdf') Traceback (most recent call last): ... ValueError: Expected "=" in option "asdf" - >>> parse_option_list('boundscheck=hey') + >>> parse_directive_list('boundscheck=hey') Traceback (most recent call last): ... ValueError: Must pass a boolean value for option "boundscheck" - >>> parse_option_list('unknown=True') + >>> parse_directive_list('unknown=True') Traceback (most recent call last): ... ValueError: Unknown option: "unknown" @@ -149,7 +149,7 @@ def parse_option_list(s): if not '=' in item: raise ValueError('Expected "=" in option "%s"' % item) name, value = item.strip().split('=') try: - type = option_types[name] + type = directive_types[name] except KeyError: raise ValueError('Unknown option: "%s"' % name) if type is bool: diff --git a/Cython/Compiler/ParseTreeTransforms.py b/Cython/Compiler/ParseTreeTransforms.py index 0ca4add7..a1eb2e5f 100644 --- a/Cython/Compiler/ParseTreeTransforms.py +++ b/Cython/Compiler/ParseTreeTransforms.py @@ -153,10 +153,10 @@ class PostParse(CythonTransform): - For __cythonbufferdefaults__ the arguments are checked for validity. - CBufferAccessTypeNode has its options interpreted: + CBufferAccessTypeNode has its directives interpreted: Any first positional argument goes into the "dtype" attribute, any "ndim" keyword argument goes into the "ndim" attribute and - so on. Also it is checked that the option combination is valid. + so on. Also it is checked that the directive combination is valid. - __cythonbufferdefaults__ attributes are parsed and put into the type information. @@ -304,14 +304,14 @@ class PxdPostParse(CythonTransform, SkipDeclarations): class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): """ - After parsing, options can be stored in a number of places: + After parsing, directives can be stored in a number of places: - #cython-comments at the top of the file (stored in ModuleNode) - Command-line arguments overriding these - - @cython.optionname decorators - - with cython.optionname: statements + - @cython.directivename decorators + - with cython.directivename: statements This transform is responsible for interpreting these various sources - and store the option in two ways: + and store the directive in two ways: - Set the directives attribute of the ModuleNode for global directives. - Use a CompilerDirectivesNode to override directives for a subtree. @@ -330,16 +330,16 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): """ special_methods = set(['declare', 'union', 'struct', 'typedef', 'sizeof', 'typeof', 'cast', 'address', 'pointer', 'compiled', 'NULL']) - def __init__(self, context, compilation_option_overrides): + def __init__(self, context, compilation_directive_overrides): super(InterpretCompilerDirectives, self).__init__(context) - self.compilation_option_overrides = {} - for key, value in compilation_option_overrides.iteritems(): - self.compilation_option_overrides[unicode(key)] = value + self.compilation_directive_overrides = {} + for key, value in compilation_directive_overrides.iteritems(): + self.compilation_directive_overrides[unicode(key)] = value self.cython_module_names = set() - self.option_names = {} + self.directive_names = {} def check_directive_scope(self, pos, directive, scope): - legal_scopes = Options.option_scopes.get(directive, None) + legal_scopes = Options.directive_scopes.get(directive, None) if legal_scopes and scope not in legal_scopes: self.context.nonfatal_error(PostParseError(pos, 'The %s compiler directive ' 'is not allowed in %s scope' % (directive, scope))) @@ -349,19 +349,19 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): # Set up processing and handle the cython: comments. def visit_ModuleNode(self, node): - options = copy.copy(Options.option_defaults) - for key, value in self.compilation_option_overrides.iteritems(): + directives = copy.copy(Options.directive_defaults) + for key, value in self.compilation_directive_overrides.iteritems(): if not self.check_directive_scope(node.pos, key, 'module'): self.wrong_scope_error(node.pos, key, 'module') - del self.compilation_option_overrides[key] + del self.compilation_directive_overrides[key] continue - if key in node.option_comments and node.option_comments[key] != value: + if key in node.directive_comments and node.directive_comments[key] != value: warning(node.pos, "Compiler directive differs between environment and file header; this will change " "in Cython 0.12. See http://article.gmane.org/gmane.comp.python.cython.devel/5233", 2) - options.update(node.option_comments) - options.update(self.compilation_option_overrides) - self.options = options - node.directives = options + directives.update(node.directive_comments) + directives.update(self.compilation_directive_overrides) + self.directives = directives + node.directives = directives self.visitchildren(node) node.cython_module_names = self.cython_module_names return node @@ -380,15 +380,15 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): if node.module_name == u"cython": newimp = [] for pos, name, as_name, kind in node.imported_names: - if (name in Options.option_types or + if (name in Options.directive_types or name in self.special_methods or PyrexTypes.parse_basic_type(name)): if as_name is None: as_name = name - self.option_names[as_name] = name + self.directive_names[as_name] = name if kind is not None: self.context.nonfatal_error(PostParseError(pos, - "Compiler option imports must be plain imports")) + "Compiler directive imports must be plain imports")) else: newimp.append((pos, name, as_name, kind)) if not newimp: @@ -400,10 +400,10 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): if node.module.module_name.value == u"cython": newimp = [] for name, name_node in node.items: - if (name in Options.option_types or + if (name in Options.directive_types or name in self.special_methods or PyrexTypes.parse_basic_type(name)): - self.option_names[name_node.name] = name + self.directive_names[name_node.name] = name else: newimp.append((name, name_node)) if not newimp: @@ -426,12 +426,12 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): if node.name in self.cython_module_names: node.is_cython_module = True else: - node.cython_attribute = self.option_names.get(node.name) + node.cython_attribute = self.directive_names.get(node.name) return node - def try_to_parse_option(self, node): - # If node is the contents of an option (in a with statement or - # decorator), returns (optionname, value). + def try_to_parse_directive(self, node): + # If node is the contents of an directive (in a with statement or + # decorator), returns (directivename, value). # Otherwise, returns None optname = None if isinstance(node, CallNode): @@ -439,56 +439,56 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): optname = node.function.as_cython_attribute() if optname: - optiontype = Options.option_types.get(optname) - if optiontype: + directivetype = Options.directive_types.get(optname) + if directivetype: args, kwds = node.explicit_args_kwds() - if optiontype is bool: + if directivetype is bool: if kwds is not None or len(args) != 1 or not isinstance(args[0], BoolNode): raise PostParseError(node.function.pos, - 'The %s option takes one compile-time boolean argument' % optname) + 'The %s directive takes one compile-time boolean argument' % optname) return (optname, args[0].value) - elif optiontype is str: + elif directivetype is str: if kwds is not None or len(args) != 1 or not isinstance(args[0], (StringNode, UnicodeNode)): raise PostParseError(node.function.pos, - 'The %s option takes one compile-time string argument' % optname) + 'The %s directive takes one compile-time string argument' % optname) return (optname, str(args[0].value)) - elif optiontype is dict: + elif directivetype is dict: if len(args) != 0: raise PostParseError(node.function.pos, - 'The %s option takes no prepositional arguments' % optname) + 'The %s directive takes no prepositional arguments' % optname) return optname, dict([(key.value, value) for key, value in kwds.key_value_pairs]) - elif optiontype is list: + elif directivetype is list: if kwds and len(kwds) != 0: raise PostParseError(node.function.pos, - 'The %s option takes no keyword arguments' % optname) + 'The %s directive takes no keyword arguments' % optname) return optname, [ str(arg.value) for arg in args ] else: assert False return None - def visit_with_options(self, body, options): - oldoptions = self.options - newoptions = copy.copy(oldoptions) - newoptions.update(options) - self.options = newoptions + def visit_with_directives(self, body, directives): + olddirectives = self.directives + newdirectives = copy.copy(olddirectives) + newdirectives.update(directives) + self.directives = newdirectives assert isinstance(body, StatListNode), body retbody = self.visit_Node(body) directive = CompilerDirectivesNode(pos=retbody.pos, body=retbody, - directives=newoptions) - self.options = oldoptions + directives=newdirectives) + self.directives = olddirectives return directive # Handle decorators def visit_FuncDefNode(self, node): - options = [] + directives = [] if node.decorators: - # Split the decorators into two lists -- real decorators and options + # Split the decorators into two lists -- real decorators and directives realdecs = [] for dec in node.decorators: - option = self.try_to_parse_option(dec.decorator) - if option is not None: - options.append(option) + directive = self.try_to_parse_directive(dec.decorator) + if directive is not None: + directives.append(directive) else: realdecs.append(dec) if realdecs and isinstance(node, CFuncDefNode): @@ -496,12 +496,12 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): else: node.decorators = realdecs - if options: + if directives: optdict = {} - options.reverse() # Decorators coming first take precedence - for option in options: - name, value = option - legal_scopes = Options.option_scopes.get(name, None) + directives.reverse() # Decorators coming first take precedence + for directive in directives: + name, value = directive + legal_scopes = Options.directive_scopes.get(name, None) if not self.check_directive_scope(node.pos, name, 'function'): continue if name in optdict: @@ -517,16 +517,16 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): else: optdict[name] = value body = StatListNode(node.pos, stats=[node]) - return self.visit_with_options(body, optdict) + return self.visit_with_directives(body, optdict) else: return self.visit_Node(node) def visit_CVarDefNode(self, node): if node.decorators: for dec in node.decorators: - option = self.try_to_parse_option(dec.decorator) - if option is not None and option[0] == u'locals': - node.directive_locals = option[1] + directive = self.try_to_parse_directive(dec.decorator) + if directive is not None and directive[0] == u'locals': + node.directive_locals = directive[1] else: self.context.nonfatal_error(PostParseError(dec.pos, "Cdef functions can only take cython.locals() decorator.")) @@ -535,15 +535,15 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations): # Handle with statements def visit_WithStatNode(self, node): - option = self.try_to_parse_option(node.manager) - if option is not None: + directive = self.try_to_parse_directive(node.manager) + if directive is not None: if node.target is not None: self.context.nonfatal_error( - PostParseError(node.pos, "Compiler option with statements cannot contain 'as'")) + PostParseError(node.pos, "Compiler directive with statements cannot contain 'as'")) else: - name, value = option + name, value = directive if self.check_directive_scope(node.pos, name, 'with statement'): - return self.visit_with_options(node.body, {name:value}) + return self.visit_with_directives(node.body, {name:value}) return self.visit_Node(node) class WithTransform(CythonTransform, SkipDeclarations): diff --git a/Cython/Compiler/Parsing.py b/Cython/Compiler/Parsing.py index c42a419e..c567bdcd 100644 --- a/Cython/Compiler/Parsing.py +++ b/Cython/Compiler/Parsing.py @@ -2582,7 +2582,7 @@ def p_compiler_directive_comments(s): if m: name = m.group(1) try: - value = Options.parse_option_value(str(name), str(m.group(2).strip())) + value = Options.parse_directive_value(str(name), str(m.group(2).strip())) if value is not None: # can be False! result[name] = value except ValueError, e: @@ -2593,7 +2593,7 @@ def p_compiler_directive_comments(s): def p_module(s, pxd, full_module_name): pos = s.position() - option_comments = p_compiler_directive_comments(s) + directive_comments = p_compiler_directive_comments(s) s.parse_comments = False doc = p_doc_string(s) @@ -2608,7 +2608,7 @@ def p_module(s, pxd, full_module_name): repr(s.sy), repr(s.systring))) return ModuleNode(pos, doc = doc, body = body, full_module_name = full_module_name, - option_comments = option_comments) + directive_comments = directive_comments) #---------------------------------------------- #