Parse skeleton, save each field's width.
It is used for looking for best match skeleton,
and adjust pattern field width.
@param skeleton            skeleton to be parsed
@param skeletonFieldWidth  parsed skeleton field width
553474
static void parseSkeleton(String skeleton, int[] skeletonFieldWidth) {
        int PATTERN_CHAR_BASE = 0x41;
        for ( int i = 0; i < skeleton.length(); ++i ) {
            ++skeletonFieldWidth[skeleton.charAt(i) - PATTERN_CHAR_BASE];
        }
    }
1037339
private void saveToContext(Context context, boolean updateSiteStructure) {
		ParameterParser urlParamParser = context.getUrlParamParser();
		ParameterParser formParamParser = context.getPostParamParser();
		List<String> structParams = new ArrayList<String>();
		List<StructuralNodeModifier> ddns = new ArrayList<StructuralNodeModifier>();
		
		for (StructuralNodeModifier snm : this.ddnTableModel.getElements()) {
			if (snm.getType().equals(StructuralNodeModifier.Type.StructuralParameter)) {
				structParams.add(snm.getName());
			} else {
				ddns.add(snm);
			}
		}

		if (urlParamParser instanceof StandardParameterParser) {
			StandardParameterParser urlStdParamParser = (StandardParameterParser) urlParamParser;
			urlStdParamParser.setKeyValuePairSeparators(this.getUrlKvPairSeparators().getText());
			urlStdParamParser.setKeyValueSeparators(this.getUrlKeyValueSeparators().getText());

			urlStdParamParser.setStructuralParameters(structParams);

			context.setUrlParamParser(urlStdParamParser);
			urlStdParamParser.setContext(context);
		}
		if (formParamParser instanceof StandardParameterParser) {
			StandardParameterParser formStdParamParser = (StandardParameterParser) formParamParser;
			formStdParamParser.setKeyValuePairSeparators(this.getPostKvPairSeparators().getText());
			formStdParamParser.setKeyValueSeparators(this.getPostKeyValueSeparators().getText());
			context.setPostParamParser(formStdParamParser);
			formStdParamParser.setContext(context);
		}
		
		context.setDataDrivenNodes(ddns);
		
		if (updateSiteStructure) {
			context.restructureSiteTree();
		}
	}
1257712
@Override
	protected void parse(Node node) {
		NamedNodeMap attributes = node.getAttributes();
		width = getValueRecursiveAsInteger(attributes.getNamedItem("width"));
		height = getValueRecursiveAsInteger(attributes.getNamedItem("height"));
		mimeType = getValueRecursive(attributes.getNamedItem("mime-type"));
		extension = getValueRecursive(attributes.getNamedItem("extension"));
		setParsed(true);
	}
602371
private Node parseFieldName(JsDocToken token) {
    switch (token) {
      case STRING:
        String s = stream.getString();
        Node n = Node.newString(
            Token.STRING_KEY, s, stream.getLineno(), stream.getCharno())
            .clonePropsFrom(templateNode);
        n.setLength(s.length());
        return n;

      default:
        return null;
    }
  }
1116514
public void setWidth(float width) {
		if (width != this.width) {
	        pointsDirty = true;
			this.width = width;
			maxX = x+width;
		}
	}
718367
def parse_tree_line(line)
      mode, _type, sha, size, *name = line.split(/\s+/)
      BlobEntry.new(sha, name.join(' '), size.to_i, mode.to_i(8))
    end
1039633
function ( skeletons, geometryMap, materialMap ) {

			var modelMap = new Map();
			var modelNodes = fbxTree.Objects.Model;

			for ( var nodeID in modelNodes ) {

				var id = parseInt( nodeID );
				var node = modelNodes[ nodeID ];
				var relationships = connections.get( id );

				var model = this.buildSkeleton( relationships, skeletons, id, node.attrName );

				if ( ! model ) {

					switch ( node.attrType ) {

						case 'Camera':
							model = this.createCamera( relationships );
							break;
						case 'Light':
							model = this.createLight( relationships );
							break;
						case 'Mesh':
							model = this.createMesh( relationships, geometryMap, materialMap );
							break;
						case 'NurbsCurve':
							model = this.createCurve( relationships, geometryMap );
							break;
						case 'LimbNode': // usually associated with a Bone, however if a Bone was not created we'll make a Group instead
						case 'Null':
						default:
							model = new THREE.Group();
							break;

					}

					model.name = THREE.PropertyBinding.sanitizeNodeName( node.attrName );
					model.ID = id;

				}

				this.setModelTransforms( model, node );
				modelMap.set( id, model );

			}

			return modelMap;

		}
297671
public final void setLengthForTree(int length) {
    this.length = length;

    for (Node child = first; child != null; child = child.next) {
      child.setLengthForTree(length);
    }
  }
673197
public void setWidth(java.lang.String width) {
        getStateHelper().put(PropertyKeys.width, width);
        handleAttribute("width", width);
    }
1015409
public void processPacket(OggPacket packet) {
        SkeletonPacket skel = SkeletonPacketFactory.create(packet);

        // First packet must be the head
        if (packet.isBeginningOfStream()) {
            fishead = (SkeletonFishead)skel;
        } else if (skel instanceof SkeletonFisbone) {
            SkeletonFisbone bone = (SkeletonFisbone)skel;
            fisbones.add(bone);
            bonesByStream.put(bone.getSerialNumber(), bone);
        } else if (skel instanceof SkeletonKeyFramePacket) {
            keyFrames.add((SkeletonKeyFramePacket)skel);
        } else {
            throw new IllegalStateException("Unexpected Skeleton " + skel);
        }

        if (packet.isEndOfStream()) {
            hasWholeStream = true;
        }
    }
