Mcicommands: Difference between revisions

From Color 64 BBS Wiki
← Older edit
m Protected "Mcicommands" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))
No edit summary
 
(4 intermediate revisions by the same user not shown)
Line 1: Line 1:
Color 64 supports MCI commands--MCI stands for Message Command Interpreter, a system used on many BBS types.  In short, an MCI command is a set of characters that you embed in a message to control the appearance of the text or perform special functions.  One command could inform the computer to wait for a key to be pressed, and another command could turn on rainbow mode.  MCI commands are not performed until the lines you have typed are viewed by you or someone else (whether listing the lines in the editor or by reading the message itself).  Until then, all you see is a representation of them as you type the lines.  MCI commands can also be used with the BASIC output commands (see section 3.11.1, on using MCI commands in BASIC).  In fact, MCI commands can be used anywhere that output can occur, except for BASIC’s PRINT statement, because PRINT is not tied into the ML output routines.
{{DISPLAYTITLE:MCI Commands and Use}}
[[bbs operation|BBS Operation]] - <strong>MCI Commands</strong>


While in the message editor, all MCI commands begin with the British Pound symbol (£). The next character in the MCI command tells the computer which command you wish to use.  It must be an unshifted letter; the interpreter will not recognize shifted letter commands. A 'c' for example tells the computer to wait for a key to be pressed.  On the screen the command would appear as '£c'.  Of course, if you are in Uppercase/Graphics mode then unshifted characters will appear as uppercase characters (i.e. ‘C').  
== MCI Command Overview ==
Color 64 includes support for MCI commands. MCI stands for Message Command Interpreter, a feature common to many BBS systems. An MCI command is a special character sequence embedded in a message to control formatting or trigger functions. For example, one command can pause output until a key is pressed, while another enables rainbow text effects.


Some MCI commands require additional characters to supplement the command, such as the rainbow mode MCI commands. If you wish to use standard character rainbow mode, then the sequence would be £r followed by 2 to 8 colors.  To type the colors, just use the CTRL and C= keys just as if you were changing the cursor color (e.g. CTRL/2 is white, C=3 is light red, etc.). The colors will be used just like the rainbow mode enacted by the ‘F3' character, except they will be your own chosen colors rather than the system colors.  If you use less than 2 colors, the current rainbow mode will be left unchanged.  If you use more than 8 colors, only the first 8 will be used.  All rainbow modes except for Caps/Punctuation Mode accept 2 to 8 colors.  
MCI commands are interpreted only when the message is displayed, either in the editor or when read by a user. While typing, you will simply see their character representation. MCI commands may also be used with BASIC output routines (see section 3.11.1). They function anywhere ML-based output occurs, except within BASIC’s PRINT statement, which does not use the ML output handler.


The table below defines the standard MCI commands:
While in the message editor, every MCI command begins with the British Pound symbol (£). The character immediately following determines the command and must be an unshifted letter. Shifted letters will not be recognized. For example, typing £c tells the system to wait for a keypress. In Uppercase/Graphics mode, unshifted characters appear as uppercase, but they are still interpreted correctly.


{| class="wikitable
Some commands require additional characters. Rainbow modes, for example, must be followed by color selections entered using CTRL or C= key combinations, just as when changing cursor colors. Most rainbow modes accept 2 to 8 colors. If fewer than 2 colors are entered, the current mode remains unchanged. If more than 8 are entered, only the first 8 are used. Caps/Punctuation mode is limited to 2 or 3 colors.
 
=== Standard MCI Commands ===
The table below lists the standard MCI commands:
 
{| class="wikitable"
|-
|-
|+Standard MCI Commands  
|+ Standard MCI Commands
! Command
! Command
! Function
! Function
! Description
! Description
|-
|-
| £r  
| £r
|Character Rainbow  
| Character Rainbow
|Color changes for each character  
| Changes color with each character
|-
|-
| £w  
| £w
| Word Rainbow
| Word Rainbow
| The color changes for each word  
| Changes color with each word
|-
|-
| £s  
| £s
| Sentence Rainbow  
| Sentence Rainbow
| The color changes for each sentence that ends with a period (.), question mark (?), or exclamation point (!)  
| Changes color at each sentence ending (., ?, !)
|-
|-
| £l  
| £l
| Line Rainbow  
| Line Rainbow
| The color changes for each line that ends with a carriage return  
| Changes color at each carriage return
|-
|-
| £g  
| £g
| Paragraph Rainbow  
| Paragraph Rainbow
| The color changes for each paragraph that ends with two carriage returns
| Changes color at each double carriage return
|-
|-
| £p  
| £p
| Caps/Punctuation  
| Caps/Punctuation
| This will use from 2 to 3 colors. If 3 colors are used, a separate color is defined for uppercase letters, lowercase letters, and punctuation/graphics characters respectively. If only 2 colors are used, then a separate color is defined for alphabetic and punctuation characters, respectively. Both versions produce a very nice-looking effect  
| Uses 2 or 3 colors. With 3 colors: separate colors for uppercase, lowercase, and punctuation/graphics. With 2 colors: alphabetic vs punctuation. Produces a visually distinctive effect.
|-
|-
| £n  
| £n
| Normal  
| Normal
| This command cancels the currently set mode (returning text to normal output)
| Cancels current mode and returns to normal output
|-
|-
| £v  
| £v
| Character Velocity  
| Character Velocity
| This command is followed with a digit from 0 to 9. 0 sets the output speed so there is no delay between characters (which is the fastest).  9 is the slowest speed. This command is cancelled by a £v0 command or by a RETURN.  
| Follow with digit 0–9. 0 is fastest (no delay), 9 is slowest. Cancel with £v0 or RETURN.
|-
|-
| £c  
| £c
| Wait  
| Wait
| Wait for key to be pressed by user
| Pauses until a key is pressed
|-
|-
| £t  
| £t
| Tab  
| Tab
| A number from 0 to 79 must follow this command which indicates which tab position to go to. If the current position is less than the tab position, then spaces are printed.  For example, if you were at position 5 (which would be the equivalent of hitting the spacebar 5 times), then issued a .t10 command, the computer would automatically add another five spaces to get to the correct position. If the current position is greater than the tab position, then crsr-lefts are printed.  
| Follow with position 0–79. If current position is less, spaces are added. If greater, cursor-left characters are printed. Tabs on the same line should move in one direction only.
 
Note: If several tabs are to be executed on the same line, they should all be in the same direction (e.g.  from left to right, or from right to left).  Moving back and forth on the screen may produce undesirable effects.  
|-
|-
| £i  
| £i
| Wait for Line of Input  
| Wait for Line of Input
| Waits for a line of input to be entered. Up to 127 characters can be entered. The text that was entered is stored in memory and can be printed with the £a0 command (refer to Section 3.9).  
| Accepts up to 127 characters. Stored input may be printed with £a0.
|}  
|}


There are two MCI commands that have level-restricted access, Message Output MCI and Variable MCI. You will see that their levels of use are definable in SETUP. 
Two additional commands may be restricted by security level in SETUP: Message Output MCI and Variable MCI.


<strong>The Message Output MCI</strong>
=== The Message Output MCI ===


<strong>£a</strong>: message output MCI. This command prints a different message depending on the digit following the command as defined in the table below.
<strong>£a</strong> outputs system or user-specific information. The digit following the command selects the output:


{| class="wikitable
{| class="wikitable"
|-
|-
|+Message MCI Commands  
|+ Message MCI Commands
! Command
! Command
! Function
! Function
|-
|-
| £a0  
| £a0
| Print the input typed when the last £i command was issued
| Print text entered from last £i command
|-
|-
| £a1  
| £a1
| Print the name/alias of the current caller (This uses the current contents of the string NA$)  
| Current caller’s name/alias (NA$)
|-
|-
|£a2  
| £a2
| Print the last calling date of the user (LD$)  
| Caller’s last calling date (LD$)
|-
|-
| £a3  
| £a3
| Current time (T$)  
| Current time (T$)
|-
|-
| £a4  
| £a4
| Current date (DA$)  
| Current date (DA$)
|-
|-
| £a5  
| £a5
| Print the name/alias of the last caller (LC$).  
| Last caller’s name (LC$). If last call was network exchange, remote BBS name is shown.
Note: If the last call was an incoming network exchange, then the name of the remote BBS will be stored in this variable.  
|-
|-
| £a6  
| £a6
| Print the contents of the string variable DD$.  This is the SYSOP definable "Membership Information" field in the caller's password record.  See section 3.3, "Password Record Information", for information on its use.
| Membership information field (DD$), SYSOP-defined
|-
|-
| £a7  
| £a7
| User's real name (RN$)  
| User’s real name (RN$)
|-
|-
| £a8  
| £a8
| User’s birth date (BD$)  
| User’s birth date (BD$)
|-
|-
| £a9  
| £a9
| User’s phone number (PH$)  
| User’s phone number (PH$)
|-
|-
| £aa  
| £aa
| User’s email or street address (A1$)  
| Email or street address (A1$)
|-
|-
| £ab  
| £ab
| User’s city, state, and ZIP (A2$)  
| City, state, ZIP (A2$)
|}
|}


One more note about the Message (£a) MCI command.  The command £a6 prints the contents of DD$ (membership information).  The information in DD$ may vary as you decide how it is used.  Therefore, the option of disabling the DD$ commands for security reasons is available in SETUP.  
Note: Because DD$ may contain sensitive membership information, SETUP allows disabling of £a6 for security.


<strong>The Variable MCI Command. </strong>
=== The Variable MCI Command ===


<strong>£[</strong>: variable expression output.  This MCI command lets you print any type of variable or expression you want.
<strong>£[</strong> allows output of any BASIC variable or expression. An expression may be numeric or string-based, such as:


An expression is just a mathematical formula which you use in BASIC to calculate things.  For example, <strong>5*4+3/16</strong> is an expression, just as <strong>a$+mid$(str$(lv),2)</strong> is an expression.  Just follow the £[ with an expression and then end the string of characters with a close-bracket symbol (]).  This command requires some explanation about the inner workings of BASIC.
<strong>5*4+3/16</strong>
<strong>a$+mid$(str$(lv),2)</strong>


* Keywords and Tokens
Type £[ followed by the expression and terminate with a closing bracket ]. The system evaluates the expression and prints the result.
: The BASIC language is made up of what are called "keywords", which are the very base commands and functions of the BASIC language.  PRINT, for example, is a BASIC keyword.  Since there really aren't that many keywords, it would be a waste of time and space if the BASIC interpreter stored each letter of each of these keywords individually. Instead, the BASIC interpreter scans each line as you enter it into the program and crunches each keyword into a single character called a "token".  When you LIST the program, of course, these tokens are printed as the entire keyword.  The keyword crunching process saves space when the program is being stored on disk, and it saves time when the program is running (for it doesn't have to figure out what the command is by searching character by character).  When you are editing a BASIC program, the whole process of keyword crunching is invisible, because it is taken care of by the computer from when you enter the line to when you LIST it again.  


: The <strong>£[</strong> command is different, though, because it expects you to take care of the keyword crunching for it. The reason for this is that the regular BASIC interpreter is busy running a program and doesn't have any need to go about crunching keywords inside of MCI commands. Don't get worried, though, because I have installed a feature into this command which allows you to use it without understanding the BASIC tokens.  Just read on though because the process of keyword crunching is very simple.  
BASIC keywords are stored internally as single-character tokens. Normally this tokenization happens automatically when entering program lines. However, within £[ expressions, you must either manually enter tokens or use the automatic keyword cruncher.


* Typing in the BASIC Tokens
==== Typing BASIC Tokens ====
: It is pure chance, I guess, that all the necessary keywords that would be needed in the <strong>£[</strong> command are easily typeable from the Commodore keyboard.  This fact, though, allows you to access all the functions and symbols that you would have access to when typing a line in BASIC.  The only difference, though, is that all of them are represented by a single character.  The enclosed chart below shows all the numeric/string symbols and functions with their token equivalents.  The "C=" by a character means to press that key while holding the Commodore logo key down, just like when you type Commodore graphics characters.  If something is not on the chart, then it doesn't need to be converted (such as the "%" percent sign).  Also note that all mathematical symbols such as the plus and minus signs need to be converted to a token.  In the following paragraphs, angle brackets "< >" will enclose special characters.


: {| class="wikitable
The table below lists common numeric and string tokens and their key combinations:
 
{| class="wikitable"
|-
|-
|+BASIC Token Reference Chart
|+ BASIC Token Reference Chart
! Token
! Token
! Hex
! Hex
Line 135: Line 140:
! CHR$()
! CHR$()
|-
|-
| +  
| +
| AA  
| AA
| C= + J  
| C= + J
| CHR$(170)  
| CHR$(170)
|-
|-
| -  
| -
| AB  
| AB
| C= + K  
| C= + K
| CHR$(171)  
| CHR$(171)
|-
|-
| *  
| *
| AC  
| AC
| C= + L  
| C= + L
| CHR$(172)  
| CHR$(172)
|-
|-
| /  
| /
| AD  
| AD
| C= + Z  
| C= + Z
| CHR$(173)  
| CHR$(173)
|-
|-
| ↑  
| ↑
| AE  
| AE
| C= + X  
| C= + X
| CHR$(174)  
| CHR$(174)
|-
|-
| AND  
| AND
| AF  
| AF
| C= + C  
| C= + C
| CHR$(175)  
| CHR$(175)
|-
|-
| OR  
| OR
| B0  
| B0
| C= + V  
| C= + V
| CHR$(176)  
| CHR$(176)
|-
|-
| >
| >
| B1  
| B1
| C= + B  
| C= + B
| CHR$(177)  
| CHR$(177)
|-
|-
| =  
| =
| B2  
| B2
| C= + N  
| C= + N
| CHR$(178)  
| CHR$(178)
|-
|-
| <
| <
| B3  
| B3
| C= + M  
| C= + M
| CHR$(179)  
| CHR$(179)
|-
|-
| SGN  
| SGN
| B4  
| B4
| C= + H  
| C= + H
| CHR$(180)  
| CHR$(180)
|-
|-
| INT  
| INT
| B5  
| B5
| C= + J  
| C= + J
| CHR$(181)  
| CHR$(181)
|-
|-
| ABS  
| ABS
| B6  
| B6
| C= + L  
| C= + L
| CHR$(182)  
| CHR$(182)
|-
|-
| USR  
| USR
| B7  
| B7
| C= + Y  
| C= + Y
| CHR$(183)  
| CHR$(183)
|-
|-
| FRE  
| FRE
| B8  
| B8
| C= + U  
| C= + U
| CHR$(184)  
| CHR$(184)
|-
|-
| POS  
| POS
| B9  
| B9
| C= + O  
| C= + O
| CHR$(185)  
| CHR$(185)
|-
|-
| SQR  
| SQR
| BA  
| BA
| SHIFT-@  
| SHIFT-@
| CHR$(186)  
| CHR$(186)
|-
|-
| RND  
| RND
| BB  
| BB
| C= + F  
| C= + F
| CHR$(187)  
| CHR$(187)
|-
|-
| LOG  
| LOG
| BC  
| BC
| C= + C  
| C= + C
| CHR$(188)  
| CHR$(188)
|-
|-
| EXP  
| EXP
| BD  
| BD
| C= + X  
| C= + X
| CHR$(189)  
| CHR$(189)
|-
|-
| COS  
| COS
| BE  
| BE
| C= + V  
| C= + V
| CHR$(190)  
| CHR$(190)
|-
|-
| SIN  
| SIN
| BF  
| BF
| C= + B  
| C= + B
| CHR$(191)  
| CHR$(191)
|-
|-
| TAN  
| TAN
| C0  
| C0
| SHIFT-*  
| SHIFT-*
| CHR$(192)  
| CHR$(192)
|-
|-
| ATN  
| ATN
| C1  
| C1
| SHIFT-A  
| SHIFT-A
| CHR$(193)  
| CHR$(193)
|-
|-
| PEEK  
| PEEK
| C2  
| C2
| SHIFT-B  
| SHIFT-B
| CHR$(194)  
| CHR$(194)
|-
|-
| LEN  
| LEN
| C3  
| C3
| SHIFT-C  
| SHIFT-C
| CHR$(195)  
| CHR$(195)
|}
|}


: Example: you want the computer to print the expression "<strong>INT(RND(0)*16+5)</strong>" with the <strong>£[</strong> command.  The first thing you would do is consult the chart and find the token for "INT". This happens to be the C=J character (which looks like a thick vertical line).  Then the parenthesis would be typed as normal.  Next would be the keyword "RND".  On the chart, it is listed as the C=F character (a small square).  Then everything would be the same until the "*” character.  So far, the command would be "£[", then a C=J symbol, then a “(", then a C=F symbol, then "(0)".  
Example: To output INT(RND(0)*16+5), convert keywords and mathematical operators to their token equivalents. The completed command appears visually as shown below:
 
[[File:variablemci1.jpeg|center|200px]]


: Next, remember that mathematical symbols like "*" are also converted to tokens.  Using the chart, it would be converted to a C=D character (a small square).  The "16" is fine as it is. The "+" sign is converted to C=N (a thin vertical line).  And the final parenthesis is left alone. The complete command would be (without the spaces): <strong>£ [ <C=J> ( <C=F> ( 0 ) <C=D> 1 6 <C=N> 5 ) ]</strong>
Close the expression with ] to execute it. Any syntax error within the expression will generate the same error BASIC normally produces. For this reason, access to £[ should be restricted to trusted users.


: On a live and breathing Commodore display, it should look like this:
==== Automatic Keyword Cruncher ====
: [[File:variablemci1.jpeg|center|200px]]


: A final "<strong>]</strong>" close-bracket symbol finishes the command.  This example appears on the keywords sheet as it would appear on screen.
To avoid manually entering tokens, place a greater-than symbol (>) immediately after the opening bracket:


: Again, anything that isn't on the chart is usable as it is.  Remember that the text between the brackets is under the same rules as any BASIC expression.  Therefore, you can create a SYNTAX ERROR, or any other error a bad expression may create.  So be careful to make sure the expression has been entered correctly.  For this reason, it is also highly recommended that use of this command is restricted to only you, or those who you can absolutely trust with using the command.
£[>int(rnd(0)*16+5)]


* An Easier (but slower) Solution: Automatic Keyword Cruncher
This version is easier to type and read, though slightly slower in execution. Comparison:
: If you still do not understand tokens, it is perfectly fine.  This is a concept that rarely comes up in everyday practical programming.  That is why I included the "automatic keyword cruncher".  Be forewarned, though, that the automatic keyword cruncher calculates the expression a lot slower than a manually crunched expression.  Keep this fact in mind if you notice slight delays while printing a file that uses a lot of Variable MCI commands.  To use the automatic keyword cruncher, just include the "<strong>></strong>“ greater-than symbol right after the "<strong>[</strong>" opening bracket. Here is a comparison of how the <strong>£[</strong> command would be with and without the automatic keyword-cruncher, using the expression <strong>int(rnd(0)*16+5)</strong>:


: {| class="wikitable
{| class="wikitable"
|-
|-
|+Automatic Keyword Cruncher Example  
|+ Automatic Keyword Cruncher Example
|+"int(rnd(0)*16+5)"  
|+"int(rnd(0)*16+5)"
! With Automatic Keyword Cruncher
! With Automatic Keyword Cruncher
! Without Automatic Keyword Cruncher  
! Without Automatic Keyword Cruncher
|-
|-
| [[File:variablemci2.jpeg|center|200px]]
| [[File:variablemci2.jpeg|center|200px]]
Line 291: Line 296:
|}
|}


: As you can see, the automatic version is a lot simpler to read, although it takes up more room (in characters). 
=== MCI Command Security ===


<strong>MCI Command Security</strong>
Access levels for £a and £[ are configurable in SETUP. If a caller lacks permission, the system prevents entry of the command. The message loader also filters unauthorized usage.


You can set the levels for the "<strong>£a</strong>" Message and the "<strong>£[</strong>" Variable MCI commands in SETUP. If the caller doesn't have access to a command, then he will not be allowed to type the character after a "£".  Also, the default message loader will sift out any unauthorized use of MCI commands if the levels do not permit their use.  
Internally, allowed commands are converted to special characters. For example, the “a” in £a is stored as F2. The “[" in £[ is stored as F4. These function-key characters cannot be entered directly by online callers, preventing unauthorized command injection.


The way the security measures are accomplished involves substituting special characters in the place of what the caller is typing.  For example, if the caller has access to the <strong>£a</strong> command, the input routine will convert the "a” in the command to an F2 (function key two) character.  This process is completely invisible to the caller, and it appears that an "a" is being typed because that is what is printed.  Internally, though, the command sequence is stored as a "£" character and an F2 character.  If the <strong>£[</strong> command is used, then the "[" character is converted to an F4 (function key four).
=== Using MCI Commands in BASIC ===


All of this may seem to be a lot of programming to accomplish nothing, but it is the most effective way to prevent tampering of the MCI commands. Both the F2 character and the F4 character are "impossible keys" when online, meaning that no matter what a caller does, there is no way to directly input a converted MCI command if they do not have access.
When programming in BASIC, you must enter £a and £[ using their internal representations. Instead of typing “£a”, enter “£” followed by F2. For Variable MCI, enter “£” followed by F4. These appear visually as £a and £[, but internally use protected characters.


<strong>Using MCI Commands in BASIC</strong>
Next Section: [[textediting|Text Editing Features]]


Because of the security measures mentioned above, it is necessary for you to use the £a and £[ commands in their native form when programming in BASIC.  This means that instead of typing "£" then "a" for a Message MCI command inside the quotes of a BASIC statement, you will have to type "£" then F2 (an uppercase reverse "I").  The same with the Variable MCI, which instead of appearing as "<strong>£[</strong>" like in the message editor, it will appear as a “£” then F4 (an uppercase reverse 'J').
[[bbs operation|BBS Operation]]

Latest revision as of 18:19, 23 February 2026

BBS Operation - MCI Commands

MCI Command Overview

Color 64 includes support for MCI commands. MCI stands for Message Command Interpreter, a feature common to many BBS systems. An MCI command is a special character sequence embedded in a message to control formatting or trigger functions. For example, one command can pause output until a key is pressed, while another enables rainbow text effects.

MCI commands are interpreted only when the message is displayed, either in the editor or when read by a user. While typing, you will simply see their character representation. MCI commands may also be used with BASIC output routines (see section 3.11.1). They function anywhere ML-based output occurs, except within BASIC’s PRINT statement, which does not use the ML output handler.

While in the message editor, every MCI command begins with the British Pound symbol (£). The character immediately following determines the command and must be an unshifted letter. Shifted letters will not be recognized. For example, typing £c tells the system to wait for a keypress. In Uppercase/Graphics mode, unshifted characters appear as uppercase, but they are still interpreted correctly.

Some commands require additional characters. Rainbow modes, for example, must be followed by color selections entered using CTRL or C= key combinations, just as when changing cursor colors. Most rainbow modes accept 2 to 8 colors. If fewer than 2 colors are entered, the current mode remains unchanged. If more than 8 are entered, only the first 8 are used. Caps/Punctuation mode is limited to 2 or 3 colors.

Standard MCI Commands

The table below lists the standard MCI commands:

Standard MCI Commands
Command Function Description
£r Character Rainbow Changes color with each character
£w Word Rainbow Changes color with each word
£s Sentence Rainbow Changes color at each sentence ending (., ?, !)
£l Line Rainbow Changes color at each carriage return
£g Paragraph Rainbow Changes color at each double carriage return
£p Caps/Punctuation Uses 2 or 3 colors. With 3 colors: separate colors for uppercase, lowercase, and punctuation/graphics. With 2 colors: alphabetic vs punctuation. Produces a visually distinctive effect.
£n Normal Cancels current mode and returns to normal output
£v Character Velocity Follow with digit 0–9. 0 is fastest (no delay), 9 is slowest. Cancel with £v0 or RETURN.
£c Wait Pauses until a key is pressed
£t Tab Follow with position 0–79. If current position is less, spaces are added. If greater, cursor-left characters are printed. Tabs on the same line should move in one direction only.
£i Wait for Line of Input Accepts up to 127 characters. Stored input may be printed with £a0.

Two additional commands may be restricted by security level in SETUP: Message Output MCI and Variable MCI.

The Message Output MCI

£a outputs system or user-specific information. The digit following the command selects the output:

Message MCI Commands
Command Function
£a0 Print text entered from last £i command
£a1 Current caller’s name/alias (NA$)
£a2 Caller’s last calling date (LD$)
£a3 Current time (T$)
£a4 Current date (DA$)
£a5 Last caller’s name (LC$). If last call was network exchange, remote BBS name is shown.
£a6 Membership information field (DD$), SYSOP-defined
£a7 User’s real name (RN$)
£a8 User’s birth date (BD$)
£a9 User’s phone number (PH$)
£aa Email or street address (A1$)
£ab City, state, ZIP (A2$)

Note: Because DD$ may contain sensitive membership information, SETUP allows disabling of £a6 for security.

The Variable MCI Command

£[ allows output of any BASIC variable or expression. An expression may be numeric or string-based, such as:

5*4+3/16 a$+mid$(str$(lv),2)

Type £[ followed by the expression and terminate with a closing bracket ]. The system evaluates the expression and prints the result.

BASIC keywords are stored internally as single-character tokens. Normally this tokenization happens automatically when entering program lines. However, within £[ expressions, you must either manually enter tokens or use the automatic keyword cruncher.

Typing BASIC Tokens

The table below lists common numeric and string tokens and their key combinations:

BASIC Token Reference Chart
Token Hex Key Combination CHR$()
+ AA C= + J CHR$(170)
- AB C= + K CHR$(171)
* AC C= + L CHR$(172)
/ AD C= + Z CHR$(173)
↑ AE C= + X CHR$(174)
AND AF C= + C CHR$(175)
OR B0 C= + V CHR$(176)
> B1 C= + B CHR$(177)
= B2 C= + N CHR$(178)
< B3 C= + M CHR$(179)
SGN B4 C= + H CHR$(180)
INT B5 C= + J CHR$(181)
ABS B6 C= + L CHR$(182)
USR B7 C= + Y CHR$(183)
FRE B8 C= + U CHR$(184)
POS B9 C= + O CHR$(185)
SQR BA SHIFT-@ CHR$(186)
RND BB C= + F CHR$(187)
LOG BC C= + C CHR$(188)
EXP BD C= + X CHR$(189)
COS BE C= + V CHR$(190)
SIN BF C= + B CHR$(191)
TAN C0 SHIFT-* CHR$(192)
ATN C1 SHIFT-A CHR$(193)
PEEK C2 SHIFT-B CHR$(194)
LEN C3 SHIFT-C CHR$(195)

Example: To output INT(RND(0)*16+5), convert keywords and mathematical operators to their token equivalents. The completed command appears visually as shown below:

Close the expression with ] to execute it. Any syntax error within the expression will generate the same error BASIC normally produces. For this reason, access to £[ should be restricted to trusted users.

Automatic Keyword Cruncher

To avoid manually entering tokens, place a greater-than symbol (>) immediately after the opening bracket:

£[>int(rnd(0)*16+5)]

This version is easier to type and read, though slightly slower in execution. Comparison:

Automatic Keyword Cruncher Example "int(rnd(0)*16+5)"
With Automatic Keyword Cruncher Without Automatic Keyword Cruncher

MCI Command Security

Access levels for £a and £[ are configurable in SETUP. If a caller lacks permission, the system prevents entry of the command. The message loader also filters unauthorized usage.

Internally, allowed commands are converted to special characters. For example, the “a” in £a is stored as F2. The “[" in £[ is stored as F4. These function-key characters cannot be entered directly by online callers, preventing unauthorized command injection.

Using MCI Commands in BASIC

When programming in BASIC, you must enter £a and £[ using their internal representations. Instead of typing “£a”, enter “£” followed by F2. For Variable MCI, enter “£” followed by F4. These appear visually as £a and £[, but internally use protected characters.

Next Section: Text Editing Features

BBS Operation

Retrieved from "https://www.color64wiki.itchybutt.org/index.php?title=Mcicommands&oldid=873"