Differences

This shows you the differences between two versions of the page.

@@ Line 1: / Line 1: @@
+<code>
+-------------------------------------------------------------------------------
+    MPL Functions, Variables, Constants, Records and more
+-------------------------------------------------------------------------------
+  INDEX
+. Date Functions
+. String Manipulation
+. Theme Related
+. Screen Manipulation
+-------------------------------------------------------------------------------
+. Date Functions
+-------------------------------------------------------------------------------
+  Function TIMESTR (DT: LongInt, Mode: Byte)
+         This function converts a packed datetime number into a time
+         string.  The passed mode variable defines the format of the time
+         string returned.  Valid options are:
+= 24 hour format: HH:MM:SS
+= 12 hour format: HH:MMa or HH:MMp
+         Example:
+         WriteLn ('The current time is: ', TimeStr(DateTime, 1))
+         The above example outputs the current time to the screen using the
+         TIMESTR and DATETIME functions.
+  Function DATETIME : LongInt
+         This function returns the current Date and Time in the packed
+         format.  DATESTR and TIMESTR can be used to convert this value
+         into strings.
+         Example:
+         WriteLn ('Current Date: ', DateStr(DateTime), 0)
+         WriteLn ('Current Time: ', TimeStr(DateTime), 1)
+         The above example outputs the current date and time to the screen
+         using the DATESTR and TIMESTR functions.  The DateTime function
+         which is passed to DATESTR and TIMESTR, contains the current date
+         and time in the packed format.
+  Function DATE2DOS (Str : String) : LongInt
+        This function takes a MM/DD/YY format date and converts it to DOS
+        packed datetime format.
+  Function DATE2JULIAN (Str : String) : LongInt
+        This function takes a MM/DD/YY format date and converts it to a Julian
+        date format.
+  Function DATEG2J (Str : String) : LongInt
+        This function takes a gregorian date format (MMDDYY) and converts it to
+        a Julian format
+  Function DATEJ2G (LI : LongInt) : String
+        This function takes a julian date format and converts it to a gregorian
+        format (MMDDYY).
+  Function DateValid(S: String) : Boolean
+        Takes a MM/DD/YY date and returns true or false depending on if the
+        date is valid (ie, month is 01-12, etc).
+  DateJulian:LongInt;
+        Returns the longint Julian value of the current date.
+  Function DATESTR (DT: LongInt, dType: Byte)
+         This function will take a packed datetime number and convert it to
+         a date string.  The dType parameter is used to set the format of the
+         date which is returned.  Valid types are:
+= Returns date in format: MM/DD/YY
+= Returns date in format: DD/MM/YY
+= Returns date in format: YY/DD/MM
+         Example:
+         GetThisUser
+         WriteLn ('Welcome.  You last called on ', DateStr(UserLast))
+         The above example loads the currently logged in user's information
+         into the USER variables using GETTHISUSER, then displays the last
+         time the user has called to the screen using the DATESTR procedure.
+          No longer accepts 0 as the users current date format.  Pass the
+          user's actual date format to it if you want that.  For example:
+          Str := DateStr(MyDateTime, UserDateType);
+         The other parameters (ie 1 = MM/DD/YY) work as they used to.
+  Function DateStrJulian(DT: LongInt, dType: Byte)
+        Works just like DateStr but accepts a Julian date.
+  Function DayOfWeek:Byte;
+        Returns a number between 0-6 depending on the day of the week:
+= Sun, 1 = Mon, 2 = Tue, 3 = Wed, 4 = Thu, 5 = Fri, 6 = Sat
+  Function DaysAgo(J:LongInt) : LongInt
+        This function takes a Julian date value and returns the number of days
+        between the current date and the passed date.
+  Function TIMER : LongInt
+         This function will return the current number of seconds which have
+         passed since midnight.  This function can be used to time how long
+         a user is doing something.
+         Example:
+         Var StartTime LongInt
+         Var EndTime   LongInt
+         Var Total     LongInt
+         Var Str       String
+         StartTime := Timer
+         Write ('Enter something: ')
+         Str := Input (40, 11, 'Nothing')
+         EndTime := Timer
+         Total := EndTime - StartTime
+         WriteLn ('You took ', Total, ' seconds to type something!')
+         The above example will prompt the user to type something and time
+         how long in seconds they took.  WriteLn will then display the
+         number of seconds the user took to the screen.
+  Function TimerMS : LongInt
+        This may or may not stay but it provides a way to do millsecond timing
+        of things.
+  Function TimerMin : LongInt
+        Same as TimerMS, but gives time in Minutes
+  Procedure FormatDate(dosDate, mask) : String;
+        Allows you to convert a DOS format date to a string using the mask:
+            YYYY - 4 digit year
+              YY - 2 digit year
+              MM - 2 digit month
+             DDD - 3 char weekday (ie Mon Tue)
+              DD - 2 digit day
+              HH - 2 digit hour
+              II - 2 digit minute
+              SS - 2 digit second
+             NNN - 3 char month (ie Jan, Feb, Mar)
+  Function datedos2str(D:Longint; T:Byte) : String
+= MM/DD/YYYY
+= DD/MM/YYYY
+= YYYY/MM/DD
+  Function datejulian2str(D:Longint; T:Byte) : String
+= MM/DD/YYYY
+= DD/MM/YYYY
+= YYYY/MM/DD
+. String Manipulation
+-------------------------------------------------------------------------------
+  Function POS (Sub: String, S: String) : Byte
+         This function returns the starting position of a substring in a
+         string.
+         Example:
+         Var A Byte
+         A := POS('World', 'Hello World')
+         WriteLn (A)
+         The above example would output "7" to the screen becase POS
+         returns the position of the text "World" in the string
+         "Hello World".  If POS does not find a match, a zero will be
+         returned.  IE: A := POS('Blah', 'Hello World') would return a zero
+         because the text "Blah" was not found in the string "Hello World".
+  Function CHR (B: Byte) : Char
+         This function will take a numerical byte value and return it's
+         ASCII character.  The byte value must be between 0 and 255 as
+         there are only 255 characters in the ASCII character set.
+         Example:
+         WriteLn ('Hello', Chr(32), 'World')
+         This will output the text "Hello World" to the screen.  The ASCII
+         number for the space character is 32 and by passing a 32 to CHR,
+         a space is returned.
+  Function COPY (S: String, Index: Byte, Count: Byte) : String;
+         This function will copy a defined part of a string and return
+         the copied portion as a string.
+         Example:
+         Var Str String
+         Str := 'Hello World'
+         WriteLn (Copy(Str, 1, 5))
+         This will output "Hello" to the screen.  The copy function takes
+         the given Str and copies Count number of character from the Index.
+         So the above copies 5 characters starting at the 1st character in
+         Str and WriteLn outputs it to the screen.
+  Procedure DELETE (S: String, Index: Byte, Count: Byte)
+         This procedure will delete a defined portion of a string
+         variable.
+         Example:
+         Var Str String
+         Str := 'Hello World'
+         Delete (Str, 6, 6);
+         WriteLn (Str)
+         This example will delete 6 characters from the string Str starting
+         at the 6th character.  The resulting output from WriteLn will be
+         "Hello"
+  Procedure INSERT (Source: String, Target: String, Index: Byte)
+         This procedure will insert text into a string at a specified
+         location.
+         Example:
+         Var Str String
+         Str := 'Mystic v1.00'
+         Insert ('BBS ', Str, 8)
+         WriteLn (Str)
+         The above example will insert the text "BBS" into the Str variable
+         starting at the 8th character in the string.  The result WriteLn
+         output would be "Mystic BBS v1.00"
+  Function INT2STR (L: LongInt) : String
+         This function converts a numerical type variable to a string
+         type variable.
+         Example:
+         Var A Byte
+         Var S String
+         A := 255
+         S := Int2Str(A)
+         WriteLn (S)
+         The above example sets the numerical variable to the value of
+, which is then converted to a string variable using Int2Str.
+         The resulting value of S will be '255' as WriteLn will output to
+         the screen.
+  Function LENGTH (S: String) : Byte
+         This function returns the length in characters of the passed
+         string variable.
+         Example:
+         WriteLn (Length('Hello World'))
+         The above example would output "11" to the screen, which is the
+         number of characters in the text passed to Length.
+  Function LOWER (S: String) : String
+         This function converts a passed string variable to all lower
+         case letters.
+         Example:
+         WriteLn (Lower('HELLO'))
+         The above statement would output the text "hello" to the screen.
+         The original text of HELLO is converted to all lower case letters
+         and than displayed by WriteLn.
+  Function ORD (C: Char) : Byte
+         This function returns the ASCII code of the passed Char variable.
+         This function works the exact opposite of the CHR function.
+         Example:
+         WriteLn (Ord(' '))
+         The above example would output the text "32" to the screen because
+is the ASCII character code for space.
+  Function INITIALS (String) : String
+        This function takes a user name and attempts to return one or two
+        character  initials.
+            S := Initials('Jack Phlash'); // should return "JP"
+  Function INPUT (Field: Byte, Max: Byte, Mode: Byte, Default: string) : String
+        This function gives input to the user, and returns the result of
+        the input as a string variable.
+         The Field parameter is the size of the input field (in characters)
+         that the user will be able to see.  If the field size is smaller
+         than the maximum number of characters allowed in the input, the
+         input line will scroll when the user reaches the end.  This field
+         is usually set to the same as the Max parameter.
+         The Max parameter is the maximum number of characters that
+         Input will allow to be entered.  Note that the Field parameter, in
+         most cases, should be set to the same value as this.
+         The Mode parameter is the type of input that will be accepted, and
+         can be any one of the following input types:
+: Standard input.  All characters allowed.
+: Upper case input.  Allows all characters, but will convert
+                  any lower case letters into upper case.
+: Proper input.  Allows all characters, but will convert
+                  the first letter in each word to an upper case letter.
+: Phone input.  Allows only numbers and will pre-format them
+                  using the USA-style phone numbers.  IE: XXX-XXX-XXXX.
+                  Note that the length of this input should always be 12,
+                  as that is the length of the USA phone number format.
+: Date input.  Allows only numbers and will pre-format them
+                  using the date format (ie XX/XX/XX) that is currently
+                  selected by the user.  NOTE: The date input will always
+                  return the date in the MM/DD/YY format, regardless of what
+                  format the user has selected.  For example, if the user
+                  has selected the DD/MM/YY format, Input will expect the
+                  user to enter the date in that format, but will then
+                  convert it to MM/DD/YY when it returns the date back to
+                  the MPE program.
+: Password input.  Allows all characters, but will convert
+                  any lower case letters into upper case.  The character
+                  that is typed is NOT echoed to the screen.  Instead, it
+                  is replaced by the * character so that what they have
+                  entered will not be shown on the screen.
+         NOTE: If any of the above input values are increased by 10, Input
+         will create an input field using the foreground/background color
+         that has been defined for that language.  For example, input type
+will function the same as input type 1, but will fill an input
+         field to the maximum field length.
+         The Default parameter can be used to force a default text into
+         the input field.  If you do not wish to have any default text in
+         the buffer, supply a blank string parameter (ie '').
+         EXAMPLE:
+         Var Str String
+         Write ('Enter something: ')
+         Str := Input (30, 30, 1, '')
+         The above example will print the text "Enter something: " to the
+         screen and the allow input of up to 30 characters in length, using
+         input type 1 (allows all characters).  No default text has been
+         supplied so the input field will be empty by default.
+         Var Str String
+         Write ('Enter something: ')
+         Str := Input (30, 30, 11, 'Default')
+         The above example will function just like the first example, except
+         it will create an input field background and stuff the text of
+         "Default" into the input field.
+  Function INPUTNY (Text: String) : Boolean
+         This function prompts the user with a Yes/No question, defaulting
+         to No. TRUE will be returned if the user answered Yes, or FALSE if
+         the user answered No.  The passed Text variable is the text that is
+         displayed to the user asking the question.
+         Example:
+         If Not InputNY('Do you want to run this program? ')
+              Halt
+         The above example will prompt the user with the Yes/No question
+         passed as <Text>.  This question will default to No.  If the user
+         answers No, the program will halt from being executed.
+  Function INPUTYN (Text: String) : Boolean
+         This function prompts the user with a Yes/No question, defaulting
+         to Yes.  TRUE will be returned if the user answered Yes, or FALSE
+         if the user answered No.  The passed Text variable is the text
+         that is displayed to the user asking the question.
+         Example:
+         If Not InputYN('Do you want to run this program? ')
+              Halt
+         The above example will prompt the user with a Yes/No question,
+         asking "Do you want to run this program?".  If the user responds
+         No, the program will not run, using the Halt command.
+  Function ISARROW : Boolean
+         This function is used along with the READKEY function.  After
+         READKEY is called, this function can be checked to process various
+         extended keys, such as arrow keys.  When ISARROW is true, READKEY
+         will return the following:
+         ASCII #     Char     Key Pressed
+         -------     ----     -----------
+          G        Home
+          H        Up Arrow
+          I        Page Up
+          K        Left Arrow
+          M        Right Arrow
+          O        End
+          P        Down Arrow
+          Q        Page Down
+          S        Delete
+         The character returned by READKEY can be checked by either the
+         ASCII # or the actual character.  Below is an example:
+         Example:
+         Var Ch Char
+         Ch := ReadKey                 # Input one key
+         If IsArrow                    # Is key returned an arrow key?
+           If Ch = 'H'
+             WriteLn ('Up arrow')
+           Else If Ch = Chr(80)
+             WriteLn ('Down arrow')
+         Else                          # No arrow key.  A normal character
+           WriteLn ('You entered character: ', Ch)
+         End
+         The above example reads a key with READKEY and then uses the
+         ISARROW function to process the Up Arrow and Down Arrow keys.
+  Function StrMci(Str:String) : String;   [mci2str also works]
+        StrMci takes an entire string and attempts to translate any MCI codes
+        found in it, returning the entire result. Ex:
+            S := StrMci('Hello |UH');
+  Function PADCT (S: String, N: Byte, C: Char) : String
+         This function pads a string to the center with the specified
+         character.
+         Example:
+         Var Str String
+         Str := PadCT('Hello World', 80, ' ')
+         WriteLn (Str)
+         The above example would display the text "Hello World" centered on
+         the screen.  The PadCT function returns the text "Hello World"
+         centered in 80 spaces with the character of " " used to fill the
+         blank spaces.
+  Function PADLT (S: String, N: Byte, C: Char) : String
+         This function returns a text string padded with spaces to the
+         left side.
+         Example:
+         Var Str String
+         Str := PadLT('Hello World', 79, ' ')
+         The above example would return a string which is 79 characters in
+         length with the text "Hello World" as the leftmost part of the
+         string.  The passed character is the character that is used to
+         fill the blank spaces.
+  Function PADRT (S: String, N: Byte, C: Char) : String
+         This function returns a text string padded with spaces to the
+         right side.
+         Example:
+         Var Str String
+         Str := PadRT('Hello World', 79, ' ')
+         The above example would return a string which is 79 characters in
+         length with the text "Hello World" being the rightmost part of the
+         string.  The empty spaces are filled with the passed charcter (in
+         this case ' ').
+  Function STR2INT (S: String) : LongInt
+         This function converts a passed string variable to a numerical
+         variable.  The passed string variable must contain a valid number.
+         Example:
+         Var A Byte
+         Var S String
+         S := '100'
+         A := Str2Int(S)
+         WriteLn (S)
+         WriteLn (A)
+         The above example will output "100" twice the screen.  The
+         variable S is assigned to '100' and the function Str2Int converts
+         the string into a numerical value which is assigned to variable
+         A.
+  Function STRIPMCI (S : String) : String
+         This function will strip the passed string variable of all MCI
+         codes and return the "cleaned" version.
+         Example
+         Var S String
+         S := '|10|H|02ello |10W|02orld|07'
+         WriteLn ('Normal   : ', S)
+         WriteLn ('Stripped : ', StripMCI(S))
+         The above example assigns a string with MCI codes in it to the S
+         variable.  It then writes the original string and the stripped
+         string to the screen, so the difference is shown.
+  Function STRREP (Ch: Char, Num: Byte) : String
+         This function returns a string filled with character <CH> to the
+         length of <NUM>.
+         Example:
+         WriteLn (strRep('-', 60 ))
+         The above example will use strRep to create a string 60 characters
+         long of the character '-', then write it to the screen.  So the
+         outputted text would look like:
+         "------------------------------------------------------------"
+  Function UPPER (S: String) : String
+         This function coverts the passed string variable to all upper
+         case letters.
+         Example:
+         WriteLn (Upper('hello'))
+         The above example would output the text "HELLO" to the screen.
+         The UPPER function converts the passed text of "hello" to all
+         upper cased letters, which is then printed to the screen by
+         WriteLn.
+  Function StrComma(L:LongInt) : String;
+        Accepts a longint and returns it as a string, with commas added where
+        applicable: Ex:
+            WriteLn (strComma(1000000));  // will print 1,000,000
+  Function StripL(Str1,Str2:String) : String;
+        Strips the left side of a string of any specified leading characters. Ex:
+            Var S : String = '    Hello';
+            S := StripL(S, ' ');
+  Function StripR(Str1,Str2:String) : String;
+        Strips the right side of a string of any specifcied trailing character:
+            Var S : String = 'Hello     ';
+            S := StripR(S, ' ');
+  Function StripB(Str1,Str2:String) : String;
+        Strips both sides of the string if a specific character.
+            Var S : String = '     Hello     ';
+            S := StripB(S, ' ');
+  Function StripLow(S: String) : String
+        Strips all chracters from a string that are less than ascii code #32. Ex:
+            Var S : String = #12#12#12#12 + 'Hello';
+            S := StripLow(S);
+  Function stripmci(S:String) : String
+        Returns a string without any MCI codes if included in the string.
+  Function StripPipe(Str:String) : String
+      Takes a string and strips only pipe color codes from it. Ex:
+          S := StripPipe('|15Hello there, |UH');  //returns "Hello There, |UH"
+  Function MCILength(Str:String) : Byte;
+        Works just like "Length" except it tries to ignore MCI codes.  It doesn't
+        check for actual validity of MCI codes. Ex:
+            Var B : Byte;
+            B := MCILength('|15Hello|UH');
+            WriteLn ('Length should be 5: ' + Int2Str(B));
+  Function Initials(Str:String) : String
+        Takes a user name and attempts to return one or two character initials. Ex:
+            S := Initials('Jack Phlash'); // should return "JP"
+  Function StrWrap(S:String; S2:String; Pos:Byte) : String;
+        strWrap takes two strings and wraps them after the word closest to the
+        maximum supplied length.  It optionally returns the actual position where it
+        wrapped. Ex:
+            Var Str   : String = 'This will wrap';
+            Var Str2  : String = '';
+            Var Where : Byte;
+            Where := strWrap(Str, Str2, 10);
+            WriteLn ('It wrapped at ' + Int2Str(Where));
+            WriteLn ('First string: ' + Str);
+            WriteLn ('Second string: ' + Str2);
+  Function Replace(S:String; Find:String; Rep:String):String;
+        Replace replaces all occurances of a supplied text and returns a
+        string.  Ex:
+            Var Str : String = 'Hello Hello Hello';
+            Str := Replace(Str, 'Hello', 'World');  // Str is now World World
+                                                    // World
+  Function WordCount(S: String; C:Char):Integer;
+        Returns the number of words in a string using the final parameter to
+        define the character that determines what separates words.  Ex:
+            Str := 'Hello this is a test';
+            WriteLn ('Str has ' + Int2Str(WordCount(Str, ' ')) +
+            ' words in it.');
+  Function WordGet(P:Byte; S:String; C:Char):String;
+        Returns the actual word at a specific word count. Ex:
+            Str := 'Hello this is a test';
+            WriteLn('The second word was: ' + WordGet(2, Str, ' '));
+  Function WordPos((P:Byte; S:String; C:Char):Integer;
+        WordPos returns the character position in the string where s specific
+        word is located.  Ex:
+            Str := 'Hello this is a test';
+            WriteLn ('Second word is at: ' + Int2Str(WordPos(2, Str, ' ')));
+  Function Real2Str(R:Real; D:Byte) : String;
+        This takes a string and decimal place value.  Example:
+            Var
+              R : Real;
+            Begin
+              R := 1234.1234;
+              WriteLn (Real2Str(R, 2));  // Will print 1234.12
+            End
+. Theme Related
+-------------------------------------------------------------------------------
+  Function GETPROMPT (N : Word) : String
+         This function will return a prompt from the current user's language
+         file.  The passed N varliable is the prompt number to return.
+         Example:
+         WriteLn(GetPrompt(1))
+         The above example writes prompt #1 from the user's currently
+         selected language file to the screen.
+  Procedure SetPromptInfo(D:Byte; S:String);
+        This allows you to set Mystic's internal "changing" PromptInfo MCI codes
+        (the |&X codes).  For example:
+            SetPromptInfo(1, 'Hello!');
+            WriteLn ('This MCI code would like to say: |&1');
+. Screen Manipulation
+-------------------------------------------------------------------------------
+  Variables
+  =========
+  allowarrow  : boolean
+          Undocumented
+  textattr    :   Byte
+          Returns the text attribute (color) of the screen.
+  AllowMci        boolean
+          Toggles on/off MCI code parsing. This is used outside of MPL so
+          adjust this with caution.
+  Functions
+  =========
+  Function GRAPHICS : Byte
+         This function returns the user's current graphics mode in
+         numerical format:
+= ASCII graphics mode
+= ANSI graphics mode
+         Example:
+         If Graphics = 1
+              WriteLn ('ANSI graphics')
+         Else
+              WriteLn ('ASCII graphics')
+         EndIf
+         The above example will print the user's current graphics mode
+         to the screen.  If the user has ANSI (graphics mode 1), "ANSI
+         graphics" will be printed.  If the user does not have ANSI
+         (graphics mode 0), "ASCII graphics" will be printed to the screen.
+  Function PausePos : Byte
+        Gives access to Mystic's internal line counter used for screen pauses.
+  Procedure MOVEX (Pos : Byte)
+				 This procedure is used to move the cursor to the passed X coordinate
+				 on the screen.  It only works if the user has ANSI graphics enabled.
+				 Example:
+				 MoveX (20)
+				 WriteLn ('This text starts on the 20th space')
+  Procedure MOVEY (Pos : Byte)
+				 This procedure is used to move the cursor to the passed Y coordinate
+				 on the screen.  It only works if the user has ANSI graphics enabled.
+				 Example:
+				 MoveY (10)
+				 WriteLn ('This is on the 10th line of the screen')
+  Procedure GetScreenInfo(1, X, Y, Attr);
+        This allows you to read Mystic's internal ScreenInfo codes, used in
+        Templates so your MPLs can easily have templates just like Mystic!
+        These are the |!X codes. Example:
+           Var
+             X, Y, Attr : Byte;
+           Begin
+             GetScreenInfo(1, X, Y, Attr);
+             WriteLn('The value of the !1 MCI code was:');
+             WriteLn('   X: ' + Int2Str(X));
+             WriteLn('   Y: ' + Int2Str(Y));
+             WriteLn('Attr: ' + Int2Str(Attr));
+           End;
+  Function GetCharXY(X,Y;Byte) : Char;
+          Returns the character located on the user's screen at the XY
+          location. Ex:
+              Var Ch : Char;
+              Ch := GetCharXY(1, 1);
+              WriteLn('The user has the following character at 1,1: ' + Ch);
+  Function GetAttrXY(X,Y;Byte) : Byte;
+        Returns the attribute of the character at position XY on the user's
+        screen:
+            Var Attr : Byte;
+            Attr := GetAttrXY(1, 1);
+            WriteLn ('The attribure of the character at 1,1 is: ' +
+            strI2S(Attr));
+  Procedure GotoXY (X: Byte, Y:Byte)
+        This procedure will move the cursor to a specified X and Y position on
+        the screen. This only works for users who have ANSI graphics
+  Procedure WritePipe(S: String);
+        Works just like Write but only parses Pipe color codes instead of all
+        MCI codes.
+  Procedure WritePipeLn(S: String);
+        Is WritePipe with a CRLF at the end.
+  Procedure WriteRaw(S: String);
+        Works just like write except it does not parse any pipe color codes OR
+        MCI codes.
+  WriteRawLn(S: String);
+  Works just like WriteRaw except with a CRLF added to the end.
+  WriteXY(X,Y,At:Byte; Str:String);
+  Writes a string of text at the defined X/Y location with a specific text
+  attribute.  This of course requires the user has ANSI to function properly.
+      WriteXY (1, 10, 8, 'Prints at X:1 Y:10 with dark grey text');
+  WriteXYPipe(X,Y,At,F:Byte; Str:String);
+  This procedure writes a string of text at the defined location, similar to
+  WriteXY *except* it parses pipe color codes *and* requires a "maximum field
+  size" of which it will always extend or restrict the length of the text
+  within that field. Ex:
+        WriteXYPipe (1, 10, 8, 50, 'This pads to 50 chars at location 1,10');
+  Procedure WRITE (Text)
+         This procedure is used to write text to the screen without
+         going to the next line (ie, without sending a carriage return).
+         All text to be printed to the screen should be enclosed inside of
+         ' characters.  If you wish to print the value of a variable to
+         the screen, just include the variable name without the '
+         characters.  If you wish to combine multiple text and variables,
+         they must be separated by commas.
+         Examples:
+         Write ('Hello ')
+         Write ('World')
+         This example will write the text "Hello World" to the screen.
+         Write ('Hello World')
+         This example does the exact same thing as the function above, but
+         makes a little more sense.
+         Var Str String
+         Str := 'Hello World'
+         Write (Str)
+         This example will write the value held in the variable Str to the
+         screen.  The resulting output will be "Hello World"
+         Var Str String
+         Str := 'Hello '
+         Write (Str, 'World')
+         This example will write the value of the variable Str to the
+         screen, followed by the text "World".  The resulting output will
+         be "Hello World".  An unlimited number of variables and text can
+         be outputted with the Write statement, but they must all be
+         separated by a comma, as shown above.
+         If a ' character needs to be printed to the screen, it can be done
+         by doubling the ' character.  For example:
+         Write ('This is how it''s done.')
+         The resulting screen output will be "This is how it's done", with
+         only one ' character.
+         All MCI display codes can be used within the Write statement.  If
+         you wish to change the display colors, use the MCI color system to
+         do so.  For example:
+         Write ('~14Hello World')
+         This example will write the text Hello World in yellow to the
+         screen.  All MCI display codes are available to the write
+         statement.
+    Procedure WRITELN (Text)
+         This procedure outputs text to the screen.  It functioning is
+         identical to the WRITE statement except that it goes to the next
+         line after the text is printed (ie, it sends a carriage return).
+         For example:
+         WriteLn ('Hello')
+         WriteLn ('World')
+         The above example will write the text "Hello" on one line, and
+         then the text of "World" on the next line.
+  clrscr           none         none
+  clreol           none         none
+  Function WHEREX : Byte
+         This function returns the current X coordinate of the cursor.
+         Example:
+         Var X Byte
+         Var Y Byte
+         X := WhereX
+         Y := WhereY
+         WriteLn ('      World')
+         GotoXY  (X, Y)
+         WriteLn ('Hello')
+         The above example will save the current X and Y cursor positions
+         and then write the text "World" to the screen.  After which, it
+         will return to the saved X and Y position and write the text
+         "Hello" to the screen.  The end result will be the text of
+         "Hello World" written to the screen.  Note: GotoXY can only be
+         used if the user has ANSI graphics mode.
+    Function WHEREY : Byte
+         This function returns the current Y coordinate of the cursor.
+         For more information on this function, please see the definition
+         of the WHEREX function.
+  Procedure DISPFILE (FN: String)
+         This procedure displays a text or ANSI file to the screen.  If a
+         path not included in the passed filename, Mystic will look for
+         the file in the language text file directory.  If no file
+         extension is provided in the passed file name, Mystic will display
+         the correct file according to the user's graphics settings
+         (ie .ANS for ANSI, .ASC for non-ansi).
+         Example:
+         DispFile ('WELCOME')
+         The above example will display the text file "WELCOME" from the
+         language text file directory.  Since there is no file extension
+         provided, Mystic will display "WELCOME.ANS" or "WELCOME.ASC"
+         depending on what the user's terminal settings are.
+  disptemplate     s            None
+  outbs            bo           None
+  textcolor        bo           None
+  outpipe          s            None
+  outpipeln        s            None
+  outraw           s            None
+  outrawln         s            None
+  bufaddstr        s            None
+  BufFlush;
+  This causes Mystic to immediately send whatever is in the output buffer to
+  the client.
+Program related
+---------------
+  Variables
+  PathChar : String;
+  Returns the Path character used, according to the system. For Linux is / and
+  for Windows is \.
+  ProgParams : String
+  Returns any of the parameters passed to the MPL program as a single string.
+  ProgName : String;
+  Returns the path and filename of the current MPL program.
+  Procedures/Functions
+  Procedure HALT
+  This procedure will exit the program and return the user back to the BBS
+  immediately.
+  Procedure DELAY (MS: Word)
+         This procedure will delay for a specified number of milliseconds.
+         Example:
+         DELAY (1000)
+         The above example will delay the program for one second.
+  Function RANDOM (Max: Word) : Word
+         This function will return a random number within the range
+         specified.
+         Example:
+         Var A Byte
+         A := Random(255)
+         WriteLn (A)
+         The above example will generate a random number within the range
+         of 0 to 255 in the variable A and then print it to the screen.
+  randomize        none         none
+  Function PARAMCOUNT : Byte
+         This function is used to determine the number of command line
+         options which have been passed to the MPE program.  For more
+         information, see the PARAMSTR function.
+         Example:
+         If ParamCount < 2
+              WriteLn ('Invalid command line.')
+              Halt
+         EndIf
+         The above example will check to see if less than 2 command line
+         options have been passed to the MPE program.  If there are less
+         than two, the program will terminal with a "invalid command line"
+         message.
+    Function PARAMSTR (Number : Byte) : String
+         This function returns the command line option specified by the
+         NUMBER parameter.  A command line is the optional data which
+         is passed on the "Data" field of a menu command.  For example,
+         when defining a menu command which executes an MPE program in
+         the menu editor, the text after the program name becomes command
+         line options.
+         Menu Command: GX
+         Data        : BULLETIN p1 p2 p3 p4
+         If the above was defined in the menu editor, the following would
+         be true:
+         ParamCount  would return 4
+         ParanStr(0) would return "BULLETIN"
+         ParamStr(1) would return "p1"
+         ParamStr(2) would return "p2"
+         ParamStr(3) would return "p3"
+         ParamStr(4) would return "p4"
+         Note that ParamStr(0) will ALWAYS return the file name of the
+         MPE program being executed.  Even when there are no other
+         parameters defined.
+  IgnoreGroups    boolean
+  Is used to cause all group ACS evaluations to return true even if they are
+  not in the group.  This is also used outside of MPL so change it with caution.
+  shutdown        boolean
+  Procedure SYSOPLOG (S: String)
+         This procedure will add a line into the sysop log file found in
+         the logs directory.
+         Example:
+         SysopLog ('User ran this program.')
+         The above example will write the text "User ran this program" in
+         the system log file, using the same format as Mystic uses in the
+         log files (ie, the date and time will automatically be added).
+  Procedure HANGUP
+         This procedure will stop the program immediately, hangup up on the
+         user, and return Mystic BBS to the waiting for caller screen.
+         Example:
+         If InputYN ('Do you want to hangup now? ')
+              HangUp
+         EndIf
+         The above example will prompt the user with a Yes/No question
+         asking "Do you want to hangup now?" and if the user responds
+         "Yes", they will be logged off the BBS using the HangUp command.
+  Procedure MENUCMD (CM: String, Data: String)
+         This procedure will allow menu commands to be ran from within a
+         program.  <CM> is the menu command, and <DATA> is the menu command
+         data.
+         Example:
+         MenuCmd ('NW', '')
+         The above example will run the menu command "NW" with the optional
+         data field set to nothing.  This example will display the Who's
+         Online list.  See MYSTIC.DOC for a list of all available menu
+         commands.
+    Function NODENUM : Byte
+         This function returns the current node number which the program
+         is being ran on.
+         Example:
+         WriteLn ('Welcome to node number ', NodeNum)
+         The above example will print the text "welcome to node number x"
+         to the screen, where the x will be the current node number which
+         the program is being ran on.
+  Function LOCAL : Boolean
+         This function returns TRUE if the user is logged into the BBS
+         system locally.  It will return FALSE if the user is connected
+         via a remote location.
+         Example:
+         If Local Then
+           WriteLn ('Local caller detected.')
+         Else
+           WriteLn ('Remote caller detected.')
+         EndIf
+Keyboard Related
+----------------
+  Variables
+  =========
+  isarrow         boolean
+  Procedures
+  ==========
+  Function READKEY : Char
+         This function will read a key from the buffer and return it as
+         a char variable.  If there are no keys in the buffer, readkey will
+         wait for a key to be pressed.
+         Example:
+         Var Ch Char
+         Repeat Until KeyPressed
+         Ch := ReadKey
+         WriteLn ('You entered: ', Ch)
+         The above example will wait for a key to be pressed by using the
+         KEYPRESSED function.  Afterwards, the key will be read into the
+         CH variable using readkey, and then print it to the screen.
+  getkey           l            String
+  getyn            so           boolean
+  getstr           bbhs         String
+  pause            none         None
+  more             none         String
+  onekey           so           String
+  Procedure STUFFKEY (S : String)
+         This function will stuff a string of text into the keyboard
+         buffer.  This can be used to force your program into thinking
+         the user had actually typed "S".
+         Example:
+         Var Ch Char
+         StuffKey ('A')
+         Ch := ReadKey
+         WriteLn ('You entered: ', Ch)
+         The above example will stuff the character "A" into the input
+         buffer, where it will be read into Ch using the ReadKey function.
+         It is possible to stuff entire strings of text into the buffer
+         too.
+         Example:
+         Var Str String
+         StuffKey 'Hello World'
+         Str := Input (20, 20, 1, '')
+         The above example will stuff "Hello World" into the input buffer.
+         This will cause the input function to think the user has actually
+         typed in "Hello World".  In this case, the above is the same as
+         supplying "Hello World" in the <DEFAULT> field of the Input
+         function.
+  Function KEYPRESSED : Boolean
+         This function returns TRUE if a key has been pressed either
+         remotely or locally.  Keep in mind two things about this
+         function:
+              (1) It doesn't check for inactivity timeout.  If you are
+                  using this function to wait for a key to be pressed then
+                  you may want to use the TIMER function and check for
+                  inactivity.
+              (2) This function only returns whether a key was PRESSED.
+                  It does not actually read the key out of the buffer.
+                  See the READKEY function for reading keys from the
+                  buffer.
+         Example:
+         Repeat
+         Until KeyPressed
+         WriteLn ('You pressed a key!')
+         The above example will wait for a key to be pressed and then
+         write to the screen "You pressed a key!".
+  PurgeInput;
+  This will clear out any local or remote input data.
+  OneKeyRange
+  This function works similar to OneKey, except that it will also allow for a
+  number input within a certain range.  The number value is stored in a
+  variable called RangeValue and the function returns a #0 if a number was
+  entered.  For example:
+       Var
+         Ch : Char;
+       Begin
+         Write ('Enter letters A-G or a number between 1-50: ');
+         Ch := OneKeyRange('ABCDEFG', 1, 50);
+         If Ch = #0 Then
+           WriteLn ('You entered a number: ' + Int2Str(RangeValue))
+         Else
+           WriteLn ('You entered character: ' + Ch);
+       End.
+  MorePrompt;
+  Displays the system more prompt and returns a Char value of either Y N or C
+  depending on what the user selected.
+  Pause;
+  Displays the system pause prompt, for those that don't like doing a
+  "Write('|PA')".
+File I/O
+--------
+  Variables
+  ioresult        LongInt
+  The result of the last call is now stored in the "IoResult" variable.  Ex:
+      fAssign (MyFile, 'myfile.txt' 66);
+      fReset  (MyFile);
+      If IoResult <> 0 Then
+        WriteLn('Unable to open file!');
+  DIRECTORY READING VARS (FOR FINDFIRST/NEXT/CLOSE):
+  doserror        Integer
+  dirname         String
+  dirsize         LongInt
+  dirtime         LongInt
+  dirattr         Byte
+  Procedures
+  ==========
+  Function fEOF (Handle) : Boolean
+         This function will return true if the file position of an opened
+         file is at the End Of the File (EOF).  The passed Handle value is
+         the file number of the already opened file.
+         Example:
+         Var Str String
+         FOpen (1, Text, Reset, 'BLAH.TXT')
+         While Not fEOF(1)
+              FReadLn (1, Str)
+              WriteLn (Str)
+         End
+         FClose (1)
+         The above example will open a text file under the filename of
+         BLAH.TXT.  The WHILE loop is used to repeat the code until the
+         EOF (end of file) is reached.  The FCLOSE statement will close
+         the file after it is done being accessed.
+         The result of the above example will be (in pseudocode):
+. Open text file.
+. If not at the end of file, run this code:
+. Read line from text file into string variable
+. Print line read from text file to the screen.
+. Goto 2.
+. Close the text file.
+         So the above example will basically write the entire text file to
+         the screen.
+  SizeOf(Var) : Integer;
+  Returns the size of a variable or record type
+  FillChar(Var; Size:Integer; C:Char);
+  Fills a variable/record with a specific character. Ex:
+       type
+         myuserrecord = record
+           username  : string[30];
+           somevalue : array[1..5] of byte;
+         end;
+       var
+         u : myuserrecord;
+       begin
+         fillchar(u, sizeof(u), #0);
+       end.
+  Function FileExist (FileName: String) : Boolean
+         The above function will check to see if a file exists, and return
+         TRUE if it does.  The passed FileName string if the path and file
+         name of the file to check.  This file should not already be opened
+         with the FOPEN procedure.
+         Example:
+         If FileExist('BLAH.TXT')
+              WriteLn ('BLAH.TXT exists.')
+         Else
+              WriteLn ('BLAH.TXT does NOT exist.')
+         The above example will check to see if the file "BLAH.TXT" exists
+         and if it does, will output "BLAH.TXT exists" to the screen.  If
+         BLAH.TXT does NOT exist, the output will be "BLAH.TXT does NOT
+         exist".
+  Procedure FileErase (FileName: String)
+         This procedure is used to erase an existing file from the disk.
+         The FileName variable is a string variable which contains the
+         file name which is to be erased.  The result of the FERASE
+         procedure can be checked by checking the DOSERROR function.
+         DOSERROR will return a 0 if successful or a 2 if an error occured.
+         Example:
+         FileErase ('C:\HELLO.TXT')
+         The above example will erase the file "C:\HELLO.TXT" if it exists.
+  DirExist(S:String) : Boolean;
+  Returns true or false if a directory exists.
+  Function FileCopy (Source: String, Dest: String) : Boolean
+         This function will copy a file from the specified source location
+         to the specified destination location.  The function will return
+         as TRUE if the file was copied successfully, or FALSE if an error
+         occured.  Note:  The file which is being copied should not already
+         be opened for File I/O by the program.
+         Example:
+         Write ('Copying C:\HELLO.TXT -> D:\HELLO.TXT: ')
+         If FileCopy ('C:\HELLO.TXT', 'D:\HELLO.TXT')
+              WriteLn ('OK')
+         Else
+              WriteLn ('ERROR')
+         The above example will attempt to copy the file "C:\HELLO.TXT" to
+         the destination of "D:\HELLO.TXT".  If the file is copied without
+         any problems an "OK" will be printed to the screen.  If an error
+         occured while copying, "ERROR" will be printed to the screen.
+  JustFile(S:String) : String;
+  Takes a string arguement and returns only the filename. Ex:
+      WriteLn ('This MPX filename is: ' + JustFile(ProgName));
+  JustFileName(S:String) : String;
+  Takes a string arguement and returns only the base filename (ie, not the
+  extension so it basically just removes a file extension).  This does not
+  remove a path, JustFile does that.
+  JustFileExt(S:String) : String;
+  Takes a string arguement and returns only the file extension.
+  fassign          Fsl          None
+  freset           F            None
+  frewrite         F            None
+  fclose           F            None
+  fseek            F            None
+  feof             F            boolean
+  Function FILEPOS (Handle) : LongInt
+         This function returns the current file position of an opened
+         file.  The passed Handle is the file handle number used when the
+         file was opened.  The FilePos function only works for files that
+         are opened as Binary, since Text files are read line by line.
+         Example:
+         fOpen (1, Bin, Reset, 'TEST.DAT')
+         If FilePos(1) = FileSize(1)
+              WriteLn ('END OF FILE.')
+         EndIf
+         fClose (1)
+         The above example opens the file "TEST.DAT" for binary and then
+         writes to the screen if the file position is at the end of the
+         file.  The above statement "FilePos(1) = FileSize(1)" is the same
+         as "Eof(1)" since it's stating "if the file position is equal to
+         the total file size, then we're at the end of the file."
+    Function FILESIZE (Handle) : LongInt
+         This function returns the total file size of an opened file.  The
+         passed Handle is the file handle number used when the file was
+         opened.  This function only works with files that have been opened
+         as Binary since Text files are read line by line.
+         Example:
+         fOpen (1, Bin, Reset, 'TEST.DAT')
+         WriteLn ('This file is ', FileSize(1), ' bytes in size.')
+         fClose (1)
+         The above example opens the file "TEST.DAT", writes the size of
+         the file to the screen, and then closes the file.
+  fread            F*w          None
+  freadrec
+  fwrite           F*w          None
+  rwriterec
+  freadln          FS           None
+  fwriteln         FS           None
+  pathsep          none         String
+  Function DOSERROR : Byte
+         This function returns the current DosError and is used with the
+         FindFirst and FindNext functions.  The possible values which may
+         be returned by DosError are as follows:
+         Value  Meaning
+         -----  ---------------------
+    No error
+    File not found
+    Path not found
+    Access denied
+    Invalid handle
+    Not enough memory
+    Invalid environment
+    Invalid format
+    No more files
+         -----  ---------------------
+         Example:
+         FindFirst ('*.*', AnyFile)
+         While DosError = 0
+              WriteLn ('File Name: ', DirName)
+              FindNext
+         WEnd
+         FindClose
+         The above example will list all files in the current directory.
+         The DosError function is used to return when there are no more
+         files to be listed.  For more information on this see the reference
+         for the FindFirst and FindNext functions.
+    Procedure FINDCLOSE
+         This function is used along with the FindFirst and FindNext
+         functions.  It is called only after all "Find" procedures have
+         completed.  See the "FindFirst" and "FindNext" command references
+         for more information.
+    Procedure FINDFIRST (Mask : String, Attributes)
+         This function is used to search a drive for files using a supplied
+         file mask and attribute list.  The results of the search are held
+         in the DIR variables as listed below.
+         Mask : The mask variable must contain at least a file mask
+                (ie "*.*") but can also contain a drive and directory name
+                as well (ie "C:\MYSTIC\TEXT\*.*").
+         Attributes : The file attributes are used to specify what type of
+                      files to return in the DIR variables.  The following
+                      is a list of supported file attributes:
+                      Attribute   Description
+                      ----------- -------------------------
+                      ReadOnly    Return files marked as "read only".
+                      Hidden      Return files marked as "hidden".
+                      SysFile     Return files marked as "system files".
+                      VolumeID    Return files marked as "volume ID".
+                      Directory   Return files marked as "directory".
+                      Archive     Return files marked as "archive".
+                      AnyFile     Returns any and all files.
+                      These attributes can be combined when passed to
+                      FindFirst.  For example: READONLY + HIDDEN will return
+                      any files which have been marked as "readonly" OR
+                      "hidden".  Example: DIRECTORY will only return names
+                      of directories.
+         DIR Variables : The DIR variables are what contain the information
+                         returned by the FindFirst command.  If your program
+                         is going to use these variables, it must be declared
+                         with the USES statement at the beginning of your
+                         program source code.  The following DIR variables
+                         are supported:
+                         DirName : Holds the file name.
+                         DirSize : Holds the file size.
+                         DirTime : Holds the file date and time in packed
+                                   date format.  The DateSTR and TimeSTR
+                                   functions will need to be used in order
+                                   to display these.
+         Example:
+         USES DIR
+         WriteLn ('The following files are in the C:\ directory:')
+         WriteLn ('')
+         FindFirst ('C:\*.*', ReadOnly + Archive)
+         While DosError = 0
+              WriteLn ('File Name: ', DirName)
+              WriteLn ('     Size: ', DirSize)
+              WriteLn ('     Date: ', DateSTR(DirTime), 0)
+              WriteLn ('     Time: ', TimeSTR(DirTime), 1)
+              Write   ('Press a key to search for more.~PN')
+              FindNext
+         WEnd
+         FindClose
+         WriteLn ('No more files have been found.')
+         The above example will list all files which fit the file mask of
+         "C:\*.*" and fit the attributes of either ReadOnly or Archive.
+         The DOSERROR function is used to determine when there are no more
+         files found (See the DOSERROR reference).  If a file has been
+         found, it will then be printed to the screen using the DIR
+         variables.  The FindNext functon is used to find the next file
+         that matches the name and attributes specified in the earlier call
+         to FindFirst.  FindClose is used when all "Find" functions have been
+         completed.
+    Procedure FINDNEXT
+         This procedure is used to find the next file which matches the file
+         mask and attibutes specified in the last call to FindFirst.
+         Example:
+         Uses DIR
+         FindFirst ('*.*', Archive)
+         While DosError = 0
+              WriteLn ('File Name: ', DirName)
+              FindNext
+         WEnd
+         FindClose
+         The above example uses the FindFirst/FindNext functions to do a
+         listing of all files in the current directory.  The DosError
+         function is used to determine when no more files have been found.
+  JustPath(S: String) : String;
+  Takes a string arguement and returns only the path (including the trailing
+  backslash).  Ex:
+      WriteLn ('This MPX is located in ' + JustPath(ProgName));
+  getsauce         sSSSS        boolean
+  FileOpen
+     FileEOF
+     FileRead
+     FileSeek
+     FilePos
+     FileSize
+     FileWrite
+     FileWriteBlock
+     FileRead
+     FileReadBlock
+     FileClose
+  AddSlash(String) : String;
+  Takes a directory and appends the appropriate ending backslash or forward
+  slash depending on operating system.  If the slash is already there, it does
+  nothing.
+  AppendText (FileName, Text: String)
+  This procedure will append a single line of text onto a text file.  If the
+  file does not exist, it will be created.  Example:
+      AppendText("c:\test.txt', 'This is a line of text added to test.txt!')
+User Related
+------------
+  Variables
+  userid          LongInt
+  username        String[30]
+  userhandle      String[30]
+  userpw          String[20]
+  useradd         String[30]
+  usercity        String[25]
+  userzip         String[10]
+  userhphone      String[15]
+  userdphone      String[15]
+  usergender      String[1]
+  userbday        LongInt    // julian date
+  useremail       String[40]
+  userinfo        String[40]
+  usersec         Byte
+  userstart       String[20]
+  userexp         String[8]
+  userexpto       Byte
+  useraf1         LongInt
+  useraf2         LongInt
+  userdtype       Byte
+  userscrnsize    Byte
+  userhotkey      Boolean
+  userfsedit      Boolean
+  userquotewin    Boolean
+  userflist       Boolean
+  usermread       Boolean
+  usermidx        Boolean
+  usermeidx       Boolean
+  userchat        Boolean
+  usersig         Boolean
+  usersigptr      LongInt
+  userarc         String[4]
+  usertheme       String[20]
+  usercname       String[30]
+  userinvis       Boolean
+  useravail       Boolean
+  userpip         String[20]
+  userpname       String[50]
+  usertime        Integer
+  usercmbase      Word
+  usercmgroup     Word
+  usercfbase      Word
+  usercfgroup     Word
+  usercall        LongInt
+  usertcall       Word
+  userdls         LongInt
+  usertdls        Word
+  userdlkb        LongInt
+  usertdlkb       LongInt
+  userfcall       LongInt   //dos date
+  userlcall       LongInt   //dos date
+  userposts       LongInt
+  useremails      LongInt
+  useruls         LongInt
+  userulkb        LongInt
+  userbank        Word
+  userlastpw      String[8]
+  uservyes        Byte
+  uservno         Byte
+  userdoors       LongInt
+  userflag        LongInt
+  useropts        Array[1..10] of String[60];
+  UserLastOn
+  UserFirstOn
+  Procedure UPUSER (Sec: Byte)
+         This procedure will upgrade the currently logged in user's
+         security level using the validation system.  The passed value
+         is the security level to upgrade to and must be between the
+         range of 0 to 255.
+         Example:
+         WriteLn ('Upgrading your access to level 20')
+         UpUser (20)
+         The above example will do a validation upgrade to the security
+         level of 20.
+  Function ACS (S: String) : Boolean
+         This function processes an ACS string and returns true if the user
+         has passed.
+         Example:
+         If ACS('s10g1')
+              WriteLn ('You have access to this.')
+         Else
+              WriteLn ('Sorry, you do not have access.')
+         EndIf
+         The above example checks to see if the user passes the ACS string
+         of "s10g1" and prints the result to the screen.
+  Function GETUSER (N: Integer) : Boolean
+         This procedure will read user data into the USER variables.  The
+         supplied N is the record number to read.  The function returns
+         true if the record was read, or false if a record was not read.
+         The following USER variables will be set when a record is read:
+         Variable Name   Type     Description
+         -------------------------------------------------------------------
+         USERDELETED     Boolean  Is the user marked as deleted?
+         USERNAME        String   User's real name.
+         USERALIAS       String   User's BBS alias.
+         USERPASSWORD    String   User's password.
+         USERADDRESS     String   User's street address.
+         USERCITY        String   User's City/State.
+         USERZIP         String   User's ZipCode.
+         USERHPHONE      String   User's home phone number.
+         USERDPHONE      String   User's data phone number.
+         USERBDAY        String   User's birth date.
+         USERSEX         Char     User's gender (M = Male, F = FeMale).
+         USERSEC         Byte     User's security level (0-255).
+         USERMENU        String   User's Starting Menu (if blank, Mystic
+                                  uses the default menu as setup in the
+                                  configuration).
+         USERFIRST       LongInt  User's date/time of first call to the BBS.
+                                  This is stored in the packed date format
+                                  so in order to display the date & time,
+                                  the functions of DATESTR and TIMESTR need
+                                  to be used.
+         USERLAST        LongInt  User's date/time of the last call to the
+                                  BBS.  This is also stored in a packed date
+                                  format, so the same rules for USERFIRST
+                                  apply to this.
+         USERCALLS       LongInt  User's total calls to the BBS system.
+         USERTCALLS      Integer  User's number of calls to the BBS today.
+         USERDLS         LongInt  User's total # of downloaded files.
+         USERTDLS        Integer  User's total # of downloaded files today.
+         -------------------------------------------------------------------
+         Example:
+         Var A Integer
+         A := 1
+         While GetUser(A)
+              WriteLn ('User Alias: ', UserAlias)
+              A := A + 1
+         WEnd
+         The above example will list all user accounts on the BBS system.
+   Procedure GETTHISUSER;
+         This procedure loads the user information for the currently
+         logged in user into the USER variables.  See the GETUSER function
+         for a reference of the USER variables.
+         Example:
+         GetThisUser
+         WriteLn ('Welcome to this BBS, ', UserAlias)
+         WriteLn ('You have called ', UserCalls, ' times!')
+         The above example will load the currently logged in user
+         information into the user variables, then display a line of
+         text welcoming them to the BBS.
+  Procedure PUTTHISUSER
+         This procedure will save the USER variables into the currently
+         logged in user's record.  See the GETUSER function for a list of
+         the USER variables which are saved by the PutThisUser function.
+         Example:
+         GetThisUser
+         WriteLn ('Welcome ', UserAlias, '.  Your account is being deleted.')
+         UserDeleted := True
+         PutThisUser
+         HangUp
+         The above example will load the USER variables with the currently
+         logged in user's information, then mark them as deleted with the
+         UserDeleted variable.  Their account is then saved with the
+         PutThisUser procedure and then they are hangup on using the HangUp
+         command.
+    Procedure PUTUSER (N: Integer)
+         This procedure will save the USER variables into the user file.
+         The passed N parameter is the record number to save under.  See
+         the GETUSER function for a list of the USER variables which are
+         saved by the PutUser procedure.
+         Example:
+         If GetUser(1)
+              UserDeleted := True
+              PutUser(1)
+         EndIf
+         The above example will attempt to load the data from user record
+into the USER variables.  If the data is loaded without any
+         errors, it will mark the user as deleted using the USERDELETED
+         variable, and then save the record back to the user file.
+  getuserbyname    s            boolean
+  getuserbyid      l            boolean
+  IsUser(Str:String) : Boolean;
+  Takes a string value which can contain either a user realname, handle, or
+  user perm index number.  If the user exists, it will return a TRUE result or
+  FALSE if the user does not exist.
+  settimeleft      i            none
+FBASE Unit
+----------
+  FBaseIndex
+  FGROUPHIDDEN
+  MGROUPHIDDEN
+  fbasefn" returns the file base's filename
+MBASE Unit
+----------
+  Function GETMBASE (N : Word) : Boolean
+         This procedure will read message base data into the MBASE variables.
+         The supplied N is the record number to read.  The function will
+         return TRUE if the record was read successfully, or FALSE if the
+				 record was not read.  The "USES MBASE" command must be called at
+				 the start of your program for the MBASE functions to work
+				 correctly.
+         The following MBASE variables will be set when a record is read:
+         Variable Name   Type     Description
+         -------------------------------------------------------------------
+         MBASENAME      String    Name
+				 MBASEQWK       String    QWK name
+				 MBASEFILE      String    File name
+				 MBASEPATH      String    Storage Path
+				 MBASEPTYPE     Byte      Post type: 0 = Public, 1 = Private
+				 MBASEACS       String    ACS level
+				 MBASERACS      String    Read ACS level
+				 MBASEPACS      String    Post ACS level
+				 MBASESACS      String    SysOp ACS level
+				 MBASEPW        String    Password
+				 MBASECQUOTE    Byte      Quote color (text attribute)
+				 MBASECTEXT     Byte      Text color
+				 MBASECTEAR     Byte      Tear color
+				 MBASECORIG     Byte      Origin color
+				 MBASEBTYPE     Byte      Base type: 0 = JAM, 1 = Squish
+				 MBASEAKA       Byte      Network address AKA #
+				 MBASEORIG      String    Origin line
+				 MBASEREAL      Boolean   Use real names?
+				 MBASEDNSCAN    Byte      New scan? 0 = no, 1 = yes, 2 = always
+				 MBASEDQSCAN    Byte      QWK scan? 0 = no, 1 = yes, 2 = always
+				 MBASEHDR       String    Header file
+				 MBASEINDEX     Integer   Index number (*NEVER* change this)
+         Example:
+         Var A Word
+         A := 1
+         While GetMBase
+              WriteLn ('Base name: ', MBaseName)
+              A := A + 1
+         Wend
+         The above example will list all available message base systems on
+         the BBS.
+  GetMBStats(id:LongInt; ExMsgF, ExMsgT: Boolean; total, new, yours: Longint);
+  This can be used as a function or a procedure (returning true if successful).
+  It takes 6 parameters.
+      #1: Message base number
+      #2: Exclude messages FROM the current user in stats
+      #3: Exclude messages TO the current user that have already been read
+      #4: Total messages (this is a VAR parameter)
+      #5: New messages (this is a VAR parameter)
+      #6: New messages to you (this is a VAR parameter)
+    Example:
+          uses mbase;
+          var
+            count, total, new, yours : longint;
+          begin
+            count := 1;  //start @1 to skip email base
+            while getmbase(count) do begin
+              getmbstats(count, true, true, total, new, yours);
+              writeln('base       : ' + mbasename);
+              writeln('total msgs : ' + int2str(total));
+              writeln('new msgs   : ' + int2str(new));
+              writeln('your msgs  : ' + int2str(yours));
+              writeln('');
+              count := count + 1
+            end;
+          end.
+  GetMBaseTotal (Compress: Boolean) : LongInt
+  This function returns the total message bases on the system.  If Compressed
+  is true, then it will return the total number of message bases the user has
+  access to (slower to calculate).  If it is false, it returns the raw total
+  number of bases on the system.
+  GetMailStats(Total, UnRead:LongInt);
+  Returns the number of e-mail messages and the number of unread email messages:
+       Var
+         Total, UnRead: LongInt;
+       Begin
+         GetMailStats(Total, UnRead);
+         WriteLn ('You have ' + Int2Str(Total) + ' emails, ' + Int2Str(UnRead) + ' unread');
+       End;
+  CfgNetDesc (array 1..30 of string[25] contains network descriptions) and
+  MBaseNetAddr (contains the network address target of the message base).  Ex:
+      Uses CFG, MBASE;
+      Begin
+        If GetMBase(1) Then
+          WriteLn ('Base #1 is in network: ' + CfgNetDesc[MBaseNetAddr]);
+      End.
+  Procedure PUTMBASE
+         This procedure will save the currently loaded MBASE variables into
+         a message base record.  See the GETMBASE function for a list of
+         valid MBASE variables.
+         Example:
+         If GetMBase(1) Then
+              MBaseName := 'Message Base #1'
+              PutMBase(1)
+         EndIf
+         The above example will read the data for message base #1, set the
+         name to "Message Base #1" and write the data back to the data file.
+CFG Unit
+--------
+  Variables
+  cfgpathsys      string[60]
+  cfgpathdata     string[60]
+  cfgpathlogs     string[60]
+  cfgpathmsgs     string[60]
+  cfgpathfile     string[60]
+  cfgpathmail     string[60]
+  cfgpathmenu     string[60]
+  cfgpathtext     string[60]
+  cfgpathansi     string[60]
+  cfgpathmpl      string[60]
+  cfgtimeout      word
+  CfgTNNodes
+  Variable, which now contains the number of telnet nodes to allow.  These are
+  basically interchangable in your MPL code but it is changing to more
+  accurately reflect what Mystic is doing.
+  CfgTempPath
+  returns the location of the current node temporary directory.
+  CfgChatStart and CfgChatEnd.
+  These return the byte of the chat hour start and end variables from the
+  System Configuration
+  CfgSeeInvis
+  Gives you access to the "See Invisible" ACS value from Mystic's configuration
+  ReadEnv(S:String) : String;
+  Returns the value of an environment variable of the operating system.
+  menucmd          ss           None
+  Procedure GETCFG
+         This procedure will load the current configuration data into the
+				 CFG variables.  The "USES CFG" command must be used at the start
+				 of your program for GETCFG to work.  The following variables will
+				 be loaded:
+         CFGSYSPATH     : System Path
+         CFGDATAPATH    : Data Path
+         CFGMSGSPATH    : Message Base Path
+         CFGPROTPATH    : Protocol Path
+         CFGARCSPATH    : Archive Path
+         CFGQWKPATH     : Local QWK Path
+         CFGMPEPATH     : Script (MPE) Path
+         CFGATTPATH     : File Attach Path
+         CFGLOGSPATH    : System Logs Path
+         CFGTEXTPATH    : Text Files Path (for the current language)
+         CFGMENUPATH    : Menu Files Path (for the current language)
+         CFGSTATUSTYPE  : Returns status line mode (0 = 2 line, 1 = 1 line)
+         Example:
+				 Uses CFG
+				 GetCFG
+         WriteLn ('Mystic BBS is installed in ', CfgSysPath)
+         The above example will load the configuration into the CFG
+         variables, and then print the directory where Mystic BBS is
+         installed in to the screen.
+Bit Operations
+---------------
+  BitCheck(Pos:Byte; AnyVar) : Boolean
+  Accepts a bit position and checks it against an integer, returning true or
+  false if the bit is on.  So for example in the Records, the third bit in
+  UserFlags is UserDeleted:
+      GetThisUser
+      If BitCheck(3, UserFlags) Then WriteLn('User is marked deleted');
+  BitToggle(Pos:Byte; AnyVar);
+  Accepts a bit position and an integer and toggles the bit.
+      GetThisUser
+      BitToggle(3, UserFlags);  // undeletes if they are deleted or deletes if
+                                // they are not deleted.
+  BitSet(Pos:Byte; AnyVar; True:Boolean);
+  Accepts a bit position and an integer and sets the bit ON/OFF based on a
+  boolean:
+      GetThisUser
+      BitSet(3, UserFlags, True);  // user is marked as deleted
+  MPL now fully supports bitwise math and operators!  The following are
+   implemented:
+      AND - Bitwise AND
+      OR  - Bitwise OR
+      XOR - Bitwise exclusive OR
+      SHL - Bitwise shift left
+      SHR - Bitwise shift right
+   Example:
+     Const
+       UserDeleted = $04;  // established bit for userdeleted from records.pas
+                           // note: this value has changed check records.pas!
+     Begin
+       GetThisUser
+       If UserFlags AND UserDeleted <> 0 Then
+         WriteLn('User is deleted');
+     End;
+Math & Number Related
+---------------------
+  Types
+  =====
+    Real
+    Integer
+    Byte
+    Word
+  Procedures
+  ==========
+  Mod (%)
+  Gets the mod of a division. Example:
+      A := 10 % 8;
+  POWER operator in mathmatical equations:
+      A := 2 ^ 3;
+  Function odd(l:LongInt):Boolean
+  Returns True if number is odd.
+  Real2Str(R:Real; D:Byte) : String;
+  This takes a string and decimal place value.  Example:
+      Var
+        R : Real;
+      Begin
+        R := 1234.1234;
+        WriteLn (Real2Str(R, 2));  // Will print 1234.12
+      End
+  ABS (Num: LongInt) : LongInt;
+  This value takes a signed integer and returns the absolute value.
+Special Things...
+-----------------
+  Message Editor
+   MsgEditor, MsgEditSet, MsgEditGet.  These allow
+   access to the internal Mystic msg editor (line and/or full) from within
+   MPL.  It even allows you to define wrap position and template to completely
+   make it look like its not the Mystic editor!
+   As a little hint the MsgEditSet and MsgEditGet stuff could be used to post
+   process message text on posts.  Like say for example you wanted to write
+   a MPL that allows users to add Tag lines, you could do that by replacing
+   the "Saving message..." prompt and using those two in order to modify the
+   text before it is saved by Mystic!
+   Rather than trying to explain it all, here is an example of all 3:
+     Var
+       Lines    : Integer = 0;
+       WrapPos  : Integer = 79;
+       MaxLines : Integer = 200;
+       Forced   : Boolean = False;
+       Template : String  = 'ansiedit';
+       Subject  : String  = 'My subject';
+       Count    : Integer;
+     Begin
+       MsgEditSet (1, 'this is line 1');
+       MsgEditSet (2, 'this is line 2!');
+       Lines := 2;
+       SetPromptInfo(1, 'MsgTo');  // if template uses &1 for "To:" display
+       If MsgEditor(0, Lines, WrapPos, MaxLines, Forced, Template, Subject) Then Begin
+         WriteLn('User selected to save.');
+         WriteLn('There are ' + Int2Str(Lines) + ' of text in buffer:');
+         For Count := 1 to Lines Do
+           WriteLn(MsgEditGet(Count));
+         Pause;
+       End Else Begin
+         WriteLn('User aborted the edit.');
+         Pause;
+       End
+     End
+  Classes
+  =======
+  MPL now has the ability to interface directly with internal Mystic BBS
+   classes.  This opens up a whole world of new possibilities in the future
+   (for example) sockets, full remote ANSI screen library (boxes, listboxes)
+   data sorting, and more.
+   Classes must first be created and then freed after using.  Mystic will
+   create the class instance and return a handle to that specific class to
+   use with the functions.  Finally, the class is freed.  Two new functions
+   go with this:
+      ClassCreate (ClassHandle, ClassType)
+      ClassFree (ClassHandle)
+ + MPL now supports the ANSI box class.  There are three functions which
+   go along with this: BoxOpen, BoxClose, and BoxOptions.  The Box class
+   will automatically save and and subsequently restore the text under the
+   box when it is closed.
+   See TESTBOX.MPS for an example.
+ + MPL now supports the ANSI input class.  There are several functions which
+   go along with this: InputString, InputNumber, InputEnter, InputOptions.
+   This class allows you more freedom over input functions than the standard
+   MPL input functions do.
+   See TESTINPUT.MPS for an example.
+   MPL now supports ANSI screen class.  This allows the ability to save and
+   restore portions of the user's screen.  The example below saves the screen
+   coordinates defined as: X1:20, Y1:5, X2:60, Y2:10.  It then clears the
+   screen and then restores the saved portion of the screen.
+      Var SavedScreen : LongInt;
+      ClassCreate (SavedScreen, 'image');
+      ImageGet    (SavedScreen, 20, 5, 60, 10);
+      ClrScr;
+      WriteLn ('Press a key to restore');
+      Pause;
+      ImagePut (SavedScreen);
+      ClassFree (SavedScreen);
+      Pause;
+</code>

fsxNet Wiki

User Tools

Site Tools

Differences

Page Tools