SLASH

#define     SLASH

SLASHSTR

#define     SLASHSTR

CTRLZ

#define CTRLZ 26

string_is_blank ()

int         string_is_blank                 (const char *s);

has_suffix ()

int         has_suffix                      (const char *str,
                                             const char *sfx);

numeric_string ()

int         numeric_string                  (const char *str);

count_fields ()

int         count_fields                    (const char *s);

dot_atof ()

double      dot_atof                        (const char *s);

dotpos ()

int         dotpos                          (const char *str);

slashpos ()

int         slashpos                        (const char *str);

delchar ()

char*       delchar                         (int c,
                                             char *str);

Deletes all instances of c within str.

haschar ()

int         haschar                         (char c,
                                             const char *s);

lastchar ()

int         lastchar                        (char c,
                                             const char *s);

ends_with_backslash ()

int         ends_with_backslash             (const char *s);

gretl_varchar_spn ()

int         gretl_varchar_spn               (const char *s);

gretl_trunc ()

char*       gretl_trunc                     (char *str,
                                             size_t n);

Truncates the given str to the specified length.

gretl_delete ()

char*       gretl_delete                    (char *str,
                                             int idx,
                                             int count);

Deletes count characters from str, starting at position indx.

gretl_strdup ()

char*       gretl_strdup                    (const char *src);

gretl_strndup ()

char*       gretl_strndup                   (const char *src,
                                             size_t n);

gretl_strdup_printf ()

char*       gretl_strdup_printf             (const char *template,
                                             ...);

Print the arguments according to format.

gretl_word_strdup ()

char*       gretl_word_strdup               (const char *src,
                                             const char **ptr);

Copies the first 'word' found in src, where a word is defined as consisting of alphanumeric characters and the underscore. If ptr is not NULL, on exit it points at the next position in src after the copied word.

gretl_string_split ()

char**      gretl_string_split              (const char *s,
                                             int *n);

Parses s into a set of zero or more substrings, separated by one or more spaces, and creates an array of those substrings. On sucessful exit, n holds the number of substrings.

gretl_str_expand ()

char*       gretl_str_expand                (char **orig,
                                             const char *add,
                                             const char *sep);

Creates a newly allocated string built by concatenating orig and add, with sep interpolated unless sep is NULL, and replaces the content of orig with the new string. As a special case, if orig is NULL, or if the content of orig is NULL, we just duplicate add.

gretl_double_from_string ()

double      gretl_double_from_string        (const char *s,
                                             const char **ptr);

Tries to parse the first 'word' found in s as a floating-point number, and returns either the number or NADBL on failure. If the parsing was successful and if ptr is not NULL, on exit it points at the next position in s after the just-parsed numeric portion.

charsub ()

char*       charsub                         (char *str,
                                             char find,
                                             char repl);

Replaces all occurrences of find with repl in str.

shift_string_left ()

char*       shift_string_left               (char *str,
                                             size_t move);

Shifts the content of str left by move places, dropping leading bytes as needed.

lower ()

char*       lower                           (char *str);

Converts any upper case characters in str to lower case.

clear ()

void        clear                           (char *str,
                                             int len);

Sets all bytes in str to 0.

chopstr ()

char*       chopstr                         (char *str);

Removes both leading and trailing space from a string.

switch_ext ()

char*       switch_ext                      (char *targ,
                                             const char *src,
                                             char *ext);

For processing filenames: copies src to targ, minus any existing filename extension, and adds to targ the specified extension.

get_base ()

int         get_base                        (char *targ,
                                             const char *src,
                                             char c);

If c is found in src, puts into targ the portion of src up to and including the last occurrence of c within src.

equation_get_lhs_and_rhs ()

int         equation_get_lhs_and_rhs        (const char *s,
                                             char **plh,
                                             char **prh);

Given a string s, parse it into a left-hand side and a right-hand side, separated by an equals sign. Return in plh and prh allocated copies of the respective sides, with any leading or trailing white space trimmed.

