region skip header fields
519983
private void skipHeaders(int flag) {
		// trying to skip optional gzip file members if any is present
		if ((flag & FEXTRA) != 0) {
			skipExtra(flag);
		} else if ((flag & FNAME) != 0) {
			skipTerminatorByte(flag, FNAME);
		} else if ((flag & FCOMMENT) != 0) {
			skipTerminatorByte(flag, FCOMMENT);
		} else if ((flag & FHCRC) != 0) {
			skipCRC16(flag);
		}
	}
39719
private State skipSpaces(State state) throws IOException {
        for (;;) {
            switch (state.current) {
                default:
                    return state;
                case 0x20:
                case 0x09:
                case 0x0D:
                case 0x0A:
            }
            state.current = state.reader.read();
            state = appendToContext(state);
        }
    }
108243
public void setExtent( JGTProcessingRegion region ) {
        west = region.getWest();
        east = region.getEast();
        south = region.getSouth();
        north = region.getNorth();
        rows = region.getRows();
        cols = region.getCols();
        fixResolution();
        fixRowsAndCols();
    }
942293
def forbid_multi_line_headers(name, val):
    """"""
    val = smart_text(val)
    if "\n" in val or "\r" in val:
        raise BadHeaderError(
            "Header values can't contain newlines "
            "(got %r for header %r)" % (val, name)
        )
    try:
        val = val.encode("ascii")
    except UnicodeEncodeError:
        if name.lower() in ("to", "from", "cc"):
            result = []
            for item in val.split(", "):
                nm, addr = parseaddr(item)
                nm = str(Header(nm, DEFAULT_CHARSET))
                result.append(formataddr((nm, str(addr))))
            val = ", ".join(result)
        else:
            val = Header(val, DEFAULT_CHARSET)
    else:
        if name.lower() == "subject":
            val = Header(val)
    return name, val
740857
function(res){
	Object.keys(res._headers).forEach(function(field){
		if (0 === field.indexOf('content')) {
			res.removeHeader(field);
		}
	});
}
931825
private static Properties parseHeaderFields(String[] pHeaders) {
        Properties headers = new Properties();

        // Get header information
        int split;
        String field;
        String value;

        for (String header : pHeaders) {
            //System.err.println(pHeaders[i]);
            if ((split = header.indexOf(":")) > 0) {

                // Read & parse..?
                field = header.substring(0, split);
                value = header.substring(split + 1);

                //System.err.println(field + ": " + value.trim());
                headers.setProperty(StringUtil.toLowerCase(field), value.trim());
            }
        }
        return headers;
    }
771984
private void initHeader(final List<String> currentFields) {
		final Map<String, Integer> localHeaderMap = new LinkedHashMap<>(currentFields.size());
		for (int i = 0; i < currentFields.size(); i++) {
			final String field = currentFields.get(i);
			if (StrUtil.isNotEmpty(field) && false ==localHeaderMap.containsKey(field)) {
				localHeaderMap.put(field, i);
			}
		}
		
		header = new CsvRow(this.lineNo, Collections.unmodifiableMap(localHeaderMap),  Collections.unmodifiableList(currentFields));
	}
636639
public void skipEofPacket() throws SQLException, IOException {
    Buffer buffer = reader.getPacket(true);
    switch (buffer.getByteAt(0)) {
      case EOF:
        break;

      case ERROR:
        ErrorPacket ep = new ErrorPacket(buffer);
        throw new SQLException("Could not connect: " + ep.getMessage(), ep.getSqlState(),
            ep.getErrorNumber());

      default:
        throw new SQLException("Unexpected packet type " + buffer.getByteAt(0)
            + " instead of EOF");
    }
  }
892551
function(region) {
            // Get form data.
            var serializeFormField = function(array) {
                var sarr = [];

                var i = 0;
                for (i=0; i<array.length;i++) {
                    var a = array[i];
                    var o = {};
                    o.name = a.name;
                    o.value = a.value;
                    o.type = a.type;
                    if (a.type === "checkbox") {
                        o.value = (a.checked) ? "on" : "off";
                    }
                    sarr.push(o);
                }
                return sarr;
            };

            var n = serializeFormField(document.querySelectorAll(region + " > input"));

            var data = (n).reduce(function(obj, field) {
                switch (field.type) {
                case 'number':
                    if (field.value !== "") {
                        obj[field.name] = parseFloat(field.value); // for fields that are numbers.
                    }
                    break;

                case 'checkbox':
                    obj[field.name] = (field.value === 'on') ? true : false; // for checkboxes.
                    break;

                default:
                    obj[field.name] = field.value; // default for fields that are text.
                    break;
                }

                return obj;
            }, {});

            return data;
        }
