// lib - A fledgling library in paraFlow

global class lib
    {
    int version = 1;	// Library version number.  Should change very slowly.

    to randomIx(int size) into int ix
    /* Return a random number in range 0 <= num < size */
        {
	ix = random() * size;
	if (ix == size)
	    ix = 0;
	}

    to getEnv() into dir of string env
    /* Get a dir containing the environment strings passed
     * into program. */
        {
	static dir of string cached;
	if (!cached)
	    {
	    array of string envArray = getEnvArray();
	    env = ();
	    for (s in envArray)
		{
		int eqPos = s.find("=");
		string key = s.first(eqPos);
		string val = s.rest(eqPos+1);
		env[key] = val;
		}
	    cached = env;
	    }
	env = cached;
	}

    to countChars(string s, char c) into int count
    /* Count the number of times c is in s. */
        {
	for (b in s)
	    if (c == b)
	        count += 1;
	}

    to getPathArray() into array of string paths
    // Get the system path into an array of directory strings.
        {
	dir of string env = lib.getEnv();
	string path = env["PATH"];
	int startPos, endPos = 0;
	int colonCount = lib.countChars(path, ':');
	array[colonCount+1] of string results;
	// Might be nice to express this instead as
	//    paths = [colonCount+1] 
	// and dispense with the results variable.
	for (int i=0; i<colonCount; i += 1)
	    {
	    endPos = path.findNext(":", startPos);
	    if (endPos < 0)
	        break;
	    results[i] = path.middle(startPos, endPos-startPos);
	    startPos = endPos + 1;
	    }
	results[colonCount] = path.rest(startPos);
	paths = results;
	}

    to countSpacedWords(string s) into int count
    // Count number of space separated words.
        {
	count = s.words().size;
	}

    to countWords(string s) into int count
    // Count number of words and punctuation.
        {
	count = s.tokens().size;
	}

    to splitSpaced(string s) into array of string result
    // Return an array of space separated words.
        {
	result = s.words();
	}

    to splitWords(string s) into array of string result
    // Return an array of words and punctuation (no spaces).
        {
	result = s.tokens();
	}

    to findFirstUseOfChar(string s, char c) into int pos
    // Return first occurence of c in string or -1 if none.
        {
	for (pos=0; pos < s.size; pos += 1)
	    if (s[pos] == c)
	        return;
	pos = -1;
	}

    to findLastUseOfChar(string s, char c) into int pos
    // Return position in string of last occurence of char,
    // or -1 if none
        {
	for (pos = s.size-1; pos >= 0; pos -= 1)
	    if (s[pos] == c)
	        return;
	pos = -1;
	}

    to subChar(dyString s, char oldChar, char newChar)
    // Substitute newChar for oldChar throughout string s
        {
	for (int i=0; i<s.size; i += 1)
	    if (s[i] == oldChar)
	        s[i] = newChar;
	}

    to subString(string s, string oldString, string newString) into dyString r
    // Create a string r that is a copy of s except with each
    // occurence of oldString replaced with newString.
        {
	int start, oldStart;
	r = "";
	for (;;)
	    {
	    start = s.findNext(oldString, oldStart);
	    if (start < 0)
		{
	        r += s.rest(oldStart);
		break;
		}
	    r += s.middle(oldStart, start - oldStart);
	    r += newString;
	    oldStart = start + oldString.size;
	    }
	}

    to splitPath(string path) into (string dir, name, extension)
    // Split "some/dirs/and/file.ext" into "some/dirs/and/" "file" ".ext"
        {
	int dirEnd = lib.findLastUseOfChar(path, '/');
	if (dirEnd >= 0)
	     {
	     dirEnd += 1;
	     dir = path.first(dirEnd);
	     path = path.rest(dirEnd);
	     }
	else
	     {
	     dir = "";
	     }
	int extStart = lib.findLastUseOfChar(path, '.');
	if (extStart >= 0)
	     {
	     name = path.first(extStart);
	     extension = path.rest(extStart);
	     }
	else
	     {
	     name = path;
	     extension = "";
	     }
	}

    to startsWith(string prefix, string s) into bit result
    // Return 1 if s starts with prefix
        {
	if (s.size >= prefix.size)
	    {
	    for (int i=0; i<prefix.size; i += 1)
	        if (s[i] != prefix[i])
		    return;
	    result = 1;
	    }
	}

    to endsWith(string s, string suffix) into bit result
    // Return 1 if s ends with suffix
        {
	int sizeDif = s.size - suffix.size;
	if (sizeDif >= 0)
	    {
	    for (int i=0; i<suffix.size; i += 1)
	        if (s[i+sizeDif] != suffix[i])
		    return;
	    result = 1;
	    }
	}
    
    to lastChar(string s) into char c
        {
	c = s[s.size-1];
	}

    to wildMatch(string wild, string s) into bit result
        {
	int sPos = 0, wPos = 0;
	for (;;)
	    {
	    if (sPos == s.size)
		{
	        if (wPos == wild.size)
		    result = 1;
		return;
		}
	    else if (wPos == wild.size)
	        return;
	    char c = wild[wPos];
	    if (c == '?')
	        {
		sPos += 1;
		wPos += 1;
		}
	    else if (c == '*')
	        {
		// Skip over any other *'s
		wPos += 1;
		while (wPos < wild.size)
		    {
		    if (wild[wPos] == '*')
			wPos += 1;
		    else
		        break;
		    }

		// If the * is the last char, then we will match
		// anything else.
		if (wPos == wild.size)
		    {
		    result = 1;
		    return;
		    }

		// Count up following ?'s if any
		int qCount = 0;
		while (wPos < wild.size)
		    {
		    if (wild[wPos] == '?')
			{
			qCount += 1;
			wPos += 1;
			}
		    else
		        break;
		    }

		// If we've got nothing but ?'s to the end
		// then just make sure have enough characters
		// in s.
		if (wPos == wild.size)
		    {
		    result =  (s.size - sPos >= qCount);
		    return;
		    }
		    
		// Actually have a real character after wild card.
		// Skip through s until find a match to it.
		c = wild[wPos];
		for (;;)
		    {
		    if (sPos >= s.size)
		        return;		// Didn't find it
		    if (c == s[sPos])
		        break;
		    sPos += 1;
		    }
		sPos += 1;
		wPos += 1;
		}
	    else if (c == s[sPos])
	        {
		sPos += 1;
		wPos += 1;
		}
	    else
	        return;
	    }
	}

    }

global lib lib = ();