Processes a line that represents a comment or an empty line in a Content Specification.

@param parserData
@param line       The line to be processed.
@return True if the line was processed without errors, otherwise false.
335397
protected boolean parseEmptyOrCommentLine(final ParserData parserData, final String line) {
        if (isBlankLine(line)) {
            if (parserData.getCurrentLevel().getLevelType() == LevelType.BASE) {
                parserData.getContentSpec().appendChild(new TextNode("\n"));
            } else {
                parserData.getCurrentLevel().appendChild(new TextNode("\n"));
            }
            return true;
        } else {
            if (parserData.getCurrentLevel().getLevelType() == LevelType.BASE) {
                parserData.getContentSpec().appendComment(line);
            } else {
                parserData.getCurrentLevel().appendComment(line);
            }
            return true;
        }
    }
1222971
@Override
    public void handleComment(
            final char[] buffer,
            final int contentOffset, final int contentLen,
            final int outerOffset, final int outerLen,
            final int line, final int col)
            throws ParseException {

        this.someSelectorsMatch = false;
        for (int i = 0; i < this.selectorsLen; i++) {

            this.selectorMatches[i] =
                    this.selectorFilters[i].matchComment(false, this.markupLevel, this.markupBlocks[this.markupLevel]);
            if (this.selectorMatches[i]) {
                this.someSelectorsMatch = true;
            }

        }

        if (this.someSelectorsMatch) {
            markCurrentSelection();
            this.selectedHandler.handleComment(
                    buffer, contentOffset, contentLen, outerOffset, outerLen, line, col);
            unmarkCurrentSelection();
            return;
        }

        unmarkCurrentSelection();
        this.nonSelectedHandler.handleComment(
                buffer, contentOffset, contentLen, outerOffset, outerLen, line, col);

    }
1006847
public void parse( String line, File sourceFile, int lineNumber ) {

		// Reset
		this.rawNameToVariables.clear();
		this.errors.clear();
		this.cursor = 0;

		// Parse
		while( this.cursor < line.length()) {

			char c = line.charAt( this.cursor );
			if( Character.isWhitespace( c ) || c == ',' )
				this.cursor ++;

			recognizeVariable( line, sourceFile, lineNumber );
		}
	}
862003
protected void serializeComment(Comment node) throws SAXException {
        // comments=true
        if ((fFeatures & COMMENTS) != 0) {
            String data = node.getData();

            // well-formed=true
            if ((fFeatures & WELLFORMED) != 0) {
                isCommentWellFormed(data);
            }

            if (fLexicalHandler != null) {
                // apply the LSSerializer filter after the operations requested by the 
                // DOMConfiguration parameters have been applied 
                if (!applyFilter(node, NodeFilter.SHOW_COMMENT)) {
                    return;
                }

                fLexicalHandler.comment(data.toCharArray(), 0, data.length());
            }
        }
    }
186178
public void removeLine(final Line line)
    {
        if (line.previous == null)
        {
            this.lines = line.next;
        }
        else
        {
            line.previous.next = line.next;
        }
        if (line.next == null)
        {
            this.lineTail = line.previous;
        }
        else
        {
            line.next.previous = line.previous;
        }
        line.previous = line.next = null;
    }
1217581
public boolean isFirstHeaderLine(String line) {
        return firstLineDetectionPattern != null && line != null && firstLineDetectionPattern.matcher(line).matches();
    }
903117
private Optional<SqlCommandCall> parseCommand(String line) {
		final Optional<SqlCommandCall> parsedLine = SqlCommandParser.parse(line);
		if (!parsedLine.isPresent()) {
			printError(CliStrings.MESSAGE_UNKNOWN_SQL);
		}
		return parsedLine;
	}
