Geas MUD, enter the Aventure!
Geas Home | Play the Game

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

2.3.6 String functions

In a gaming environment based on text, it's natural to expect that we've gone into a bit of trouble in making string handling functions both easy to use and versatile. As you already know, strings can be added together using the + operator, even mixing in integers without any special considerations. Floats and object pointers have to be converted however, floats with the special ftoa() efun (described later) and object pointers with the file_name() efun that I described earlier.

One of the most interesting properties of strings, apart from what they contain, is the length. You find that with the efun strlen(). Since it accepts ints as well (returning 0 for them) you can use it to test uninitialized string variables as well.

int strlen(string str)
    string str = "Fatty is a bloated blimp";
    write("The length of the string '" + str + 
                "' is " + strlen(str) + " characters.\n");

Often you will want to capitalize names and sentences for output to the screen. You do that with the efun capitalize(), it will only turn the first character in the string to upper case. The converse of this function is the efun lower_case(), however, it turns the entire string into lowercase and not only the first character.

string capitalize(string str)
string lower_case(string str)
// Present a given name on the output, formatted properly
present_nice_name(string name)
    string new_name;

    // Assume name = "fAttY"
    new_name = lower_case(name);
    // Name is now = "fatty"
    new_name = capitalize(name);

    write("The name is: " + name + "\n");

    /* The result is:

       The name is: Fatty

Sometimes it's desirable to break up a string in smaller pieces, just to present a nicer output. The efun break_string() will do that for you. It can even pad spaces in front of the broken strings if you want that. What it does is simply to insert newlines after whole words where you have indicated you want to break it up. The third argument specifying either space pad length or a string to pad with, is optional.

string break_string(string str, int brlen, int indlen|string indstr|void)
    string str = "This is the string I want to present in different ways.";

    write(break_string(str, 20) + "\n");
    write(break_string(str, 20, 5) + "\n");
    write(break_string(str, 20, "Fatty says: ") + "\n");

    /* The result is:

       This is the string I
       want to present in
       different ways.

            This is the string I
            want to present in
            different ways.

       Fatty says: This is the string I
       Fatty says: want to present in
       Fatty says: different ways.

You will very often want to present information stored in variables. As shown you can do that by converting the contents to strings and then just print the strings. Integers don't even have to be converted, you just add them on with the +-operator. However, what you get then is something that's not very well formatted, you'll have to do that yourself. Particularly if you try to produce tables this is a nuisance, having to determine the length of strings and add on a certain amount of spaces depending on this length and so on. Instead of doing this you can use the efun sprintf().

What sprintf() does is simply to take a format-string that describes how you want the resulting string to look and put in the contents of the given variables according to your specifications. The result is a string that you then can present on the screen with write() for example.

All characters in the format string will be copied to the resulting string with exceptions of the special pattern %<width spec><type spec>. The width specifier can contain a field width parameter, simply an integer that specifies the width of the box you want to put it in and if you want it left- or right-aligned. A positive number denotes right-alined insertion and negative number left-aligned. If you omit the width specifier the variable will be inserted in a box exactly the width of its contents. The type specifier is one or more characters defining what kind of variable you want to have inserted.

The integer argument is printed in decimal.

string str;
int a;

a = 7;
str = sprintf("test: >%-3d%i<", 1, a);

write(str + "\n");

// The result is: 
// test: >1  7<

The argument is a string.

The integer arg is to be printed as a character.

The integer arg is printed in octal.

The integer arg is printed in hex.

The integer arg is printed in hex (in capitals).

The argument is an LPC datatype. This is an excellent function for debug purposes since you can print ANY kind of variable using this specifier.

write(sprintf("1:%d 2:%s 3:%c 4:%o\n5:%x 6:%X 7:%O\n", 5, 
              "hupp happ", 85, 584, 32434, 85852, strlen));

// The result is: 
// 1:5 2:hupp happ 3:U 4:1110
// 5:7eb2 6:14F5C 7:<<FUNCTION &strlen()>>

This specifier is also the only one you can use for denoting floats right now.

Now, these were all the available type specifiers with a few width specifiers given as examples. However, there's a lot more of them.

`' ''
The integer argument is padded with a space if it is positive. This way you can write neat tables with both positive and negative numbers without having to take special measure to handle the minus-sign.

Positive integer arguments are padded with a plus sign.

The character(s) within the quotes is used to pad the argument to the field size.

The argument will here be centered within the field size.

This is table mode. The result will be a list of \n-separated words in a table within the field size. This naturally only is meaningful with strings.

write((sprintf(">%19|s<\n", "Fatty the blimp")));

// The result is:
// >  Fatty the blimp  <

This specifier is only valid for strings. It outputs the result in columns if the arguments are wider than their field size.

Specifies to sprintf to use the corresponding argument as field size. If you combine this with table mode you will get neat tables formatted after the biggest argument.

The argument is an array. You must naturally combine with with a type specifier denoting the specific type in the array.

Very often you want to find out if a certain substring is part of a greater string. You're not interested in exactly where the string is, just that it is there. For that purpose you want something that closely resembles the UNIX shell approach to string matching. The efun wildmatch() will do this for you. It simply return 1 if a specified substring is part of a specified main string, and 0 otherwise. The substring can contain the simple UNIX pattern matching symbols.

matches any number of any characters
Matches any single character
Matches any characters in xyz
Matches any characters not in xyz
Matches c even if it is special

int wildmatch(string pattern, string str);
    // Anything ending with .foo
    wildmatch("*.foo", "") == 1
    // Anything starting with a, b or c, containing at least
    // one more character
    wildmatch("[abc]?*", "axy") == 1
    wildmatch("[abc]?*", "dxy") == 0
    wildmatch("[abc]?*", "a") == 0

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

This document was generated by Ronny Wikh on July, 8 2003 using texi2html