Returns a string describing, in order of 'expensiveness', the top-level failed rule chains in the parse run.
551289
public String getOverviewReport() {
		TreeSet<ReportEntry<V>> topLevelFailed = new TreeSet<ReportEntry<V>>();
		fillReport(topLevelFailed, rootReport);
		StringBuilder out = new StringBuilder();
		for (ReportEntry<V> entry : topLevelFailed) {
			if (entry.getSubSteps() < 100) break;
			out.append(formatReport(entry, false));
		}
		
		return out.toString();
	}
775702
public final void mRULE_IN_RICH_STRING() throws RecognitionException {
        try {
            // InternalSARL.g:48781:30: ( ( '\\'\\'' ~ ( ( '\\uFFFD' | '\\'' ) ) | '\\'' ~ ( ( '\\uFFFD' | '\\'' ) ) | ~ ( ( '\\uFFFD' | '\\'' ) ) ) )
            // InternalSARL.g:48781:32: ( '\\'\\'' ~ ( ( '\\uFFFD' | '\\'' ) ) | '\\'' ~ ( ( '\\uFFFD' | '\\'' ) ) | ~ ( ( '\\uFFFD' | '\\'' ) ) )
            {
            // InternalSARL.g:48781:32: ( '\\'\\'' ~ ( ( '\\uFFFD' | '\\'' ) ) | '\\'' ~ ( ( '\\uFFFD' | '\\'' ) ) | ~ ( ( '\\uFFFD' | '\\'' ) ) )
            int alt35=3;
            int LA35_0 = input.LA(1);

            if ( (LA35_0=='\'') ) {
                int LA35_1 = input.LA(2);

                if ( (LA35_1=='\'') ) {
                    alt35=1;
                }
                else if ( ((LA35_1>='\u0000' && LA35_1<='&')||(LA35_1>='(' && LA35_1<='\uFFFC')||(LA35_1>='\uFFFE' && LA35_1<='\uFFFF')) ) {
                    alt35=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 35, 1, input);

                    throw nvae;
                }
            }
            else if ( ((LA35_0>='\u0000' && LA35_0<='&')||(LA35_0>='(' && LA35_0<='\uFFFC')||(LA35_0>='\uFFFE' && LA35_0<='\uFFFF')) ) {
                alt35=3;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 35, 0, input);

                throw nvae;
            }
            switch (alt35) {
                case 1 :
                    // InternalSARL.g:48781:33: '\\'\\'' ~ ( ( '\\uFFFD' | '\\'' ) )
                    {
                    match("''"); 

                    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFC')||(input.LA(1)>='\uFFFE' && input.LA(1)<='\uFFFF') ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;
                case 2 :
                    // InternalSARL.g:48781:59: '\\'' ~ ( ( '\\uFFFD' | '\\'' ) )
                    {
                    match('\''); 
                    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFC')||(input.LA(1)>='\uFFFE' && input.LA(1)<='\uFFFF') ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;
                case 3 :
                    // InternalSARL.g:48781:83: ~ ( ( '\\uFFFD' | '\\'' ) )
                    {
                    if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFC')||(input.LA(1)>='\uFFFE' && input.LA(1)<='\uFFFF') ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;

            }


            }

        }
        finally {
        }
    }
967121
function (rules) {
		if (!_.isArray(rules)) {
			rules = [ rules ];
		}

		var that = this;

		return _.map(rules, function (rule) {
			if (typeof rule === 'string') {
				return that._parseString(rule);
			}

			if (_.isPlainObject(rule)) {
				return that._parseObject(rule);
			}

			throw new Error('#V1: invalid rule type, must be string or plain object');
		});
	}
859978
def getter_fail(error)
      message = "#{self.class.to_s} Error: #{error.inspect}"

      if RUBY_PLATFORM == 'opal'
        if `#{@getter}`
          message += "\n" + `#{@getter}.toString()`
        end
      else
        if error.respond_to?(:backtrace)
          message += "\n" + error.backtrace.join("\n")
        end
      end

      Volt.logger.error(message)
    end
1242941
private String getParserErrorMessage() {
	StringBuffer code = new StringBuffer(text);
	code = code.insert(maxPosition, " >><< ");
	String codeString = code.substring(maxPosition - 100 < 0 ? 0 : maxPosition - 100,
		maxPosition + 100 >= code.length() ? code.length() : maxPosition + 100);
	return "Could not parse the input string near '" + codeString + "'!";
    }
1304636
private String getArgRequiredErrorMessage() {
        return getMutexTargetList().isEmpty() ?
                String.format("Argument '%s' is required", getLongName()) :
                String.format("Argument '%s' is required unless one of {%s} are provided", getLongName(), getMutexTargetList());
    }
654664
public String getError() {
    if (GoldenGrammarError_Type.featOkTst
        && ((GoldenGrammarError_Type) jcasType).casFeat_error == null)
      jcasType.jcas.throwFeatMissing("error", "cogroo.uima.GoldenGrammarError");
    return jcasType.ll_cas.ll_getStringValue(addr,
        ((GoldenGrammarError_Type) jcasType).casFeatCode_error);
  }
1053550
def parse_requirements(strs):
    
    # create a steppable iterator, so we can handle \-continuations
    lines = iter(yield_lines(strs))

    for line in lines:
        # Drop comments -- a hash without a space may be in a URL.
        if ' #' in line:
            line = line[:line.find(' #')]
        # If there is a line continuation, drop it, and append the next line.
        if line.endswith('\\'):
            line = line[:-2].strip()
            try:
                line += next(lines)
            except StopIteration:
                return
        yield Requirement(line)
60777
def bad_syntax(cls, syntax, resource_name, ex=None):
        

        if ex:
            msg = "The syntax is '%s' (%s)." % (syntax, ex)
        else:
            msg = "The syntax is '%s'." % syntax

        msg = "Could not parse '%s'. %s" % (resource_name, msg)

        return cls(msg)
489284
def _get_description(self):
        
        return ", ".join([
            part for part in [
                "missing: {}".format(self.missing) if self.missing else "",
                (
                    "forbidden: {}".format(self.forbidden)
                    if self.forbidden else ""
                ),
                "invalid: {}:".format(self.invalid) if self.invalid else "",
                (
                    "failed to parse: {}".format(self.failed)
                    if self.failed else ""
                )
            ] if part
        ])
746437
private static List<String> strings(final List<IOException> failures) {
        final List<String> result = new ArrayList<>(failures.size());
        final Iterable<String> transform = new Transform<>(
            failures,
            new TransformAction<IOException, String>() {
                @Override
                public String transform(final IOException element) {
                    final Opt<String> message = new Opt.Single<>(
                        element.getMessage()
                    );
                    String result = "";
                    if (message.has()) {
                        result = message.get();
                    }
                    return result;
                }
            }
        );
        final Iterator<String> messages = transform.iterator();
        while (messages.hasNext()) {
            result.add(messages.next());
        }
        return result;
    }
1274985
def get_chain(self, name, table="filter"):
        
        return [r for r in self.rules if r["table"] == table and r["chain"] == name]
908654
function (err) {
    "use strict";

    var message = '';

    if (typeof err === 'string') {
      return new Error(err);

    } else if (typeof err === 'object') {

      if (err.cause) {
        // probably a webdriver error
        try {
          message = JSON.parse(err.cause.value.message).errorMessage;
        } catch ($) {
          message = err.cause.value.message;
        }
      } else {
        message = err.message || err.toString();
      }
      return new Error(message);
    }
    return new Error(err.toString());
  }
304074
def error_string(self):
        

        if self.has_correct_call_count():
            return ''

        return '{} instead of {} {} '.format(
            self._restriction_string(),
            self.count,
            pluralize('time', self.count)
        )
805295
public String topFeaturesToString(List<Triple<F,L,Double>> topFeatures)
  {
    // find longest key length (for pretty printing) with a limit
    int maxLeng = 0;
    for (Triple<F,L,Double> t : topFeatures) {
      String key = "(" + t.first + "," + t.second + ")";
      int leng = key.length();
      if (leng > maxLeng) {
        maxLeng = leng;
      }
    }
    maxLeng = Math.min(64, maxLeng);

    // set up pretty printing of weights
    NumberFormat nf = NumberFormat.getNumberInstance();
    nf.setMinimumFractionDigits(4);
    nf.setMaximumFractionDigits(4);
    if (nf instanceof DecimalFormat) {
      ((DecimalFormat) nf).setPositivePrefix(" ");
    }

    //print high weight features to a String
    StringBuilder sb = new StringBuilder();
    for (Triple<F,L,Double> t : topFeatures) {
      String key = "(" + t.first + "," + t.second + ")";
      sb.append(StringUtils.pad(key, maxLeng));
      sb.append(" ");
      double cnt = t.third();
      if (Double.isInfinite(cnt)) {
        sb.append(cnt);
      } else {
        sb.append(nf.format(cnt));
      }
      sb.append("\n");
    }
    return sb.toString();
  }
1239959
def get_friendly_title(err):
    
    if isinstance(err, basestring):
        string = err
    else:
        try:
            string = err.__name__
        except AttributeError:
            string = err.__class__.__name__
    split = _SPLITCASE_RE.findall(string)
    if not split:
        split.append(string)
    if len(split) > 1 and split[0] == 'Fastfood':
        split.pop(0)

    return " ".join(split)
606929
public String
getErrorString() {
	checkDone();
	if (error != null)
		return error;
	switch (result) {
		case SUCCESSFUL:	return "successful";
		case UNRECOVERABLE:	return "unrecoverable error";
		case TRY_AGAIN:		return "try again";
		case HOST_NOT_FOUND:	return "host not found";
		case TYPE_NOT_FOUND:	return "type not found";
	}
	throw new IllegalStateException("unknown result");
}