ALeXiA BASIC :: INSTRUCTIONS

the power to assimilate and conquer the world wide web
HOME :: ABOUT :: CHEATSHEET :: INSTRUCTIONS :: VIDEOS :: DOWNLOAD :: BUY :: BLOG

IMPORTANT: You should seriously consider loading and printing the (one page!) cheatsheet first. It's an incredibly useful reference that will help you create Alexia BASIC spells very quickly and easily.

The instructions on this page are useful if you want some code samples and more detailed information about commands, user inuput variables, system variables, and web form variables.

HINT: Depending on what browser you're using to view this page, you can click on CTRL-F (or its equivalent) to "search" this page for whatever you're seeking.


INTRODUCTION

There are three major areas within the Alexia BASIC interface:

Alexia BASIC Layout

Section (1) is the spell window. This is the area where spells are typed in or loaded by clicking on the 'LOAD' button. Spells that are type into the spell window can also be saved by clicking on the 'SAVE' button.

Section (2) is the emulated computer screen window. This is the area where output that is printed by spells can be displayed.

Section (3) is the webview window of a chromium embedded framework browser. Upon loading Alexia BASIC it displays an animated splash screen image. The webview window is where any websites that are visited are displayed.

As we begin reviewing commands and producing example code, you will notice that all the relevant code samples include comments that are preceeded by the single quote symbol. You can safely cut and paste the comments and code into Alexia BASIC.

'This is a comment
PRINT < ...and this is actual code. >

GENERAL COMMANDS

CLS

CLear the Screen. As this simple acronym suggests, the CLS command enables you to clear the emulated computer screen window.

'To clear the emulated computer screen window, just use 
'the CLS command as depicted in this example

CLS
PRINT < *|sv|uiv >

Prints free form typing (*), system variables (sv), and user input variables (uiv) to the emulated computer screen window.

You can find a list of system variables and user input variables at the bottom of this page or on the cheat sheet.

'This prints the free form typing (*) message onto the emulated
'computer screeen window.

PRINT < Hello, world! >

In addition to printing free form typing (*) you can also print system variables (sv) as you can see from the following examples:

'This uses the system variable (sv) $stockprice, and in this example 
'prints the stock price for a company called Chicago Bridge & Iron
'to the emulated computer screen window. 

PRINT < $stockprice[cbi] >
'This uses the system variable (sv) $month, and in this example 
'prints the current month in a fully spelled out manner to the
'emulated computer screen window.

PRINT < $month >

You can also combine system variables that do not rely upon additional input into the same PRINT command.

'This uses the system variables (sv) $day, $month, and $time and 
'in this example prints the current day, month, and time to the
'emulated computer screen window.

PRINT < $day $month $time >
'This uses the system variables (sv) $day, $month, and $time and 
'in this example includes free form typing (*). Everything is then
'printed onto the emulated computer screen window.

PRINT < Today is, $day. It's the month of $month. The time is $time. >

