// Append the specified component to the end of the op.
static void append(text_op *op, const text_op_component c) {
if (c.type == NONE
|| ((c.type == SKIP || c.type == DELETE) && c.num == 0)
|| (c.type == INSERT && !c.str.mem && c.str.chars[0] == '\0')) {
// We're not inserting any actual data. Skip.
return;
} else if (op->components == NULL) {
// Small op.
if (op->content.type == NONE) {
if (c.type == SKIP) {
op->skip += c.num;
} else {
op->content = copy_component(c);
}
return;
} else if (op->content.type == c.type) {
if (c.type == DELETE) {
op->content.num += c.num;
return;
} else if (c.type == INSERT) {
str_append(&op->content.str, &c.str);
return;
}
}
// Fall through here if the small op can't hold the new component. Expand it and append.
ensure_capacity(op);
op->components[op->num_components++] = copy_component(c);
} else {
// Big op.
if (op->num_components == 0) { // This will basically never happen.
// The list is empty. Create a new node.
ensure_capacity(op);
op->components[0] = copy_component(c);
op->num_components++;
} else {
text_op_component *lastC = &op->components[op->num_components - 1];
if (lastC->type == c.type) {
if (c.type == DELETE || c.type == SKIP) {
// Extend the delete / skip component.
lastC->num += c.num;
} else {
// Extend the insert component.
str_append(&lastC->str, &c.str);
}
} else {
ensure_capacity(op);
op->components[op->num_components++] = copy_component(c);
}
}
}
}
void text_op_clone2(text_op *dest, text_op *src) {
if (src->components) {
size_t num = src->num_components;
dest->components = malloc(sizeof(text_op_component) * num);
dest->capacity = dest->num_components = num;
for (int i = 0; i < num; i++) {
dest->components[i] = copy_component(src->components[i]);
}
} else {
dest->components = NULL;
dest->skip = src->skip;
dest->content = copy_component(src->content);
}
}
Graph Graph::copy_component(std::list< std::string > const& items) const {
Graph ret{};
for (std::string const &item : items) {
ret.add_component(copy_component(item));
}
return ret;
}
grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors) {
grpc_uri *uri;
size_t scheme_begin = 0;
size_t scheme_end = NOT_SET;
size_t authority_begin = NOT_SET;
size_t authority_end = NOT_SET;
size_t path_begin = NOT_SET;
size_t path_end = NOT_SET;
size_t query_begin = NOT_SET;
size_t query_end = NOT_SET;
size_t fragment_begin = NOT_SET;
size_t fragment_end = NOT_SET;
size_t i;
for (i = scheme_begin; uri_text[i] != 0; i++) {
if (uri_text[i] == ':') {
scheme_end = i;
break;
}
if (uri_text[i] >= 'a' && uri_text[i] <= 'z') continue;
if (uri_text[i] >= 'A' && uri_text[i] <= 'Z') continue;
if (i != scheme_begin) {
if (uri_text[i] >= '0' && uri_text[i] <= '9') continue;
if (uri_text[i] == '+') continue;
if (uri_text[i] == '-') continue;
if (uri_text[i] == '.') continue;
}
break;
}
if (scheme_end == NOT_SET) {
return bad_uri(uri_text, i, "scheme", suppress_errors);
}
if (uri_text[scheme_end + 1] == '/' && uri_text[scheme_end + 2] == '/') {
authority_begin = scheme_end + 3;
for (i = authority_begin; uri_text[i] != 0 && authority_end == NOT_SET;
i++) {
if (uri_text[i] == '/' || uri_text[i] == '?' || uri_text[i] == '#') {
authority_end = i;
}
}
if (authority_end == NOT_SET && uri_text[i] == 0) {
authority_end = i;
}
if (authority_end == NOT_SET) {
return bad_uri(uri_text, i, "authority", suppress_errors);
}
/* TODO(ctiller): parse the authority correctly */
path_begin = authority_end;
} else {
path_begin = scheme_end + 1;
}
for (i = path_begin; uri_text[i] != 0; i++) {
if (uri_text[i] == '?' || uri_text[i] == '#') {
path_end = i;
break;
}
}
if (path_end == NOT_SET && uri_text[i] == 0) {
path_end = i;
}
if (path_end == NOT_SET) {
return bad_uri(uri_text, i, "path", suppress_errors);
}
if (uri_text[i] == '?') {
query_begin = ++i;
if (!parse_fragment_or_query(uri_text, &i)) {
return bad_uri(uri_text, i, "query", suppress_errors);
} else if (uri_text[i] != 0 && uri_text[i] != '#') {
/* We must be at the end or at the beginning of a fragment */
return bad_uri(uri_text, i, "query", suppress_errors);
}
query_end = i;
}
if (uri_text[i] == '#') {
fragment_begin = ++i;
if (!parse_fragment_or_query(uri_text, &i)) {
return bad_uri(uri_text, i - fragment_end, "fragment", suppress_errors);
} else if (uri_text[i] != 0) {
/* We must be at the end */
return bad_uri(uri_text, i, "fragment", suppress_errors);
}
fragment_end = i;
}
uri = gpr_malloc(sizeof(*uri));
memset(uri, 0, sizeof(*uri));
uri->scheme = copy_component(uri_text, scheme_begin, scheme_end);
uri->authority = copy_component(uri_text, authority_begin, authority_end);
uri->path = copy_component(uri_text, path_begin, path_end);
uri->query = copy_component(uri_text, query_begin, query_end);
uri->fragment = copy_component(uri_text, fragment_begin, fragment_end);
parse_query_parts(uri);
return uri;
}
static void
gimp_brush_clipboard_buffer_changed (Gimp *gimp,
GimpBrush *brush)
{
gint width;
gint height;
if (brush->mask)
{
temp_buf_free (brush->mask);
brush->mask = NULL;
}
if (brush->pixmap)
{
temp_buf_free (brush->pixmap);
brush->pixmap = NULL;
}
if (gimp->global_buffer)
{
TileManager *tiles = gimp_buffer_get_tiles (gimp->global_buffer);
GimpImageType type = gimp_buffer_get_image_type (gimp->global_buffer);
width = MIN (gimp_buffer_get_width (gimp->global_buffer), 1024);
height = MIN (gimp_buffer_get_height (gimp->global_buffer), 1024);
brush->mask = temp_buf_new (width, height, 1, 0, 0, NULL);
brush->pixmap = temp_buf_new (width, height, 3, 0, 0, NULL);
/* copy the alpha channel into the brush's mask */
if (GIMP_IMAGE_TYPE_HAS_ALPHA (type))
{
PixelRegion bufferPR;
PixelRegion maskPR;
pixel_region_init (&bufferPR, tiles,
0, 0, width, height, FALSE);
pixel_region_init_temp_buf (&maskPR, brush->mask,
0, 0, width, height);
extract_alpha_region (&bufferPR, NULL, &maskPR);
}
else
{
PixelRegion maskPR;
guchar opaque = OPAQUE_OPACITY;
pixel_region_init_temp_buf (&maskPR, brush->mask,
0, 0, width, height);
color_region (&maskPR, &opaque);
}
/* copy the color channels into the brush's pixmap */
if (GIMP_IMAGE_TYPE_IS_RGB (type))
{
PixelRegion bufferPR;
PixelRegion pixmapPR;
pixel_region_init (&bufferPR, tiles,
0, 0, width, height, FALSE);
pixel_region_init_temp_buf (&pixmapPR, brush->pixmap,
0, 0, width, height);
if (GIMP_IMAGE_TYPE_HAS_ALPHA (type))
copy_color (&bufferPR, &pixmapPR);
else
copy_region (&bufferPR, &pixmapPR);
}
else
{
PixelRegion bufferPR;
PixelRegion tempPR;
TempBuf *temp = temp_buf_new (width, height, 1, 0, 0, NULL);
pixel_region_init (&bufferPR, tiles,
0, 0, width, height, FALSE);
pixel_region_init_temp_buf (&tempPR, temp,
0, 0, width, height);
if (GIMP_IMAGE_TYPE_HAS_ALPHA (type))
copy_component (&bufferPR, &tempPR, 0);
else
copy_region (&bufferPR, &tempPR);
temp_buf_copy (temp, brush->pixmap);
temp_buf_free (temp);
}
}
else
{
guchar color = 0;
width = 17;
height = 17;
brush->mask = temp_buf_new (width, height, 1, 0, 0, &color);
}
brush->x_axis.x = width / 2;
brush->x_axis.y = 0;
brush->y_axis.x = 0;
brush->y_axis.y = height / 2;
gimp_data_dirty (GIMP_DATA (brush));
}
