Once parsed, @data and @errors are frozen since there's no need to alter them
519933
def tokenize(lines)
      @errors = []
      @data = {}
      lines.each do |line|
        case line
        when /^ADCO (\S{12}) ./
          @data[:adco] = $1
        when /^OPTARIF (....) ./
          @data[:optarif] = $1.sub(/\.+$/, '')
        when /^ISOUSC (\d{2}) ./
          @data[:isousc] = $1.to_i
        when /^BASE (\d{9}) ./ # BASE TARIF
          @data[:base] = $1.to_i
        when /^HCHC (\d{9}) ./ # HPHC TARIF
          @data[:hchc] = $1.to_i # HPHC TARIF
        when /^HCHP (\d{9}) ./ # HPHC TARIF
          @data[:hchp] = $1.to_i
        when /^PAPP (\d{5}) ./
          @data[:papp] = $1.to_i
        when /^PTEC (\S{4}) ./
          @data[:ptec] = $1.sub(/\.+$/, '')
        when /^IINST (\d{3}) ./
          @data[:iinst] = $1.to_i
        when /^IMAX (\d{3}) ./
          @data[:imax] = $1.to_i
        when /^HHPHC (\S{1})/ # HPHC TARIF
          @data[:hhphc] = $1
        when /^BBRHCJB (\d{9}) ./ # TEMPO Jour Bleu
          @data[:bbrhcjb] = $1.to_i
        when /^BBRHPJB (\d{9}) ./
          @data[:bbrhpjb] = $1.to_i # TEMPO Jour Bleu
        when /^BBRHCJW (\d{9}) ./
          @data[:bbrhcjw] = $1.to_i # TEMPO Jour Blanc
        when /^BBRHPJW (\d{9}) ./
          @data[:bbrhpjw] = $1.to_i # TEMPO Jour Blanc
        when /^BBRHCJR (\d{9}) ./
          @data[:bbrhcjr] = $1.to_i # TEMPO Jour rouge
        when /^BBRHPJR (\d{9}) ./
          @data[:bbrhpjr] = $1.to_i # TEMPO Jour rouge
        when /^DEMAIN (\S{4}) ./ # TEMPO lendemain
          @data[:bbrhpjr] = $1
        when /^ADPS (\d{3})/ # Alerte dépassement de seuil
          @data[:adps] = $1.to_i
        when /MOTDETAT/
          # always 00000…
        else
          @errors << "Can't parse: #{line}"
        end
      end
      @data.freeze
      @errors.freeze
    end
131325
function() {
      var self = this;
      if (self._refreshingCache) {
        return;
      }
      self._refreshingCache = true;
      Parse._objectEach(this.attributes, function(value, key) {
        if (value instanceof Parse.Object) {
          value._refreshCache();
        } else if (_.isObject(value)) {
          if (self._resetCacheForKey(key)) {
            self.set(key, new Parse.Op.Set(value), { silent: true });
          }
        }
      });
      delete self._refreshingCache;
    }
1346979
function unknownError(message, stack) {
    jitsu.log.error(message);
    stack.split('\n').forEach(function (line) {
      jitsu.log.error(line);
    })
  }
1456
def _post_clean(self):
        
        super(NgModelFormMixin, self)._post_clean()
        if self._errors and self.prefix:
            self._errors = ErrorDict((self.add_prefix(name), value) for name, value in self._errors.items())
277704
function freezeData (freezeData) {
    if (defined(freezeData)) {
        // set default
        immutable.defaultFreezeData = freezeData ? true : false
        // return immutable
        return ImmutableCore
    }
    // return default value
    return immutable.defaultFreezeData
}
1353023
public void endParsing() throws SnowflakeSQLException
  {
    if (partialEscapedUnicode.position() > 0)
    {
      partialEscapedUnicode.flip();
      continueParsingInternal(partialEscapedUnicode, true);
      partialEscapedUnicode.clear();
    }

    if (state != State.ROW_FINISHED)
    {
      throw new SnowflakeSQLException(SqlState.INTERNAL_ERROR,
                                      ErrorCode.INTERNAL_ERROR.getMessageCode(),
                                      "SFResultJsonParser2Failed: Chunk is truncated!");
    }
    currentColumn = 0;
    state = State.UNINITIALIZED;
  }
930310
private void parseViewError(boolean last) {
        if (!last) {
            return;
        }

        if (responseHeader.getStatus().code() == 200) {
            int openBracketPos = responseContent.bytesBefore((byte) '[') + responseContent.readerIndex();
            int closeBracketLength = findSectionClosingPosition(responseContent, '[', ']') - openBracketPos + 1;
            ByteBuf slice = responseContent.slice(openBracketPos, closeBracketLength);
            viewErrorObservable.onNext("{\"errors\":" + slice.toString(CharsetUtil.UTF_8) + "}");
        } else {
            viewErrorObservable.onNext("{\"errors\":[" + responseContent.toString(CharsetUtil.UTF_8) + "]}");
        }

        viewErrorObservable.onCompleted();
        viewParsingState = QUERY_STATE_DONE;
        responseContent.discardReadBytes();
    }
