Dyia

by Conor O'Brien

HTML

<h1>Dyia</h1>
<h2>By Conor O'Brien</h2>
<h2>Test parse</h2>
<p>This gives you the initial parse (tokenization) and the final parse (parsing) of the input line. It only works for single lines.</p>
<textarea id="c" spellcheck="false">+~2</textarea>
<button id="g">Go</button>
<div id="o"></div>
<h2>Execute</h2>
<p>This is what an actual program would look like. It allows for multiple lines to be evaluated in succession.</p>
<textarea id="code" spellcheck="false">(i.5) + i.5</textarea>
<button id="submit">Go</button>
<div id="output"></div>
<h2>About</h2>
<p>Dyia is a language similar to J, APL, and the like. It is currently under devolpment, so only basic things (like operations and variable assignments) are available. No hooks, chains, etc. are as of yet implemented, but the following table
  contains some of the implemented features and commands. LHS is "Left Hand Side" and is the left argument to the function, and RHS is "Right Hand Side" in the same fashion. (Parens are grouping.)</p>
<table>
  <tr>
    <th>Command</th>
    <th>Dyadic case</th>
    <th>Monadic case</th>
    <tr>
      <tr>
        <td>%</td>
        <td>divide: LHS / RHS</td>
        <td>reciprocal: is 1 / RHS</td>
      </tr>
      <tr>
        <td>*</td>
        <td>multiply: LHS &times; RHS</td>
        <td>square: is RHS<sup>2</sup></td>
      </tr>
      <tr>
        <td>+</td>
        <td>add: LHS + RHS</td>
        <td>sign: -1, if RHS &lt; 0; 0, if RHS = 0; and 1, if RHS &gt; 0.</td>
      </tr>
      <tr>
        <td>-</td>
        <td>subtract: LHS - RHS</td>
        <td>negatin: -RHS</td>
      </tr>
      <tr>
        <td>=:</td>
        <td>assign: creates a variabl (LHS) with the value RHS.</td>
        <td>none.</td>
      </tr>
      <tr>
        <td>i.</td>
        <td>zero cycle; J's <code>i.</code>.</td>
        <td>none.</td>
      </tr>
</table>
<p>Single-line comments are the semicolon, and multiline comments are like <code>;- this is a comment -;</code></p>
<div id=end></div>

CSS

@import url(https://fonts.googleapis.com/css?family=Open+Sans:400,300);
html {
  font-family: "Open Sans", Consolas, monospace;
}

h1,
h2 {
  margin: 0;
  font-weight: 300;
}

#o {
  white-space: pre;
}

textarea,
#o,
#output,
td:first-child {
  font-family: Consolas, monospace;
}

p {
  margin: 0
}

table {
  border-collapse: collapse;
}

td,
th {
  padding: 15px;
}

#end {
  margin-bottom: 20em;
}

#output {
  white-space: pre;
}

JavaScript

//pollyfills
Array.isArray||(Array.isArray=function(r){return"[object Array]"===Object.prototype.toString.call(r)});String.prototype.repeat||(String.prototype.repeat=function(n){return Array(n+1).join(this);});

(function(t){
	function inBase(number, base){
  	// special case: unary
    if(base === 1)
    	return "1".repeat(number);
    if(2 <= base && base <= 36)
    	return number.toString(base).toUpperCase();
    else if(base < 1 || base > 36)
    	throw new Error("base " + base + " is an invalid base");
  }
  
  function subscript(n){
  	return String(n)
    	.replace(/\d/g,
    		function(digit){
      		return "\u2080\u2081\u2082\u2083\u2084\u2085\u2086\u2087\u2088\u2089"[digit];
        });
  }
  
  function NumberToken(value, base){
    value = String(value);
  	// base detection, with b
    var bIndex = value.indexOf("B");
    if(bIndex >= 0){
      this.base = value.slice(bIndex + 1);
    	value = value.slice(0, bIndex);
    } else this.base = base || 10;
    this.value = value[0] === "_" ? -Number(value.slice(1)) : Number(value);
    if(value === ".") this.value = 0.5;
    else if(value === "_") this.value = Infinity;
    else if(value === "__") this.value = -Infinity;
    
    // no base has been assigned yet
    if(typeof this.base === "undefined"){
    	this.base = 10;
    } else {	// we need to convert to base 10 for reference
    	this.value = parseInt(this.value, this.base)
    }
    if(isNaN(this.value))
      throw new Error("malformed number \"" + value + "\"");
  }
  NumberToken.prototype.valueOf = function(){
    return Number(this.value);
  }
  NumberToken.prototype.toString = function(){
    return ("NumberToken[" + inBase(this.value, this.base) + subscript(this.base) + "]")
      .replace(/-/g, "_");
  }

  function VerbToken(operator){
    this.operation = operator;
    this.monadic = false;
    this.modifiers = [];
    this.action = null;
  }
  VerbToken.prototype.toString = function(){
    return "VerbToken["
      + this.operation
   ...