Lugaru's Epsilon
Programmer's
Editor

Context:
Epsilon User's Manual and Reference
   Primitives and EEL Subroutines
      . . .
      Operating System Primitives
         System Primitives
         Window System Primitives
         Timing
         Calling Windows DLLs
         Running a Process
      Control Primitives
         Control Flow
         Character Types
         Examining Strings
         Modifying Strings
         Byte Arrays
         . . .
      Input Primitives
         Keys
         The Mouse
         Window Events
         . . .
         Binding Primitives
      . . .

Previous   Up    Next
Character Types  Primitives and EEL Subroutines   Modifying Strings


Epsilon User's Manual and Reference > Primitives and EEL Subroutines > Control Primitives >

Examining Strings

int strlen(char *s)

Epsilon provides various functions for manipulating strings, or equivalently, zero-terminated arrays of characters. (General-purpose functions for modifying strings are covered in the next section.) The strlen( ) primitive returns the length of a string. That is, it tells the position in the array of the first zero character.

int strcmp(char *first, char *second)
int strncmp(char *first, char *second, int count)

The strcmp( ) primitive tells if two strings are identical. It returns 0 if all characters in them are the same (and if they have the same length). Otherwise, it returns a negative number if the lexicographic ordering of these strings would put the first before the second. It returns a positive number otherwise. The strncmp( ) primitive is like strcmp( ), except only the first count characters matter.

int strfcmp(char *first, char *second)
int strnfcmp(char *first, char *second, int count)
int charfcmp(int first, int second)

Epsilon also has similar comparison primitives that consider upper case and lower case letters to be equal. The strfcmp( ) primitive acts like strcmp( ) and the strnfcmp( ) primitive acts like strncmp( ), but if the buffer-specific variable case_fold is nonzero, Epsilon folds characters in the same way searching or sorting would before making the comparison. The charfcmp( ) primitive takes two characters and performs the same comparison on them. For characters a and b, charfcmp('a', 'b') equals strfcmp("a", "b"). (EEL also recognizes the corresponding ANSI C name stricmp( ) instead of strfcmp( ).)

int compare_chars(char *str1, char *str2, int num, int fold)

The compare_chars( ) primitive works like strcmp( ), except that it makes no assumptions about zero-termination. It takes two strings and a size, then compares that many characters from each string. If the strings exactly match, compare_chars( ) returns zero. If str1 would be alphabetically before str2, it returns a negative value. If str2 would be alphabetically before str1, it returns a positive value. It ignores the case of the characters when comparing if fold is nonzero.

char *index(char *s, int ch)
char *rindex(char *s, int ch)
char *strstr(char *s, char *t)
char *strpbrk(char *s, char *charset)
char *strpbrk_cnt(char *s, char *charset, int skip)

The index( ) primitive tells if a character ch appears in the string s. It returns a pointer to the first appearance of ch, or a null pointer if there is none. The rindex( ) primitive works the same, but returns a pointer to the last appearance of ch. (EEL also recognizes the corresponding ANSI C names strchr( ) instead of index( ) and strrchr( ) instead of rindex( ).)

The strstr( ) primitive searches the string s for a copy of the string t. It returns a pointer to the first appearance of t, or a null pointer if there is none. It case-folds as described above for strfcmp( ).

The strpbrk( ) subroutine returns a pointer to the first character in s that appears in the list of characters charset. Both strings must be null-terminated. If the strings have no characters in common, it returns a null pointer.

The strpbrk_cnt( ) subroutine is similar, but it skips over the first skip characters in s that also appear in charset. For instance, with skip set to 1, it returns a pointer to the second character in s that also appears in charset.

int fpatmatch(char *s, char *pat, int prefix, int flags)
#define FPAT_FOLD                      1
#define FPAT_IGNORE_SQUARE_BRACKETS    2

The fpatmatch( ) primitive returns nonzero if a string s matches a pattern pat. It uses a simple filename-style pattern syntax: * matches any number of characters; ? matches a single character, and [a-z] match a character class (with the same character class syntax as other patterns in Epsilon). It also recognizes | to permit alternatives. If prefix is nonzero, s must begin with text matching pat; otherwise pat must match all of s.

The flags parameter recognizes two bits. The FPAT_FOLD bit makes Epsilon fold characters before comparing, according to the current buffer's folding rules. The FPAT_IGNORE_SQUARE_BRACKETS bit makes Epsilon treat the character [ in a pattern like any other, instead of interpreting it as the start of a character class.

int string_matches_regex(char *str, char *pat, int fold)
int string_matches_pattern(char *str, char *pat)

The string_matches_regex( ) subroutine returns nonzero if the start of the given string matches the regular expression pattern. Use <eof> at the end of the pattern to check if the entire string matches. It does case-folding if fold is nonzero.

The similar string_matches_pattern( ) subroutine returns the length of match (which differs from the above only with patterns that can match zero-length text), and uses case_fold.default.

Both return zero when given an invalid regular expression pattern.

int word_in_list(char *word, char *list, int fold)
int starts_with_in_list(char *word, char *list, int fold)

The word_in_list( ) subroutine returns nonzero whenever the text in word appears in the |-separated list of words list. "Word" here means any text that doesn't contain an actual | character. The list of words must begin and end with | delimiters. The similar starts_with_in_list( ) subroutine returns nonzero whenever word starts with one of the words in the list. Both do case-folding if fold is nonzero. They are faster than the regular-expression-based subroutines above.



Previous   Up    Next
Character Types  Primitives and EEL Subroutines   Modifying Strings


Lugaru Copyright (C) 1984, 2012 Lugaru Software Ltd. All Rights Reserved.