"""Parses the commandline args."""
  parser = argparse.ArgumentParser(
      description='Extracts ResultStore links from a build log.\n'
                  'These can be then printed out, and/or output into a '
                  'JUnit-based XML file inside a specified directory.')

  parser.add_argument('build_log',
                      help='Path to a build log.')
  parser.add_argument('--xml-out-path',

                inQuotes = !inQuotes;
            } else if (c == ch && !inQuotes) {
                count++;
            }
        }

        return count;
    }

    /**
     * Parses a CSV line into fields.
     *
     * @param line the CSV line
     * @param delimiter the delimiter character
     * @return array of field values
     */

            return data;
        } catch (final MessagingException e) {
            throw new ExtractException(e);
        }
    }

    /**
     * Puts a value into the extract data with appropriate type conversion.
     *
     * @param data the extract data to store the value in
     * @param key the key for the value
     * @param value the value to store
     */

### Async Context Manager { #async-context-manager }

If you check, the function is decorated with an `@asynccontextmanager`.

That converts the function into something called an "**async context manager**".

{* ../../docs_src/events/tutorial003_py39.py hl[1,13] *}

     * those already in the buffer.
     */
    internal var finished: Boolean,
  ) : Source {
    /** Buffer to receive data from the network into. Only accessed by the reader thread. */
    val receiveBuffer = Buffer()

    /** Buffer with readable data. Guarded by Http2Stream.this. */
    val readBuffer = Buffer()

    /**

        byte[] buffer = new byte[100];
        int startIndex = 5;
        original.encode(buffer, startIndex);

        // Now decode into a new instance
        int bytesRead = fileBasicInfo.decode(buffer, startIndex, 36);

        // Verify bytes read
        assertEquals(36, bytesRead);

        // Verify decoded values match original

                expanded.append(rightPart);
            }
            expandedAddress = expanded.toString();
        } else {
            expandedAddress = ipv6Address;
        }

        // Split address into parts
        final String[] parts = expandedAddress.split(":");
        if (parts.length != 8) {
            // Not a standard IPv6 address, return as-is
            return ipv6Address;
        }

 * using a lock, however it is dangerous to dispatch listeners while holding a lock because they
 * might run on the {@code directExecutor()} or be otherwise re-entrant (call back into your
 * object). So it is important to not call {@link #dispatch} while holding any locks. This is why
 * {@link #enqueue} and {@link #dispatch} are 2 different methods. It is expected that the decision

	p.input = operand
	p.inputPos = 0
}

// address parses the operand into a link address structure.
func (p *Parser) address(operand []lex.Token) obj.Addr {
	p.start(operand)
	addr := obj.Addr{}
	p.operand(&addr)
	return addr
}

// parseScale converts a decimal string into a valid scale factor.
func (p *Parser) parseScale(s string) int8 {
	switch s {
	case "1", "2", "4", "8":

    while (!receivedCloseFrame) {
      readHeader()
      if (!isControlFrame) {
        break
      }
      readControlFrame()
    }
  }

  /**
   * Reads a message body into across one or more frames. Control frames that occur between
   * fragments will be processed. If the message payload is masked this will unmask as it's being
   * processed.
   */
  @Throws(IOException::class)