std.lsp: Function and Context Index

    (Global Constants) - Protected
    lc-chars: Lower-case alphabetic characters
    uc-chars: Upper-case alphabetic characters
    alpha: Upper and lower case characters
    alphanum: Upper/lower case characters and numerics

Function: aligned?

(aligned? 12 3) => true, (aligned? 12 5) => nil
Returns if v is evenly divisible by n

Function: cd

(cd <str-path>) => Change directory to <str-path>

Function: cgi?

syntax: (cgi?) Are we in a cgi environment?

Function: clear

    (clear val) => "" (if val is string) => () (If val is list)
    Argument: <list-or-string> Remember to quote
    Note!: This is a destructive function.

Function: compose

    (compose <lst-l> <sep=" ">)
    Takes a list, converts members to strings, evaluating only
    When preceded by a , and joins with a seperator.

Function: data?

(data? ()) => nil, (data? "yes") => true
Does argument have any meaningful data?

Function: either

    (either <condition> <true-clause> else <false-clause>)
    If condition is true, evaluates all expression up to else
    If condition is false,evaluates all expressions following else
    WARNING!: Using in loops can cause great performance penalties,
    if is at least 16 times faster

Function: even?

(even? 4) => true, (even? 5) => nil
Is argument evenly divisible by 2

Function: filesize

(filesize "myfile.txt") => <int-size-of-file>
Get the size of the file

Function: fourth

(fourth (1 2 3 4)) => 4
returns fourth element

Function: halt

(halt <str-optional>)
(exit) and if needed, leave a message

Function: inspect

syntax: (inspect <context-obj>)
Print out names and values of context members

Function: ls

    (ls <the current directory>)
    Args:: "*" - find any substring
          "$" - substring at end
          "^" - substring at beginning
          nil - all of directory

Function: ltrim

(ltrim <str-target> <str-charstrimmed>)
shortcut for (trim target of whitespace at beginning)

Function: ltrims

    syntax: (ltrims <str-target> <str-removed>)
    example:
    (ltrims "onething" "one") => "thing"

Function: merge

    syntax: (merge <lst-1> <lst-2> <lst...n>)
    Description:: Interweave two lists
    Example:
    (merge (1 2 3) ("one" "two" "three")) => ((1 "one")(2 "two")(3 "three"))

Function: mold

param: (mold s) converts a symbol to a string and removes context prefix

Function: mrk

(mrk <str-may-be-empty>)
Just an obvious mark

Function: MTime

    (MTime "myfile.txt") => <int-modification-time>
    param: <str-filename> - name of file. required
    param: <sym-mode> - one of: seconds, minutes, hours, days
      with mode parameter, calculate time since last modification
    default:: seconds

Function: pad

syntax: (pad <lst-src> <int-length> <optional-any-val>)
usage: "pads" list with items up to length, if not val, pad with nils

Function: parseint

syntax: (parseint "abc123.txt") => 123
return: First embedded integer or nil

Function: pass

(pass) Simply do nothing. Good for readability

Function: path-add

(path-add <str-path> <str-added>)
Extend a path resolving beginning and ending forward slashes

Function: path-chop

    syntax: (path-chop <str-path>). Remove last segment of a path
    example:
    (chop-path "/one/two/three") => "/one/two"

Function: putb

    syntax: (putb "onemorething" "more") => "one" and returns "thing"
    <str> String to print
    <break-point> Substring to print _TO_
    Return If break-point is found, substring following or nil

Function: pwd

syntax: (pwd) => get the current directory

Function: rm

syntax: (rm filename) => delete <str filename> unix only
Delete the file

Function: rtrims

    (rtrims "onething" "thing") => "one"
    returns first argument with second arg removed from end
    (rtrims "one ") => "one"
    Returns argument trimmed of whitespaces from end

Function: rtrims

    (rtrims "onething" "thing") => "one"
    returns first argument with second arg removed from end
    (rtrims "one ") => "one"
    Returns argument trimmed of whitespaces from end

Function: second

(second (1 2)) => 2
Return second element

Function: srand

    syntax: (srand 8 "abcdefghijklmnopqrstuvwxyz") => string of 8 random chars
    First argument <number> Length of random string
    Second argument <chars> Optional. Source string, default is alpha string of upper and lower case chars
    return: Random string of length num

Function: third

(third (1 2 3)) => 3
Return 3rd element

Function: trim-thru

    syntax: (trim-thru target src)
    arguments: <str-target> substring to find <str-src> source string
    If target found, substring following target, else original string
    example::
    (trim-thru "@" "tim@johnsons-web.com") => "johnsons-web.com"

Function: type