while_statement: 'while' local_or_expr compound
482297
def while_statement(self):
        
        self._process(Nature.WHILE)
        condition = self.logical_or_expr()
        compound = self.compound()
        return WhileStatement(condition=condition, compound=compound)
859701
def drop_while(&predicate)
      filter("drop_while") do |yielder|
        take = false
        each do |element|
          take ||= !yield(element)
          yielder.call(element) if take
        end
      end
    end
146268
def compound_statements(logical_line):
    
    line = logical_line
    found = line.find(':')
    if -1 < found < len(line) - 1:
        before = line[:found]
        if (before.count('{') <= before.count('}') and # {'a': 1} (dict)
            before.count('[') <= before.count(']') and # [1:2] (slice)
            not re.search(r'\blambda\b', before)):     # lambda x: x
            return found, "E701 multiple statements on one line (colon)"
    found = line.find(';')
    if -1 < found:
        return found, "E702 multiple statements on one line (semicolon)"
904285
public void whilst(Precondition condition, final Outcome outcome, final Function function) {
        whilst(condition, outcome, function, -1);
    }
872039
def take_while(&predicate)
      filter("take_while") do |yielder, all_done|
        each do |element|
          throw all_done unless yield(element)
          yielder.call(element)
        end
      end
    end
1190192
def statement_after(self, i):
        """"""
        k = i + 1
        o = len(self.body)
        n = o + len(self.else_body)
        if k > 0:
            if k < o:
                return self.body.statement(k)
            if k > o and k < n:
                return self.else_body.statement(k)
        if k < 0:
            if k < o - n and k > -n:
                return self.body.statement(k)
            if k > o - n:
                return self.else_body.statement(k)
        return None
186780
def p_statements_statement(p):
    
    if len(p) == 2:
        p[0] = make_block(p[1])
    else:
        p[0] = make_block(p[1], p[2])
1304495
def p_with_statement(self, p):
        """"""
        p[0] = self.asttypes.With(expr=p[3], statement=p[5])
        p[0].setpos(p)
664995
def do_elif(self, t):
        
        d = self.dispatch_table
        if self.eval_expression(t):
            self.start_handling_includes()
            d['elif'] = self.stop_handling_includes
            d['else'] = self.stop_handling_includes
99035
def p_namedblock_statement(self, p):
        
        if isinstance(p[1], Decl):
            for r in p[1].list:
                if (not isinstance(r, Reg) and not isinstance(r, Wire)
                    and not isinstance(r, Integer) and not isinstance(r, Real)
                        and not isinstance(r, Parameter) and not isinstance(r, Localparam)):
                    raise ParseError("Syntax Error")
        p[0] = p[1]
        p.set_lineno(0, p.lineno(1))
995834
def p_statement_while(p):
    ''
    p[0] = ast.While(p[3], p[5], lineno=p.lineno(1))
630924
def int_or_str(v: Optional[str]) -> Union[None, int, str]:
    """"""
    if v is None:
        return
    try:
        return int(v)
    except ValueError:
        return v
1344293
def compound(self):
        
        root = Compound()
        self._process(Nature.LBRACKET)

        while self.token.nature != Nature.RBRACKET:
            root.children.append(self.statement())

        self._process(Nature.RBRACKET)
        return root
784495
def p_expr_OR_expr(p):
    
    p[0] = make_binary(p.lineno(2), 'OR', p[1], p[3], lambda x, y: x or y)
906740
def or_(cls, obj, **kwargs):
        
        return cls.__eval_seqexp(obj, operator.or_, **kwargs)
323575
def p_expr_include_once(p):
    ''
    p[0] = ast.Include(p[2], True, lineno=p.lineno(1))
348594
def take_until(condition):
    
    f = partial(takewhile, pipe | condition | operator.not_)
    f.attrs = {'including': take_until_including(condition)}
    return f