Using our own parse to enable the flag below.
433684
def parse(cls, parser, text, pos):
        """"""
        try:
            parser._parsing_parenthesized_simple_values_expression = True
            remaining_text, recognized_tokens = parser.parse(text, cls.grammar)
            return remaining_text, recognized_tokens
        except SyntaxError as e:
            return text, e
        finally:
            parser._parsing_parenthesized_simple_values_expression = False
467669
def parse_placeholder(parser, token):
    """"""
    bits = token.split_contents()
    count = len(bits)
    error_string = '%r tag requires at least one argument' % bits[0]
    if count <= 1:
        raise TemplateSyntaxError(error_string)
    name = bits[1]
    remaining = bits[2:]
    params = {}
    simple_options = ['parsed', 'inherited', 'untranslated']
    param_options = ['as', 'on', 'with']
    all_options = simple_options + param_options
    while remaining:
        bit = remaining[0]
        if bit not in all_options:
            raise TemplateSyntaxError(
                "%r is not an correct option for a placeholder" % bit)
        if bit in param_options:
            if len(remaining) < 2:
                raise TemplateSyntaxError(
                "Placeholder option '%s' need a parameter" % bit)
            if bit == 'as':
                params['as_varname'] = remaining[1]
            if bit == 'with':
                params['widget'] = remaining[1]
            if bit == 'on':
                params['page'] = remaining[1]
            remaining = remaining[2:]
        elif bit == 'parsed':
            params['parsed'] = True
            remaining = remaining[1:]
        elif bit == 'inherited':
            params['inherited'] = True
            remaining = remaining[1:]
        elif bit == 'untranslated':
            params['untranslated'] = True
            remaining = remaining[1:]
    return name, params
607258
def normalize_flags(self, flags):
        
        flags['type'] = flags.get('type', None)
        paction = flags.get('action', 'store')
        if paction == 'store_false':
            flags['default'] = True 
            flags['type'] = bool

        elif paction == 'store_true':
            flags['default'] = False
            flags['type'] = bool

        prequired = False if 'default' in flags else flags.get('required', True)

        flags["action"] = paction
        flags["required"] = prequired
        self.flags = flags
493674
def set_flag(self, info, code=None):
        """"""
        self.flag = True
        self.flag_info += info
        if code is not None:
            self.flag_code = code
667627
def []=(flag, value)
      if o = option(flag)
        o.value = value
      else
        raise ArgumentError, "no option with flag `#{flag}'"
      end
    end
632436
def relaxParserSetFlag(self, flags):
        
        ret = libxml2mod.xmlRelaxParserSetFlag(self._o, flags)
        return ret
787327
private void addFlagFileOption() {
        String name = "flagfile";
        String shortName = getAndAddUniqueShortName(name);
        String description = "Special flag: file from which to read additional flags"
                + " (lines starting with # are ignored as comments,"
                + " and these flags are always processed before those on the command line).";
        flagfileOpt = new Option(shortName, name, true, description);
        flagfileOpt.setRequired(false);
        options.addOption(flagfileOpt);
    }
515851
def FlagValues(*params)
      if params.size==1 && params.first.kind_of?(FlagValues)
        params.first
      else
        FlagValues.new(*params)
      end
    end
1184892
private void setupParse ()
    {
    if (parent == null) {
        throw new NullPointerException("No parent for filter");
    }
    parent.setEntityResolver(this);
    parent.setDTDHandler(this);
    parent.setContentHandler(this);
    parent.setErrorHandler(this);
    }
605500
def setup_parse(self, inputstring, document):
        """"""
        self.inputstring = inputstring
        self.document = document
1349517
protected function setFlag($flag, $enable = true)
    {
        if ($enable) {
            $this->flags[$flag] = true;
        } else {
            unset($this->flags[$flag]);
        }
    }
1223657
def _process_flags(self):
        
        super()._process_flags()

        if len(self.args) == 0:
            self.multi_mode = False
96405
def add_flag(var, flag):
    
    if var:
        var = flag + " " + str(var)
    else:
        var = ""
    return var
1004835
def add_flag(self, flag):
        
        super(Entry, self).add_flag(flag)
        self._changed_attrs.add('flags')
958455
function querySelector(sel, flag) {
      var node = this.root.querySelector(normalize(sel));
      return !flag ? node : node._tag || undefined;
    }
115468
def _setFlag(self, name, val, defVal):
        """"""
        if not hasattr(self, "flags"):
            self.flags = {}
        if val != defVal:
            self.flags[name] = val
87453
def flag_arg(key, desc, opts = {}, &block)
            self << ArgParser::FlagArgument.new(key, desc, opts, &block)
        end