968758
protected final boolean parseRequestLine(ByteBuffer in) throws InvalidState, BadMessage {
        lineLoop: while(true) {
            char ch;
            switch (lineState) {
                case START:
                    lineState = LineState.METHOD;
                    resetLimit(maxRequestLineSize);

                case METHOD:
                    for(ch = next(in, false); HttpTokens.A <= ch && ch <= HttpTokens.Z; ch = next(in, false)) {
                        putChar(ch);
                    }

                    if (ch == HttpTokens.EMPTY_BUFF) return false;

                    method = getString();
                    clearBuffer();


                    if (!HttpTokens.isWhiteSpace(ch)) {
                        String badmethod = method + (char)ch;
                        shutdownParser();
                        throw new BadMessage("Invalid request method: '" + badmethod + "'");
                    }

                   lineState = LineState.SPACE1;

                case SPACE1:
                    // Eat whitespace
                    for(ch = next(in, false); ch == HttpTokens.SPACE || ch == HttpTokens.TAB; ch = next(in, false));

                    if (ch == HttpTokens.EMPTY_BUFF) return false;

                    putChar(ch);
                    lineState = LineState.PATH;

                case PATH:
                    for(ch = next(in, false); ch != HttpTokens.SPACE && ch != HttpTokens.TAB; ch = next(in, false)) {
                        if (ch == HttpTokens.EMPTY_BUFF) return false;
                        putChar(ch);
                    }

                    path = getString();
                    clearBuffer();

                    lineState = LineState.SPACE2;

                case SPACE2:
                    // Eat whitespace
                    for(ch = next(in, false); ch == HttpTokens.SPACE || ch == HttpTokens.TAB; ch = next(in, false));

                    if (ch == HttpTokens.EMPTY_BUFF) return false;

                    if (ch != 'H') {
                        shutdownParser();
                        throw new BadMessage("Http version started with illegal character: " + ch);
                    }

                    putChar(ch);
                    lineState = LineState.VERSION;

                case VERSION:
                    for(ch = next(in, false); ch != HttpTokens.LF; ch = next(in, false)) {
                        if (ch == HttpTokens.EMPTY_BUFF) return false;
                        putChar(ch);
                    }

                    int majorVersion;
                    int minorVersion;
                    String scheme;

                    if (arrayMatches(HTTP11Bytes)) {
                        majorVersion = 1;
                        minorVersion = 1;
                        scheme = "http";
                    } else if (arrayMatches(HTTPS11Bytes)) {
                        majorVersion = 1;
                        minorVersion = 1;
                        scheme = "https";
                    } else if (arrayMatches(HTTP10Bytes)) {
                        majorVersion = 1;
                        minorVersion = 0;
                        scheme = "http";
                    } else if (arrayMatches(HTTPS10Bytes)) {
                        majorVersion = 1;
                        minorVersion = 0;
                        scheme = "https";
                    } else {
                        String reason =  "Bad HTTP version: " + getString();
                        clearBuffer();
                        shutdownParser();
                        throw new BadMessage(reason);
                    }

                    clearBuffer();

                    // We are through parsing the request line
                    lineState = LineState.END;
                    return !submitRequestLine(method, path, scheme, majorVersion, minorVersion);

                default:
                    throw new InvalidState(
                            "Attempted to parse Request line when already " +
                                    "complete. LineState: '" + lineState + "'");
            }    // switch
        }        // while loop
    }
78695
private static String getClassFromLine(String line) {
        line = line.trim();

        // Skip commented lines
        if (line.length() == 0 || line.startsWith("#"))
            return null;

        // lop off spaces/tabs/end-of-line-comments
        String[] className = line.split("[\\s#]");

        if (className.length >= 1)
            return className[0];

        return null;
    }
1234945
protected function isComment($line)
    {
        if (is_string($line) && (substr($line, 0, 1) == ';' || trim($line) == '')) {
            return true;
        }

        return false;
    }
640801
public static String[] getDataFromLine(final String line, final String seperator)
	{
		return getDataFromLine(line, seperator, false);
	}
215312
def process_stream_line(line)
      return if @mutex.synchronize { @subscriptions.any? { |subscription| subscription.process_stream_data line } }
      return if process_send_message_outcome line

      warn "Lightstreamer: unprocessed stream data '#{line}'"
    end
485281
private boolean processLine(final CommandLine line, final Options options) {
        if (line.hasOption(OPTION_VERSION)) {
            log.info(getVersion(true));
            return false;
        }
        if (line.hasOption(OPTION_HELP)) {
            produceHelp(options);
            return false;
        }
        if (line.hasOption(OPTION_INPUT)) {
            setInput(line.getOptionValue(OPTION_INPUT).trim());
        }
        if (line.hasOption(OPTION_INPUT_ENCODING)) {
            setInputEncoding(line.getOptionValue(OPTION_INPUT_ENCODING).trim());
        }
        if (line.hasOption(OPTION_OUTPUT)) {
            setOutput(line.getOptionValue(OPTION_OUTPUT).trim());
        }
        if (line.hasOption(OPTION_OUTPUT_PACKAGE_PREFIX)) {
            setOutputPackagePrefix(line.getOptionValue(
                    OPTION_OUTPUT_PACKAGE_PREFIX).trim());
        }
        if (line.hasOption(OPTION_CONFIG)) {
            setConfigProps(line.getOptionValue(OPTION_CONFIG).trim());
        }
        if (line.hasOption(OPTION_XSLT_FILE_NAME)) {
            setXsltFileName(line.getOptionValue(
                    OPTION_XSLT_FILE_NAME).trim());
        }

        return true;
    }
