util.c File Reference

#include "postgres_fe.h"
#include <unistd.h>
#include "preproc_extern.h"

Include dependency graph for util.c:

Go to the source code of this file.

Data Structures
struct	loc_chunk

Macros
#define	LOC_CHUNK_OVERHEAD   MAXALIGN(offsetof(loc_chunk, data))
#define	LOC_CHUNK_MIN_SIZE   8192

Typedefs
typedef struct loc_chunk	loc_chunk

Functions
static void	vmmerror (int error_code, enum errortype type, const char *error, va_list ap) pg_attribute_printf(3
void	mmerror (int error_code, enum errortype type, const char *error,...)
void	mmfatal (int error_code, const char *error,...)
void *	mm_alloc (size_t size)
char *	mm_strdup (const char *string)
void *	loc_alloc (size_t size)
char *	loc_strdup (const char *string)
void	reclaim_local_storage (void)
char *	cat2_str (const char *str1, const char *str2)
char *	cat_str (int count,...)
char *	make2_str (const char *str1, const char *str2)
char *	make3_str (const char *str1, const char *str2, const char *str3)

Variables
static loc_chunk *	loc_chunks = NULL

Macro Definition Documentation

LOC_CHUNK_MIN_SIZE

#define LOC_CHUNK_MIN_SIZE   8192

Definition at line 127 of file util.c.

LOC_CHUNK_OVERHEAD

#define LOC_CHUNK_OVERHEAD   MAXALIGN(offsetof(loc_chunk, data))

Definition at line 126 of file util.c.

Typedef Documentation

loc_chunk

typedef struct loc_chunk loc_chunk

Function Documentation

cat2_str()

char * cat2_str	(	const char *	str1,
		const char *	str2
	)

Definition at line 205 of file util.c.

{
    char       *res_str = (char *) loc_alloc(strlen(str1) + strlen(str2) + 2);
 
    strcpy(res_str, str1);
    if (strlen(str1) != 0 && strlen(str2) != 0)
        strcat(res_str, " ");
    strcat(res_str, str2);
    return res_str;
}

References fb(), and loc_alloc().

Referenced by cat_str().

cat_str()

char * cat_str	(	int	count,
			...
	)

Definition at line 220 of file util.c.

{
    va_list     args;
    int         i;
    char       *res_str;
 
    va_start(args, count);
 
    res_str = va_arg(args, char *);
 
    /* now add all other strings */
    for (i = 1; i < count; i++)
        res_str = cat2_str(res_str, va_arg(args, char *));
 
    va_end(args);
 
    return res_str;
}

References cat2_str(), fb(), and i.

loc_alloc()

void * loc_alloc

(

size_t

size

)

Definition at line 138 of file util.c.

{
    void       *result;
    loc_chunk  *cur_chunk = loc_chunks;
 
    /* Ensure all allocations are adequately aligned */
    size = MAXALIGN(size);
 
    /* Need a new chunk? */
    if (cur_chunk == NULL || size > cur_chunk->chunk_avail)
    {
        size_t      chunk_size = Max(size, LOC_CHUNK_MIN_SIZE);
 
        cur_chunk = mm_alloc(chunk_size + LOC_CHUNK_OVERHEAD);
        /* Depending on alignment rules, we could waste a bit here */
        cur_chunk->chunk_used = LOC_CHUNK_OVERHEAD - offsetof(loc_chunk, data);
        cur_chunk->chunk_avail = chunk_size;
        /* New chunk becomes the head of the list */
        cur_chunk->next = loc_chunks;
        loc_chunks = cur_chunk;
    }
 
    result = cur_chunk->data + cur_chunk->chunk_used;
    cur_chunk->chunk_used += size;
    cur_chunk->chunk_avail -= size;
    return result;
}

References loc_chunk::data, data, fb(), LOC_CHUNK_MIN_SIZE, LOC_CHUNK_OVERHEAD, loc_chunks, Max, MAXALIGN, and mm_alloc().

Referenced by cat2_str(), hashline_number(), loc_nstrdup(), loc_strdup(), make2_str(), make3_str(), and sqlda_variable().

loc_strdup()

char * loc_strdup

(

const char *

string

)

Definition at line 170 of file util.c.

{
    char       *result = loc_alloc(strlen(string) + 1);
 
    strcpy(result, string);
    return result;
}

References fb(), and loc_alloc().

Referenced by base_yylex_location(), filtered_base_yylex(), process_integer_literal(), and sqlda_variable().

make2_str()

char * make2_str	(	const char *	str1,
		const char *	str2
	)

Definition at line 243 of file util.c.

{
    char       *res_str = (char *) loc_alloc(strlen(str1) + strlen(str2) + 1);
 
    strcpy(res_str, str1);
    strcat(res_str, str2);
    return res_str;
}

References fb(), and loc_alloc().

make3_str()

char * make3_str	(	const char *	str1,
		const char *	str2,
		const char *	str3
	)

Definition at line 256 of file util.c.

{
    char       *res_str = (char *) loc_alloc(strlen(str1) + strlen(str2) + strlen(str3) + 1);
 
    strcpy(res_str, str1);
    strcat(res_str, str2);
    strcat(res_str, str3);
    return res_str;
}

References fb(), and loc_alloc().

Referenced by filtered_base_yylex().

mm_alloc()

void * mm_alloc

(

size_t

size

)

Definition at line 85 of file util.c.

{
    void       *ptr = malloc(size);
 
    if (ptr == NULL)
        mmfatal(OUT_OF_MEMORY, "out of memory");
 
    return ptr;
}

References fb(), malloc, mmfatal(), and OUT_OF_MEMORY.

Referenced by add_descriptor(), add_include_path(), add_preprocessor_define(), add_variable_to_head(), add_variable_to_tail(), ECPGdump_a_simple(), ECPGdump_a_struct(), ECPGmake_simple_type(), ECPGmake_struct_member(), isdefine(), isinformixdefine(), lex_init(), loc_alloc(), main(), new_variable(), parse_include(), and push_assignment().

mm_strdup()

char * mm_strdup

(

const char *

string

)

Definition at line 97 of file util.c.

{
    char       *new = strdup(string);
 
    if (new == NULL)
        mmfatal(OUT_OF_MEMORY, "out of memory");
 
    return new;
}

References fb(), mmfatal(), and OUT_OF_MEMORY.

Referenced by add_descriptor(), add_preprocessor_define(), dump_variables(), ECPGdump_a_type(), ECPGmake_simple_type(), ECPGmake_struct_member(), ECPGmake_struct_type(), isdefine(), isinformixdefine(), lookup_descriptor(), main(), new_variable(), output_get_descr(), output_set_descr(), parse_include(), and push_assignment().

mmerror()

void mmerror	(	int	error_code,
		enum errortype	type,
		const char *	error,
			...
	)

Definition at line 50 of file util.c.

{
    va_list     ap;
 
    va_start(ap, error);
    vmmerror(error_code, type, error, ap);
    va_end(ap);
}

References error(), fb(), type, and vmmerror().

mmfatal()

void mmfatal	(	int	error_code,
		const char *	error,
			...
	)

Definition at line 61 of file util.c.

{
    va_list     ap;
 
    va_start(ap, error);
    vmmerror(error_code, ET_ERROR, error, ap);
    va_end(ap);
 
    if (base_yyin)
        fclose(base_yyin);
    if (base_yyout)
        fclose(base_yyout);
 
    if (strcmp(output_filename, "-") != 0 && unlink(output_filename) != 0)
        fprintf(stderr, _("could not remove output file \"%s\"\n"), output_filename);
    exit(error_code);
}

References _, base_yyin, base_yyout, error(), ET_ERROR, fb(), fprintf, output_filename, and vmmerror().

Referenced by mm_alloc(), and mm_strdup().

reclaim_local_storage()

void reclaim_local_storage

(

void

)

Definition at line 182 of file util.c.

{
    loc_chunk  *cur_chunk,
               *next_chunk;
 
    for (cur_chunk = loc_chunks; cur_chunk; cur_chunk = next_chunk)
    {
        next_chunk = cur_chunk->next;
        free(cur_chunk);
    }
    loc_chunks = NULL;
}

References fb(), free, loc_chunks, and loc_chunk::next.

vmmerror()

static void static void vmmerror ( int  error_code, enum errortype  type, const char *  error, va_list  ap  )

static

Definition at line 16 of file util.c.

{
    /* localize the error message string */
    error = _(error);
 
    fprintf(stderr, "%s:%d: ", input_filename, base_yylineno);
 
    switch (type)
    {
        case ET_WARNING:
            fprintf(stderr, _("WARNING: "));
            break;
        case ET_ERROR:
            fprintf(stderr, _("ERROR: "));
            break;
    }
 
    vfprintf(stderr, error, ap);
 
    fprintf(stderr, "\n");
 
    /* If appropriate, set error code to be inspected by ecpg.c */
    switch (type)
    {
        case ET_WARNING:
            break;
        case ET_ERROR:
            ret_value = error_code;
            break;
    }
}

References _, base_yylineno, error(), ET_ERROR, ET_WARNING, fb(), fprintf, input_filename, ret_value, type, and vfprintf.

Referenced by mmerror(), and mmfatal().

Variable Documentation

loc_chunks

loc_chunk* loc_chunks = NULL

static

Definition at line 130 of file util.c.

Referenced by loc_alloc(), and reclaim_local_storage().