top_n_tail ()

int         top_n_tail                      (char *str);

Drop leading space and trailing space and newline from string, then replace a trailing backslash (if any) with a space.

tailstrip ()

char*       tailstrip                       (char *str);

Drop trailing space (and newline if any) from string.

compress_spaces ()

char*       compress_spaces                 (char *s);

Reduce multiple contiguous space characters to single spaces within s.

space_to_score ()

char*       space_to_score                  (char *s);

Replace any spaces with underscores in s.

safecpy ()

char*       safecpy                         (char *targ,
                                             const char *src,
                                             int n);

Copies at most n characters from src to targ, and ensures that targ[n] is a NUL byte.

strings_array_new ()

char**      strings_array_new               (int nstrs);

Allocates storage for nstrs strings and initalizes all to NULL.

strings_array_add ()

int         strings_array_add               (char ***pS,
                                             int *n,
                                             const char *p);

Allocates storage for an extra member of S and adds a copy of string p in the last position. On success, the content of n is incremented by 1.

strings_array_new_with_length ()

char**      strings_array_new_with_length   (int nstrs,
                                             int len);

Allocates storage for nstrs strings, each of them len bytes long. The first byte of each string is initialized to 0.

strings_array_dup ()

char**      strings_array_dup               (char **strs,
                                             int n);

free_strings_array ()

void        free_strings_array              (char **strs,
                                             int nstrs);

Frees each allocated string in strs, then frees strs itself. Checks that strs is not NULL before proceeding.

get_obs_string ()

char*       get_obs_string                  (char *obs,
                                             int t,
                                             const DATAINFO *pdinfo);

get_full_obs_string ()

char*       get_full_obs_string             (char *obs,
                                             int t,
                                             const DATAINFO *pdinfo);

obs_str_to_double ()

double      obs_str_to_double               (const char *obs);

colonize_obs ()

char*       colonize_obs                    (char *obs);

Converts a decimal point in obs to a colon.

modify_date_for_csv ()

void        modify_date_for_csv             (char *s,
                                             int pd);

csv_obs_to_prn ()

void        csv_obs_to_prn                  (int t,
                                             const DATAINFO *pdinfo,
                                             PRN *prn);

print_time ()

const char* print_time                      (const time_t *timep);

gretl_xml_validate ()

int         gretl_xml_validate              (const char *s);

gretl_xml_encode ()

char*       gretl_xml_encode                (const char *str);

gretl_xml_encode_to_buf ()

int         gretl_xml_encode_to_buf         (char *targ,
                                             const char *src,
                                             int n);

Writes into targ a version of src in which characters that are special in XML are encoded as character entities. See also gretl_xml_encode() for the case where the encoding of src is of unknown size at compile time.

unescape_url ()

void        unescape_url                    (char *url);

make_varname_unique ()

char*       make_varname_unique             (char *vname,
                                             int v,
                                             DATAINFO *pdinfo);

Given a tenative name for a new variable, check that it is not a duplicate of an existing varname. If it is, modify the new name so that it becomes unique. The ID number v is required so that, if the variable has already been added to the dataset, its name does not appear to conflict with itself! If the name to be tested is not associated with an existing variable, pass 0 for v.

fix_varname_duplicates ()

int         fix_varname_duplicates          (DATAINFO *pdinfo);

append_dir ()

char*       append_dir                      (char *fname,
                                             const char *dir);

build_path ()

char*       build_path                      (char *targ,
                                             const char *dirname,
                                             const char *fname,
                                             const char *ext);

Writes to targ a full path composed of dirname, fname and (optionally) ext. This function ensures that an appropriate separator is inserted between dirname and fname, if dirname is not already terminated with such a separator.

path_last_element ()

const char* path_last_element               (const char *path);

varname_match_list ()

int*        varname_match_list              (const DATAINFO *pdinfo,
                                             const char *pattern);