876969
private static void addHeaderIfNotNull(Request<?> request, String header, String value) {
        if (value != null) {
            request.addHeader(header, value);
        }
    }
424850
function _fillMissingFields(attrs) {
  var attr;
  for(var i = 0; i < attrs.length; ++i) {
    attr = attrs[i];

    // populate missing name
    if(typeof attr.name === 'undefined') {
      if(attr.type && attr.type in pki.oids) {
        attr.name = pki.oids[attr.type];
      } else if(attr.shortName && attr.shortName in _shortNames) {
        attr.name = pki.oids[_shortNames[attr.shortName]];
      }
    }

    // populate missing type (OID)
    if(typeof attr.type === 'undefined') {
      if(attr.name && attr.name in pki.oids) {
        attr.type = pki.oids[attr.name];
      } else {
        var error = new Error('Attribute type not specified.');
        error.attribute = attr;
        throw error;
      }
    }

    // populate missing shortname
    if(typeof attr.shortName === 'undefined') {
      if(attr.name && attr.name in _shortNames) {
        attr.shortName = _shortNames[attr.name];
      }
    }

    // convert extensions to value
    if(attr.type === oids.extensionRequest) {
      attr.valueConstructed = true;
      attr.valueTagClass = asn1.Type.SEQUENCE;
      if(!attr.value && attr.extensions) {
        attr.value = [];
        for(var ei = 0; ei < attr.extensions.length; ++ei) {
          attr.value.push(pki.certificateExtensionToAsn1(
            _fillMissingExtensionFields(attr.extensions[ei])));
        }
      }
    }

    if(typeof attr.value === 'undefined') {
      var error = new Error('Attribute value not specified.');
      error.attribute = attr;
      throw error;
    }
  }
}
1183633
function _fillMissingFields(attrs) {
  var attr;
  for(var i = 0; i < attrs.length; ++i) {
    attr = attrs[i];

    // populate missing name
    if(typeof(attr.name) === 'undefined') {
      if(attr.type && attr.type in pki.oids) {
        attr.name = pki.oids[attr.type];
      } else if(attr.shortName && attr.shortName in _shortNames) {
        attr.name = pki.oids[_shortNames[attr.shortName]];
      }
    }

    // populate missing type (OID)
    if(typeof(attr.type) === 'undefined') {
      if(attr.name && attr.name in pki.oids) {
        attr.type = pki.oids[attr.name];
      } else {
        var error = new Error('Attribute type not specified.');
        error.attribute = attr;
        throw error;
      }
    }

    // populate missing shortname
    if(typeof(attr.shortName) === 'undefined') {
      if(attr.name && attr.name in _shortNames) {
        attr.shortName = _shortNames[attr.name];
      }
    }

    if(typeof(attr.value) === 'undefined') {
      var error = new Error('Attribute value not specified.');
      error.attribute = attr;
      throw error;
    }
  }
}
1029028
private void removeHdr(HeaderElement elem) {
        if (null == elem) {
            return;
        }
        HeaderKeys key = elem.getKey();
        elem.remove();
        if (key.useFilters()) {
            filterRemove(key, elem.asBytes());
        }
    }
490624
function cleanHeaders(e) {
  for (var headerIndex = 1; headerIndex < 7; headerIndex++) {
    var headers = e.getElementsByTagName('h' + headerIndex);
    for (var i = headers.length - 1; i >= 0; --i) {
      if (getClassWeight(headers[i]) < 0 || getLinkDensity(headers[i]) > 0.33) {
        headers[i].parentNode.removeChild(headers[i]);
      }
    }
  }
}
749903
function capitalizeHeaderField(field) {
    return field.split('-').map(function (part) {
        return part[ 0 ].toUpperCase() + part.substring(1).toLowerCase()
    }).join('-')
}
790106
function cleanSingleHeader(e) {
  for (var headerIndex = 1; headerIndex < 7; headerIndex++) {
    var headers = e.getElementsByTagName('h' + headerIndex);
    for (var i = headers.length - 1; i >= 0; --i) {
      if (headers[i].nextSibling === null) {
        headers[i].parentNode.removeChild(headers[i]);
      }
    }
  }

}
1231851
protected static final void skipWhitespaces(Source src) {
		if (src.idx <= src.last) {
			src.ch = src.chars[src.idx];
		}
		if (src.ch <= 32) {
			for (; src.idx <= src.last; src.idx++) {
				if (src.chars[src.idx] > 32) {
					break;
				}
			}
			src.ch = src.chars[src.idx];
		}
	}