936845
private void storeField(Field field, StructImpl fieldsMap) {
	String fieldName = field.getName();
	Object o = fieldsMap.get(fieldName, null);
	Field[] args;
	if (o == null) {
	    args = new Field[1];
	    fieldsMap.setEL(fieldName, args);
	}
	else {
	    Field[] fs = (Field[]) o;
	    args = new Field[fs.length + 1];
	    for (int i = 0; i < fs.length; i++) {
		fs[i].setAccessible(true);
		args[i] = fs[i];
	    }
	    fieldsMap.setEL(fieldName, args);
	}
	args[args.length - 1] = field;
    }
748579
def parse(node, unit = :dxa)
      node.attributes.each do |key, value|
        case key
        when 'top'
          @top = OoxmlSize.new(value.value.to_f, unit)
        when 'left'
          @left = OoxmlSize.new(value.value.to_f, unit)
        when 'right'
          @right = OoxmlSize.new(value.value.to_f, unit)
        when 'bottom'
          @bottom = OoxmlSize.new(value.value.to_f, unit)
        when 'header'
          @header = OoxmlSize.new(value.value.to_f, unit)
        when 'footer'
          @footer = OoxmlSize.new(value.value.to_f, unit)
        when 'gutter'
          @gutter = OoxmlSize.new(value.value.to_f, unit)
        end
      end
      self
    end
158595
@SuppressWarnings("unchecked")
	private static void computeAnyFieldDifferences(FieldNode oField, FieldNode nField, TypeDelta td) {
		// Want to record things that are different between these two fields...
		FieldDelta fd = new FieldDelta(oField.name);
		if (oField.access != nField.access) {
			// access changed
			fd.setAccessChanged(oField.access, nField.access);
		}
		if (!oField.desc.equals(nField.desc)) {
			// type changed
			fd.setTypeChanged(oField.desc, nField.desc);
		}
		String annotationChange = compareAnnotations(oField.invisibleAnnotations, nField.invisibleAnnotations);
		annotationChange = annotationChange + compareAnnotations(oField.visibleAnnotations, nField.visibleAnnotations);
		if (annotationChange.length() != 0) {
			fd.setAnnotationsChanged(annotationChange);
		}
		if (fd.hasAnyChanges()) {
			// it needs recording
			td.addChangedField(fd);
		}
	}
1279480
function onSkeletonUpdate(skeleton) {
    for (var c in connections) {
        connections[c].sendUTF(JSON.stringify(skeleton));
    }
}
370478
function(class_data, source_object, is_root) {

		var name,
			skeleton = {},
			value,
			type,
			skeleton_value;

		for (name in source_object) {

			if (is_root && (this._reserved_members.indexOf(name) != -1 || (name in class_data.shared))) {

				continue;

			}

			value = source_object[name];
			type = Firestorm.getType(value);

			switch (type) {
				case 'null':
				case 'boolean':
				case 'number':
					skeleton_value = {type: this.MEMBER_TYPES.PRIMITIVE, value: value};
					break;
				case 'string':
					skeleton_value = {type: this.MEMBER_TYPES.STRING, value: value};
					break;
				case 'function':
					skeleton_value = {type: this.MEMBER_TYPES.FUNCTION, index: class_data.references.length};
					class_data.references.push(value);
					break;
				case 'regexp':
					skeleton_value = {type: this.MEMBER_TYPES.REGEXP, index: class_data.references.length};
					class_data.references.push(value);
					break;
				case 'object':
					skeleton_value = {
						type: this.MEMBER_TYPES.OBJECT,
						skeleton: this._disassemble(class_data, value, false)
					};
					break;
				case 'array':
					if (value.length == 0) {
						skeleton_value = {type: this.MEMBER_TYPES.EMPTY_ARRAY};
					} else if (this.inline_simple_arrays && this.isInlineArray(value)) {
						skeleton_value = {type: this.MEMBER_TYPES.INLINE_ARRAY, value: value};
					} else {
						skeleton_value = {type: this.MEMBER_TYPES.SLICE_ARRAY, index: class_data.references.length};
						class_data.references.push(value);
					}
					break;
				case 'undefined':
					Lava.t("[ClassManager] Forced code style restriction: please, replace undefined member values with null. Member name: " + name);
					break;
				default:
					Lava.t("[ClassManager] Unsupported property type in source object: " + type);
					break;
			}

			skeleton[name] = skeleton_value;

		}

		return skeleton;

	}
99893
public static Document parseBodyFragment(String bodyHtml, String baseUri) {
        return Parser.parseBodyFragment(bodyHtml, baseUri);
    }
1163918
function parse( str , limit ) {
	var v , runtime = {
		i: 0
		, depth: 0	//# noDepthTracking!
		, depthLimit: limit || depthLimit   //# noDepthLimit!
		, ancestors: []	//# noRefNotation!
	} ;

	if ( typeof str !== 'string' ) {
		if ( str && typeof str === 'object' ) { str = str.toString() ; }
		else { throw new TypeError( "Argument #0 should be a string or an object with a .toString() method" ) ; }
	}

	parseIdle( str , runtime ) ;

	if ( runtime.i >= str.length ) { throw new SyntaxError( "Empty" ) ; }

	v = parseValue( str , runtime ) ;
	parseIdle( str , runtime ) ;

	if ( runtime.i < str.length ) { throw new SyntaxError( "Unexpected " + str[ runtime.i ] ) ; }

	return v ;
}