///|
priv struct EntityParser((String) -> @repository.AnyEntity raise StepParseError)
///|
let parsers : Map[String, EntityParser] = Map([])
///|
fn init {
parsers.set("CARTESIAN_POINT", fn(args) raise StepParseError {
@repository.any_entity_cartesian_point(parse_cartesian_point(args))
})
parsers.set("DIRECTION", fn(args) raise StepParseError {
@repository.any_entity_direction(parse_direction(args))
})
parsers.set("AXIS1_PLACEMENT", fn(args) raise StepParseError {
@repository.any_entity_axis1_placement(parse_axis1_placement(args))
})
parsers.set("AXIS2_PLACEMENT_2D", fn(args) raise StepParseError {
@repository.any_entity_axis2_placement_2d(parse_axis2_placement_2d(args))
})
parsers.set("AXIS2_PLACEMENT_3D", fn(args) raise StepParseError {
@repository.any_entity_axis2_placement_3d(parse_axis2_placement_3d(args))
})
parsers.set("PLANE", fn(args) raise StepParseError {
@repository.any_entity_plane(parse_plane(args))
})
parsers.set("CIRCLE", fn(args) raise StepParseError {
@repository.any_entity_circle(parse_circle(args))
})
parsers.set("ELLIPSE", fn(args) raise StepParseError {
@repository.any_entity_ellipse(parse_ellipse(args))
})
parsers.set("PARABOLA", fn(args) raise StepParseError {
@repository.any_entity_parabola(parse_parabola(args))
})
parsers.set("HYPERBOLA", fn(args) raise StepParseError {
@repository.any_entity_hyperbola(parse_hyperbola(args))
})
parsers.set("CYL_SURF", fn(args) raise StepParseError {
@repository.any_entity_cylindrical_surface(parse_cylindrical_surface(args))
})
parsers.set("CYLINDRICAL_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_cylindrical_surface(parse_cylindrical_surface(args))
})
parsers.set("CONICAL_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_conical_surface(parse_conical_surface(args))
})
parsers.set("SPHERICAL_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_spherical_surface(parse_spherical_surface(args))
})
parsers.set("TOROIDAL_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_toroidal_surface(parse_toroidal_surface(args))
})
parsers.set("B_SPLINE_CURVE", fn(args) raise StepParseError {
@repository.any_entity_b_spline_curve(parse_b_spline_curve(args))
})
parsers.set("B_SPLINE_CURVE_WITH_KNOTS", fn(args) raise StepParseError {
@repository.any_entity_b_spline_curve_with_knots(
parse_b_spline_curve_with_knots(args),
)
})
parsers.set("COMPOSITE_CURVE", fn(args) raise StepParseError {
@repository.any_entity_composite_curve(parse_composite_curve(args))
})
parsers.set("COMPOSITE_CURVE_SEGMENT", fn(args) raise StepParseError {
@repository.any_entity_composite_curve_segment(
parse_composite_curve_segment(args),
)
})
parsers.set("B_SPLINE_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_b_spline_surface(parse_b_spline_surface(args))
})
parsers.set("B_SPLINE_SURFACE_WITH_KNOTS", fn(args) raise StepParseError {
@repository.any_entity_b_spline_surface_with_knots(
parse_b_spline_surface_with_knots(args),
)
})
parsers.set("RATIONAL_B_SPLINE_CURVE", fn(args) raise StepParseError {
@repository.any_entity_rational_b_spline_curve(
parse_rational_b_spline_curve(args),
)
})
parsers.set("RATIONAL_B_SPLINE_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_rational_b_spline_surface(
parse_rational_b_spline_surface(args),
)
})
parsers.set("TRIMMED_CURVE", fn(args) raise StepParseError {
@repository.any_entity_trimmed_curve(parse_trimmed_curve(args))
})
parsers.set("OFFSET_CURVE_3D", fn(args) raise StepParseError {
@repository.any_entity_offset_curve_3d(parse_offset_curve_3d(args))
})
parsers.set("OFFSET_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_offset_surface(parse_offset_surface(args))
})
parsers.set("SURFACE_OF_LINEAR_EXTRUSION", fn(args) raise StepParseError {
@repository.any_entity_surface_of_linear_extrusion(
parse_surface_of_linear_extrusion(args),
)
})
parsers.set("SURFACE_OF_REVOLUTION", fn(args) raise StepParseError {
@repository.any_entity_surface_of_revolution(
parse_surface_of_revolution(args),
)
})
parsers.set("SWEPT_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_swept_surface(parse_swept_surface(args))
})
parsers.set("RECTANGULAR_TRIMMED_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_rectangular_trimmed_surface(
parse_rectangular_trimmed_surface(args),
)
})
parsers.set("POLYLINE", fn(args) raise StepParseError {
@repository.any_entity_polyline(parse_polyline(args))
})
parsers.set("VECTOR", fn(args) raise StepParseError {
@repository.any_entity_vector(parse_vector(args))
})
parsers.set("LINE", fn(args) raise StepParseError {
@repository.any_entity_line(parse_line(args))
})
parsers.set("REPRESENTATION_RELATIONSHIP", fn(args) raise StepParseError {
@repository.any_entity_representation_relationship(
parse_representation_relationship(args),
)
})
parsers.set("REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION", fn(
args,
) raise StepParseError {
@repository.any_entity_representation_relationship_with_transformation(
parse_representation_relationship_with_transformation(args),
)
})
parsers.set("SHAPE_REPRESENTATION_RELATIONSHIP", fn(
args,
) raise StepParseError {
@repository.any_entity_shape_representation_relationship(
parse_shape_representation_relationship(args),
)
})
parsers.set("ADVANCED_BREP_SHAPE_REPRESENTATION", fn(
args,
) raise StepParseError {
@repository.any_entity_advanced_brep_shape_representation(
parse_advanced_brep_shape_representation(args),
)
})
parsers.set("SHAPE_DEFINITION_REPRESENTATION", fn(args) raise StepParseError {
@repository.any_entity_shape_definition_representation(
parse_shape_definition_representation(args),
)
})
parsers.set("SHAPE_REPRESENTATION", fn(args) raise StepParseError {
@repository.any_entity_shape_representation(
parse_shape_representation(args),
)
})
parsers.set("REPRESENTATION", fn(args) raise StepParseError {
@repository.any_entity_representation(parse_representation(args))
})
parsers.set("DESCRIPTIVE_REPRESENTATION_ITEM", fn(args) raise StepParseError {
@repository.any_entity_descriptive_representation_item(
parse_descriptive_representation_item(args),
)
})
parsers.set("MEASURE_REPRESENTATION_ITEM", fn(args) raise StepParseError {
@repository.any_entity_measure_representation_item(
parse_measure_representation_item(args),
)
})
parsers.set("CONTEXT_DEPENDENT_SHAPE_REPRESENTATION", fn(
args,
) raise StepParseError {
@repository.any_entity_context_dependent_shape_representation(
parse_context_dependent_shape_representation(args),
)
})
parsers.set("ITEM_DEFINED_TRANSFORMATION", fn(args) raise StepParseError {
@repository.any_entity_item_defined_transformation(
parse_item_defined_transformation(args),
)
})
parsers.set("NEXT_ASSEMBLY_USAGE_OCCURRENCE", fn(args) raise StepParseError {
@repository.any_entity_next_assembly_usage_occurrence(
parse_next_assembly_usage_occurrence(args),
)
})
parsers.set("PRODUCT_DEFINITION_SHAPE", fn(args) raise StepParseError {
@repository.any_entity_product_definition_shape(
parse_product_definition_shape(args),
)
})
parsers.set("PRODUCT_DEFINITION", fn(args) raise StepParseError {
@repository.any_entity_product_definition(parse_product_definition(args))
})
parsers.set("PRODUCT_DEFINITION_CONTEXT", fn(args) raise StepParseError {
@repository.any_entity_product_definition_context(
parse_product_definition_context(args),
)
})
parsers.set("PRODUCT_DEFINITION_FORMATION", fn(args) raise StepParseError {
@repository.any_entity_product_definition_formation(
parse_product_definition_formation(args),
)
})
parsers.set("PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE", fn(
args,
) raise StepParseError {
@repository.any_entity_product_definition_formation_with_specified_source(
parse_product_definition_formation_with_specified_source(args),
)
})
parsers.set("PROPERTY_DEFINITION", fn(args) raise StepParseError {
@repository.any_entity_property_definition(parse_property_definition(args))
})
parsers.set("PROPERTY_DEFINITION_REPRESENTATION", fn(
args,
) raise StepParseError {
@repository.any_entity_property_definition_representation(
parse_property_definition_representation(args),
)
})
parsers.set("PRODUCT_RELATED_PRODUCT_CATEGORY", fn(
args,
) raise StepParseError {
@repository.any_entity_product_related_product_category(
parse_product_related_product_category(args),
)
})
parsers.set("PRODUCT", fn(args) raise StepParseError {
@repository.any_entity_product(parse_product(args))
})
parsers.set("PRODUCT_CONTEXT", fn(args) raise StepParseError {
@repository.any_entity_product_context(parse_product_context(args))
})
parsers.set("APPLICATION_PROTOCOL_DEFINITION", fn(args) raise StepParseError {
@repository.any_entity_application_protocol_definition(
parse_application_protocol_definition(args),
)
})
parsers.set("APPLICATION_CONTEXT", fn(args) raise StepParseError {
@repository.any_entity_application_context(parse_application_context(args))
})
parsers.set("APPROVAL", fn(args) raise StepParseError {
@repository.any_entity_approval(parse_approval(args))
})
parsers.set("APPROVAL_STATUS", fn(args) raise StepParseError {
@repository.any_entity_approval_status(parse_approval_status(args))
})
parsers.set("APPROVAL_ROLE", fn(args) raise StepParseError {
@repository.any_entity_approval_role(parse_approval_role(args))
})
parsers.set("APPROVAL_PERSON_ORGANIZATION", fn(args) raise StepParseError {
@repository.any_entity_approval_person_organization(
parse_approval_person_organization(args),
)
})
parsers.set("PERSON", fn(args) raise StepParseError {
@repository.any_entity_person(parse_person(args))
})
parsers.set("ORGANIZATION", fn(args) raise StepParseError {
@repository.any_entity_organization(parse_organization(args))
})
parsers.set("PERSON_AND_ORGANIZATION", fn(args) raise StepParseError {
@repository.any_entity_person_and_organization(
parse_person_and_organization(args),
)
})
parsers.set("DATE_AND_TIME", fn(args) raise StepParseError {
@repository.any_entity_date_and_time(parse_date_and_time(args))
})
parsers.set("LOCAL_TIME", fn(args) raise StepParseError {
@repository.any_entity_local_time(parse_local_time(args))
})
parsers.set("CALENDAR_DATE", fn(args) raise StepParseError {
@repository.any_entity_calendar_date(parse_calendar_date(args))
})
parsers.set("COORDINATED_UNIVERSAL_TIME_OFFSET", fn(
args,
) raise StepParseError {
@repository.any_entity_coordinated_universal_time_offset(
parse_coordinated_universal_time_offset(args),
)
})
parsers.set("SECURITY_CLASSIFICATION", fn(args) raise StepParseError {
@repository.any_entity_security_classification(
parse_security_classification(args),
)
})
parsers.set("SECURITY_CLASSIFICATION_LEVEL", fn(args) raise StepParseError {
@repository.any_entity_security_classification_level(
parse_security_classification_level(args),
)
})
parsers.set("CERTIFICATION", fn(args) raise StepParseError {
@repository.any_entity_certification(parse_certification(args))
})
parsers.set("CERTIFICATION_TYPE", fn(args) raise StepParseError {
@repository.any_entity_certification_type(parse_certification_type(args))
})
parsers.set("DOCUMENT", fn(args) raise StepParseError {
@repository.any_entity_document(parse_document(args))
})
parsers.set("DOCUMENT_REFERENCE", fn(args) raise StepParseError {
@repository.any_entity_document_reference(parse_document_reference(args))
})
parsers.set("DOCUMENT_TYPE", fn(args) raise StepParseError {
@repository.any_entity_document_type(parse_document_type(args))
})
parsers.set("KINEMATIC_LINK", fn(args) raise StepParseError {
@repository.any_entity_kinematic_link(parse_kinematic_link(args))
})
parsers.set("KINEMATIC_JOINT", fn(args) raise StepParseError {
@repository.any_entity_kinematic_joint(parse_kinematic_joint(args))
})
parsers.set("KINEMATIC_PAIR", fn(args) raise StepParseError {
@repository.any_entity_kinematic_pair(parse_kinematic_pair(args))
})
parsers.set("GEOMETRIC_TOLERANCE", fn(args) raise StepParseError {
@repository.any_entity_geometric_tolerance(parse_geometric_tolerance(args))
})
parsers.set("DATUM", fn(args) raise StepParseError {
@repository.any_entity_datum(parse_datum(args))
})
parsers.set("DATUM_FEATURE", fn(args) raise StepParseError {
@repository.any_entity_datum_feature(parse_datum_feature(args))
})
parsers.set("DIMENSIONAL_SIZE", fn(args) raise StepParseError {
@repository.any_entity_dimensional_size(parse_dimensional_size(args))
})
parsers.set("MANIFOLD_SOLID_BREP", fn(args) raise StepParseError {
@repository.any_entity_manifold_solid_brep(parse_manifold_solid_brep(args))
})
parsers.set("CLOSED_SHELL", fn(args) raise StepParseError {
@repository.any_entity_closed_shell(parse_closed_shell(args))
})
parsers.set("OPEN_SHELL", fn(args) raise StepParseError {
@repository.any_entity_open_shell(parse_open_shell(args))
})
parsers.set("CONNECTED_FACE_SET", fn(args) raise StepParseError {
@repository.any_entity_connected_face_set(parse_connected_face_set(args))
})
parsers.set("SHELL_BASED_SURFACE_MODEL", fn(args) raise StepParseError {
@repository.any_entity_shell_based_surface_model(
parse_shell_based_surface_model(args),
)
})
parsers.set("ADVANCED_FACE", fn(args) raise StepParseError {
@repository.any_entity_advanced_face(parse_advanced_face(args))
})
parsers.set("FACE_SURFACE", fn(args) raise StepParseError {
@repository.any_entity_face_surface(parse_face_surface(args))
})
parsers.set("SUBFACE", fn(args) raise StepParseError {
@repository.any_entity_subface(parse_subface(args))
})
parsers.set("SHAPE_ASPECT", fn(args) raise StepParseError {
@repository.any_entity_shape_aspect(parse_shape_aspect(args))
})
parsers.set("FACE_OUTER_BOUND", fn(args) raise StepParseError {
@repository.any_entity_face_outer_bound(parse_face_outer_bound(args))
})
parsers.set("FACE_BOUND", fn(args) raise StepParseError {
@repository.any_entity_face_bound(parse_face_bound(args))
})
parsers.set("EDGE_LOOP", fn(args) raise StepParseError {
@repository.any_entity_edge_loop(parse_edge_loop(args))
})
parsers.set("ORIENTED_EDGE", fn(args) raise StepParseError {
@repository.any_entity_oriented_edge(parse_oriented_edge(args))
})
parsers.set("EDGE_CURVE", fn(args) raise StepParseError {
@repository.any_entity_edge_curve(parse_edge_curve(args))
})
parsers.set("VERTEX_POINT", fn(args) raise StepParseError {
@repository.any_entity_vertex_point(parse_vertex_point(args))
})
parsers.set("COLOUR_RGB", fn(args) raise StepParseError {
@repository.any_entity_color_rgb(parse_color_rgb(args))
})
parsers.set("DRAUGHTING_PRE_DEFINED_COLOUR", fn(args) raise StepParseError {
@repository.any_entity_draughting_pre_defined_color(
parse_draughting_pre_defined_color(args),
)
})
parsers.set("FILL_AREA_STYLE_COLOUR", fn(args) raise StepParseError {
@repository.any_entity_fill_area_style_color(
parse_fill_area_style_color(args),
)
})
parsers.set("FILL_AREA_STYLE", fn(args) raise StepParseError {
@repository.any_entity_fill_area_style(parse_fill_area_style(args))
})
parsers.set("SURFACE_STYLE_FILL_AREA", fn(args) raise StepParseError {
@repository.any_entity_surface_style_fill_area(
parse_surface_style_fill_area(args),
)
})
parsers.set("SURFACE_SIDE_STYLE", fn(args) raise StepParseError {
@repository.any_entity_surface_side_style(parse_surface_side_style(args))
})
parsers.set("SURFACE_STYLE_USAGE", fn(args) raise StepParseError {
@repository.any_entity_surface_style_usage(parse_surface_style_usage(args))
})
parsers.set("PRESENTATION_LAYER_ASSIGNMENT", fn(args) raise StepParseError {
@repository.any_entity_presentation_layer_assignment(
parse_presentation_layer_assignment(args),
)
})
parsers.set("MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION", fn(
args,
) raise StepParseError {
@repository.any_entity_mechanical_design_geometric_presentation_representation(
parse_mechanical_design_geometric_presentation_representation(args),
)
})
parsers.set("PRESENTATION_STYLE_ASSIGNMENT", fn(args) raise StepParseError {
@repository.any_entity_presentation_style_assignment(
parse_presentation_style_assignment(args),
)
})
parsers.set("STYLED_ITEM", fn(args) raise StepParseError {
@repository.any_entity_styled_item(parse_styled_item(args))
})
parsers.set("OVER_RIDING_STYLED_ITEM", fn(args) raise StepParseError {
@repository.any_entity_over_riding_styled_item(
parse_over_riding_styled_item(args),
)
})
parsers.set("HIDDEN_ELEMENT_OVER_RIDING_STYLED_ITEM", fn(
args,
) raise StepParseError {
@repository.any_entity_hidden_element_over_riding_styled_item(
parse_hidden_element_over_riding_styled_item(args),
)
})
parsers.set("ANNOTATION_OCCURRENCE", fn(args) raise StepParseError {
@repository.any_entity_annotation_occurrence(
parse_annotation_occurrence(args),
)
})
parsers.set("TEXT_LITERAL", fn(args) raise StepParseError {
@repository.any_entity_text_literal(parse_text_literal(args))
})
parsers.set("DIMENSIONAL_EXPONENTS", fn(args) raise StepParseError {
@repository.any_entity_dimensional_exponents(
parse_dimensional_exponents(args),
)
})
parsers.set("UNCERTAINTY_MEASURE_WITH_UNIT", fn(args) raise StepParseError {
@repository.any_entity_uncertainty_measure_with_unit(
parse_uncertainty_measure_with_unit(args),
)
})
parsers.set("PLANE_ANGLE_MEASURE_WITH_UNIT", fn(args) raise StepParseError {
@repository.any_entity_plane_angle_measure_with_unit(
parse_plane_angle_measure_with_unit(args),
)
})
parsers.set("MEASURE_WITH_UNIT", fn(args) raise StepParseError {
@repository.any_entity_measure_with_unit(parse_measure_with_unit(args))
})
parsers.set("DERIVED_UNIT_ELEMENT", fn(args) raise StepParseError {
@repository.any_entity_derived_unit_element(
parse_derived_unit_element(args),
)
})
parsers.set("DERIVED_UNIT", fn(args) raise StepParseError {
@repository.any_entity_derived_unit(parse_derived_unit(args))
})
parsers.set("BOOLEAN_RESULT", fn(args) raise StepParseError {
@repository.any_entity_boolean_result(parse_boolean_result(args))
})
parsers.set("CSG_SOLID", fn(args) raise StepParseError {
@repository.any_entity_csg_solid(parse_csg_solid(args))
})
parsers.set("BLOCK", fn(args) raise StepParseError {
@repository.any_entity_block(parse_block(args))
})
parsers.set("SPHERE", fn(args) raise StepParseError {
@repository.any_entity_sphere(parse_sphere(args))
})
parsers.set("RIGHT_CIRCULAR_CYLINDER", fn(args) raise StepParseError {
@repository.any_entity_right_circular_cylinder(
parse_right_circular_cylinder(args),
)
})
parsers.set("RIGHT_CIRCULAR_CONE", fn(args) raise StepParseError {
@repository.any_entity_right_circular_cone(parse_right_circular_cone(args))
})
parsers.set("TORUS", fn(args) raise StepParseError {
@repository.any_entity_torus(parse_torus(args))
})
parsers.set("RECTANGULAR_PYRAMID", fn(args) raise StepParseError {
@repository.any_entity_rectangular_pyramid(parse_rectangular_pyramid(args))
})
parsers.set("RIGHT_ANGULAR_WEDGE", fn(args) raise StepParseError {
@repository.any_entity_right_angular_wedge(parse_right_angular_wedge(args))
})
parsers.set("HALF_SPACE_SOLID", fn(args) raise StepParseError {
@repository.any_entity_half_space_solid(parse_half_space_solid(args))
})
}
///|
fn parse_double(s : String) -> Double raise StepParseError {
let t = s.trim().to_owned()
// Use core string->double parsing for correct rounding and stable roundtrips.
@string.parse_double(t) catch {
_ => fail_parse()
}
}
///|
fn strip_quotes(s : String) -> String {
let t = s.trim().to_owned()
if t.length() >= 2 &&
cu_at(t, 0) == Char::to_int('\'') &&
cu_at(t, t.length() - 1) == Char::to_int('\'') {
return substr(t, 1, t.length() - 1)
}
t
}
///|
// Parse a STEP string literal of the form '...'
// and unescape doubled quotes '' -> '.
//
// Returns None if the input isn't a valid STEP string literal.
fn parse_step_string_literal_unescaped(s : String) -> String? {
let t = s.trim().to_owned()
if t.length() >= 2 &&
cu_at(t, 0) == Char::to_int('\'') &&
cu_at(t, t.length() - 1) == Char::to_int('\'') {
let inner = substr(t, 1, t.length() - 1)
let builder = StringBuilder()
let n = inner.length()
let mut i = 0
while i < n {
let ci = cu_at(inner, i)
if ci == Char::to_int('\'') {
// STEP escaping: doubled quotes '' represent a literal '.
if i + 1 < n && cu_at(inner, i + 1) == Char::to_int('\'') {
builder.write_char('\'')
i = i + 2
continue
} else {
// Unescaped quote in the middle is invalid.
return None
}
}
builder.write_char(ci.unsafe_to_char())
i = i + 1
}
return Some(builder.to_string())
}
None
}
///|
// Best-effort STEP string parsing: returns decoded string when possible,
// otherwise falls back to the previous strip_quotes behavior.
fn parse_step_string_or_strip(s : String) -> String {
match parse_step_string_literal_unescaped(s) {
Some(v) => v
None => strip_quotes(s)
}
}
///|
fn parse_ref_int(s : String) -> @step.EntityId raise StepParseError {
let t = s.trim().to_owned()
if t.length() < 2 || cu_at(t, 0) != Char::to_int('#') {
fail_parse()
}
let v = parse_int_dec(substr(t, 1, t.length()))
@step.EntityId::{ value: v, }
}
///|
fn parse_cartesian_point(
args : String,
) -> @geometry.CartesianPoint raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let coord_parts = split_args(parts[1])
let coords = coord_parts.map(parse_double)
@geometry.CartesianPoint::new(name, coords)
}
///|
fn parse_direction(args : String) -> @geometry.Direction raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let ratio_parts = split_args(parts[1])
let ratios = ratio_parts.map(parse_double)
@geometry.Direction::new(name, ratios)
}
///|
fn parse_axis2_placement_3d(
args : String,
) -> @geometry.Axis2Placement3D raise StepParseError {
let parts = split_args(args)
if parts.length() < 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let location_id = parse_ref_int(parts[1])
let axis_id = parse_ref_int(parts[2])
let ref_dir_id = parse_ref_int(parts[3])
@geometry.Axis2Placement3D::new(
name,
@step.Ref::{ id: location_id, },
@step.Ref::{ id: axis_id, },
@step.Ref::{ id: ref_dir_id, },
)
}
///|
fn parse_axis1_placement(
args : String,
) -> @geometry.Axis1Placement raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let location_id = parse_ref_int(parts[1])
let axis_id_str = parts[2].trim().to_owned()
let axis = if axis_id_str == "$" {
None
} else {
Some(@step.Ref::{ id: parse_ref_int(axis_id_str), })
}
@geometry.Axis1Placement::new(name, @step.Ref::{ id: location_id, }, axis~)
}
///|
fn parse_axis2_placement_2d(
args : String,
) -> @geometry.Axis2Placement2D raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let location_id = parse_ref_int(parts[1])
let dir_id_str = parts[2].trim().to_owned()
let ref_direction = if dir_id_str == "$" {
None
} else {
Some(@step.Ref::{ id: parse_ref_int(dir_id_str), })
}
@geometry.Axis2Placement2D::new(
name,
@step.Ref::{ id: location_id, },
ref_direction~,
)
}
///|
fn parse_vector(args : String) -> @geometry.Vector raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let dir_id = parse_ref_int(parts[1])
let magnitude = parse_double(parts[2])
@geometry.Vector::new(name, @step.Ref::{ id: dir_id, }, magnitude)
}
///|
fn parse_line(args : String) -> @geometry.Line raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pnt_id = parse_ref_int(parts[1])
let vec_id = parse_ref_int(parts[2])
@geometry.Line::new(name, @step.Ref::{ id: pnt_id, }, @step.Ref::{
id: vec_id,
})
}
///|
fn parse_circle(args : String) -> @geometry.Circle raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let radius_literal = parts[2].trim().to_owned()
@geometry.Circle::new(name, @step.Ref::{ id: pos_id, }, radius_literal)
}
///|
fn parse_ellipse(args : String) -> @geometry.Ellipse raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let semi_axis_1_literal = parts[2].trim().to_owned()
let semi_axis_2_literal = parts[3].trim().to_owned()
@geometry.Ellipse::new(
name,
@step.Ref::{ id: pos_id, },
semi_axis_1_literal,
semi_axis_2_literal,
)
}
///|
fn parse_parabola(args : String) -> @geometry.Parabola raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let focal_dist = parse_double(parts[2])
@geometry.Parabola::new(name, @step.Ref::{ id: pos_id, }, focal_dist)
}
///|
fn parse_hyperbola(args : String) -> @geometry.Hyperbola raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let semi = parse_double(parts[2])
let semi_imag = parse_double(parts[3])
@geometry.Hyperbola::new(name, @step.Ref::{ id: pos_id, }, semi, semi_imag)
}
///|
fn parse_cylindrical_surface(
args : String,
) -> @geometry.CylindricalSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let radius_literal = parts[2].trim().to_owned()
@geometry.CylindricalSurface::new(
name,
@step.Ref::{ id: pos_id, },
radius_literal,
)
}
///|
fn parse_conical_surface(
args : String,
) -> @geometry.ConicalSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let radius_literal = parts[2].trim().to_owned()
let semi_angle_literal = parts[3].trim().to_owned()
@geometry.ConicalSurface::new(
name,
@step.Ref::{ id: pos_id, },
radius_literal,
semi_angle_literal,
)
}
///|
fn parse_spherical_surface(
args : String,
) -> @geometry.SphericalSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let radius_literal = parts[2].trim().to_owned()
@geometry.SphericalSurface::new(
name,
@step.Ref::{ id: pos_id, },
radius_literal,
)
}
///|
fn parse_toroidal_surface(
args : String,
) -> @geometry.ToroidalSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let major_radius_literal = parts[2].trim().to_owned()
let minor_radius_literal = parts[3].trim().to_owned()
@geometry.ToroidalSurface::new(
name,
@step.Ref::{ id: pos_id, },
major_radius_literal,
minor_radius_literal,
)
}
///|
fn parse_b_spline_curve(
args : String,
) -> @geometry.BSplineCurve raise StepParseError {
let parts = split_args(args)
if parts.length() != 6 {
fail_parse()
}
let name = strip_quotes(parts[0])
let degree = parse_int_dec(parts[1])
let cp_ids = parse_ref_ids(parts[2])
let control_points = cp_ids.map(fn(id) { @step.Ref::{ id, } })
let curve_form = parts[3].trim().to_owned()
let closed_str = parts[4].trim().to_owned()
let self_i_str = parts[5].trim().to_owned()
let closed_curve = if closed_str == ".T." {
true
} else if closed_str == ".F." {
false
} else {
fail_parse()
}
let self_intersect = if self_i_str == ".T." {
true
} else if self_i_str == ".F." {
false
} else {
fail_parse()
}
@geometry.BSplineCurve::new(
name, degree, control_points, curve_form, closed_curve, self_intersect,
)
}
///|
fn parse_int_list(arg : String) -> Array[Int32] {
split_args(arg).map(parse_int_dec)
}
///|
fn parse_literal_list(arg : String) -> Array[String] {
split_args(arg).map(parse_step_string_or_strip)
}
///|
fn parse_b_spline_curve_with_knots(
args : String,
) -> @geometry.BSplineCurveWithKnots raise StepParseError {
let parts = split_args(args)
if parts.length() != 9 {
fail_parse()
}
let name = strip_quotes(parts[0])
let degree = parse_int_dec(parts[1])
let cp_ids = parse_ref_ids(parts[2])
let control_points = cp_ids.map(fn(id) { @step.Ref::{ id, } })
let curve_form = parts[3].trim().to_owned()
let closed_str = parts[4].trim().to_owned()
let self_i_str = parts[5].trim().to_owned()
let closed_curve = if closed_str == ".T." {
true
} else if closed_str == ".F." {
false
} else {
fail_parse()
}
let self_intersect = if self_i_str == ".T." {
true
} else if self_i_str == ".F." {
false
} else {
fail_parse()
}
let knot_multiplicities = parse_int_list(parts[6])
let knots = parse_literal_list(parts[7])
let knot_spec = parts[8].trim().to_owned()
@geometry.BSplineCurveWithKnots::new(
name, degree, control_points, curve_form, closed_curve, self_intersect, knot_multiplicities,
knots, knot_spec,
)
}
///|
fn parse_composite_curve(
args : String,
) -> @geometry.CompositeCurve raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let seg_ids = parse_ref_ids(parts[1])
let segments = seg_ids.map(fn(id) { @step.Ref::{ id, } })
let si_str = parts[2].trim().to_owned()
let self_intersect = if si_str == ".T." {
true
} else if si_str == ".F." {
false
} else {
fail_parse()
}
@geometry.CompositeCurve::new(name, segments, self_intersect)
}
///|
fn parse_composite_curve_segment(
args : String,
) -> @geometry.CompositeCurveSegment raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let trans_str = parts[0].trim().to_owned()
let transition = match @geometry.TransitionCode::from_string(trans_str) {
Some(t) => t
None => fail_parse()
}
let ss_str = parts[1].trim().to_owned()
let same_sense = if ss_str == ".T." {
true
} else if ss_str == ".F." {
false
} else {
fail_parse()
}
let curve_id = parse_ref_int(parts[2])
@geometry.CompositeCurveSegment::new(transition, same_sense, @step.Ref::{
id: curve_id,
})
}
///|
fn parse_rational_b_spline_curve(
args : String,
) -> @geometry.RationalBSplineCurve raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let weights = parse_literal_list(parts[0])
@geometry.RationalBSplineCurve::new(weights)
}
///|
fn parse_b_spline_surface(
args : String,
) -> @geometry.BSplineSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 7 {
fail_parse()
}
let u_degree = parse_int_dec(parts[0])
let v_degree = parse_int_dec(parts[1])
let row_parts = split_args(parts[2])
let control_points_list = row_parts.map(row_part => {
parse_ref_ids(row_part).map(fn(id) { @step.Ref::{ id, } })
})
let surface_form = parts[3].trim().to_owned()
let u_closed_str = parts[4].trim().to_owned()
let v_closed_str = parts[5].trim().to_owned()
let self_i_str = parts[6].trim().to_owned()
let u_closed = if u_closed_str == ".T." {
true
} else if u_closed_str == ".F." {
false
} else {
fail_parse()
}
let v_closed = if v_closed_str == ".T." {
true
} else if v_closed_str == ".F." {
false
} else {
fail_parse()
}
let self_intersect = if self_i_str == ".T." {
true
} else if self_i_str == ".F." {
false
} else {
fail_parse()
}
@geometry.BSplineSurface::new(
u_degree, v_degree, control_points_list, surface_form, u_closed, v_closed, self_intersect,
)
}
///|
fn parse_b_spline_surface_with_knots(
args : String,
) -> @geometry.BSplineSurfaceWithKnots raise StepParseError {
let parts = split_args(args)
if parts.length() != 5 {
fail_parse()
}
let u_mults = parse_int_list(parts[0])
let v_mults = parse_int_list(parts[1])
let u_knots = parse_literal_list(parts[2])
let v_knots = parse_literal_list(parts[3])
let knot_spec = parts[4].trim().to_owned()
@geometry.BSplineSurfaceWithKnots::new(
u_mults, v_mults, u_knots, v_knots, knot_spec,
)
}
///|
fn parse_rational_b_spline_surface(
args : String,
) -> @geometry.RationalBSplineSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
// parts[0] looks like: ((1.,...),(...),(...))
let row_parts = split_args(parts[0])
let weights = row_parts.map(parse_literal_list)
@geometry.RationalBSplineSurface::new(weights)
}
///|
fn parse_trimmed_curve(
args : String,
) -> @geometry.TrimmedCurve raise StepParseError {
let parts = split_args(args)
if parts.length() != 6 {
fail_parse()
}
let name = strip_quotes(parts[0])
let basis_id = parse_ref_int(parts[1])
let trim_1 = parts[2].trim().to_owned()
let trim_2 = parts[3].trim().to_owned()
let sense_str = parts[4].trim().to_owned()
let sense = if sense_str == ".T." {
true
} else if sense_str == ".F." {
false
} else {
fail_parse()
}
let master_rep = parts[5].trim().to_owned()
@geometry.TrimmedCurve::new(
name,
@step.Ref::{ id: basis_id, },
trim_1,
trim_2,
sense,
master_rep,
)
}
///|
fn parse_offset_curve_3d(
args : String,
) -> @geometry.OffsetCurve3D raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let basis_id = parse_ref_int(parts[1])
let distance = parse_double(parts[2])
let dir_id = parse_ref_int(parts[3])
@geometry.OffsetCurve3D::new(name, @step.Ref::{ id: basis_id, }, distance, @step.Ref::{
id: dir_id,
})
}
///|
fn parse_offset_surface(
args : String,
) -> @geometry.OffsetSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let basis_id = parse_ref_int(parts[1])
let distance = parse_double(parts[2])
let si_str = parts[3].trim().to_owned()
let self_intersect = if si_str == ".T." {
true
} else if si_str == ".F." {
false
} else {
fail_parse()
}
@geometry.OffsetSurface::new(
name,
@step.Ref::{ id: basis_id, },
distance,
self_intersect,
)
}
///|
fn parse_surface_of_linear_extrusion(
args : String,
) -> @geometry.SurfaceOfLinearExtrusion raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let curve_id = parse_ref_int(parts[1])
let axis_id = parse_ref_int(parts[2])
@geometry.SurfaceOfLinearExtrusion::new(name, @step.Ref::{ id: curve_id, }, @step.Ref::{
id: axis_id,
})
}
///|
fn parse_surface_of_revolution(
args : String,
) -> @geometry.SurfaceOfRevolution raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let curve_id = parse_ref_int(parts[1])
let axis_id = parse_ref_int(parts[2])
@geometry.SurfaceOfRevolution::new(name, @step.Ref::{ id: curve_id, }, @step.Ref::{
id: axis_id,
})
}
///|
fn parse_swept_surface(
args : String,
) -> @geometry.SweptSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let curve_id = parse_ref_int(parts[1])
@geometry.SweptSurface::new(name, @step.Ref::{ id: curve_id, })
}
///|
fn parse_rectangular_trimmed_surface(
args : String,
) -> @geometry.RectangularTrimmedSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 8 {
fail_parse()
}
let name = strip_quotes(parts[0])
let basis_id = parse_ref_int(parts[1])
let u1 = parts[2].trim().to_owned()
let u2 = parts[3].trim().to_owned()
let v1 = parts[4].trim().to_owned()
let v2 = parts[5].trim().to_owned()
let usense_str = parts[6].trim().to_owned()
let usense = if usense_str == ".T." {
true
} else if usense_str == ".F." {
false
} else {
fail_parse()
}
let vsense_str = parts[7].trim().to_owned()
let vsense = if vsense_str == ".T." {
true
} else if vsense_str == ".F." {
false
} else {
fail_parse()
}
@geometry.RectangularTrimmedSurface::new(
name,
@step.Ref::{ id: basis_id, },
u1,
u2,
v1,
v2,
usense,
vsense,
)
}
///|
fn parse_polyline(args : String) -> @geometry.Polyline raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let ids = parse_ref_ids(parts[1])
let points = ids.map(fn(id) { @step.Ref::{ id, } })
@geometry.Polyline::new(name, points)
}
///|
fn parse_boolean_result(
args : String,
) -> @geometry.BooleanResult raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let op_str = parts[1].trim().to_owned()
let operator = match @geometry.BooleanOperator::from_string(op_str) {
Some(op) => op
None => fail_parse()
}
let op1_id = parse_ref_int(parts[2])
let op2_id = parse_ref_int(parts[3])
@geometry.BooleanResult::new(name, operator, @step.Ref::{ id: op1_id, }, @step.Ref::{
id: op2_id,
})
}
///|
fn parse_csg_solid(args : String) -> @geometry.CsgSolid raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let root_id = parse_ref_int(parts[1])
@geometry.CsgSolid::new(name, @step.Ref::{ id: root_id, })
}
///|
fn parse_block(args : String) -> @geometry.Block raise StepParseError {
let parts = split_args(args)
if parts.length() != 5 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let x = parse_double(parts[2])
let y = parse_double(parts[3])
let z = parse_double(parts[4])
@geometry.Block::new(name, @step.Ref::{ id: pos_id, }, x, y, z)
}
///|
fn parse_sphere(args : String) -> @geometry.Sphere raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let radius = parse_double(parts[2])
@geometry.Sphere::new(name, @step.Ref::{ id: pos_id, }, radius)
}
///|
fn parse_right_circular_cylinder(
args : String,
) -> @geometry.RightCircularCylinder raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let height = parse_double(parts[2])
let radius = parse_double(parts[3])
@geometry.RightCircularCylinder::new(
name,
@step.Ref::{ id: pos_id, },
height,
radius,
)
}
///|
fn parse_right_circular_cone(
args : String,
) -> @geometry.RightCircularCone raise StepParseError {
let parts = split_args(args)
if parts.length() != 5 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let height = parse_double(parts[2])
let radius = parse_double(parts[3])
let semi_angle = parse_double(parts[4])
@geometry.RightCircularCone::new(
name,
@step.Ref::{ id: pos_id, },
height,
radius,
semi_angle,
)
}
///|
fn parse_torus(args : String) -> @geometry.Torus raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let major = parse_double(parts[2])
let minor = parse_double(parts[3])
@geometry.Torus::new(name, @step.Ref::{ id: pos_id, }, major, minor)
}
///|
fn parse_rectangular_pyramid(
args : String,
) -> @geometry.RectangularPyramid raise StepParseError {
let parts = split_args(args)
if parts.length() != 5 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let x = parse_double(parts[2])
let y = parse_double(parts[3])
let height = parse_double(parts[4])
@geometry.RectangularPyramid::new(
name,
@step.Ref::{ id: pos_id, },
x,
y,
height,
)
}
///|
fn parse_right_angular_wedge(
args : String,
) -> @geometry.RightAngularWedge raise StepParseError {
let parts = split_args(args)
if parts.length() != 6 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
let x = parse_double(parts[2])
let y = parse_double(parts[3])
let z = parse_double(parts[4])
let ltx = parse_double(parts[5])
@geometry.RightAngularWedge::new(
name,
@step.Ref::{ id: pos_id, },
x,
y,
z,
ltx,
)
}
///|
fn parse_half_space_solid(
args : String,
) -> @geometry.HalfSpaceSolid raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let surf_id = parse_ref_int(parts[1])
let flag_str = parts[2].trim().to_owned()
let flag = if flag_str == ".T." {
true
} else if flag_str == ".F." {
false
} else {
fail_parse()
}
@geometry.HalfSpaceSolid::new(name, @step.Ref::{ id: surf_id, }, flag)
}
///|
fn parse_plane(args : String) -> @geometry.Plane raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let pos_id = parse_ref_int(parts[1])
@geometry.Plane::new(name, @step.Ref::{ id: pos_id, })
}
///|
fn parse_representation_relationship(
args : String,
) -> @product.RepresentationRelationship raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let rep_1_id = parse_ref_int(parts[2])
let rep_2_id = parse_ref_int(parts[3])
@product.RepresentationRelationship::new(
name,
description,
@step.Ref::{ id: rep_1_id, },
@step.Ref::{ id: rep_2_id, },
)
}
///|
fn parse_representation_relationship_with_transformation(
args : String,
) -> @product.RepresentationRelationshipWithTransformation raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let t_id = parse_ref_int(parts[0])
@product.RepresentationRelationshipWithTransformation::new(@step.Ref::{
id: t_id,
})
}
///|
fn parse_shape_representation_relationship(
args : String,
) -> @product.ShapeRepresentationRelationship raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let rep_1_id = parse_ref_int(parts[2])
let rep_2_id = parse_ref_int(parts[3])
@product.ShapeRepresentationRelationship::new(
name,
description,
@step.Ref::{ id: rep_1_id, },
@step.Ref::{ id: rep_2_id, },
)
}
///|
fn parse_advanced_brep_shape_representation(
args : String,
) -> @product.AdvancedBrepShapeRepresentation raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let item_ids = parse_ref_ids(parts[1])
let items = item_ids.map(fn(id) { @step.Ref::{ id, } })
let ctx_id = parse_ref_int(parts[2])
@product.AdvancedBrepShapeRepresentation::new(name, items, @step.Ref::{
id: ctx_id,
})
}
///|
fn parse_shape_definition_representation(
args : String,
) -> @product.ShapeDefinitionRepresentation raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let def_id = parse_ref_int(parts[0])
let rep_id = parse_ref_int(parts[1])
@product.ShapeDefinitionRepresentation::new(@step.Ref::{ id: def_id, }, @step.Ref::{
id: rep_id,
})
}
///|
fn parse_shape_representation(
args : String,
) -> @product.ShapeRepresentation raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let item_ids = parse_ref_ids(parts[1])
let items = item_ids.map(fn(id) { @step.Ref::{ id, } })
let ctx_id = parse_ref_int(parts[2])
@product.ShapeRepresentation::new(name, items, @step.Ref::{ id: ctx_id, })
}
///|
fn parse_representation(
args : String,
) -> @product.Representation raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let item_ids = parse_ref_ids(parts[1])
let items = item_ids.map(fn(id) { @step.Ref::{ id, } })
let ctx_id = parse_ref_int(parts[2])
@product.Representation::new(name, items, @step.Ref::{ id: ctx_id, })
}
///|
fn parse_descriptive_representation_item(
args : String,
) -> @product.DescriptiveRepresentationItem raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse_msg(
"DESCRIPTIVE_REPRESENTATION_ITEM expected 2 args, got " +
Int32::to_string(parts.length()) +
": " +
args,
)
}
// Use proper STEP string unescaping so roundtrip is stable for values
// containing doubled quotes (''), semicolons, or comment-like sequences.
let name = parse_step_string_or_strip(parts[0])
let description = parse_step_string_or_strip(parts[1])
@product.DescriptiveRepresentationItem::new(name, description)
}
///|
fn parse_measure_representation_item(
args : String,
) -> @product.MeasureRepresentationItem raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let value_component_str = parts[1].trim().to_owned()
let value_component = if String::has_prefix(
value_component_str, "POSITIVE_RATIO_MEASURE",
) {
// Looks like: POSITIVE_RATIO_MEASURE(7850.)
// Keep the inner literal as raw string to preserve formatting.
let args_part = substr(
value_component_str,
"POSITIVE_RATIO_MEASURE".length(),
value_component_str.length(),
)
let inner = strip_outer_parens(args_part).trim().to_owned()
@product.MeasureValueComponent::PositiveRatioMeasure(
@units.PositiveRatioMeasure::new(inner),
)
} else {
@product.MeasureValueComponent::Raw(value_component_str)
}
let unit_id = parse_ref_int(parts[2])
@product.MeasureRepresentationItem::new(name, value_component, @step.Ref::{
id: unit_id,
})
}
///|
fn parse_context_dependent_shape_representation(
args : String,
) -> @product.ContextDependentShapeRepresentation raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let rr_id = parse_ref_int(parts[0])
let rpr_id = parse_ref_int(parts[1])
@product.ContextDependentShapeRepresentation::new(@step.Ref::{ id: rr_id, }, @step.Ref::{
id: rpr_id,
})
}
///|
fn parse_item_defined_transformation(
args : String,
) -> @product.ItemDefinedTransformation raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let i1_id = parse_ref_int(parts[2])
let i2_id = parse_ref_int(parts[3])
@product.ItemDefinedTransformation::new(
name,
description,
@step.Ref::{ id: i1_id, },
@step.Ref::{ id: i2_id, },
)
}
///|
fn parse_next_assembly_usage_occurrence(
args : String,
) -> @product.NextAssemblyUsageOccurrence raise StepParseError {
let parts = split_args(args)
if parts.length() != 6 {
fail_parse()
}
let id = strip_quotes(parts[0])
let name = strip_quotes(parts[1])
let description = strip_quotes(parts[2])
let relating_id = parse_ref_int(parts[3])
let related_id = parse_ref_int(parts[4])
let designator = strip_quotes(parts[5])
@product.NextAssemblyUsageOccurrence::new(
id,
name,
description,
@step.Ref::{ id: relating_id, },
@step.Ref::{ id: related_id, },
designator,
)
}
///|
fn parse_product_definition_shape(
args : String,
) -> @product.ProductDefinitionShape raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let def_id = parse_ref_int(parts[2])
@product.ProductDefinitionShape::new(name, description, @step.Ref::{
id: def_id,
})
}
///|
fn parse_product_definition(
args : String,
) -> @product.ProductDefinition raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let id = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let formation_id = parse_ref_int(parts[2])
let ctx_id = parse_ref_int(parts[3])
@product.ProductDefinition::new(
id,
description,
@step.Ref::{ id: formation_id, },
@step.Ref::{ id: ctx_id, },
)
}
///|
fn parse_product_definition_context(
args : String,
) -> @product.ProductDefinitionContext raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let app_id = parse_ref_int(parts[1])
let life_cycle_stage = strip_quotes(parts[2])
@product.ProductDefinitionContext::new(
name,
@step.Ref::{ id: app_id, },
life_cycle_stage,
)
}
///|
fn parse_product_definition_formation(
args : String,
) -> @product.ProductDefinitionFormation raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let id = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let product_id = parse_ref_int(parts[2])
@product.ProductDefinitionFormation::new(id, description, @step.Ref::{
id: product_id,
})
}
///|
fn parse_property_definition(
args : String,
) -> @product.PropertyDefinition raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let def_id = parse_ref_int(parts[2])
@product.PropertyDefinition::new(name, description, @step.Ref::{ id: def_id, })
}
///|
fn parse_property_definition_representation(
args : String,
) -> @product.PropertyDefinitionRepresentation raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let def_id = parse_ref_int(parts[0])
let rep_id = parse_ref_int(parts[1])
@product.PropertyDefinitionRepresentation::new(@step.Ref::{ id: def_id, }, @step.Ref::{
id: rep_id,
})
}
///|
fn parse_product_definition_formation_with_specified_source(
args : String,
) -> @product.ProductDefinitionFormationWithSpecifiedSource raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let id = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let product_id = parse_ref_int(parts[2])
let make_or_buy = parts[3].trim().to_owned()
// Enumeration like .NOT_KNOWN.
if make_or_buy != ".NOT_KNOWN." &&
make_or_buy != ".MAKE." &&
make_or_buy != ".BUY." {
fail_parse()
}
@product.ProductDefinitionFormationWithSpecifiedSource::new(
id,
description,
@step.Ref::{ id: product_id, },
make_or_buy,
)
}
///|
fn parse_product_related_product_category(
args : String,
) -> @product.ProductRelatedProductCategory raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let product_ids = parse_ref_ids(parts[2])
let products = product_ids.map(fn(id) { @step.Ref::{ id, } })
@product.ProductRelatedProductCategory::new(name, description, products)
}
///|
fn parse_product(args : String) -> @product.Product raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let id = strip_quotes(parts[1])
let description = strip_quotes(parts[2])
let ref_ids = parse_ref_ids(parts[3])
let refs = ref_ids.map(fn(id) { @step.Ref::{ id, } })
@product.Product::new(name, id, description, refs)
}
///|
fn parse_product_context(
args : String,
) -> @product.ProductContext raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let frame_id = parse_ref_int(parts[1])
let discipline_type = strip_quotes(parts[2])
@product.ProductContext::new(
name,
@step.Ref::{ id: frame_id, },
discipline_type,
)
}
///|
fn parse_application_protocol_definition(
args : String,
) -> @product.ApplicationProtocolDefinition raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let status = strip_quotes(parts[0])
let schema_name = strip_quotes(parts[1])
let year = parse_int_dec(parts[2])
let application_id = parse_ref_int(parts[3])
@product.ApplicationProtocolDefinition::new(status, schema_name, year, @step.Ref::{
id: application_id,
})
}
///|
fn parse_application_context(
args : String,
) -> @product.ApplicationContext raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let application = strip_quotes(parts[0])
@product.ApplicationContext::new(application)
}
///|
fn parse_approval(args : String) -> @product.Approval raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let status_id = parse_ref_int(parts[0])
let level = strip_quotes(parts[1])
@product.Approval::new(@step.Ref::{ id: status_id, }, level)
}
///|
fn parse_approval_status(
args : String,
) -> @product.ApprovalStatus raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let name = strip_quotes(parts[0])
@product.ApprovalStatus::new(name)
}
///|
fn parse_approval_role(
args : String,
) -> @product.ApprovalRole raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let role = strip_quotes(parts[0])
@product.ApprovalRole::new(role)
}
///|
fn parse_approval_person_organization(
args : String,
) -> @product.ApprovalPersonOrganization raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let po_id = parse_ref_int(parts[0])
let approval_id = parse_ref_int(parts[1])
let role_id = parse_ref_int(parts[2])
@product.ApprovalPersonOrganization::new(
@step.Ref::{ id: po_id, },
@step.Ref::{ id: approval_id, },
@step.Ref::{ id: role_id, },
)
}
///|
fn parse_person(args : String) -> @product.Person raise StepParseError {
let parts = split_args(args)
if parts.length() != 6 {
fail_parse()
}
let id = strip_quotes(parts[0])
let last = strip_quotes(parts[1])
let first = strip_quotes(parts[2])
let middles = parse_literal_list(parts[3])
let prefixes = parse_literal_list(parts[4])
let suffixes = parse_literal_list(parts[5])
@product.Person::new(id, last, first, middles, prefixes, suffixes)
}
///|
fn parse_organization(
args : String,
) -> @product.Organization raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let id = strip_quotes(parts[0])
let name = strip_quotes(parts[1])
let desc = strip_quotes(parts[2])
@product.Organization::new(id, name, desc)
}
///|
fn parse_person_and_organization(
args : String,
) -> @product.PersonAndOrganization raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let person_id = parse_ref_int(parts[0])
let org_id = parse_ref_int(parts[1])
@product.PersonAndOrganization::new(@step.Ref::{ id: person_id, }, @step.Ref::{
id: org_id,
})
}
///|
fn parse_date_and_time(
args : String,
) -> @product.DateAndTime raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let date_id = parse_ref_int(parts[0])
let time_id = parse_ref_int(parts[1])
@product.DateAndTime::new(@step.Ref::{ id: date_id, }, @step.Ref::{
id: time_id,
})
}
///|
fn parse_local_time(args : String) -> @product.LocalTime raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let hour = parse_int_dec(parts[0])
let minute = parse_int_dec(parts[1])
let second = parse_double(parts[2])
let zone_id = parse_ref_int(parts[3])
@product.LocalTime::new(hour, minute, second, @step.Ref::{ id: zone_id, })
}
///|
fn parse_calendar_date(
args : String,
) -> @product.CalendarDate raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let year = parse_int_dec(parts[0])
let day = parse_int_dec(parts[1])
let month = parse_int_dec(parts[2])
@product.CalendarDate::new(year, day, month)
}
///|
fn parse_coordinated_universal_time_offset(
args : String,
) -> @product.CoordinatedUniversalTimeOffset raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let hour = parse_int_dec(parts[0])
let minute = parse_int_dec(parts[1])
let sense = parts[2].trim().to_owned()
@product.CoordinatedUniversalTimeOffset::new(hour, minute, sense)
}
///|
fn parse_security_classification(
args : String,
) -> @product.SecurityClassification raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let purpose = strip_quotes(parts[1])
let level_id = parse_ref_int(parts[2])
@product.SecurityClassification::new(name, purpose, @step.Ref::{
id: level_id,
})
}
///|
fn parse_security_classification_level(
args : String,
) -> @product.SecurityClassificationLevel raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let name = strip_quotes(parts[0])
@product.SecurityClassificationLevel::new(name)
}
///|
fn parse_certification(
args : String,
) -> @product.Certification raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let purpose = strip_quotes(parts[1])
let kind_id = parse_ref_int(parts[2])
@product.Certification::new(name, purpose, @step.Ref::{ id: kind_id, })
}
///|
fn parse_certification_type(
args : String,
) -> @product.CertificationType raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let desc = strip_quotes(parts[0])
@product.CertificationType::new(desc)
}
///|
fn parse_document(args : String) -> @product.Document raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let id = strip_quotes(parts[0])
let name = strip_quotes(parts[1])
let description = strip_quotes(parts[2])
let kind_id = parse_ref_int(parts[3])
@product.Document::new(id, name, description, @step.Ref::{ id: kind_id, })
}
///|
fn parse_document_reference(
args : String,
) -> @product.DocumentReference raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let id = strip_quotes(parts[0])
let name = strip_quotes(parts[1])
let description = strip_quotes(parts[2])
let doc_id = parse_ref_int(parts[3])
@product.DocumentReference::new(id, name, description, @step.Ref::{
id: doc_id,
})
}
///|
fn parse_document_type(
args : String,
) -> @product.DocumentType raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let desc = strip_quotes(parts[0])
@product.DocumentType::new(desc)
}
///|
fn parse_kinematic_link(
args : String,
) -> @kinematics.KinematicLink raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let name = strip_quotes(parts[0])
@kinematics.KinematicLink::new(name)
}
///|
fn parse_kinematic_joint(
args : String,
) -> @kinematics.KinematicJoint raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let l1_id = parse_ref_int(parts[1])
let l2_id = parse_ref_int(parts[2])
@kinematics.KinematicJoint::new(name, @step.Ref::{ id: l1_id, }, @step.Ref::{
id: l2_id,
})
}
///|
fn parse_kinematic_pair(
args : String,
) -> @kinematics.KinematicPair raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let desc = strip_quotes(parts[1])
let joint_id = parse_ref_int(parts[2])
@kinematics.KinematicPair::new(name, desc, @step.Ref::{ id: joint_id, })
}
///|
fn parse_geometric_tolerance(
args : String,
) -> @tolerancing.GeometricTolerance raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let desc = strip_quotes(parts[1])
let mag_id = parse_ref_int(parts[2])
let shape_id = parse_ref_int(parts[3])
@tolerancing.GeometricTolerance::new(name, desc, @step.Ref::{ id: mag_id, }, @step.Ref::{
id: shape_id,
})
}
///|
fn parse_datum(args : String) -> @tolerancing.Datum raise StepParseError {
let parts = split_args(args)
if parts.length() != 5 {
fail_parse()
}
let name = strip_quotes(parts[0])
let desc = strip_quotes(parts[1])
let shape_id = parse_ref_int(parts[2])
let definitional = parts[3].trim().to_owned()
let identification = strip_quotes(parts[4])
@tolerancing.Datum::new(
name,
desc,
@step.Ref::{ id: shape_id, },
definitional,
identification,
)
}
///|
fn parse_datum_feature(
args : String,
) -> @tolerancing.DatumFeature raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let desc = strip_quotes(parts[1])
let shape_id = parse_ref_int(parts[2])
let definitional = parts[3].trim().to_owned()
@tolerancing.DatumFeature::new(
name,
desc,
@step.Ref::{ id: shape_id, },
definitional,
)
}
///|
fn parse_dimensional_size(
args : String,
) -> @tolerancing.DimensionalSize raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let shape_id = parse_ref_int(parts[0])
let name = strip_quotes(parts[1])
@tolerancing.DimensionalSize::new(@step.Ref::{ id: shape_id, }, name)
}
///|
fn parse_manifold_solid_brep(
args : String,
) -> @topology.ManifoldSolidBrep raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let outer_id = parse_ref_int(parts[1])
@topology.ManifoldSolidBrep::new(name, @step.Ref::{ id: outer_id, })
}
///|
fn parse_closed_shell(
args : String,
) -> @topology.ClosedShell raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let face_ids = parse_ref_ids(parts[1])
let faces = face_ids.map(fn(id) { @step.Ref::{ id, } })
@topology.ClosedShell::new(name, faces)
}
///|
fn parse_open_shell(args : String) -> @topology.OpenShell raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let face_ids = parse_ref_ids(parts[1])
let faces = face_ids.map(fn(id) { @step.Ref::{ id, } })
@topology.OpenShell::new(name, faces)
}
///|
fn parse_connected_face_set(
args : String,
) -> @topology.ConnectedFaceSet raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let face_ids = parse_ref_ids(parts[1])
let faces = face_ids.map(fn(id) { @step.Ref::{ id, } })
@topology.ConnectedFaceSet::new(name, faces)
}
///|
fn parse_face_surface(
args : String,
) -> @topology.FaceSurface raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let bound_ids = parse_ref_ids(parts[1])
let bounds = bound_ids.map(fn(id) { @step.Ref::{ id, } })
let geom_id = parse_ref_int(parts[2])
let ss_str = parts[3].trim().to_owned()
let same_sense = if ss_str == ".T." {
true
} else if ss_str == ".F." {
false
} else {
fail_parse()
}
@topology.FaceSurface::new(
name,
bounds,
@step.Ref::{ id: geom_id, },
same_sense,
)
}
///|
fn parse_subface(args : String) -> @topology.Subface raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let bound_ids = parse_ref_ids(parts[1])
let bounds = bound_ids.map(fn(id) { @step.Ref::{ id, } })
let parent_id = parse_ref_int(parts[2])
@topology.Subface::new(name, bounds, @step.Ref::{ id: parent_id, })
}
///|
fn parse_shape_aspect(
args : String,
) -> @product.ShapeAspect raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let desc = strip_quotes(parts[1])
let shape_id = parse_ref_int(parts[2])
let definitional = parts[3].trim().to_owned()
@product.ShapeAspect::new(
name,
desc,
@step.Ref::{ id: shape_id, },
definitional,
)
}
///|
fn parse_shell_based_surface_model(
args : String,
) -> @topology.ShellBasedSurfaceModel raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let bound_ids = parse_ref_ids(parts[1])
let bounds = bound_ids.map(fn(id) { @step.Ref::{ id, } })
@topology.ShellBasedSurfaceModel::new(name, bounds)
}
///|
fn parse_advanced_face(
args : String,
) -> @topology.AdvancedFace raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let bound_ids = parse_ref_ids(parts[1])
let bounds = bound_ids.map(fn(id) { @step.Ref::{ id, } })
let surface_id = parse_ref_int(parts[2])
let ss = parts[3].trim().to_owned()
let same_sense = if ss == ".T." {
true
} else if ss == ".F." {
false
} else {
fail_parse()
}
@topology.AdvancedFace::new(
name,
bounds,
@step.Ref::{ id: surface_id, },
same_sense,
)
}
///|
fn parse_face_outer_bound(
args : String,
) -> @topology.FaceOuterBound raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let bound_id = parse_ref_int(parts[1])
let ori_str = parts[2].trim().to_owned()
let orientation = if ori_str == ".T." {
true
} else if ori_str == ".F." {
false
} else {
fail_parse()
}
@topology.FaceOuterBound::new(name, @step.Ref::{ id: bound_id, }, orientation)
}
///|
fn parse_face_bound(args : String) -> @topology.FaceBound raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let bound_id = parse_ref_int(parts[1])
let ori_str = parts[2].trim().to_owned()
let orientation = if ori_str == ".T." {
true
} else if ori_str == ".F." {
false
} else {
fail_parse()
}
@topology.FaceBound::new(name, @step.Ref::{ id: bound_id, }, orientation)
}
///|
fn parse_edge_loop(args : String) -> @topology.EdgeLoop raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let edge_ids = parse_ref_ids(parts[1])
let edges = edge_ids.map(fn(id) { @step.Ref::{ id, } })
@topology.EdgeLoop::new(name, edges)
}
///|
fn parse_oriented_edge(
args : String,
) -> @topology.OrientedEdge raise StepParseError {
let parts = split_args(args)
if parts.length() != 5 {
fail_parse()
}
let name = strip_quotes(parts[0])
let edge_start = parts[1].trim().to_owned()
let edge_end = parts[2].trim().to_owned()
let edge_element_id = parse_ref_int(parts[3])
let ori_str = parts[4].trim().to_owned()
let orientation = if ori_str == ".T." {
true
} else if ori_str == ".F." {
false
} else {
fail_parse()
}
@topology.OrientedEdge::new(
name,
edge_start,
edge_end,
@step.Ref::{ id: edge_element_id, },
orientation,
)
}
///|
fn parse_edge_curve(args : String) -> @topology.EdgeCurve raise StepParseError {
let parts = split_args(args)
if parts.length() != 5 {
fail_parse()
}
let name = strip_quotes(parts[0])
let start_id = parse_ref_int(parts[1])
let end_id = parse_ref_int(parts[2])
let geom_id = parse_ref_int(parts[3])
let ss_str = parts[4].trim().to_owned()
let same_sense = if ss_str == ".T." {
true
} else if ss_str == ".F." {
false
} else {
fail_parse()
}
@topology.EdgeCurve::new(
name,
@step.Ref::{ id: start_id, },
@step.Ref::{ id: end_id, },
@step.Ref::{ id: geom_id, },
same_sense,
)
}
///|
fn parse_vertex_point(
args : String,
) -> @topology.VertexPoint raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let geom_id = parse_ref_int(parts[1])
@topology.VertexPoint::new(name, @step.Ref::{ id: geom_id, })
}
///|
fn parse_color_rgb(
args : String,
) -> @presentation.ColorRgb raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let r = parse_double(parts[1])
let g = parse_double(parts[2])
let b = parse_double(parts[3])
@presentation.ColorRgb::new(name, r, g, b)
}
///|
fn parse_draughting_pre_defined_color(
args : String,
) -> @presentation.DraughtingPreDefinedColour raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let name = strip_quotes(parts[0])
@presentation.DraughtingPreDefinedColour::new(name)
}
///|
fn parse_ref_ids(arg : String) -> Array[@step.EntityId] raise StepParseError {
split_args(arg).map(parse_ref_int)
}
///|
fn parse_surface_side(s : String) -> String raise StepParseError {
let t = s.trim().to_owned()
if t == ".BOTH." {
t
} else if t == ".POSITIVE." {
t
} else if t == ".NEGATIVE." {
t
} else {
fail_parse()
}
}
///|
fn parse_fill_area_style_color(
args : String,
) -> @presentation.FillAreaStyleColor raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let color_id = parse_ref_int(parts[1])
@presentation.FillAreaStyleColor::new(name, @step.Ref::{ id: color_id, })
}
///|
fn parse_fill_area_style(
args : String,
) -> @presentation.FillAreaStyle raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let style_ids = parse_ref_ids(parts[1])
let styles = style_ids.map(fn(id) { @step.Ref::{ id, } })
@presentation.FillAreaStyle::new(name, styles)
}
///|
fn parse_surface_style_fill_area(
args : String,
) -> @presentation.SurfaceStyleFillArea raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let fa_id = parse_ref_int(parts[0])
@presentation.SurfaceStyleFillArea::new(@step.Ref::{ id: fa_id, })
}
///|
fn parse_surface_side_style(
args : String,
) -> @presentation.SurfaceSideStyle raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let name = strip_quotes(parts[0])
let style_ids = parse_ref_ids(parts[1])
let styles = style_ids.map(fn(id) { @step.Ref::{ id, } })
@presentation.SurfaceSideStyle::new(name, styles)
}
///|
fn parse_surface_style_usage(
args : String,
) -> @presentation.SurfaceStyleUsage raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let side = parse_surface_side(parts[0])
let style_id = parse_ref_int(parts[1])
@presentation.SurfaceStyleUsage::new(side, @step.Ref::{ id: style_id, })
}
///|
fn parse_presentation_style_assignment(
args : String,
) -> @presentation.PresentationStyleAssignment raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let style_ids = parse_ref_ids(parts[0])
let styles = style_ids.map(fn(id) { @step.Ref::{ id, } })
@presentation.PresentationStyleAssignment::new(styles)
}
///|
fn parse_presentation_layer_assignment(
args : String,
) -> @presentation.PresentationLayerAssignment raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let description = strip_quotes(parts[1])
let item_ids = parse_ref_ids(parts[2])
let items = item_ids.map(fn(id) { @step.Ref::{ id, } })
@presentation.PresentationLayerAssignment::new(name, description, items)
}
///|
fn parse_text_literal(
args : String,
) -> @presentation.TextLiteral raise StepParseError {
let parts = split_args(args)
if parts.length() != 6 {
fail_parse()
}
let name = strip_quotes(parts[0])
let literal = strip_quotes(parts[1])
let placement_id = parse_ref_int(parts[2])
let alignment = strip_quotes(parts[3])
let path_str = parts[4].trim().to_owned()
let path = match @presentation.TextPath::from_string(path_str) {
Some(p) => p
None => fail_parse()
}
let font_id = parse_ref_int(parts[5])
@presentation.TextLiteral::new(
name,
literal,
@step.Ref::{ id: placement_id, },
alignment,
path,
@step.Ref::{ id: font_id, },
)
}
///|
fn parse_mechanical_design_geometric_presentation_representation(
args : String,
) -> @presentation.MechanicalDesignGeometricPresentationRepresentation raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let item_ids = parse_ref_ids(parts[1])
let items = item_ids.map(fn(id) { @step.Ref::{ id, } })
let ctx_id = parse_ref_int(parts[2])
@presentation.MechanicalDesignGeometricPresentationRepresentation::new(
name,
items,
@step.Ref::{ id: ctx_id, },
)
}
///|
fn parse_styled_item(
args : String,
) -> @presentation.StyledItem raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let style_ids = parse_ref_ids(parts[1])
let styles = style_ids.map(fn(id) { @step.Ref::{ id, } })
let item_id = parse_ref_int(parts[2])
@presentation.StyledItem::new(name, styles, @step.Ref::{ id: item_id, })
}
///|
fn parse_over_riding_styled_item(
args : String,
) -> @presentation.OverRidingStyledItem raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let style_ids = parse_ref_ids(parts[1])
let styles = style_ids.map(fn(id) { @step.Ref::{ id, } })
let item_id = parse_ref_int(parts[2])
let over_id = parse_ref_int(parts[3])
@presentation.OverRidingStyledItem::new(
name,
styles,
@step.Ref::{ id: item_id, },
@step.Ref::{ id: over_id, },
)
}
///|
fn parse_hidden_element_over_riding_styled_item(
args : String,
) -> @presentation.HiddenElementOverRidingStyledItem raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let name = strip_quotes(parts[0])
let style_ids = parse_ref_ids(parts[1])
let styles = style_ids.map(fn(id) { @step.Ref::{ id, } })
let item_id = parse_ref_int(parts[2])
let over_id = parse_ref_int(parts[3])
@presentation.HiddenElementOverRidingStyledItem::new(
name,
styles,
@step.Ref::{ id: item_id, },
@step.Ref::{ id: over_id, },
)
}
///|
fn parse_annotation_occurrence(
args : String,
) -> @presentation.AnnotationOccurrence raise StepParseError {
let parts = split_args(args)
if parts.length() != 3 {
fail_parse()
}
let name = strip_quotes(parts[0])
let style_ids = parse_ref_ids(parts[1])
let styles = style_ids.map(fn(id) { @step.Ref::{ id, } })
let item_id = parse_ref_int(parts[2])
@presentation.AnnotationOccurrence::new(name, styles, @step.Ref::{
id: item_id,
})
}
///|
fn parse_dimensional_exponents(
args : String,
) -> @units.DimensionalExponents raise StepParseError {
let parts = split_args(args)
if parts.length() != 7 {
fail_parse()
}
@units.DimensionalExponents::new(
parse_double(parts[0]),
parse_double(parts[1]),
parse_double(parts[2]),
parse_double(parts[3]),
parse_double(parts[4]),
parse_double(parts[5]),
parse_double(parts[6]),
)
}
///|
fn parse_length_measure_literal(arg : String) -> String raise StepParseError {
let t = arg.trim().to_owned()
if !t.has_prefix("LENGTH_MEASURE(") {
fail_parse()
}
if t.length() < 16 || !t.has_suffix(")") {
fail_parse()
}
// Inner literal (preserve scientific notation like `2.E-005`).
// "LENGTH_MEASURE(" is 15 chars; the opening paren is index 14.
substr(t, 15, t.length() - 1).trim().to_owned()
}
///|
fn parse_uncertainty_measure_with_unit(
args : String,
) -> @units.UncertaintyMeasureWithUnit raise StepParseError {
let parts = split_args(args)
if parts.length() != 4 {
fail_parse()
}
let length_measure_literal = parse_length_measure_literal(parts[0])
let unit_id = parse_ref_int(parts[1])
let name = strip_quotes(parts[2])
let description = strip_quotes(parts[3])
@units.UncertaintyMeasureWithUnit::new(
length_measure_literal,
@step.Ref::{ id: unit_id, },
name,
description,
)
}
///|
fn parse_plane_angle_measure_literal(
arg : String,
) -> String raise StepParseError {
let t = arg.trim().to_owned()
if !t.has_prefix("PLANE_ANGLE_MEASURE(") {
fail_parse()
}
if t.length() < 22 || !t.has_suffix(")") {
fail_parse()
}
// Inner literal (preserve formatting).
// "PLANE_ANGLE_MEASURE(" is 20 chars.
substr(t, 20, t.length() - 1).trim().to_owned()
}
///|
fn parse_plane_angle_measure_with_unit(
args : String,
) -> @units.PlaneAngleMeasureWithUnit raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let plane_angle_measure_literal = parse_plane_angle_measure_literal(parts[0])
let unit_id = parse_ref_int(parts[1])
@units.PlaneAngleMeasureWithUnit::new(plane_angle_measure_literal, @step.Ref::{
id: unit_id,
})
}
///|
fn parse_derived_unit_element(
args : String,
) -> @units.DerivedUnitElement raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let unit_id = parse_ref_int(parts[0])
let exponent = parse_double(parts[1])
@units.DerivedUnitElement::new(@step.Ref::{ id: unit_id, }, exponent)
}
///|
fn parse_derived_unit(args : String) -> @units.DerivedUnit raise StepParseError {
let parts = split_args(args)
if parts.length() != 1 {
fail_parse()
}
let elem_ids = parse_ref_ids(parts[0])
let elems = elem_ids.map(fn(id) { @step.Ref::{ id, } })
@units.DerivedUnit::new(elems)
}
///|
fn parse_measure_with_unit(
args : String,
) -> @units.MeasureWithUnit raise StepParseError {
let parts = split_args(args)
if parts.length() != 2 {
fail_parse()
}
let val = parts[0].trim().to_owned()
let unit_id = parse_ref_int(parts[1])
@units.MeasureWithUnit::new(val, @step.Ref::{ id: unit_id, })
}
///|
fn is_complex_ws(ci : Int32) -> Bool {
ci == Char::to_int(' ') ||
ci == Char::to_int('\t') ||
ci == Char::to_int('\n') ||
ci == Char::to_int('\r')
}
///|
fn is_complex_name_char(ci : Int32) -> Bool {
(ci >= Char::to_int('A') && ci <= Char::to_int('Z')) ||
(ci >= Char::to_int('0') && ci <= Char::to_int('9')) ||
ci == Char::to_int('_')
}
///|
fn split_complex_parts(body : String) -> Array[String] {
// A complex instance is a whitespace-separated sequence of
// `NAME()` parts. Parts may be separated by spaces, newlines, or both;
// some writers put several parts on one line, so splitting on newlines alone
// is not sufficient. Scan each `NAME` and its balanced parenthesised args.
let out : Array[String] = []
let n = body.length()
let quote = Char::to_int('\'')
let lparen = Char::to_int('(')
let rparen = Char::to_int(')')
let mut i = 0
while i < n {
while i < n && is_complex_ws(cu_at(body, i)) {
i = i + 1
}
if i >= n {
break
}
let start = i
while i < n && is_complex_name_char(cu_at(body, i)) {
i = i + 1
}
while i < n && is_complex_ws(cu_at(body, i)) {
i = i + 1
}
if i >= n || cu_at(body, i) != lparen {
let rest = substr(body, start, n).trim().to_owned()
if rest.length() > 0 {
out.push(rest)
}
break
}
let mut depth = 0
let mut in_str = false
let mut skip_quote = false
let mut j = i
let mut closed = -1
while j < n {
let cj = cu_at(body, j)
if cj == quote {
if skip_quote {
skip_quote = false
} else if in_str {
if j + 1 < n && cu_at(body, j + 1) == quote {
skip_quote = true
} else {
in_str = false
}
} else {
in_str = true
}
} else if !in_str {
if cj == lparen {
depth = depth + 1
} else if cj == rparen {
depth = depth - 1
if depth == 0 {
closed = j
break
}
}
}
j = j + 1
}
if closed < 0 {
let rest = substr(body, start, n).trim().to_owned()
if rest.length() > 0 {
out.push(rest)
}
break
}
let part = substr(body, start, closed + 1).trim().to_owned()
if part.length() > 0 {
out.push(part)
}
i = closed + 1
}
out
}
///|
fn strip_outer_parens(arg : String) -> String raise StepParseError {
let t = arg.trim().to_owned()
if t.length() < 2 ||
cu_at(t, 0) != Char::to_int('(') ||
cu_at(t, t.length() - 1) != Char::to_int(')') {
fail_parse()
}
substr(t, 1, t.length() - 1)
}
///|
fn expect_empty_parens(arg : String) -> Unit raise StepParseError {
let inner = strip_outer_parens(arg).trim().to_owned()
if inner.length() != 0 {
fail_parse()
}
}
///|
fn parse_complex_instance(
args : String,
) -> @context.ComplexInstance raise StepParseError {
// args is the raw parenthesized complex instance body, like:
// (\nNAME(...)\nNAME(...)\n)
let t = args.trim().to_owned()
if t.length() < 2 ||
cu_at(t, 0) != Char::to_int('(') ||
cu_at(t, t.length() - 1) != Char::to_int(')') {
fail_parse()
}
let inner = substr(t, 1, t.length() - 1)
let part_strs = split_complex_parts(inner)
let parts = part_strs.map(fn(s) raise StepParseError {
let lp_idx = match String::find(s, "(") {
Some(j) => j
None => fail_parse()
}
let name = substr(s, 0, lp_idx).trim().to_owned()
let a = substr(s, lp_idx, s.length()).trim().to_owned()
if name == "GEOMETRIC_REPRESENTATION_CONTEXT" {
let inner_args = strip_outer_parens(a)
let dim = parse_int_dec(inner_args.trim().to_owned())
@context.ComplexPart::GeomRepCtx(
@context.GeometricRepresentationContext::new(dim),
)
} else if name == "REPRESENTATION_CONTEXT" {
let inner_args = strip_outer_parens(a)
let args_parts = split_args(inner_args)
if args_parts.length() != 2 {
fail_parse()
}
let ident = strip_quotes(args_parts[0])
let ctx_type = strip_quotes(args_parts[1])
@context.ComplexPart::RepCtx(
@context.RepresentationContext::new(ident, ctx_type),
)
} else if name == "NAMED_UNIT" {
let inner_args = strip_outer_parens(a).trim().to_owned()
@context.ComplexPart::NamedUnit(@units.NamedUnit::new(inner_args))
} else if name == "SI_UNIT" {
let inner_args = strip_outer_parens(a)
let args_parts = split_args(inner_args)
if args_parts.length() != 2 {
fail_parse()
}
let prefix = args_parts[0].trim().to_owned()
let si_name = args_parts[1].trim().to_owned()
@context.ComplexPart::SiUnit(@units.SiUnit::new(prefix, si_name))
} else if name == "SOLID_ANGLE_UNIT" {
expect_empty_parens(a)
@context.ComplexPart::SolidAngleUnit(@units.SolidAngleUnit::new())
} else if name == "CONVERSION_BASED_UNIT" {
let inner_args = strip_outer_parens(a)
let args_parts = split_args(inner_args)
if args_parts.length() != 2 {
fail_parse()
}
let unit_name = strip_quotes(args_parts[0])
let factor_id = parse_ref_int(args_parts[1])
@context.ComplexPart::ConversionBasedUnit(
@units.ConversionBasedUnit::new(unit_name, @step.Ref::{ id: factor_id, }),
)
} else if name == "LENGTH_UNIT" {
expect_empty_parens(a)
@context.ComplexPart::LengthUnit(@units.LengthUnit::new())
} else if name == "MASS_UNIT" {
expect_empty_parens(a)
@context.ComplexPart::MassUnit(@units.MassUnit::new())
} else if name == "PLANE_ANGLE_UNIT" {
expect_empty_parens(a)
@context.ComplexPart::PlaneAngleUnit(@units.PlaneAngleUnit::new())
} else if name == "GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT" {
// args look like: ((#188))
let inner_args = strip_outer_parens(a) // -> (#188)
let ids = parse_ref_ids(inner_args)
@context.ComplexPart::GlobUncCtx(
@context.GlobalUncertaintyAssignedContext::new(ids),
)
} else if name == "GLOBAL_UNIT_ASSIGNED_CONTEXT" {
// args look like: ((#194,#190,#189))
let inner_args = strip_outer_parens(a) // -> (#194,#190,#189)
let ids = parse_ref_ids(inner_args)
@context.ComplexPart::GlobUnitCtx(
@context.GlobalUnitAssignedContext::new(ids),
)
} else if name == "REPRESENTATION_RELATIONSHIP" {
let inner_args = strip_outer_parens(a)
let args_parts = split_args(inner_args)
if args_parts.length() != 4 {
fail_parse()
}
let rr_name = strip_quotes(args_parts[0])
let rr_desc = strip_quotes(args_parts[1])
let rep_1_id = parse_ref_int(args_parts[2])
let rep_2_id = parse_ref_int(args_parts[3])
@context.ComplexPart::RepRel(
@product.RepresentationRelationship::new(
rr_name,
rr_desc,
@step.Ref::{ id: rep_1_id, },
@step.Ref::{ id: rep_2_id, },
),
)
} else if name == "REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION" {
let inner_args = strip_outer_parens(a)
let args_parts = split_args(inner_args)
if args_parts.length() != 1 {
fail_parse()
}
let t_id = parse_ref_int(args_parts[0])
@context.ComplexPart::RepRelWT(
@product.RepresentationRelationshipWithTransformation::new(@step.Ref::{
id: t_id,
}),
)
} else if name == "SHAPE_REPRESENTATION_RELATIONSHIP" {
expect_empty_parens(a)
@context.ComplexPart::ShapeRepRel
} else if name == "REPRESENTATION_ITEM" {
let inner_args = strip_outer_parens(a)
@context.ComplexPart::RepresentationItem(inner_args.trim().to_owned())
} else if name == "GEOMETRIC_REPRESENTATION_ITEM" {
expect_empty_parens(a)
@context.ComplexPart::GeometricRepresentationItem
} else if name == "SURFACE" {
expect_empty_parens(a)
@context.ComplexPart::Surface
} else if name == "BOUNDED_SURFACE" {
expect_empty_parens(a)
@context.ComplexPart::BoundedSurface
} else if name == "RATIONAL_B_SPLINE_CURVE" {
let inner_args = strip_outer_parens(a)
let weights = parse_literal_list(inner_args)
@context.ComplexPart::RatBSpline(
@geometry.RationalBSplineCurve::new(weights),
)
} else if name == "B_SPLINE_SURFACE" {
let inner_args = strip_outer_parens(a)
let inner = parse_b_spline_surface(inner_args)
@context.ComplexPart::BSplineSurf(inner)
} else if name == "B_SPLINE_SURFACE_WITH_KNOTS" {
let inner_args = strip_outer_parens(a)
let inner = parse_b_spline_surface_with_knots(inner_args)
@context.ComplexPart::BSplineSurfKnots(inner)
} else if name == "RATIONAL_B_SPLINE_SURFACE" {
let inner = parse_rational_b_spline_surface(a)
@context.ComplexPart::RatBSplineSurf(inner)
} else {
@context.ComplexPart::Raw(name, a)
}
})
@context.ComplexInstance::new(parts)
}
///|
fn find_literal_outside_step_strings_with_state(
haystack : String,
needle : String,
) -> (Int32?, Int32?) {
let n = haystack.length()
let m = needle.length()
if m == 0 {
return (Some(0), None)
}
let needle0 = cu_at(needle, 0)
let quote = Char::to_int('\'')
let mut in_string = false
let mut string_start = 0
let mut i = 0
while i < n {
let ci = cu_at(haystack, i)
if in_string {
if ci == quote {
// STEP string escaping: doubled quotes '' represent a literal '.
if i + 1 < n && cu_at(haystack, i + 1) == quote {
i = i + 2
continue
}
in_string = false
}
i = i + 1
continue
}
if ci == quote {
in_string = true
string_start = i
i = i + 1
continue
}
if ci == needle0 && i + m <= n {
let mut j = 1
let mut ok = true
while j < m {
if cu_at(haystack, i + j) != cu_at(needle, j) {
ok = false
break
}
j = j + 1
}
if ok {
return (Some(i), None)
}
}
i = i + 1
}
if in_string {
(None, Some(string_start))
} else {
(None, None)
}
}
///|
fn line_slice_at(s : String, idx : Int32) -> String {
let n = s.length()
let mut start = if idx < 0 { 0 } else { idx }
if start > n {
start = n
}
let mut i = start
while i > 0 {
if cu_at(s, i - 1) == Char::to_int('\n') {
break
}
i = i - 1
}
let line_start = i
let mut j = start
while j < n {
if cu_at(s, j) == Char::to_int('\n') {
break
}
j = j + 1
}
substr(s, line_start, j)
}
///|
fn[T] raise_unterminated_string_in_source(
content : String,
quote_idx : Int32,
) -> T raise StepParseError {
let (line, col) = index_to_line_col(content, quote_idx)
let stmt = line_slice_at(content, quote_idx)
fail_parse_at("unterminated STEP string literal", line, col, stmt)
}
///|
fn index_to_line_col(s : String, idx : Int32) -> (Int32, Int32) {
let mut line = 1
let mut col = 1
let mut i = 0
while i < idx && i < s.length() {
let ci = cu_at(s, i)
if ci == Char::to_int('\n') {
line = line + 1
col = 1
} else {
col = col + 1
}
i = i + 1
}
(line, col)
}
///|
fn extract_data_section_with_pos(
content : String,
) -> (String, Int32, Int32) raise StepParseError {
let data_idx = match
find_literal_outside_step_strings_with_state(content, "DATA;") {
(Some(i), _) => i
(None, Some(q0)) => raise_unterminated_string_in_source(content, q0)
(None, None) => fail_parse_msg("missing DATA section")
}
let after_data = data_idx + 5
let tail = substr(content, after_data, content.length())
let end_idx_local = match
find_literal_outside_step_strings_with_state(tail, "ENDSEC;") {
(Some(i), _) => i
(None, Some(q0)) =>
raise_unterminated_string_in_source(content, after_data + q0)
(None, None) => fail_parse_msg("missing ENDSEC; for DATA section")
}
let (line, col) = index_to_line_col(content, after_data)
(substr(tail, 0, end_idx_local), line, col)
}
///|
fn extract_header_section(content : String) -> String? raise StepParseError {
let header_idx = match
find_literal_outside_step_strings_with_state(content, "HEADER;") {
(Some(i), _) => i
(None, Some(q0)) =>
// Prefer surfacing a real parse error over silently ignoring HEADER.
raise_unterminated_string_in_source(content, q0)
(None, None) => return None
}
let after_header = header_idx + 7
let tail = substr(content, after_header, content.length())
let end_idx_local = match
find_literal_outside_step_strings_with_state(tail, "ENDSEC;") {
(Some(i), _) => i
(None, Some(q0)) =>
raise_unterminated_string_in_source(content, after_header + q0)
(None, None) => return None
}
Some(substr(tail, 0, end_idx_local).trim().to_owned())
}
///|
fn parse_step_string_literal(s : String) -> String? {
let t = s.trim().to_owned()
if t.length() >= 2 &&
cu_at(t, 0) == Char::to_int('\'') &&
cu_at(t, t.length() - 1) == Char::to_int('\'') {
let inner = substr(t, 1, t.length() - 1)
let builder = StringBuilder()
let n = inner.length()
let mut i = 0
while i < n {
let ci = cu_at(inner, i)
if ci == Char::to_int('\'') {
// STEP string escaping: doubled quotes '' represent a literal '.
if i + 1 < n && cu_at(inner, i + 1) == Char::to_int('\'') {
builder.write_char('\'')
i = i + 2
continue
} else {
// Unescaped quote in the middle is invalid; fall back.
return None
}
}
builder.write_char(ci.unsafe_to_char())
i = i + 1
}
return Some(builder.to_string())
}
None
}
///|
fn parse_string_or_dollar(arg : String) -> @header.StringOrDollar? {
let t = arg.trim().to_owned()
if t == "$" {
return Some(@header.StringOrDollar::Dollar)
}
match parse_step_string_literal(t) {
Some(v) => Some(@header.StringOrDollar::Str(v))
None => None
}
}
///|
fn parse_string_list_or_dollar(arg : String) -> @header.StringListOrDollar? {
let t = arg.trim().to_owned()
if t == "$" {
return Some(@header.StringListOrDollar::Dollar)
}
// Expect something like ('a','b') or ().
if !(t.length() >= 2 &&
cu_at(t, 0) == Char::to_int('(') &&
cu_at(t, t.length() - 1) == Char::to_int(')')) {
return None
}
let parts = split_args(t)
let values : Array[String] = []
for p in parts {
match parse_step_string_literal(p) {
Some(v) => values.push(v)
None => return None
}
}
Some(@header.StringListOrDollar::List(values))
}
///|
fn parse_file_description(stmt : String, args : String) -> @header.HeaderEntity {
let parts = split_args(args)
if parts.length() != 2 {
return @header.HeaderEntity::Raw(stmt)
}
let desc_opt = parse_string_list_or_dollar(parts[0])
let impl_opt = parse_string_or_dollar(parts[1])
match (desc_opt, impl_opt) {
(
Some(@header.StringListOrDollar::List(desc)),
Some(@header.StringOrDollar::Str(impl_level)),
) =>
@header.HeaderEntity::FileDescription(
@header.FileDescription::new(desc, impl_level),
)
_ => @header.HeaderEntity::Raw(stmt)
}
}
///|
fn parse_file_name(stmt : String, args : String) -> @header.HeaderEntity {
let parts = split_args(args)
if parts.length() != 7 {
return @header.HeaderEntity::Raw(stmt)
}
let a0 = parse_string_or_dollar(parts[0])
let a1 = parse_string_or_dollar(parts[1])
let a2 = parse_string_list_or_dollar(parts[2])
let a3 = parse_string_list_or_dollar(parts[3])
let a4 = parse_string_or_dollar(parts[4])
let a5 = parse_string_or_dollar(parts[5])
let a6 = parse_string_or_dollar(parts[6])
match (a0, a1, a2, a3, a4, a5, a6) {
(Some(n), Some(ts), Some(auth), Some(org), Some(pp), Some(os), Some(az)) =>
@header.HeaderEntity::FileName(
@header.FileName::new(n, ts, auth, org, pp, os, az),
)
_ => @header.HeaderEntity::Raw(stmt)
}
}
///|
fn parse_file_schema(stmt : String, args : String) -> @header.HeaderEntity {
let parts = split_args(args)
if parts.length() != 1 {
return @header.HeaderEntity::Raw(stmt)
}
let list_opt = parse_string_list_or_dollar(parts[0])
match list_opt {
Some(@header.StringListOrDollar::List(schemas)) =>
@header.HeaderEntity::FileSchema(@header.FileSchema::new(schemas))
_ => @header.HeaderEntity::Raw(stmt)
}
}
///|
fn parse_header_section(header_section : String) -> @header.HeaderSection {
let stmts = split_statements(header_section)
let entities = stmts.map(fn(stmt) {
let lp_idx = String::find(stmt, "(")
match lp_idx {
None => @header.HeaderEntity::Raw(stmt)
Some(j) => {
let name = substr(stmt, 0, j).trim().to_owned()
let args = substr(stmt, j, stmt.length()).trim().to_owned()
if name == "FILE_DESCRIPTION" {
parse_file_description(stmt, args)
} else if name == "FILE_NAME" {
parse_file_name(stmt, args)
} else if name == "FILE_SCHEMA" {
parse_file_schema(stmt, args)
} else {
@header.HeaderEntity::Raw(stmt)
}
}
}
})
@header.HeaderSection::new(entities)
}
///|
fn bytes_ascii_to_string_preserve(ascii : Bytes) -> String {
let builder = StringBuilder()
for byte in ascii {
// STEP files are typically ASCII; preserve CR/LF/tab literally.
builder.write_char(byte.to_int().unsafe_to_char())
}
builder.to_string()
}
///|
// Async entrypoint: read a STEP file and parse it into a Repository.
// Uses moonbitlang/async for file I/O.
pub async fn parse_repository_from_file(
path : StringView,
) -> @repository.Repository raise Error {
let content_bytes = @fs.read_file(path)
let content = bytes_ascii_to_string_preserve(content_bytes.binary())
parse_repository_from_string(content)
}
///|
// A non-raising parse result for library consumers that prefer not to use `raise`.
pub enum ParseRepositoryResult {
Ok(@repository.Repository)
Err(StepParseErrorInfo)
}
///|
// A non-raising parse result for file parsing, capturing either parse errors or I/O.
pub enum ParseRepositoryFromFileResult {
Ok(@repository.Repository)
ParseErr(StepParseErrorInfo)
IoErr(Error)
}
///|
pub fn parse_repository_from_string_result(
content : String,
) -> ParseRepositoryResult {
ParseRepositoryResult::Ok(parse_repository_from_string(content)) catch {
StepParseError(info) => ParseRepositoryResult::Err(info)
}
}
///|
pub async fn parse_repository_from_file_result(
path : StringView,
) -> ParseRepositoryFromFileResult {
try {
let repo = parse_repository_from_file(path)
ParseRepositoryFromFileResult::Ok(repo)
} catch {
StepParseError(info) => ParseRepositoryFromFileResult::ParseErr(info)
e => ParseRepositoryFromFileResult::IoErr(e)
}
}
///|
// Minimal parser: only supports the three entities currently ported.
// Unknown entity names are preserved as raw entities for round-trip support.
pub fn parse_repository_from_string(
content : String,
) -> @repository.Repository raise StepParseError {
// Normalize Windows CRLF (and stray CR) to keep parsing and serialization stable.
let normalized = content.replace(old="\r", new="")
// Strip STEP block comments (/* ... */) outside of string literals.
let cleaned = strip_step_comments(normalized)
let header = match extract_header_section(cleaned) {
Some(h) => parse_header_section(h)
None => @header.HeaderSection::empty()
}
let (data_section, base_line, base_col) = extract_data_section_with_pos(
cleaned,
)
let rows = tokenize_step_data_section_with_base(
data_section, base_line, base_col,
)
let mut repo = @repository.new()
for row in rows {
match parsers.get(row.name) {
Some(parser_fn) => {
let entity = parser_fn(row.args)
repo = repo.insert_with_id(row.id, entity)
}
None =>
if row.name == "__COMPLEX__" {
let entity = parse_complex_instance(row.args)
repo = repo.insert_with_id(
row.id,
@repository.any_entity_complex_instance(entity),
)
} else {
let raw = @step.RawEntity::new(row.name, row.args)
repo = repo.insert_with_id(
row.id,
@repository.any_entity_raw_entity(raw),
)
}
}
}
repo.set_header(header)
}
///|
/// parse_repository_from_string_lenient parses a STEP file and keeps entities
/// whose typed parser rejects the standard spelling as lossless `RawEntity`
/// values. Tokenizer and grammar errors still fail. This is used by
/// `tools/step-stats` to inspect third-party golden files without weakening
/// the strict parser used by the library.
pub fn parse_repository_from_string_lenient(
content : String,
) -> @repository.Repository raise StepParseError {
let normalized = content.replace(old="\r", new="")
let cleaned = strip_step_comments(normalized)
let header = match extract_header_section(cleaned) {
Some(h) => parse_header_section(h)
None => @header.HeaderSection::empty()
}
let (data_section, base_line, base_col) = extract_data_section_with_pos(
cleaned,
)
let rows = tokenize_step_data_section_with_base(
data_section, base_line, base_col,
)
let mut repo = @repository.new()
for row in rows {
match parsers.get(row.name) {
Some(parser_fn) => {
let entity = parser_fn(row.args) catch {
_ =>
@repository.any_entity_raw_entity(
@step.RawEntity::new(row.name, row.args),
)
}
repo = repo.insert_with_id(row.id, entity)
}
None =>
if row.name == "__COMPLEX__" {
let entity = @repository.any_entity_complex_instance(
parse_complex_instance(row.args),
) catch {
_ =>
@repository.any_entity_raw_entity(
@step.RawEntity::new(row.name, row.args),
)
}
repo = repo.insert_with_id(row.id, entity)
} else {
let raw = @step.RawEntity::new(row.name, row.args)
repo = repo.insert_with_id(
row.id,
@repository.any_entity_raw_entity(raw),
)
}
}
}
repo.set_header(header)
}
///|
/// parse_repository_from_string_lenient_result is the non-raising lenient
/// wrapper used by tooling.
pub fn parse_repository_from_string_lenient_result(
content : String,
) -> ParseRepositoryResult {
ParseRepositoryResult::Ok(parse_repository_from_string_lenient(content)) catch {
StepParseError(info) => ParseRepositoryResult::Err(info)
}
}