Ignition

From Esolang
Jump to: navigation, search

Ignition is a rather simple Interpreted Esoteric programming language designed by Luxen De'Mark that is meant to be run on lightweight devices, like the TI-83+/84+.

Background

Ignition was created as an attempt to simplify the command syntax of TI-Basic, but also poke fun at the person who requested it. the final product was a Programming Language that uses about 15 commands. It happens to be usable, but is pointless to code in.

Instructions

The Interpreter

The Interpreter, otherwise known as the IILE (Ignition Interpreted Language Engine), is what interprets Ignition Code. you need to supply it with the starting point of the code. this is usually handled by an external shell or another program.

Introduction

All Ignition code is treated as string data (unless math operators are used, but output is returned back to a string), accessible through comments. data must be loaded into 1 of 3 temporary variables, which could be thought of as non-destructive assembly registers.

Language Basics

Any Ignition code begins with "Igni", and customarily ends with a Quit command. The beginning snippet ensures to the Ignition interpreter that the code being read is Ignition code. The final Quit command ensures proper end-of-file execution (as the current engine is likely to continue running past the end of the file, resulting in garbage (or a crash, for the TI-Basic implementation of the engine)). also, you can optionally include a "Name:xxx" and "Type:xxx" after the Igni header, though currently these tags are ignored.

Ignition programming etiquette

Ignition code should begin after the header and a starting label, most often ":Start". Data should come after all code execution, at the bottom of the document. the final data tag should be ":EOF", and Quit on the next line. Ignition can handle excessive new lines, but whitespacing will cause the code to be skipped, as commands and arguments are literal matches in the engine.

Ignition Syntax

there are only a few executable commands and tags.

:xxx

Creates a Label, similar to the Batch Label naming. in this case, you created a Label called xxx. Labels arent indexed, so jumping to one in a lengthy program can be a tad bit slow.

Jump xxx

Jumps to the first declared label "xxx". Label searching begins from the start of the code.

Comp

Compares Var1 to Var2. If they are not the same, the interpreter skips the next line. otherwise, execution occurs as normal.

Load xxx

Loads the data in the line after label xxx into Var1.

Swap Var#,Var#

Loads the data in Var# and stores it into Var#.

Save xxx

Loads the data from Var1 and places it in the line after label xxx. data is overwritten.

Clear

Wipes the screen of all contents.

Print

Displays the string in Var1, and a new line.

Input

Gets a string from the user. This data is stored into Var1.

Rand #

Creates a random number between 0-#, and stores to Var1

Quit

Stops program execution.

Math ~some operator that is +,-,*,or /~

does simple math on Var1 and Var2, storing the results in Var1. If you need to use Var1 multiple times, you should store it to Var3 before using Math.

Platform:xxx

Currently, this does nothing, but an IILE in the works would allow for specific platform checking (as in "Platform:TI" returning true if the interpreter is run on a TI-83+/84+). If true, the interpreter skips the next line.

Plugin:xxx

Currently, this does nothing, but an IILE in the works would allow for extensions to the programming language (perhaps making it useful). If the listed plugin is installed, then this returns true and skips the next line.

Wait #

Currently, this does nothing, but an IILE in the works would allow for halting program execution for # program ticks.

Speed #

Currently, this does nothing, but an IILE in the works would allow for switching between max processing speed(1) and snail speed(2)(about the speed that the TI-Basic-based interpreter processes Ignition code).

Exec xxx (xxx)

Currently, this does nothing, but an IILE in the works would allow for the current program to close and execution of another program to begin. an optional argument allows for automatic label searching, so it would jump directly to that label after opening the program.

The following are tags, and dont effect program execution:

Igni

This is essentially the program header. If you load a program into the Ignition interpreter, and this is not the first line of that program, then execution will not occur.

Name:xxx

Currently, this does nothing, but a planned Ignition program shell would allow Ignition programs to have long (<8 character) names using this tag after the program header.

Type:xxx

Currently, this does nothing, but a planned Ignition program shell would allow Ignition programs to have descriptions using this tag after the name tag.


Sample Programs

Hello World

Igni
Name:Hello World
Type:Other
:Start
Load Var1,Message
Print
Quit
 
:Message
Hello World!
:EOF
Quit

Random Number Guessing Game

Igni
Name:Guess My Number
Type:Game
:Start
Clear
Rand 10
Swap Var1,Var2
:Game
Load Var1,Msg1
Print
Load Var1,Msg2
Print
Input
Comp
Jump Win
Load Var1,MsgLose
Print
Jump Game
:Win
Load Var1,MsgWin
Print
Quit
 
:Msg1
Guess My Number
:Msg2
Any Number 1-10
:MsgWin
You Won!
:MsgLose
Try Again
:EOF
Quit

External resources