/*! \brief Add new line to updated \param Plus pointer to Plus_head structure \param line line id \param offset line offset (negative offset is ignored) */ void dig_line_add_updated(struct Plus_head *Plus, int line) { int i; G_debug(3, "dig_line_add_updated(): line = %d", line); /* Check if already in list */ for (i = 0; i < Plus->uplist.n_uplines; i++) { if (Plus->uplist.uplines[i] == line) { G_debug(3, "\tskipped"); return; } } /* Alloc space if needed */ if (Plus->uplist.n_uplines == Plus->uplist.alloc_uplines) { Plus->uplist.alloc_uplines += 1000; Plus->uplist.uplines = (int *)G_realloc(Plus->uplist.uplines, Plus->uplist.alloc_uplines * sizeof(int)); Plus->uplist.uplines_offset = (off_t *)G_realloc(Plus->uplist.uplines_offset, Plus->uplist.alloc_uplines * sizeof(off_t)); } Plus->uplist.uplines[Plus->uplist.n_uplines] = line; Plus->uplist.n_uplines++; }
/*! \brief Add new line to updated \param Plus pointer to Plus_head structure \param line line id \param offset line offset (negative offset is ignored) */ void dig_line_add_updated(struct Plus_head *Plus, int line, off_t offset) { int i; G_debug(3, "dig_line_add_updated(): line = %d", line); /* undo/redo in the digitizer needs all steps, * disable check */ #if 0 /* Check if already in list */ for (i = 0; i < Plus->uplist.n_uplines; i++) { if (Plus->uplist.uplines[i] == line) { G_debug(3, "\tskipped"); return; } } #endif /* Alloc space if needed */ if (Plus->uplist.n_uplines == Plus->uplist.alloc_uplines) { Plus->uplist.alloc_uplines += 1000; Plus->uplist.uplines = (int *)G_realloc(Plus->uplist.uplines, Plus->uplist.alloc_uplines * sizeof(int)); Plus->uplist.uplines_offset = (off_t *)G_realloc(Plus->uplist.uplines_offset, Plus->uplist.alloc_uplines * sizeof(off_t)); } Plus->uplist.uplines[Plus->uplist.n_uplines] = line; Plus->uplist.uplines_offset[Plus->uplist.n_uplines] = offset; Plus->uplist.n_uplines++; }
static int draw_cell(int A_row, const void *array, struct Colors *colors, RASTER_MAP_TYPE data_type) { static unsigned char *red, *grn, *blu, *set; static int nalloc; int ncols = src[0][1] - src[0][0]; int i; if (nalloc < ncols) { nalloc = ncols; red = G_realloc(red, nalloc); grn = G_realloc(grn, nalloc); blu = G_realloc(blu, nalloc); set = G_realloc(set, nalloc); } Rast_lookup_colors(array, red, grn, blu, set, ncols, colors, data_type); if (D__overlay_mode) for (i = 0; i < ncols; i++) { set[i] = Rast_is_null_value(array, data_type); array = G_incr_void_ptr(array, Rast_cell_size(data_type)); } A_row = COM_raster(ncols, A_row, red, grn, blu, D__overlay_mode ? set : NULL); return (A_row < src[1][1]) ? A_row : -1; }
/*! \brief Convert ordered array of integers to cat_list structure. \param vals array of integers \param nvals number of values \param[in,out] list pointer to cat_list structure \return number of ranges */ int Vect_array_to_cat_list(const int *vals, int nvals, struct cat_list *list) { int i, range; G_debug(1, "Vect_array_to_cat_list()"); range = -1; for (i = 0; i < nvals; i++) { if (i == 0 || (vals[i] - list->max[range]) > 1) { range++; if (range == list->alloc_ranges) { list->alloc_ranges += 1000; list->min = (int *)G_realloc((void *)list->min, list->alloc_ranges * sizeof(int)); list->max = (int *)G_realloc((void *)list->max, list->alloc_ranges * sizeof(int)); } list->min[range] = vals[i]; list->max[range] = vals[i]; } else { list->max[range] = vals[i]; } } list->n_ranges = range + 1; return (list->n_ranges); }
int I_new_control_point(struct Control_Points *cp, double e1, double n1, double e2, double n2, int status) { int i; unsigned int size; if (status < 0) return 1; i = (cp->count)++; size = cp->count * sizeof(double); cp->e1 = (double *)G_realloc(cp->e1, size); cp->e2 = (double *)G_realloc(cp->e2, size); cp->n1 = (double *)G_realloc(cp->n1, size); cp->n2 = (double *)G_realloc(cp->n2, size); size = cp->count * sizeof(int); cp->status = (int *)G_realloc(cp->status, size); cp->e1[i] = e1; cp->e2[i] = e2; cp->n1[i] = n1; cp->n2[i] = n2; cp->status[i] = status; return 0; }
int G_rasprintf(char **out, size_t *size, const char *fmt, ...) { va_list ap; int count; char *buf = *out; size_t osize = *size; if (osize < strlen(fmt) + 50) { osize = strlen(fmt) + 50; buf = G_realloc(buf, osize); } for (;;) { va_start(ap, fmt); count = vsnprintf(buf, osize, fmt, ap); va_end(ap); if (count >= 0 && count < osize) break; if (count > -1) osize = count + 1; else osize *= 2; buf = G_realloc(buf, osize); } *out = buf; *size = osize; return count; }
int G_vasprintf(char **out, const char *fmt, va_list ap) { #ifdef HAVE_ASPRINTF return vasprintf(out, fmt, ap); #else size_t size = strlen(fmt) + 50; char *buf = G_malloc(size); int count; for (;;) { /* BUG: according to man vsnprintf, * va_start() should be called immediately before vsnprintf(), * and va_end() immediately after vsnprintf() * otherwise there will be memory corruption */ count = vsnprintf(buf, size, fmt, ap); if (count >= 0 && count < size) break; size *= 2; buf = G_realloc(buf, size); } buf = G_realloc(buf, count + 1); *out = buf; return count; #endif /* HAVE_ASPRINTF */ }
int I_new_ref_point(struct Ortho_Photo_Points *cp, double e1, double n1, double e2, double n2, int status) { int i; size_t size; /*fprintf (stderr, "Try to new_ref_point \n"); */ if (status < 0) return 0; i = (cp->count)++; size = cp->count * sizeof(double); cp->e1 = (double *)G_realloc(cp->e1, size); cp->e2 = (double *)G_realloc(cp->e2, size); cp->n1 = (double *)G_realloc(cp->n1, size); cp->n2 = (double *)G_realloc(cp->n2, size); size = cp->count * sizeof(int); cp->status = (int *)G_realloc(cp->status, size); cp->e1[i] = e1; cp->e2[i] = e2; cp->n1[i] = n1; cp->n2[i] = n2; cp->status[i] = status; return 0; }
void newpoint(double z, double east, double north, int noindex) { int row, column; row = (int)((window.north - north) / window.ns_res); column = (int)((east - window.west) / window.ew_res); if (!noindex) { if (row < 0 || row >= window.rows || column < 0 || column >= window.cols) ; else { /* Ignore sites outside current region as can't be indexed */ points[row][column] = (struct Point *)G_realloc(points[row][column], (1 + npoints_currcell[row][column]) * sizeof(struct Point)); points[row][column][npoints_currcell[row][column]].north = north; points[row][column][npoints_currcell[row][column]].east = east; points[row][column][npoints_currcell[row][column]].z = z; npoints_currcell[row][column]++; npoints++; } } else { noidxpoints = (struct Point *)G_realloc(noidxpoints, (1 + npoints) * sizeof(struct Point)); noidxpoints[npoints].north = north; noidxpoints[npoints].east = east; noidxpoints[npoints].z = z; npoints++; } }
/* Add item to box list, does not check for duplicates */ int dig_boxlist_add(struct boxlist *list, int id, struct bound_box box) { if (list->n_values == list->alloc_values) { size_t size = (list->n_values + 1000) * sizeof(int); void *p = G_realloc((void *)list->id, size); if (p == NULL) return 0; list->id = (int *)p; if (list->have_boxes) { size = (list->n_values + 1000) * sizeof(struct bound_box); p = G_realloc((void *)list->box, size); if (p == NULL) return 0; list->box = (struct bound_box *)p; } list->alloc_values = list->n_values + 1000; } list->id[list->n_values] = id; if (list->have_boxes) list->box[list->n_values] = box; list->n_values++; return 1; }
void add_coor(SYMBCHAIN *chain, double x, double y) { G_debug(5, " add_coor %f, %f", x, y); if (chain->scount == chain->salloc) { chain->salloc += 10; chain->sx = (double *)G_realloc(chain->sx, chain->salloc * sizeof(double)); chain->sy = (double *)G_realloc(chain->sy, chain->salloc * sizeof(double)); } chain->sx[chain->scount] = x; chain->sy[chain->scount] = y; chain->scount++; }
int loadSiteCoordinates(struct Map_info *Map, struct Point **points, int region, struct Cell_head *window, int field, struct cat_list *cat_list) { int i, pointIdx; struct line_pnts *sites; struct line_cats *cats; struct bound_box box; int type; sites = Vect_new_line_struct(); cats = Vect_new_cats_struct(); *points = NULL; pointIdx = 0; /* copy window to box */ Vect_region_box(window, &box); while ((type = Vect_read_next_line(Map, sites, cats)) > -1) { if (type != GV_POINT && !(type & GV_LINES)) continue; if (field > 0 && !Vect_cats_in_constraint(cats, field, cat_list)) continue; for (i = 0; i < sites->n_points; i++) { G_debug(4, "Point: %f|%f|%f", sites->x[i], sites->y[i], sites->z[i]); if (region && !Vect_point_in_box(sites->x[i], sites->y[i], sites->z[i], &box)) continue; G_debug(4, "Point in the box"); if ((pointIdx % ALLOC_CHUNK) == 0) *points = (struct Point *) G_realloc(*points, (pointIdx + ALLOC_CHUNK) * sizeof(struct Point)); (*points)[pointIdx].x = sites->x[i]; (*points)[pointIdx].y = sites->y[i]; (*points)[pointIdx].z = sites->z[i]; pointIdx++; } } if (pointIdx > 0) *points = (struct Point *)G_realloc(*points, (pointIdx + 1) * sizeof(struct Point)); return pointIdx; }
/*! \brief Draw raster row in RGB mode \param A_row row number \param r_raster red data buffer \param g_raster green data buffer \param b_raster blue data buffer \param r_colors colors used for red channel \param g_colors colors used for green channel \param b_colors colors used for blue channel \param r_type raster type used for red channel \param g_type raster type used for red channel \param b_type raster type used for red channel \return */ int D_draw_raster_RGB(int A_row, const void *r_raster, const void *g_raster, const void *b_raster, struct Colors *r_colors, struct Colors *g_colors, struct Colors *b_colors, RASTER_MAP_TYPE r_type, RASTER_MAP_TYPE g_type, RASTER_MAP_TYPE b_type) { static unsigned char *r_buf, *g_buf, *b_buf, *n_buf; static int nalloc; int r_size = Rast_cell_size(r_type); int g_size = Rast_cell_size(g_type); int b_size = Rast_cell_size(b_type); int ncols = src[0][1] - src[0][0]; int i; /* reallocate color_buf if necessary */ if (nalloc < ncols) { nalloc = ncols; r_buf = G_realloc(r_buf, nalloc); g_buf = G_realloc(g_buf, nalloc); b_buf = G_realloc(b_buf, nalloc); n_buf = G_realloc(n_buf, nalloc); } /* convert cell values to bytes */ Rast_lookup_colors(r_raster, r_buf, n_buf, n_buf, n_buf, ncols, r_colors, r_type); Rast_lookup_colors(g_raster, n_buf, g_buf, n_buf, n_buf, ncols, g_colors, g_type); Rast_lookup_colors(b_raster, n_buf, n_buf, b_buf, n_buf, ncols, b_colors, b_type); if (D__overlay_mode) for (i = 0; i < ncols; i++) { n_buf[i] = (Rast_is_null_value(r_raster, r_type) || Rast_is_null_value(g_raster, g_type) || Rast_is_null_value(b_raster, b_type)); r_raster = G_incr_void_ptr(r_raster, r_size); g_raster = G_incr_void_ptr(g_raster, g_size); b_raster = G_incr_void_ptr(b_raster, b_size); } A_row = COM_raster(ncols, A_row, r_buf, g_buf, b_buf, D__overlay_mode ? n_buf : NULL); return (A_row < src[1][1]) ? A_row : -1; }
/* add point to line */ void add_point(SYMBEL * el, double x, double y) { if (el->coor.line.count == el->coor.line.alloc) { el->coor.line.alloc += 10; el->coor.line.x = (double *)G_realloc(el->coor.line.x, el->coor.line.alloc * sizeof(double)); el->coor.line.y = (double *)G_realloc(el->coor.line.y, el->coor.line.alloc * sizeof(double)); } el->coor.line.x[el->coor.line.count] = x; el->coor.line.y[el->coor.line.count] = y; el->coor.line.count++; }
/*! \brief Get list of color rules for Option->options \return allocated string buffer with options */ char *G_color_rules_options(void) { char *list, **rules; const char *name; int size, len, nrules; int i, n; list = NULL; size = len = 0; rules = scan_rules(&nrules); for (i = 0; i < nrules; i++) { name = rules[i]; n = strlen(name); if (size < len + n + 2) { size = len + n + 200; list = G_realloc(list, size); } if (len > 0) list[len++] = ','; memcpy(&list[len], name, n + 1); len += n; } G_free(rules); return list; }
/* get list of running monitors */ void list_mon(char ***list, int *n) { int i; const char *name; const char *env_prefix = "MONITOR_"; int env_prefix_len; char **tokens; env_prefix_len = strlen(env_prefix); *list = NULL; *n = 0; tokens = NULL; for (i = 0; (name = G_get_env_name(i)); i++) { if (strncmp(env_prefix, name, env_prefix_len) == 0) { tokens = G_tokenize(name, "_"); if (G_number_of_tokens(tokens) != 3 || strcmp(tokens[2], "ENVFILE") != 0) continue; *list = G_realloc(*list, (*n + 1) * sizeof(char *)); /* GRASS variable names are upper case, but monitor names are lower * case. */ (*list)[*n] = G_store_lower(tokens[1]); (*n)++; G_free_tokens(tokens); tokens = NULL; } } }
char *G_rc_path(const char *element, const char *item) { size_t len; char *path, *ptr; assert(!(element == NULL && item == NULL)); /* Simple item in top-level */ if (element == NULL) { path = _make_toplevel(); } else if (item == NULL) { return _make_sublevels(element); } else { path = _make_sublevels(element); } assert(*item != '.'); assert(path != NULL); ptr = strchr(item, '/'); /* should not have slashes */ assert(ptr == NULL); len = strlen(path) + strlen(item) + 2; if ((ptr = G_realloc(path, len)) == NULL) { G_free(path); return NULL; } path = ptr; ptr = strchr(path, '\0'); sprintf(ptr, "/%s", item); return path; } /* G_rc_path */
static void _get_list(char ***list, int *count) { char **a; int n; char *buf; *list = NULL; *count = 0; buf = _get_text_2(); for (n = 0; *buf; n++) { if (n == 0) a = G_malloc(sizeof(char *)); else a = G_realloc(a, (n + 1) * sizeof(char *)); a[n] = G_strdup(buf); buf = _get_text_2(); } *list = a; *count = n; }
int set_cat(CELL result, CELL * cat, struct Categories *pcats) { int i, n; static char *buf = NULL; static int len = 0; char *lbl; if (result == 0) return 1; n = 0; for (i = 0; i < nfiles; i++) { lbl = get_label(cat[i], &labels[i]); n += strlen(lbl) + 2; } if (len < n) buf = G_realloc(buf, len = n); *buf = 0; for (i = 0; i < nfiles; i++) { if (i) strcat(buf, "; "); lbl = get_label(cat[i], &labels[i]); strcat(buf, lbl); } G_set_cat(result, buf, pcats); return 0; }
static int add_to_list(int x, int y) { int n, i; struct equiv_table *e_list_y; e_list_y = e_list + y; n = e_list_y->count; if (n == 0) { /* first time through--start list */ e_list_y->length = 20; /* initial guess at storage needed */ e_list_y->ptr = (int *)G_malloc(e_list_y->length * sizeof(int)); *(e_list_y->ptr) = x; (e_list_y->count)++; } else { /* list already started */ for (i = 0; i < n; i++) { /* check whether x is already *//* in list */ if (*(e_list_y->ptr + i) == x) return (0); /* if so, we don't need to add it */ } if (n + 1 >= e_list_y->length) { /* add more space for storage *//* if necessary */ e_list_y->length += 10; e_list_y->ptr = (int *)G_realloc(e_list_y->ptr, e_list_y->length * sizeof(int)); } *(e_list_y->ptr + n) = x; /* add x to list */ (e_list_y->count)++; } return (1); /* indicate addition made */ }
static char *rules_list(void) { char *list = NULL; int size = 0; int len = 0; int i; for (i = 0; i < nrules; i++) { const char *name = rules[i]; int n = strlen(name); if (size < len + n + 2) { size = len + n + 200; list = G_realloc(list, size); } if (len > 0) list[len++] = ','; memcpy(&list[len], name, n + 1); len += n; } return list; }
struct SubSig *I_NewSubSig(struct SigSet *S, struct ClassSig *C) { struct SubSig *Sp; int i; if (C->nsubclasses == 0) C->SubSig = (struct SubSig *)G_malloc(sizeof(struct SubSig)); else C->SubSig = (struct SubSig *)G_realloc((char *)C->SubSig, sizeof(struct SubSig) * (C->nsubclasses + 1)); Sp = &C->SubSig[C->nsubclasses++]; Sp->used = 1; Sp->R = (double **)G_calloc(S->nbands, sizeof(double *)); Sp->R[0] = (double *)G_calloc(S->nbands * S->nbands, sizeof(double)); for (i = 1; i < S->nbands; i++) Sp->R[i] = Sp->R[i - 1] + S->nbands; Sp->Rinv = (double **)G_calloc(S->nbands, sizeof(double *)); Sp->Rinv[0] = (double *)G_calloc(S->nbands * S->nbands, sizeof(double)); for (i = 1; i < S->nbands; i++) Sp->Rinv[i] = Sp->Rinv[i - 1] + S->nbands; Sp->means = (double *)G_calloc(S->nbands, sizeof(double)); Sp->N = 0; Sp->pi = 0; Sp->cnst = 0; return Sp; }
static int try_get_colors(Colormap cmap, int nr, int ng, int nb) { XColor xcolor; int n_pixels; int r, g, b; xpixels = (unsigned long *)G_realloc(xpixels, nr * ng * nb * sizeof(unsigned long)); n_pixels = 0; xcolor.flags = DoRed | DoGreen | DoBlue; for (r = 0; r < nr; r++) { for (g = 0; g < ng; g++) { for (b = 0; b < nb; b++) { xcolor.red = (unsigned short)(r * 0xFFFF / (nr - 1)); xcolor.green = (unsigned short)(g * 0xFFFF / (ng - 1)); xcolor.blue = (unsigned short)(b * 0xFFFF / (nb - 1)); if (!XAllocColor(dpy, cmap, &xcolor)) { XFreeColors(dpy, cmap, xpixels, n_pixels, (unsigned long)0); return 0; } xpixels[n_pixels++] = xcolor.pixel; } } } return 1; }
/* add table to database */ int add_table(char *table, char *name) { G_debug(2, "add_table(): table = %s name = %s", table, name); if (db.atables == db.ntables) { db.atables += 15; db.tables = (TABLE *) G_realloc(db.tables, db.atables * sizeof(TABLE)); } strcpy(db.tables[db.ntables].name, table); #ifdef __MINGW32__ sprintf(db.tables[db.ntables].file, "%s\\%s", db.name, name); #else sprintf(db.tables[db.ntables].file, "%s/%s", db.name, name); #endif db.tables[db.ntables].alive = TRUE; db.tables[db.ntables].described = FALSE; db.tables[db.ntables].loaded = FALSE; db.tables[db.ntables].updated = FALSE; db.tables[db.ntables].cols = NULL; db.tables[db.ntables].rows = NULL; db.tables[db.ntables].acols = 0; db.tables[db.ntables].ncols = 0; db.tables[db.ntables].arows = 0; db.tables[db.ntables].nrows = 0; db.ntables++; return DB_OK; }
static void ensure(struct buffer *b, size_t n) { if (b->size <= b->len + n + 1) { b->size = b->len + n + INCREMENT; b->str = G_realloc(b->str, b->size); } }
static int try_get_grays(Colormap cmap, int ny) { XColor xcolor; int n_pixels; int y; xpixels = (unsigned long *)G_realloc(xpixels, ny * sizeof(unsigned long)); n_pixels = 0; xcolor.flags = DoRed | DoGreen | DoBlue; for (y = 0; y < ny; y++) { unsigned short v = (unsigned short)(y * 0xFFFF / (ny - 1)); xcolor.red = v; xcolor.green = v; xcolor.blue = v; if (!XAllocColor(dpy, cmap, &xcolor)) { XFreeColors(dpy, cmap, xpixels, n_pixels, (unsigned long)0); return y; } xpixels[n_pixels++] = xcolor.pixel; } return ny; }
static void add_search_dir(const char *name) { char envvar_name[256]; char *fullname = NULL; if (sscanf(name, "${%255[^}]}", envvar_name) == 1) { char *envvar_value = getenv(envvar_name); /* N.B. If the envvar isn't set, directory is skipped completely */ if (envvar_value) G_asprintf(&fullname, "%s%s", envvar_value, (name + strlen(envvar_name) + 3)); } else fullname = G_store(name); if (fullname) { searchdirs = (char **)G_realloc(searchdirs, (numsearchdirs + 1) * sizeof(char *)); searchdirs[numsearchdirs] = fullname; G_convert_dirseps_to_host(searchdirs[numsearchdirs]); numsearchdirs++; } return; }
static void draw_bitmap(FT_Bitmap * bitmap, FT_Int x, FT_Int y) { static unsigned char *buf; static int nalloc; int w, h; int bw = bitmap->width; int bh = bitmap->rows; const unsigned char *sbuf = bitmap->buffer; int offset, i, j; double x1, y1, x2, y2; x1 = x; y1 = y; x2 = x1 + bw; y2 = y1 + bh; w = x2 - x1; h = y2 - y1; if (w <= 0 || h <= 0) return; offset = ((int)y1 - y) * bw + (int)x1 - x; if (nalloc < w * h) { nalloc = w * h; buf = G_realloc(buf, nalloc); } for (j = 0; j < h; j++) for (i = 0; i < w; i++) buf[j * w + i] = sbuf[offset + j * bw + i]; COM_Pos_abs(x1, y1); COM_Bitmap(w, h, 128, buf); }
/*! \brief Add node to updated \param Plus pointer to Plus_head structure \param node node id */ void dig_node_add_updated(struct Plus_head *Plus, int node) { int i; G_debug(3, "dig_node_add_updated(): node = %d", node); /* Check if already in list */ for (i = 0; i < Plus->uplist.n_upnodes; i++) { if (abs(Plus->uplist.upnodes[i]) == abs(node)) { G_debug(3, "\tskipped"); return; } } /* Alloc space if needed */ if (Plus->uplist.n_upnodes == Plus->uplist.alloc_upnodes) { Plus->uplist.alloc_upnodes += 1000; Plus->uplist.upnodes = (int *)G_realloc(Plus->uplist.upnodes, Plus->uplist.alloc_upnodes * sizeof(int)); } Plus->uplist.upnodes[Plus->uplist.n_upnodes] = node; Plus->uplist.n_upnodes++; }
/*! Add new fringe \param data nviz data \param id surface id \param color color \param elev fringe elevation \param nw,ne,sw,se 1 (turn on) 0 (turn off) \return pointer to allocated fringe_data structure \return NULL on error */ struct fringe_data *Nviz_new_fringe(nv_data *data, int id, unsigned long color, double elev, int nw, int ne, int sw, int se) { int num; int *surf; struct fringe_data *f; if (!GS_surf_exists(id)) { /* select first surface from the list */ surf = GS_get_surf_list(&num); if (num < 1) return NULL; id = surf[0]; G_free(surf); } f = (struct fringe_data *) G_malloc(sizeof(struct fringe_data)); f->id = id; f->color = color; f->elev = elev; f->where[0] = nw; f->where[1] = ne; f->where[2] = sw; f->where[3] = se; data->fringe = (struct fringe_data **) G_realloc(data->fringe, data->num_fringes + 1 * sizeof(struct fringe_data *)); data->fringe[data->num_fringes++] = f; return f; }