There are currently 6 system variables that cannot be combined with any other system variables within a PRINT command: (1) $math[+/-*] (2) $random[#,#] (3) $rot13[*|wb] (4) $weather[zip] (5) $stockprice[tick] (6) $gibberish[#]

The reason why these 6 system variables (sv) cannot be combined with any other system variables (sv) within a PRINT command is because of the miscellaneous nature of the user input that needs to be included in each system variable (sv).

As you will soon see, the way to include these 6 system variables (sv) within a PRINT command alongside other system variables is to first put the system variable (sv) you want to include in a PRINT statement into a user input variable (uiv).

Speaking of user input variables (uiv), here's an example of how they're used:

'This uses the system variables (sv) $stockprice and $day, and 
'in this example includes free form typing (*). We PUT the $stockprice
'result into the user input variable (uiv) $numberbox1 and then it
'all gets printed onto the emulated computer screen window.

PUT < $stockprice[cbi] > INTO < $numberbox1 >
PRINT < Today is $day. CBI's stock is trading at $numberbox1! >
PUT < *|sv|uiv > INTO < uiv >

This command allows you to put free form typing (*), system variables (sv), and the data contained within user input variables (uiv) into user input variables. Let's start with some simple examples.

'This uses the user input variables (uiv) $Wordbox1 and $Wordbox2 as 
'well as free form typing (*). You will notice that capitalization is 
'not important when it comes to the use of UseR iNpuT vAriAbles (uiv). 
'We PUT the word Alexia into $wordbox1 and put the word BASIC into
'$wordbox2 and then use the PRINT command to print the output onto
'the the emulated computer screen window.

PUT < Alexia > INTO < $WORDBOX1 >
PUT < BASIC > INTO < $Wordbox2 >
PRINT < My name is $WORDBOX1 $wordbox2. >

Here is another example...

'This uses the user input variables (uiv) $numberbox1 and $numberbox2
'as well as free form typing (*). We also use the system variable (sv)
'$math as part of this example. We put 5 into $numberbox1. Then we put
'the result of $math[$numberbox1+5] into $numberbox2. Notice how we
'are adding the contents of $numberbox1 with the number 5 and placing
'the result of that mathematical calculation into $numberbox3. We then  
'We PUT the word Alexia into $wordbox1 and put the word BASIC into
'use the PRINT command to print the output onto the the emulated 
'computer screen window along with some free form typing (*).

PUT < 5 > INTO < $numberbox1 >
PUT < $math[$numberbox1+5] > INTO < $numberbox3 >
PRINT < The total is: $numberbox3 >

...and another example...

'This places system value (sv) $rot13 with the free form typing (*) 
'phrase "Hello, world!" into user input variable (uiv) $wordbox1 and
'then print the output onot the emulated computer screeen window.

PUT < $rot13[Hello, world!] > INTO < $wordbox1 >
PRINT < $wordbox1 >

If you're wondering, the system variable (sv) $rot13 is a simple letter substitution cipher that replaces a letter with the letter 13 letters after it in the alphabet. This is a special case of the Caesar cipher, developed in ancient Rome.

Here is one more example of how to use the PUT INTO command:

'This places free form typing (*) words, separated by a pipe "|",
'into user input variable (uiv) $listbox1. Since each word is 
'separated by a pipe "|", each word is placed on a new line inside
'of $listbox1. We then print the output onot the emulated computer 
'screeen window. Each word appears on a new line. Finally, we use
'the EMPTY command to empty $listbox1.

PUT < Alexia|BASIC|is|amazing > INTO < $listbox1 >
PRINT < $listbox1 >
EMPTY < $listbox1 >
INPUTBOX < * > INTO < wb|nb >

The INPUTBOX command prompts the user to input data according to the question asked in the free form typing (*) space in the first parameter, and then puts that data into either user input variables (uiv) $wordbox[1-4], or $numberbox[1-4].

'This asks a user what their name is, and then places the reply
'provided by the user into user input variable (uiv) $wordbox1.
'Finally, the PRINT command is used to output the result to the
'emulated computer screen window.

INPUTBOX < What is your name? > INTO < $wordbox1 >
PRINT < Your name is $wordbox1 >

Here is another example, which creates a simple calculator:

'When prompted, the user is asked to enter a math formula. Try
'providing the following: (5+5)*5  This math formula gets placed
'into $numberbox1. Next, the system variable (sv) $math is used
'to compute the formula and print 50, which is the result of 
'first adding 5+5, and then multiplying the sum by 5.

INPUTBOX < Enter the math formula I should solve: > INTO < $numberbox1 >
PRINT < $math[$numberbox1] >
INPUTPOP < * > INTO < wb|nb >

The INPUTPOP command prompts the user via a popup box to input data according to the question asked in the free form typing (*) space in the first parameter, and then puts that data into either user input variables (uiv) $wordbox[1-4], or $numberbox[1-4].

'This asks a user what their name is, and then places the reply
'provided by the user into user input variable (uiv) $wordbox1.
'Finally, the PRINT command is used to output the result to the
'emulated computer screen window.

INPUTPOP < What is your name? > INTO < $wordbox1 >
PRINT < Your name is $wordbox1 >

Here is another example, which creates a simple calculator:

'When prompted, the user is asked to enter a math formula. Try
'providing the following: (5+5)*5  This math formula gets placed
'into $numberbox1. Next, the system variable (sv) $math is used
'to compute the formula and print 50, which is the result of 
'first adding 5+5, and then multiplying the sum by 5.

INPUTPOP < Enter the math formula I should solve: > INTO < $numberbox1 >
PRINT < $math[$numberbox1] >
EMPTY < uiv|all >

The EMPTY command empties any specific user input variable (uiv) that you specify, or if you indicate "all", then all user input variables (uiv) are emptied.

Here is an exmaple of when this can be extremely useful:

'We place the numbers 1 through 8 inside user input variable (uiv)
'$listbox1, with each number occupying a separate line inside $listbox1 
'because each number has a pipe "|" symbol between them. We then 
'print the contents of $listbox1 onto the emulated computer screen
'window followed by a dash --- line. We then put the words Alexia
'and BASIC into $listbox1. Since there is already data inside of
'$listbox1, the words Alexia and BASIC are appended to the end
'of $listbox1, as evidenced by what happens when we then use the
'PRINT command to print what is inside $listbox1 followed once again
'by a dash --- line. We then use the EMPTY command to empty $listbox1
'of all the data it contains. We then PUT the words Alexia and BASIC
'into $listbox1 again, each word separated by a pipe "|" symbol so
'each word goes into a separate line within $listbox1, and then we
'use the PRINT command again to print the contents of $listbox1 onto
'the emulated computer screen window. The result is just the words
'Alexia and BASIC (on separate lines) because we used the EMPTY
'command to empty the contents of $listbox1 before adding new data.   

PUT < 1|2|3|4|5|6|7|8 > INTO < $listbox1 >
PRINT < $listbox1 >
PRINT < --- >
PUT < Alexia|BASIC > INTO < $listbox1 > 
PRINT < $listbox1 >
PRINT < --- >
EMPTY < $listbox1 >
PUT < Alexia|BASIC > INTO < $listbox1 >
PRINT < $listbox1 >
NOTICE < *|wb|nb >

The NOTICE command will create a pop-up window brings up a free form typing (*) message, or the contents of user input variables (uiv) $wordbox[1-4] or $numberbox[1-4]. The pop-up window will vanish once the user clicks the "OK" button that appears immediately beneath the pop-up window.

Here is an example of how the NOTICE command can be used in a creative way:
'We ask the user for their US-based 5 digit zip code and place that
'data into user input value (uiv) $numberbox1. We then PUT the $weather
'system variable (sv) which includes the data inside $numberbox1 into
'$Wordbox1. This adds a verbal description of the current weather
'conditions at the location specified by the ZIP code into $Wordbox1.
'We then PUT the $weather system variable (sv) data into $Numberbox1.
'This adds a numerical description of the current weather temperature
'at the location specified by the ZIP code into $Numberbox1. We then
'finish the spell by using the NOTICE command to output a description 
'of the weather conditions and temperature at the location specified
'by the 5 digit zip code.

INPUTBOX < What is your zip code? > INTO < $Numberbox1 >
PUT < $weather[$numberbox1] > INTO < $Wordbox1 >
PUT < $weather[$numberbox1] > INTO < $Numberbox2 > 
NOTICE < The weather is $WORDBOX1 with temperatures hovering around $NUMBERBOX1 degrees. >

You can also use the NOTICE command as a way to stop your spell from being executed until the "OK" button is clicked beneath the pop-up window generated by the NOTICE command.

'This will print output to the emulated computer screen window
'and then the NOTICE command will prompt the user to click on the
'OK button that appears beneath the pop-up window generated by
'the NOTICE command. Finally, the total of the mathematical 
'equation is printed onto the emulated computer screen window.

PRINT < The total is... >
NOTICE < Click on OK >
PRINT < $math[10000/35] >
REM < * >

The REM command is short for REMARK, and is another way of including comments in your spells. Here is a quick example of how the REM command can be used:

REM < The code that follows will print Alexia BASIC to the >
REM < emulated computer screen window. >
PRINT < Alexia BASIC >

Bare in mind that the option also exists to simply used a single quotation mark ( ' ) at the beginning of a line to denote that what follows will be a comment.

SAY < *|wb|nb >

The SAY command brings your computer system to life by giving it a voice. You can include free form typing (*), and the user input variables (uiv) $Wordbox[1-4] and $Numberbox[1-4].

'We begin by using the PUT command to place an emotion
'into user input variable (uiv) $wordbox1. We then use the
'SAY command have our system speak the words aloud. Make
'sure your speakers are turned on.

PUT < $emotion > INTO < $wordbox1 >
SAY < I am feeling $wordbox1 right now. >
GOTO < *|wb >

The GOTO command performs a one-way transfer of control to another line of code identified by a @label that must begin with the at "@" symbol immediately followed without spaces by the label name.

'We place the result of a system variable (sv) $cointoss into 
'the user input variable (uiv) $wordbox1. So that we can better
'see what is happening, we PRINT the contents of $wordbox1 to
'the emulated computer screen window. We then see a label called
'@tryagain. There is then an INPUTBOX command asking the user 
'to pick either heads or tails. The value of what the user types 
'in is placed into $wordbox2. An IF NOT EQUAL TO analysis command
'is used to determine if the contents of $wordbox1 is not equal
'to the contents of $wordbox2. If there is no match, the NOTICE
'command is used to tell the user that a wrong choice was made,
'and then tells the user to try again. After the user clicks on
'the OK button that appears beneath the NOTICE command pop-up
'window, the GOTO command is executed. The GOTO command performs
'a one-way transfer of control to the label identified within the
'GOTO command, which in this case, is the @tryagain label. At
'this point, Alexia BASIC executes the next command which is the
'INPUTBOX command. This process will repeat indefinitely until
'the correct guess is made, at which point a NOTICE command will
'congratulate the user on winning.

PUT < $cointoss > INTO < $wordbox1 >
PRINT < $wordbox1 >
@tryagain
INPUTBOX < Heads or tails? > INTO < $wordbox2 >
IF < $wordbox1 > NOT EQUAL TO < $wordbox2 > THEN --
NOTICE < Sorry, wrong choice. Try again! >
GOTO < @tryagain >
-- END IF
NOTICE < Congratulations, you win! >
SLEEP < *|nb >

The SLEEP command pauses whatever spell is being cast for a period of time. The period of time during which a spell should SLEEP is defined in seconds, and can be represented by free form typing (*) numerical input, or alternatively by the numerical contents of a $numberbox[1-4] user input variable (uiv).

'We use the REPEAT command to tell Alexia BASIC 
'to PRINT the words Alexia BASIC a total of 10 
'times, making sure to SLEEP for 1 second between
'each REPEAT cycle.

REPEAT < 10 > TIMES --
PRINT < Alexia BASIC >
SLEEP < 1 >
-- END REPEAT
INCREMENT < nb >

The INCREMENT command adds 1 to the existing numerical value contained within a $numberbox[1-4] user input variable (uiv).

'We clear the screen. Then we empty the value of all user input
'variables. Then we PUT the number 0 into $numberbox1. Then we 
'PRINT the contents of $numberbox1. Then we increment $numberbox1.
'Finally, we PRINT the contents of $numberbox1 again, and we see
'that the numerical value has increased from 0 to 1.

CLS
EMPTY < all >
PUT < 0 > INTO < $numberbox1 >
PRINT < $numberbox1 >
INCREMENT < $numberbox1 >
PRINT < $numberbox1 >
DECREMENT < nb >

The DECREMENT command subtracts 1 from the existing numerical value contained within a $numberbox[1-4] user input variable (uiv).

'We clear the screen. Then we empty the value of all user input
'variables. Then we PUT the number 1 into $numberbox1. Then we 
'PRINT the contents of $numberbox1. Then we decrement $numberbox1.
'Finally, we PRINT the contents of $numberbox1 again, and we see
'that the numerical value has decreased from 1 to 0.

CLS
EMPTY < all >
PUT < 1 > INTO < $numberbox1 >
PRINT < $numberbox1 >
DECREMENT < $numberbox1 >
PRINT < $numberbox1 >
CHART < lb > AS < line|bar >

The CHART command generates either a line chart or a bar chart within the Alexia BASIC webview window using the data contained within a $listbox[1-4] user input value (uiv).

'We empty the contents of user input variable (uiv) $listbox1.
'Then we REPEAT a PUT command 10 times in which a $random system
'variable (sv) picks a number between 0 and 100 and places the
'number into $listbox1. After we -- END REPEAT, we issue the 
'CHART command to create a line chart within the Alexia BASIC
'webview window with the data contained within $listbox1.

EMPTY < $listbox1 >
REPEAT < 10 > TIMES --
PUT < $random[0,100] > INTO < $listbox1 > 
-- END REPEAT
CHART < $listbox1 > AS < line >
REPEAT < *|nb|lb[ls] > TIMES --
-- END REPEAT

The REPEAT command performs a sequence of instructions however many times specified. Exactly how many times the REPEAT command should perform the sequence of instructions contained within its enclosed loop can be specified with numerical free form typing (*), a user input variable (uiv) that is either a $numberbox[1-4] or a $listbox[1-4] that includes a special modifier of [listsize].

Let's review two examples:

'We start by putting the number 1 into $numberbox1.
'Then we use the REPEAT command to indicate that a 
'the sequence of instructions contained between REPEAT 
'and -- END REPEAT be peformed 3 times. We then use
'the PRINT command to output the words Alexia BASIC
'followed by the contents of $numberbox1 onto the
'emulated computer screen window. The INCREMENT command
'is used to add 1 to the value of $numberbox1. Finally,
'we use -- END REPEAT to indicate the end of REPEAT.

PUT < 1 > INTO < $numberbox1 >
REPEAT < 3 > TIMES --
PRINT < Alexia BASIC $numberbox1 >
INCREMENT < $numberbox1 >
-- END REPEAT

Here is another example. This example will use $listbox1[listsize] as the means through which to tell the REPEAT command how many times to perform a sequence of instructions contained within its enclosed loop:

'We start by emptying all the user input variables (uiv).
'We then use the VISIT command to visit Google news. The web 
'page is loaded into the webview window. We use the PUT
'command and the system variable (sv) $links to put all the
'links contained on the main Google news website page into
'user input variable (uiv) $listbox1. We then use REPEAT and
'specify that the sequence of instructions contained within
'the REPEAT enclosed loop should be repeated the number of
'times that is represented by the size of the list of links
'that is contained within $listbox1. Within the REPEAT
'enclosed loop, we use the VISIT command in conjunction with
'the SEQUENTIAL modifier to have Alexia BASIC visit each of the
'web links contained inside of $listbox1, loading each website
'into the webview window in sequential order, one after another.

EMPTY < all >
VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
REPEAT < $listbox1[listsize] > TIMES --
VISIT < $listbox1 > SEQUENTIAL
-- END REPEAT

One final example...

'We start by using the system variable $random to place
'a random number between 1 and 10 into the user input
'variable (uiv) $numberbox1. We then place $numberbox1
'into the REPEAT command so that REPEAT will peform the
'enclosed loop the number of times defined by the numerical
'value contained within $numberbox1. We then use the
'PRINT command to specify that the words Alexia BASIC be
'sent to the emulated computer screen window as many times
'as specified within the REPEAT commmand. We then have the
'-- END REPEAT closing command to specify the end of the
'enclosed loop.

PUT < $random[1,10] > INTO < $numberbox1 >
REPEAT < $numberbox1 > TIMES --
PRINT < Alexia BASIC >
-- END REPEAT
REMOVE < * > FROM < uiv >

The REMOVE command allows you to completely remove the entire row of contents within any user input variable (uiv) that contains the word or phrase that you specify.

'We start by emptying the user input variable (uiv) $listbox1,
'then we use the SEARCH FOR ON command to search for the
'keyword Bitcoin on the Bing search engine. The results
'of the search are displayed in the webview window. We then
'use the system variable (sv) $links and PUT all the $links
'contained on the search results page into $listbox1. We then
'use the REMOVE FROM command to remove any links within the
'list contained in $listbox1 that contain the word microsoft,
'and we do this again and remove any links within $listbox1
'that contain the word bing. Finally, we use the PRINT command
'to print the contents of $listbox1 onto the emulated computer
'screen window so we can see the contents of the $listbox1.

EMPTY < $listbox1 >
SEARCH FOR < Bitcoin > ON < Bing >
PUT < $links > INTO < $listbox1 >
REMOVE < microsoft > FROM < $listbox1 >
REMOVE < bing > FROM < $listbox1 >
PRINT < $listbox1 >

REMOVE FROM < uiv > IF NOT < * >

The REMOVE FROM command allows you to completely remove the entire row of contents within any user input variable (uiv) that DOES NOT CONTAIN the word or phrase that you specify.

'We start by emptying the user input variable (uiv) $listbox1,
'then we use the SEARCH FOR ON command to search for the
'keyword iPhone on the Google search engine. The results
'of the search are displayed in the webview window. We then
'use the system variable (sv) $links and PUT all the $links
'contained on the search results page into $listbox1. We then
'use the REMOVE FROM command to remove any links within the
'list contained in $listbox1 if it does not contain the word 
'apple. Finally, we use the PRINT command to print the 
'contents of $listbox1 onto the emulated computer screen window 
'so we can see the contents of the $listbox1.

EMPTY < $listbox1 >
SEARCH FOR < iPhone > ON < Google >
PUT < $links > INTO < $listbox1 >
REMOVE FROM < $listbox1 > IF NOT < apple >
PRINT < $listbox1 >

REPLACE < * > WITH < * > IN < uiv >

The REPLACE command enbales you to replace the contents of the first parameter with the contents of the second parameter in a user input variable (uiv).

IMPORTANT: The input provided in the first and second parameters are CaSe SeNsiTivE.


'First we place the words Alexia BASIC Sucks into
'the user input variable $wordbox1. Note the casing
'of the words, especially the word Sucks. The first
'letter of the word is capitalized. We print the
'content of $wordbox1 onto the emulated computer
'screen window. Next we use the REPLACE WITH command
'to replace the word Sucks with the word Rocks. It is
'important to note that the word Sucks needed to be
'capitalized in the firt parameter because that is how
'the word appears inside $wordbox1. Finally, we print
'the contents of $wordbox1 to the emulated computer
'screen and see that the word Sucks has been replaced
'by the word Rocks.

PUT < Alexia BASIC Sucks > INTO < $wordbox1 >
PRINT < $wordbox1 >
REPLACE < Sucks > WITH < Rocks > IN < $wordbox1 >
PRINT < $wordbox1 >

WEBVIEW COMMANDS

The webview commands control the Alexia BASIC window that is powered by a chromium embedded framework browser.

WEBVIEW < on|off >

Alexia BASIC's webview window of a chromium embedded framework browser is on by default when you start Alexia BASIC.

By turning WEBVIEW to the off position, Alexia BASIC uses the chromium embedded framework browser to connect with the world wide web without graphically rendering or displaying HTML, showing ads, loading images, loading Javascript, loading CSS, and/or loading Flash.

This means you get BLAZING FAST access to all the data on whatever website Alexia BASIC is visiting without the delays and hangups that are common on media-rich websites that have lots of ads, images, Javascript, that are generally bloated.

Here's an example of the WEBVIEW command in action:

'We start by using the PRINT command to display a the $time
'system variable which represents the current hour, minute, 
'and second of time. We then use the WEBVIEW command to turn
'the webview browser window off. We then VISIT the media heavy
'website TMZ. Next, we use the PRINT command to output all the 
'links that are on the TMZ website to the emulated computer
'screen window. We finally use the PRINT command again to 
'output the current hour, minute, and second of time. Your
'Internet speed will be a factor in determining how quickly
'Alexia BASIC gets this done. In our test, it took 3 seconds.

PRINT < $time >
WEBVIEW < off >
VISIT < http://www.tmz.com >
PRINT < $links >
PRINT < $time >

DELETE COOKIES

The DELETE COOKIES command enables you to delete all the cookies for whatever website you visit.


'We use the VISIT command to visit the UK version of the
'YouTube website, and then we immediately visit the non-
'geographic .com version of the YouTube website. However,
'a cookie has already been set and YouTube indicates we 
'are using the GB (Great Britain) version of YouTube. We
'then use the DELETE COOKIES command, and then we use the
'SLEEP command to stop the spell from being cast for 5
'seconds. Finally, we re-visit the non-geographic .com 
'version of the YouTube website and see that the cookie
'originally set by YouTube UK has been deleted and now we
'are presented with the non-geographic version of YouTube. 

VISIT < http://www.youtube.co.uk >
visit < http://www.youtube.com >
DELETE COOKIES
SLEEP < 5 >
VISIT < http://www.youtube.com >
SPOOF HEADER < * > WITH < * >

The SPOOF HEADER allows you to change the header settings of the Alexia BASIC chromium embedded framework browser. When you falsify the browser header data using the SPOOF HEADER command, future browser usage reflects the header settings you change using the SPOOF HEADER command.

There are over 30 different header settings that you can change using the SPOOF HEADER command, including:

Accept, Accept-Charset, Accept-Encoding, Accept-Language, Accept-Datetime, Authorization, Cache-Control, Connection, Cookie, Content-Length, Content-MD5, Content-Type, Date, Expect, From, Host, If-Match, If-Modified-Since, If-None-Match, If-Range, If-Unmodified-Since, Max-Forwards, Origin, Pragma, Proxy-Authorization, Range, Referrer, TE, User-Agent, Upgrade, Via, and Warning.

It's beyond the scope of these instructions to provide a detailed description of what each of these browser header setting mean, but more information can be found at the Header Field Definitions page maintained by the World Wide Web Consortium (W3C).

'We use the VISIT command to visit the IPChicken website,
'and we scroll down a little bit and see what it says next
'to the browser setting. The SLEEP command gives us 10
'seconds to make the aforementioned visual notation. Then 
'the SPOOF HEADER command is used and we specifically spoof
'the User-Agent setting to reflect the data we provide in
'the second parameter of the SPOOF HEADER command. Finally,
'we visit the IPChicken website again and make a visual note
'of what it says beside the browser setting. Our spoofed 
'header should reflect the new data we provided.
  
VISIT < http://www.ipchicken.com >
SLEEP < 10 >
SPOOF HEADER < User-Agent > WITH < AlexiaBASIC/1.0 (IBM PC XT; DOS v3.2) >
VISIT < http://www.ipchicken.com >
UNSPOOF HEADER

The UNSPOOF HEADER command reverts the header settings of the Alexia BASIC chromium embedded framework browser to their default settings.

'We use the VISIT command to visit the IPChicken website,
'and we scroll down a little bit and see what it says next
'to the browser setting. The SLEEP command gives us 10
'seconds to make the aforementioned visual notation. Then 
'the SPOOF HEADER command is used and we specifically spoof
'the User-Agent setting to reflect the data we provide in
'the second parameter of the SPOOF HEADER command. Finally,
'we visit the IPChicken website again and make a visual note
'of what it says beside the browser setting. Our spoofed 
'header should reflect the new data we provided. After 
'going to sleep for 10 additional seconds, the UNSPOOF HEADER
'command is used to revert the header to their default
'settings, and then the IPChicken website is loaded again
'allowing us to see the change in the browser setting.
  
VISIT < http://www.ipchicken.com >
SLEEP < 10 >
SPOOF HEADER < User-Agent > WITH < AlexiaBASIC/1.0 (IBM PC XT; DOS v3.2) >
VISIT < http://www.ipchicken.com >
SLEEP < 10 >
UNSPOOF HEADER
VISIT < http://www.ipchicken.com >
PROXY USERNAME < * > PASSWORD < * >

The PROXY USERNAME PASSWORD command will allow the Alexia BASIC chromium embedded framework browser to set the credentials for a proxy that requires a username and password in order to run.

It is important to use the PROXY USERNAME PASSWORD command before the USE PROXY command for any proxy that requires a username and password for access.

'We enter the relevant username, which in this example is
'simply the word Alexia, and we then enter the relevant
'password, which in this example us Proxy123. By doing this
'we establish the credentials that the proxy service will
'need prior to using the command USE PROXY to select the
'new IP address that Alexia BASIC should use. 

PROXY USERNAME < Alexia > PASSWORD < Proxy123 > 
USE PROXY < ip:port|lb|none >

The USE PROXY command allows the Alexia BASIC chromium embedded framework browser to use whatever proxy you place into it when formatted as ip:port, and can also accept proxies that are inside a $listbox[1-4] user input variable (uiv). You can also go back to the default IP address by using the none parameter within the USE PROXY command.

'We load a fairly reliable proxy server using the USE PROXY
'command, and place an IP address and port number into the 
'USE PROXY command following the ip:port format. We then use
'the VISIT command to load the IPChicken website. We can see
'the IP address being displayed is the one that we just loaded
'using the USE PROXY command. After using the SLEEP command
'for 10 seconds, the USE PROXY command is used again, this
'time specifying none, so that no proxy is used. We then visit
'the IPChicken website again and immediately see out default
'IP address being displayed by the website.

USE PROXY <207.46.157.153:80>
VISIT < http://www.ipchicken.com >
SLEEP < 10 >
USE PROXY < none >
VISIT < http://www.ipchicken.com >

TYPE < * > INTO < *|wfv >

The TYPE INTO command enables Alexia BASIC to type words, numbers, or whatever other information you wish you input on a website.

'We visit the Alexia BASIC Labyrinth, then we use the
'TYPE INTO command to input the words AlexiaBASIC into
'the web from variable identified as username. Alexia
'BASIC will attempt to automatically locate the username
'input field on the page and enter the words AlexiaBASIC

VISIT < http://www.alexiabasic.com/labyrinth/ >
TYPE < AlexiaBASIC > INTO < username >
CLICK ON < * >

The CLICK ON command clicks on an element within the Alexia BASIC chromium embedded framework browser using the web form variables (wfv) as described at the bottom of this page.

'We use the VISIT command to visit the Example.com website,
'and then we use the CLICK ON command along with a web form
'variable (wfv) modifier to click on the link whose text
'says "More information..."

VISIT < http://www.example.com >
CLICK ON < linktext="More information..." >

Rememeber, you can see what HTML inputs are on a website you are visiting by using the PRINT < $htmlinputs > command, which will output all the relavent HTML form input types as well as buttons to the emulated computer screen window.

CHANGE DROPDOWN < *|wfv > TO < * >

The CHANGE DROPDOWN TO command allows you to change the dropdown value of an HTML form element within the Alexia BASIC chromium embedded framework browser using free form typing and the web form variables (wfv) as described at the bottom of this page.

'We visit the Alexia BASIC Labyrinth, then we use the
'CHANGE DROPDOWN command to select the female gender from
'the web from variable identified as sexchoice. Alexia
'BASIC will attempt to automatically locate the sexchoice
'gender option field on the page and select female.

VISIT < http://www.alexiabasic.com/labyrinth/ >
CHANGE DROPDOWN < sexchoice > TO < female >
CHANGE CHECKBOX < *|wfv > TO < checked|unchecked >

The CHANGE CHECKBOX TO command allows you to check or uncheck an HTML form input checkbox within the Alexia BASIC chromium embedded framework browser using free form typing and the web form variables (wfv) as described at the bottom of this page.

'We visit the Alexia BASIC Labyrinth, then we use the
'CHANGE CHECKBOX command to check the terms of service
'checkbox from the web from variable identified as
'termsrvc. Alexia BASIC will attempt to automatically 
'locate the terms of service checkbox field on the page 
'and change it from being unchecked to checked.

VISIT < http://www.alexiabasic.com/labyrinth/ >
CHANGE CHECKBOX < termsrvc > TO < checked >
VISIT < * >

The VISIT command directs the Alexia BASIC chromium embedded framework browser to visit the web address specified by the free form typing within the command.

'We visit the Alexia BASIC website and the site is loaded within 
'the Alexia BASIC chromium embedded framework browser.

VISIT < http://www.alexiabasic.com >
 
VISIT < * > EXTERNAL

The VISIT EXTERNAL command directs the Windows operating system in which Alexia BASIC is running to load the web address specified by the free form typing within the command within the default external browser.

'We visit the Alexia BASIC website and the site is loaded within 
'the default external web browser by the Windows operating system.

VISIT < http://www.alexiabasic.com > EXTERNAL
 
VISIT < lb > RANDOM

The VISIT RANDOM command directs the Alexia BASIC chromium embedded framework browser to visit a random web address in the $listbox[1-4] user input variable (uiv) specified within the command.

'We visit the Slashdot website and the site is loaded within 
'the Alexia BASIC chromium embedded framework browser. We then
'use the PUT INTO command along with the $links system variable (sv)
'to place all the links contained within the web page into the 
'$listbox1 user input variable (uiv). Finally, we use the VISIT
'RANDOM command to randomly visit a web address within $listbox1.

VISIT < http://www.slashdot.org >
PUT < $links > INTO < $listbox1 >
VISIT < $listbox1 > RANDOM
 
VISIT < lb > SEQUENTIAL

The VISIT SEQUENTIAL command directs the Alexia BASIC chromium embedded framework browser to visit a web address in the $listbox[1-4] user input variable (uiv) specified within the command in sequential order.

'We visit the Slashdot website and the site is loaded within 
'the Alexia BASIC chromium embedded framework browser. We then
'use the PUT INTO command along with the $links system variable (sv)
'to place all the links contained within the web page into the 
'$listbox1 user input variable (uiv). We then use the REPEAT
'command along with the $listbox1[listsize] user input variable (uiv)
'to have Alexia BASIC execute the instructions wihtin the REPEAT
'loop. How many times should the loop repeat? The same number as
'the the size of the list within $listbox1. Finally, we use the 
'VISIT SEQUENTIAL command to sequentially visit the web addresses 
'within $listbox1 in sequential order.

VISIT < http://www.slashdot.org >
PUT < $links > INTO < $listbox1 >
REPEAT < $listbox1[listsize] >
VISIT < $listbox1 > RANDOM
-- END REPEAT
 
SEARCH FOR < *|uiv > ON < google | bing | duckduckgo | twitter | facebook | wikipedia | youtube >

The SEARCH FOR command allows you to search for anything specified via free form typing (*) or anything contained within a user input variable (uiv) within the following platforms: Google, Bing, DuckDuckGo, Twitter, Facebook, Wikipedia, and YouTube.


'We use the SEARCH FOR command to seek information about
'the game Super Meat Boy on Wikipedia. This command performs
'the search within the Alexia BASIC chromium embedded framework 
'browser and displays the results of the search.

SEARCH FOR < Super Meat Boy > ON < wikipedia >

ANALYSIS COMMANDS

The Alexia BASIC analysis commands enable you to control your spells.

It's important to remember that the only SYSTEM VARIABLES (^sv) that can be used within ANALYSIS commands are: $url, $title, $description, $keywords, $pagetext -- in other words, it's a limited subset of the system variables.

You can always use the PUT INTO command to put ANY system variable (sv) into a user input variable (uiv) and perform the analysis based on what's contained within the specified user input variable (uiv) that contains the system variable (sv).

IF < *|^sv|uiv > CONTAINS < *|uiv > THEN --
-- END IF

The IF CONTAINS THEN command determins if something should happen if the specified free form typing (*), subset system variables (^sv), or user input variables (uiv) contain the specified free form typing (*) or user input variables (uiv).


'We use the VISIT command to visit Google News.
'Then we use the PUT INTO command to put the
'system variable (sv) $links into a user input
'variable (uiv) called $listbox1. We then use
'the IF CONTAINS THEN command to determine if
'$listbox1 contains the word bitcoin. If true,
'then we use the REMOVE FROM IF NOT command to
'remove any links from within $listbox1 if they 
'don't contain the word bitcoin. 
 
VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
IF < $listbox1 > CONTAINS < bitcoin > THEN --
REMOVE FROM < $listbox1 > IF NOT < bitcoin >
-- END IF

IF < *|^sv|uiv > CONTAINS < *|uiv > AND < *|uiv > THEN --
-- END IF

The IF CONTAINS AND THEN command determins if something should happen if the specified free form typing (*), subset system variables (^sv), or user input variables (uiv) contain the specified free form typing (*) or user input variables (uiv) and another specified free form typing (*) or user input variables (uiv).


'We use the VISIT command to visit Google News.
'Then we use the PUT INTO command to put the
'system variable (sv) $links into a user input
'variable (uiv) called $listbox1. We then use
'the IF CONTAINS THEN command to determine if
'$listbox1 contains the word bitcoin and etherium. 
'If true, then we use the PRINT command to output 
'a message to the emulated computer screen window. 
 
VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
IF < $listbox1 > CONTAINS < bitcoin > AND < etherium > THEN --
PRINT < Found bitcoin and etherium! >
-- END IF

IF < *|^sv|uiv > CONTAINS < *|uiv > OR < *|uiv > THEN --
-- END IF

The IF CONTAINS OR THEN command determins if something should happen if the specified free form typing (*), subset system variables (^sv), or user input variables (uiv) contain the specified free form typing (*) or user input variables (uiv) or another specified free form typing (*) or user input variables (uiv).


'We use the VISIT command to visit Google News.
'Then we use the PUT INTO command to put the
'system variable (sv) $links into a user input
'variable (uiv) called $listbox1. We then use
'the IF CONTAINS THEN command to determine if
'$listbox1 contains the word bitcoin or etherium. 
'If true, then we use the PRINT command to output 
'a message to the emulated computer screen window. 
 
VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
IF < $listbox1 > CONTAINS < bitcoin > OR < etherium > THEN --
PRINT < Found either bitcoin or etherium! >
-- END IF

IF < *|^sv|uiv > CONTAINS < *|uiv > AND DOES NOT CONTAIN < *|uiv > THEN --
-- END IF

The IF CONTAINS AND DOES NOT CONTAIN THEN command determins if something should happen if the specified free form typing (*), subset system variables (^sv), or user input variables (uiv) contain the specified free form typing (*) or user input variables (uiv) and does not contain another specified free form typing (*) or user input variables (uiv).


'We use the VISIT command to visit Google News.
'Then we use the PUT INTO command to put the
'system variable (sv) $links into a user input
'variable (uiv) called $listbox1. We then use
'the IF CONTAINS AND DOES NOT CONTAIN THEN command 
'to determine if $listbox1 contains the word bitcoin 
'and doea not contain etherium. If true, then we 
'use the PRINT command to output a message to the 
'emulated computer screen window. 
 
VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
IF < $listbox1 > CONTAINS < bitcoin > AND DOES NOT CONTAIN < etherium > THEN --
PRINT < This page contains bitcoin but does not contain etherium! >
-- END IF

IF < *|^sv|uiv > DOES NOT CONTAIN < *|uiv > THEN --
-- END IF

The IF DOES NOT CONTAIN THEN command determins if something should happen if the specified free form typing (*), subset system variables (^sv), or user input variables (uiv) does not contain the specified free form typing (*) or user input variables (uiv).


'We use the VISIT command to visit Google News.
'Then we use the PUT INTO command to put the
'system variable (sv) $links into a user input
'variable (uiv) called $listbox1. We then use
'the IF DOES NOT CONTAIN THEN command to determine 
'if $listbox1 does not contain the word bitcoin. If 
'true, then we use the PRINT command to output 
'a message to the emulated computer screen window. 
 
VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
IF < $listbox1 > DOES NOT CONTAIN < bitcoin > THEN --
PRINT < Listbox1 does not contain bitcoin! >
-- END IF

IF < *|^sv|uiv > DOES NOT CONTAIN < *|uiv > AND < *|uiv > THEN --
-- END IF

The IF DOES NOT CONTAIN AND THEN command determins if something should happen if the specified free form typing (*), subset system variables (^sv), or user input variables (uiv) does not contain the specified free form typing (*) or user input variables (uiv) and another specified free form typing (*) or user input variables (uiv).


'We use the VISIT command to visit Google News.
'Then we use the PUT INTO command to put the
'system variable (sv) $links into a user input
'variable (uiv) called $listbox1. We then use
'the IF DOES NOT CONTAIN AND THEN command to determine
'if $listbox1 contains the word bitcoin and etherium. 
'If true, then we use the PRINT command to output 
'a message to the emulated computer screen window. 
 
VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
IF < $listbox1 > DOES NOT CONTAIN < bitcoin > AND < etherium > THEN --
PRINT < Listbox1 does not contain bitcoin and does not contain etherium! >
-- END IF

IF < *|^sv|uiv > DOES NOT CONTAIN < *|uiv > OR < *|uiv > THEN --
-- END IF

The IF DOES NOT CONTAIN THEN command determins if something should happen if the specified free form typing (*), subset system variables (^sv), or user input variables (uiv) does not contain the specified free form typing (*) or user input variables (uiv) or another specified free form typing (*) or user input variables (uiv).


'We use the VISIT command to visit Google News.
'Then we use the PUT INTO command to put the
'system variable (sv) $links into a user input
'variable (uiv) called $listbox1. We then use
'the IF DOES NOT CONTAIN OR THEN command to determine
'if $listbox1 does not contain the word bitcoin or 
'etherium. If true, then we use the PRINT command to 
'output a message to the emulated computer screen window. 
 
VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
IF < $listbox1 > DOES NOT CONTAIN < bitcoin > OR < etherium > THEN --
PRINT < Found either bitcoin or etherium! >
-- END IF

IF < *|^sv|uiv > DOES NOT CONTAIN < *|uiv > AND DOES CONTAIN < *|uiv > THEN --
-- END IF

The IF DOES NOT CONTAIN AND DOES CONTAIN THEN command determins if something should happen if the specified free form typing (*), subset system variables (^sv), or user input variables (uiv) contain the specified free form typing (*) or user input variables (uiv) and does contain another specified free form typing (*) or user input variables (uiv).


'We use the VISIT command to visit Google News.
'Then we use the PUT INTO command to put the
'system variable (sv) $links into a user input
'variable (uiv) called $listbox1. We then use
'the IF CONTAINS AND DOES NOT CONTAIN THEN command 
'to determine if $listbox1 does not contain the 
'word gold and does contain cash. If true, then we 
'use the PRINT command to output a message to the 
'emulated computer screen window. 
 
VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
IF < $listbox1 > DOES NOT CONTAIN < gold > AND DOES CONTAIN < cash > THEN --
PRINT < This page does not contain gold and does contain cash! >
-- END IF

IF < *|wb|nb > EQUAL TO < *|wb|nb > THEN --
-- END IF

The IF EQUAL TO THEN command determines if something should happen if the specified free form typing (*), or user input variables (uiv) $wordbox[1-4] or $numberbox[1-4] are equal to the specified free form typing (*), or user input variables (uiv) $wordbox[1-4] or $numberbox[1-4]


'We start by using the PUT INTO command to place a random
'number (1 through 10) into the user input variable (uiv)
'named $numberbox1. Then we use the IF EUQAL TO THEN
'command to determine if $numberbox1 is equal to the
'number 4. If true, we then use the PRINT command to 
'output a message to the emulated computer screen window. 

PUT < $random[1,10] > INTO < $numberbox1 >
IF < $numberbox1 > EQUAL TO < 4 > THEN --
PRINT < Equal! >
-- END IF 
IF < *|wb|nb > NOT EQUAL TO < *|wb|nb > THEN --
-- END IF

The IF NOT EQUAL TO THEN command determines if something should happen if the specified free form typing (*), or user input variables (uiv) $wordbox[1-4] or $numberbox[1-4] are not equal to the specified free form typing (*), or user input variables (uiv) $wordbox[1-4] or $numberbox[1-4]


'We start by using the PUT INTO command to place a random
'number (1 through 10) into the user input variable (uiv)
'named $numberbox1. Then we use the IF EUQAL TO THEN
'command to determine if $numberbox1 is equal to the
'number 4. If true, we then use the PRINT command to 
'output a message to the emulated computer screen window. 

PUT < $random[1,10] > INTO < $numberbox1 >
IF < $numberbox1 > NOT EQUAL TO < 4 > THEN --
PRINT < Not Equal! >
-- END IF 
IF < *|nb > GREATER THAN < *|nb > THEN --
-- END IF

The IF GREATER THAN THEN command determines if something should happen if the specified free form typing (*) or user input variable (uiv) $numberbox[1-4] is greater than the specified free form typing (*) or user input variable (uiv) $numberbox[1-4]


'We start by using the PUT INTO command to place a random
'number (1 through 10) into the user input variable (uiv)
'named $numberbox1. Then we use the IF GREATER THAN THEN
'command to determine if $numberbox1 is greater than the
'number 4. If true, we then use the PRINT command to output 
'a message to the emulated computer screen window. 

PUT < $random[1,10] > INTO < $numberbox1 >
IF < $numberbox1 > GREATER THAN < 4 > THEN --
PRINT < Greater than 4! >
-- END IF 
IF < *|nb > LESS THAN < *|nb > THEN --
-- END IF

The IF LESS THAN THEN command determines if something should happen if the specified free form typing (*) or user input variable (uiv) $numberbox[1-4] is less than the specified free form typing (*) or user input variable (uiv) $numberbox[1-4]


'We start by using the PUT INTO command to place a random
'number (1 through 10) into the user input variable (uiv)
'named $numberbox1. Then we use the IF LESS THAN THEN
'command to determine if $numberbox1 is less than the
'number 4. If true, we then use the PRINT command to 
'output a message to the emulated computer screen window. 

PUT < $random[1,10] > INTO < $numberbox1 >
IF < $numberbox1 > LESS THAN < 4 > THEN --
PRINT < Less than 4! >
-- END IF 

FILE COMMANDS

The file commands allow you to save, load, and download things to (and from) files on your computer.

Generally speaking, if you don't use a full path to define a filename when using the file commands, the default path is to the cauldron folder within Alexia BASIC. This is what your Alexia BASIC structure looks like when you install the program:

Alexia BASIC ::
-> cauldron (where files are saved, loaded from and downloaded to)
-> spellbox (where your spells are saved and loaded from)
-> systemic (where Alexia BASIC system files are stored)

RUN FILENAME < * >

The RUN FILENAME command will run any executable program specified within the command.

'Run the Notepad program within the Windows OS.

RUN FILENAME < notepad.exe >

Here's another example:


'Run the program 'runme.exe' that's located in the
'specified directory.

RUN FILENAME < c:\users\whatever\folder\runme.exe >

DELETE FILENAME < * >

The DELETE FILENAME command will delete any file specified within the command.

'Delete the filename allthelinks.txt, and since we are
'not specifying a full path, Alexia BASIC will assume the
'filename specified is located in the cauldron folder. 

DELETE FILENAME < allthelinks.txt >

Here's another example:


'Delete the filename allthelinks.txt, and since we *are*
'specifying a full path, Alexia BASIC will delete that
'particular file located in the location specified.

DELETE FILENAME < c:\users\whatever\folder\allthelinks.txt >

RENAME FILENAME < * > TO < * >

The RENAME FILENAME command will rename the filename specified in the first parameter to the filename specified in the second parameter. Remember, if no full filename path is defined, Alexia BASIC assumes the file is located in the cauldron folder.


'We use the RENAME FILENAME command to rename the
'filename called allthelinks.txt to mylinks.txt. We
'are not using c:\user\whatever\folder\allthelinks.txt
'or whatever specific filename path we may want to use
'and so Alexia BASIC assumes the allthelinks.txt file
'is in the cauldron folder.

RENAME FILENAME < allthelinks.txt > TO < mylinks.txt >

MOVE FILENAME < * > TO < * >

The MOVE FILENAME command will move the filename specified in the first parameter to the location specified in the second parameter. Remember, if no full filename path is defined, Alexia BASIC assumes the file is located in the cauldron folder.


'We use the MOVE FILENAME command to move the
'filename called allthelinks.txt to another folder
inside the cauldron called textfiles.

MOVE FILENAME < allthelinks.txt > TO < textfiles\allthelinks.txt >

COPY FILENAME < * > TO < * >

The COPY FILENAME command will copy the filename specified in the first parameter to the filename specified in the second parameter. Remember, if no full filename path is defined, Alexia BASIC assumes the file is located in the cauldron folder.


'We use the COPY FILENAME command to copy the
'filename called allthelinks.txt to mylinks.txt. We
'are not using c:\user\whatever\folder\allthelinks.txt
'or whatever specific filename path we may want to use
'and so Alexia BASIC assumes the allthelinks.txt file
'is in the cauldron folder.

COPY FILENAME < allthelinks.txt > TO < mylinks.txt >

SAVE < *|wb|nb|lb > TO FILENAME < * >

The SAVE TO FILENAME command will save the data specified in the first parameter to the filename specified in the second parameter. Remember, if no full filename path is defined, Alexia BASIC assumes the file is located in the cauldron folder.


'We use the VISIT command to visit the Google News
'website. Then we use the PUT command along with the
'$links system variable (sv) to place all the links
'located on the webpage we are visiting into the 
'$listbox1 user input variable (uiv). We then use the
'SAVE TO FILENAME command to save the contents of 
'$listbox1 to the filename called allthelinks.txt. We
'are not using c:\user\whatever\folder\allthelinks.txt
'or whatever specific filename path we may want to use
'and so Alexia BASIC assumes the allthelinks.txt file
'should be saved to the cauldron folder.

VISIT < http://news.google.com >
PUT < $links > INTO < $listbox1 >
SAVE < $listbox1 > TO FILENAME < allthelinks.txt >

LOAD < wb|nb|lb > FROM FILENAME < * >

The LOAD FROM FILENAME command will load the user input variable (uiv) specified in the first parameter with the data contained in the filename specified in the second parameter. Remember, if no full filename path is defined, Alexia BASIC assumes the file is located in the cauldron folder.


'We then use the LOAD FROM FILENAME command to load the 
'contents of what is inside the allthelinks.txt file 
'into the $listbox1 user input variable (uiv). We
'are not using c:\user\whatever\folder\allthelinks.txt
'or whatever specific filename path we may want to use
'and so Alexia BASIC assumes the allthelinks.txt file
'should be saved to the cauldron folder. We then use
'the PRINT command to output the contents of $listbox1
'onto the emulated computer screen window.


LOAD < $listbox1 > WITH FILENAME < allthelinks.txt >
PRINT < $listbox1 >

DOWNLOAD < *|wb|lb > TO FILENAME < * >

The DOWNLOAD TO FILENAME command will save the data specified in the web address contained in the first parameter to the filename specified in the second parameter. Remember, if no full filename path is defined, Alexia BASIC assumes the file is located in the cauldron folder.


'We then use the SAVE TO FILENAME command to download the 
'http://alexiabasic.com/readme.txt file to the filename 
'called readme.txt. Since we are not using a full path like
'c:\user\whatever\folder\readme.txt or whatever specific 
'filename path we may want to use, Alexia BASIC assumes 
'the readme.txt file should be saved to the cauldron folder.

DOWNLOAD < http://alexiabasic.com/readme.txt > TO FILENAME < readme.txt >

EMAIL COMMANDS

These commands are intended to faciliate the sending of e-mail.

SETUP EMAIL --      <--- initialize e-mail setup command              
  SERVER < * >      <--- your e-mail server address
USERNAME < * >      <--- your e-mail username
PASSWORD < * >      <--- your e-mail password
    PORT < * >      <--- the port to access e-mail from your ISP
-- EMAIL READY      <--- establish that e-mail is ready

WRITE EMAIL --      <--- tells Alexia BASIC to start writing
        TO < * >    <--- the e-mail address of the receipient
      FROM < * >    <--- the e-mail address of the sender
   SUBJECT < * >    <--- the subject line of the e-mail
   MESSAGE < * >    <--- the e-mail message, no line breaks
ATTACHMENT < * >    <--- OPTIONAL: the path/file to attach
       BCC < * >    <--- OPTIONAL: blind carbon copy recipients
-- SEND EMAIL       <--- command to send the e-mail

MYSQL COMMANDS

The MySQL commands are intended to facilitate adding and removing data from a MySQL database. The databse itself needs to already exist. These commands only facilitate addiing or removing tables, as well as adding and displaying data to/from those tables.

IMPORTANT: You need to make sure that the database you setup for Alexia BASIC to work with has remote access enabled, in addition to local access.


SETUP SQL --        <--- initialize MySQL setup command                        
  SERVER < * >		<--- your MySQL server address              
USERNAME < * >		<--- your MySQL username              
PASSWORD < * >		<--- your MySQL password
DATABASE < * >      <--- your MySQL database name
    PORT < * >      <--- your MySQL remote access port
-- SQL READY

MAKE TABLE < * >    <--- Make a table specified by the command 
DROP TABLE < * >    <--- Drop/Erase a table specified by the command

FILL TABLE < * > WITH < *|uiv >    
^
|--- Fill the table specified with either free form typing or 
the contents of a user input variable (uiv)
 
SHOW TABLE < * >    <--- Show the contents of a table inside the
                         emulated comoyter screen window

SYSTEM VARIABLES

Generally speaking, system variables (sv) are used within the context of the PRINT command as well as the PUT INTO command. You can PUT any of these system variables (sv) into a user input variable.

What follows is a description of each system variable (sv) and what it represents:

$url - the web address of the web page that is currently loaded.
$title - the HTML defined title of the web page that is currently loaded.
$description - the HTML meta description of the the web page that is being visited.
$keywords - the HTML meta keywords of the web page that is being visited.
$links - the HTML < a href > links on the web page that is being visited.
$pagetext - the non-HTML text on the web page the that is being visited.
$pagesource - the raw HTML source code of the web page that is being visited.
$htmlinputs - the HTML form input and button code of the web page that is being visited.
$math[+/-*] - performs a mathematical computation, such as: $math[(5*5)+25], result = 50.
$random[#,#] - generates a random number between, such as: $random[1,10].
$rot13[*|wb] - replaces a letter with the letter 13 letters after it in the alphabet.
$noun - produces one word that is classified as being a noun in the English language.
$verb - produces one word that is classified as being a verb in the English language.
$adjective - produces one word that is classified as being a adjective in the English language.
$emotion - produces one word that is classified as being an emotion in the English language.
$output - everything contained in the emulated computer screen window.
$dandt - the curent date and time, MM/DD/YYYY HH:MM:SS, example: 10/13/2017 10:12:26
$date - the current date, MM/DD/YYY, example: 10/13/2017
$time - the current time, HH:MM:SS, example: 10:14:21
$month - the current month as a fully spelled out word, example: October
$day - the current day as a fully spelled out word, example: Friday
$hour - the current hour in numerical 24-hour HH format.
$minute - the current minute in numerical MM format.
$stockprice[tick] - the current price of a stock, where tick = stock ticker symbol.
$weather[zip] - the current weather conditions and temperature, where zip = US zip code.
$gibberish[#] - random alphanumeric characters, the # being how many characters, example: 78eARR38
$citystate - generates a random US city and state, example: Hamel, Illinois
$oracle - generates a short affirmative, negative, or non-committal statement.
$cointoss - simulates the tossing of a coin, produces word that says heads or tails.
$diceroll - simulates the rolling of one die, producing a numerical results between 1 and 6

USER INPUT VARIABLES

Alexia BASIC currently provides you with a total of 12 user input variables (uiv) that can store data.

$wordbox1, $wordbox2, $wordbox3, and $wordbox4 - primarily useful for storing alphanumeric characters

$numberbox1, $numberbox2, $numberbox3, $numberbox4 - primarily useful for storing numerical values

$listbox1, $listbox2, $listbox3, $listbox4 - primarily useful for storing alphanumeric data in lists

Anything that's stored in a $wordbox[1-4] or $numberbox[1-4] will immediately be overwritten whenever new data is assigned to the variable that already contains data.

For example:

'We PUT the numeric value 1 into the user input
'variable (uiv) $numberbox1. We PRINT the value
'of $numberbox1 onto the emulated computer screen
'window so we can see what is inside $numberbox1.
'Next, we PUT the numeric value 2 into the user
'input variable $numberbox1. This immediately 
'overwrites the numeric value 1 that had been in
'$numberbox1 before. We PRINT $numberbox1 again
'and we see in the emulated computer screen window
'that the value of $numberbox1 is now 2.

PUT < 1 > INTO < $numberbox1 >
PRINT < $numberbox1 >
PUT < 2 > INTO < $numberbox1 >
PRINT < $numberbox1 >

If we had used a $wordbox[1-4] user input variable in the previous example, the same result would have been obtained. In other words, when you PUT a new value into a particular $wordbox[1-4], it overwrites whatever value may have been contained inside the variable.

When more data is added to a $lisbox[1-4] user input variable, the behavior of the variable is different from the $wordbox[1-4] and $numberbox[1-4] variables.

New data that is PUT into a $listbox[1-4] variable gets added as a new list item, and does not overwrite the data that was previously contained in the variable.

For example:

'We PUT the numeric value 1 into the user input
'variable (uiv) $listbox1. We PRINT the value
'of $listbox1 onto the emulated computer screen
'window so we can see what is inside $listbox1.
'Next, we PUT the numeric value 2 into the user
'input variable $listbox1. This immediately gets 
'included in $listbox1 after the value that was
'in $listbox1 before. We PRINT $listbox1 again
'and we see in the emulated computer screen window
'that the value of $listbox1 is now 1 followed by 2.

PUT < 1 > INTO < $listbox1 >
PRINT < $listbox1 >
PUT < 2 > INTO < $listbox1 >
PRINT < $listbox1 >

The EMPTY command is very useful for emptying user input variables (uiv) of all the data they contain. This is especially important for $listbox[1-4] user input variables, especially if you want to add fresh data without continuing to keep data that was previously added to a particular $listbox[1-4] variable.

WEB FORM VARIABLES

There are currently 32 web form variables (wfv):

username - attempts to identify an HTML FORM username input field
password - attempts to identify an HTML FORM password input field
email - attempts to identify an HTML FORM email address input field
firstname - attempts to identify an HTML FORM first name input field
lastname - attempts to identify an HTML FORM last name input field
fullname - attempts to identify an HTML FORM full name input field
address1 - attempts to identify an HTML FORM address line 1 input field
address2 - attempts to identify an HTML FORM address line 2 input field
city - attempts to identify an HTML FORM city input field
state - attempts to identify an HTML FORM state input field
zipcode - attempts to identify an HTML FORM zip code input field
country - attempts to identify an HTML FORM country input field
phone - attempts to identify an HTML FORM phone number input field
fax - attempts to identify an HTML FORM fax number input field
company - attempts to identify an HTML FORM company input field
birthday - attempts to identify an HTML FORM birth day input field
birthyear - attempts to identify an HTML FORM birth year input field
headline - attempts to identify an HTML FORM headline input field
aboutme - attempts to identify an HTML FORM about me input field
sexmale - attempts to identify an HTML FORM male option select field
sexfemale - attempts to identify an HTML FORM female option select field
sexchoice - attempts to identify an HTML FORM gender option select field
termsrvc - attempts to identify an HTML FORM terms of service checkbox
url - attempts to identify an HTML FORM url input field
login - attempts to identify an HTML FORM login submit input field
create - attempts to identify an HTML FORM create account submit input field
linktext= - allows you to identify an object by the HTML link anchor text
name= - allows you to identify an object by its HTML name
id= - allows you to identify an object by its HTML id
type= - allows you to identify an object by its HTML type
class= - allows you to identify an object by its HTML class
value= - allows you to identify an object by its HTML value

This page was last updated on October 11, 2017 at 11:27am ET.


::::::::::::::::::::::::::
::::::::::::::::::
:::::::::::::::::::::::::::::
::::::::::::::::::::::::
  ClickMonkey Interactive Ltd
2001 Boulevard Robert-Bourassa
Montréal, QC H3A 2A6 (Canada)
stephen AT clickmonkey DOT com