1197868
protected boolean isMetaDataLine(ParserData parserData, String line) {
        return parserData.getCurrentLevel().getLevelType() == LevelType.BASE && line.trim().matches("^\\w[\\w\\.\\s-]+=.*");
    }
842523
public List<String> parse(String line) throws ParseException {
    List<String> cols = new ArrayList<>();
    boolean afterQuote = false;
    boolean afterEscape = false;
    boolean afterSeparator = false;
    boolean outerQuote = false;
    boolean afterEndField = false;
    StringBuilder sb = new StringBuilder();

    for (int i = 0; ; ++i) {
      char c = (i == line.length()) ? EOT : line.charAt(i);
      if (afterEndField && c != separator && c != EOT) {
        if (!trim || c != ' ') {
          throw new ParseException("Extraneous character after end of quoted field", i);
        }
      } else if (afterEscape) {
        if (c == EOT) {
          // [abc\^]
          throw new ParseException("Escape not followed by a character", i);
        } else {
          // [abc\x...] => abcx...
          afterEscape = false;
          sb.append(c);
        }
      } else if (c == separator) {
        if (outerQuote && !afterQuote) {
          // ["abc,...] => abc,...
          sb.append(c);
          afterSeparator = false;
        } else {
          // [abc,...] => {abc, ...}
          endCol(cols, sb, i, outerQuote, afterQuote);
          afterQuote = afterEscape = afterEndField = outerQuote = false;
          afterSeparator = true;
        }
      } else if (c == EOT) {
        if (sb.length() != 0 || afterSeparator || outerQuote) {
          // [...,abc^] => {..., abc}
          // [...,^] => {..., ""}
          endCol(cols, sb, i, outerQuote, afterQuote);
        }
        return cols;
      } else if (c == escape) {
        // [...\...]
        afterEscape = true;
        afterSeparator = false;
      } else if (c == quote) {
        if (afterQuote && outerQuote) {
          // Two consecutive quotes inside quoted string, so the pair has to be internal
          // (the second quote cannot be terminating the field).
          sb.append(quote);
          afterQuote = false;
        } else if (sb.length() == 0 && !outerQuote) {
          outerQuote = true;
        } else if (sb.length() != 0 && !outerQuote) {
          // Fields that are not quote-delimited cannot have any internal quotes,
          // unless they are escaped which was already handled.
          throw new ParseException(escape == NUL
              ? "Unescaped quote inside non-quote-delimited field"
              : "Quote inside non-quote-delimited field",
              i);
        } else {
          afterQuote = true;
        }
        afterSeparator = false;
      } else if (c == ' ' && trim
          && ((!outerQuote && sb.length() == 0) // Trimmed space before field
              || afterEndField)) {              // Trimmed space after field
      } else if (c == ' ' && trim && afterQuote) {
        afterEndField = true;
      } else if (outerQuote && afterQuote) {
        // ["abc"x]
        throw new ParseException("Extraneous character after end of quoted field", i);
      } else {
        // Common character.
        sb.append(c);
        afterSeparator = false;
      }
    }
  }
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()); 
					}
				}
			}
		);
	}
980518
private boolean multiLineComment(Data data) throws TemplateException {
	SourceCode cfml = data.srcCode;
	if (!cfml.forwardIfCurrent("/*")) return false;
	int pos = cfml.getPos();
	boolean isDocComment = cfml.isCurrent('*');
	while (cfml.isValidIndex()) {
	    if (cfml.isCurrent("*/")) break;
	    cfml.next();
	}
	if (!cfml.forwardIfCurrent("*/")) {
	    cfml.setPos(pos);
	    throw new TemplateException(cfml, "comment is not closed");
	}
	if (isDocComment) {
	    String comment = cfml.substring(pos - 2, cfml.getPos() - pos);
	    data.docComment = docCommentTransformer.transform(data.factory, comment);
	}
	return true;
    }