Terminate the current line by writing the line separator string. The line
separator string is defined by the system property
<code>line.separator</code>, and is not necessarily a single newline
character (<code>'\n'</code>).
770188
public void println() {
        if (ivSuppress == true)
            return;
        String writeData = null;
        LogRecord sse = null;

        // Add data to cache, then forward on to logging subsystem. Must not
        // hold the object synchronizer on the dispatch.
        {
            sse = getTraceData(writeData);
            dispatchEvent(sse);
        }

        // // Write the data to the PrintStream this stream is wrapping.
        // if (ivFormatted == false)
        // ivStream.println();
        // else {
        // // Write data in formatted form. If a write is pending a header has
        // // already been written.
        // // Otherwise new up an event and write it, which also writes the
        // // header.
        // synchronized (this) {
        // if (ivWritePending)
        // ivStream.println();
        // else {
        // sse = createEvent(writeData);
        // sse.writeSelfToStream(ivStream, ivFormatType, true, ivBuffer,
        // ivFormatter, ivDate, ivFieldPos);
        // }
        // ivWritePending = false;
        // }
        // }
    }
1276260
public int getCharno() {
    Node cur = curNode;
    while (cur != null) {
      int line = cur.getCharno();
      if (line >= 0) {
        return line;
      }
      cur = cur.getParent();
    }
    return 0;
  }
931255
private void skipToEndOfLine()
  {
    while (pos < limit) {
      char c = in.charAt(pos++);
      if (c == '\n') {
        lineNumber++;
        lineStart = pos;
        break;
      } else if (c == '\r') {
        break;
      }
    }
  }
193653
protected void writeLine(final String line) {
		getContainer().getShell().getDisplay().syncExec(
			new Runnable() {
				public void run() {
					if (statusTextArea != null) {
						statusTextArea.setText(line + '\n' + statusTextArea.getText()); 
					}
				}
			}
		);
	}
119996
def _newline_end_of_file(relative_path, contents, linter_options):
    """
    del relative_path
    del linter_options
    last_line = len(contents) - 1
    if not len(contents) or not contents[last_line].endswith("\n"):
        if len(contents):
            last_line_replacement = contents[last_line] + "\n"
        else:
            last_line_replacement = "\n"
        return LinterFailure(r"No \n at end of file",
                             last_line + 1,
                             last_line_replacement)
1052255
private char rdCh()
	{
		char c = super.readCh();

		if (c == '\n')
		{
			linecount++;
			charpos = 0;
		} else if (c == '\t')
		{
			charpos += Properties.parser_tabstop - charpos
					% Properties.parser_tabstop;
		} else if (c != (char) -1)
		{
			charpos++;
		}

		ch = c;
		charsread++;
		offset = getCurrentRawReadOffset();

		// if(ch == '\r')
		// {
		// ch = rdCh();
		// }else
		// {
		// ch = c;
		// }
		return ch;
	}
109897
private boolean finishLine(boolean sawNewline) throws IOException {
    handleLine(line.toString(), sawReturn
        ? (sawNewline ? "\r\n" : "\r")
        : (sawNewline ? "\n" : ""));
    line = new StringBuilder();
    sawReturn = false;
    return sawNewline;
  }
1124090
def nextline(self):
        
        linebuf = b''
        linepos = self.bufpos + self.charpos
        eol = False
        while 1:
            self.fillbuf()
            if eol:
                c = self.buf[self.charpos]
                # handle b'\r\n'
                if c == b'\n':
                    linebuf += c
                    self.charpos += 1
                break
            m = EOL.search(self.buf, self.charpos)
            if m:
                linebuf += self.buf[self.charpos:m.end(0)]
                self.charpos = m.end(0)
                if linebuf[-1] == b'\r':
                    eol = True
                else:
                    break
            else:
                linebuf += self.buf[self.charpos:]
                self.charpos = len(self.buf)
        if self.debug:
            logging.debug('nextline: %r, %r' % (linepos, linebuf))
        return (linepos, linebuf)
863364
def _write_line(self, text=''):
        
        if text:
            self._code += str(text) + "\n"
        else:
            self._code += "\n"
684458
function lineTop (){
    var l = line(chars.top
               , chars['top-left'] || chars.top
               , chars['top-right'] ||  chars.top
               , chars['top-mid']);
    if (l)
      ret += l + "\n";
  }
309611
def line_is_continuation(line: str) -> bool:
    

    llstr = line.lstrip()
    return len(llstr) > 0 and llstr[0] == "&"
36086
public void write(int c) {
        if (c != -1) {
            current.append((char)c);
        }
        if (c == '\n') {
            current = new StringBuilder();
            lines.add(current);
        }
    }
744619
def get_text_line(self, line_nb):
        """"""
        # Taking into account the case when a file ends in an empty line,
        # since splitlines doesn't return that line as the last element
        # TODO: Make this function more efficient
        try:
            return to_text_string(self.toPlainText()).splitlines()[line_nb]
        except IndexError:
            return self.get_line_separator()
176542
private void writeChar(final char chr) throws IOException {
    switch (chr) {
      case '\t':
        this.Tab();
        break;
      case '\n': {
        this.out.write(this.lineSeparator);
        this.lineNumber++;
        this.prevMode = this.mode;
        this.mode = MODE_START_LINE;
        this.linePosition = 0;
        for (final Extra e : extras) {
          e.onNewLine(this, this.lineNumber);
        }
      }
      break;
      case '\r':
        break;
      default: {
        if (!Character.isISOControl(chr)) {
          this.out.write(chr);
          this.linePosition++;
          if (this.mode == MODE_START_LINE) {
            this.mode = this.prevMode;
          }
        }
      }
      break;
    }
  }
1335945
static int isNewLine(int[] chars)
  {
    checkArgument(chars.length > 1);
    // nl \n|\r\n|\r|\f
    if (chars[0] == '\r' && chars[1] == '\n')
    {
      return 2;
    }
    else if (chars[0] == '\n' || chars[0] == '\r' || chars[0] == '\f')
    {
      return 1;
    }
    return 0;
  }
451589
private static String stripIndentFromLine(String line, int numChars) {
        int length = line.length();
        return numChars <= length ? line.substring(numChars) : "";
    }
805363
function nextLine() {
            var at;
            line += 1;
            if (line >= lines.length) {
                return false;
            }
            character = 0;
            s = lines[line];
            at = s.search(cx);
            if (at >= 0) {
                warningAt("Unsafe character.", line, at);
            }
            return true;
        }