1270647
function parseError(error: Error | string | string[]): StackFrame[] {
  if (error == null) {
    throw new Error('You cannot pass a null object.')
  }
  if (typeof error === 'string') {
    return parseStack(error.split('\n'))
  }
  if (Array.isArray(error)) {
    return parseStack(error)
  }
  if (typeof error.stack === 'string') {
    return parseStack(error.stack.split('\n'))
  }
  throw new Error('The error you provided does not contain a stack trace.')
}
191382
function processData(err, data) {
              if (enc) { file.text = data.toString(enc); } else { file.buffer = data; }
              if (entry.sha) { file.sha = entry.sha; }
              append(err, file);
              readDone();
            }
712763
private void parseQueryError(boolean lastChunk) {
        while (true) {
            int openBracketPos = findNextChar(responseContent, '{');
            if (isEmptySection(openBracketPos) || (lastChunk && openBracketPos < 0)) {
                sectionDone();
                queryParsingState = transitionToNextToken(lastChunk); //warnings or status
                break;
            }

            int closeBracketPos = findSectionClosingPosition(responseContent, '{', '}');
            if (closeBracketPos == -1) {
                break;
            }

            int length = closeBracketPos - openBracketPos - responseContent.readerIndex() + 1;
            responseContent.skipBytes(openBracketPos);
            ByteBuf resultSlice = responseContent.readSlice(length);
            queryErrorObservable.onNext(resultSlice.copy());
        }
    }
415458
function parseError(res, body) {
  // Res is optional.
  if (body == null) {
    body = res;
  }
  // Status code is required.
  const status = parseError.findErrorCode(sliced(arguments));
  if (!status) {
    return false;
  }
  // Body can have an error-like object, in which case the attributes will be used.
  const obj = findErrorObj(body);
  if (obj) {
    body = Object.assign(body, obj);
  }
  return [status, body];
}
1045821
function ignoreErrorForStatusCodes() {
  var statusCodes = Array.prototype.slice.call(arguments);

  return function(ctx, next) {
    if (ctx.err && ctx.res && statusCodes.indexOf(ctx.res.statusCode) !== -1) {
      delete ctx.err;
    }

    next();
  };
}
434095
function parse(contents, retained, parser) {
    var errors = [], data = [], lines = 0;

    // optional parser
    if (!parser) parser = JSON;

    // process each line of the file
    contents.toString().split('\n').forEach(function(line) {
        if (!line) return;
        lines++;
        try {
            data.push(parser.parse(line));
        } catch (e) {
            e.line = line;
            errors.push(e);
        }
    });

    // if no errors/data, don't return an empty array
    var ret = {};
    if (errors.length) ret.errors = errors;
    if (data.length) ret.data = data;

    // if every line failed, probably not line-delimited
    if (errors.length == lines) ret.errors = retained;

    return ret;
}
1016727
function HTTPError(statusCode, data) {
  Error.call(this);
  Error.captureStackTrace(this, this.constructor);

  /**
   * Human-readable error name.
   *
   * @type {String}
   */
  this.name = http.STATUS_CODES[statusCode];

  /**
   * HTTP status code.
   *
   * @type {Number}
   */
  this.statusCode = statusCode;

  /**
   * Any additional data.
   *
   * @type {*}
   */
  this.data = data;

  if (data) {
    // Property of Error.
    this.message = JSON.stringify(data);
  }
}
115525
private function parsing() : void
    {
        $lines = explode("\n", $this->raw);

        foreach ($lines as $line) {
            // check "at" mark
            if (false === strpos($line, '@')) {
                continue;
            }

            // check inline annotation
            if ($anp = strpos($line, '//')) {
                $line = substr($line, 0, $anp);
            }

            // trim blanks
            $line = trim(ltrim($line, ' *'));

            // analyze expr
            if (false === $fws = strpos($line, ' ')) {
                // @some-key
                $key = substr($line, 1);
                $val = true;
            } else {
                // @some-key some-val
                $key = substr($line, 1, $fws - 1);
                $val = trim(substr($line, $fws));
            }

            $this->lines[] = [$key, $val];

            $this->declares[$key][] = $val;
        }
    }
505598
function done(error) {
    if (error) {
      errors.push(error);
    }
    if (--initializing <= 0) {
      if (errors && errors.length) {
        var errorResult = new Error('Errors occurred during initialization.');
        errorResult.initializationErrors = errors;
        callback(errorResult);
      } else {
        processPostInitializeQueue(postInitializeQueue, callback);
      }
    }
  }
1106627
function load(err, data){
            if (err) throw err
            _.log('view added: '+name+': '+source)
            views[name] = compile(''+data)
        }