string_is_blank ()

int
string_is_blank (const char *s);

has_suffix ()

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

has_native_data_suffix ()

int
has_native_data_suffix (const char *fname);

numeric_string ()

int
numeric_string (const char *str);

integer_string ()

int
integer_string (const char *str);

count_fields ()

int
count_fields (const char *s,
              const char *sep);

count_lines ()

int
count_lines (const char *s);

dot_atof ()

double
dot_atof (const char *s);

set_atof_point ()

void
set_atof_point (char c);

gretl_dotpos ()

int
gretl_dotpos (const char *str);

gretl_slashpos ()

int
gretl_slashpos (const char *str);

strrslash ()

char *
strrslash (const char *s);

gretl_delchar ()

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

Deletes all instances of c within str .

gretl_charpos ()

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

ends_with_backslash ()

int
ends_with_backslash (const char *s);

is_greek_letter ()

int
is_greek_letter (const char *s);

Checks for the case where s contains a greek letter, followed by a nul byte or an ascii character that cannot occur in a gretl identifier.

gretl_namechar_spn ()

int
gretl_namechar_spn (const char *s);

double_quote_position ()

int
double_quote_position (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 idx .

gretl_unquote ()

char *
gretl_unquote (char *str,
               int *err);

If str begins with the ASCII double-quote character, checks that the last character is also a double-quote, and in that case trims the quotes from both ends. If the first character is a double quote but the last is not, flags an error. If the string is not quoted at all, returns the original string.

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 *format,
                     ...);

Print the arguments according to format .

gretl_word_strdup ()

char *
gretl_word_strdup (const char *src,
                   const char **ptr,
                   gretlopt opt,
                   int *err);

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_quoted_string_strdup ()

char *
gretl_quoted_string_strdup (const char *s,
                            const char **ptr);

If s starts with a quote (double or single), return a copy of the portion of s that is enclosed in quotes. That is, from s + 1 up to but not including the next matching quote. If ptr is not NULL, on output it receives a pointer to the next byte in s after the closing quote.

gretl_string_split ()

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

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

gretl_string_split_quoted ()

char **
gretl_string_split_quoted (const char *s,
                           int *n,
                           const char *sep,
                           int *err);

Similar to gretl_string_split(), except that this variant allows for the presence of double-quoted substrings which may contain spaces. The quotes are removed in the members of the returned array.

gretl_string_split_lines ()

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

Parses s into a set of zero or more substrings, one per complete line of s , 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_charsub ()

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

Replaces all occurrences of find with repl in str .

gretl_substring ()

char *
gretl_substring (const char *str,
                 int first,
                 int last,
                 int *err);

comma_separate_numbers ()

char *
comma_separate_numbers (char *s);

Given a string which contains two or more numbers separated by spaces and/or commas, revise the string to ensure that all the numbers are comma-separated.

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.

gretl_lower ()

char *
gretl_lower (char *str);

Converts any upper case characters in str to lower case.

gretl_strstrip ()

char *
gretl_strstrip (char *str);

Removes leading and trailing white space from a string.

gretl_strstrip_copy ()

char *
gretl_strstrip_copy (const char *str,
                     int *err);

switch_ext ()

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

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

switch_ext_in_place ()

char *
switch_ext_in_place (char *fname,
                     const char *ext);

For processing filenames: removes any existing dot-extension on fname and appends a dot followed by ext .

switch_ext_new ()

char *
switch_ext_new (const char *src,
                const char *ext);

For processing filenames: creates a copy of src in which any existing dot-extension is removed and ext is appended (with a dot automatically inserted).

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,
            size_t maxlen,
            int *err);

Drop leading space and trailing space and newline from string, then replace a trailing backslash (if any) with a space. If str does not end with a newline within the limit set by maxlen , and err is not NULL, then E_TOOLONG is written to err .

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 .

strings_array_new ()

char **
strings_array_new (int nstrs);

Allocates storage for nstrs strings and initializes all to NULL.

strings_array_realloc_with_length ()

char **
strings_array_realloc_with_length (char ***pS,
                                   int oldn,
                                   int newn,
                                   int len);

Adjusts the storage in pS to a size of newn strings, each of them len bytes long. The first byte of any additional strings is initialized to 0. This function may be used either to expand or to shrink an existing array of strings.

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_donate ()

int
strings_array_donate (char ***pS,
                      int *n,
                      char *p);

Allocates storage for an extra member of S and adds string p in the last position. Unlike strings_array_add(), the array takes ownnership of p rather than copying it. On success, the content of n is incremented by 1.

strings_array_add_uniq ()

int
strings_array_add_uniq (char ***pS,
                        int *n,
                        const char *p,
                        int *pos);

If the array does not already include a copy of p , allocates storage for an extra member of pS and adds a copy of string p in the last position. On successful addition the content of n is incremented by 1.

strings_array_prepend_uniq ()

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

If p is already present in the array at location pS , moves it into first position if it is not already there. Otherwise allocates storage for an extra member of the array and pushes p into first position, in which case 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);

strings_array_sort ()

int
strings_array_sort (char ***pS,
                    int *n,
                    gretlopt opt);

Sorts an array of strings in ascending lexicographical order. If OPT_U is given, n holds the number of unique strings on exit. It is assumed that storage for the strings array was obtained via strings_array_new() or a similar libgretl function.

strings_array_cmp ()

int
strings_array_cmp (char **strs1,
                   char **strs2,
                   int n);

Compares for equality two arrays of strings, each of which must contain at least n elements. Equality of the arrays means that strcmp returns 0 for each pair of strings strs1 [i], strs2 [i], for i equals 0 to n - 1.

strings_array_position ()

int
strings_array_position (char **strs,
                        int n,
                        const char *s);

strings_array_diff ()

int
strings_array_diff (char **strs1,
                    int n1,
                    char **strs2,
                    int n2,
                    char ***extra,
                    int *n_extra);

Fills out extra with any strings present in strs2 but not in strs1 .

strings_array_reverse ()

char **
strings_array_reverse (char **strs,
                       int nstrs);

strings_array_free ()

void
strings_array_free (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 DATASET *dset);

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);

print_time ()

char *
print_time (char *s);

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,
                     DATASET *dset);

Given a tentative 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 (DATASET *dset);

append_dir ()

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

path_last_element ()

const char *
path_last_element (const char *path);

trim_slash ()

char *
trim_slash (char *s);

If s ends with SLASH, remove this character.

gretl_string_ends_with ()

int
gretl_string_ends_with (const char *s,
                        const char *test);

get_column_widths ()

void
get_column_widths (const char **strs,
                   int *widths,
                   int n);

If need be, increases the column widths in widths to accomodate the current translations of strs .

gretl_utf8_strncat ()

char *
gretl_utf8_strncat (char *dest,
                    const char *src,
                    size_t n);

Works just like strncat(), except that it ensures that we don't end up with an incomplete UTF-8 character preceding the terminating NUL byte.

gretl_utf8_strncat_trim ()

char *
gretl_utf8_strncat_trim (char *dest,
                         const char *src,
                         size_t n);

The same as gretl_utf8_strncat(), except that any leading and/or trailing white space is trimmed from dest .

gretl_utf8_truncate ()

char *
gretl_utf8_truncate (char *s,
                     size_t nmax);

Truncates s to a maximum length of nmax UTF-8 characters, ensuring that we don't end up with an incomplete UTF-8 character preceding the terminating NUL byte.

gretl_utf8_truncate_b ()

char *
gretl_utf8_truncate_b (char *s,
                       size_t bmax);

Truncates s to a maximum length of bmax bytes, ensuring that we don't end up with an incomplete UTF-8 character preceding the terminating NUL byte.

gretl_utf8_replace_char ()

char *
gretl_utf8_replace_char (char *targ,
                         char *src,
                         int pos);

Notes: pos must be prechecked as within bounds, and src must be prechecked for containing a single character.

gretl_utf8_select ()

char *
gretl_utf8_select (const char *s,
                   const int *list);

Constructs a string composed of the selected characters from s , which do not have to be contiguous or in order.

gretl_scan_varname ()

int
gretl_scan_varname (const char *src,
                    char *targ);

Performs sscanf() on src , using a conversion specifier which allows for writing up to VNAMELEN-1 bytes into targ (stopping at white space); targ therefore be at least VNAMELEN bytes long. No checking is done for the validity of the scanned string as a gretl identifier.

gretl_normalize_varname ()

int
gretl_normalize_varname (char *targ,
                         const char *src,
                         int underscore,
                         int seq);

Writes a valid gretl identifier to targ , which must be at least VNAMELEN bytes in length, taking src as basis and replacing any illegal characters as described in the documentation for the userland fixname function.

gretl_regexp_replace ()

char *
gretl_regexp_replace (const char *orig,
                      const char *match,
                      const char *repl,
                      int *err);

Builds a string based on orig but in which all occurrences of match (which is interpreted as a regular expression of the Perl type) are replaced by means of repl (also interpreted as a regular expression).

gretl_literal_replace ()

char *
gretl_literal_replace (const char *orig,
                       const char *match,
                       const char *repl,
                       int *err);

Builds a string based on orig but in which all occurrences of match (which is interpreted as a straight string literal) are replaced by repl (also a straight string literal).

SLASH

#define SLASH '\\'

SLASHSTR

#define SLASHSTR "\\"

CTRLZ

#define CTRLZ 26